oh-my-codex-cli 0.1.0

package/.agent/skills/test-coverage/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: test-coverage
+description: Imported from everything-codex command test-coverage
+---
+
+# Test Coverage
+
+
+## Native Subagent Protocol (Codex)
+
+Codex supports native subagents. Delegate with `spawn_agent`, coordinate with `send_input`, collect via `wait`, and clean up with `close_agent`.
+
+Execution preference:
+1. Use native subagents first for independent workstreams (parallel when possible).
+2. Merge results in main thread and run final verification.
+3. Fallback only when delegation is blocked: use the `[ANALYST]`/`[ARCHITECT]`/`[EXECUTOR]`/`[REVIEWER]` structure in a single response.
+
+Minimal orchestration pattern:
+```text
+spawn_agent -> send_input (optional) -> wait -> close_agent
+```
+
+Analyze test coverage and generate missing tests:
+
+1. Run tests with coverage: npm test --coverage or pnpm test --coverage
+
+2. Analyze coverage report (coverage/coverage-summary.json)
+
+3. Identify files below 80% coverage threshold
+
+4. For each under-covered file:
+   - Analyze untested code paths
+   - Generate unit tests for functions
+   - Generate integration tests for APIs
+   - Generate E2E tests for critical flows
+
+5. Verify new tests pass
+
+6. Show before/after coverage metrics
+
+7. Ensure project reaches 80%+ overall coverage
+
+Focus on:
+- Happy path scenarios
+- Error handling
+- Edge cases (null, undefined, empty)
+- Boundary conditions
+

package/.agent/skills/thinkdeep/HOW_TO_USE.md

@@ -0,0 +1,183 @@
+# ThinkDeep - Detailed Usage Guide
+
+## Overview
+
+Extended reasoning using Gemini CLI's native thinking capability for complex problem analysis, multi-hypothesis exploration, and evidence-based conclusions.
+
+## When to Use
+
+- Complex architectural decisions
+- Multi-faceted problem solving
+- Trade-off analysis requiring deep thought
+- Strategic planning
+- Risk assessment
+
+## Basic Usage
+
+```
+"Think deeply about microservices vs monolith for our use case"
+"Extended reasoning on database sharding strategy"
+"Analyze trade-offs of event sourcing pattern"
+```
+
+## Extended Thinking Mode
+
+Gemini's native thinking capability provides:
+- **Multi-hypothesis exploration**: Consider multiple approaches
+- **Evidence evaluation**: Weigh pros/cons systematically
+- **Confidence scoring**: Rate certainty of conclusions
+- **Alternative generation**: Explore different perspectives
+
+## Output Format
+
+```markdown
+## 🧠 Deep Reasoning Analysis
+
+**Topic**: [Your question]
+
+### Hypothesis Exploration
+
+**Hypothesis 1**: Microservices architecture
+- Pros: Independent scaling, tech diversity
+- Cons: Operational complexity, distributed debugging
+- Confidence: Medium (60%)
+
+**Hypothesis 2**: Modular monolith
+- Pros: Simpler operations, easier debugging
+- Cons: Scaling limitations, tighter coupling
+- Confidence: High (80%)
+
+**Hypothesis 3**: Hybrid approach
+- Pros: Gradual migration path
+- Cons: Temporary complexity increase
+- Confidence: Medium-High (70%)
+
+### Evidence Analysis
+
+**Supporting modular monolith**:
+1. Team size (10 developers) suits monolith
+2. Traffic (100k users) within monolith capacity
+3. Deployment simplicity reduces ops overhead
+
+**Against microservices**:
+1. Operational overhead high for small team
+2. Distributed tracing complexity
+3. Service orchestration learning curve
+
+### Trade-off Analysis
+
+| Factor | Monolith | Microservices | Winner |
+|--------|----------|---------------|--------|
+| Ops complexity | Simple | Complex | Monolith |
+| Scaling flexibility | Limited | High | Microservices |
+| Development speed | Fast | Slower | Monolith |
+| Tech diversity | Limited | High | Microservices |
+
+### Final Recommendation
+
+**Choose Modular Monolith** (Confidence: 85%)
+
+**Rationale**:
+- Team size and traffic don't justify microservices complexity
+- Can achieve modular benefits without distributed overhead
+- Clear migration path to microservices if needed later
+
+**Decision triggers for microservices**:
+- Team grows beyond 30 developers
+- Traffic exceeds 1M daily active users
+- Need independent deployment of modules
+
+**Action plan**:
+1. Design clear module boundaries now
+2. Use dependency injection for loose coupling
+3. Separate databases per module
+4. Monitor when triggers are approached
+```
+
+## Advanced Usage
+
+### Confidence-Based Decisions
+
+```
+"Think deeply - what's the confidence level for using Kafka vs RabbitMQ?"
+```
+
+Provides explicit confidence scores for each option.
+
+### Multi-Dimensional Analysis
+
+```
+"Deeply analyze database choice across performance, cost, team expertise, and scalability"
+```
+
+Systematic evaluation across specified dimensions.
+
+### Risk Assessment
+
+```
+"Extended reasoning on risks of migrating from MySQL to Cassandra"
+```
+
+Identifies and quantifies potential risks.
+
+## Real-World Scenarios
+
+### Scenario 1: Technology Migration Decision
+
+**Question**: "Think deeply about migrating from REST to GraphQL"
+
+**Analysis includes**:
+- Current REST pain points
+- GraphQL benefits and costs
+- Migration complexity
+- Team readiness
+- Rollback strategy
+
+### Scenario 2: Architecture Pattern Selection
+
+**Question**: "Deep analysis of CQRS pattern for our e-commerce system"
+
+**Analysis includes**:
+- CQRS fit for use case
+- Implementation complexity
+- Eventual consistency implications
+- Alternative patterns comparison
+
+## CLI Usage
+
+```bash
+cat > /tmp/thinkdeep_prompt.txt << 'PROMPT_EOF'
+Think deeply about the following decision:
+
+[Your complex question]
+
+Consider:
+- Multiple perspectives
+- Evidence for/against each option
+- Trade-offs and risks
+- Confidence levels
+- Decision criteria
+PROMPT_EOF
+
+cat /tmp/thinkdeep_prompt.txt | gemini --yolo 2>&1 | grep -v "STARTUP\|YOLO\|Load"
+```
+
+## Tips for Better Results
+
+**Be specific about**:
+- Context and constraints
+- Decision criteria
+- What dimensions to analyze
+- Acceptable trade-offs
+
+**Example**:
+```
+❌ "Should I use Redis?"
+✅ "Think deeply: Redis vs Memcached for session storage with 100k concurrent users, 10GB RAM budget, high availability requirement"
+```
+
+## Related Skills
+
+- **consensus**: Multi-model validation of deep reasoning
+- **architect-planner**: Architecture planning with deep analysis
+- **brainstorming**: Explore alternatives before deep thinking

package/.agent/skills/thinkdeep/README.md

@@ -0,0 +1,41 @@
+# ThinkDeep (Deep Reasoning)
+
+Deep reasoning analysis using Gemini CLI's native thinking capability with extended reasoning mode.
+
+## Quick Install
+
+```bash
+# Already installed at:
+~/.claude/skills/thinkdeep/
+```
+
+## Usage
+
+```
+"Deeply analyze this architectural decision"
+"Think through this complex problem"
+"Extended reasoning for optimization strategy"
+```
+
+## What It Does
+
+- ✅ Extended thinking mode (Gemini native capability)
+- ✅ Multi-hypothesis exploration
+- ✅ Systematic problem decomposition
+- ✅ Evidence-based reasoning
+- ✅ Confidence scoring
+
+## Files
+
+- `SKILL.md` - Complete reasoning methodology
+- `README.md` - This quick start guide
+- `HOW_TO_USE.md` - Detailed reasoning guide (Phase 1)
+- `references/` - Thinking patterns library (Phase 2)
+
+## When to Use
+
+- Complex architectural decisions
+- Multi-faceted problem solving
+- Trade-off analysis
+- Risk assessment
+- Strategic planning

package/.agent/skills/thinkdeep/SKILL.md

@@ -0,0 +1,343 @@
+---
+name: thinkdeep
+description: 深度推理分析 - 使用 Gemini CLI 的原生思考能力进行复杂问题推理，支持会话延续。
+auto_invoke: true
+tags: [thinkdeep, reasoning, gemini, thinking-mode]
+---
+
+# ThinkDeep - 深度推理分析 Skill
+
+## 🎯 核心功能
+
+使用 Gemini CLI 的**原生深度思考能力**进行复杂问题推理和分析。
+
+**替代**: PAL MCP thinkdeep 工具
+
+**关键优势**: Gemini CLI 内置思考模式，比 Claude 的推理更适合长链条逻辑。
+
+## 📋 触发场景
+
+**自动触发**:
+- "深度思考"
+- "复杂推理"
+- "thinkdeep"
+- "系统性分析"
+- "战略规划"
+
+**手动触发**:
+```
+使用 thinkdeep 分析：<复杂问题>
+```
+
+## 🧠 Gemini 思考模式
+
+Gemini 有内置的思考能力，体现在：
+1. **逐步推理**: 自动展开思考链条
+2. **假设验证**: 提出假设并验证
+3. **多角度分析**: 从不同视角审视问题
+4. **反思修正**: 自我质疑并修正结论
+
+## 🔄 Workflow
+
+### Step 1: 准备复杂问题
+
+确保问题需要深度推理：
+- 多步骤决策
+- 需要权衡利弊
+- 涉及不确定性
+- 需要战略思考
+
+### Step 2: Gemini 深度推理
+
+**⚠️ 重要: 优先使用 `gemp` (长任务优化版)，`gemini` CLI 作为备用**
+
+```bash
+# Step 1: 写入 prompt 到临时文件
+cat > /tmp/gemini_thinkdeep_prompt.txt << 'PROMPT_EOF'
+作为战略思考专家，对以下问题进行深度推理：
+
+【问题】
+<用户问题>
+
+请使用系统化思考方法：
+
+1. **问题分解**
+   - 拆解为子问题
+   - 识别关键变量
+   - 确定约束条件
+
+2. **多角度分析**
+   - 技术可行性
+   - 经济成本收益
+   - 组织影响
+   - 风险评估
+
+3. **假设验证**
+   - 列出关键假设
+   - 验证假设合理性
+   - 识别不确定性
+
+4. **方案对比**
+   - 列出可选方案
+   - 量化对比分析
+   - 权衡利弊
+
+5. **最终建议**
+   - 推荐方案
+   - 决策依据
+   - 实施路径
+   - 风险缓解
+
+请展示你的完整思考过程，包括中间推理步骤。
+PROMPT_EOF
+
+# Step 2: 优先使用 gemp (20分钟超时，输出纯净)
+cat /tmp/gemini_thinkdeep_prompt.txt | node ~/.gemini/long_task_runner.js 2>&1
+```
+
+**备用方案** (如果 gemp 失败):
+```bash
+cat /tmp/gemini_thinkdeep_prompt.txt | gemini --yolo 2>&1 | grep -v "STARTUP\|YOLO\|Load"
+```
+
+### Step 3: Claude 结构化整理
+
+Claude 将 Gemini 的深度推理整理成易读的格式。
+
+## 📊 输出格式
+
+```markdown
+## 🧠 深度推理分析报告
+
+**问题**: [复杂问题]
+
+---
+
+### 🤖 Gemini 深度推理过程
+
+#### 1. 问题分解
+
+**子问题**:
+1. [子问题1]
+2. [子问题2]
+3. [子问题3]
+
+**关键变量**:
+- [变量1]: [描述]
+- [变量2]: [描述]
+
+**约束条件**:
+- [约束1]
+- [约束2]
+
+---
+
+#### 2. 多角度分析
+
+**技术可行性** (评分: 8/10)
+- 优势: [...]
+- 挑战: [...]
+- 关键技术: [...]
+
+**经济成本收益**
+- 初始投入: [估算]
+- 预期收益: [估算]
+- ROI: [计算]
+- 回本周期: [估算]
+
+**组织影响**
+- 团队能力要求: [...]
+- 学习曲线: [...]
+- 资源需求: [...]
+
+**风险评估**
+- 高风险: [风险1] (发生概率: X%, 影响: Y)
+- 中风险: [风险2] (发生概率: X%, 影响: Y)
+
+---
+
+#### 3. 假设验证
+
+**假设1**: [关键假设]
+- 验证方法: [...]
+- 合理性: [高/中/低]
+- 不确定性: [...]
+
+**假设2**: [关键假设]
+- 验证方法: [...]
+- 合理性: [高/中/低]
+- 不确定性: [...]
+
+---
+
+#### 4. 方案对比
+
+| 方案 | 技术难度 | 成本 | 收益 | 风险 | 综合评分 |
+|------|---------|------|------|------|---------|
+| 方案A | 高 | $$$ | $$$$$ | 中 | 8.5 |
+| 方案B | 中 | $$ | $$$ | 低 | 7.0 |
+| 方案C | 低 | $ | $$ | 高 | 6.0 |
+
+**详细对比**:
+- 方案A: [详细分析]
+- 方案B: [详细分析]
+- 方案C: [详细分析]
+
+---
+
+#### 5. 最终建议
+
+**推荐方案**: 方案A
+
+**决策依据**:
+1. [理由1]: 技术可行性最高
+2. [理由2]: ROI 最优 (18 个月回本)
+3. [理由3]: 符合长期战略
+
+**实施路径**:
+
+**Phase 1: 准备阶段** (1-2 个月)
+- [ ] 任务1: [具体任务]
+- [ ] 任务2: [具体任务]
+
+**Phase 2: 试点阶段** (2-3 个月)
+- [ ] 任务3: [具体任务]
+- [ ] 任务4: [具体任务]
+
+**Phase 3: 推广阶段** (3-6 个月)
+- [ ] 任务5: [具体任务]
+- [ ] 任务6: [具体任务]
+
+**风险缓解**:
+- 风险1 → 缓解措施: [...]
+- 风险2 → 缓解措施: [...]
+
+**关键决策点**:
+- 决策点1: [在 Phase 1 结束时确认]
+- 决策点2: [在 Phase 2 结束时确认]
+
+---
+
+### 🎯 Claude 补充分析
+
+[Claude 基于 Gemini 的推理，补充实际可操作的建议]
+
+---
+
+**📅 推理时间**: [时间戳]
+**🤖 模型**: Gemini (深度推理) + Claude (结构化整理)
+**⏱️ 推理耗时**: [X 分钟]
+```
+
+## 🎓 使用示例
+
+### 示例 1: 技术战略决策
+
+**输入**:
+```
+thinkdeep：我们公司应该自建 AI 能力还是使用第三方 API？
+团队规模 50 人，预算 500 万/年，业务需求不确定。
+```
+
+**Gemini 推理**:
+1. 分解为技术、成本、团队、风险等子问题
+2. 对比自建 vs 第三方的多维度分析
+3. 量化成本收益 (研发投入 vs API 费用)
+4. 评估团队能力缺口和学习曲线
+5. 给出阶段性建议 (先用第三方，后期自建核心能力)
+
+### 示例 2: 架构演进规划
+
+**输入**:
+```
+thinkdeep：单体应用何时重构为微服务？
+当前 30 万行代码，10 个服务模块，团队 20 人。
+```
+
+**Gemini 推理**:
+1. 分析当前痛点 (部署耦合、扩展困难、技术债)
+2. 评估微服务化收益 (独立部署、技术栈自由、扩展性)
+3. 计算重构成本 (人力、时间、风险)
+4. 对比渐进重构 vs 一次性重构
+5. 给出分模块迁移路线图
+
+### 示例 3: 产品方向决策
+
+**输入**:
+```
+thinkdeep：B2B SaaS 应该专注垂直行业还是水平扩展？
+当前客户 100 家，主要在金融行业，竞争激烈。
+```
+
+**Gemini 推理**:
+1. 分析垂直深耕 vs 水平扩展的战略差异
+2. 评估金融行业的市场规模和天花板
+3. 对比进入新行业的成本和风险
+4. 分析竞争格局和差异化机会
+5. 给出阶段性战略 (深耕金融 + 试点相近行业)
+
+## 🔄 多轮深度思考
+
+**使用 gemp 进行多轮对话** (每轮新建临时文件):
+
+```bash
+# 第一轮：初步推理
+cat > /tmp/gemini_think1.txt << 'PROMPT_EOF'
+深度思考这个战略问题...
+PROMPT_EOF
+cat /tmp/gemini_think1.txt | node ~/.gemini/long_task_runner.js 2>&1
+
+# 第二轮：质疑假设 (在同一会话中继续)
+cat > /tmp/gemini_think2.txt << 'PROMPT_EOF'
+你的假设2 '市场规模可达10亿' 依据是什么？
+PROMPT_EOF
+cat /tmp/gemini_think2.txt | node ~/.gemini/long_task_runner.js 2>&1
+
+# 第三轮：优化方案
+cat > /tmp/gemini_think3.txt << 'PROMPT_EOF'
+能否优化方案A，降低初始投入？
+PROMPT_EOF
+cat /tmp/gemini_think3.txt | node ~/.gemini/long_task_runner.js 2>&1
+```
+
+**备用方案** (gemini CLI 多轮):
+```bash
+gemini -p "深度思考..." --yolo
+gemini -p "深入分析..." --resume latest --yolo
+```
+
+## 🧪 适用场景
+
+**适合 ThinkDeep 的问题**:
+- ✅ 战略规划 (产品方向、技术路线)
+- ✅ 架构决策 (微服务化、技术选型)
+- ✅ 成本收益分析 (自建 vs 外包)
+- ✅ 风险评估 (新技术引入、组织变革)
+- ✅ 多方案对比 (需要量化分析)
+
+**不适合 ThinkDeep 的问题**:
+- ❌ 简单技术问题 (查 API 文档就能解决)
+- ❌ 紧急 bug (需要快速定位，不需要深度推理)
+- ❌ 代码实现细节 (用 Codex 更合适)
+
+## ⚠️ 注意事项
+
+1. **推理时间较长**: Gemini 深度思考可能需要 2-5 分钟
+2. **需要清晰问题**: 问题越具体，推理越准确
+3. **提供充分背景**: 给出数据、约束条件、目标
+4. **多轮对话**: 利用 `--resume` 逐步深化思考
+
+## 🆚 vs PAL MCP ThinkDeep
+
+| 特性 | PAL MCP | Direct CLI Skill |
+|------|---------|-----------------|
+| 超时问题 | ❌ 容易超时 | ✅ 不会超时 |
+| 思考深度 | ✅ 支持 | ✅ Gemini 原生能力更强 |
+| 上下文延续 | ✅ continuation_id | ✅ --resume |
+| 推理可见性 | ⚠️ 黑盒 | ✅ 完整思考过程可见 |
+
+---
+
+**创建时间**: 2025-12-19
+**版本**: v1.0
+**替代**: PAL MCP thinkdeep 工具