@oscharko-dev/keiko 0.1.5 → 0.1.7

package/dist/workflows/bug-investigation/verify-stage.js

@@ -1,91 +0,0 @@
-// The verification stage (ADR-0009 D11). Runs ONLY after a successful apply: it resolves a
-// verification plan by deriving the just-fixed/added tests from the changed SOURCE files via #7
-// resolveTargetedTests (so it finds the sibling/mirrored test incl. the just-added regression
-// test), falling back to the full `test` script, and records an explicit skip reason when neither
-// resolves or the framework is unknown. Verification reuses the #7 orchestrator unchanged; this
-// stage only wires the plan and projects an output-text-free audit summary. DEFERRED (D11): a
-// pre-patch reproduction baseline — Wave-1 verifies only the post-apply state.
-import { nodeSpawnFn } from "../../tools/index.js";
-import {} from "../../workspace/index.js";
-import { buildVerificationPlan, detectScripts, resolveTargetedTests, runVerification, summarizeForAudit, DEFAULT_VERIFICATION_LIMITS, } from "../../verification/index.js";
-import { isSensitivePath } from "./guard.js";
-export const SKIP_UNRESOLVED = "verification skipped: framework unknown or no test files resolved";
-// The non-test source files the patch changed — passed to resolveTargetedTests so it can find the
-// associated tests (incl. the just-added regression test). We approximate "source" as any changed
-// path that is not itself a test file (basename marks .test/.spec) and not a sensitive path.
-function changedSourceFiles(files) {
-    return files.map((f) => f.path).filter((path) => !isSensitivePath(path) && !isTestFile(path));
-}
-function changedTestFiles(files) {
-    return files.map((f) => f.path).filter((path) => !isSensitivePath(path) && isTestFile(path));
-}
-function isTestFile(path) {
-    const slash = path.lastIndexOf("/");
-    const base = slash === -1 ? path : path.slice(slash + 1);
-    const segments = base.split(".");
-    return segments.includes("test") || segments.includes("spec");
-}
-function buildPlanFallback(workspace, fs) {
-    const catalog = detectScripts(workspace, fs);
-    return buildVerificationPlan(workspace, catalog, { only: ["test"] }, fs);
-}
-function targetedChangedTests(workspace, testFiles) {
-    if (testFiles.length === 0) {
-        return undefined;
-    }
-    if (workspace.testFramework === "vitest") {
-        return {
-            kind: "targeted-test",
-            scriptName: undefined,
-            command: "npx",
-            args: ["vitest", "run", ...testFiles],
-            limits: DEFAULT_VERIFICATION_LIMITS,
-        };
-    }
-    if (workspace.testFramework === "jest") {
-        return {
-            kind: "targeted-test",
-            scriptName: undefined,
-            command: "npx",
-            args: ["jest", ...testFiles],
-            limits: DEFAULT_VERIFICATION_LIMITS,
-        };
-    }
-    return undefined;
-}
-function resolveVerificationPlan(workspace, changedFiles, fs) {
-    const directTests = targetedChangedTests(workspace, changedTestFiles(changedFiles));
-    if (directTests !== undefined) {
-        return { workspaceRoot: workspace.root, steps: [directTests] };
-    }
-    const targeted = resolveTargetedTests(workspace, changedSourceFiles(changedFiles), fs, DEFAULT_VERIFICATION_LIMITS);
-    if (targeted.length > 0) {
-        return { workspaceRoot: workspace.root, steps: targeted };
-    }
-    const fallback = buildPlanFallback(workspace, fs);
-    const runnable = fallback.steps.filter((step) => step.skipReason === undefined);
-    return runnable.length > 0 ? { workspaceRoot: workspace.root, steps: runnable } : undefined;
-}
-export async function runBugVerification(state, workspace, changedFiles, fs) {
-    const plan = resolveVerificationPlan(workspace, changedFiles, fs);
-    if (plan === undefined) {
-        return { summary: undefined, skipReason: SKIP_UNRESOLVED };
-    }
-    const report = await runVerification(plan, {
-        workspace,
-        signal: state.signal,
-        spawn: state.deps.spawn ?? nodeSpawnFn,
-        processEnv: state.deps.processEnv ?? process.env,
-        now: state.now,
-        fs,
-    });
-    const summary = summarizeForAudit(report);
-    state.emitter.emit({
-        type: "bug:verification:result",
-        overallStatus: summary.overallStatus,
-        stepCount: summary.results.length,
-        passedCount: summary.results.filter((r) => r.status === "passed").length,
-        durationMs: summary.durationMs,
-    });
-    return { summary, skipReason: undefined };
-}

package/dist/workflows/bug-investigation/workflow.d.ts

@@ -1,2 +0,0 @@
-import type { BugInvestigationDeps, BugInvestigationInput, BugInvestigationReport } from "./types.js";
-export declare function investigateBug(input: BugInvestigationInput, deps: BugInvestigationDeps): Promise<BugInvestigationReport>;

package/dist/workflows/bug-investigation/workflow.js

@@ -1,74 +0,0 @@
-// The single public entry: investigateBug (ADR-0009 D2/D6/D10/D11). A deterministic linear pipeline
-// (NOT the harness loop): intake precondition -> parse failure evidence -> build context -> [prompt
-// -> model -> parse -> validate -> scope-guard] (bounded retries) -> [investigation-only |
-// rejected | dry-run | apply -> verify] -> report. It composes #3-#7 UNCHANGED and emits redacted
-// progress events. The model loop, verify stage, and report stages live in sibling files to keep
-// each under the LOC limit; this file owns the stage sequencing, the intake precondition (return
-// `rejected` with no model call when no evidence is present), and the single top-level catch
-// boundary that maps a CancelledError to a "cancelled" report and any other IO failure to a
-// redacted "failed" report.
-import { CancelledError } from "../../gateway/errors.js";
-import { detectWorkspace } from "../../workspace/index.js";
-import { nodeWorkspaceFs } from "../../workspace/fs.js";
-import { buildBugContext } from "./context.js";
-import { computeBugFingerprint } from "./emit.js";
-import { parseFailureEvidence } from "./failure-parse.js";
-import { runBugModelLoop } from "./model-loop.js";
-import { cancelledReport, emitCompleted, failedReport, finishPipeline, insufficientInputReport, } from "./stages.js";
-import { buildBugRunState, EMPTY_BUG_LOOP } from "./internal.js";
-// Intake precondition (D2): at least one evidence field must be present, else there is nothing to
-// investigate and we reject WITHOUT calling the model.
-function hasEvidence(report) {
-    return (nonEmpty(report.description) ||
-        nonEmpty(report.failingOutput) ||
-        nonEmpty(report.stackTrace) ||
-        (report.targetFiles?.some((file) => nonEmpty(file)) ?? false));
-}
-function nonEmpty(value) {
-    return value !== undefined && value.trim().length > 0;
-}
-async function runPipeline(state) {
-    const report = state.input.report;
-    state.emitter.emit({
-        type: "bug:started",
-        workflowId: "bug-investigation",
-        modelId: state.input.modelId,
-        applyEnabled: state.input.apply === true,
-        limits: state.limits,
-    });
-    if (!hasEvidence(report)) {
-        return insufficientInputReport(state);
-    }
-    const fs = state.deps.fs ?? nodeWorkspaceFs;
-    const workspace = detectWorkspace(state.input.workspaceRoot, fs);
-    const evidence = parseFailureEvidence(report);
-    state.emitter.emit({
-        type: "bug:failure:parsed",
-        frameCount: evidence.frames.length,
-        messageCount: evidence.messages.length,
-    });
-    const pack = buildBugContext(workspace, report.description, evidence, state.limits, { fs });
-    state.emitter.emit({
-        type: "bug:context:selected",
-        entryCount: pack.selected.length,
-        usedBytes: pack.usedBytes,
-        budgetBytes: pack.budgetBytes,
-        droppedForBudget: pack.droppedForBudget,
-    });
-    const loop = await runBugModelLoop(state, workspace, report, evidence, pack);
-    return finishPipeline(state, workspace, loop, evidence);
-}
-export async function investigateBug(input, deps) {
-    const state = buildBugRunState(input, deps, computeBugFingerprint(input.report, input.modelId));
-    let report;
-    try {
-        report = await runPipeline(state);
-    }
-    catch (error) {
-        report =
-            error instanceof CancelledError
-                ? cancelledReport(state, EMPTY_BUG_LOOP, undefined, { frames: [], messages: [] })
-                : failedReport(state, error);
-    }
-    return emitCompleted(state, report);
-}

package/dist/workflows/unit-tests/context.d.ts

@@ -1,7 +0,0 @@
-import { type ContextPack, type WorkspaceInfo } from "../../workspace/index.js";
-import { type WorkspaceFs } from "../../workspace/fs.js";
-import type { UnitTestWorkflowInput, WorkflowLimits } from "./types.js";
-export interface TestGenContextDeps {
-    readonly fs?: WorkspaceFs | undefined;
-}
-export declare function buildTestGenContext(workspace: WorkspaceInfo, input: UnitTestWorkflowInput, limits: WorkflowLimits, deps?: TestGenContextDeps): ContextPack;

package/dist/workflows/unit-tests/context.js

@@ -1,129 +0,0 @@
-// Context assembly for the generation call (ADR-0008 D1). Delegates to #5 buildContextPack so the
-// target file, nearby test files, manifests/config, and type definitions are selected, ranked, and
-// excerpted under a byte budget — every excerpt already redacted by #5 at the IO boundary. Pure
-// except for the WorkspaceFs seam threaded into buildContextPack. The `task` hint is a forward-
-// compatible natural-language description of the target for a future embedding ranker; the Wave-1
-// lexical strategy tolerates it.
-import { buildContextPack, DEFAULT_DISCOVERY_OPTIONS, lexicalRetrievalStrategy, SELECTION_REASON_PRIORITY, } from "../../workspace/index.js";
-import { nodeWorkspaceFs } from "../../workspace/fs.js";
-function toPosix(path) {
-    return path.split("\\").join("/");
-}
-function underDir(path, dir) {
-    const normalized = toPosix(dir);
-    return path === normalized || path.startsWith(`${normalized}/`);
-}
-function basename(path) {
-    const normalized = toPosix(path);
-    const idx = normalized.lastIndexOf("/");
-    return idx === -1 ? normalized : normalized.slice(idx + 1);
-}
-function stem(path) {
-    const base = basename(path);
-    const idx = base.lastIndexOf(".");
-    return idx <= 0 ? base : base.slice(0, idx);
-}
-function testStem(path) {
-    const parts = stem(path).split(".");
-    const marker = parts.findIndex((part) => part === "test" || part === "spec");
-    return marker === -1 ? parts.join(".") : parts.slice(0, marker).join(".");
-}
-function targetPaths(target) {
-    if (target.kind === "file") {
-        return [toPosix(target.filePath)];
-    }
-    if (target.kind === "changedFiles") {
-        return target.filePaths.map(toPosix);
-    }
-    return [];
-}
-function moduleDir(target) {
-    return target.kind === "module" ? toPosix(target.moduleDir) : undefined;
-}
-function isRequestedTarget(path, input) {
-    const module = moduleDir(input.target);
-    return (targetPaths(input.target).includes(path) || (module !== undefined && underDir(path, module)));
-}
-function isTestCandidate(path, workspace, selectionReason) {
-    return (selectionReason === "test" ||
-        workspace.testDirs.some((testDir) => underDir(path, testDir)) ||
-        stem(path)
-            .split(".")
-            .some((part) => part === "test" || part === "spec"));
-}
-function isNearbyTest(path, workspace, input, selectionReason) {
-    if (!isTestCandidate(path, workspace, selectionReason)) {
-        return false;
-    }
-    const targets = targetPaths(input.target);
-    if (targets.length === 0) {
-        const module = moduleDir(input.target);
-        return module !== undefined && path.includes(basename(module));
-    }
-    const candidateStem = testStem(path);
-    return targets.some((target) => candidateStem === stem(target));
-}
-function priorityIndex(reason) {
-    return SELECTION_REASON_PRIORITY.indexOf(reason);
-}
-function issue8Priority(ranked, workspace, input) {
-    const path = toPosix(ranked.file.relativePath);
-    if (isRequestedTarget(path, input)) {
-        return 0;
-    }
-    if (isNearbyTest(path, workspace, input, ranked.selectionReason)) {
-        return 1;
-    }
-    return 2;
-}
-function isSupportContext(ranked) {
-    return ranked.selectionReason === "manifest" || ranked.selectionReason === "config";
-}
-function focusedContext(ranked, workspace, input) {
-    const focused = ranked.filter((item) => issue8Priority(item, workspace, input) < 2 || isSupportContext(item));
-    return focused.length === 0 ? ranked : focused;
-}
-function createUnitTestRetrievalStrategy(workspace, input) {
-    return {
-        rank: (files, task) => {
-            const ranked = focusedContext(lexicalRetrievalStrategy.rank(files, task), workspace, input);
-            return [...ranked].sort((a, b) => {
-                const byIssue8 = issue8Priority(a, workspace, input) - issue8Priority(b, workspace, input);
-                if (byIssue8 !== 0) {
-                    return byIssue8;
-                }
-                const byReason = priorityIndex(a.selectionReason) - priorityIndex(b.selectionReason);
-                if (byReason !== 0) {
-                    return byReason;
-                }
-                return a.file.relativePath.localeCompare(b.file.relativePath);
-            });
-        },
-    };
-}
-function taskHint(target) {
-    if (target.kind === "file") {
-        return target.targetFunction === undefined
-            ? `unit tests for ${target.filePath}`
-            : `unit tests for ${target.targetFunction} in ${target.filePath}`;
-    }
-    if (target.kind === "module") {
-        return `unit tests for module ${target.moduleDir}`;
-    }
-    return `unit tests for ${target.filePaths.join(", ")}`;
-}
-export function buildTestGenContext(workspace, input, limits, deps = {}) {
-    const request = {
-        task: taskHint(input.target),
-        budgetBytes: limits.contextBudgetBytes,
-        maxBytesPerFile: limits.maxBytesPerFile,
-        discovery: DEFAULT_DISCOVERY_OPTIONS,
-    };
-    // buildContextPack defaults to the lexical strategy, but ContextPackDeps requires the field; pass
-    // the #5 barrel default explicitly so we hand a complete deps object without reaching past #5.
-    const packDeps = {
-        fs: deps.fs ?? nodeWorkspaceFs,
-        strategy: createUnitTestRetrievalStrategy(workspace, input),
-    };
-    return buildContextPack(workspace, request, packDeps);
-}

package/dist/workflows/unit-tests/conventions.d.ts

@@ -1,4 +0,0 @@
-import type { ContextPack, WorkspaceInfo } from "../../workspace/index.js";
-import type { TestConventions } from "./types.js";
-export declare function isTestPath(workspace: WorkspaceInfo, relPath: string): boolean;
-export declare function detectConventions(workspace: WorkspaceInfo, pack: ContextPack): TestConventions;

package/dist/workflows/unit-tests/descriptor.d.ts

@@ -1,4 +0,0 @@
-import { type WorkflowLimits } from "./types.js";
-import type { WorkflowDescriptor } from "../descriptor.js";
-export type { WorkflowDescriptor, WorkflowInputSpec } from "../descriptor.js";
-export declare const UNIT_TEST_WORKFLOW_DESCRIPTOR: WorkflowDescriptor<WorkflowLimits>;

package/dist/workflows/unit-tests/emit.d.ts

@@ -1,12 +0,0 @@
-import type { UnitTestTarget } from "./types.js";
-import type { WorkflowEvent, WorkflowEventSink } from "./events.js";
-export declare function computeFingerprint(target: UnitTestTarget, modelId: string): string;
-type EnvelopeFields = "schemaVersion" | "runId" | "fingerprint" | "seq" | "ts";
-export type WorkflowEventBody = {
-    [E in WorkflowEvent as E["type"]]: Omit<E, EnvelopeFields>;
-}[WorkflowEvent["type"]];
-export interface EventEmitter {
-    readonly emit: (body: WorkflowEventBody) => void;
-}
-export declare function createEventEmitter(sink: WorkflowEventSink, runId: string, fingerprint: string, now: () => number): EventEmitter;
-export {};

package/dist/workflows/unit-tests/emit.js

@@ -1,35 +0,0 @@
-// Event emission helper for the workflow (ADR-0008 D4). Owns the monotonic seq counter and stamps
-// every event with the shared envelope ({ schemaVersion, runId, fingerprint, seq, ts }). The
-// fingerprint is SHA-256(workflowId + canonical(target) + modelId) truncated to 16 hex chars — the
-// same shape as the harness fingerprinter — reusing `canonicalise` from the harness barrel so two
-// structurally equal targets fingerprint identically regardless of key order. Sensitive fields are
-// redacted by the CALLER before handing the event here (this helper does not inspect payloads).
-import { createHash } from "node:crypto";
-import { canonicalise } from "../../harness/index.js";
-const FINGERPRINT_HEX_CHARS = 16;
-export function computeFingerprint(target, modelId) {
-    const canonical = canonicalise({ workflowId: "unit-test-generation", target, modelId });
-    return createHash("sha256")
-        .update(canonical, "utf8")
-        .digest("hex")
-        .slice(0, FINGERPRINT_HEX_CHARS);
-}
-export function createEventEmitter(sink, runId, fingerprint, now) {
-    let seq = 0;
-    return {
-        emit: (body) => {
-            seq += 1;
-            // The body is a complete discriminated-union member minus the envelope; re-attaching the
-            // envelope yields a valid WorkflowEvent. The cast is over the union, not a widening to any.
-            const event = {
-                schemaVersion: "1",
-                runId,
-                fingerprint,
-                seq,
-                ts: now(),
-                ...body,
-            };
-            sink.emit(event);
-        },
-    };
-}

package/dist/workflows/unit-tests/events.d.ts

@@ -1,78 +0,0 @@
-import type { TestFramework } from "../../workspace/index.js";
-import type { VerificationStatus } from "../../verification/index.js";
-import type { FileNamingStyle, WorkflowLimits, WorkflowStatus } from "./types.js";
-interface BaseWorkflowEvent {
-    readonly schemaVersion: "1";
-    readonly runId: string;
-    readonly fingerprint: string;
-    readonly seq: number;
-    readonly ts: number;
-}
-export interface WorkflowStartedEvent extends BaseWorkflowEvent {
-    readonly type: "workflow:started";
-    readonly workflowId: "unit-test-generation";
-    readonly modelId: string;
-    readonly applyEnabled: boolean;
-    readonly limits: WorkflowLimits;
-}
-export interface ConventionsDetectedEvent extends BaseWorkflowEvent {
-    readonly type: "conventions:detected";
-    readonly framework: TestFramework;
-    readonly testDirs: readonly string[];
-    readonly fileNamingStyle: FileNamingStyle;
-}
-export interface ContextSelectedEvent extends BaseWorkflowEvent {
-    readonly type: "context:selected";
-    readonly entryCount: number;
-    readonly usedBytes: number;
-    readonly budgetBytes: number;
-    readonly droppedForBudget: number;
-}
-export interface ModelCallStartedEvent extends BaseWorkflowEvent {
-    readonly type: "workflow:model:call:started";
-    readonly attempt: number;
-    readonly contextBytes: number;
-}
-export interface ModelCallCompletedEvent extends BaseWorkflowEvent {
-    readonly type: "workflow:model:call:completed";
-    readonly attempt: number;
-    readonly finishReason: string;
-    readonly promptTokens: number;
-    readonly completionTokens: number;
-    readonly latencyMs: number;
-}
-export interface PatchValidatedEvent extends BaseWorkflowEvent {
-    readonly type: "patch:validated";
-    readonly ok: boolean;
-    readonly patchBytes: number;
-    readonly filesChanged: number;
-    readonly rejectionCode?: string | undefined;
-}
-export interface PatchAppliedEvent extends BaseWorkflowEvent {
-    readonly type: "workflow:patch:applied";
-    readonly changedFiles: number;
-    readonly created: number;
-    readonly deleted: number;
-}
-export interface VerificationResultEvent extends BaseWorkflowEvent {
-    readonly type: "workflow:verification:result";
-    readonly overallStatus: VerificationStatus;
-    readonly stepCount: number;
-    readonly passedCount: number;
-    readonly durationMs: number;
-}
-export interface WorkflowCompletedEvent extends BaseWorkflowEvent {
-    readonly type: "workflow:completed";
-    readonly status: WorkflowStatus;
-    readonly durationMs: number;
-}
-export interface WorkflowFailedEvent extends BaseWorkflowEvent {
-    readonly type: "workflow:failed";
-    readonly errorCode: string;
-    readonly message: string;
-}
-export type WorkflowEvent = WorkflowStartedEvent | ConventionsDetectedEvent | ContextSelectedEvent | ModelCallStartedEvent | ModelCallCompletedEvent | PatchValidatedEvent | PatchAppliedEvent | VerificationResultEvent | WorkflowCompletedEvent | WorkflowFailedEvent;
-export interface WorkflowEventSink {
-    readonly emit: (event: WorkflowEvent) => void;
-}
-export {};

package/dist/workflows/unit-tests/events.js

@@ -1,7 +0,0 @@
-// The WorkflowEvent discriminated union and its BaseWorkflowEvent envelope (ADR-0008 D4). The
-// envelope reuses the harness BaseEvent field shape ({ schemaVersion, runId, fingerprint, seq,
-// ts }) by structural convention — NOT a TypeScript import — so the #10 audit ledger and #13 UI
-// can narrow workflow events with the same envelope logic they apply to HarnessEvent. This union
-// is SEPARATE from HarnessEvent because the workflow does not pass through the harness state
-// machine. No runtime logic lives here. Every SENSITIVE field is redacted before emit.
-export {};

package/dist/workflows/unit-tests/index.d.ts

@@ -1,6 +0,0 @@
-export { generateUnitTests } from "./workflow.js";
-export { assembleReport, renderMarkdownReport, type ReportParts } from "./report.js";
-export { UNIT_TEST_WORKFLOW_DESCRIPTOR, type WorkflowDescriptor, type WorkflowInputSpec, } from "./descriptor.js";
-export { detectConventions, isTestPath } from "./conventions.js";
-export { DEFAULT_WORKFLOW_LIMITS, type AddedTestFile, type FileNamingStyle, type TestConventions, type UnitTestTarget, type UnitTestWorkflowDeps, type UnitTestWorkflowInput, type UnitTestWorkflowReport, type WorkflowLimits, type WorkflowStatus, } from "./types.js";
-export type { ConventionsDetectedEvent, ContextSelectedEvent, ModelCallCompletedEvent, ModelCallStartedEvent, PatchAppliedEvent, PatchValidatedEvent, VerificationResultEvent, WorkflowCompletedEvent, WorkflowEvent, WorkflowEventSink, WorkflowFailedEvent, WorkflowStartedEvent, } from "./events.js";

package/dist/workflows/unit-tests/internal.d.ts

@@ -1,35 +0,0 @@
-import type { PatchValidation } from "../../tools/index.js";
-import { type EventEmitter } from "./emit.js";
-import { type UnitTestWorkflowDeps, type UnitTestWorkflowInput, type WorkflowLimits } from "./types.js";
-import type { WorkflowEventSink } from "./events.js";
-export declare const NO_OP_SINK: WorkflowEventSink;
-export interface WorkflowProgress {
-    modelCallCount: number;
-    patchRetryCount: number;
-}
-export interface RunState {
-    readonly input: UnitTestWorkflowInput;
-    readonly deps: UnitTestWorkflowDeps;
-    readonly limits: WorkflowLimits;
-    readonly signal: AbortSignal;
-    readonly now: () => number;
-    readonly emitter: EventEmitter;
-    readonly startedAt: number;
-    readonly progress: WorkflowProgress;
-}
-export interface AcceptedPatch {
-    readonly diff: string;
-    readonly validation: PatchValidation;
-    readonly coveredBehavior: string | undefined;
-    readonly knownGaps: string | undefined;
-}
-export interface ModelLoopResult {
-    readonly accepted: AcceptedPatch | undefined;
-    readonly modelCallCount: number;
-    readonly patchRetryCount: number;
-    readonly lastRejectionCode: string | undefined;
-}
-export declare const EMPTY_LOOP: ModelLoopResult;
-export declare function resolveLimits(input: UnitTestWorkflowInput): WorkflowLimits;
-export declare function buildRunState(input: UnitTestWorkflowInput, deps: UnitTestWorkflowDeps, fingerprint: string): RunState;
-export declare function nextActionsFor(applied: boolean, files: readonly string[]): readonly string[];

package/dist/workflows/unit-tests/model-loop.d.ts

@@ -1,4 +0,0 @@
-import type { ContextPack, WorkspaceInfo } from "../../workspace/index.js";
-import type { ModelLoopResult, RunState } from "./internal.js";
-import type { TestConventions } from "./types.js";
-export declare function runModelLoop(state: RunState, workspace: WorkspaceInfo, conventions: TestConventions, pack: ContextPack): Promise<ModelLoopResult>;

package/dist/workflows/unit-tests/model-loop.js

@@ -1,95 +0,0 @@
-// The bounded model/validate/production-guard retry loop (ADR-0008 D6/D8). Each attempt builds the
-// prompt, calls the injected ModelPort, parses the output, validates the diff through #6, and
-// applies the production-code guard. The loop stops on the first accepted patch, after maxRetries
-// rejections, or when model calls reach the maxModelCalls hard ceiling — whichever comes first. The
-// model call is the one IO boundary here; its failure propagates to the workflow catch boundary.
-import { nodeWorkspaceFs } from "../../workspace/fs.js";
-import { validatePatch } from "../../tools/index.js";
-import { isTestPath } from "./conventions.js";
-import { parseModelOutput } from "./parse.js";
-import { buildPrompt } from "./prompt.js";
-// The production-code guard (D6): every changed path must satisfy isTestPath. Returns "out-of-scope"
-// when any path is a non-test/traversal path, or undefined when all pass. The guard runs on
-// validation.files[].path — the SAME string #6 resolves and would write.
-function productionGuard(workspace, validation) {
-    const offending = validation.files.some((file) => !isTestPath(workspace, file.path));
-    return offending ? "out-of-scope" : undefined;
-}
-function emitValidation(state, validation, code) {
-    const ok = code === undefined && validation.ok;
-    state.emitter.emit({
-        type: "patch:validated",
-        ok,
-        patchBytes: validation.totalBytes,
-        filesChanged: validation.files.length,
-        ...(ok ? {} : { rejectionCode: code ?? validation.reasons[0]?.code }),
-    });
-}
-function emptyPatchRejection(parsedDiff, validation) {
-    return parsedDiff.trim().length === 0 || validation.files.length === 0 ? "empty" : undefined;
-}
-async function callModel(state, messages, attempt, contextBytes) {
-    state.progress.modelCallCount = Math.max(state.progress.modelCallCount, attempt);
-    state.emitter.emit({ type: "workflow:model:call:started", attempt, contextBytes });
-    const response = await state.deps.model.call({ modelId: state.input.modelId, messages }, state.signal);
-    state.emitter.emit({
-        type: "workflow:model:call:completed",
-        attempt,
-        finishReason: response.finishReason,
-        promptTokens: response.usage.promptTokens,
-        completionTokens: response.usage.completionTokens,
-        latencyMs: response.usage.latencyMs,
-    });
-    return response.content;
-}
-// One attempt: prompt -> model -> parse -> validate -> guard.
-async function attemptOnce(state, workspace, conventions, pack, attempt, rejectionReason) {
-    const messages = buildPrompt(state.input, conventions, pack, rejectionReason);
-    const content = await callModel(state, messages, attempt, pack.usedBytes);
-    const parsed = parseModelOutput(content);
-    const validation = validatePatch(workspace, parsed.diff, {
-        fs: state.deps.fs ?? nodeWorkspaceFs,
-    });
-    const effectiveDiff = validation.normalizedDiff ?? parsed.diff;
-    const guardCode = validation.ok
-        ? (emptyPatchRejection(effectiveDiff, validation) ?? productionGuard(workspace, validation))
-        : validation.reasons[0]?.code;
-    emitValidation(state, validation, guardCode);
-    if (validation.ok && guardCode === undefined) {
-        const accepted = {
-            diff: effectiveDiff,
-            validation,
-            coveredBehavior: parsed.coveredBehavior,
-            knownGaps: parsed.knownGaps,
-        };
-        return { accepted, rejectionCode: undefined };
-    }
-    return { accepted: undefined, rejectionCode: guardCode ?? "malformed" };
-}
-export async function runModelLoop(state, workspace, conventions, pack) {
-    let modelCallCount = 0;
-    let patchRetryCount = 0;
-    let rejectionReason;
-    while (modelCallCount < state.limits.maxModelCalls &&
-        patchRetryCount <= state.limits.maxRetries) {
-        modelCallCount += 1;
-        const result = await attemptOnce(state, workspace, conventions, pack, modelCallCount, rejectionReason);
-        if (result.accepted !== undefined) {
-            return {
-                accepted: result.accepted,
-                modelCallCount,
-                patchRetryCount,
-                lastRejectionCode: undefined,
-            };
-        }
-        patchRetryCount += 1;
-        state.progress.patchRetryCount = patchRetryCount;
-        rejectionReason = result.rejectionCode;
-    }
-    return {
-        accepted: undefined,
-        modelCallCount,
-        patchRetryCount,
-        lastRejectionCode: rejectionReason,
-    };
-}

package/dist/workflows/unit-tests/parse.d.ts

@@ -1,6 +0,0 @@
-export interface ParsedModelOutput {
-    readonly diff: string;
-    readonly coveredBehavior: string | undefined;
-    readonly knownGaps: string | undefined;
-}
-export declare function parseModelOutput(content: string): ParsedModelOutput;

package/dist/workflows/unit-tests/prompt.d.ts

@@ -1,4 +0,0 @@
-import type { ChatMessage } from "../../gateway/types.js";
-import type { ContextPack } from "../../workspace/index.js";
-import type { TestConventions, UnitTestWorkflowInput } from "./types.js";
-export declare function buildPrompt(input: UnitTestWorkflowInput, conventions: TestConventions, pack: ContextPack, rejectionReason?: string): readonly ChatMessage[];

package/dist/workflows/unit-tests/report.d.ts

@@ -1,21 +0,0 @@
-import type { PatchFileChange } from "../../tools/index.js";
-import type { VerificationAuditSummary } from "../../verification/index.js";
-import type { UnitTestWorkflowReport, WorkflowStatus } from "./types.js";
-export interface ReportParts {
-    readonly status: WorkflowStatus;
-    readonly modelId: string;
-    readonly durationMs: number;
-    readonly patchFiles: readonly PatchFileChange[];
-    readonly dryRunPreview: string | undefined;
-    readonly proposedDiff: string | undefined;
-    readonly coveredBehavior: string | undefined;
-    readonly knownGaps: string | undefined;
-    readonly nextActions: readonly string[];
-    readonly failureReason?: string | undefined;
-    readonly verificationSummary: VerificationAuditSummary | undefined;
-    readonly verificationSkipReason: string | undefined;
-    readonly modelCallCount: number;
-    readonly patchRetryCount: number;
-}
-export declare function assembleReport(parts: ReportParts): UnitTestWorkflowReport;
-export declare function renderMarkdownReport(report: UnitTestWorkflowReport): string;