@elench/testkit 0.1.98 → 0.1.100

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

@@ -1,584 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { execaCommand } from "execa";
-import { loadCurrentRunArtifact, loadLatestRunArtifact, resolveFileSubject } from "../../results/artifacts.mjs";
-import { readContextContent } from "../../results/context.mjs";
-import { buildRunRequest, executeRunRequest } from "../operations/run/operation.mjs";
-import { executeDiscoverOperation } from "../operations/discover/operation.mjs";
-import { executeDoctorOperation } from "../operations/doctor/operation.mjs";
-import { executeTypecheckOperation } from "../operations/typecheck/operation.mjs";
-import { executeStatusOperation } from "../operations/status/operation.mjs";
-import { renderDiscoverResult } from "../renderers/discover/text.mjs";
-import { renderDoctorResult } from "../renderers/doctor/text.mjs";
-import { renderTypecheckResult } from "../renderers/typecheck/text.mjs";
-import { renderStatusResult } from "../renderers/status/text.mjs";
-import { createRunSession } from "../renderers/run/interactive.mjs";
-import { loadCliConfig } from "../config.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 suites in-process with the shared live run session and tree state.",
-    },
-    {
-      name: "discover_tests",
-      description: "Discover testkit suites and files in the current repository.",
-    },
-    {
-      name: "show_status",
-      description: "Show local testkit runtime and database state for the current repository.",
-    },
-    {
-      name: "run_doctor",
-      description: "Run built-in testkit doctor checks for the current repository.",
-    },
-    {
-      name: "run_typecheck",
-      description: "Run testkit typechecking for config, helpers, and suites.",
-    },
-    {
-      name: "shell_exec",
-      description: "Execute a shell command inside the repository for arbitrary repo work outside first-class testkit actions.",
-    },
-    {
-      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 "discover_tests":
-      return discoverTestsTool(args, context);
-    case "show_status":
-      return showStatusTool(args, context);
-    case "run_doctor":
-      return doctorTool(args, context);
-    case "run_typecheck":
-      return typecheckTool(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 shellExecTool(args, context) {
-  const command = String(args.command || "").trim();
-  if (!command) throw new Error("shell_exec requires a command string");
-  if (isTestkitCommand(command)) {
-    throw new Error("Use the dedicated testkit tools for run/discover/status/doctor/typecheck instead of shell_exec.");
-  }
-
-  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-start",
-    tool: "shell_exec",
-    command,
-    title: shellCommand.title,
-    testkitRelated: shellCommand.testkitRelated,
-    message: `Running ${shellCommand.display}`,
-  });
-
-  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",
-    },
-  });
-
-  context.commandLog?.appendCommandLog({
-    type: "command_exit",
-    command: shellCommand.command,
-    commandId,
-    cwd: context.productDir,
-    raw: command,
-    code: result.exitCode ?? 0,
-    signal: result.signal ?? null,
-  });
-  context.onEvent?.({
-    type: "tool-exit",
-    tool: "shell_exec",
-    command,
-    title: shellCommand.title,
-    testkitRelated: shellCommand.testkitRelated,
-    code: result.exitCode ?? 0,
-    signal: result.signal ?? null,
-    message: `${shellCommand.display} exited ${result.exitCode ?? 0}`,
-  });
-
-  if (shellCommand.testkitRelated) {
-    refreshArtifactSelection(context);
-  }
-  context.commandLog?.refresh?.();
-
-  const lines = formatCommandResult(command, result, shellCommand);
-  return {
-    ok: (result.exitCode ?? 0) === 0,
-    title: shellCommand.title,
-    text: lines.join("\n"),
-    data: {
-      command,
-      stdout: result.stdout || "",
-      stderr: result.stderr || "",
-      exitCode: result.exitCode ?? 0,
-      signal: result.signal ?? null,
-      testkitRelated: shellCommand.testkitRelated,
-    },
-  };
-}
-
-async function runTestsTool(args, context) {
-  const invocationId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-  const normalizedArgs = normalizeRunToolArgs(args, context.productDir);
-  const rawCommand = buildRunCommandLine(normalizedArgs);
-  const request = await buildRunRequest(normalizedArgs, null, context.productDir, context.productDir);
-  const runSession = createRunSession({
-    productDir: request.productDir,
-    stderr: process.stderr,
-    config: loadCliConfig(request.productDir),
-  });
-  context.commandLog?.appendCommandLog({
-    type: "command_start",
-    command: "testkit",
-    commandId: invocationId,
-    cwd: context.productDir,
-    raw: rawCommand,
-  });
-  context.onEvent?.({
-    type: "tool-start",
-    tool: "run_tests",
-    invocationId,
-    title: buildRunToolTitle(normalizedArgs),
-    testkitRelated: true,
-    message: `Running ${buildRunDisplay(normalizedArgs)}`,
-  });
-  context.onEvent?.({
-    type: "run-session-start",
-    tool: "run_tests",
-    invocationId,
-    session: runSession,
-  });
-
-  const previousExitCode = process.exitCode;
-  try {
-    const result = await executeRunRequest(request, {
-      outputMode: "compact",
-      terminal: {
-        stdout: process.stdout,
-        stderr: process.stderr,
-        stdin: process.stdin,
-        env: context.env,
-      },
-      attachedRunSession: runSession,
-    });
-    process.exitCode = previousExitCode;
-    refreshArtifactSelection(context);
-    context.commandLog?.refresh?.();
-    context.commandLog?.appendCommandLog({
-      type: "command_exit",
-      command: "testkit",
-      commandId: invocationId,
-      cwd: context.productDir,
-      raw: rawCommand,
-      code: result.exitCode ?? 0,
-      signal: null,
-    });
-    const text = formatRunSessionText(runSession);
-    context.onEvent?.({
-      type: "tool-exit",
-      tool: "run_tests",
-      invocationId,
-      title: buildRunToolTitle(normalizedArgs),
-      testkitRelated: true,
-      code: result.exitCode ?? 0,
-      message: `${buildRunDisplay(normalizedArgs)} exited ${result.exitCode ?? 0}`,
-    });
-    context.onEvent?.({
-      type: "run-session-end",
-      tool: "run_tests",
-      invocationId,
-      session: runSession,
-    });
-    return {
-      ok: (result.exitCode ?? 0) === 0,
-      title: buildRunToolTitle(normalizedArgs),
-      text,
-      data: {
-        exitCode: result.exitCode ?? 0,
-        testkitRelated: true,
-        summaryRows: runSession.getSnapshot().summaryData?.rows || [],
-      },
-    };
-  } finally {
-    process.exitCode = previousExitCode;
-  }
-}
-
-async function discoverTestsTool(args, context) {
-  const flags = {
-    dir: context.productDir,
-    service: normalizeOptionalString(args.service),
-    type: normalizeStringArray(args.type),
-    suite: normalizeStringArray(args.suite),
-    file: normalizeStringArray(args.file || args.path),
-    "runnable-only": Boolean(args.runnableOnly || args["runnable-only"]),
-    strict: Boolean(args.strict),
-    output: normalizeOptionalString(args.output),
-  };
-  const result = await executeDiscoverOperation(flags, context.productDir);
-  return {
-    ok: true,
-    title: "testkit discover",
-    text: renderDiscoverResult(result, { outputMode: args.outputMode || "compact" }).join("\n"),
-    data: {
-      testkitRelated: true,
-      services: result.services?.length || 0,
-      files: result.files?.length || 0,
-    },
-  };
-}
-
-async function showStatusTool(args, context) {
-  const flags = {
-    dir: context.productDir,
-    service: normalizeOptionalString(args.service),
-  };
-  const results = await executeStatusOperation(flags);
-  return {
-    ok: true,
-    title: "testkit status",
-    text: results.flatMap(renderStatusResult).join("\n"),
-    data: {
-      testkitRelated: true,
-      services: results.map((result) => result.name),
-    },
-  };
-}
-
-async function doctorTool(args, context) {
-  const result = await executeDoctorOperation({
-    dir: context.productDir,
-    typecheck: args.typecheck == null ? true : Boolean(args.typecheck),
-  });
-  return {
-    ok: result.ok,
-    title: "testkit doctor",
-    text: renderDoctorResult(result).join("\n"),
-    data: {
-      testkitRelated: true,
-      ok: result.ok,
-    },
-  };
-}
-
-async function typecheckTool(_args, context) {
-  const result = await executeTypecheckOperation({ dir: context.productDir });
-  return {
-    ok: true,
-    title: "testkit typecheck",
-    text: renderTypecheckResult(result).join("\n"),
-    data: {
-      testkitRelated: true,
-      count: result.results.length,
-    },
-  };
-}
-
-function readContextTool(args, context) {
-  if (args.file || args.path) {
-    ensureArtifactLoaded(context);
-    const artifact = context.runState.getSnapshot().runArtifact;
-    const subject = resolveFileSubject(artifact, args.file || args.path, args.service || null);
-    context.runState.revealFile(subject.service.name, subject.file.path);
-  } else if (args.service) {
-    ensureArtifactLoaded(context);
-    if (!context.runState.revealService(args.service)) {
-      throw new Error(`Unknown service "${args.service}"`);
-    }
-  }
-
-  const content = readContextContent({
-    productDir: context.productDir,
-    snapshot: context.runState.getSnapshot(),
-    mode: normalizeContextMode(args.mode),
-    logTail: args.logTail == null ? 12 : Number(args.logTail),
-  });
-  context.commandLog?.refresh?.();
-  return {
-    ok: true,
-    title: content.title,
-    text: content.lines.join("\n"),
-    data: {
-      title: content.title,
-      lines: content.lines,
-      selection: content.selection,
-      mode: content.mode,
-    },
-  };
-}
-
-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");
-  }
-  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,
-    text: selected.join("\n"),
-    data: {
-      path: resolved,
-      relativePath: path.relative(context.productDir, resolved),
-      startLine,
-      endLine,
-      lines: selected,
-    },
-  };
-}
-
-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 combined = truncateLines((result.stdout || "").split(/\r?\n/).filter(Boolean), COMMAND_LINE_LIMIT);
-  const lines =
-    combined.length > 0
-      ? combined
-      : [`No matches for ${query}`];
-  return {
-    ok: (result.exitCode ?? 1) === 0,
-    title: `Search ${query}`,
-    text: lines.join("\n"),
-    data: {
-      query,
-      matches: combined,
-      exitCode: result.exitCode ?? 1,
-    },
-  };
-}
-
-function classifyShellCommand(command) {
-  const normalized = command.trim();
-  return {
-    command: normalized.split(/\s+/)[0] || "command",
-    display: normalized,
-    title: "Shell command",
-    testkitRelated: false,
-  };
-}
-
-function isTestkitCommand(command) {
-  const normalized = command.trim();
-  return /^(testkit)\b/.test(normalized) || /^(npx)\s+testkit\b/.test(normalized) || /^(npm)\s+run\s+testkit\b/.test(normalized) || /^(npm)\s+run\s+testkit:/.test(normalized);
-}
-
-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;
-}
-
-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 normalizeOptionalString(value) {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}
-
-function normalizeStringArray(value) {
-  if (Array.isArray(value)) return value.flatMap((entry) => String(entry).split(",")).map((entry) => entry.trim()).filter(Boolean);
-  if (value == null) return [];
-  return String(value).split(",").map((entry) => entry.trim()).filter(Boolean);
-}
-
-function normalizeRunToolArgs(args, productDir) {
-  return {
-    dir: productDir,
-    service: normalizeOptionalString(args.service),
-    type: normalizeStringArray(args.type),
-    suite: normalizeStringArray(args.suite),
-    file: normalizeStringArray(args.file || args.path),
-    workers: normalizeOptionalString(args.workers),
-    "file-timeout-seconds": normalizeOptionalString(args.fileTimeoutSeconds || args["file-timeout-seconds"]),
-    shard: normalizeOptionalString(args.shard),
-    seed: normalizeOptionalString(args.seed),
-    "write-status": Boolean(args.writeStatus || args["write-status"]),
-    "allow-partial-status": Boolean(args.allowPartialStatus || args["allow-partial-status"]),
-    "ignore-skip-rules": Boolean(args.ignoreSkipRules || args["ignore-skip-rules"]),
-    "output-mode": "compact",
-    debug: false,
-  };
-}
-
-function buildRunDisplay(args) {
-  return buildRunCommandLine(args);
-}
-
-function buildRunToolTitle(args) {
-  const types = args.type?.length ? args.type.join(",") : "all";
-  return `testkit run ${types}`;
-}
-
-function formatRunSessionText(runSession) {
-  const snapshot = runSession.getSnapshot();
-  const fileLines = collectRunTreeFiles(snapshot.services || [])
-    .map((entry) => `${formatRunStatus(entry.status)} ${entry.serviceName} ${entry.type} ${entry.filePath || entry.path}`);
-  const rows = snapshot.summaryData?.rows || [];
-  const summaryLines = rows.map(([label, value]) => `${label}: ${value}`);
-  const lines = [...fileLines, ...summaryLines];
-  return lines.length > 0 ? lines.join("\n") : "Run complete.";
-}
-
-function collectRunTreeFiles(services) {
-  const files = [];
-  for (const service of services || []) {
-    for (const typeNode of service.types || []) {
-      for (const suite of typeNode.suites || []) {
-        for (const file of suite.files || []) {
-          files.push(file);
-        }
-      }
-    }
-  }
-  return files;
-}
-
-function formatRunStatus(status) {
-  if (status === "passed") return "PASS";
-  if (status === "failed") return "FAIL";
-  if (status === "skipped") return "SKIP";
-  if (status === "running") return "RUN";
-  if (status === "not_run") return "NOT_RUN";
-  return "PENDING";
-}
-
-function buildRunCommandLine(args) {
-  const parts = ["testkit", "run"];
-  if (args.type?.length === 1) parts.push(args.type[0]);
-  parts.push("--dir", ".");
-  if (args.type?.length !== 1) {
-    for (const type of args.type || []) parts.push("--type", type);
-  }
-  for (const suite of args.suite || []) parts.push("--suite", suite);
-  for (const file of args.file || []) parts.push("--file", file);
-  if (args.service) parts.push("--service", args.service);
-  return parts.join(" ");
-}
-
-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) {
-  const snapshot = context.runState.getSnapshot();
-  if (snapshot.runArtifact) return snapshot.runArtifact;
-  try {
-    context.runState.hydrateFromArtifact(loadCurrentRunArtifact(context.productDir));
-  } catch {
-    context.runState.hydrateFromArtifact(loadLatestRunArtifact(context.productDir));
-  }
-  return context.runState.getSnapshot().runArtifact;
-}
-
-function refreshArtifactSelection(context) {
-  try {
-    context.runState.hydrateFromArtifact(loadCurrentRunArtifact(context.productDir));
-  } catch {
-    try {
-      context.runState.hydrateFromArtifact(loadLatestRunArtifact(context.productDir));
-    } catch {
-      // Ignore missing artifacts.
-    }
-  }
-}