byterover-cli 0.3.5 → 0.4.0

package/dist/infra/repl/commands/arg-parser.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 { type Interfaces } from '@oclif/core';
+import type { CommandFlag } from '../../../tui/types.js';
+export { Args, Flags } from '@oclif/core';
+type ArgInput = Interfaces.ArgInput;
+type FlagInput = Interfaces.FlagInput;
+/**
+ * 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 declare function toCommandFlags(flags: FlagInput): CommandFlag[];
+/**
+ * Result from splitArgs with file references
+ */
+export interface SplitArgsResult {
+    /** Regular arguments */
+    args: string[];
+    /** File references (tokens starting with @) */
+    files: string[];
+}
+/**
+ * Split a string into args array, respecting quoted strings
+ * Handles both single and double quotes, and extracts @file references
+ *
+ * @example
+ * splitArgs('"hello world" --force') // { args: ['hello world', '--force'], files: [] }
+ * splitArgs("'hello world' -f") // { args: ['hello world', '-f'], files: [] }
+ * splitArgs('query @src/file.ts') // { args: ['query'], files: ['src/file.ts'] }
+ * splitArgs('"context" @src/a.ts @src/b.ts') // { args: ['context'], files: ['src/a.ts', 'src/b.ts'] }
+ */
+export declare function splitArgs(input: string): SplitArgsResult;
+/**
+ * Parse result from parseReplArgs
+ */
+export interface ParsedReplArgs<TFlags extends FlagInput, TArgs extends ArgInput> {
+    /** Parsed arguments */
+    args: {
+        [K in keyof TArgs]: TArgs[K] extends {
+            required: true;
+        } ? string : string | undefined;
+    };
+    /** Remaining unparsed arguments (when strict: false) */
+    argv: string[];
+    /** File references extracted from @filepath tokens */
+    files: string[];
+    /** Parsed flags */
+    flags: {
+        [K in keyof TFlags]: TFlags[K] extends {
+            type: 'boolean';
+        } ? boolean : string | undefined;
+    };
+}
+/**
+ * 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 declare function parseReplArgs<TFlags extends FlagInput, TArgs extends ArgInput>(input: string, options: {
+    args?: TArgs;
+    flags?: TFlags;
+    strict?: boolean;
+}): Promise<ParsedReplArgs<TFlags, TArgs>>;

package/dist/infra/repl/commands/arg-parser.js

@@ -0,0 +1,129 @@
+/**
+ * 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';
+// 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',
+    }));
+}
+/**
+ * Split a string into args array, respecting quoted strings
+ * Handles both single and double quotes, and extracts @file references
+ *
+ * @example
+ * splitArgs('"hello world" --force') // { args: ['hello world', '--force'], files: [] }
+ * splitArgs("'hello world' -f") // { args: ['hello world', '-f'], files: [] }
+ * splitArgs('query @src/file.ts') // { args: ['query'], files: ['src/file.ts'] }
+ * splitArgs('"context" @src/a.ts @src/b.ts') // { args: ['context'], files: ['src/a.ts', 'src/b.ts'] }
+ */
+export function splitArgs(input) {
+    const args = [];
+    const files = [];
+    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('@')) {
+                    // File reference - strip the @ prefix
+                    files.push(current.slice(1));
+                }
+                else {
+                    args.push(current);
+                }
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    // Don't forget the last arg
+    if (current) {
+        if (current.startsWith('@')) {
+            files.push(current.slice(1));
+        }
+        else {
+            args.push(current);
+        }
+    }
+    return { args, files };
+}
+/**
+ * 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 } = 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,
+    };
+}

package/dist/infra/repl/commands/clear-command.d.ts

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

package/dist/infra/repl/commands/clear-command.js

@@ -0,0 +1,61 @@
+import { CommandKind } from '../../../tui/types.js';
+import { FileContextTreeService } from '../../context-tree/file-context-tree-service.js';
+import { FileContextTreeSnapshotService } from '../../context-tree/file-context-tree-snapshot-service.js';
+import { ReplTerminal } from '../../terminal/repl-terminal.js';
+import { ClearUseCase } from '../../usecase/clear-use-case.js';
+import { Args, Flags, parseReplArgs, toCommandFlags } from './arg-parser.js';
+// Flags - defined once, used for both parsing and help display
+const clearFlags = {
+    yes: Flags.boolean({
+        char: 'y',
+        default: false,
+        description: 'Skip confirmation prompt',
+    }),
+};
+// Args - defined once for parsing
+const clearArgs = {
+    directory: Args.string({
+        description: 'Project directory (defaults to current directory)',
+        required: false,
+    }),
+};
+/**
+ * clear command
+ */
+export const clearCommand = {
+    action(_context, args) {
+        return {
+            async execute(onMessage, onPrompt) {
+                const terminal = new ReplTerminal({ onMessage, onPrompt });
+                const parsed = await parseReplArgs(args, {
+                    args: clearArgs,
+                    flags: clearFlags,
+                    strict: false,
+                });
+                const useCase = new ClearUseCase({
+                    contextTreeService: new FileContextTreeService(),
+                    contextTreeSnapshotService: new FileContextTreeSnapshotService(),
+                    terminal,
+                });
+                await useCase.run({
+                    directory: parsed.args.directory,
+                    skipConfirmation: parsed.flags.yes ?? false,
+                });
+            },
+            type: 'streaming',
+        };
+    },
+    aliases: [],
+    args: [
+        {
+            description: 'Project directory (defaults to current directory)',
+            name: 'directory',
+            required: false,
+        },
+    ],
+    autoExecute: true,
+    description: 'Reset the current context tree and start with 6 default domains',
+    flags: toCommandFlags(clearFlags),
+    kind: CommandKind.BUILT_IN,
+    name: 'clear',
+};

package/dist/infra/repl/commands/curate-command.d.ts

@@ -0,0 +1,9 @@
+import { type SlashCommand } from '../../../tui/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/infra/repl/commands/curate-command.js

@@ -0,0 +1,88 @@
+import { randomUUID } from 'node:crypto';
+import { isDevelopment } from '../../../config/environment.js';
+import { CommandKind } from '../../../tui/types.js';
+import { ProjectConfigStore } from '../../config/file-config-store.js';
+import { FileGlobalConfigStore } from "../../storage/file-global-config-store.js";
+import { KeychainTokenStore } from '../../storage/keychain-token-store.js';
+import { ReplTerminal } from '../../terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../tracking/mixpanel-tracking-service.js';
+import { CurateUseCase } from '../../usecase/curate-use-case.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 are pre-extracted by the command processor
+                const files = context.invocation?.files ?? [];
+                // 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 = new KeychainTokenStore();
+                const globalConfigStore = new FileGlobalConfigStore();
+                const useCase = new CurateUseCase({
+                    projectConfigStore: new ProjectConfigStore(),
+                    terminal,
+                    tokenStore,
+                    trackingService: new MixpanelTrackingService({ globalConfigStore, tokenStore }),
+                });
+                // Run the use case - mode determined by whether context is provided
+                await useCase.run({
+                    apiKey: flags.apiKey,
+                    context: contextText,
+                    files: files.length > 0 ? files : undefined,
+                    model: flags.model,
+                    verbose: flags.verbose,
+                });
+                onMessage({
+                    content: 'View in Activity tab.             [tab]',
+                    id: randomUUID(),
+                    type: 'output',
+                });
+            },
+            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: 'files',
+            type: 'file',
+        },
+        ...(isDevelopment() ? toCommandFlags(devFlags) : []),
+    ],
+    kind: CommandKind.BUILT_IN,
+    name: 'curate',
+};

package/dist/infra/repl/commands/gen-rules-command.d.ts

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

package/dist/infra/repl/commands/gen-rules-command.js

@@ -0,0 +1,38 @@
+import { CommandKind } from '../../../tui/types.js';
+import { FsFileService } from '../../file/fs-file-service.js';
+import { LegacyRuleDetector } from '../../rule/legacy-rule-detector.js';
+import { RuleTemplateService } from '../../rule/rule-template-service.js';
+import { FileGlobalConfigStore } from "../../storage/file-global-config-store.js";
+import { KeychainTokenStore } from '../../storage/keychain-token-store.js';
+import { FsTemplateLoader } from '../../template/fs-template-loader.js';
+import { ReplTerminal } from '../../terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../tracking/mixpanel-tracking-service.js';
+import { GenerateRulesUseCase } from '../../usecase/generate-rules-use-case.js';
+/**
+ * Generate rules command
+ *
+ * Creates and runs GenerateRulesUseCase with ReplTerminal for TUI integration.
+ */
+export const genRulesCommand = {
+    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: new KeychainTokenStore() });
+            // Create and run UseCase
+            const useCase = new GenerateRulesUseCase(fileService, new LegacyRuleDetector(), templateService, terminal, trackingService);
+            await useCase.run();
+        },
+        type: 'streaming',
+    }),
+    aliases: [],
+    autoExecute: true,
+    description: 'Generate rule instructions for coding agents to work with ByteRover correctly',
+    kind: CommandKind.BUILT_IN,
+    name: 'gen-rules',
+};

package/dist/infra/repl/commands/index.d.ts

@@ -0,0 +1,8 @@
+import { SlashCommand } from '../../../tui/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/infra/repl/commands/index.js

@@ -0,0 +1,36 @@
+import { clearCommand } from './clear-command.js';
+import { curateCommand } from './curate-command.js';
+import { genRulesCommand } from './gen-rules-command.js';
+import { initCommand } from './init-command.js';
+import { loginCommand } from './login-command.js';
+import { logoutCommand } from './logout-command.js';
+import { pullCommand } from './pull-command.js';
+import { pushCommand } from './push-command.js';
+import { queryCommand } from './query-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
+    // Sync operations
+    pushCommand, // Push to cloud
+    pullCommand, // Pull from cloud
+    // Space management
+    spaceCommand, // Switch/list spaces
+    // Context tree management
+    genRulesCommand, // Generate rule files
+    clearCommand, // Reset context tree (destructive)
+    // Setup
+    initCommand, // Project setup (once per project)
+    // Auth
+    loginCommand, // Sign in
+    logoutCommand, // Sign out
+];

package/dist/infra/repl/commands/init-command.d.ts

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

package/dist/infra/repl/commands/init-command.js

@@ -0,0 +1,83 @@
+import { getCurrentConfig } from '../../../config/environment.js';
+import { CommandKind } from '../../../tui/types.js';
+import { HttpCogitPullService } from '../../cogit/http-cogit-pull-service.js';
+import { ProjectConfigStore } from '../../config/file-config-store.js';
+import { FileContextTreeService } from '../../context-tree/file-context-tree-service.js';
+import { FileContextTreeSnapshotService } from '../../context-tree/file-context-tree-snapshot-service.js';
+import { FileContextTreeWriterService } from '../../context-tree/file-context-tree-writer-service.js';
+import { FsFileService } from '../../file/fs-file-service.js';
+import { LegacyRuleDetector } from '../../rule/legacy-rule-detector.js';
+import { RuleTemplateService } from '../../rule/rule-template-service.js';
+import { HttpSpaceService } from '../../space/http-space-service.js';
+import { FileGlobalConfigStore } from "../../storage/file-global-config-store.js";
+import { KeychainTokenStore } from '../../storage/keychain-token-store.js';
+import { HttpTeamService } from '../../team/http-team-service.js';
+import { FsTemplateLoader } from '../../template/fs-template-loader.js';
+import { ReplTerminal } from '../../terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../tracking/mixpanel-tracking-service.js';
+import { InitUseCase } from '../../usecase/init-use-case.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 = new KeychainTokenStore();
+                const globalConfigStore = new FileGlobalConfigStore();
+                const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
+                const fileService = new FsFileService();
+                const templateLoader = new FsTemplateLoader(fileService);
+                const ruleTemplateService = new RuleTemplateService(templateLoader);
+                const legacyRuleDetector = new LegacyRuleDetector();
+                const contextTreeSnapshotService = new FileContextTreeSnapshotService();
+                // Create and run use case
+                const useCase = new InitUseCase({
+                    cogitPullService: new HttpCogitPullService({
+                        apiBaseUrl: envConfig.cogitApiBaseUrl,
+                    }),
+                    contextTreeService: new FileContextTreeService(),
+                    contextTreeSnapshotService,
+                    contextTreeWriterService: new FileContextTreeWriterService({
+                        snapshotService: contextTreeSnapshotService,
+                    }),
+                    fileService,
+                    legacyRuleDetector,
+                    projectConfigStore: new ProjectConfigStore(),
+                    spaceService: new HttpSpaceService({
+                        apiBaseUrl: envConfig.apiBaseUrl,
+                    }),
+                    teamService: new HttpTeamService({
+                        apiBaseUrl: envConfig.apiBaseUrl,
+                    }),
+                    templateService: ruleTemplateService,
+                    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/infra/repl/commands/login-command.d.ts

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

package/dist/infra/repl/commands/login-command.js

@@ -0,0 +1,50 @@
+import { getAuthConfig } from '../../../config/auth.config.js';
+import { getCurrentConfig } from '../../../config/environment.js';
+import { CommandKind } from '../../../tui/types.js';
+import { OAuthService } from '../../auth/oauth-service.js';
+import { OidcDiscoveryService } from '../../auth/oidc-discovery-service.js';
+import { SystemBrowserLauncher } from '../../browser/system-browser-launcher.js';
+import { CallbackHandler } from '../../http/callback-handler.js';
+import { FileGlobalConfigStore } from "../../storage/file-global-config-store.js";
+import { KeychainTokenStore } from '../../storage/keychain-token-store.js';
+import { ReplTerminal } from '../../terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../tracking/mixpanel-tracking-service.js';
+import { LoginUseCase } from '../../usecase/login-use-case.js';
+import { HttpUserService } from '../../user/http-user-service.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 = new KeychainTokenStore();
+            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/infra/repl/commands/logout-command.d.ts

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