sequant 1.1.3 → 1.2.1

package/dist/src/commands/run.js

@@ -6,11 +6,213 @@
  */
 import chalk from "chalk";
 import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { getManifest } from "../lib/manifest.js";
 import { getSettings } from "../lib/settings.js";
+import { PM_CONFIG } from "../lib/stacks.js";
 import { LogWriter, createPhaseLogFromTiming, } from "../lib/workflow/log-writer.js";
 import { DEFAULT_PHASES, DEFAULT_CONFIG, } from "../lib/workflow/types.js";
+/**
+ * Slugify a title for branch naming
+ */
+function slugify(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .substring(0, 50);
+}
+/**
+ * Get the git repository root directory
+ */
+function getGitRoot() {
+    const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+        stdio: "pipe",
+    });
+    if (result.status === 0) {
+        return result.stdout.toString().trim();
+    }
+    return null;
+}
+/**
+ * Check if a worktree exists for a given branch
+ */
+function findExistingWorktree(branch) {
+    const result = spawnSync("git", ["worktree", "list", "--porcelain"], {
+        stdio: "pipe",
+    });
+    if (result.status !== 0)
+        return null;
+    const output = result.stdout.toString();
+    const lines = output.split("\n");
+    let currentPath = "";
+    for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+            currentPath = line.substring(9);
+        }
+        else if (line.startsWith("branch refs/heads/") && line.includes(branch)) {
+            return currentPath;
+        }
+    }
+    return null;
+}
+/**
+ * List all active worktrees with their branches
+ */
+export function listWorktrees() {
+    const result = spawnSync("git", ["worktree", "list", "--porcelain"], {
+        stdio: "pipe",
+    });
+    if (result.status !== 0)
+        return [];
+    const output = result.stdout.toString();
+    const lines = output.split("\n");
+    const worktrees = [];
+    let currentPath = "";
+    let currentBranch = "";
+    for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+            currentPath = line.substring(9);
+        }
+        else if (line.startsWith("branch refs/heads/")) {
+            currentBranch = line.substring(18);
+            // Extract issue number from branch name (e.g., feature/123-some-title)
+            const issueMatch = currentBranch.match(/feature\/(\d+)-/);
+            const issue = issueMatch ? parseInt(issueMatch[1], 10) : null;
+            worktrees.push({ path: currentPath, branch: currentBranch, issue });
+            currentPath = "";
+            currentBranch = "";
+        }
+    }
+    return worktrees;
+}
+/**
+ * Get changed files in a worktree compared to main
+ */
+export function getWorktreeChangedFiles(worktreePath) {
+    const result = spawnSync("git", ["-C", worktreePath, "diff", "--name-only", "main...HEAD"], { stdio: "pipe" });
+    if (result.status !== 0)
+        return [];
+    return result.stdout
+        .toString()
+        .trim()
+        .split("\n")
+        .filter((f) => f.length > 0);
+}
+/**
+ * Create or reuse a worktree for an issue
+ */
+async function ensureWorktree(issueNumber, title, verbose, packageManager) {
+    const gitRoot = getGitRoot();
+    if (!gitRoot) {
+        console.log(chalk.red("    ❌ Not in a git repository"));
+        return null;
+    }
+    const slug = slugify(title);
+    const branch = `feature/${issueNumber}-${slug}`;
+    const worktreesDir = path.join(path.dirname(gitRoot), "worktrees");
+    const worktreePath = path.join(worktreesDir, branch);
+    // Check if worktree already exists
+    const existingPath = findExistingWorktree(branch);
+    if (existingPath) {
+        if (verbose) {
+            console.log(chalk.gray(`    📂 Reusing existing worktree: ${existingPath}`));
+        }
+        return {
+            issue: issueNumber,
+            path: existingPath,
+            branch,
+            existed: true,
+        };
+    }
+    // Check if branch exists (but no worktree)
+    const branchCheck = spawnSync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], { stdio: "pipe" });
+    const branchExists = branchCheck.status === 0;
+    if (verbose) {
+        console.log(chalk.gray(`    🌿 Creating worktree for #${issueNumber}...`));
+    }
+    // Ensure worktrees directory exists
+    if (!existsSync(worktreesDir)) {
+        spawnSync("mkdir", ["-p", worktreesDir], { stdio: "pipe" });
+    }
+    // Create the worktree
+    let createResult;
+    if (branchExists) {
+        // Use existing branch
+        createResult = spawnSync("git", ["worktree", "add", worktreePath, branch], {
+            stdio: "pipe",
+        });
+    }
+    else {
+        // Create new branch from main
+        createResult = spawnSync("git", ["worktree", "add", worktreePath, "-b", branch], { stdio: "pipe" });
+    }
+    if (createResult.status !== 0) {
+        const error = createResult.stderr.toString();
+        console.log(chalk.red(`    ❌ Failed to create worktree: ${error}`));
+        return null;
+    }
+    // Copy .env.local if it exists
+    const envLocalSrc = path.join(gitRoot, ".env.local");
+    const envLocalDst = path.join(worktreePath, ".env.local");
+    if (existsSync(envLocalSrc) && !existsSync(envLocalDst)) {
+        spawnSync("cp", [envLocalSrc, envLocalDst], { stdio: "pipe" });
+    }
+    // Copy .claude/settings.local.json if it exists
+    const claudeSettingsSrc = path.join(gitRoot, ".claude", "settings.local.json");
+    const claudeSettingsDst = path.join(worktreePath, ".claude", "settings.local.json");
+    if (existsSync(claudeSettingsSrc) && !existsSync(claudeSettingsDst)) {
+        spawnSync("mkdir", ["-p", path.join(worktreePath, ".claude")], {
+            stdio: "pipe",
+        });
+        spawnSync("cp", [claudeSettingsSrc, claudeSettingsDst], { stdio: "pipe" });
+    }
+    // Install dependencies if needed
+    const nodeModulesPath = path.join(worktreePath, "node_modules");
+    if (!existsSync(nodeModulesPath)) {
+        if (verbose) {
+            console.log(chalk.gray(`    📦 Installing dependencies...`));
+        }
+        // Use detected package manager or default to npm
+        const pm = packageManager || "npm";
+        const pmConfig = PM_CONFIG[pm];
+        const [cmd, ...args] = pmConfig.installSilent.split(" ");
+        spawnSync(cmd, args, {
+            cwd: worktreePath,
+            stdio: "pipe",
+        });
+    }
+    if (verbose) {
+        console.log(chalk.green(`    ✅ Worktree ready: ${worktreePath}`));
+    }
+    return {
+        issue: issueNumber,
+        path: worktreePath,
+        branch,
+        existed: false,
+    };
+}
+/**
+ * Ensure worktrees exist for all issues before execution
+ */
+async function ensureWorktrees(issues, verbose, packageManager) {
+    const worktrees = new Map();
+    console.log(chalk.blue("\n  📂 Preparing worktrees..."));
+    for (const issue of issues) {
+        const worktree = await ensureWorktree(issue.number, issue.title, verbose, packageManager);
+        if (worktree) {
+            worktrees.set(issue.number, worktree);
+        }
+    }
+    const created = Array.from(worktrees.values()).filter((w) => !w.existed).length;
+    const reused = Array.from(worktrees.values()).filter((w) => w.existed).length;
+    if (created > 0 || reused > 0) {
+        console.log(chalk.gray(`  Worktrees: ${created} created, ${reused} reused`));
+    }
+    return worktrees;
+}
 /**
  * Natural language prompts for each phase
  * These prompts will invoke the corresponding skills via natural language
@@ -122,10 +324,15 @@ function formatDuration(seconds) {
 function getPhasePrompt(phase, issueNumber) {
     return PHASE_PROMPTS[phase].replace(/\{issue\}/g, String(issueNumber));
 }
+/**
+ * Phases that require worktree isolation (exec, test, qa)
+ * Spec runs in main repo since it's planning-only
+ */
+const ISOLATED_PHASES = ["exec", "test", "qa"];
 /**
  * Execute a single phase for an issue using Claude Agent SDK
  */
-async function executePhase(issueNumber, phase, config, sessionId) {
+async function executePhase(issueNumber, phase, config, sessionId, worktreePath) {
     const startTime = Date.now();
     if (config.dryRun) {
         // Dry run - just simulate
@@ -141,7 +348,13 @@ async function executePhase(issueNumber, phase, config, sessionId) {
     const prompt = getPhasePrompt(phase, issueNumber);
     if (config.verbose) {
         console.log(chalk.gray(`    Prompt: ${prompt}`));
+        if (worktreePath && ISOLATED_PHASES.includes(phase)) {
+            console.log(chalk.gray(`    Worktree: ${worktreePath}`));
+        }
     }
+    // Determine working directory and environment
+    const shouldUseWorktree = worktreePath && ISOLATED_PHASES.includes(phase);
+    const cwd = shouldUseWorktree ? worktreePath : process.cwd();
     try {
         // Create abort controller for timeout
         const abortController = new AbortController();
@@ -152,12 +365,24 @@ async function executePhase(issueNumber, phase, config, sessionId) {
         let resultMessage;
         let lastError;
         let capturedOutput = "";
+        // Build environment with worktree isolation variables
+        const env = {
+            ...process.env,
+            CLAUDE_HOOKS_SMART_TESTS: config.noSmartTests ? "false" : "true",
+        };
+        // Set worktree isolation environment variables
+        if (shouldUseWorktree) {
+            env.SEQUANT_WORKTREE = worktreePath;
+            env.SEQUANT_ISSUE = String(issueNumber);
+        }
         // Execute using Claude Agent SDK
+        // Note: Don't resume sessions when switching to worktree (different cwd breaks resume)
+        const canResume = sessionId && !shouldUseWorktree;
         const queryInstance = query({
             prompt,
             options: {
                 abortController,
-                cwd: process.cwd(),
+                cwd,
                 // Load project settings including skills
                 settingSources: ["project"],
                 // Use Claude Code's system prompt and tools
@@ -166,13 +391,10 @@ async function executePhase(issueNumber, phase, config, sessionId) {
                 // Bypass permissions for headless execution
                 permissionMode: "bypassPermissions",
                 allowDangerouslySkipPermissions: true,
-                // Resume from previous session if provided
-                ...(sessionId ? { resume: sessionId } : {}),
-                // Configure smart tests via environment
-                env: {
-                    ...process.env,
-                    CLAUDE_HOOKS_SMART_TESTS: config.noSmartTests ? "false" : "true",
-                },
+                // Resume from previous session if provided (but not when switching directories)
+                ...(canResume ? { resume: sessionId } : {}),
+                // Configure smart tests and worktree isolation via environment
+                env,
             },
         });
         // Stream and process messages
@@ -274,21 +496,14 @@ async function executePhase(issueNumber, phase, config, sessionId) {
  */
 async function getIssueInfo(issueNumber) {
     try {
-        const result = spawnSync("gh", [
-            "issue",
-            "view",
-            String(issueNumber),
-            "--json",
-            "title,labels",
-            "--jq",
-            '"\(.title)|\(.labels | map(.name) | join(","))"',
-        ], { stdio: "pipe", shell: true });
+        const result = spawnSync("gh", ["issue", "view", String(issueNumber), "--json", "title,labels"], { stdio: "pipe" });
         if (result.status === 0) {
-            const output = result.stdout.toString().trim().replace(/^"|"$/g, "");
-            const [title, labelsStr] = output.split("|");
+            const data = JSON.parse(result.stdout.toString());
             return {
-                title: title || `Issue #${issueNumber}`,
-                labels: labelsStr ? labelsStr.split(",").filter(Boolean) : [],
+                title: data.title || `Issue #${issueNumber}`,
+                labels: Array.isArray(data.labels)
+                    ? data.labels.map((l) => l.name)
+                    : [],
             };
         }
     }
@@ -297,6 +512,105 @@ async function getIssueInfo(issueNumber) {
     }
     return { title: `Issue #${issueNumber}`, labels: [] };
 }
+/**
+ * Parse dependencies from issue body and labels
+ * Returns array of issue numbers this issue depends on
+ */
+function parseDependencies(issueNumber) {
+    try {
+        const result = spawnSync("gh", ["issue", "view", String(issueNumber), "--json", "body,labels"], { stdio: "pipe" });
+        if (result.status !== 0)
+            return [];
+        const data = JSON.parse(result.stdout.toString());
+        const dependencies = [];
+        // Parse from body: "Depends on: #123" or "**Depends on**: #123"
+        if (data.body) {
+            const bodyMatch = data.body.match(/\*?\*?depends\s+on\*?\*?:?\s*#?(\d+)/gi);
+            if (bodyMatch) {
+                for (const match of bodyMatch) {
+                    const numMatch = match.match(/(\d+)/);
+                    if (numMatch) {
+                        dependencies.push(parseInt(numMatch[1], 10));
+                    }
+                }
+            }
+        }
+        // Parse from labels: "depends-on/123" or "depends-on-123"
+        if (data.labels && Array.isArray(data.labels)) {
+            for (const label of data.labels) {
+                const labelName = label.name || label;
+                const labelMatch = labelName.match(/depends-on[-/](\d+)/i);
+                if (labelMatch) {
+                    dependencies.push(parseInt(labelMatch[1], 10));
+                }
+            }
+        }
+        return [...new Set(dependencies)]; // Remove duplicates
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Sort issues by dependencies (topological sort)
+ * Issues with no dependencies come first, then issues that depend on them
+ */
+function sortByDependencies(issueNumbers) {
+    // Build dependency graph
+    const dependsOn = new Map();
+    for (const issue of issueNumbers) {
+        const deps = parseDependencies(issue);
+        // Only include dependencies that are in our issue list
+        dependsOn.set(issue, deps.filter((d) => issueNumbers.includes(d)));
+    }
+    // Topological sort using Kahn's algorithm
+    const inDegree = new Map();
+    for (const issue of issueNumbers) {
+        inDegree.set(issue, 0);
+    }
+    for (const deps of dependsOn.values()) {
+        for (const dep of deps) {
+            inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
+        }
+    }
+    // Note: inDegree counts how many issues depend on each issue
+    // We want to process issues that nothing depends on last
+    // So we sort by: issues nothing depends on first, then dependent issues
+    const sorted = [];
+    const queue = [];
+    // Start with issues that have no dependencies
+    for (const issue of issueNumbers) {
+        const deps = dependsOn.get(issue) || [];
+        if (deps.length === 0) {
+            queue.push(issue);
+        }
+    }
+    const visited = new Set();
+    while (queue.length > 0) {
+        const issue = queue.shift();
+        if (visited.has(issue))
+            continue;
+        visited.add(issue);
+        sorted.push(issue);
+        // Find issues that depend on this one
+        for (const [other, deps] of dependsOn.entries()) {
+            if (deps.includes(issue) && !visited.has(other)) {
+                // Check if all dependencies of 'other' are satisfied
+                const allDepsSatisfied = deps.every((d) => visited.has(d));
+                if (allDepsSatisfied) {
+                    queue.push(other);
+                }
+            }
+        }
+    }
+    // Add any remaining issues (circular dependencies or unvisited)
+    for (const issue of issueNumbers) {
+        if (!visited.has(issue)) {
+            sorted.push(issue);
+        }
+    }
+    return sorted;
+}
 /**
  * Check if an issue has UI-related labels
  */
@@ -404,11 +718,20 @@ export async function runCommand(issues, options) {
     }
     if (issueNumbers.length === 0) {
         console.log(chalk.red("❌ No valid issue numbers provided."));
-        console.log(chalk.gray("\nUsage: sequant run <issues...> [options]"));
-        console.log(chalk.gray("Example: sequant run 1 2 3 --sequential"));
-        console.log(chalk.gray('Batch example: sequant run --batch "1 2" --batch "3"'));
+        console.log(chalk.gray("\nUsage: npx sequant run <issues...> [options]"));
+        console.log(chalk.gray("Example: npx sequant run 1 2 3 --sequential"));
+        console.log(chalk.gray('Batch example: npx sequant run --batch "1 2" --batch "3"'));
         return;
     }
+    // Sort issues by dependencies (if more than one issue)
+    if (issueNumbers.length > 1 && !batches) {
+        const originalOrder = [...issueNumbers];
+        issueNumbers = sortByDependencies(issueNumbers);
+        const orderChanged = !originalOrder.every((n, i) => n === issueNumbers[i]);
+        if (orderChanged) {
+            console.log(chalk.gray(`  Dependency order: ${issueNumbers.map((n) => `#${n}`).join(" → ")}`));
+        }
+    }
     // Build config
     // Note: config.phases is only used when --phases is explicitly set or autoDetect fails
     const explicitPhases = mergedOptions.phases
@@ -469,6 +792,25 @@ export async function runCommand(issues, options) {
         console.log(chalk.gray(`  Logging: JSON (run ${logWriter.getRunId()?.slice(0, 8)}...)`));
     }
     console.log(chalk.gray(`  Issues: ${issueNumbers.map((n) => `#${n}`).join(", ")}`));
+    // Worktree isolation is enabled by default for multi-issue runs
+    const useWorktreeIsolation = mergedOptions.worktreeIsolation !== false && issueNumbers.length > 0;
+    if (useWorktreeIsolation) {
+        console.log(chalk.gray(`  Worktree isolation: enabled`));
+    }
+    // Fetch issue info for all issues first
+    const issueInfoMap = new Map();
+    for (const issueNumber of issueNumbers) {
+        issueInfoMap.set(issueNumber, await getIssueInfo(issueNumber));
+    }
+    // Create worktrees for all issues before execution (if isolation enabled)
+    let worktreeMap = new Map();
+    if (useWorktreeIsolation && !config.dryRun) {
+        const issueData = issueNumbers.map((num) => ({
+            number: num,
+            title: issueInfoMap.get(num)?.title || `Issue #${num}`,
+        }));
+        worktreeMap = await ensureWorktrees(issueData, config.verbose, manifest.packageManager);
+    }
     // Execute
     const results = [];
     if (batches) {
@@ -476,7 +818,7 @@ export async function runCommand(issues, options) {
         for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
             const batch = batches[batchIdx];
             console.log(chalk.blue(`\n  Batch ${batchIdx + 1}/${batches.length}: Issues ${batch.map((n) => `#${n}`).join(", ")}`));
-            const batchResults = await executeBatch(batch, config, logWriter, mergedOptions);
+            const batchResults = await executeBatch(batch, config, logWriter, mergedOptions, issueInfoMap, worktreeMap);
             results.push(...batchResults);
             // Check if batch failed and we should stop
             const batchFailed = batchResults.some((r) => !r.success);
@@ -489,12 +831,16 @@ export async function runCommand(issues, options) {
     else if (config.sequential) {
         // Sequential execution
         for (const issueNumber of issueNumbers) {
-            const issueInfo = await getIssueInfo(issueNumber);
+            const issueInfo = issueInfoMap.get(issueNumber) ?? {
+                title: `Issue #${issueNumber}`,
+                labels: [],
+            };
+            const worktreeInfo = worktreeMap.get(issueNumber);
             // Start issue logging
             if (logWriter) {
                 logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
             }
-            const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions);
+            const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions, worktreeInfo?.path);
             results.push(result);
             // Complete issue logging
             if (logWriter) {
@@ -510,12 +856,16 @@ export async function runCommand(issues, options) {
         // Parallel execution (for now, just run sequentially but don't stop on failure)
         // TODO: Add proper parallel execution with listr2
         for (const issueNumber of issueNumbers) {
-            const issueInfo = await getIssueInfo(issueNumber);
+            const issueInfo = issueInfoMap.get(issueNumber) ?? {
+                title: `Issue #${issueNumber}`,
+                labels: [],
+            };
+            const worktreeInfo = worktreeMap.get(issueNumber);
             // Start issue logging
             if (logWriter) {
                 logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
             }
-            const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions);
+            const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions, worktreeInfo?.path);
             results.push(result);
             // Complete issue logging
             if (logWriter) {
@@ -563,15 +913,19 @@ export async function runCommand(issues, options) {
 /**
  * Execute a batch of issues
  */
-async function executeBatch(issueNumbers, config, logWriter, options) {
+async function executeBatch(issueNumbers, config, logWriter, options, issueInfoMap, worktreeMap) {
     const results = [];
     for (const issueNumber of issueNumbers) {
-        const issueInfo = await getIssueInfo(issueNumber);
+        const issueInfo = issueInfoMap.get(issueNumber) ?? {
+            title: `Issue #${issueNumber}`,
+            labels: [],
+        };
+        const worktreeInfo = worktreeMap.get(issueNumber);
         // Start issue logging
         if (logWriter) {
             logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
         }
-        const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, options);
+        const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, options, worktreeInfo?.path);
         results.push(result);
         // Complete issue logging
         if (logWriter) {
@@ -583,12 +937,15 @@ async function executeBatch(issueNumbers, config, logWriter, options) {
 /**
  * Execute all phases for a single issue with logging and quality loop
  */
-async function runIssueWithLogging(issueNumber, config, logWriter, labels, options) {
+async function runIssueWithLogging(issueNumber, config, logWriter, labels, options, worktreePath) {
     const startTime = Date.now();
     const phaseResults = [];
     let loopTriggered = false;
     let sessionId;
     console.log(chalk.blue(`\n  Issue #${issueNumber}`));
+    if (worktreePath) {
+        console.log(chalk.gray(`    Worktree: ${worktreePath}`));
+    }
     // Determine phases for this specific issue
     let phases;
     let detectedQualityLoop = false;
@@ -607,7 +964,8 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
             console.log(chalk.gray(`    Running spec to determine workflow...`));
             console.log(chalk.gray(`    ⏳ spec...`));
             const specStartTime = new Date();
-            const specResult = await executePhase(issueNumber, "spec", config, sessionId);
+            // Note: spec runs in main repo (not worktree) for planning
+            const specResult = await executePhase(issueNumber, "spec", config, sessionId, worktreePath);
             const specEndTime = new Date();
             if (specResult.sessionId) {
                 sessionId = specResult.sessionId;
@@ -693,7 +1051,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
         for (const phase of phases) {
             console.log(chalk.gray(`    ⏳ ${phase}...`));
             const phaseStartTime = new Date();
-            const result = await executePhase(issueNumber, phase, config, sessionId);
+            const result = await executePhase(issueNumber, phase, config, sessionId, worktreePath);
             const phaseEndTime = new Date();
             // Capture session ID for subsequent phases
             if (result.sessionId) {
@@ -721,7 +1079,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
                 // If quality loop enabled, run loop phase to fix issues
                 if (useQualityLoop && iteration < maxIterations) {
                     console.log(chalk.yellow(`    Running /loop to fix issues...`));
-                    const loopResult = await executePhase(issueNumber, "loop", config, sessionId);
+                    const loopResult = await executePhase(issueNumber, "loop", config, sessionId, worktreePath);
                     phaseResults.push(loopResult);
                     if (loopResult.sessionId) {
                         sessionId = loopResult.sessionId;