oh-my-customcode 0.8.0 → 0.9.0

package/templates/.codex/install-hooks.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+# Claude Code Hooks & Contexts Installer
+# Source: https://github.com/affaan-m/everything-claude-code
+# Hook installation script
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CLAUDE_HOME="${HOME}/.codex"
+SETTINGS_FILE="${CLAUDE_HOME}/settings.json"
+
+echo "┌─────────────────────────────────────────────┐"
+echo "│  Claude Code Hooks & Contexts Installer     │"
+echo "└─────────────────────────────────────────────┘"
+echo ""
+
+# Create directories
+echo "[1/5] Creating directories..."
+mkdir -p "${CLAUDE_HOME}/hooks/memory-persistence"
+mkdir -p "${CLAUDE_HOME}/hooks/strategic-compact"
+mkdir -p "${CLAUDE_HOME}/sessions"
+mkdir -p "${CLAUDE_HOME}/skills/learned"
+mkdir -p "${CLAUDE_HOME}/contexts"
+echo "      ✓ Directories created"
+
+# Copy scripts
+echo "[2/5] Copying hook scripts..."
+cp "${SCRIPT_DIR}/hooks/memory-persistence/"*.sh "${CLAUDE_HOME}/hooks/memory-persistence/"
+cp "${SCRIPT_DIR}/hooks/strategic-compact/"*.sh "${CLAUDE_HOME}/hooks/strategic-compact/"
+echo "      ✓ Scripts copied"
+
+# Copy contexts
+echo "[3/5] Copying context files..."
+cp "${SCRIPT_DIR}/contexts/"*.md "${CLAUDE_HOME}/contexts/"
+echo "      ✓ Contexts copied"
+
+# Set permissions
+echo "[4/5] Setting execute permissions..."
+chmod +x "${CLAUDE_HOME}/hooks/memory-persistence/"*.sh
+chmod +x "${CLAUDE_HOME}/hooks/strategic-compact/"*.sh
+echo "      ✓ Permissions set"
+
+# Handle settings.json
+echo "[5/5] Configuring settings.json..."
+
+if [ -f "$SETTINGS_FILE" ]; then
+  # Backup existing settings
+  BACKUP_FILE="${SETTINGS_FILE}.backup.$(date +%Y%m%d_%H%M%S)"
+  cp "$SETTINGS_FILE" "$BACKUP_FILE"
+  echo "      ✓ Backed up existing settings to: $BACKUP_FILE"
+
+  # Check if jq is available for merging
+  if command -v jq &> /dev/null; then
+    # Merge hooks into existing settings
+    HOOKS_JSON="${SCRIPT_DIR}/hooks/hooks.json"
+    TEMP_FILE=$(mktemp)
+
+    # Extract hooks from hooks.json and merge with existing settings
+    jq -s '.[0] * .[1]' "$SETTINGS_FILE" "$HOOKS_JSON" > "$TEMP_FILE"
+    mv "$TEMP_FILE" "$SETTINGS_FILE"
+    echo "      ✓ Merged hooks into settings.json"
+  else
+    echo "      ⚠ jq not found. Please manually merge hooks."
+    echo "      Copy content from: ${SCRIPT_DIR}/hooks/hooks.json"
+    echo "      Into: ${SETTINGS_FILE}"
+  fi
+else
+  # Create new settings.json from hooks.json
+  cp "${SCRIPT_DIR}/hooks/hooks.json" "$SETTINGS_FILE"
+  echo "      ✓ Created new settings.json"
+fi
+
+echo ""
+echo "┌─────────────────────────────────────────────┐"
+echo "│  Installation Complete!                     │"
+echo "└─────────────────────────────────────────────┘"
+echo ""
+echo "Installed to: ${CLAUDE_HOME}/"
+echo ""
+echo "Structure:"
+echo "  ~/.codex/"
+echo "  ├── settings.json          (hooks config)"
+echo "  ├── hooks/"
+echo "  │   ├── memory-persistence/"
+echo "  │   │   ├── pre-compact.sh"
+echo "  │   │   ├── session-start.sh"
+echo "  │   │   └── session-end.sh"
+echo "  │   └── strategic-compact/"
+echo "  │       └── suggest-compact.sh"
+echo "  ├── contexts/"
+echo "  │   ├── dev.md"
+echo "  │   ├── review.md"
+echo "  │   └── research.md"
+echo "  ├── sessions/              (auto-created logs)"
+echo "  └── skills/learned/        (for future use)"
+echo ""
+echo "Next steps:"
+echo "  1. Restart Claude Code to activate hooks"
+echo "  2. Use contexts by referencing them in prompts"
+echo ""

package/templates/.codex/rules/MAY-optimization.md

@@ -0,0 +1,93 @@
+# [MAY] Optimization Guide
+
+> **Priority**: MAY - Optional
+> **Apply when**: Basic functionality is stable
+
+## Efficiency Optimization
+
+### Parallel Processing
+```
+Apply when:
+- 3+ independent tasks
+- Each task is I/O bound
+
+Example:
+- Read multiple files simultaneously
+- Run independent searches in parallel
+```
+
+### Caching
+```
+Apply when:
+- Same data accessed repeatedly
+- Data changes infrequently
+
+Example:
+- Cache file contents
+- Reuse search results
+```
+
+### Lazy Loading
+```
+Apply when:
+- Large datasets
+- Only portion actually used
+
+Example:
+- Read only needed files
+- Stream results
+```
+
+## Token Optimization
+
+### Context Management
+```
+✓ Include only necessary info
+✓ Remove duplicates
+✓ Use summaries
+```
+
+### Response Optimization
+```
+✓ Concise expressions
+✓ Minimize code blocks
+✓ Remove unnecessary repetition
+```
+
+## Task Optimization
+
+### Batch Processing
+```
+Group similar tasks together
+Example: Edit 10 files → Process at once
+```
+
+### Incremental Processing
+```
+Process only changed parts
+Example: Full build → Incremental build
+```
+
+## Apply Criteria
+
+### Do Optimize
+```
+✓ Repetitive tasks
+✓ Clear performance bottleneck
+✓ Measurable improvement
+```
+
+### Don't Optimize
+```
+✗ One-time tasks
+✗ Already fast enough
+✗ Complexity increase outweighs benefit
+```
+
+## Caution
+
+```
+⚠ Premature optimization is root of evil
+⚠ Readability > Optimization
+⚠ No optimization without measurement
+```

package/templates/.codex/rules/MUST-agent-design.md

@@ -0,0 +1,162 @@
+# [MUST] Agent Design Rules
+
+> **Priority**: MUST - Never violate
+> **ID**: R006
+
+## Agent Structure
+
+### Single File Format
+```
+.codex/agents/{name}.md
+
+Format:
+---
+name: agent-name
+description: Brief agent description
+model: sonnet | opus | haiku
+memory: project            # Optional
+tools:
+  - Read
+  - Write
+  - Bash
+skills:
+  - skill-name-1
+  - skill-name-2
+---
+
+# Agent Content
+
+Agent purpose and role description...
+```
+
+### Frontmatter Fields (REQUIRED)
+```yaml
+name: agent-name           # Unique identifier (kebab-case)
+description: Brief desc    # One-line summary
+model: sonnet             # Default model (sonnet | opus | haiku)
+memory: project           # Persistent memory scope (user | project | local)
+effort: high              # Effort level (low | medium | high)
+tools: [Read, Write, ...]  # Allowed tools
+skills: [skill-1, ...]     # Required skill names
+```
+
+### Memory Scope Reference
+| Scope | Location | Use Case |
+|-------|----------|----------|
+| `user` | `~/.codex/agent-memory/<name>/` | Cross-project learnings (infra, db) |
+| `project` | `.codex/agent-memory/<name>/` | Project-specific, versioned |
+| `local` | `.codex/agent-memory-local/<name>/` | Project-specific, not versioned |
+
+### Effort Level Reference
+| Level | Use Case | Agents |
+|-------|----------|--------|
+| `high` | Complex reasoning, design decisions | lang-*, be-*, arch-*, qa-planner |
+| `medium` | Routine operations, structured work | fe-*, tool-*, mgr-gitnerd |
+| `low` | Simple validation, file scanning | mgr-supplier, mgr-sync-checker, sys-naggy |
+
+### Agent Content Must NOT Contain
+```
+✗ Detailed skill instructions (use .codex/skills/ instead)
+✗ Reference documentation (use guides/ instead)
+✗ Implementation scripts (use .codex/skills/{name}/scripts/ instead)
+```
+
+### Agent Content Should Contain
+```
+✓ Agent purpose and role
+✓ Capabilities overview (not details)
+✓ Required skills (by name reference)
+✓ Workflow description
+✓ Source info (if external)
+```
+
+## Memory Scope (OPTIONAL)
+
+Agents can have persistent memory that survives across conversations.
+
+| Scope | Location | Use Case | Git Tracked |
+|-------|----------|----------|-------------|
+| `user` | `~/.codex/agent-memory/<name>/` | Cross-project learnings (infra, DB patterns) | No |
+| `project` | `.codex/agent-memory/<name>/` | Project-specific patterns | Yes |
+| `local` | `.codex/agent-memory-local/<name>/` | Local-only knowledge | No |
+
+When enabled:
+- First 200 lines of MEMORY.md loaded into agent's system prompt
+- Read/Write/Edit tools automatically enabled for memory directory
+- Agent builds knowledge across conversations
+
+Agents that should NOT have memory (stateless by design):
+- Manager agents for one-time operations (mgr-creator, mgr-updater, mgr-supplier)
+- Validation agents (mgr-sync-checker, mgr-claude-code-bible)
+- Meta-agents (sys-memory-keeper, sys-naggy)
+
+## External Agent Requirements
+
+External agents (from GitHub, npm, etc.) MUST include source information in frontmatter:
+
+### Frontmatter Source Fields
+```yaml
+source:
+  type: external
+  origin: github | npm | other
+  url: https://github.com/org/repo
+  version: 1.0.0
+  last_updated: 2025-01-22
+  update_command: "npx add-skill org/repo"
+```
+
+### Update Tracking
+```
+- version: Current version installed
+- last_updated: Date of last sync
+- update_command: Command to update
+- changelog_url: Where to check updates
+```
+
+## Separation of Concerns
+
+### .codex/agents/
+```
+Purpose: Define WHAT the agent does
+Content: Role, capabilities, workflow
+Format: Single .md file with YAML frontmatter
+NOT: How to do it (that's skills/)
+```
+
+### .codex/skills/
+```
+Purpose: Define HOW to do tasks
+Content: Instructions, scripts, rules
+Location: .codex/skills/{name}/SKILL.md
+```
+
+### guides/
+```
+Purpose: Reference documentation
+Content: Best practices, tutorials
+Location: guides/{topic}/
+```
+
+## Agent → Skill References
+
+### In Frontmatter
+```yaml
+---
+name: agent-name
+skills:
+  - react-best-practices
+  - web-design-guidelines
+---
+```
+
+Skills are referenced by name only. The system automatically discovers skills in `.codex/skills/` by scanning for `SKILL.md` files.
+
+## Naming Conventions
+
+| Type | Pattern | Example |
+|------|---------|---------|
+| Agent file | `kebab-case.md` | `.codex/agents/fe-vercel-agent.md` |
+| Skill directory | `kebab-case/` | `.codex/skills/react-best-practices/` |
+| Guide directory | `kebab-case/` | `guides/web-design/` |
+| Agent filename | lowercase | `{name}.md` |
+| Skill file | UPPERCASE | `SKILL.md` |

package/templates/.codex/rules/MUST-agent-identification.md

@@ -0,0 +1,108 @@
+# [MUST] Agent Identification Rules
+
+> **Priority**: MUST - ENFORCED, NO EXCEPTIONS
+> **ID**: R007
+> **Violation**: Immediate correction required
+
+## CRITICAL
+
+**EVERY response MUST start with agent identification. This is NON-NEGOTIABLE.**
+
+Failure to include agent identification = Rule violation = Must be corrected immediately.
+
+## Purpose
+
+Display which agent is responding and which skills are being used for transparency and traceability.
+
+## Response Header Format
+
+Every response MUST start with an agent identification block:
+
+```
+┌─ Agent: {agent-name} ({agent-type})
+├─ Skill: {skill-name} (if applicable)
+└─ Task: {brief-task-description}
+```
+
+## Examples
+
+### Single Agent Response
+```
+┌─ Agent: mgr-creator (manager)
+└─ Task: Creating new agent
+
+[Response content...]
+```
+
+### With Skill Usage
+```
+┌─ Agent: fe-vercel-agent (worker)
+├─ Skill: react-best-practices
+└─ Task: Optimizing React component
+
+[Response content...]
+```
+
+### Multiple Skills
+```
+┌─ Agent: fe-vercel-agent (worker)
+├─ Skills: react-best-practices, web-design-guidelines
+└─ Task: Full code review
+
+[Response content...]
+```
+
+### No Specific Agent (Default)
+```
+┌─ Agent: claude (default)
+└─ Task: General assistance
+
+[Response content...]
+```
+
+## When to Display
+
+| Situation | Display |
+|-----------|---------|
+| Agent-specific task | Full header with agent |
+| Using skill | Include skill name |
+| General conversation | "claude (default)" |
+| Multiple agents | Show primary agent |
+
+## Agent Types
+
+| Type | Symbol | Example |
+|------|--------|---------|
+| manager | 🔧 | mgr-creator, mgr-updater |
+| worker | ⚙️ | fe-vercel-agent |
+| orchestrator | 🎯 | (future) |
+| default | 💬 | claude |
+
+## Simplified Format (Optional)
+
+For brief responses, use inline format:
+
+```
+[mgr-creator] Creating agent structure...
+```
+
+Or with skill:
+
+```
+[fe-vercel-agent → react-best-practices] Analyzing performance...
+```
+
+## Status Updates
+
+During long tasks, show progress with agent context:
+
+```
+┌─ Agent: mgr-updater (manager)
+└─ Task: Checking external updates
+
+[Progress] Scanning .codex/agents/ (1/3)
+[Progress] Scanning .codex/skills/ (2/3)
+[Progress] Scanning .codex/guides/ (3/3)
+
+[Done] Found 2 updates available
+```

package/templates/.codex/rules/MUST-continuous-improvement.md

@@ -0,0 +1,132 @@
+# [MUST] Continuous Improvement Rules
+
+> **Priority**: MUST - Top-level enforcement
+> **ID**: R016
+> **Trigger**: User points out rule violation
+
+## CRITICAL
+
+**When user points out a rule violation, you MUST update the rules to prevent future violations BEFORE continuing with the task.**
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  WHEN USER POINTS OUT A VIOLATION:                               ║
+║                                                                   ║
+║  1. STOP current task immediately                                ║
+║  2. UPDATE the relevant rule to be clearer/stronger              ║
+║  3. COMMIT the rule update                                       ║
+║  4. THEN continue with the original task                         ║
+║                                                                   ║
+║  DO NOT just apologize and continue.                             ║
+║  DO NOT promise to do better next time.                          ║
+║  ACTUALLY UPDATE THE RULES.                                      ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+## Workflow
+
+```
+User points out violation
+         │
+         ▼
+┌─────────────────────────┐
+│ 1. Acknowledge violation │
+└───────────┬─────────────┘
+            │
+            ▼
+┌─────────────────────────┐
+│ 2. Identify root cause   │
+│    - Which rule was weak?│
+│    - What was unclear?   │
+└───────────┬─────────────┘
+            │
+            ▼
+┌─────────────────────────┐
+│ 3. Update the rule       │
+│    - Add clarity         │
+│    - Add examples        │
+│    - Add self-checks     │
+└───────────┬─────────────┘
+            │
+            ▼
+┌─────────────────────────┐
+│ 4. Commit the change     │
+└───────────┬─────────────┘
+            │
+            ▼
+┌─────────────────────────┐
+│ 5. Continue original task│
+│    (now following rules) │
+└─────────────────────────┘
+```
+
+## Examples
+
+### Example 1: Parallel Execution Violation
+
+```
+User: "병렬 실행을 안 지킨거 아닌가?"
+
+WRONG Response:
+  "맞습니다, 죄송합니다. 다음부터 잘 지키겠습니다."
+  [continues task without updating rules]
+
+CORRECT Response:
+  1. "맞습니다. R009 위반입니다."
+  2. [Updates MUST-parallel-execution.md with clearer guidance]
+  3. [Commits the update]
+  4. [Continues task with proper parallel execution]
+```
+
+### Example 2: Wrong Agent Used
+
+```
+User: "mgr-creator 에이전트를 써야 하는거 아닌가?"
+
+WRONG Response:
+  "맞습니다. mgr-creator를 사용하겠습니다."
+  [continues without updating rules]
+
+CORRECT Response:
+  1. "맞습니다. R010 위반입니다."
+  2. [Updates relevant rules to clarify agent delegation]
+  3. [Commits the update]
+  4. [Continues with proper agent delegation]
+```
+
+## Why This Matters
+
+```
+Without rule updates:
+  Violation → Apology → Same mistake later → Apology → ...
+
+With rule updates:
+  Violation → Rule improvement → Better behavior → Learning preserved
+```
+
+1. **Institutional Memory**: Rules capture learnings permanently
+2. **Prevents Recurrence**: Clearer rules = fewer future violations
+3. **Continuous Improvement**: System gets better over time
+4. **Accountability**: Actions, not just words
+
+## Integration with Other Rules
+
+This rule takes precedence when violations are pointed out:
+
+| Situation | Action |
+|-----------|--------|
+| User points out violation | STOP → Update rule → Continue |
+| Self-detected violation | Fix immediately, consider rule update |
+| Ambiguous situation | Ask user, then update if needed |
+
+## Enforcement
+
+```
+Violation of this rule = Ignoring user feedback = Unacceptable
+
+When caught violating this rule:
+1. Stop immediately
+2. Update THIS rule to be even clearer
+3. Update the ORIGINAL violated rule
+4. Continue with proper behavior
+```