@elench/testkit 0.1.89 → 0.1.90

package/lib/cli/commands/assistant.mjs

@@ -1,12 +1,10 @@
-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";
+import { runInteractiveAssistant } from "../assistant/interactive.mjs";
 
 export default class AssistantCommand extends Command {
-  static summary = "Launch the interactive testkit assistant";
+  static summary = "Launch a native Codex or Claude session with testkit context";
 
   static enableJsonFlag = true;
 
@@ -20,6 +18,9 @@ export default class AssistantCommand extends Command {
     file: Flags.string({
       description: "Initial file selection",
     }),
+    prompt: Flags.string({
+      description: "Initial interactive prompt for the provider session",
+    }),
     message: Flags.string({
       description: "Run one assistant turn non-interactively",
     }),
@@ -27,29 +28,41 @@ export default class AssistantCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(AssistantCommand);
+    if (flags.message && flags.prompt) {
+      this.error("Use either --message or --prompt, not both.");
+    }
     const { allConfigs } = await resolveConfigsForCommand(flags);
     const productDir = allConfigs[0]?.productDir || process.cwd();
-    const assistantState = createAssistantState({
-      productDir,
-      provider: flags.provider,
-      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 || process.env.TESTKIT_FORCE_INTERACTIVE_ASSISTANT === "1") &&
+      !this.jsonEnabled() &&
+      !flags.message;
+    if (flags.prompt && !interactive) {
+      this.error("--prompt requires an interactive assistant session.");
     }
-
-    const interactive = process.stdout.isTTY && !this.jsonEnabled() && !flags.message;
     if (!interactive) {
+      if (!flags.message) {
+        this.error("assistant requires an interactive tty; use --message for one non-interactive turn.");
+      }
+      const assistantState = createAssistantState({
+        productDir,
+        provider: flags.provider,
+        configs: allConfigs,
+        env: process.env,
+      });
+      await assistantState.loadLatestArtifact();
+      if (flags.file) {
+        try {
+          const { loadLatestRunArtifact, resolveFileSubject } = await import("../viewer.mjs");
+          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);
+      }
       if (flags.message) {
         await assistantState.submitInput(flags.message);
       }
@@ -62,16 +75,13 @@ export default class AssistantCommand extends Command {
       return snapshot;
     }
 
-    const { AssistantApp } = await import("../tui/assistant-app.mjs");
-    const app = render(
-      createElement(AssistantApp, {
-        assistantState,
-        stdout: process.stdout,
-      }),
-      { stdout: process.stdout, exitOnCtrlC: false }
-    );
-
-    await app.waitUntilExit();
-    return assistantState.getSnapshot();
+    return runInteractiveAssistant({
+      productDir,
+      provider: flags.provider,
+      file: flags.file || null,
+      service: flags.service || null,
+      prompt: flags.prompt || null,
+      env: process.env,
+    });
   }
 }

package/lib/cli/{tui/detail-pane.mjs → context-resources.mjs}

@@ -7,32 +7,87 @@ import {
   getSetupOperationsForService,
   loadCurrentRunArtifact,
   resolveFileSubject,
-} from "../viewer.mjs";
-import { formatDuration } from "../../runner/formatting.mjs";
-import { readLogTail } from "../../runner/logs.mjs";
+} 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;
+export function readContextContent({
+  productDir,
+  snapshot,
+  mode = "detail",
+  logTail = 12,
+  previewLength = 6,
+} = {}) {
+  const normalizedMode = normalizeMode(mode);
+  const selectedEntry = snapshot?.selectedEntry || null;
+  const summaryRows = snapshot?.summaryData?.rows || [];
   if (!selectedEntry) {
-    return { title: "Selection", lines: ["No entry selected."], data: null };
+    return {
+      mode: normalizedMode,
+      title: "Selection",
+      lines: ["No entry selected."],
+      data: null,
+      selection: null,
+      summaryRows,
+    };
   }
 
   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);
+  let content = null;
+  if (normalizedMode === "artifacts") {
+    content = buildArtifactsContent(productDir, runArtifact, selectedEntry, subject, previewLength);
+  } else if (normalizedMode === "logs") {
+    content = buildLogsContent(productDir, runArtifact, selectedEntry, logTail);
+  } else if (normalizedMode === "setup") {
+    content = buildSetupContent(runArtifact, selectedEntry);
+  } else {
+    content = buildDetailContent(productDir, runArtifact, selectedEntry, subject, logTail);
   }
-  return buildDetailPane(productDir, runArtifact, selectedEntry, subject, logTail);
+
+  return {
+    mode: normalizedMode,
+    title: content.title,
+    lines: content.lines || [],
+    data: content.data ?? null,
+    selection: selectedEntry,
+    summaryRows,
+  };
 }
 
-function buildDetailPane(productDir, runArtifact, entry, subject, logTail) {
+export function buildContextSelection(snapshot) {
+  const selectedEntry = snapshot?.selectedEntry || null;
+  const summaryRows = snapshot?.summaryData?.rows || [];
+  return {
+    selection: selectedEntry
+      ? {
+          kind: selectedEntry.kind,
+          label: selectedEntry.label || selectedEntry.filePath || selectedEntry.serviceName || "selection",
+          serviceName: selectedEntry.serviceName || null,
+          type: selectedEntry.type || null,
+          suiteName: selectedEntry.suiteName || null,
+          filePath: selectedEntry.filePath || null,
+          status: selectedEntry.status || null,
+        }
+      : null,
+    summaryRows,
+    phase: snapshot?.phase || null,
+    hasArtifact: Boolean(snapshot?.runArtifact),
+  };
+}
+
+export function formatContextToolText(title, lines) {
+  const normalizedTitle = String(title || "").trim();
+  const normalizedLines = Array.isArray(lines) ? lines.filter((line) => String(line).length > 0) : [];
+  if (normalizedTitle && normalizedLines.length > 0) {
+    return [normalizedTitle, ...normalizedLines].join("\n");
+  }
+  if (normalizedTitle) return normalizedTitle;
+  return normalizedLines.join("\n");
+}
+
+function buildDetailContent(productDir, runArtifact, entry, subject, logTail) {
   if (subject && runArtifact) {
     return {
       title: "Detail",
@@ -48,7 +103,7 @@ function buildDetailPane(productDir, runArtifact, entry, subject, logTail) {
   };
 }
 
-function buildArtifactsPane(productDir, runArtifact, entry, subject) {
+function buildArtifactsContent(productDir, runArtifact, entry, subject, previewLength) {
   if (!runArtifact || !subject) {
     return {
       title: "Artifacts",
@@ -65,7 +120,7 @@ function buildArtifactsPane(productDir, runArtifact, entry, subject) {
     kind: item.artifactRef.kind,
     summary: item.artifactRef.summary,
     path: item.artifactRef.path,
-    preview: formatArtifactPreview(item.payload, 6),
+    preview: formatArtifactPreview(item.payload, previewLength),
   }));
 
   if (entries.length === 0) {
@@ -82,7 +137,7 @@ function buildArtifactsPane(productDir, runArtifact, entry, subject) {
   return { title: "Artifacts", lines, data: entries };
 }
 
-function buildLogsPane(productDir, runArtifact, entry, tail) {
+function buildLogsContent(productDir, runArtifact, entry, tail) {
   if (!runArtifact) {
     return { title: "Logs", lines: ["Backend logs are available only from persisted run artifacts."], data: [] };
   }
@@ -103,7 +158,7 @@ function buildLogsPane(productDir, runArtifact, entry, tail) {
   return { title: "Logs", lines, data: logs };
 }
 
-function buildSetupPane(productDir, runArtifact, entry) {
+function buildSetupContent(runArtifact, entry) {
   if (!runArtifact) {
     return { title: "Setup", lines: ["Setup operations are available only from persisted run artifacts."], data: [] };
   }
@@ -123,7 +178,7 @@ function buildSetupPane(productDir, runArtifact, entry) {
 }
 
 function resolveArtifact(productDir, snapshot) {
-  if (snapshot.runArtifact) return snapshot.runArtifact;
+  if (snapshot?.runArtifact) return snapshot.runArtifact;
   try {
     return loadCurrentRunArtifact(productDir);
   } catch {
@@ -159,3 +214,8 @@ function formatAggregateDetail(entry) {
   if (entry.error) lines.push(`Error: ${entry.error}`);
   return lines;
 }
+
+function normalizeMode(mode) {
+  if (mode === "logs" || mode === "artifacts" || mode === "setup") return mode;
+  return "detail";
+}

package/lib/cli/entrypoint.mjs

@@ -36,10 +36,13 @@ export function normalizeCliArgs(argv) {
     "--log-tail",
     "--provider",
     "--message",
+    "--prompt",
   ]);
   const positionals = findPositionals(argv, valueFlags);
   const firstPositional = positionals[0] || null;
-  const interactiveTty = process.stdout.isTTY;
+  const forcedInteractiveAssistant = process.env.TESTKIT_FORCE_INTERACTIVE_ASSISTANT === "1";
+  const interactiveTty = process.stdout.isTTY || forcedInteractiveAssistant;
+  const assistantDefaultDisabled = process.env.TESTKIT_NO_ASSISTANT_DEFAULT === "1";
   const runFlagPresent = argv.some((value) =>
     [
       "--type",
@@ -65,7 +68,7 @@ export function normalizeCliArgs(argv) {
     runFlagPresent ||
     !topLevelCommands.has(firstPositional?.value);
 
-  if (!firstPositional && interactiveTty && !runFlagPresent) {
+  if (!firstPositional && interactiveTty && !runFlagPresent && !assistantDefaultDisabled) {
     return ["assistant", ...argv];
   }
 
@@ -73,8 +76,13 @@ export function normalizeCliArgs(argv) {
     return reorderCommandArgs(argv, positionals);
   }
 
-  if (!topLevelCommands.has(firstPositional?.value) && interactiveTty && !runFlagPresent) {
-    return ["assistant", "--message", argv.join(" ")];
+  if (!topLevelCommands.has(firstPositional?.value) && interactiveTty && !assistantDefaultDisabled) {
+    const shouldOpenAssistantPrompt =
+      forcedInteractiveAssistant ||
+      (!runFlagPresent && !runTypeShortcuts.has(firstPositional?.value));
+    if (shouldOpenAssistantPrompt) {
+      return ["assistant", "--prompt", argv.join(" ")];
+    }
   }
 
   if (shouldPrefixRun) {

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

@@ -9,24 +9,16 @@ import {
   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 inspectState = createInspectState({ dataSource: "live" });
-  let activeAgentSession = null;
-  let activeInterpreter = null;
-  let investigationToken = 0;
 
   const app = render(
     createElement(InspectApp, {
       inspectState,
       stdout,
       productDir,
-      onInvestigate: startInvestigation,
       onRequestClose: close,
-      onCancelInvestigation: cancelInvestigation,
     }),
     { stdout, exitOnCtrlC: false }
   );
@@ -98,100 +90,7 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
     close,
   };
 
-  async function startInvestigation({ provider = "auto", userMessage } = {}) {
-    const snapshot = inspectState.getSnapshot();
-    if (!snapshot.selectedFailure) {
-      inspectState.setNotice("No failed file is selected for investigation.");
-      return;
-    }
-    if (activeAgentSession) {
-      inspectState.setNotice("An investigation is already running.");
-      return;
-    }
-
-    const token = ++investigationToken;
-    let finalDelivered = false;
-    inspectState.beginInvestigation({ provider, userMessage });
-
-    try {
-      activeInterpreter = createInvestigationInterpreter();
-      activeAgentSession = startHostedInvestigation({
-        productDir,
-        serviceName: snapshot.selectedFailure.serviceName,
-        filePath: snapshot.selectedFailure.filePath,
-        provider,
-        userMessage,
-        onEvent(event) {
-          if (token !== investigationToken) return;
-          if (event.type === "final") finalDelivered = true;
-          const presentation = activeInterpreter?.consumeProviderEvent(event) || null;
-          inspectState.recordInvestigationProgress(event, presentation);
-        },
-      });
-      const result = await activeAgentSession.completion;
-      if (token !== investigationToken) return;
-      activeAgentSession = null;
-      if (result.finalText && !finalDelivered) {
-        const finalEvent = { type: "final", text: result.finalText };
-        const presentation = activeInterpreter?.consumeProviderEvent(finalEvent) || null;
-        inspectState.recordInvestigationProgress(finalEvent, presentation);
-      }
-      if (result.cancelled) {
-        inspectState.cancelAgentSession("Cancelled investigation.");
-        persistInvestigationLog();
-        activeInterpreter = null;
-        return;
-      }
-      if (result.exitCode !== 0 && !result.finalText) {
-        inspectState.failAgentSession(result.stderr || `Agent exited with code ${result.exitCode}`);
-        persistInvestigationLog();
-        activeInterpreter = null;
-        return;
-      }
-      inspectState.completeAgentSession({
-        finalText: result.finalText,
-        exitCode: result.exitCode,
-      });
-      persistInvestigationLog();
-      activeInterpreter = null;
-    } catch (error) {
-      if (token !== investigationToken) return;
-      activeAgentSession = null;
-      inspectState.failAgentSession(error);
-      persistInvestigationLog();
-      activeInterpreter = null;
-    }
-  }
-
-  function cancelInvestigation() {
-    if (!activeAgentSession) {
-      inspectState.returnToSummary();
-      return;
-    }
-    investigationToken += 1;
-    activeAgentSession.cancel();
-    activeAgentSession = null;
-    inspectState.cancelAgentSession("Cancelled investigation.");
-    persistInvestigationLog();
-    activeInterpreter = null;
-  }
-
   function close() {
-    if (activeAgentSession) {
-      investigationToken += 1;
-      activeAgentSession.cancel();
-      activeAgentSession = null;
-    }
     app.unmount();
   }
-
-  function persistInvestigationLog() {
-    const snapshot = inspectState.getSnapshot();
-    if (!snapshot.selectedFailure || !snapshot.agentSession) return;
-    writeInvestigationLog({
-      productDir,
-      selectedFailure: snapshot.selectedFailure,
-      agentSession: snapshot.agentSession,
-    });
-  }
 }

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

@@ -13,9 +13,8 @@ import {
 } from "../presentation/colors.mjs";
 import { renderSummaryBox } from "../presentation/summary-box.mjs";
 import { getTerminalWidth } from "../presentation/terminal-layout.mjs";
-import { defaultInvestigationMessage } from "../agents/prompt-builder.mjs";
+import { readContextContent } from "../context-resources.mjs";
 import { applyHighlight } from "./fuzzy-match.mjs";
-import { buildInspectPaneContent } from "./detail-pane.mjs";
 import { FilterBar } from "./filter-bar.mjs";
 
 const SPINNER_FRAMES = ["|", "/", "-", "\\"];
@@ -24,9 +23,7 @@ export function InspectApp({
   inspectState,
   stdout,
   productDir,
-  onInvestigate,
   onRequestClose,
-  onCancelInvestigation,
 } = {}) {
   const { exit } = useApp();
   const [snapshot, setSnapshot] = useState(() => inspectState.getSnapshot());
@@ -41,25 +38,6 @@ export function InspectApp({
   }, [inspectState]);
 
   useInput((input, key) => {
-    if (snapshot.mode === "investigating") {
-      if (input === "q") {
-        (onRequestClose || exit)();
-        return;
-      }
-      if (input === "t") {
-        inspectState.toggleInvestigationViewMode();
-        return;
-      }
-      if (input === "x") {
-        onCancelInvestigation?.();
-        return;
-      }
-      if (input === "b" && snapshot.agentSession?.status !== "running" && snapshot.agentSession?.status !== "starting") {
-        inspectState.returnToSummary();
-      }
-      return;
-    }
-
     if (!snapshot.finished) {
       if (input === "q") {
         inspectState.setNotice("Run is still in progress. Wait for completion before closing.");
@@ -115,20 +93,6 @@ export function InspectApp({
       inspectState.cyclePaneMode();
       return;
     }
-    if ((input === "y" || input === "i") && snapshot.selectedFailure) {
-      onInvestigate?.({
-        provider: "auto",
-        userMessage: defaultInvestigationMessage(),
-      });
-      return;
-    }
-    if (input === "c" && snapshot.selectedFailure) {
-      onInvestigate?.({ provider: "claude", userMessage: defaultInvestigationMessage() });
-      return;
-    }
-    if (input === "o" && snapshot.selectedFailure) {
-      onInvestigate?.({ provider: "codex", userMessage: defaultInvestigationMessage() });
-    }
   });
 
   const terminalWidth = getTerminalWidth(stdout, 100);
@@ -140,13 +104,11 @@ export function InspectApp({
   );
   const paneContent = useMemo(
     () =>
-      snapshot.mode === "investigating"
-        ? { title: "Investigation", lines: buildInvestigationLines(snapshot) }
-        : buildInspectPaneContent({
-            productDir,
-            snapshot,
-            paneMode: snapshot.paneMode,
-          }),
+      readContextContent({
+        productDir,
+        snapshot,
+        mode: snapshot.paneMode,
+      }),
     [productDir, snapshot]
   );
   const summaryLines = snapshot.finished && snapshot.summaryData
@@ -188,55 +150,12 @@ export function buildHeaderText(snapshot) {
 }
 
 export function buildFooterText(snapshot) {
-  if (snapshot.mode === "investigating") {
-    if (snapshot.agentSession?.status === "running" || snapshot.agentSession?.status === "starting") {
-      return "t transcript · x cancel investigation · q quit";
-    }
-    return "t transcript · b back · q quit";
-  }
   if (!snapshot.finished) return "Run in progress";
   if (snapshot.filter.active) {
     return "type to filter · ↑/↓ move · Esc clear filter · q quit";
   }
   const inspectKeys = "↑/↓ move · Enter collapse/expand · Tab cycle pane · / filter";
-  if (!snapshot.selectedFailure) return `${inspectKeys} · q quit`;
-  return `${inspectKeys} · y investigate · c Claude · o Codex · q quit`;
-}
-
-export function formatAgentEntry(entry) {
-  if (!entry) return "";
-  if (entry.kind === "status") return `[status] ${entry.text}`;
-  if (entry.kind === "tool") return `[tool] ${entry.text}`;
-  if (entry.kind === "error") return `[error] ${entry.text}`;
-  return entry.text;
-}
-
-export function formatTimelineEntry(entry) {
-  if (!entry) return "";
-  if (entry.kind === "result") return entry.summary || "";
-  if (entry.kind === "notice") return `${entry.severity || "info"}: ${entry.message}`;
-  return entry.message || entry.summary || "";
-}
-
-function buildInvestigationLines(snapshot) {
-  const transcriptEntries = snapshot.agentSession?.transcriptEntries || [];
-  const timeline = snapshot.agentSession?.timeline || [];
-  const viewMode = snapshot.agentSession?.viewMode || "summary";
-  const status = snapshot.agentSession?.status || "idle";
-  const lines = [
-    `Status: ${status}`,
-    `Phase: ${snapshot.agentSession?.activePhase || "planning"}`,
-    "",
-  ];
-  if (viewMode === "transcript") {
-    for (const entry of transcriptEntries.slice(-28)) lines.push(formatAgentEntry(entry));
-    return lines;
-  }
-  for (const entry of timeline.slice(-16)) lines.push(formatTimelineEntry(entry));
-  if (timeline.length === 0 && snapshot.agentSession?.finalText) {
-    lines.push(snapshot.agentSession.finalText);
-  }
-  return lines;
+  return `${inspectKeys} · q quit`;
 }
 
 function buildTreeViewport(entries, selectedEntryId, radius) {