@mintlify/cli 4.0.1654 → 4.0.1656

package/bin/agent-harness/generateTestCode.js

@@ -1,337 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { SYSTEM_PROMPT, buildTaskPrompt } from './buildTaskPrompt.js';
-import { loadClaudeAgentSdk, loadCodexSdk } from './loadAgentSdk.js';
-import { MANIFEST_FILENAME, SAFE_EXECUTABLES, appendAgentReply, readManifest, writeErrorDetails, } from './manifest.js';
-import { mapWithConcurrency } from './mapWithConcurrency.js';
-import { checkFileTestability } from './tasks/checkTestability.js';
-const SCAFFOLD_FILENAMES = new Set([MANIFEST_FILENAME, 'package.json']);
-const IGNORED_GENERATED_DIRECTORIES = new Set(['.git', 'node_modules']);
-function promptClaude(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ prompt, systemPrompt, model, workingDirectory, docsRoot, tools, signal, }) {
-        var _b, e_1, _c, _d;
-        const { query } = yield loadClaudeAgentSdk();
-        const abortController = new AbortController();
-        const abort = () => abortController.abort(signal.reason);
-        if (signal.aborted)
-            abort();
-        else
-            signal.addEventListener('abort', abort, { once: true });
-        const session = query({
-            prompt,
-            options: {
-                abortController,
-                additionalDirectories: [docsRoot],
-                allowedTools: tools,
-                cwd: workingDirectory,
-                model,
-                permissionMode: 'dontAsk',
-                persistSession: false,
-                settingSources: [],
-                strictMcpConfig: true,
-                systemPrompt,
-                tools,
-            },
-        });
-        try {
-            try {
-                for (var _e = true, session_1 = __asyncValues(session), session_1_1; session_1_1 = yield session_1.next(), _b = session_1_1.done, !_b; _e = true) {
-                    _d = session_1_1.value;
-                    _e = false;
-                    const message = _d;
-                    if (message.type !== 'result')
-                        continue;
-                    if (message.subtype !== 'success' || message.is_error) {
-                        const details = message.subtype === 'success' ? message.result : message.errors.join('; ');
-                        throw new Error(details || `Claude stopped with ${message.subtype}`);
-                    }
-                    const usage = message.usage;
-                    return {
-                        tokens: usage.input_tokens +
-                            usage.output_tokens +
-                            usage.cache_creation_input_tokens +
-                            usage.cache_read_input_tokens,
-                        result: message.result,
-                    };
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_e && !_b && (_c = session_1.return)) yield _c.call(session_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            throw new Error('Claude finished without returning a result');
-        }
-        finally {
-            signal.removeEventListener('abort', abort);
-            session.close();
-        }
-    });
-}
-const AGENT_TOOLS = ['Read', 'Glob', 'Grep', 'Write', 'Edit', 'Bash'];
-function isPathInside(root, candidate) {
-    const relative = path.relative(root, candidate);
-    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
-}
-function validateManifest(manifest, directory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const errors = [];
-        const realDirectory = yield fs.realpath(directory);
-        for (const file of manifest.generatedFiles) {
-            if (path.isAbsolute(file)) {
-                errors.push(`Generated file path must be relative: ${file}`);
-                continue;
-            }
-            const resolved = path.resolve(directory, file);
-            if (!isPathInside(directory, resolved)) {
-                errors.push(`Generated file leaves its task: ${file}`);
-                continue;
-            }
-            const realPath = yield fs.realpath(resolved).catch(() => undefined);
-            if (!realPath || !isPathInside(realDirectory, realPath)) {
-                errors.push(`Generated file leaves its task through a link: ${file}`);
-                continue;
-            }
-            const stats = yield fs.stat(realPath).catch(() => undefined);
-            if (!(stats === null || stats === void 0 ? void 0 : stats.isFile()))
-                errors.push(`Generated file does not exist: ${file}`);
-        }
-        const commandIds = new Set();
-        for (const command of [...manifest.setupCommands, ...manifest.testCommands]) {
-            if (commandIds.has(command.id))
-                errors.push(`Duplicate command ID: ${command.id}`);
-            commandIds.add(command.id);
-            if (path.isAbsolute(command.executable) || command.executable.split(/[\\/]/).includes('..')) {
-                errors.push(`Unsafe command executable: ${command.executable}`);
-                continue;
-            }
-            if (!SAFE_EXECUTABLES.has(command.executable) && !command.executable.startsWith('./')) {
-                errors.push(`Unsupported command executable: ${command.executable}`);
-                continue;
-            }
-            if (command.executable.startsWith('./')) {
-                const executablePath = yield fs
-                    .realpath(path.resolve(directory, command.executable))
-                    .catch(() => undefined);
-                const stats = executablePath
-                    ? yield fs.stat(executablePath).catch(() => undefined)
-                    : undefined;
-                if (!executablePath || !isPathInside(realDirectory, executablePath) || !(stats === null || stats === void 0 ? void 0 : stats.isFile())) {
-                    errors.push(`Command executable leaves its task or is not a file: ${command.executable}`);
-                }
-            }
-            const cwd = (_a = command.cwd) !== null && _a !== void 0 ? _a : '.';
-            if (path.isAbsolute(cwd)) {
-                errors.push(`Command cwd must be relative: ${cwd}`);
-                continue;
-            }
-            const resolvedCwd = path.resolve(directory, cwd);
-            const realCwd = yield fs.realpath(resolvedCwd).catch(() => undefined);
-            const stats = realCwd ? yield fs.stat(realCwd).catch(() => undefined) : undefined;
-            if (!isPathInside(directory, resolvedCwd) ||
-                !realCwd ||
-                !isPathInside(realDirectory, realCwd) ||
-                !(stats === null || stats === void 0 ? void 0 : stats.isDirectory())) {
-                errors.push(`Command cwd is missing or leaves its task: ${cwd}`);
-            }
-        }
-        return errors;
-    });
-}
-function readValidManifest(directory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const manifest = yield readManifest(directory);
-            const errors = yield validateManifest(manifest, directory);
-            return errors.length === 0 ? manifest : null;
-        }
-        catch (_a) {
-            return null;
-        }
-    });
-}
-function discoverGeneratedFiles(directory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const realDirectory = yield fs.realpath(directory);
-        const files = [];
-        function walk(currentDirectory) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const entries = yield fs.readdir(currentDirectory, { withFileTypes: true }).catch(() => []);
-                for (const entry of entries) {
-                    if (files.length >= 1000)
-                        return;
-                    if (currentDirectory === directory && SCAFFOLD_FILENAMES.has(entry.name))
-                        continue;
-                    const candidate = path.join(currentDirectory, entry.name);
-                    if (entry.isDirectory()) {
-                        if (IGNORED_GENERATED_DIRECTORIES.has(entry.name))
-                            continue;
-                        yield walk(candidate);
-                        continue;
-                    }
-                    if (!entry.isFile())
-                        continue;
-                    const realPath = yield fs.realpath(candidate).catch(() => undefined);
-                    if (realPath && isPathInside(realDirectory, realPath))
-                        files.push(path.resolve(candidate));
-                }
-            });
-        }
-        yield walk(directory);
-        return files.sort((left, right) => left.localeCompare(right));
-    });
-}
-export const CHECK_CONCURRENCY = 20;
-export function checkTestability(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ tasks, runDirectory, signal, onTaskUpdate, }) {
-        const folderOrdered = [...tasks].sort((left, right) => path.dirname(left.file).localeCompare(path.dirname(right.file)) ||
-            left.file.localeCompare(right.file) ||
-            left.agent.localeCompare(right.agent));
-        return mapWithConcurrency(folderOrdered, CHECK_CONCURRENCY, checkFileTestability, {
-            signal,
-            onTaskUpdate,
-            runDirectory,
-        });
-    });
-}
-export function generateTestCode(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ tasks, docsRoot, model, concurrency, signal, onTaskUpdate, onGenerationResult, }) {
-        const generateTask = (task) => __awaiter(this, void 0, void 0, function* () {
-            if (task.error || !task.testable)
-                return task;
-            const emit = (phase, tokens, generatedFiles = [], error) => onTaskUpdate(Object.assign({ id: task.id, agent: task.agent, file: task.file, directory: task.directory, generatedFiles,
-                phase,
-                tokens }, (error ? { error } : {})));
-            let attempts = task.attempts;
-            let tokens = task.tokens;
-            let lastError = 'run cancelled';
-            const attemptErrors = [];
-            const existing = yield readValidManifest(task.directory);
-            if (existing) {
-                emit('generated', tokens, existing.generatedFiles.map((file) => path.resolve(task.directory, file)));
-                return Object.assign(Object.assign({}, task), { manifest: existing });
-            }
-            const startedAt = Date.now();
-            const startingTokens = tokens;
-            let generationAttempts = 0;
-            const emitGenerationResult = (result) => {
-                try {
-                    onGenerationResult === null || onGenerationResult === void 0 ? void 0 : onGenerationResult(result);
-                }
-                catch (_a) { }
-            };
-            for (let attempt = 1; attempt <= 2 && !signal.aborted; attempt++) {
-                attempts += 1;
-                generationAttempts += 1;
-                if (attempt === 1)
-                    emit('generating', tokens);
-                try {
-                    const prompt = buildTaskPrompt(docsRoot, task.file, task.directory);
-                    const reply = task.agent === 'claude'
-                        ? yield promptClaude({
-                            prompt,
-                            systemPrompt: SYSTEM_PROMPT,
-                            model,
-                            workingDirectory: task.directory,
-                            docsRoot,
-                            tools: AGENT_TOOLS,
-                            signal,
-                        })
-                        : yield promptCodex({
-                            prompt,
-                            systemPrompt: SYSTEM_PROMPT,
-                            workingDirectory: task.directory,
-                            docsRoot,
-                            signal,
-                        });
-                    tokens += reply.tokens;
-                    yield appendAgentReply(task.directory, attempt, reply.result);
-                    const manifest = yield readManifest(task.directory);
-                    const errors = yield validateManifest(manifest, task.directory);
-                    if (errors.length > 0) {
-                        const [first = '', ...rest] = errors;
-                        throw new Error([`${MANIFEST_FILENAME} has problems: ${first}`, ...rest].join('\n'));
-                    }
-                    const generatedFiles = manifest.generatedFiles.map((file) => path.resolve(task.directory, file));
-                    emit('generated', tokens, generatedFiles);
-                    emitGenerationResult({
-                        status: 'succeeded',
-                        agent: task.agent,
-                        model,
-                        attemptCount: generationAttempts,
-                        tokenCount: tokens - startingTokens,
-                        durationMs: Date.now() - startedAt,
-                        generatedFileCount: generatedFiles.length,
-                    });
-                    return Object.assign(Object.assign({}, task), { attempts, tokens, manifest });
-                }
-                catch (error) {
-                    lastError = error instanceof Error ? error.message : String(error);
-                    attemptErrors.push(`Attempt ${attempt}: ${lastError}`);
-                }
-            }
-            if (signal.aborted) {
-                const generatedFiles = yield discoverGeneratedFiles(task.directory);
-                emit('cancelled', tokens, generatedFiles, 'run cancelled');
-                return Object.assign(Object.assign({}, task), { attempts, tokens, generatedFiles, error: 'run cancelled' });
-            }
-            const generatedFiles = yield discoverGeneratedFiles(task.directory);
-            emitGenerationResult({
-                status: 'failed',
-                agent: task.agent,
-                model,
-                attemptCount: generationAttempts,
-                tokenCount: tokens - startingTokens,
-                durationMs: Date.now() - startedAt,
-                generatedFileCount: generatedFiles.length,
-            });
-            const detailsPath = yield writeErrorDetails(task.directory, attemptErrors);
-            const error = detailsPath ? `${lastError}\nDetails: ${detailsPath}` : lastError;
-            emit('agent_error', tokens, generatedFiles, error);
-            return Object.assign(Object.assign({}, task), { attempts, tokens, generatedFiles, error });
-        });
-        return mapWithConcurrency(tasks, concurrency, generateTask);
-    });
-}
-function promptCodex(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ prompt, systemPrompt, workingDirectory, docsRoot, signal, }) {
-        const { Codex } = yield loadCodexSdk();
-        const thread = new Codex().startThread({
-            additionalDirectories: [docsRoot],
-            approvalPolicy: 'never',
-            networkAccessEnabled: true,
-            sandboxMode: 'workspace-write',
-            skipGitRepoCheck: true,
-            workingDirectory,
-        });
-        const result = yield thread.run(`${systemPrompt}\n\n${prompt}`, { signal });
-        const usage = result.usage;
-        const tokens = usage
-            ? usage.input_tokens +
-                usage.cached_input_tokens +
-                usage.cache_write_input_tokens +
-                usage.output_tokens +
-                usage.reasoning_output_tokens
-            : 0;
-        return { tokens, result: result.finalResponse };
-    });
-}

package/bin/agent-harness/index.js

@@ -1,95 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import fs from 'node:fs/promises';
-import { ensureAgentSdks } from './agentPreflight.js';
-import { discoverCodeBlocks } from './discoverCodeBlocks.js';
-import { executeCodeBlocks } from './executeCodeBlocks.js';
-import { filterSelectedPages } from './filterSelectedPages.js';
-import { checkTestability, generateTestCode } from './generateTestCode.js';
-import { recordTestRun, testRunReportPath } from './runHistory.js';
-import { clearRunSave, writeRunSave } from './runSave.js';
-import { scaffoldTaskDirectories, setupFolders } from './setupFolders.js';
-export const DEFAULT_CONCURRENCY = 5;
-export const DEFAULT_COMMAND_TIMEOUT_MS = 2 * 60 * 1000;
-export { discoverCodeBlocks } from './discoverCodeBlocks.js';
-export { countReport } from './countReport.js';
-export { loadLatestTestRun, loadTestRuns } from './runHistory.js';
-export { clearRunSave, loadRunSave } from './runSave.js';
-export function runCodeTests(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ path: docsPath, agents, model, selectedFiles, outputDirectory, runId: savedRunId, concurrency, commandTimeoutMs, signal, onTaskUpdate, onGenerationResult, }) {
-        const startedAt = new Date();
-        const uniqueAgents = [...new Set(agents)];
-        const { docsRoot, pages: allPages } = yield discoverCodeBlocks(docsPath);
-        const pages = filterSelectedPages(allPages, selectedFiles);
-        if (pages.length > 0)
-            yield ensureAgentSdks(uniqueAgents);
-        const { runId, runDirectory, reportPath: legacyReportPath, tasks, } = yield setupFolders({
-            pages,
-            agents: uniqueAgents,
-            docsRoot,
-            outputDirectory,
-            runId: savedRunId,
-        });
-        const reportPath = testRunReportPath(docsRoot, runId);
-        yield writeRunSave(outputDirectory, {
-            version: 1,
-            runId,
-            agents: uniqueAgents,
-            model,
-            selectedFiles: pages.map((page) => page.file),
-            createdAt: startedAt.toISOString(),
-        });
-        const checked = yield checkTestability({ tasks, runDirectory, signal, onTaskUpdate });
-        yield scaffoldTaskDirectories(checked.filter((task) => task.testable === true));
-        const generated = yield generateTestCode({
-            tasks: checked,
-            docsRoot,
-            model,
-            concurrency,
-            signal,
-            onTaskUpdate,
-            onGenerationResult,
-        });
-        const results = yield executeCodeBlocks({
-            tasks: generated,
-            docsRoot,
-            concurrency,
-            commandTimeoutMs,
-            signal,
-            onTaskUpdate,
-        });
-        const completedAt = new Date();
-        const report = {
-            version: 1,
-            runId,
-            status: signal.aborted
-                ? 'cancelled'
-                : results.every((task) => task.status === 'passed')
-                    ? 'passed'
-                    : results.some((task) => task.status === 'passed')
-                        ? 'completed'
-                        : 'failed',
-            docsRoot,
-            outputDirectory: runDirectory,
-            reportPath,
-            agents: uniqueAgents,
-            model,
-            selectedFiles: pages.map((page) => page.file),
-            startedAt: startedAt.toISOString(),
-            completedAt: completedAt.toISOString(),
-            durationMs: completedAt.getTime() - startedAt.getTime(),
-            tasks: results,
-        };
-        yield fs.writeFile(legacyReportPath, `${JSON.stringify(report, null, 2)}\n`);
-        if (!signal.aborted)
-            yield clearRunSave(outputDirectory);
-        return recordTestRun(docsRoot, report, legacyReportPath);
-    });
-}

package/bin/agent-harness/loadAgentSdk.js

@@ -1,46 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-const INSTALL_HINTS = {
-    '@anthropic-ai/claude-agent-sdk': 'npm install @anthropic-ai/claude-agent-sdk @anthropic-ai/sdk @modelcontextprotocol/sdk',
-    '@openai/codex-sdk': 'npm install @openai/codex-sdk',
-};
-function isModuleNotFound(error) {
-    if (typeof error !== 'object' || error === null)
-        return false;
-    const { code } = error;
-    return code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND';
-}
-function missingSdkError(packageName) {
-    return new Error(`mint test requires the optional dependency ${packageName}, which is not installed. Install it with: ${INSTALL_HINTS[packageName]}`);
-}
-export function loadClaudeAgentSdk() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return yield import('@anthropic-ai/claude-agent-sdk');
-        }
-        catch (error) {
-            if (isModuleNotFound(error))
-                throw missingSdkError('@anthropic-ai/claude-agent-sdk');
-            throw error;
-        }
-    });
-}
-export function loadCodexSdk() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return yield import('@openai/codex-sdk');
-        }
-        catch (error) {
-            if (isModuleNotFound(error))
-                throw missingSdkError('@openai/codex-sdk');
-            throw error;
-        }
-    });
-}

package/bin/agent-harness/manifest.js

@@ -1,113 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { manifestSchema } from './types.js';
-export const MANIFEST_FILENAME = 'mint-test.json';
-export const AGENT_REPLY_FILENAME = 'mint-test-agent.md';
-export const ERROR_FILENAME = 'mint-test-error.txt';
-export const SAFE_EXECUTABLES = new Set([
-    'bun',
-    'bunx',
-    'bundle',
-    'cargo',
-    'composer',
-    'deno',
-    'dotnet',
-    'go',
-    'gradle',
-    'java',
-    'javac',
-    'mvn',
-    'node',
-    'npm',
-    'npx',
-    'php',
-    'pip',
-    'pip3',
-    'pnpm',
-    'python',
-    'python3',
-    'pytest',
-    'ruby',
-    'rustc',
-    'uv',
-    'vitest',
-    'yarn',
-]);
-function isMissingFile(error) {
-    return (typeof error === 'object' && error !== null && error.code === 'ENOENT');
-}
-/** Turn a schema failure into one readable line per problem, e.g. `testCommands.0.id: expected string`. */
-export function formatManifestIssues(error) {
-    return error.issues
-        .map((issue) => {
-        const location = issue.path.map(String).join('.');
-        return `${location || MANIFEST_FILENAME}: ${issue.message}`;
-    })
-        .join('\n');
-}
-/**
- * Read and schema-check the manifest an agent wrote. Every failure mode has a message a
- * documentation author can act on, because it is what `mint test` shows for the page.
- */
-export function readManifest(directory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const manifestPath = path.join(directory, MANIFEST_FILENAME);
-        let raw;
-        try {
-            raw = yield fs.readFile(manifestPath, 'utf8');
-        }
-        catch (error) {
-            if (isMissingFile(error)) {
-                throw new Error(`The agent finished without writing ${MANIFEST_FILENAME}`);
-            }
-            throw error;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch (error) {
-            const reason = error instanceof Error ? error.message : String(error);
-            throw new Error(`${MANIFEST_FILENAME} is not valid JSON: ${reason}`);
-        }
-        const result = manifestSchema.safeParse(parsed);
-        if (!result.success) {
-            const [first = '', ...rest] = formatManifestIssues(result.error).split('\n');
-            throw new Error([`${MANIFEST_FILENAME} does not match the expected shape: ${first}`, ...rest].join('\n'));
-        }
-        return result.data;
-    });
-}
-/** Keep the agent's final message next to its output so a failure can be traced later. */
-export function appendAgentReply(directory, attempt, reply) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const body = reply.trim() || '(no summary)';
-        yield fs
-            .appendFile(path.join(directory, AGENT_REPLY_FILENAME), `## Attempt ${attempt}\n\n${body}\n\n`)
-            .catch(() => { });
-    });
-}
-/** Persist every attempt's failure reason. Returns the file path, or undefined if it could not be written. */
-export function writeErrorDetails(directory, errors) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (errors.length === 0)
-            return undefined;
-        const errorPath = path.join(directory, ERROR_FILENAME);
-        try {
-            yield fs.writeFile(errorPath, `${errors.join('\n\n')}\n`);
-            return errorPath;
-        }
-        catch (_a) {
-            return undefined;
-        }
-    });
-}

package/bin/agent-harness/mapWithConcurrency.js

@@ -1,26 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export function mapWithConcurrency(items, concurrency, fn, ...args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const results = new Array(items.length);
-        let nextIndex = 0;
-        const worker = () => __awaiter(this, void 0, void 0, function* () {
-            for (;;) {
-                const index = nextIndex++;
-                const item = items[index];
-                if (index >= items.length || item === undefined)
-                    return;
-                results[index] = yield fn(item, ...args);
-            }
-        });
-        yield Promise.all(Array.from({ length: Math.min(Math.max(1, concurrency), items.length) }, () => worker()));
-        return results;
-    });
-}