sequant 2.9.0 → 2.11.0

package/dist/src/lib/workflow/pr-operations.js

@@ -1,326 +0,0 @@
-/**
- * PR Operations Module
- *
- * Handles pre-PR and PR creation operations:
- * - Checkpoint commits for chain recovery
- * - Lockfile change detection and dependency reinstall
- * - Pre-PR rebase onto origin/main
- * - PR creation with existing-PR detection
- *
- * @module pr-operations
- */
-import chalk from "chalk";
-import { spawnSync } from "child_process";
-import { PM_CONFIG } from "../stacks.js";
-/**
- * Lockfile names for different package managers
- */
-const LOCKFILES = [
-    "package-lock.json",
-    "pnpm-lock.yaml",
-    "bun.lock",
-    "yarn.lock",
-];
-/**
- * Create a checkpoint commit in the worktree after QA passes
- * This allows recovery in case later issues in the chain fail
- * @internal Exported for testing
- */
-export function createCheckpointCommit(worktreePath, issueNumber, verbose) {
-    // Check if there are uncommitted changes
-    const statusResult = spawnSync("git", ["-C", worktreePath, "status", "--porcelain"], { stdio: "pipe" });
-    if (statusResult.status !== 0) {
-        if (verbose) {
-            console.log(chalk.yellow(`    ⚠️  Could not check git status for checkpoint`));
-        }
-        return false;
-    }
-    const hasChanges = statusResult.stdout.toString().trim().length > 0;
-    if (!hasChanges) {
-        if (verbose) {
-            console.log(chalk.gray(`    📌 No changes to checkpoint (already committed)`));
-        }
-        return true;
-    }
-    // Stage all changes
-    const addResult = spawnSync("git", ["-C", worktreePath, "add", "-A"], {
-        stdio: "pipe",
-    });
-    if (addResult.status !== 0) {
-        if (verbose) {
-            console.log(chalk.yellow(`    ⚠️  Could not stage changes for checkpoint`));
-        }
-        return false;
-    }
-    // Create checkpoint commit
-    const commitMessage = `checkpoint(#${issueNumber}): QA passed
-
-This is an automatic checkpoint commit created after issue #${issueNumber}
-passed QA in chain mode. It serves as a recovery point if later issues fail.`;
-    const commitResult = spawnSync("git", ["-C", worktreePath, "commit", "-m", commitMessage], { stdio: "pipe" });
-    if (commitResult.status !== 0) {
-        const error = commitResult.stderr.toString();
-        if (verbose) {
-            console.log(chalk.yellow(`    ⚠️  Could not create checkpoint commit: ${error}`));
-        }
-        return false;
-    }
-    console.log(chalk.green(`    📌 Checkpoint commit created for #${issueNumber}`));
-    return true;
-}
-/**
- * Check if any lockfile changed during a rebase and re-run install if needed.
- * This prevents dependency drift when the lockfile was updated on main.
- * @param worktreePath Path to the worktree
- * @param packageManager Package manager to use for install
- * @param verbose Whether to show verbose output
- * @param preRebaseRef Git ref pointing to pre-rebase HEAD (defaults to ORIG_HEAD,
- *        which git sets automatically after rebase). Using ORIG_HEAD captures all
- *        lockfile changes across multi-commit rebases, unlike HEAD~1 which only
- *        checks the last commit.
- * @returns true if reinstall was performed, false otherwise
- * @internal Exported for testing
- */
-export function reinstallIfLockfileChanged(worktreePath, packageManager, verbose, preRebaseRef = "ORIG_HEAD") {
-    // Compare pre-rebase state to current HEAD to detect all lockfile changes
-    // introduced by the rebase (including changes from main that were pulled in)
-    let lockfileChanged = false;
-    for (const lockfile of LOCKFILES) {
-        const result = spawnSync("git", [
-            "-C",
-            worktreePath,
-            "diff",
-            "--name-only",
-            `${preRebaseRef}..HEAD`,
-            "--",
-            lockfile,
-        ], { stdio: "pipe" });
-        if (result.status === 0 && result.stdout.toString().trim().length > 0) {
-            lockfileChanged = true;
-            if (verbose) {
-                console.log(chalk.gray(`    📦 Lockfile changed: ${lockfile}`));
-            }
-            break;
-        }
-    }
-    if (!lockfileChanged) {
-        if (verbose) {
-            console.log(chalk.gray(`    📦 No lockfile changes detected`));
-        }
-        return false;
-    }
-    // Re-run install to sync node_modules with updated lockfile
-    console.log(chalk.blue(`    📦 Reinstalling dependencies (lockfile changed)...`));
-    const pm = packageManager || "npm";
-    const pmConfig = PM_CONFIG[pm];
-    const [cmd, ...args] = pmConfig.installSilent.split(" ");
-    const installResult = spawnSync(cmd, args, {
-        cwd: worktreePath,
-        stdio: "pipe",
-    });
-    if (installResult.status !== 0) {
-        const error = installResult.stderr.toString();
-        console.log(chalk.yellow(`    ⚠️  Dependency reinstall failed: ${error.trim()}`));
-        return false;
-    }
-    console.log(chalk.green(`    ✅ Dependencies reinstalled`));
-    return true;
-}
-/**
- * Rebase the worktree branch onto origin/main before PR creation.
- * This ensures the branch is up-to-date and prevents lockfile drift.
- *
- * @param worktreePath Path to the worktree
- * @param issueNumber Issue number (for logging)
- * @param packageManager Package manager to use if reinstall needed
- * @param verbose Whether to show verbose output
- * @returns RebaseResult indicating success/failure and whether reinstall was performed
- * @internal Exported for testing
- */
-export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbose) {
-    if (verbose) {
-        console.log(chalk.gray(`    🔄 Rebasing #${issueNumber} onto origin/main before PR...`));
-    }
-    // Fetch latest main to ensure we're rebasing onto fresh state
-    const fetchResult = spawnSync("git", ["-C", worktreePath, "fetch", "origin", "main"], {
-        stdio: "pipe",
-    });
-    if (fetchResult.status !== 0) {
-        const error = fetchResult.stderr.toString();
-        console.log(chalk.yellow(`    ⚠️  Could not fetch origin/main: ${error.trim()}`));
-        // Continue anyway - might work with local state
-    }
-    // Perform the rebase
-    const rebaseResult = spawnSync("git", ["-C", worktreePath, "rebase", "origin/main"], { stdio: "pipe" });
-    if (rebaseResult.status !== 0) {
-        const rebaseError = rebaseResult.stderr.toString();
-        // Check if it's a conflict
-        if (rebaseError.includes("CONFLICT") ||
-            rebaseError.includes("could not apply")) {
-            console.log(chalk.yellow(`    ⚠️  Rebase conflict detected. Aborting rebase and keeping original branch state.`));
-            console.log(chalk.yellow(`    ℹ️  PR will be created without rebase. Manual rebase may be required before merge.`));
-            // Abort the rebase to restore branch state
-            spawnSync("git", ["-C", worktreePath, "rebase", "--abort"], {
-                stdio: "pipe",
-            });
-            return {
-                performed: true,
-                success: false,
-                reinstalled: false,
-                error: "Rebase conflict - manual resolution required",
-            };
-        }
-        else {
-            console.log(chalk.yellow(`    ⚠️  Rebase failed: ${rebaseError.trim()}`));
-            console.log(chalk.yellow(`    ℹ️  Continuing with branch in its original state.`));
-            return {
-                performed: true,
-                success: false,
-                reinstalled: false,
-                error: rebaseError.trim(),
-            };
-        }
-    }
-    console.log(chalk.green(`    ✅ Branch rebased onto origin/main`));
-    // Check if lockfile changed and reinstall if needed
-    const reinstalled = reinstallIfLockfileChanged(worktreePath, packageManager, verbose);
-    return {
-        performed: true,
-        success: true,
-        reinstalled,
-    };
-}
-/**
- * Push branch and create a PR after successful QA.
- *
- * Handles both fresh PR creation and detection of existing PRs.
- * Failures are warnings — they don't fail the run.
- *
- * @param worktreePath Path to the worktree
- * @param issueNumber Issue number
- * @param issueTitle Issue title (for PR title)
- * @param branch Branch name
- * @param verbose Whether to show verbose output
- * @returns PRCreationResult with PR info or error
- * @internal Exported for testing
- */
-export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose, labels) {
-    // Step 1: Check for existing PR on this branch
-    const existingPR = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
-    if (existingPR.status === 0 && existingPR.stdout) {
-        try {
-            const prInfo = JSON.parse(existingPR.stdout.toString());
-            if (prInfo.number && prInfo.url) {
-                if (verbose) {
-                    console.log(chalk.gray(`    ℹ️  PR #${prInfo.number} already exists for branch ${branch}`));
-                }
-                return {
-                    attempted: true,
-                    success: true,
-                    prNumber: prInfo.number,
-                    prUrl: prInfo.url,
-                };
-            }
-        }
-        catch {
-            // JSON parse failed — no existing PR, continue to create
-        }
-    }
-    // Step 2: Push branch to remote
-    if (verbose) {
-        console.log(chalk.gray(`    🚀 Pushing branch ${branch} to origin...`));
-    }
-    const pushResult = spawnSync("git", ["-C", worktreePath, "push", "-u", "origin", branch], { stdio: "pipe", timeout: 60000 });
-    if (pushResult.status !== 0) {
-        const pushError = pushResult.stderr?.toString().trim() ?? "Unknown error";
-        console.log(chalk.yellow(`    ⚠️  git push failed: ${pushError}`));
-        return {
-            attempted: true,
-            success: false,
-            error: `git push failed: ${pushError}`,
-        };
-    }
-    // Step 3: Create PR
-    if (verbose) {
-        console.log(chalk.gray(`    📝 Creating PR for #${issueNumber}...`));
-    }
-    const isBug = labels?.some((l) => /^bug/i.test(l));
-    const prefix = isBug ? "fix" : "feat";
-    const prTitle = `${prefix}(#${issueNumber}): ${issueTitle}`;
-    const prBody = [
-        `## Summary`,
-        ``,
-        `Automated PR for issue #${issueNumber}.`,
-        ``,
-        `Fixes #${issueNumber}`,
-        ``,
-        `---`,
-        `🤖 Generated by \`sequant run\``,
-    ].join("\n");
-    const prResult = spawnSync("gh", ["pr", "create", "--title", prTitle, "--body", prBody, "--head", branch], { stdio: "pipe", cwd: worktreePath, timeout: 30000 });
-    if (prResult.status !== 0) {
-        const prError = prResult.stderr?.toString().trim() ?? "Unknown error";
-        // Check if PR already exists (race condition or push-before-PR scenarios)
-        if (prError.includes("already exists")) {
-            const retryView = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
-            if (retryView.status === 0 && retryView.stdout) {
-                try {
-                    const prInfo = JSON.parse(retryView.stdout.toString());
-                    return {
-                        attempted: true,
-                        success: true,
-                        prNumber: prInfo.number,
-                        prUrl: prInfo.url,
-                    };
-                }
-                catch {
-                    // Fall through to error
-                }
-            }
-        }
-        console.log(chalk.yellow(`    ⚠️  PR creation failed: ${prError}`));
-        return {
-            attempted: true,
-            success: false,
-            error: `gh pr create failed: ${prError}`,
-        };
-    }
-    // Step 4: Extract PR URL from output and get PR details
-    const prOutput = prResult.stdout?.toString().trim() ?? "";
-    const prUrlMatch = prOutput.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
-    if (prUrlMatch) {
-        const prNumber = parseInt(prUrlMatch[1], 10);
-        const prUrl = prUrlMatch[0];
-        console.log(chalk.green(`    ✅ PR #${prNumber} created: ${prUrl}`));
-        return {
-            attempted: true,
-            success: true,
-            prNumber,
-            prUrl,
-        };
-    }
-    // Fallback: try gh pr view to get details
-    const viewResult = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
-    if (viewResult.status === 0 && viewResult.stdout) {
-        try {
-            const prInfo = JSON.parse(viewResult.stdout.toString());
-            console.log(chalk.green(`    ✅ PR #${prInfo.number} created: ${prInfo.url}`));
-            return {
-                attempted: true,
-                success: true,
-                prNumber: prInfo.number,
-                prUrl: prInfo.url,
-            };
-        }
-        catch {
-            // Fall through
-        }
-    }
-    // PR was created but we couldn't parse the URL
-    console.log(chalk.yellow(`    ⚠️  PR created but could not extract URL from output: ${prOutput}`));
-    return {
-        attempted: true,
-        success: true,
-        error: "PR created but URL extraction failed",
-    };
-}

package/dist/src/lib/workflow/run-summary.d.ts

@@ -1,36 +0,0 @@
-/**
- * Run Summary Module
- *
- * Handles post-execution reporting for sequant run:
- * - Metrics recording (local analytics)
- * - Summary display with pass/fail counts
- *
- * @module run-summary
- */
-import type { ExecutionConfig, IssueResult } from "./types.js";
-import type { WorktreeInfo } from "./worktree-manager.js";
-import type { RunOptions } from "./batch-executor.js";
-/**
- * Record run metrics to local analytics file
- *
- * @param params - Metrics recording parameters
- */
-export declare function recordRunMetrics(params: {
-    results: IssueResult[];
-    issueNumbers: number[];
-    config: ExecutionConfig;
-    worktreeMap: Map<number, WorktreeInfo>;
-    mergedOptions: RunOptions;
-}): Promise<void>;
-/**
- * Print the run summary to console
- *
- * @param params - Summary display parameters
- * @returns exit code (0 for success, 1 if any failed)
- */
-export declare function printRunSummary(params: {
-    results: IssueResult[];
-    logPath: string | null;
-    config: ExecutionConfig;
-    mergedOptions: RunOptions;
-}): number;

package/dist/src/lib/workflow/run-summary.js

@@ -1,142 +0,0 @@
-/**
- * Run Summary Module
- *
- * Handles post-execution reporting for sequant run:
- * - Metrics recording (local analytics)
- * - Summary display with pass/fail counts
- *
- * @module run-summary
- */
-import chalk from "chalk";
-import { MetricsWriter } from "./metrics-writer.js";
-import { determineOutcome } from "./metrics-schema.js";
-import { ui, colors } from "../cli-ui.js";
-import { getTokenUsageForRun } from "./token-utils.js";
-import { getWorktreeDiffStats } from "./worktree-manager.js";
-import { formatDuration } from "./phase-executor.js";
-/**
- * Record run metrics to local analytics file
- *
- * @param params - Metrics recording parameters
- */
-export async function recordRunMetrics(params) {
-    const { results, issueNumbers, config, worktreeMap, mergedOptions } = params;
-    const metricsWriter = new MetricsWriter({ verbose: config.verbose });
-    // Calculate total duration
-    const totalDuration = results.reduce((sum, r) => sum + (r.durationSeconds ?? 0), 0);
-    // Get unique phases from all results
-    const allPhases = new Set();
-    for (const result of results) {
-        for (const phaseResult of result.phaseResults) {
-            const phase = phaseResult.phase;
-            if ([
-                "spec",
-                "security-review",
-                "testgen",
-                "exec",
-                "test",
-                "qa",
-                "loop",
-            ].includes(phase)) {
-                allPhases.add(phase);
-            }
-        }
-    }
-    // Calculate aggregate metrics from worktrees
-    let totalFilesChanged = 0;
-    let totalLinesAdded = 0;
-    let totalQaIterations = 0;
-    for (const result of results) {
-        const worktreeInfo = worktreeMap.get(result.issueNumber);
-        if (worktreeInfo?.path) {
-            const stats = getWorktreeDiffStats(worktreeInfo.path);
-            totalFilesChanged += stats.filesChanged;
-            totalLinesAdded += stats.linesAdded;
-        }
-        if (result.loopTriggered) {
-            totalQaIterations += result.phaseResults.filter((p) => p.phase === "loop").length;
-        }
-    }
-    // Build CLI flags for metrics
-    const cliFlags = [];
-    if (mergedOptions.sequential)
-        cliFlags.push("--sequential");
-    if (mergedOptions.chain)
-        cliFlags.push("--chain");
-    if (mergedOptions.qaGate)
-        cliFlags.push("--qa-gate");
-    if (mergedOptions.qualityLoop)
-        cliFlags.push("--quality-loop");
-    if (mergedOptions.testgen)
-        cliFlags.push("--testgen");
-    // Read token usage from SessionEnd hook files
-    const tokenUsage = getTokenUsageForRun(undefined, true);
-    const passed = results.filter((r) => r.success).length;
-    await metricsWriter.recordRun({
-        issues: issueNumbers,
-        phases: Array.from(allPhases),
-        outcome: determineOutcome(passed, results.length),
-        duration: totalDuration,
-        model: process.env.ANTHROPIC_MODEL ?? "opus",
-        flags: cliFlags,
-        metrics: {
-            tokensUsed: tokenUsage.tokensUsed,
-            filesChanged: totalFilesChanged,
-            linesAdded: totalLinesAdded,
-            acceptanceCriteria: 0,
-            qaIterations: totalQaIterations,
-            inputTokens: tokenUsage.inputTokens || undefined,
-            outputTokens: tokenUsage.outputTokens || undefined,
-            cacheTokens: tokenUsage.cacheTokens || undefined,
-        },
-    });
-    if (config.verbose) {
-        console.log(chalk.gray(`  📊 Metrics recorded to .sequant/metrics.json`));
-    }
-}
-/**
- * Print the run summary to console
- *
- * @param params - Summary display parameters
- * @returns exit code (0 for success, 1 if any failed)
- */
-export function printRunSummary(params) {
-    const { results, logPath, config, mergedOptions } = params;
-    const passed = results.filter((r) => r.success).length;
-    const failed = results.filter((r) => !r.success).length;
-    console.log("\n" + ui.divider());
-    console.log(colors.info("  Summary"));
-    console.log(ui.divider());
-    console.log(colors.muted(`\n  Results: ${colors.success(`${passed} passed`)}, ${colors.error(`${failed} failed`)}`));
-    for (const result of results) {
-        const status = result.success
-            ? ui.statusIcon("success")
-            : ui.statusIcon("error");
-        const duration = result.durationSeconds
-            ? colors.muted(` (${formatDuration(result.durationSeconds)})`)
-            : "";
-        const phases = result.phaseResults
-            .map((p) => (p.success ? colors.success(p.phase) : colors.error(p.phase)))
-            .join(" → ");
-        const loopInfo = result.loopTriggered ? colors.warning(" [loop]") : "";
-        const prInfo = result.prUrl
-            ? colors.muted(` → PR #${result.prNumber}`)
-            : "";
-        console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${prInfo}${duration}`);
-    }
-    console.log("");
-    if (logPath) {
-        console.log(colors.muted(`  📝 Log: ${logPath}`));
-        console.log("");
-    }
-    if (results.length > 1 && passed > 0 && !config.dryRun) {
-        console.log(colors.muted("  💡 Verify batch integration before merging:"));
-        console.log(colors.muted("     sequant merge --check"));
-        console.log("");
-    }
-    if (config.dryRun) {
-        console.log(colors.warning("  ℹ️  This was a dry run. Use without --dry-run to execute."));
-        console.log("");
-    }
-    return failed > 0 && !config.dryRun ? 1 : 0;
-}

package/templates/agents/sequant-explorer.md

@@ -1,24 +0,0 @@
----
-name: sequant-explorer
-description: Codebase exploration agent for sequant /spec phase. Searches for existing patterns, components, database schemas, and file structures. Use when gathering context before planning a feature implementation.
-# Note: per anthropics/claude-code#43869 this is currently a no-op; agent runs on parent's model
-model: haiku
-maxTurns: 15
-tools:
-  - Read
-  - Grep
-  - Glob
----
-
-You are an exploration agent for the sequant development workflow.
-
-Your job is to search the codebase for existing patterns, components, and structures relevant to a planned feature.
-
-Rules:
-- Search thoroughly across relevant directories
-- Report findings in structured format: file paths, patterns discovered, recommendations
-- Do NOT modify any files
-- Do NOT run shell commands
-- Send results back via SendMessage when complete
-- All grep commands must use `|| true` to prevent exit code 1 on zero matches
-- Focus on actionable findings that inform implementation decisions