@elench/testkit 0.1.86 → 0.1.88

package/lib/cli/assistant/state.mjs

@@ -0,0 +1,279 @@
+import { loadCurrentRunArtifact, loadLatestRunArtifact } from "../viewer.mjs";
+import { createInspectState } from "../tui/inspect-state.mjs";
+import { parseSlashCommand, formatSlashHelpLines } from "./slash-commands.mjs";
+import { executeAssistantTool } from "./tool-registry.mjs";
+import { runAssistantConversationTurn } from "./session.mjs";
+
+export function createAssistantState({
+  productDir,
+  provider = "auto",
+  initialPane = "detail",
+  dataSource = "artifact",
+  configs = [],
+} = {}) {
+  const inspectState = createInspectState({ dataSource });
+  inspectState.setPaneMode(initialPane);
+
+  const listeners = new Set();
+  const messages = [];
+  let composer = "";
+  let notice = null;
+  let busy = false;
+  let providerName = provider;
+  let activeStatus = null;
+
+  inspectState.subscribe(() => notify());
+
+  function notify() {
+    for (const callback of listeners) callback();
+  }
+
+  function appendMessage(message) {
+    messages.push({
+      id: `msg-${messages.length + 1}`,
+      ...message,
+    });
+    notify();
+  }
+
+  function setBusy(nextBusy, status = null) {
+    busy = Boolean(nextBusy);
+    activeStatus = status || null;
+    notify();
+  }
+
+  return {
+    inspectState,
+
+    async loadLatestArtifact() {
+      try {
+        inspectState.hydrateFromArtifact(loadLatestRunArtifact(productDir));
+      } catch {
+        // No artifact yet.
+      }
+    },
+
+    async loadCurrentArtifact() {
+      try {
+        inspectState.hydrateFromArtifact(loadCurrentRunArtifact(productDir));
+      } catch {
+        // No artifact yet.
+      }
+    },
+
+    revealFile(serviceName, filePath) {
+      return inspectState.revealFile(serviceName, filePath);
+    },
+
+    revealService(serviceName) {
+      return inspectState.revealService(serviceName);
+    },
+
+    setPaneMode(pane) {
+      inspectState.setPaneMode(pane);
+    },
+
+    setComposer(value) {
+      composer = String(value || "");
+      notify();
+    },
+
+    appendComposer(text) {
+      composer += String(text || "");
+      notify();
+    },
+
+    backspaceComposer() {
+      composer = composer.slice(0, -1);
+      notify();
+    },
+
+    clearNotice() {
+      notice = null;
+      notify();
+    },
+
+    setNotice(message) {
+      notice = message ? String(message) : null;
+      notify();
+    },
+
+    setProvider(nextProvider) {
+      providerName = nextProvider || "auto";
+      notify();
+    },
+
+    clearMessages() {
+      messages.length = 0;
+      notify();
+    },
+
+    async submitCurrentComposer() {
+      const value = composer.trim();
+      composer = "";
+      notify();
+      if (!value) return;
+      await this.submitInput(value);
+    },
+
+    async submitInput(input) {
+      const trimmed = String(input || "").trim();
+      if (!trimmed) return;
+      appendMessage({ role: "user", text: trimmed });
+
+      const slash = parseSlashCommandSafe(trimmed);
+      if (slash?.type === "__error__") {
+        appendMessage({
+          role: "system",
+          text: slash.error,
+        });
+        return;
+      }
+      if (slash) {
+        try {
+          await executeSlashCommand({
+            slash,
+            productDir,
+            inspectState,
+            configs,
+            setProvider: (value) => {
+              providerName = value;
+            },
+            appendMessage,
+            setNotice: (value) => {
+              notice = value;
+            },
+            clearMessages: () => {
+              messages.length = 0;
+            },
+          });
+        } catch (error) {
+          appendMessage({
+            role: "system",
+            text: error instanceof Error ? error.message : String(error),
+          });
+        }
+        notify();
+        return;
+      }
+
+      try {
+        setBusy(true, "Waiting for assistant...");
+        const emitted = await runAssistantConversationTurn({
+          productDir,
+          inspectState,
+          transcript: messages.map((entry) => ({ role: entry.role, text: entry.text })),
+          userMessage: trimmed,
+          provider: providerName,
+          configs,
+          onStatus(status) {
+            activeStatus = status;
+            notify();
+          },
+        });
+        for (const message of emitted) appendMessage(message);
+      } catch (error) {
+        appendMessage({
+          role: "system",
+          text: error instanceof Error ? error.message : String(error),
+        });
+      } finally {
+        setBusy(false, null);
+      }
+    },
+
+    subscribe(callback) {
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    },
+
+    getSnapshot() {
+      return {
+        workbench: inspectState.getSnapshot(),
+        messages: [...messages],
+        composer,
+        notice,
+        busy,
+        provider: providerName,
+        activeStatus,
+      };
+    },
+  };
+}
+
+async function executeSlashCommand({
+  slash,
+  productDir,
+  inspectState,
+  configs,
+  setProvider,
+  appendMessage,
+  setNotice,
+  clearMessages,
+} = {}) {
+  if (slash.type === "help") {
+    appendMessage({ role: "assistant", text: formatSlashHelpLines().join("\n") });
+    return;
+  }
+  if (slash.type === "clear") {
+    clearMessages?.();
+    return;
+  }
+  if (slash.type === "quit") {
+    setNotice?.("Use q or Ctrl+C to quit the interactive assistant.");
+    return;
+  }
+  if (slash.type === "provider") {
+    setProvider(slash.provider);
+    appendMessage({ role: "assistant", text: `Provider set to ${slash.provider}.` });
+    return;
+  }
+
+  const result = await executeSlashTool(slash, {
+    productDir,
+    inspectState,
+    configs,
+  });
+  appendMessage({
+    role: "tool",
+    toolName: slash.type,
+    text: result.text || result.title || "Done.",
+    data: result.data || null,
+  });
+}
+
+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);
+    case "inspect":
+      return slash.file
+        ? executeAssistantTool("select_file", { file: slash.file }, context)
+        : executeAssistantTool("inspect_selection", {}, context);
+    case "service":
+      return executeAssistantTool("select_service", { service: slash.service }, context);
+    case "status":
+      return executeAssistantTool("show_status", {}, context);
+    case "discover":
+      return executeAssistantTool("discover_tests", {}, context);
+    case "doctor":
+      return executeAssistantTool("run_doctor", {}, context);
+    case "run":
+      return executeAssistantTool("run_tests", slash.options, context);
+    default:
+      throw new Error(`Unsupported slash command "${slash.type}"`);
+  }
+}
+
+function parseSlashCommandSafe(input) {
+  try {
+    return parseSlashCommand(input);
+  } catch (error) {
+    return {
+      type: "__error__",
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

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

@@ -0,0 +1,236 @@
+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 { loadCurrentRunArtifact, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { buildInspectPaneContent } from "../tui/detail-pane.mjs";
+import { createAssistantRunReporter } from "./tool-run-reporter.mjs";
+import { buildRunRequest } from "../command-helpers.mjs";
+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: "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." },
+  ];
+}
+
+export async function executeAssistantTool(name, argumentsObject, context) {
+  const args = argumentsObject && typeof argumentsObject === "object" ? argumentsObject : {};
+  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 "discover_tests":
+      return discoverTestsTool(args, context);
+    case "show_status":
+      return showStatusTool(args, context);
+    case "run_doctor":
+      return runDoctorTool(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()
+  );
+
+  context.inspectState.resetForLive();
+  const liveReporter = createAssistantRunReporter({
+    inspectState: context.inspectState,
+    onStatus(message) {
+      context.onEvent?.({ type: "tool-status", tool: "run_tests", message });
+    },
+  });
+
+  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;
+  }
+}
+
+function selectFileTool(args, context) {
+  const file = args.file || args.path || null;
+  if (!file) throw new Error("select_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);
+}
+
+function selectServiceTool(args, context) {
+  const service = args.service || args.name || null;
+  if (!service) throw new Error("select_service requires a service argument");
+  ensureArtifactLoaded(context);
+  if (!context.inspectState.revealService(service)) {
+    throw new Error(`Unknown service "${service}"`);
+  }
+  return inspectSelectionTool({}, context);
+}
+
+function setPaneTool(args, context) {
+  const pane = args.pane || "detail";
+  context.inspectState.setPaneMode(pane);
+  return inspectSelectionTool({}, context);
+}
+
+function inspectSelectionTool(_args, context) {
+  ensureArtifactLoaded(context);
+  const snapshot = context.inspectState.getSnapshot();
+  const pane = buildInspectPaneContent({
+    productDir: context.productDir,
+    snapshot,
+    paneMode: snapshot.paneMode,
+    logTail: 12,
+  });
+  return {
+    ok: true,
+    title: pane.title,
+    text: pane.lines.join("\n"),
+    data: {
+      title: pane.title,
+      lines: pane.lines,
+      selection: snapshot.selectedEntry,
+      paneMode: snapshot.paneMode,
+    },
+  };
+}
+
+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" });
+  return {
+    ok: true,
+    title: "Discovery",
+    text: lines.join("\n"),
+    data: result,
+  };
+}
+
+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: lines.join("\n"),
+    data: { 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: lines.join("\n"),
+    data: result,
+  };
+}
+
+function ensureArtifactLoaded(context) {
+  const snapshot = context.inspectState.getSnapshot();
+  if (snapshot.runArtifact) return snapshot.runArtifact;
+  try {
+    context.inspectState.hydrateFromArtifact(loadCurrentRunArtifact(context.productDir));
+  } catch {
+    context.inspectState.hydrateFromArtifact(loadLatestRunArtifact(context.productDir));
+  }
+  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(" "));
+  };
+  try {
+    const result = fn();
+    return { result, output };
+  } finally {
+    console.log = originalLog;
+  }
+}

package/lib/cli/assistant/tool-run-reporter.mjs

@@ -0,0 +1,80 @@
+import {
+  applyReporterPlans,
+  applyReporterRunSummary,
+  applyReporterTaskFinished,
+  applyReporterTaskStarted,
+} from "../tui/inspect-live-adapter.mjs";
+import { suiteSelectionType } from "../../runner/suite-selection.mjs";
+
+export function createAssistantRunReporter({ inspectState, onStatus } = {}) {
+  return {
+    reporter: {
+      outputMode: "compact",
+
+      setServicePlans(plans) {
+        applyReporterPlans(inspectState, plans);
+        onStatus?.("Planned run.");
+      },
+
+      setTotalFileCount(count) {
+        inspectState.setTotalFileCount(count);
+      },
+
+      setRegressionCatalog(document) {
+        inspectState.setRegressionCatalog(document);
+      },
+
+      serviceSkipped(config, reason) {
+        inspectState.markServiceSkipped(config.name, reason);
+      },
+
+      plannedSkip(entry) {
+        inspectState.markPlannedSkip(entry);
+      },
+
+      taskStarted(task) {
+        const suiteKey = `${task.displayType || suiteSelectionType(task.type, task.framework)}:${task.suiteName}`;
+        applyReporterTaskStarted(inspectState, task, suiteKey);
+      },
+
+      taskFinished(task, outcome) {
+        applyReporterTaskFinished(inspectState, task, outcome);
+        if (outcome.failed) {
+          onStatus?.(`Failed ${task.file}`);
+        }
+      },
+
+      runtimeError(task, message) {
+        inspectState.markRuntimeError(task, message);
+      },
+
+      setupOperationFinished() {},
+
+      phaseStarted(label) {
+        inspectState.setPhase(label);
+        onStatus?.(label);
+      },
+
+      toolchainResolved() {},
+      localServiceStarting() {},
+      writeLine() {},
+      writeDebugLine() {},
+      telemetry() {},
+
+      runSummary(results, durationMs, regressionReport) {
+        applyReporterRunSummary(inspectState, results, durationMs, regressionReport);
+        onStatus?.("Run finished.");
+      },
+
+      error(message) {
+        onStatus?.(String(message));
+      },
+    },
+
+    finalize: Promise.resolve(),
+
+    close() {
+      // No long-lived UI resources to close.
+    },
+  };
+}

package/lib/cli/command-helpers.mjs

@@ -19,7 +19,7 @@ export const sharedFlags = {
     description: "Explicit product directory",
   }),
   service: Flags.string({
-    description: "Run or inspect only one service",
+    description: "Limit the operation or assistant context to one service",
   }),
 };
 
@@ -79,18 +79,8 @@ export async function resolveConfigsForCommand(flags) {
 }
 
 export async function executeRunCommand(command, flags, positionalType = null) {
-  const { allConfigs, configs } = await resolveConfigsForCommand(flags);
-  const workers = flags.workers == null ? null : parseWorkersOption(flags.workers);
-  const fileTimeoutSeconds =
-    flags["file-timeout-seconds"] == null
-      ? null
-      : parseFileTimeoutOption(flags["file-timeout-seconds"]);
-  const shard = parseShardOption(flags.shard);
-  const typeValues = parseTypeOption(flags.type, positionalType);
-  const suiteSelectors = parseSuiteOption(flags.suite);
-  const rawFileNames = Array.isArray(flags.file) ? flags.file : [flags.file].filter(Boolean);
-  const productDir = allConfigs[0]?.productDir || process.cwd();
-  const fileNames = resolveRequestedFiles(rawFileNames, productDir, process.cwd());
+  const request = await buildRunRequest(flags, positionalType, process.cwd(), process.cwd());
+  const { allConfigs, configs, typeValues, suiteSelectors, productDir } = request;
   const outputMode = command.jsonEnabled()
     ? "json"
     : flags.debug
@@ -122,18 +112,8 @@ export async function executeRunCommand(command, flags, positionalType = null) {
       typeValues,
       suiteSelectors,
       {
-        ...flags,
-        typeValues,
-        fileNames,
-        workers,
-        fileTimeoutSeconds,
-        shard,
-        scenarioSeed: flags.seed || null,
-        serviceFilter: flags.service || null,
         reporter,
-        writeStatus: flags["write-status"],
-        allowPartialStatus: flags["allow-partial-status"],
-        ignoreSkipRules: flags["ignore-skip-rules"],
+        ...request.runOptions,
       },
       allConfigs
     );
@@ -149,6 +129,42 @@ export async function executeRunCommand(command, flags, positionalType = null) {
   }
 }
 
+export async function buildRunRequest(flags, positionalType = null, cwd = process.cwd(), invocationCwd = process.cwd()) {
+  const { allConfigs, configs } = await resolveConfigsForCommand(flags);
+  const workers = flags.workers == null ? null : parseWorkersOption(flags.workers);
+  const fileTimeoutSeconds =
+    flags["file-timeout-seconds"] == null
+      ? null
+      : parseFileTimeoutOption(flags["file-timeout-seconds"]);
+  const shard = parseShardOption(flags.shard);
+  const typeValues = parseTypeOption(flags.type, positionalType);
+  const suiteSelectors = parseSuiteOption(flags.suite);
+  const rawFileNames = Array.isArray(flags.file) ? flags.file : [flags.file].filter(Boolean);
+  const productDir = allConfigs[0]?.productDir || cwd;
+  const fileNames = resolveRequestedFiles(rawFileNames, productDir, invocationCwd);
+
+  return {
+    allConfigs,
+    configs,
+    productDir,
+    typeValues,
+    suiteSelectors,
+    runOptions: {
+      ...flags,
+      typeValues,
+      fileNames,
+      workers,
+      fileTimeoutSeconds,
+      shard,
+      scenarioSeed: flags.seed || null,
+      serviceFilter: flags.service || null,
+      writeStatus: flags["write-status"],
+      allowPartialStatus: flags["allow-partial-status"],
+      ignoreSkipRules: flags["ignore-skip-rules"],
+    },
+  };
+}
+
 export async function runStatusLike(commandName, flags) {
   const { allConfigs, configs } = await resolveConfigsForCommand(flags);