@elench/testkit 0.1.97 → 0.1.99

package/lib/cli/assistant/state.mjs

@@ -1,9 +1,16 @@
-import { loadCurrentRunArtifact, loadLatestRunArtifact } from "../viewer.mjs";
-import { createInspectState } from "../tui/inspect-state.mjs";
-import { buildContextSelection } from "../context-resources.mjs";
-import { isProviderInstalled } from "../agents/index.mjs";
+import { loadCurrentRunArtifact, loadLatestRunArtifact } from "../../results/artifacts.mjs";
+import {
+  formatCliConfig,
+  loadCliConfig,
+  mergeCliConfig,
+  resetCliConfig,
+  saveCliConfig,
+} from "../config.mjs";
+import { createRunState } from "../state/run/state.mjs";
+import { buildContextSelection } from "../../results/context.mjs";
+import { isProviderInstalled } from "./providers/index.mjs";
 import { parseSlashCommand, formatSlashHelpLines } from "./slash-commands.mjs";
-import { executeAssistantTool } from "./tool-registry.mjs";
+import { executeAssistantAction } from "./actions.mjs";
 import { runAssistantConversationTurn } from "./session.mjs";
 import { prepareAssistantContextPack } from "./context-pack.mjs";
 import {
@@ -41,10 +48,12 @@ export function createAssistantState({
   configs = [],
   env = process.env,
 } = {}) {
-  const inspectState = createInspectState({ dataSource });
+  const runState = createRunState({ dataSource });
+  let cliConfig = loadCliConfig(productDir);
+  runState.setAutoCollapsePassedTreeBranches(cliConfig.autoCollapsePassedTreeBranches);
   const commandLog = prepareAssistantContextPack({
     productDir,
-    inspectState,
+    runState,
   });
 
   const listeners = new Set();
@@ -76,8 +85,11 @@ export function createAssistantState({
     model: settings.model,
     prompt: "",
   });
+  let liveRunSession = null;
+  let lastRunSession = null;
+  let liveRunSessionUnsubscribe = null;
 
-  inspectState.subscribe(() => {
+  runState.subscribe(() => {
     commandLog.refresh();
     notify();
   });
@@ -104,13 +116,46 @@ export function createAssistantState({
     commandLog.refresh();
   }
 
+  function attachRunSession(session, { active = true } = {}) {
+    if (liveRunSessionUnsubscribe) {
+      liveRunSessionUnsubscribe();
+      liveRunSessionUnsubscribe = null;
+    }
+    if (!session) {
+      if (!active) notify();
+      return;
+    }
+    lastRunSession = session;
+    if (active) {
+      liveRunSession = session;
+      liveRunSessionUnsubscribe = session.runState.subscribe(() => {
+        notify();
+      });
+    }
+    notify();
+  }
+
+  function completeRunSession(session) {
+    if (liveRunSession === session) {
+      if (liveRunSessionUnsubscribe) {
+        liveRunSessionUnsubscribe();
+        liveRunSessionUnsubscribe = null;
+      }
+      liveRunSession = null;
+    }
+    if (session) lastRunSession = session;
+    notify();
+  }
+
   const state = {
-    inspectState,
+    runState,
     commandLog,
+    attachRunSession,
+    completeRunSession,
 
     async loadLatestArtifact() {
       try {
-        inspectState.hydrateFromArtifact(loadLatestRunArtifact(productDir));
+        runState.hydrateFromArtifact(loadLatestRunArtifact(productDir));
       } catch {
         // No artifact yet.
       }
@@ -119,7 +164,7 @@ export function createAssistantState({
 
     async loadCurrentArtifact() {
       try {
-        inspectState.hydrateFromArtifact(loadCurrentRunArtifact(productDir));
+        runState.hydrateFromArtifact(loadCurrentRunArtifact(productDir));
       } catch {
         // No artifact yet.
       }
@@ -127,13 +172,13 @@ export function createAssistantState({
     },
 
     revealFile(serviceName, filePath) {
-      const revealed = inspectState.revealFile(serviceName, filePath);
+      const revealed = runState.revealFile(serviceName, filePath);
       refreshContextPack();
       return revealed;
     },
 
     revealService(serviceName) {
-      const revealed = inspectState.revealService(serviceName);
+      const revealed = runState.revealService(serviceName);
       refreshContextPack();
       return revealed;
     },
@@ -228,6 +273,19 @@ export function createAssistantState({
       notify();
     },
 
+    setCliConfig(nextConfig) {
+      cliConfig = mergeCliConfig(cliConfig, nextConfig);
+      saveCliConfig(productDir, cliConfig);
+      runState.setAutoCollapsePassedTreeBranches(cliConfig.autoCollapsePassedTreeBranches);
+      notify();
+    },
+
+    resetCliConfig() {
+      cliConfig = resetCliConfig(productDir);
+      runState.setAutoCollapsePassedTreeBranches(cliConfig.autoCollapsePassedTreeBranches);
+      notify();
+    },
+
     resetSettings() {
       settings = resetAssistantSettings(productDir);
       resolvedProviderName = null;
@@ -239,6 +297,14 @@ export function createAssistantState({
       notify();
     },
 
+    getLiveRunSession() {
+      return liveRunSession;
+    },
+
+    getLastRunSession() {
+      return lastRunSession;
+    },
+
     async submitCurrentComposer() {
       const value = composerState.text.trim();
       composerState = createComposerState();
@@ -263,6 +329,7 @@ export function createAssistantState({
       }
       if (slash) {
         try {
+          setBusy(true, `Running ${slash.type}...`);
           await executeSlashCommand({
             slash,
             state,
@@ -277,6 +344,8 @@ export function createAssistantState({
             role: "system",
             text: error instanceof Error ? error.message : String(error),
           });
+        } finally {
+          setBusy(false, null);
         }
         refreshContextPack();
         notify();
@@ -286,6 +355,7 @@ export function createAssistantState({
       const routedSlash = routeLocalIntent(trimmed);
       if (routedSlash) {
         try {
+          setBusy(true, `Running ${routedSlash.type}...`);
           await executeSlashCommand({
             slash: routedSlash,
             state,
@@ -300,6 +370,8 @@ export function createAssistantState({
             role: "system",
             text: error instanceof Error ? error.message : String(error),
           });
+        } finally {
+          setBusy(false, null);
         }
         refreshContextPack();
         notify();
@@ -310,7 +382,7 @@ export function createAssistantState({
         setBusy(true, `Thinking with ${settings.provider === "auto" ? "provider" : settings.provider}...`);
         const emitted = await runAssistantConversationTurn({
           productDir,
-          inspectState,
+          runState,
           transcript: messages.map((entry) => ({ role: entry.role, text: entry.text })),
           userMessage: trimmed,
           settings,
@@ -334,7 +406,7 @@ export function createAssistantState({
             notify();
           },
           onToolEvent(event) {
-            handleAssistantToolEvent(event, appendMessage);
+            handleAssistantToolEvent(state, event, appendMessage);
           },
         });
         for (const message of emitted) appendMessage(message);
@@ -356,8 +428,8 @@ export function createAssistantState({
 
     getSnapshot() {
       return {
-        context: buildContextSelection(inspectState.getSnapshot()),
-        inspect: inspectState.getSnapshot(),
+        context: buildContextSelection(runState.getSnapshot()),
+        run: runState.getSnapshot(),
         productDir,
         messages: [...messages],
         composer: composerState.text,
@@ -369,8 +441,11 @@ export function createAssistantState({
         model: settings.model,
         effort: settings.effort,
         providerArgs: [...settings.providerArgs],
+        cliConfig,
         activeStatus,
         contextUsage,
+        liveRunSession: serializeRunSession(liveRunSession),
+        lastRunSession: serializeRunSession(lastRunSession),
         contextPaths: {
           contextPath: commandLog.contextPath,
           summaryPath: commandLog.summaryPath,
@@ -460,28 +535,32 @@ async function executeSlashCommand({
     appendMessage({ role: "assistant", text: "Assistant settings reset." });
     return;
   }
+  if (slash.type === "config-show") {
+    appendMessage({ role: "assistant", text: formatCliConfig(state.getSnapshot().cliConfig) });
+    return;
+  }
+  if (slash.type === "config-reset") {
+    state.resetCliConfig();
+    appendMessage({ role: "assistant", text: "CLI config reset." });
+    return;
+  }
+  if (slash.type === "config-set-auto-collapse") {
+    state.setCliConfig({ autoCollapsePassedTreeBranches: slash.value });
+    appendMessage({
+      role: "assistant",
+      text: `autoCollapsePassedTreeBranches set to ${slash.value}.`,
+    });
+    return;
+  }
 
   const result = await executeSlashTool(slash, {
     productDir,
-    inspectState: state.inspectState,
+    runState: state.runState,
     configs,
     env,
     commandLog: state.commandLog,
     onEvent(event) {
-      if (event.type === "tool-start") {
-        appendMessage({
-          role: "tool",
-          status: "running",
-          title: event.title || event.tool || "Tool",
-          text: event.message,
-          data: {
-            command: event.command || null,
-            testkitRelated: Boolean(event.testkitRelated),
-          },
-        });
-      } else if (event.type === "tool-status") {
-        state.setNotice(event.message);
-      }
+      handleAssistantToolEvent(state, event, appendMessage);
     },
     provider: settings.provider,
   });
@@ -494,18 +573,53 @@ async function executeSlashCommand({
   });
 }
 
-function handleAssistantToolEvent(event, appendMessage) {
-  if (!event || event.type !== "tool-start") return;
-  appendMessage({
-    role: "tool",
-    status: "running",
-    title: event.title || event.tool || "Tool",
-    text: event.message || "Running tool",
-    data: {
-      command: event.command || null,
-      testkitRelated: Boolean(event.testkitRelated),
-    },
-  });
+function handleAssistantToolEvent(state, event, appendMessage) {
+  if (!event) return;
+  if (event.type === "tool-start") {
+    appendMessage({
+      role: "tool",
+      status: "running",
+      title: event.title || event.tool || "Tool",
+      text: event.message || "Running tool",
+      data: {
+        command: event.command || null,
+        testkitRelated: Boolean(event.testkitRelated),
+      },
+    });
+    return;
+  }
+  if (event.type === "tool-status") {
+    state.setNotice(event.message);
+    return;
+  }
+  if (event.type === "run-session-start") {
+    state.attachRunSession(event.session, { active: true });
+    return;
+  }
+  if (event.type === "run-session-end") {
+    state.completeRunSession(event.session);
+    return;
+  }
+  if (event.type === "observed-run-artifact") {
+    const observedSession = {
+      productDir: state.getSnapshot().productDir,
+      runState: state.runState,
+      getSnapshot() {
+        return state.runState.getSnapshot();
+      },
+    };
+    state.attachRunSession(observedSession, { active: false });
+    return;
+  }
+  if (event.type === "observed-testkit-command") {
+    appendMessage({
+      role: "tool",
+      toolName: event.command?.kind || "testkit",
+      title: formatObservedCommandTitle(event.command),
+      text: formatObservedCommandText(event.command),
+      data: event.command || null,
+    });
+  }
 }
 
 function formatSettings(snapshot) {
@@ -520,62 +634,7 @@ function formatSettings(snapshot) {
 }
 
 async function executeSlashTool(slash, context) {
-  switch (slash.type) {
-    case "inspect":
-      return executeAssistantTool(
-        "read_context",
-        { file: slash.file || null, mode: "detail" },
-        context
-      );
-    case "logs":
-      return executeAssistantTool("read_context", { service: slash.service || null, mode: "logs" }, context);
-    case "artifacts":
-      return executeAssistantTool("read_context", { file: slash.file || null, mode: "artifacts" }, context);
-    case "setup":
-      return executeAssistantTool("read_context", { service: slash.service || null, mode: "setup" }, context);
-    case "file":
-      return executeAssistantTool("read_file", { path: slash.file }, context);
-    case "service":
-      return executeAssistantTool("read_context", { service: slash.service, mode: "detail" }, context);
-    case "status":
-      return executeAssistantTool("shell_exec", { command: "testkit status --dir ." }, context);
-    case "discover":
-      return executeAssistantTool("shell_exec", { command: "testkit discover --dir ." }, context);
-    case "doctor":
-      return executeAssistantTool("shell_exec", { command: "testkit doctor --dir ." }, context);
-    case "run":
-      return executeAssistantTool("shell_exec", { command: buildRunSlashCommand(slash.options) }, context);
-    default:
-      throw new Error(`Unsupported slash command "${slash.type}"`);
-  }
-}
-
-function buildRunSlashCommand(options = {}) {
-  const types = options.type || [];
-  const parts = ["testkit", "run"];
-  if (types.length === 1) {
-    parts.push(types[0]);
-  }
-  parts.push("--dir", ".");
-  if (types.length !== 1) {
-    for (const type of types) {
-      parts.push("--type", type);
-    }
-  }
-  for (const suite of options.suite || []) {
-    parts.push("--suite", suite);
-  }
-  for (const file of options.file || []) {
-    parts.push("--file", file);
-  }
-  if (options.service) parts.push("--service", options.service);
-  return parts.map(shellEscapeArg).join(" ");
-}
-
-function shellEscapeArg(value) {
-  const stringValue = String(value);
-  if (/^[a-zA-Z0-9._:/-]+$/.test(stringValue)) return stringValue;
-  return `'${stringValue.replace(/'/g, `'\\''`)}'`;
+  return executeAssistantAction(slash.type, slash, context);
 }
 
 function parseSlashCommandSafe(input) {
@@ -619,3 +678,31 @@ function routeLocalIntent(input) {
   if (/^list\s+test\s+files$/.test(normalized)) return { type: "discover" };
   return null;
 }
+
+function serializeRunSession(session) {
+  if (!session) return null;
+  return {
+    productDir: session.productDir,
+    snapshot: session.getSnapshot(),
+  };
+}
+
+function formatObservedCommandTitle(command) {
+  const kind = command?.kind || "command";
+  return `testkit ${kind}`;
+}
+
+function formatObservedCommandText(command) {
+  if (!command) return "Observed Testkit command.";
+  const lines = [];
+  lines.push(`$ testkit ${command.argv?.join(" ") || command.kind || ""}`.trim());
+  if (Number.isInteger(command.exitCode)) lines.push(`exit code: ${command.exitCode}`);
+  const rows = command.result?.runSession?.summaryData?.rows || command.result?.summaryRows || command.result?.runArtifact?.summaryRows || null;
+  if (Array.isArray(rows) && rows.length > 0) {
+    for (const [label, value] of rows) lines.push(`${label}: ${value}`);
+  } else if (command.kind === "run" && command.result?.runArtifact?.summary?.files) {
+    const files = command.result.runArtifact.summary.files;
+    lines.push(`Files: ${files.total || 0} total, ${files.passed || 0} passed, ${files.failed || 0} failed, ${files.skipped || 0} skipped`);
+  }
+  return lines.join("\n");
+}

package/lib/cli/assistant/view-model.mjs

@@ -23,7 +23,7 @@ export function buildAssistantViewModel(snapshot, { cwd = process.cwd(), termina
 }
 
 export function buildWelcomeModel(snapshot, { cwd = process.cwd(), providerLabel = null } = {}) {
-  const summaryRows = snapshot?.inspect?.summaryData?.rows || snapshot?.summaryData?.rows || [];
+  const summaryRows = snapshot?.run?.summaryData?.rows || snapshot?.summaryData?.rows || [];
   const rowValue = (label) => summaryRows.find(([key]) => key === label)?.[1] || null;
   const contextSelection = snapshot?.context?.selection || {};
   const latestResult = rowValue("Result");

package/lib/cli/command-flags.mjs

@@ -0,0 +1,61 @@
+import { Flags } from "@oclif/core";
+
+export const sharedFlags = {
+  dir: Flags.string({
+    description: "Explicit product directory",
+  }),
+  service: Flags.string({
+    description: "Limit the operation or assistant context to one service",
+  }),
+};
+
+export const runFlags = {
+  ...sharedFlags,
+  type: Flags.string({
+    char: "t",
+    multiple: true,
+    description: "Run specific suite type(s): int, e2e, scenario, dal, load, pw, all",
+  }),
+  suite: Flags.string({
+    char: "s",
+    multiple: true,
+    description: "Run specific suite(s)",
+  }),
+  file: Flags.string({
+    char: "f",
+    multiple: true,
+    description: "Run specific file(s)",
+  }),
+  workers: Flags.string({
+    description: "Number of test executors for the whole run",
+  }),
+  "file-timeout-seconds": Flags.string({
+    description: "Per-file wall-clock timeout in seconds",
+  }),
+  shard: Flags.string({
+    description: "Run only shard i of n at suite granularity",
+  }),
+  seed: Flags.string({
+    description: "Deterministic seed for scenario suites",
+  }),
+  "write-status": Flags.boolean({
+    description: "Write a deterministic testkit.status.json snapshot",
+    default: false,
+  }),
+  "allow-partial-status": Flags.boolean({
+    description: "Allow --write-status for filtered runs",
+    default: false,
+  }),
+  "ignore-skip-rules": Flags.boolean({
+    description: "Run files even if testkit.config.ts marks them skipped",
+    default: false,
+  }),
+  "output-mode": Flags.string({
+    description: "Reporter mode",
+    options: ["compact", "debug", "events"],
+  }),
+  debug: Flags.boolean({
+    description: "Alias for --output-mode debug",
+    default: false,
+  }),
+};

package/lib/cli/commands/assistant.mjs

@@ -1,5 +1,7 @@
 import { Command, Flags } from "@oclif/core";
-import { sharedFlags, resolveConfigsForCommand } from "../command-helpers.mjs";
+import { loadManagedConfigs } from "../../app/configs.mjs";
+import { loadLatestRunArtifact, resolveFileSubject } from "../../results/artifacts.mjs";
+import { sharedFlags } from "../command-flags.mjs";
 import { createAssistantState } from "../assistant/state.mjs";
 import { runInteractiveAssistant } from "../assistant/interactive.mjs";
 
@@ -44,7 +46,7 @@ export default class AssistantCommand extends Command {
     if (flags.message && flags.prompt) {
       this.error("Use either --message or --prompt, not both.");
     }
-    const { allConfigs } = await resolveConfigsForCommand(flags);
+    const { allConfigs } = await loadManagedConfigs({ dir: flags.dir, service: flags.service });
     const productDir = allConfigs[0]?.productDir || process.cwd();
     const interactive =
       (process.stdout.isTTY || process.env.TESTKIT_FORCE_INTERACTIVE_ASSISTANT === "1") &&
@@ -70,7 +72,6 @@ export default class AssistantCommand extends Command {
       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);

package/lib/cli/commands/browser/serve.mjs

@@ -1,6 +1,6 @@
 import { Command, Flags } from "@oclif/core";
-import { startBrowserBridgeServer } from "@elench/testkit-bridge";
-import { loadBrowserBridgeContext } from "../../../app/browser-bridge.mjs";
+import { executeBrowserServeOperation } from "../../operations/browser/serve/operation.mjs";
+import { renderBrowserServeResult } from "../../renderers/browser-serve/text.mjs";
 
 export default class BrowserServeCommand extends Command {
   static summary = "Serve the local browser bridge for the current testkit product";
@@ -23,31 +23,13 @@ export default class BrowserServeCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(BrowserServeCommand);
-    const { productDir, context } = await loadBrowserBridgeContext({ dir: flags.dir });
-
-    const adapter = {
-      loadProductContext: async () => context,
-    };
-
-    const serverRef = await startBrowserBridgeServer(adapter, {
-      host: flags.host,
-      port: flags.port,
-    });
-
-    const payload = {
-      ok: true,
-      productDir,
-      host: serverRef.host,
-      port: serverRef.port,
-      url: serverRef.url,
-    };
+    const result = await executeBrowserServeOperation(flags);
 
     if (!this.jsonEnabled()) {
-      this.log(`testkit browser bridge serving ${productDir}`);
-      this.log(`Listening on ${serverRef.url}`);
+      for (const line of renderBrowserServeResult(result)) this.log(line);
     }
 
     await new Promise(() => {});
-    return payload;
+    return result;
   }
 }

package/lib/cli/commands/cleanup.mjs

@@ -1,5 +1,7 @@
 import { Command } from "@oclif/core";
-import { runStatusLike, sharedFlags } from "../command-helpers.mjs";
+import { sharedFlags } from "../command-flags.mjs";
+import { executeCleanupOperation } from "../operations/cleanup/operation.mjs";
+import { renderCleanupResult } from "../renderers/cleanup/text.mjs";
 
 export default class CleanupCommand extends Command {
   static summary = "Clean stale local testkit state";
@@ -10,6 +12,10 @@ export default class CleanupCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(CleanupCommand);
-    return runStatusLike("cleanup", flags);
+    const result = await executeCleanupOperation(flags);
+    if (!this.jsonEnabled()) {
+      for (const line of renderCleanupResult(result)) this.log(line);
+    }
+    return { ok: true, ...result };
   }
 }

package/lib/cli/commands/db/snapshot/capture.mjs

@@ -1,6 +1,7 @@
 import { Command, Flags } from "@oclif/core";
-import { sharedFlags } from "../../../command-helpers.mjs";
-import { runDatabaseSnapshotCaptureCommand } from "../../../db.mjs";
+import { sharedFlags } from "../../../command-flags.mjs";
+import { executeDatabaseSnapshotCaptureOperation } from "../../../operations/db/snapshot/capture/operation.mjs";
+import { renderDatabaseSnapshotCaptureResult } from "../../../renderers/db-snapshot-capture/text.mjs";
 
 export default class DbSnapshotCaptureCommand extends Command {
   static summary = "Capture a database schema snapshot";
@@ -16,7 +17,10 @@ export default class DbSnapshotCaptureCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(DbSnapshotCaptureCommand);
-    await runDatabaseSnapshotCaptureCommand(flags);
-    return { ok: true };
+    const result = await executeDatabaseSnapshotCaptureOperation(flags);
+    if (!this.jsonEnabled()) {
+      for (const line of renderDatabaseSnapshotCaptureResult(result)) this.log(line);
+    }
+    return result;
   }
 }

package/lib/cli/commands/destroy.mjs

@@ -1,5 +1,7 @@
 import { Command } from "@oclif/core";
-import { runStatusLike, sharedFlags } from "../command-helpers.mjs";
+import { sharedFlags } from "../command-flags.mjs";
+import { executeDestroyOperation } from "../operations/destroy/operation.mjs";
+import { renderDestroyResult } from "../renderers/destroy/text.mjs";
 
 export default class DestroyCommand extends Command {
   static summary = "Destroy local testkit state";
@@ -10,6 +12,10 @@ export default class DestroyCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(DestroyCommand);
-    return runStatusLike("destroy", flags);
+    const results = await executeDestroyOperation(flags);
+    if (!this.jsonEnabled()) {
+      for (const line of renderDestroyResult(results)) this.log(line);
+    }
+    return { ok: true, results };
   }
 }