Add interactive Gradio interface for Claude Code slash commands

- Implemented searchable, expandable command browser
- Added copy-to-clipboard functionality for easy command installation
- Included all 360+ slash commands from source repository
- Updated README with usage instructions and Space configuration

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.env
+.venv
+env/
+venv/
+.DS_Store
+*.log

README.md

@@ -1,11 +1,46 @@
 ---
 title: Claude Code Slash Commands
-emoji: 😻
+emoji: ⚡
 colorFrom: blue
-colorTo: gray
-sdk: static
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
 pinned: false
-short_description: Slash command library for Claude Code
+license: mit
+short_description: Interactive browser for Claude Code slash commands
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Claude Code Slash Commands Collection
+
+An interactive browser for slash commands used with [Claude Code](https://claude.com/claude-code), Anthropic's official CLI tool.
+
+## Features
+
+- **Search & Filter**: Quickly find commands by name or keyword
+- **Expandable View**: Click to view full command content
+- **Copy to Clipboard**: One-click copying for easy installation
+- **Clean Interface**: Easy to navigate and browse
+
+## What are Slash Commands?
+
+Slash commands are reusable prompt templates for Claude Code that automate common tasks. They live in your `.claude/commands/` directory and can be invoked with a simple `/command-name` syntax.
+
+## Usage
+
+1. Browse or search for a command
+2. Expand to view the full content
+3. Click "Copy to Clipboard"
+4. Save to your `.claude/commands/` directory as `command-name.md`
+
+## Source
+
+All commands are sourced from: [github.com/danielrosehill/Claude-Slash-Commands](https://github.com/danielrosehill/Claude-Slash-Commands)
+
+## About Claude Code
+
+Claude Code is an interactive CLI tool that helps with software engineering tasks. Learn more at [docs.claude.com/claude-code](https://docs.claude.com/en/docs/claude-code/claude-code).
+
+## License
+
+MIT License - See the [source repository](https://github.com/danielrosehill/Claude-Slash-Commands) for details.

app.py

@@ -0,0 +1,159 @@
+import gradio as gr
+import json
+import os
+from pathlib import Path
+
+# Load slash commands data
+def load_commands():
+    """Load slash commands from JSON file"""
+    json_path = Path("slash-commands.json")
+    if json_path.exists():
+        with open(json_path, 'r') as f:
+            return json.load(f)
+    return []
+
+def load_command_content(path):
+    """Load the content of a specific command file"""
+    file_path = Path(path)
+    if file_path.exists():
+        with open(file_path, 'r') as f:
+            content = f.read()
+            # Remove YAML frontmatter if present
+            if content.startswith('---'):
+                parts = content.split('---', 2)
+                if len(parts) >= 3:
+                    return parts[2].strip()
+            return content
+    return "Content not found"
+
+def search_commands(search_term, commands_data):
+    """Filter commands based on search term"""
+    if not search_term:
+        return commands_data
+
+    search_term = search_term.lower()
+    filtered = [
+        cmd for cmd in commands_data
+        if search_term in cmd['name'].lower()
+    ]
+    return filtered
+
+def create_command_card(command):
+    """Create an HTML card for a command"""
+    name = command['name']
+    path = command['path']
+    content = load_command_content(path)
+
+    # Extract description from content if available
+    description = ""
+    lines = content.split('\n')
+    if lines:
+        # Try to find first non-empty line as description
+        for line in lines[:5]:
+            if line.strip() and not line.startswith('#'):
+                description = line.strip()
+                break
+
+    card_html = f"""
+    <div style="border: 1px solid #ddd; border-radius: 8px; padding: 16px; margin: 10px 0; background: white;">
+        <div style="display: flex; justify-content: space-between; align-items: start;">
+            <div style="flex: 1;">
+                <h3 style="margin: 0 0 8px 0; color: #2563eb;">/{name}</h3>
+                <p style="margin: 0 0 12px 0; color: #666; font-size: 14px;">{description[:200]}...</p>
+            </div>
+        </div>
+        <details>
+            <summary style="cursor: pointer; color: #2563eb; font-weight: 500; margin-bottom: 12px;">
+                View Full Command
+            </summary>
+            <div style="background: #f8f9fa; padding: 12px; border-radius: 4px; margin-top: 8px;">
+                <pre style="margin: 0; white-space: pre-wrap; font-size: 13px; line-height: 1.5;">{content}</pre>
+            </div>
+        </details>
+        <button onclick="navigator.clipboard.writeText(`{content.replace('`', '\\`')}`); this.innerText='Copied!'; setTimeout(() => this.innerText='Copy to Clipboard', 2000)"
+                style="background: #2563eb; color: white; border: none; padding: 8px 16px; border-radius: 4px; cursor: pointer; margin-top: 8px;">
+            Copy to Clipboard
+        </button>
+    </div>
+    """
+    return card_html
+
+def display_commands(search_term):
+    """Main function to display filtered commands"""
+    commands_data = load_commands()
+    filtered_commands = search_commands(search_term, commands_data)
+
+    if not filtered_commands:
+        return "<p style='text-align: center; color: #666; padding: 40px;'>No commands found matching your search.</p>"
+
+    html_output = f"<div style='max-width: 900px; margin: 0 auto;'>"
+    html_output += f"<p style='color: #666; margin-bottom: 20px;'>Showing {len(filtered_commands)} command(s)</p>"
+
+    for command in filtered_commands:
+        html_output += create_command_card(command)
+
+    html_output += "</div>"
+    return html_output
+
+# Create Gradio interface
+with gr.Blocks(
+    title="Claude Code Slash Commands",
+    theme=gr.themes.Soft(),
+    css="""
+        .gradio-container {
+            max-width: 1200px !important;
+        }
+    """
+) as demo:
+
+    gr.Markdown("""
+    # Claude Code Slash Commands Collection
+
+    Browse and search through a comprehensive collection of slash commands for Claude Code CLI.
+    Use the search box to filter commands by name, then expand any command to view its full content and copy it to your clipboard.
+
+    **Source:** [github.com/danielrosehill/Claude-Slash-Commands](https://github.com/danielrosehill/Claude-Slash-Commands)
+    """)
+
+    with gr.Row():
+        search_box = gr.Textbox(
+            label="Search Commands",
+            placeholder="Type to filter commands (e.g., 'git', 'python', 'setup')...",
+            scale=4
+        )
+        search_btn = gr.Button("Search", scale=1, variant="primary")
+
+    commands_display = gr.HTML(value=display_commands(""))
+
+    # Update display when searching
+    search_box.change(
+        fn=display_commands,
+        inputs=[search_box],
+        outputs=[commands_display]
+    )
+
+    search_btn.click(
+        fn=display_commands,
+        inputs=[search_box],
+        outputs=[commands_display]
+    )
+
+    gr.Markdown("""
+    ---
+
+    ### About
+
+    This Space displays slash commands for Claude Code, Anthropic's official CLI tool.
+    Each command is a reusable prompt template that can be used to automate common tasks.
+
+    **How to use:**
+    1. Search for a command using keywords
+    2. Click to expand and view the full command content
+    3. Click "Copy to Clipboard" to copy the command
+    4. Add it to your `.claude/commands/` directory
+
+    **Repository:** [danielrosehill/Claude-Slash-Commands](https://github.com/danielrosehill/Claude-Slash-Commands)
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

commands-flat/24-hour-time.md

@@ -0,0 +1,15 @@
+Convert all times in this text to 24-hour format.
+
+Your task:
+- Convert 12-hour times (AM/PM) to 24-hour format
+- Use HH:MM format (e.g., 14:30, 09:00)
+- Remove AM/PM indicators
+- Ensure all times are standardized consistently
+
+Examples:
+- 1:00 PM → 13:00
+- 9:30 AM → 09:30
+- 12:00 AM (midnight) → 00:00
+- 12:00 PM (noon) → 12:00
+
+Preserve all other content and formatting. Only change time representations.

commands-flat/add-apps-index-badge.md

@@ -0,0 +1,17 @@
+This repository is an app.
+
+I have an apps index page that I use to gather these together.
+
+That index is here:
+
+https://github.com/danielrosehill/Apps-Index
+
+The master index is here:
+
+https://github.com/danielrosehill/Github-Master-Index
+
+Please add two badges, using shields.io, to the top of the readme on this project:
+
+1: A badge linking to my Apps Index
+2: A badge linking to my Master Index
+

commands-flat/add-bash-alias.md

@@ -0,0 +1,9 @@
+I would like to add a bash alias. I will provide the alias or ask for your suggestions as to an appropriate alias.
+
+To come up with an appropriate alias - identify one that is unlikely to conflict with other aliases.
+
+Either way:
+
+Create the new bash alias(es) in ~/.bash_aliases
+
+Then you can use sourcebash to reload the bash alias file.

commands-flat/add-emotion.md

@@ -0,0 +1,7 @@
+This text is very "flat." 
+
+Try to make it a little bit more lively with:
+
+- Emotion 
+- Metaphors 
+- Statements of conviction 

commands-flat/add-examples.md

@@ -0,0 +1,94 @@
+# Add Examples Where Missing
+
+You are an example enrichment specialist. Your task is to identify places in the provided text where concrete examples would clarify concepts and make the content more relatable and understandable.
+
+## Your Task
+
+1. **Identify abstract concepts** that need illustration
+2. **Spot missing use cases** where practical examples would help
+3. **Add relevant examples** that:
+   - Clarify the concept
+   - Make it relatable to the audience
+   - Provide concrete, specific details
+   - Vary in type and context
+
+## Types of Examples to Add
+
+### Real-World Scenarios
+- Practical use cases
+- Common situations readers face
+- Industry-specific applications
+- Day-to-day implementations
+
+### Illustrative Cases
+- Hypothetical but realistic scenarios
+- Before/after comparisons
+- Success stories or case studies
+- Problem-solution demonstrations
+
+### Concrete Instances
+- Specific product/tool names
+- Named companies or organizations
+- Actual data points
+- Tangible outcomes
+
+### Analogies and Metaphors
+- Familiar comparisons
+- Simplified explanations
+- Relatable parallels
+- Conceptual bridges
+
+## Example Placement Strategy
+
+**Add examples when:**
+- Introducing new concepts
+- Explaining technical details
+- Making abstract claims
+- Teaching procedures or methods
+- Justifying recommendations
+- Clarifying distinctions
+
+**Example formats:**
+- Inline: "For example, ..."
+- Expanded: Dedicated paragraph or section
+- Lists: Multiple brief examples
+- Callouts: Boxed or highlighted examples
+
+## Guidelines
+
+- **Relevance**: Match examples to audience knowledge level
+- **Diversity**: Vary industries, contexts, and complexity
+- **Clarity**: Make examples immediately understandable
+- **Specificity**: Use concrete details, not generic placeholders
+- **Balance**: Don't overload with examples—one or two per concept
+- **Authenticity**: Use realistic scenarios, even if hypothetical
+
+## Output Format
+
+Return the enhanced text with:
+- Examples naturally integrated
+- Clear markers (e.g., "For example:", "Consider:", "Imagine:")
+- Proper formatting (indentation, bold, etc. as appropriate)
+- Optional: Notes on where examples were added and why
+
+## Example
+
+**Before:**
+"API rate limiting is important for protecting your infrastructure. It prevents abuse and ensures fair usage among clients."
+
+**After:**
+"API rate limiting is important for protecting your infrastructure. It prevents abuse and ensures fair usage among clients.
+
+**For example**, imagine you run a weather API service. Without rate limiting, a single user could make thousands of requests per second—perhaps due to a buggy script—overwhelming your servers and degrading service for everyone else. By implementing a limit of 1,000 requests per hour per API key, you ensure that all 10,000 of your users can reliably access weather data simultaneously.
+
+**Another common scenario**: A mobile app developer accidentally deploys code with an infinite loop that hammers your authentication endpoint. Rate limiting (say, 5 login attempts per minute) stops this runaway process from bringing down your auth service, while still allowing legitimate users to log in normally."
+
+**Changes made:**
+- Added two concrete examples with specific numbers
+- Included both malicious (buggy script) and accidental (deployment error) scenarios
+- Used realistic metrics (1,000 requests/hour, 10,000 users)
+- Demonstrated clear cause-and-effect relationships
+
+---
+
+Now, please provide the text where you'd like me to add examples.

commands-flat/add-git-ignore.md

@@ -0,0 +1,7 @@
+Add a Git ignore at the base of this repository
+
+Inspect the codebase to infer which parts of the repo should not be committed and which are not already ignored by the global git ignore
+
+If you find any such folders, add them to .gitignore
+
+If you are unsure as to whether directories or files should be added, ask the user

commands-flat/add-git-lfs.md

@@ -0,0 +1,7 @@
+This repository contains large binaries
+
+We should add LFS 
+
+Please set it up and ensure that all large files are being tracked
+
+Validate the installation by pushing the repo

commands-flat/add-gitkeep.md

@@ -0,0 +1 @@
+Add a git hook which should seed .gitkeep folders into every folder lacking one before push

commands-flat/add-headings.md

@@ -0,0 +1,10 @@
+Structure the provided text by generating, reviewing, and refining subheadings.
+
+Your task:
+1. **Add Subheadings** – Break the text into well-defined sections with concise, descriptive subheadings
+2. **Logical Division** – Ensure every major shift in topic, argument, or focus is clearly marked
+3. **Hierarchy** – Use appropriate heading levels (##, ###, etc.) to show information hierarchy
+4. **Descriptive** – Make headings informative and aligned with the main ideas of each section
+5. **Readability** – Improve navigation and comprehension through clear section breaks
+
+Apply changes directly. Preserve the original content while adding structure.

commands-flat/add-master-index-badge.md

@@ -0,0 +1,15 @@
+This repository is an indexing repository. 
+
+I create these to gather together resources I create about a common topic.
+
+I also have a master index which I use as a "top level" map of the repos I create on Github.
+
+That's here:
+
+https://github.com/danielrosehill/Github-Master-Index
+
+Please:
+
+Add a link to the master index, using Shields.io, to the top of the readme. If there is an existing badges section, add that into it. if not, create one alongside an index repo badge.
+
+The purpose of these links is to make it easier to jump between the various indexing related repos I have on Github.

commands-flat/add-metaphors.md

@@ -0,0 +1,180 @@
+# Add Metaphors - Figurative Language Enhancer
+
+Inject vivid metaphors, analogies, and figurative language into content to make it more engaging, memorable, and accessible. Perfect for making technical concepts relatable, adding color to dry content, or creating more evocative writing.
+
+## Your Task
+
+Take the user's content and strategically add metaphors, similes, and analogies that illuminate concepts, create visual imagery, and make the writing more engaging while maintaining clarity and professionalism.
+
+## Types of Figurative Language to Add
+
+### 1. Conceptual Metaphors
+
+Explain abstract concepts through concrete comparisons:
+
+**Before**: "The database stores information efficiently."
+
+**After**: "The database is like a well-organized library, storing information efficiently with each piece of data catalogued and indexed so you can retrieve exactly what you need in seconds rather than searching through piles of unsorted papers."
+
+### 2. Visual Metaphors
+
+Create mental images:
+
+**Before**: "The network experienced high traffic."
+
+**After**: "The network experienced a rush-hour traffic jam, with data packets bumper-to-bumper, inching along congested digital highways as the infrastructure struggled to handle the volume."
+
+### 3. Process Analogies
+
+Compare processes to familiar activities:
+
+**Before**: "The compiler checks your code for errors."
+
+**After**: "The compiler acts like a meticulous editor reviewing your manuscript, catching typos, grammar mistakes, and logical inconsistencies before your code goes to 'publication.'"
+
+### 4. Comparative Metaphors
+
+Contrast before/after or different approaches:
+
+**Before**: "The old system was slow and the new one is fast."
+
+**After**: "Upgrading from the old system to the new one is like trading in a bicycle for a sports car—you're still getting from A to B, but the experience and speed are in completely different leagues."
+
+### 5. Personification
+
+Give human qualities to abstract concepts or systems:
+
+**Before**: "The algorithm learns from data."
+
+**After**: "The algorithm is a diligent student, poring over data sets and learning from each example, gradually building expertise and improving its performance with every lesson."
+
+### 6. Extended Metaphors
+
+Develop a metaphor across multiple sentences:
+
+**Before**: "The architecture has multiple layers that work together."
+
+**After**: "Think of the architecture as a well-run kitchen brigade. The front-end is like the waitstaff, presenting beautifully plated experiences to customers. The middleware is the expediter, coordinating between front and back. The backend is the kitchen itself—the real powerhouse where the magic happens. And the database? That's the walk-in freezer and pantry, storing all the ingredients these layers need to work their magic."
+
+### 7. Everyday Analogies
+
+Use common experiences to explain technical concepts:
+
+**Before**: "Caching improves performance by storing frequently accessed data."
+
+**After**: "Caching is like keeping your coffee mug on your desk instead of walking to the kitchen cabinet every time you want a sip. By storing frequently accessed data close at hand, the system dramatically reduces the time spent fetching information."
+
+### 8. Nature and Physical World Metaphors
+
+Draw from natural phenomena:
+
+**Before**: "The system handles multiple requests simultaneously."
+
+**After**: "The system juggles multiple requests simultaneously, like a river branching into tributaries—each stream flowing independently yet all part of the same watershed, eventually converging back together downstream."
+
+## Metaphor Placement Strategies
+
+### Where to Add Metaphors
+
+1. **Introducing new concepts**: Use metaphors to make first exposure memorable
+2. **Explaining complex processes**: Break down complexity with familiar comparisons
+3. **Transitions**: Create bridges between sections with thematic metaphors
+4. **Opening hooks**: Start sections with engaging comparisons
+5. **Summaries**: Reinforce key points with memorable imagery
+6. **Abstract ideas**: Ground theoretical concepts in concrete terms
+
+### Density Guidelines
+
+**Light touch (1-2 metaphors per page)**:
+- Professional/technical documents
+- Subtle enhancement
+- Preserve formal tone
+
+**Moderate use (3-5 metaphors per page)**:
+- Blog posts and articles
+- Educational content
+- Balanced engagement
+
+**Heavy use (6+ metaphors per page)**:
+- Creative writing
+- Marketing content
+- Maximum engagement and memorability
+
+## Metaphor Quality Guidelines
+
+### Good Metaphors
+
+✓ **Illuminating**: Actually clarifies the concept
+✓ **Appropriate**: Matches the audience and context
+✓ **Consistent**: Doesn't contradict itself when extended
+✓ **Fresh**: Avoids clichés (unless intentionally used)
+✓ **Cultural**: Accessible to your target audience
+✓ **Scalable**: Works at the intended level of detail
+
+### Avoid
+
+✗ **Mixed metaphors**: "We'll burn that bridge when we come to it"
+✗ **Overextension**: Pushing a metaphor too far
+✗ **Obscure references**: Metaphors the audience won't understand
+✗ **Inappropriate comparisons**: Context-insensitive or offensive analogies
+✗ **Clichéd overuse**: Too many tired expressions
+✗ **Confusing metaphors**: More confusing than the original concept
+
+## Domain-Specific Metaphor Banks
+
+### Technology/Software
+- Architecture as buildings/construction
+- Networks as highways/roads
+- Data as water/flow
+- Security as locks/fortresses
+- Code as recipes/blueprints
+- Processes as assembly lines
+
+### Business/Management
+- Growth as gardening/cultivation
+- Strategy as chess/war games
+- Teams as sports/orchestras
+- Markets as weather/oceans
+- Innovation as exploration/pioneering
+
+### Science/Research
+- Discovery as treasure hunting
+- Analysis as detective work
+- Experimentation as cooking
+- Theories as frameworks/scaffolding
+
+## Example Transformations
+
+**Before (Technical, no metaphors)**:
+```
+Machine learning models require training data to develop predictive capabilities. The quality of the training data significantly impacts model performance. More diverse data typically produces more robust models that generalize well to new situations.
+```
+
+**After (Metaphor-enhanced)**:
+```
+Machine learning models are like apprentices learning a craft—they require training data to develop predictive capabilities. The quality of their education (the training data) significantly impacts their professional performance. Just as a chef who trains in multiple cuisines becomes more versatile than one who specializes narrowly, models fed diverse data become more robust, able to handle the unexpected ingredients of new situations with confidence and skill.
+```
+
+**Before (Plain business writing)**:
+```
+Our company is transitioning to a new strategic direction. This requires all teams to adapt their processes and adopt new tools. The change will take time but will ultimately improve efficiency.
+```
+
+**After (Metaphor-rich)**:
+```
+Our company is turning the ship toward new waters. Like a sailing vessel changing course, this requires all teams to adjust their sails—adapting processes and hauling in new tools to harness the winds of change. The turn won't happen overnight; ships of our size need time to change direction. But once we're sailing this new heading, we'll cut through the waves with greater speed and efficiency than ever before.
+```
+
+## Output Format
+
+Return the enhanced version of the content with metaphors naturally woven throughout. If the original content has a specific tone (technical, casual, formal), preserve it while adding figurative language that fits.
+
+## Usage Notes
+
+Specify if you want:
+- **Metaphor density**: Light, moderate, or heavy
+- **Tone**: Professional, casual, creative, educational
+- **Audience**: Technical experts, general public, specific industry
+- **Specific themes**: Prefer certain types of metaphors (nature, sports, cooking, etc.)
+
+Share the content you'd like to enhance with metaphors and analogies.

commands-flat/add-missing-subheadings.md

@@ -0,0 +1,74 @@
+# Add Missing Subheadings
+
+You are a document structure specialist. Your task is to analyze the provided text and add appropriate subheadings to improve readability and organization.
+
+## Your Task
+
+1. **Analyze the text structure**
+   - Identify major topic shifts and logical sections
+   - Look for paragraphs that introduce new concepts or themes
+   - Notice where the text transitions between ideas
+
+2. **Create appropriate subheadings**
+   - Use clear, descriptive titles that reflect the content
+   - Maintain consistent heading hierarchy (H2, H3, H4 as needed)
+   - Follow the document's existing tone and style
+   - Use parallel structure when possible (e.g., all verb phrases or all noun phrases)
+
+3. **Insert subheadings strategically**
+   - Break up long blocks of text
+   - Create logical sections (aim for 2-4 paragraphs per section)
+   - Don't over-segment short sections
+   - Preserve the original text without modification
+
+## Heading Hierarchy Guidelines
+
+- **H2 (##)**: Main sections representing major topic divisions
+- **H3 (###)**: Subsections within a major topic
+- **H4 (####)**: Sub-subsections for detailed breakdowns (use sparingly)
+
+## Style Guidelines
+
+- Keep headings concise (2-6 words typically)
+- Use title case or sentence case consistently
+- Avoid redundant words ("Section on..." or "Information about...")
+- Make headings scannable and informative
+- Consider SEO-friendly phrasing when appropriate
+
+## Example
+
+**Before:**
+```
+Content about topic A spanning 3 paragraphs...
+
+Content about topic B spanning 2 paragraphs...
+
+Content about topic C spanning 4 paragraphs...
+```
+
+**After:**
+```
+## Topic A
+
+Content about topic A spanning 3 paragraphs...
+
+## Topic B
+
+Content about topic B spanning 2 paragraphs...
+
+## Topic C
+
+### Subtopic C1
+Content about first aspect...
+
+### Subtopic C2
+Content about second aspect...
+```
+
+## Output Format
+
+Return the full text with subheadings inserted. Preserve all original content exactly as written, adding only markdown heading syntax.
+
+---
+
+Now, please provide the text you'd like me to enhance with subheadings.

commands-flat/add-mit-license.md

@@ -0,0 +1,12 @@
+I would like to add the MIT license to this repo.
+
+Do the folllowing:
+
+1- Add the license 
+2 - Note, in README, that this project is licensed under MIT
+
+Use these details:
+
+Name: Daniel Rosehill
+Email: public@danielrosehill.com 
+Current year: 2025

commands-flat/add-punctuation.md

@@ -0,0 +1,12 @@
+This text is missing basic punctuation.
+
+Add appropriate punctuation including:
+
+- Periods at the end of sentences
+- Commas where needed for readability
+- Question marks for questions
+- Exclamation points where appropriate
+- Apostrophes for contractions and possessives
+- Quotation marks where needed
+
+Keep the original meaning and tone intact. Don't change the words themselves unless absolutely necessary for clarity.

commands-flat/add-readme.md

@@ -0,0 +1,18 @@
+Add the README.md
+
+Do:
+
+- Summarise clearly and simply the purpose of this project/codebase as you can infer it. You may use the understanding of the repository you have built up during this session, or in prior memory, to supplement your current indexing
+
+- Use shields.io badges sparingly to visually identify languages and components used
+
+- Prefer markdown tables over bullet point lists. When adding a table of repositories, use shields.io badges for linking to the repos 
+
+- Add internal links on README.md by adding relative links that will be navigable when visited on github.com 
+
+DO NOT:
+
+- Use emojis! 
+- Add a contributor guidelines section (unless otherwise stated)
+- Add a license or make any note of licensing.
+- Include navigable links to any parts of the repository which are deliberately not commited: for example if there's a folder called /private, don't mention it or add links to it 

commands-flat/add-related-repos-section.md

@@ -0,0 +1,13 @@
+This repository is part of a group of repositories. 
+
+The user would like to add a "Related Repos" section to both make that clear and make it easier for browsers to find the connected parts of this project.
+
+Here's the approach you should take:
+
+- Ask the user to provide the list of related repos. Alternatively the user will provide these one by one. 
+
+Once you've got the list:
+
+- Add a related repos section towards the bottom of README.md
+- List the related repos alphabetically, unless the user has requested an alternative method
+-  Add the links as github repo badges wit shields.io 

commands-flat/add-repo-index.md

@@ -0,0 +1,13 @@
+I would like you to add an index to this repository that users can navigate on Github.com (to do this, use relative links).
+
+This index should be:
+
+- Created programmatically 
+- Created incrementally, if possible
+
+Follow this general preference:
+
+- The index is created by a script as a standalone file 
+- That file is injected into README.md using injection markers 
+
+The script to generate the index, once validated, can be implemented as a pre push hook

commands-flat/add-sources.md

@@ -0,0 +1,25 @@
+Add inline Markdown source links to factual claims in the provided text.
+
+Your task:
+1. Identify claims that require sourcing (statistics, dates, names, study findings, quotations, events)
+2. Find reliable sources for each claim
+3. Insert inline Markdown links `[anchor text](URL)` at the point of claim
+4. If a source cannot be found, append `[source needed]`
+
+What requires a source:
+- Specific numbers and statistics
+- Dates and timelines
+- Names and roles of people/organizations
+- Study findings and research results
+- Legal/policy references
+- Standards and specifications
+- Quotations
+- Notable events
+
+Source hierarchy:
+1. Primary/official sources
+2. Peer-reviewed literature
+3. High-quality secondary sources (.gov, .edu, major journals)
+4. Reputable reports with transparent methods
+
+Use concise, factual anchor text. Link the first occurrence of recurring facts. Preserve document structure and formatting.

commands-flat/add-statistics.md

@@ -0,0 +1,61 @@
+# Add Statistics
+
+You are a data enrichment specialist. Your task is to identify places in the provided text where statistics would strengthen arguments and either suggest specific statistics to add or indicate where they should be researched.
+
+## Your Task
+
+1. **Analyze the text** for claims that would benefit from statistical support
+2. **Identify opportunities** where numbers would add credibility
+3. **Suggest relevant statistics** when you have knowledge of them, OR
+4. **Mark locations** where statistics should be researched and added
+
+## Types of Statistics to Consider
+
+### Quantitative Support
+- **Market data**: Size, growth rates, trends
+- **Performance metrics**: Success rates, improvements, ROI
+- **Demographic data**: Population statistics, user numbers
+- **Research findings**: Study results, survey data, meta-analyses
+- **Comparative data**: Industry benchmarks, before/after comparisons
+- **Temporal data**: Historical trends, projections, time-based metrics
+
+### Statistical Formats
+- **Percentages**: "40% increase", "9 out of 10 users"
+- **Absolute numbers**: "2.5 million customers", "$500K saved"
+- **Ratios**: "3:1 return on investment"
+- **Ranges**: "Between 15-20% improvement"
+- **Rates**: "95% satisfaction rate"
+
+## Guidelines
+
+- **Precision matters**: Use specific numbers rather than vague claims
+- **Source credibility**: Note reputable sources when suggesting statistics
+- **Relevance**: Only add statistics that directly support the argument
+- **Recency**: Prefer recent data (note when data may be outdated)
+- **Context**: Include necessary context (timeframe, sample size, methodology)
+- **Balance**: Don't overwhelm with numbers—use strategically
+
+## Output Format
+
+Provide the text with:
+- **[STAT NEEDED: description]** markers where research is required
+- **[SUGGESTED STAT: statistic + source]** where you can suggest specific data
+- Integrated statistics with proper context and sourcing
+
+## Example
+
+**Before:**
+"Email marketing is very effective. Many businesses see good results. Our platform helps companies improve their email campaigns."
+
+**After:**
+"Email marketing delivers exceptional ROI: businesses see an average return of $42 for every $1 spent [SUGGESTED STAT: DMA 2023 Email Marketing Metrics]. Over 80% of marketers report increased engagement through personalized email campaigns [SUGGESTED STAT: HubSpot 2024 Marketing Report]. Our platform has helped companies improve their email open rates by [STAT NEEDED: internal performance data - average open rate improvement percentage] compared to industry baseline."
+
+**Changes made:**
+- Added ROI statistic with source
+- Added engagement percentage with source
+- Marked where company-specific data should be inserted
+- Provided context for each statistic
+
+---
+
+Now, please provide the text you'd like me to enrich with statistics.

commands-flat/add-technical-depth.md

@@ -0,0 +1,10 @@
+Add more technical depth and specificity to this text.
+
+Enhance technical content:
+- Replace general terms with specific technical terminology
+- Add relevant technical details
+- Include technical context where appropriate
+- Use industry-standard nomenclature
+- Make explanations more technically precise
+
+Assume the reader has technical background. Keep accuracy paramount.

commands-flat/add-to-my-notes.md

@@ -0,0 +1,9 @@
+Thanks for that useful information.
+
+I would like to document this for my later reference.
+
+Please do the following:
+
+- Navigate to my reference notebook at: /home/daniel/obsidian-notebooks/notes-from-ai
+- Create a document in the most logical folder in the filesystem. If one doesn't exist to house this topic, create it 
+- When the note has been created, push the notebook

commands-flat/add-ubuntu-build-script.md

@@ -0,0 +1,11 @@
+Please add a build script to this repository.
+
+The build script should be optimised to work on Ubuntu Linux, which is the target OS for this application.
+
+In the first instance: the build script should generate a debian package (.deb). 
+
+If this can be reliably generated from the codebase, then do *not* write the build script to create any other packages (such as App Image).
+
+However, if there are issues compiling to debian, then consider and use these other options instead. 
+
+Create, as well, an update script. This should: uninstall the current package, build the new one, and then install it in its place.

commands-flat/add-uv-venv.md

@@ -0,0 +1,7 @@
+This Python projects should use a virtual environment.
+
+Create one with uv by:
+
+- Writing requirements.txt
+- Writing a bash script to create the venv
+- Run it and debug any errors that we encounter 

commands-flat/add-vibe-coding-disclosure.md

@@ -0,0 +1,13 @@
+Please add a note to the README that the code in this repo was generated entirely by AI or with AI assistance. 
+
+To do so, let's add this badge somewhere prominent in the README:
+ 
+ ![AI Assisted Development](https://img.shields.io/badge/AI%20Assisted-Development-brightgreen?style=for-the-badge&logo=robot)
+
+And add it again in the footer like this.
+
+## AI Assisted Development
+
+![AI Assisted Development](https://img.shields.io/badge/AI%20Assisted-Development-brightgreen?style=for-the-badge&logo=robot)
+
+The code in this repository was generated by or with an AI tool. Use and integrate with your projects at your own risk.

commands-flat/add-watermark.md

@@ -0,0 +1,57 @@
+# Add Watermark to Video
+
+You are a video editing assistant specialized in adding watermarks (text or image overlays) to videos using FFmpeg.
+
+## Your Task
+
+Help the user add a watermark to their video:
+
+1. Ask the user for:
+   - Input video file path
+   - Watermark type (text or image)
+   - For text: content, font, size, color
+   - For image: image file path, transparency level
+   - Position (corner, center, custom coordinates)
+   - Output file path
+
+2. Construct the appropriate FFmpeg overlay command:
+   - Use `drawtext` filter for text watermarks
+   - Use `overlay` filter for image watermarks
+   - Position correctly (top-left, top-right, bottom-left, bottom-right, center)
+   - Apply transparency/opacity if requested
+
+3. Execute and verify output quality
+
+## Text Watermark Examples
+
+**Simple text in bottom-right corner:**
+```bash
+ffmpeg -i input.mp4 -vf "drawtext=text='Copyright 2025':fontcolor=white:fontsize=24:x=w-tw-10:y=h-th-10" output.mp4
+```
+
+**Text with shadow/outline:**
+```bash
+ffmpeg -i input.mp4 -vf "drawtext=text='My Channel':fontcolor=white:fontsize=30:borderw=2:bordercolor=black:x=10:y=10" output.mp4
+```
+
+## Image Watermark Examples
+
+**Logo in top-right corner with 50% opacity:**
+```bash
+ffmpeg -i input.mp4 -i logo.png -filter_complex "[1:v]format=rgba,colorchannelmixer=aa=0.5[logo];[0:v][logo]overlay=W-w-10:10" output.mp4
+```
+
+**Centered watermark:**
+```bash
+ffmpeg -i input.mp4 -i watermark.png -filter_complex "overlay=(W-w)/2:(H-h)/2" output.mp4
+```
+
+## Position Shortcuts
+
+- Top-left: `x=10:y=10`
+- Top-right: `x=w-tw-10:y=10` (text) or `x=W-w-10:10` (image)
+- Bottom-left: `x=10:y=h-th-10` (text) or `x=10:y=H-h-10` (image)
+- Bottom-right: `x=w-tw-10:y=h-th-10` (text) or `x=W-w-10:H-h-10` (image)
+- Center: `x=(w-tw)/2:y=(h-th)/2` (text) or `x=(W-w)/2:y=(H-h)/2` (image)
+
+Be creative and help users protect their content with professional watermarks.

commands-flat/add-wip.md

@@ -0,0 +1,11 @@
+This repository is a work in progress (WIP). I would like to highlight that. 
+
+To do this, please:
+
+- Add a work in progress badge (using Shields.io). Position this at the top of the readme.
+
+Add somewhere else in the readme:
+
+## Work In Progress
+
+This repository is a work in progress

commands-flat/adding-to-awesome-list.md

@@ -0,0 +1,17 @@
+Please help me to add a new resource to this awesome list.
+
+Context:
+
+- This repo is my fork of an awesome list 
+- I have a project(s) that I would like to add to it 
+
+To do that we should:
+
+- Study the contributor guidelines (if any) 
+- Identify the right place to add my contribution
+
+Then, we should follow the usual protocol:
+
+- Create a new branch 
+- Add our addition 
+- Open a PR

commands-flat/ai-context.md

@@ -0,0 +1,8 @@
+Add an "AI Context Repository" badge to the repository README indicating this repo contains context files, documentation, or resources designed for AI agent consumption.
+
+Use this shields.io badge format:
+```markdown
+![AI Context Repository](https://img.shields.io/badge/AI_Context_Repository-FF6B6B?style=for-the-badge&logo=robot&logoColor=white)
+```
+
+Add it to the appropriate badges section in the README.

commands-flat/ai-friendly-seo.md

@@ -0,0 +1,47 @@
+Optimize content for AI search engines and crawlers (ChatGPT, Claude, Perplexity, etc.).
+
+Your task:
+1. Implement AI-friendly structured data:
+   - Clear, semantic HTML structure
+   - Proper heading hierarchy
+   - Descriptive section labels
+   - Schema.org structured data
+
+2. Optimize content for AI understanding:
+   - Clear, concise descriptions
+   - Well-structured paragraphs
+   - Logical content flow
+   - Explicit relationships between concepts
+
+3. Add metadata for AI crawlers:
+   ```html
+   <!-- Traditional SEO that also helps AI -->
+   <meta name="description" content="Clear, comprehensive description">
+
+   <!-- Structured data -->
+   <script type="application/ld+json">
+   {
+     "@context": "https://schema.org",
+     "@type": "Article",
+     "headline": "...",
+     "description": "...",
+     "author": {...}
+   }
+   </script>
+   ```
+
+4. Improve content discoverability:
+   - Clear, descriptive page titles
+   - Comprehensive introductions
+   - Table of contents for long content
+   - Summary sections
+   - FAQ sections in structured format
+
+5. Technical optimizations:
+   - Clean, crawlable URLs
+   - Proper internal linking
+   - Breadcrumb navigation
+   - RSS/Atom feeds
+   - API endpoints for content (if applicable)
+
+Focus on making content easily discoverable and understandable by AI systems while maintaining human readability.

commands-flat/allow-env.md

@@ -0,0 +1,5 @@
+I have a global git ignore that blocks .env from syncing
+
+This is a private repo and I wish to override that behavior and ensure that .env is synced
+
+Please add or update a manual .gitignore at the repo level to achieve that behavior and verify that it makes it into version control

commands-flat/analyze-commits.md

@@ -0,0 +1,56 @@
+Analyze and summarize changes from repository commit history.
+
+Your task:
+1. Examine recent commit history:
+   ```bash
+   git log --oneline -20
+   git log --since="1 week ago" --oneline
+   ```
+
+2. Analyze the changes made:
+   - Types of changes (features, fixes, refactoring, docs)
+   - Files most frequently modified
+   - Code complexity trends
+   - Patterns in commit messages
+
+3. Identify incremental progress:
+   - Feature development trajectory
+   - Bug fix patterns
+   - Refactoring efforts
+   - Documentation improvements
+
+4. Determine technical skills demonstrated:
+   - Programming languages used
+   - Frameworks and libraries
+   - Design patterns implemented
+   - Testing approaches
+   - DevOps practices
+
+5. Generate summary report:
+   ```markdown
+   ## Commit Analysis Summary
+
+   **Period:** Last 30 days
+   **Total Commits:** 45
+
+   ### Key Changes:
+   - Feature: User authentication system (15 commits)
+   - Refactor: Database layer optimization (8 commits)
+   - Fix: Various UI bugs (12 commits)
+   - Docs: API documentation updates (10 commits)
+
+   ### Technical Skills Demonstrated:
+   - Node.js/Express backend development
+   - React frontend development
+   - PostgreSQL database design
+   - JWT authentication
+   - REST API design
+   - Git workflow management
+
+   ### Most Active Areas:
+   - src/auth/ (25 commits)
+   - src/components/ (18 commits)
+   - docs/api/ (10 commits)
+   ```
+
+Help users understand project evolution and learning progress through commit analysis.

commands-flat/analyze-firewall.md

@@ -0,0 +1,286 @@
+# Analyze Firewall and Suggest Hardening
+
+You are helping the user check if a firewall is running, analyze open ports, and suggest potential hardening.
+
+## Your tasks:
+
+1. **Check if a firewall is active:**
+
+   **UFW (Uncomplicated Firewall):**
+   ```bash
+   sudo ufw status verbose
+   ```
+
+   **iptables (lower level):**
+   ```bash
+   sudo iptables -L -n -v
+   sudo ip6tables -L -n -v
+   ```
+
+   **firewalld (if used):**
+   ```bash
+   sudo firewall-cmd --state
+   sudo firewall-cmd --list-all
+   ```
+
+   **nftables (modern replacement for iptables):**
+   ```bash
+   sudo nft list ruleset
+   ```
+
+2. **If no firewall is active, recommend enabling UFW:**
+   ```bash
+   sudo apt install ufw
+   sudo ufw enable
+   sudo ufw status
+   ```
+
+3. **Check currently listening services:**
+   ```bash
+   sudo ss -tulpn
+   # Or
+   sudo netstat -tulpn
+   ```
+
+   This shows what services are listening on which ports.
+
+4. **Check for open ports from external perspective:**
+   ```bash
+   sudo nmap -sT -O localhost
+   ```
+
+   Or install nmap if not available:
+   ```bash
+   sudo apt install nmap
+   ```
+
+5. **Analyze each open port:**
+   For each listening port, identify:
+   - Which service is using it
+   - Whether it should be accessible from network
+   - Current firewall rules for it
+
+   Common ports to check:
+   - 22 (SSH)
+   - 80 (HTTP)
+   - 443 (HTTPS)
+   - 3306 (MySQL)
+   - 5432 (PostgreSQL)
+   - 6379 (Redis)
+   - 27017 (MongoDB)
+   - 3389 (RDP)
+   - 445 (SMB)
+   - 2049 (NFS)
+
+6. **Check UFW rules in detail:**
+   ```bash
+   sudo ufw status numbered
+   sudo ufw show added
+   ```
+
+7. **Check iptables rules in detail:**
+   ```bash
+   sudo iptables -S
+   sudo iptables -L INPUT -v -n
+   sudo iptables -L OUTPUT -v -n
+   sudo iptables -L FORWARD -v -n
+   ```
+
+8. **Identify potential security issues:**
+
+   **Services listening on 0.0.0.0 (all interfaces):**
+   These are accessible from network. Should they be?
+   ```bash
+   sudo ss -tulpn | grep "0.0.0.0"
+   ```
+
+   **Services that should only be local:**
+   Databases, Redis, etc. should typically only listen on 127.0.0.1:
+   ```bash
+   sudo ss -tulpn | grep -v "127.0.0.1"
+   ```
+
+   **Unnecessary services:**
+   Check for services that shouldn't be running:
+   ```bash
+   sudo systemctl list-units --type=service --state=running | grep -E "telnet|ftp|rsh"
+   ```
+
+9. **Analyze by service type:**
+
+   **SSH (port 22):**
+   - Should SSH be accessible from internet?
+   - Consider changing default port
+   - Check SSH configuration: `cat /etc/ssh/sshd_config | grep -v "^#" | grep -v "^$"`
+   - Verify key-only authentication is enforced
+   - Check fail2ban status: `sudo systemctl status fail2ban`
+
+   **Web services (80, 443):**
+   - Are these intentional?
+   - Is there a web server running?
+   - Check for default/test pages
+
+   **Databases (3306, 5432, 27017, etc.):**
+   - Should NEVER be exposed to internet
+   - Should listen only on 127.0.0.1
+   - Check configuration files
+
+10. **Check for common attack vectors:**
+    ```bash
+    # Check for services with known vulnerabilities
+    sudo ss -tulpn | grep -E "telnet|ftp|rlogin|rsh|rexec"
+
+    # Check for uncommon high ports
+    sudo ss -tulpn | awk '{print $5}' | cut -d: -f2 | sort -n | uniq
+    ```
+
+11. **Suggest hardening measures:**
+
+    **Enable UFW if not active:**
+    ```bash
+    sudo ufw default deny incoming
+    sudo ufw default allow outgoing
+    sudo ufw enable
+    ```
+
+    **For SSH access:**
+    ```bash
+    sudo ufw allow 22/tcp comment 'SSH'
+    # Or from specific IP:
+    sudo ufw allow from <IP-address> to any port 22 comment 'SSH from specific IP'
+    ```
+
+    **For web server:**
+    ```bash
+    sudo ufw allow 80/tcp comment 'HTTP'
+    sudo ufw allow 443/tcp comment 'HTTPS'
+    ```
+
+    **For local network only:**
+    ```bash
+    sudo ufw allow from 192.168.1.0/24 comment 'Local network'
+    ```
+
+12. **Install and configure fail2ban (recommended):**
+    ```bash
+    sudo apt install fail2ban
+    sudo systemctl enable fail2ban
+    sudo systemctl start fail2ban
+    sudo fail2ban-client status
+    sudo fail2ban-client status sshd
+    ```
+
+13. **Check for IPv6 exposure:**
+    ```bash
+    sudo ss -tulpn6
+    sudo ufw status
+    ```
+
+    Ensure IPv6 is also protected:
+    ```bash
+    sudo ufw default deny incoming
+    # UFW handles both IPv4 and IPv6
+    ```
+
+14. **Advanced iptables hardening (if using iptables):**
+
+    **Drop invalid packets:**
+    ```bash
+    sudo iptables -A INPUT -m conntrack --ctstate INVALID -j DROP
+    ```
+
+    **Rate limit SSH:**
+    ```bash
+    sudo iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --set
+    sudo iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 4 -j DROP
+    ```
+
+    **Log dropped packets:**
+    ```bash
+    sudo iptables -A INPUT -j LOG --log-prefix "iptables-dropped: "
+    ```
+
+15. **Check for Docker interference:**
+    Docker manipulates iptables directly, which can bypass UFW:
+    ```bash
+    sudo iptables -L DOCKER -n
+    ```
+
+    To prevent Docker from bypassing UFW, edit `/etc/docker/daemon.json`:
+    ```json
+    {
+      "iptables": false
+    }
+    ```
+
+    Or use firewalld instead for better Docker integration.
+
+16. **Check connection tracking:**
+    ```bash
+    sudo conntrack -L
+    cat /proc/sys/net/netfilter/nf_conntrack_count
+    cat /proc/sys/net/netfilter/nf_conntrack_max
+    ```
+
+17. **Review logging:**
+    ```bash
+    sudo grep UFW /var/log/syslog | tail -20
+    sudo tail -20 /var/log/ufw.log
+    ```
+
+18. **Generate hardening recommendations:**
+    Based on findings, suggest:
+    - Enable firewall if not active
+    - Block unnecessary ports
+    - Restrict services to local interface only
+    - Install fail2ban for brute-force protection
+    - Change SSH port (optional, security through obscurity)
+    - Disable root SSH login
+    - Use key-based SSH authentication only
+    - Close database ports from external access
+    - Remove unnecessary services
+    - Enable connection rate limiting
+    - Set up intrusion detection (OSSEC, Snort)
+    - Regular security updates
+    - Monitor logs regularly
+
+19. **Provide firewall management commands:**
+
+    **UFW:**
+    - `sudo ufw status` - Check status
+    - `sudo ufw enable` - Enable firewall
+    - `sudo ufw disable` - Disable firewall
+    - `sudo ufw allow <port>` - Allow port
+    - `sudo ufw deny <port>` - Deny port
+    - `sudo ufw delete <rule>` - Delete rule
+    - `sudo ufw reset` - Reset to default
+    - `sudo ufw logging on` - Enable logging
+
+    **iptables:**
+    - `sudo iptables -L` - List rules
+    - `sudo iptables -A INPUT -p tcp --dport <port> -j ACCEPT` - Allow port
+    - `sudo iptables -D INPUT <rule-number>` - Delete rule
+    - `sudo iptables-save > /etc/iptables/rules.v4` - Save rules
+    - `sudo iptables-restore < /etc/iptables/rules.v4` - Restore rules
+
+20. **Report findings:**
+    Summarize:
+    - Firewall status (active/inactive)
+    - List of open ports
+    - Services listening on each port
+    - Current firewall rules
+    - Security issues found
+    - Recommended hardening measures
+    - Priority actions (critical vs. nice-to-have)
+
+## Important notes:
+- Test firewall rules carefully to avoid locking yourself out
+- Always have a backup access method (console/KVM) before changing SSH rules
+- UFW and iptables can conflict - use one or the other
+- Docker can bypass UFW - special configuration needed
+- Deny incoming by default, allow specific services
+- Keep logs for intrusion detection
+- Regularly review and update firewall rules
+- Consider using VPN for remote access instead of exposing services
+- fail2ban is essential for SSH protection
+- Don't expose databases to the internet

commands-flat/apply-filters.md

@@ -0,0 +1,244 @@
+# Apply Image Filters
+
+You are a photo editing assistant specialized in applying artistic and corrective filters to images using ImageMagick and other tools.
+
+## Your Task
+
+Help the user apply filters and effects to their images:
+
+1. Ask the user for:
+   - Input image(s)
+   - Desired filter/effect type
+   - Intensity/parameters
+   - Whether to batch process
+   - Output path
+
+2. Apply filters using ImageMagick:
+   - Color adjustments
+   - Artistic effects
+   - Blur and sharpening
+   - Vintage/retro effects
+   - Custom filter chains
+
+3. Execute and verify results
+
+## Popular Filters
+
+### Black and White
+
+**Simple grayscale:**
+```bash
+convert input.jpg -colorspace Gray output.jpg
+```
+
+**High-contrast B&W:**
+```bash
+convert input.jpg -colorspace Gray -contrast -contrast output.jpg
+```
+
+**Dramatic B&W (channel mixer):**
+```bash
+convert input.jpg -channel R -evaluate multiply 0.3 -channel G -evaluate multiply 0.59 -channel B -evaluate multiply 0.11 -separate -average output.jpg
+```
+
+### Vintage/Retro Effects
+
+**Sepia tone:**
+```bash
+convert input.jpg -sepia-tone 80% output.jpg
+```
+
+**Vintage fade:**
+```bash
+convert input.jpg -modulate 100,80,100 -fill '#ffe4b5' -colorize 20% output.jpg
+```
+
+**Polaroid effect:**
+```bash
+convert input.jpg -bordercolor white -border 10 -bordercolor grey60 -border 1 -background black \( +clone -shadow 60x4+4+4 \) +swap -background white -flatten output.jpg
+```
+
+### Color Adjustments
+
+**Boost saturation:**
+```bash
+convert input.jpg -modulate 100,150,100 output.jpg
+```
+
+**Warm tone:**
+```bash
+convert input.jpg -modulate 100,100,110 output.jpg
+```
+
+**Cool tone:**
+```bash
+convert input.jpg -modulate 100,100,90 output.jpg
+```
+
+**Auto-level (normalize colors):**
+```bash
+convert input.jpg -auto-level output.jpg
+```
+
+**Increase vibrance:**
+```bash
+convert input.jpg -modulate 100,120 output.jpg
+```
+
+### Blur Effects
+
+**Gaussian blur:**
+```bash
+convert input.jpg -blur 0x8 output.jpg
+```
+
+**Motion blur:**
+```bash
+convert input.jpg -motion-blur 0x20+45 output.jpg
+```
+
+**Radial blur:**
+```bash
+convert input.jpg -radial-blur 10 output.jpg
+```
+
+### Sharpen
+
+**Unsharp mask:**
+```bash
+convert input.jpg -unsharp 0x1.5+1.0+0.05 output.jpg
+```
+
+**Strong sharpen:**
+```bash
+convert input.jpg -sharpen 0x2.0 output.jpg
+```
+
+### Artistic Effects
+
+**Oil painting:**
+```bash
+convert input.jpg -paint 4 output.jpg
+```
+
+**Sketch/pencil drawing:**
+```bash
+convert input.jpg -colorspace Gray -sketch 0x20+135 output.jpg
+```
+
+**Charcoal drawing:**
+```bash
+convert input.jpg -charcoal 2 output.jpg
+```
+
+**Edge detection:**
+```bash
+convert input.jpg -edge 2 output.jpg
+```
+
+**Emboss:**
+```bash
+convert input.jpg -emboss 2 output.jpg
+```
+
+**Posterize:**
+```bash
+convert input.jpg -posterize 4 output.jpg
+```
+
+### HDR Effect
+
+```bash
+convert input.jpg \( +clone -blur 0x12 \) -compose overlay -composite -modulate 100,130 output.jpg
+```
+
+### Instagram-Style Filters
+
+**Nashville (warm, vintage):**
+```bash
+convert input.jpg -modulate 120,150,100 -fill '#f7daae' -colorize 20% -gamma 1.2 output.jpg
+```
+
+**Kelvin (warm, high contrast):**
+```bash
+convert input.jpg -modulate 110,100,100 -fill '#ff9900' -colorize 10% -contrast output.jpg
+```
+
+**Lomo (high contrast, vignette):**
+```bash
+convert input.jpg -modulate 100,150,100 -sigmoidal-contrast 3,50% \( +clone -sparse-color Barycentric '0,0 black 0,%h black %w,0 black %w,%h black' -function polynomial 1,-1,1 \) -compose multiply -composite output.jpg
+```
+
+## Batch Processing
+
+**Apply filter to all images:**
+```bash
+for file in *.jpg; do
+  convert "$file" -sepia-tone 80% "vintage_${file}"
+done
+```
+
+**Multiple filters in sequence:**
+```bash
+convert input.jpg -modulate 100,120 -unsharp 0x1.5 -auto-level output.jpg
+```
+
+## Advanced Filter Combinations
+
+**Professional portrait enhancement:**
+```bash
+convert input.jpg \
+  -unsharp 0x1.0+1.0+0.05 \
+  -modulate 100,105,100 \
+  -sigmoidal-contrast 2,50% \
+  output.jpg
+```
+
+**Landscape enhancement:**
+```bash
+convert input.jpg \
+  -modulate 100,130,100 \
+  -unsharp 0x1.5 \
+  -auto-level \
+  output.jpg
+```
+
+**Matte effect:**
+```bash
+convert input.jpg \
+  -modulate 100,80,100 \
+  -gamma 0.9 \
+  -fill black -colorize 5% \
+  output.jpg
+```
+
+## Custom LUT (Color Grading)
+
+Create and apply custom color lookup tables:
+```bash
+convert input.jpg your_lut.png -hald-clut output.jpg
+```
+
+## Best Practices
+
+- Always keep original images
+- Test filters on a single image before batch processing
+- Combine multiple subtle effects rather than one extreme effect
+- Use `-quality 95` to preserve image quality
+- Preview results before processing large batches
+- Document your filter recipes for consistent style
+
+## Quick Reference
+
+| Effect | Command Option |
+|--------|----------------|
+| Grayscale | `-colorspace Gray` |
+| Sepia | `-sepia-tone 80%` |
+| Blur | `-blur 0x8` |
+| Sharpen | `-unsharp 0x1.5` |
+| Contrast | `-contrast` |
+| Brightness | `-modulate 120` |
+| Saturation | `-modulate 100,150` |
+| Edge detect | `-edge 2` |
+
+Help users create stunning visual effects and enhance their photos professionally.

commands-flat/audit-local-ai-packages.md

@@ -0,0 +1,97 @@
+---
+description: Evaluate local AI inference packages and suggest additions
+tags: [ai, ml, inference, packages, recommendations, project, gitignored]
+---
+
+You are helping the user evaluate their local AI inference setup and suggest packages to install.
+
+## Process
+
+1. **Check currently installed AI/ML packages**
+
+   **Python packages:**
+   - `pip list | grep -E "torch|tensorflow|transformers|diffusers|onnx"`
+
+   **System packages:**
+   - `dpkg -l | grep -E "rocm|cuda|python3-"`
+
+   **Conda environments:**
+   - `conda env list` (if conda is installed)
+
+   **Standalone tools:**
+   - Check for: Ollama, ComfyUI, LocalAI, text-generation-webui
+   - Check `~/programs/ai-ml/`
+
+2. **Assess hardware configuration**
+   - GPU: `rocm-smi` or `nvidia-smi`
+   - RAM: `free -h`
+   - Storage: `df -h`
+   - CPU capabilities: `lscpu | grep -E "Model name|Thread|Core"`
+
+3. **Categorize AI inference needs**
+
+   **LLM Inference:**
+   - Ollama (already covered)
+   - llama.cpp
+   - vllm
+   - text-generation-webui (oobabooga)
+   - LocalAI
+
+   **Image Generation:**
+   - ComfyUI (already covered)
+   - AUTOMATIC1111/stable-diffusion-webui
+   - InvokeAI
+   - Fooocus
+
+   **Audio/Speech:**
+   - Whisper (speech-to-text)
+   - Coqui TTS
+   - Bark
+   - MusicGen
+
+   **Video:**
+   - AnimateDiff
+   - Video generation models
+
+   **Code:**
+   - Continue.dev
+   - Tabby (local copilot)
+   - Aider
+
+   **Vector DB / RAG:**
+   - ChromaDB
+   - Qdrant
+   - FAISS
+   - LangChain
+
+4. **Check Python ML libraries**
+   - PyTorch (with ROCm/CUDA)
+   - TensorFlow
+   - transformers (Hugging Face)
+   - diffusers
+   - accelerate
+   - bitsandbytes (quantization)
+   - ONNX Runtime
+   - optimum
+
+5. **Suggest based on gaps**
+   - Identify what's missing for common workflows
+   - Prioritize based on hardware capabilities
+   - Consider ease of use vs. flexibility
+
+6. **Installation recommendations**
+   - Provide commands for suggested packages
+   - Recommend conda environments for isolation
+   - Suggest Docker containers for complex setups
+
+## Output
+
+Provide a report showing:
+- Currently installed AI/ML packages by category
+- Hardware capability summary
+- Recommended packages to install based on:
+  - User's hardware
+  - Current gaps in capabilities
+  - Popular/useful tools
+- Installation commands for each suggestion
+- Notes on hardware requirements

commands-flat/audit-ollama-models.md

@@ -0,0 +1,5 @@
+Check which ollama models I currently have.
+
+Provide me with a list grouping them into logical groups.
+
+Suggest any additions I may wish to consider or any duplicates that I may have accidentally pulled.

commands-flat/awesome-list-creation.md

@@ -0,0 +1,17 @@
+I created this repo in order to start an "awesome list"
+
+An "awesome list" is a list of resources that developers create to map out tech ecosystems. Frequently, I do not use the term "awesome" to describe them. In fact, usually, I just call them something like resource lists.
+
+Either way, expect the following workflow:
+
+- I'll describe what I'm indexing in this repo 
+- I'll create a rough note list in which I jot down links and add descriptions 
+
+Your task is to make order out of the chaos:
+
+- Create README.md 
+- Add a nicely formatted version of my notes 
+- Organise the README into headings/sections 
+- Add shields.io badges linking to the projects  
+
+You may also be asked to update READMe files that I've already created

commands-flat/awesome-list-data-extraction.md

@@ -0,0 +1,14 @@
+This repository contains an "awesome list" - a list of useful resources.
+
+I have created it, as is conventional, using README.md.
+
+I would like to refactor the list, however, to support a more programmatic workflow.
+
+To do that, let's work through the following steps:
+
+- Identify the categorisation system used. Capture this in cats.json 
+- Identify the repositories listed. Capture them in repos.json noting their categories. These should correspond to the JSON
+
+After we have created the data files, let's add a compile.sh script which will build the README from a template inserting the data from the JSON files.
+
+The goal is to make it easier to maintain the readme by modularising its maintenance (down the line, I might create a UI. But for now, leave it at the JSON creation stage)

commands-flat/backup-repo.md

@@ -0,0 +1,15 @@
+Create an on-demand backup of this repository.
+
+Your task:
+1. Create a timestamped archive of the current repository state
+2. Include all files except those in .gitignore
+3. Save the backup with a clear naming convention:
+   - Format: `{repo-name}_backup_{YYYY-MM-DD}_{HH-MM}.tar.gz`
+   - Or: `{repo-name}_backup_{YYYY-MM-DD}_{HH-MM}.zip`
+
+4. Optionally, the user may specify:
+   - Backup location (default: parent directory or ~/backups)
+   - Compression format preference
+   - Exclusion patterns beyond .gitignore
+
+Confirm backup creation and report the file location and size.

commands-flat/basic-voice-audio-edits.md

@@ -0,0 +1,9 @@
+This file contains a voice recording.
+
+Please write a script to apply the following processes:
+
+- Cut out silences 
+- Mix down to mono
+- Normalise 
+- Sample a minute of the audio. Based upon the sample, apply EQ to optimise the audio clarity. You may do this by applying low/high pass cuts, band EQ, compression, etc. 
+- Suffix the processed audio file with _suffix.

commands-flat/batch-resize.md

@@ -0,0 +1,178 @@
+# Batch Resize Images
+
+You are a photo editing assistant specialized in batch resizing images efficiently.
+
+## Your Task
+
+Help the user resize single or multiple images:
+
+1. Ask the user for:
+   - Input image(s) or directory
+   - Target dimensions (width x height, or percentage, or max dimension)
+   - Whether to maintain aspect ratio
+   - Output format (keep original or convert)
+   - Output directory/naming pattern
+
+2. Choose the appropriate tool:
+   - **ImageMagick** (`convert`/`mogrify`) - powerful CLI tool
+   - **FFmpeg** - for image sequences
+   - **Python PIL/Pillow** - for complex batch operations
+
+3. Execute and verify:
+   - Process images
+   - Report dimensions before/after
+   - Check output quality
+   - List processed files
+
+## ImageMagick Resize Commands
+
+**Resize single image to exact dimensions:**
+```bash
+convert input.jpg -resize 1920x1080! output.jpg
+```
+
+**Resize maintaining aspect ratio (fit within box):**
+```bash
+convert input.jpg -resize 1920x1080 output.jpg
+```
+
+**Resize to specific width (auto height):**
+```bash
+convert input.jpg -resize 1920x output.jpg
+```
+
+**Resize to specific height (auto width):**
+```bash
+convert input.jpg -resize x1080 output.jpg
+```
+
+**Resize by percentage:**
+```bash
+convert input.jpg -resize 50% output.jpg
+```
+
+**Resize to maximum dimension (longest side):**
+```bash
+convert input.jpg -resize 1920x1920\> output.jpg
+```
+
+## Batch Processing with ImageMagick
+
+**Resize all JPGs in directory:**
+```bash
+for file in *.jpg; do
+  convert "$file" -resize 1920x1080 "resized_${file}"
+done
+```
+
+**In-place resize with mogrify:**
+```bash
+mogrify -resize 1920x1080 *.jpg
+```
+
+**Resize and convert to different format:**
+```bash
+for file in *.png; do
+  convert "$file" -resize 1920x1080 "${file%.png}.jpg"
+done
+```
+
+**Resize with quality control:**
+```bash
+for file in *.jpg; do
+  convert "$file" -resize 1920x1080 -quality 90 "resized_${file}"
+done
+```
+
+## Advanced Options
+
+**Resize and add padding/background:**
+```bash
+convert input.jpg -resize 1920x1080 -background black -gravity center -extent 1920x1080 output.jpg
+```
+
+**Resize with sharpening:**
+```bash
+convert input.jpg -resize 1920x1080 -sharpen 0x1.0 output.jpg
+```
+
+**Resize multiple images to same directory:**
+```bash
+mkdir resized
+for file in *.jpg; do
+  convert "$file" -resize 1920x1080 "resized/$file"
+done
+```
+
+## Common Use Cases & Presets
+
+**Thumbnail generation (200px):**
+```bash
+convert input.jpg -resize 200x200^ -gravity center -extent 200x200 thumbnail.jpg
+```
+
+**Social media - Instagram (1080x1080):**
+```bash
+convert input.jpg -resize 1080x1080^ -gravity center -extent 1080x1080 instagram.jpg
+```
+
+**Social media - Facebook cover (820x312):**
+```bash
+convert input.jpg -resize 820x312^ -gravity center -extent 820x312 fb_cover.jpg
+```
+
+**4K to HD:**
+```bash
+convert input.jpg -resize 1920x1080 hd_output.jpg
+```
+
+**Mobile optimization (800px max width):**
+```bash
+convert input.jpg -resize 800x\> mobile.jpg
+```
+
+## Python Script for Complex Batch Operations
+
+Offer to create a Python script for advanced needs:
+
+```python
+from PIL import Image
+import os
+
+def resize_images(input_dir, output_dir, max_size=(1920, 1080)):
+    os.makedirs(output_dir, exist_ok=True)
+
+    for filename in os.listdir(input_dir):
+        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
+            img_path = os.path.join(input_dir, filename)
+            img = Image.open(img_path)
+
+            # Resize maintaining aspect ratio
+            img.thumbnail(max_size, Image.Resampling.LANCZOS)
+
+            output_path = os.path.join(output_dir, filename)
+            img.save(output_path, quality=90, optimize=True)
+            print(f"Resized: {filename} -> {img.size}")
+
+resize_images("./input", "./output", (1920, 1080))
+```
+
+## Best Practices
+
+- Always keep original images as backup
+- Use `-quality 90` or higher for minimal quality loss
+- Use `>` suffix to only shrink images, never enlarge
+- Test on a few images before batch processing
+- Consider using `-strip` to remove metadata and reduce file size
+- Use appropriate resampling filters: Lanczos for best quality
+
+## Performance Tips
+
+- Use `mogrify` for in-place batch operations (faster)
+- Process in parallel with GNU parallel:
+  ```bash
+  ls *.jpg | parallel convert {} -resize 1920x1080 resized/{}
+  ```
+- For huge batches, use `-quality 85` to balance size/quality
+
+Help users efficiently resize their image collections with professional quality.

commands-flat/batch-to-100.md

@@ -0,0 +1,5 @@
+This directory and/or subfolders contains levels with more than 100 files.
+
+Create subfolders each of which contains exactly 100 files.
+
+Move the files into them. 

commands-flat/bg-removal.md

@@ -0,0 +1,7 @@
+This folder contains images.
+
+I need the background removed.
+
+Let's use rmbg for this purpose (installed on this machine).
+
+Script the job.

commands-flat/blog-post-to-outline.md

@@ -0,0 +1,318 @@
+# Blog Post to Outline Converter
+
+Distill blog posts, articles, or long-form content into clear, structured outlines that capture the key points, arguments, and organization. Perfect for content planning, studying, creating presentation slides, or understanding structure.
+
+## Your Task
+
+Take the user's blog post and convert it into a well-organized outline that:
+- Captures the main ideas and structure
+- Shows the hierarchy of information
+- Preserves key examples and evidence
+- Maintains logical flow
+- Strips away narrative fluff while keeping substance
+
+## Outline Creation Process
+
+### 1. Identify the Core Structure
+
+Extract:
+- **Main topic/thesis**: What is the central argument or purpose?
+- **Major sections**: What are the main divisions of content?
+- **Key points**: What are the essential claims or ideas?
+- **Supporting elements**: What examples, evidence, or details support each point?
+
+### 2. Create Hierarchical Organization
+
+Use standard outline formatting:
+
+```
+# Main Title / Topic
+
+## I. First Major Section
+   A. Primary point
+      1. Supporting detail
+      2. Supporting detail
+   B. Secondary point
+      1. Supporting detail
+
+## II. Second Major Section
+   A. Primary point
+   B. Secondary point
+      1. Supporting detail
+      2. Supporting detail
+         a. Sub-detail
+         b. Sub-detail
+
+## III. Conclusion / Summary
+   A. Key takeaway
+   B. Call to action
+```
+
+Or use markdown-style:
+
+```
+# Main Title
+
+## Section One
+- Main point
+  - Supporting detail
+  - Example
+- Second point
+  - Detail
+
+## Section Two
+- Main point
+  - Sub-point
+    - Detail
+```
+
+### 3. Distillation Techniques
+
+**From paragraphs to bullets**:
+
+Blog post:
+```
+The first step in optimizing your development workflow is implementing continuous integration. CI automates the process of testing and validating code changes, catching bugs early before they reach production. Modern CI systems like GitHub Actions, CircleCI, and Jenkins can run your entire test suite automatically whenever code is pushed, giving you immediate feedback on whether changes break existing functionality. This rapid feedback loop is crucial for maintaining code quality and team velocity.
+```
+
+Outline:
+```
+## Optimizing Development Workflow
+
+### I. Implement Continuous Integration (CI)
+   A. Automates testing and validation
+   B. Catches bugs before production
+   C. Tools: GitHub Actions, CircleCI, Jenkins
+   D. Benefits
+      1. Immediate feedback on code changes
+      2. Maintains code quality
+      3. Improves team velocity
+```
+
+**Condensing examples**:
+- Keep representative examples
+- Note "e.g., X, Y, Z" for lists
+- Preserve specific data/statistics
+- Summarize case studies briefly
+
+**Extracting arguments**:
+- Identify claims vs. supporting evidence
+- Note cause-effect relationships
+- Capture comparisons and contrasts
+- Preserve key definitions
+
+### 4. Outline Types
+
+Choose the appropriate format based on purpose:
+
+**A. Topic Outline** (uses phrases, no complete sentences)
+```
+## Improving Team Communication
+- Challenges in remote work
+  - Time zone differences
+  - Lack of informal interaction
+- Solutions
+  - Async communication tools
+  - Regular video check-ins
+  - Documentation culture
+```
+
+**B. Sentence Outline** (complete sentences for each point)
+```
+## Improving Team Communication
+- Remote work creates communication challenges
+  - Time zones make synchronous meetings difficult
+  - Teams lose informal "water cooler" conversations
+- Several solutions address these challenges
+  - Async tools allow flexible communication
+  - Regular video calls maintain connection
+  - Strong documentation reduces dependency on meetings
+```
+
+**C. Concept Map Outline** (shows relationships)
+```
+Team Communication
+├── Problems
+│   ├── Remote challenges
+│   └── Tool fragmentation
+├── Solutions
+│   ├── Technology (Slack, Zoom)
+│   └── Processes (documentation)
+└── Results
+    ├── Better alignment
+    └── Higher productivity
+```
+
+**D. Presentation Outline** (formatted for slides)
+```
+Slide 1: Title - "Improving Team Communication"
+
+Slide 2: The Problem
+• Remote work communication challenges
+• Tool overload and fragmentation
+• Lost context and alignment
+
+Slide 3: Solution - Tools
+• Async: Slack, Notion
+• Sync: Zoom, Teams
+• Documentation: Confluence, Wiki
+
+Slide 4: Solution - Processes
+• Daily async stand-ups
+• Weekly team syncs
+• Documentation-first culture
+
+Slide 5: Results
+• 40% reduction in meetings
+• Faster onboarding
+• Better team alignment
+```
+
+## What to Include
+
+### Essential Elements
+
+✓ **Main arguments and claims**
+✓ **Key supporting evidence** (data, examples)
+✓ **Important definitions or concepts**
+✓ **Action items or recommendations**
+✓ **Significant examples or case studies** (summarized)
+✓ **Structural transitions** (how sections connect)
+
+### Elements to Condense or Omit
+
+✗ Narrative fluff and throat-clearing
+✗ Redundant explanations
+✗ Extended anecdotes (keep one-line summary if important)
+✗ Rhetorical flourishes
+✗ Transitional prose
+✗ Repetitive examples
+✗ Purely atmospheric writing
+
+## Special Cases
+
+### Lists and Enumerations
+
+Blog post lists often translate directly:
+
+```
+The three pillars of DevOps are:
+1. Automation
+2. Collaboration
+3. Continuous improvement
+```
+
+Outline:
+```
+### Three Pillars of DevOps
+1. Automation
+2. Collaboration
+3. Continuous improvement
+```
+
+### How-To Content
+
+Preserve step-by-step instructions:
+
+```
+## How to Set Up CI/CD
+1. Choose CI platform (GitHub Actions, CircleCI)
+2. Create configuration file
+   a. Define build steps
+   b. Set up test runners
+   c. Configure deployment
+3. Test the pipeline
+4. Monitor and iterate
+```
+
+### Comparison Content
+
+Use tables or parallel structure:
+
+```
+## Tool Comparison
+### Asana
+- Strengths: Complex projects, dependencies
+- Weaknesses: Learning curve
+- Best for: Large teams
+
+### Trello
+- Strengths: Visual, simple
+- Weaknesses: Limited features
+- Best for: Small teams, visual thinkers
+```
+
+## Outline Depth Guidelines
+
+**High-level outline** (skim/overview):
+- Major sections only
+- 1-2 levels of hierarchy
+- Key points without details
+
+**Medium outline** (standard):
+- Main sections and subsections
+- 2-3 levels of hierarchy
+- Key examples noted
+
+**Detailed outline** (comprehensive):
+- All sections and subsections
+- 3-4 levels of hierarchy
+- Examples, evidence, specific details included
+- Could recreate most of the original content
+
+## Example Transformation
+
+**Blog Post Excerpt**:
+```
+# Why Your Team Needs Better Documentation
+
+Every developer has been there: you join a new project, and the only documentation is a README that says "See John for questions"—but John left the company six months ago. You spend days reverse-engineering the codebase, making assumptions that turn out to be wrong, and bothering your teammates with questions they've answered a hundred times before.
+
+Good documentation isn't just nice to have; it's a force multiplier for your team. It reduces onboarding time from weeks to days, prevents repetitive questions from fragmenting your team's focus, and creates institutional knowledge that survives employee turnover.
+
+The key is making documentation a first-class part of your workflow, not an afterthought. Here's how to build a documentation culture that actually works...
+```
+
+**Outline**:
+```
+# Building a Documentation Culture
+
+## I. The Problem
+   A. Poor documentation is common
+      - Example: "Ask John" (who left months ago)
+   B. Consequences
+      1. Slow onboarding (weeks instead of days)
+      2. Wasted time reverse-engineering
+      3. Repetitive questions interrupt work
+      4. Knowledge loss when people leave
+
+## II. Benefits of Good Documentation
+   A. Team force multiplier
+   B. Faster onboarding
+   C. Reduced interruptions
+   D. Preserved institutional knowledge
+
+## III. Implementation Strategy
+   [To be filled from subsequent content]
+   A. Make documentation first-class
+   B. Integrate into workflow
+   C. ...
+```
+
+## Output Format
+
+Provide:
+1. The structured outline in the requested format (topic/sentence/concept map/presentation)
+2. Appropriate hierarchy and indentation
+3. Key points, examples, and evidence captured
+4. Optional: Brief note on the blog post's main argument/purpose
+
+## Usage Notes
+
+When providing content, optionally specify:
+- **Outline type**: Topic, sentence, concept map, or presentation format
+- **Depth level**: High-level, medium, or detailed
+- **Purpose**: Study notes, presentation prep, content planning, structural analysis
+- **Special focus**: Emphasize certain sections or aspects
+
+Share the blog post content you'd like to convert into an outline.

commands-flat/blog-post-to-tech-doc.md

@@ -0,0 +1,90 @@
+# Blog Post to Technical Documentation Converter
+
+Convert informal, narrative blog posts into structured, professional technical documentation. This command transforms conversational content into precise, reference-quality documentation.
+
+## Your Task
+
+Take the user's blog post content and convert it into technical documentation with these characteristics:
+
+### Structure Transformation
+
+- **Remove narrative elements**: Strip out personal anecdotes, casual introductions, and storytelling
+- **Create clear hierarchy**: Use proper heading levels (H1, H2, H3) for logical organization
+- **Add standardized sections**: Include Overview, Prerequisites, Installation, Configuration, Usage, Examples, Troubleshooting, etc.
+- **Extract actionable content**: Convert prose into step-by-step instructions where applicable
+- **Organize information**: Group related concepts into logical sections
+
+### Style Changes
+
+- **Imperative voice for instructions**: "Run the command" not "You can run the command"
+- **Remove conversational tone**: Eliminate phrases like "Let's dive in," "Pretty cool, right?", "So here's the thing"
+- **Technical precision**: Replace casual explanations with accurate technical terms
+- **Objective language**: Remove opinions and subjective statements unless factual
+- **Concise writing**: Eliminate fluff and redundancy
+- **Consistent terminology**: Use the same terms throughout (no synonyms for key concepts)
+
+### Content Enhancement
+
+- **Add code blocks**: Format any code examples with proper syntax highlighting
+- **Create tables**: Convert lists of options/parameters into structured tables
+- **Include warnings/notes**: Use callouts for important information
+- **Add cross-references**: Link related sections together
+- **Specify prerequisites**: Clearly state requirements upfront
+- **Version information**: Include version numbers and compatibility details if mentioned
+
+### Documentation Elements to Add
+
+1. **Synopsis/Overview**: Brief description of what this documents
+2. **Table of Contents**: If the document is substantial
+3. **Installation/Setup**: Step-by-step setup instructions
+4. **Configuration**: Available options and parameters
+5. **Examples**: Practical usage examples with expected output
+6. **API Reference**: If applicable, document functions/methods
+7. **Troubleshooting**: Common issues and solutions
+8. **Additional Resources**: Links to related documentation
+
+## Example Transformation
+
+**Blog Post Style**:
+```
+Hey everyone! Today I want to share this awesome trick I discovered for speeding up your Docker builds. So basically, you know how Docker builds can be super slow sometimes? Well, I found that if you use multi-stage builds, you can cut down the time significantly. Let me show you how I do it...
+```
+
+**Technical Documentation Style**:
+```
+# Multi-Stage Docker Builds
+
+## Overview
+Multi-stage builds reduce Docker image build time and final image size by separating the build environment from the runtime environment.
+
+## Prerequisites
+- Docker Engine 17.05 or later
+- Basic understanding of Dockerfiles
+
+## Implementation
+
+### Syntax
+Multi-stage builds use multiple `FROM` statements in a single Dockerfile:
+
+```dockerfile
+FROM node:16 AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+
+FROM node:16-alpine
+WORKDIR /app
+COPY --from=builder /app/node_modules ./node_modules
+```
+
+### Benefits
+- Reduced build time through layer caching
+- Smaller final images (runtime-only dependencies)
+- Cleaner separation of build and runtime concerns
+```
+
+## Output Format
+
+Provide the converted technical documentation in clean markdown format, ready for inclusion in a documentation repository or wiki.
+
+Paste the blog post content you'd like to convert to technical documentation.

commands-flat/break-up-long-sentences.md

@@ -0,0 +1,31 @@
+You are a text editor specializing in breaking up long, run-on sentences into shorter, more digestible sentences.
+
+Your task is to identify overly long sentences and split them into multiple shorter sentences that improve readability and comprehension.
+
+## Guidelines
+
+1. **Identify long sentences**: Look for sentences exceeding 25-30 words or containing multiple independent clauses
+2. **Find natural break points**: Split at conjunctions (and, but, or), semicolons, or logical thought boundaries
+3. **Maintain logical flow**: Ensure that split sentences maintain clear connections and transitions
+4. **Use appropriate transitions**: Add transition words (However, Additionally, Therefore, etc.) when needed for coherence
+5. **Preserve meaning**: Keep the original message and all important details intact
+6. **Improve readability**: Aim for an average sentence length of 15-20 words for optimal web readability
+7. **Vary sentence length**: Create some variety - not all sentences should be exactly the same length
+8. **Keep paragraph integrity**: Don't split sentences that would create awkward single-sentence paragraphs
+
+## Target Sentence Lengths
+
+- **Ideal**: 15-20 words per sentence
+- **Maximum**: 25-30 words per sentence
+- **Variety**: Mix shorter (10-15 words) and medium (20-25 words) sentences for rhythm
+
+## Process
+
+1. Identify sentences that are too long (>30 words)
+2. Locate natural splitting points (conjunctions, semicolons, logical breaks)
+3. Split into two or more sentences
+4. Add transitions if needed for clarity
+5. Review for flow and coherence
+6. Present the revised text
+
+Return only the revised text with split sentences, without explanations or commentary unless specifically requested.

commands-flat/btrfs-snapper-health.md

@@ -0,0 +1,41 @@
+# BTRFS and Snapper Snapshot Health Check
+
+You are helping the user check their BTRFS filesystem configuration and Snapper snapshot setup.
+
+## Your tasks:
+
+1. **Check if BTRFS is in use:**
+   - Run `df -T` to identify BTRFS filesystems
+   - Run `sudo btrfs filesystem show` to display all BTRFS filesystems
+   - Run `mount | grep btrfs` to see mounted BTRFS filesystems with their options
+
+2. **Check BTRFS filesystem health:**
+   - For each BTRFS filesystem found, run `sudo btrfs filesystem usage <mountpoint>`
+   - Run `sudo btrfs device stats <mountpoint>` to check for device errors
+   - Run `sudo btrfs scrub status <mountpoint>` to check scrub status
+
+3. **Check Snapper configuration:**
+   - Check if Snapper is installed: `which snapper`
+   - If not installed, ask the user if they want to install it
+   - List Snapper configurations: `sudo snapper list-configs`
+   - For each configuration, show snapshots: `sudo snapper -c <config> list`
+   - Show Snapper configuration details: `sudo snapper -c <config> get-config`
+
+4. **Analyze snapshot usage:**
+   - Check disk space used by snapshots
+   - Identify if there are too many snapshots that should be cleaned up
+   - Check automatic snapshot policies
+
+5. **Report findings:**
+   - Summarize BTRFS health status
+   - Report on snapshot configurations and disk usage
+   - Provide recommendations for:
+     - Snapshot retention policies if too many snapshots exist
+     - Running scrub if it hasn't been run recently
+     - Fixing any errors or issues detected
+     - Setting up Snapper if BTRFS is in use but Snapper is not configured
+
+## Important notes:
+- Use sudo for all BTRFS and Snapper commands
+- Be clear about what you find and what actions you recommend
+- If BTRFS is not in use, inform the user and exit gracefully

commands-flat/business-to-casual.md

@@ -0,0 +1,31 @@
+---
+description: Convert business-appropriate text to casual, conversational style
+tags: [writing, editing, style, tone, conversion]
+---
+
+You are a text style conversion specialist. Convert the provided business-appropriate text to a casual, conversational style while preserving the core message and key information.
+
+**Guidelines:**
+
+1. **Tone**: Transform formal language into friendly, relaxed communication
+2. **Vocabulary**: Replace business jargon and formal terms with everyday language
+3. **Structure**: Use shorter sentences, contractions, and natural flow
+4. **Pronouns**: Switch from third person to first/second person where appropriate
+5. **Formality markers**: Remove or soften overly formal phrases (e.g., "I am writing to inform you" → "Just wanted to let you know")
+6. **Preserve meaning**: Keep all important facts, dates, and commitments intact
+7. **Context-appropriate**: Maintain professionalism where necessary (don't make it too informal for the situation)
+
+**Example transformations:**
+
+- "Please be advised that" → "Just so you know" or "FYI"
+- "We kindly request" → "Could you" or "Would you mind"
+- "At your earliest convenience" → "When you get a chance" or "Whenever works for you"
+- "Pursuant to our previous discussion" → "Like we talked about"
+- "I would like to express my gratitude" → "Thanks!" or "Really appreciate it"
+
+**Output format:**
+- Provide the converted casual text
+- If multiple interpretations are possible, offer the most natural-sounding option
+- Maintain paragraph structure unless combining short paragraphs improves flow
+
+Please convert the following business text to casual style: