@elench/testkit 0.1.82 → 0.1.84

package/lib/cli/command-helpers.mjs

@@ -11,6 +11,8 @@ import {
 } from "./args.mjs";
 import * as runner from "../runner/index.mjs";
 import { createRunReporter } from "./presentation/run-reporter.mjs";
+import { createTreeReporter } from "./presentation/tree-reporter.mjs";
+import { createRunEventsReporter } from "./presentation/events-reporter.mjs";
 
 export const sharedFlags = {
   dir: Flags.string({
@@ -64,7 +66,7 @@ export const runFlags = {
   }),
   "output-mode": Flags.string({
     description: "Reporter mode",
-    options: ["compact", "debug"],
+    options: ["compact", "debug", "events"],
   }),
   debug: Flags.boolean({
     description: "Alias for --output-mode debug",
@@ -94,31 +96,57 @@ export async function executeRunCommand(command, flags, positionalType = null) {
     : flags.debug
       ? "debug"
       : flags["output-mode"] || "compact";
-  const reporter = createRunReporter({ outputMode });
-  const result = await runner.runAll(
-    configs,
-    typeValues,
-    suiteSelectors,
-    {
-      ...flags,
+
+  let reporter;
+  let finalize = Promise.resolve();
+  let close = () => {};
+
+  if (outputMode === "compact" && process.stdout.isTTY) {
+    const tree = createTreeReporter({
+      stdout: process.stdout,
+      stderr: process.stderr,
+      productDir,
+    });
+    reporter = tree.reporter;
+    finalize = tree.finalize;
+    close = tree.close;
+  } else if (outputMode === "events") {
+    reporter = createRunEventsReporter({ stdout: process.stdout, stderr: process.stderr });
+  } else {
+    reporter = createRunReporter({ outputMode });
+  }
+
+  try {
+    const result = await runner.runAll(
+      configs,
       typeValues,
-      fileNames,
-      workers,
-      fileTimeoutSeconds,
-      shard,
-      scenarioSeed: flags.seed || null,
-      serviceFilter: flags.service || null,
-      reporter,
-      writeStatus: flags["write-status"],
-      allowPartialStatus: flags["allow-partial-status"],
-      ignoreSkipRules: flags["ignore-skip-rules"],
-    },
-    allConfigs
-  );
-  return {
-    outputMode,
-    ...result,
-  };
+      suiteSelectors,
+      {
+        ...flags,
+        typeValues,
+        fileNames,
+        workers,
+        fileTimeoutSeconds,
+        shard,
+        scenarioSeed: flags.seed || null,
+        serviceFilter: flags.service || null,
+        reporter,
+        writeStatus: flags["write-status"],
+        allowPartialStatus: flags["allow-partial-status"],
+        ignoreSkipRules: flags["ignore-skip-rules"],
+      },
+      allConfigs
+    );
+    await finalize;
+    return {
+      outputMode,
+      ...result,
+    };
+  } catch (error) {
+    close();
+    await finalize.catch(() => {});
+    throw error;
+  }
 }
 
 export async function runStatusLike(commandName, flags) {

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/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/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/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/tui/run-app.mjs

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