@straiffi/archon 1.0.0

package/dist/server/lib/projectAutoConfig.js

@@ -0,0 +1,682 @@
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, posix } from 'path';
+import { validateProjectPayload } from './projects.js';
+const MAX_FILE_CHARS = 12_000;
+const TOP_LEVEL_TEXT_FILES = new Set([
+    'package.json',
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lock',
+    'pnpm-workspace.yaml',
+    'turbo.json',
+    'nx.json',
+    'lerna.json',
+    'docker-compose.yml',
+    'docker-compose.yaml',
+    'compose.yml',
+    'compose.yaml',
+    '.env.example',
+    '.env.local.example',
+]);
+const TOP_LEVEL_EXISTENCE_PATHS = ['.env', '.idea', 'node_modules'];
+const README_INSTALL_SECTION_KEYWORDS = ['install dependencies', 'install', 'setup'];
+const README_START_SECTION_KEYWORDS = ['start', 'run'];
+const SERVICE_SCRIPT_PREFERENCE = ['start:dev', 'dev', 'serve:dev', 'start'];
+const KNOWN_SHELL_COMMANDS = new Set([
+    'npm',
+    'pnpm',
+    'yarn',
+    'bun',
+    'npx',
+    'pnpx',
+    'node',
+    'tsx',
+    'vite',
+    'turbo',
+    'nx',
+    'lerna',
+    'corepack',
+    'docker',
+    'docker-compose',
+    'make',
+    'just',
+    'go',
+    'cargo',
+    'python',
+    'python3',
+    'pip',
+    'pip3',
+    'uv',
+    'poetry',
+    'composer',
+    'bundle',
+    'rails',
+    'mix',
+    'deno',
+    'sh',
+    'bash',
+    'zsh',
+    'task',
+]);
+export class ProjectAutoConfigError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = 'ProjectAutoConfigError';
+        this.status = status;
+    }
+}
+const truncateFileContent = (content) => {
+    if (content.length <= MAX_FILE_CHARS) {
+        return content;
+    }
+    return `${content.slice(0, MAX_FILE_CHARS)}\n... [truncated]`;
+};
+const extractLeadingJsonObject = (line) => {
+    if (!line.startsWith('{')) {
+        return null;
+    }
+    let depth = 0;
+    let inString = false;
+    let escaping = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaping = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === '{') {
+            depth += 1;
+            continue;
+        }
+        if (char === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                return line.slice(0, index + 1);
+            }
+        }
+    }
+    return null;
+};
+const parseOpencodeEvent = (line) => {
+    const trimmedLine = line.trim();
+    if (!trimmedLine) {
+        return null;
+    }
+    const jsonLine = extractLeadingJsonObject(trimmedLine);
+    if (!jsonLine) {
+        return null;
+    }
+    try {
+        return JSON.parse(jsonLine);
+    }
+    catch {
+        return null;
+    }
+};
+const stripSystemReminderBlocks = (output) => {
+    return output.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
+};
+const extractOpencodeOutput = (output) => {
+    const trimmedOutput = output.trim();
+    if (!trimmedOutput) {
+        return trimmedOutput;
+    }
+    const finalParts = [];
+    const textParts = [];
+    let sawStructuredOutput = false;
+    for (const line of trimmedOutput.split('\n')) {
+        const event = parseOpencodeEvent(line);
+        if (!event) {
+            continue;
+        }
+        sawStructuredOutput = true;
+        if (event.type === 'text' && event.part?.type === 'text' && event.part.text) {
+            textParts.push(event.part.text);
+        }
+        if (event.type === 'text'
+            && event.part?.type === 'text'
+            && event.part.metadata?.openai?.phase === 'final_answer'
+            && event.part.text) {
+            finalParts.push(event.part.text);
+        }
+    }
+    if (finalParts.length > 0) {
+        return finalParts.join('');
+    }
+    if (sawStructuredOutput) {
+        return textParts.length > 0 ? stripSystemReminderBlocks(textParts.join('')) : '';
+    }
+    return stripSystemReminderBlocks(trimmedOutput);
+};
+const stripMarkdownCodeFence = (output) => {
+    const trimmedOutput = output.trim();
+    const fencedMatch = trimmedOutput.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    return fencedMatch ? fencedMatch[1].trim() : trimmedOutput;
+};
+const extractFirstJsonObject = (output) => {
+    const normalizedOutput = stripMarkdownCodeFence(stripSystemReminderBlocks(output));
+    try {
+        return JSON.parse(normalizedOutput);
+    }
+    catch {
+        // Fall back to scanning for the first balanced JSON object.
+    }
+    for (let index = 0; index < normalizedOutput.length; index += 1) {
+        if (normalizedOutput[index] !== '{') {
+            continue;
+        }
+        let depth = 0;
+        let inString = false;
+        let escaping = false;
+        for (let endIndex = index; endIndex < normalizedOutput.length; endIndex += 1) {
+            const char = normalizedOutput[endIndex];
+            if (inString) {
+                if (escaping) {
+                    escaping = false;
+                    continue;
+                }
+                if (char === '\\') {
+                    escaping = true;
+                    continue;
+                }
+                if (char === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (char === '"') {
+                inString = true;
+                continue;
+            }
+            if (char === '{') {
+                depth += 1;
+                continue;
+            }
+            if (char === '}') {
+                depth -= 1;
+                if (depth === 0) {
+                    try {
+                        return JSON.parse(normalizedOutput.slice(index, endIndex + 1));
+                    }
+                    catch {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    throw new ProjectAutoConfigError(500, 'Auto-config did not return valid JSON.');
+};
+const collectTopLevelContext = (repoPath) => {
+    const entries = readdirSync(repoPath);
+    const entrySet = new Set(entries);
+    const readmeName = [...entrySet].find(entry => {
+        const normalized = entry.toLowerCase();
+        return normalized === 'readme' || normalized.startsWith('readme.');
+    });
+    const textFileNames = [
+        ...(readmeName ? [readmeName] : []),
+        ...[...TOP_LEVEL_TEXT_FILES].filter(fileName => entrySet.has(fileName)),
+    ];
+    const files = textFileNames.map(name => ({
+        name,
+        content: truncateFileContent(readFileSync(join(repoPath, name), 'utf8')),
+    }));
+    const existingPaths = TOP_LEVEL_EXISTENCE_PATHS.filter(pathName => existsSync(join(repoPath, pathName)));
+    return { entries, files, existingPaths };
+};
+const getContextFile = (context, name) => {
+    return context.files.find(file => file.name === name) ?? null;
+};
+const getPackageManagerRunner = (packageJson, context) => {
+    const packageManager = packageJson?.packageManager?.toLowerCase() ?? '';
+    if (packageManager.startsWith('pnpm')) {
+        return 'pnpm';
+    }
+    if (packageManager.startsWith('yarn')) {
+        return 'yarn';
+    }
+    if (packageManager.startsWith('bun')) {
+        return 'bun';
+    }
+    if (packageManager.startsWith('npm')) {
+        return 'npm';
+    }
+    const fileNames = new Set(context.files.map(file => file.name));
+    if (fileNames.has('pnpm-lock.yaml')) {
+        return 'pnpm';
+    }
+    if (fileNames.has('yarn.lock')) {
+        return 'yarn';
+    }
+    if (fileNames.has('bun.lock') || fileNames.has('bun.lockb')) {
+        return 'bun';
+    }
+    if (fileNames.has('package-lock.json')) {
+        return 'npm';
+    }
+    if (packageJson) {
+        return 'npm';
+    }
+    return null;
+};
+const dedupeStrings = (values) => {
+    const seen = new Set();
+    return values.filter(value => {
+        if (seen.has(value)) {
+            return false;
+        }
+        seen.add(value);
+        return true;
+    });
+};
+const dedupeWorktreeSync = (items) => {
+    const seen = new Set();
+    return items.filter(item => {
+        const key = JSON.stringify(item);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+};
+const buildScriptCommand = (runner, scriptName) => {
+    const normalizedRunner = runner ?? 'npm';
+    if (normalizedRunner === 'npm') {
+        return scriptName === 'start' ? 'npm start' : `npm run ${scriptName}`;
+    }
+    return `${normalizedRunner} ${scriptName}`;
+};
+const normalizeCommandCwd = (rawTarget, context) => {
+    let target = rawTarget.trim().replaceAll('\\', '/').replace(/^['"]|['"]$/g, '');
+    if (target === '') {
+        return null;
+    }
+    if (target.startsWith('/') || target.startsWith('~')) {
+        return null;
+    }
+    while (target.startsWith('./')) {
+        target = target.slice(2);
+    }
+    while (target.startsWith('../')) {
+        target = target.slice(3);
+    }
+    const normalizedTarget = posix.normalize(target).replace(/\/+$/g, '');
+    if (normalizedTarget === '' || normalizedTarget === '.') {
+        return '';
+    }
+    if (normalizedTarget === '..' || normalizedTarget.startsWith('../')) {
+        return null;
+    }
+    const firstSegment = normalizedTarget.split('/')[0];
+    if (!context.entries.includes(firstSegment)) {
+        return null;
+    }
+    return normalizedTarget;
+};
+const normalizeCommand = (command, context) => {
+    const trimmedCommand = command.trim().replace(/^\$\s*/, '');
+    if (!trimmedCommand) {
+        return null;
+    }
+    const cdPrefixMatch = trimmedCommand.match(/^cd\s+(.+?)\s*&&\s*(.+)$/);
+    if (!cdPrefixMatch) {
+        return trimmedCommand;
+    }
+    const normalizedCwd = normalizeCommandCwd(cdPrefixMatch[1], context);
+    if (normalizedCwd == null) {
+        return null;
+    }
+    const remainder = cdPrefixMatch[2].trim();
+    return normalizedCwd === '' ? remainder : `cd ${normalizedCwd} && ${remainder}`;
+};
+const parseCommandBlock = (block) => {
+    return block
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line !== '' && !line.startsWith('#'));
+};
+const isLikelyShellCommand = (command) => {
+    const trimmedCommand = command.trim();
+    if (trimmedCommand === '' || trimmedCommand.endsWith(':')) {
+        return false;
+    }
+    let remaining = trimmedCommand;
+    const cdPrefixMatch = remaining.match(/^cd\s+.+?\s*&&\s*(.+)$/);
+    if (cdPrefixMatch) {
+        remaining = cdPrefixMatch[1].trim();
+    }
+    while (true) {
+        const envAssignmentMatch = remaining.match(/^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+/);
+        if (!envAssignmentMatch) {
+            break;
+        }
+        remaining = remaining.slice(envAssignmentMatch[0].length).trim();
+    }
+    const executable = remaining.split(/\s+/)[0] ?? '';
+    if (executable === '') {
+        return false;
+    }
+    if (KNOWN_SHELL_COMMANDS.has(executable)) {
+        return true;
+    }
+    return executable.startsWith('./');
+};
+const extractReadmeSectionCommands = (readmeContent, keywords) => {
+    for (const keyword of keywords) {
+        const escapedKeyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const match = readmeContent.match(new RegExp(`${escapedKeyword}[\\s\\S]{0,220}?\`\`\`(?:bash|sh)?\\n([\\s\\S]*?)\`\`\``, 'i'));
+        if (match?.[1]) {
+            return parseCommandBlock(match[1]);
+        }
+    }
+    return [];
+};
+const normalizeSetupCommands = (commands, context) => {
+    return dedupeStrings(commands
+        .map(command => normalizeCommand(command, context))
+        .filter((command) => Boolean(command))
+        .filter(isLikelyShellCommand));
+};
+const hasInstallCommand = (command) => {
+    return /\b(?:npm|pnpm|yarn|bun)(?:\s+run)?\s+(?:install|ci)\b/.test(command);
+};
+const normalizeNotes = (value) => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return dedupeStrings(value
+        .filter((entry) => typeof entry === 'string')
+        .map(entry => entry.trim())
+        .filter(Boolean));
+};
+const getPreferredServiceScript = (scripts) => {
+    for (const scriptName of SERVICE_SCRIPT_PREFERENCE) {
+        const script = scripts[scriptName];
+        if (typeof script === 'string' && script.trim() !== '') {
+            return scriptName;
+        }
+    }
+    return null;
+};
+const normalizeRawService = (service) => {
+    if (!service || typeof service !== 'object' || Array.isArray(service)) {
+        return null;
+    }
+    const candidate = service;
+    if (typeof candidate.cmd !== 'string' || candidate.cmd.trim() === '') {
+        return null;
+    }
+    const normalizedService = {
+        cmd: candidate.cmd.trim(),
+        ...(typeof candidate.cwd === 'string' && candidate.cwd.trim() !== '' ? { cwd: candidate.cwd.trim() } : {}),
+    };
+    const validation = validateProjectPayload({ run_services: [normalizedService] }, { partial: true });
+    if ('error' in validation) {
+        return null;
+    }
+    return normalizedService;
+};
+const normalizeWorktreeSync = (items, runSetup, existingPaths) => {
+    if (!Array.isArray(items)) {
+        return [];
+    }
+    const normalizedItems = items.flatMap(item => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            return [];
+        }
+        const candidate = item;
+        if (typeof candidate.source !== 'string' || (candidate.mode !== 'copy' && candidate.mode !== 'symlink')) {
+            return [];
+        }
+        const normalizedItem = {
+            source: candidate.source.trim(),
+            ...(typeof candidate.target === 'string' && candidate.target.trim() !== '' ? { target: candidate.target.trim() } : {}),
+            mode: candidate.mode,
+        };
+        const validation = validateProjectPayload({ worktree_sync: [normalizedItem] }, { partial: true });
+        if ('error' in validation) {
+            return [];
+        }
+        return [normalizedItem];
+    });
+    const installDetected = runSetup.some(hasInstallCommand);
+    return normalizedItems.filter(item => {
+        if (item.source !== 'node_modules') {
+            return true;
+        }
+        if (!existingPaths.includes('node_modules')) {
+            return false;
+        }
+        return !installDetected;
+    });
+};
+const normalizeAutoConfigResult = (rawResult, context, packageJson, runner, fallbackNotes = []) => {
+    const runSetup = normalizeSetupCommands(Array.isArray(rawResult.run_setup) ? rawResult.run_setup.filter((value) => typeof value === 'string') : [], context);
+    const scripts = packageJson?.scripts ?? {};
+    const preferredScript = getPreferredServiceScript(scripts);
+    const rawServices = Array.isArray(rawResult.run_services)
+        ? rawResult.run_services.map(normalizeRawService).filter((service) => Boolean(service))
+        : [];
+    const runServices = preferredScript
+        ? [{ cmd: buildScriptCommand(runner, preferredScript) }]
+        : rawServices.slice(0, 1);
+    const worktreeSync = normalizeWorktreeSync(rawResult.worktree_sync, runSetup, context.existingPaths);
+    return {
+        run_setup: runSetup,
+        run_services: runServices,
+        worktree_sync: worktreeSync,
+        notes: dedupeStrings([...normalizeNotes(rawResult.notes), ...fallbackNotes]),
+    };
+};
+const buildHeuristicAutoConfig = (context) => {
+    const notes = [];
+    const packageJsonFile = getContextFile(context, 'package.json');
+    let packageJson = null;
+    if (packageJsonFile) {
+        try {
+            packageJson = JSON.parse(packageJsonFile.content);
+        }
+        catch {
+            notes.push('Top-level package.json could not be parsed, so auto-config used file presence only.');
+        }
+    }
+    const runner = getPackageManagerRunner(packageJson, context);
+    const scripts = packageJson?.scripts ?? {};
+    const readmeContent = getContextFile(context, 'README.md')?.content ?? getContextFile(context, 'README')?.content ?? '';
+    const readmeInstallCommands = readmeContent ? extractReadmeSectionCommands(readmeContent, README_INSTALL_SECTION_KEYWORDS) : [];
+    const preferredScript = getPreferredServiceScript(scripts);
+    const run_setup = readmeInstallCommands.length > 0
+        ? normalizeSetupCommands(readmeInstallCommands, context)
+        : runner ? [`${runner} install`] : [];
+    if (runner) {
+        notes.push(`Detected ${runner} from top-level files.`);
+    }
+    const run_services = preferredScript ? [{ cmd: buildScriptCommand(runner, preferredScript) }] : [];
+    if (preferredScript) {
+        notes.push(`Detected ${preferredScript} script in package.json.`);
+    }
+    else if (readmeContent) {
+        const readmeStartCommands = extractReadmeSectionCommands(readmeContent, README_START_SECTION_KEYWORDS);
+        if (readmeStartCommands.length > 0) {
+            const normalizedStartCommand = normalizeCommand(readmeStartCommands[0], context);
+            if (normalizedStartCommand) {
+                run_services.push({ cmd: normalizedStartCommand });
+                notes.push('Detected start command from the top-level README.');
+            }
+        }
+    }
+    const fileNames = new Set(context.files.map(file => file.name));
+    const worktree_sync = [];
+    if (fileNames.has('.env.example') && !context.existingPaths.includes('.env')) {
+        worktree_sync.push({ source: '.env.example', target: '.env', mode: 'copy' });
+        notes.push('Suggested copying .env.example to .env for local configuration.');
+    }
+    if (context.existingPaths.includes('node_modules') && !run_setup.some(hasInstallCommand)) {
+        worktree_sync.push({ source: 'node_modules', mode: 'symlink' });
+        notes.push('Suggested symlinking node_modules into new worktrees.');
+    }
+    return normalizeAutoConfigResult({
+        run_setup,
+        run_services,
+        worktree_sync,
+        notes,
+    }, context, packageJson, runner);
+};
+const buildAutoConfigPrompt = (context) => {
+    const fileBlocks = context.files.length > 0
+        ? context.files.map(file => `## ${file.name}\n\n\`\`\`\n${file.content}\n\`\`\``).join('\n\n')
+        : 'No allowed top-level files were found.';
+    return `You are helping auto-configure an Archon project from a repository's top-level files.
+
+Use ONLY the provided top-level file contents and path existence checks. Do not assume anything about deeper files or folders.
+
+Return ONLY a JSON object with this exact shape:
+{
+  "run_setup": ["command"],
+  "run_services": [{ "cmd": "command", "cwd": "optional-relative-path" }],
+  "worktree_sync": [{ "source": "relative-path", "target": "optional-relative-path", "mode": "copy|symlink" }],
+  "notes": ["short explanation"]
+}
+
+Rules:
+- Do not suggest any IDE or editor command.
+- Prefer conservative suggestions. If a value is not clearly supported by the provided files, leave it out.
+ - 'run_setup' should contain one-time bootstrap commands, not long-running dev servers.
+ - 'run_services' should contain long-running dev commands only when they are clearly indicated.
+ - 'cwd' must be omitted unless a top-level file clearly points to a subdirectory.
+ - 'worktree_sync' should include only clearly useful repo-level items such as 'node_modules', '.env', or '.idea'.
+ - Do not suggest symlinking 'node_modules' when you also suggest any install command such as npm/pnpm/yarn/bun install or ci.
+ - If you cannot infer any configuration confidently, return empty arrays and explain why in 'notes'.
+ - Do not include any keys other than 'run_setup', 'run_services', 'worktree_sync', and 'notes'.
+- Do not wrap the JSON in markdown fences.
+
+Top-level path existence checks:
+${context.existingPaths.length > 0 ? context.existingPaths.map(pathName => `- ${pathName}: present`).join('\n') : '- none present'}
+
+Top-level file contents:
+${fileBlocks}`;
+};
+const runAutoConfigPrompt = ({ tool, model, variant }, prompt, cwd) => {
+    const resolvedModel = typeof model === 'string' && model.trim() !== '' ? model.trim() : null;
+    const resolvedVariant = typeof variant === 'string' && variant.trim() !== '' ? variant.trim() : null;
+    const [cmd, args] = tool === 'claude'
+        ? ['claude', ['--dangerously-skip-permissions', '--print', prompt]]
+        : ['opencode', ['run', '--agent', 'plan', '--format', 'json', ...(resolvedModel ? ['--model', resolvedModel] : []), ...(resolvedVariant ? ['--variant', resolvedVariant] : []), prompt]];
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: process.env,
+            cwd,
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout?.on('data', (chunk) => stdoutChunks.push(chunk));
+        child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+        child.on('close', code => {
+            const rawOutput = Buffer.concat(stdoutChunks).toString();
+            const output = tool === 'opencode' ? extractOpencodeOutput(rawOutput).trim() : rawOutput.trim();
+            const errorOutput = Buffer.concat(stderrChunks).toString().trim();
+            if (code === 0 && output) {
+                resolve(output);
+                return;
+            }
+            const fallbackError = code === 0
+                ? 'Auto-config did not return a usable result.'
+                : `Process exited with code ${code}`;
+            reject(new ProjectAutoConfigError(500, output || errorOutput || fallbackError));
+        });
+        child.on('error', error => {
+            const errorCode = error.code;
+            if (errorCode === 'ENOENT') {
+                reject(new ProjectAutoConfigError(500, `${tool === 'claude' ? 'Claude' : 'OpenCode'} CLI is not available.`));
+                return;
+            }
+            reject(new ProjectAutoConfigError(500, error instanceof Error ? error.message : String(error)));
+        });
+    });
+};
+const parseStringJsonArray = (value) => {
+    if (!value) {
+        return [];
+    }
+    return JSON.parse(value);
+};
+export const autoConfigProject = async (repoPath, execution) => {
+    const context = collectTopLevelContext(repoPath);
+    if (context.files.length === 0 && context.existingPaths.length === 0) {
+        throw new ProjectAutoConfigError(422, 'Unable to infer project config from top-level README and config files.');
+    }
+    const heuristicResult = buildHeuristicAutoConfig(context);
+    const fallbackNotes = [...heuristicResult.notes];
+    const packageJsonFile = getContextFile(context, 'package.json');
+    let packageJson = null;
+    if (packageJsonFile) {
+        try {
+            packageJson = JSON.parse(packageJsonFile.content);
+        }
+        catch {
+            packageJson = null;
+        }
+    }
+    const runner = getPackageManagerRunner(packageJson, context);
+    try {
+        const output = await runAutoConfigPrompt(execution, buildAutoConfigPrompt(context), repoPath);
+        const suggestion = extractFirstJsonObject(output);
+        const validation = validateProjectPayload({
+            run_setup: Array.isArray(suggestion.run_setup) ? suggestion.run_setup.filter((value) => typeof value === 'string') : [],
+            run_services: Array.isArray(suggestion.run_services) ? suggestion.run_services.map(normalizeRawService).filter(Boolean) : [],
+            worktree_sync: Array.isArray(suggestion.worktree_sync) ? suggestion.worktree_sync : [],
+        }, { partial: true });
+        const agentResult = normalizeAutoConfigResult({
+            run_setup: Array.isArray(suggestion.run_setup) ? suggestion.run_setup : [],
+            run_services: Array.isArray(suggestion.run_services) ? suggestion.run_services : [],
+            worktree_sync: Array.isArray(suggestion.worktree_sync) ? suggestion.worktree_sync : [],
+            notes: suggestion.notes,
+        }, context, packageJson, runner, fallbackNotes);
+        if ('error' in validation && agentResult.run_setup.length === 0 && agentResult.run_services.length === 0 && agentResult.worktree_sync.length === 0) {
+            throw new ProjectAutoConfigError(500, `Auto-config returned invalid project settings: ${validation.error}`);
+        }
+        const combinedResult = {
+            run_setup: dedupeStrings([...heuristicResult.run_setup, ...agentResult.run_setup]),
+            run_services: agentResult.run_services.length > 0 ? agentResult.run_services : heuristicResult.run_services,
+            worktree_sync: normalizeWorktreeSync(dedupeWorktreeSync([...heuristicResult.worktree_sync, ...agentResult.worktree_sync]), dedupeStrings([...heuristicResult.run_setup, ...agentResult.run_setup]), context.existingPaths),
+            notes: dedupeStrings([...agentResult.notes, ...fallbackNotes]),
+        };
+        if (combinedResult.run_setup.length === 0 && combinedResult.run_services.length === 0 && combinedResult.worktree_sync.length === 0) {
+            throw new ProjectAutoConfigError(422, 'Unable to infer project config from top-level README and config files.');
+        }
+        return combinedResult;
+    }
+    catch (error) {
+        if (error instanceof ProjectAutoConfigError && error.status !== 500) {
+            throw error;
+        }
+        if (heuristicResult.run_setup.length > 0 || heuristicResult.run_services.length > 0 || heuristicResult.worktree_sync.length > 0) {
+            return heuristicResult;
+        }
+        if (error instanceof ProjectAutoConfigError) {
+            throw error;
+        }
+        throw new ProjectAutoConfigError(500, error instanceof Error ? error.message : 'Auto-config failed');
+    }
+};
+//# sourceMappingURL=projectAutoConfig.js.map