@vpxa/aikit 0.1.74 → 0.1.76

package/scaffold/dist/definitions/prompts.mjs

@@ -0,0 +1,225 @@
+const e={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\n\n1. **Parse Error** — Use `parse_output` on the error message/stack trace\n2. **AI Kit Recall** — Search for known issues matching this pattern\n3. **Reproduce** — Run the failing command/test to confirm\n4. **Trace** — Use `symbol` and `trace` to follow the call chain\n5. **Diagnose** — Form hypothesis, gather evidence\n6. **Fix** — Implement minimal fix\n7. **Verify** — `check` + `test_run` to confirm fix and no regressions\n8. **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`}};export{e as PROMPTS};