@oscharko-dev/keiko 0.1.5 → 0.1.7

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/context.js

@@ -0,0 +1,129 @@
+// 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 "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+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/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/conventions.d.ts

@@ -0,0 +1,5 @@
+import type { ContextPack, WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+import type { TestConventions } from "./types.js";
+export declare function isTestPath(workspace: WorkspaceInfo, relPath: string): boolean;
+export declare function detectConventions(workspace: WorkspaceInfo, pack: ContextPack): TestConventions;
+//# sourceMappingURL=conventions.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/conventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/conventions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAChF,OAAO,KAAK,EAAmB,eAAe,EAAE,MAAM,YAAY,CAAC;AA0CnE,wBAAgB,UAAU,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAM7E;AA4CD,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,GAAG,eAAe,CAO9F"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/descriptor.d.ts

@@ -0,0 +1,5 @@
+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>;
+//# sourceMappingURL=descriptor.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/descriptor.ts"],"names":[],"mappings":"AAKA,OAAO,EAA2B,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE9E,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,cAAc,CAuCnE,CAAC"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/emit.d.ts

@@ -0,0 +1,13 @@
+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 {};
+//# sourceMappingURL=emit.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/emit.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAMlF;AAID,KAAK,cAAc,GAAG,eAAe,GAAG,OAAO,GAAG,aAAa,GAAG,KAAK,GAAG,IAAI,CAAC;AAC/E,MAAM,MAAM,iBAAiB,GAAG;KAC7B,CAAC,IAAI,aAAa,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,cAAc,CAAC;CAC3D,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;AAEzB,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,MAAM,MAAM,GAChB,YAAY,CAkBd"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/emit.js

@@ -0,0 +1,35 @@
+// 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 "@oscharko-dev/keiko-harness";
+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/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/events.d.ts

@@ -0,0 +1,2 @@
+export type { WorkflowStartedEvent, ConventionsDetectedEvent, ContextSelectedEvent, ModelCallStartedEvent, ModelCallCompletedEvent, PatchValidatedEvent, PatchAppliedEvent, VerificationResultEvent, WorkflowCompletedEvent, WorkflowFailedEvent, WorkflowEvent, WorkflowEventSink, } from "@oscharko-dev/keiko-contracts/unit-test-events";
+//# sourceMappingURL=events.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/events.ts"],"names":[],"mappings":"AAMA,YAAY,EACV,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,GAClB,MAAM,gDAAgD,CAAC"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/events.js

@@ -0,0 +1,6 @@
+// Re-export shim: the unit-test workflow event union and every member interface live in
+// @oscharko-dev/keiko-contracts (issue #158). The contracts BARREL exposes only WorkflowEvent +
+// WorkflowEventSink because several member names collide with HarnessEvent members by structural
+// convention (ADR-0008 D4); the contracts subpath `unit-test-events` carries the full member set
+// so internal consumers can keep importing concrete shapes from "./events.js" unchanged.
+export {};

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/index.d.ts

@@ -0,0 +1,7 @@
+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";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAErF,OAAO,EACL,6BAA6B,EAC7B,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEjE,OAAO,EACL,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,cAAc,GACpB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,wBAAwB,EACxB,oBAAoB,EACpB,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,aAAa,CAAC"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/internal.d.ts

@@ -0,0 +1,36 @@
+import type { PatchValidation } from "@oscharko-dev/keiko-tools";
+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[];
+//# sourceMappingURL=internal.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/internal.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGrD,eAAO,MAAM,UAAU,EAAE,iBAAmD,CAAC;AAE7E,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB;AAGD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;CACrC;AAGD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;CAChD;AAGD,eAAO,MAAM,UAAU,EAAE,eAKxB,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,qBAAqB,GAAG,cAAc,CAE1E;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,qBAAqB,EAC5B,IAAI,EAAE,oBAAoB,EAC1B,WAAW,EAAE,MAAM,GAClB,QAAQ,CAaV;AAGD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAS5F"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/model-loop.d.ts

@@ -0,0 +1,5 @@
+import type { ContextPack, WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+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>;
+//# sourceMappingURL=model-loop.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/model-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-loop.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/model-loop.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAKhF,OAAO,KAAK,EAAiB,eAAe,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA4FlD,wBAAsB,YAAY,CAChC,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,aAAa,EACxB,WAAW,EAAE,eAAe,EAC5B,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,eAAe,CAAC,CAmC1B"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/model-loop.js

@@ -0,0 +1,95 @@
+// 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 "@oscharko-dev/keiko-workspace/internal/fs";
+import { validatePatch } from "@oscharko-dev/keiko-tools";
+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/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/parse.d.ts

@@ -0,0 +1,7 @@
+export interface ParsedModelOutput {
+    readonly diff: string;
+    readonly coveredBehavior: string | undefined;
+    readonly knownGaps: string | undefined;
+}
+export declare function parseModelOutput(content: string): ParsedModelOutput;
+//# sourceMappingURL=parse.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/parse.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,iBAAiB;IAEhC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7C,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AA8DD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CASnE"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/prompt.d.ts

@@ -0,0 +1,5 @@
+import type { ChatMessage } from "@oscharko-dev/keiko-model-gateway";
+import type { ContextPack } from "@oscharko-dev/keiko-workspace";
+import type { TestConventions, UnitTestWorkflowInput } from "./types.js";
+export declare function buildPrompt(input: UnitTestWorkflowInput, conventions: TestConventions, pack: ContextPack, rejectionReason?: string): readonly ChatMessage[];
+//# sourceMappingURL=prompt.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/prompt.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAkB,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA0EzF,wBAAgB,WAAW,CACzB,KAAK,EAAE,qBAAqB,EAC5B,WAAW,EAAE,eAAe,EAC5B,IAAI,EAAE,WAAW,EACjB,eAAe,CAAC,EAAE,MAAM,GACvB,SAAS,WAAW,EAAE,CAKxB"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/report.d.ts

@@ -0,0 +1,22 @@
+import type { PatchFileChange } from "@oscharko-dev/keiko-tools";
+import type { VerificationAuditSummary } from "../../../../src/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;
+//# sourceMappingURL=report.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/report.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACtF,OAAO,KAAK,EAAiB,sBAAsB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AA6BxF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;IAChD,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,mBAAmB,EAAE,wBAAwB,GAAG,SAAS,CAAC;IACnE,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAMD,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,sBAAsB,CAkBzE;AA4BD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAe3E"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/report.js

@@ -0,0 +1,90 @@
+// 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 "@oscharko-dev/keiko-security";
+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/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/stages.d.ts

@@ -0,0 +1,10 @@
+import type { WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+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>;
+//# sourceMappingURL=stages.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/stages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stages.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/stages.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAGnE,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,eAAe,GAAG,sBAAsB,CAmB7F;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,aAAa,GACtB,sBAAsB,CAkBxB;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,aAAa,GAAG,SAAS,GAClC,sBAAsB,CAiBxB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,GAAG,sBAAsB,CAoBpF;AAmDD,wBAAgB,aAAa,CAC3B,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,sBAAsB,GAC7B,sBAAsB,CAOxB;AAID,wBAAsB,cAAc,CAClC,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,aAAa,EACxB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,sBAAsB,CAAC,CAWjC"}