@oscharko-dev/keiko 0.1.6 → 0.1.7

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

@@ -1,90 +0,0 @@
-// Report assembly and Markdown rendering (ADR-0008 D3, steering note A). assembleReport composes
-// the JSON-serializable UnitTestWorkflowReport from pipeline stage outputs; renderMarkdownReport
-// produces the CLI text path. ALL prose (coveredBehavior, knownGaps, nextActions), the dry-run
-// preview, the proposed diff, verificationSkipReason, and addedTestFiles[].path are redacted via
-// redact() here so nothing the report carries can leak a secret — defence in depth on top of the
-// redaction already applied upstream. Pure: no IO, no clock; the caller injects durationMs and counters.
-import { redact } from "../../gateway/redaction.js";
-const TEST_CASE_PREFIXES = ["test(", "it(", "describe("];
-// Best-effort count of added test cases: added (`+`) lines whose trimmed text begins with a known
-// test-case opener. Not authoritative — purely informational for the report.
-function estimateTestCount(file) {
-    let count = 0;
-    for (const hunk of file.hunks) {
-        for (const line of hunk.lines) {
-            if (!line.startsWith("+")) {
-                continue;
-            }
-            const trimmed = line.slice(1).trimStart();
-            if (TEST_CASE_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
-                count += 1;
-            }
-        }
-    }
-    return count;
-}
-function toAddedTestFiles(files) {
-    return files.map((file) => ({
-        path: redact(file.path),
-        estimatedTestCount: estimateTestCount(file),
-    }));
-}
-function redactOptional(value) {
-    return value === undefined ? undefined : redact(value);
-}
-export function assembleReport(parts) {
-    return {
-        workflowId: "unit-test-generation",
-        status: parts.status,
-        modelId: parts.modelId,
-        durationMs: parts.durationMs,
-        dryRunPreview: redactOptional(parts.dryRunPreview),
-        proposedDiff: redactOptional(parts.proposedDiff),
-        addedTestFiles: toAddedTestFiles(parts.patchFiles),
-        coveredBehavior: redactOptional(parts.coveredBehavior),
-        knownGaps: redactOptional(parts.knownGaps),
-        nextActions: parts.nextActions.map((action) => redact(action)),
-        failureReason: redactOptional(parts.failureReason),
-        verificationSummary: parts.verificationSummary,
-        verificationSkipReason: redactOptional(parts.verificationSkipReason),
-        modelCallCount: parts.modelCallCount,
-        patchRetryCount: parts.patchRetryCount,
-    };
-}
-function sectionIf(heading, body) {
-    return body === undefined ? [] : [`## ${heading}`, body, ""];
-}
-function fileLines(report) {
-    if (report.addedTestFiles.length === 0) {
-        return [];
-    }
-    const rows = report.addedTestFiles.map((f) => `- ${f.path} (~${String(f.estimatedTestCount)} test case(s))`);
-    return ["## Test files", ...rows, ""];
-}
-function verificationLine(report) {
-    if (report.verificationSummary !== undefined) {
-        return [`## Verification`, `Status: ${report.verificationSummary.overallStatus}`, ""];
-    }
-    if (report.verificationSkipReason !== undefined) {
-        return [`## Verification`, report.verificationSkipReason, ""];
-    }
-    return [];
-}
-// A human-readable Markdown report for the CLI text path. Every field is already redacted by
-// assembleReport, so rendering is plain string composition.
-export function renderMarkdownReport(report) {
-    return [
-        `# Unit-test generation: ${report.status}`,
-        `Model: ${report.modelId} · ${String(report.durationMs)}ms · ` +
-            `${String(report.modelCallCount)} model call(s) · ${String(report.patchRetryCount)} retry(ies)`,
-        "",
-        ...fileLines(report),
-        ...sectionIf("Covered behavior", report.coveredBehavior),
-        ...sectionIf("Known gaps", report.knownGaps),
-        ...sectionIf("Failure", report.failureReason),
-        ...verificationLine(report),
-        ...(report.nextActions.length > 0
-            ? ["## Next actions", ...report.nextActions.map((a) => `- ${a}`), ""]
-            : []),
-    ].join("\n");
-}

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

@@ -1,9 +0,0 @@
-import type { WorkspaceInfo } from "../../workspace/index.js";
-import { type AcceptedPatch, type ModelLoopResult, type RunState } from "./internal.js";
-import type { UnitTestWorkflowReport } from "./types.js";
-export declare function rejectedReport(state: RunState, loop: ModelLoopResult): UnitTestWorkflowReport;
-export declare function dryRunReport(state: RunState, loop: ModelLoopResult, accepted: AcceptedPatch): UnitTestWorkflowReport;
-export declare function cancelledReport(state: RunState, loop: ModelLoopResult, accepted: AcceptedPatch | undefined): UnitTestWorkflowReport;
-export declare function failedReport(state: RunState, error: unknown): UnitTestWorkflowReport;
-export declare function emitCompleted(state: RunState, report: UnitTestWorkflowReport): UnitTestWorkflowReport;
-export declare function finishPipeline(state: RunState, workspace: WorkspaceInfo, loop: ModelLoopResult): Promise<UnitTestWorkflowReport>;

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

@@ -1,155 +0,0 @@
-// Terminal-report stages (ADR-0008 D3/D5). Each function maps a pipeline outcome — rejected,
-// dry-run, applied+verified, cancelled, or failed — to the redacted UnitTestWorkflowReport via
-// assembleReport. applyPatch (apply mode) is the one IO boundary here and is fail-closed in #6
-// (applyEnabled gates the write). finishPipeline selects the branch; emitCompleted stamps the
-// terminal event. All prose/diff redaction happens inside assembleReport.
-import { redact } from "../../gateway/redaction.js";
-import { applyPatch, CommandCancelledError, renderDryRun, } from "../../tools/index.js";
-import { nodeWorkspaceFs } from "../../workspace/fs.js";
-import { assembleReport } from "./report.js";
-import { runWorkflowVerification } from "./verify-stage.js";
-import { nextActionsFor, } from "./internal.js";
-export function rejectedReport(state, loop) {
-    return assembleReport({
-        status: "rejected",
-        modelId: state.input.modelId,
-        durationMs: state.now() - state.startedAt,
-        patchFiles: [],
-        dryRunPreview: undefined,
-        proposedDiff: undefined,
-        coveredBehavior: undefined,
-        knownGaps: undefined,
-        nextActions: [
-            `The model did not produce an in-scope test patch (${loop.lastRejectionCode ?? "unknown"})`,
-        ],
-        failureReason: undefined,
-        verificationSummary: undefined,
-        verificationSkipReason: undefined,
-        modelCallCount: loop.modelCallCount,
-        patchRetryCount: loop.patchRetryCount,
-    });
-}
-export function dryRunReport(state, loop, accepted) {
-    const files = accepted.validation.files.map((f) => f.path);
-    return assembleReport({
-        status: "dry-run",
-        modelId: state.input.modelId,
-        durationMs: state.now() - state.startedAt,
-        patchFiles: accepted.validation.files,
-        dryRunPreview: renderDryRun(accepted.validation),
-        proposedDiff: accepted.diff,
-        coveredBehavior: accepted.coveredBehavior,
-        knownGaps: accepted.knownGaps,
-        nextActions: nextActionsFor(false, files),
-        failureReason: undefined,
-        verificationSummary: undefined,
-        verificationSkipReason: "verification skipped: dry-run, no files written",
-        modelCallCount: loop.modelCallCount,
-        patchRetryCount: loop.patchRetryCount,
-    });
-}
-export function cancelledReport(state, loop, accepted) {
-    return assembleReport({
-        status: "cancelled",
-        modelId: state.input.modelId,
-        durationMs: state.now() - state.startedAt,
-        patchFiles: accepted?.validation.files ?? [],
-        dryRunPreview: accepted === undefined ? undefined : renderDryRun(accepted.validation),
-        proposedDiff: accepted?.diff,
-        coveredBehavior: undefined,
-        knownGaps: undefined,
-        nextActions: ["The workflow was cancelled before completion"],
-        failureReason: undefined,
-        verificationSummary: undefined,
-        verificationSkipReason: "verification skipped: cancelled",
-        modelCallCount: loop.modelCallCount,
-        patchRetryCount: loop.patchRetryCount,
-    });
-}
-export function failedReport(state, error) {
-    const message = redact(error instanceof Error ? error.message : "unexpected workflow failure");
-    const errorCode = error instanceof Error ? error.name : "UNKNOWN";
-    state.emitter.emit({ type: "workflow:failed", errorCode, message });
-    return assembleReport({
-        status: "failed",
-        modelId: state.input.modelId,
-        durationMs: state.now() - state.startedAt,
-        patchFiles: [],
-        dryRunPreview: undefined,
-        proposedDiff: undefined,
-        coveredBehavior: undefined,
-        knownGaps: undefined,
-        nextActions: [`Inspect the error and retry: ${message}`],
-        failureReason: message,
-        verificationSummary: undefined,
-        verificationSkipReason: undefined,
-        modelCallCount: state.progress.modelCallCount,
-        patchRetryCount: state.progress.patchRetryCount,
-    });
-}
-async function applyAndVerify(state, workspace, loop, accepted) {
-    const fs = state.deps.fs ?? nodeWorkspaceFs;
-    let applyResult;
-    try {
-        applyResult = applyPatch(workspace, accepted.diff, {
-            applyEnabled: true,
-            signal: state.signal,
-            fs,
-            ...(state.deps.writer === undefined ? {} : { writer: state.deps.writer }),
-        });
-    }
-    catch (error) {
-        if (error instanceof CommandCancelledError) {
-            return cancelledReport(state, loop, accepted);
-        }
-        throw error;
-    }
-    state.emitter.emit({
-        type: "workflow:patch:applied",
-        changedFiles: applyResult.changedFiles.length,
-        created: applyResult.created.length,
-        deleted: applyResult.deleted.length,
-    });
-    if (state.signal.aborted) {
-        return cancelledReport(state, loop, accepted);
-    }
-    const verification = await runWorkflowVerification(state, workspace, fs);
-    return assembleReport({
-        status: "completed",
-        modelId: state.input.modelId,
-        durationMs: state.now() - state.startedAt,
-        patchFiles: accepted.validation.files,
-        dryRunPreview: renderDryRun(accepted.validation),
-        proposedDiff: accepted.diff,
-        coveredBehavior: accepted.coveredBehavior,
-        knownGaps: accepted.knownGaps,
-        nextActions: nextActionsFor(true, applyResult.changedFiles),
-        failureReason: undefined,
-        verificationSummary: verification.summary,
-        verificationSkipReason: verification.skipReason,
-        modelCallCount: loop.modelCallCount,
-        patchRetryCount: loop.patchRetryCount,
-    });
-}
-export function emitCompleted(state, report) {
-    state.emitter.emit({
-        type: "workflow:completed",
-        status: report.status,
-        durationMs: report.durationMs,
-    });
-    return report;
-}
-// Selects the terminal branch from the model-loop result: rejected (no patch), cancelled (abort
-// before apply), apply+verify (apply mode), or dry-run (default).
-export async function finishPipeline(state, workspace, loop) {
-    if (loop.accepted === undefined) {
-        return rejectedReport(state, loop);
-    }
-    if (state.signal.aborted) {
-        return cancelledReport(state, loop, loop.accepted);
-    }
-    if (state.input.apply === true) {
-        return applyAndVerify(state, workspace, loop, loop.accepted);
-    }
-    return dryRunReport(state, loop, loop.accepted);
-}

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

@@ -1,70 +0,0 @@
-import type { ModelPort } from "../../harness/ports.js";
-import type { SpawnFn, WorkspaceWriter } from "../../tools/index.js";
-import type { TestFramework, WorkspaceFs } from "../../workspace/index.js";
-import type { VerificationAuditSummary } from "../../verification/index.js";
-import type { WorkflowEventSink } from "./events.js";
-export type WorkflowStatus = "completed" | "dry-run" | "rejected" | "cancelled" | "failed";
-export type UnitTestTarget = {
-    readonly kind: "file";
-    readonly filePath: string;
-    readonly targetFunction?: string | undefined;
-} | {
-    readonly kind: "module";
-    readonly moduleDir: string;
-} | {
-    readonly kind: "changedFiles";
-    readonly filePaths: readonly string[];
-};
-export type FileNamingStyle = "sibling" | "mirrored" | "unknown";
-export interface TestConventions {
-    readonly framework: TestFramework;
-    readonly testDirs: readonly string[];
-    readonly fileNamingStyle: FileNamingStyle;
-    readonly assertionStyleSamples: readonly string[];
-}
-export interface WorkflowLimits {
-    readonly maxModelCalls: number;
-    readonly maxRetries: number;
-    readonly contextBudgetBytes: number;
-    readonly maxBytesPerFile: number;
-}
-export declare const DEFAULT_WORKFLOW_LIMITS: WorkflowLimits;
-export interface UnitTestWorkflowInput {
-    readonly workspaceRoot: string;
-    readonly target: UnitTestTarget;
-    readonly apply?: boolean | undefined;
-    readonly modelId: string;
-    readonly limits?: Partial<WorkflowLimits> | undefined;
-}
-export interface UnitTestWorkflowDeps {
-    readonly model: ModelPort;
-    readonly fs?: WorkspaceFs | undefined;
-    readonly writer?: WorkspaceWriter | undefined;
-    readonly spawn?: SpawnFn | undefined;
-    readonly now?: (() => number) | undefined;
-    readonly idSource?: (() => string) | undefined;
-    readonly sink?: WorkflowEventSink | undefined;
-    readonly processEnv?: NodeJS.ProcessEnv | undefined;
-    readonly signal?: AbortSignal | undefined;
-}
-export interface AddedTestFile {
-    readonly path: string;
-    readonly estimatedTestCount: number;
-}
-export interface UnitTestWorkflowReport {
-    readonly workflowId: "unit-test-generation";
-    readonly status: WorkflowStatus;
-    readonly modelId: string;
-    readonly durationMs: number;
-    readonly dryRunPreview?: string | undefined;
-    readonly proposedDiff?: string | undefined;
-    readonly addedTestFiles: readonly AddedTestFile[];
-    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;
-}

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

@@ -1,11 +0,0 @@
-// All interfaces, type aliases, and frozen constant tables for the unit-test generation
-// workflow (ADR-0008 D2/D3/D7). No runtime logic lives here beyond the frozen tables the type
-// layer exposes as values, mirroring the ADR-0003/0004/0005/0006/0007 `types.ts` precedent.
-// `readonly` everywhere; optional props are `| undefined` because exactOptionalPropertyTypes
-// is on. Every report shape is plain JSON-serializable so the #10 audit ledger can persist it.
-export const DEFAULT_WORKFLOW_LIMITS = {
-    maxModelCalls: 3,
-    maxRetries: 2,
-    contextBudgetBytes: 65_536,
-    maxBytesPerFile: 8_192,
-};

package/dist/workflows/unit-tests/verify-stage.d.ts

@@ -1,9 +0,0 @@
-import { type WorkspaceFs, type WorkspaceInfo } from "../../workspace/index.js";
-import { type VerificationAuditSummary } from "../../verification/index.js";
-import type { RunState } from "./internal.js";
-export declare const SKIP_UNRESOLVED = "verification skipped: framework unknown or no test files resolved";
-export interface VerificationOutcome {
-    readonly summary: VerificationAuditSummary | undefined;
-    readonly skipReason: string | undefined;
-}
-export declare function runWorkflowVerification(state: RunState, workspace: WorkspaceInfo, fs: WorkspaceFs): Promise<VerificationOutcome>;

package/dist/workflows/unit-tests/verify-stage.js

@@ -1,56 +0,0 @@
-// The verification stage (ADR-0008 D5, steering note C). Runs ONLY after a successful apply: it
-// resolves a verification plan by deriving the just-created test from the target SOURCE file(s) via
-// #7 resolveTargetedTests, 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.
-import { nodeSpawnFn } from "../../tools/index.js";
-import {} from "../../workspace/index.js";
-import { buildVerificationPlan, detectScripts, resolveTargetedTests, runVerification, summarizeForAudit, DEFAULT_VERIFICATION_LIMITS, } from "../../verification/index.js";
-export const SKIP_UNRESOLVED = "verification skipped: framework unknown or no test files resolved";
-// The source files the target points at — passed to resolveTargetedTests so it can find the
-// just-created sibling/mirrored test (steering note C). Test files are NOT passed here.
-function targetSourceFiles(target) {
-    if (target.kind === "file") {
-        return [target.filePath];
-    }
-    if (target.kind === "changedFiles") {
-        return target.filePaths;
-    }
-    return [target.moduleDir];
-}
-function buildPlanFallback(workspace, fs) {
-    const catalog = detectScripts(workspace, fs);
-    return buildVerificationPlan(workspace, catalog, { only: ["test"] }, fs);
-}
-function resolveVerificationPlan(workspace, target, fs) {
-    const targeted = resolveTargetedTests(workspace, targetSourceFiles(target), 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 runWorkflowVerification(state, workspace, fs) {
-    const plan = resolveVerificationPlan(workspace, state.input.target, 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: "workflow: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/unit-tests/workflow.d.ts

@@ -1,2 +0,0 @@
-import type { UnitTestWorkflowDeps, UnitTestWorkflowInput, UnitTestWorkflowReport } from "./types.js";
-export declare function generateUnitTests(input: UnitTestWorkflowInput, deps: UnitTestWorkflowDeps): Promise<UnitTestWorkflowReport>;

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

@@ -1,58 +0,0 @@
-// The single public entry: generateUnitTests (ADR-0008 D2/D5/D6). A deterministic linear pipeline
-// (NOT the harness loop): intake -> detect -> context -> conventions -> [prompt -> model -> parse ->
-// validate -> production-guard] (bounded retries) -> [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 only the
-// stage sequencing and the single top-level catch boundary that maps an unexpected IO failure to a
-// redacted "failed" report (and a CancelledError to a "cancelled" report).
-import { CancelledError } from "../../gateway/errors.js";
-import { detectWorkspace } from "../../workspace/index.js";
-import { nodeWorkspaceFs } from "../../workspace/fs.js";
-import { buildTestGenContext } from "./context.js";
-import { detectConventions } from "./conventions.js";
-import { computeFingerprint } from "./emit.js";
-import { runModelLoop } from "./model-loop.js";
-import { cancelledReport, emitCompleted, failedReport, finishPipeline } from "./stages.js";
-import { buildRunState, EMPTY_LOOP } from "./internal.js";
-async function runPipeline(state) {
-    const fs = state.deps.fs ?? nodeWorkspaceFs;
-    const workspace = detectWorkspace(state.input.workspaceRoot, fs);
-    state.emitter.emit({
-        type: "workflow:started",
-        workflowId: "unit-test-generation",
-        modelId: state.input.modelId,
-        applyEnabled: state.input.apply === true,
-        limits: state.limits,
-    });
-    const pack = buildTestGenContext(workspace, state.input, state.limits, { fs });
-    const conventions = detectConventions(workspace, pack);
-    state.emitter.emit({
-        type: "conventions:detected",
-        framework: conventions.framework,
-        testDirs: conventions.testDirs,
-        fileNamingStyle: conventions.fileNamingStyle,
-    });
-    state.emitter.emit({
-        type: "context:selected",
-        entryCount: pack.selected.length,
-        usedBytes: pack.usedBytes,
-        budgetBytes: pack.budgetBytes,
-        droppedForBudget: pack.droppedForBudget,
-    });
-    const loop = await runModelLoop(state, workspace, conventions, pack);
-    return finishPipeline(state, workspace, loop);
-}
-export async function generateUnitTests(input, deps) {
-    const state = buildRunState(input, deps, computeFingerprint(input.target, input.modelId));
-    let report;
-    try {
-        report = await runPipeline(state);
-    }
-    catch (error) {
-        report =
-            error instanceof CancelledError
-                ? cancelledReport(state, EMPTY_LOOP, undefined)
-                : failedReport(state, error);
-    }
-    return emitCompleted(state, report);
-}