ai-foreman 1.0.9 → 1.0.11

package/dist/branch/planner.d.ts

@@ -0,0 +1,19 @@
+import type { TicketDef } from "../tickets/ticketSchema.js";
+import type { TicketState } from "../tickets/stateDb.js";
+import type { BranchPlan } from "./types.js";
+export interface AuditDependency {
+    ticket: string;
+    dependsOn: string;
+    reason?: string;
+}
+export interface BuildBranchPlanOptions {
+    steps: number;
+    baseRef: string;
+    branchPrefix: string;
+    maxBranchDepth: number;
+    auditDependencies?: AuditDependency[];
+}
+export declare function buildBranchPlan(tickets: TicketDef[], states: Map<string, TicketState>, opts: BuildBranchPlanOptions): BranchPlan;
+export declare function selectTicketsForBranchRun(tickets: TicketDef[], states: Map<string, TicketState>, steps: number): TicketDef[];
+export declare function parseAuditDependencies(text: string): AuditDependency[];
+export declare function buildBranchAuditInstruction(tickets: TicketDef[]): string;

package/dist/branch/planner.js

@@ -0,0 +1,196 @@
+export function buildBranchPlan(tickets, states, opts) {
+    const selected = selectTicketsForBranchRun(tickets, states, opts.steps);
+    const selectedIds = new Set(selected.map((ticket) => ticket.id));
+    const issues = [];
+    const dependencyMap = new Map();
+    for (const ticket of selected) {
+        dependencyMap.set(ticket.id, ticket.depends_on.filter((dep) => selectedIds.has(dep)));
+    }
+    for (const dep of opts.auditDependencies ?? []) {
+        if (!selectedIds.has(dep.ticket) || !selectedIds.has(dep.dependsOn))
+            continue;
+        const existing = dependencyMap.get(dep.ticket) ?? [];
+        if (!existing.includes(dep.dependsOn))
+            existing.push(dep.dependsOn);
+        dependencyMap.set(dep.ticket, existing);
+    }
+    for (const cycle of detectSelectedCycles(selected, dependencyMap)) {
+        issues.push({ code: "cycle", message: `branch dependency cycle: ${cycle}`, blocking: true });
+    }
+    const usedBranches = new Set();
+    const branchById = new Map();
+    const nodeById = new Map();
+    const depthMemo = new Map();
+    const depthOf = (id, visiting = new Set()) => {
+        if (depthMemo.has(id))
+            return depthMemo.get(id);
+        if (visiting.has(id))
+            return Number.POSITIVE_INFINITY;
+        visiting.add(id);
+        const deps = dependencyMap.get(id) ?? [];
+        const depth = deps.length === 0 ? 1 : Math.max(...deps.map((dep) => depthOf(dep, visiting))) + 1;
+        visiting.delete(id);
+        depthMemo.set(id, depth);
+        return depth;
+    };
+    for (const ticket of selected) {
+        const dependencies = dependencyMap.get(ticket.id) ?? [];
+        if (dependencies.length > 1 && !hasAncestorJoin(dependencies, dependencyMap)) {
+            issues.push({
+                ticket: ticket.id,
+                code: "multi_root_join",
+                message: `${ticket.id} depends on multiple selected roots (${dependencies.join(", ")})`,
+                blocking: true,
+            });
+        }
+        const depth = depthOf(ticket.id);
+        if (depth > opts.maxBranchDepth) {
+            issues.push({
+                ticket: ticket.id,
+                code: "depth_exceeded",
+                message: `${ticket.id} branch depth ${depth} exceeds --max-branch-depth ${opts.maxBranchDepth}`,
+                blocking: true,
+            });
+        }
+    }
+    for (const ticket of selected) {
+        branchById.set(ticket.id, uniqueBranchName(opts.branchPrefix, ticket, usedBranches));
+    }
+    for (const ticket of selected) {
+        const dependencies = dependencyMap.get(ticket.id) ?? [];
+        const branch = branchById.get(ticket.id);
+        const baseTicket = chooseBaseDependency(dependencies, dependencyMap);
+        const baseBranch = baseTicket ? (branchById.get(baseTicket) ?? opts.baseRef) : opts.baseRef;
+        const node = {
+            ticket,
+            branch,
+            baseRef: opts.baseRef,
+            baseBranch,
+            dependencies,
+            depth: depthOf(ticket.id),
+        };
+        nodeById.set(ticket.id, node);
+    }
+    return { baseRef: opts.baseRef, nodes: selected.map((ticket) => nodeById.get(ticket.id)), issues };
+}
+export function selectTicketsForBranchRun(tickets, states, steps) {
+    const remaining = tickets
+        .filter((ticket) => {
+        const status = states.get(ticket.id)?.status ?? "planned";
+        return status !== "done" && status !== "canceled";
+    })
+        .sort((a, b) => a.order - b.order);
+    const simulatedDone = new Set(Array.from(states.values())
+        .filter((state) => state.status === "done")
+        .map((state) => state.ticket_id));
+    const selected = [];
+    for (const ticket of remaining) {
+        if (selected.length >= steps)
+            break;
+        if (ticket.depends_on.every((dep) => simulatedDone.has(dep))) {
+            selected.push(ticket);
+            simulatedDone.add(ticket.id);
+        }
+    }
+    return selected;
+}
+export function parseAuditDependencies(text) {
+    const deps = [];
+    for (const line of text.split(/\r?\n/)) {
+        const match = line.match(/\b([A-Za-z][A-Za-z0-9-_]*)\s+(?:depends_on|depends on|after)\s+([A-Za-z][A-Za-z0-9-_]*)\b/i);
+        if (match)
+            deps.push({ ticket: match[1], dependsOn: match[2], reason: line.trim() });
+    }
+    return deps;
+}
+export function buildBranchAuditInstruction(tickets) {
+    const body = tickets.map((ticket) => [
+        `${ticket.id}: ${ticket.title}`,
+        `Summary: ${ticket.summary}`,
+        `Acceptance: ${ticket.acceptance.join("; ")}`,
+        `Likely files: ${ticket.likely_files.join(", ") || "unknown"}`,
+        `Declared depends_on: ${ticket.depends_on.join(", ") || "None"}`,
+    ].join("\n")).join("\n\n");
+    return `Audit this selected ticket batch for undeclared code dependencies. Do not implement anything.
+
+Return one line per required selected-ticket dependency using:
+<ticket> depends_on <ticket> - <short reason>
+
+Only name dependencies where both tickets are in this selected batch. If there are none, say "None".
+
+${body}`;
+}
+function uniqueBranchName(prefix, ticket, used) {
+    const cleanPrefix = prefix.replace(/^\/+|\/+$/g, "") || "rafi";
+    const baseSlug = `${ticket.id}-${ticket.title}`
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 72);
+    let branch = `${cleanPrefix}/${baseSlug}`;
+    let i = 2;
+    while (used.has(branch)) {
+        branch = `${cleanPrefix}/${baseSlug}-${i}`;
+        i++;
+    }
+    used.add(branch);
+    return branch;
+}
+function detectSelectedCycles(tickets, deps) {
+    const selected = new Set(tickets.map((ticket) => ticket.id));
+    const visited = new Set();
+    const inStack = new Set();
+    const cycles = [];
+    function dfs(id, path) {
+        if (inStack.has(id)) {
+            const start = path.indexOf(id);
+            cycles.push([...path.slice(start), id].join(" -> "));
+            return;
+        }
+        if (visited.has(id))
+            return;
+        visited.add(id);
+        inStack.add(id);
+        for (const dep of deps.get(id) ?? []) {
+            if (selected.has(dep))
+                dfs(dep, [...path, id]);
+        }
+        inStack.delete(id);
+    }
+    for (const ticket of tickets)
+        dfs(ticket.id, []);
+    return cycles;
+}
+function hasAncestorJoin(parents, deps) {
+    for (const left of parents) {
+        for (const right of parents) {
+            if (left !== right && isAncestor(left, right, deps))
+                return true;
+        }
+    }
+    return false;
+}
+function isAncestor(ancestor, child, deps, visited = new Set()) {
+    if (visited.has(child))
+        return false;
+    visited.add(child);
+    for (const dep of deps.get(child) ?? []) {
+        if (dep === ancestor || isAncestor(ancestor, dep, deps, visited))
+            return true;
+    }
+    return false;
+}
+function chooseBaseDependency(dependencies, deps) {
+    if (dependencies.length === 0)
+        return undefined;
+    return [...dependencies].sort((a, b) => chainDepth(b, deps) - chainDepth(a, deps))[0];
+}
+function chainDepth(id, deps, visiting = new Set()) {
+    if (visiting.has(id))
+        return 0;
+    visiting.add(id);
+    const parents = deps.get(id) ?? [];
+    const depth = parents.length === 0 ? 1 : Math.max(...parents.map((dep) => chainDepth(dep, deps, visiting))) + 1;
+    visiting.delete(id);
+    return depth;
+}

package/dist/branch/resume.d.ts

@@ -0,0 +1,21 @@
+import type { BranchRunSummary } from "./types.js";
+export interface BranchResumeSession {
+    ticket: string;
+    branch: string;
+    base: string;
+    worktreePath: string;
+    sessionId: string;
+    logPath: string;
+    agent?: string;
+    model?: string;
+    effort?: string;
+    fast?: boolean;
+    qaEnabled?: boolean;
+    createPr?: boolean;
+    prReady?: boolean;
+    keepWorktrees?: boolean;
+    ts?: string;
+}
+export declare function findResumableBranchSessions(foremanDir: string): BranchResumeSession[];
+export declare function formatBranchContinueCommand(projectDir: string, session: BranchResumeSession): string;
+export declare function formatBranchSummaryFollowupCommands(projectDir: string, foremanDir: string, summaries: Pick<BranchRunSummary, "ticket" | "buildStatus">[]): string[];

package/dist/branch/resume.js

@@ -0,0 +1,115 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export function findResumableBranchSessions(foremanDir) {
+    if (!existsSync(foremanDir))
+        return [];
+    const byTicket = new Map();
+    const logs = readdirSync(foremanDir)
+        .filter((file) => file.endsWith(".jsonl"))
+        .sort();
+    for (const file of logs) {
+        const logPath = join(foremanDir, file);
+        const lines = readFileSync(logPath, "utf8").split(/\r?\n/).filter(Boolean);
+        for (const line of lines) {
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (record.event === "branch-session") {
+                const ticket = stringField(record.ticket);
+                const branch = stringField(record.branch);
+                const base = stringField(record.base);
+                const worktreePath = stringField(record.worktreePath);
+                const sessionId = stringField(record.sessionId);
+                if (!ticket || !branch || !base || !worktreePath || !sessionId)
+                    continue;
+                byTicket.set(ticket, {
+                    ticket,
+                    branch,
+                    base,
+                    worktreePath,
+                    sessionId,
+                    logPath,
+                    agent: stringField(record.agent),
+                    model: stringField(record.model),
+                    effort: stringField(record.effort),
+                    fast: booleanField(record.fast),
+                    qaEnabled: booleanField(record.qaEnabled),
+                    createPr: booleanField(record.createPr),
+                    prReady: booleanField(record.prReady),
+                    keepWorktrees: booleanField(record.keepWorktrees),
+                    ts: stringField(record.ts),
+                });
+            }
+            else if (record.event === "branch-complete") {
+                const ticket = stringField(record.ticket);
+                const status = stringField(record.status);
+                if (ticket && status === "done")
+                    byTicket.delete(ticket);
+            }
+        }
+    }
+    return Array.from(byTicket.values())
+        .filter((session) => existsSync(session.worktreePath))
+        .sort((a, b) => a.ticket.localeCompare(b.ticket, undefined, { numeric: true }));
+}
+export function formatBranchContinueCommand(projectDir, session) {
+    const args = [
+        "ai-foreman",
+        "start",
+        shellQuote(projectDir),
+        "--steps",
+        "1",
+        session.createPr ? "--create-pr" : "--branch-per-ticket",
+        "--continue",
+        "--ticket",
+        shellQuote(session.ticket),
+    ];
+    if (session.agent && session.agent !== "claude")
+        args.push("--agent", shellQuote(session.agent));
+    if (session.model)
+        args.push("--model", shellQuote(session.model));
+    if (session.effort)
+        args.push("--effort", shellQuote(session.effort));
+    if (session.fast)
+        args.push("--fast");
+    if (session.qaEnabled === false)
+        args.push("--no-qa");
+    if (session.prReady)
+        args.push("--pr-ready");
+    if (session.keepWorktrees)
+        args.push("--keep-worktrees");
+    return args.join(" ");
+}
+export function formatBranchSummaryFollowupCommands(projectDir, foremanDir, summaries) {
+    const sessions = findResumableBranchSessions(foremanDir);
+    const sessionByTicket = new Map(sessions.map((session) => [session.ticket, session]));
+    const seen = new Set();
+    const commands = [];
+    for (const summary of summaries) {
+        if (summary.buildStatus !== "blocked" && summary.buildStatus !== "needs-human")
+            continue;
+        if (summary.ticket === "plan" || seen.has(summary.ticket))
+            continue;
+        const session = sessionByTicket.get(summary.ticket);
+        if (!session)
+            continue;
+        seen.add(summary.ticket);
+        commands.push(formatBranchContinueCommand(projectDir, session));
+    }
+    return commands;
+}
+function stringField(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function booleanField(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, "'\"'\"'")}'`;
+}

package/dist/branch/runner.d.ts

@@ -0,0 +1,28 @@
+import type { BuilderAdapter, EffortLevel } from "../adapters/types.js";
+import type { Log } from "../log.js";
+import type { BranchPlan, BranchPlanNode, BranchRunSummary } from "./types.js";
+export interface BranchRunnerOptions {
+    projectDir: string;
+    runId: string;
+    plan: BranchPlan;
+    log: Log;
+    agent?: string;
+    model?: string;
+    effort?: EffortLevel;
+    fast?: boolean;
+    notificationsEnabled: boolean;
+    qaEnabled: boolean;
+    createPr: boolean;
+    prReady: boolean;
+    keepWorktrees: boolean;
+    allowedBaseDirtyPaths?: string[];
+    resumeSessions?: Map<string, {
+        worktreePath: string;
+        sessionId: string;
+    }>;
+    createBuilder: (cwd: string, sessionId?: string) => Promise<BuilderAdapter>;
+    observeBuilder?: (builder: BuilderAdapter) => Promise<void>;
+}
+export declare function runBranchPlan(opts: BranchRunnerOptions): Promise<BranchRunSummary[]>;
+export declare function buildBranchTicketInstruction(node: BranchPlanNode): string;
+export declare function buildBranchTicketResumeInstruction(node: BranchPlanNode): string;