bobo-ai-cli 1.0.1

package/knowledge/skills/pyright-lsp.md

@@ -0,0 +1,43 @@
+---
+id: "pyright-lsp"
+title: "pyright-lsp"
+category: "other"
+tags: ["pyright-lsp", "supported extensions", "installation", "more information"]
+triggers: []
+dependencies: []
+source: "E:/Bobo's Coding cache/.claude/skills/pyright-lsp"
+---
+
+# pyright-lsp
+
+Python language server (Pyright) for Claude Code, providing static type checking and code intelligence.
+
+## Supported Extensions
+
+`.py`, `.pyi`
+
+## Installation
+
+Install Pyright globally via npm:
+
+```bash
+npm install -g pyright
+```
+
+Or with pip:
+
+```bash
+pip install pyright
+```
+
+Or with pipx (recommended for CLI tools):
+
+```bash
+pipx install pyright
+```
+
+## More Information
+
+- [Pyright on npm](https://www.npmjs.com/package/pyright)
+- [Pyright on PyPI](https://pypi.org/project/pyright/)
+- [GitHub Repository](https://github.com/microsoft/pyright)

package/knowledge/skills/quality-assurance-framework.md

@@ -0,0 +1,168 @@
+---
+id: "quality-assurance-framework"
+title: "Quality Assurance Framework"
+category: "agent-engineering"
+tags: ["quality assurance framework", "pre-commit qa", "combined qa workflow", "quick reference"]
+triggers: []
+dependencies: []
+source: "E:/Bobo's Coding cache/.claude/skills/quality-assurance-framework"
+---
+
+---
+name: quality-assurance-framework
+description: Unified QA - combines adversarial-verification (find vulnerabilities via attack) + self-rationalization-guard (prevent self-deception). Use before commits, after code changes, or when reviewing critical logic.
+---
+
+# Quality Assurance Framework
+
+> **Merged from**: adversarial-verification + self-rationalization-guard
+> **Core principle**: Attack first, defend assumptions, verify ruthlessly
+
+## Module 1: Adversarial Verification
+
+### Attack Modes
+
+**Mode A: Input Attack** — What inputs break this?
+```
+- Empty input? null? undefined?
+- Extremely large input? (1M chars)
+- Special characters? (<script>, SQL injection, path traversal)
+- Unicode edge cases? (RTL, zero-width, emoji)
+- Concurrent requests?
+```
+
+**Mode B: State Attack** — What states break this?
+```
+- Race conditions between operations
+- State transitions out of order
+- Partial failures (network timeout mid-write)
+- Resource exhaustion (disk full, memory OOM)
+- Permission escalation paths
+```
+
+**Mode C: Logic Attack** — What assumptions are wrong?
+```
+- "This API always returns data" → What if it returns null?
+- "This file always exists" → What if deleted mid-operation?
+- "This operation is atomic" → What if interrupted?
+- "This order is guaranteed" → What if reordered?
+```
+
+### Verification Checklist
+
+```markdown
+## Pre-Commit QA
+
+### Input Validation
+- [ ] All user inputs validated at system boundary
+- [ ] SQL uses parameterized queries (no string concat)
+- [ ] HTML output sanitized (no raw user content)
+- [ ] File paths validated (no path traversal)
+- [ ] Rate limiting on all public endpoints
+
+### Error Handling
+- [ ] All async operations have try/catch
+- [ ] Errors are thrown, not silently swallowed
+- [ ] Error messages don't leak sensitive data
+- [ ] Failed operations clean up resources
+
+### State Safety
+- [ ] No race conditions in shared state
+- [ ] Atomic operations where needed
+- [ ] Proper locking for concurrent access
+- [ ] Rollback on partial failures
+
+### Security
+- [ ] No hardcoded secrets
+- [ ] Authentication verified on protected routes
+- [ ] Authorization checked at each level
+- [ ] CSRF protection enabled
+```
+
+---
+
+## Module 2: Self-Rationalization Guard
+
+### Red Flags (Self-Deception Patterns)
+
+| Pattern | What You Tell Yourself | Reality |
+|---------|----------------------|---------|
+| **Hand-waving** | "This edge case won't happen" | It will, in production |
+| **Scope creep** | "While I'm here, let me also..." | Unrelated changes introduce bugs |
+| **Assumption skip** | "The caller will validate this" | They won't |
+| **Optimism bias** | "This should work" | Prove it with a test |
+| **Sunk cost** | "I've already spent time on this approach" | Switch if a better one exists |
+| **Complexity justify** | "It needs to be this complex" | Simpler exists, find it |
+
+### Anti-Deception Protocol
+
+Before marking any task complete:
+
+```
+1. Red Team your own code
+   → "If I wanted to break this, how would I?"
+   → Find at least ONE potential issue
+
+2. Challenge your assumptions
+   → List every assumption you made
+   → Verify each one is actually true
+
+3. Ask "What would make this fail?"
+   → Not "Does this work?"
+   → But "Under what conditions does this break?"
+
+4. Simplicity check
+   → Could this be done with fewer abstractions?
+   → Is every line earning its existence?
+
+5. Test the negative path
+   → Don't just test the happy path
+   → Test every error/failure scenario
+```
+
+---
+
+## Combined QA Workflow
+
+### Before Every Commit
+
+```
+1. Adversarial scan (Module 1)
+   ├─ Input attack: 2 min
+   ├─ State attack: 2 min
+   └─ Logic attack: 2 min
+
+2. Self-deception check (Module 2)
+   ├─ Red flag scan: 1 min
+   ├─ Assumption challenge: 1 min
+   └─ Simplicity check: 1 min
+
+3. Automated verification
+   ├─ Run tests: npm test
+   ├─ Type check: tsc --noEmit
+   └─ Lint: eslint .
+
+Total: ~10 minutes per commit
+```
+
+### Before Every PR
+
+```
+1. Full adversarial verification (Module 1)
+2. Self-deception deep dive (Module 2)
+3. Security scan (OWASP top 10)
+4. Performance check (no regressions)
+5. Accessibility check (if UI changes)
+```
+
+---
+
+## Quick Reference
+
+```markdown
+# 3-Question QA (use for every change)
+
+1. "How would I break this?" → Fix the break point
+2. "What assumption am I making?" → Verify the assumption
+3. "Could this be simpler?" → Simplify if yes
+```

package/knowledge/skills/question-refiner.md

@@ -0,0 +1,160 @@
+---
+id: "question-refiner"
+title: "Question Refiner"
+category: "research"
+tags: ["question refiner", "role", "core directives", "interaction flow", "examples", "critical success factors", "remember"]
+triggers: []
+dependencies: []
+source: "E:/Bobo's Coding cache/.claude/skills/question-refiner"
+---
+
+---
+name: question-refiner
+description: 将原始研究问题细化为结构化的深度研究任务。通过提问澄清需求，生成符合 OpenAI/Google Deep Research 标准的结构化提示词。当用户提出研究问题、需要帮助定义研究范围、或想要生成结构化研究提示词时使用此技能。
+---
+
+# Question Refiner
+
+## Role
+
+You are a **Deep Research Question Refiner** specializing in crafting, refining, and optimizing prompts for deep research. Your primary objectives are:
+
+1. **Ask clarifying questions first** to ensure full understanding of the user's needs, scope, and context
+2. **Generate structured research prompts** that follow best practices for deep research
+3. **Eliminate the need for external tools** (like ChatGPT) - everything is done within Claude Code
+
+## Core Directives
+
+- **Do Not Answer the Research Query Directly**: Focus on prompt crafting, not solving the research request
+- **Be Explicit & Skeptical**: If the user's instructions are vague or contradictory, request more detail
+- **Enforce Structure**: Encourage the user to use headings, bullet points, or other organizational methods
+- **Demand Constraints & Context**: Identify relevant timeframes, geographical scope, data sources, and desired output formats
+- **Invite Clarification**: Prompt the user to clarify ambiguous instructions or incomplete details
+
+## Interaction Flow
+
+### Step 1: Initial Response - Ask Clarifying Questions
+
+When a user provides a raw research question, ask ALL of these relevant questions:
+
+#### 1. Core Research Question
+
+- What is the main topic or question you want to investigate?
+- What specific aspects or angles are most important?
+- What problem are you trying to solve with this research?
+
+#### 2. Output Requirements
+
+- What format do you prefer? (comprehensive report, executive summary, presentation slides, data analysis)
+- How long should the output be? (3-5 pages, 20-30 pages, brief overview, detailed analysis)
+- Do you need visualizations? (charts, graphs, diagrams, comparison tables)
+- File structure preference? (single document vs. folder with multiple files)
+
+#### 3. Scope & Boundaries
+
+- Geographic focus? (global, US, Europe, specific countries/regions)
+- Time period? (current state, last 3 years, historical trends, future projections to 2028)
+- Industry or domain constraints?
+- What should be explicitly EXCLUDED from the research?
+
+#### 4. Sources & Credibility
+
+- Preferred source types? (academic papers, industry reports, news articles, government documents)
+- Any sources to prioritize or avoid?
+- Required credibility level? (peer-reviewed only, industry reports OK, general web sources)
+
+#### 5. Special Requirements
+
+- Specific data or statistics needed?
+- Comparison frameworks to use?
+- Regulatory or compliance considerations?
+- Target audience? (technical team, business executives, general public, policymakers)
+
+### Step 2: Wait for User Response
+
+**CRITICAL**: Do NOT generate the structured prompt until the user answers your clarifying questions. If they provide incomplete answers, ask follow-up questions.
+
+### Step 3: Generate Structured Prompt
+
+Once you have sufficient clarity, generate a structured research prompt using this format:
+
+```markdown
+### TASK
+
+[Clear, concise statement of what needs to be researched]
+
+### CONTEXT/BACKGROUND
+
+[Why this research matters, who will use it, what decisions it will inform]
+
+### SPECIFIC QUESTIONS OR SUBTASKS
+
+1. [First specific question]
+2. [Second specific question]
+3. [Third specific question]
+   ...
+
+### KEYWORDS
+
+[keyword1, keyword2, keyword3, ...]
+
+### CONSTRAINTS
+
+- Timeframe: [specific date range]
+- Geography: [specific regions]
+- Source Types: [academic, industry, news, etc.]
+- Length: [expected word count]
+- Language: [if not English]
+
+### OUTPUT FORMAT
+
+- [Format 1: e.g., Executive Summary (1-2 pages)]
+- [Format 2: e.g., Full Report (20-30 pages)]
+- [Format 3: e.g., Data tables and visualizations]
+- Citation style: [APA, MLA, Chicago, inline with URLs]
+- Include: [checklists, roadmaps, blueprints if applicable]
+
+### FINAL INSTRUCTIONS
+
+Remain concise, reference sources accurately, and ask for clarification if any part of this prompt is unclear. Ensure every factual claim includes:
+
+1. Author/Organization name
+2. Publication date
+3. Source title
+4. Direct URL/DOI
+5. Page numbers (if applicable)
+```
+
+## Structured Prompt Quality Checklist
+
+Before delivering the structured prompt, verify:
+
+- [ ] TASK is clear and specific (not vague like "research AI")
+- [ ] CONTEXT explains why this research matters
+- [ ] SPECIFIC QUESTIONS break down the topic into 3-7 concrete sub-questions
+- [ ] KEYWORDS cover the main concepts and synonyms
+- [ ] CONSTRAINTS specify timeframe, geography, and source types
+- [ ] OUTPUT FORMAT is detailed with specific lengths and components
+- [ ] FINAL INSTRUCTIONS emphasize citation requirements
+
+## Examples
+
+See [examples.md](examples.md) for detailed usage examples.
+
+## Critical Success Factors
+
+1. **Patience**: Never rush to generate the prompt. Better to ask one more question than deliver a vague prompt.
+2. **Specificity**: Every field in the structured prompt should be filled with concrete, actionable details.
+3. **User-Centric**: The prompt should reflect what the USER wants, not what YOU think they should want.
+4. **Quality Over Speed**: A well-refined prompt saves hours of research time later.
+
+## Remember
+
+You are replacing ChatGPT's o3/o3-pro models for this task. The structured prompts you generate should be just as good or better than what ChatGPT would produce. This means:
+
+- Ask MORE clarifying questions, not fewer
+- Be MORE specific about constraints and output formats
+- Provide BETTER structure and organization
+- Ensure EVERY field is filled out completely
+
+Your goal: The user should never feel the need to use ChatGPT for question refinement again.

package/knowledge/skills/ralph-loop.md

@@ -0,0 +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.

package/knowledge/skills/refactoring-expert.md

@@ -0,0 +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]
+```