@elench/testkit 0.1.86 → 0.1.88

package/lib/cli/commands/assistant.mjs

@@ -0,0 +1,84 @@
+import React, { createElement } from "react";
+import { Command, Flags } from "@oclif/core";
+import { render } from "ink";
+import { sharedFlags, resolveConfigsForCommand } from "../command-helpers.mjs";
+import { createAssistantState } from "../assistant/state.mjs";
+import { loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+
+export default class AssistantCommand extends Command {
+  static summary = "Launch the interactive testkit assistant";
+
+  static enableJsonFlag = true;
+
+  static flags = {
+    ...sharedFlags,
+    provider: Flags.string({
+      description: "Assistant provider",
+      options: ["auto", "claude", "codex"],
+      default: "auto",
+    }),
+    pane: Flags.string({
+      description: "Initial workbench pane",
+      options: ["detail", "artifacts", "logs", "setup"],
+      default: "detail",
+    }),
+    file: Flags.string({
+      description: "Initial file selection",
+    }),
+    message: Flags.string({
+      description: "Run one assistant turn non-interactively",
+    }),
+  };
+
+  async run() {
+    const { flags } = await this.parse(AssistantCommand);
+    const { allConfigs } = await resolveConfigsForCommand(flags);
+    const productDir = allConfigs[0]?.productDir || process.cwd();
+    const assistantState = createAssistantState({
+      productDir,
+      provider: flags.provider,
+      initialPane: flags.pane,
+      configs: allConfigs,
+    });
+
+    await assistantState.loadLatestArtifact();
+    if (flags.file) {
+      try {
+        const artifact = loadLatestRunArtifact(productDir);
+        const subject = resolveFileSubject(artifact, flags.file, flags.service || null);
+        assistantState.revealFile(subject.service.name, subject.file.path);
+      } catch {
+        // Ignore missing initial selection.
+      }
+    } else if (flags.service) {
+      assistantState.revealService(flags.service);
+    }
+
+    const interactive = process.stdout.isTTY && !this.jsonEnabled() && !flags.message;
+    if (!interactive) {
+      if (flags.message) {
+        await assistantState.submitInput(flags.message);
+      }
+      const snapshot = assistantState.getSnapshot();
+      if (!this.jsonEnabled()) {
+        for (const message of snapshot.messages) {
+          this.log(`${message.role}: ${message.text}`);
+        }
+      }
+      return snapshot;
+    }
+
+    const { AssistantApp } = await import("../tui/assistant-app.mjs");
+    const app = render(
+      createElement(AssistantApp, {
+        assistantState,
+        stdout: process.stdout,
+        productDir,
+      }),
+      { stdout: process.stdout, exitOnCtrlC: false }
+    );
+
+    await app.waitUntilExit();
+    return assistantState.getSnapshot();
+  }
+}

package/lib/cli/entrypoint.mjs

@@ -1,17 +1,13 @@
 export function normalizeCliArgs(argv) {
   const topLevelCommands = new Set([
+    "assistant",
     "run",
     "status",
     "destroy",
     "cleanup",
-    "show",
-    "logs",
-    "artifacts",
-    "watch",
     "discover",
     "typecheck",
     "doctor",
-    "investigate",
     "browser",
     "db",
     "help",
@@ -40,22 +36,52 @@ export function normalizeCliArgs(argv) {
     "--log-tail",
     "--provider",
     "--message",
+    "--pane",
   ]);
   const positionals = findPositionals(argv, valueFlags);
   const firstPositional = positionals[0] || null;
+  const interactiveTty = process.stdout.isTTY;
+  const runFlagPresent = argv.some((value) =>
+    [
+      "--type",
+      "-t",
+      "--suite",
+      "-s",
+      "--file",
+      "-f",
+      "--workers",
+      "--file-timeout-seconds",
+      "--shard",
+      "--seed",
+      "--write-status",
+      "--allow-partial-status",
+      "--ignore-skip-rules",
+      "--output-mode",
+      "--debug",
+    ].includes(value)
+  );
   const shouldPrefixRun =
-    !firstPositional ||
-    runTypeShortcuts.has(firstPositional.value) ||
-    !topLevelCommands.has(firstPositional.value);
+    (!firstPositional && !interactiveTty) ||
+    runTypeShortcuts.has(firstPositional?.value) ||
+    runFlagPresent ||
+    !topLevelCommands.has(firstPositional?.value);
 
-  if (shouldPrefixRun) {
-    return ["run", ...argv];
+  if (!firstPositional && interactiveTty && !runFlagPresent) {
+    return ["assistant", ...argv];
   }
 
-  if (topLevelCommands.has(firstPositional.value) && argv[0] !== firstPositional.value) {
+  if (!shouldPrefixRun && topLevelCommands.has(firstPositional?.value) && argv[0] !== firstPositional.value) {
     return reorderCommandArgs(argv, positionals);
   }
 
+  if (!topLevelCommands.has(firstPositional?.value) && interactiveTty && !runFlagPresent) {
+    return ["assistant", "--message", argv.join(" ")];
+  }
+
+  if (shouldPrefixRun) {
+    return ["run", ...argv];
+  }
+
   return argv;
 }
 

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

@@ -1,21 +1,27 @@
 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 { createInspectState } from "../tui/inspect-state.mjs";
+import { InspectApp } from "../tui/inspect-app.mjs";
+import {
+  applyReporterPlans,
+  applyReporterRunSummary,
+  applyReporterTaskFinished,
+  applyReporterTaskStarted,
+} from "../tui/inspect-live-adapter.mjs";
 import { suiteSelectionType } from "../../runner/suite-selection.mjs";
 import { startHostedInvestigation } from "../agents/investigate.mjs";
 import { createInvestigationInterpreter } from "../agents/investigation-interpreter.mjs";
 import { writeInvestigationLog } from "../agents/investigation-log.mjs";
 
 export function createTreeReporter({ stdout = process.stdout, stderr = process.stderr, productDir } = {}) {
-  const sessionState = createRunSessionState();
+  const inspectState = createInspectState({ dataSource: "live" });
   let activeAgentSession = null;
   let activeInterpreter = null;
   let investigationToken = 0;
 
   const app = render(
-    createElement(RunSessionApp, {
-      sessionState,
+    createElement(InspectApp, {
+      inspectState,
       stdout,
       productDir,
       onInvestigate: startInvestigation,
@@ -31,36 +37,36 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
     outputMode: "compact",
 
     setServicePlans(plans) {
-      sessionState.initFromPlans(plans);
+      applyReporterPlans(inspectState, plans);
     },
 
     setTotalFileCount(count) {
-      sessionState.setTotalFileCount(count);
+      inspectState.setTotalFileCount(count);
     },
 
     setRegressionCatalog(document) {
-      sessionState.setRegressionCatalog(document);
+      inspectState.setRegressionCatalog(document);
     },
 
     serviceSkipped(config, reason) {
-      sessionState.markServiceSkipped(config.name, reason);
+      inspectState.markServiceSkipped(config.name, reason);
     },
 
     plannedSkip(entry) {
-      sessionState.markPlannedSkip(entry);
+      inspectState.markPlannedSkip(entry);
     },
 
     taskStarted(task, _config) {
       const suiteKey = `${task.displayType || suiteSelectionType(task.type, task.framework)}:${task.suiteName}`;
-      sessionState.markFileRunning(task.serviceName, suiteKey, task.file);
+      applyReporterTaskStarted(inspectState, task, suiteKey);
     },
 
     taskFinished(task, outcome) {
-      sessionState.markFileFinished(task, outcome);
+      applyReporterTaskFinished(inspectState, task, outcome);
     },
 
     runtimeError(task, message) {
-      sessionState.markRuntimeError(task, message);
+      inspectState.markRuntimeError(task, message);
     },
 
     setupOperationFinished(_operation) {
@@ -68,7 +74,7 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
     },
 
     phaseStarted(label) {
-      sessionState.setPhase(label);
+      inspectState.setPhase(label);
     },
 
     toolchainResolved() {},
@@ -78,7 +84,7 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
     telemetry() {},
 
     runSummary(results, durationMs, regressionReport) {
-      sessionState.finish(results, durationMs, regressionReport);
+      applyReporterRunSummary(inspectState, results, durationMs, regressionReport);
     },
 
     error(message) {
@@ -93,19 +99,19 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
   };
 
   async function startInvestigation({ provider = "auto", userMessage } = {}) {
-    const snapshot = sessionState.getSnapshot();
+    const snapshot = inspectState.getSnapshot();
     if (!snapshot.selectedFailure) {
-      sessionState.setNotice("No failed file is selected for investigation.");
+      inspectState.setNotice("No failed file is selected for investigation.");
       return;
     }
     if (activeAgentSession) {
-      sessionState.setNotice("An investigation is already running.");
+      inspectState.setNotice("An investigation is already running.");
       return;
     }
 
     const token = ++investigationToken;
     let finalDelivered = false;
-    sessionState.beginInvestigation({ provider, userMessage });
+    inspectState.beginInvestigation({ provider, userMessage });
 
     try {
       activeInterpreter = createInvestigationInterpreter();
@@ -119,7 +125,7 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
           if (token !== investigationToken) return;
           if (event.type === "final") finalDelivered = true;
           const presentation = activeInterpreter?.consumeProviderEvent(event) || null;
-          sessionState.recordInvestigationProgress(event, presentation);
+          inspectState.recordInvestigationProgress(event, presentation);
         },
       });
       const result = await activeAgentSession.completion;
@@ -128,21 +134,21 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
       if (result.finalText && !finalDelivered) {
         const finalEvent = { type: "final", text: result.finalText };
         const presentation = activeInterpreter?.consumeProviderEvent(finalEvent) || null;
-        sessionState.recordInvestigationProgress(finalEvent, presentation);
+        inspectState.recordInvestigationProgress(finalEvent, presentation);
       }
       if (result.cancelled) {
-        sessionState.cancelAgentSession("Cancelled investigation.");
+        inspectState.cancelAgentSession("Cancelled investigation.");
         persistInvestigationLog();
         activeInterpreter = null;
         return;
       }
       if (result.exitCode !== 0 && !result.finalText) {
-        sessionState.failAgentSession(result.stderr || `Agent exited with code ${result.exitCode}`);
+        inspectState.failAgentSession(result.stderr || `Agent exited with code ${result.exitCode}`);
         persistInvestigationLog();
         activeInterpreter = null;
         return;
       }
-      sessionState.completeAgentSession({
+      inspectState.completeAgentSession({
         finalText: result.finalText,
         exitCode: result.exitCode,
       });
@@ -151,7 +157,7 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
     } catch (error) {
       if (token !== investigationToken) return;
       activeAgentSession = null;
-      sessionState.failAgentSession(error);
+      inspectState.failAgentSession(error);
       persistInvestigationLog();
       activeInterpreter = null;
     }
@@ -159,13 +165,13 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
 
   function cancelInvestigation() {
     if (!activeAgentSession) {
-      sessionState.returnToSummary();
+      inspectState.returnToSummary();
       return;
     }
     investigationToken += 1;
     activeAgentSession.cancel();
     activeAgentSession = null;
-    sessionState.cancelAgentSession("Cancelled investigation.");
+    inspectState.cancelAgentSession("Cancelled investigation.");
     persistInvestigationLog();
     activeInterpreter = null;
   }
@@ -180,7 +186,7 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
   }
 
   function persistInvestigationLog() {
-    const snapshot = sessionState.getSnapshot();
+    const snapshot = inspectState.getSnapshot();
     if (!snapshot.selectedFailure || !snapshot.agentSession) return;
     writeInvestigationLog({
       productDir,

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

@@ -0,0 +1,131 @@
+import React, { createElement, useEffect, useMemo, useState } from "react";
+import { Box, Text, useAnimation, useApp, useInput } from "ink";
+import { bold, dim, yellow } from "../presentation/colors.mjs";
+import { getTerminalWidth } from "../presentation/terminal-layout.mjs";
+import { buildInspectPaneContent } from "./detail-pane.mjs";
+
+const SPINNER_FRAMES = ["|", "/", "-", "\\"];
+
+export function AssistantApp({ assistantState, stdout, productDir } = {}) {
+  const { exit } = useApp();
+  const [snapshot, setSnapshot] = useState(() => assistantState.getSnapshot());
+  const { frame } = useAnimation({ interval: 80, isActive: snapshot.busy });
+
+  useEffect(() => {
+    const unsubscribe = assistantState.subscribe(() => {
+      setSnapshot(assistantState.getSnapshot());
+    });
+    return unsubscribe;
+  }, [assistantState]);
+
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (input === "q" && !snapshot.composer) {
+      exit();
+      return;
+    }
+    if (key.return) {
+      void assistantState.submitCurrentComposer();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      assistantState.backspaceComposer();
+      return;
+    }
+    if (key.tab) {
+      const panes = ["detail", "artifacts", "logs", "setup"];
+      const index = panes.indexOf(snapshot.workbench.paneMode || "detail");
+      assistantState.setPaneMode(panes[(index + 1) % panes.length]);
+      return;
+    }
+    if (isPrintableInput(input, key)) {
+      assistantState.appendComposer(input);
+    }
+  });
+
+  const terminalWidth = getTerminalWidth(stdout, 100);
+  const transcriptWidth = Math.max(54, Math.floor(terminalWidth * 0.58));
+  const contextWidth = Math.max(26, terminalWidth - transcriptWidth - 1);
+  const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+  const contextPane = useMemo(
+    () =>
+      buildInspectPaneContent({
+        productDir,
+        snapshot: snapshot.workbench,
+        paneMode: snapshot.workbench.paneMode,
+        logTail: 12,
+      }),
+    [productDir, snapshot.workbench]
+  );
+
+  return createElement(
+    Box,
+    { flexDirection: "column" },
+    createElement(Text, null, dim(buildHeader(snapshot, spinner))),
+    snapshot.notice ? createElement(Text, null, yellow(snapshot.notice)) : null,
+    createElement(
+      Box,
+      { flexDirection: "row", marginTop: 1 },
+      createElement(
+        Box,
+        { width: transcriptWidth, flexDirection: "column", paddingRight: 1 },
+        ...buildTranscriptLines(snapshot).map((line, index) => createElement(Text, { key: `line-${index}` }, line))
+      ),
+      createElement(
+        Box,
+        { width: contextWidth, flexDirection: "column", paddingLeft: 1 },
+        createElement(Text, null, bold(contextPane.title)),
+        createElement(Text, null, ""),
+        ...contextPane.lines.slice(0, 34).map((line, index) => createElement(Text, { key: `pane-${index}` }, line))
+      )
+    ),
+    createElement(Text, null, ""),
+    createElement(Text, null, dim("Enter send · Tab cycle pane · q quit")),
+    createElement(Text, null, bold("> "), snapshot.composer || dim("Ask testkit or use /run, /file, /discover, /status"))
+  );
+}
+
+function buildHeader(snapshot, spinner) {
+  const workbench = snapshot.workbench;
+  const status = snapshot.busy ? `${spinner} ${snapshot.activeStatus || "working"}` : "ready";
+  const selection = workbench.selectedEntry?.label || workbench.selectedEntry?.filePath || "no selection";
+  return [`testkit assistant`, `provider ${snapshot.provider}`, status, selection].join(" · ");
+}
+
+function buildTranscriptLines(snapshot) {
+  const lines = [];
+  for (const message of snapshot.messages.slice(-28)) {
+    const prefix = rolePrefix(message.role, message.toolName);
+    const messageLines = String(message.text || "").split(/\r?\n/);
+    for (const [index, line] of messageLines.entries()) {
+      lines.push(index === 0 ? `${prefix}${line}` : `  ${line}`);
+    }
+    lines.push("");
+  }
+  if (snapshot.busy && snapshot.messages.length === 0) {
+    lines.push("assistant is starting...");
+  }
+  return lines.slice(-40);
+}
+
+function rolePrefix(role, toolName) {
+  if (role === "user") return "you> ";
+  if (role === "assistant") return "tk> ";
+  if (role === "tool") return `${toolName || "tool"}> `;
+  return "sys> ";
+}
+
+function isPrintableInput(input, key) {
+  return Boolean(
+    input &&
+      input.length === 1 &&
+      !key.ctrl &&
+      !key.meta &&
+      !key.return &&
+      !key.escape &&
+      !key.tab
+  );
+}

package/lib/cli/tui/detail-pane.mjs

@@ -0,0 +1,161 @@
+import path from "path";
+import {
+  collectArtifactEntries,
+  formatArtifactPreview,
+  formatFileDetail,
+  getServiceLogRefs,
+  getSetupOperationsForService,
+  loadCurrentRunArtifact,
+  resolveFileSubject,
+} from "../viewer.mjs";
+import { formatDuration } from "../../runner/formatting.mjs";
+import { readLogTail } from "../../runner/logs.mjs";
+
+export function buildInspectPaneContent({ productDir, snapshot, paneMode = "detail", logTail = 12 } = {}) {
+  const selectedEntry = snapshot.selectedEntry || null;
+  if (!selectedEntry) {
+    return { title: "Selection", lines: ["No entry selected."], data: null };
+  }
+
+  const runArtifact = resolveArtifact(productDir, snapshot);
+  const subject = resolveSubject(runArtifact, selectedEntry);
+
+  if (paneMode === "artifacts") {
+    return buildArtifactsPane(productDir, runArtifact, selectedEntry, subject);
+  }
+  if (paneMode === "logs") {
+    return buildLogsPane(productDir, runArtifact, selectedEntry, logTail);
+  }
+  if (paneMode === "setup") {
+    return buildSetupPane(productDir, runArtifact, selectedEntry);
+  }
+  return buildDetailPane(productDir, runArtifact, selectedEntry, subject, logTail);
+}
+
+function buildDetailPane(productDir, runArtifact, entry, subject, logTail) {
+  if (subject && runArtifact) {
+    return {
+      title: "Detail",
+      lines: formatFileDetail(productDir, runArtifact, subject, { logTail }),
+      data: subject,
+    };
+  }
+
+  return {
+    title: "Detail",
+    lines: formatAggregateDetail(entry),
+    data: entry,
+  };
+}
+
+function buildArtifactsPane(productDir, runArtifact, entry, subject) {
+  if (!runArtifact || !subject) {
+    return {
+      title: "Artifacts",
+      lines: ["Artifacts are available for file selections from a persisted run artifact."],
+      data: [],
+    };
+  }
+
+  const entries = collectArtifactEntries(productDir, runArtifact, subject.file.path, subject.service.name).map((item) => ({
+    service: item.service.name,
+    suite: `${item.suite.type}:${item.suite.name}`,
+    file: item.file.path,
+    name: item.artifactRef.name,
+    kind: item.artifactRef.kind,
+    summary: item.artifactRef.summary,
+    path: item.artifactRef.path,
+    preview: formatArtifactPreview(item.payload, 6),
+  }));
+
+  if (entries.length === 0) {
+    return { title: "Artifacts", lines: ["No artifacts were persisted for the selected file."], data: [] };
+  }
+
+  const lines = [];
+  for (const item of entries) {
+    lines.push(`${item.name}${item.kind ? ` [${item.kind}]` : ""}`);
+    if (item.summary) lines.push(`  ${item.summary}`);
+    for (const line of item.preview) lines.push(`  ${line}`);
+    lines.push(`  ${item.path}`);
+  }
+  return { title: "Artifacts", lines, data: entries };
+}
+
+function buildLogsPane(productDir, runArtifact, entry, tail) {
+  if (!runArtifact) {
+    return { title: "Logs", lines: ["Backend logs are available only from persisted run artifacts."], data: [] };
+  }
+  const serviceName = entry.serviceName;
+  const logs = getServiceLogRefs(runArtifact, serviceName).map((item) => ({
+    ...item,
+    lines: readLogTail(path.join(productDir, item.path), tail),
+  }));
+  if (logs.length === 0) {
+    return { title: "Logs", lines: ["No backend logs were recorded for the selected service."], data: [] };
+  }
+  const lines = [];
+  for (const item of logs) {
+    lines.push(item.runtimeLabel);
+    lines.push(`  ${item.path}`);
+    for (const line of item.lines) lines.push(`  ${line}`);
+  }
+  return { title: "Logs", lines, data: logs };
+}
+
+function buildSetupPane(productDir, runArtifact, entry) {
+  if (!runArtifact) {
+    return { title: "Setup", lines: ["Setup operations are available only from persisted run artifacts."], data: [] };
+  }
+  const operations = getSetupOperationsForService(runArtifact, entry.serviceName);
+  if (operations.length === 0) {
+    return { title: "Setup", lines: ["No setup operations were recorded for the selected service."], data: [] };
+  }
+  const lines = [];
+  for (const operation of operations) {
+    const duration = operation.durationMs == null ? "" : ` ${formatDuration(operation.durationMs)}`;
+    const summary = operation.summary ? ` ${operation.summary}` : "";
+    lines.push(`${operation.status} ${operation.stage}${duration}${summary}`);
+    if (operation.error) lines.push(`  ${operation.error}`);
+    if (operation.logRef?.path) lines.push(`  ${operation.logRef.path}`);
+  }
+  return { title: "Setup", lines, data: operations };
+}
+
+function resolveArtifact(productDir, snapshot) {
+  if (snapshot.runArtifact) return snapshot.runArtifact;
+  try {
+    return loadCurrentRunArtifact(productDir);
+  } catch {
+    return null;
+  }
+}
+
+function resolveSubject(runArtifact, entry) {
+  if (!runArtifact || !entry || entry.kind !== "file") return null;
+  try {
+    return resolveFileSubject(runArtifact, entry.filePath, entry.serviceName);
+  } catch {
+    return null;
+  }
+}
+
+function formatAggregateDetail(entry) {
+  const lines = [`Kind: ${entry.kind}`];
+  if (entry.serviceName) lines.push(`Service: ${entry.serviceName}`);
+  if (entry.type) lines.push(`Type: ${entry.type}`);
+  if (entry.suiteName) lines.push(`Suite: ${entry.suiteName}`);
+  if (entry.filePath) lines.push(`File: ${entry.filePath}`);
+  if (entry.status) lines.push(`Status: ${entry.status}`);
+  if (entry.summary) {
+    lines.push(
+      `Files: ${entry.summary.total} total · ${entry.summary.passed} passed · ${entry.summary.failed} failed · ${entry.summary.skipped} skipped · ${entry.summary.notRun} not run`
+    );
+    if (entry.summary.durationMs > 0) {
+      lines.push(`Duration: ${formatDuration(entry.summary.durationMs)}`);
+    }
+  }
+  if (entry.skipReason) lines.push(`Skip reason: ${entry.skipReason}`);
+  if (entry.error) lines.push(`Error: ${entry.error}`);
+  return lines;
+}

package/lib/cli/tui/filter-bar.mjs

@@ -0,0 +1,12 @@
+import React, { createElement } from "react";
+import { Text } from "ink";
+import { bold, dim } from "../presentation/colors.mjs";
+
+export function FilterBar({ filter } = {}) {
+  if (!filter?.active) return null;
+  return createElement(
+    Text,
+    null,
+    `${bold("/")}${filter.query}${dim(`  ${filter.count} ${filter.count === 1 ? "match" : "matches"}`)}`
+  );
+}