@elench/testkit 0.1.88 → 0.1.90

package/lib/cli/assistant/state.mjs

@@ -1,5 +1,6 @@
 import { loadCurrentRunArtifact, loadLatestRunArtifact } from "../viewer.mjs";
 import { createInspectState } from "../tui/inspect-state.mjs";
+import { buildContextSelection } from "../context-resources.mjs";
 import { parseSlashCommand, formatSlashHelpLines } from "./slash-commands.mjs";
 import { executeAssistantTool } from "./tool-registry.mjs";
 import { runAssistantConversationTurn } from "./session.mjs";
@@ -7,12 +8,11 @@ import { runAssistantConversationTurn } from "./session.mjs";
 export function createAssistantState({
   productDir,
   provider = "auto",
-  initialPane = "detail",
   dataSource = "artifact",
   configs = [],
+  env = process.env,
 } = {}) {
   const inspectState = createInspectState({ dataSource });
-  inspectState.setPaneMode(initialPane);
 
   const listeners = new Set();
   const messages = [];
@@ -69,10 +69,6 @@ export function createAssistantState({
       return inspectState.revealService(serviceName);
     },
 
-    setPaneMode(pane) {
-      inspectState.setPaneMode(pane);
-    },
-
     setComposer(value) {
       composer = String(value || "");
       notify();
@@ -165,6 +161,7 @@ export function createAssistantState({
           transcript: messages.map((entry) => ({ role: entry.role, text: entry.text })),
           userMessage: trimmed,
           provider: providerName,
+          env,
           configs,
           onStatus(status) {
             activeStatus = status;
@@ -189,7 +186,7 @@ export function createAssistantState({
 
     getSnapshot() {
       return {
-        workbench: inspectState.getSnapshot(),
+        context: buildContextSelection(inspectState.getSnapshot()),
         messages: [...messages],
         composer,
         notice,
@@ -237,6 +234,7 @@ async function executeSlashCommand({
   appendMessage({
     role: "tool",
     toolName: slash.type,
+    title: result.title || slash.type,
     text: result.text || result.title || "Done.",
     data: result.data || null,
   });
@@ -244,16 +242,20 @@ async function executeSlashCommand({
 
 async function executeSlashTool(slash, context) {
   switch (slash.type) {
-    case "pane":
-      return executeAssistantTool("set_pane", { pane: slash.pane }, context);
     case "file":
-      return executeAssistantTool("select_file", { file: slash.file }, context);
+      return executeAssistantTool("focus_file", { file: slash.file }, context);
     case "inspect":
       return slash.file
-        ? executeAssistantTool("select_file", { file: slash.file }, context)
-        : executeAssistantTool("inspect_selection", {}, context);
+        ? executeAssistantTool("focus_file", { file: slash.file }, context)
+        : executeAssistantTool("inspect_focus", {}, context);
+    case "logs":
+      return executeAssistantTool("read_logs", { service: slash.service || null }, context);
+    case "artifacts":
+      return executeAssistantTool("read_artifacts", { file: slash.file || null }, context);
+    case "setup":
+      return executeAssistantTool("read_setup", { service: slash.service || null }, context);
     case "service":
-      return executeAssistantTool("select_service", { service: slash.service }, context);
+      return executeAssistantTool("focus_service", { service: slash.service }, context);
     case "status":
       return executeAssistantTool("show_status", {}, context);
     case "discover":

package/lib/cli/assistant/tool-registry.mjs

@@ -4,7 +4,10 @@ import { resolveProductDir } from "../../config/index.mjs";
 import { resolveRequestedFiles } from "../args.mjs";
 import { buildDiscoveryReportLines } from "../presentation/discovery-reporter.mjs";
 import { loadCurrentRunArtifact, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
-import { buildInspectPaneContent } from "../tui/detail-pane.mjs";
+import {
+  formatContextToolText,
+  readContextContent,
+} from "../context-resources.mjs";
 import { createAssistantRunReporter } from "./tool-run-reporter.mjs";
 import { buildRunRequest } from "../command-helpers.mjs";
 import * as runner from "../../runner/index.mjs";
@@ -12,10 +15,12 @@ import * as runner from "../../runner/index.mjs";
 export function listAssistantTools() {
   return [
     { name: "run_tests", description: "Run testkit-managed tests with optional type/service/file filters." },
-    { name: "select_file", description: "Focus a specific test file in the workbench." },
-    { name: "select_service", description: "Focus a specific service in the workbench." },
-    { name: "set_pane", description: "Switch the workbench pane: detail, artifacts, logs, or setup." },
-    { name: "inspect_selection", description: "Render the current selection in the active pane." },
+    { name: "focus_file", description: "Focus a specific test file and summarize it." },
+    { name: "focus_service", description: "Focus a specific service and summarize it." },
+    { name: "inspect_focus", description: "Inspect the current focus inline in the conversation." },
+    { name: "read_logs", description: "Read backend logs for the current focus or an explicit service." },
+    { name: "read_artifacts", description: "Read persisted artifacts for the current focus or an explicit file." },
+    { name: "read_setup", description: "Read setup operations for the current focus or an explicit service." },
     { name: "discover_tests", description: "Discover managed tests and summarize them." },
     { name: "show_status", description: "Show the current local testkit state for the product." },
     { name: "run_doctor", description: "Run built-in testkit doctor checks." },
@@ -27,14 +32,18 @@ export async function executeAssistantTool(name, argumentsObject, context) {
   switch (name) {
     case "run_tests":
       return runTestsTool(args, context);
-    case "select_file":
-      return selectFileTool(args, context);
-    case "select_service":
-      return selectServiceTool(args, context);
-    case "set_pane":
-      return setPaneTool(args, context);
-    case "inspect_selection":
-      return inspectSelectionTool(args, context);
+    case "focus_file":
+      return focusFileTool(args, context);
+    case "focus_service":
+      return focusServiceTool(args, context);
+    case "inspect_focus":
+      return inspectFocusTool(args, context);
+    case "read_logs":
+      return readLogsTool(args, context);
+    case "read_artifacts":
+      return readArtifactsTool(args, context);
+    case "read_setup":
+      return readSetupTool(args, context);
     case "discover_tests":
       return discoverTestsTool(args, context);
     case "show_status":
@@ -101,50 +110,120 @@ async function runTestsTool(args, context) {
   }
 }
 
-function selectFileTool(args, context) {
+function focusFileTool(args, context) {
   const file = args.file || args.path || null;
-  if (!file) throw new Error("select_file requires a file argument");
+  if (!file) throw new Error("focus_file requires a file argument");
   ensureArtifactLoaded(context);
   const artifact = context.inspectState.getSnapshot().runArtifact;
   const subject = resolveFileSubject(artifact, file, args.service || null);
   context.inspectState.revealFile(subject.service.name, subject.file.path);
-  return inspectSelectionTool({}, context);
+  return inspectFocusTool({}, context);
 }
 
-function selectServiceTool(args, context) {
+function focusServiceTool(args, context) {
   const service = args.service || args.name || null;
-  if (!service) throw new Error("select_service requires a service argument");
+  if (!service) throw new Error("focus_service requires a service argument");
   ensureArtifactLoaded(context);
   if (!context.inspectState.revealService(service)) {
     throw new Error(`Unknown service "${service}"`);
   }
-  return inspectSelectionTool({}, context);
+  return inspectFocusTool({}, context);
 }
 
-function setPaneTool(args, context) {
-  const pane = args.pane || "detail";
-  context.inspectState.setPaneMode(pane);
-  return inspectSelectionTool({}, context);
+function inspectFocusTool(_args, context) {
+  const content = readContextContent({
+    productDir: context.productDir,
+    snapshot: context.inspectState.getSnapshot(),
+    mode: "detail",
+    logTail: 12,
+  });
+  return {
+    ok: true,
+    title: content.title,
+    text: formatContextToolText(content.title, content.lines),
+    data: {
+      title: content.title,
+      lines: content.lines,
+      selection: content.selection,
+      mode: "detail",
+    },
+  };
 }
 
-function inspectSelectionTool(_args, context) {
-  ensureArtifactLoaded(context);
-  const snapshot = context.inspectState.getSnapshot();
-  const pane = buildInspectPaneContent({
+function readLogsTool(args, context) {
+  if (args.service) {
+    ensureArtifactLoaded(context);
+    if (!context.inspectState.revealService(args.service)) {
+      throw new Error(`Unknown service "${args.service}"`);
+    }
+  }
+  const content = readContextContent({
+    productDir: context.productDir,
+    snapshot: context.inspectState.getSnapshot(),
+    mode: "logs",
+    logTail: args.logTail == null ? 12 : Number(args.logTail),
+  });
+  return {
+    ok: true,
+    title: content.title,
+    text: formatContextToolText(content.title, content.lines),
+    data: {
+      title: content.title,
+      lines: content.lines,
+      selection: content.selection,
+      mode: "logs",
+    },
+  };
+}
+
+function readArtifactsTool(args, context) {
+  if (args.file || args.path) {
+    ensureArtifactLoaded(context);
+    const artifact = context.inspectState.getSnapshot().runArtifact;
+    const subject = resolveFileSubject(artifact, args.file || args.path, args.service || null);
+    context.inspectState.revealFile(subject.service.name, subject.file.path);
+  }
+  const content = readContextContent({
     productDir: context.productDir,
-    snapshot,
-    paneMode: snapshot.paneMode,
+    snapshot: context.inspectState.getSnapshot(),
+    mode: "artifacts",
     logTail: 12,
   });
   return {
     ok: true,
-    title: pane.title,
-    text: pane.lines.join("\n"),
+    title: content.title,
+    text: formatContextToolText(content.title, content.lines),
     data: {
-      title: pane.title,
-      lines: pane.lines,
-      selection: snapshot.selectedEntry,
-      paneMode: snapshot.paneMode,
+      title: content.title,
+      lines: content.lines,
+      selection: content.selection,
+      mode: "artifacts",
+    },
+  };
+}
+
+function readSetupTool(args, context) {
+  if (args.service) {
+    ensureArtifactLoaded(context);
+    if (!context.inspectState.revealService(args.service)) {
+      throw new Error(`Unknown service "${args.service}"`);
+    }
+  }
+  const content = readContextContent({
+    productDir: context.productDir,
+    snapshot: context.inspectState.getSnapshot(),
+    mode: "setup",
+    logTail: 12,
+  });
+  return {
+    ok: true,
+    title: content.title,
+    text: formatContextToolText(content.title, content.lines),
+    data: {
+      title: content.title,
+      lines: content.lines,
+      selection: content.selection,
+      mode: "setup",
     },
   };
 }
@@ -176,7 +255,7 @@ function showStatusTool(_args, context) {
   return {
     ok: true,
     title: "Status",
-    text: lines.join("\n"),
+    text: formatContextToolText("Status", lines),
     data: { lines },
   };
 }
@@ -193,7 +272,7 @@ async function runDoctorTool(args, context) {
   return {
     ok: result.ok,
     title: "Doctor",
-    text: lines.join("\n"),
+    text: formatContextToolText("Doctor", lines),
     data: result,
   };
 }

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;
 
@@ -17,14 +15,12 @@ export default class AssistantCommand extends Command {
       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",
     }),
+    prompt: Flags.string({
+      description: "Initial interactive prompt for the provider session",
+    }),
     message: Flags.string({
       description: "Run one assistant turn non-interactively",
     }),
@@ -32,30 +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,
-      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 || 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);
       }
@@ -68,17 +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,
-        productDir,
-      }),
-      { 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,11 +36,13 @@ export function normalizeCliArgs(argv) {
     "--log-tail",
     "--provider",
     "--message",
-    "--pane",
+    "--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",
@@ -66,7 +68,7 @@ export function normalizeCliArgs(argv) {
     runFlagPresent ||
     !topLevelCommands.has(firstPositional?.value);
 
-  if (!firstPositional && interactiveTty && !runFlagPresent) {
+  if (!firstPositional && interactiveTty && !runFlagPresent && !assistantDefaultDisabled) {
     return ["assistant", ...argv];
   }
 
@@ -74,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) {