evolve-lite:save

What this skill does

# Save Session as Skill

## Overview

This skill analyzes your current successful session and generates a new reusable skill with:
- **SKILL.md**: Comprehensive documentation with workflow steps, parameters, and examples
- **Helper scripts**: Python scripts for any programmatic operations identified in the workflow

It extracts the workflow pattern from your conversation history (user requests, reasoning steps, tool calls, and responses) and creates parameterized files that can be invoked in future sessions.

Use this skill when you've completed a task successfully and want to save the workflow for future reuse.

## When to Use

- After completing a multi-step task successfully
- When you've discovered a useful workflow pattern
- When you want to standardize a process for future use
- After solving a problem that might recur
- When the workflow involves programmatic operations that could benefit from helper scripts

## Workflow

### Step 1: Review Current Session

Analyze the conversation history available in the current context, which includes:

- **User messages**: All requests and questions from the user
- **Assistant reasoning**: Thinking tags and decision-making process
- **Tool calls**: All tools invoked with their arguments
- **Tool responses**: Results and outcomes from each tool
- **Final outcome**: The successful result achieved

**Action**: Review the entire conversation from start to current point

### Step 2: Identify the Workflow Pattern

Extract the high-level workflow by:

1. **Identifying the goal**: What was the user trying to accomplish?
2. **Grouping related actions**: Which tool calls belong together as logical steps?
3. **Recognizing decision points**: Where did the workflow branch based on conditions?
4. **Noting error handling**: How were errors or edge cases handled?
5. **Extracting the sequence**: What is the step-by-step process?

**Example Pattern Recognition**:
```
User Goal: "Read a file and display its contents"

Workflow Pattern:
1. Attempt to read file at expected location
2. If access denied → check allowed directories
3. Search for file in allowed directories
4. Read file from correct location
5. Format and present results
```

### Step 3: Identify Parameterizable Values

Apply **conservative parameterization** - only parameterize obvious session-specific values:

**Parameterize**:
- Absolute file paths → `{file_path}` or `{directory}`
- Specific file names → `{filename}`
- User-specific data → `{data_value}`
- Project-specific names → `{project_name}`
- Workspace directories → `{workspace_dir}`

**Keep Unchanged**:
- Tool names (e.g., `read_file`, `execute_command`)
- General patterns and logic
- Error handling approaches
- Workflow structure

**Example**:
```
Original: "Read /home/user/projects/myapp/config.json"
Parameterized: "Read {project_dir}/{config_file}"
```

### Step 4: Identify Script Opportunities

Analyze the workflow to determine if helper scripts would be beneficial:

**Generate scripts when the workflow includes**:
- Data transformation or parsing (JSON, CSV, XML processing)
- File operations (reading, writing, searching, filtering)
- API calls or HTTP requests
- Complex calculations or data analysis
- Repetitive operations that could be automated
- Integration with external tools or services

**Script Types to Consider**:
- **Data processors**: Parse, transform, or validate data
- **File handlers**: Read, write, or manipulate files
- **API clients**: Interact with external services
- **Validators**: Check inputs or outputs
- **Formatters**: Convert data between formats

**Example**:
```
Workflow includes: Reading JSON file, extracting specific fields, formatting output
→ Generate: parse_and_format.py script
```

### Step 5: Generate Skill Document

Create a new SKILL.md file with the following structure:

```markdown
---
name: {skill-name}
description: {one-line description of what this skill does}
---

# {Skill Title}

## Overview

{Brief description of the skill's purpose and when to use it}

## Parameters

{List parameters the user needs to provide}

- **{param_name}**: {description and example}

## Workflow

### Step 1: {Step Name}

{What this step does}

**Action**: {Tool or approach to use}

**Example**:
```
{Example tool call or command}
```

{If helper script exists, reference it}
**Helper Script**: Use `scripts/{script_name}.py` for this operation

{Repeat for each step}

## Helper Scripts

{If scripts were generated, document them}

### {script_name}.py

**Purpose**: {What the script does}

**Usage**:
```bash
python3 .bob/skills/{skill-name}/scripts/{script_name}.py [arguments]
```

**Parameters**:
- `{param}`: {description}

**Example**:
```bash
python3 .bob/skills/{skill-name}/scripts/parse_data.py input.json
```

## Error Handling

{Common errors and how to handle them}

## Examples

### Example 1: {Use Case}

**Input**:
- {param}: {value}

**Expected Output**:
{What the user should see}

## Notes

{Additional guidelines or context}
```

### Step 6: Generate Helper Scripts

For each identified script opportunity, create a Python script with:

**Script Template**:
```python
#!/usr/bin/env python3
"""
{Script description}

Usage:
    python3 {script_name}.py [arguments]

Arguments:
    {arg1}: {description}
    {arg2}: {description}
"""

import sys
import json
import argparse
from pathlib import Path


def main():
    """Main function implementing the script logic."""
    parser = argparse.ArgumentParser(description="{Script description}")
    parser.add_argument("{arg1}", help="{description}")
    parser.add_argument("{arg2}", help="{description}", nargs="?")

    args = parser.parse_args()

    # Implementation based on workflow pattern
    try:
        # Core logic here
        result = process_data(args.{arg1})
        print(json.dumps(result, indent=2))
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)


def process_data(input_data):
    """Process the input data according to the workflow pattern."""
    # Implementation extracted from session workflow
    pass


if __name__ == "__main__":
    main()
```

**Script Guidelines**:
- Include proper error handling
- Accept parameters via command-line arguments
- Output results in a structured format (JSON when appropriate)
- Include usage documentation in docstring
- Make scripts executable (`chmod +x`)

### Step 7: Prompt for Skill Name

Ask the user: **"What would you like to name this skill?"**

**Naming Guidelines**:
- Use lowercase letters
- Separate words with hyphens (kebab-case)
- Be descriptive but concise
- Examples: `read-file-with-permissions`, `deploy-to-staging`, `analyze-logs`

**Suggest a name** based on the workflow if the user is unsure:
- Extract key actions and objects from the workflow
- Combine into a descriptive name
- Example: "Read file → Check permissions → Search" → `read-file-with-permission-check`

### Step 8: Check for Existing Skill

Before saving, check if a skill with this name already exists:

**Action**: Check if `.bob/skills/{skill-name}/SKILL.md` exists

**If exists**:
- Inform the user
- Ask: "A skill with this name already exists. Would you like to:"
  - Overwrite the existing skill
  - Choose a different name
  - Cancel

### Step 9: Save the Skill

**Action**: Create the skill directory structure and save all files

1. Create directory: `.bob/skills/{skill-name}/`
2. Write SKILL.md to: `.bob/skills/{skill-name}/SKILL.md`
3. If scripts were generated:
   - Create directory: `.bob/skills/{skill-name}/scripts/`
   - Write each script to: `.bob/skills/{skill-name}/scripts/{script_name}.py`
   - Make scripts executable: `chmod +x .bob/skills/{skill-name}/scripts/*.py`
4. Ensure proper permissions (readable by user)

**Directory Structure**:
```
.bob/skills/{skill-name}/
├── SKILL.md
└── scripts/           (if applicable)
    ├── script1.py
    └── script2.py
```

**Note**: The skill is saved to the user's home directory (`.bob/skills/`) making it available a