oh-my-customcode 0.12.1 → 0.12.2

package/templates/.codex/skills/go-best-practices/SKILL.md

@@ -1,203 +0,0 @@
----
-name: go-best-practices
-description: Idiomatic Go patterns from Effective Go
-user-invocable: false
----
-
-## Purpose
-
-Apply idiomatic Go patterns and best practices from official Go documentation.
-
-## Rules
-
-### 1. Formatting
-
-```yaml
-rules:
-  - Use gofmt for all code formatting
-  - Indentation uses tabs, not spaces
-  - No line length limit, but break long lines sensibly
-  - Let gofmt handle alignment
-```
-
-### 2. Naming Conventions
-
-```yaml
-package_names:
-  - Short, concise, lowercase, single-word
-  - No underscores or mixedCaps
-  - Name is basename of source directory
-  - Example: bufio, not bufIO or buf_io
-
-getters:
-  - No "Get" prefix for getters
-  - obj.Owner() not obj.GetOwner()
-  - Setter can use "Set": obj.SetOwner(user)
-
-interface_names:
-  - One-method interfaces: method name + "er"
-  - Reader, Writer, Formatter, CloseNotifier
-  - Avoid stealing standard names unless same signature
-
-mixedCaps:
-  - Use MixedCaps or mixedCaps, never underscores
-  - Exported: MixedCaps (uppercase first)
-  - Unexported: mixedCaps (lowercase first)
-```
-
-### 3. Control Structures
-
-```yaml
-if_statements:
-  - Accept initialization statement
-  - Prefer: if err := file.Chmod(0664); err != nil
-  - Omit else when if ends with break/continue/return
-  - Avoid unnecessary else
-
-for_loops:
-  - Go's only loop construct
-  - for init; condition; post { } - like C for
-  - for condition { } - like C while
-  - for { } - infinite loop
-  - Use range for strings, slices, arrays, maps, channels
-
-switch:
-  - Cases don't fall through by default
-  - Use fallthrough keyword if needed
-  - Multiple cases: case '0', '1', '2'
-  - Type switch: switch v := x.(type)
-```
-
-### 4. Functions
-
-```yaml
-multiple_returns:
-  - Return multiple values for result + error
-  - func (file *File) Write(b []byte) (n int, err error)
-
-named_results:
-  - Document return values with names
-  - Can simplify code but use judiciously
-  - Unnamed returns OK for short functions
-
-defer:
-  - Executes when function returns
-  - LIFO order for multiple defers
-  - Use for cleanup: unlock mutexes, close files
-  - Arguments evaluated when defer executes, not when called
-```
-
-### 5. Data
-
-```yaml
-new_vs_make:
-  - new(T): allocates zeroed storage, returns *T
-  - make(T, args): creates slices, maps, channels only
-  - make returns initialized (not zeroed) value of type T
-
-slices:
-  - Backed by arrays, can grow
-  - append() to add elements
-  - copy() for safe duplication
-  - Slice of slice shares underlying array
-
-maps:
-  - Reference type, nil until initialized
-  - make(map[KeyType]ValueType)
-  - Comma ok idiom: val, ok := map[key]
-  - delete(map, key) to remove
-```
-
-### 6. Methods
-
-```yaml
-pointer_vs_value_receivers:
-  - Pointer receiver: can modify, no copy overhead
-  - Value receiver: safe from modification
-  - If any method needs pointer, all should use pointer
-  - Rule: values immutable, pointers mutable
-```
-
-### 7. Interfaces
-
-```yaml
-design:
-  - Interfaces define behavior, not data
-  - Small interfaces (1-3 methods) preferred
-  - Accept interfaces, return structs
-  - If type implements interface, it satisfies implicitly
-
-common_interfaces:
-  - io.Reader: Read(p []byte) (n int, err error)
-  - io.Writer: Write(p []byte) (n int, err error)
-  - fmt.Stringer: String() string
-  - error: Error() string
-```
-
-### 8. Concurrency
-
-```yaml
-goroutines:
-  - Lightweight, multiplexed onto OS threads
-  - go function() to start
-  - Don't communicate by sharing memory
-  - Share memory by communicating
-
-channels:
-  - Primary synchronization mechanism
-  - ch := make(chan int) - unbuffered
-  - ch := make(chan int, 100) - buffered
-  - Send: ch <- v
-  - Receive: v := <-ch
-  - Close: close(ch)
-
-patterns:
-  - Don't leak goroutines - ensure they exit
-  - Use context for cancellation
-  - select for multiple channel operations
-  - sync.WaitGroup for goroutine coordination
-```
-
-### 9. Error Handling
-
-```yaml
-principles:
-  - Errors are values, handle them explicitly
-  - Check errors immediately after call
-  - Return errors, don't panic
-  - Add context when propagating: fmt.Errorf("op failed: %w", err)
-
-panic_recover:
-  - Panic for unrecoverable errors only
-  - Library functions should return errors, not panic
-  - Recover only in deferred functions
-  - Convert internal panics to errors at package boundary
-```
-
-### 10. Project Structure
-
-```yaml
-packages:
-  - One package per directory
-  - Package name matches directory name
-  - main package for executables
-  - Avoid circular imports
-
-files:
-  - doc.go for package documentation
-  - _test.go suffix for test files
-  - Group related types and functions
-```
-
-## Application
-
-When writing or reviewing Go code:
-
-1. **Always** run `gofmt` or `goimports`
-2. **Always** handle returned errors
-3. **Prefer** composition over inheritance
-4. **Prefer** small interfaces
-5. **Prefer** channels for goroutine communication
-6. **Avoid** global state
-7. **Avoid** init() when possible
-8. **Document** exported identifiers

package/templates/.codex/skills/help/SKILL.md

@@ -1,125 +0,0 @@
----
-name: help
-description: Show help information for commands and system
-argument-hint: "[command] [--agents] [--rules]"
----
-
-# Help Skill
-
-Show help information for commands, agents, and system rules.
-
-## Options
-
-```
---agents, -a     List all available agents
---commands, -c   List all commands (same as 'lists')
---rules, -r      List all rules
-```
-
-## Output Format
-
-### Default Help
-```
-AI Agent System - Help
-
-Usage: {command} [arguments] [options]
-
-Quick Start:
-  lists              Show all available commands
-  status             Show system status
-  help <command>     Get help for a specific command
-
-Common Commands:
-  /update-docs       Sync documentation with project
-  /update-external   Update external agents
-  /audit-agents      Check agent dependencies
-  /create-agent      Create a new agent
-
-Use "lists" to see all available commands.
-Use "help <command>" for detailed help.
-```
-
-### Command Help
-```
-help /update-docs
-
-Command: /update-docs
-
-Description:
-  Sync documentation with project structure. Ensures all
-  documentation accurately reflects the current project state.
-
-Usage:
-  /update-docs
-  /update-docs --check
-  /update-docs --target <path>
-
-Options:
-  --check, -c      Check only, don't modify
-  --verbose, -v    Show detailed changes
-  --target, -t     Specific target to update
-
-Examples:
-  /update-docs                 # Update all documentation
-  /update-docs --check         # Check for issues
-  /update-docs --target agents # Update agents only
-```
-
-### Agent List
-```
-help --agents
-
-Available Agents:
-
-Orchestrator:
-  secretary        Manages manager agents
-
-Manager:
-  mgr-creator          Creates new agents
-  mgr-updater          Updates external sources and docs
-  mgr-supplier         Validates dependencies
-
-SW Engineer:
-  lang-golang-expert       Go development (Effective Go)
-  lang-python-expert       Python development (PEP 8)
-  lang-rust-expert         Rust development (API Guidelines)
-  lang-kotlin-expert       Kotlin development (JetBrains)
-  lang-typescript-expert   TypeScript development (Google)
-  fe-vercel-agent  React/Next.js (Vercel)
-
-Backend Engineer:
-  be-fastapi-expert      FastAPI (Python async)
-  be-springboot-expert   Spring Boot (Java)
-  be-go-backend-expert   Go backend (Uber style)
-
-Infra Engineer:
-  infra-docker-expert       Docker containerization
-  infra-aws-expert          AWS architecture
-
-Total: 15 agents
-```
-
-### Rules List
-```
-help --rules
-
-Global Rules:
-
-MUST (Never violate):
-  R000  Language Policy      Korean I/O, English files
-  R001  Safety Rules         Prohibited actions
-  R002  Permission Rules     Tool tiers, file access
-  R006  Agent Design         Structure, separation
-
-SHOULD (Strongly recommended):
-  R003  Interaction Rules    Response format
-  R004  Error Handling       Error levels, recovery
-  R007  Agent Identification Display agent in responses
-  R008  Tool Identification  Display agent when using tools
-
-MAY (Optional):
-  R005  Optimization         Efficiency guidelines
-  R009  Parallel Execution   Max 4 parallel instances
-
-Total: 10 rules
-```

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

@@ -1,215 +0,0 @@
----
-name: intent-detection
-description: Automatically detect user intent and route to appropriate agent
-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
-
-```
-[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?
-```
-
-### 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
-```