byterover-cli 1.2.0 → 1.3.0

package/dist/infra/connectors/mcp/mcp-connector.js

@@ -19,7 +19,7 @@ import { TomlMcpConfigWriter } from './toml-mcp-config-writer.js';
  * - Safe uninstall: Only removes ByteRover's MCP server entry and rule content
  */
 export class McpConnector {
-    type = 'mcp';
+    connectorType = 'mcp';
     fileService;
     projectRoot;
     ruleFileManager;
@@ -34,7 +34,7 @@ export class McpConnector {
             projectRoot: options.projectRoot,
         });
         this.supportedAgents = Object.entries(AGENT_CONNECTOR_CONFIG)
-            .filter(([_, config]) => config.supported.includes(this.type))
+            .filter(([_, config]) => config.supported.includes(this.connectorType))
             .map(([agent]) => agent);
     }
     getConfigPath(agent) {
@@ -66,7 +66,7 @@ export class McpConnector {
         return this.installAutomatic(agent, config);
     }
     isSupported(agent) {
-        return agent in MCP_CONNECTOR_CONFIGS && AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.type);
+        return agent in MCP_CONNECTOR_CONFIGS && AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.connectorType);
     }
     async status(agent) {
         if (!this.isSupported(agent)) {
@@ -254,7 +254,7 @@ export class McpConnector {
         if (!rulesConfig) {
             return;
         }
-        const ruleContent = await this.templateService.generateRuleContent(agent, this.type);
+        const ruleContent = await this.templateService.generateRuleContent(agent, this.connectorType);
         await this.ruleFileManager.install(rulesConfig.filePath, rulesConfig.writeMode, ruleContent);
     }
     /**

package/dist/infra/connectors/rules/rules-connector.d.ts

@@ -17,7 +17,7 @@ type RulesConnectorOptions = {
  * Manages the installation, uninstallation, and status of rule files.
  */
 export declare class RulesConnector implements IConnector {
-    readonly type: ConnectorType;
+    readonly connectorType: ConnectorType;
     private readonly fileService;
     private readonly projectRoot;
     private readonly ruleFileManager;

package/dist/infra/connectors/rules/rules-connector.js

@@ -7,7 +7,7 @@ import { RULES_CONNECTOR_CONFIGS } from './rules-connector-config.js';
  * Manages the installation, uninstallation, and status of rule files.
  */
 export class RulesConnector {
-    type = 'rules';
+    connectorType = 'rules';
     fileService;
     projectRoot;
     ruleFileManager;
@@ -22,7 +22,7 @@ export class RulesConnector {
             projectRoot: options.projectRoot,
         });
         this.supportedAgents = Object.entries(AGENT_CONNECTOR_CONFIG)
-            .filter(([_, config]) => config.supported.includes(this.type))
+            .filter(([_, config]) => config.supported.includes(this.connectorType))
             .map(([agent]) => agent);
     }
     getConfigPath(agent) {
@@ -34,7 +34,7 @@ export class RulesConnector {
     async install(agent) {
         const config = RULES_CONNECTOR_CONFIGS[agent];
         try {
-            const ruleContent = await this.templateService.generateRuleContent(agent, this.type);
+            const ruleContent = await this.templateService.generateRuleContent(agent, this.connectorType);
             // Write the rule content to the file
             await this.ruleFileManager.install(config.filePath, config.writeMode, ruleContent);
             return {
@@ -54,7 +54,7 @@ export class RulesConnector {
         }
     }
     isSupported(agent) {
-        return AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.type);
+        return AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.connectorType);
     }
     async status(agent) {
         const config = RULES_CONNECTOR_CONFIGS[agent];

package/dist/infra/connectors/shared/template-service.js

@@ -8,6 +8,10 @@ import { BRV_RULE_MARKERS, BRV_RULE_TAG } from './constants.js';
  * @returns The wrapped content with boundary markers.
  */
 const wrapContentWithBoundaryMarkers = (content, agent, header) => {
+    if (agent === 'Windsurf' && header !== '') {
+        const parts = [header, BRV_RULE_MARKERS.START, content, '---', `${BRV_RULE_TAG} ${agent}`, BRV_RULE_MARKERS.END];
+        return parts.join('\n');
+    }
     const parts = [BRV_RULE_MARKERS.START, header, content, '---', `${BRV_RULE_TAG} ${agent}`, BRV_RULE_MARKERS.END];
     return parts.join('\n');
 };

package/dist/infra/connectors/skill/index.d.ts

@@ -0,0 +1 @@
+export { SkillConnector } from './skill-connector.js';

package/dist/infra/connectors/skill/index.js

@@ -0,0 +1 @@
+export { SkillConnector } from './skill-connector.js';

package/dist/infra/connectors/skill/skill-connector-config.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Scope for skill connector configuration.
+ * - 'project': Path relative to project root
+ * - 'global': Path relative to user home directory
+ */
+export type SkillConfigScope = 'global' | 'project';
+/**
+ * Configuration for agent-specific skill file directories.
+ */
+export type SkillConnectorConfig = {
+    /** Base directory for skill files (relative to scope root) */
+    basePath: string;
+    /** Whether path is relative to project root or home dir */
+    scope: SkillConfigScope;
+};
+/**
+ * Agent-specific skill connector configurations.
+ * Maps each supported agent to its skill directory path and scope.
+ */
+export declare const SKILL_CONNECTOR_CONFIGS: {
+    readonly 'Claude Code': {
+        readonly basePath: ".claude/skills/byterover";
+        readonly scope: "project";
+    };
+    readonly Codex: {
+        readonly basePath: ".codex/skills/byterover";
+        readonly scope: "global";
+    };
+    readonly Cursor: {
+        readonly basePath: ".cursor/skills/byterover";
+        readonly scope: "project";
+    };
+    readonly 'Github Copilot': {
+        readonly basePath: ".github/skills/byterover";
+        readonly scope: "project";
+    };
+};
+/**
+ * Type representing agents that have skill connector support.
+ */
+export type SkillSupportedAgent = keyof typeof SKILL_CONNECTOR_CONFIGS;
+/**
+ * Names of the skill files written by the skill connector.
+ */
+export declare const SKILL_FILE_NAMES: readonly ["SKILL.md", "TROUBLESHOOTING.md", "WORKFLOWS.md"];

package/dist/infra/connectors/skill/skill-connector-config.js

@@ -0,0 +1,26 @@
+/**
+ * Agent-specific skill connector configurations.
+ * Maps each supported agent to its skill directory path and scope.
+ */
+export const SKILL_CONNECTOR_CONFIGS = {
+    'Claude Code': {
+        basePath: '.claude/skills/byterover',
+        scope: 'project',
+    },
+    Codex: {
+        basePath: '.codex/skills/byterover',
+        scope: 'global',
+    },
+    Cursor: {
+        basePath: '.cursor/skills/byterover',
+        scope: 'project',
+    },
+    'Github Copilot': {
+        basePath: '.github/skills/byterover',
+        scope: 'project',
+    },
+};
+/**
+ * Names of the skill files written by the skill connector.
+ */
+export const SKILL_FILE_NAMES = ['SKILL.md', 'TROUBLESHOOTING.md', 'WORKFLOWS.md'];

package/dist/infra/connectors/skill/skill-connector.d.ts

@@ -0,0 +1,39 @@
+import type { Agent } from '../../../core/domain/entities/agent.js';
+import type { ConnectorType } from '../../../core/domain/entities/connector-type.js';
+import type { ConnectorInstallResult, ConnectorStatus, ConnectorUninstallResult } from '../../../core/interfaces/connectors/connector-types.js';
+import type { IConnector } from '../../../core/interfaces/connectors/i-connector.js';
+import type { IFileService } from '../../../core/interfaces/i-file-service.js';
+import type { SkillSupportedAgent } from './skill-connector-config.js';
+/**
+ * Options for constructing SkillConnector.
+ */
+type SkillConnectorOptions = {
+    fileService: IFileService;
+    projectRoot: string;
+};
+/**
+ * Connector that integrates BRV with coding agents via skill files.
+ * Writes static markdown files (SKILL.md, TROUBLESHOOTING.md, WORKFLOWS.md)
+ * into an agent-specific subdirectory.
+ */
+export declare class SkillConnector implements IConnector {
+    readonly connectorType: ConnectorType;
+    private readonly contentLoader;
+    private readonly fileService;
+    private readonly projectRoot;
+    private readonly supportedAgents;
+    constructor(options: SkillConnectorOptions);
+    getConfigPath(agent: Agent): string;
+    getSupportedAgents(): Agent[];
+    install(agent: Agent): Promise<ConnectorInstallResult>;
+    isSupported(agent: Agent): agent is SkillSupportedAgent;
+    status(agent: Agent): Promise<ConnectorStatus>;
+    uninstall(agent: Agent): Promise<ConnectorUninstallResult>;
+    /**
+     * Get the full (absolute) path for skill file operations.
+     * - Project scope: relative to project root
+     * - Global scope: relative to os.homedir()
+     */
+    private getFullPath;
+}
+export {};

package/dist/infra/connectors/skill/skill-connector.js

@@ -0,0 +1,160 @@
+import os from 'node:os';
+import path from 'node:path';
+import { AGENT_CONNECTOR_CONFIG } from '../../../core/domain/entities/agent.js';
+import { SKILL_CONNECTOR_CONFIGS, SKILL_FILE_NAMES } from './skill-connector-config.js';
+import { SkillContentLoader } from './skill-content-loader.js';
+/**
+ * Connector that integrates BRV with coding agents via skill files.
+ * Writes static markdown files (SKILL.md, TROUBLESHOOTING.md, WORKFLOWS.md)
+ * into an agent-specific subdirectory.
+ */
+export class SkillConnector {
+    connectorType = 'skill';
+    contentLoader;
+    fileService;
+    projectRoot;
+    supportedAgents;
+    constructor(options) {
+        this.fileService = options.fileService;
+        this.projectRoot = options.projectRoot;
+        this.contentLoader = new SkillContentLoader(options.fileService);
+        this.supportedAgents = Object.entries(AGENT_CONNECTOR_CONFIG)
+            .filter(([_, config]) => config.supported.includes(this.connectorType))
+            .map(([agent]) => agent);
+    }
+    getConfigPath(agent) {
+        if (!this.isSupported(agent)) {
+            throw new Error(`Skill connector does not support agent: ${agent}`);
+        }
+        return SKILL_CONNECTOR_CONFIGS[agent].basePath;
+    }
+    getSupportedAgents() {
+        return this.supportedAgents;
+    }
+    async install(agent) {
+        if (!this.isSupported(agent)) {
+            return {
+                alreadyInstalled: false,
+                configPath: '',
+                message: `Skill connector does not support agent: ${agent}`,
+                success: false,
+            };
+        }
+        const config = SKILL_CONNECTOR_CONFIGS[agent];
+        const fullDir = this.getFullPath(config.basePath, config.scope);
+        try {
+            // Check if already installed
+            const skillFilePath = path.join(fullDir, SKILL_FILE_NAMES[0]);
+            if (await this.fileService.exists(skillFilePath)) {
+                return {
+                    alreadyInstalled: true,
+                    configPath: config.basePath,
+                    message: `Skill connector is already installed for ${agent}`,
+                    success: true,
+                };
+            }
+            // Write all skill files
+            await Promise.all(SKILL_FILE_NAMES.map(async (fileName) => {
+                const content = await this.contentLoader.loadSkillFile(fileName);
+                const filePath = path.join(fullDir, fileName);
+                await this.fileService.write(content, filePath, 'overwrite');
+            }));
+            return {
+                alreadyInstalled: false,
+                configPath: fullDir,
+                message: `Skill connector installed for ${agent} (created ${fullDir}/)`,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                alreadyInstalled: false,
+                configPath: config.basePath,
+                message: `Failed to install skill connector for ${agent}: ${error instanceof Error ? error.message : String(error)}`,
+                success: false,
+            };
+        }
+    }
+    isSupported(agent) {
+        return agent in SKILL_CONNECTOR_CONFIGS && AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.connectorType);
+    }
+    async status(agent) {
+        if (!this.isSupported(agent)) {
+            return {
+                configExists: false,
+                configPath: '',
+                error: `Skill connector does not support agent: ${agent}`,
+                installed: false,
+            };
+        }
+        const config = SKILL_CONNECTOR_CONFIGS[agent];
+        const fullDir = this.getFullPath(config.basePath, config.scope);
+        try {
+            const skillFilePath = path.join(fullDir, SKILL_FILE_NAMES[0]);
+            const exists = await this.fileService.exists(skillFilePath);
+            return {
+                configExists: exists,
+                configPath: config.basePath,
+                installed: exists,
+            };
+        }
+        catch (error) {
+            return {
+                configExists: false,
+                configPath: config.basePath,
+                error: error instanceof Error ? error.message : String(error),
+                installed: false,
+            };
+        }
+    }
+    async uninstall(agent) {
+        if (!this.isSupported(agent)) {
+            return {
+                configPath: '',
+                message: `Skill connector does not support agent: ${agent}`,
+                success: false,
+                wasInstalled: false,
+            };
+        }
+        const config = SKILL_CONNECTOR_CONFIGS[agent];
+        const fullDir = this.getFullPath(config.basePath, config.scope);
+        try {
+            const skillFilePath = path.join(fullDir, SKILL_FILE_NAMES[0]);
+            const exists = await this.fileService.exists(skillFilePath);
+            if (!exists) {
+                return {
+                    configPath: config.basePath,
+                    message: `Skill connector is not installed for ${agent}`,
+                    success: true,
+                    wasInstalled: false,
+                };
+            }
+            await this.fileService.deleteDirectory(fullDir);
+            return {
+                configPath: config.basePath,
+                message: `Skill connector uninstalled for ${agent}`,
+                success: true,
+                wasInstalled: true,
+            };
+        }
+        catch (error) {
+            return {
+                configPath: config.basePath,
+                message: `Failed to uninstall skill connector for ${agent}: ${error instanceof Error ? error.message : String(error)}`,
+                success: false,
+                wasInstalled: true,
+            };
+        }
+    }
+    /**
+     * Get the full (absolute) path for skill file operations.
+     * - Project scope: relative to project root
+     * - Global scope: relative to os.homedir()
+     */
+    getFullPath(basePath, scope) {
+        if (scope === 'global') {
+            return path.join(os.homedir(), basePath);
+        }
+        return path.join(this.projectRoot, basePath);
+    }
+}

package/dist/infra/connectors/skill/skill-content-loader.d.ts

@@ -0,0 +1,18 @@
+import type { IFileService } from '../../../core/interfaces/i-file-service.js';
+/**
+ * Loads static skill markdown files from the templates/skill/ directory.
+ * Uses the same import.meta.url path resolution pattern as FsTemplateLoader.
+ */
+export declare class SkillContentLoader {
+    private readonly fileService;
+    private readonly skillDir;
+    constructor(fileService: IFileService);
+    /**
+     * Loads a skill file by name from the templates/skill/ directory.
+     *
+     * @param fileName - Name of the skill file (e.g., 'SKILL.md')
+     * @returns Promise resolving to the file content
+     * @throws Error if the file cannot be read
+     */
+    loadSkillFile(fileName: string): Promise<string>;
+}

package/dist/infra/connectors/skill/skill-content-loader.js

@@ -0,0 +1,33 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Loads static skill markdown files from the templates/skill/ directory.
+ * Uses the same import.meta.url path resolution pattern as FsTemplateLoader.
+ */
+export class SkillContentLoader {
+    fileService;
+    skillDir;
+    constructor(fileService) {
+        this.fileService = fileService;
+        const currentFilePath = fileURLToPath(import.meta.url);
+        const currentDir = path.dirname(currentFilePath);
+        // Navigate from src/infra/connectors/skill/ to src/templates/skill/
+        this.skillDir = path.join(currentDir, '..', '..', '..', 'templates', 'skill');
+    }
+    /**
+     * Loads a skill file by name from the templates/skill/ directory.
+     *
+     * @param fileName - Name of the skill file (e.g., 'SKILL.md')
+     * @returns Promise resolving to the file content
+     * @throws Error if the file cannot be read
+     */
+    async loadSkillFile(fileName) {
+        const fullPath = path.join(this.skillDir, fileName);
+        try {
+            return await this.fileService.read(fullPath);
+        }
+        catch (error) {
+            throw new Error(`Failed to load skill file '${fileName}': ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/infra/file/fs-file-service.d.ts

@@ -11,6 +11,13 @@ export declare class FsFileService implements IFileService {
      * @returns A promise that resolves when the file has been deleted.
      */
     delete(filePath: string): Promise<void>;
+    /**
+     * Deletes a directory and all its contents recursively.
+     *
+     * @param dirPath The path to the directory to delete.
+     * @returns A promise that resolves when the directory has been deleted.
+     */
+    deleteDirectory(dirPath: string): Promise<void>;
     /**
      * Checks if a file exists at the specified path.
      *

package/dist/infra/file/fs-file-service.js

@@ -1,4 +1,4 @@
-import { access, appendFile, copyFile, mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { access, appendFile, copyFile, mkdir, readFile, rm, unlink, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 /**
  * File service implementation using Node.js fs module.
@@ -30,6 +30,20 @@ export class FsFileService {
             throw new Error(`Failed to delete file '${filePath}': ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    /**
+     * Deletes a directory and all its contents recursively.
+     *
+     * @param dirPath The path to the directory to delete.
+     * @returns A promise that resolves when the directory has been deleted.
+     */
+    async deleteDirectory(dirPath) {
+        try {
+            await rm(dirPath, { force: true, recursive: true });
+        }
+        catch (error) {
+            throw new Error(`Failed to delete directory '${dirPath}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
     /**
      * Checks if a file exists at the specified path.
      *

package/dist/infra/mcp/tools/task-result-waiter.js

@@ -29,6 +29,14 @@ export async function waitForTaskResult(client, taskId, timeoutMs = 120_000) {
         }, timeoutMs);
         // Set up all event listeners
         unsubscribers.push(
+        // Listen for connection state changes - fail fast on disconnect
+        client.onStateChange((state) => {
+            if (state === 'disconnected' && !completed) {
+                completed = true;
+                cleanup();
+                reject(new Error('Connection lost to ByteRover instance'));
+            }
+        }), 
         // Listen for LLM response content
         client.on('llmservice:response', (payload) => {
             if (payload.taskId === taskId && payload.content) {

package/dist/infra/process/agent-worker.js

@@ -29,7 +29,6 @@ import { QueryExecutor } from '../core/executors/query-executor.js';
 import { createTaskProcessor } from '../core/task-processor.js';
 import { createTokenStore } from '../storage/token-store.js';
 import { createTransportClient } from '../transport/transport-factory.js';
-import { CURATE_MAX_CONCURRENT } from './constants.js';
 import { createParentHeartbeat } from './parent-heartbeat.js';
 import { TaskQueueManager } from './task-queue-manager.js';
 // IPC types imported from ./ipc-types.ts
@@ -104,19 +103,37 @@ let eventForwarders = [];
 // ============================================================================
 /**
  * Task queue manager handles:
- * - Separate queues for curate and query tasks
- * - Concurrency limits (max 1 concurrent per type)
+ * - Unified queue for all task types (curate, query)
+ * - Sequential FIFO execution (max 1 concurrent)
  * - Task deduplication (same taskId can't be queued twice)
  * - Cancel tasks from queue before processing
- * - FIFO processing order
  */
 const taskQueueManager = new TaskQueueManager({
-    curate: { maxConcurrent: CURATE_MAX_CONCURRENT },
+    maxConcurrent: 1, // Sequential FIFO execution for all tasks
     onExecutorError(taskId, error) {
         agentLog(`Executor error for task ${taskId}: ${error}`);
     },
-    query: { maxConcurrent: Infinity },
 });
+/**
+ * Notify clients about dropped tasks and clear the queue.
+ * Extracted to avoid DRY violation across reinit, stop, and shutdown paths.
+ */
+function notifyQueuedTasksAboutDropAndClear(reason) {
+    const queuedTasks = taskQueueManager.getQueuedTasks();
+    if (queuedTasks.length > 0) {
+        const error = serializeTaskError(new AgentNotInitializedError(`Task dropped - ${reason}`));
+        if (transportClient) {
+            agentLog(`Notifying ${queuedTasks.length} queued task(s): ${reason}`);
+            for (const task of queuedTasks) {
+                transportClient.request('task:error', { error, taskId: task.taskId }).catch(logTransportError);
+            }
+        }
+        else {
+            agentLog(`Cannot notify ${queuedTasks.length} queued task(s): no transport client`);
+        }
+    }
+    taskQueueManager.clear();
+}
 /**
  * Get Transport port from environment.
  */
@@ -318,7 +335,7 @@ const TASK_EXECUTION_TIMEOUT_MS = 5 * 60 * 1000;
 function setupTaskExecutor() {
     taskQueueManager.setExecutor(async (task) => {
         const { taskId, type } = task;
-        const stats = taskQueueManager.getStats(type);
+        const stats = taskQueueManager.getStats();
         agentLog(`Processing task ${taskId} (${type}), ${stats.queued} queued, ${stats.active} active`);
         // Fix #2: Lazy initialization - if agent not ready, try to initialize now
         // This enables processing tasks that arrived while init was failing
@@ -499,9 +516,8 @@ async function tryInitializeAgent(forceReinit = false) {
     try {
         // If forcing reinit, drain queue and stop existing agent first
         if (forceReinit) {
-            // Drain task queue before reinit to prevent tasks executing with stale processor
             agentLog('Draining task queue before reinit...');
-            taskQueueManager.clear(); // Clear queued (not yet started) tasks
+            notifyQueuedTasksAboutDropAndClear('credential/config change');
             // Wait for active tasks to complete (with timeout)
             await waitForActiveTasksToComplete(10_000);
             await stopExistingAgentForReinit();
@@ -727,7 +743,7 @@ async function startAgent() {
         }
         const result = taskQueueManager.enqueue(data);
         if (result.success) {
-            const stats = taskQueueManager.getStats(data.type);
+            const stats = taskQueueManager.getStats();
             agentLog(`Task ${data.taskId} (${data.type}) queued at position ${result.position}, ${stats.queued} in queue`);
         }
         else if (result.reason === 'duplicate') {
@@ -857,8 +873,8 @@ async function startAgent() {
 async function stopCipherAgent() {
     // Cleanup event forwarders
     cleanupAgentEventForwarding();
-    // Clear task queue (can't process without agent)
-    taskQueueManager.clear();
+    // Notify and clear task queue (can't process without agent)
+    notifyQueuedTasksAboutDropAndClear('agent stopped');
     // Stop CipherAgent
     if (cipherAgent) {
         try {
@@ -1098,8 +1114,8 @@ async function stopAgent() {
         // Stop polling and heartbeat first
         stopCredentialsPolling();
         parentHeartbeat?.stop();
-        // Clear task queue
-        taskQueueManager.clear();
+        // Notify and clear task queue
+        notifyQueuedTasksAboutDropAndClear('agent shutting down');
         // Cleanup event forwarders before stopping agent
         cleanupAgentEventForwarding();
         // Stop CipherAgent first