sequant 1.10.1 → 1.11.0

package/dist/src/lib/workflow/state-utils.js

@@ -18,6 +18,30 @@ import { spawnSync } from "child_process";
 import { StateManager } from "./state-manager.js";
 import { createEmptyState, createIssueState, createPhaseState, } from "./state-schema.js";
 import { RunLogSchema, LOG_PATHS } from "./run-log-schema.js";
+/**
+ * Check the merge status of a PR using the gh CLI
+ *
+ * @param prNumber - The PR number to check
+ * @returns "MERGED" | "CLOSED" | "OPEN" | null (null if PR not found or gh unavailable)
+ */
+export function checkPRMergeStatus(prNumber) {
+    try {
+        const result = spawnSync("gh", ["pr", "view", String(prNumber), "--json", "state", "-q", ".state"], { stdio: "pipe", timeout: 10000 });
+        if (result.status === 0 && result.stdout) {
+            const state = result.stdout.toString().trim().toUpperCase();
+            if (state === "MERGED")
+                return "MERGED";
+            if (state === "CLOSED")
+                return "CLOSED";
+            if (state === "OPEN")
+                return "OPEN";
+        }
+    }
+    catch {
+        // gh not available or error - return null
+    }
+    return null;
+}
 /**
  * Rebuild workflow state from run logs
  *
@@ -143,8 +167,11 @@ export async function rebuildStateFromLogs(options = {}) {
 /**
  * Clean up stale and orphaned entries from workflow state
  *
- * - Removes issues with non-existent worktrees (orphaned)
- * - Optionally removes old merged/abandoned issues
+ * - Checks GitHub to detect if associated PR was merged
+ * - Orphaned entries with merged PRs get status "merged" and are removed automatically
+ * - Orphaned entries without merged PRs get status "abandoned" (kept for review)
+ * - Use removeAll to remove both merged and abandoned orphaned entries in one step
+ * - Use maxAgeDays to remove old merged/abandoned issues
  */
 export async function cleanupStaleEntries(options = {}) {
     const manager = new StateManager({
@@ -156,12 +183,14 @@ export async function cleanupStaleEntries(options = {}) {
             success: true,
             removed: [],
             orphaned: [],
+            merged: [],
         };
     }
     try {
         const state = await manager.getState();
         const removed = [];
         const orphaned = [];
+        const merged = [];
         // Get list of active worktrees
         const activeWorktrees = getActiveWorktrees();
         for (const [issueNumStr, issueState] of Object.entries(state.issues)) {
@@ -169,20 +198,61 @@ export async function cleanupStaleEntries(options = {}) {
             // Check if worktree exists (if issue has one)
             if (issueState.worktree &&
                 !activeWorktrees.includes(issueState.worktree)) {
-                orphaned.push(issueNum);
                 if (options.verbose) {
-                    console.log(`🗑️  Orphaned: #${issueNum} (worktree not found: ${issueState.worktree})`);
+                    console.log(`🔍 Orphaned: #${issueNum} (worktree not found: ${issueState.worktree})`);
+                }
+                // Check if this issue has a PR and if it's merged
+                let prMerged = false;
+                if (issueState.pr?.number) {
+                    if (options.verbose) {
+                        console.log(`   Checking PR #${issueState.pr.number} status...`);
+                    }
+                    const prStatus = checkPRMergeStatus(issueState.pr.number);
+                    prMerged = prStatus === "MERGED";
+                    if (options.verbose) {
+                        console.log(`   PR status: ${prStatus ?? "unknown"}`);
+                    }
                 }
                 if (!options.dryRun) {
-                    // Mark as abandoned or remove based on status
-                    if (issueState.status === "merged" ||
-                        issueState.status === "abandoned") {
+                    if (prMerged || issueState.status === "merged") {
+                        // Merged PRs are auto-removed
+                        merged.push(issueNum);
                         removed.push(issueNum);
+                        if (options.verbose) {
+                            console.log(`   ✓ Merged PR detected, removing entry`);
+                        }
+                        delete state.issues[issueNumStr];
+                    }
+                    else if (issueState.status === "abandoned" || options.removeAll) {
+                        // Already abandoned or removeAll flag - remove it
+                        orphaned.push(issueNum);
+                        removed.push(issueNum);
+                        if (options.verbose) {
+                            console.log(`   ✓ Removing abandoned entry`);
+                        }
                         delete state.issues[issueNumStr];
                     }
                     else {
-                        // Update status to indicate orphaned state
+                        // Mark as abandoned (kept for review)
+                        orphaned.push(issueNum);
                         issueState.status = "abandoned";
+                        if (options.verbose) {
+                            console.log(`   → Marked as abandoned (kept for review)`);
+                        }
+                    }
+                }
+                else {
+                    // Dry run - report what would happen
+                    if (prMerged || issueState.status === "merged") {
+                        merged.push(issueNum);
+                        removed.push(issueNum);
+                    }
+                    else if (issueState.status === "abandoned" || options.removeAll) {
+                        orphaned.push(issueNum);
+                        removed.push(issueNum);
+                    }
+                    else {
+                        orphaned.push(issueNum);
                     }
                 }
                 continue;
@@ -211,6 +281,7 @@ export async function cleanupStaleEntries(options = {}) {
             success: true,
             removed,
             orphaned,
+            merged,
         };
     }
     catch (error) {
@@ -218,6 +289,7 @@ export async function cleanupStaleEntries(options = {}) {
             success: false,
             removed: [],
             orphaned: [],
+            merged: [],
             error: String(error),
         };
     }
@@ -241,3 +313,212 @@ function getActiveWorktrees() {
     }
     return paths;
 }
+/**
+ * Parse issue number from a branch name
+ *
+ * Supports patterns:
+ * - feature/<number>-<slug>
+ * - issue-<number>
+ * - <number>-<slug>
+ */
+function parseIssueNumberFromBranch(branch) {
+    // Pattern: feature/123-description or feature/123
+    const featureMatch = branch.match(/^feature\/(\d+)(?:-|$)/);
+    if (featureMatch) {
+        return parseInt(featureMatch[1], 10);
+    }
+    // Pattern: issue-123
+    const issueMatch = branch.match(/^issue-(\d+)$/);
+    if (issueMatch) {
+        return parseInt(issueMatch[1], 10);
+    }
+    // Pattern: 123-description (bare number prefix)
+    const bareMatch = branch.match(/^(\d+)-/);
+    if (bareMatch) {
+        return parseInt(bareMatch[1], 10);
+    }
+    return null;
+}
+/**
+ * Fetch issue title from GitHub using gh CLI
+ *
+ * Returns placeholder if gh is not available or fetch fails.
+ */
+function fetchIssueTitle(issueNumber) {
+    try {
+        const result = spawnSync("gh", ["issue", "view", String(issueNumber), "--json", "title", "-q", ".title"], { stdio: "pipe", timeout: 10000 });
+        if (result.status === 0 && result.stdout) {
+            const title = result.stdout.toString().trim();
+            if (title) {
+                return title;
+            }
+        }
+    }
+    catch {
+        // gh not available or error - use placeholder
+    }
+    return `(title unavailable for #${issueNumber})`;
+}
+function getWorktreeDetails() {
+    const result = spawnSync("git", ["worktree", "list", "--porcelain"], {
+        stdio: "pipe",
+    });
+    if (result.status !== 0) {
+        return [];
+    }
+    const output = result.stdout.toString();
+    const worktrees = [];
+    let current = {};
+    for (const line of output.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            // Start of new worktree entry
+            if (current.path) {
+                worktrees.push(current);
+            }
+            current = { path: line.substring(9) };
+        }
+        else if (line.startsWith("HEAD ")) {
+            current.head = line.substring(5);
+        }
+        else if (line.startsWith("branch refs/heads/")) {
+            current.branch = line.substring(18);
+        }
+        else if (line === "" && current.path) {
+            // End of entry
+            worktrees.push(current);
+            current = {};
+        }
+    }
+    // Don't forget the last entry
+    if (current.path && current.branch) {
+        worktrees.push(current);
+    }
+    return worktrees;
+}
+/**
+ * Infer the current phase for an issue by checking logs
+ */
+function inferPhaseFromLogs(issueNumber) {
+    const logPath = LOG_PATHS.project;
+    if (!fs.existsSync(logPath)) {
+        return undefined;
+    }
+    try {
+        const files = fs.readdirSync(logPath).filter((f) => f.endsWith(".json"));
+        // Sort by timestamp (newest first)
+        files.sort().reverse();
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(logPath, file), "utf-8");
+                const logData = JSON.parse(content);
+                const log = RunLogSchema.safeParse(logData);
+                if (!log.success)
+                    continue;
+                // Find this issue in the log
+                const issueLog = log.data.issues.find((i) => i.issueNumber === issueNumber);
+                if (issueLog && issueLog.phases.length > 0) {
+                    // Return the last executed phase
+                    const lastPhase = issueLog.phases[issueLog.phases.length - 1];
+                    return lastPhase.phase;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Discover worktrees that are not yet tracked in state
+ *
+ * Scans all git worktrees, identifies those with issue-related branch names,
+ * and returns information about worktrees not yet in the state file.
+ */
+export async function discoverUntrackedWorktrees(options = {}) {
+    try {
+        const worktrees = getWorktreeDetails();
+        const discovered = [];
+        const skipped = [];
+        let alreadyTracked = 0;
+        // Get existing state
+        const manager = new StateManager({
+            statePath: options.statePath,
+            verbose: options.verbose,
+        });
+        const state = await manager.getState();
+        const trackedIssues = new Set(Object.keys(state.issues).map((n) => parseInt(n, 10)));
+        for (const worktree of worktrees) {
+            // Skip if no branch (detached HEAD)
+            if (!worktree.branch) {
+                skipped.push({
+                    path: worktree.path,
+                    reason: "detached HEAD (no branch)",
+                });
+                continue;
+            }
+            // Skip main/master branches
+            if (worktree.branch === "main" || worktree.branch === "master") {
+                skipped.push({
+                    path: worktree.path,
+                    reason: "main/master branch (not a feature worktree)",
+                });
+                continue;
+            }
+            // Try to parse issue number from branch
+            const issueNumber = parseIssueNumberFromBranch(worktree.branch);
+            if (issueNumber === null) {
+                skipped.push({
+                    path: worktree.path,
+                    reason: `branch name doesn't match issue pattern: ${worktree.branch}`,
+                });
+                continue;
+            }
+            // Check if already tracked
+            if (trackedIssues.has(issueNumber)) {
+                alreadyTracked++;
+                if (options.verbose) {
+                    console.log(`  Already tracked: #${issueNumber} (${worktree.branch})`);
+                }
+                continue;
+            }
+            // Fetch title from GitHub
+            if (options.verbose) {
+                console.log(`  Fetching title for #${issueNumber}...`);
+            }
+            const title = fetchIssueTitle(issueNumber);
+            // Try to infer phase from logs
+            const inferredPhase = inferPhaseFromLogs(issueNumber);
+            discovered.push({
+                issueNumber,
+                title,
+                worktreePath: worktree.path,
+                branch: worktree.branch,
+                inferredPhase,
+            });
+            if (options.verbose) {
+                console.log(`  Discovered: #${issueNumber} - ${title}${inferredPhase ? ` (phase: ${inferredPhase})` : ""}`);
+            }
+        }
+        return {
+            success: true,
+            worktreesScanned: worktrees.length,
+            alreadyTracked,
+            discovered,
+            skipped,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            worktreesScanned: 0,
+            alreadyTracked: 0,
+            discovered: [],
+            skipped: [],
+            error: String(error),
+        };
+    }
+}

package/dist/src/lib/workflow/types.d.ts

@@ -33,6 +33,8 @@ export interface ExecutionConfig {
     noSmartTests: boolean;
     /** Dry run mode - don't actually execute */
     dryRun: boolean;
+    /** Enable MCP servers in headless mode (true by default, false if --no-mcp flag used) */
+    mcp: boolean;
 }
 /**
  * Default execution configuration

package/dist/src/lib/workflow/types.js

@@ -19,4 +19,5 @@ export const DEFAULT_CONFIG = {
     verbose: false,
     noSmartTests: false,
     dryRun: false,
+    mcp: true,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sequant",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "description": "Quantize your development workflow - Sequential AI phases with quality gates",
   "type": "module",
   "bin": {
@@ -55,10 +55,14 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.11",
+    "@hono/node-server": "^1.19.9",
     "chalk": "^5.3.0",
+    "chokidar": "^5.0.0",
     "commander": "^12.1.0",
     "diff": "^7.0.0",
+    "hono": "^4.11.4",
     "inquirer": "^12.3.2",
+    "open": "^11.0.0",
     "yaml": "^2.7.0",
     "zod": "^4.3.5"
   },