byterover-cli 3.1.0 → 3.2.0

package/dist/tui/features/commands/definitions/source-add.js

@@ -0,0 +1,48 @@
+import { resolve } from 'node:path';
+import { addSourceViaTransport } from '../../source/api/source-api.js';
+import { Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const sourceAddFlags = {
+    alias: Flags.string({
+        description: 'Custom alias for the source (defaults to directory name)',
+    }),
+};
+export const sourceAddSubCommand = {
+    async action(_context, args) {
+        const parsed = await parseReplArgs(args ?? '', { flags: sourceAddFlags, strict: false });
+        const targetArg = parsed.argv[0];
+        if (!targetArg) {
+            return {
+                content: 'Usage: /source add <path-to-project> [--alias <name>]',
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        const targetPath = resolve(targetArg);
+        try {
+            const result = await addSourceViaTransport(targetPath, parsed.flags.alias);
+            return {
+                content: result.message,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Source add failed: ${message}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+    },
+    args: [
+        {
+            description: 'Path to the target project containing .brv/',
+            name: 'path',
+            required: true,
+        },
+    ],
+    description: "Add a read-only knowledge source from another project's context tree",
+    flags: toCommandFlags(sourceAddFlags),
+    name: 'add',
+};

package/dist/tui/features/commands/definitions/source-list.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const sourceListSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/source-list.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import { listSourcesViaTransport } from '../../source/api/source-api.js';
+export const sourceListSubCommand = {
+    async action() {
+        try {
+            const result = await listSourcesViaTransport();
+            if (result.error) {
+                return {
+                    content: result.error,
+                    messageType: 'error',
+                    type: 'message',
+                };
+            }
+            if (result.statuses.length === 0) {
+                return {
+                    content: 'No knowledge sources configured.',
+                    messageType: 'error',
+                    type: 'message',
+                };
+            }
+            const lines = ['Knowledge Sources:'];
+            for (const source of result.statuses) {
+                if (source.valid) {
+                    lines.push(`   ${source.alias} → ${source.projectRoot} ${chalk.green('(valid)')}`);
+                }
+                else {
+                    lines.push(`   ${source.alias} → ${source.projectRoot} ${chalk.red(`[BROKEN - run /source remove ${source.alias}]`)}`);
+                }
+            }
+            return {
+                content: lines.join('\n'),
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Source list failed: ${message}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+    },
+    description: 'List all knowledge sources and their status',
+    name: 'list',
+};

package/dist/tui/features/commands/definitions/source-remove.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const sourceRemoveSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/source-remove.js

@@ -0,0 +1,38 @@
+import { removeSourceViaTransport } from '../../source/api/source-api.js';
+export const sourceRemoveSubCommand = {
+    async action(_context, args) {
+        const argTrimmed = args?.trim();
+        if (!argTrimmed) {
+            return {
+                content: 'Usage: /source remove <alias-or-path>',
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        try {
+            const result = await removeSourceViaTransport(argTrimmed);
+            return {
+                content: result.message,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Source remove failed: ${message}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+    },
+    args: [
+        {
+            description: 'Alias or path of the knowledge source to remove',
+            name: 'aliasOrPath',
+            required: true,
+        },
+    ],
+    description: 'Remove a knowledge source',
+    name: 'remove',
+};

package/dist/tui/features/commands/definitions/source.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const sourceCommand: SlashCommand;

package/dist/tui/features/commands/definitions/source.js

@@ -0,0 +1,8 @@
+import { sourceAddSubCommand } from './source-add.js';
+import { sourceListSubCommand } from './source-list.js';
+import { sourceRemoveSubCommand } from './source-remove.js';
+export const sourceCommand = {
+    description: "Manage knowledge sources from other projects' context trees",
+    name: 'source',
+    subCommands: [sourceAddSubCommand, sourceRemoveSubCommand, sourceListSubCommand],
+};

package/dist/tui/features/commands/definitions/worktree-add.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const worktreeAddSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/worktree-add.js

@@ -0,0 +1,35 @@
+import { resolve } from 'node:path';
+import { addWorktreeViaTransport } from '../../worktree/api/worktree-api.js';
+export const worktreeAddSubCommand = {
+    async action(_context, args) {
+        const cwd = resolve(process.cwd());
+        const argTrimmed = args?.trim();
+        // Resolve worktree path: if argument provided, resolve relative to cwd; otherwise use cwd itself
+        const worktreePath = argTrimmed ? resolve(argTrimmed) : cwd;
+        try {
+            const result = await addWorktreeViaTransport(worktreePath, true);
+            return {
+                content: result.success ? result.message + ' Run /status to verify.' : result.message,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Worktree add failed: ${message}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+    },
+    args: [
+        {
+            description: 'Path to the directory to register as a worktree (auto-detects parent if omitted)',
+            name: 'path',
+            required: false,
+        },
+    ],
+    description: 'Register a directory as a worktree of a project',
+    name: 'add',
+};

package/dist/tui/features/commands/definitions/worktree-list.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const worktreeListSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/worktree-list.js

@@ -0,0 +1,36 @@
+import { listWorktreesViaTransport } from '../../worktree/api/worktree-api.js';
+export const worktreeListSubCommand = {
+    async action() {
+        try {
+            const result = await listWorktreesViaTransport();
+            const lines = [];
+            if (result.source === 'linked') {
+                lines.push(`Worktree: ${result.worktreeRoot}`, `Linked to: ${result.projectRoot}`);
+            }
+            else {
+                lines.push(`Project: ${result.projectRoot}`);
+            }
+            if (result.worktrees.length > 0) {
+                lines.push('', 'Registered worktrees:');
+                for (const wt of result.worktrees) {
+                    lines.push(`   ${wt.name} → ${wt.worktreePath}`);
+                }
+            }
+            return {
+                content: lines.join('\n'),
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Worktree list failed: ${message}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+    },
+    description: 'Show the current worktree link and list all registered worktrees',
+    name: 'list',
+};

package/dist/tui/features/commands/definitions/worktree-remove.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const worktreeRemoveSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/worktree-remove.js

@@ -0,0 +1,33 @@
+import { resolve } from 'node:path';
+import { removeWorktreeViaTransport } from '../../worktree/api/worktree-api.js';
+export const worktreeRemoveSubCommand = {
+    async action(_context, args) {
+        const argTrimmed = args?.trim();
+        const targetPath = argTrimmed ? resolve(argTrimmed) : resolve(process.cwd());
+        try {
+            const result = await removeWorktreeViaTransport(targetPath);
+            return {
+                content: result.message,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Worktree remove failed: ${message}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+    },
+    args: [
+        {
+            description: 'Path to the worktree to remove (defaults to current directory)',
+            name: 'path',
+            required: false,
+        },
+    ],
+    description: 'Remove a worktree registration',
+    name: 'remove',
+};

package/dist/tui/features/commands/definitions/worktree.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const worktreeCommand: SlashCommand;

package/dist/tui/features/commands/definitions/worktree.js

@@ -0,0 +1,8 @@
+import { worktreeAddSubCommand } from './worktree-add.js';
+import { worktreeListSubCommand } from './worktree-list.js';
+import { worktreeRemoveSubCommand } from './worktree-remove.js';
+export const worktreeCommand = {
+    description: 'Manage worktree links for nested directories',
+    name: 'worktree',
+    subCommands: [worktreeAddSubCommand, worktreeRemoveSubCommand, worktreeListSubCommand],
+};

package/dist/tui/features/curate/api/create-curate-task.js

@@ -15,7 +15,7 @@ import { useTransportStore } from '../../../stores/transport-store.js';
  * triggers the FolderPackExecutor on the server for full directory analysis.
  */
 export const createCurateTask = async ({ content, files, folders }) => {
-    const { apiClient } = useTransportStore.getState();
+    const { apiClient, projectPath, worktreeRoot } = useTransportStore.getState();
     if (!apiClient) {
         throw new Error('Not connected to server');
     }
@@ -33,8 +33,10 @@ export const createCurateTask = async ({ content, files, folders }) => {
         content: resolvedContent,
         ...(hasFolder && folders ? { folderPath: folders[0] } : {}),
         ...(!hasFolder && files && files.length > 0 ? { files } : {}),
+        ...(projectPath ? { projectPath } : {}),
         taskId,
         type: taskType,
+        ...(worktreeRoot ? { worktreeRoot } : {}),
     });
     return { taskId };
 };

package/dist/tui/features/query/api/create-query-task.js

@@ -12,7 +12,7 @@ import { useTransportStore } from '../../../stores/transport-store.js';
  * Returns immediately after task is acknowledged - actual execution is async.
  */
 export const createQueryTask = async ({ query }) => {
-    const { apiClient } = useTransportStore.getState();
+    const { apiClient, projectPath, worktreeRoot } = useTransportStore.getState();
     if (!apiClient) {
         throw new Error('Not connected to server');
     }
@@ -20,8 +20,10 @@ export const createQueryTask = async ({ query }) => {
     await apiClient.request(TaskEvents.CREATE, {
         clientCwd: process.cwd(),
         content: query,
+        ...(projectPath ? { projectPath } : {}),
         taskId,
         type: 'query',
+        ...(worktreeRoot ? { worktreeRoot } : {}),
     });
     return { taskId };
 };

package/dist/tui/features/source/api/source-api.d.ts

@@ -0,0 +1,4 @@
+import { type SourceAddResponse, type SourceListResponse, type SourceRemoveResponse } from '../../../../shared/transport/events/source-events.js';
+export declare const addSourceViaTransport: (targetPath: string, alias?: string) => Promise<SourceAddResponse>;
+export declare const removeSourceViaTransport: (aliasOrPath: string) => Promise<SourceRemoveResponse>;
+export declare const listSourcesViaTransport: () => Promise<SourceListResponse>;

package/dist/tui/features/source/api/source-api.js

@@ -0,0 +1,22 @@
+import { SourceEvents, } from '../../../../shared/transport/events/source-events.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const addSourceViaTransport = (targetPath, alias) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    const request = { alias, targetPath };
+    return apiClient.request(SourceEvents.ADD, request);
+};
+export const removeSourceViaTransport = (aliasOrPath) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    const request = { aliasOrPath };
+    return apiClient.request(SourceEvents.REMOVE, request);
+};
+export const listSourcesViaTransport = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(SourceEvents.LIST);
+};

package/dist/tui/features/status/api/get-status.js

@@ -5,7 +5,8 @@ export const getStatus = () => {
     const { apiClient } = useTransportStore.getState();
     if (!apiClient)
         return Promise.reject(new Error('Not connected'));
-    return apiClient.request(StatusEvents.GET);
+    const request = { cwd: process.cwd() };
+    return apiClient.request(StatusEvents.GET, request);
 };
 export const getStatusQueryOptions = () => queryOptions({
     queryFn: getStatus,

package/dist/tui/features/status/utils/format-status.js

@@ -22,13 +22,35 @@ export function formatStatus(status, version) {
             lines.push('Account: Unable to check');
         }
     }
-    lines.push(`Current Directory: ${status.currentDirectory}`);
+    lines.push(`Project: ${status.projectRoot ?? status.currentDirectory}`);
+    if (status.worktreeRoot && status.worktreeRoot !== status.projectRoot) {
+        lines.push(`Worktree: ${status.worktreeRoot} (linked)`);
+    }
+    if (status.resolverError) {
+        lines.push(chalk.yellow(`⚠ ${status.resolverError}`));
+    }
     if (status.teamName && status.spaceName) {
         lines.push(`Space: ${status.teamName}/${status.spaceName}`);
     }
     else {
         lines.push('Space: Not connected');
     }
+    // Knowledge sources
+    if (status.sourcesError) {
+        lines.push(chalk.yellow(`⚠ ${status.sourcesError}`));
+    }
+    else if (status.sources && status.sources.length > 0) {
+        lines.push('Knowledge Sources:');
+        for (const source of status.sources) {
+            if (source.valid) {
+                const sizeInfo = source.contextTreeSize === undefined ? '' : ` [${source.contextTreeSize} files]`;
+                lines.push(`   ${source.alias} → ${source.projectRoot} ${chalk.green('(valid)')}${sizeInfo}`);
+            }
+            else {
+                lines.push(`   ${source.alias} → ${source.projectRoot} ${chalk.red(`[BROKEN - run brv source remove ${source.alias}]`)}`);
+            }
+        }
+    }
     switch (status.contextTreeStatus) {
         case 'git_vc': {
             lines.push('Context Tree: Byterover version control (use /vc commands)');

package/dist/tui/features/transport/components/transport-initializer.js

@@ -8,6 +8,8 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
  */
 import { connectToDaemon, createDaemonReconnector, } from '@campfirein/brv-transport-client';
 import { useEffect } from 'react';
+// eslint-disable-next-line no-restricted-imports -- fallback resolver when store has no projectPath
+import { resolveProject } from '../../../../server/infra/project/resolve-project.js';
 import { getAllEventValues } from '../../../../shared/transport/events/index.js';
 import { initTransportLog, logTransportEvent } from '../../../lib/transport-logger.js';
 import { useTransportStore } from '../../../stores/transport-store.js';
@@ -16,6 +18,7 @@ export function TransportInitializer({ children }) {
     useEffect(() => {
         let mounted = true;
         let reconnectorHandle;
+        let unsubProjectSync;
         const eventUnsubscribes = [];
         function registerEventHandlers(client) {
             // Clear old handlers first
@@ -36,12 +39,43 @@ export function TransportInitializer({ children }) {
             try {
                 initTransportLog();
                 setConnectionState('connecting');
+                const getCurrentProjectPath = () => {
+                    const storedProjectPath = useTransportStore.getState().projectPath;
+                    if (storedProjectPath)
+                        return storedProjectPath;
+                    // Attempt live resolution as a last resort (e.g. store not yet populated).
+                    // If resolution fails or returns null, throw — registering with raw cwd
+                    // would put the client in the wrong room.
+                    const resolution = resolveProject();
+                    if (!resolution) {
+                        throw new Error('No ByteRover project could be resolved. Ensure you are inside a brv project directory.');
+                    }
+                    return resolution.projectRoot;
+                };
                 // connectToDaemon = ensureDaemonRunning (no-op, already running) + connect + register + join rooms
+                // Use resolved projectPath from store (set by oclif main via resolveProject()),
+                // falling back to process.cwd() for backwards compatibility.
+                //
+                // connectOptions is a mutable object — the reconnector captures it by reference
+                // (daemon-reconnector.js line 60), so mutating .projectPath here is visible
+                // on subsequent reconnect attempts.
                 const connectOptions = {
                     clientType: 'tui',
                     joinRooms: ['broadcast-room'],
-                    projectPath: process.cwd(),
+                    projectPath: getCurrentProjectPath(),
                 };
+                // Keep connectOptions.projectPath in sync with the store so reconnects
+                // use the latest value (e.g. after reassociation from worktree add/remove).
+                // If projectPath is cleared and resolver fails, keep the last good value
+                // rather than registering with raw cwd.
+                unsubProjectSync = useTransportStore.subscribe((state) => {
+                    try {
+                        connectOptions.projectPath = state.projectPath ?? getCurrentProjectPath();
+                    }
+                    catch {
+                        // Resolver failed — keep existing connectOptions.projectPath unchanged
+                    }
+                });
                 const { client: newClient } = await connectToDaemon(connectOptions);
                 if (!mounted) {
                     await newClient.disconnect();
@@ -89,6 +123,7 @@ export function TransportInitializer({ children }) {
         return () => {
             mounted = false;
             reconnectorHandle?.cancel();
+            unsubProjectSync?.();
             // Clean up all event handlers
             for (const unsub of eventUnsubscribes) {
                 unsub();

package/dist/tui/features/worktree/api/worktree-api.d.ts

@@ -0,0 +1,4 @@
+import { type WorktreeAddResponse, type WorktreeListResponse, type WorktreeRemoveResponse } from '../../../../shared/transport/events/worktree-events.js';
+export declare const addWorktreeViaTransport: (worktreePath: string, force?: boolean) => Promise<WorktreeAddResponse>;
+export declare const removeWorktreeViaTransport: (worktreePath: string) => Promise<WorktreeRemoveResponse>;
+export declare const listWorktreesViaTransport: () => Promise<WorktreeListResponse>;

package/dist/tui/features/worktree/api/worktree-api.js

@@ -0,0 +1,22 @@
+import { WorktreeEvents, } from '../../../../shared/transport/events/worktree-events.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const addWorktreeViaTransport = (worktreePath, force) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    const request = { force, worktreePath };
+    return apiClient.request(WorktreeEvents.ADD, request);
+};
+export const removeWorktreeViaTransport = (worktreePath) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    const request = { worktreePath };
+    return apiClient.request(WorktreeEvents.REMOVE, request);
+};
+export const listWorktreesViaTransport = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(WorktreeEvents.LIST);
+};

package/dist/tui/repl-startup.d.ts

@@ -5,7 +5,9 @@
  * - TransportInitializer connects to daemon via connectToDaemon()
  */
 export interface ReplOptions {
+    projectPath?: string;
     version: string;
+    worktreeRoot?: string;
 }
 /**
  * Start the ByteRover REPL

package/dist/tui/repl-startup.js

@@ -7,9 +7,11 @@ import { useTransportStore } from './stores/transport-store.js';
  * Start the ByteRover REPL
  */
 export async function startRepl(options) {
-    const { version } = options;
-    // Set version in store before rendering
-    useTransportStore.getState().setVersion(version);
+    const { projectPath, version, worktreeRoot } = options;
+    // Set version and project info in store before rendering
+    const store = useTransportStore.getState();
+    store.setVersion(version);
+    store.setProjectInfo(projectPath, worktreeRoot);
     const { waitUntilExit } = render(_jsx(AppProviders, { children: _jsx(App, {}) }));
     await waitUntilExit();
 }

package/dist/tui/stores/transport-store.d.ts

@@ -18,10 +18,14 @@ export interface TransportState {
     error: Error | null;
     /** Whether the client is connected */
     isConnected: boolean;
+    /** Resolved project path (where .brv/ lives) */
+    projectPath: null | string;
     /** Number of reconnection attempts */
     reconnectCount: number;
     /** App version */
     version: string;
+    /** Resolved workspace root (linked subdir or projectRoot if unlinked) */
+    worktreeRoot: null | string;
 }
 export interface TransportActions {
     /** Increment reconnect count */
@@ -34,6 +38,8 @@ export interface TransportActions {
     setConnectionState: (state: ConnectionState) => void;
     /** Set connection error */
     setError: (error: Error | null) => void;
+    /** Set resolved project info from oclif main */
+    setProjectInfo: (projectPath?: string, worktreeRoot?: string) => void;
     /** Set app version */
     setVersion: (version: string) => void;
 }

package/dist/tui/stores/transport-store.js

@@ -13,8 +13,10 @@ const initialState = {
     connectionState: 'disconnected',
     error: null,
     isConnected: false,
+    projectPath: null,
     reconnectCount: 0,
     version: '',
+    worktreeRoot: null,
 };
 export const useTransportStore = create()((set) => ({
     ...initialState,
@@ -36,5 +38,9 @@ export const useTransportStore = create()((set) => ({
         error,
         isConnected: false,
     }),
+    setProjectInfo: (projectPath, worktreeRoot) => set({
+        projectPath: projectPath ?? null,
+        worktreeRoot: worktreeRoot ?? null,
+    }),
     setVersion: (version) => set({ version }),
 }));