bobo-ai-cli 3.0.3 → 3.0.5

package/knowledge/skills/ralph-loop.md

@@ -1,205 +1,205 @@
----
-id: "ralph-loop"
-title: "Ralph Loop Plugin"
-category: "agent-engineering"
-tags: ["ralph loop plugin", "what is ralph loop?", "1. works on the task", "2. tries to exit", "3. stop hook blocks exit", "5. repeat until completion", "quick start", "commands", "prompt writing best practices"]
-triggers: []
-dependencies: []
-source: "E:/Bobo's Coding cache/.claude/skills/ralph-loop"
----
-
-# Ralph Loop Plugin
-
-Implementation of the Ralph Wiggum technique for iterative, self-referential AI development loops in Claude Code.
-
-## What is Ralph Loop?
-
-Ralph Loop is a development methodology based on continuous AI agent loops. As Geoffrey Huntley describes it: **"Ralph is a Bash loop"** - a simple `while true` that repeatedly feeds an AI agent a prompt file, allowing it to iteratively improve its work until completion.
-
-This technique is inspired by the Ralph Wiggum coding technique (named after the character from The Simpsons), embodying the philosophy of persistent iteration despite setbacks.
-
-### Core Concept
-
-This plugin implements Ralph using a **Stop hook** that intercepts Claude's exit attempts:
-
-```bash
-# You run ONCE:
-/ralph-loop "Your task description" --completion-promise "DONE"
-
-# Then Claude Code automatically:
-# 1. Works on the task
-# 2. Tries to exit
-# 3. Stop hook blocks exit
-# 4. Stop hook feeds the SAME prompt back
-# 5. Repeat until completion
-```
-
-The loop happens **inside your current session** - you don't need external bash loops. The Stop hook in `hooks/stop-hook.sh` creates the self-referential feedback loop by blocking normal session exit.
-
-This creates a **self-referential feedback loop** where:
-
-- The prompt never changes between iterations
-- Claude's previous work persists in files
-- Each iteration sees modified files and git history
-- Claude autonomously improves by reading its own past work in files
-
-## Quick Start
-
-```bash
-/ralph-loop "Build a REST API for todos. Requirements: CRUD operations, input validation, tests. Output <promise>COMPLETE</promise> when done." --completion-promise "COMPLETE" --max-iterations 50
-```
-
-Claude will:
-
-- Implement the API iteratively
-- Run tests and see failures
-- Fix bugs based on test output
-- Iterate until all requirements met
-- Output the completion promise when done
-
-## Commands
-
-### /ralph-loop
-
-Start a Ralph loop in your current session.
-
-**Usage:**
-
-```bash
-/ralph-loop "<prompt>" --max-iterations <n> --completion-promise "<text>"
-```
-
-**Options:**
-
-- `--max-iterations <n>` - Stop after N iterations (default: unlimited)
-- `--completion-promise <text>` - Phrase that signals completion
-
-### /cancel-ralph
-
-Cancel the active Ralph loop.
-
-**Usage:**
-
-```bash
-/cancel-ralph
-```
-
-## Prompt Writing Best Practices
-
-### 1. Clear Completion Criteria
-
-❌ Bad: "Build a todo API and make it good."
-
-✅ Good:
-
-```markdown
-Build a REST API for todos.
-
-When complete:
-
-- All CRUD endpoints working
-- Input validation in place
-- Tests passing (coverage > 80%)
-- README with API docs
-- Output: <promise>COMPLETE</promise>
-```
-
-### 2. Incremental Goals
-
-❌ Bad: "Create a complete e-commerce platform."
-
-✅ Good:
-
-```markdown
-Phase 1: User authentication (JWT, tests)
-Phase 2: Product catalog (list/search, tests)
-Phase 3: Shopping cart (add/remove, tests)
-
-Output <promise>COMPLETE</promise> when all phases done.
-```
-
-### 3. Self-Correction
-
-❌ Bad: "Write code for feature X."
-
-✅ Good:
-
-```markdown
-Implement feature X following TDD:
-
-1. Write failing tests
-2. Implement feature
-3. Run tests
-4. If any fail, debug and fix
-5. Refactor if needed
-6. Repeat until all green
-7. Output: <promise>COMPLETE</promise>
-```
-
-### 4. Escape Hatches
-
-Always use `--max-iterations` as a safety net to prevent infinite loops on impossible tasks:
-
-```bash
-# Recommended: Always set a reasonable iteration limit
-/ralph-loop "Try to implement feature X" --max-iterations 20
-
-# In your prompt, include what to do if stuck:
-# "After 15 iterations, if not complete:
-#  - Document what's blocking progress
-#  - List what was attempted
-#  - Suggest alternative approaches"
-```
-
-**Note**: The `--completion-promise` uses exact string matching, so you cannot use it for multiple completion conditions (like "SUCCESS" vs "BLOCKED"). Always rely on `--max-iterations` as your primary safety mechanism.
-
-## Philosophy
-
-Ralph embodies several key principles:
-
-### 1. Iteration > Perfection
-
-Don't aim for perfect on first try. Let the loop refine the work.
-
-### 2. Failures Are Data
-
-"Deterministically bad" means failures are predictable and informative. Use them to tune prompts.
-
-### 3. Operator Skill Matters
-
-Success depends on writing good prompts, not just having a good model.
-
-### 4. Persistence Wins
-
-Keep trying until success. The loop handles retry logic automatically.
-
-## When to Use Ralph
-
-**Good for:**
-
-- Well-defined tasks with clear success criteria
-- Tasks requiring iteration and refinement (e.g., getting tests to pass)
-- Greenfield projects where you can walk away
-- Tasks with automatic verification (tests, linters)
-
-**Not good for:**
-
-- Tasks requiring human judgment or design decisions
-- One-shot operations
-- Tasks with unclear success criteria
-- Production debugging (use targeted debugging instead)
-
-## Real-World Results
-
-- Successfully generated 6 repositories overnight in Y Combinator hackathon testing
-- One $50k contract completed for $297 in API costs
-- Created entire programming language ("cursed") over 3 months using this approach
-
-## Learn More
-
-- Original technique: https://ghuntley.com/ralph/
-- Ralph Orchestrator: https://github.com/mikeyobrien/ralph-orchestrator
-
-## For Help
-
-Run `/help` in Claude Code for detailed command reference and examples.
+---
+id: "ralph-loop"
+title: "Ralph Loop Plugin"
+category: "agent-engineering"
+tags: ["ralph loop plugin", "what is ralph loop?", "1. works on the task", "2. tries to exit", "3. stop hook blocks exit", "5. repeat until completion", "quick start", "commands", "prompt writing best practices"]
+triggers: []
+dependencies: []
+source: "E:/Bobo's Coding cache/.claude/skills/ralph-loop"
+---
+
+# Ralph Loop Plugin
+
+Implementation of the Ralph Wiggum technique for iterative, self-referential AI development loops in Claude Code.
+
+## What is Ralph Loop?
+
+Ralph Loop is a development methodology based on continuous AI agent loops. As Geoffrey Huntley describes it: **"Ralph is a Bash loop"** - a simple `while true` that repeatedly feeds an AI agent a prompt file, allowing it to iteratively improve its work until completion.
+
+This technique is inspired by the Ralph Wiggum coding technique (named after the character from The Simpsons), embodying the philosophy of persistent iteration despite setbacks.
+
+### Core Concept
+
+This plugin implements Ralph using a **Stop hook** that intercepts Claude's exit attempts:
+
+```bash
+# You run ONCE:
+/ralph-loop "Your task description" --completion-promise "DONE"
+
+# Then Claude Code automatically:
+# 1. Works on the task
+# 2. Tries to exit
+# 3. Stop hook blocks exit
+# 4. Stop hook feeds the SAME prompt back
+# 5. Repeat until completion
+```
+
+The loop happens **inside your current session** - you don't need external bash loops. The Stop hook in `hooks/stop-hook.sh` creates the self-referential feedback loop by blocking normal session exit.
+
+This creates a **self-referential feedback loop** where:
+
+- The prompt never changes between iterations
+- Claude's previous work persists in files
+- Each iteration sees modified files and git history
+- Claude autonomously improves by reading its own past work in files
+
+## Quick Start
+
+```bash
+/ralph-loop "Build a REST API for todos. Requirements: CRUD operations, input validation, tests. Output <promise>COMPLETE</promise> when done." --completion-promise "COMPLETE" --max-iterations 50
+```
+
+Claude will:
+
+- Implement the API iteratively
+- Run tests and see failures
+- Fix bugs based on test output
+- Iterate until all requirements met
+- Output the completion promise when done
+
+## Commands
+
+### /ralph-loop
+
+Start a Ralph loop in your current session.
+
+**Usage:**
+
+```bash
+/ralph-loop "<prompt>" --max-iterations <n> --completion-promise "<text>"
+```
+
+**Options:**
+
+- `--max-iterations <n>` - Stop after N iterations (default: unlimited)
+- `--completion-promise <text>` - Phrase that signals completion
+
+### /cancel-ralph
+
+Cancel the active Ralph loop.
+
+**Usage:**
+
+```bash
+/cancel-ralph
+```
+
+## Prompt Writing Best Practices
+
+### 1. Clear Completion Criteria
+
+❌ Bad: "Build a todo API and make it good."
+
+✅ Good:
+
+```markdown
+Build a REST API for todos.
+
+When complete:
+
+- All CRUD endpoints working
+- Input validation in place
+- Tests passing (coverage > 80%)
+- README with API docs
+- Output: <promise>COMPLETE</promise>
+```
+
+### 2. Incremental Goals
+
+❌ Bad: "Create a complete e-commerce platform."
+
+✅ Good:
+
+```markdown
+Phase 1: User authentication (JWT, tests)
+Phase 2: Product catalog (list/search, tests)
+Phase 3: Shopping cart (add/remove, tests)
+
+Output <promise>COMPLETE</promise> when all phases done.
+```
+
+### 3. Self-Correction
+
+❌ Bad: "Write code for feature X."
+
+✅ Good:
+
+```markdown
+Implement feature X following TDD:
+
+1. Write failing tests
+2. Implement feature
+3. Run tests
+4. If any fail, debug and fix
+5. Refactor if needed
+6. Repeat until all green
+7. Output: <promise>COMPLETE</promise>
+```
+
+### 4. Escape Hatches
+
+Always use `--max-iterations` as a safety net to prevent infinite loops on impossible tasks:
+
+```bash
+# Recommended: Always set a reasonable iteration limit
+/ralph-loop "Try to implement feature X" --max-iterations 20
+
+# In your prompt, include what to do if stuck:
+# "After 15 iterations, if not complete:
+#  - Document what's blocking progress
+#  - List what was attempted
+#  - Suggest alternative approaches"
+```
+
+**Note**: The `--completion-promise` uses exact string matching, so you cannot use it for multiple completion conditions (like "SUCCESS" vs "BLOCKED"). Always rely on `--max-iterations` as your primary safety mechanism.
+
+## Philosophy
+
+Ralph embodies several key principles:
+
+### 1. Iteration > Perfection
+
+Don't aim for perfect on first try. Let the loop refine the work.
+
+### 2. Failures Are Data
+
+"Deterministically bad" means failures are predictable and informative. Use them to tune prompts.
+
+### 3. Operator Skill Matters
+
+Success depends on writing good prompts, not just having a good model.
+
+### 4. Persistence Wins
+
+Keep trying until success. The loop handles retry logic automatically.
+
+## When to Use Ralph
+
+**Good for:**
+
+- Well-defined tasks with clear success criteria
+- Tasks requiring iteration and refinement (e.g., getting tests to pass)
+- Greenfield projects where you can walk away
+- Tasks with automatic verification (tests, linters)
+
+**Not good for:**
+
+- Tasks requiring human judgment or design decisions
+- One-shot operations
+- Tasks with unclear success criteria
+- Production debugging (use targeted debugging instead)
+
+## Real-World Results
+
+- Successfully generated 6 repositories overnight in Y Combinator hackathon testing
+- One $50k contract completed for $297 in API costs
+- Created entire programming language ("cursed") over 3 months using this approach
+
+## Learn More
+
+- Original technique: https://ghuntley.com/ralph/
+- Ralph Orchestrator: https://github.com/mikeyobrien/ralph-orchestrator
+
+## For Help
+
+Run `/help` in Claude Code for detailed command reference and examples.

package/knowledge/skills/refactoring-expert.md

@@ -1,103 +1,103 @@
----
-id: "refactoring-expert"
-title: "Refactoring Expert"
-category: "dev-tools"
-tags: ["refactoring expert", "refactoring catalog", "analysis process", "output format", "code smell analysis", "recommended refactorings", "step-by-step plan", "risk assessment"]
-triggers: ["Long methods", "duplicated code", "comments explaining code blocks"]
-dependencies: []
-source: "E:/Bobo's Coding cache/.claude/skills/refactoring-expert"
----
-
----
-name: refactoring-expert
-description: Expert skill for identifying refactoring opportunities and applying clean code transformations
----
-
-# Refactoring Expert
-
-You are an expert in code refactoring with deep knowledge of refactoring patterns, design patterns, and clean code principles.
-
-## Refactoring Catalog
-
-### Extract Method
-
-When to use: Long methods, duplicated code, comments explaining code blocks
-
-```
-Before: Long function with multiple responsibilities
-After: Multiple focused functions with clear names
-```
-
-### Extract Variable
-
-When to use: Complex expressions, magic numbers, repeated calculations
-
-```
-Before: if (user.age >= 18 && user.country === 'US' && user.verified)
-After: const isEligible = user.age >= 18 && user.country === 'US' && user.verified;
-       if (isEligible)
-```
-
-### Replace Conditional with Polymorphism
-
-When to use: Switch statements based on type, repeated type checking
-
-```
-Before: switch(type) { case 'A': ... case 'B': ... }
-After: interface Handler { handle(): void }
-       class AHandler implements Handler { ... }
-```
-
-### Introduce Parameter Object
-
-When to use: Multiple related parameters, data clumps
-
-```
-Before: function createUser(name, email, age, country)
-After: function createUser(userData: UserData)
-```
-
-### Replace Magic Numbers with Constants
-
-When to use: Unexplained numeric literals
-
-```
-Before: if (status === 200)
-After: if (status === HTTP_OK)
-```
-
-## Analysis Process
-
-1. **Identify Code Smells**
-   - Long methods (> 20 lines)
-   - Large classes
-   - Duplicate code
-   - Long parameter lists
-   - Feature envy
-   - Data clumps
-
-2. **Assess Impact**
-   - Risk level of change
-   - Test coverage
-   - Dependencies affected
-
-3. **Plan Refactoring**
-   - Small, incremental steps
-   - Maintain behavior
-   - Run tests after each step
-
-## Output Format
-
-```
-## Code Smell Analysis
-[Identified issues and their locations]
-
-## Recommended Refactorings
-[Prioritized list of refactoring operations]
-
-## Step-by-Step Plan
-[Detailed refactoring steps with code examples]
-
-## Risk Assessment
-[Potential risks and mitigation strategies]
-```
+---
+id: "refactoring-expert"
+title: "Refactoring Expert"
+category: "dev-tools"
+tags: ["refactoring expert", "refactoring catalog", "analysis process", "output format", "code smell analysis", "recommended refactorings", "step-by-step plan", "risk assessment"]
+triggers: ["Long methods", "duplicated code", "comments explaining code blocks"]
+dependencies: []
+source: "E:/Bobo's Coding cache/.claude/skills/refactoring-expert"
+---
+
+---
+name: refactoring-expert
+description: Expert skill for identifying refactoring opportunities and applying clean code transformations
+---
+
+# Refactoring Expert
+
+You are an expert in code refactoring with deep knowledge of refactoring patterns, design patterns, and clean code principles.
+
+## Refactoring Catalog
+
+### Extract Method
+
+When to use: Long methods, duplicated code, comments explaining code blocks
+
+```
+Before: Long function with multiple responsibilities
+After: Multiple focused functions with clear names
+```
+
+### Extract Variable
+
+When to use: Complex expressions, magic numbers, repeated calculations
+
+```
+Before: if (user.age >= 18 && user.country === 'US' && user.verified)
+After: const isEligible = user.age >= 18 && user.country === 'US' && user.verified;
+       if (isEligible)
+```
+
+### Replace Conditional with Polymorphism
+
+When to use: Switch statements based on type, repeated type checking
+
+```
+Before: switch(type) { case 'A': ... case 'B': ... }
+After: interface Handler { handle(): void }
+       class AHandler implements Handler { ... }
+```
+
+### Introduce Parameter Object
+
+When to use: Multiple related parameters, data clumps
+
+```
+Before: function createUser(name, email, age, country)
+After: function createUser(userData: UserData)
+```
+
+### Replace Magic Numbers with Constants
+
+When to use: Unexplained numeric literals
+
+```
+Before: if (status === 200)
+After: if (status === HTTP_OK)
+```
+
+## Analysis Process
+
+1. **Identify Code Smells**
+   - Long methods (> 20 lines)
+   - Large classes
+   - Duplicate code
+   - Long parameter lists
+   - Feature envy
+   - Data clumps
+
+2. **Assess Impact**
+   - Risk level of change
+   - Test coverage
+   - Dependencies affected
+
+3. **Plan Refactoring**
+   - Small, incremental steps
+   - Maintain behavior
+   - Run tests after each step
+
+## Output Format
+
+```
+## Code Smell Analysis
+[Identified issues and their locations]
+
+## Recommended Refactorings
+[Prioritized list of refactoring operations]
+
+## Step-by-Step Plan
+[Detailed refactoring steps with code examples]
+
+## Risk Assessment
+[Potential risks and mitigation strategies]
+```