skills.rest
cowwoc
cowwocCOMMUNITY
Explore all skills by this author →
GitHub

parse-conversation-timeline

Transform raw session logs into queryable timeline JSON with event typing.

4|Updated Sep 25, 2025
Search Tags:#timeline#data transformation#event tracking#parsing#AI analysis#audit data#conversation logs
One-click install
npx skills add https://github.com/cowwoc/styler --skill parse-conversation-timeline
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: parse-conversation-timeline
Source: https://github.com/cowwoc/styler/tree/main/.claude/skills/parse-conversation-timeline
Command: npx skills add https://github.com/cowwoc/styler --skill parse-conversation-timeline

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires jq, git.

What problem does it solve?

Raw AI conversation logs are often large, unstructured, and difficult to parse, making it challenging for auditors or analysts to extract specific events, track state changes, or understand the chronological flow of an AI agent's work. This complexity hinders effective compliance checks and efficiency analysis. This Skill automates the transformation into actionable data.

Core Features & Use Cases

  • Structured Timeline Generation: Converts verbose .jsonl conversation logs into a concise, queryable JSON timeline, making data accessible for analysis.
  • Event & File Classification: Automatically categorizes all events (user messages, tool uses, state transitions) and classifies file operations (source, test, infrastructure, documentation) and worktree types.
  • Contextual Data Enrichment: Preserves crucial context like working directory, Git branch, and task state for every event, enabling precise auditing and debugging.
  • Use Case: An audit skill needs to verify if an agent correctly transitioned through all task states and performed operations in the right worktree. This Skill processes the raw conversation log into a structured timeline, allowing the audit skill to easily query for state transitions, tool uses, and their associated contexts, simplifying complex compliance checks and saving hours of manual log review.

Quick Start

Parse the current session's raw conversation logs into a structured timeline JSON for audit analysis.

Frequently Asked Questions about parse-conversation-timeline

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I transform AI conversation logs into queryable audit data?▼

Parse raw conversation logs into structured JSON timelines by classifying events (user messages, tool uses, state transitions) and enriching them with context like git branch and working directory. This creates compact, queryable data for compliance audits and efficiency analysis.

Can I extract state transitions and file operations from raw session logs?▼

Yes. The parser automatically detects state transitions, classifies file operations by type (source, test, infrastructure, documentation), identifies worktree context, and preserves git metadata for each event, enabling precise tracking of agent behavior across the session.

What event types does the parser extract from conversation logs?▼

The parser identifies and categorizes user_message, assistant_message, tool_use, tool_result, and state_transition events, then generates aggregate statistics and approval checkpoint extraction to support protocol compliance verification and task execution pattern analysis.

Do I need git and jq to parse conversation timelines?▼

Yes. The Skill depends on jq for JSON transformation and git for repository context gathering. Both tools are required to enrich timeline events with branch information and enable comprehensive session analysis.

When should I use conversation timeline parsing before audits?▼

Use it before protocol compliance audits, efficiency audits, and task execution investigations. Parsing converts verbose logs into structured data that auditors can query quickly, reducing manual review time and improving investigation accuracy.

What's the difference between raw logs and parsed timeline output?▼

Raw logs are large, unstructured .jsonl files difficult to search. Parsed timelines are compact JSON with typed events, classified file operations, contextual metadata, and statistics—making specific events, state changes, and chronological flows immediately accessible for analysis.

Related Skills

Explore More Software Engineering Skills→
DeL-TaiseiOzakiDeL-TaiseiOzaki
190

checkpointing

Capture CLI logs and Git activity into centralized checkpoint files.

Community
Intermediate
riethmayerriethmayer
2

trace

Visualize chronological event timelines of hooks, keywords, skills, agents, and tools.

Community
Intermediate
pradyumnasagarpradyumnasagar
6

agent-handoff

Automate inter-skill data transfer and provenance capture via JSON Material Passports.

Community
Advanced
yun520-1yun520-1
38

log-analyzer

Parse and search application logs using grep, awk, jq, and Python3.

Community
Advanced