@elench/testkit 0.1.89 → 0.1.91

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

@@ -1,280 +1,284 @@
-import { discoverTests } from "../../discovery/index.mjs";
-import { runDoctor } from "../../app/doctor.mjs";
-import { resolveProductDir } from "../../config/index.mjs";
-import { resolveRequestedFiles } from "../args.mjs";
-import { buildDiscoveryReportLines } from "../presentation/discovery-reporter.mjs";
+import fs from "fs";
+import path from "path";
+import { execaCommand } from "execa";
 import { loadCurrentRunArtifact, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
 import {
-  formatAssistantToolText,
-  readAssistantContent,
-} from "./content.mjs";
-import { createAssistantRunReporter } from "./tool-run-reporter.mjs";
-import { buildRunRequest } from "../command-helpers.mjs";
-import * as runner from "../../runner/index.mjs";
+  readContextContent,
+} from "../context-resources.mjs";
+
+const COMMAND_OUTPUT_LIMIT = 14_000;
+const COMMAND_LINE_LIMIT = 220;
+const FILE_LINE_LIMIT = 160;
 
 export function listAssistantTools() {
   return [
-    { name: "run_tests", description: "Run testkit-managed tests with optional type/service/file filters." },
-    { 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." },
+    {
+      name: "shell_exec",
+      description: "Execute a shell command inside the repository. Prefer real repo commands such as npm, npx, and testkit.",
+    },
+    {
+      name: "read_context",
+      description: "Read testkit-managed context such as focused detail, logs, artifacts, setup, or run summary.",
+    },
+    {
+      name: "read_file",
+      description: "Read a local file with optional start and end lines.",
+    },
+    {
+      name: "search_repo",
+      description: "Search the repository with ripgrep and return matching lines.",
+    },
   ];
 }
 
 export async function executeAssistantTool(name, argumentsObject, context) {
   const args = argumentsObject && typeof argumentsObject === "object" ? argumentsObject : {};
   switch (name) {
-    case "run_tests":
-      return runTestsTool(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":
-      return showStatusTool(args, context);
-    case "run_doctor":
-      return runDoctorTool(args, context);
+    case "shell_exec":
+      return shellExecTool(args, context);
+    case "read_context":
+      return readContextTool(args, context);
+    case "read_file":
+      return readFileTool(args, context);
+    case "search_repo":
+      return searchRepoTool(args, context);
     default:
       throw new Error(`Unknown assistant tool "${name}"`);
   }
 }
 
-async function runTestsTool(args, context) {
-  const request = await buildRunRequest(
-    {
-      dir: context.productDir,
-      service: args.service || null,
-      type: normalizeArray(args.type),
-      suite: normalizeArray(args.suite),
-      file: normalizeArray(args.file),
-      workers: args.workers == null ? null : String(args.workers),
-      "file-timeout-seconds": args.fileTimeoutSeconds == null ? null : String(args.fileTimeoutSeconds),
-      shard: args.shard || null,
-      seed: args.seed || null,
-      "write-status": Boolean(args.writeStatus),
-      "allow-partial-status": Boolean(args.allowPartialStatus),
-      "ignore-skip-rules": Boolean(args.ignoreSkipRules),
-    },
-    null,
-    context.productDir,
-    process.cwd()
-  );
+async function shellExecTool(args, context) {
+  const command = String(args.command || "").trim();
+  if (!command) throw new Error("shell_exec requires a command string");
 
-  context.inspectState.resetForLive();
-  const liveReporter = createAssistantRunReporter({
-    inspectState: context.inspectState,
-    onStatus(message) {
-      context.onEvent?.({ type: "tool-status", tool: "run_tests", message });
-    },
+  const shellCommand = classifyShellCommand(command);
+  const commandId = `cmd-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  context.commandLog?.appendCommandLog({
+    type: "command_start",
+    command: shellCommand.command,
+    commandId,
+    cwd: context.productDir,
+    raw: command,
+  });
+  context.onEvent?.({
+    type: "tool-status",
+    tool: "shell_exec",
+    message: `Running ${shellCommand.display}`,
   });
 
-  try {
-    const result = await runner.runAll(
-      request.configs,
-      request.typeValues,
-      request.suiteSelectors,
-      {
-        ...request.runOptions,
-        reporter: liveReporter,
-      },
-      request.allConfigs
-    );
-    await liveReporter.finalize;
-
-    return {
-      ok: result.ok,
-      title: "Run complete",
-      text: summarizeRunResult(context.inspectState.getSnapshot()),
-      data: result,
-    };
-  } catch (error) {
-    liveReporter.close();
-    await liveReporter.finalize.catch(() => {});
-    throw error;
-  }
-}
+  const result = await execaCommand(command, {
+    cwd: context.productDir,
+    reject: false,
+    shell: true,
+    env: {
+      ...process.env,
+      ...context.env,
+      PATH: [context.commandLog?.binDir, context.env?.PATH, process.env.PATH].filter(Boolean).join(path.delimiter),
+      TESTKIT_NO_ASSISTANT_DEFAULT: "1",
+    },
+  });
 
-function focusFileTool(args, context) {
-  const file = args.file || args.path || null;
-  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 inspectFocusTool({}, context);
-}
+  context.commandLog?.appendCommandLog({
+    type: "command_exit",
+    command: shellCommand.command,
+    commandId,
+    cwd: context.productDir,
+    raw: command,
+    code: result.exitCode ?? 0,
+    signal: result.signal ?? null,
+  });
 
-function focusServiceTool(args, context) {
-  const service = args.service || args.name || null;
-  if (!service) throw new Error("focus_service requires a service argument");
-  ensureArtifactLoaded(context);
-  if (!context.inspectState.revealService(service)) {
-    throw new Error(`Unknown service "${service}"`);
+  if (shellCommand.testkitRelated) {
+    refreshArtifactSelection(context);
   }
-  return inspectFocusTool({}, context);
-}
+  context.commandLog?.refresh?.();
 
-function inspectFocusTool(_args, context) {
-  const content = readAssistantContent({
-    productDir: context.productDir,
-    inspectState: context.inspectState,
-    mode: "detail",
-    logTail: 12,
-  });
+  const lines = formatCommandResult(command, result, shellCommand);
   return {
-    ok: true,
-    title: content.title,
-    text: formatAssistantToolText(content.title, content.lines),
+    ok: (result.exitCode ?? 0) === 0,
+    title: shellCommand.title,
+    text: lines.join("\n"),
     data: {
-      title: content.title,
-      lines: content.lines,
-      selection: content.selection,
-      mode: "detail",
+      command,
+      stdout: result.stdout || "",
+      stderr: result.stderr || "",
+      exitCode: result.exitCode ?? 0,
+      signal: result.signal ?? null,
+      testkitRelated: shellCommand.testkitRelated,
     },
   };
 }
 
-function readLogsTool(args, context) {
-  if (args.service) {
+function readContextTool(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);
+  } else if (args.service) {
     ensureArtifactLoaded(context);
     if (!context.inspectState.revealService(args.service)) {
       throw new Error(`Unknown service "${args.service}"`);
     }
   }
-  const content = readAssistantContent({
+
+  const content = readContextContent({
     productDir: context.productDir,
-    inspectState: context.inspectState,
-    mode: "logs",
+    snapshot: context.inspectState.getSnapshot(),
+    mode: normalizeContextMode(args.mode),
     logTail: args.logTail == null ? 12 : Number(args.logTail),
   });
+  context.commandLog?.refresh?.();
   return {
     ok: true,
     title: content.title,
-    text: formatAssistantToolText(content.title, content.lines),
+    text: content.lines.join("\n"),
     data: {
       title: content.title,
       lines: content.lines,
       selection: content.selection,
-      mode: "logs",
+      mode: content.mode,
     },
   };
 }
 
-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);
+function readFileTool(args, context) {
+  const file = String(args.path || args.file || "").trim();
+  if (!file) throw new Error("read_file requires a path");
+  const resolved = resolveRepoPath(context.productDir, file);
+  if (!resolved.startsWith(path.resolve(context.productDir))) {
+    throw new Error("read_file only supports paths inside the current repository");
   }
-  const content = readAssistantContent({
-    productDir: context.productDir,
-    inspectState: context.inspectState,
-    mode: "artifacts",
-    logTail: 12,
-  });
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`File not found: ${file}`);
+  }
+  const startLine = Math.max(1, Number(args.startLine || args.start || 1) || 1);
+  const requestedEnd = Number(args.endLine || args.end || startLine + FILE_LINE_LIMIT - 1) || startLine + FILE_LINE_LIMIT - 1;
+  const endLine = Math.max(startLine, Math.min(requestedEnd, startLine + FILE_LINE_LIMIT - 1));
+  const lines = fs.readFileSync(resolved, "utf8").split(/\r?\n/);
+  const selected = [];
+  for (let lineNumber = startLine; lineNumber <= Math.min(endLine, lines.length); lineNumber += 1) {
+    selected.push(`${lineNumber}: ${lines[lineNumber - 1]}`);
+  }
+  const title = `File ${path.relative(context.productDir, resolved) || path.basename(resolved)}`;
   return {
     ok: true,
-    title: content.title,
-    text: formatAssistantToolText(content.title, content.lines),
+    title,
+    text: selected.join("\n"),
     data: {
-      title: content.title,
-      lines: content.lines,
-      selection: content.selection,
-      mode: "artifacts",
+      path: resolved,
+      relativePath: path.relative(context.productDir, resolved),
+      startLine,
+      endLine,
+      lines: selected,
     },
   };
 }
 
-function readSetupTool(args, context) {
-  if (args.service) {
-    ensureArtifactLoaded(context);
-    if (!context.inspectState.revealService(args.service)) {
-      throw new Error(`Unknown service "${args.service}"`);
+async function searchRepoTool(args, context) {
+  const query = String(args.query || args.pattern || "").trim();
+  if (!query) throw new Error("search_repo requires a query");
+  const result = await execaCommand(
+    `rg --line-number --smart-case --hidden --glob '!node_modules' --glob '!.git' ${shellQuote(query)} .`,
+    {
+      cwd: context.productDir,
+      reject: false,
+      shell: true,
     }
-  }
-  const content = readAssistantContent({
-    productDir: context.productDir,
-    inspectState: context.inspectState,
-    mode: "setup",
-    logTail: 12,
-  });
+  );
+  const combined = truncateLines((result.stdout || "").split(/\r?\n/).filter(Boolean), COMMAND_LINE_LIMIT);
+  const lines =
+    combined.length > 0
+      ? combined
+      : [`No matches for ${query}`];
   return {
-    ok: true,
-    title: content.title,
-    text: formatAssistantToolText(content.title, content.lines),
+    ok: (result.exitCode ?? 1) === 0,
+    title: `Search ${query}`,
+    text: lines.join("\n"),
     data: {
-      title: content.title,
-      lines: content.lines,
-      selection: content.selection,
-      mode: "setup",
+      query,
+      matches: combined,
+      exitCode: result.exitCode ?? 1,
     },
   };
 }
 
-async function discoverTestsTool(args, context) {
-  const productDir = resolveProductDir(process.cwd(), context.productDir);
-  const fileNames = resolveRequestedFiles(normalizeArray(args.file), productDir, process.cwd());
-  const result = await discoverTests({
-    dir: productDir,
-    service: args.service || null,
-    type: normalizeArray(args.type),
-    suite: normalizeArray(args.suite),
-    file: fileNames,
-    runnableOnly: Boolean(args.runnableOnly),
-    diagnostics: args.strict ? "error" : "report",
-  });
-  const lines = buildDiscoveryReportLines(result, { outputMode: args.outputMode || "compact" });
+function classifyShellCommand(command) {
+  const normalized = command.trim();
+  if (/^(testkit)\b/.test(normalized)) {
+    return {
+      command: "testkit",
+      display: normalized,
+      title: "testkit command",
+      testkitRelated: true,
+    };
+  }
+  if (/^(npx)\s+testkit\b/.test(normalized)) {
+    return {
+      command: "npx testkit",
+      display: normalized,
+      title: "npx testkit",
+      testkitRelated: true,
+    };
+  }
+  if (/^(npm)\s+run\s+testkit\b/.test(normalized) || /^(npm)\s+run\s+testkit:/.test(normalized)) {
+    return {
+      command: "npm run testkit",
+      display: normalized,
+      title: "npm testkit script",
+      testkitRelated: true,
+    };
+  }
   return {
-    ok: true,
-    title: "Discovery",
-    text: lines.join("\n"),
-    data: result,
+    command: normalized.split(/\s+/)[0] || "command",
+    display: normalized,
+    title: "Shell command",
+    testkitRelated: false,
   };
 }
 
-function showStatusTool(_args, context) {
-  const { output } = captureConsoleOutput(() => runner.showStatus(context.configs[0]));
-  const lines = output.length > 0 ? output : ["No state"];
-  return {
-    ok: true,
-    title: "Status",
-    text: formatAssistantToolText("Status", lines),
-    data: { lines },
-  };
+function formatCommandResult(command, result, shellCommand) {
+  const lines = [`$ ${command}`];
+  const stdout = (result.stdout || "").trim();
+  const stderr = (result.stderr || "").trim();
+  const merged = [];
+  if (stdout) merged.push(...stdout.split(/\r?\n/));
+  if (stderr) merged.push(...stderr.split(/\r?\n/).map((line) => `stderr: ${line}`));
+  if (merged.length === 0) {
+    merged.push(`exit ${result.exitCode ?? 0}`);
+  }
+  const trimmed = truncateLines(merged, COMMAND_LINE_LIMIT).map((line) => truncateText(line, COMMAND_OUTPUT_LIMIT));
+  lines.push(...trimmed);
+  if ((result.exitCode ?? 0) !== 0) {
+    lines.push(`exit code: ${result.exitCode ?? 0}`);
+  } else if (!shellCommand.testkitRelated) {
+    lines.push("exit code: 0");
+  }
+  return lines;
 }
 
-async function runDoctorTool(args, context) {
-  const result = await runDoctor({
-    dir: context.productDir,
-    typecheck: args.typecheck ?? true,
-  });
-  const lines = [
-    `testkit doctor ${result.ok ? "passed" : "failed"} for ${result.productDir}`,
-    ...result.checks.map((check) => `${String(check.level || "").toUpperCase()} ${check.code} ${check.message}`),
-  ];
-  return {
-    ok: result.ok,
-    title: "Doctor",
-    text: formatAssistantToolText("Doctor", lines),
-    data: result,
-  };
+function truncateLines(lines, limit) {
+  if (lines.length <= limit) return lines;
+  return [...lines.slice(0, limit - 1), `… ${lines.length - limit + 1} more lines omitted`];
+}
+
+function truncateText(value, maxLength) {
+  const normalized = String(value || "");
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength - 1)}…`;
+}
+
+function resolveRepoPath(productDir, file) {
+  return path.resolve(productDir, file);
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function normalizeContextMode(mode) {
+  if (mode === "logs" || mode === "artifacts" || mode === "setup") return mode;
+  return "detail";
 }
 
 function ensureArtifactLoaded(context) {
@@ -288,28 +292,14 @@ function ensureArtifactLoaded(context) {
   return context.inspectState.getSnapshot().runArtifact;
 }
 
-function normalizeArray(value) {
-  if (value == null) return [];
-  if (Array.isArray(value)) return value.filter(Boolean);
-  return [value].filter(Boolean);
-}
-
-function summarizeRunResult(snapshot) {
-  const rows = snapshot?.summaryData?.rows || [];
-  if (rows.length === 0) return "Run finished.";
-  return rows.map(([label, value]) => `${label}: ${value}`).join("\n");
-}
-
-function captureConsoleOutput(fn) {
-  const output = [];
-  const originalLog = console.log;
-  console.log = (...args) => {
-    output.push(args.map((value) => String(value)).join(" "));
-  };
+function refreshArtifactSelection(context) {
   try {
-    const result = fn();
-    return { result, output };
-  } finally {
-    console.log = originalLog;
+    context.inspectState.hydrateFromArtifact(loadCurrentRunArtifact(context.productDir));
+  } catch {
+    try {
+      context.inspectState.hydrateFromArtifact(loadLatestRunArtifact(context.productDir));
+    } catch {
+      // Ignore missing artifacts.
+    }
   }
 }

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 = "Open the testkit assistant shell";
 
   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,51 +28,66 @@ 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);
       }
       const snapshot = assistantState.getSnapshot();
       if (!this.jsonEnabled()) {
         for (const message of snapshot.messages) {
+          if (message.role === "tool" && message.title) {
+            this.log(`tool: ${message.title}`);
+            if (message.text) this.log(message.text);
+            continue;
+          }
           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,
-      }),
-      { 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,
+      configs: allConfigs,
+    });
   }
 }