@elench/testkit 0.1.81 → 0.1.83

package/lib/cli/commands/investigate.mjs

@@ -0,0 +1,87 @@
+import { Args, Command, Flags } from "@oclif/core";
+import { sharedFlags } from "../command-helpers.mjs";
+import { loadCurrentRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { runInteractiveInvestigation, startHostedInvestigation } from "../agents/investigate.mjs";
+
+export default class InvestigateCommand extends Command {
+  static summary = "Investigate a failed file from the latest run with Codex or Claude";
+
+  static enableJsonFlag = true;
+
+  static args = {
+    file: Args.string({
+      description: "Optional file path; defaults to the first failed file",
+      required: false,
+    }),
+  };
+
+  static flags = {
+    ...sharedFlags,
+    provider: Flags.string({
+      description: "Agent provider to use",
+      options: ["auto", "claude", "codex"],
+      default: "auto",
+    }),
+    message: Flags.string({
+      description: "Additional user instruction for the investigation prompt",
+    }),
+    handoff: Flags.boolean({
+      description: "Launch the provider's native interactive TUI instead of hosted output",
+      default: false,
+    }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(InvestigateCommand);
+    const productDir = flags.dir || process.cwd();
+    const runArtifact = loadCurrentRunArtifact(productDir);
+    const subject = resolveFileSubject(runArtifact, args.file || null, flags.service || null);
+
+    if (flags.handoff) {
+      const result = await runInteractiveInvestigation({
+        productDir,
+        serviceName: subject.service.name,
+        filePath: subject.file.path,
+        provider: flags.provider,
+        userMessage: flags.message || null,
+      });
+      if (!this.jsonEnabled()) {
+        this.log(`${result.provider} exited with code ${result.exitCode}`);
+      }
+      return result;
+    }
+
+    let finalText = "";
+    const session = startHostedInvestigation({
+      productDir,
+      serviceName: subject.service.name,
+      filePath: subject.file.path,
+      provider: flags.provider,
+      userMessage: flags.message || null,
+      onEvent: this.jsonEnabled()
+        ? null
+        : (event) => {
+            if (event.type === "status" || event.type === "tool") {
+              this.log(event.type === "tool" ? `[tool] ${event.name}${event.detail ? `: ${event.detail}` : ""}` : `[status] ${event.message}`);
+            } else if (event.type === "error") {
+              this.error(event.message);
+            }
+          },
+    });
+    const result = await session.completion;
+    finalText = result.finalText || "";
+
+    if (!this.jsonEnabled() && finalText.trim()) {
+      this.log("");
+      this.log(finalText.trim());
+    }
+
+    return {
+      provider: result.provider,
+      exitCode: result.exitCode,
+      file: subject.file.path,
+      service: subject.service.name,
+      finalText,
+    };
+  }
+}

package/lib/cli/commands/investigate.test.mjs

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const loadCurrentRunArtifactMock = vi.fn();
+const resolveFileSubjectMock = vi.fn();
+const startHostedInvestigationMock = vi.fn();
+const runInteractiveInvestigationMock = vi.fn();
+
+vi.mock("../viewer.mjs", () => ({
+  loadCurrentRunArtifact: loadCurrentRunArtifactMock,
+  resolveFileSubject: resolveFileSubjectMock,
+}));
+
+vi.mock("../agents/investigate.mjs", () => ({
+  startHostedInvestigation: startHostedInvestigationMock,
+  runInteractiveInvestigation: runInteractiveInvestigationMock,
+}));
+
+afterEach(() => {
+  loadCurrentRunArtifactMock.mockReset();
+  resolveFileSubjectMock.mockReset();
+  startHostedInvestigationMock.mockReset();
+  runInteractiveInvestigationMock.mockReset();
+});
+
+function seedSubject() {
+  loadCurrentRunArtifactMock.mockReturnValue({});
+  resolveFileSubjectMock.mockReturnValue({
+    service: { name: "api" },
+    suite: { name: "users", type: "integration" },
+    file: { path: "tests/api/users.int.testkit.ts" },
+  });
+}
+
+describe("InvestigateCommand", () => {
+  it("runs hosted investigation and returns the final text", async () => {
+    seedSubject();
+    startHostedInvestigationMock.mockReturnValue({
+      completion: Promise.resolve({
+        provider: "codex",
+        exitCode: 0,
+        finalText: "Likely root cause.",
+      }),
+    });
+
+    const { default: InvestigateCommand } = await import("./investigate.mjs");
+    const result = await InvestigateCommand.run(["--json"]);
+
+    expect(startHostedInvestigationMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        productDir: process.cwd(),
+        serviceName: "api",
+        filePath: "tests/api/users.int.testkit.ts",
+      })
+    );
+    expect(result).toMatchObject({
+      provider: "codex",
+      finalText: "Likely root cause.",
+      file: "tests/api/users.int.testkit.ts",
+      service: "api",
+    });
+  });
+
+  it("runs handoff investigation when requested", async () => {
+    seedSubject();
+    runInteractiveInvestigationMock.mockResolvedValue({
+      provider: "claude",
+      exitCode: 0,
+    });
+
+    const { default: InvestigateCommand } = await import("./investigate.mjs");
+    const result = await InvestigateCommand.run(["--json", "--handoff", "--provider", "claude"]);
+
+    expect(runInteractiveInvestigationMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        productDir: process.cwd(),
+        serviceName: "api",
+        filePath: "tests/api/users.int.testkit.ts",
+        provider: "claude",
+      })
+    );
+    expect(result).toMatchObject({ provider: "claude", exitCode: 0 });
+  });
+});

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();
+  }
+}