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

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.
Filter Fields: Use --include (Python) or -Include (PowerShell) to restrict fields to what is absolutely necessary to diagnose the issue (usually timestamp,level,body).
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.

Files3

3 files · 9.6 KB

Select a file to preview

Overall Score

82/100

Grade

B

Good

Safety

88

Quality

83

Clarity

85

Completeness

76

Summary

This skill parses Simplicité application logs from raw `.txt` files into structured JSON format, with optional field filtering to reduce context size and noise. It provides two converter scripts (Python and PowerShell) that extract relevant fields like timestamp, level, and body while discarding verbose structural metadata.

Detected Capabilities

file readregex pattern matchingJSON output generationcommand-line argument parsingstdout/stderr outputfile write

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

parse simplicité logsconvert logs to jsonreduce log context sizefilter log fieldsoptimize log fileanalyze application logsextract stack traces

Use Cases

Analyze Simplicité application logs for troubleshooting without consuming excessive context tokens
Extract stack traces and multiline errors from verbose log output into structured JSON
Filter log fields to focus on diagnostically relevant information (timestamp, level, body)
Convert user-provided log files into processable JSON format before analysis
Optimize token consumption when ingesting large Simplicité logs (claimed ~56% reduction)

Quality Notes

Clear, well-structured documentation with specific use cases and examples
Provides two implementation options (Python and PowerShell) with concrete command examples
Robust input validation: validate_fields() function enforces allowed field names
Proper error handling for file read/write failures with user-friendly messages
Correctly handles multiline log entries using timestamp-based line buffering
Explicit guidance to avoid reading raw logs directly (always use converter first)
Usage examples are practical and directly executable
Output summary (processed/skipped counts) helps users verify conversion success
PowerShell example contains a syntax error (missing `&` for script invocation), reducing confidence in that path
Documentation clearly lists available fields and limitations regarding custom log formats

Model: claude-haiku-4-5-20251001Analyzed: Jun 26, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

optimize-simplicite-logs