byterover-cli 1.7.2 → 2.0.0

package/dist/oclif/commands/curate/index.js

@@ -0,0 +1,256 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { randomUUID } from 'node:crypto';
+import { TransportStateEventNames } from '../../../server/core/domain/transport/index.js';
+import { extractCurateOperations } from '../../../server/utils/curate-result-parser.js';
+import { TaskEvents } from '../../../shared/transport/events/index.js';
+import { formatConnectionError, hasLeakedHandles, withDaemonRetry, } from '../../lib/daemon-client.js';
+import { writeJsonResponse } from '../../lib/json-response.js';
+import { waitForTaskCompletion } from '../../lib/task-client.js';
+export default class Curate extends Command {
+    static args = {
+        context: Args.string({
+            description: 'Knowledge context: patterns, decisions, errors, or insights',
+            required: false,
+        }),
+    };
+    static description = `Curate context to the context tree
+
+Good examples:
+- "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"
+- "API rate limit is 100 req/min per user. Implemented using Redis with sliding window in rateLimiter.ts"
+Bad examples:
+- "Authentication" or "JWT tokens" (too vague, lacks context)
+- "Rate limiting" (no implementation details or file references)`;
+    static examples = [
+        '# Curate context - queues task for background processing',
+        '<%= config.bin %> <%= command.id %> "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"',
+        '',
+        '# Include relevant files for comprehensive context (max 5 files)',
+        '<%= config.bin %> <%= command.id %> "Authentication middleware validates JWT tokens" -f src/middleware/auth.ts',
+        '',
+        '# Multiple files',
+        '<%= config.bin %> <%= command.id %> "JWT authentication implementation" --files src/auth/jwt.ts --files docs/auth.md',
+        '',
+        '# Folder pack - analyze and curate entire folder',
+        '<%= config.bin %> <%= command.id %> --folder src/auth/',
+        '',
+        '# Folder pack with context',
+        '<%= config.bin %> <%= command.id %> "Analyze authentication module" -d src/auth/',
+        '',
+        '# View curate history',
+        '<%= config.bin %> curate view',
+        '<%= config.bin %> curate view --status completed --since 1h',
+    ];
+    static flags = {
+        detach: Flags.boolean({
+            default: false,
+            description: 'Queue task and exit without waiting for completion',
+        }),
+        files: Flags.string({
+            char: 'f',
+            description: 'Include specific file paths for critical context (max 5 files)',
+            multiple: true,
+        }),
+        folder: Flags.string({
+            char: 'd',
+            description: 'Folder path to pack and analyze (triggers folder pack flow)',
+            multiple: true,
+        }),
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format (text or json)',
+            options: ['text', 'json'],
+        }),
+    };
+    getDaemonClientOptions() {
+        return {};
+    }
+    async run() {
+        const { args, flags: rawFlags } = await this.parse(Curate);
+        const flags = {
+            detach: rawFlags.detach,
+            files: rawFlags.files,
+            folder: rawFlags.folder,
+            format: rawFlags.format === 'json' ? 'json' : rawFlags.format === 'text' ? 'text' : undefined,
+        };
+        const format = flags.format ?? 'text';
+        if (!this.validateInput(args, flags, format))
+            return;
+        const resolvedContent = args.context?.trim()
+            ? args.context
+            : flags.folder?.length
+                ? 'Analyze this folder and extract all relevant knowledge, patterns, and documentation.'
+                : '';
+        const taskType = flags.folder?.length ? 'curate-folder' : 'curate';
+        let providerContext;
+        try {
+            await withDaemonRetry(async (client, projectRoot) => {
+                const active = await client.requestWithAck(TransportStateEventNames.GET_PROVIDER_CONFIG);
+                providerContext = { activeModel: active.activeModel, activeProvider: active.activeProvider };
+                if (!active.activeProvider) {
+                    throw new Error('No provider connected. Run "brv providers connect byterover" to use the free built-in provider, or connect another provider.');
+                }
+                if (active.providerKeyMissing) {
+                    throw new Error(active.providerCredentialError
+                        ?? `${active.activeProvider} API key is missing from storage.\nPlease reconnect: brv providers connect ${active.activeProvider} --api-key <your-key>`);
+                }
+                await this.submitTask({ client, content: resolvedContent, flags, format, projectRoot, taskType });
+            }, {
+                ...this.getDaemonClientOptions(),
+                onRetry: format === 'text'
+                    ? (attempt, maxRetries) => this.log(`\nConnection lost. Restarting daemon... (attempt ${attempt}/${maxRetries})`)
+                    : undefined,
+            });
+        }
+        catch (error) {
+            this.reportError(error, format, providerContext);
+        }
+    }
+    /**
+     * Extract file changes from collected tool calls (same logic as TUI useActivityLogs).
+     */
+    composeChangesFromToolCalls(toolCalls) {
+        const changes = { created: [], updated: [] };
+        for (const tc of toolCalls) {
+            if (tc.status !== 'completed')
+                continue;
+            const ops = extractCurateOperations({ result: tc.result, toolName: tc.toolName });
+            this.extractChangesFromApplied(ops, changes);
+        }
+        return changes;
+    }
+    extractChangesFromApplied(applied, changes) {
+        for (const op of applied) {
+            if (op.status !== 'success' || !op.filePath)
+                continue;
+            switch (op.type) {
+                case 'ADD': {
+                    changes.created.push(op.filePath);
+                    break;
+                }
+                case 'UPDATE':
+                case 'UPSERT': {
+                    changes.updated.push(op.filePath);
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+        }
+    }
+    reportError(error, format, providerContext) {
+        const errorMessage = error instanceof Error ? error.message : 'Curate failed';
+        if (format === 'json') {
+            writeJsonResponse({ command: 'curate', data: { error: errorMessage, status: 'error' }, success: false });
+        }
+        else {
+            this.log(formatConnectionError(error, providerContext));
+        }
+        if (hasLeakedHandles(error)) {
+            // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+            process.exit(1);
+        }
+    }
+    async submitTask(props) {
+        const { client, content, flags, format, projectRoot, taskType } = props;
+        const hasFolders = Boolean(flags.folder?.length);
+        const taskId = randomUUID();
+        const taskPayload = {
+            clientCwd: process.cwd(),
+            content,
+            ...(flags.files?.length ? { files: flags.files } : {}),
+            ...(hasFolders && flags.folder ? { folderPath: flags.folder[0] } : {}),
+            ...(projectRoot ? { projectPath: projectRoot } : {}),
+            taskId,
+            type: taskType,
+        };
+        if (flags.detach) {
+            const ack = await client.requestWithAck(TaskEvents.CREATE, taskPayload);
+            const { logId } = ack;
+            if (format === 'json') {
+                writeJsonResponse({
+                    command: 'curate',
+                    data: { logId, message: 'Context queued for processing', status: 'queued', taskId },
+                    success: true,
+                });
+            }
+            else {
+                const logSuffix = logId ? ` (Log: ${logId})` : '';
+                this.log(`✓ Context queued for processing.${logSuffix}`);
+            }
+        }
+        else {
+            const completionPromise = waitForTaskCompletion({
+                client,
+                command: 'curate',
+                format,
+                onCompleted: ({ logId, taskId: tid, toolCalls }) => {
+                    const changes = this.composeChangesFromToolCalls(toolCalls);
+                    if (format === 'text') {
+                        for (const file of changes.created) {
+                            this.log(`  add ${file}`);
+                        }
+                        for (const file of changes.updated) {
+                            this.log(`  update ${file}`);
+                        }
+                        const logSuffix = logId ? ` (Log: ${logId})` : '';
+                        this.log(`✓ Context curated successfully.${logSuffix}`);
+                    }
+                    else {
+                        writeJsonResponse({
+                            command: 'curate',
+                            data: {
+                                changes: changes.created.length > 0 || changes.updated.length > 0 ? changes : undefined,
+                                event: 'completed',
+                                logId,
+                                message: 'Context curated successfully',
+                                status: 'completed',
+                                taskId: tid,
+                            },
+                            success: true,
+                        });
+                    }
+                },
+                onError({ error, logId }) {
+                    if (format === 'json') {
+                        writeJsonResponse({
+                            command: 'curate',
+                            data: { event: 'error', logId, message: error.message, status: 'error' },
+                            success: false,
+                        });
+                    }
+                },
+                taskId,
+            }, (msg) => this.log(msg));
+            await client.requestWithAck(TaskEvents.CREATE, taskPayload);
+            await completionPromise;
+        }
+    }
+    validateInput(args, flags, format) {
+        const hasContext = Boolean(args.context?.trim());
+        const hasFiles = Boolean(flags.files?.length);
+        const hasFolders = Boolean(flags.folder?.length);
+        if (hasContext || hasFiles || hasFolders)
+            return true;
+        if (format === 'json') {
+            writeJsonResponse({
+                command: 'curate',
+                data: {
+                    message: 'Either a context argument, file reference, or folder reference is required.',
+                    status: 'error',
+                },
+                success: false,
+            });
+        }
+        else {
+            this.log('Either a context argument, file reference, or folder reference is required.');
+            this.log('Usage:');
+            this.log('  brv curate "your context here"');
+            this.log('  brv curate "your context" -f src/file.ts');
+            this.log('  brv curate -d src/             # folder pack');
+            this.log('  brv curate "context with files" -f src/file.ts -f src/other.ts');
+        }
+        return false;
+    }
+}

package/dist/oclif/commands/curate/view.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class CurateView extends Command {
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        before: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        detail: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        since: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private parseTime;
+}

package/dist/oclif/commands/curate/view.js

@@ -0,0 +1,104 @@
+import { findProjectRoot } from '@campfirein/brv-transport-client';
+import { Args, Command, Flags } from '@oclif/core';
+import { FileCurateLogStore } from '../../../server/infra/storage/file-curate-log-store.js';
+import { CurateLogUseCase } from '../../../server/infra/usecase/curate-log-use-case.js';
+import { getProjectDataDir } from '../../../server/utils/path-utils.js';
+const VALID_STATUSES = ['cancelled', 'completed', 'error', 'processing'];
+const RELATIVE_TIME_PATTERN = /^(\d+)(m|h|d|w)$/;
+/**
+ * Parse a time filter value into a UTC millisecond timestamp.
+ *
+ * Accepts:
+ *  - Relative: "30m", "1h", "24h", "7d", "2w"
+ *  - Absolute: ISO date "2024-01-15" or datetime "2024-01-15T12:00:00Z"
+ *
+ * Returns null when the value cannot be parsed.
+ */
+function parseTimeFilter(value) {
+    const relMatch = RELATIVE_TIME_PATTERN.exec(value);
+    if (relMatch) {
+        const amount = Number(relMatch[1]);
+        const unit = relMatch[2];
+        const multipliers = { d: 86_400_000, h: 3_600_000, m: 60_000, w: 604_800_000 };
+        return Date.now() - amount * multipliers[unit];
+    }
+    const ts = new Date(value).getTime();
+    return Number.isNaN(ts) ? null : ts;
+}
+export default class CurateView extends Command {
+    static args = {
+        id: Args.string({
+            description: 'Log entry ID to view in detail',
+            required: false,
+        }),
+    };
+    static description = 'View curate history';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> cur-1739700001000',
+        '<%= config.bin %> <%= command.id %> --limit 20',
+        '<%= config.bin %> <%= command.id %> --status completed',
+        '<%= config.bin %> <%= command.id %> --status completed --status error',
+        '<%= config.bin %> <%= command.id %> --since 1h',
+        '<%= config.bin %> <%= command.id %> --since 2024-01-15',
+        '<%= config.bin %> <%= command.id %> --before 2024-02-01',
+        '<%= config.bin %> <%= command.id %> --detail',
+        '<%= config.bin %> <%= command.id %> --format json',
+    ];
+    static flags = {
+        before: Flags.string({
+            description: 'Show entries started before this time (ISO date or relative: 1h, 24h, 7d, 2w)',
+        }),
+        detail: Flags.boolean({
+            default: false,
+            description: 'Show operations for each entry in list view',
+        }),
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format',
+            options: ['text', 'json'],
+        }),
+        limit: Flags.integer({
+            default: 10,
+            description: 'Maximum number of log entries to display',
+            min: 1,
+        }),
+        since: Flags.string({
+            description: 'Show entries started after this time (ISO date or relative: 1h, 24h, 7d, 2w)',
+        }),
+        status: Flags.string({
+            description: `Filter by status (can be repeated). Options: ${VALID_STATUSES.join(', ')}`,
+            multiple: true,
+            options: VALID_STATUSES,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CurateView);
+        const after = flags.since ? this.parseTime(flags.since, '--since') : undefined;
+        const before = flags.before ? this.parseTime(flags.before, '--before') : undefined;
+        const format = flags.format === 'json' ? 'json' : 'text';
+        const projectRoot = (await findProjectRoot(process.cwd())) ?? process.cwd();
+        const baseDir = getProjectDataDir(projectRoot);
+        const store = new FileCurateLogStore({ baseDir });
+        const useCase = new CurateLogUseCase({
+            curateLogStore: store,
+            terminal: { log: (m) => this.log(m ?? '') },
+        });
+        await useCase.run({
+            after,
+            before,
+            detail: flags.detail,
+            format,
+            id: args.id,
+            limit: flags.limit,
+            status: flags.status?.filter((s) => VALID_STATUSES.includes(s)),
+        });
+    }
+    parseTime(value, flagName) {
+        const ts = parseTimeFilter(value);
+        if (ts === null) {
+            this.error(`Invalid time value for ${flagName}: "${value}". Use ISO date (2024-01-15) or relative (1h, 24h, 7d, 2w).`, { exit: 2 });
+        }
+        return ts;
+    }
+}

package/dist/oclif/commands/debug.d.ts

@@ -0,0 +1,35 @@
+import { type EnsureDaemonResult, type ITransportClient } from '@campfirein/brv-transport-client';
+import { Command } from '@oclif/core';
+export default class Debug extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        once: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static hidden: boolean;
+    protected clearScreen(): void;
+    protected connect(): Promise<{
+        client: ITransportClient;
+        projectRoot?: string;
+    }>;
+    protected ensureDaemon(): Promise<EnsureDaemonResult>;
+    /**
+     * Kill the running daemon and wait for it to die.
+     * Internal to debug --force. Returns the PID that was killed, or undefined if none found.
+     */
+    protected killExistingDaemon(): Promise<number | undefined>;
+    run(): Promise<void>;
+    private delay;
+    private formatDuration;
+    private formatTimeAgo;
+    private renderAgentPool;
+    private renderClients;
+    private renderOnce;
+    private renderStoragePaths;
+    private renderTasks;
+    private renderTree;
+    private resolveStoragePaths;
+    private runMonitor;
+}