azclaude-copilot 0.1.0

package/templates/commands/create.md

@@ -0,0 +1,156 @@
+---
+name: create
+description: >
+  Build a new command/skill with proper frontmatter, test cases, and evaluation.
+  Guided workflow: intent → draft → test → iterate. Creates production-quality commands.
+  Triggers on: "create skill", "new command", "build a skill for", "make a command",
+  "I want a slash command that", "create a workflow for".
+argument-hint: "[what the skill should do]"
+disable-model-invocation: true
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# /create — Skill Creator
+
+$ARGUMENTS
+
+---
+
+## Phase 1: Intent Capture
+
+If $ARGUMENTS is blank or vague, use **AskUserQuestion**:
+- What should this skill do? (specific action, not category)
+- When should it trigger? (what phrases or situations)
+- What tools does it need? (Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch)
+- Should it modify files or just report? (read-only vs read-write)
+
+---
+
+## Phase 2: Check for Duplicates
+
+Before creating, check if something similar exists:
+
+```bash
+# Check project commands
+grep -li "{keyword}" .claude/commands/*.md 2>/dev/null
+
+# Check shared skills
+grep -li "{keyword}" ~/shared-skills/*.md 2>/dev/null
+
+# Check capabilities
+grep -i "{keyword}" .claude/capabilities/manifest.md 2>/dev/null
+```
+
+If a match exists: show it. Ask if the user wants to extend it instead of creating new.
+
+---
+
+## Phase 3: Draft the Skill
+
+Create `.claude/commands/{name}.md` with this structure:
+
+```markdown
+---
+name: {name}
+description: >
+  {What it does. Include 5+ trigger phrases for reliable invocation.}
+argument-hint: "[{what args it takes}]"
+disable-model-invocation: true
+allowed-tools: {tools list}
+---
+
+# /{name} — {Title}
+
+$ARGUMENTS
+
+---
+
+## Step 1: {First action}
+{Clear instructions — what to read, check, or prepare}
+
+---
+
+## Step 2: {Main action}
+{The core work — what to do, how to do it}
+
+---
+
+## Step 3: {Verify}
+{How to confirm it worked — show output, run tests}
+
+---
+
+## Completion Rule
+{What to show as proof — never say "done" without evidence}
+```
+
+**Guidelines:**
+- Description must have 5+ trigger phrases (Claude under-triggers with fewer)
+- Use `disable-model-invocation: true` unless the skill needs free-form reasoning
+- Include a completion rule — every skill must show proof of work
+- Use `$ARGUMENTS` to accept user input
+- Include **AskUserQuestion** fallback for blank arguments
+- Match the style of existing commands in this project
+
+---
+
+## Phase 4: Generate Test Cases
+
+Create 2-3 test prompts to verify the skill works:
+
+```bash
+mkdir -p .claude/evals
+```
+
+Write `.claude/evals/{name}-tests.md`:
+
+```markdown
+# Test Cases: /{name}
+
+## Test 1: Basic usage
+Prompt: "/{name} {typical argument}"
+Expected: {what should happen}
+
+## Test 2: No arguments
+Prompt: "/{name}"
+Expected: AskUserQuestion should trigger
+
+## Test 3: Edge case
+Prompt: "/{name} {unusual input}"
+Expected: {graceful handling}
+```
+
+---
+
+## Phase 5: Validate
+
+1. Read the created skill file — verify frontmatter is correct
+2. Check it appears in the commands list:
+```bash
+ls .claude/commands/{name}.md
+```
+3. Verify description has 5+ trigger phrases
+4. Verify completion rule exists
+
+---
+
+## Phase 6: Register (if needed)
+
+If this is a command that should ship with azclaude (not just this project):
+- Add to `COMMANDS` array in `bin/cli.js`
+- Add to `templates/commands/`
+- Add tests to `tests/test-features.sh`
+- Add dispatch entry to `templates/CLAUDE.md`
+
+For project-only skills: no registration needed — it's already in `.claude/commands/`.
+
+---
+
+## Completion Rule
+
+Show:
+1. The created skill file content
+2. The test cases
+3. How to invoke: `/{name} [args]`
+
+Do not say "skill created" without showing the file content.

package/templates/commands/debate.md

@@ -0,0 +1,75 @@
+---
+name: debate
+description: Adversarial decision protocol for hard architectural choices. Opt-in only — not for routine decisions.
+argument-hint: "[decision or tradeoff to evaluate]"
+disable-model-invocation: true
+---
+
+# /debate — Adversarial Decision Protocol
+
+$ARGUMENTS
+
+---
+
+---
+
+## When to Use This
+
+Use when:
+- The decision is genuinely uncertain
+- Multiple criteria are in tension
+- Getting it wrong costs real time to reverse
+
+Do NOT use when:
+- The answer is obvious on reflection
+- The decision is reversible and low-cost
+- You just want validation — ask directly instead
+
+---
+
+## Copilot Mode Detection
+
+```bash
+[ -f .claude/copilot-intent.md ] && echo "COPILOT_MODE" || echo "INTERACTIVE_MODE"
+```
+
+If `COPILOT_MODE`:
+- Skip AskUserQuestion — read `.claude/memory/blockers.md` for the blocker context
+- The decision to debate is: how to unblock the stuck milestone
+- Frame options from: the error message, what was tried, and alternative approaches
+- After debate concludes: return the winning approach to /copilot for implementation
+- Record decision in `.claude/memory/decisions.md` as normal
+
+If `INTERACTIVE_MODE`: run Frame the Decision as normal.
+
+---
+
+## Frame the Decision
+
+If $ARGUMENTS is vague (no clear options stated), use **AskUserQuestion**:
+- What are the options being considered?
+- What constraint matters most? (performance / maintainability / cost / speed)
+- What would make this decision irreversible or costly to reverse?
+
+Do not proceed without clear options.
+
+---
+
+## Run the Debate
+
+**EnterPlanMode** — the debate protocol is analysis only. No files touched during debate.
+
+Read `capabilities/intelligence/debate.md` and execute the full protocol.
+
+If the decision involves ranking multiple options (not binary):
+Also read `capabilities/intelligence/elo.md` for pairwise ranking.
+
+---
+
+## Completion Rule
+
+**ExitPlanMode** — now record the decision.
+
+State the winner, the confidence level, and the one verified claim that decided it.
+Record the decision in `.claude/memory/decisions.md`.
+Do not say "I recommend X" without showing the evidence-weighted reasoning.

package/templates/commands/deps.md

@@ -0,0 +1,112 @@
+---
+name: deps
+description: >
+  Audit project dependencies. Find outdated, vulnerable, and unused packages.
+  Triggers on: "audit", "dependencies", "outdated packages", "vulnerable",
+  "unused imports", "npm audit", "security scan", "check deps", "update packages".
+argument-hint: "[optional: 'outdated', 'security', 'unused', or blank for full audit]"
+disable-model-invocation: true
+allowed-tools: Read, Bash, Glob, Grep
+---
+
+# /deps — Dependency Audit
+
+$ARGUMENTS
+
+---
+
+## Step 1: Detect Package Manager
+
+```bash
+ls package.json package-lock.json yarn.lock pnpm-lock.yaml requirements.txt \
+   pyproject.toml Cargo.toml go.mod Gemfile 2>/dev/null
+```
+
+---
+
+## Step 2: Outdated Check
+
+```bash
+# Node.js
+npm outdated 2>&1
+
+# Python
+pip list --outdated 2>&1 | head -20
+
+# Go
+go list -m -u all 2>&1 | head -20
+```
+
+Classify each outdated package:
+| Type | Risk | Action |
+|------|------|--------|
+| Patch (1.0.0 → 1.0.1) | Low | Update immediately |
+| Minor (1.0.0 → 1.1.0) | Medium | Review changelog, then update |
+| Major (1.0.0 → 2.0.0) | High | Use `/migrate` — breaking changes likely |
+
+---
+
+## Step 3: Security Audit
+
+```bash
+# Node.js
+npm audit 2>&1
+
+# Python
+pip audit 2>&1 || safety check 2>&1
+
+# Go
+govulncheck ./... 2>&1
+```
+
+For each vulnerability:
+```
+Package:    {name}
+Severity:   {critical|high|medium|low}
+CVE:        {ID}
+Fix:        {version that patches it}
+```
+
+---
+
+## Step 4: Unused Dependencies (if $ARGUMENTS includes 'unused' or is blank)
+
+```bash
+# Node.js — check package.json deps vs actual imports
+cat package.json | grep -A 100 '"dependencies"' | grep '"' | sed 's/.*"\(.*\)".*/\1/' | while read pkg; do
+  grep -r "$pkg" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" \
+    -l 2>/dev/null | head -1 | grep -q . || echo "UNUSED: $pkg"
+done
+
+# Python — check imports vs requirements
+cat requirements.txt 2>/dev/null | sed 's/[>=<].*//' | while read pkg; do
+  grep -r "$pkg" --include="*.py" -l 2>/dev/null | head -1 | grep -q . || echo "UNUSED: $pkg"
+done
+```
+
+---
+
+## Output Format
+
+```
+## Dependency Audit — {project name}
+
+### Outdated ({count})
+| Package | Current | Latest | Type | Risk |
+|---------|---------|--------|------|------|
+
+### Vulnerabilities ({count})
+| Package | Severity | CVE | Fix Version |
+|---------|----------|-----|-------------|
+
+### Unused ({count})
+| Package | Last import found |
+|---------|-------------------|
+
+### Recommended Actions
+1. {highest priority action}
+2. {next action}
+3. {next action}
+```
+
+Do not say "audit complete" without showing the tables.

package/templates/commands/doc.md

@@ -0,0 +1,100 @@
+---
+name: doc
+description: >
+  Generate or update documentation from code. JSDoc, docstrings, README sections,
+  API docs, inline comments. Reads the actual code — never guesses signatures.
+  Triggers on: "document", "add docs", "generate docs", "update README",
+  "add JSDoc", "add docstrings", "API docs", "explain this code in docs".
+argument-hint: "[file, function, or 'readme' to update]"
+disable-model-invocation: true
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# /doc — Generate Documentation
+
+$ARGUMENTS
+
+---
+
+## Phase 1: Detect Scope
+
+If $ARGUMENTS is blank, use **AskUserQuestion**:
+- What needs documenting? (specific file, function, or project-level README)
+- What format? (JSDoc, docstring, README section, API reference)
+
+Detect documentation style already in the project:
+```bash
+# Check existing doc patterns
+grep -r "\/\*\*" --include="*.ts" --include="*.js" -l | head -5
+grep -r '"""' --include="*.py" -l | head -5
+grep -r "\/\/\/" --include="*.go" -l | head -5
+```
+
+**Rule: match the existing doc style.** If the project uses JSDoc, write JSDoc. If it uses Google-style docstrings, use that. Never introduce a new doc format.
+
+---
+
+## Phase 2: Read the Code
+
+Read every function/class/module you're documenting. Extract:
+- Function signature (params, return type)
+- What it actually does (read the implementation)
+- Edge cases and error conditions
+- Dependencies and side effects
+
+**Never document from memory or inference.** Read the code, then write the doc.
+
+```bash
+# For a specific file
+cat {file} | head -100
+# For all exports
+grep -n "export\|module.exports\|def \|func \|public " {file}
+```
+
+---
+
+## Phase 3: Write Documentation
+
+### For inline docs (JSDoc / docstrings):
+- One doc block per public function/method/class
+- Include: description, @param types, @returns, @throws
+- Skip private/internal functions unless explicitly asked
+- Keep descriptions to 1-2 sentences — what it does, not how
+
+### For README sections:
+- Read existing README first — update, don't duplicate
+- Sections: Installation, Usage, API, Configuration, Examples
+- Include real code examples that actually work
+- Run any example code to verify it works:
+```bash
+# Verify example works
+node -e "{example code}" 2>&1 | head -10
+```
+
+### For API reference:
+- Group by module/file
+- Table format: `| Function | Params | Returns | Description |`
+- Include example usage for each endpoint/function
+
+---
+
+## Phase 4: Verify
+
+1. Check docs match the actual code — no stale signatures
+2. If examples were written: run them to verify
+3. Lint check if doc linter exists:
+```bash
+# Check for doc linters
+npx tsc --noEmit 2>&1 | grep "JSDoc" | head -5
+```
+
+---
+
+## Completion Rule
+
+Show:
+1. List of documented items: `file:line — function/class name`
+2. Sample of the generated docs (first 2-3 blocks)
+3. Verification that examples work (if applicable)
+
+Do not say "docs updated" without showing what was written.

package/templates/commands/dream.md

@@ -0,0 +1,120 @@
+---
+name: dream
+description: Build a project from an idea — scaffolds rules file, memory, skills, and agents level by level.
+argument-hint: "[project idea and tech stack]"
+disable-model-invocation: true
+context: fork
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Agent
+---
+
+# /dream — Build a Project From an Idea
+
+$ARGUMENTS
+
+---
+
+## Copilot Mode Detection
+
+```bash
+[ -f .claude/copilot-intent.md ] && echo "COPILOT_MODE" || echo "INTERACTIVE_MODE"
+```
+
+If `COPILOT_MODE`: skip Phase 1 (AskUserQuestion). Read `.claude/copilot-intent.md` as the
+complete input — it contains the product description, stack, and scope. Extract answers to
+all four questions below from the intent file. If any are missing, infer reasonable defaults
+from the intent rather than asking the user.
+
+If `INTERACTIVE_MODE`: run Phase 1 as normal.
+
+---
+
+## Phase 1: Structured Intake
+
+**Use AskUserQuestion** to collect all context in one shot. Do not ask in prose.
+
+Ask these questions:
+- **What do you want to build?** — the core problem it solves, not just the feature list
+- **Tech stack** — what technologies, or "help me choose"
+- **Who uses this?** — developers / end users / internal team
+- **What is explicitly OUT of scope for v1?** — prevents scope creep from the start
+
+If $ARGUMENTS already answers one of these clearly, pre-fill it and only ask what's missing.
+
+Do not proceed to Phase 2 until all four answers are collected (or extracted from copilot-intent.md).
+
+---
+
+## Phase 2: Environment Scan
+
+Use **EnterPlanMode** — read the environment, do not touch files yet.
+
+```bash
+[ -f CLAUDE.md ] && echo "CLAUDE.md exists" || echo "clean slate"
+[ -d .claude ] && ls .claude/ || echo "no .claude dir"
+```
+
+Read `.claude/capabilities/manifest.md` if it exists.
+
+Detect current level (0–7) from what's present.
+
+**ExitPlanMode** — ready to build.
+
+---
+
+## Phase 3: Build Level by Level
+
+Create **TaskCreate** entries before starting — one per level to build:
+- `L1: CLAUDE.md — rules file`
+- `L2: MCP config`
+- `L3: Skills — project commands`
+- `L4: Memory — goals.md`
+- `L5: Agents`
+- `L6: Hooks`
+- (only create tasks for levels not yet present)
+
+For each level:
+1. **TaskUpdate → in_progress**
+2. Read the matching `capabilities/level-builders/level{N}.md` — load ONE at a time
+3. Execute what it says using answers from Phase 1 as input
+4. Show what was created: file path + one-line purpose
+5. **TaskUpdate → completed**
+
+Spawn `agents/orchestrator-init.md` to fill CLAUDE.md and goals.md with the actual project data.
+
+If tech stack is unfamiliar → **WebSearch** "{stack} project structure best practices {year}" before scaffolding.
+
+---
+
+## Phase 3b: Generate Domain Advisor Skill
+
+After detecting the project domain in Phase 1/2:
+
+1. Read `capabilities/shared/domain-advisor-generator.md`
+2. If domain is NOT pure developer (compliance, marketing, finance, medical, research, legal, logistics):
+   - Generate `{domain}-advisor/` skill using the domain template
+   - Include decision matrices, thresholds, and anti-patterns
+   - Run `skill-creator` quality checklist
+3. If domain IS developer → `architecture-advisor` already covers this (installed by default)
+4. For multi-domain projects → generate one advisor per domain
+
+This gives the copilot evidence-based guidance for domain-specific decisions,
+not just code patterns.
+
+---
+
+## Phase 4: Quality Gate
+
+Load `capabilities/shared/quality-check.md` and run all checks.
+All ✓ required before printing "project ready."
+
+---
+
+## Completion Rule
+
+Show:
+1. The created `CLAUDE.md` (full content)
+2. The created `goals.md` (full content)
+3. The level checklist (what was built)
+4. First task to work on
+
+Do not say "project ready" without showing these four outputs.