oh-my-codex-cli 0.1.0

package/.agent/skills/project-session-manager/templates/issue-fix.md

@@ -0,0 +1,57 @@
+# Issue Fix Context
+
+You are fixing Issue #{{ISSUE_NUMBER}}: **{{ISSUE_TITLE}}**
+
+## Issue Details
+
+- **URL**: {{ISSUE_URL}}
+- **Labels**: {{ISSUE_LABELS}}
+- **Branch**: `{{BRANCH_NAME}}`
+
+## Description
+
+{{ISSUE_BODY}}
+
+## Approach
+
+1. **Understand the Issue**
+   - Reproduce the problem if applicable
+   - Identify root cause
+   - Consider edge cases
+
+2. **Plan the Fix**
+   - Minimal changes to fix the issue
+   - Don't introduce regressions
+   - Consider backwards compatibility
+
+3. **Implement**
+   - Write the fix
+   - Add/update tests
+   - Update documentation if needed
+
+4. **Verify**
+   - Run existing tests
+   - Test the specific fix
+   - Check for regressions
+
+## Commands
+
+```bash
+# Run tests
+npm test  # or appropriate test command
+
+# Check build
+npm run build  # or appropriate build command
+
+# Create PR when done
+gh pr create --title "Fix #{{ISSUE_NUMBER}}: <description>" --body "Fixes #{{ISSUE_NUMBER}}"
+```
+
+## Fix Checklist
+
+- [ ] Root cause identified
+- [ ] Fix implemented
+- [ ] Tests added/updated
+- [ ] All tests pass
+- [ ] No regressions introduced
+- [ ] Ready for PR

package/.agent/skills/project-session-manager/templates/pr-review.md

@@ -0,0 +1,65 @@
+# PR Review Context
+
+You are reviewing PR #{{PR_NUMBER}}: **{{PR_TITLE}}**
+
+## PR Details
+
+- **Author**: @{{PR_AUTHOR}}
+- **Branch**: `{{HEAD_BRANCH}}` → `{{BASE_BRANCH}}`
+- **URL**: {{PR_URL}}
+
+## Description
+
+{{PR_BODY}}
+
+## Changed Files
+
+{{CHANGED_FILES}}
+
+## Review Focus
+
+1. **Code Quality**
+   - Follow existing patterns and conventions
+   - Clean, readable, maintainable code
+   - Appropriate abstractions
+
+2. **Correctness**
+   - Does it do what it claims?
+   - Edge cases handled?
+   - Error handling appropriate?
+
+3. **Security**
+   - Input validation
+   - No hardcoded secrets
+   - Safe dependencies
+
+4. **Testing**
+   - Adequate test coverage
+   - Tests are meaningful
+   - Edge cases tested
+
+5. **Documentation**
+   - Code is self-documenting
+   - Complex logic explained
+   - API changes documented
+
+## Commands
+
+```bash
+# View diff
+git diff {{BASE_BRANCH}}...HEAD
+
+# Run tests
+npm test  # or appropriate test command
+
+# Check build
+npm run build  # or appropriate build command
+```
+
+## Review Checklist
+
+- [ ] Code follows project style
+- [ ] No obvious bugs or logic errors
+- [ ] Security concerns addressed
+- [ ] Tests pass and cover changes
+- [ ] Documentation updated if needed

package/.agent/skills/project-session-manager/templates/projects.json

@@ -0,0 +1,19 @@
+{
+  "aliases": {
+    "omc": {
+      "repo": "Yeachan-Heo/oh-my-codex",
+      "local": "~/Workspace/oh-my-codex",
+      "default_base": "main"
+    },
+    "cc": {
+      "repo": "anthropics/claude-code",
+      "local": "~/Workspace/claude-code",
+      "default_base": "main"
+    }
+  },
+  "defaults": {
+    "worktree_root": "~/.psm/worktrees",
+    "cleanup_after_days": 14,
+    "auto_cleanup_merged": true
+  }
+}

package/.agent/skills/quality-check/HOW_TO_USE.md

@@ -0,0 +1,171 @@
+# Quality Check - Detailed Usage Guide
+
+## Overview
+
+Analyze code quality using CodeDNA-inspired 6-dimension intelligent scoring system with ROI-optimized refactoring recommendations.
+
+## Six Quality Dimensions
+
+### 1. Clarity (20%)
+**What it measures**: Code readability and intent clarity
+
+**Scoring criteria**:
+- Variable/function naming (10%)
+- Comments and documentation (5%)
+- Code organization (5%)
+
+**Score range**:
+- 90-100: Self-documenting code
+- 70-89: Clear with minor issues
+- 50-69: Needs improvement
+- <50: Confusing
+
+### 2. Structure (20%)
+**What it measures**: Code organization and modularity
+
+**Scoring criteria**:
+- Module boundaries (7%)
+- Function size and complexity (7%)
+- Dependency management (6%)
+
+**Score range**:
+- 90-100: Excellent separation of concerns
+- 70-89: Well-structured
+- 50-69: Some coupling issues
+- <50: Monolithic or tangled
+
+### 3. Examples (15%)
+**What it measures**: Usage examples and documentation quality
+
+**Scoring criteria**:
+- README completeness (5%)
+- Usage examples (5%)
+- API documentation (5%)
+
+### 4. Trigger Detection (15%)
+**What it measures**: API discoverability and intuitiveness
+
+**Scoring criteria**:
+- Function naming (7%)
+- API surface clarity (5%)
+- Error messages (3%)
+
+### 5. Best Practices (15%)
+**What it measures**: Standards and conventions compliance
+
+**Scoring criteria**:
+- Style guide adherence (7%)
+- Security best practices (5%)
+- Performance patterns (3%)
+
+### 6. Maintainability (15%)
+**What it measures**: Long-term code sustainability
+
+**Scoring criteria**:
+- Test coverage (7%)
+- Technical debt (5%)
+- Change risk (3%)
+
+## Usage Scenarios
+
+### Scenario 1: File Quality Check
+
+```
+"Analyze code quality for src/services/payment.ts"
+```
+
+**Output**:
+```markdown
+## 📊 Code Quality Report
+
+**File**: src/services/payment.ts
+**Overall Score**: 78/100 (Good)
+
+### Dimension Scores
+1. Clarity: 85/100 ✅
+2. Structure: 75/100 ✅
+3. Examples: 60/100 ⚠️
+4. Trigger Detection: 80/100 ✅
+5. Best Practices: 70/100 ⚠️
+6. Maintainability: 75/100 ✅
+
+### ROI-Optimized Recommendations
+**High ROI** (10 min → 80% improvement):
+1. Add JSDoc comments to public methods
+2. Extract 120-line processPayment into smaller functions
+
+**Medium ROI** (30 min → 60% improvement):
+3. Add integration tests for edge cases
+4. Refactor error handling into middleware
+
+**Low ROI** (2 hrs → 20% improvement):
+5. Migrate to TypeScript strict mode
+6. Comprehensive input validation
+```
+
+### Scenario 2: Project-Wide Analysis
+
+```
+"Generate quality report for entire project"
+```
+
+Analyzes all files and provides aggregated scores.
+
+### Scenario 3: Trend Analysis
+
+```
+"Compare quality with last month"
+```
+
+Shows quality improvement/degradation over time.
+
+## ROI-Optimized Refactoring
+
+**High ROI** (<30 min, 50%+ impact):
+- Rename unclear variables
+- Add missing documentation
+- Extract magic numbers
+- Fix obvious bugs
+
+**Medium ROI** (30 min-2 hrs, 30% impact):
+- Reduce function complexity
+- Add test coverage
+- Refactor duplicated code
+
+**Low ROI** (>2 hrs, <20% impact):
+- Large-scale refactoring
+- Migration to new patterns
+- Complete test rewrites
+
+## Real-World Examples
+
+### Example 1: Pre-Commit Check
+
+```bash
+git add .
+"Run quality check before commit"
+```
+
+Ensures minimum quality threshold before committing.
+
+### Example 2: Technical Debt Assessment
+
+```
+"Identify technical debt hotspots"
+```
+
+Finds areas with lowest quality scores requiring urgent attention.
+
+### Example 3: Refactoring Prioritization
+
+```
+"Prioritize refactoring by ROI"
+```
+
+Orders improvements by effort/impact ratio.
+
+## Related Skills
+
+- **code-review**: Combines with quality analysis
+- **project-analyze**: Project-wide quality assessment
+- **agent-kb**: Historical quality patterns

package/.agent/skills/quality-check/README.md

@@ -0,0 +1,50 @@
+# Code Quality Check
+
+Analyze code quality using CodeDNA 6-dimension intelligent scoring system with ROI-optimized refactoring recommendations.
+
+## Quick Install
+
+```bash
+# Already installed at:
+~/.claude/skills/quality-check/
+```
+
+## Usage
+
+```
+"Check code quality"
+"Analyze this file for refactoring opportunities"
+"Generate quality report"
+```
+
+## What It Does
+
+- ✅ 6-dimension quality scoring (like CodeDNA)
+- ✅ ROI-optimized refactoring recommendations
+- ✅ Technical debt assessment
+- ✅ Maintainability analysis
+- ✅ Actionable improvement suggestions
+
+## Six Dimensions
+
+1. **Clarity** (20%) - Code readability and intent
+2. **Structure** (20%) - Organization and modularity
+3. **Examples** (15%) - Documentation and usage
+4. **Trigger Detection** (15%) - API discoverability
+5. **Best Practices** (15%) - Standards compliance
+6. **Maintainability** (15%) - Long-term sustainability
+
+## Files
+
+- `SKILL.md` - Complete quality methodology
+- `README.md` - This quick start guide
+- `HOW_TO_USE.md` - Detailed scoring guide
+- `references/` - Scoring criteria details (Phase 2)
+- `assets/` - Report templates (Phase 2)
+
+## When to Use
+
+- Pre-commit quality checks
+- Refactoring prioritization
+- Code review preparation
+- Technical debt audits

package/.agent/skills/quality-check/SKILL.md

@@ -0,0 +1,240 @@
+---
+name: quality-check
+description: CodeDNA 6-dimension intelligent scoring for code quality. Provides ROI-optimized refactoring recommendations when analyzing code.
+---
+
+> Codex CLI: Manual invocation only (`$quality-check`). No hooks or auto-run.
+
+# Code Quality Check Skill
+
+## When to Use This Skill
+
+Automatically invoke this Skill when:
+- User asks to "check code quality", "review this code"
+- User mentions refactoring or code improvements
+- User wants quality scores or metrics
+- Before major refactoring efforts
+- During code review processes
+- Keywords: "quality", "refactor", "review", "improve code", "code smell"
+
+## What This Skill Does
+
+**CodeDNA Quality Analyzer** provides:
+1. **6-Dimension Scoring** - Comprehensive quality assessment
+2. **Issue Identification** - Specific problems with severity levels
+3. **ROI-Optimized Suggestions** - High-value refactoring priorities
+4. **PageRank Analysis** - Quality hotspot identification
+
+## The 6 Quality Dimensions
+
+1. **Complexity** - Cyclomatic complexity, nesting depth
+2. **Maintainability** - Code readability, documentation quality
+3. **Modularity** - Coupling, cohesion, dependency structure
+4. **Test Coverage** - Test quality and coverage metrics
+5. **Documentation** - Comment ratio, API docs completeness
+6. **Best Practices** - Style guide adherence, pattern usage
+
+## Instructions
+
+When this Skill is invoked:
+
+### Step 1: Determine Analysis Mode
+
+Ask yourself:
+- Is it a **single file**? → Use `test_quality_simple.py`
+- Is it a **project directory**? → Use `project_quality_analyzer.py --mode overview`
+- Need **impact analysis**? → Use `project_quality_analyzer.py --mode impact-analysis`
+
+### Step 2: Execute the Analysis
+
+**IMPORTANT**: You MUST execute one of these Python commands:
+
+**Single File Analysis**:
+```bash
+python /Users/WangQiao/claude-enhanced-quality/test_quality_simple.py [file_path]
+```
+
+**Project Overview**:
+```bash
+python /Users/WangQiao/claude-enhanced-quality/project_quality_analyzer.py --project [directory_path] --mode overview
+```
+
+**Impact Analysis**:
+```bash
+python /Users/WangQiao/claude-enhanced-quality/project_quality_analyzer.py --file [file_path] --mode impact-analysis
+```
+
+### Step 3: Present Results
+
+Format the output as:
+
+```markdown
+## 🔬 Code Quality Analysis
+
+**Target**: [File/Project Path]
+**Overall Score**: XX/100 [🟢/🟡/🔴]
+
+### 6-Dimension Breakdown
+
+| Dimension | Score | Status | Key Insights |
+|-----------|-------|--------|--------------|
+| Complexity | XX/100 | 🟢/🟡/🔴 | [Main issue] |
+| Maintainability | XX/100 | 🟢/🟡/🔴 | [Main issue] |
+| Modularity | XX/100 | 🟢/🟡/🔴 | [Main issue] |
+| Test Coverage | XX/100 | 🟢/🟡/🔴 | [Main issue] |
+| Documentation | XX/100 | 🟢/🟡/🔴 | [Main issue] |
+| Best Practices | XX/100 | 🟢/🟡/🔴 | [Main issue] |
+
+### 🔴 Critical Issues (Fix Immediately)
+1. **[Issue Name]** - [File:Line]
+   - Impact: [High/Medium/Low]
+   - Explanation: [What's wrong]
+   - Fix: [Specific solution]
+
+### 🟡 Important Issues (Fix This Sprint)
+1. **[Issue Name]** - [File:Line]
+   - Impact: [explanation]
+   - Suggested approach: [how to fix]
+
+### 💡 Refactoring Priorities (ROI-Optimized)
+
+Based on PageRank and quality analysis:
+
+1. **[Module/File Name]** (ROI: High)
+   - Current Score: XX/100
+   - Effort: [X hours]
+   - Benefit: [Specific improvements]
+   - Priority: P0/P1/P2
+
+2. **[Module/File Name]** (ROI: Medium)
+   - [Details...]
+
+### 📊 Quality Hotspots
+
+Files that would benefit most from refactoring:
+- [File 1]: Score XX, high dependency count
+- [File 2]: Score XX, complex and frequently changed
+- [File 3]: Score XX, critical business logic
+
+### 🎯 Recommended Actions
+
+**Immediate (This Week)**:
+- [ ] [Specific action with file:line]
+- [ ] [Specific action with file:line]
+
+**Short-term (This Sprint)**:
+- [ ] [Refactoring task]
+- [ ] [Testing improvement]
+
+**Long-term (Next Quarter)**:
+- [ ] [Architecture improvement]
+- [ ] [Technical debt reduction]
+```
+
+### Step 4: Provide Context
+
+Explain:
+- Why these scores matter
+- Business impact of the issues
+- Risk of not fixing critical problems
+- Expected improvement from suggested changes
+
+## Examples
+
+### Example 1: Single File Review
+**User**: "Check the quality of src/auth/login.ts"
+
+**You execute**:
+```bash
+python ~/claude-enhanced-quality/test_quality_simple.py src/auth/login.ts
+```
+
+**You present**: 6-dimension scores, specific issues, and refactoring suggestions.
+
+### Example 2: Project Overview
+**User**: "How's the code quality of my payment module?"
+
+**You execute**:
+```bash
+python ~/claude-enhanced-quality/project_quality_analyzer.py --project src/payment --mode overview
+```
+
+**You present**: Project-wide quality assessment, hotspots, and priority fixes.
+
+### Example 3: Impact Analysis
+**User**: "I want to refactor the database layer, what's the impact?"
+
+**You execute**:
+```bash
+python ~/claude-enhanced-quality/project_quality_analyzer.py --file src/core/database.ts --mode impact-analysis
+```
+
+**You present**: Dependency analysis, affected files, risk assessment, and refactoring plan.
+
+## Quality Thresholds
+
+Scoring system:
+- **🟢 80-100**: Good quality, minor improvements only
+- **🟡 60-79**: Acceptable, needs improvement
+- **🔴 <60**: Poor quality, refactoring required
+
+## ROI Calculation
+
+Refactoring priority is based on:
+- **Quality Score** (lower = higher priority)
+- **PageRank** (higher = more important)
+- **Dependency Count** (higher = more impact)
+- **Change Frequency** (higher = more value)
+
+## Integration with ProjectMind
+
+For project-level analysis, the system uses:
+- **Knowledge Graph** - Deep project understanding
+- **Dependency Mapping** - Complete relationship analysis
+- **Historical Data** - Evolution patterns and trends
+
+## Important Notes
+
+- **Always execute** the Python command, don't guess scores
+- **Explain the "why"** behind each issue
+- **Prioritize by ROI**, not just severity
+- **Provide specific fixes**, not generic advice
+- **Consider business context** in recommendations
+
+## Common Quality Issues
+
+### Complexity Issues
+- High cyclomatic complexity (>10)
+- Deep nesting (>4 levels)
+- Long functions (>50 lines)
+- God classes/objects
+
+### Maintainability Issues
+- Poor naming conventions
+- Missing documentation
+- Magic numbers/strings
+- Code duplication
+
+### Modularity Issues
+- High coupling
+- Low cohesion
+- Circular dependencies
+- Tight integration
+
+### Testing Issues
+- Low coverage (<80%)
+- Missing edge cases
+- Flaky tests
+- No integration tests
+
+## Prerequisites
+
+- Python environment with CodeDNA installed
+- Access to project files
+- ProjectMind system for project-level analysis
+
+## Performance
+
+- **Single File**: <5 seconds
+- **Project Overview**: 10-30 seconds
+- **Impact Analysis**: 15-45 seconds