nemonix-cli 1.0.0

package/src/config/claude-code-config/skills/utils-refactor/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: refactor
+description: Refactor code across the codebase using parallel Snipper agents. Use when user wants to rename methods, update patterns, fix code smells, or apply consistent changes across multiple files.
+argument-hint: <search-pattern-or-description>
+---
+
+# Refactor
+
+Refactor code matching `$ARGUMENTS` across the codebase using parallel Snipper agents for maximum speed.
+
+## Process
+
+### Phase 1: Discovery
+
+1. **Parse the refactor request** from `$ARGUMENTS`
+   - Identify: method name, component name, pattern, or code smell
+   - Choose search strategy: Grep for code patterns, Glob for file patterns
+
+2. **Find all affected files**
+   - Use Grep/Glob to search the codebase
+   - Exclude: node_modules, .git, dist, build
+   - If >15 files found, ask user to confirm or narrow scope
+
+### Phase 2: Create Instructions
+
+3. **Create task folder**: `.claude/tasks/refactor-{timestamp}/`
+
+4. **Create ONE instruction file** at `instructions.md`:
+
+```markdown
+# Refactor: {title}
+
+## Objective
+{What to refactor - derived from $ARGUMENTS}
+
+## Pattern to Find
+{Exact code pattern or structure to locate}
+
+## Transformation
+{How to transform - be specific and adaptive}
+
+## Examples
+Before:
+{current code}
+
+After:
+{refactored code}
+
+## Constraints
+- Only modify code matching the pattern
+- Preserve all existing functionality
+- Follow codebase conventions
+```
+
+### Phase 3: Execute in Parallel
+
+5. **Group files** into batches of max 3 files each
+
+6. **Launch Snipper agents in parallel** - ALL batches in a SINGLE message:
+
+```
+Using instructions in .claude/tasks/refactor-{id}/instructions.md, refactor:
+- {file_1}
+- {file_2}
+- {file_3}
+
+Read instructions first, then apply the refactor to each file.
+```
+
+### Phase 4: Verification
+
+7. **Validate changes**
+   - Run `pnpm lint` (if available)
+   - Run `pnpm tsc` (if TypeScript)
+
+8. **Report summary**
+   - Files modified
+   - Errors encountered
+   - Next steps if needed
+
+## Example
+
+User: `/refactor rename getUserData to fetchUserProfile`
+
+1. Grep finds 12 files containing "getUserData"
+2. Creates `.claude/tasks/refactor-1702489200/instructions.md`
+3. Groups into 4 batches of 3 files
+4. Launches 4 Snipper agents in parallel
+5. Runs lint, reports: "Refactored 12 files"

package/src/config/claude-code-config/skills/utils-save-docs/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: save-docs
+description: Fetch library documentation using Context7 MCP and save to .claude/output/docs/
+allowed-tools: Write, Bash(mkdir :*)
+argument-hint: <library> <topic>
+---
+
+# Save Docs
+
+Fetch documentation for a library/topic and save it locally for future reference.
+
+## Workflow
+
+1. **PARSE REQUEST**: Extract library and topic
+   - Example: `shadcn ui button` → library: `shadcn`, topic: `button`
+   - Example: `react hooks` → library: `react`, topic: `hooks`
+
+2. **RESOLVE LIBRARY**: Use `mcp__context7__resolve-library-id`
+   - Search for the library name
+   - Get the Context7-compatible library ID
+   - Example: `shadcn` → `/shadcn-ui/ui`
+
+3. **FETCH DOCS**: Use `mcp__context7__query-docs`
+   - Query with the resolved library ID
+   - Include the specific topic in the query
+   - Request comprehensive documentation with examples
+
+4. **CREATE OUTPUT DIRECTORY**:
+   ```bash
+   mkdir -p .claude/output/docs
+   ```
+
+5. **SAVE DOCUMENTATION**: Write to file
+   - Filename: `{library}-{topic}.md` (kebab-case)
+   - Example: `.claude/output/docs/shadcn-button.md`
+   - Include: API reference, usage examples, configuration options
+
+## File Format
+
+```markdown
+# {Library} - {Topic}
+
+> Source: Context7 documentation
+
+## Overview
+[Brief description]
+
+## Usage
+[Code examples]
+
+## API Reference
+[Props, methods, options]
+
+## Examples
+[Working code snippets]
+```
+
+## Examples
+
+| Command | Output File |
+|---------|-------------|
+| `/save-docs shadcn button` | `.claude/output/docs/shadcn-button.md` |
+| `/save-docs react useEffect` | `.claude/output/docs/react-useeffect.md` |
+| `/save-docs nextjs app router` | `.claude/output/docs/nextjs-app-router.md` |
+
+## Rules
+
+- ALWAYS resolve library ID first with `resolve-library-id`
+- ALWAYS create output directory before writing
+- Use kebab-case for filenames
+- Include code examples from documentation
+- Keep documentation concise but complete
+
+User: $ARGUMENTS

package/src/config/claude-code-config/skills/utils-ultrathink/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: ultrathink
+description: Deep thinking mode - approach problems like a craftsman, obsess over details, and create elegant solutions
+---
+
+# Ultrathink
+
+Take a deep breath. We're not here to write code. We're here to make a dent in the universe.
+
+## The Approach
+
+1. **Think Different** - Question every assumption. Why does it have to work that way? What would the most elegant solution look like?
+
+2. **Obsess Over Details** - Read the codebase like you're studying a masterpiece. Understand the patterns, the philosophy, the _soul_ of this code.
+
+3. **Plan Like Da Vinci** - Before writing a single line, sketch the architecture. Create a plan so clear anyone could understand it.
+
+4. **Craft, Don't Code** - Every function name should sing. Every abstraction should feel natural. Every edge case handled with grace.
+
+5. **Iterate Relentlessly** - The first version is never good enough. Run tests. Compare results. Refine until it's _insanely great_.
+
+6. **Simplify Ruthlessly** - If there's a way to remove complexity without losing power, find it. Elegance is achieved when there's nothing left to take away.
+
+## Your Tools Are Instruments
+
+- Use bash tools, MCP servers, and custom commands like a virtuoso
+- Git history tells the story—read it, learn from it, honor it
+- Multiple Claude instances aren't redundancy—they're collaboration between perspectives
+
+## The Integration
+
+Technology alone is not enough. Your code should:
+- Work seamlessly with the human's workflow
+- Feel intuitive, not mechanical
+- Solve the _real_ problem, not just the stated one
+- Leave the codebase better than you found it
+
+## Reality Distortion Field
+
+When something seems impossible, that's your cue to ultrathink harder. The people crazy enough to think they can change the world are the ones who do.
+
+Don't just tell me how you'll solve it. _Show me_ why this solution is the only one that makes sense.

package/src/config/claude-code-config/skills/workflow-apex/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: apex
+description: Systematic implementation using APEX methodology (Analyze-Plan-Execute-eXamine) with parallel agents, self-validation, and optional adversarial review. Use when implementing features, fixing bugs, or making code changes that benefit from structured workflow.
+argument-hint: "[-a] [-x] [-s] [-t] [-b] [-pr] [-i] [-m] [-r <task-id>] <task description>"
+---
+
+<objective>
+Execute systematic implementation workflows using the APEX methodology with progressive step loading.
+</objective>
+
+<quick_start>
+
+```bash
+/apex add authentication middleware           # Basic
+/apex -a -s implement user registration       # Autonomous + save
+/apex -a -x -s fix login bug                  # With adversarial review
+/apex -a -m implement full auth system        # Agent Teams (parallel)
+/apex -a -x -s -t add auth middleware         # Full workflow with tests
+/apex -a -pr add auth middleware              # With PR creation
+/apex -r 01-auth-middleware                   # Resume previous task
+/apex -e add auth middleware                  # Economy mode (save tokens)
+/apex -i add auth middleware                  # Interactive flag config
+```
+
+</quick_start>
+
+<flags>
+**Enable (lowercase ON) / Disable (UPPERCASE OFF):**
+
+| ON | OFF | Long | Description |
+|----|-----|------|-------------|
+| `-a` | `-A` | `--auto` | Skip confirmations, auto-approve |
+| `-x` | `-X` | `--examine` | Adversarial code review |
+| `-s` | `-S` | `--save` | Save outputs to `.claude/output/apex/` |
+| `-t` | `-T` | `--test` | Include test creation + runner |
+| `-e` | `-E` | `--economy` | No subagents, save tokens |
+| `-b` | `-B` | `--branch` | Verify not on main, create branch |
+| `-pr` | `-PR` | `--pull-request` | Create PR at end (enables -b) |
+| `-i` | | `--interactive` | Configure flags via menu |
+| `-k` | `-K` | `--tasks` | Task breakdown with dependencies |
+| `-m` | `-M` | `--teams` | Agent Teams parallel execution (enables -k) |
+| `-r` | | `--resume` | Resume from previous task ID |
+
+**Parsing:** Defaults from `steps/step-00-init.md`, flags override, remainder = `{task_description}`, ID = `NN-kebab-case`.
+</flags>
+
+<workflow>
+1. **Init** → Parse flags, setup state
+2. **Analyze** → Context gathering (1-10 parallel agents)
+3. **Plan** → File-by-file strategy + TaskList creation
+4. **Tasks** → Task breakdown (if -k or -m)
+5. **Execute** → Implementation (standard or Agent Teams if -m)
+6. **Validate** → Typecheck, lint, tests
+7. **Tests** → Create + run tests (if -t)
+8. **Examine** → Adversarial review (if -x)
+9. **Resolve** → Fix findings (if examine found issues)
+10. **Finish** → Create PR (if -pr)
+</workflow>
+
+<step_files>
+
+| Step | File | Purpose |
+|------|------|---------|
+| 00 | `steps/step-00-init.md` | Parse flags, initialize state |
+| 00b | `steps/step-00b-save.md` | Setup save output structure (if -s) |
+| 00b | `steps/step-00b-branch.md` | Git branch setup (if -b) |
+| 00b | `steps/step-00b-economy.md` | Economy mode overrides (if -e) |
+| 00b | `steps/step-00b-interactive.md` | Interactive flag config (if -i) |
+| 01 | `steps/step-01-analyze.md` | Smart context gathering |
+| 02 | `steps/step-02-plan.md` | File-by-file plan + TaskList |
+| 02b | `steps/step-02b-tasks.md` | Task breakdown (if -k/-m) |
+| 03 | `steps/step-03-execute.md` | Todo-driven implementation |
+| 03t | `steps/step-03-execute-teams.md` | Agent Team execution (if -m) |
+| 04 | `steps/step-04-validate.md` | Self-check and validation |
+| 05 | `steps/step-05-examine.md` | Adversarial code review |
+| 06 | `steps/step-06-resolve.md` | Finding resolution |
+| 07 | `steps/step-07-tests.md` | Test analysis and creation |
+| 08 | `steps/step-08-run-tests.md` | Test runner loop |
+| 09 | `steps/step-09-finish.md` | Create pull request |
+
+</step_files>
+
+<state_variables>
+
+| Variable | Type | Set by |
+|----------|------|--------|
+| `{task_description}` | string | step-00 |
+| `{feature_name}` | string | step-00 |
+| `{task_id}` | string | step-00 / step-00b-save |
+| `{acceptance_criteria}` | list | step-01 |
+| `{auto_mode}` | boolean | step-00 |
+| `{examine_mode}` | boolean | step-00 |
+| `{save_mode}` | boolean | step-00 |
+| `{test_mode}` | boolean | step-00 |
+| `{economy_mode}` | boolean | step-00 |
+| `{branch_mode}` | boolean | step-00 |
+| `{pr_mode}` | boolean | step-00 |
+| `{tasks_mode}` | boolean | step-00 |
+| `{teams_mode}` | boolean | step-00 |
+| `{output_dir}` | string | step-00b-save |
+| `{branch_name}` | string | step-00b-branch |
+
+</state_variables>
+
+<execution_rules>
+- **Load one step at a time** (progressive loading)
+- **ULTRA THINK** before major decisions
+- **Persist state variables** across all steps
+- **Follow next_step directive** at end of each step
+- **Save outputs** if `{save_mode}` = true (each step appends to its file)
+- **Use parallel agents** for independent exploration (step-01)
+</execution_rules>
+
+<entry_point>
+**FIRST ACTION:** Load `steps/step-00-init.md`
+</entry_point>

package/src/config/claude-code-config/skills/workflow-apex/scripts/setup-templates.sh

@@ -0,0 +1,144 @@
+#!/bin/bash
+# APEX Template Setup Script
+# Creates output directory structure and initializes template files
+#
+# Usage: setup-templates.sh "feature-name" [other args...]
+# The script auto-generates the task ID with the next available number.
+
+set -e
+
+# Arguments - first arg is now just the feature name (kebab-case)
+FEATURE_NAME="$1"
+TASK_DESCRIPTION="$2"
+AUTO_MODE="${3:-false}"
+EXAMINE_MODE="${4:-false}"
+SAVE_MODE="${5:-false}"
+TEST_MODE="${6:-false}"
+ECONOMY_MODE="${7:-false}"
+BRANCH_MODE="${8:-false}"
+PR_MODE="${9:-false}"
+INTERACTIVE_MODE="${10:-false}"
+TASKS_MODE="${11:-false}"
+BRANCH_NAME="${12:-}"
+ORIGINAL_INPUT="${13:-}"
+
+# Validate required arguments
+if [[ -z "$FEATURE_NAME" ]]; then
+    echo "Error: FEATURE_NAME is required"
+    exit 1
+fi
+
+if [[ -z "$TASK_DESCRIPTION" ]]; then
+    echo "Error: TASK_DESCRIPTION is required"
+    exit 1
+fi
+
+# Get current timestamp
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+# Use current working directory as project root
+PROJECT_ROOT=$(pwd)
+APEX_OUTPUT_DIR="${PROJECT_ROOT}/.claude/output/apex"
+
+# Create apex output directory if it doesn't exist
+mkdir -p "$APEX_OUTPUT_DIR"
+
+# Find the next available number
+NEXT_NUM=1
+if [[ -d "$APEX_OUTPUT_DIR" ]]; then
+    # Find highest existing number prefix
+    HIGHEST=$(ls -1 "$APEX_OUTPUT_DIR" 2>/dev/null | grep -oE '^[0-9]+' | sort -n | tail -1)
+    if [[ -n "$HIGHEST" ]]; then
+        # Force base-10 interpretation (leading zeros would be treated as octal)
+        NEXT_NUM=$((10#$HIGHEST + 1))
+    fi
+fi
+
+# Format with leading zeros (2 digits)
+TASK_NUM=$(printf "%02d" "$NEXT_NUM")
+
+# Build full task ID
+TASK_ID="${TASK_NUM}-${FEATURE_NAME}"
+
+OUTPUT_DIR="${APEX_OUTPUT_DIR}/${TASK_ID}"
+
+# Get skill directory
+SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TEMPLATE_DIR="${SKILL_DIR}/templates"
+
+# Create output directory
+mkdir -p "$OUTPUT_DIR"
+
+# Function to replace template variables
+render_template() {
+    local template_file="$1"
+    local output_file="$2"
+
+    # Determine status strings based on flags
+    local examine_status="⏭ Skip"
+    [[ "$EXAMINE_MODE" == "true" ]] && examine_status="⏸ Pending"
+
+    local test_status="⏭ Skip"
+    [[ "$TEST_MODE" == "true" ]] && test_status="⏸ Pending"
+
+    local pr_status="⏭ Skip"
+    [[ "$PR_MODE" == "true" ]] && pr_status="⏸ Pending"
+
+    local tasks_status="⏭ Skip"
+    [[ "$TASKS_MODE" == "true" ]] && tasks_status="⏸ Pending"
+
+    # Read template and replace variables
+    sed -e "s|{{task_id}}|${TASK_ID}|g" \
+        -e "s|{{task_description}}|${TASK_DESCRIPTION}|g" \
+        -e "s|{{timestamp}}|${TIMESTAMP}|g" \
+        -e "s|{{auto_mode}}|${AUTO_MODE}|g" \
+        -e "s|{{examine_mode}}|${EXAMINE_MODE}|g" \
+        -e "s|{{save_mode}}|${SAVE_MODE}|g" \
+        -e "s|{{test_mode}}|${TEST_MODE}|g" \
+        -e "s|{{economy_mode}}|${ECONOMY_MODE}|g" \
+        -e "s|{{branch_mode}}|${BRANCH_MODE}|g" \
+        -e "s|{{pr_mode}}|${PR_MODE}|g" \
+        -e "s|{{interactive_mode}}|${INTERACTIVE_MODE}|g" \
+        -e "s|{{tasks_mode}}|${TASKS_MODE}|g" \
+        -e "s|{{branch_name}}|${BRANCH_NAME}|g" \
+        -e "s|{{original_input}}|${ORIGINAL_INPUT}|g" \
+        -e "s|{{examine_status}}|${examine_status}|g" \
+        -e "s|{{test_status}}|${test_status}|g" \
+        -e "s|{{tasks_status}}|${tasks_status}|g" \
+        -e "s|{{pr_status}}|${pr_status}|g" \
+        "$template_file" > "$output_file"
+}
+
+# Initialize 00-context.md
+render_template "${TEMPLATE_DIR}/00-context.md" "${OUTPUT_DIR}/00-context.md"
+
+# Initialize other step files (only headers, content appended during execution)
+render_template "${TEMPLATE_DIR}/01-analyze.md" "${OUTPUT_DIR}/01-analyze.md"
+render_template "${TEMPLATE_DIR}/02-plan.md" "${OUTPUT_DIR}/02-plan.md"
+render_template "${TEMPLATE_DIR}/03-execute.md" "${OUTPUT_DIR}/03-execute.md"
+render_template "${TEMPLATE_DIR}/04-validate.md" "${OUTPUT_DIR}/04-validate.md"
+
+# Conditional templates
+if [[ "$EXAMINE_MODE" == "true" ]]; then
+    render_template "${TEMPLATE_DIR}/05-examine.md" "${OUTPUT_DIR}/05-examine.md"
+    render_template "${TEMPLATE_DIR}/06-resolve.md" "${OUTPUT_DIR}/06-resolve.md"
+fi
+
+if [[ "$TEST_MODE" == "true" ]]; then
+    render_template "${TEMPLATE_DIR}/07-tests.md" "${OUTPUT_DIR}/07-tests.md"
+    render_template "${TEMPLATE_DIR}/08-run-tests.md" "${OUTPUT_DIR}/08-run-tests.md"
+fi
+
+if [[ "$TASKS_MODE" == "true" ]]; then
+    mkdir -p "${OUTPUT_DIR}/tasks"
+fi
+
+if [[ "$PR_MODE" == "true" ]]; then
+    render_template "${TEMPLATE_DIR}/09-finish.md" "${OUTPUT_DIR}/09-finish.md"
+fi
+
+# Output the generated task_id for capture by caller
+echo "TASK_ID=${TASK_ID}"
+echo "OUTPUT_DIR=${OUTPUT_DIR}"
+echo "✓ APEX templates initialized: ${OUTPUT_DIR}"
+exit 0

package/src/config/claude-code-config/skills/workflow-apex/scripts/update-progress.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+# APEX Progress Update Script
+# Updates 00-context.md progress table
+
+set -e
+
+# Arguments
+TASK_ID="$1"
+STEP_NUMBER="$2"
+STEP_NAME="$3"
+STATUS="$4"  # "in_progress" or "complete"
+
+# Validate required arguments
+if [[ -z "$TASK_ID" ]] || [[ -z "$STEP_NUMBER" ]] || [[ -z "$STEP_NAME" ]] || [[ -z "$STATUS" ]]; then
+    echo "Usage: $0 <task_id> <step_number> <step_name> <status>"
+    echo "Example: $0 01-add-auth 01 analyze complete"
+    exit 1
+fi
+
+# Find project root
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CONTEXT_FILE="${PROJECT_ROOT}/.claude/output/apex/${TASK_ID}/00-context.md"
+
+# Validate context file exists
+if [[ ! -f "$CONTEXT_FILE" ]]; then
+    echo "Error: Context file not found: $CONTEXT_FILE"
+    exit 1
+fi
+
+# Get timestamp
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+# Determine status symbol
+if [[ "$STATUS" == "in_progress" ]]; then
+    STATUS_SYMBOL="⏳ In Progress"
+elif [[ "$STATUS" == "complete" ]]; then
+    STATUS_SYMBOL="✓ Complete"
+else
+    echo "Error: Invalid status. Use 'in_progress' or 'complete'"
+    exit 1
+fi
+
+# Create temp file
+TEMP_FILE=$(mktemp)
+
+# Update the progress table
+awk -v step="${STEP_NUMBER}-${STEP_NAME}" \
+    -v status="$STATUS_SYMBOL" \
+    -v timestamp="$TIMESTAMP" '
+BEGIN { in_table = 0; found = 0 }
+{
+    # Detect progress table start
+    if ($0 ~ /^## Progress/) {
+        in_table = 1
+        print $0
+        next
+    }
+
+    # If in table and found the matching step
+    if (in_table && $0 ~ "\\| " step " \\|") {
+        printf "| %s | %s | %s |\n", step, status, timestamp
+        found = 1
+        next
+    }
+
+    # Print line as-is
+    print $0
+}
+END {
+    if (!found) {
+        print "Warning: Step not found in progress table" > "/dev/stderr"
+    }
+}
+' "$CONTEXT_FILE" > "$TEMP_FILE"
+
+# Replace original file
+mv "$TEMP_FILE" "$CONTEXT_FILE"
+
+echo "✓ Progress updated: ${STEP_NUMBER}-${STEP_NAME} → ${STATUS_SYMBOL}"
+exit 0