@navels/neal 0.1.0

package/dist/neal/commands/squash.js

@@ -0,0 +1,113 @@
+import process from 'node:process';
+import readline from 'node:readline';
+import { parseSquashArgs } from '../cli.js';
+import { assertGitRepositoryWithCommit } from '../git.js';
+import { buildSquashCommitMessage, buildSquashResultMetadata, executeSquashForRun, selectLatestSquashRun, selectSquashRunForPlan, validateSelectedRunForSquash, } from '../squash.js';
+export async function runSquashCommand(args) {
+    const parsed = parseSquashArgs(args);
+    await assertGitRepositoryWithCommit(process.cwd(), 'neal squash');
+    const selection = parsed.planDoc
+        ? await selectSquashRunForPlan({
+            cwd: process.cwd(),
+            planDocArg: parsed.planDoc,
+        })
+        : await selectLatestSquashRun({
+            cwd: process.cwd(),
+        });
+    const validation = await validateSelectedRunForSquash({
+        cwd: process.cwd(),
+        selected: selection.selected,
+    });
+    const commitMessage = await buildSquashCommitMessage({
+        cwd: process.cwd(),
+        selected: selection.selected,
+    });
+    const metadata = await buildSquashResultMetadata({
+        cwd: process.cwd(),
+        selected: selection.selected,
+        validation,
+        commitMessage,
+    });
+    writeSquashPreview({
+        selection,
+        validation,
+        commitMessage,
+        metadata,
+    });
+    await confirmSquashRewrite();
+    const execution = await executeSquashForRun({
+        cwd: process.cwd(),
+        selected: selection.selected,
+        validation,
+        commitMessage,
+    });
+    process.stdout.write(JSON.stringify({
+        ok: true,
+        mode: 'squash_result',
+        rewriteReady: true,
+        planDoc: selection.normalizedPlanDoc,
+        selectedRunDir: selection.selected.runDir,
+        selectedRunId: selection.selected.runId,
+        completedMatchCount: selection.completedMatchCount,
+        selectionWarning: selection.selectionWarning,
+        baseCommit: validation.baseCommit,
+        finalCommit: validation.finalCommit,
+        createdCommits: validation.createdCommits,
+        postPlanCommits: validation.postPlanCommits,
+        commitMessageSource: commitMessage.source,
+        commitMessageSubject: commitMessage.subject,
+        commitMessage: commitMessage.message,
+        planDocDisposition: execution.artifact.metadata.planDocDisposition,
+        planDocIncludedInReplacementCommit: execution.artifact.metadata.planDocIncludedInReplacementCommit,
+        metadata: execution.artifact.metadata,
+        replacementCommit: execution.replacementCommit,
+        finalHeadCommit: execution.finalHeadCommit,
+        squashArtifactPath: execution.artifactPath,
+    }, null, 2) + '\n');
+}
+function writeSquashPreview({ selection, validation, commitMessage, metadata }) {
+    const lines = [
+        `[neal] selected squash run: ${selection.selected.runId}`,
+        `[neal] run dir: ${selection.selected.runDir}`,
+        `[neal] plan doc: ${selection.normalizedPlanDoc}`,
+        `[neal] plan doc disposition: ${metadata.planDocDisposition}`,
+        `[neal] replacement tree includes plan doc: ${metadata.planDocIncludedInReplacementCommit ? 'yes' : 'no'}`,
+        `[neal] base commit: ${validation.baseCommit}`,
+        `[neal] final commit: ${validation.finalCommit}`,
+        '[neal] commits to replace:',
+        ...validation.createdCommits.map((commit) => `  - ${commit}`),
+        validation.postPlanCommits.length > 0 ? '[neal] later commits to preserve:' : '[neal] later commits to preserve: none',
+        ...validation.postPlanCommits.map((commit) => `  - ${commit}`),
+        `[neal] commit message source: ${metadata.commitMessageSource}`,
+        `[neal] commit message subject: ${metadata.commitMessageSubject}`,
+        '[neal] generated commit message:',
+        commitMessage.message,
+    ];
+    if (selection.selectionWarning) {
+        lines.splice(2, 0, `[neal] ${selection.selectionWarning}`);
+    }
+    process.stderr.write(lines.join('\n') + '\n');
+}
+async function confirmSquashRewrite() {
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+        process.stderr.write('[neal] Interactive TTY confirmation is required before rewriting history; automated squash confirmation is not part of the public CLI.\n');
+        throw new Error('neal squash requires interactive TTY confirmation; no history was rewritten');
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+        terminal: true,
+    });
+    try {
+        const answer = await new Promise((resolve) => {
+            rl.question('[neal] Proceed with squash rewrite? [y/N] ', resolve);
+        });
+        const normalized = answer.trim().toLowerCase();
+        if (normalized !== 'y' && normalized !== 'yes') {
+            throw new Error('neal squash aborted; no history was rewritten');
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/neal/commands/status.js

@@ -0,0 +1,33 @@
+import process from 'node:process';
+import { parseStatusArgs } from '../cli.js';
+import { listRuns } from '../run-registry.js';
+import { buildStatusListSnapshot, buildStatusSnapshot, renderHumanStatusListSnapshot, renderHumanStatusSnapshot, } from '../status.js';
+import { resolveCliRunStatePath } from './runtime.js';
+export async function runStatusCommand(args) {
+    const parsed = parseStatusArgs(args);
+    if (parsed.all) {
+        const snapshot = await buildStatusListSnapshot({ cwd: process.cwd() });
+        if (parsed.json) {
+            process.stdout.write(JSON.stringify(snapshot, null, 2) + '\n');
+            return;
+        }
+        process.stdout.write(renderHumanStatusListSnapshot(snapshot).trimEnd() + '\n');
+        return;
+    }
+    if (!parsed.json && parsed.runId === null && (await listRuns(process.cwd())).length === 0) {
+        process.stdout.write('No Neal runs found in this repository yet. Start one with: neal run <plan.md>\n');
+        return;
+    }
+    const resolution = await resolveCliRunStatePath({
+        runId: parsed.runId,
+    });
+    const snapshot = await buildStatusSnapshot({
+        cwd: process.cwd(),
+        statePath: resolution.statePath,
+    });
+    if (parsed.json) {
+        process.stdout.write(JSON.stringify(snapshot, null, 2) + '\n');
+        return;
+    }
+    process.stdout.write(renderHumanStatusSnapshot(snapshot).trimEnd() + '\n');
+}

package/dist/neal/commands/writer-exit-codes.js

@@ -0,0 +1,42 @@
+import process from 'node:process';
+import { determinePlanRefinementConvergence, isPlanRefinementState, planRefinementExitCode, } from '../plan-refinement.js';
+import { getRunDisplayStatus } from '../run-status.js';
+export function getExecuteRunResultExitCode(result) {
+    if (isPlanRefinementState(result.finalState)) {
+        const convergenceReason = determinePlanRefinementConvergence(result.finalState);
+        if (convergenceReason !== null) {
+            return planRefinementExitCode(convergenceReason);
+        }
+    }
+    const displayStatus = getRunDisplayStatus(result.finalState);
+    if (displayStatus.effectiveStatus === 'waiting_for_operator' ||
+        displayStatus.effectiveStatus === 'waiting_for_manual_gate' ||
+        displayStatus.pendingOperatorGuidance) {
+        return 2;
+    }
+    switch (result.finalState.status) {
+        case 'done':
+            return 0;
+        case 'failed':
+            return 3;
+        case 'blocked':
+        case 'paused':
+        case 'running':
+            return 2;
+    }
+}
+export function getPlanAndExecuteQueueExitCode(state) {
+    switch (state.status) {
+        case 'completed':
+            return 0;
+        case 'failed':
+            return 3;
+        case 'blocked':
+        case 'paused':
+        case 'running':
+            return 2;
+    }
+}
+export function setWriterCommandExitCode(code) {
+    process.exitCode = code;
+}

package/dist/neal/commit-message.js

@@ -0,0 +1,17 @@
+const SCOPE_PREFIX_PATTERN = /^Scope(?:\s+|:\s*)\d+(?:\.\d+)*(?:[A-Za-z])?(?:\s*(?::|-)\s*|$)/;
+export function stripScopePrefixFromSubject(subject) {
+    return subject.trim().replace(SCOPE_PREFIX_PATTERN, '').trim();
+}
+export function stripScopePrefixFromCommitMessage(message) {
+    const normalized = message.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    const strippedSubject = stripScopePrefixFromSubject(lines[0] ?? '');
+    if (strippedSubject) {
+        return [strippedSubject, ...lines.slice(1)].join('\n');
+    }
+    const firstBodyLineIndex = lines.findIndex((line, index) => index > 0 && line.trim());
+    if (firstBodyLineIndex === -1) {
+        return '';
+    }
+    return lines.slice(firstBodyLineIndex).join('\n');
+}

package/dist/neal/config.js

@@ -0,0 +1,432 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import YAML from 'yaml';
+import { assertAgentConfigSupportsWriterRun, parseProviderId, } from './providers/registry.js';
+const OPENAI_COMPATIBLE_DEFAULT_API_KEY_ENV = 'OPENAI_COMPATIBLE_API_KEY';
+const WRITER_PROVIDER_CONFIG_KEYS = {
+    coder: 'agent.coder.provider',
+    reviewer: 'agent.reviewer.provider',
+};
+const DEFAULT_CONFIG = {
+    neal: {
+        phase_heartbeat_ms: 60_000,
+        max_review_rounds: 20,
+        review_stuck_window: 5,
+        inactivity_timeout_ms: 600_000,
+        api_retry_limit: 10,
+        agent_turn_startup_timeout_ms: 300_000,
+        agent_turn_retry_limit: 1,
+        interactive_blocked_recovery_max_turns: 3,
+        final_completion_continue_execution_max: 2,
+        review_stuck_arbiter_max_attempts: 1,
+        notify_bin: null,
+    },
+    agent: {
+        planner: {
+            provider: 'openai-codex',
+            model: null,
+        },
+        coder: {
+            provider: 'openai-codex',
+            model: null,
+        },
+        reviewer: {
+            provider: 'anthropic-claude',
+            model: null,
+        },
+        unattended: false,
+    },
+};
+const cachedConfig = new Map();
+function buildWriterProviderSetupLines(guidance, missingProviderKeys) {
+    const missingKeys = missingProviderKeys.length > 0
+        ? missingProviderKeys
+        : Object.values(WRITER_PROVIDER_CONFIG_KEYS);
+    if (guidance === 'check') {
+        return [
+            'Neal is not set up yet.',
+            'Run `neal setup` to choose providers, then run `neal check` again.',
+        ];
+    }
+    return [
+        'Neal is not set up yet.',
+        `Run \`neal setup\` to choose providers, or set ${formatInlineList(missingKeys)} in config.yml.`,
+    ];
+}
+function formatInlineList(values) {
+    if (values.length <= 1) {
+        return values[0] ?? '';
+    }
+    return `${values.slice(0, -1).join(', ')} and ${values[values.length - 1]}`;
+}
+export class WriterProvidersNotConfiguredError extends Error {
+    guidance;
+    lines;
+    missingProviderKeys;
+    constructor(guidance = 'writer-run', missingProviderKeys = []) {
+        const lines = buildWriterProviderSetupLines(guidance, missingProviderKeys);
+        super(lines.join('\n'));
+        this.name = 'WriterProvidersNotConfiguredError';
+        this.guidance = guidance;
+        this.lines = lines;
+        this.missingProviderKeys = [...missingProviderKeys];
+    }
+}
+export function isWriterProvidersNotConfiguredError(error) {
+    return error instanceof WriterProvidersNotConfiguredError;
+}
+export function formatWriterProviderSetupRequiredLines(error, prefix = '') {
+    return prefix ? error.lines.map((line) => `${prefix} ${line}`) : [...error.lines];
+}
+export function clearConfigCache(cwd) {
+    if (cwd) {
+        cachedConfig.delete(resolve(cwd));
+        return;
+    }
+    cachedConfig.clear();
+}
+function parseNumberValue(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value.trim());
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function parseStringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function parseConfigProviderValue(value, fieldPath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === 'string' && !value.trim()) {
+        return undefined;
+    }
+    return parseProviderId(value, fieldPath);
+}
+function parseExplicitProviderValue(value, fieldPath) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value === 'string' && !value.trim()) {
+        return null;
+    }
+    return parseProviderId(value, fieldPath);
+}
+function parseExplicitModelValue(value) {
+    return parseStringValue(value) ?? null;
+}
+function parseExplicitEffortValue(value) {
+    return parseStringValue(value) ?? null;
+}
+function hasOwnConfigKey(value, key) {
+    return value !== null && value !== undefined && Object.prototype.hasOwnProperty.call(value, key);
+}
+function readYamlFileIfPresent(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    const parsed = YAML.parse(readFileSync(path, 'utf8'));
+    if (!parsed || typeof parsed !== 'object') {
+        return null;
+    }
+    return parsed;
+}
+function mergeConfig(base, override) {
+    if (!override) {
+        return base;
+    }
+    return {
+        neal: {
+            ...base.neal,
+            ...override.neal,
+        },
+        agent: {
+            planner: {
+                ...base.agent?.planner,
+                ...override.agent?.planner,
+            },
+            coder: {
+                ...base.agent?.coder,
+                ...override.agent?.coder,
+            },
+            reviewer: {
+                ...base.agent?.reviewer,
+                ...override.agent?.reviewer,
+            },
+            // Scalar agent toggle: merged explicitly because the deep-merge above only
+            // covers the three provider sub-objects. Override wins when present.
+            unattended: override.agent?.unattended ?? base.agent?.unattended,
+        },
+        providers: {
+            openai_compatible: {
+                ...base.providers?.openai_compatible,
+                ...override.providers?.openai_compatible,
+            },
+        },
+    };
+}
+export function getConfigSourceInfo(cwd = process.cwd()) {
+    const repoPath = resolve(cwd, 'config.yml');
+    const userPath = join(homedir(), '.neal', 'config.yml');
+    return {
+        repo: {
+            path: repoPath,
+            exists: existsSync(repoPath),
+        },
+        user: {
+            path: userPath,
+            exists: existsSync(userPath),
+        },
+    };
+}
+function loadConfigFile(cwd = process.cwd()) {
+    const cacheKey = resolve(cwd);
+    const cached = cachedConfig.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const sources = getConfigSourceInfo(cacheKey);
+    const resolved = mergeConfig(mergeConfig({}, readYamlFileIfPresent(sources.user.path)), readYamlFileIfPresent(sources.repo.path));
+    cachedConfig.set(cacheKey, resolved);
+    return resolved;
+}
+export function getRawMergedConfig(cwd = process.cwd()) {
+    return loadConfigFile(cwd);
+}
+function readExplicitAgentConfig(cwd = process.cwd()) {
+    const config = getRawMergedConfig(cwd);
+    const coderProvider = parseExplicitProviderValue(config.agent?.coder?.provider, WRITER_PROVIDER_CONFIG_KEYS.coder);
+    const reviewerProvider = parseExplicitProviderValue(config.agent?.reviewer?.provider, WRITER_PROVIDER_CONFIG_KEYS.reviewer);
+    const missingProviderKeys = [];
+    if (!coderProvider) {
+        missingProviderKeys.push(WRITER_PROVIDER_CONFIG_KEYS.coder);
+    }
+    if (!reviewerProvider) {
+        missingProviderKeys.push(WRITER_PROVIDER_CONFIG_KEYS.reviewer);
+    }
+    if (!coderProvider || !reviewerProvider) {
+        return {
+            agentConfig: null,
+            missingProviderKeys,
+        };
+    }
+    const plannerProvider = parseConfigProviderValue(config.agent?.planner?.provider, 'agent.planner.provider');
+    return {
+        agentConfig: {
+            planner: {
+                provider: plannerProvider ?? coderProvider,
+                model: hasOwnConfigKey(config.agent?.planner, 'model')
+                    ? parseExplicitModelValue(config.agent.planner.model)
+                    : plannerProvider
+                        ? null
+                        : parseExplicitModelValue(config.agent?.coder?.model),
+                effort: hasOwnConfigKey(config.agent?.planner, 'effort')
+                    ? parseExplicitEffortValue(config.agent.planner.effort)
+                    : plannerProvider
+                        ? null
+                        : parseExplicitEffortValue(config.agent?.coder?.effort),
+            },
+            coder: {
+                provider: coderProvider,
+                model: parseExplicitModelValue(config.agent?.coder?.model),
+                effort: parseExplicitEffortValue(config.agent?.coder?.effort),
+            },
+            reviewer: {
+                provider: reviewerProvider,
+                model: parseExplicitModelValue(config.agent?.reviewer?.model),
+                effort: parseExplicitEffortValue(config.agent?.reviewer?.effort),
+            },
+        },
+        missingProviderKeys: [],
+    };
+}
+export function getExplicitAgentConfig(cwd = process.cwd()) {
+    return readExplicitAgentConfig(cwd).agentConfig;
+}
+export function assertWriterProvidersConfigured(cwd = process.cwd(), options = {}) {
+    const { agentConfig, missingProviderKeys } = readExplicitAgentConfig(cwd);
+    if (!agentConfig) {
+        throw new WriterProvidersNotConfiguredError(options.guidance ?? 'writer-run', missingProviderKeys);
+    }
+    assertAgentConfigSupportsWriterRun(agentConfig, { context: options.context });
+    return agentConfig;
+}
+export function getInactivityTimeoutMs(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.inactivity_timeout_ms) ??
+        DEFAULT_CONFIG.neal.inactivity_timeout_ms);
+}
+export function getApiRetryLimit(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.api_retry_limit) ??
+        DEFAULT_CONFIG.neal.api_retry_limit);
+}
+export function getAgentTurnStartupTimeoutMs(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.agent_turn_startup_timeout_ms) ??
+        DEFAULT_CONFIG.neal.agent_turn_startup_timeout_ms);
+}
+export function getAgentTurnRetryLimit(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.agent_turn_retry_limit) ??
+        DEFAULT_CONFIG.neal.agent_turn_retry_limit);
+}
+export function getPhaseHeartbeatMs(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.phase_heartbeat_ms) ??
+        DEFAULT_CONFIG.neal.phase_heartbeat_ms);
+}
+export function getMaxReviewRounds(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.max_review_rounds) ??
+        DEFAULT_CONFIG.neal.max_review_rounds);
+}
+export function getReviewStuckWindow(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.review_stuck_window) ??
+        DEFAULT_CONFIG.neal.review_stuck_window);
+}
+export function getReviewStuckArbiterMaxAttempts(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    const raw = parseNumberValue(config.neal?.review_stuck_arbiter_max_attempts) ??
+        DEFAULT_CONFIG.neal.review_stuck_arbiter_max_attempts;
+    // Clamp to a non-negative integer (0 disables the arbiter entirely).
+    if (!Number.isFinite(raw) || raw <= 0) {
+        return 0;
+    }
+    return Math.floor(raw);
+}
+export function getInteractiveBlockedRecoveryMaxTurns(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.interactive_blocked_recovery_max_turns) ??
+        DEFAULT_CONFIG.neal.interactive_blocked_recovery_max_turns);
+}
+export function getFinalCompletionContinueExecutionMax(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseNumberValue(config.neal?.final_completion_continue_execution_max) ??
+        DEFAULT_CONFIG.neal.final_completion_continue_execution_max);
+}
+export function getNotifyBin(cwd = process.cwd(), env = process.env) {
+    // NEAL_NOTIFY_BIN overrides config entirely: a non-empty value selects that
+    // helper, and a defined-but-empty value disables notifications. The test
+    // suite sets the empty form so test fixtures that resolve effective config
+    // (which falls through to ~/.neal/config.yml) never invoke the operator's
+    // real notification helper.
+    const envOverride = env.NEAL_NOTIFY_BIN;
+    if (envOverride !== undefined) {
+        return envOverride.trim() === '' ? null : envOverride;
+    }
+    const config = loadConfigFile(cwd);
+    return (parseStringValue(config.neal?.notify_bin) ??
+        DEFAULT_CONFIG.neal.notify_bin);
+}
+function parseOpenAICompatibleHeaders(value) {
+    if (value === undefined || value === null) {
+        return {};
+    }
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Invalid providers.openai_compatible.headers: expected a map of string header names to string values.');
+    }
+    const headers = {};
+    for (const [key, headerValue] of Object.entries(value)) {
+        if (!key.trim()) {
+            throw new Error('Invalid providers.openai_compatible.headers: header names must be non-empty strings.');
+        }
+        if (typeof headerValue !== 'string') {
+            throw new Error(`Invalid providers.openai_compatible.headers: value for "${key}" must be a string.`);
+        }
+        headers[key] = headerValue;
+    }
+    return headers;
+}
+export function getOpenAICompatibleSettings(cwd = process.cwd(), env = process.env) {
+    const config = loadConfigFile(cwd).providers?.openai_compatible;
+    const baseUrl = parseStringValue(config?.base_url) ??
+        parseStringValue(env.OPENAI_COMPATIBLE_BASE_URL) ??
+        null;
+    const apiKeyEnv = parseStringValue(config?.api_key_env) ?? OPENAI_COMPATIBLE_DEFAULT_API_KEY_ENV;
+    const apiKey = parseStringValue(env[apiKeyEnv]) ?? null;
+    const defaultModel = parseStringValue(config?.default_model) ??
+        parseStringValue(env.OPENAI_COMPATIBLE_MODEL) ??
+        null;
+    const headers = parseOpenAICompatibleHeaders(config?.headers);
+    return {
+        baseUrl,
+        apiKeyEnv,
+        apiKey,
+        defaultModel,
+        headers,
+    };
+}
+export function getDefaultCoderProvider(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseConfigProviderValue(config.agent?.coder?.provider, 'agent.coder.provider') ??
+        DEFAULT_CONFIG.agent.coder.provider);
+}
+export function getDefaultCoderModel(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return config.agent?.coder?.model === null
+        ? null
+        : (parseStringValue(config.agent?.coder?.model) ?? DEFAULT_CONFIG.agent.coder.model);
+}
+export function getConfiguredUnattended(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return typeof config.agent?.unattended === 'boolean'
+        ? config.agent.unattended
+        : DEFAULT_CONFIG.agent.unattended;
+}
+export function getDefaultPlannerProvider(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseConfigProviderValue(config.agent?.planner?.provider, 'agent.planner.provider') ??
+        getDefaultCoderProvider(cwd));
+}
+export function getDefaultPlannerModel(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    const plannerProvider = parseConfigProviderValue(config.agent?.planner?.provider, 'agent.planner.provider');
+    if (hasOwnConfigKey(config.agent?.planner, 'model')) {
+        return config.agent.planner.model === null
+            ? null
+            : (parseStringValue(config.agent.planner.model) ?? null);
+    }
+    if (plannerProvider) {
+        return DEFAULT_CONFIG.agent.planner.model;
+    }
+    return getDefaultCoderModel(cwd);
+}
+export function getDefaultReviewerProvider(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return (parseConfigProviderValue(config.agent?.reviewer?.provider, 'agent.reviewer.provider') ??
+        DEFAULT_CONFIG.agent.reviewer.provider);
+}
+export function getDefaultReviewerModel(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return config.agent?.reviewer?.model === null
+        ? null
+        : (parseStringValue(config.agent?.reviewer?.model) ?? DEFAULT_CONFIG.agent.reviewer.model);
+}
+export function getDefaultCoderEffort(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return parseStringValue(config.agent?.coder?.effort) ?? null;
+}
+export function getDefaultReviewerEffort(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return parseStringValue(config.agent?.reviewer?.effort) ?? null;
+}
+export function getDefaultPlannerEffort(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    const plannerProvider = parseConfigProviderValue(config.agent?.planner?.provider, 'agent.planner.provider');
+    if (hasOwnConfigKey(config.agent?.planner, 'effort')) {
+        return parseStringValue(config.agent.planner.effort) ?? null;
+    }
+    if (plannerProvider) {
+        return null;
+    }
+    return getDefaultCoderEffort(cwd);
+}