@elench/testkit 0.1.97 → 0.1.99

package/lib/cli/assistant/composer.mjs

@@ -1,4 +1,4 @@
-import { measureWidth } from "../presentation/terminal-layout.mjs";
+import { measureWidth } from "../terminal/layout.mjs";
 
 const segmenter =
   typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"

package/lib/cli/assistant/context-pack.mjs

@@ -1,15 +1,26 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { readContextContent, buildContextSelection } from "../context-resources.mjs";
+import { readContextContent, buildContextSelection } from "../../results/context.mjs";
+import {
+  ASSISTANT_COMMAND_ID_ENV,
+  ASSISTANT_COMMAND_LOG_ENV,
+  ASSISTANT_RESULT_DIR_ENV,
+  ASSISTANT_SESSION_ENV,
+  ASSISTANT_WRAPPER_LOGGED_ENV,
+} from "./command-results.mjs";
 
 export function prepareAssistantContextPack({
   productDir,
-  inspectState,
+  runState,
 } = {}) {
   const contextDir = path.join(productDir, ".testkit", "assistant");
   const binDir = path.join(contextDir, "bin");
+  const resultDir = path.join(contextDir, "command-results");
+  const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
   fs.mkdirSync(binDir, { recursive: true });
+  fs.rmSync(resultDir, { recursive: true, force: true });
+  fs.mkdirSync(resultDir, { recursive: true });
 
   const commandLogPath = path.join(contextDir, "commands.jsonl");
   const contextPath = path.join(contextDir, "context.md");
@@ -23,7 +34,7 @@ export function prepareAssistantContextPack({
   const wrapperPath = path.join(binDir, "testkit");
 
   function refresh() {
-    const snapshot = inspectState?.getSnapshot?.() || {};
+    const snapshot = runState?.getSnapshot?.() || {};
     const detailContent = readContextContent({ productDir, snapshot, mode: "detail", logTail: 12 });
     const logsContent = readContextContent({ productDir, snapshot, mode: "logs", logTail: 12 });
     const artifactsContent = readContextContent({ productDir, snapshot, mode: "artifacts", logTail: 12 });
@@ -55,7 +66,7 @@ export function prepareAssistantContextPack({
       }),
       "utf8"
     );
-    fs.writeFileSync(wrapperPath, buildWrapperScript({ cliPath: resolveCliPath() }), {
+    fs.writeFileSync(wrapperPath, buildWrapperScript({ cliPath: resolveCliPath(), sessionId, resultDir, commandLogPath }), {
       encoding: "utf8",
       mode: 0o755,
     });
@@ -71,12 +82,23 @@ export function prepareAssistantContextPack({
     selectionPath,
     commandsPath,
     commandLogPath,
+    resultDir,
+    sessionId,
     focusedDetailPath,
     focusedLogsPath,
     focusedArtifactsPath,
     focusedSetupPath,
     binDir,
     wrapperPath,
+    providerEnv(baseEnv = process.env) {
+      return {
+        ...baseEnv,
+        PATH: [binDir, baseEnv?.PATH, process.env.PATH].filter(Boolean).join(path.delimiter),
+        [ASSISTANT_SESSION_ENV]: sessionId,
+        [ASSISTANT_RESULT_DIR_ENV]: resultDir,
+        [ASSISTANT_COMMAND_LOG_ENV]: commandLogPath,
+      };
+    },
     refresh,
     appendCommandLog(event) {
       if (!event || typeof event !== "object") return;
@@ -97,15 +119,36 @@ function resolveCliPath() {
   return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "bin", "testkit.mjs");
 }
 
-function buildWrapperScript({ cliPath } = {}) {
+function buildWrapperScript({ cliPath, sessionId, resultDir, commandLogPath } = {}) {
   return `#!/usr/bin/env node
 import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
+const commandId = process.env.${ASSISTANT_COMMAND_ID_ENV} || \`cmd-\${Date.now()}-\${Math.random().toString(36).slice(2, 10)}\`;
+const commandLogPath = process.env.${ASSISTANT_COMMAND_LOG_ENV} || ${JSON.stringify(commandLogPath)};
+const sessionId = process.env.${ASSISTANT_SESSION_ENV} || ${JSON.stringify(sessionId)};
+const argv = process.argv.slice(2);
+
+appendCommandLog({
+  type: "command_start",
+  commandId,
+  command: "testkit",
+  kind: inferKind(argv),
+  argv,
+  cwd: process.cwd(),
+});
 
 const result = spawnSync(process.execPath, [${JSON.stringify(cliPath)}, ...process.argv.slice(2)], {
   cwd: process.cwd(),
   env: {
     ...process.env,
     TESTKIT_NO_ASSISTANT_DEFAULT: "1",
+    ${ASSISTANT_SESSION_ENV}: sessionId,
+    ${ASSISTANT_RESULT_DIR_ENV}: process.env.${ASSISTANT_RESULT_DIR_ENV} || ${JSON.stringify(resultDir)},
+    ${ASSISTANT_COMMAND_LOG_ENV}: commandLogPath,
+    ${ASSISTANT_COMMAND_ID_ENV}: commandId,
+    ${ASSISTANT_WRAPPER_LOGGED_ENV}: "1",
   },
   stdio: "inherit",
 });
@@ -113,7 +156,30 @@ const result = spawnSync(process.execPath, [${JSON.stringify(cliPath)}, ...proce
 if (result.error) {
   throw result.error;
 }
+appendCommandLog({
+  type: "command_exit",
+  commandId,
+  command: "testkit",
+  kind: inferKind(argv),
+  argv,
+  cwd: process.cwd(),
+  code: result.status ?? 0,
+  signal: result.signal ?? null,
+});
 process.exit(result.status ?? 0);
+
+function appendCommandLog(event) {
+  try {
+    fs.mkdirSync(path.dirname(commandLogPath), { recursive: true });
+    fs.appendFileSync(commandLogPath, \`\${JSON.stringify({ timestamp: new Date().toISOString(), sessionId, ...event })}\\n\`, "utf8");
+  } catch {
+    // Command observation must not affect command execution.
+  }
+}
+
+function inferKind(args) {
+  return args.find((arg) => !String(arg).startsWith("-")) || "run";
+}
 `;
 }
 
@@ -160,7 +226,8 @@ function buildContextMarkdown(productDir, snapshot, paths) {
   lines.push(
     "",
     "## Guidance",
-    "- Use shell commands like `npm run testkit`, `npx testkit`, or `testkit run <type> --dir .` when you need to execute tests.",
+    "- Work normally in the repository and run real commands. Testkit observes recognized Testkit commands and renders them in the assistant UI.",
+    "- Prefer `testkit ...` commands when using Testkit directly; `npx testkit ...` and project scripts are also valid.",
     "- Do not reinterpret CLI syntax after an execution failure unless `testkit run --help` confirms a syntax problem.",
     "- Use the command log and focused context files before rereading artifacts manually.",
     "- Prefer repo-local commands over guessing project-specific wrappers.",

package/lib/cli/assistant/interactive.mjs

@@ -2,7 +2,7 @@ import React, { createElement } from "react";
 import { render } from "ink";
 import { createAssistantState } from "./state.mjs";
 import { AssistantApp } from "./app.mjs";
-import { loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { loadLatestRunArtifact, resolveFileSubject } from "../../results/artifacts.mjs";
 
 export async function runInteractiveAssistant({
   productDir,

package/lib/cli/assistant/prompt-builder.mjs

@@ -1,12 +1,11 @@
-import { readContextContent } from "../context-resources.mjs";
-import { buildAssistantResponseContract } from "./protocol.mjs";
+import { readContextContent } from "../../results/context.mjs";
 
 export function buildAssistantPrompt({
   productDir,
   snapshot,
   transcript = [],
-  tools = [],
   userMessage,
+  commandLog = null,
 } = {}) {
   const selectionSummary = buildSelectionSummary(snapshot);
   const focusPreview = buildFocusPreview(productDir, snapshot);
@@ -14,11 +13,19 @@ export function buildAssistantPrompt({
 
   return [
     "You are Testkit Assistant.",
-    "You help users run tests, inspect failures, read logs and artifacts, and navigate the current local test state.",
-    "All user natural-language requests must be handled through your own reasoning plus the available tools.",
-    "Prefer real repository commands through shell_exec when the user asks to run tests or inspect the working repo.",
-    "Use read_context before repeating artifact/log inspection work, and use read_file/search_repo when you need codebase context.",
-    buildAssistantResponseContract({ tools }),
+    "You are running as a coding agent inside the user's repository.",
+    "Work normally: inspect files, edit files, run real shell commands, and iterate until the user's request is handled.",
+    "When using Testkit, run real commands such as `testkit discover`, `testkit run int`, `npx testkit run int`, or the repository's package scripts.",
+    "Testkit observes recognized Testkit commands and renders rich assistant UI from the real command output, sidecars, and artifacts.",
+    "Do not respond with a JSON tool envelope. Give the user a normal final answer when you are done.",
+    "",
+    "Assistant context files:",
+    ...(commandLog ? [
+      `- Context: ${commandLog.contextPath}`,
+      `- Command reference: ${commandLog.commandsPath}`,
+      `- Command log: ${commandLog.commandLogPath}`,
+      `- Current selection: ${commandLog.selectionPath}`,
+    ] : ["- No assistant context pack is available."]),
     "",
     "Current run summary:",
     ...(summaryRows.length > 0 ? summaryRows.map(([label, value]) => `- ${label}: ${value}`) : ["- No run artifact is currently loaded."]),

package/lib/cli/{agents → assistant}/providers/claude.mjs

@@ -16,6 +16,7 @@ export function startClaudeHostedSession({
   model = null,
   effort = null,
   providerArgs = [],
+  env = process.env,
 } = {}) {
   const args = [
     "-p",
@@ -25,9 +26,6 @@ export function startClaudeHostedSession({
     "--include-partial-messages",
   ];
 
-  if (purpose === "assistant") {
-    args.push("--permission-mode", "plan");
-  }
   if (model) {
     args.push("--model", String(model));
   }
@@ -44,6 +42,7 @@ export function startClaudeHostedSession({
     stdout: "pipe",
     stderr: "pipe",
     reject: false,
+    env,
   });
 
   return createHostedSessionRunner({

package/lib/cli/{agents → assistant}/providers/codex.mjs

@@ -19,6 +19,7 @@ export function startCodexHostedSession({
   purpose = "assistant",
   model = null,
   providerArgs = [],
+  env = process.env,
 } = {}) {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-codex-"));
   const outputFile = path.join(tempDir, "final-message.txt");
@@ -28,7 +29,6 @@ export function startCodexHostedSession({
     model,
     providerArgs,
     prompt,
-    sandbox: process.env.TESTKIT_CODEX_SANDBOX,
   });
 
   const child = execa(command, args, {
@@ -37,6 +37,7 @@ export function startCodexHostedSession({
     stdout: "pipe",
     stderr: "pipe",
     reject: false,
+    env,
   });
 
   const session = createHostedSessionRunner({
@@ -64,18 +65,13 @@ export function startCodexHostedSession({
 
 export function buildCodexArgs({
   outputFile,
-  purpose = "assistant",
   model = null,
   providerArgs = [],
   prompt = "",
-  sandbox = null,
 } = {}) {
   const args = ["exec", "--json"];
   if (outputFile) args.push("-o", outputFile);
 
-  if (purpose === "assistant") {
-    args.push("-s", String(sandbox || "workspace-write"));
-  }
   if (model) {
     args.push("--model", String(model));
   }

package/lib/cli/{agents → assistant/providers}/index.mjs

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
-import { startClaudeHostedSession } from "./providers/claude.mjs";
-import { startCodexHostedSession } from "./providers/codex.mjs";
+import { startClaudeHostedSession } from "./claude.mjs";
+import { startCodexHostedSession } from "./codex.mjs";
 
 const PROVIDERS = ["codex", "claude"];
 
@@ -55,7 +55,7 @@ export function isProviderInstalled(provider, env = process.env) {
   return false;
 }
 
-export function startAgentSession({
+export function startProviderSession({
   provider = "auto",
   model = null,
   effort = null,
@@ -69,7 +69,7 @@ export function startAgentSession({
   const resolvedProvider = resolvePreferredProvider(provider, env);
   const command = resolveProviderBinary(resolvedProvider, env);
   if (resolvedProvider === "claude") {
-    return startClaudeHostedSession({ command, cwd, prompt, onEvent, purpose, model, effort, providerArgs });
+    return startClaudeHostedSession({ command, cwd, prompt, onEvent, purpose, model, effort, providerArgs, env });
   }
-  return startCodexHostedSession({ command, cwd, prompt, onEvent, purpose, model, providerArgs });
+  return startCodexHostedSession({ command, cwd, prompt, onEvent, purpose, model, providerArgs, env });
 }

package/lib/cli/assistant/session.mjs

@@ -1,11 +1,10 @@
-import { startAgentSession, resolvePreferredProvider } from "../agents/index.mjs";
+import { startProviderSession, resolvePreferredProvider } from "./providers/index.mjs";
 import { buildAssistantPrompt } from "./prompt-builder.mjs";
-import { listAssistantTools, executeAssistantTool } from "./tool-registry.mjs";
-import { parseAssistantEnvelope } from "./protocol.mjs";
+import { createAssistantCommandObserver } from "./command-observer.mjs";
 
 export async function runAssistantConversationTurn({
   productDir,
-  inspectState,
+  runState,
   transcript,
   userMessage,
   provider = "auto",
@@ -18,41 +17,37 @@ export async function runAssistantConversationTurn({
   onResolvedProvider,
   onPrompt,
 } = {}) {
-  const tools = listAssistantTools();
-  const toolContext = {
+  const observer = createAssistantCommandObserver({
     productDir,
-    inspectState,
-    configs,
-    env,
+    runState,
     commandLog,
     onEvent: onToolEvent,
-  };
+  });
 
-  let currentTranscript = [...(transcript || []), { role: "user", text: userMessage }];
-  const emitted = [];
+  const snapshot = runState.getSnapshot();
+  const prompt = buildAssistantPrompt({
+    productDir,
+    snapshot,
+    transcript: [...(transcript || []), { role: "user", text: userMessage }],
+    userMessage,
+    commandLog,
+  });
 
-  for (let attempt = 0; attempt < 6; attempt += 1) {
-    const snapshot = inspectState.getSnapshot();
-    const prompt = buildAssistantPrompt({
-      productDir,
-      snapshot,
-      transcript: currentTranscript,
-      tools,
-      userMessage,
-    });
+  const runtimeSettings = settings || { provider };
+  const resolvedProvider = resolvePreferredProvider(runtimeSettings.provider || provider, env);
+  const providerEnv = commandLog?.providerEnv?.(env) || env;
+  onResolvedProvider?.(resolvedProvider);
+  onPrompt?.({
+    prompt,
+    provider: resolvedProvider,
+    model: runtimeSettings.model || null,
+    effort: runtimeSettings.effort || null,
+  });
+  onStatus?.(`Thinking with ${resolvedProvider}...`);
 
-    const runtimeSettings = settings || { provider };
-    const resolvedProvider = resolvePreferredProvider(runtimeSettings.provider || provider, env);
-    onResolvedProvider?.(resolvedProvider);
-    onPrompt?.({
-      prompt,
-      provider: resolvedProvider,
-      model: runtimeSettings.model || null,
-      effort: runtimeSettings.effort || null,
-    });
-    onStatus?.(`Thinking with ${resolvedProvider}...`);
-    const events = [];
-    const session = startAgentSession({
+  observer.start();
+  try {
+    const session = startProviderSession({
       provider: runtimeSettings.provider || provider,
       model: runtimeSettings.model || null,
       effort: runtimeSettings.effort || null,
@@ -60,74 +55,21 @@ export async function runAssistantConversationTurn({
       cwd: productDir,
       prompt,
       purpose: "assistant",
-      env,
+      env: providerEnv,
       onEvent(event) {
-        events.push(event);
         if (event.type === "status" || event.type === "tool") onStatus?.(formatProviderEvent(event));
       },
     });
     const result = await session.completion;
-    const envelope = parseAssistantEnvelope(result.finalText || "");
-
-    if (envelope.type === "tool") {
-      if (envelope.commentary) {
-        emitted.push({ role: "assistant", text: envelope.commentary });
-        currentTranscript.push({ role: "assistant", text: envelope.commentary });
-      }
-      let toolResult;
-      try {
-        toolResult = await executeAssistantTool(envelope.tool, envelope.arguments, toolContext);
-      } catch (error) {
-        const toolText = formatToolError(envelope.tool, error);
-        emitted.push({
-          role: "tool",
-          text: toolText,
-          toolName: envelope.tool,
-          title: `${envelope.tool} error`,
-          data: { ok: false, error: toolText },
-        });
-        currentTranscript.push({
-          role: "tool",
-          text: `${envelope.tool}: ${toolText}`,
-        });
-        continue;
-      }
-      const toolText = toolResult.text || `${envelope.tool} completed`;
-      emitted.push({
-        role: "tool",
-        text: toolText,
-        toolName: envelope.tool,
-        title: toolResult.title || envelope.tool,
-        data: toolResult.data || null,
-      });
-      currentTranscript.push({
-        role: "tool",
-        text: `${envelope.tool}: ${toolText}`,
-      });
-      onToolEvent?.({ type: "tool-result", tool: envelope.tool, text: toolText });
-      continue;
-    }
-
-    emitted.push({
+    observer.scan();
+    commandLog?.refresh?.();
+    return [{
       role: "assistant",
-      text: envelope.message || result.finalText || "",
-    });
-    return emitted;
-  }
-
-  emitted.push({
-    role: "assistant",
-    text: "I hit the assistant tool-call limit before reaching a final answer.",
-  });
-  return emitted;
-}
-
-export function formatToolError(tool, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (tool === "shell_exec" && /command string/.test(message)) {
-    return "The assistant requested shell_exec without a command. Retry with arguments.command set to the exact shell command.";
+      text: result.finalText || "",
+    }];
+  } finally {
+    observer.stop();
   }
-  return `Tool failed: ${message}`;
 }
 
 function formatProviderEvent(event) {

package/lib/cli/assistant/slash-commands.mjs

@@ -1,6 +1,6 @@
-const RUN_TYPES = new Set(["int", "e2e", "scenario", "dal", "load", "pw", "all"]);
 import { ASSISTANT_EFFORTS, ASSISTANT_PROVIDERS } from "./settings.mjs";
 
+const RUN_TYPES = new Set(["int", "e2e", "scenario", "dal", "load", "pw", "all"]);
 const PROVIDERS = new Set(ASSISTANT_PROVIDERS);
 const EFFORTS = new Set(ASSISTANT_EFFORTS);
 
@@ -62,6 +62,17 @@ export function parseSlashCommand(input) {
     throw new Error('/settings expects "show" or "reset"');
   }
 
+  if (command === "config") {
+    const action = tokens[0] || "show";
+    if (action === "show") return { type: "config-show" };
+    if (action === "reset") return { type: "config-reset" };
+    if (action === "auto-collapse-passed" || action === "autoCollapsePassedTreeBranches") {
+      const value = parseBooleanToken(tokens[1], "/config auto-collapse-passed");
+      return { type: "config-set-auto-collapse", value };
+    }
+    throw new Error('/config expects "show", "reset", or "auto-collapse-passed <on|off>"');
+  }
+
   if (command === "file" || command === "focus") {
     if (!tokens[0]) throw new Error(`/${command} expects a file path`);
     return { type: "file", file: tokens.join(" ") };
@@ -134,11 +145,21 @@ export function formatSlashHelpLines() {
     "/provider-arg clear",
     "/settings",
     "/settings reset",
+    "/config",
+    "/config auto-collapse-passed <on|off>",
+    "/config reset",
     "/clear",
     "/quit",
   ];
 }
 
+function parseBooleanToken(value, commandName) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (["on", "true", "yes", "1"].includes(normalized)) return true;
+  if (["off", "false", "no", "0"].includes(normalized)) return false;
+  throw new Error(`${commandName} expects on or off`);
+}
+
 function parseRunCommandTokens(tokens) {
   const options = {
     type: [],