oh-my-customcodex 0.1.0

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

@@ -0,0 +1,88 @@
+---
+name: idea
+description: Analyze a natural language idea against the project codebase and return structured issue specs
+scope: core
+version: 1.0.0
+user-invocable: true
+argument-hint: "<idea text>"
+---
+
+# /idea — Natural Language Idea Analysis
+
+Analyze a natural language idea against the current project's codebase, assess feasibility and scope, and return structured JSON that can be turned into one or more GitHub issues.
+
+## Usage
+
+```
+/idea Add OAuth login with Google and GitHub providers
+/idea Add a monitoring dashboard to the Discord bot
+```
+
+## Output Contract
+
+Return structured JSON only:
+
+```json
+{
+  "title": "Short feature title",
+  "scope": "S|M|L",
+  "estimatedIssues": 1,
+  "summary": "One-paragraph summary",
+  "details": {
+    "problem": "What user or system problem this addresses",
+    "approach": "Recommended technical approach",
+    "touchedAreas": ["src/module-a", "docs/guide-x"],
+    "risks": ["migration risk", "auth edge cases"],
+    "dependencies": ["issue-123", "external-api"]
+  },
+  "issueSpecs": [
+    {
+      "title": "Implement core feature slice",
+      "priority": "P1|P2|P3",
+      "body": "Markdown issue body"
+    }
+  ]
+}
+```
+
+## Workflow
+
+### Phase 1: Parse Input
+
+1. Extract the core intent from the natural language idea
+2. Normalize it into a concrete product or engineering change
+3. If the request is too vague, state assumptions explicitly in the JSON summary
+
+### Phase 2: Codebase Analysis
+
+1. `Read(AGENTS.md)` to understand the project contract
+2. `Read(README.md)` and relevant docs for product/system context
+3. Use `Glob` and `Grep` to find likely touched files, modules, and patterns
+4. Identify overlap with existing features to avoid duplicate issue creation
+
+### Phase 3: Feasibility Assessment
+
+Assess:
+- implementation scope (`S`, `M`, `L`)
+- likely modules to change
+- architectural or migration risk
+- whether the idea should be one issue or decomposed into multiple issues
+
+### Phase 4: Issue Spec Generation
+
+Generate:
+- one concise top-level title
+- a short summary
+- one or more issue specs with priority and actionable markdown bodies
+
+## Heuristics
+
+- Prefer decomposition when the idea spans UI + API + infra
+- Prefer a single issue when the change is local and independently shippable
+- Reuse project terminology found in AGENTS.md/README/docs
+- Keep issue bodies implementation-oriented, not marketing-oriented
+
+## Notes
+
+- This skill is analysis-first: it produces issue-ready output, but it does not create GitHub issues by itself
+- Downstream tooling such as builder-factory or a human operator can take the JSON and create the actual issues

package/templates/.claude/skills/impeccable-design/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: impeccable-design
+description: AI design language for production-grade UI — 10 commands covering typography, color, motion, layout, and UX writing quality
+scope: core
+user-invocable: false
+version: 1.0.0
+source:
+  type: external
+  origin: github
+  url: https://github.com/pbakaus/impeccable
+---
+
+## Purpose
+
+Impeccable is a design language for producing intentional, production-grade UI. It defines a vocabulary of steering commands that guide an AI toward specific design dimensions — typography, color, motion, layout, and UX writing — while actively avoiding the generic patterns associated with AI-generated interfaces.
+
+## Commands
+
+### 10 Selected Commands
+
+| Command | Trigger phrases | Description |
+|---------|----------------|-------------|
+| **critique** | "review design", "UX feedback" | UX design review: hierarchy, clarity, emotional resonance, and intentionality across the interface |
+| **audit** | "design audit", "quality check" | Systematic quality checks across all design dimensions simultaneously |
+| **typeset** | "fix fonts", "typography" | Fix font choices, weight contrast, scale, line-height, tracking, and type pairing |
+| **colorize** | "add color", "color palette" | Introduce strategic color using OKLCH; construct tinted neutral palettes, avoid pure black/white |
+| **animate** | "add motion", "animation" | Add purposeful motion using the 100ms/300ms/500ms rule; eliminate decorative or distracting animation |
+| **normalize** | "align design system" | Align output with design system standards: spacing scales, token usage, component consistency |
+| **polish** | "final pass", "ship ready" | Pre-ship quality sweep across all design dimensions, including AI slop test |
+| **clarify** | "improve copy", "UX writing" | Improve UX copy: labels, microcopy, empty states, error messages, button specificity |
+| **arrange** | "fix layout", "spacing" | Fix layout structure, whitespace, alignment, and visual rhythm |
+| **adapt** | "responsive", "mobile" | Adapt design decisions for different devices, screen sizes, and input modes |
+
+### Command Detail
+
+#### critique
+Holistic UX review. Evaluates information hierarchy, interaction clarity, emotional resonance, and whether design decisions feel intentional. Surfaces both friction points and missed opportunities. Output: prioritized list of issues with impact level (critical / moderate / minor).
+
+#### audit
+Systematic multi-dimension check. Runs all other command lenses in sequence and produces a structured report. Use when you need a full picture before starting work. Output: dimension-by-dimension audit with specific findings.
+
+#### typeset
+Typography repair. Evaluates and fixes:
+- Font family selection (avoid default Inter/Roboto/Arial without rationale)
+- Type scale (use modular scale, not arbitrary pixel sizes)
+- Weight contrast (body vs. heading vs. label differentiation)
+- Line-height and measure (optimal reading width 60-75 chars)
+- Letter-spacing for display vs. body contexts
+- Font pairing coherence
+
+#### colorize
+Color strategy and implementation using OKLCH. Key principles:
+- Build tinted neutrals (never pure gray — always a 5-10% hue push)
+- Use OKLCH for perceptually uniform lightness steps
+- Establish semantic color roles (primary, surface, on-surface, accent, destructive)
+- Avoid pure black backgrounds; tint with brand hue at low chroma
+- Check color relationships for harmony, not just individual values
+
+#### animate
+Motion design with purpose. Core rule — 100/300/500ms:
+- 100ms: micro-interactions, state transitions (hover, focus, active)
+- 300ms: element entrances, panel transitions, drawer opens
+- 500ms: page transitions, complex sequence animations
+Avoid: bounce/elastic easing as decoration, animation on load without user trigger, looping animations in primary content areas.
+Use: ease-out for entrances, ease-in for exits, linear for progress/loading.
+
+#### normalize
+Design system alignment. Enforces:
+- Spacing scale usage (4/8/12/16/24/32/48/64 or 4pt grid)
+- Border radius consistency (choose a base radius, derive multiples)
+- Shadow scale (0-3 elevation levels, not arbitrary per-component)
+- Color token usage vs. hardcoded values
+- Component variant consistency
+
+#### polish
+Pre-ship quality sweep. Runs: typeset + colorize + arrange + AI slop test + final coherence check. Output includes a ship-readiness verdict (ship / ship with minor fixes / needs work).
+
+#### clarify
+UX writing improvement. Targets:
+- Button labels: specific verbs over generic ("Save changes" not "Submit")
+- Empty states: explain what goes here + clear action to fill it
+- Error messages: say what happened + what to do (not "An error occurred")
+- Tooltips and help text: answer the user's actual question
+- Confirmation dialogs: describe the consequence, not the action
+
+#### arrange
+Layout and spatial design. Fixes:
+- Visual hierarchy via size, weight, and position
+- Negative space: increase breathing room between unrelated groups
+- Alignment: establish a clear grid baseline
+- Proximity: group related elements, separate unrelated ones
+- Visual rhythm: consistent incremental spacing within components
+
+#### adapt
+Responsive and cross-device adaptation:
+- Mobile-first breakpoint strategy
+- Touch target sizing (minimum 44x44px)
+- Content reflow for narrow viewports
+- Progressive disclosure for complex interfaces on mobile
+- Pointer vs. touch interaction mode awareness
+
+## AI Slop Test
+
+The AI Slop Test is a critical checkpoint embedded in every `audit` and `polish` command. It must also be run manually on any design output before declaring it complete.
+
+**The question**: Would someone immediately identify this as AI-generated?
+
+### Patterns to Flag as AI Slop
+
+**Typography slop**
+- Inter, Roboto, or Arial as the default font with no intentional reason stated
+- All text the same weight except headings
+- Line-height exactly 1.5 applied universally regardless of font size
+
+**Color slop**
+- Pure black (`#000000` or `#0d0d0d`) or pure gray (`#f5f5f5`, `#e5e5e5`) backgrounds without tinting
+- One brand color on an otherwise completely neutral palette
+- Blue-purple or coral-orange gradients with no contextual rationale
+
+**Layout slop**
+- Centered-everything layout that avoids making spatial decisions
+- Identical card components with same border-radius, same shadow, and same padding stacked vertically
+- Hero section: gradient blob behind centered heading + subheading + two buttons
+
+**Motion slop**
+- Bounce or elastic easing used as "delight" with no functional purpose
+- Every element animates on page load with staggered delays
+- Hover states that scale to 1.05 on every interactive element
+
+**Copy slop**
+- Empty states: "[Icon] No [items] yet. [Create button]"
+- Error messages: "Something went wrong. Please try again."
+- Buttons: "Submit", "Confirm", "OK"
+- Tooltips: restate the label they're attached to
+
+### Slop Test Verdict
+
+After running the test, assign one of:
+- **Clean**: No slop patterns detected
+- **Mild slop**: 1-2 patterns present, easy to fix
+- **Heavy slop**: 3+ patterns, requires deliberate design work before ship
+
+## Role Separation
+
+This skill operates in the aesthetic/creative layer. It does not replace technical compliance tooling.
+
+| Design Aspect | impeccable-design (this skill) | web-design-guidelines |
+|---------------|-------------------------------|----------------------|
+| Typography | Font selection, pairing, type scale, expressive hierarchy | Minimum font sizes (16px body), contrast ratios |
+| Color | Palette building, OKLCH, tinted neutrals, emotional resonance | WCAG 2.1 AA/AAA contrast compliance |
+| Motion | Purposeful animation, easing curves, timing strategy, felt quality | prefers-reduced-motion compliance, no-animation-on-load |
+| Layout | Visual rhythm, spatial design, negative space, hierarchy | Accessibility, semantic HTML structure, ARIA landmarks |
+| Copy | Tone, clarity, specificity, label quality | (no overlap) |
+
+**When both apply**: Run `impeccable-design` for aesthetic quality, then `web-design-guidelines` for compliance. They are complementary, not competing.
+
+## Reference Guides
+
+- `guides/impeccable-design/typography.md` — type scale construction, font pairing strategy, hierarchy patterns
+- `guides/impeccable-design/color-and-contrast.md` — OKLCH primer, tinted neutral construction, palette strategy
+- `guides/impeccable-design/motion-design.md` — 100/300/500ms rule, easing reference, purposeful vs. decorative motion
+- `guides/impeccable-design/ux-writing.md` — microcopy patterns, empty state templates, error message formulas
+
+## Execution Flow
+
+```
+1. Identify active command(s) from trigger phrase or explicit instruction
+2. Read target component/page files
+3. Consult relevant reference guides for the active command
+4. Apply changes with explicit rationale for each decision
+5. Run AI Slop Test on output
+6. Report: changes made + slop test verdict + any deferred items
+```

package/templates/.claude/skills/intent-detection/SKILL.md

@@ -0,0 +1,293 @@
+---
+name: intent-detection
+description: Automatically detect user intent and route to appropriate agent
+scope: core
+user-invocable: false
+---
+
+## Purpose
+
+Automatically detect user intent and route to the appropriate agent with full transparency.
+
+## Detection Algorithm
+
+### 1. Input Analysis
+
+```
+User Input: "Go 코드 리뷰해줘"
+            │
+            ▼
+┌─────────────────────────────┐
+│  Tokenize & Extract         │
+├─────────────────────────────┤
+│  Keywords: ["Go"]           │
+│  Actions: ["리뷰"]          │
+│  File refs: []              │
+│  Context: []                │
+└─────────────────────────────┘
+```
+
+### 2. Pattern Matching
+
+Match extracted tokens against agent triggers:
+
+```yaml
+# For each agent in agent-triggers.yaml
+match_score = 0
+
+# Keyword match
+for keyword in user_keywords:
+  if keyword in agent.keywords:
+    match_score += agent.keyword_weight (default: 40)
+
+# Action match
+for action in user_actions:
+  if action in agent.actions:
+    match_score += agent.action_weight (default: 40)
+
+# File pattern match
+for pattern in user_file_refs:
+  if matches(pattern, agent.file_patterns):
+    match_score += agent.file_weight (default: 30)
+
+# Context bonus
+if agent == recent_agent:
+  match_score += context_bonus (default: 10)
+```
+
+### 3. Confidence Calculation
+
+```
+confidence = min(100, match_score)
+```
+
+### 4. Decision
+
+```
+if confidence >= 90:
+    auto_execute()
+elif confidence >= 70:
+    request_confirmation()
+else:
+    list_options()
+```
+
+## Detection Patterns
+
+### Keyword Patterns
+
+```yaml
+# Korean keywords
+korean:
+  - "고" → go
+  - "파이썬" → python
+  - "러스트" → rust
+  - "타입스크립트" → typescript
+
+# Action verbs (Korean)
+actions_kr:
+  - "리뷰" → review
+  - "분석" → analyze
+  - "수정" → fix
+  - "생성" → create
+  - "만들어" → create
+  - "확인" → check
+```
+
+### File Pattern Matching
+
+```yaml
+patterns:
+  go: ["*.go", "go.mod", "go.sum"]
+  python: ["*.py", "requirements.txt", "pyproject.toml", "setup.py"]
+  rust: ["*.rs", "Cargo.toml"]
+  typescript: ["*.ts", "*.tsx", "tsconfig.json"]
+  kotlin: ["*.kt", "*.kts", "build.gradle.kts"]
+```
+
+## Output Format
+
+### High Confidence
+
+```
+[Intent Detected]
+├── Input: "Go 코드 리뷰해줘"
+├── Agent: lang-golang-expert
+├── Confidence: 95%
+└── Reason: "Go" keyword + "리뷰" action
+
+┌─ Agent: lang-golang-expert (sw-engineer)
+└─ Task: Code review
+```
+
+### Medium Confidence
+
+```
+[Intent Detected]
+├── Input: "백엔드 API 확인해줘"
+├── Detected: be-go-backend-expert (?)
+├── Confidence: 78%
+└── Alternatives available
+
+Select agent:
+  1. be-go-backend-expert (78%)
+  2. be-fastapi-expert (72%)
+  3. be-springboot-expert (68%)
+
+Choice [1-3, or agent name]:
+```
+
+### Override
+
+```
+[Override Detected]
+├── Input: "@lang-python-expert review api.py"
+├── Agent: lang-python-expert (explicit)
+└── Bypassing intent detection
+
+┌─ Agent: lang-python-expert (sw-engineer)
+└─ Task: Review api.py
+```
+
+## Integration
+
+### With Secretary
+
+```
+Secretary uses this skill to:
+1. Parse incoming user requests
+2. Detect intent and select agent
+3. Display reasoning
+4. Handle confirmations
+5. Route to selected agent
+```
+
+### With Agent Triggers
+
+```
+Load triggers from:
+.codex/skills/intent-detection/patterns/agent-triggers.yaml
+
+Each agent defines:
+- keywords (language names, tech terms)
+- file_patterns (extensions, config files)
+- actions (supported actions)
+- weights (scoring factors)
+```
+
+## Error Handling
+
+### No Match (< 30% confidence)
+
+**Generic task** (no identifiable domain):
+```
+[Intent Unclear]
+├── Input: "도와줘"
+├── Confidence: < 30%
+└── Too generic to detect intent
+
+How can I help? Please be more specific:
+- What type of task? (review, create, fix, ...)
+- What language/technology? (Go, Python, ...)
+- What file or project?
+```
+
+**Specialized task with identifiable domain** (keywords/files detected but no matching agent):
+```
+[No Matching Agent]
+├── Input: "Terraform 모듈 리뷰해줘"
+├── Domain: terraform (detected from keywords)
+├── Matching Agent: none
+└── Action: Trigger dynamic agent creation
+
+→ Delegating to mgr-creator with context:
+  domain: terraform
+  keywords: ["terraform", "모듈"]
+  file_patterns: ["*.tf"]
+```
+
+### Ambiguous Match
+
+```
+[Intent Ambiguous]
+├── Input: "코드 리뷰"
+├── Top matches:
+│   └── All experts: ~50% each
+└── Need file context or language hint
+
+Specify the language or provide a file path.
+```
+
+## Configuration
+
+```yaml
+intent_detection:
+  enabled: true
+  auto_execute_threshold: 90
+  confirm_threshold: 70
+  show_reasoning: true
+  max_alternatives: 3
+  korean_support: true
+```
+
+## Research Intent Routing
+
+When a research/information gathering intent is detected:
+
+### Detection Keywords
+
+```yaml
+# Korean
+korean:
+  - "조사" → research
+  - "검색" → search
+  - "리서치" → research
+  - "탐색" → explore
+  - "찾아" → look up
+  - "알아봐" → find out
+  - "자료" → gather materials
+  - "정보 수집" → gather information
+
+# English
+english:
+  - "research"
+  - "investigate"
+  - "search for"
+  - "look up"
+  - "gather information"
+```
+
+### Routing Logic
+
+```
+Research intent detected (confidence >= 70%)
+    ↓
+Check Codex CLI availability
+    ├─ Available (codex binary + OPENAI_API_KEY)
+    │   → Use codex-exec skill with --effort xhigh
+    │   → Prompt: "Research and analyze: {user_request}"
+    │   → Returns: structured findings for orchestrator
+    └─ Unavailable
+        → Fall back to Claude's WebFetch/WebSearch
+        → Orchestrator handles directly or via general-purpose agent
+```
+
+### Confidence Scoring
+
+| Factor | Weight | Example |
+|--------|--------|---------|
+| Research keyword match | +40 | "조사해줘", "research" |
+| Action verb match | +30 | "찾아", "investigate" |
+| URL/topic present | +20 | specific URL or topic mentioned |
+| Context (previous research) | +10 | follow-up research request |
+
+### Output Format
+
+```
+[Intent Detected]
+├── Input: "{user input}"
+├── Workflow: research-workflow
+├── Confidence: {percentage}%
+├── Method: codex-exec (xhigh) | WebFetch fallback
+└── Reason: {explanation}
+```