@stephen-lord/docs 1.0.0

package/dist/claude-code-settings/commands/gh/review-pr.md

@@ -0,0 +1,57 @@
+---
+description: Review GitHub pull request with detailed code analysis
+argument-hint: [pr-number]
+allowed-tools: Write, Read, LS, Glob, Grep, Bash(gh:*), Bash(git:*)
+---
+
+# Review PR
+
+You are an expert code reviewer. Follow these steps to review github PR $ARGUMENTS:
+
+1. If no PR number is provided in the args, use Bash(`gh pr list`) to show open PRs
+2. If a PR number is provided, use Bash(`gh pr view $ARGUMENTS`) to get PR details
+3. Use Bash(`gh pr diff $ARGUMENTS`) to get the diff
+4. Analyze the changes and provide a thorough code review that includes:
+    - Overview of what the PR does
+    - Analysis of code quality and style
+    - Specific suggestions for improvements
+    - Any potential issues or risks
+5. Providing code review comments with suggestions and required changes only:
+    - DONOT comment what the PR does or summarize PR contents
+    - ONLY focus on suggestions, code changes and potential issues and risks
+    - USE Bash(`gh api repos/OWNER/REPO/pulls/PR_NUMBER/comments`) to post your review comments
+
+Keep your review concise but thorough. Focus on:
+
+- Code correctness
+- Following project conventions
+- Performance implications
+- Test coverage
+- Security considerations
+
+Format your review with clear sections and bullet points.
+
+## gh command reference
+
+```sh
+# list PR
+gh pr list
+
+# view PR description
+gh pr view 78
+
+# view PR code changes
+gh pr diff 78
+
+# review comments should be posted to the changed file
+gh api repos/OWNER/REPO/pulls/PR_NUMBER/comments \
+    --method POST \
+    --field body="[your-comment]" \
+    --field commit_id="[commitID]" \
+    --field path="path/to/file" \
+    --field line=lineNumber \
+    --field side="RIGHT"
+
+# sample command to fetch commitID
+gh api repos/OWNER/REPO/pulls/PR_NUMBER --jq '.head.sha'
+```

package/dist/claude-code-settings/commands/reflection-harder.md

@@ -0,0 +1,177 @@
+---
+description: Comprehensive session analysis and learning capture
+argument-hint: none
+allowed-tools: Read, Write, TodoWrite, Bash(git:*)
+---
+
+You are an expert in analyzing development sessions and optimizing AI-human collaboration. Your task is to reflect on today's work session and extract learnings that will improve future interactions.
+
+## Session Analysis Phase
+
+  Review the entire conversation history and identify:
+
+### 1. Problems & Solutions
+
+- **What problems did we encounter?**
+  - Initial symptoms reported by user
+  - Root causes discovered
+  - Solutions implemented
+  - Key insights learned
+
+### 2. Code Patterns & Architecture
+
+- **What patterns emerged?**
+  - Design decisions made
+  - Architecture choices
+  - Code relationships discovered
+  - Integration points identified
+
+### 3. User Preferences & Workflow
+
+- **How does the user prefer to work?**
+  - Communication style
+  - Decision-making patterns
+  - Quality standards
+  - Workflow preferences
+  - Direct quotes that reveal preferences
+
+### 4. System Understanding
+
+- **What did we learn about the system?**
+  - Component interactions
+  - Critical paths and dependencies
+  - Failure modes and recovery
+  - Performance considerations
+
+### 5. Knowledge Gaps & Improvements
+
+- **Where can we improve?**
+  - Misunderstandings that occurred
+  - Information that was missing
+  - Better approaches discovered
+  - Future considerations
+
+## Reflection Output Phase
+
+  Structure your reflection in this format:
+
+  <session_overview>
+
+- Date: [Today's date]
+- Primary objectives: [What we set out to do]
+- Outcome: [What was accomplished]
+- Time invested: [Approximate duration]
+  </session_overview>
+
+  <problems_solved>
+  [For each major problem:]
+  Problem: [Name]
+
+- User Experience: [What the user saw/experienced]
+- Technical Cause: [Why it happened]
+- Solution Applied: [What we did]
+- Key Learning: [Important insight for future]
+- Related Files: [Key files involved]
+  </problems_solved>
+
+  <patterns_established>
+  [For each pattern:]
+
+- Pattern: [Name and description]
+- Example: [Specific code/command]
+- When to Apply: [Circumstances]
+- Why It Matters: [Impact on system]
+  </patterns_established>
+
+  <user_preferences>
+  [For each preference discovered:]
+
+- Preference: [What user prefers]
+- Evidence: "[Direct quote from user]"
+- How to Apply: [Specific implementation]
+- Priority: [High/Medium/Low]
+  </user_preferences>
+
+  <system_relationships>
+  [For each relationship:]
+
+- Component A → Component B: [Interaction description]
+- Trigger: [What causes interaction]
+- Effect: [What happens]
+- Monitoring: [How to observe it]
+  </system_relationships>
+
+  <knowledge_updates>
+
+## Updates for CLAUDE.md
+
+  [Key points that should be added to project memory:]
+
+- [Point 1]
+- [Point 2]
+
+## Code Comments Needed
+
+  [Where comments would help future understanding:]
+
+- File: [Path] - Explain: [What needs clarification]
+
+## Documentation Improvements
+
+  [What should be added to README or docs:]
+
+- Topic: [What to document]
+- Location: [Where to add it]
+  </knowledge_updates>
+
+  <commands_and_tools>
+
+## Useful Commands Discovered
+
+- `[command]`: [What it does and when to use it]
+
+## Key File Locations
+
+- [Path]: [What it contains and why it matters]
+
+## Debugging Workflows
+
+- When [X] happens: [Step-by-step approach]
+  </commands_and_tools>
+
+  <future_improvements>
+
+## For Next Session
+
+- Remember to: [Important points]
+- Watch out for: [Potential issues]
+- Consider: [Alternative approaches]
+
+## Suggested Enhancements
+
+- Tool/Command: [What could be improved]
+- Workflow: [How to optimize]
+- Documentation: [What's missing]
+  </future_improvements>
+
+  <collaboration_insights>
+
+## Working Better Together
+
+- Communication: [What worked well]
+- Efficiency: [How to save time]
+- Understanding: [How to clarify requirements]
+- Trust: [Where autonomy is appropriate]
+  </collaboration_insights>
+
+## Action Items
+
+  [What should be done after this reflection:]
+
+  1. Update CLAUDE.md with: [Specific sections]
+  2. Add comments to: [Specific files]
+  3. Create documentation for: [Specific topics]
+  4. Test: [What needs verification]
+
+  Remember: The goal is to build cumulative knowledge that makes each session more effective than the last. Focus on patterns, preferences, and system understanding that will
+  apply to future work.

package/dist/claude-code-settings/commands/reflection.md

@@ -0,0 +1,65 @@
+---
+description: Analyze and improve Claude Code instructions
+argument-hint: none
+allowed-tools: Read, Edit, TodoWrite, Bash(git:*)
+---
+
+You are an expert in prompt engineering, specializing in optimizing AI code assistant instructions. Your task is to analyze and improve the instructions for Claude Code found in CLAUDE.md. Follow these steps carefully:
+
+1. Analysis Phase:
+   Review the chat history in your context window.
+
+Then, examine the current Claude instructions by reading the CLAUDE.md file in the repository root.
+
+Analyze the chat history and instructions to identify areas that could be improved. Look for:
+
+- Inconsistencies in Claude's responses
+- Misunderstandings of user requests
+- Areas where Claude could provide more detailed or accurate information
+- Opportunities to enhance Claude's ability to handle specific types of queries or tasks
+
+2. Analysis Documentation:
+   Document your findings using the TodoWrite tool to track each identified improvement area and create a structured approach.
+
+3. Interaction Phase:
+   Present your findings and improvement ideas to the human. For each suggestion:
+   a) Explain the current issue you've identified
+   b) Propose a specific change or addition to the instructions
+   c) Describe how this change would improve Claude's performance
+
+Wait for feedback from the human on each suggestion before proceeding. If the human approves a change, move it to the implementation phase. If not, refine your suggestion or move on to the next idea.
+
+4. Implementation Phase:
+   For each approved change:
+   a) Use the Edit tool to modify the CLAUDE.md file
+   b) Clearly state the section of the instructions you're modifying
+   c) Present the new or modified text for that section
+   d) Explain how this change addresses the issue identified in the analysis phase
+
+5. Output Format:
+   Present your final output in the following structure:
+
+<analysis>
+[List the issues identified and potential improvements]
+</analysis>
+
+<improvements>
+[For each approved improvement:
+1. Section being modified
+2. New or modified instruction text
+3. Explanation of how this addresses the identified issue]
+</improvements>
+
+<final_instructions>
+[Present the complete, updated set of instructions for Claude, incorporating all approved changes]
+</final_instructions>
+
+## Best Practices
+
+- Use TodoWrite to track analysis progress and implementation tasks
+- Read the current CLAUDE.md file thoroughly before making suggestions
+- Test any proposed changes by considering edge cases and common scenarios
+- Ensure all modifications maintain consistency with existing command patterns
+- Commit changes using git after successful implementation
+
+Remember, your goal is to enhance Claude's performance and consistency while maintaining the core functionality and purpose of the AI assistant. Be thorough in your analysis, clear in your explanations, and precise in your implementations.

package/dist/claude-code-settings/commands/think-harder.md

@@ -0,0 +1,54 @@
+---
+description: Enhanced analytical thinking for complex problems
+argument-hint: [problem or question]
+---
+
+# Think Harder Command
+
+Engage in intensive analytical thinking to think harder about: **$ARGUMENTS**
+
+## Deep Analysis Protocol
+
+Apply systematic reasoning with the following methodology:
+
+### 1. Problem Clarification
+
+- Define the core question and identify implicit assumptions
+- Establish scope, constraints, and success criteria
+- Surface potential ambiguities and multiple interpretations
+
+### 2. Multi-Dimensional Analysis
+
+- **Structural decomposition**: Break into fundamental components and dependencies
+- **Stakeholder perspectives**: Consider viewpoints of all affected parties
+- **Temporal analysis**: Examine short-term vs. long-term implications
+- **Causal reasoning**: Map cause-effect relationships and feedback loops
+- **Contextual factors**: Assess environmental, cultural, and situational influences
+
+### 3. Critical Evaluation
+
+- Challenge your initial assumptions and identify cognitive biases
+- Generate and evaluate alternative hypotheses or solutions
+- Conduct pre-mortem analysis: What could go wrong and why?
+- Consider opportunity costs and trade-offs for each approach
+- Assess confidence levels and sources of uncertainty
+
+### 4. Synthesis and Integration
+
+- Connect insights across different domains and disciplines
+- Identify emergent properties from component interactions
+- Reconcile apparent contradictions or paradoxes
+- Develop meta-insights about the problem-solving process itself
+
+## Output Structure
+
+Present your analysis in this format:
+
+1. **Problem Reframing**: How you understand the core issue
+2. **Key Insights**: Most important discoveries from your analysis
+3. **Reasoning Chain**: Step-by-step logical progression
+4. **Alternatives Considered**: Different approaches evaluated
+5. **Uncertainties**: What you don't know and why it matters
+6. **Actionable Recommendations**: Specific, implementable next steps
+
+Be thorough yet concise. Show your reasoning process, not just conclusions.

package/dist/claude-code-settings/commands/think-ultra.md

@@ -0,0 +1,125 @@
+---
+description: Ultra-comprehensive analytical thinking for the most complex problems
+argument-hint: [complex problem or question]
+---
+
+# Think Ultra Command
+
+Activate maximum cognitive ultrathink processing for ultra-comprehensive analysis of: **$ARGUMENTS**
+
+## Ultra-Analysis Framework
+
+Deploy the most rigorous analytical methodology with exhaustive examination across all dimensions:
+
+### Phase 1: Problem Architecture
+
+- **Ontological analysis**: What is the fundamental nature of this problem?
+- **Epistemological examination**: How do we know what we know about this?
+- **Semantic decomposition**: Deconstruct all key terms and concepts
+- **Boundary analysis**: What's included, excluded, and why?
+- **Meta-problem identification**: What's the problem behind the problem?
+
+### Phase 2: Multi-Paradigm Analysis
+
+- **Reductionist approach**: Break down to smallest analyzable components
+- **Holistic systems view**: Examine emergent properties and interactions
+- **Dialectical reasoning**: Explore contradictions and their resolution
+- **Phenomenological perspective**: How is this experienced subjectively?
+- **Pragmatic evaluation**: What works in practice vs. theory?
+
+### Phase 3: Cross-Disciplinary Integration
+
+- **Scientific methodology**: Hypothesis formation, testing, validation
+- **Mathematical modeling**: Quantitative relationships and patterns
+- **Philosophical frameworks**: Logical consistency and ethical implications
+- **Historical analysis**: Patterns, precedents, and evolutionary trends
+- **Anthropological view**: Cultural, social, and behavioral dimensions
+- **Economic analysis**: Resource allocation, incentives, and trade-offs
+
+### Phase 4: Temporal and Spatial Scaling
+
+- **Multi-timescale analysis**: Immediate, short-term, medium-term, long-term
+- **Generational thinking**: Impact across multiple generations
+- **Spatial scaling**: Local, regional, national, global implications
+- **Fractal analysis**: Self-similar patterns across different scales
+- **Path dependency**: How history constrains future options
+
+### Phase 5: Uncertainty and Risk Modeling
+
+- **Probabilistic reasoning**: Bayesian updating and confidence intervals
+- **Scenario planning**: Multiple future pathways and their implications
+- **Black swan analysis**: Low-probability, high-impact events
+- **Antifragility assessment**: What benefits from disorder?
+- **Robustness testing**: Performance under various stress conditions
+
+### Phase 6: Decision Theory and Game Theory
+
+- **Multi-criteria decision analysis**: Weighted evaluation of options
+- **Strategic interactions**: How others' decisions affect outcomes
+- **Mechanism design**: Optimal system architecture for desired outcomes
+- **Behavioral economics**: Cognitive biases and psychological factors
+- **Evolutionary stable strategies**: What persists over time?
+
+### Phase 7: Meta-Cognitive Reflection
+
+- **Cognitive bias audit**: Systematic identification of thinking errors
+- **Perspective-taking**: Steel-manning opposing viewpoints
+- **Assumption archaeology**: Digging deep into foundational beliefs
+- **Reasoning transparency**: Making implicit logic explicit
+- **Intellectual humility**: Acknowledging limits and uncertainties
+
+## Ultra-Structured Output
+
+Present your comprehensive analysis using this detailed format:
+
+### 1. Problem Reconceptualization
+
+- **Original question**: As stated
+- **Refined question**: After deep analysis
+- **Hidden assumptions**: Uncovered implicit beliefs
+- **Reframing**: Alternative ways to view the issue
+
+### 2. Multi-Dimensional Mapping
+
+- **Core components**: Essential elements and their relationships
+- **System dynamics**: Feedback loops and emergent behaviors
+- **Stakeholder ecosystem**: All affected parties and their interests
+- **Constraint analysis**: Limitations and boundary conditions
+
+### 3. Evidence and Research Integration
+
+- **Data synthesis**: Relevant empirical findings
+- **Theoretical frameworks**: Applicable models and theories
+- **Case studies**: Historical precedents and analogies
+- **Expert consensus**: Areas of agreement and disagreement
+
+### 4. Comprehensive Option Analysis
+
+- **Option generation**: Creative alternatives beyond obvious choices
+- **Multi-criteria evaluation**: Systematic comparison across dimensions
+- **Sensitivity analysis**: How robust are conclusions to assumption changes?
+- **Implementation pathways**: Practical steps for each option
+
+### 5. Risk and Uncertainty Assessment
+
+- **Known unknowns**: Identified areas of uncertainty
+- **Unknown unknowns**: Potential blind spots
+- **Failure modes**: What could go wrong and why
+- **Mitigation strategies**: Risk reduction approaches
+
+### 6. Strategic Recommendations
+
+- **Primary recommendation**: Best course of action with rationale
+- **Alternative pathways**: Backup options and contingencies
+- **Implementation roadmap**: Sequenced steps with timelines
+- **Success metrics**: How to measure progress and outcomes
+- **Adaptation triggers**: When to reconsider the approach
+
+### 7. Meta-Analysis and Reflection
+
+- **Confidence assessment**: How certain are you and why?
+- **Key insights**: Most important discoveries
+- **Remaining questions**: What still needs investigation?
+- **Learning opportunities**: What this analysis teaches about problem-solving
+
+**Note**: This ultra-analysis may require significant processing time and computational resources. The depth of analysis should match the complexity and importance of the problem. Consider using `/think-harder` for less complex issues that don't require the full 7-phase ultra-comprehensive framework.

package/dist/claude-code-settings/commands/translate.md

@@ -0,0 +1,30 @@
+---
+description: Translate texts to Chinese
+argument-hint: [text-to-translate]
+allowed-tools: Read, LS, Glob, Grep
+---
+
+## Tech Article Translator
+Role and Goal:
+You are a professional tech translator specialized in translating English/Japanese tech articles into natural, fluent Chinese. Your task is to translate input text (English or Japanese) into high-quality Chinese that reads naturally while maintaining technical accuracy.
+
+## Constraints:
+- Input format: Markdown (preserve all formatting in output)
+- Output language: Chinese ONLY (all steps and final output must be in Chinese)
+- Keep technical terms untranslated: AI, LLM, GPT, API, ML, DL, NLP, CV, RL, AGI, RAG, Transformer, Token, Prompt, Fine-tuning, Model, Framework, Dataset, Neural Network, Deep Learning, Machine Learning, etc.
+- Keep product names and brand names in original form: OpenAI, Claude, ChatGPT, GitHub, Google, etc.
+- Do not answer questions - translate them instead
+- Do not add any content not present in the original
+
+## Guidelines:
+Execute the following three steps IN CHINESE:
+1. 直译（Direct Translation）: Translate content directly into Chinese while keeping technical terms unchanged
+2. 问题识别（Issue Identification）: Identify awkward phrasing, unnatural expressions, or unclear parts IN CHINESE
+3. 意译优化（Reinterpretation）: Produce a polished Chinese translation that reads naturally and fluently while maintaining technical precision
+
+## Output Format:
+Output ONLY the final reinterpreted Chinese translation. No explanations. No additional commentary.
+
+---
+请将以下英文或日文科技内容翻译成中文（Translate the following English or Japanese tech content into Chinese）:
+$ARGUMENTS

package/dist/claude-code-settings/config.json

@@ -0,0 +1,3 @@
+{
+  "primaryApiKey": "sk-dummy"
+}

package/dist/claude-code-settings/guidances/github-copilot.md

@@ -0,0 +1,70 @@
+# Claude Code with GitHub Copilot as Model Provider
+
+Guidance for how to connect [GitHub Copilot](https://github.com/features/copilot) as a model provider for Claude Code.
+
+> NOTICE: calling GitHub Copilot is not against its policy as this is officially supported per doc [here](https://docs.github.com/en/copilot/how-tos/build-copilot-extensions/building-a-copilot-agent-for-your-copilot-extension/using-copilots-llm-for-your-agent). And actually, there are lots of AI tools (e.g. Aider and Cline VSCode extension) already support GitHub Copilot as one of the LLM providers.
+
+## 1) Install Claude Code and Copilot API proxy
+
+```sh
+npm install -g copilot-api @anthropic-ai/claude-code
+```
+
+## 2) Start copilot-api and authenticate to GitHub Copilot
+
+```
+$ copilot-api start --proxy-env
+...
+Please visit https://github.com/login/device and enter code XXXX-XXXX to authenticate
+...
+```
+
+Once succeeds, you'd see the model list and API address:
+
+```sh
+...
+- claude-3.5-sonnet
+- claude-3.7-sonnet
+- claude-3.7-sonnet-thought
+- claude-sonnet-4.5
+- claude-opus-4
+- gemini-2.0-flash-001
+- gemini-2.5-pro
+- o3
+...
+  ➜ Listening on: http://localhost:4141/ (all interfaces)
+```
+
+## 3) Create Claude Code configure file `~/.claude/settings.json` with the following contents
+
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://localhost:4141",
+    "ANTHROPIC_AUTH_TOKEN": "sk-dummy",
+    "ANTHROPIC_MODEL": "claude-sonnet-4.5",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gpt-5-mini",
+    "DISABLE_NON_ESSENTIAL_MODEL_CALLS": "1",
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
+  }
+}
+```
+
+## 4) Run claude
+
+Open another terminal and then run `claude` at your will. DO read its [best practices](https://www.anthropic.com/engineering/claude-code-best-practices) for fully leveraging its capabilities.
+
+## Alternative config
+
+If the above-configured file doesn't work, use the env variable directly:
+
+```sh
+export ANTHROPIC_BASE_URL="http://localhost:4141"
+export ANTHROPIC_AUTH_TOKEN="sk-dummy"
+export ANTHROPIC_MODEL="claude-sonnet-4.5"
+export ANTHROPIC_DEFAULT_HAIKU_MODEL="gpt-5-mini"
+export DISABLE_NON_ESSENTIAL_MODEL_CALLS="1"
+export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"
+
+claude
+```

package/dist/claude-code-settings/guidances/litellm_config.yaml

@@ -0,0 +1,38 @@
+general_settings:
+  master_key: sk-dummy
+litellm_settings:
+  drop_params: true
+model_list:
+- model_name: gpt-5.1-codex
+  model_info:
+    mode: responses
+    supports_vision: true
+  litellm_params:
+    model: github_copilot/gpt-5.1-codex
+    drop_params: true
+    extra_headers:
+      editor-version: "vscode/1.95.0"
+      editor-plugin-version: "copilot-chat/0.26.7"
+- model_name: gpt-5.1-codex-max
+  model_info:
+    mode: responses
+    supports_vision: true
+  litellm_params:
+    model: github_copilot/gpt-5.1-codex-max
+    drop_params: true
+    extra_headers:
+      editor-version: "vscode/1.95.0"
+      editor-plugin-version: "copilot-chat/0.26.7"
+- model_name: claude-opus-4.5
+  litellm_params:
+    model: github_copilot/claude-opus-4.5
+    drop_params: true
+    extra_headers:
+      editor-version: "vscode/1.95.0"
+      editor-plugin-version: "copilot-chat/0.26.7"
+- model_name: "*"
+  litellm_params:
+    model: "github_copilot/*"
+    extra_headers:
+      editor-version: "vscode/1.95.0"
+      editor-plugin-version: "copilot-chat/0.26.7"