supipowers 0.2.6 → 0.3.0

package/src/discipline/tdd.ts

@@ -0,0 +1,77 @@
+/**
+ * TDD enforcement instructions for sub-agent prompts.
+ * Matches superpowers' test-driven-development skill depth.
+ */
+export function buildTddInstructions(): string {
+  return [
+    "## Test-Driven Development",
+    "",
+    "### Iron Law",
+    "",
+    "NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST.",
+    "",
+    "Write code before the test? Delete it. Start over.",
+    "",
+    "### Red-Green-Refactor Cycle",
+    "",
+    "**RED — Write failing test:**",
+    "- One behavior per test, clear name, real code (no mocks unless unavoidable)",
+    "- Watch it fail. MANDATORY. Never skip.",
+    "- Confirm: test fails (not errors), failure message is expected, fails because feature is missing",
+    "- Test passes? You're testing existing behavior. Fix the test.",
+    "",
+    "**GREEN — Write the simplest code to pass:**",
+    "- Minimal, simplest code that makes the test pass",
+    "- Don't add features, refactor other code, or improve beyond the test",
+    "- Watch it pass. MANDATORY.",
+    "- Confirm: test passes, other tests still pass, output pristine",
+    "- Test fails? Fix code, not test. Other tests fail? Fix now.",
+    "",
+    "**REFACTOR — Clean up (after green only):**",
+    "- Remove duplication, improve names, extract helpers",
+    "- Keep tests green. Don't add behavior.",
+    "",
+    "### Verification Checklist",
+    "",
+    "Before marking work complete:",
+    "- Every new function/method has a test",
+    "- Watched each test fail before implementing",
+    "- Each test failed for expected reason (feature missing, not typo)",
+    "- Wrote minimal code to pass each test",
+    "- All tests pass with pristine output",
+    "- Tests use real code (mocks only if unavoidable)",
+    "- Edge cases and errors covered",
+    "",
+    "### Red Flags — STOP and Start Over",
+    "",
+    "- Code before test",
+    "- Test after implementation",
+    "- Test passes immediately",
+    "- Can't explain why test failed",
+    "- Tests added later",
+    "- Rationalizing \"just this once\"",
+    "",
+    "### Testing Anti-Patterns",
+    "",
+    "- Don't test mock behavior instead of real behavior",
+    "- Don't add test-only methods to production classes",
+    "- Don't mock without understanding dependencies",
+    "- Don't use incomplete mocks (partial data structures)",
+    "- Mocks are tools to isolate, not things to test",
+    "",
+    "### When Stuck",
+    "",
+    "| Problem | Solution |",
+    "|---------|----------|",
+    "| Don't know how to test | Write wished-for API. Write assertion first. Ask. |",
+    "| Test too complicated | Design too complicated. Simplify interface. |",
+    "| Must mock everything | Code too coupled. Use dependency injection. |",
+    "| Test setup huge | Extract helpers. Still complex? Simplify design. |",
+    "",
+    "### Bug Fix Flow",
+    "",
+    "Bug found? Write a failing test reproducing it first.",
+    "Follow the TDD cycle. The test proves the fix and prevents regression.",
+    "Never fix bugs without a failing test.",
+  ].join("\n");
+}

package/src/discipline/verification.ts

@@ -0,0 +1,68 @@
+/**
+ * Verification-before-completion instructions for sub-agent prompts.
+ * Matches superpowers' verification-before-completion skill depth.
+ */
+export function buildVerificationInstructions(): string {
+  return [
+    "## Verification Before Completion",
+    "",
+    "### Iron Law",
+    "",
+    "NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE.",
+    "Evidence before assertions, always.",
+    "",
+    "### The Gate Function (Mandatory Before Any Status Claim)",
+    "",
+    "1. **IDENTIFY:** What command proves this claim?",
+    "2. **RUN:** Execute the FULL command (fresh, complete).",
+    "3. **READ:** Full output. Check exit code. Count failures.",
+    "4. **VERIFY:** Does output confirm the claim?",
+    "   - If NO: State actual status with evidence.",
+    "   - If YES: State claim WITH evidence.",
+    "5. **ONLY THEN:** Make the claim.",
+    "",
+    "Skip any step = lying, not verifying.",
+    "",
+    "### Common Failure Patterns",
+    "",
+    "| Claim | Requires | Not Sufficient |",
+    "|-------|----------|----------------|",
+    "| Tests pass | Test command output: 0 failures | Previous run, \"should pass\" |",
+    "| Build succeeds | Build command: exit 0 | Linter passing, logs look good |",
+    "| Bug fixed | Test original symptom: passes | Code changed, assumed fixed |",
+    "| Regression test works | Red-green cycle verified | Test passes once |",
+    "| Agent completed | VCS diff shows changes | Agent reports \"success\" |",
+    "| Requirements met | Line-by-line checklist | Tests passing |",
+    "",
+    "### Red Flags — STOP Before Claiming",
+    "",
+    "- Using \"should\", \"probably\", \"seems to\"",
+    "- Expressing satisfaction before verification (\"Great!\", \"Perfect!\", \"Done!\")",
+    "- About to commit/push/PR without verification",
+    "- Trusting agent success reports without checking",
+    "- Relying on partial verification",
+    "- Thinking \"just this once\"",
+    "",
+    "### Verification Patterns",
+    "",
+    "**Tests:**",
+    "- Run test command → see actual pass count → then claim",
+    "- Never say \"should pass now\" or \"looks correct\"",
+    "",
+    "**Regression tests (TDD red-green):**",
+    "- Write → Run (pass) → Revert fix → Run (MUST FAIL) → Restore → Run (pass)",
+    "- Never say \"I've written a regression test\" without red-green verification",
+    "",
+    "**Build:**",
+    "- Run build → see exit 0 → then claim",
+    "- Linter passing does not prove compilation",
+    "",
+    "**Requirements:**",
+    "- Re-read plan → create checklist → verify each → report gaps or completion",
+    "- Never say \"tests pass, phase complete\" without checking requirements",
+    "",
+    "**Agent delegation:**",
+    "- Agent reports success → check VCS diff → verify changes → report actual state",
+    "- Never trust agent report without independent verification",
+  ].join("\n");
+}

package/src/git/branch-finish.ts

@@ -0,0 +1,101 @@
+export interface FinishOption {
+  id: "merge" | "pr" | "keep" | "discard";
+  label: string;
+}
+
+/** The 4 structured options for finishing a branch */
+export const FINISH_OPTIONS: FinishOption[] = [
+  { id: "merge", label: "Merge back to base branch locally" },
+  { id: "pr", label: "Push and create a Pull Request" },
+  { id: "keep", label: "Keep the branch as-is (handle later)" },
+  { id: "discard", label: "Discard this work" },
+];
+
+export interface BranchFinishPromptOptions {
+  branchName: string;
+  baseBranch: string;
+  worktreePath?: string;
+}
+
+/**
+ * Build the prompt that guides the agent through finishing a development branch.
+ * Follows superpowers' finishing-a-development-branch skill:
+ * - Verify tests pass first
+ * - Present exactly 4 options
+ * - Execute chosen option
+ * - Clean up worktree (conditional)
+ */
+export function buildBranchFinishPrompt(options: BranchFinishPromptOptions): string {
+  const { branchName, baseBranch, worktreePath } = options;
+
+  const sections: string[] = [
+    "## Finish Development Branch",
+    "",
+    `Branch: \`${branchName}\` (base: \`${baseBranch}\`)`,
+    "",
+    "### Step 1: Verify tests pass",
+    "",
+    "Run the full test suite. All tests must pass before proceeding.",
+    "If tests fail, fix them first — do not offer options until green.",
+    "",
+    "### Step 2: Present options",
+    "",
+    "Ask the user:",
+    "",
+    "> Implementation complete. What would you like to do?",
+    ">",
+    `> 1. Merge back to \`${baseBranch}\` locally`,
+    "> 2. Push and create a Pull Request",
+    "> 3. Keep the branch as-is (handle later)",
+    "> 4. Discard this work",
+    "",
+    "### Option 1: Merge locally",
+    "",
+    "```bash",
+    `git checkout ${baseBranch}`,
+    "git pull",
+    `git merge ${branchName}`,
+    "# Verify tests pass on merged result",
+    `git branch -d ${branchName}`,
+    "```",
+    "",
+    "### Option 2: Push and create Pull Request",
+    "",
+    "```bash",
+    `git push -u origin ${branchName}`,
+    `gh pr create --title "<title>" --body "<summary>"`,
+    "```",
+    "",
+    "### Option 3: Keep as-is",
+    "",
+    `Report: "Keeping branch ${branchName}."`,
+    "Do NOT clean up worktree.",
+    "",
+    "### Option 4: Discard",
+    "",
+    "**Require explicit confirm before deleting.** Show what will be lost:",
+    "",
+    "```bash",
+    `git checkout ${baseBranch}`,
+    `git branch -D ${branchName}`,
+    "```",
+  ];
+
+  if (worktreePath) {
+    sections.push(
+      "",
+      "### Worktree cleanup",
+      "",
+      `Worktree at: \`${worktreePath}\``,
+      "",
+      "- **Options 1 and 4:** Clean up the worktree:",
+      "  ```bash",
+      `  git worktree remove ${worktreePath}`,
+      "  ```",
+      "- **Option 2:** Keep worktree (PR may need updates)",
+      "- **Option 3:** Keep worktree",
+    );
+  }
+
+  return sections.join("\n");
+}

package/src/git/worktree.ts

@@ -0,0 +1,119 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface ProjectSetup {
+  type: "node" | "rust" | "python" | "go" | "unknown";
+  installCommand: string | null;
+  testCommand: string | null;
+}
+
+/**
+ * Detect existing worktree directory following priority:
+ * .worktrees > worktrees > null
+ */
+export function detectWorktreeDir(cwd: string): string | null {
+  const dotWorktrees = path.join(cwd, ".worktrees");
+  if (fs.existsSync(dotWorktrees)) return dotWorktrees;
+
+  const worktrees = path.join(cwd, "worktrees");
+  if (fs.existsSync(worktrees)) return worktrees;
+
+  return null;
+}
+
+/**
+ * Auto-detect project type and setup commands from project files.
+ */
+export function detectProjectSetup(cwd: string): ProjectSetup {
+  if (fs.existsSync(path.join(cwd, "package.json"))) {
+    return { type: "node", installCommand: "npm install", testCommand: "npm test" };
+  }
+  if (fs.existsSync(path.join(cwd, "Cargo.toml"))) {
+    return { type: "rust", installCommand: "cargo build", testCommand: "cargo test" };
+  }
+  if (fs.existsSync(path.join(cwd, "requirements.txt"))) {
+    return { type: "python", installCommand: "pip install -r requirements.txt", testCommand: "pytest" };
+  }
+  if (fs.existsSync(path.join(cwd, "pyproject.toml"))) {
+    return { type: "python", installCommand: "poetry install", testCommand: "pytest" };
+  }
+  if (fs.existsSync(path.join(cwd, "go.mod"))) {
+    return { type: "go", installCommand: "go mod download", testCommand: "go test ./..." };
+  }
+  return { type: "unknown", installCommand: null, testCommand: null };
+}
+
+export interface WorktreePromptOptions {
+  branchName: string;
+  cwd: string;
+}
+
+/**
+ * Build the prompt that guides the agent through creating an isolated git worktree.
+ * Follows superpowers' using-git-worktrees skill:
+ * - Smart directory selection (.worktrees > worktrees > ask)
+ * - .gitignore verification
+ * - Project setup detection
+ * - Baseline test verification
+ */
+export function buildWorktreePrompt(options: WorktreePromptOptions): string {
+  const { branchName, cwd } = options;
+
+  return [
+    "## Set Up Isolated Worktree",
+    "",
+    `Create an isolated workspace for branch \`${branchName}\`.`,
+    "",
+    "### Step 1: Select directory",
+    "",
+    "Check in priority order:",
+    `1. \`${cwd}/.worktrees/\` — if it exists, use it`,
+    `2. \`${cwd}/worktrees/\` — if it exists, use it`,
+    "3. Check CLAUDE.md for worktree directory preference",
+    "4. If none found, ask the user:",
+    '   - `.worktrees/` (project-local, hidden)',
+    '   - `~/.config/supipowers/worktrees/<project>/` (global location)',
+    "",
+    "### Step 2: Verify gitignore",
+    "",
+    "For project-local directories, verify the directory is ignored:",
+    "",
+    "```bash",
+    "git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null",
+    "```",
+    "",
+    "If NOT ignored, add it to .gitignore and commit before proceeding.",
+    "",
+    "### Step 3: Create worktree",
+    "",
+    "```bash",
+    `git worktree add <dir>/${branchName} -b ${branchName}`,
+    `cd <dir>/${branchName}`,
+    "```",
+    "",
+    "### Step 4: Project setup",
+    "",
+    "Auto-detect and run appropriate setup:",
+    "",
+    "| File | Command |",
+    "|------|---------|",
+    "| `package.json` | `npm install` |",
+    "| `Cargo.toml` | `cargo build` |",
+    "| `requirements.txt` | `pip install -r requirements.txt` |",
+    "| `pyproject.toml` | `poetry install` |",
+    "| `go.mod` | `go mod download` |",
+    "",
+    "### Step 5: Verify baseline",
+    "",
+    "Run the test suite to verify a clean baseline before starting work.",
+    "If tests fail, report failures and ask whether to proceed or investigate.",
+    "",
+    "### Step 6: Report",
+    "",
+    "```",
+    "Worktree ready at <full-path>",
+    "Tests passing (<N> tests, 0 failures)",
+    `Ready to implement ${branchName}`,
+    "```",
+  ].join("\n");
+}

package/src/index.ts

@@ -5,7 +5,8 @@ import { homedir, tmpdir } from "node:os";
 import { registerSupiCommand, handleSupi } from "./commands/supi.js";
 import { registerConfigCommand, handleConfig } from "./commands/config.js";
 import { registerStatusCommand, handleStatus } from "./commands/status.js";
-import { registerPlanCommand } from "./commands/plan.js";
+import { registerPlanCommand, getActiveVisualSessionDir, setActiveVisualSessionDir } from "./commands/plan.js";
+import { getScriptsDir } from "./visual/companion.js";
 import { registerRunCommand } from "./commands/run.js";
 import { registerReviewCommand } from "./commands/review.js";
 import { registerQaCommand } from "./commands/qa.js";
@@ -61,13 +62,21 @@ export default function supipowers(pi: ExtensionAPI): void {
 
   // Session start
   pi.on("session_start", async (_event, ctx) => {
+    // Clean up any leftover visual companion from a previous session
+    const previousVisualDir = getActiveVisualSessionDir();
+    if (previousVisualDir) {
+      const stopScript = join(getScriptsDir(), "stop-server.sh");
+      pi.exec("bash", [stopScript, previousVisualDir], { cwd: getScriptsDir() }).catch(() => {});
+      setActiveVisualSessionDir(null);
+    }
+
     // Check for updates in the background
     const currentVersion = getInstalledVersion();
     if (!currentVersion) return;
 
     pi.exec("npm", ["view", "supipowers", "version"], { cwd: tmpdir() })
       .then((result) => {
-        if (result.exitCode !== 0) return;
+        if (result.code !== 0) return;
         const latest = result.stdout.trim();
         if (latest && latest !== currentVersion) {
           ctx.ui.notify(

package/src/lsp/detector.ts

@@ -10,13 +10,13 @@ export interface LspServerStatus {
  * Check which LSP servers are installed by looking for their binaries.
  */
 export async function checkInstalledServers(
-  exec: (cmd: string, args: string[]) => Promise<{ stdout: string; exitCode: number }>
+  exec: (cmd: string, args: string[]) => Promise<{ stdout: string; code: number }>
 ): Promise<LspServerStatus[]> {
   const results: LspServerStatus[] = [];
   for (const server of LSP_SERVERS) {
     try {
       const result = await exec("which", [server.server]);
-      results.push({ server, installed: result.exitCode === 0 });
+      results.push({ server, installed: result.code === 0 });
     } catch {
       results.push({ server, installed: false });
     }