@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/dist/update-check.js

@@ -0,0 +1,235 @@
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import chalk from 'chalk';
+import { isInteractiveOutputAllowed, writeLine } from './terminal.js';
+const PACKAGE_NAME = '@todoist/doistbot-cli';
+const REGISTRY_LATEST_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
+const BACKGROUND_FETCH_TIMEOUT_MS = 5_000;
+const FOREGROUND_FETCH_TIMEOUT_MS = 10_000;
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1_000;
+export function getDefaultUpdateCheckCachePath() {
+    const configRoot = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+    return path.join(configRoot, 'doistbot-cli', 'update-check.json');
+}
+export function isNewerVersion(latestVersion, currentVersion) {
+    const latest = parseVersion(latestVersion);
+    const current = parseVersion(currentVersion);
+    if (!latest || !current) {
+        return false;
+    }
+    for (const [index, latestPart] of latest.entries()) {
+        const currentPart = current[index] ?? 0;
+        if (latestPart > currentPart) {
+            return true;
+        }
+        if (latestPart < currentPart) {
+            return false;
+        }
+    }
+    return false;
+}
+export async function notifyIfCliUpdateAvailable({ cachePath = getDefaultUpdateCheckCachePath(), currentVersion, fetchLatestVersion = fetchLatestPackageVersion, timeoutMs = FOREGROUND_FETCH_TIMEOUT_MS, writeLine: write = writeLine, }) {
+    const latestVersion = await refreshCliUpdateCache({
+        cachePath,
+        currentVersion,
+        fetchLatestVersion,
+        timeoutMs,
+    });
+    if (!latestVersion) {
+        write('Unable to check for Doistbot CLI updates.');
+        return;
+    }
+    if (!isNewerVersion(latestVersion, currentVersion)) {
+        write(`doistbot ${currentVersion} is up to date.`);
+        return;
+    }
+    write(formatCliUpdateNotice({ currentVersion, latestVersion }));
+}
+export async function notifyAndRefreshCliUpdateCache({ cachePath = getDefaultUpdateCheckCachePath(), currentVersion, env = process.env, now = new Date(), spawnProcess = spawn, stdout = process.stdout, updateCacheEntrypointPath, writeLine: write = writeLine, }) {
+    if (!isUpdateCheckEnabled({ env, stdout })) {
+        return;
+    }
+    const cache = await readUpdateCheckCache(cachePath);
+    writeCachedCliUpdateNotice({ cache, currentVersion, writeLine: write });
+    if (shouldRefreshCliUpdateCache({ cache, now })) {
+        refreshCliUpdateCacheInBackground({
+            cachePath,
+            currentVersion,
+            env,
+            spawnProcess,
+            updateCacheEntrypointPath,
+        });
+    }
+}
+export function isUpdateCheckEnabled({ env = process.env, stdout = process.stdout, } = {}) {
+    return (env.DOISTBOT_DISABLE_UPDATE_CHECK !== 'true' &&
+        env.DOISTBOT_DISABLE_UPDATE_CHECK !== '1' &&
+        isInteractiveOutputAllowed({ env, stream: stdout }));
+}
+export async function refreshCliUpdateCache({ cachePath = getDefaultUpdateCheckCachePath(), fetchLatestVersion = fetchLatestPackageVersion, now = new Date(), timeoutMs = BACKGROUND_FETCH_TIMEOUT_MS, }) {
+    const latestVersion = await fetchLatestVersionWithTimeout(fetchLatestVersion, timeoutMs);
+    const previousCache = await readUpdateCheckCache(cachePath);
+    try {
+        await writeUpdateCheckCache({
+            cachePath,
+            checkedAt: now,
+            latestVersion: latestVersion ?? previousCache?.latestVersion,
+        });
+    }
+    catch {
+        // Cache writes are best-effort; a successful registry lookup should still be usable.
+    }
+    return latestVersion;
+}
+export function formatCliUpdateNotice({ currentVersion, latestVersion, }) {
+    const homebrewCommand = 'brew update && brew upgrade doistbot-cli';
+    const npmCommand = `npm install -g ${PACKAGE_NAME}@latest`;
+    const plainLines = [
+        `Update available: doistbot ${currentVersion} -> ${latestVersion}`,
+        '',
+        'Homebrew',
+        `  ${homebrewCommand}`,
+        '',
+        'npm',
+        `  ${npmCommand}`,
+    ];
+    const innerWidth = Math.max(...plainLines.map((line) => line.length)) + 2;
+    const border = colorizeUpdateNotice(`┌${'─'.repeat(innerWidth + 2)}┐`);
+    const footer = colorizeUpdateNotice(`└${'─'.repeat(innerWidth + 2)}┘`);
+    const renderedLines = plainLines.map((line, index) => renderBoxLine(line, index === 0 ? renderUpdateTitle(currentVersion, latestVersion) : renderUpdateLine(line), innerWidth));
+    return ['', '', border, ...renderedLines, footer].join('\n');
+}
+function renderUpdateTitle(currentVersion, latestVersion) {
+    return [
+        chalk.yellow('Update available: doistbot '),
+        chalk.bold.yellow(currentVersion),
+        chalk.yellow(' -> '),
+        chalk.bold.yellow(latestVersion),
+    ].join('');
+}
+function renderUpdateLine(line) {
+    if (line.startsWith('  ')) {
+        return `  ${chalk.italic.white(line.trim())}`;
+    }
+    return colorizeUpdateNotice(line);
+}
+function renderBoxLine(plainLine, renderedLine, innerWidth) {
+    const padding = ' '.repeat(innerWidth - plainLine.length);
+    const border = colorizeUpdateNotice('│');
+    return `${border} ${renderedLine}${padding} ${border}`;
+}
+function colorizeUpdateNotice(value) {
+    return chalk.yellow(value);
+}
+async function fetchLatestVersionWithTimeout(fetchLatestVersion, timeoutMs) {
+    try {
+        return await fetchLatestVersion(AbortSignal.timeout(timeoutMs));
+    }
+    catch {
+        return undefined;
+    }
+}
+function shouldRefreshCliUpdateCache({ cache, now, }) {
+    if (!cache?.checkedAt) {
+        return true;
+    }
+    return now.getTime() - cache.checkedAt.getTime() >= UPDATE_CHECK_INTERVAL_MS;
+}
+function refreshCliUpdateCacheInBackground({ cachePath, currentVersion, env, spawnProcess, updateCacheEntrypointPath, }) {
+    try {
+        const child = spawnProcess(process.execPath, [
+            updateCacheEntrypointPath,
+            '--cache-path',
+            cachePath,
+            '--current-version',
+            currentVersion,
+        ], {
+            detached: true,
+            env: createUpdateCacheRefreshEnv(env),
+            stdio: 'ignore',
+        });
+        child.on('error', () => undefined);
+        child.unref();
+    }
+    catch {
+        // Background refresh must never fail the foreground CLI command.
+    }
+}
+function createUpdateCacheRefreshEnv(env) {
+    const allowedEnvKeys = [
+        'HOME',
+        'HTTPS_PROXY',
+        'HTTP_PROXY',
+        'LOGNAME',
+        'NODE_EXTRA_CA_CERTS',
+        'NO_PROXY',
+        'PATH',
+        'SHELL',
+        'SSL_CERT_DIR',
+        'SSL_CERT_FILE',
+        'TEMP',
+        'TMP',
+        'TMPDIR',
+        'USER',
+        'XDG_CACHE_HOME',
+        'https_proxy',
+        'http_proxy',
+        'no_proxy',
+    ];
+    const minimalEnv = {};
+    for (const key of allowedEnvKeys) {
+        if (env[key] !== undefined) {
+            minimalEnv[key] = env[key];
+        }
+    }
+    return minimalEnv;
+}
+function writeCachedCliUpdateNotice({ cache, currentVersion, writeLine: write, }) {
+    if (!cache?.latestVersion || !isNewerVersion(cache.latestVersion, currentVersion)) {
+        return;
+    }
+    write(formatCliUpdateNotice({ currentVersion, latestVersion: cache.latestVersion }));
+}
+async function readUpdateCheckCache(cachePath) {
+    try {
+        const cache = JSON.parse(await readFile(cachePath, 'utf8'));
+        const checkedAt = typeof cache.checkedAt === 'string' ? new Date(cache.checkedAt) : undefined;
+        return {
+            checkedAt: checkedAt && Number.isFinite(checkedAt.getTime()) ? checkedAt : undefined,
+            latestVersion: typeof cache.latestVersion === 'string' ? cache.latestVersion : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeUpdateCheckCache({ cachePath, checkedAt, latestVersion, }) {
+    await mkdir(path.dirname(cachePath), { recursive: true });
+    const cache = {
+        checkedAt: checkedAt.toISOString(),
+    };
+    if (latestVersion) {
+        cache.latestVersion = latestVersion;
+    }
+    await writeFile(cachePath, `${JSON.stringify(cache, null, 4)}\n`);
+}
+async function fetchLatestPackageVersion(signal) {
+    const response = await fetch(REGISTRY_LATEST_URL, {
+        headers: { accept: 'application/json' },
+        signal,
+    });
+    if (!response.ok) {
+        return undefined;
+    }
+    const body = (await response.json());
+    return typeof body.version === 'string' ? body.version : undefined;
+}
+function parseVersion(version) {
+    const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)/);
+    if (!match) {
+        return undefined;
+    }
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}

package/package.json

@@ -1,6 +1,66 @@
 {
-  "name": "@todoist/doistbot-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@todoist/doistbot-cli",
+    "version": "1.0.16",
+    "description": "Local self-review CLI for Doistbot",
+    "type": "module",
+    "main": "dist/index.js",
+    "bin": {
+        "db": "dist/index.js",
+        "doistbot": "dist/index.js"
+    },
+    "keywords": [
+        "doist",
+        "doistbot",
+        "cli",
+        "review"
+    ],
+    "author": "Doist",
+    "license": "UNLICENSED",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/todoist/doistbot-app.git",
+        "directory": "apps/cli"
+    },
+    "preferGlobal": true,
+    "publishConfig": {
+        "access": "public"
+    },
+    "engines": {
+        "node": ">=24"
+    },
+    "files": [
+        "dist",
+        "!dist/**/*.test.js",
+        "!dist/pr-review-dry-run.*",
+        "sandbox",
+        "!sandbox/**/*.test.d.ts",
+        "!sandbox/**/*.test.js",
+        "!sandbox/dist/tasks/review/pr-dry-run*",
+        "scripts/restore-runtime-assets.mjs",
+        "package.json"
+    ],
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json && node scripts/copy-runtime-assets.mjs && node scripts/mark-bin-executable.mjs",
+        "postinstall": "node scripts/restore-runtime-assets.mjs",
+        "prepublishOnly": "npm run build && npm test",
+        "typecheck": "tsc --noEmit",
+        "test": "vitest run src scripts --config ../../config/vitest.base.ts"
+    },
+    "dependencies": {
+        "@earendil-works/pi-ai": "0.99.2",
+        "@earendil-works/pi-coding-agent": "0.99.2",
+        "@inquirer/checkbox": "5.2.8",
+        "@inquirer/password": "5.2.5",
+        "@napi-rs/keyring": "1.3.0",
+        "@opentelemetry/api": "1.10.0",
+        "ajv": "8.20.0",
+        "chalk": "4.1.2",
+        "commander": "14.0.3",
+        "js-yaml": "4.3.2",
+        "undici": "8.12.4",
+        "yocto-spinner": "1.2.2"
+    },
+    "devDependencies": {
+        "vitest": "4.1.12"
+    }
+}

package/sandbox/_node_modules/doistbot-logging/dist/index.d.ts

@@ -0,0 +1,23 @@
+export type LogLevel = 'info' | 'warn' | 'error';
+export type LogMeta = Record<string, unknown>;
+export type LoggerOptions = {
+    baseContext?: LogMeta;
+    getContext?: () => LogMeta | undefined;
+    getTraceInfo?: () => LogMeta | undefined;
+    suppressLogs?: (level: LogLevel) => boolean;
+    suppressInfoLogs?: () => boolean;
+    includeLogField?: boolean;
+    /** Receives serialized JSON without a trailing newline. The writer must add one. */
+    write?: (line: string) => void;
+    buildInfo?: {
+        version: number;
+        commit: string;
+    };
+};
+export type Logger = {
+    info: (message: string, meta?: LogMeta) => void;
+    warn: (message: string, meta?: LogMeta) => void;
+    error: (message: string, meta?: LogMeta) => void;
+    setBaseContext: (meta: LogMeta) => void;
+};
+export declare function createLogger(options?: LoggerOptions): Logger;

package/sandbox/_node_modules/doistbot-logging/dist/index.js

@@ -0,0 +1,51 @@
+export function createLogger(options = {}) {
+    let baseContext = options.baseContext ?? {};
+    const includeLogField = options.includeLogField ?? false;
+    const buildInfo = options.buildInfo;
+    function setBaseContext(meta) {
+        baseContext = meta;
+    }
+    function log(level, message, meta) {
+        if (options.suppressLogs?.(level) === true) {
+            return;
+        }
+        if (level === 'info' && options.suppressInfoLogs?.() === true) {
+            return;
+        }
+        const context = options.getContext?.() ?? {};
+        const traceInfo = options.getTraceInfo?.() ?? {};
+        const metaInfo = {
+            ...context,
+            ...baseContext,
+            ...(meta ?? {}),
+        };
+        const payload = {
+            level,
+            message,
+            timestamp: new Date().toISOString(),
+        };
+        if (includeLogField) {
+            payload.log = message;
+        }
+        if (buildInfo) {
+            payload.version = buildInfo.version;
+            payload.commit = buildInfo.commit;
+        }
+        Object.assign(payload, traceInfo);
+        payload.meta = metaInfo;
+        const line = JSON.stringify(payload);
+        if (options.write) {
+            options.write(line);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(line);
+        }
+    }
+    return {
+        info: (message, meta) => log('info', message, meta),
+        warn: (message, meta) => log('warn', message, meta),
+        error: (message, meta) => log('error', message, meta),
+        setBaseContext,
+    };
+}

package/sandbox/_node_modules/doistbot-logging/package.json

@@ -0,0 +1,12 @@
+{
+    "name": "doistbot-logging",
+    "version": "1.0.0",
+    "type": "module",
+    "main": "dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./src/index.ts",
+            "default": "./dist/index.js"
+        }
+    }
+}

package/sandbox/_node_modules/doistbot-repo-config/dist/index.d.ts

@@ -0,0 +1,93 @@
+import type { Logger } from 'doistbot-logging';
+import type { Octokit } from 'octokit';
+export declare const CONFIG_FILE_PATH = ".github/doistbot.yml";
+export declare const DEFAULT_REVIEW_MODELS: readonly ["openai", "deepseek", "zai"];
+export type DefaultReviewModel = (typeof DEFAULT_REVIEW_MODELS)[number];
+export type AutofixPolicy = {
+    guidance?: string;
+    forbidden_test_paths?: string[];
+    verification: {
+        checks: {
+            name: string;
+            command: string;
+            use_test_selectors?: boolean;
+        }[];
+    };
+};
+export type ReviewModeConfig = {
+    guidance_path?: string;
+    labels?: {
+        ask?: string[];
+        show?: string[];
+        ship?: string[];
+    };
+};
+export type RepoConfig = {
+    review?: {
+        skip_forks?: boolean;
+        skip_drafts?: boolean;
+        skip_title_pattern?: string;
+        skip_branch_pattern?: string;
+        mode?: ReviewModeConfig;
+        /**
+         * @deprecated Ignored as of #274. Doistbot now posts a GitHub Check
+         * Run for every `/review` (always-on; no opt-in) when `HEAD_SHA` is
+         * available. Kept here for back-compat: any existing
+         * `.github/doistbot.yml` setting this field will parse fine but the
+         * value has no effect.
+         */
+        post_commit_status?: boolean;
+    };
+    issue_triage?: {
+        enable_auto_triage?: boolean;
+        prompts?: {
+            triage?: string;
+            autofix?: string;
+        };
+        /** @deprecated Ignored. Every actionable triage report starts a fix. */
+        enable_auto_fix?: boolean;
+        /** @deprecated Ignored. Every issue fix uses the review and CI loop. */
+        use_fix_loop?: boolean;
+        max_changed_files?: number;
+        max_changed_lines?: number;
+        autofix?: AutofixPolicy;
+    };
+};
+type FetchFileParams = {
+    octokit: Octokit;
+    owner: string;
+    repo: string;
+    path: string;
+    ref?: string;
+    signal?: AbortSignal;
+    logger?: Logger;
+    strict?: boolean;
+    maxBytes?: number;
+};
+export declare class RepoFileContentError extends Error {
+    readonly reason: 'not_file' | 'too_large' | 'unavailable';
+    constructor(reason: 'not_file' | 'too_large' | 'unavailable');
+}
+/** Review-mode validation is opt-in so it cannot block unrelated config callers. */
+export declare function parseRepoConfigContent(content: string, { validateReviewMode }?: {
+    validateReviewMode?: boolean;
+}): RepoConfig;
+export declare function fetchFileContent({ octokit, owner, repo, path, ref, signal, logger, strict, maxBytes, }: FetchFileParams): Promise<string | null>;
+/**
+ * Fetches the repository-specific configuration from .github/doistbot.yml.
+ * Returns null when the file is genuinely absent (404) or the path is not a file.
+ * Throws on transport / authorization errors so callers can distinguish "no
+ * config" from "could not load config" — important when an opt-out flag would
+ * otherwise be silently ignored.
+ */
+export declare function getRepoConfig({ octokit, owner, repo, ref, signal, logger, }: Omit<FetchFileParams, 'path' | 'strict' | 'maxBytes'> & {
+    logger: Logger;
+}): Promise<RepoConfig | null>;
+export declare function getLocalRepoConfig({ workspaceDir, logger, strict, }: {
+    workspaceDir: string;
+    logger: Logger;
+    strict?: boolean;
+}): RepoConfig | null;
+export declare function getDefaultReviewModels(): DefaultReviewModel[];
+export declare function parseReviewModelsEnabled(value: string | undefined): string[];
+export {};

package/sandbox/_node_modules/doistbot-repo-config/dist/index.js

@@ -0,0 +1,197 @@
+import fs from 'fs';
+import path from 'path';
+import { load as yamlLoad } from 'js-yaml';
+export const CONFIG_FILE_PATH = '.github/doistbot.yml';
+export const DEFAULT_REVIEW_MODELS = ['openai', 'deepseek', 'zai'];
+export class RepoFileContentError extends Error {
+    reason;
+    constructor(reason) {
+        super(`Repository file content is ${reason}`);
+        this.reason = reason;
+        this.name = 'RepoFileContentError';
+    }
+}
+function isMapping(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null));
+}
+function hasControlCharacters(value) {
+    return [...value].some((character) => {
+        const code = character.charCodeAt(0);
+        return code < 0x20 || code === 0x7f;
+    });
+}
+function parseReviewModeConfig(value) {
+    if (!isMapping(value)) {
+        throw new Error('review.mode must be a mapping');
+    }
+    const mode = {};
+    if (value.guidance_path !== undefined) {
+        const guidancePath = value.guidance_path;
+        if (typeof guidancePath !== 'string' ||
+            !guidancePath.trim() ||
+            path.posix.isAbsolute(guidancePath.trim()) ||
+            path.win32.isAbsolute(guidancePath.trim()) ||
+            /^[a-z][a-z\d+.-]*:/i.test(guidancePath.trim()) ||
+            guidancePath.includes('\\') ||
+            hasControlCharacters(guidancePath) ||
+            guidancePath.trim().split('/').includes('..') ||
+            !/\.(md|markdown)$/i.test(guidancePath.trim())) {
+            throw new Error('review.mode.guidance_path must be a repository-relative Markdown path');
+        }
+        mode.guidance_path = path.posix.normalize(guidancePath.trim());
+    }
+    if (value.labels !== undefined) {
+        if (!isMapping(value.labels)) {
+            throw new Error('review.mode.labels must be a mapping');
+        }
+        mode.labels = {};
+        for (const category of ['ask', 'show', 'ship']) {
+            const labels = value.labels[category];
+            if (labels === undefined)
+                continue;
+            if (!Array.isArray(labels) ||
+                labels.some((label) => typeof label !== 'string' || !label.trim() || hasControlCharacters(label))) {
+                throw new Error(`review.mode.labels.${category} must contain non-empty label names`);
+            }
+            mode.labels[category] = labels.map((label) => label.trim());
+        }
+    }
+    return mode;
+}
+/** Review-mode validation is opt-in so it cannot block unrelated config callers. */
+export function parseRepoConfigContent(content, { validateReviewMode = false } = {}) {
+    const config = yamlLoad(content);
+    if (!validateReviewMode)
+        return config;
+    if (!isMapping(config)) {
+        throw new Error('Repository configuration must be a mapping');
+    }
+    if (config.review !== undefined) {
+        if (!isMapping(config.review)) {
+            throw new Error('review must be a mapping');
+        }
+        if (config.review.mode !== undefined) {
+            config.review.mode = parseReviewModeConfig(config.review.mode);
+        }
+    }
+    return config;
+}
+export async function fetchFileContent({ octokit, owner, repo, path, ref, signal, logger, strict = false, maxBytes, }) {
+    const params = {
+        owner,
+        repo,
+        path,
+    };
+    if (ref) {
+        params.ref = ref;
+    }
+    if (signal) {
+        params.request = { signal };
+    }
+    let response;
+    try {
+        response = await octokit.rest.repos.getContent(params);
+    }
+    catch (error) {
+        if (error instanceof Error && 'status' in error && error.status === 404) {
+            logger?.info('File not found', {
+                component: 'repo-config',
+                repository: `${owner}/${repo}`,
+                path,
+            });
+            return null;
+        }
+        throw error;
+    }
+    const { data } = response;
+    if (!('type' in data) || data.type !== 'file' || (strict && 'target' in data)) {
+        if (strict)
+            throw new RepoFileContentError('not_file');
+        logger?.warn('Path exists but is not a file', {
+            component: 'repo-config',
+            repository: `${owner}/${repo}`,
+            path,
+        });
+        return null;
+    }
+    if (maxBytes !== undefined && 'size' in data && data.size > maxBytes) {
+        throw new RepoFileContentError('too_large');
+    }
+    if (!('content' in data) ||
+        typeof data.content !== 'string' ||
+        (strict && 'encoding' in data && data.encoding !== 'base64')) {
+        if (strict)
+            throw new RepoFileContentError('unavailable');
+        return null;
+    }
+    if (!strict && !data.content)
+        return null;
+    const content = Buffer.from(data.content, 'base64').toString('utf8');
+    if (maxBytes !== undefined && Buffer.byteLength(content, 'utf8') > maxBytes) {
+        throw new RepoFileContentError('too_large');
+    }
+    return content;
+}
+/**
+ * Fetches the repository-specific configuration from .github/doistbot.yml.
+ * Returns null when the file is genuinely absent (404) or the path is not a file.
+ * Throws on transport / authorization errors so callers can distinguish "no
+ * config" from "could not load config" — important when an opt-out flag would
+ * otherwise be silently ignored.
+ */
+export async function getRepoConfig({ octokit, owner, repo, ref, signal, logger, }) {
+    const content = await fetchFileContent({
+        octokit,
+        owner,
+        repo,
+        path: CONFIG_FILE_PATH,
+        ref,
+        signal,
+        logger,
+    });
+    if (content === null) {
+        return null;
+    }
+    const config = parseRepoConfigContent(content);
+    logger.info('Loaded repo config', {
+        component: 'repo-config',
+        repository: `${owner}/${repo}`,
+        path: CONFIG_FILE_PATH,
+    });
+    return config;
+}
+export function getLocalRepoConfig({ workspaceDir, logger, strict = false, }) {
+    const configPath = path.join(workspaceDir, CONFIG_FILE_PATH);
+    try {
+        const config = parseRepoConfigContent(fs.readFileSync(configPath, 'utf8'));
+        logger.info('Loaded local repo config', {
+            component: 'repo-config',
+            path: CONFIG_FILE_PATH,
+        });
+        return config;
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+            return null;
+        if (strict)
+            throw error;
+        logger.warn('Failed to parse local repo config', {
+            component: 'repo-config',
+            path: CONFIG_FILE_PATH,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+export function getDefaultReviewModels() {
+    return [...DEFAULT_REVIEW_MODELS];
+}
+export function parseReviewModelsEnabled(value) {
+    const models = value
+        ?.split(',')
+        .map((model) => model.trim())
+        .filter(Boolean) ?? [];
+    return models.length > 0 ? [...new Set(models)] : getDefaultReviewModels();
+}