@elench/testkit 0.1.82 → 0.1.83

package/lib/cli/entrypoint.mjs

@@ -11,6 +11,7 @@ export function normalizeCliArgs(argv) {
     "discover",
     "typecheck",
     "doctor",
+    "investigate",
     "browser",
     "db",
     "help",
@@ -37,6 +38,8 @@ export function normalizeCliArgs(argv) {
     "--output-mode",
     "--tail",
     "--log-tail",
+    "--provider",
+    "--message",
   ]);
   const positionals = findPositionals(argv, valueFlags);
   const firstPositional = positionals[0] || null;

package/lib/cli/presentation/colors.mjs

@@ -35,6 +35,18 @@ export function red(text) {
   return pc.red(text);
 }
 
+export function green(text) {
+  return pc.green(text);
+}
+
+export function yellow(text) {
+  return pc.yellow(text);
+}
+
+export function cyan(text) {
+  return pc.cyan(text);
+}
+
 export function muted(text) {
   return pc.dim(text);
 }

package/lib/cli/presentation/events-reporter.mjs

@@ -0,0 +1,135 @@
+export function createRunEventsReporter({ stdout = process.stdout, stderr = process.stderr } = {}) {
+  function writeEvent(type, payload = {}) {
+    stdout.write(`${JSON.stringify({ type, ...payload })}\n`);
+  }
+
+  return {
+    outputMode: "events",
+
+    setRegressionCatalog(document) {
+      writeEvent("run.regression_catalog", {
+        configured: Boolean(document?.configured),
+      });
+    },
+
+    setServicePlans(plans) {
+      writeEvent("run.service_plans", {
+        services: plans.map((plan) => ({
+          service: plan.config.name,
+          skipped: Boolean(plan.skipped),
+          suites: (plan.suites || []).map((suite) => ({
+            name: suite.name,
+            type: suite.type,
+            displayType: suite.displayType,
+            framework: suite.framework,
+            files: suite.files,
+          })),
+        })),
+      });
+    },
+
+    setTotalFileCount(count) {
+      writeEvent("run.total_files", { total: count });
+    },
+
+    phaseStarted(label) {
+      writeEvent("run.phase_started", { label });
+    },
+
+    toolchainResolved(config, resolvedToolchain) {
+      writeEvent("run.toolchain_resolved", {
+        service: config.name,
+        runtimeLabel: config.runtimeLabel || config.name,
+        summary: resolvedToolchain.summary,
+      });
+    },
+
+    setupOperationFinished(operation) {
+      if (!operation) return;
+      writeEvent("run.setup_finished", {
+        service: operation.serviceName,
+        stage: operation.stage,
+        status: operation.status,
+        summary: operation.summary || null,
+        durationMs: operation.durationMs ?? null,
+        error: operation.error || null,
+      });
+    },
+
+    localServiceStarting(config, command) {
+      writeEvent("run.local_service_starting", {
+        service: config.name,
+        runtimeLabel: config.runtimeLabel || config.name,
+        command,
+      });
+    },
+
+    serviceSkipped(config, reason) {
+      writeEvent("run.service_skipped", {
+        service: config.name,
+        reason,
+      });
+    },
+
+    plannedSkip(entry) {
+      writeEvent("run.task_planned_skip", {
+        service: entry.serviceName,
+        file: entry.file,
+        reason: entry.reason || null,
+      });
+    },
+
+    taskStarted(task) {
+      writeEvent("run.task_started", {
+        service: task.serviceName,
+        file: task.file,
+        suite: task.suiteName,
+        type: task.type,
+        framework: task.framework,
+      });
+    },
+
+    taskFinished(task, outcome) {
+      writeEvent("run.task_finished", {
+        service: task.serviceName,
+        file: task.file,
+        suite: task.suiteName,
+        type: task.type,
+        framework: task.framework,
+        outcome,
+      });
+    },
+
+    runtimeError(task, message) {
+      writeEvent("run.runtime_error", {
+        service: task.serviceName,
+        file: task.file,
+        message,
+      });
+    },
+
+    telemetry(message) {
+      writeEvent("run.telemetry", { message });
+    },
+
+    writeLine(line = "") {
+      writeEvent("run.output", { line });
+    },
+
+    writeDebugLine(line = "") {
+      writeEvent("run.debug", { line });
+    },
+
+    runSummary(results, durationMs, regressionReport) {
+      writeEvent("run.summary", {
+        results,
+        durationMs,
+        regressionReport,
+      });
+    },
+
+    error(message) {
+      stderr.write(`${message}\n`);
+    },
+  };
+}

package/lib/cli/presentation/events-reporter.test.mjs

@@ -0,0 +1,73 @@
+import { Writable } from "stream";
+import { describe, expect, it } from "vitest";
+import { createRunEventsReporter } from "./events-reporter.mjs";
+
+function createCapture() {
+  let output = "";
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      output += chunk.toString();
+      callback();
+    },
+  });
+  return {
+    stream,
+    lines() {
+      return output.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+    },
+  };
+}
+
+describe("events reporter", () => {
+  it("emits structured run lifecycle events", () => {
+    const capture = createCapture();
+    const reporter = createRunEventsReporter({ stdout: capture.stream });
+
+    reporter.setTotalFileCount(2);
+    reporter.taskStarted({
+      serviceName: "api",
+      file: "tests/api/users.int.testkit.ts",
+      suiteName: "users",
+      type: "integration",
+      framework: "k6",
+    });
+    reporter.taskFinished(
+      {
+        serviceName: "api",
+        file: "tests/api/users.int.testkit.ts",
+        suiteName: "users",
+        type: "integration",
+        framework: "k6",
+      },
+      { failed: true, error: "status 500" }
+    );
+    reporter.runSummary([{ name: "api", failed: true }], 1200, null);
+
+    expect(capture.lines()).toEqual([
+      { type: "run.total_files", total: 2 },
+      {
+        type: "run.task_started",
+        service: "api",
+        file: "tests/api/users.int.testkit.ts",
+        suite: "users",
+        type: "integration",
+        framework: "k6",
+      },
+      {
+        type: "run.task_finished",
+        service: "api",
+        file: "tests/api/users.int.testkit.ts",
+        suite: "users",
+        type: "integration",
+        framework: "k6",
+        outcome: { failed: true, error: "status 500" },
+      },
+      {
+        type: "run.summary",
+        results: [{ name: "api", failed: true }],
+        durationMs: 1200,
+        regressionReport: null,
+      },
+    ]);
+  });
+});

package/lib/cli/presentation/summary-box.mjs

@@ -8,8 +8,8 @@ export function renderSummaryBox(
     widthRatio = 0.55,
     minWidth = 30,
     maxWidth = 56,
+    minKeyWidth = 6,
     minValueWidth = 8,
-    maxKeyWidth = 12,
   } = {}
 ) {
   if (!Array.isArray(rows) || rows.length === 0) return [];
@@ -17,23 +17,23 @@ export function renderSummaryBox(
   const terminalWidth = getTerminalWidth(stdout, 100);
   const preferredWidth = clamp(Math.floor(terminalWidth * widthRatio), minWidth, maxWidth);
   const maxRenderableWidth = Math.max(minWidth, Math.min(preferredWidth, terminalWidth - 1));
-  const keyWidth = Math.min(
-    maxKeyWidth,
-    Math.max(...rows.map(([label]) => measureWidth(label)), 6)
-  );
-  const minBoxWidth = keyWidth + minValueWidth + 7;
-  const boxWidth = Math.max(minBoxWidth, maxRenderableWidth);
-  const valueWidth = Math.max(minValueWidth, boxWidth - keyWidth - 7);
+  const widestLabel = Math.max(...rows.map(([label]) => measureWidth(label)), minKeyWidth);
+  const boxWidth = Math.max(minWidth, maxRenderableWidth);
+  const contentWidth = Math.max(2, boxWidth - 7);
+  const keyWidth = Math.min(widestLabel, Math.max(minKeyWidth, contentWidth - minValueWidth));
+  const valueWidth = Math.max(1, contentWidth - keyWidth);
 
   const top = `${figures.lineDownRight}${figures.line.repeat(boxWidth - 2)}${figures.lineDownLeft}`;
   const bottom = `${figures.lineUpRight}${figures.line.repeat(boxWidth - 2)}${figures.lineUpLeft}`;
   const rendered = [top];
 
   for (const [label, value] of rows) {
+    const wrappedKeyLines = wrapText(label, keyWidth);
     const wrappedValueLines = wrapText(value, valueWidth);
-    for (let index = 0; index < wrappedValueLines.length; index += 1) {
-      const keyCell = index === 0 ? padEndVisible(label, keyWidth) : " ".repeat(keyWidth);
-      const valueCell = padEndVisible(wrappedValueLines[index], valueWidth);
+    const lineCount = Math.max(wrappedKeyLines.length, wrappedValueLines.length);
+    for (let index = 0; index < lineCount; index += 1) {
+      const keyCell = padEndVisible(wrappedKeyLines[index] ?? "", keyWidth);
+      const valueCell = padEndVisible(wrappedValueLines[index] ?? "", valueWidth);
       rendered.push(
         `${figures.lineVertical} ${keyCell} ${figures.lineVertical} ${valueCell} ${figures.lineVertical}`
       );

package/lib/cli/presentation/summary-box.test.mjs

@@ -1,6 +1,7 @@
 import { Writable } from "stream";
 import { describe, expect, it } from "vitest";
 import { renderSummaryBox } from "./summary-box.mjs";
+import { measureWidth } from "./terminal-layout.mjs";
 
 function createStream(columns) {
   const stream = new Writable({
@@ -40,4 +41,20 @@ describe("summary box", () => {
     expect(lines.join("\n")).toContain("stale");
     expect(lines.join("\n")).toContain("cache");
   });
+
+  it("keeps long labels inside the box width", () => {
+    const lines = renderSummaryBox(
+      [
+        ["Result", "FAILED"],
+        ["New regressions", "1"],
+      ],
+      { stdout: createStream(80) }
+    );
+
+    const boxWidth = measureWidth(lines[0]);
+    expect(lines.join("\n")).toContain("New regressions");
+    for (const line of lines) {
+      expect(measureWidth(line)).toBe(boxWidth);
+    }
+  });
 });

package/lib/cli/presentation/tree-reporter.mjs

@@ -0,0 +1,159 @@
+import React, { createElement } from "react";
+import { render } from "ink";
+import { createRunSessionState } from "../tui/run-session-state.mjs";
+import { RunSessionApp } from "../tui/run-session-app.mjs";
+import { suiteSelectionType } from "../../runner/suite-selection.mjs";
+import { startHostedInvestigation } from "../agents/investigate.mjs";
+
+export function createTreeReporter({ stdout = process.stdout, stderr = process.stderr, productDir } = {}) {
+  const sessionState = createRunSessionState();
+  let activeAgentSession = null;
+  let investigationToken = 0;
+
+  const app = render(
+    createElement(RunSessionApp, {
+      sessionState,
+      stdout,
+      productDir,
+      onInvestigate: startInvestigation,
+      onRequestClose: close,
+      onCancelInvestigation: cancelInvestigation,
+    }),
+    { stdout, exitOnCtrlC: false }
+  );
+
+  const finalize = app.waitUntilExit();
+
+  const reporter = {
+    outputMode: "compact",
+
+    setServicePlans(plans) {
+      sessionState.initFromPlans(plans);
+    },
+
+    setTotalFileCount(count) {
+      sessionState.setTotalFileCount(count);
+    },
+
+    setRegressionCatalog(document) {
+      sessionState.setRegressionCatalog(document);
+    },
+
+    serviceSkipped(config, reason) {
+      sessionState.markServiceSkipped(config.name, reason);
+    },
+
+    plannedSkip(entry) {
+      sessionState.markPlannedSkip(entry);
+    },
+
+    taskStarted(task, _config) {
+      const suiteKey = `${task.displayType || suiteSelectionType(task.type, task.framework)}:${task.suiteName}`;
+      sessionState.markFileRunning(task.serviceName, suiteKey, task.file);
+    },
+
+    taskFinished(task, outcome) {
+      sessionState.markFileFinished(task, outcome);
+    },
+
+    runtimeError(task, message) {
+      sessionState.markRuntimeError(task, message);
+    },
+
+    setupOperationFinished(_operation) {
+      // tree handles this implicitly through phase
+    },
+
+    phaseStarted(label) {
+      sessionState.setPhase(label);
+    },
+
+    toolchainResolved() {},
+    localServiceStarting() {},
+    writeLine() {},
+    writeDebugLine() {},
+    telemetry() {},
+
+    runSummary(results, durationMs, regressionReport) {
+      sessionState.finish(results, durationMs, regressionReport);
+    },
+
+    error(message) {
+      stderr.write(`${message}\n`);
+    },
+  };
+
+  return {
+    reporter,
+    finalize,
+    close,
+  };
+
+  async function startInvestigation({ provider = "auto", userMessage } = {}) {
+    const snapshot = sessionState.getSnapshot();
+    if (!snapshot.selectedFailure) {
+      sessionState.setNotice("No failed file is selected for investigation.");
+      return;
+    }
+    if (activeAgentSession) {
+      sessionState.setNotice("An investigation is already running.");
+      return;
+    }
+
+    const token = ++investigationToken;
+    sessionState.beginInvestigation({ provider, userMessage });
+
+    try {
+      activeAgentSession = startHostedInvestigation({
+        productDir,
+        serviceName: snapshot.selectedFailure.serviceName,
+        filePath: snapshot.selectedFailure.filePath,
+        provider,
+        userMessage,
+        onEvent(event) {
+          if (token !== investigationToken) return;
+          sessionState.appendAgentEvent(event);
+        },
+      });
+      const result = await activeAgentSession.completion;
+      if (token !== investigationToken) return;
+      activeAgentSession = null;
+      if (result.cancelled) {
+        sessionState.cancelAgentSession("Cancelled investigation.");
+        return;
+      }
+      if (result.exitCode !== 0 && !result.finalText) {
+        sessionState.failAgentSession(result.stderr || `Agent exited with code ${result.exitCode}`);
+        return;
+      }
+      sessionState.completeAgentSession({
+        finalText: result.finalText,
+        exitCode: result.exitCode,
+      });
+    } catch (error) {
+      if (token !== investigationToken) return;
+      activeAgentSession = null;
+      sessionState.failAgentSession(error);
+    }
+  }
+
+  function cancelInvestigation() {
+    if (!activeAgentSession) {
+      sessionState.returnToSummary();
+      return;
+    }
+    investigationToken += 1;
+    activeAgentSession.cancel();
+    activeAgentSession = null;
+    sessionState.cancelAgentSession("Cancelled investigation.");
+  }
+
+  function close() {
+    if (activeAgentSession) {
+      investigationToken += 1;
+      activeAgentSession.cancel();
+      activeAgentSession = null;
+    }
+    app.unmount();
+  }
+}

package/lib/cli/presentation/tree-reporter.test.mjs

@@ -0,0 +1,166 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const renderMock = vi.fn();
+const startHostedInvestigationMock = vi.fn();
+let capturedElement = null;
+let finalizeResolve = null;
+let unmountSpy;
+
+vi.mock("ink", () => ({
+  render: renderMock,
+}));
+
+vi.mock("../agents/investigate.mjs", () => ({
+  startHostedInvestigation: startHostedInvestigationMock,
+}));
+
+function flush() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+beforeEach(() => {
+  capturedElement = null;
+  unmountSpy = vi.fn(() => finalizeResolve?.());
+  renderMock.mockImplementation((element) => {
+    capturedElement = element;
+    return {
+      waitUntilExit() {
+        return new Promise((resolve) => {
+          finalizeResolve = resolve;
+        });
+      },
+      unmount: unmountSpy,
+    };
+  });
+});
+
+afterEach(() => {
+  renderMock.mockReset();
+  startHostedInvestigationMock.mockReset();
+  finalizeResolve = null;
+});
+
+function getSessionState() {
+  return capturedElement.props.sessionState;
+}
+
+function seedFailure(reporter) {
+  reporter.setServicePlans([
+    {
+      config: { name: "api" },
+      skipped: false,
+      suites: [
+        {
+          name: "users",
+          type: "integration",
+          displayType: "int",
+          framework: "k6",
+          files: ["tests/api/users.int.testkit.ts"],
+        },
+      ],
+    },
+  ]);
+  reporter.taskFinished(
+    {
+      serviceName: "api",
+      type: "integration",
+      displayType: "int",
+      framework: "k6",
+      suiteName: "users",
+      file: "tests/api/users.int.testkit.ts",
+    },
+    { failed: true, error: "status 500", durationMs: 1000, failureDetails: [] }
+  );
+}
+
+describe("tree reporter", () => {
+  it("keeps the session mounted after run summary until close is requested", async () => {
+    const { createTreeReporter } = await import("./tree-reporter.mjs");
+    const tree = createTreeReporter({ productDir: "/tmp/project" });
+
+    tree.reporter.runSummary([], 1000, null);
+
+    let settled = false;
+    tree.finalize.then(() => {
+      settled = true;
+    });
+    await flush();
+
+    expect(settled).toBe(false);
+    tree.close();
+    await tree.finalize;
+    expect(unmountSpy).toHaveBeenCalled();
+  });
+
+  it("streams hosted investigation events into the session state", async () => {
+    const { createTreeReporter } = await import("./tree-reporter.mjs");
+    startHostedInvestigationMock.mockImplementation(({ onEvent }) => {
+      onEvent({ type: "start" });
+      onEvent({ type: "status", message: "Inspecting repository" });
+      onEvent({ type: "delta", text: "Likely root cause." });
+      return {
+        cancel: vi.fn(),
+        completion: Promise.resolve({
+          provider: "codex",
+          exitCode: 0,
+          finalText: "Likely root cause.",
+          cancelled: false,
+        }),
+      };
+    });
+
+    const tree = createTreeReporter({ productDir: "/tmp/project" });
+    seedFailure(tree.reporter);
+
+    await capturedElement.props.onInvestigate({
+      provider: "codex",
+      userMessage: "Investigate the selected failure",
+    });
+
+    const snapshot = getSessionState().getSnapshot();
+    expect(startHostedInvestigationMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        productDir: "/tmp/project",
+        serviceName: "api",
+        filePath: "tests/api/users.int.testkit.ts",
+      })
+    );
+    expect(snapshot.agentSession.status).toBe("complete");
+    expect(snapshot.agentSession.entries.some((entry) => entry.kind === "assistant")).toBe(true);
+  });
+
+  it("cancels an active investigation and unmounts cleanly on close", async () => {
+    const { createTreeReporter } = await import("./tree-reporter.mjs");
+    const cancel = vi.fn();
+    let resolveCompletion;
+    startHostedInvestigationMock.mockReturnValue({
+      cancel,
+      completion: new Promise((resolve) => {
+        resolveCompletion = resolve;
+      }),
+    });
+
+    const tree = createTreeReporter({ productDir: "/tmp/project" });
+    seedFailure(tree.reporter);
+
+    const pending = capturedElement.props.onInvestigate({
+      provider: "claude",
+      userMessage: "Investigate the selected failure",
+    });
+    await flush();
+    capturedElement.props.onCancelInvestigation();
+    resolveCompletion({
+      provider: "claude",
+      exitCode: 130,
+      finalText: "",
+      cancelled: true,
+    });
+    await pending;
+
+    expect(cancel).toHaveBeenCalled();
+    expect(getSessionState().getSnapshot().notice).toContain("Cancelled");
+    tree.close();
+    await tree.finalize;
+    expect(unmountSpy).toHaveBeenCalled();
+  });
+});

package/lib/cli/tui/run-app.mjs

@@ -0,0 +1 @@
+export { RunSessionApp as RunApp } from "./run-session-app.mjs";