sequant 1.20.3 → 2.0.1

package/dist/src/lib/workflow/drivers/aider.js

@@ -0,0 +1,160 @@
+/**
+ * AiderDriver — AgentDriver implementation wrapping the Aider CLI.
+ *
+ * Shells out to `aider --yes --no-auto-commits --message "<prompt>"`
+ * for fully non-interactive phase execution. Sequant manages git,
+ * not Aider.
+ */
+import { spawn } from "child_process";
+import { execSync } from "child_process";
+import { RingBuffer } from "../ring-buffer.js";
+export class AiderDriver {
+    name = "aider";
+    settings;
+    constructor(settings) {
+        this.settings = settings;
+    }
+    async executePhase(prompt, config) {
+        const args = this.buildArgs(prompt, config.files);
+        return new Promise((resolve) => {
+            let capturedOutput = "";
+            let capturedStderr = "";
+            const stderrBuffer = new RingBuffer(50);
+            const stdoutBuffer = new RingBuffer(50);
+            const proc = spawn("aider", args, {
+                cwd: config.cwd,
+                env: { ...process.env, ...config.env },
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            // Set up timeout
+            const timeoutId = setTimeout(() => {
+                proc.kill("SIGTERM");
+            }, config.phaseTimeout * 1000);
+            // Wire external abort signal
+            if (config.abortSignal) {
+                const onAbort = () => {
+                    proc.kill("SIGTERM");
+                };
+                config.abortSignal.addEventListener("abort", onAbort);
+                proc.on("close", () => {
+                    config.abortSignal?.removeEventListener("abort", onAbort);
+                });
+            }
+            proc.stdout.on("data", (data) => {
+                const text = data.toString();
+                capturedOutput += text;
+                const lines = text.split("\n").filter((l) => l.length > 0);
+                for (const line of lines) {
+                    stdoutBuffer.push(line);
+                }
+                if (config.verbose) {
+                    config.onOutput?.(text);
+                }
+            });
+            proc.stderr.on("data", (data) => {
+                const text = data.toString();
+                capturedStderr += text;
+                const lines = text.split("\n").filter((l) => l.length > 0);
+                for (const line of lines) {
+                    stderrBuffer.push(line);
+                }
+                config.onStderr?.(text);
+            });
+            proc.on("error", (err) => {
+                clearTimeout(timeoutId);
+                if (err.code === "ENOENT") {
+                    resolve({
+                        success: false,
+                        output: capturedOutput,
+                        error: "Aider CLI not found. Install it with: pip install aider-chat",
+                        stderrTail: stderrBuffer.getLines(),
+                        stdoutTail: stdoutBuffer.getLines(),
+                    });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        output: capturedOutput,
+                        error: `Failed to start aider: ${err.message}`,
+                        stderrTail: stderrBuffer.getLines(),
+                        stdoutTail: stdoutBuffer.getLines(),
+                    });
+                }
+            });
+            proc.on("close", (code, signal) => {
+                clearTimeout(timeoutId);
+                if (signal) {
+                    const isTimeout = signal === "SIGTERM";
+                    resolve({
+                        success: false,
+                        output: capturedOutput,
+                        error: isTimeout
+                            ? `Timeout after ${config.phaseTimeout}s`
+                            : `Process killed by signal: ${signal}`,
+                        stderrTail: stderrBuffer.getLines(),
+                        stdoutTail: stdoutBuffer.getLines(),
+                        exitCode: code ?? undefined,
+                    });
+                    return;
+                }
+                if (code === 0) {
+                    resolve({
+                        success: true,
+                        output: capturedOutput,
+                        stderrTail: stderrBuffer.getLines(),
+                        stdoutTail: stdoutBuffer.getLines(),
+                        exitCode: 0,
+                    });
+                }
+                else {
+                    const stderrSuffix = capturedStderr
+                        ? `\nStderr: ${capturedStderr.slice(0, 500)}`
+                        : "";
+                    resolve({
+                        success: false,
+                        output: capturedOutput,
+                        error: `Aider exited with code ${code}${stderrSuffix}`,
+                        stderrTail: stderrBuffer.getLines(),
+                        stdoutTail: stdoutBuffer.getLines(),
+                        exitCode: code ?? undefined,
+                    });
+                }
+            });
+        });
+    }
+    async isAvailable() {
+        try {
+            execSync("which aider", { stdio: "pipe" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Build the CLI argument list for aider. */
+    buildArgs(prompt, files) {
+        const args = [
+            "--yes",
+            "--no-auto-commits",
+            "--no-pretty",
+            "--message",
+            prompt,
+        ];
+        if (this.settings?.model) {
+            args.push("--model", this.settings.model);
+        }
+        if (this.settings?.editFormat) {
+            args.push("--edit-format", this.settings.editFormat);
+        }
+        if (this.settings?.extraArgs) {
+            args.push(...this.settings.extraArgs);
+        }
+        // Pass relevant files for context (e.g., changed files from git diff)
+        if (files?.length) {
+            for (const file of files) {
+                args.push("--file", file);
+            }
+        }
+        return args;
+    }
+}

package/dist/src/lib/workflow/drivers/claude-code.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ClaudeCodeDriver — AgentDriver implementation wrapping the Claude Agent SDK.
+ *
+ * Owns the `@anthropic-ai/claude-agent-sdk` import. No other file in the
+ * orchestration layer should import the SDK directly.
+ */
+import type { AgentDriver, AgentExecutionConfig, AgentPhaseResult } from "./agent-driver.js";
+export declare class ClaudeCodeDriver implements AgentDriver {
+    name: string;
+    /**
+     * Track session ID across calls so callers can implement resume.
+     * Set after each executePhase() call.
+     */
+    private lastSessionId?;
+    executePhase(prompt: string, config: AgentExecutionConfig): Promise<AgentPhaseResult>;
+    isAvailable(): Promise<boolean>;
+}

package/dist/src/lib/workflow/drivers/claude-code.js

@@ -0,0 +1,165 @@
+/**
+ * ClaudeCodeDriver — AgentDriver implementation wrapping the Claude Agent SDK.
+ *
+ * Owns the `@anthropic-ai/claude-agent-sdk` import. No other file in the
+ * orchestration layer should import the SDK directly.
+ */
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { getMcpServersConfig } from "../../system.js";
+import { RingBuffer } from "../ring-buffer.js";
+export class ClaudeCodeDriver {
+    name = "claude-code";
+    /**
+     * Track session ID across calls so callers can implement resume.
+     * Set after each executePhase() call.
+     */
+    lastSessionId;
+    async executePhase(prompt, config) {
+        const abortController = new AbortController();
+        // Wire external abort signal
+        if (config.abortSignal) {
+            config.abortSignal.addEventListener("abort", () => abortController.abort());
+        }
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+            abortController.abort();
+        }, config.phaseTimeout * 1000);
+        let resultSessionId;
+        let resultMessage;
+        let capturedOutput = "";
+        let capturedStderr = "";
+        const stderrBuffer = new RingBuffer(50);
+        const stdoutBuffer = new RingBuffer(50);
+        try {
+            // Get MCP servers config if enabled
+            const mcpServers = config.mcp ? getMcpServersConfig() : undefined;
+            const queryInstance = query({
+                prompt,
+                options: {
+                    abortController,
+                    cwd: config.cwd,
+                    settingSources: ["project"],
+                    systemPrompt: { type: "preset", preset: "claude_code" },
+                    tools: { type: "preset", preset: "claude_code" },
+                    permissionMode: "bypassPermissions",
+                    allowDangerouslySkipPermissions: true,
+                    // Resume from previous session if provided
+                    ...(config.sessionId ? { resume: config.sessionId } : {}),
+                    env: config.env,
+                    ...(mcpServers ? { mcpServers } : {}),
+                    stderr: (data) => {
+                        capturedStderr += data;
+                        // Split on newlines and push each line to the ring buffer
+                        const lines = data.split("\n").filter((l) => l.length > 0);
+                        for (const line of lines) {
+                            stderrBuffer.push(line);
+                        }
+                        config.onStderr?.(data);
+                    },
+                },
+            });
+            // Stream and process messages
+            for await (const message of queryInstance) {
+                if (message.type === "system" && message.subtype === "init") {
+                    resultSessionId = message.session_id;
+                }
+                if (message.type === "assistant") {
+                    const content = message.message.content;
+                    const textContent = content
+                        .filter((c) => c.type === "text" && c.text)
+                        .map((c) => c.text)
+                        .join("");
+                    if (textContent) {
+                        capturedOutput += textContent;
+                        const lines = textContent.split("\n").filter((l) => l.length > 0);
+                        for (const line of lines) {
+                            stdoutBuffer.push(line);
+                        }
+                        config.onOutput?.(textContent);
+                    }
+                }
+                if (message.type === "result") {
+                    resultMessage = message;
+                }
+            }
+            clearTimeout(timeoutId);
+            this.lastSessionId = resultSessionId;
+            if (resultMessage) {
+                if (resultMessage.subtype === "success") {
+                    return {
+                        success: true,
+                        output: capturedOutput,
+                        sessionId: resultSessionId,
+                        stderrTail: stderrBuffer.getLines(),
+                        stdoutTail: stdoutBuffer.getLines(),
+                    };
+                }
+                // Handle error subtypes
+                let error;
+                const errorSubtype = resultMessage.subtype;
+                if (errorSubtype === "error_max_turns") {
+                    error = "Max turns reached";
+                }
+                else if (errorSubtype === "error_during_execution") {
+                    error = resultMessage.errors?.join(", ") || "Error during execution";
+                }
+                else if (errorSubtype === "error_max_budget_usd") {
+                    error = "Budget limit exceeded";
+                }
+                else {
+                    error = `Error: ${errorSubtype}`;
+                }
+                return {
+                    success: false,
+                    output: capturedOutput,
+                    sessionId: resultSessionId,
+                    error,
+                    stderrTail: stderrBuffer.getLines(),
+                    stdoutTail: stdoutBuffer.getLines(),
+                };
+            }
+            return {
+                success: false,
+                output: capturedOutput,
+                sessionId: resultSessionId,
+                error: "No result received from Claude",
+                stderrTail: stderrBuffer.getLines(),
+                stdoutTail: stdoutBuffer.getLines(),
+            };
+        }
+        catch (err) {
+            clearTimeout(timeoutId);
+            const error = err instanceof Error ? err.message : String(err);
+            if (error.includes("abort") || error.includes("AbortError")) {
+                return {
+                    success: false,
+                    output: capturedOutput,
+                    error: `Timeout after ${config.phaseTimeout}s`,
+                    stderrTail: stderrBuffer.getLines(),
+                    stdoutTail: stdoutBuffer.getLines(),
+                };
+            }
+            const stderrSuffix = capturedStderr
+                ? `\nStderr: ${capturedStderr.slice(0, 500)}`
+                : "";
+            return {
+                success: false,
+                output: capturedOutput,
+                sessionId: resultSessionId,
+                error: error + stderrSuffix,
+                stderrTail: stderrBuffer.getLines(),
+                stdoutTail: stdoutBuffer.getLines(),
+            };
+        }
+    }
+    async isAvailable() {
+        try {
+            // If we can import the SDK, it's available
+            await import("@anthropic-ai/claude-agent-sdk");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/src/lib/workflow/drivers/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Agent driver registry.
+ *
+ * Simple map-based registry — not a plugin system.
+ * New drivers are registered by adding entries to DRIVERS.
+ */
+import type { AgentDriver } from "./agent-driver.js";
+import type { AiderSettings } from "../../settings.js";
+export type { AgentDriver, AgentExecutionConfig, AgentPhaseResult, } from "./agent-driver.js";
+export interface DriverOptions {
+    aiderSettings?: AiderSettings;
+}
+/**
+ * Get an agent driver by name.
+ *
+ * @param name - Driver name (default: "claude-code")
+ * @param options - Optional driver-specific settings
+ * @throws Error if driver name is unknown
+ */
+export declare function getDriver(name?: string, options?: DriverOptions): AgentDriver;

package/dist/src/lib/workflow/drivers/index.js

@@ -0,0 +1,27 @@
+/**
+ * Agent driver registry.
+ *
+ * Simple map-based registry — not a plugin system.
+ * New drivers are registered by adding entries to DRIVERS.
+ */
+import { ClaudeCodeDriver } from "./claude-code.js";
+import { AiderDriver } from "./aider.js";
+const DRIVERS = {
+    "claude-code": () => new ClaudeCodeDriver(),
+    aider: (opts) => new AiderDriver(opts?.aiderSettings),
+};
+/**
+ * Get an agent driver by name.
+ *
+ * @param name - Driver name (default: "claude-code")
+ * @param options - Optional driver-specific settings
+ * @throws Error if driver name is unknown
+ */
+export function getDriver(name = "claude-code", options) {
+    const factory = DRIVERS[name];
+    if (!factory) {
+        const available = Object.keys(DRIVERS).join(", ");
+        throw new Error(`Unknown agent driver "${name}". Available drivers: ${available}`);
+    }
+    return factory(options);
+}

package/dist/src/lib/workflow/error-classifier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Error classifier — categorizes phase failures from stderr content.
+ *
+ * Pattern-matches stderr lines against known error signatures to produce
+ * a structured category for analytics and debugging.
+ */
+/** All recognized error categories (AC-7: defined as constants). */
+export declare const ERROR_CATEGORIES: readonly ["context_overflow", "api_error", "hook_failure", "build_error", "timeout", "unknown"];
+export type ErrorCategory = (typeof ERROR_CATEGORIES)[number];
+/**
+ * Classify stderr lines into an error category.
+ *
+ * Scans lines in order; the first classifier whose pattern matches any line wins.
+ * Returns "unknown" if no patterns match.
+ */
+export declare function classifyError(stderrLines: string[]): ErrorCategory;

package/dist/src/lib/workflow/error-classifier.js

@@ -0,0 +1,90 @@
+/**
+ * Error classifier — categorizes phase failures from stderr content.
+ *
+ * Pattern-matches stderr lines against known error signatures to produce
+ * a structured category for analytics and debugging.
+ */
+/** All recognized error categories (AC-7: defined as constants). */
+export const ERROR_CATEGORIES = [
+    "context_overflow",
+    "api_error",
+    "hook_failure",
+    "build_error",
+    "timeout",
+    "unknown",
+];
+/**
+ * Ordered list of classifiers. First match wins (highest priority first).
+ */
+const CLASSIFIERS = [
+    {
+        category: "context_overflow",
+        patterns: [
+            /context window/i,
+            /token limit/i,
+            /context length/i,
+            /max.?context/i,
+            /exceeded.*context/i,
+        ],
+    },
+    {
+        category: "timeout",
+        patterns: [/timeout/i, /timed?\s*out/i, /SIGTERM/, /deadline exceeded/i],
+    },
+    {
+        category: "api_error",
+        patterns: [
+            /rate.?limit/i,
+            /\b429\b/,
+            /api.*error/i,
+            /auth.*fail/i,
+            /unauthorized/i,
+            /\b503\b/,
+            /\b502\b/,
+            /overloaded/i,
+        ],
+    },
+    {
+        category: "hook_failure",
+        patterns: [
+            /hook.*fail/i,
+            /pre-?commit/i,
+            /HOOK_BLOCKED/i,
+            /blocked by hook/i,
+        ],
+    },
+    {
+        category: "build_error",
+        patterns: [
+            /typescript.*error/i,
+            /TS\d{4,5}:/,
+            /syntax\s*error/i,
+            /cannot find module/i,
+            /compilation.*fail/i,
+            /build.*fail/i,
+            /eslint/i,
+            /npm ERR!/,
+        ],
+    },
+];
+/**
+ * Classify stderr lines into an error category.
+ *
+ * Scans lines in order; the first classifier whose pattern matches any line wins.
+ * Returns "unknown" if no patterns match.
+ */
+export function classifyError(stderrLines) {
+    if (!stderrLines || stderrLines.length === 0) {
+        return "unknown";
+    }
+    for (const { category, patterns } of CLASSIFIERS) {
+        for (const line of stderrLines) {
+            for (const pattern of patterns) {
+                if (pattern.test(line)) {
+                    return category;
+                }
+            }
+        }
+    }
+    return "unknown";
+}

package/dist/src/lib/workflow/log-writer.d.ts

@@ -32,6 +32,9 @@ export interface LogWriterOptions {
  */
 export declare class LogWriter {
     private runLog;
+    /** Active issues being tracked concurrently, keyed by issue number */
+    private activeIssues;
+    /** @deprecated Single-issue slot for backwards compatibility — use activeIssues */
     private currentIssue;
     private logPath;
     private writeToUserLogs;
@@ -62,11 +65,11 @@ export declare class LogWriter {
     /**
      * Set PR info on the current issue (call before completeIssue)
      */
-    setPRInfo(prNumber: number, prUrl: string): void;
+    setPRInfo(prNumber: number, prUrl: string, issueNumber?: number): void;
     /**
      * Complete the current issue and add it to the run log
      */
-    completeIssue(): void;
+    completeIssue(issueNumber?: number): void;
     /**
      * Finalize the run log and write to disk
      *
@@ -96,4 +99,4 @@ export declare class LogWriter {
  *
  * Utility function for creating phase logs when you have start/end times.
  */
-export declare function createPhaseLogFromTiming(phase: Phase, issueNumber: number, startTime: Date, endTime: Date, status: PhaseLog["status"], options?: Partial<Pick<PhaseLog, "error" | "iterations" | "filesModified" | "testsRun" | "testsPassed" | "verdict" | "commitHash" | "fileDiffStats" | "cacheMetrics">>): PhaseLog;
+export declare function createPhaseLogFromTiming(phase: Phase, issueNumber: number, startTime: Date, endTime: Date, status: PhaseLog["status"], options?: Partial<Pick<PhaseLog, "error" | "iterations" | "filesModified" | "testsRun" | "testsPassed" | "verdict" | "summary" | "commitHash" | "fileDiffStats" | "cacheMetrics" | "errorContext">>): PhaseLog;

package/dist/src/lib/workflow/log-writer.js

@@ -23,6 +23,9 @@ import { rotateIfNeeded, DEFAULT_ROTATION_SETTINGS, } from "./log-rotation.js";
  */
 export class LogWriter {
     runLog = null;
+    /** Active issues being tracked concurrently, keyed by issue number */
+    activeIssues = new Map();
+    /** @deprecated Single-issue slot for backwards compatibility — use activeIssues */
     currentIssue = null;
     logPath;
     writeToUserLogs;
@@ -64,7 +67,7 @@ export class LogWriter {
         if (!this.runLog) {
             throw new Error("LogWriter not initialized. Call initialize() first.");
         }
-        this.currentIssue = {
+        const issueData = {
             issueNumber,
             title,
             labels,
@@ -72,6 +75,9 @@ export class LogWriter {
             status: "success",
             totalDurationSeconds: 0,
         };
+        this.activeIssues.set(issueNumber, issueData);
+        // Keep currentIssue in sync for callers that don't pass issueNumber
+        this.currentIssue = issueData;
         if (this.verbose) {
             console.log(`📝 Started logging issue #${issueNumber}`);
         }
@@ -82,17 +88,18 @@ export class LogWriter {
      * @param phaseLog - Complete phase log entry
      */
     logPhase(phaseLog) {
-        if (!this.currentIssue) {
-            throw new Error("No current issue. Call startIssue() first.");
+        // Route to the correct issue by issueNumber, falling back to currentIssue
+        const issue = this.activeIssues.get(phaseLog.issueNumber) ?? this.currentIssue;
+        if (!issue) {
+            throw new Error(`No active issue #${phaseLog.issueNumber}. Call startIssue() first.`);
         }
-        this.currentIssue.phases = [...(this.currentIssue.phases ?? []), phaseLog];
+        issue.phases = [...(issue.phases ?? []), phaseLog];
         // Update issue status based on phase result
         if (phaseLog.status === "failure") {
-            this.currentIssue.status = "failure";
+            issue.status = "failure";
         }
-        else if (phaseLog.status === "timeout" &&
-            this.currentIssue.status !== "failure") {
-            this.currentIssue.status = "partial";
+        else if (phaseLog.status === "timeout" && issue.status !== "failure") {
+            issue.status = "partial";
         }
         if (this.verbose) {
             console.log(`📝 Logged phase: ${phaseLog.phase} (${phaseLog.status}) - ${phaseLog.durationSeconds.toFixed(1)}s`);
@@ -101,38 +108,57 @@ export class LogWriter {
     /**
      * Set PR info on the current issue (call before completeIssue)
      */
-    setPRInfo(prNumber, prUrl) {
-        if (!this.currentIssue) {
+    setPRInfo(prNumber, prUrl, issueNumber) {
+        const issue = issueNumber
+            ? (this.activeIssues.get(issueNumber) ?? this.currentIssue)
+            : this.currentIssue;
+        if (!issue) {
             return;
         }
-        this.currentIssue.prNumber = prNumber;
-        this.currentIssue.prUrl = prUrl;
+        issue.prNumber = prNumber;
+        issue.prUrl = prUrl;
     }
     /**
      * Complete the current issue and add it to the run log
      */
-    completeIssue() {
-        if (!this.runLog || !this.currentIssue) {
-            throw new Error("No current issue to complete.");
+    completeIssue(issueNumber) {
+        if (!this.runLog) {
+            throw new Error("No run log. Call initialize() first.");
+        }
+        // Resolve the issue to complete
+        const issue = issueNumber
+            ? this.activeIssues.get(issueNumber)
+            : this.currentIssue;
+        if (!issue) {
+            throw new Error(issueNumber
+                ? `No active issue #${issueNumber} to complete.`
+                : "No current issue to complete.");
         }
         // Calculate total duration from phases
-        const totalDurationSeconds = this.currentIssue.phases?.reduce((sum, p) => sum + p.durationSeconds, 0) ?? 0;
+        const totalDurationSeconds = issue.phases?.reduce((sum, p) => sum + p.durationSeconds, 0) ?? 0;
         const issueLog = {
-            issueNumber: this.currentIssue.issueNumber,
-            title: this.currentIssue.title,
-            labels: this.currentIssue.labels,
-            status: this.currentIssue.status,
-            phases: this.currentIssue.phases,
+            issueNumber: issue.issueNumber,
+            title: issue.title,
+            labels: issue.labels,
+            status: issue.status,
+            phases: issue.phases,
             totalDurationSeconds,
-            ...(this.currentIssue.prNumber != null && {
-                prNumber: this.currentIssue.prNumber,
+            ...(issue.prNumber != null && {
+                prNumber: issue.prNumber,
             }),
-            ...(this.currentIssue.prUrl != null && {
-                prUrl: this.currentIssue.prUrl,
+            ...(issue.prUrl != null && {
+                prUrl: issue.prUrl,
             }),
         };
         this.runLog.issues.push(issueLog);
-        this.currentIssue = null;
+        // Clean up from activeIssues map
+        if (issue.issueNumber != null) {
+            this.activeIssues.delete(issue.issueNumber);
+        }
+        // Clear currentIssue if it was the one completed
+        if (this.currentIssue === issue) {
+            this.currentIssue = null;
+        }
         if (this.verbose) {
             console.log(`📝 Completed issue #${issueLog.issueNumber} (${issueLog.status})`);
         }
@@ -150,7 +176,11 @@ export class LogWriter {
         if (!this.runLog) {
             throw new Error("LogWriter not initialized.");
         }
-        // Complete any pending issue
+        // Complete any pending issues (Map-based concurrent tracking)
+        for (const issueNum of [...this.activeIssues.keys()]) {
+            this.completeIssue(issueNum);
+        }
+        // Fallback: complete legacy currentIssue if not already handled
         if (this.currentIssue) {
             this.completeIssue();
         }