oh-my-customcodex 0.1.0

package/templates/.claude/skills/analysis/SKILL.md

@@ -0,0 +1,223 @@
+---
+name: omcodex:analysis
+description: Analyze project and auto-configure agents, skills, rules, and guides
+scope: harness
+argument-hint: "[target-dir] [--interview]"
+user-invocable: true
+---
+
+# Project Analysis Skill
+
+Scan a project's tech stack, compare against installed agents/skills, and auto-configure missing items.
+
+## Options
+
+```
+--dry-run      Show what would be added without making changes
+--verbose      Show detailed detection reasoning
+--interview, -i   Run interactive architecture interview before file-based detection
+```
+
+## Workflow
+
+### Step 0: Architecture Interview (--interview only)
+
+When `--interview` flag is provided, conduct an interactive AI interview before file-based detection. This captures human context that file scanning cannot determine.
+
+**Interview flow** (sequential, AI-guided):
+
+1. **프로젝트 유형**: "이 프로젝트는 어떤 종류입니까?"
+   → 옵션: web app, REST API, CLI tool, library, monorepo, data pipeline, mobile app
+
+2. **아키텍처 패턴**: "어떤 아키텍처를 따르고 있습니까?"
+   → 옵션: microservices, monolith, serverless, event-driven, layered, hexagonal
+
+3. **주요 언어**: "주로 사용하는 프로그래밍 언어는?"
+   → 자유 입력, 알려진 에이전트와 매칭
+
+4. **배포 대상**: "어디에 배포합니까?"
+   → 옵션: AWS, GCP, Azure, Vercel, on-premises, Docker/K8s, edge
+
+5. **팀 우선순위**: "팀의 주요 관심사는?"
+   → 옵션: performance, security, developer experience, cost, scalability
+
+**Interview results feed into Step 1 as weighted detection hints:**
+- File evidence + interview agreement = `confidence: high`
+- File evidence only = `confidence: medium` (unchanged from current)
+- Interview only (no file evidence) = `confidence: suggested`
+
+**Integration with report:**
+```
+Interview Insights (--interview):
+  Project type: REST API (user-specified, confirmed by file scan)
+  Architecture: microservices (user-specified)
+  Deployment: AWS + Docker (confirmed by file scan)
+  Team focus: security → sec-codeql-expert [suggested]
+
+Suggested (from interview, no file evidence):
+  ~ sec-codeql-expert  [suggested — no CodeQL config found]
+  ~ de-kafka-expert     [suggested — no kafka deps found]
+```
+
+### Step 1: Project Scan
+
+Detect tech stack by checking indicator files and dependency manifests.
+
+| Indicator | Files to Check | Agent | Skill |
+|-----------|---------------|-------|-------|
+| TypeScript | tsconfig.json, *.ts, *.tsx | lang-typescript-expert | typescript-best-practices |
+| React/Next.js | next.config.*, package.json (next dep) | fe-vercel-agent | react-best-practices |
+| Vue.js | vue.config.*, *.vue | fe-vuejs-agent | - |
+| Svelte | svelte.config.*, *.svelte | fe-svelte-agent | - |
+| Flutter/Dart | pubspec.yaml, *.dart, lib/main.dart | fe-flutter-agent | - |
+| Python | pyproject.toml, requirements.txt, *.py | lang-python-expert | python-best-practices |
+| FastAPI | "fastapi" in imports/deps | be-fastapi-expert | fastapi-best-practices |
+| Go | go.mod, *.go | lang-golang-expert | go-best-practices |
+| Go Backend | go.mod + cmd/ or internal/ dirs | be-go-backend-expert | go-backend-best-practices |
+| Rust | Cargo.toml, *.rs | lang-rust-expert | rust-best-practices |
+| Kotlin | *.kt, build.gradle.kts | lang-kotlin-expert | kotlin-best-practices |
+| Java | *.java, pom.xml | lang-java21-expert | - |
+| Spring Boot | spring-boot in deps | be-springboot-expert | springboot-best-practices |
+| Express.js | "express" in deps | be-express-expert | - |
+| NestJS | "@nestjs" in deps | be-nestjs-expert | - |
+| Docker | Dockerfile, compose.yml | infra-docker-expert | docker-best-practices |
+| AWS | CDK/SAM/CloudFormation files | infra-aws-expert | aws-best-practices |
+| PostgreSQL | *.sql, pg in deps | db-postgres-expert | postgres-best-practices |
+| Redis | redis in deps | db-redis-expert | redis-best-practices |
+| Supabase | supabase in deps/config | db-supabase-expert | supabase-postgres-best-practices |
+| Airflow | dags/*.py, airflow in deps | de-airflow-expert | airflow-best-practices |
+| dbt | dbt_project.yml | de-dbt-expert | dbt-best-practices |
+| Kafka | kafka in deps/config | de-kafka-expert | kafka-best-practices |
+| Spark | spark in deps/config | de-spark-expert | spark-best-practices |
+| Snowflake | snowflake in deps/config | de-snowflake-expert | snowflake-best-practices |
+
+**Detection logic:**
+
+```
+1. Read package.json / go.mod / Cargo.toml / pyproject.toml / pom.xml
+2. Glob for indicator files (tsconfig.json, *.vue, Dockerfile, etc.)
+3. Grep dependencies for framework/library names
+4. For verbose mode: log each indicator found and confidence level
+```
+
+### Step 2: Gap Analysis
+
+Compare detected stack against what is already installed.
+
+```
+1. List existing agents:  ls .codex/agents/*.md
+2. List existing skills:  find .codex/skills -name "SKILL.md"
+3. For each detected indicator:
+   a. Check if required agent file exists → mark MISSING or PRESENT
+   b. Check if required skill directory exists → mark MISSING or PRESENT
+4. Build two lists:
+   - missing_agents[]   — agents needed but not present
+   - missing_skills[]   — skills needed but not present
+5. (Optional) Build unused list for suggestions:
+   - Agents present but no indicator matched → flag for review
+```
+
+### Step 3: Auto-Configure
+
+Apply changes for all missing items (skip in --dry-run mode).
+
+```
+For each missing agent:
+  - If agent exists in templates/.codex/agents/ → copy to .codex/agents/
+  - Else → delegate to mgr-creator with detected domain context
+
+For each missing skill:
+  - If skill exists in templates/.codex/skills/ → copy to .codex/skills/
+  - Else → log as "skill not available in templates, manual setup needed"
+
+Rules:
+  - Keep all existing rules (they are universal, never remove)
+
+Guides:
+  - Verify templates/guides/ directory has relevant reference docs
+  - Log missing guide topics as suggestions only (no auto-copy)
+```
+
+### Step 4: Report
+
+Output a structured summary after the run.
+
+```
+[analysis] Project: <detected project name or path>
+
+Tech Stack Detected:
+  - TypeScript (tsconfig.json found)
+  - React/Next.js (next in package.json deps)
+  - Docker (Dockerfile found)
+
+Agents:
+  + lang-typescript-expert  [added]
+  + fe-vercel-agent          [added]
+  ~ infra-docker-expert      [already present, skipped]
+
+Skills:
+  + typescript-best-practices  [added]
+  + react-best-practices        [added]
+  ~ docker-best-practices       [already present, skipped]
+
+Rules:   no changes (universal rules kept as-is)
+
+Guides:  react/ — present
+         docker/ — present
+         typescript/ — present
+
+Suggestions:
+  - infra-aws-expert not detected (no CDK/SAM files found)
+  - de-* agents not detected (no pipeline indicators found)
+
+Summary: 2 agents added, 2 skills added, 0 removed
+```
+
+**--dry-run output** prefixes all additions with `[would add]` instead of `[added]` and makes no file changes.
+
+**--verbose output** adds a Detection section before the report:
+
+```
+Detection Details:
+  tsconfig.json            → TypeScript confirmed
+  package.json[next]       → Next.js confirmed (confidence: high)
+  package.json[react]      → React confirmed (confidence: high)
+  Dockerfile               → Docker confirmed
+  no go.mod found          → Go skipped
+  no Cargo.toml found      → Rust skipped
+```
+
+### Step 5: Adaptive Harness Integration
+
+After analysis completes, offer adaptive-harness optimization:
+
+```
+[Analysis Complete] Tech stack detected. Optimize harness for this project?
+├── Yes → Run /omcodex:adaptive-harness --optimize (deactivate unused, suggest missing)
+├── Dry-run → Run /omcodex:adaptive-harness --optimize --dry-run (show changes only)
+└── Skip → Keep current harness configuration
+```
+
+If user selects Yes or Dry-run, invoke the adaptive-harness skill with the analysis results as context. The project profile generated by analysis feeds directly into adaptive-harness optimization.
+
+## Integration
+
+| Skill | Integration |
+|-------|-------------|
+| adaptive-harness | Called after analysis to optimize harness based on detected stack |
+
+## Example Invocation
+
+```
+/analysis
+/analysis --dry-run
+/analysis --verbose
+/analysis --dry-run --verbose
+```
+
+## Notes
+
+- Always run `--dry-run` first on unfamiliar projects to preview changes
+- Agents and skills are additive only — existing items are never removed automatically
+- For stacks not in the detection table, delegate to `mgr-creator` for dynamic agent creation
+- Rules are never auto-removed; they are project-universal

package/templates/.claude/skills/audit-agents/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: omcodex:audit-agents
+description: Audit agent dependencies and references
+scope: harness
+argument-hint: "[agent-name] [--all] [--fix]"
+user-invocable: true
+---
+
+# Audit Agents Skill
+
+Audit agent dependencies to ensure all skill and guide references are valid and symlinks are working.
+
+## Options
+
+```
+--all, -a        Audit all agents
+--verbose, -v    Show detailed results
+--fix            Auto-fix issues (delegates to /fix-refs)
+```
+
+## Workflow
+
+```
+1. Load agent configuration
+   └── Read agent .md file
+
+2. Check skills
+   ├── Skill exists in .codex/skills/
+   └── Skill path is valid
+
+3. Check guides
+   ├── Guide exists in templates/guides/
+   └── Guide path is valid
+
+4. Report results
+```
+
+## Output Format
+
+### Single Agent
+```
+[mgr-supplier:audit lang-golang-expert]
+
+Auditing: lang-golang-expert
+
+Skills:
+  ✓ go-best-practices
+    Path: .codex/skills/go-best-practices/
+    Status: Valid
+
+Guides:
+  ✓ golang
+    Path: templates/guides/golang/
+    Status: Valid
+
+Summary:
+  Skills: 1/1 valid
+  Guides: 1/1 valid
+  Status: HEALTHY
+```
+
+### All Agents
+```
+[mgr-supplier:audit --all]
+
+Auditing all agents...
+
+sw-engineer:
+  ✓ lang-golang-expert      (2/2 deps valid)
+  ✓ lang-python-expert      (2/2 deps valid)
+  ✓ lang-rust-expert        (2/2 deps valid)
+  ✗ lang-kotlin-expert      (1/2 deps valid)
+    └─ Missing: kotlin guide symlink
+
+sw-engineer/backend:
+  ✓ be-fastapi-expert     (2/2 deps valid)
+  ✓ be-springboot-expert  (2/2 deps valid)
+  ✓ be-go-backend-expert  (2/2 deps valid)
+
+infra-engineer:
+  ✓ infra-docker-expert      (2/2 deps valid)
+  ✓ infra-aws-expert         (2/2 deps valid)
+
+Summary:
+  Total agents: 15
+  Healthy: 14
+  Issues: 1
+
+Run "mgr-supplier:fix lang-kotlin-expert" to fix issues.
+```
+
+### Verbose Output
+```
+[mgr-supplier:audit lang-golang-expert --verbose]
+
+Auditing: lang-golang-expert
+
+Configuration:
+  Path: .codex/agents/lang-golang-expert.md
+  Type: sw-engineer
+  Source: internal
+
+Declared Skills:
+  [1] go-best-practices
+      Path: .codex/skills/go-best-practices/
+      Exists: ✓
+
+Declared Guides:
+  [1] golang
+      Path: templates/guides/golang/
+      Exists: ✓
+
+Cross-references:
+  ✓ go-best-practices.used_by includes lang-golang-expert
+  ✓ golang.used_by includes lang-golang-expert
+
+Status: HEALTHY (all checks passed)
+```

package/templates/.claude/skills/aws-best-practices/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: aws-best-practices
+description: AWS patterns from Well-Architected Framework
+scope: core
+user-invocable: false
+---
+
+## Purpose
+
+Apply AWS patterns for building scalable, secure, and cost-effective cloud infrastructure.
+
+## Well-Architected Framework Pillars
+
+### 1. Operational Excellence
+
+```yaml
+principles:
+  - Perform operations as code
+  - Make frequent, small, reversible changes
+  - Refine operations procedures frequently
+  - Anticipate failure
+  - Learn from all operational failures
+
+practices:
+  - Use CloudFormation/CDK for IaC
+  - Implement CI/CD pipelines
+  - Use CloudWatch for monitoring
+  - Set up alarms and dashboards
+  - Document runbooks
+```
+
+### 2. Security
+
+```yaml
+principles:
+  - Implement strong identity foundation
+  - Enable traceability
+  - Apply security at all layers
+  - Automate security best practices
+  - Protect data in transit and at rest
+  - Keep people away from data
+  - Prepare for security events
+
+iam:
+  - Use least privilege principle
+  - Never use root account for daily tasks
+  - Enable MFA for all users
+  - Use IAM roles for services
+  - Rotate credentials regularly
+
+patterns: |
+  # IAM Policy - Least Privilege
+  {
+    "Version": "2012-10-17",
+    "Statement": [{
+      "Effect": "Allow",
+      "Action": [
+        "s3:GetObject",
+        "s3:PutObject"
+      ],
+      "Resource": "arn:aws:s3:::my-bucket/*",
+      "Condition": {
+        "IpAddress": {
+          "aws:SourceIp": "10.0.0.0/8"
+        }
+      }
+    }]
+  }
+```
+
+### 3. Reliability
+
+```yaml
+principles:
+  - Automatically recover from failure
+  - Test recovery procedures
+  - Scale horizontally
+  - Stop guessing capacity
+  - Manage change through automation
+
+practices:
+  - Multi-AZ deployments
+  - Auto Scaling groups
+  - Health checks and self-healing
+  - Backup and disaster recovery
+  - Loose coupling with queues
+
+patterns:
+  high_availability: |
+    # Multi-AZ RDS
+    - Primary in us-east-1a
+    - Standby in us-east-1b
+    - Read replicas in us-east-1c
+
+  auto_scaling: |
+    # Target tracking scaling
+    - Metric: CPUUtilization
+    - Target: 70%
+    - Min: 2, Max: 10
+```
+
+### 4. Performance Efficiency
+
+```yaml
+principles:
+  - Democratize advanced technologies
+  - Go global in minutes
+  - Use serverless architectures
+  - Experiment more often
+  - Consider mechanical sympathy
+
+compute:
+  - Right-size instances
+  - Use Spot for fault-tolerant workloads
+  - Consider Graviton (ARM) processors
+  - Containerize with ECS/EKS
+
+storage:
+  - Use appropriate storage class
+  - S3 Intelligent-Tiering for variable access
+  - EBS volume types based on IOPS needs
+
+database:
+  - Aurora for MySQL/PostgreSQL
+  - DynamoDB for key-value/document
+  - ElastiCache for caching
+```
+
+### 5. Cost Optimization
+
+```yaml
+principles:
+  - Implement cloud financial management
+  - Adopt consumption model
+  - Measure overall efficiency
+  - Stop spending on undifferentiated heavy lifting
+  - Analyze and attribute expenditure
+
+practices:
+  - Use Reserved Instances/Savings Plans
+  - Right-size resources
+  - Delete unused resources
+  - Use Spot Instances
+  - Implement auto scaling
+
+tools:
+  - AWS Cost Explorer
+  - AWS Budgets
+  - AWS Trusted Advisor
+  - Cost Allocation Tags
+```
+
+### 6. Sustainability
+
+```yaml
+principles:
+  - Understand your impact
+  - Establish sustainability goals
+  - Maximize utilization
+  - Anticipate and adopt more efficient offerings
+  - Use managed services
+  - Reduce downstream impact
+
+practices:
+  - Use efficient instance types (Graviton)
+  - Optimize storage lifecycle
+  - Use serverless where possible
+  - Select regions with lower carbon intensity
+```
+
+## Common Patterns
+
+### VPC Design
+
+```yaml
+pattern: |
+  VPC (10.0.0.0/16)
+  ├── Public Subnets
+  │   ├── us-east-1a: 10.0.1.0/24
+  │   ├── us-east-1b: 10.0.2.0/24
+  │   └── us-east-1c: 10.0.3.0/24
+  ├── Private Subnets (App)
+  │   ├── us-east-1a: 10.0.11.0/24
+  │   ├── us-east-1b: 10.0.12.0/24
+  │   └── us-east-1c: 10.0.13.0/24
+  └── Private Subnets (Data)
+      ├── us-east-1a: 10.0.21.0/24
+      ├── us-east-1b: 10.0.22.0/24
+      └── us-east-1c: 10.0.23.0/24
+
+components:
+  - Internet Gateway (public access)
+  - NAT Gateway (private outbound)
+  - VPC Endpoints (AWS services)
+  - Network ACLs (subnet level)
+  - Security Groups (instance level)
+```
+
+### Three-Tier Architecture
+
+```yaml
+pattern: |
+  [Internet]
+      │
+  [CloudFront]
+      │
+  [ALB] ← Public Subnet
+      │
+  [ECS/EC2] ← Private Subnet (App)
+      │
+  [RDS Multi-AZ] ← Private Subnet (Data)
+
+components:
+  web_tier:
+    - CloudFront for CDN
+    - WAF for protection
+    - ALB for load balancing
+
+  app_tier:
+    - ECS Fargate or EC2
+    - Auto Scaling
+    - ElastiCache
+
+  data_tier:
+    - RDS Multi-AZ
+    - Read Replicas
+    - Automated backups
+```
+
+### Serverless Pattern
+
+```yaml
+pattern: |
+  [API Gateway]
+      │
+  [Lambda] → [DynamoDB]
+      │
+  [SQS] → [Lambda] → [S3]
+
+components:
+  - API Gateway for REST/HTTP APIs
+  - Lambda for compute
+  - DynamoDB for NoSQL
+  - SQS for decoupling
+  - S3 for storage
+  - Step Functions for orchestration
+```
+
+### CI/CD Pipeline
+
+```yaml
+pattern: |
+  [CodeCommit/GitHub]
+      │
+  [CodePipeline]
+      │
+  ├── [CodeBuild] - Build & Test
+  │
+  ├── [ECR] - Container Registry
+  │
+  └── [CodeDeploy/ECS] - Deploy
+
+practices:
+  - Blue/Green deployments
+  - Canary releases
+  - Automated rollback
+  - Infrastructure as Code
+```
+
+## Application
+
+When designing AWS architecture:
+
+1. **Always** follow least privilege for IAM
+2. **Always** use Multi-AZ for production
+3. **Always** encrypt data at rest and in transit
+4. **Prefer** managed services over self-managed
+5. **Implement** monitoring and alerting
+6. **Use** IaC for all infrastructure
+7. **Design** for failure
+8. **Optimize** costs continuously

package/templates/.claude/skills/claude-code-bible/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: claude-code-bible
+description: Fetch Claude Code official documentation. Use when updating local reference docs or checking official spec.
+scope: core
+disable-model-invocation: true
+user-invocable: false
+---
+
+# Claude Code Bible
+
+Official documentation reference management for Claude Code.
+
+## Purpose
+
+Maintain up-to-date local copies of Claude Code official documentation.
+
+## Commands
+
+### /claude-code-bible update
+
+Fetch the latest documentation from code.claude.com.
+
+**What it does:**
+- Fetches `https://code.claude.com/docs/llms.txt`
+- Extracts all documentation URLs from the llms.txt content
+- Downloads each documentation page and saves as markdown
+- Writes a timestamp file for cache tracking
+- Respects a 24-hour cache (skip if fresh, unless `--force` used)
+
+**Usage:**
+```bash
+# Fetch latest docs (skip if cached < 24h)
+node .codex/skills/claude-code-bible/scripts/fetch-docs.js
+
+# Force update even if cache is fresh
+node .codex/skills/claude-code-bible/scripts/fetch-docs.js --force
+
+# Custom output directory
+node .codex/skills/claude-code-bible/scripts/fetch-docs.js --output /path/to/output
+```
+
+**Default output location:**
+```
+~/.codex/references/claude-code/
+├── llms.txt              # Master index
+├── last-updated.txt      # ISO timestamp
+├── <doc-name>.md         # Individual doc pages
+└── ...
+```
+
+**Exit codes:**
+- `0`: Success (or cache is fresh)
+- `1`: Fatal error
+
+## Implementation Notes
+
+### Fetch Script (fetch-docs.js)
+
+**Features:**
+- Uses only Node.js built-in modules (https, fs, path)
+- Handles HTTP redirects (3xx responses)
+- Respects server with 200ms delay between requests
+- 24-hour cache to avoid unnecessary fetches
+- Comprehensive error reporting
+
+**Cache behavior:**
+- Checks `last-updated.txt` timestamp
+- Skips fetch if < 24 hours old (unless --force)
+- Always updates timestamp on successful fetch
+
+**Error handling:**
+- Reports HTTP errors with status codes
+- Continues on individual page failures
+- Prints summary of successes and failures
+
+## Integration with Other Skills
+
+### update-docs
+- Should update local docs first: `/claude-code-bible update`
+
+### dev-review
+- Can reference official docs for best practices
+
+## Benefits
+
+1. **Up-to-date**: Always have latest documentation locally
+2. **Offline access**: Work with docs even without internet
+3. **Learning**: Reference official patterns when creating new components
+
+## Notes
+
+- The fetch script is production-ready and can be used immediately
+- Consider running `/claude-code-bible update` weekly to stay current