@elench/testkit 0.1.96 → 0.1.98

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

@@ -1,11 +1,19 @@
 import fs from "fs";
 import path from "path";
 import { execaCommand } from "execa";
-import { loadCurrentRunArtifact, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
-import {
-  readContextContent,
-} from "../context-resources.mjs";
-import { extractShellCommand, planShellCommand } from "./command-plan.mjs";
+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;
@@ -13,9 +21,29 @@ 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. Use local testkit commands for testkit work.",
+      description: "Execute a shell command inside the repository for arbitrary repo work outside first-class testkit actions.",
     },
     {
       name: "read_context",
@@ -35,6 +63,16 @@ export function listAssistantTools() {
 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":
@@ -49,10 +87,13 @@ export async function executeAssistantTool(name, argumentsObject, context) {
 }
 
 async function shellExecTool(args, context) {
-  const command = extractShellCommand(args).trim();
+  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 = planShellCommand(command);
+  const shellCommand = classifyShellCommand(command);
   const commandId = `cmd-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
   context.commandLog?.appendCommandLog({
     type: "command_start",
@@ -60,22 +101,17 @@ async function shellExecTool(args, context) {
     commandId,
     cwd: context.productDir,
     raw: command,
-    executable: shellCommand.executableCommand,
-    normalized: shellCommand.normalized,
   });
   context.onEvent?.({
     type: "tool-start",
     tool: "shell_exec",
-    command: shellCommand.executableCommand,
-    rawCommand: command,
+    command,
     title: shellCommand.title,
     testkitRelated: shellCommand.testkitRelated,
-    message: shellCommand.normalized
-      ? `Running ${shellCommand.displayCommand} (${shellCommand.normalizationReason})`
-      : `Running ${shellCommand.displayCommand}`,
+    message: `Running ${shellCommand.display}`,
   });
 
-  const result = await execaCommand(shellCommand.executableCommand, {
+  const result = await execaCommand(command, {
     cwd: context.productDir,
     reject: false,
     shell: true,
@@ -93,21 +129,18 @@ async function shellExecTool(args, context) {
     commandId,
     cwd: context.productDir,
     raw: command,
-    executable: shellCommand.executableCommand,
-    normalized: shellCommand.normalized,
     code: result.exitCode ?? 0,
     signal: result.signal ?? null,
   });
   context.onEvent?.({
     type: "tool-exit",
     tool: "shell_exec",
-    command: shellCommand.executableCommand,
-    rawCommand: command,
+    command,
     title: shellCommand.title,
     testkitRelated: shellCommand.testkitRelated,
     code: result.exitCode ?? 0,
     signal: result.signal ?? null,
-    message: `${shellCommand.displayCommand} exited ${result.exitCode ?? 0}`,
+    message: `${shellCommand.display} exited ${result.exitCode ?? 0}`,
   });
 
   if (shellCommand.testkitRelated) {
@@ -115,15 +148,13 @@ async function shellExecTool(args, context) {
   }
   context.commandLog?.refresh?.();
 
-  const lines = formatCommandResult(result, shellCommand);
+  const lines = formatCommandResult(command, result, shellCommand);
   return {
     ok: (result.exitCode ?? 0) === 0,
     title: shellCommand.title,
     text: lines.join("\n"),
     data: {
       command,
-      executableCommand: shellCommand.executableCommand,
-      normalizedCommand: shellCommand.normalized,
       stdout: result.stdout || "",
       stderr: result.stderr || "",
       exitCode: result.exitCode ?? 0,
@@ -133,22 +164,179 @@ async function shellExecTool(args, context) {
   };
 }
 
+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.inspectState.getSnapshot().runArtifact;
+    const artifact = context.runState.getSnapshot().runArtifact;
     const subject = resolveFileSubject(artifact, args.file || args.path, args.service || null);
-    context.inspectState.revealFile(subject.service.name, subject.file.path);
+    context.runState.revealFile(subject.service.name, subject.file.path);
   } else if (args.service) {
     ensureArtifactLoaded(context);
-    if (!context.inspectState.revealService(args.service)) {
+    if (!context.runState.revealService(args.service)) {
       throw new Error(`Unknown service "${args.service}"`);
     }
   }
 
   const content = readContextContent({
     productDir: context.productDir,
-    snapshot: context.inspectState.getSnapshot(),
+    snapshot: context.runState.getSnapshot(),
     mode: normalizeContextMode(args.mode),
     logTail: args.logTail == null ? 12 : Number(args.logTail),
   });
@@ -227,11 +415,23 @@ async function searchRepoTool(args, context) {
   };
 }
 
-function formatCommandResult(result, shellCommand) {
-  const lines = [`$ ${shellCommand.displayCommand}`];
-  if (shellCommand.normalized) {
-    lines.push(`normalized from: ${shellCommand.rawCommand}`);
-  }
+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 = [];
@@ -265,6 +465,92 @@ 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, `'\\''`)}'`;
 }
@@ -275,22 +561,22 @@ function normalizeContextMode(mode) {
 }
 
 function ensureArtifactLoaded(context) {
-  const snapshot = context.inspectState.getSnapshot();
+  const snapshot = context.runState.getSnapshot();
   if (snapshot.runArtifact) return snapshot.runArtifact;
   try {
-    context.inspectState.hydrateFromArtifact(loadCurrentRunArtifact(context.productDir));
+    context.runState.hydrateFromArtifact(loadCurrentRunArtifact(context.productDir));
   } catch {
-    context.inspectState.hydrateFromArtifact(loadLatestRunArtifact(context.productDir));
+    context.runState.hydrateFromArtifact(loadLatestRunArtifact(context.productDir));
   }
-  return context.inspectState.getSnapshot().runArtifact;
+  return context.runState.getSnapshot().runArtifact;
 }
 
 function refreshArtifactSelection(context) {
   try {
-    context.inspectState.hydrateFromArtifact(loadCurrentRunArtifact(context.productDir));
+    context.runState.hydrateFromArtifact(loadCurrentRunArtifact(context.productDir));
   } catch {
     try {
-      context.inspectState.hydrateFromArtifact(loadLatestRunArtifact(context.productDir));
+      context.runState.hydrateFromArtifact(loadLatestRunArtifact(context.productDir));
     } catch {
       // Ignore missing artifacts.
     }

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/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 "./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 "./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 "../../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 "./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 };
   }
 }

package/lib/cli/commands/discover.mjs

@@ -1,11 +1,7 @@
-import fs from "fs";
-import path from "path";
 import { Command, Flags } from "@oclif/core";
-import { discoverTests } from "../../discovery/index.mjs";
-import { resolveProductDir } from "../../config/index.mjs";
-import { buildDiscoveryReportLines } from "../presentation/discovery-reporter.mjs";
-import { resolveRequestedFiles } from "../args.mjs";
-import { sharedFlags } from "../command-helpers.mjs";
+import { executeDiscoverOperation } from "../operations/discover/operation.mjs";
+import { renderDiscoverResult } from "../renderers/discover/text.mjs";
+import { sharedFlags } from "./flags.mjs";
 
 export default class DiscoverCommand extends Command {
   static summary = "Discover managed tests and report their metadata";
@@ -49,30 +45,12 @@ export default class DiscoverCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(DiscoverCommand);
-    const productDir = resolveProductDir(process.cwd(), flags.dir);
-    const fileNames = resolveRequestedFiles(flags.file || [], productDir, process.cwd());
-    const result = await discoverTests({
-      dir: productDir,
-      service: flags.service || null,
-      type: flags.type || [],
-      suite: flags.suite || [],
-      file: fileNames,
-      runnableOnly: flags["runnable-only"],
-      diagnostics: flags.strict ? "error" : "report",
-    });
-    let outputLabel = null;
-    if (flags.output) {
-      const outputPath = path.resolve(productDir, flags.output);
-      fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-      fs.writeFileSync(outputPath, `${JSON.stringify(result, null, 2)}\n`);
-      outputLabel = path.relative(productDir, outputPath) || path.basename(outputPath);
-    }
+    const result = await executeDiscoverOperation(flags, process.cwd());
 
     if (!this.jsonEnabled()) {
-      for (const line of buildDiscoveryReportLines(result, { outputMode: flags["output-mode"] })) {
+      for (const line of renderDiscoverResult(result, { outputMode: flags["output-mode"] })) {
         this.log(line);
       }
-      if (outputLabel) this.log(`Wrote ${outputLabel}`);
     }
 
     return result;