Index of every page on this site: llms.txt
All skills
github avatar

/optimize-simplicite-logs

@f10fdb8 official
by githubgithub/awesome-copilot41k stars
5,399
Run it yourself

capability to parse Simplicité logs from a raw `.txt` file, filter fields to reduce noise, and output the result as structured JSON.

Use this Skill: https://skilld.dev/gh/github/awesome-copilot/optimize-simplicite-logs

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈40 tokens for metadata: the name and description. ≈889 when used: this file.

Description uses 2.0% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈159 characters, or 2.0%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Optimize Simplicite Logs

This skill provides the capability to parse Simplicité logs from a raw .txt file, filter fields to reduce noise, and output the result as structured JSON. This is critical for optimizing AI context size (saving ~56% of tokens) and providing structured, predictable data for troubleshooting.

When to Use This Skill

Use this skill when you need to:

  • Analyze user-provided Simplicité log files in .txt format.
  • Avoid ingesting massive raw log files into your context window.
  • Extract structured fields (like timestamp, level, body) from verbose multi-line log output.

IMPORTANT: Instead of directly reading a raw .txt log file provided by the user using file read tools, you must use one of the log converter scripts (PowerShell or Python) to parse the file into a JSON format first, optionally extracting only the fields needed.

Prerequisites

  • Access to either the PowerShell script (/scripts/SimpliciteLog2Json.ps1) or the Python script (/scripts/simplicite-log2json.py).

Core Capabilities

1. Context Optimization

Reduces the tokens consumed by large Simplicité logs by extracting only relevant log fields (e.g. body, timestamp, level) and discarding non-relevant structural log data (like app, endpoint, contextPath).

2. Multi-line Support

Properly captures stack traces and multiline errors inside the body field of the JSON structure, which a simple text search might miss.

3. Stdout Support

If no output path is provided for the JSON file (e.g. omitting --output or -Output), the parsed JSON will be printed directly to stdout, allowing you to pipe the output to other tools.

Output Summary

After processing, the tool prints a summary to stderr (or console):

Processed: 123 entries, Skipped: 2 entries

Usage Examples

Example 1: Python Version (Recommended)

Convert a log file to JSON, keeping only the most important fields:

python /absolute/path/to/skills/optimize-simplicite-logs/scripts/simplicite-log2json.py <input.txt> --include timestamp,level,body --output <output.json>

Example 2: PowerShell Version

/python /absolute/path/to/skills/optimize-simplicite-logs/scripts/SimpliciteLog2Json.ps1 -InputPath "<input.txt>" -Output "<output.json>" -Include "body,timestamp,level"

After generating the <output.json>, you can safely read the resulting file to perform your analysis.

Guidelines

  1. Always Convert First: Never directly read .txt log files from Simplicité using standard text reading tools. Always convert them to JSON using the available scripts.
  2. Filter Fields: Use --include (Python) or -Include (PowerShell) to restrict fields to what is absolutely necessary to diagnose the issue (usually timestamp,level,body).
  3. Available Fields: The fields you can filter include: timestamp, app, level, endpoint, contextPath, event, user, class, function, rowId, body.

Common Patterns

Pattern: Fast Contextual Troubleshooting

# 1. Run the script to generate a minified JSON output in the current directory
python /absolute/path/to/skills/optimize-simplicite-logs/scripts/simplicite-log2json.py logs.txt --include timestamp,level,body --output logs_minified.json

# 2. Then read logs_minified.json to understand the context.

Limitations

  • The parser depends on a fixed regex pattern that matches the standard Simplicité log output. If the log format has been heavily customized, parsing might fail or degrade.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts25d3 checks · Risk SAFE
  • Gen Agent Trust Hub25d

    The skill provides tools for converting Simplicité log files into structured JSON. While functional and devoid of direct malicious code, it processes untrusted log data which carries a low risk of indirect prompt injection if those logs contain instructions that the agent might later follow.

  • Socket25d

    No alerts

  • Snyk25d

    Risk: LOW · No issues

Signed by skilld at f10fdb8. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 6 months ago
  • Python
  • logs
  • simplicite
  • parsing
  • json
  • context-optimization
  • troubleshooting
  • powershell

README badge

README badge for github/awesome-copilot/optimize-simplicite-logs

Parses Simplicité `.txt` log files into structured JSON, filtering fields to reduce token consumption by up to 56%. Helps troubleshoot Simplicité application logs efficiently by extracting only relevant fields like timestamp, level, and body while discarding structural noise.

Generated from the current SKILL.md.

What fields can I filter from Simplicité logs?
Available fields are: timestamp, app, level, endpoint, contextPath, event, user, class, function, rowId, and body. Use the --include flag to specify which fields to keep in the JSON output.
Does this skill work with custom Simplicité log formats?
No. The parser relies on a fixed regex pattern for standard Simplicité log output. If your log format has been heavily customized, parsing may fail or degrade.
What's the token savings from using this skill?
Filtering logs to only essential fields (timestamp, level, body) typically saves around 56% of tokens compared to ingesting raw log files.
Do I need to choose between Python and PowerShell scripts?
The Python version is recommended, but both scripts perform the same function. Use whichever matches your environment.
Can I output the JSON directly to stdout instead of a file?
Yes. Omit the --output (Python) or -Output (PowerShell) flag, and the parsed JSON will be printed to stdout so you can pipe it to other tools.

Generated from the current SKILL.md. These answers refresh after source changes.