byterover-cli 1.5.0 → 1.7.0

package/dist/tui/commands/arg-parser.js

@@ -0,0 +1,186 @@
+/**
+ * Shared argument parser for REPL commands
+ *
+ * Combines shell-like string splitting with oclif's Parser for consistent
+ * flag and argument handling across REPL commands.
+ */
+import { Parser } from '@oclif/core';
+import fs from 'node:fs';
+import path from 'node:path';
+// Re-export Args and Flags for use by REPL commands
+export { Args, Flags } from '@oclif/core';
+/**
+ * Convert oclif flag definitions to CommandFlag[] for SlashCommand.flags
+ *
+ * This allows defining flags once using oclif format and auto-generating
+ * the CommandFlag[] needed for help display.
+ *
+ * @example
+ * const flags = {
+ *   apiKey: Flags.string({char: 'k', description: 'API key'}),
+ *   verbose: Flags.boolean({char: 'v', description: 'Verbose output'}),
+ * }
+ *
+ * export const myCommand: SlashCommand = {
+ *   action(context, args) {
+ *     const parsed = await parseReplArgs(args, {flags})
+ *   },
+ *   flags: toCommandFlags(flags),
+ * }
+ */
+export function toCommandFlags(flags) {
+    return Object.entries(flags).map(([name, flag]) => ({
+        char: flag.char,
+        default: flag.default,
+        description: flag.description ?? '',
+        name,
+        type: flag.type === 'boolean' ? 'boolean' : 'string',
+    }));
+}
+/**
+ * Check if a path refers to a directory.
+ * Handles both explicit trailing slash and actual filesystem check.
+ */
+function isDirectoryPath(refPath) {
+    // Empty path is not a directory (edge case for @ alone)
+    if (!refPath) {
+        return false;
+    }
+    // Handle current directory explicitly (. or ./)
+    if (refPath === '.' || refPath === './') {
+        return true;
+    }
+    // Explicit trailing slash indicates folder intent
+    if (refPath.endsWith('/') || refPath.endsWith(path.sep)) {
+        return true;
+    }
+    // Check filesystem
+    try {
+        const fullPath = path.isAbsolute(refPath) ? refPath : path.resolve(process.cwd(), refPath);
+        const stats = fs.statSync(fullPath);
+        return stats.isDirectory();
+    }
+    catch {
+        // If path doesn't exist, default to file
+        return false;
+    }
+}
+/**
+ * Categorize a @ reference as file or folder.
+ */
+function categorizeReference(refPath) {
+    return isDirectoryPath(refPath) ? 'folder' : 'file';
+}
+/**
+ * Split a string into args array, respecting quoted strings
+ * Handles both single and double quotes, and extracts @file and @folder references
+ *
+ * @example
+ * splitArgs('"hello world" --force') // { args: ['hello world', '--force'], files: [], folders: [] }
+ * splitArgs("'hello world' -f") // { args: ['hello world', '-f'], files: [], folders: [] }
+ * splitArgs('query @src/file.ts') // { args: ['query'], files: ['src/file.ts'], folders: [] }
+ * splitArgs('"context" @src/') // { args: ['context'], files: [], folders: ['src/'] }
+ * splitArgs('text @src/ @README.md') // { args: ['text'], files: ['README.md'], folders: ['src/'] }
+ */
+export function splitArgs(input) {
+    const args = [];
+    const files = [];
+    const folders = [];
+    let current = '';
+    let inQuote = null;
+    for (const char of input) {
+        if (inQuote) {
+            // Inside a quoted string
+            if (char === inQuote) {
+                // End of quoted string - don't include the quote
+                inQuote = null;
+            }
+            else {
+                current += char;
+            }
+        }
+        else if (char === '"' || char === "'") {
+            // Start of quoted string - don't include the quote
+            inQuote = char;
+        }
+        else if (char === ' ' || char === '\t') {
+            // Whitespace outside quotes - end current arg
+            if (current) {
+                if (current.startsWith('@')) {
+                    // Reference - strip the @ prefix and categorize
+                    const refPath = current.slice(1);
+                    // Skip empty @ references (just "@" alone)
+                    if (refPath) {
+                        if (categorizeReference(refPath) === 'folder') {
+                            folders.push(refPath);
+                        }
+                        else {
+                            files.push(refPath);
+                        }
+                    }
+                }
+                else {
+                    args.push(current);
+                }
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    // Don't forget the last arg
+    if (current) {
+        if (current.startsWith('@')) {
+            const refPath = current.slice(1);
+            // Skip empty @ references (just "@" alone)
+            if (refPath) {
+                if (categorizeReference(refPath) === 'folder') {
+                    folders.push(refPath);
+                }
+                else {
+                    files.push(refPath);
+                }
+            }
+        }
+        else {
+            args.push(current);
+        }
+    }
+    return { args, files, folders };
+}
+/**
+ * Parse REPL command arguments using oclif's Parser
+ *
+ * @param input - Raw input string from REPL (e.g., '"hello world" --force @src/file.ts')
+ * @param options - Parser options
+ * @param options.args - Argument definitions using Args from @oclif/core
+ * @param options.flags - Flag definitions using Flags from @oclif/core
+ * @param options.strict - Whether to error on unknown flags (default: false)
+ * @returns Parsed flags, args, remaining argv, and file references
+ *
+ * @example
+ * const result = await parseReplArgs('query text --verbose @src/auth.ts', {
+ *   args: { query: Args.string({ required: true }) },
+ *   flags: { verbose: Flags.boolean({ char: 'v' }) },
+ * })
+ * // result.args.query === 'query'
+ * // result.flags.verbose === true
+ * // result.argv === ['query', 'text']
+ * // result.files === ['src/auth.ts']
+ */
+export async function parseReplArgs(input, options) {
+    const { args: argv, files, folders } = splitArgs(input);
+    const result = await Parser.parse(argv, {
+        args: options.args ?? {},
+        flags: options.flags ?? {},
+        strict: options.strict ?? false,
+    });
+    return {
+        args: result.args,
+        argv: result.argv,
+        files,
+        flags: result.flags,
+        folders,
+    };
+}

package/dist/tui/commands/connectors-command.d.ts

@@ -0,0 +1,8 @@
+import { SlashCommand } from '../types.js';
+/**
+ * Connectors command
+ *
+ * Manages connectors (rules, hook) for integrating BRV with coding agents.
+ * Lists connected agents and allows managing or adding new connections.
+ */
+export declare const connectorsCommand: SlashCommand;

package/dist/tui/commands/connectors-command.js

@@ -0,0 +1,49 @@
+import { ConnectorManager } from '../../server/infra/connectors/connector-manager.js';
+import { RuleTemplateService } from '../../server/infra/connectors/shared/template-service.js';
+import { FsFileService } from '../../server/infra/file/fs-file-service.js';
+import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
+import { createTokenStore } from '../../server/infra/storage/token-store.js';
+import { FsTemplateLoader } from '../../server/infra/template/fs-template-loader.js';
+import { ReplTerminal } from '../../server/infra/terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
+import { ConnectorsUseCase } from '../../server/infra/usecase/connectors-use-case.js';
+import { CommandKind } from '../types.js';
+/**
+ * Connectors command
+ *
+ * Manages connectors (rules, hook) for integrating BRV with coding agents.
+ * Lists connected agents and allows managing or adding new connections.
+ */
+export const connectorsCommand = {
+    action: () => ({
+        async execute(onMessage, onPrompt) {
+            // Create ReplTerminal with callbacks
+            const terminal = new ReplTerminal({ onMessage, onPrompt });
+            // Create services
+            const fileService = new FsFileService();
+            const templateLoader = new FsTemplateLoader(fileService);
+            const templateService = new RuleTemplateService(templateLoader);
+            const globalConfigStore = new FileGlobalConfigStore();
+            const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore: createTokenStore() });
+            // Create ConnectorManager
+            const connectorManager = new ConnectorManager({
+                fileService,
+                projectRoot: process.cwd(),
+                templateService,
+            });
+            // Create and run UseCase
+            const useCase = new ConnectorsUseCase({
+                connectorManager,
+                terminal,
+                trackingService,
+            });
+            await useCase.run();
+        },
+        type: 'streaming',
+    }),
+    aliases: ['connectors'],
+    autoExecute: true,
+    description: 'Manage agent connectors (rules, hook, mcp, or skill)',
+    kind: CommandKind.BUILT_IN,
+    name: 'connector',
+};

package/dist/tui/commands/curate-command.d.ts

@@ -0,0 +1,9 @@
+import { SlashCommand } from '../types.js';
+/**
+ * Curate command - Curate context to the context tree
+ *
+ * Supports both modes:
+ * - Autonomous mode: /curate "your context" @file1 @file2
+ * - Interactive mode: /curate (no args) - navigates context tree
+ */
+export declare const curateCommand: SlashCommand;

package/dist/tui/commands/curate-command.js

@@ -0,0 +1,80 @@
+import { isDevelopment } from '../../server/config/environment.js';
+import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
+import { createTokenStore } from '../../server/infra/storage/token-store.js';
+import { ReplTerminal } from '../../server/infra/terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
+import { CurateUseCase } from '../../server/infra/usecase/curate-use-case.js';
+import { CommandKind } from '../types.js';
+import { Flags, parseReplArgs, toCommandFlags } from './arg-parser.js';
+// Dev-only flags - defined once, used for both parsing and help display
+const devFlags = {
+    apiKey: Flags.string({ char: 'k', description: 'OpenRouter API key [Dev only]' }),
+    model: Flags.string({ char: 'm', description: 'Model to use [Dev only]' }),
+    verbose: Flags.boolean({ char: 'v', description: 'Enable verbose debug output [Dev only]' }),
+};
+/**
+ * Curate command - Curate context to the context tree
+ *
+ * Supports both modes:
+ * - Autonomous mode: /curate "your context" @file1 @file2
+ * - Interactive mode: /curate (no args) - navigates context tree
+ */
+export const curateCommand = {
+    action(context, args) {
+        return {
+            async execute(onMessage, onPrompt) {
+                // Files and folders are pre-extracted by the command processor
+                const files = context.invocation?.files ?? [];
+                const folders = context.invocation?.folders ?? [];
+                // Parse flags and get context text
+                let contextText;
+                let flags = {};
+                if (isDevelopment()) {
+                    const parsed = await parseReplArgs(args, { flags: devFlags, strict: false });
+                    contextText = parsed.argv.join(' ') || undefined;
+                    flags = parsed.flags;
+                }
+                else {
+                    contextText = args || undefined;
+                }
+                const terminal = new ReplTerminal({ onMessage, onPrompt });
+                const tokenStore = createTokenStore();
+                const globalConfigStore = new FileGlobalConfigStore();
+                const useCase = new CurateUseCase({
+                    terminal,
+                    trackingService: new MixpanelTrackingService({ globalConfigStore, tokenStore }),
+                });
+                // Run the use case - mode determined by whether context is provided
+                // Folder takes precedence over files (triggers folder pack flow)
+                await useCase.run({
+                    context: contextText,
+                    files: files.length > 0 ? files : undefined,
+                    folders: folders.length > 0 ? folders : undefined,
+                    verbose: flags.verbose,
+                });
+            },
+            type: 'streaming',
+        };
+    },
+    aliases: [],
+    args: [
+        {
+            description: 'Knowledge context (optional, triggers autonomous mode)',
+            name: 'context',
+            required: false,
+        },
+    ],
+    autoExecute: true,
+    description: 'Curate context to the context tree.',
+    flags: [
+        {
+            char: '@',
+            description: 'Include files (type @ to browse, max 5)',
+            name: 'file',
+            type: 'file',
+        },
+        ...(isDevelopment() ? toCommandFlags(devFlags) : []),
+    ],
+    kind: CommandKind.BUILT_IN,
+    name: 'curate',
+};

package/dist/tui/commands/index.d.ts

@@ -0,0 +1,8 @@
+import { SlashCommand } from '../types.js';
+/**
+ * Load all REPL slash commands.
+ *
+ * IMPORTANT: Order matters - commands are displayed in the UI suggestions
+ * in the same order as defined here. Keep grouped by priority/category.
+ */
+export declare const load: () => SlashCommand[];

package/dist/tui/commands/index.js

@@ -0,0 +1,45 @@
+import { connectorsCommand } from './connectors-command.js';
+import { curateCommand } from './curate-command.js';
+import { initCommand } from './init-command.js';
+import { loginCommand } from './login-command.js';
+import { logoutCommand } from './logout-command.js';
+import { modelCommand } from './model-command.js';
+import { newCommand } from './new-command.js';
+import { providerCommand } from './provider-command.js';
+import { pullCommand } from './pull-command.js';
+import { pushCommand } from './push-command.js';
+import { queryCommand } from './query-command.js';
+import { resetCommand } from './reset-command.js';
+import { spaceCommand } from './space/index.js';
+import { statusCommand } from './status-command.js';
+/**
+ * Load all REPL slash commands.
+ *
+ * IMPORTANT: Order matters - commands are displayed in the UI suggestions
+ * in the same order as defined here. Keep grouped by priority/category.
+ */
+export const load = () => [
+    // Core workflow - most frequently used
+    statusCommand, // Quick check current state
+    curateCommand, // Add context (primary action)
+    queryCommand, // Query context tree
+    // Connectors management
+    connectorsCommand, // Manage agent connectors (rules/hook)
+    // Sync operations
+    pushCommand, // Push to cloud
+    pullCommand, // Pull from cloud
+    // Provider management
+    providerCommand, // Connect to LLM providers
+    modelCommand, // Select model from provider
+    // Space management
+    spaceCommand, // Switch/list spaces
+    // Context tree management
+    resetCommand, // Reset context tree (destructive)
+    // Session management
+    newCommand, // Start fresh session (ends current, clears conversation)
+    // Setup
+    initCommand, // Project setup (once per project)
+    // Auth
+    loginCommand, // Sign in
+    logoutCommand, // Sign out
+];

package/dist/tui/commands/init-command.d.ts

@@ -0,0 +1,7 @@
+import { SlashCommand } from '../types.js';
+/**
+ * Initialize command
+ *
+ * Creates and runs InitUseCase with ReplTerminal for TUI integration.
+ */
+export declare const initCommand: SlashCommand;

package/dist/tui/commands/init-command.js

@@ -0,0 +1,87 @@
+import { getCurrentConfig } from '../../server/config/environment.js';
+import { HttpCogitPullService } from '../../server/infra/cogit/http-cogit-pull-service.js';
+import { ProjectConfigStore } from '../../server/infra/config/file-config-store.js';
+import { ConnectorManager } from '../../server/infra/connectors/connector-manager.js';
+import { RuleTemplateService } from '../../server/infra/connectors/shared/template-service.js';
+import { FileContextTreeService } from '../../server/infra/context-tree/file-context-tree-service.js';
+import { FileContextTreeSnapshotService } from '../../server/infra/context-tree/file-context-tree-snapshot-service.js';
+import { FileContextTreeWriterService } from '../../server/infra/context-tree/file-context-tree-writer-service.js';
+import { FsFileService } from '../../server/infra/file/fs-file-service.js';
+import { HttpSpaceService } from '../../server/infra/space/http-space-service.js';
+import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
+import { createTokenStore } from '../../server/infra/storage/token-store.js';
+import { HttpTeamService } from '../../server/infra/team/http-team-service.js';
+import { FsTemplateLoader } from '../../server/infra/template/fs-template-loader.js';
+import { ReplTerminal } from '../../server/infra/terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
+import { InitUseCase } from '../../server/infra/usecase/init-use-case.js';
+import { CommandKind } from '../types.js';
+import { Flags, parseReplArgs, toCommandFlags } from './arg-parser.js';
+// Flags - defined once, used for both parsing and help display
+const initFlags = {
+    force: Flags.boolean({ char: 'f', description: 'Force re-initialization without confirmation prompt' }),
+};
+/**
+ * Initialize command
+ *
+ * Creates and runs InitUseCase with ReplTerminal for TUI integration.
+ */
+export const initCommand = {
+    action(_context, args) {
+        return {
+            async execute(onMessage, onPrompt) {
+                // Parse flags
+                const parsed = await parseReplArgs(args, { flags: initFlags });
+                const force = parsed.flags.force ?? false;
+                // Create ReplTerminal with callbacks
+                const terminal = new ReplTerminal({ onMessage, onPrompt });
+                // Create services
+                const envConfig = getCurrentConfig();
+                const tokenStore = createTokenStore();
+                const globalConfigStore = new FileGlobalConfigStore();
+                const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
+                const fileService = new FsFileService();
+                const templateLoader = new FsTemplateLoader(fileService);
+                const templateService = new RuleTemplateService(templateLoader);
+                const contextTreeSnapshotService = new FileContextTreeSnapshotService();
+                // Create ConnectorManager
+                const connectorManager = new ConnectorManager({
+                    fileService,
+                    projectRoot: process.cwd(),
+                    templateService,
+                });
+                // Create and run use case
+                const useCase = new InitUseCase({
+                    cogitPullService: new HttpCogitPullService({
+                        apiBaseUrl: envConfig.cogitApiBaseUrl,
+                    }),
+                    connectorManager,
+                    contextTreeService: new FileContextTreeService(),
+                    contextTreeSnapshotService,
+                    contextTreeWriterService: new FileContextTreeWriterService({
+                        snapshotService: contextTreeSnapshotService,
+                    }),
+                    fileService,
+                    projectConfigStore: new ProjectConfigStore(),
+                    spaceService: new HttpSpaceService({
+                        apiBaseUrl: envConfig.apiBaseUrl,
+                    }),
+                    teamService: new HttpTeamService({
+                        apiBaseUrl: envConfig.apiBaseUrl,
+                    }),
+                    terminal,
+                    tokenStore,
+                    trackingService,
+                });
+                await useCase.run({ force });
+            },
+            type: 'streaming',
+        };
+    },
+    aliases: [],
+    autoExecute: true,
+    description: 'Initialize a project with ByteRover',
+    flags: toCommandFlags(initFlags),
+    kind: CommandKind.BUILT_IN,
+    name: 'init',
+};

package/dist/tui/commands/login-command.d.ts

@@ -0,0 +1,7 @@
+import { SlashCommand } from '../types.js';
+/**
+ * Login command
+ *
+ * Creates and runs LoginUseCase with ReplTerminal for TUI integration.
+ */
+export declare const loginCommand: SlashCommand;

package/dist/tui/commands/login-command.js

@@ -0,0 +1,50 @@
+import { getAuthConfig } from '../../server/config/auth.config.js';
+import { getCurrentConfig } from '../../server/config/environment.js';
+import { OAuthService } from '../../server/infra/auth/oauth-service.js';
+import { OidcDiscoveryService } from '../../server/infra/auth/oidc-discovery-service.js';
+import { SystemBrowserLauncher } from '../../server/infra/browser/system-browser-launcher.js';
+import { CallbackHandler } from '../../server/infra/http/callback-handler.js';
+import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
+import { createTokenStore } from '../../server/infra/storage/token-store.js';
+import { ReplTerminal } from '../../server/infra/terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
+import { LoginUseCase } from '../../server/infra/usecase/login-use-case.js';
+import { HttpUserService } from '../../server/infra/user/http-user-service.js';
+import { CommandKind } from '../types.js';
+/**
+ * Login command
+ *
+ * Creates and runs LoginUseCase with ReplTerminal for TUI integration.
+ */
+export const loginCommand = {
+    action: () => ({
+        async execute(onMessage, onPrompt) {
+            // Create ReplTerminal with callbacks
+            const terminal = new ReplTerminal({ onMessage, onPrompt });
+            // Create services
+            const config = getCurrentConfig();
+            const tokenStore = createTokenStore();
+            const globalConfigStore = new FileGlobalConfigStore();
+            const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
+            const discoveryService = new OidcDiscoveryService();
+            const authConfig = await getAuthConfig(discoveryService);
+            // Create and run LoginUseCase
+            const useCase = new LoginUseCase({
+                authService: new OAuthService(authConfig),
+                browserLauncher: new SystemBrowserLauncher(),
+                callbackHandler: new CallbackHandler(),
+                terminal,
+                tokenStore,
+                trackingService,
+                userService: new HttpUserService({ apiBaseUrl: config.apiBaseUrl }),
+            });
+            await useCase.run();
+        },
+        type: 'streaming',
+    }),
+    aliases: [],
+    autoExecute: true,
+    description: 'Authenticate with ByteRover using OAuth 2.0 + PKCE',
+    kind: CommandKind.BUILT_IN,
+    name: 'login',
+};

package/dist/tui/commands/logout-command.d.ts

@@ -0,0 +1,5 @@
+import { SlashCommand } from '../types.js';
+/**
+ * Logout command
+ */
+export declare const logoutCommand: SlashCommand;

package/dist/tui/commands/logout-command.js

@@ -0,0 +1,46 @@
+import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
+import { createTokenStore } from '../../server/infra/storage/token-store.js';
+import { ReplTerminal } from '../../server/infra/terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
+import { LogoutUseCase } from '../../server/infra/usecase/logout-use-case.js';
+import { CommandKind } from '../types.js';
+import { Flags, parseReplArgs, toCommandFlags } from './arg-parser.js';
+// Flags - defined once, used for both parsing and help display
+const logoutFlags = {
+    yes: Flags.boolean({
+        char: 'y',
+        default: false,
+        description: 'Skip confirmation prompt',
+    }),
+};
+/**
+ * Logout command
+ */
+export const logoutCommand = {
+    action(_context, args) {
+        return {
+            async execute(onMessage, onPrompt) {
+                const terminal = new ReplTerminal({ onMessage, onPrompt });
+                const parsed = await parseReplArgs(args, {
+                    flags: logoutFlags,
+                    strict: false,
+                });
+                const tokenStore = createTokenStore();
+                const globalConfigStore = new FileGlobalConfigStore();
+                const useCase = new LogoutUseCase({
+                    terminal,
+                    tokenStore,
+                    trackingService: new MixpanelTrackingService({ globalConfigStore, tokenStore }),
+                });
+                await useCase.run({ skipConfirmation: parsed.flags.yes ?? false });
+            },
+            type: 'streaming',
+        };
+    },
+    aliases: [],
+    autoExecute: true,
+    description: 'Log out of ByteRover CLI and clear authentication',
+    flags: toCommandFlags(logoutFlags),
+    kind: CommandKind.BUILT_IN,
+    name: 'logout',
+};

package/dist/tui/commands/model-command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Model Command
+ *
+ * Interactive command for selecting LLM models from the active provider.
+ * Uses the streaming command pattern with inline prompts.
+ *
+ * Usage: /model
+ */
+import type { SlashCommand } from '../../tui/types.js';
+/**
+ * Model command definition.
+ */
+export declare const modelCommand: SlashCommand;