@vpxa/aikit 0.1.77 → 0.1.78

package/scaffold/definitions/prompts.mjs

@@ -1,365 +0,0 @@
-/**
- * Prompt/command definitions — IDE-agnostic workflow triggers.
- *
- * Copilot: .prompt.md files in .github/prompts/
- * Claude Code: Maps to CLAUDE.md slash commands
- * Claude Code: Slash commands
- *
- * Each prompt defines: description, target agent, required tools, and content.
- */
-
-export const PROMPTS = {
-  ask: {
-    description: 'Quick research question — find answer using AI Kit + web search',
-    agent: 'Researcher-Alpha',
-    tools: ['search', 'web_search', 'web_fetch', 'compact', 'file_summary', 'remember', 'present'],
-    content: `## Quick Research
-
-1. **AI Kit Recall** — Search knowledge base for existing answers
-2. **Web Search** — If AI Kit has no relevant results, search the web
-3. **Synthesize** — Combine findings into a clear, concise answer
-4. **Remember** — If the answer is broadly useful, persist it to KB
-
-**Always cite sources** — AI Kit entries, file paths, or URLs.`,
-  },
-
-  debug: {
-    description: 'Systematic error diagnosis: reproduce → trace → diagnose → fix → verify',
-    agent: 'Debugger',
-    tools: [
-      'search',
-      'symbol',
-      'trace',
-      'blast_radius',
-      'check',
-      'test_run',
-      'parse_output',
-      'compact',
-      'remember',
-      'present',
-    ],
-    content: `## Debug Workflow
-
-1. **Parse Error** — Use \`parse_output\` on the error message/stack trace
-2. **AI Kit Recall** — Search for known issues matching this pattern
-3. **Reproduce** — Run the failing command/test to confirm
-4. **Trace** — Use \`symbol\` and \`trace\` to follow the call chain
-5. **Diagnose** — Form hypothesis, gather evidence
-6. **Fix** — Implement minimal fix
-7. **Verify** — \`check\` + \`test_run\` to confirm fix and no regressions
-8. **Remember** — Persist the fix with category \`troubleshooting\``,
-  },
-
-  implement: {
-    description: 'Full lifecycle implementation: plan → build → review → commit',
-    agent: 'Orchestrator',
-    tools: [
-      'search',
-      'scope_map',
-      'forge_ground',
-      'check',
-      'test_run',
-      'blast_radius',
-      'remember',
-      'audit',
-      'present',
-    ],
-    content: `## Implementation Pipeline
-
-Follow the Orchestrator's full workflow:
-
-1. **Phase 0: Design Gate** — Orchestrator checks if design is needed. Creative/additive work triggers brainstorming first. Use \`/design\` if you want to start with design explicitly.
-2. **Phase 1: Planning** — Research, draft plan, present to user for approval
-3. **Phase 2: Implementation** — Execute phases in parallel batches
-4. **Phase 3: Completion** — Final review, docs, persist learnings
-
-**🛑 MANDATORY STOPS** — After plan, after each batch, after completion.
-
-Refer to the Orchestrator agent's full instructions for the detailed workflow.`,
-  },
-
-  plan: {
-    description: 'Create a detailed TDD implementation plan without executing it',
-    agent: 'Planner',
-    tools: [
-      'search',
-      'scope_map',
-      'forge_ground',
-      'forge_classify',
-      'file_summary',
-      'analyze_structure',
-      'analyze_dependencies',
-      'remember',
-      'present',
-    ],
-    content: `## Planning Workflow
-
-1. **AI Kit Recall** — Search for past plans, architecture decisions
-2. **FORGE Ground** — Classify tier, scope map, seed unknowns
-3. **Research** — Explore codebase, understand subsystems
-4. **Draft Plan** — 3-10 phases with agent assignments, TDD steps
-5. **Dependency Graph** — Group into parallel batches
-6. **Present** — Show plan with open questions
-
-**🛑 MANDATORY STOP** — Wait for user approval. Do NOT implement.`,
-  },
-
-  design: {
-    description:
-      'Collaborative design session — explore ideas, refine requirements, produce a design spec',
-    agent: 'Orchestrator',
-    tools: [
-      'search',
-      'scope_map',
-      'file_summary',
-      'compact',
-      'remember',
-      'forge_classify',
-      'present',
-    ],
-    content: `## Design Session
-
-Enter Phase 0 (Design Gate) directly — the user is requesting a design session.
-
-1. **Invoke the brainstorming skill** — interactive design dialogue with user
-2. Follow the skill's full process (auto-selects Simple or Advanced mode)
-3. If Advanced Mode, use Decision Protocol for unresolved technical choices
-4. Terminal state: brainstorming skill invokes writing-plans skill
-
-**🛑 HARD GATE** — Do NOT skip brainstorming. Do NOT write code. Design first.`,
-  },
-
-  review: {
-    description: 'Dual-model code + architecture review pipeline',
-    agent: 'Orchestrator',
-    tools: [
-      'search',
-      'blast_radius',
-      'check',
-      'test_run',
-      'analyze_dependencies',
-      'remember',
-      'present',
-    ],
-    content: `## Review Pipeline
-
-### Step 1: Scope
-Identify changed files and their blast radius.
-
-### Step 2: Code Review (parallel)
-Launch Code-Reviewer-Alpha and Code-Reviewer-Beta on the same changeset.
-
-### Step 3: Architecture Review (if needed)
-If changes cross service boundaries or modify interfaces, launch Architect-Reviewer-Alpha and Architect-Reviewer-Beta.
-
-### Step 4: Synthesis
-Merge findings from both reviewers:
-- **Agreements**: Both found same issue → HIGH confidence
-- **Unique findings**: One found, other didn't → verify
-- **Disagreements**: Contradicting verdicts → present both to user
-
-### Step 5: Report
-Present unified review with: verdict, findings by severity, recommended actions.`,
-  },
-
-  'flow-add': {
-    description:
-      'Install a new flow from a git URL or local path — with interactive error recovery',
-    agent: 'Orchestrator',
-    tools: ['flow_add', 'flow_list', 'flow_info', 'search', 'compact', 'file_summary', 'present'],
-    content: `## Flow Installation Assistant
-
-Install a development flow from a git repository or local directory.
-
-### Usage
-Provide a git URL or local path:
-- \`https://github.com/org/my-flow.git\`
-- \`git@github.com:org/my-flow.git\`
-- \`./path/to/local/flow\`
-- \`C:\\Users\\name\\flows\\my-flow\`
-
-### Workflow
-
-1. **Attempt Install** — Call \`flow_add\` with the provided source
-2. **On Success** — Show installed flow info with \`flow_info\`, present summary to user
-3. **On Failure** — Classify the error and enter the appropriate recovery path:
-
-### Error Recovery Paths
-
-#### Git Authentication Failure
-If the error mentions authentication, credentials, 401, 403, permission denied, or SAML:
-
-1. Present the error clearly to the user
-2. Ask which auth method they prefer:
-   - **SSH key**: Walk through \`ssh-keygen -t ed25519\`, adding the public key to their git host, and retrying with the SSH URL
-   - **Personal Access Token (PAT)**: Guide them to create a PAT in their git host settings, configure \`git credential.helper store\`, and retry
-   - **Git Credential Manager**: Check if GCM is installed, help install if needed, then retry (GCM opens a browser for auth)
-3. After credentials are configured, retry \`flow_add\`
-
-#### Network / Connectivity Failure
-If the error mentions timeout, host not found, SSL, or proxy:
-
-1. Present diagnostics: Is VPN needed? Is the URL correct? Is there a proxy?
-2. Guide the user through resolution
-3. Retry after the issue is resolved
-
-#### Format Not Recognized
-If \`flow_add\` succeeds cloning but returns a format/structure error:
-
-1. Explain that the source was fetched but doesn't match any supported format
-2. List the 3 supported formats:
-   - **Native**: Has a \`flow.json\` manifest in the root
-   - **Claude Plugin**: Has \`.claude-plugin/plugin.json\` with skills as steps
-   - **Copilot Agents**: Has \`.github/agents/\` with agent .md files as steps
-3. Analyze the source structure to understand what's there
-4. Offer to help migrate:
-   - If it has README files or markdown docs → propose creating a \`flow.json\` that maps them as steps
-   - If it has a different workflow format → propose conversion
-   - If it's missing key parts → guide user to fill them in
-5. Create the missing \`flow.json\` manifest and step structure
-6. Retry \`flow_add\` with the fixed source
-
-### Native flow.json Format Reference
-\`\`\`json
-{
-  "name": "my-flow",
-  "version": "1.0.0",
-  "description": "Description of the flow",
-  "steps": [
-    {
-      "id": "step-id",
-      "name": "Step Name",
-      "instruction": "steps/step-id/README.md",
-      "produces": ["output.md"],
-      "requires": [],
-      "agents": [],
-      "description": "What this step does"
-    }
-  ],
-  "agents": [],
-  "artifacts_dir": ".spec",
-  "install": []
-}
-\`\`\`
-
-### Post-Install
-After successful installation:
-- Show the flow name, steps, and description via \`present\`
-- Remind user they can start it with \`flow_start\``,
-  },
-
-  'flow-manage': {
-    description: 'List, inspect, update, and remove installed flows',
-    agent: 'Orchestrator',
-    tools: [
-      'flow_list',
-      'flow_info',
-      'flow_status',
-      'flow_update',
-      'flow_remove',
-      'flow_start',
-      'flow_reset',
-      'present',
-    ],
-    content: `## Flow Management
-
-Manage your installed development flows.
-
-### Available Actions
-
-1. **List flows** — \`flow_list\` to see all installed flows with status
-2. **Inspect a flow** — \`flow_info\` to see detailed steps, agents, and artifacts
-3. **Check status** — \`flow_status\` to see the active flow and current step
-4. **Update a flow** — \`flow_update\` to pull latest changes for git-installed flows
-5. **Remove a flow** — \`flow_remove\` to uninstall (builtin flows cannot be removed)
-6. **Start a flow** — \`flow_start\` to begin executing a flow
-7. **Reset active flow** — \`flow_reset\` to clear active flow state
-
-### Workflow
-1. If no specific action requested, start with \`flow_list\` and present overview
-2. Use \`present\` to display flow information in a clear table/card format
-3. For updates, warn if there's an active flow that might be affected
-4. For removals, confirm with user before proceeding`,
-  },
-
-  'flow-create': {
-    description: 'Create a new flow from scratch or migrate an existing workflow to aikit format',
-    agent: 'Orchestrator',
-    tools: ['flow_add', 'flow_list', 'flow_info', 'search', 'compact', 'file_summary', 'present'],
-    content: `## Flow Creation Assistant
-
-Create a new development flow or migrate an existing workflow to the aikit flow format.
-
-### Mode 1: Create from Scratch
-
-Guide the user through building a complete flow:
-
-1. **Define the workflow** — Ask what the flow should accomplish (e.g., "TDD workflow", "documentation pipeline", "migration process")
-2. **Design steps** — Break the workflow into sequential steps (3-8 is ideal)
-3. **For each step**:
-   - Define the step id, name, and description
-   - Write the instruction (README.md content — what the agent should do)
-   - Identify what it produces (output artifacts)
-   - Identify what it requires (which previous steps must complete first)
-   - Optionally assign preferred agents
-4. **Generate flow.json** — Create the manifest with all steps
-5. **Write step READMEs** — Create instruction files for each step
-6. **Install** — Use \`flow_add\` to install from the local directory
-
-### Mode 2: Migrate Existing Workflow
-
-If the user has an existing workflow (scripts, docs, runbooks) that they want to convert:
-
-1. **Analyze the source** — Read the existing workflow files to understand the process
-2. **Map to steps** — Identify discrete steps with clear inputs/outputs
-3. **Identify gaps** — What's missing for a complete flow? (instructions? ordering? agents?)
-4. **Fill gaps with user** — Ask user to clarify any ambiguous parts
-5. **Generate the flow** — Create flow.json + step READMEs
-6. **Install and validate** — Use \`flow_add\` and \`flow_info\` to verify
-
-### Flow Structure
-
-\`\`\`
-my-flow/
-  flow.json              — Flow manifest (name, version, steps, agents)
-  steps/
-    step-1/
-      README.md          — Step instructions (what the agent should do)
-    step-2/
-      README.md
-      references/        — Optional reference files for the step
-    ...
-\`\`\`
-
-### flow.json Format
-\`\`\`json
-{
-  "name": "my-flow",
-  "version": "1.0.0",
-  "description": "What this flow does",
-  "steps": [
-    {
-      "id": "step-id",
-      "name": "Human-readable Step Name",
-      "instruction": "steps/step-id/README.md",
-      "produces": ["artifact-name.md"],
-      "requires": [],
-      "agents": ["Preferred-Agent"],
-      "description": "Brief description of this step"
-    }
-  ],
-  "agents": [],
-  "artifacts_dir": ".spec",
-  "install": []
-}
-\`\`\`
-
-### Step README Format
-Each step README should include:
-- **Goal** — What this step accomplishes
-- **Inputs** — What context/artifacts from prior steps are needed
-- **Instructions** — Detailed steps for the agent to follow
-- **Output** — What artifact(s) to produce and where to save them
-- **Acceptance criteria** — How to know the step is complete`,
-  },
-};