@oscharko-dev/keiko-workflows 0.2.0

package/dist/unit-tests/frontend.js

@@ -0,0 +1,281 @@
+// Frontend test-stack detection and convention-driven test-style selection (Issue #1203, Epic #1189,
+// ADR-0042 D7). Extends the deterministic convention detection (conventions.ts) from "which base test
+// framework" to "which frontend test STYLE the target warrants" — unit, component, interaction,
+// accessibility smoke, or browser smoke — grounded in the project's declared test tooling and the
+// target file's own shape.
+//
+// PURE except for the narrow filesystem seam used to read local package manifests and detect framework
+// config (no clock, no RNG, no network). ALL path and content predicates use plain string ops
+// (split/startsWith/endsWith/includes) — zero regex — so there is no ReDoS surface (CodeQL
+// js/polynomial-redos), mirroring conventions.ts.
+//
+// "Prefer convention-driven generation over user prompt guessing" (Engineering Notes): the style is
+// derived from the detected stack plus the target path/shape, never from a user-supplied flag. When the
+// target is a frontend component but the project declares no supported frontend test stack, the
+// selector returns `unsupported` so the workflow surfaces a clear, reviewable limitation instead of
+// fabricating a browser/component test it cannot ground (Acceptance Criterion 5).
+import { dirname, join, resolve } from "node:path";
+export const EMPTY_FRONTEND_TEST_STACK = {
+    componentFramework: "none",
+    hasReactTestingLibrary: false,
+    hasUserEvent: false,
+    hasJestDom: false,
+    hasAccessibilityMatchers: false,
+    hasDomEnvironment: false,
+    hasPlaywright: false,
+};
+export const TEST_STYLES = [
+    "unit",
+    "component",
+    "interaction",
+    "accessibility-smoke",
+    "browser-smoke",
+    "unsupported",
+];
+// ─── Manifest parsing (pure) ─────────────────────────────────────────────────────────────────────
+const DEPENDENCY_FIELDS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// The union of dependency names declared across every dependency field of one package manifest.
+// Throw-free: an unparseable or non-object manifest yields an empty set.
+export function manifestDependencyNames(manifestJson) {
+    const names = new Set();
+    let parsed;
+    try {
+        parsed = JSON.parse(manifestJson);
+    }
+    catch {
+        return names;
+    }
+    if (!isRecord(parsed)) {
+        return names;
+    }
+    for (const field of DEPENDENCY_FIELDS) {
+        const block = parsed[field];
+        if (isRecord(block)) {
+            for (const name of Object.keys(block)) {
+                names.add(name);
+            }
+        }
+    }
+    return names;
+}
+// ─── Stack detection (pure over a dependency set) ──────────────────────────────────────────────────
+const REACT = "react";
+const RTL = "@testing-library/react";
+const USER_EVENT = "@testing-library/user-event";
+const JEST_DOM = "@testing-library/jest-dom";
+const PLAYWRIGHT_DEPS = ["@playwright/test", "playwright"];
+const DOM_ENV_DEPS = ["jsdom", "happy-dom"];
+const AXE_DEPS = [
+    "jest-axe",
+    "vitest-axe",
+    "@axe-core/react",
+    "@axe-core/playwright",
+    "axe-core",
+];
+function hasAny(names, candidates) {
+    return candidates.some((candidate) => names.has(candidate));
+}
+// Derives the frontend test stack from the union of declared dependency names plus framework-config
+// signals. Pure and total.
+export function detectFrontendStackFromDependencies(names, signals) {
+    return {
+        componentFramework: names.has(REACT) ? "react" : "none",
+        hasReactTestingLibrary: names.has(RTL),
+        hasUserEvent: names.has(USER_EVENT),
+        hasJestDom: names.has(JEST_DOM),
+        hasAccessibilityMatchers: hasAny(names, AXE_DEPS),
+        hasDomEnvironment: hasAny(names, DOM_ENV_DEPS),
+        hasPlaywright: hasAny(names, PLAYWRIGHT_DEPS) || signals.hasPlaywrightConfig,
+    };
+}
+const MANIFEST = "package.json";
+const PLAYWRIGHT_CONFIG_BASENAMES = [
+    "playwright.config.ts",
+    "playwright.config.js",
+    "playwright.config.mjs",
+    "playwright.config.cjs",
+    "playwright.config.mts",
+    "playwright.config.cts",
+];
+// A hard ceiling on the manifest walk-up so a pathological start directory cannot loop unboundedly.
+const MAX_WALK_DEPTH = 16;
+function readManifestNames(fs, dir) {
+    const path = join(dir, MANIFEST);
+    if (!fs.exists(path)) {
+        return new Set();
+    }
+    try {
+        return manifestDependencyNames(fs.readFileUtf8(path));
+    }
+    catch {
+        return new Set();
+    }
+}
+function hasPlaywrightConfigIn(fs, dir) {
+    return PLAYWRIGHT_CONFIG_BASENAMES.some((basename) => fs.exists(join(dir, basename)));
+}
+// The directories from the anchor's directory up to (and including) the workspace root, nearest first,
+// never escaping the root. `anchorRelPath` is a workspace-relative target path; absent → just the root.
+function manifestSearchDirs(root, anchorRelPath) {
+    const resolvedRoot = resolve(root);
+    if (anchorRelPath === undefined || anchorRelPath.length === 0) {
+        return [resolvedRoot];
+    }
+    const dirs = [];
+    let current = dirname(resolve(resolvedRoot, anchorRelPath));
+    for (let depth = 0; depth < MAX_WALK_DEPTH; depth += 1) {
+        if (current === resolvedRoot || !current.startsWith(`${resolvedRoot}/`)) {
+            break;
+        }
+        dirs.push(current);
+        current = dirname(current);
+    }
+    dirs.push(resolvedRoot);
+    return dirs;
+}
+// Reads the project's declared frontend test tooling by unioning the dependency names of the nearest
+// package manifests (target package up to the workspace root) and detecting a Playwright config. Bounded
+// and throw-free; an unreadable manifest contributes nothing.
+export function detectFrontendStack(workspace, fs, anchorRelPath) {
+    const names = new Set();
+    let hasPlaywrightConfig = false;
+    for (const dir of manifestSearchDirs(workspace.root, anchorRelPath)) {
+        for (const name of readManifestNames(fs, dir)) {
+            names.add(name);
+        }
+        if (hasPlaywrightConfigIn(fs, dir)) {
+            hasPlaywrightConfig = true;
+        }
+    }
+    return detectFrontendStackFromDependencies(names, { hasPlaywrightConfig });
+}
+// ─── Target classification (pure) ──────────────────────────────────────────────────────────────────
+function toPosix(path) {
+    return path.split("\\").join("/");
+}
+function lastSegment(path) {
+    const posix = toPosix(path);
+    const idx = posix.lastIndexOf("/");
+    return idx === -1 ? posix : posix.slice(idx + 1);
+}
+function endsWithAny(value, suffixes) {
+    return suffixes.some((suffix) => value.endsWith(suffix));
+}
+const COMPONENT_EXTENSIONS = [".tsx", ".jsx"];
+// A path that, by extension, is a React component module (`.tsx`/`.jsx`).
+export function isReactComponentPath(path) {
+    return endsWithAny(toPosix(path), COMPONENT_EXTENSIONS);
+}
+// A best-effort, regex-free check that a `.ts`/`.js` module's source looks like a React component:
+// it imports React and either returns JSX or calls React.createElement. Used only as a secondary signal
+// for non-`.tsx` files; the extension is the primary signal.
+export function looksLikeReactComponentSource(source) {
+    if (source === undefined || source.length === 0) {
+        return false;
+    }
+    const importsReact = source.includes('from "react"') ||
+        source.includes("from 'react'") ||
+        source.includes('require("react")');
+    if (!importsReact) {
+        return false;
+    }
+    return source.includes("React.createElement") || source.includes("/>") || source.includes("</");
+}
+const PLAYWRIGHT_ENTRY_DIRS = [
+    "e2e/",
+    "tests/e2e/",
+    "playwright/",
+    "app/",
+    "pages/",
+];
+const NEXT_ROUTE_BASENAMES = [
+    "page.tsx",
+    "page.jsx",
+    "layout.tsx",
+    "layout.jsx",
+];
+// Whether a path is an application entry point a Playwright browser smoke can meaningfully target:
+// a Next.js route file (`page`/`layout`), a `*.page.*` module, or a file under a recognised end-to-end
+// or app/route directory. Pure string predicates only.
+export function isPlaywrightEntryPath(path) {
+    const posix = toPosix(path);
+    const base = lastSegment(posix);
+    if (NEXT_ROUTE_BASENAMES.includes(base)) {
+        return true;
+    }
+    if (base.includes(".page.")) {
+        return true;
+    }
+    return PLAYWRIGHT_ENTRY_DIRS.some((dir) => posix.startsWith(dir) || posix.includes(`/${dir}`));
+}
+// Identifies when a Playwright browser smoke is appropriate (AC: "identify when Playwright smoke is
+// appropriate and when it is not"): only when the project declares Playwright AND the target is an
+// application entry point. A plain library or in-page component is never an appropriate Playwright
+// target, even when the project ships Playwright.
+export function isPlaywrightSmokeAppropriate(path, stack) {
+    return stack.hasPlaywright && isPlaywrightEntryPath(path);
+}
+function verificationForFramework(framework) {
+    if (framework === "vitest" || framework === "jest" || framework === "mocha") {
+        return framework;
+    }
+    return "none";
+}
+function isComponentTarget(input) {
+    return (isReactComponentPath(input.targetPath) || looksLikeReactComponentSource(input.targetSource));
+}
+const UNIT_REASON = "Selected unit-test style: the target is a plain TypeScript/JavaScript module, so a Playwright " +
+    "browser smoke is not appropriate and a standard unit test is generated.";
+const BROWSER_REASON = "Selected Playwright browser-smoke style: the target is an application entry point and the project " +
+    "declares Playwright.";
+const COMPONENT_REASON = "Selected component-test style: the target is a React component and the project declares " +
+    "@testing-library/react.";
+const INTERACTION_REASON = "Selected interaction-test style: the target is a React component and the project declares " +
+    "@testing-library/react with @testing-library/user-event, so user interactions are exercised.";
+const ACCESSIBILITY_REASON = "Selected accessibility-smoke style: the target is a React component and the project declares " +
+    "@testing-library/react with an accessibility matcher, so an accessibility assertion is included.";
+const UNSUPPORTED_REASON = "Unsupported stack: the target is a frontend component but the project does not declare a supported " +
+    "React component-testing stack (@testing-library/react). A reviewable limitation is reported instead " +
+    "of a fabricated browser or component test.";
+function componentStrategy(input) {
+    const verification = verificationForFramework(input.framework);
+    if (input.stack.hasAccessibilityMatchers) {
+        return { style: "accessibility-smoke", reason: ACCESSIBILITY_REASON, verification };
+    }
+    if (input.stack.hasUserEvent) {
+        return { style: "interaction", reason: INTERACTION_REASON, verification };
+    }
+    return { style: "component", reason: COMPONENT_REASON, verification };
+}
+// Selects the convention-driven test strategy for a target. Total over its input: every target maps to
+// exactly one style with a stated reason and a verification runner.
+//
+//  1. An application entry point in a Playwright project → browser smoke.
+//  2. A React component with a supported React testing stack → accessibility-smoke / interaction /
+//     component (richest applicable).
+//  3. A React component WITHOUT a supported stack → unsupported (a clear limitation, AC5).
+//  4. Any other module → unit (a Playwright smoke is explicitly not appropriate here, AC3).
+export function selectTestStrategy(input) {
+    if (isPlaywrightSmokeAppropriate(input.targetPath, input.stack)) {
+        return { style: "browser-smoke", reason: BROWSER_REASON, verification: "playwright" };
+    }
+    if (isComponentTarget(input)) {
+        if (input.stack.componentFramework !== "react" || !input.stack.hasReactTestingLibrary) {
+            return { style: "unsupported", reason: UNSUPPORTED_REASON, verification: "none" };
+        }
+        return componentStrategy(input);
+    }
+    return {
+        style: "unit",
+        reason: UNIT_REASON,
+        verification: verificationForFramework(input.framework),
+    };
+}

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

@@ -0,0 +1,9 @@
+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 { detectFrontendStack, detectFrontendStackFromDependencies, manifestDependencyNames, selectTestStrategy, EMPTY_FRONTEND_TEST_STACK, TEST_STYLES, type ComponentFramework, type FrontendStackSignals, type FrontendTestStack, type ManifestReaderFs, type StrategyInput, type TestStrategy, type TestStyle, type TestVerification, } from "./frontend.js";
+export { resolveTestStrategy, strategyAnchorPath } from "./strategy.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/dist/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;AAKjE,OAAO,EACL,mBAAmB,EACnB,mCAAmC,EACnC,uBAAuB,EACvB,kBAAkB,EAClB,yBAAyB,EACzB,WAAW,EACX,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExE,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/dist/unit-tests/index.js

@@ -0,0 +1,15 @@
+// Public barrel for the unit-test generation workflow (ADR-0008 D1). Re-exports the single entry
+// (generateUnitTests), the static UI descriptor, the Markdown renderer, the WorkflowEvent family,
+// and all public types. Internal pipeline modules (internal, model-loop, verify-stage, stages,
+// emit, parse, context, prompt) are NOT re-exported — they are implementation detail. Explicit
+// named re-exports, `type` keyword for type-only, double quotes, `.js`.
+export { generateUnitTests } from "./workflow.js";
+export { assembleReport, renderMarkdownReport } from "./report.js";
+export { UNIT_TEST_WORKFLOW_DESCRIPTOR, } from "./descriptor.js";
+export { detectConventions, isTestPath } from "./conventions.js";
+// Convention-driven frontend test-style selection (Issue #1203). The detector reads local manifests /
+// framework config; the selector maps a target to its test style; resolveTestStrategy composes both
+// over a workflow target and ContextPack.
+export { detectFrontendStack, detectFrontendStackFromDependencies, manifestDependencyNames, selectTestStrategy, EMPTY_FRONTEND_TEST_STACK, TEST_STYLES, } from "./frontend.js";
+export { resolveTestStrategy, strategyAnchorPath } from "./strategy.js";
+export { DEFAULT_WORKFLOW_LIMITS, } from "./types.js";

package/dist/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/dist/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/dist/unit-tests/internal.js

@@ -0,0 +1,43 @@
+// Shared internal types and small pure helpers used across the workflow pipeline stages (the
+// model loop, the verify stage, and the report stages). Kept private to the module — none of these
+// are re-exported from index.ts. Splitting them out keeps each pipeline file under the LOC limit
+// while leaving a single source of truth for the resolved RunState and the loop result shape.
+import { createEventEmitter } from "./emit.js";
+import { DEFAULT_WORKFLOW_LIMITS, } from "./types.js";
+// A no-op sink used when the caller injects none. emit is synchronous (ADR-0004 EventSink contract).
+export const NO_OP_SINK = { emit: () => undefined };
+// The zero-progress loop used to assemble a cancelled/failed report before the model loop ran.
+export const EMPTY_LOOP = {
+    accepted: undefined,
+    modelCallCount: 0,
+    patchRetryCount: 0,
+    lastRejectionCode: undefined,
+};
+export function resolveLimits(input) {
+    return { ...DEFAULT_WORKFLOW_LIMITS, ...input.limits };
+}
+export function buildRunState(input, deps, fingerprint) {
+    const now = deps.now ?? Date.now;
+    const idSource = deps.idSource ?? (() => crypto.randomUUID());
+    return {
+        input,
+        deps,
+        limits: resolveLimits(input),
+        signal: deps.signal ?? new AbortController().signal,
+        now,
+        emitter: createEventEmitter(deps.sink ?? NO_OP_SINK, idSource(), fingerprint, now),
+        startedAt: now(),
+        progress: { modelCallCount: 0, patchRetryCount: 0 },
+    };
+}
+// UI-renderable next actions for the report. Pure.
+export function nextActionsFor(applied, files) {
+    const first = files[0] ?? "the generated test file";
+    if (applied) {
+        return [`Review the generated tests in ${first}`, "Run `keiko verify` to confirm they pass"];
+    }
+    return [
+        `Review the proposed tests for ${first}`,
+        "Re-run with --apply to write the tests and verify",
+    ];
+}

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

@@ -0,0 +1,6 @@
+import type { ContextPack, WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+import type { ModelLoopResult, RunState } from "./internal.js";
+import type { TestStrategy } from "./frontend.js";
+import type { TestConventions } from "./types.js";
+export declare function runModelLoop(state: RunState, workspace: WorkspaceInfo, conventions: TestConventions, strategy: TestStrategy, pack: ContextPack): Promise<ModelLoopResult>;
+//# sourceMappingURL=model-loop.d.ts.map

package/dist/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;AAMhF,OAAO,KAAK,EAAiB,eAAe,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA+FlD,wBAAsB,YAAY,CAChC,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,aAAa,EACxB,WAAW,EAAE,eAAe,EAC5B,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,eAAe,CAAC,CAoC1B"}

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

@@ -0,0 +1,98 @@
+// 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 { governedPatchRejectionCode } from "../governed-handoff.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, strategy, pack, attempt, rejectionReason) {
+    const messages = buildPrompt(state.input, conventions, strategy, 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) ??
+            governedPatchRejectionCode(state.deps.workflowHandoff, 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, strategy, 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, strategy, 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/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/dist/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/dist/unit-tests/parse.js

@@ -0,0 +1,68 @@
+// Defensive parser for the model-output contract (ADR-0008 steering note B). The model is
+// instructed (see prompt.ts) to emit the unified diff inside a fenced ```diff ... ``` block,
+// optionally followed by labeled prose sections (## Covered behavior, ## Known gaps). This
+// parser extracts those parts WITHOUT trusting the model to comply: if no fence is present the
+// whole content is treated as the diff; prose sections are extracted only when their headings
+// appear. All extraction uses plain string ops (line splitting, startsWith, trim) — zero regex,
+// so there is no ReDoS surface (steering note F). Redaction happens at the workflow boundary,
+// not here: this module is pure string parsing.
+const FENCE = "```";
+const COVERED_HEADING = "## covered behavior";
+const GAPS_HEADING = "## known gaps";
+// Returns the contents of the FIRST fenced block (```diff ... ``` or a bare ``` ... ```) and the
+// text that follows the closing fence. When no fenced block is found, returns the whole input as
+// the diff and an empty remainder (the no-fence fallback).
+function extractFencedDiff(content) {
+    const lines = content.split("\n");
+    const openIndex = lines.findIndex((line) => line.trimStart().startsWith(FENCE));
+    if (openIndex === -1) {
+        return { diff: content.trim(), rest: "" };
+    }
+    const closeIndex = lines.findIndex((line, idx) => idx > openIndex && line.trimStart().startsWith(FENCE));
+    if (closeIndex === -1) {
+        // An opening fence with no close: treat everything after the opener as the diff.
+        return {
+            diff: lines
+                .slice(openIndex + 1)
+                .join("\n")
+                .trim(),
+            rest: "",
+        };
+    }
+    return {
+        diff: lines
+            .slice(openIndex + 1, closeIndex)
+            .join("\n")
+            .trim(),
+        rest: lines.slice(closeIndex + 1).join("\n"),
+    };
+}
+// Extracts the body of a labeled section: every line after the matching `## heading` up to the
+// next `## ` heading (or end of input). Returns undefined when the heading is absent. Returns
+// undefined when the section body is empty after trimming.
+function extractSection(text, heading) {
+    const lines = text.split("\n");
+    const start = lines.findIndex((line) => line.trim().toLowerCase() === heading);
+    if (start === -1) {
+        return undefined;
+    }
+    const body = [];
+    for (const line of lines.slice(start + 1)) {
+        if (line.trim().startsWith("## ")) {
+            break;
+        }
+        body.push(line);
+    }
+    const joined = body.join("\n").trim();
+    return joined.length === 0 ? undefined : joined;
+}
+export function parseModelOutput(content) {
+    const { diff, rest } = extractFencedDiff(content);
+    // Prose may follow the fenced diff; when there is no fence the whole content is the diff and
+    // there is no prose to scan, so `rest` is empty and both sections resolve to undefined.
+    return {
+        diff,
+        coveredBehavior: extractSection(rest, COVERED_HEADING),
+        knownGaps: extractSection(rest, GAPS_HEADING),
+    };
+}

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

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

package/dist/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,YAAY,EAAa,MAAM,eAAe,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAkB,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAoJzF,wBAAgB,WAAW,CACzB,KAAK,EAAE,qBAAqB,EAC5B,WAAW,EAAE,eAAe,EAC5B,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,WAAW,EACjB,eAAe,CAAC,EAAE,MAAM,GACvB,SAAS,WAAW,EAAE,CAKxB"}