@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/dist/runtime.js

@@ -0,0 +1,105 @@
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+const SANDBOX_REVIEW_MODULE_PATH = ['tasks', 'review', 'local.js'];
+const SANDBOX_FORMAT_MODULE_PATH = ['tasks', 'review', 'format.js'];
+function getPackageRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+}
+function getMonorepoRoot(packageRoot = getPackageRoot()) {
+    return path.resolve(packageRoot, '../..');
+}
+function getMonorepoSandboxRoot(packageRoot = getPackageRoot()) {
+    return path.join(getMonorepoRoot(packageRoot), 'apps/sandbox');
+}
+function isDoistbotMonorepoRoot(monorepoRoot) {
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(monorepoRoot, 'package.json'), 'utf8'));
+        return packageJson.name === 'doistbot-app';
+    }
+    catch {
+        return false;
+    }
+}
+function getSandboxDistPathFromRoot(sandboxRoot, ...segments) {
+    return path.join(sandboxRoot, 'dist', ...segments);
+}
+export function getSandboxRoot(packageRoot = getPackageRoot()) {
+    const monorepoRoot = getMonorepoRoot(packageRoot);
+    const monorepoSandboxRoot = getMonorepoSandboxRoot(packageRoot);
+    if (isDoistbotMonorepoRoot(monorepoRoot)) {
+        return monorepoSandboxRoot;
+    }
+    const bundledSandboxRoot = path.join(packageRoot, 'sandbox');
+    if (fs.existsSync(getSandboxDistPathFromRoot(bundledSandboxRoot, ...SANDBOX_REVIEW_MODULE_PATH))) {
+        return bundledSandboxRoot;
+    }
+    return monorepoSandboxRoot;
+}
+function getSandboxDistPath(...segments) {
+    return getSandboxDistPathFromRoot(getSandboxRoot(), ...segments);
+}
+function getSandboxReviewModulePath() {
+    return getSandboxDistPath(...SANDBOX_REVIEW_MODULE_PATH);
+}
+function getSandboxFormatModulePath() {
+    return getSandboxDistPath(...SANDBOX_FORMAT_MODULE_PATH);
+}
+async function loadBundledModule(modulePath, missingMessage) {
+    if (!modulePath || !fs.existsSync(modulePath)) {
+        throw new Error(missingMessage);
+    }
+    return (await import(pathToFileURL(modulePath).href));
+}
+export async function loadSandboxReviewModule() {
+    return loadBundledModule(getSandboxReviewModulePath(), 'Sandbox review runner is missing. Rebuild or reinstall the Doistbot CLI package.');
+}
+export async function loadSandboxFormatModule() {
+    return loadBundledModule(getSandboxFormatModulePath(), 'Sandbox review formatter is missing. Rebuild or reinstall the Doistbot CLI package.');
+}
+export async function loadSandboxPrReviewModule() {
+    return loadBundledModule(getSandboxDistPath('tasks', 'review', 'pr-dry-run.js'), 'PR dry-run runner is missing. Run `npm run build` in doistbot-app.');
+}
+export function runGit(args, cwd = process.cwd()) {
+    return execFileSync('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+}
+export function getRepositoryRoot() {
+    return runGit(['rev-parse', '--show-toplevel']).trim();
+}
+export function checkRepository() {
+    try {
+        const root = getRepositoryRoot();
+        return { ok: true, message: root };
+    }
+    catch {
+        return { ok: false, message: 'current directory is not inside a git repository' };
+    }
+}
+export function checkGit() {
+    try {
+        return { ok: true, message: runGit(['--version']).trim() };
+    }
+    catch {
+        return { ok: false, message: 'git is not installed or not on PATH' };
+    }
+}
+export function checkSandboxBuild() {
+    const modulePath = getSandboxReviewModulePath();
+    return fs.existsSync(modulePath)
+        ? { ok: true, message: 'sandbox review runner is built' }
+        : { ok: false, message: 'rebuild or reinstall the Doistbot CLI package' };
+}
+export function checkPiDependency() {
+    try {
+        import.meta.resolve('@earendil-works/pi-coding-agent');
+        return { ok: true, message: 'Pi coding agent is installed' };
+    }
+    catch {
+        return { ok: false, message: 'run `npm install` to install Pi dependencies' };
+    }
+}

package/dist/secure-store.js

@@ -0,0 +1,148 @@
+const SERVICE_NAME = 'doistbot-cli';
+export class SecureStoreUnavailableError extends Error {
+    constructor(message = 'System credential storage is unavailable') {
+        super(message);
+        this.name = 'SecureStoreUnavailableError';
+    }
+}
+export function getSecureStoreLabel(platform = process.platform) {
+    switch (platform) {
+        case 'darwin':
+            return 'macOS Keychain';
+        case 'win32':
+            return 'Windows Credential Manager';
+        default:
+            return 'system keyring';
+    }
+}
+export function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function createKeyringStore(account) {
+    let cachedUnavailable;
+    function rememberUnavailable(error) {
+        const wrapped = toUnavailableError(error);
+        cachedUnavailable = wrapped;
+        return wrapped;
+    }
+    return {
+        async getSecret() {
+            if (cachedUnavailable) {
+                throw cachedUnavailable;
+            }
+            const entry = await getEntry(account, rememberUnavailable);
+            try {
+                const raw = (await entry.getPassword()) ?? null;
+                return raw === null ? { value: null } : { value: raw, backend: 'keyring' };
+            }
+            catch (error) {
+                throw rememberUnavailable(error);
+            }
+        },
+        async setSecret(secret) {
+            if (cachedUnavailable) {
+                throw cachedUnavailable;
+            }
+            const entry = await getEntry(account, rememberUnavailable);
+            try {
+                await entry.setPassword(secret);
+                return 'keyring';
+            }
+            catch (error) {
+                throw rememberUnavailable(error);
+            }
+        },
+        async deleteSecret() {
+            if (cachedUnavailable) {
+                throw cachedUnavailable;
+            }
+            const entry = await getEntry(account, rememberUnavailable);
+            try {
+                return await entry.deleteCredential();
+            }
+            catch (error) {
+                throw rememberUnavailable(error);
+            }
+        },
+    };
+}
+export function createCompositeStore(keyring, file) {
+    return {
+        async getSecret() {
+            try {
+                const fromKeyring = await keyring.getSecret();
+                if (fromKeyring.value !== null) {
+                    return fromKeyring;
+                }
+            }
+            catch (error) {
+                if (!(error instanceof SecureStoreUnavailableError)) {
+                    throw error;
+                }
+            }
+            return await file.getSecret();
+        },
+        async setSecret(secret) {
+            try {
+                const backend = await keyring.setSecret(secret);
+                await file.deleteSecret().catch(() => undefined);
+                return backend;
+            }
+            catch (keyringError) {
+                if (!(keyringError instanceof SecureStoreUnavailableError)) {
+                    throw keyringError;
+                }
+                try {
+                    return await file.setSecret(secret);
+                }
+                catch (fileError) {
+                    throw combineFailure(keyringError, fileError);
+                }
+            }
+        },
+        async deleteSecret() {
+            let deleted = false;
+            let keyringFailure;
+            try {
+                deleted = (await keyring.deleteSecret()) || deleted;
+            }
+            catch (error) {
+                if (!(error instanceof SecureStoreUnavailableError)) {
+                    throw error;
+                }
+                keyringFailure = error;
+            }
+            try {
+                deleted = (await file.deleteSecret()) || deleted;
+            }
+            catch (fileError) {
+                if (keyringFailure) {
+                    throw combineFailure(keyringFailure, fileError);
+                }
+                throw fileError;
+            }
+            if (keyringFailure) {
+                throw new SecureStoreUnavailableError(`Failed to delete from system keyring (${keyringFailure.message}). File store deletion succeeded but the keyring entry may still exist.`);
+            }
+            return deleted;
+        },
+    };
+}
+async function getEntry(account, rememberUnavailable) {
+    try {
+        const { AsyncEntry } = await import('@napi-rs/keyring');
+        return new AsyncEntry(SERVICE_NAME, account);
+    }
+    catch (error) {
+        throw rememberUnavailable(error);
+    }
+}
+function toUnavailableError(error) {
+    if (error instanceof SecureStoreUnavailableError) {
+        return error;
+    }
+    return new SecureStoreUnavailableError(describeError(error));
+}
+function combineFailure(keyringError, fileError) {
+    return new SecureStoreUnavailableError(`System keyring unavailable (${keyringError.message}) and file fallback failed (${describeError(fileError)}).`);
+}

package/dist/terminal.js

@@ -0,0 +1,185 @@
+import chalk from 'chalk';
+import yoctoSpinner from 'yocto-spinner';
+export function isInteractiveOutputAllowed({ env = process.env, stream = process.stderr, } = {}) {
+    return env.CI !== 'true' && env.CI !== '1' && stream.isTTY === true;
+}
+export function writeLine(message = '') {
+    process.stdout.write(`${message}\n`);
+}
+export function writeErrorLine(message) {
+    process.stderr.write(`${message}\n`);
+}
+function getDefaultTerminalConfig() {
+    return {
+        supportsColor: process.env.NO_COLOR === undefined &&
+            process.env.TERM !== 'dumb' &&
+            process.stdout.isTTY === true &&
+            chalk.level > 0,
+        isInteractive: isInteractiveOutputAllowed(),
+    };
+}
+function colorize(value, style, terminalConfig) {
+    return terminalConfig.supportsColor ? style(value) : value;
+}
+export function renderAlert(input, terminalConfig = getDefaultTerminalConfig()) {
+    if (!terminalConfig.supportsColor) {
+        return input;
+    }
+    return input
+        .split(/\r?\n/)
+        .map((line) => chalk.bgRed(chalk.white.bold(line.replace(/`([^`]+)`/g, (_match, code) => chalk.whiteBright.inverse(` ${code} `)))))
+        .join('\n');
+}
+function formatStatus(message, terminalConfig) {
+    return colorize(message, chalk.blue, terminalConfig);
+}
+function formatDiagnosticText(label, result, terminalConfig) {
+    const title = colorize(label.padEnd(14), chalk.bold, terminalConfig);
+    const message = result.ok
+        ? colorize(result.message, chalk.dim, terminalConfig)
+        : colorize(result.message, chalk.red, terminalConfig);
+    return `${title} ${message}`;
+}
+function getDiagnosticSymbol(result, terminalConfig) {
+    if (result.ok) {
+        return colorize('✓', chalk.green, terminalConfig);
+    }
+    return colorize('✗', chalk.red, terminalConfig);
+}
+export async function renderDiagnosticCheck(label, check, terminalConfig = getDefaultTerminalConfig()) {
+    const result = await check();
+    process.stdout.write(`${getDiagnosticSymbol(result, terminalConfig)} ${formatDiagnosticText(label, result, terminalConfig)}\n`);
+    return result;
+}
+export function renderMarkdown(input, terminalConfig = getDefaultTerminalConfig()) {
+    const lines = input.trim().split(/\r?\n/);
+    const rendered = [];
+    let inCodeBlock = false;
+    for (const rawLine of lines) {
+        const line = rawLine.trimEnd();
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            if (!inCodeBlock) {
+                rendered.push('');
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            rendered.push(colorize(`  ${line}`, chalk.cyan, terminalConfig));
+            continue;
+        }
+        const heading = line.match(/^(#{1,6})\s+(.*)$/);
+        if (heading?.[2]) {
+            rendered.push(colorize(heading[2], chalk.bold.cyan, terminalConfig));
+            continue;
+        }
+        if (/^---+$/.test(line)) {
+            rendered.push(colorize('---', chalk.dim, terminalConfig));
+            continue;
+        }
+        if (line === 'Inline review comments:') {
+            rendered.push(colorize(line, chalk.bold.magenta, terminalConfig));
+            continue;
+        }
+        if (/^Comment \d+: .*$/.test(line)) {
+            rendered.push(colorize(line, chalk.bold.yellow, terminalConfig));
+            continue;
+        }
+        rendered.push(renderInlineCode(renderPriority(line, terminalConfig), terminalConfig));
+    }
+    return rendered.join('\n').trim();
+}
+export async function withSpinner(message, task, terminalConfig = getDefaultTerminalConfig()) {
+    if (!terminalConfig.isInteractive) {
+        return await task({ enabled: false, update() { } });
+    }
+    let currentMessage = message;
+    const spinner = yoctoSpinner({ text: formatStatus(currentMessage, terminalConfig) });
+    spinner.start();
+    const status = {
+        enabled: true,
+        update(nextMessage) {
+            if (!nextMessage.trim() || nextMessage === currentMessage) {
+                return;
+            }
+            currentMessage = nextMessage;
+            spinner.text = formatStatus(currentMessage, terminalConfig);
+        },
+    };
+    try {
+        return await task(status);
+    }
+    finally {
+        spinner.stop();
+    }
+}
+const PROVIDER_DISPLAY_NAMES = {
+    deepseek: 'DeepSeek',
+    gemini: 'Gemini',
+    grok: 'Grok',
+    zai: 'Z.ai',
+    openai: 'OpenAI',
+};
+function pluralizeChangedFiles(fileCount) {
+    return `${fileCount} changed file${fileCount === 1 ? '' : 's'}`;
+}
+export function formatReviewProgress(event) {
+    switch (event.type) {
+        case 'local_context':
+            return 'Resolving repository metadata and local diff';
+        case 'local_files_resolved':
+            return `Found ${pluralizeChangedFiles(event.fileCount)} to review`;
+        case 'prompt_prepared':
+            return `Prepared ${pluralizeChangedFiles(event.fileCount)} for review`;
+        case 'review_mode':
+            return 'Assessing review mode…';
+        case 'formatting_results':
+            return 'Review complete. Formatting results';
+        case 'agent_start':
+            return `${PROVIDER_DISPLAY_NAMES[event.provider]} started reviewing the diff`;
+        case 'agent_end':
+            return `${PROVIDER_DISPLAY_NAMES[event.provider]} finished its review pass`;
+        case 'thinking':
+            return `${PROVIDER_DISPLAY_NAMES[event.provider]} is reasoning through the changes`;
+        case 'responding':
+            return `${PROVIDER_DISPLAY_NAMES[event.provider]} is writing review findings`;
+        case 'limit_reached': {
+            const limit = event.level === 'soft' ? 'inspection budget' : 'inspection limit';
+            return `${PROVIDER_DISPLAY_NAMES[event.provider]} reached its ${limit} and is finalizing the review`;
+        }
+        case 'tool_start':
+            return event.toolName
+                ? `${PROVIDER_DISPLAY_NAMES[event.provider]} is inspecting the repo with ${event.toolName}`
+                : `${PROVIDER_DISPLAY_NAMES[event.provider]} is inspecting the repo`;
+        case 'tool_update':
+            return event.toolName
+                ? `${PROVIDER_DISPLAY_NAMES[event.provider]} is still running ${event.toolName}`
+                : `${PROVIDER_DISPLAY_NAMES[event.provider]} is still inspecting the repo`;
+        case 'tool_end':
+            return event.toolName
+                ? `${PROVIDER_DISPLAY_NAMES[event.provider]} finished ${event.toolName}`
+                : `${PROVIDER_DISPLAY_NAMES[event.provider]} finished a repo inspection step`;
+    }
+}
+function renderInlineCode(line, terminalConfig) {
+    if (!terminalConfig.supportsColor) {
+        return line;
+    }
+    return line.replace(/`([^`]+)`/g, (_match, code) => chalk.cyan(code));
+}
+function renderPriority(line, terminalConfig) {
+    if (!terminalConfig.supportsColor) {
+        return line;
+    }
+    return line.replace(/^\[(P[0-3])\]/, (_match, priority) => {
+        switch (priority) {
+            case 'P0':
+            case 'P1':
+                return chalk.bold.red(`[${priority}]`);
+            case 'P2':
+                return chalk.bold.yellow(`[${priority}]`);
+            default:
+                return chalk.bold.cyan(`[${priority}]`);
+        }
+    });
+}

package/dist/test-utils/secure-store-mocks.js

@@ -0,0 +1,29 @@
+import { vi } from 'vitest';
+import { SecureStoreUnavailableError, } from '../secure-store.js';
+export function createMemoryStore({ initial = null, backend = 'keyring', } = {}) {
+    let secret = initial;
+    return {
+        getSecret: vi.fn(async () => secret === null ? { value: null } : { value: secret, backend }),
+        setSecret: vi.fn(async (value) => {
+            secret = value;
+            return backend;
+        }),
+        deleteSecret: vi.fn(async () => {
+            if (secret === null) {
+                return false;
+            }
+            secret = null;
+            return true;
+        }),
+    };
+}
+export function createUnavailableStore(message = 'keyring offline') {
+    async function fail() {
+        throw new SecureStoreUnavailableError(message);
+    }
+    return {
+        getSecret: vi.fn(fail),
+        setSecret: vi.fn(fail),
+        deleteSecret: vi.fn(fail),
+    };
+}

package/dist/update-cache-entrypoint.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { refreshCliUpdateCache } from './update-check.js';
+const { values } = parseArgs({
+    options: {
+        'cache-path': { type: 'string' },
+        'current-version': { type: 'string' },
+    },
+});
+if (!values['current-version']) {
+    throw new Error('Missing --current-version');
+}
+await refreshCliUpdateCache({
+    cachePath: values['cache-path'],
+    currentVersion: values['current-version'],
+});