aiblueprint-cli 1.4.23 → 1.4.24

package/claude-code-config/skills/workflow-apex/templates/README.md

@@ -0,0 +1,195 @@
+# APEX Template System
+
+## Overview
+
+This directory contains template files used to initialize APEX workflow outputs when save mode (`-s`) is enabled. This template system significantly reduces token usage by moving repetitive content out of step files.
+
+## Template Files
+
+| Template | Purpose | Created When |
+|----------|---------|--------------|
+| `00-context.md` | Workflow configuration and progress tracking | Always (if save_mode) |
+| `01-analyze.md` | Analysis findings | Always (if save_mode) |
+| `02-plan.md` | Implementation plan | Always (if save_mode) |
+| `03-execute.md` | Implementation log | Always (if save_mode) |
+| `04-validate.md` | Validation results | Always (if save_mode) |
+| `05-examine.md` | Adversarial review findings | Only if examine_mode enabled |
+| `06-resolve.md` | Finding resolution log | Only if examine_mode enabled |
+| `07-tests.md` | Test analysis and creation | Only if test_mode enabled |
+| `08-run-tests.md` | Test runner log | Only if test_mode enabled |
+| `09-finish.md` | PR creation log | Only if pr_mode enabled |
+| `step-complete.md` | Completion marker template | Referenced in steps |
+
+## Template Variables
+
+Templates use `{{variable}}` syntax for placeholders:
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{{task_id}}` | Kebab-case task identifier | `01-add-auth-middleware` |
+| `{{task_description}}` | Plain text task description | `add authentication middleware` |
+| `{{timestamp}}` | ISO 8601 timestamp | `2026-01-12T10:30:00Z` |
+| `{{auto_mode}}` | Auto mode flag | `true` or `false` |
+| `{{examine_mode}}` | Examine mode flag | `true` or `false` |
+| `{{save_mode}}` | Save mode flag | `true` or `false` |
+| `{{test_mode}}` | Test mode flag | `true` or `false` |
+| `{{economy_mode}}` | Economy mode flag | `true` or `false` |
+| `{{branch_mode}}` | Branch mode flag | `true` or `false` |
+| `{{pr_mode}}` | PR mode flag | `true` or `false` |
+| `{{interactive_mode}}` | Interactive mode flag | `true` or `false` |
+| `{{branch_name}}` | Git branch name | `feature/add-auth` |
+| `{{original_input}}` | Raw user input | `/apex -a -s add auth` |
+| `{{examine_status}}` | Progress status for examine steps | `⏸ Pending` or `⏭ Skip` |
+| `{{test_status}}` | Progress status for test steps | `⏸ Pending` or `⏭ Skip` |
+| `{{pr_status}}` | Progress status for PR step | `⏸ Pending` or `⏭ Skip` |
+
+## Setup Script
+
+### `setup-templates.sh`
+
+Initializes all template files in the output directory with variables replaced.
+
+**Usage:**
+```bash
+bash scripts/setup-templates.sh \
+  "task_id" \
+  "task_description" \
+  "auto_mode" \
+  "examine_mode" \
+  "save_mode" \
+  "test_mode" \
+  "economy_mode" \
+  "branch_mode" \
+  "pr_mode" \
+  "interactive_mode" \
+  "branch_name" \
+  "original_input"
+```
+
+**Output:**
+```
+.claude/output/apex/01-add-auth-middleware/
+├── 00-context.md      # Always created
+├── 01-analyze.md      # Always created
+├── 02-plan.md         # Always created
+├── 03-execute.md      # Always created
+├── 04-validate.md     # Always created
+├── 05-examine.md      # Only if examine_mode
+├── 06-resolve.md      # Only if examine_mode
+├── 07-tests.md        # Only if test_mode
+├── 08-run-tests.md    # Only if test_mode
+└── 09-finish.md       # Only if pr_mode
+```
+
+## Progress Update Script
+
+### `update-progress.sh`
+
+Updates the progress table in `00-context.md` without manual markdown editing.
+
+**Usage:**
+```bash
+bash scripts/update-progress.sh <task_id> <step_number> <step_name> <status>
+```
+
+**Examples:**
+```bash
+# Mark step 01 as in progress
+bash scripts/update-progress.sh "01-add-auth" "01" "analyze" "in_progress"
+
+# Mark step 01 as complete
+bash scripts/update-progress.sh "01-add-auth" "01" "analyze" "complete"
+
+# Mark step 02 as in progress
+bash scripts/update-progress.sh "01-add-auth" "02" "plan" "in_progress"
+```
+
+**Status Values:**
+- `in_progress` → `⏳ In Progress`
+- `complete` → `✓ Complete`
+
+## Token Savings
+
+### Before Optimization
+
+Each step file contained full template content inline:
+
+```markdown
+### 1. Initialize Save Output (if save_mode)
+
+**If `{save_mode}` = true:**
+
+Create `{output_dir}/01-analyze.md`:
+```markdown
+# Step 01: Analyze
+
+**Task:** {task_description}
+**Started:** {ISO timestamp}
+
+---
+
+## Context Discovery
+```
+
+Update `00-context.md` progress:
+```markdown
+| 01-analyze | ⏳ In Progress | {timestamp} |
+```
+```
+
+**Token cost per step:** ~200 tokens × 9 steps = ~1,800 tokens
+
+### After Optimization
+
+Step files now reference templates and scripts:
+
+```markdown
+### 1. Initialize Save Output (if save_mode)
+
+**If `{save_mode}` = true:**
+
+The file `{output_dir}/01-analyze.md` has already been created by the setup script.
+
+Update progress:
+```bash
+bash {skill_dir}/scripts/update-progress.sh "{task_id}" "01" "analyze" "in_progress"
+```
+
+Append your findings to `01-analyze.md` as you work.
+```
+
+**Token cost per step:** ~50 tokens × 9 steps = ~450 tokens
+
+**Total savings:** ~1,350 tokens per workflow execution (75% reduction)
+
+## How It Works
+
+1. **Initialization (step-00-init.md):**
+   - Runs `setup-templates.sh` once at workflow start
+   - Creates all template files with variables replaced
+   - Output directory is ready with pre-initialized files
+
+2. **Each Step:**
+   - Runs `update-progress.sh` to mark step as "in_progress"
+   - Appends findings/logs to the pre-created step file
+   - Runs `update-progress.sh` again to mark step as "complete"
+
+3. **Benefits:**
+   - AI doesn't need to hold template content in context
+   - Consistent formatting across all workflows
+   - Easy to update templates without editing step files
+   - Scripts handle the tedious markdown updates
+
+## Updating Templates
+
+To modify template content:
+
+1. Edit the template file in `templates/`
+2. Changes apply to all future workflows automatically
+3. No need to update step files
+
+## Maintenance
+
+- Templates are stateless (no workflow-specific logic)
+- Scripts are idempotent (safe to run multiple times)
+- Variables use `{{var}}` syntax to avoid conflicts with markdown

package/claude-code-config/skills/workflow-apex/templates/step-complete.md

@@ -0,0 +1,7 @@
+---
+
+## Step Complete
+
+**Status:** ✓ Complete
+**Next:** {{next_step}}
+**Timestamp:** {{timestamp}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiblueprint-cli",
-  "version": "1.4.23",
+  "version": "1.4.24",
   "description": "AIBlueprint CLI for setting up Claude Code configurations",
   "author": "AIBlueprint",
   "license": "MIT",

package/claude-code-config/commands/explore.md

@@ -1,90 +0,0 @@
----
-description: Deep exploration of codebase, docs, and web for any topic or question
-argument-hint: <topic-or-question>
----
-
-You are an exploration specialist. Your mission is to gather comprehensive context about a topic.
-
-**ULTRA THINK before launching agents.**
-
-## Workflow
-
-1. **ULTRA THINK**: Plan exploration strategy
-   - Identify key concepts, files, patterns to find
-   - Determine which sources need exploration (codebase/docs/web)
-   - List specific questions each agent should answer
-   - **CRITICAL**: Know EXACTLY what to search for before launching agents
-
-2. **LAUNCH PARALLEL EXPLORATION**: Gather context from all sources
-
-   Launch ALL relevant agents in parallel in a single message.
-   Scale agent count based on complexity:
-
-   - **Codebase exploration** (`explore-codebase` agents):
-     - Simple topic: 1 agent for general search
-     - Complex topic: 2-3 agents for different aspects
-     - Multi-area: 1 agent per codebase area
-
-     Each agent should:
-     - Find related implementations and examples
-     - Locate relevant files and patterns
-     - Identify existing conventions and utilities
-     - Search for related helpers and abstractions
-
-   - **Documentation exploration** (`explore-docs` agents):
-     - Single library: 1 agent with focused topics
-     - Multiple libraries: 1 agent per library
-     - Complex integration: agents for each + integration
-
-     Each agent should:
-     - Search library docs for APIs and patterns
-     - Find best practices for tools being used
-     - Gather code examples from official docs
-
-   - **Web research** (`websearch` agents):
-     - Simple question: 1 agent
-     - Multi-faceted topic: 2-3 agents for different angles
-
-     Each agent should:
-     - Research latest approaches and solutions
-     - Find community examples and patterns
-     - Gather architectural guidance
-
-   ## Agent Scaling Guide
-
-   | Complexity | Codebase | Docs | Web |
-   |-----------|----------|------|-----|
-   | Simple | 1 | 1 | 1 |
-   | Medium | 2 | 1-2 | 1 |
-   | Complex | 2-3 | 2-3 | 2 |
-   | Multi-library | 1-2 | 1 per lib | 1-2 |
-
-3. **SYNTHESIZE FINDINGS**: Combine and organize results
-   - Merge findings from all agents
-   - Organize by topic/concern
-   - Include file paths with line numbers (e.g., `src/auth.ts:42`)
-   - Highlight key patterns and examples found
-   - Note any dependencies or prerequisites
-
-4. **REPORT**: Present findings to user
-   - **Key Files**: List relevant files with purposes
-   - **Patterns**: Existing conventions to follow
-   - **Examples**: Code snippets and implementations found
-   - **Documentation**: Key insights from docs
-   - **Recommendations**: Suggested approaches based on findings
-
-## Execution Rules
-
-- **PARALLEL EXECUTION**: All agents must run simultaneously for speed
-- **ULTRA THINK FIRST**: Never launch agents without clear search strategy
-- **COMPREHENSIVE**: Gather more context than seems necessary
-- **FILE REFERENCES**: Always include file paths with line numbers
-- **NO FILES**: Do NOT create any files - output findings directly
-
-## Priority
-
-Context depth > Speed. Thorough exploration prevents implementation issues.
-
----
-
-User: #$ARGUMENTS

package/claude-code-config/commands/git/commit.md

@@ -1,60 +0,0 @@
----
-description: Quick commit and push with minimal, clean messages
-model: haiku
-allowed-tools: Bash(git :*), Bash(npm :*), Bash(pnpm :*)
----
-
-<objective>
-Quickly analyze git changes and create a conventional commit message following the commitizen format (e.g., "update(statusline): refresh spend data"). This command prioritizes speed and efficiency for straightforward commits.
-</objective>
-
-<context>
-Git state: !`git status`
-Staged changes: !`git diff --cached --stat`
-Unstaged changes: !`git diff --stat`
-Recent commits: !`git log --oneline -5`
-Current branch: !`git branch --show-current`
-</context>
-
-<process>
-1. **Analyze changes**: Review git status to determine what needs to be committed
-   - If nothing staged but unstaged changes exist: stage all changes with `git add .`
-   - If nothing to commit: inform user and exit
-
-2. **Determine commit type and scope**:
-   - Types: `feat`, `fix`, `update`, `docs`, `chore`, `refactor`, `test`, `perf`, `revert`
-   - Scope: Identify the main area affected (e.g., `statusline`, `auth`, `api`, `ui`, `commands`)
-   - Use `update` for refreshing/updating existing features
-   - Use `feat` for new features
-   - Use `fix` for bug fixes
-
-3. **Generate commit message**:
-   - Format: `type(scope): brief description`
-   - Keep it under 72 characters
-   - Use imperative mood ("add" not "added")
-   - Start description with lowercase
-   - Be specific but concise
-   - Example: `update(statusline): refresh spend data`
-
-4. **Create commit**: Execute `git commit -m "message"` immediately with the generated message
-
-5. **Push changes**: After successful commit, push to remote with `git push`
-</process>
-
-<success_criteria>
-- Changes properly staged if needed
-- Commit message follows format: `type(scope): description`
-- Commit created successfully
-- Changes pushed to remote
-- No errors during git operations
-</success_criteria>
-
-<rules>
-- **SPEED OVER PERFECTION**: Generate one good commit message and commit immediately
-- **NO INTERACTION**: Never use AskUserQuestion - just analyze and commit
-- **AUTO-STAGE**: If changes exist but nothing staged, stage everything
-- **AUTO-PUSH**: Always push after committing
-- **MINIMAL OUTPUT**: Brief confirmation of what was committed
-- **IMPERATIVE MOOD**: Use "add", "update", "fix", not past tense
-- **LOWERCASE**: Description starts lowercase after colon
-</rules>

package/claude-code-config/commands/git/fix-pr-comments.md

@@ -1,59 +0,0 @@
----
-description: Fetch PR review comments and implement all requested changes
-allowed-tools: Bash(gh :*), Bash(git :*), Read, Edit, MultiEdit
----
-
-You are a PR review resolver. **Systematically address ALL unresolved review comments until PR is approved.**
-
-## Context
-
-- Current branch: !`git branch --show-current`
-- Working tree status: !`git status --short`
-- Recent commits: !`git log --oneline -3`
-
-## Workflow
-
-1. **FETCH COMMENTS**: Gather all unresolved PR feedback
-   - **Identify PR**: `gh pr status --json number,headRefName`
-   - **Get reviews**: `gh pr review list --state CHANGES_REQUESTED`
-   - **Get inline**: `gh api repos/{owner}/{repo}/pulls/{number}/comments`
-   - **CRITICAL**: Capture BOTH review comments AND inline code comments
-   - **STOP** if no PR found - ask user for PR number
-
-2. **ANALYZE & PLAN**: Map feedback to specific actions
-   - **Extract locations**: Note exact file:line references
-   - **Group by file**: Batch changes for MultiEdit efficiency
-   - **Define scope**: List **ONLY** files from review comments
-   - **STAY IN SCOPE**: NEVER fix unrelated issues
-   - **Create checklist**: One item per comment to track
-
-3. **IMPLEMENT FIXES**: Address each comment systematically
-   - **BEFORE editing**: ALWAYS `Read` the target file first
-   - **Batch changes**: Use `MultiEdit` for same-file modifications
-   - **Verify resolution**: Each comment **MUST** be fully addressed
-   - **Direct fixes only**: Make **EXACTLY** what reviewer requested
-   - **Track progress**: Check off each resolved comment
-
-4. **COMMIT & PUSH**: Submit all fixes as single commit
-   - **Stage everything**: `git add -A`
-   - **Commit format**: `fix: address PR review comments`
-   - **Push changes**: `git push` to update the PR
-   - **NEVER include**: No "Generated with Claude Code" or co-author tags
-   - **Verify**: Check PR updated with `gh pr view`
-
-## Execution Rules
-
-- **NON-NEGOTIABLE**: Every unresolved comment MUST be addressed
-- **CRITICAL RULE**: Read files BEFORE any edits - no exceptions
-- **MUST** use exact file paths from review comments
-- **STOP** if unable to fetch comments - request PR number
-- **FORBIDDEN**: Style changes beyond reviewer requests
-- **On failure**: Return to ANALYZE phase, never skip comments
-
-## Priority
-
-**Reviewer requests > Everything else**. STAY IN SCOPE - fix ONLY what was requested.
-
----
-
-User: #$ARGUMENTS

package/claude-code-config/commands/oneshot.md

@@ -1,57 +0,0 @@
----
-description: Ultra-fast feature implementation - Explore then Code then Test
-argument-hint: <feature-description>
----
-
-<objective>
-Implement #$ARGUMENTS at maximum speed using the OneShot methodology.
-
-This workflow prioritizes rapid delivery through surgical exploration, immediate implementation, and focused validation. Speed over completeness - ship fast, iterate later.
-</objective>
-
-<process>
-1. **EXPLORE** (5-10 min max):
-   - Launch 1-2 parallel subagents maximum to find relevant files
-   - Use `explore-codebase` for codebase search
-   - Use `explore-docs` ONLY if library-specific knowledge needed
-   - Find files to use as examples or edit targets
-   - Be surgical - know exactly what to search for
-   - NO PLANNING PHASE - gather context and move to coding
-
-2. **CODE** (implement immediately):
-   - Start coding as soon as basic context available
-   - Follow existing codebase patterns and style
-   - Prefer clear variable/method names over comments
-   - Stay STRICTLY in scope - change only what's needed
-   - NO comments unless absolutely necessary
-   - NO refactoring beyond feature requirements
-   - Run autoformatting scripts when done
-   - Fix reasonable linter warnings as you go
-
-3. **TEST** (validate quality):
-   - Check package.json for available scripts (lint, typecheck, format)
-   - Run: `npm run lint && npm run typecheck` (or equivalent)
-   - If checks fail: fix errors immediately and re-run
-   - Stay in scope - don't run full test suite unless requested
-   - For major changes only: run relevant tests with `npm test -- <pattern>`
-     </process>
-
-<rules>
-**Critical constraints:**
-- SPEED IS PRIORITY: Move fast, break nothing
-- NO PLANNING: Trust exploration and code directly
-- PARALLEL AGENTS: Max 2 agents during explore phase
-- MINIMAL TESTS: Lint + typecheck only (unless user requests more)
-- STAY FOCUSED: Implement exactly what's requested, nothing more
-- ULTRA THINK: Always engage deep reasoning for optimal solutions
-- If stuck or uncertain: ask user immediately instead of over-exploring
-</rules>
-
-<success_criteria>
-
-- Feature implemented following existing codebase patterns
-- Code passes linting and type checking
-- Implementation stays strictly within requested scope
-- No unnecessary comments or refactoring
-- Autoformatting applied where available
-  </success_criteria>