# [YOUR TRACEBACK HERE]

**`~/prompts/explain-concept.txt`**:

```text
Explain the following concept as if you are teaching a junior developer. Keep the explanation concise, use analogies if helpful, and provide a small, runnable code example if applicable.

Concept: [YOUR CONCEPT HERE]

~/prompts/
├── coding/
│   ├── python/
│   │   ├── debug-error.txt
│   │   ├── refactor-function.txt
│   │   └── explain-decorator.txt
│   ├── javascript/
│   │   └── create-react-component.txt
│   └── general/
│       └── generate-boilerplate.txt
├── writing/
│   ├── blog-post-outline.txt
│   ├── commit-message.txt
│   └── summarise-document.txt
├── devops/
│   └── dockerfile-generator.txt
└── general/
    └── brainstorm-ideas.txt

Select a prompt:
> coding/python/debug-error
  coding/python/refactor-function
  coding/javascript/create-react-component
  writing/commit-message
  devops/dockerfile-generator
  general/brainstorm-ideas
(Press Tab to multi-select, Enter to select, Ctrl+R to toggle fuzzy match)

Now, the Python script.
**`~/bin/prompt-mgr.py`**:

```python
#!/usr/bin/env python3

import argparse
import os
import sys
import yaml # pip install pyyaml

def get_clipboard_command():
    if sys.platform == "darwin":
        return "pbcopy"
    elif sys.platform == "linux":
        # Check if xclip is installed and available
        if os.system("command -v xclip > /dev/null") == 0:
            return "xclip -selection clipboard"
        else:
            return None
    elif sys.platform == "win32": # For Windows (e.g., Git Bash, WSL)
        return "clip.exe"
    return None

def main():
    parser = argparse.ArgumentParser(
        description="A CLI tool to manage and retrieve AI prompts from your library.",
        formatter_class=argparse.RawTextHelpFormatter
    )
    parser.add_argument(
        "prompt_name",
        nargs="?",
        help="The name/path of the prompt (e.g., coding/python/generate-test).\n"
             "Use '--fzf' to select interactively."
    )
    parser.add_argument(
        "--fzf",
        action="store_true",
        help="Use fzf for interactive prompt selection."
    )
    parser.add_argument(
        "--list",
        action="store_true",
        help="List all available prompts."
    )
    # Add an argument for each variable that might be templated
    parser.add_argument(
        "-v", "--var",
        action="append",
        nargs=2,
        metavar=("KEY", "VALUE"),
        help="Provide values for templated variables (e.g., -v function_code 'def foo(): pass')"
    )
    args = parser.parse_args()

    PROMPT_DIR = os.path.join(os.path.expanduser("~"), "prompts")

    if not os.path.exists(PROMPT_DIR):
        print(f"Error: Prompt directory '{PROMPT_DIR}' not found.", file=sys.stderr)
        sys.exit(1)

    clipboard_cmd = get_clipboard_command()
    if not clipboard_cmd:
        print("Error: No suitable clipboard utility found (pbcopy, xclip, or clip.exe).", file=sys.stderr)
        sys.exit(1)

    # Collect all available prompts
    all_prompts = {}
    for root, _, files in os.walk(PROMPT_DIR):
        for file in files:
            if file.endswith((".txt", ".yaml")):
                full_path = os.path.join(root, file)
                relative_path = os.path.relpath(full_path, PROMPT_DIR)
                # Remove extension for display/lookup
                prompt_key = os.path.splitext(relative_path)[0]
                all_prompts[prompt_key] = full_path

    if args.list:
        if not all_prompts:
            print("No prompts found in your library.")
        else:
            print("Available prompts:")
            for key in sorted(all_prompts.keys()):
                print(f"  - {key}")
        sys.exit(0)

    selected_prompt_key = None
    if args.fzf:
        if not os.system("command -v fzf > /dev/null") == 0:
            print("Error: fzf is not installed. Please install it to use this feature.", file=sys.stderr)
            sys.exit(1)
        
        prompt_list = sorted(all_prompts.keys())
        if not prompt_list:
            print("No prompts found to select.", file=sys.stderr)
            sys.exit(1)

        fzf_input = "\n".join(prompt_list)
        fzf_command = f'echo "{fzf_input}" | fzf --prompt="Select a prompt: " --no-sort --border --margin=1 --padding=1 --header="Use Ctrl+R to toggle fuzzy match, ESC to exit"'
        
        try:
            # Use os.popen to run fzf and capture its output
            with os.popen(fzf_command) as fzf_proc:
                selected_prompt_key = fzf_proc.read().strip()
        except Exception as e:
            print(f"Error running fzf: {e}", file=sys.stderr)
            sys.exit(1)
        
        if not selected_prompt_key:
            print("No prompt selected.", file=sys.stderr)
            sys.exit(0)
    elif args.prompt_name:
        selected_prompt_key = args.prompt_name
    else:
        parser.print_help()
        sys.exit(1)

    if selected_prompt_key not in all_prompts:
        print(f"Error: Prompt '{selected_prompt_key}' not found in your library.", file=sys.stderr)
        sys.exit(1)

    file_path = all_prompts[selected_prompt_key]
    
    prompt_content = ""
    if file_path.endswith(".yaml"):
        with open(file_path, 'r') as f:
            data = yaml.safe_load(f)
            prompt_content = data.get('prompt', '')
            variables_info = data.get('variables', {})
    else: # .txt file
        with open(file_path, 'r') as f:
            prompt_content = f.read()
            variables_info = {} # No explicit variables for plain text

    # Handle templating
    template_vars = {}
    if args.var:
        for key, value in args.var:
            template_vars[key] = value

    # Warn about missing variables for YAML prompts
    if file_path.endswith(".yaml"):
        missing_vars = [k for k in variables_info if k not in template_vars]
        if missing_vars:
            print(f"Warning: Missing values for variables: {', '.join(missing_vars)}", file=sys.stderr)
            print("Please provide them using -v KEY VALUE.", file=sys.stderr)
            # You might choose to exit here, or proceed with empty/default values
            # For this example, we'll proceed, allowing f-string to use literal '{var_name}'
            # if not provided. Or use a safer templating lib.

    try:
        # Use f-string formatting. Be careful with potential KeyError if variable not provided.
        # A more robust solution might use string.Template or Jinja2.
        final_prompt = prompt_content.format(**template_vars)
    except KeyError as e:
        print(f"Error: Prompt expects variable '{e}' which was not provided.", file=sys.stderr)
        print("Please provide it using -v KEY VALUE.", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"Error during prompt templating: {e}", file=sys.stderr)
        sys.exit(1)

    # Copy to clipboard
    try:
        os.system(f'echo "{final_prompt.replace("\"", "\\\"")}" | {clipboard_cmd}')
        print(f"Copied '{selected_prompt_key}' to clipboard. Content length: {len(final_prompt)} characters.")
    except Exception as e:
        print(f"Failed to copy to clipboard: {e}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

You can also use the `--fzf` flag with `prompt-mgr.py` for interactive selection, just like with `prompt-get`.

## Designing Effective Prompts for Your Library

The power of your library lies not just in its organization, but in the quality of the prompts it contains. Here are principles for crafting effective prompts:

*   **Specify Persona**: "You are an expert Python developer..."
*   **Define Task Clearly**: "Your task is to generate a pytest test suite..."
*   **Provide Context**: Explain the situation, the goal, and any constraints.
*   **Specify Format**: "Respond in Markdown...", "Provide output as a JSON array..."
*   **Use Examples (Few-shot)**: Sometimes, showing the AI a couple of examples of desired input/output pairs works wonders.
*   **Break Down Complex Tasks**: For multi-step tasks, guide the AI through each step.
*   **Iterate and Refine**: Prompts are rarely perfect on the first try. Experiment, observe results, and refine. Update your library with the improved versions!
*   **Use Placeholders**: Clearly mark where dynamic content should go (e.g., `[YOUR CODE HERE]`, `{variable_name}`).

## Maintenance and Evolution

A prompt library isn't a "set it and forget it" system.
*   **Regular Review**: Periodically go through your prompts. Are they still relevant? Can they be improved?
*   **Add New Prompts**: Whenever you craft a particularly effective prompt during your daily work, add it to your library.
*   **Delete Obsolete Prompts**: Don't let cruft build up. If a prompt is no longer useful, remove it.
*   **Share (Thoughtfully)**: If you work in a team, consider a shared prompt library for common tasks. This ensures consistency and leverages collective intelligence. Just be mindful of sensitive information.

## Conclusion

Building a prompt library is a low-effort, high-reward investment in your daily productivity. By simply organizing plain text files, leveraging basic CLI tools like `cat` and `xclip`/`pbcopy`, and adding a sprinkle of scripting with Bash or Python, you can transform your AI interactions from a chore into a seamless, efficient process. Start small, iterate, and watch your productivity soar. Happy prompting!