oh-my-codex-cli 0.1.0

package/.agent/skills/planning-with-files/templates/task_plan.md

@@ -0,0 +1,132 @@
+# Task Plan: [Brief Description]
+<!-- 
+  WHAT: This is your roadmap for the entire task. Think of it as your "working memory on disk."
+  WHY: After 50+ tool calls, your original goals can get forgotten. This file keeps them fresh.
+  WHEN: Create this FIRST, before starting any work. Update after each phase completes.
+-->
+
+## Goal
+<!-- 
+  WHAT: One clear sentence describing what you're trying to achieve.
+  WHY: This is your north star. Re-reading this keeps you focused on the end state.
+  EXAMPLE: "Create a Python CLI todo app with add, list, and delete functionality."
+-->
+[One sentence describing the end state]
+
+## Current Phase
+<!-- 
+  WHAT: Which phase you're currently working on (e.g., "Phase 1", "Phase 3").
+  WHY: Quick reference for where you are in the task. Update this as you progress.
+-->
+Phase 1
+
+## Phases
+<!-- 
+  WHAT: Break your task into 3-7 logical phases. Each phase should be completable.
+  WHY: Breaking work into phases prevents overwhelm and makes progress visible.
+  WHEN: Update status after completing each phase: pending → in_progress → complete
+-->
+
+### Phase 1: Requirements & Discovery
+<!-- 
+  WHAT: Understand what needs to be done and gather initial information.
+  WHY: Starting without understanding leads to wasted effort. This phase prevents that.
+-->
+- [ ] Understand user intent
+- [ ] Identify constraints and requirements
+- [ ] Document findings in findings.md
+- **Status:** in_progress
+<!-- 
+  STATUS VALUES:
+  - pending: Not started yet
+  - in_progress: Currently working on this
+  - complete: Finished this phase
+-->
+
+### Phase 2: Planning & Structure
+<!-- 
+  WHAT: Decide how you'll approach the problem and what structure you'll use.
+  WHY: Good planning prevents rework. Document decisions so you remember why you chose them.
+-->
+- [ ] Define technical approach
+- [ ] Create project structure if needed
+- [ ] Document decisions with rationale
+- **Status:** pending
+
+### Phase 3: Implementation
+<!-- 
+  WHAT: Actually build/create/write the solution.
+  WHY: This is where the work happens. Break into smaller sub-tasks if needed.
+-->
+- [ ] Execute the plan step by step
+- [ ] Write code to files before executing
+- [ ] Test incrementally
+- **Status:** pending
+
+### Phase 4: Testing & Verification
+<!-- 
+  WHAT: Verify everything works and meets requirements.
+  WHY: Catching issues early saves time. Document test results in progress.md.
+-->
+- [ ] Verify all requirements met
+- [ ] Document test results in progress.md
+- [ ] Fix any issues found
+- **Status:** pending
+
+### Phase 5: Delivery
+<!-- 
+  WHAT: Final review and handoff to user.
+  WHY: Ensures nothing is forgotten and deliverables are complete.
+-->
+- [ ] Review all output files
+- [ ] Ensure deliverables are complete
+- [ ] Deliver to user
+- **Status:** pending
+
+## Key Questions
+<!-- 
+  WHAT: Important questions you need to answer during the task.
+  WHY: These guide your research and decision-making. Answer them as you go.
+  EXAMPLE: 
+    1. Should tasks persist between sessions? (Yes - need file storage)
+    2. What format for storing tasks? (JSON file)
+-->
+1. [Question to answer]
+2. [Question to answer]
+
+## Decisions Made
+<!-- 
+  WHAT: Technical and design decisions you've made, with the reasoning behind them.
+  WHY: You'll forget why you made choices. This table helps you remember and justify decisions.
+  WHEN: Update whenever you make a significant choice (technology, approach, structure).
+  EXAMPLE:
+    | Use JSON for storage | Simple, human-readable, built-in Python support |
+-->
+| Decision | Rationale |
+|----------|-----------|
+|          |           |
+
+## Errors Encountered
+<!-- 
+  WHAT: Every error you encounter, what attempt number it was, and how you resolved it.
+  WHY: Logging errors prevents repeating the same mistakes. This is critical for learning.
+  WHEN: Add immediately when an error occurs, even if you fix it quickly.
+  EXAMPLE:
+    | FileNotFoundError | 1 | Check if file exists, create empty list if not |
+    | JSONDecodeError | 2 | Handle empty file case explicitly |
+-->
+| Error | Attempt | Resolution |
+|-------|---------|------------|
+|       | 1       |            |
+
+## Notes
+<!-- 
+  REMINDERS:
+  - Update phase status as you progress: pending → in_progress → complete
+  - Re-read this plan before major decisions (attention manipulation)
+  - Log ALL errors - they help avoid repetition
+  - Never repeat a failed action - mutate your approach instead
+-->
+- Update phase status as you progress: pending → in_progress → complete
+- Re-read this plan before major decisions (attention manipulation)
+- Log ALL errors - they help avoid repetition

package/.agent/skills/project-analyze/CLAUDE.md

@@ -0,0 +1,18 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+### Dec 30, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #830 | 5:27 PM | ✅ | Generated comprehensive HOW_TO_USE documentation for three core development skills | ~643 |
+| #827 | 5:23 PM | ✅ | Phase 1 README Files Added to Three Core Skills | ~589 |
+
+### Jan 10, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #1785 | 11:14 AM | 🔵 | Confirmed Obsidian-Skills Already Installed | ~266 |
+</claude-mem-context>

package/.agent/skills/project-analyze/HOW_TO_USE.md

@@ -0,0 +1,145 @@
+# Project Analyze - Detailed Usage Guide
+
+## Overview
+
+ProjectMind-powered intelligent project analysis providing 40-second architectural understanding through dependency graphs and pattern detection.
+
+## Usage Scenarios
+
+### Scenario 1: Quick Project Understanding
+
+```
+"Analyze this project structure"
+```
+
+**Output**:
+- Architecture pattern (MVC, microservices, layered)
+- Technology stack
+- Dependency graph
+- Key components and their relationships
+- Potential issues
+
+### Scenario 2: Onboarding New Developers
+
+```
+"Generate project overview for new team member"
+```
+
+Creates comprehensive onboarding document with:
+- Codebase structure
+- Module responsibilities
+- Entry points and flows
+- Development setup guide
+
+### Scenario 3: Impact Analysis
+
+```
+"Analyze impact of changing UserService"
+```
+
+Shows:
+- Direct dependents
+- Transitive dependencies
+- Affected test files
+- Risk assessment
+
+## Output Format
+
+```markdown
+## 📊 Project Analysis Report
+
+### Overview
+- **Architecture Pattern**: Layered Architecture (Backend)
+- **Primary Language**: TypeScript (95%)
+- **Framework**: Express.js + React
+- **Build System**: Webpack + Jest
+
+### Structure
+```
+src/
+├── controllers/     # HTTP request handlers
+├── services/        # Business logic
+├── models/          # Data models (Sequelize)
+├── utils/           # Shared utilities
+└── config/          # Configuration
+```
+
+### Dependency Graph
+```
+controllers → services → models
+           ↘ utils ↗
+```
+
+### Key Insights
+1. **Layering**: Clean separation of concerns ✅
+2. **Circular Dependencies**: None detected ✅
+3. **Unused Modules**: 3 files in src/legacy/ ⚠️
+4. **Test Coverage**: 72% (target: 80%) ⚠️
+
+### Recommendations
+1. Remove unused legacy files
+2. Increase test coverage for services layer
+3. Consider splitting large UserService (450 lines)
+```
+
+## Advanced Features
+
+### Dependency Visualization
+
+```
+"Show dependency graph for authentication flow"
+```
+
+ASCII graph or recommendations for visualization tools.
+
+### Architecture Pattern Detection
+
+Automatically identifies:
+- MVC
+- Microservices
+- Layered architecture
+- Event-driven
+- Hexagonal/Clean architecture
+
+### Change Impact Prediction
+
+```
+"What breaks if I change PaymentService.processPayment?"
+```
+
+Lists all affected:
+- Direct callers
+- Tests
+- Dependent modules
+
+## Real-World Examples
+
+### Example 1: Code Review Prep
+
+```
+"Analyze files changed in feature/auth-refactor"
+```
+
+Understand architectural impact before reviewing.
+
+### Example 2: Refactoring Planning
+
+```
+"Identify tightly coupled modules"
+```
+
+Find refactoring opportunities to improve modularity.
+
+### Example 3: Documentation Generation
+
+```
+"Generate architecture diagram documentation"
+```
+
+Auto-generate architecture docs from codebase analysis.
+
+## Related Skills
+
+- **quality-check**: Combines structure analysis with quality metrics
+- **code-review**: Use insights to guide review focus
+- **brainstorming**: Inform architectural brainstorming with current state

package/.agent/skills/project-analyze/README.md

@@ -0,0 +1,42 @@
+# Project Analyze (ProjectMind)
+
+Analyze project architecture, dependencies, and structure using ProjectMind knowledge graph for intelligent project understanding.
+
+## Quick Install
+
+```bash
+# Already installed at:
+~/.claude/skills/project-analyze/
+```
+
+## Usage
+
+```
+"Analyze project structure"
+"Show dependency graph"
+"Identify architectural issues"
+```
+
+## What It Does
+
+- ✅ 40-second intelligent project understanding
+- ✅ Architecture pattern detection
+- ✅ Dependency analysis and visualization
+- ✅ Impact analysis for changes
+- ✅ Knowledge graph generation
+
+## Files
+
+- `SKILL.md` - Complete analysis methodology
+- `README.md` - This quick start guide
+- `HOW_TO_USE.md` - Detailed analysis guide
+- `references/` - Analysis patterns (Phase 2)
+- `assets/` - Report templates (Phase 2)
+
+## When to Use
+
+- Understanding new codebases
+- Onboarding new team members
+- Before making large changes
+- Identifying refactoring opportunities
+- Architecture documentation

package/.agent/skills/project-analyze/SKILL.md

@@ -0,0 +1,289 @@
+---
+name: project-analyze
+description: Analyze project architecture and dependencies using ProjectMind knowledge graph. Provides 40s intelligent understanding and impact analysis.
+---
+
+> Codex CLI: Manual invocation only (`$project-analyze`). No hooks or auto-run.
+
+# Project Intelligence Analysis Skill
+
+## When to Use This Skill
+
+Automatically invoke this Skill when:
+- User asks "explain this project", "how does this work?"
+- User wants to understand architecture or module structure
+- User needs impact analysis before refactoring
+- User asks about dependencies or file relationships
+- User mentions "high-risk files", "critical modules"
+- Keywords: "project structure", "architecture", "dependencies", "impact", "understand codebase"
+
+## What This Skill Does
+
+**ProjectMind Intelligence** provides:
+1. **Knowledge Graph Analysis** - Deep project structure understanding
+2. **Dependency Mapping** - Complete relationship visualization
+3. **Risk Assessment** - High-risk file identification
+4. **Impact Prediction** - Change impact estimation
+5. **Smart Caching** - 40s first run, <1s subsequent queries
+
+## Instructions
+
+When this Skill is invoked:
+
+### Step 1: Extract the Query and Project Path
+
+Identify:
+- **User's Question**: What they want to know
+- **Project Path**: Usually current directory `$(pwd)` or user-specified path
+
+### Step 2: Execute the Analysis
+
+**IMPORTANT**: You MUST execute this Python command:
+
+```bash
+python /Users/WangQiao/claude-enhanced-quality/hybrid_intelligent_system_v2.py "user's question" [project_path]
+```
+
+If project path is not specified, use current directory:
+```bash
+python /Users/WangQiao/claude-enhanced-quality/hybrid_intelligent_system_v2.py "user's question" $(pwd)
+```
+
+### Step 3: Present Results
+
+Format the output as:
+
+```markdown
+## 🧠 Project Intelligence Analysis
+
+**Query**: [User's Question]
+**Project**: [Project Path]
+**Analysis Time**: [Cached/40s] ⚡
+
+### 📊 Project Overview
+
+- **Total Files**: XXX
+- **Lines of Code**: XXX,XXX
+- **Main Technologies**: [React, TypeScript, Node.js, etc.]
+- **Architecture Pattern**: [MVC, Microservices, Monolith, etc.]
+
+### 🎯 Answer to Your Question
+
+[Direct answer to the user's specific question based on ProjectMind analysis]
+
+### 🏗️ Architecture Insights
+
+**Module Structure**:
+```
+Core Modules:
+├── [Module 1] (XX files, core business logic)
+├── [Module 2] (XX files, data layer)
+└── [Module 3] (XX files, API layer)
+
+Supporting Modules:
+├── [Utils] (XX files)
+└── [Components] (XX files)
+```
+
+**Key Relationships**:
+- [Module A] depends heavily on [Module B]
+- [File X] is central hub (XX dependencies)
+- [Component Y] is isolated (low coupling)
+
+### ⚠️ High-Risk Areas
+
+| File/Module | Risk Level | Reason | Dependencies |
+|-------------|------------|--------|--------------|
+| [Path 1] | 🔴 Critical | Core auth logic, 45 dependencies | 45 files |
+| [Path 2] | 🟠 High | Payment processing | 32 files |
+| [Path 3] | 🟡 Medium | Complex business rules | 18 files |
+
+### 💡 Recommendations
+
+**If Planning Changes**:
+1. **[Specific Module]**
+   - Files Affected: XX files
+   - Risk Level: [Low/Medium/High]
+   - Test Requirements: [Unit/Integration/E2E]
+   - Estimated Effort: X hours
+
+2. **[Another Module]**
+   - Impact: [Detailed impact analysis]
+   - Mitigation: [How to reduce risk]
+
+**Architecture Improvements**:
+- [Specific decoupling opportunity]
+- [Specific pattern improvement]
+- [Specific technical debt reduction]
+
+### 🔍 Dependency Visualization
+
+```mermaid
+graph TD
+    A[Core Module] --> B[Feature 1]
+    A --> C[Feature 2]
+    B --> D[Util 1]
+    C --> D
+    B --> E[DB Layer]
+    C --> E
+```
+
+(Note: Mermaid diagram representing key dependencies)
+
+### 🚨 Change Impact Assessment
+
+**Before modifying [specific file/module]**:
+- ✅ Test these files: [List]
+- ⚠️ Watch for side effects in: [List]
+- 🔍 Review integration points: [List]
+- ⏱️ Estimated impact: [Low/Medium/High]
+
+### 📈 Technical Metrics
+
+- **Modularity Score**: XX/100
+- **Coupling Level**: [Low/Medium/High]
+- **Code Churn**: [Files frequently changed]
+- **Critical Path**: [Most important business logic files]
+```
+
+### Step 4: Provide Actionable Guidance
+
+Offer specific next steps:
+- Code locations to examine
+- Tests to run before changes
+- Files to backup before refactoring
+- Team members to consult (if AI annotations present)
+
+## Examples
+
+### Example 1: Understanding Architecture
+**User**: "Explain how the authentication system works"
+
+**You execute**:
+```bash
+python ~/claude-enhanced-quality/hybrid_intelligent_system_v2.py "authentication system flow" $(pwd)
+```
+
+**You present**: Architecture explanation with module relationships, file paths, and authentication flow diagram.
+
+### Example 2: Refactoring Impact
+**User**: "I want to refactor the database layer, what's the impact?"
+
+**You execute**:
+```bash
+python ~/claude-enhanced-quality/hybrid_intelligent_system_v2.py "database layer refactoring impact" $(pwd)
+```
+
+**You present**: Impact analysis showing XX affected files, risk assessment, and refactoring strategy.
+
+### Example 3: Finding High-Risk Code
+**User**: "What are the most critical files in this project?"
+
+**You execute**:
+```bash
+python ~/claude-enhanced-quality/hybrid_intelligent_system_v2.py "identify critical and high-risk files" $(pwd)
+```
+
+**You present**: List of high-risk files with dependency counts, complexity scores, and business criticality.
+
+## Performance Characteristics
+
+- **First Analysis**: ~40 seconds (deep project scan)
+- **Cached Queries**: <1 second (instant response)
+- **File Limit**: 300 files deep analysis
+- **Cache Invalidation**: Automatic on file changes
+
+## Smart Caching System
+
+The system automatically caches:
+- ✅ Project structure analysis
+- ✅ Dependency mappings
+- ✅ Code entity relationships
+- ✅ Risk assessments
+
+Cache updates when:
+- Files are modified
+- Dependencies change
+- Project structure updates
+
+## Integration with Other Systems
+
+### Git Memory Integration
+- Tracks commit intentions automatically
+- Analyzes team collaboration patterns
+- Detects potentially conflicting changes
+
+### CodeDNA Integration
+- Project-level quality scoring
+- Hotspot identification with quality metrics
+- ROI-optimized refactoring prioritization
+
+### AI-Specific Annotations
+
+Recognizes and utilizes:
+```typescript
+/*@ai:risk=1-5|deps=file1,file2|core=true|chain=auth*/
+```
+
+Annotation fields:
+- `risk`: 1 (safe) to 5 (critical)
+- `deps`: Key dependencies
+- `core`: Core functionality flag
+- `chain`: Business logic chain identifier
+- `api`: API type (internal/external)
+- `auth`: Authentication requirements
+
+## Important Notes
+
+- **Always execute** the Python command, don't simulate analysis
+- **Use current directory** as default project path
+- **Explain relationships**, not just list files
+- **Provide visual diagrams** when helpful
+- **Assess real impact**, not theoretical concerns
+- **Offer specific actions**, not generic advice
+
+## Common Analysis Queries
+
+### Architecture Understanding
+- "How does [feature] work?"
+- "What's the data flow for [process]?"
+- "Explain the module structure"
+
+### Impact Analysis
+- "Impact of changing [file/module]?"
+- "What depends on [component]?"
+- "Risk of refactoring [area]?"
+
+### Code Navigation
+- "Where is [functionality] implemented?"
+- "Which files handle [feature]?"
+- "What are the entry points?"
+
+### Quality Assessment
+- "What are the problem areas?"
+- "Where should we focus refactoring?"
+- "What's the technical debt?"
+
+## Prerequisites
+
+- Python environment
+- ProjectMind V2 system installed
+- Read access to project files
+- Write access for caching (automatic)
+
+## Fallback Strategy
+
+**DO NOT use V1** (`hybrid_intelligent_system.py`) - it's deprecated
+
+If V2 fails:
+1. Check project path is correct
+2. Verify Python environment
+3. Examine error message
+4. Report the issue
+
+## Performance Tips
+
+- First query takes 40s to build knowledge graph
+- Subsequent queries are instant (cached)
+- Narrow queries get faster responses
+- Broader queries provide more context