@mintlify/cli 4.0.1654 → 4.0.1656

package/src/agent-harness/MINT_TEST_SYSTEM_DESIGN.md

@@ -1,64 +0,0 @@
-# `mint test` system design
-
-`packages/cli` owns command parsing and terminal interaction. `packages/cli/src/agent-harness` collects code blocks, runs agents, validates generated projects, executes commands, and writes reports so other callers can use the same test engine without the CLI.
-
-```mermaid
-flowchart TD
-    User[Developer] --> Command["mint test [path]"]
-
-    subgraph CLI["packages/cli"]
-        Command --> Args["Parse path, agent, scope, and TUI flags"]
-        Mode{"Interactive TTY?"}
-        UI["Ink flow: agent, code blocks, scope, progress, results"]
-        Plain["Non-interactive runner with Claude default"]
-        Exit["Print summary and set exit code"]
-    end
-
-    subgraph Harness["packages/cli/src/agent-harness"]
-        Collect["collectCodeBlocks"]
-        Collection["CodeBlockCollection"]
-        Run["runCodeTests<br/>tasks and inline preflight, progress, and report writes"]
-        Prompt["AgentRunner.prompt()<br/>ClaudeRunner or CodexRunner"]
-        Validate["Manifest validation inside runCodeTests<br/>schema, paths, block coverage, and executables"]
-        Execute["executeCodeTestCommand<br/>setup and test commands without a shell"]
-        Report["CodeTestReport<br/>persisted as report.json"]
-    end
-
-    Docs["Documentation source, read only"] --> Collect
-    Args --> Collect
-    Collect --> Collection
-    Collection --> Mode
-    Mode -->|yes| UI
-    Mode -->|no| Plain
-    UI -->|selected agents and files| Run
-    Plain -->|default agent and selected files| Run
-    Collection -->|collected blocks| Run
-    Run --> Prompt --> Validate --> Execute --> Report
-    Docs -. "read-only context" .-> Prompt
-    Run -. "inline progress callbacks" .-> UI
-    Report --> Exit
-```
-
-## Type contracts
-
-The harness exports five types. Status unions and nested block, environment, summary, command, and task fields live on the contract that owns them.
-
-| Exported type           | Contract                                                                                                                                                                                                                  |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `HarnessAgent`          | The supported runner names, `claude` and `codex`.                                                                                                                                                                         |
-| `AgentRunner`           | One `prompt(prompt)` method returning the final response text. `ClaudeRunner` and `CodexRunner` implement it.                                                                                                             |
-| `CodeBlockCollection`   | The docs root and fenced block locations grouped by markdown file. `collectCodeBlocks` returns it.                                                                                                                        |
-| `GeneratedTestManifest` | The normalized output of the runtime `mint-test.json` schema: generated files plus setup and test commands. Command ids are optional in the file; `manifestSchema` assigns `setup-N` / `test-N` when an agent omits them. |
-| `CodeTestReport`        | The complete persisted `report.json` shape. Task, block, command, environment, summary, and status fields are nested here.                                                                                                |
-
-`GeneratedTestManifest` is produced by the runtime schema in `packages/cli/src/agent-harness/types.ts` (`manifestFileSchema.transform(assignCommandIds)`), so validation and TypeScript cannot drift apart. Contract changes still require a schema test and an update to this table.
-
-`packages/cli/src/agent-harness/manifest.ts` owns reading the manifest. It turns a missing file, invalid JSON, or a schema mismatch into one actionable message per problem; that message is what the UI, the non-interactive summary, and `report.json` show for the page. Each task directory also keeps `mint-test-agent.md` (the agent's final summary per attempt) and, after a failed generation, `mint-test-error.txt` (every attempt's failure reason).
-
-`runCodeTests` loads each selected agent SDK before any page is checked (`agentPreflight.ts`), so a missing optional dependency fails the run once with an install hint instead of failing every page minutes later.
-
-`runCodeTests` runs the pipeline in order: `setupFolders` picks the run id, creates the run directory, and builds one task per agent and page without creating task directories; `checkTestability` asks a small model whether each page is testable, running from the run directory, and only once a page is proven testable creates its task directory and writes `mint-test-check.json` there; `scaffoldTaskDirectories` then adds `tests/` and `package.json` to those same tasks; `generateTestCode` and `executeCodeBlocks` skip every other task. A page that is not testable leaves nothing on disk. A resumed run reuses the check file for testable pages, re-checks the others, and re-applies the scaffold, which is idempotent.
-
-`runCodeTests` declares its input object and progress events on the function. `executeCodeTestCommand` does the same for command input. Neither API has a separate options, request, progress, preflight, command-runner, or command-result type to keep in sync.
-
-The manifest is the boundary between generated agent output and trusted execution. The harness rejects commands outside the allowlist or task workspace, runs each command with `shell: false`, applies timeouts and cancellation, redacts secrets from captured output, and records every state change in the report.

package/src/agent-harness/agentPreflight.ts

@@ -1,13 +0,0 @@
-import { loadClaudeAgentSdk, loadCodexSdk } from './loadAgentSdk.js';
-import type { HarnessAgent } from './types.js';
-
-/**
- * Fail fast, before any page is checked, when an agent SDK is not installed. Without this every
- * page reports the same missing-dependency error minutes later as "test could not be generated".
- */
-export async function ensureAgentSdks(agents: Iterable<HarnessAgent>): Promise<void> {
-  for (const agent of new Set(agents)) {
-    if (agent === 'claude') await loadClaudeAgentSdk();
-    else await loadCodexSdk();
-  }
-}

package/src/agent-harness/buildTaskPrompt.ts

@@ -1,93 +0,0 @@
-import path from 'node:path';
-
-import { SAFE_EXECUTABLES } from './manifest.js';
-
-export const SYSTEM_PROMPT = `# Mint test generator
-
-You will be given a markdown documentation page that contains code blocks. Follow the page and
-implement the code as the page instructs, inside the given output directory.
-
-Once finished, create a mint-test.json file in the current working directory with this shape:
-
-{
-  "version": 1,
-  "generatedFiles": ["tests/example.test.js", "tests/test_example.py"],
-  "setupCommands": [],
-  "testCommands": [
-    {
-      "id": "node-tests",
-      "executable": "node",
-      "args": ["--test"],
-      "cwd": ".",
-      "timeoutMs": 120000
-    },
-    {
-      "id": "python-tests",
-      "executable": "python3",
-      "args": ["-m", "unittest", "discover", "-s", "tests"],
-      "cwd": ".",
-      "timeoutMs": 120000
-    }
-  ]
-}
-
-Manifest rules:
-- "generatedFiles" lists every file you wrote, as paths relative to the current working directory. Each one must exist.
-- Every command has a unique "id" (letters, digits, dashes). Command "cwd" values are relative to the current working directory.
-- "executable" must be one of: ${[...SAFE_EXECUTABLES].join(', ')}, or a "./" script inside the current working directory. Do not use a shell, pipes, or "&&".
-- Do not add any other keys to the manifest.
-
-Finish with a short plain-text summary of what you tested and anything you could not test.
-
-Rules:
-- Read only the page named in the task. You may also read docs.json and an OpenAPI file referenced by that page.
-- The output directory is already scaffolded: package.json exists with "npm test" wired to "node --test", and a tests/ directory is ready. Do not recreate or rewrite this scaffolding.
-- Run JavaScript tests with "node" and args ["--test"] from the task directory (no directory argument: on Node 21+ a path like "tests/" is treated as a glob and finds nothing). Node discovers tests/*.test.js on its own.
-- Write JavaScript and TypeScript tests as ES modules named tests/*.test.js using the Node built-in test runner (node:test and node:assert). Write Python tests as tests/test_*.py using the standard library unittest module, run with python3 -m unittest discover -s tests.
-- Prefer the standard library over installing dependencies; add a setup command only when a test truly cannot run without one.
-- Never write README, docs, or explanation files.
-- Keep helpers inline in the test file; do not create separate helper modules.
-- Write one test file per page unless the page genuinely needs more.
-- Create every additional source file and fixture inside the current working directory.
-- Never modify the documentation source. Do not commit, push, or open a pull request.
-- Cover fenced code blocks inside Mintlify components such as CodeGroup, Tabs, Steps, RequestExample, and ResponseExample.
-- If the page has openapi frontmatter, you may resolve its spec relative to the docs root and add tests for request snippets.
-- Do not install dependencies or run the generated tests. The Mint CLI handles setup and execution.
-- Never copy secrets into a file. In your code pull secrets from .env
-`;
-
-export function buildTaskPrompt(docsRoot: string, file: string, directory: string): string {
-  return `
-Use the guide at "${JSON.stringify(path.join(docsRoot, file))}"
-
-Write the required tests and mint-test.json output in the "${JSON.stringify(directory)}" directory.
-Record your report here "${JSON.stringify(file)}"`;
-}
-
-export const CHECK_SYSTEM_PROMPT = `# Mint test triage
-You are given a markdown page guide. Decide if the given file is able to be tested.
-
-Testable pages are pages that include any runnable code (python, typescript, bash) and any logic that could fail if the documented code was wrong
-
-Code blocks are not testable when it is used for formatting, showing logs, configuration, pseudo-code or a diff, an illustrative request or response shape, or a UI-only example.
-
-When unsure, mark it not testable.
-
-Include "reason" only when the page is not testable; omit it entirely when testable is true.`;
-
-export const CHECK_TOOL_INSTRUCTION = `
-
-Report your classification by calling the report_testability tool`;
-
-export const CHECK_JSON_INSTRUCTION = `
-
-Respond with only this JSON object and nothing else:
-{ "version": 1, "testable": false, "reason": "expected output, not runnable code" }`;
-
-export function buildCheckPrompt(file: string, fileContent: string): string {
-  return `Report if the file at filePath ${JSON.stringify(file)} is testable
-
-<file>
-${fileContent}
-</file>`;
-}

package/src/agent-harness/countReport.ts

@@ -1,17 +0,0 @@
-import type { TaskResult } from './types.js';
-
-export interface ReportCounts {
-  passed: number;
-  failed: number;
-  cancelled: number;
-  agentErrors: number;
-}
-
-export function countReport(tasks: TaskResult[]): ReportCounts {
-  const counts: ReportCounts = { passed: 0, failed: 0, cancelled: 0, agentErrors: 0 };
-  for (const task of tasks) {
-    if (task.status === 'agent_error') counts.agentErrors++;
-    else counts[task.status]++;
-  }
-  return counts;
-}

package/src/agent-harness/discoverCodeBlocks.ts

@@ -1,90 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-import type { DocsPage } from './types.js';
-
-const PAGE_EXTENSIONS = new Set(['.md', '.mdx']);
-const IGNORED_DIRECTORIES = new Set(['.git', '.next', 'build', 'dist', 'node_modules']);
-const OPENING_FENCE_PATTERN = /^\s*(`{3,}|~{3,})/;
-
-function countFencedBlocks(content: string): number {
-  const lines = content.split(/\r?\n/);
-  let count = 0;
-  for (let index = 0; index < lines.length; index++) {
-    const opening = OPENING_FENCE_PATTERN.exec(lines[index] ?? '');
-    const marker = opening?.[1];
-    if (!marker) continue;
-    const closingPattern = new RegExp(`^\\s*${marker[0]}{${marker.length},}\\s*$`);
-    let closingIndex = index + 1;
-    while (closingIndex < lines.length && !closingPattern.test(lines[closingIndex] ?? '')) {
-      closingIndex++;
-    }
-    if (closingIndex >= lines.length) break;
-    count++;
-    index = closingIndex;
-  }
-  return count;
-}
-
-async function findSiteRoot(startDirectory: string): Promise<string | null> {
-  const { root } = path.parse(startDirectory);
-  let directory = startDirectory;
-  let previous: string | null = null;
-  while (directory !== previous) {
-    for (const configName of ['docs.json', 'mint.json']) {
-      const stats = await fs.stat(path.join(directory, configName)).catch(() => null);
-      if (stats?.isFile()) return directory;
-    }
-    if (directory === root) return null;
-    previous = directory;
-    directory = path.dirname(directory);
-  }
-  return null;
-}
-
-export async function discoverCodeBlocks(
-  inputPath: string
-): Promise<{ docsRoot: string; pages: DocsPage[] }> {
-  const resolvedPath = path.resolve(inputPath);
-  const stats = await fs.stat(resolvedPath);
-  const baseDirectory = stats.isDirectory() ? resolvedPath : path.dirname(resolvedPath);
-  const docsRoot = (await findSiteRoot(baseDirectory)) ?? baseDirectory;
-
-  const filePaths: string[] = [];
-  if (stats.isDirectory()) {
-    const directories = [resolvedPath];
-    while (directories.length > 0) {
-      const directory = directories.pop();
-      if (!directory) break;
-      for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
-        const entryPath = path.join(directory, entry.name);
-        if (
-          entry.isDirectory() &&
-          !IGNORED_DIRECTORIES.has(entry.name) &&
-          !(entry.name === 'mint-test' && path.basename(directory) === 'tests')
-        ) {
-          directories.push(entryPath);
-        } else if (entry.isFile() && PAGE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
-          filePaths.push(entryPath);
-        }
-      }
-    }
-  } else if (stats.isFile() && PAGE_EXTENSIONS.has(path.extname(resolvedPath).toLowerCase())) {
-    filePaths.push(resolvedPath);
-  } else {
-    throw new Error(`Expected a docs directory or an MD/MDX file: ${resolvedPath}`);
-  }
-
-  const pages: DocsPage[] = [];
-  for (const filePath of filePaths.sort()) {
-    const content = await fs.readFile(filePath, 'utf8');
-    const blockCount = countFencedBlocks(content);
-    if (blockCount > 0) {
-      pages.push({
-        file: path.relative(docsRoot, filePath).split(path.sep).join('/'),
-        blockCount,
-      });
-    }
-  }
-  return { docsRoot, pages };
-}

package/src/agent-harness/executeCodeBlocks.ts

@@ -1,351 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-
-import { mapWithConcurrency } from './mapWithConcurrency.js';
-import type {
-  CommandResult,
-  GeneratedTask,
-  TaskUpdate,
-  ManifestCommand,
-  TaskResult,
-} from './types.js';
-
-const MAX_STREAM_BYTES = 128 * 1024;
-const KILL_GRACE_MS = 2_000;
-const FAILURE_PRECEDENCE = ['failed', 'cancelled'] as const;
-const SECRET_NAME_PATTERN = /(TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY|CREDENTIAL)/i;
-
-function redactSecrets(value: string): string {
-  let redacted = value;
-  const secrets = Object.entries(process.env)
-    .filter(
-      ([name, secret]) =>
-        SECRET_NAME_PATTERN.test(name) && typeof secret === 'string' && secret.length >= 8
-    )
-    .map(([, secret]) => secret as string)
-    .sort((left, right) => right.length - left.length);
-  for (const secret of secrets) redacted = redacted.split(secret).join('[REDACTED]');
-  return redacted
-    .replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, 'Bearer [REDACTED]')
-    .replace(/\b(?:sk|sess)-[A-Za-z0-9._-]{12,}\b/gi, '[REDACTED]');
-}
-
-function outputCollector(): { append: (chunk: Buffer | string) => void; value: () => string } {
-  let output = '';
-  let bytes = 0;
-  let truncated = false;
-  return {
-    append(chunk) {
-      if (truncated) return;
-      const value = chunk.toString();
-      const remaining = MAX_STREAM_BYTES - bytes;
-      if (Buffer.byteLength(value) <= remaining) {
-        output += value;
-        bytes += Buffer.byteLength(value);
-        return;
-      }
-      output += Buffer.from(value).subarray(0, Math.max(0, remaining)).toString();
-      output += '\n[mint test: output truncated]\n';
-      truncated = true;
-    },
-    value: () => output,
-  };
-}
-
-const MAX_FAILURE_LINE_LENGTH = 200;
-const TAP_SUMMARY_PATTERN =
-  /^#\s*(tests|suites|pass|fail|cancelled|skipped|todo|duration_ms)\b|^1\.\.\d+$|^TAP version/;
-const ERROR_LINE_PATTERN = /\b(?:[A-Za-z]*Error|Traceback|FAILED|ModuleNotFoundError)\b/;
-const TAP_METADATA_PATTERN = /^(name|code|failureType|location|stack)\s*:/;
-
-/**
- * The most useful single line from a failed command's output: the first thrown error, else the
- * first failing TAP assertion, else the last line that is not a TAP summary.
- */
-export function pickFailureLine(text: string): string {
-  const lines = text
-    .split(/\r?\n/)
-    .map((raw) => raw.trim())
-    .filter((raw) => raw.length > 0 && !raw.startsWith('[mint test:'))
-    .map((raw) => ({ raw, text: raw.replace(/^#\s?/, '').trim() }))
-    .filter((line) => line.text.length > 0);
-  const thrown = lines.find(
-    ({ text: candidate }) =>
-      ERROR_LINE_PATTERN.test(candidate) &&
-      !candidate.startsWith('at ') &&
-      !/^(ok|Traceback)\b/.test(candidate) &&
-      !TAP_METADATA_PATTERN.test(candidate)
-  );
-  const assertion = lines.find(({ text: candidate }) => candidate.startsWith('not ok'));
-  const informative = lines.filter(({ raw }) => !TAP_SUMMARY_PATTERN.test(raw));
-  const line =
-    thrown?.text ??
-    assertion?.text ??
-    informative[informative.length - 1]?.text ??
-    lines[lines.length - 1]?.text ??
-    '';
-  return line.length > MAX_FAILURE_LINE_LENGTH
-    ? `${line.slice(0, MAX_FAILURE_LINE_LENGTH - 1)}…`
-    : line;
-}
-
-/** One line explaining the first command that did not pass, for the UI and the report. */
-export function summarizeCommandFailure(commands: CommandResult[]): string | undefined {
-  const failed = commands.find((command) => command.status !== 'passed');
-  if (!failed) return undefined;
-  const invocation = [failed.executable, ...failed.args].join(' ');
-  const reason =
-    failed.error ??
-    (failed.exitCode === null ? 'did not exit cleanly' : `exited with code ${failed.exitCode}`);
-  const detail = pickFailureLine(failed.stderr) || pickFailureLine(failed.stdout);
-  return `${failed.phase} command \`${invocation}\` ${reason}${detail ? `: ${detail}` : ''}`;
-}
-
-function unrunCommandResult(
-  command: ManifestCommand,
-  phase: 'setup' | 'test',
-  cwd: string,
-  status: 'failed' | 'cancelled',
-  error: string
-): CommandResult {
-  return {
-    id: command.id,
-    phase,
-    status,
-    executable: command.executable,
-    args: command.args,
-    cwd,
-    durationMs: 0,
-    exitCode: null,
-    stdout: '',
-    stderr: '',
-    error,
-  };
-}
-
-function spawnCommand({
-  command,
-  phase,
-  cwd,
-  timeoutMs,
-  signal,
-  docsRootForCommands,
-}: {
-  command: ManifestCommand;
-  phase: 'setup' | 'test';
-  cwd: string;
-  timeoutMs: number;
-  signal: AbortSignal;
-  docsRootForCommands: string;
-}): Promise<CommandResult> {
-  const startedAt = Date.now();
-  const base = {
-    id: command.id,
-    phase,
-    executable: command.executable,
-    args: command.args,
-    cwd,
-  };
-  const commandTimeoutMs = command.timeoutMs ?? timeoutMs;
-
-  return new Promise((resolve) => {
-    const stdout = outputCollector();
-    const stderr = outputCollector();
-    let completed = false;
-    let timedOut = false;
-    let cancelled = false;
-    let forceKillTimer: NodeJS.Timeout | undefined;
-
-    const child = spawn(command.executable, command.args, {
-      cwd,
-      detached: true,
-      env: { ...process.env, MINT_DOCS_ROOT: docsRootForCommands },
-      shell: false,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    child.stdout.on('data', stdout.append);
-    child.stderr.on('data', stderr.append);
-
-    const killTree = (killSignal: NodeJS.Signals) => {
-      if (child.pid) {
-        try {
-          process.kill(-child.pid, killSignal);
-          return;
-        } catch {
-          /* noop */
-        }
-      }
-      child.kill(killSignal);
-    };
-    const kill = () => {
-      killTree('SIGTERM');
-      forceKillTimer = setTimeout(() => killTree('SIGKILL'), KILL_GRACE_MS);
-    };
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      kill();
-    }, commandTimeoutMs);
-    const abort = () => {
-      cancelled = true;
-      kill();
-    };
-    signal.addEventListener('abort', abort, { once: true });
-
-    const finish = (exitCode: number | null, spawnError?: string) => {
-      if (completed) return;
-      completed = true;
-      clearTimeout(timeout);
-      if (forceKillTimer) clearTimeout(forceKillTimer);
-      signal.removeEventListener('abort', abort);
-      const error = cancelled
-        ? 'run cancelled'
-        : timedOut
-          ? `command timed out after ${commandTimeoutMs}ms`
-          : spawnError;
-      resolve({
-        ...base,
-        status: cancelled ? 'cancelled' : exitCode === 0 && !error ? 'passed' : 'failed',
-        durationMs: Date.now() - startedAt,
-        exitCode,
-        stdout: redactSecrets(stdout.value()),
-        stderr: redactSecrets(stderr.value()),
-        ...(error ? { error } : {}),
-      });
-    };
-    child.once('error', (error) => finish(null, error.message));
-    child.once('close', (exitCode) => finish(exitCode));
-  });
-}
-
-export async function executeCodeBlocks({
-  tasks,
-  docsRoot,
-  concurrency,
-  commandTimeoutMs,
-  signal,
-  onTaskUpdate,
-}: {
-  tasks: GeneratedTask[];
-  docsRoot: string;
-  concurrency: number;
-  commandTimeoutMs: number;
-  signal: AbortSignal;
-  onTaskUpdate: (update: TaskUpdate) => void;
-}): Promise<TaskResult[]> {
-  return mapWithConcurrency(tasks, concurrency, async (task) => {
-    const generatedFiles =
-      task.manifest?.generatedFiles.map((file) => path.resolve(task.directory, file)) ??
-      task.generatedFiles ??
-      [];
-    const base = {
-      id: task.id,
-      agent: task.agent,
-      file: task.file,
-      directory: task.directory,
-      generatedFiles,
-      testable: task.testable === true,
-      attempts: task.attempts,
-      tokens: task.tokens,
-    };
-    const manifest = task.manifest;
-    if (!manifest) {
-      if (!task.error) {
-        onTaskUpdate({
-          id: task.id,
-          agent: task.agent,
-          file: task.file,
-          directory: task.directory,
-          generatedFiles,
-          phase: 'not_testable',
-          tokens: task.tokens,
-        });
-        return { ...base, status: 'passed' as const, commands: [] };
-      }
-      const status = signal.aborted ? ('cancelled' as const) : ('agent_error' as const);
-      onTaskUpdate({
-        id: task.id,
-        agent: task.agent,
-        file: task.file,
-        directory: task.directory,
-        generatedFiles,
-        phase: status,
-        tokens: task.tokens,
-        error: task.error,
-      });
-      return {
-        ...base,
-        status,
-        error: task.error,
-        commands: [],
-      };
-    }
-    onTaskUpdate({
-      id: task.id,
-      agent: task.agent,
-      file: task.file,
-      directory: task.directory,
-      generatedFiles,
-      phase: 'running',
-      tokens: task.tokens,
-    });
-
-    const commands: CommandResult[] = [];
-    let setupFailure: 'failed' | 'cancelled' | undefined;
-
-    const run = async (
-      command: ManifestCommand,
-      phase: 'setup' | 'test'
-    ): Promise<CommandResult> => {
-      const cwd = path.resolve(task.directory, command.cwd ?? '.');
-      if (signal.aborted) {
-        return unrunCommandResult(command, phase, cwd, 'cancelled', 'run cancelled');
-      }
-      if (phase === 'test' && setupFailure) {
-        return unrunCommandResult(
-          command,
-          phase,
-          cwd,
-          setupFailure,
-          `a setup command ${setupFailure === 'cancelled' ? 'was cancelled' : 'failed'}`
-        );
-      }
-      return spawnCommand({
-        command,
-        phase,
-        cwd,
-        timeoutMs: commandTimeoutMs,
-        signal,
-        docsRootForCommands: docsRoot,
-      });
-    };
-
-    for (const command of manifest.setupCommands) {
-      const result = await run(command, 'setup');
-      commands.push(result);
-      if (result.status !== 'passed') {
-        setupFailure = result.status;
-        break;
-      }
-    }
-    for (const command of manifest.testCommands) {
-      commands.push(await run(command, 'test'));
-    }
-
-    const status =
-      FAILURE_PRECEDENCE.find((candidate) =>
-        commands.some((command) => command.status === candidate)
-      ) ?? 'passed';
-    const error = status === 'passed' ? undefined : summarizeCommandFailure(commands);
-    onTaskUpdate({
-      id: task.id,
-      agent: task.agent,
-      file: task.file,
-      directory: task.directory,
-      generatedFiles,
-      phase: status,
-      tokens: task.tokens,
-      ...(error ? { error } : {}),
-    });
-    return { ...base, status, ...(error ? { error } : {}), commands };
-  });
-}

package/src/agent-harness/filterSelectedPages.ts

@@ -1,14 +0,0 @@
-import path from 'node:path';
-
-import type { DocsPage } from './types.js';
-
-export function filterSelectedPages(pages: DocsPage[], selectedFiles: string[]): DocsPage[] {
-  const selected = new Set(
-    selectedFiles.map((file) => file.split(path.sep).join('/').replace(/^\.\//, ''))
-  );
-  const known = new Set(pages.map((page) => page.file));
-  for (const file of selected) {
-    if (!known.has(file)) throw new Error(`Selected docs file was not found: ${file}`);
-  }
-  return pages.filter((page) => selected.has(page.file));
-}