byterover-cli 1.0.5 → 1.2.0

package/dist/infra/connectors/mcp/toml-mcp-config-writer.js

@@ -0,0 +1,134 @@
+/**
+ * Boundary markers for managed ByteRover MCP sections in TOML files.
+ */
+export const BRV_MCP_TOML_MARKERS = {
+    END: '# END BYTEROVER MCP',
+    START: '# BEGIN BYTEROVER MCP',
+};
+/**
+ * Convert a JavaScript object to TOML format for MCP server config.
+ * Only handles simple key-value pairs and arrays (no nested objects).
+ */
+function toTomlSection(sectionName, config) {
+    const lines = [`[${sectionName}]`];
+    for (const [key, value] of Object.entries(config)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (typeof value === 'string') {
+            lines.push(`${key} = "${value}"`);
+        }
+        else if (typeof value === 'number' || typeof value === 'boolean') {
+            lines.push(`${key} = ${value}`);
+        }
+        else if (Array.isArray(value)) {
+            const arrayStr = value.map((v) => (typeof v === 'string' ? `"${v}"` : String(v))).join(', ');
+            lines.push(`${key} = [${arrayStr}]`);
+        }
+        // Skip nested objects for simplicity
+    }
+    return lines.join('\n');
+}
+/**
+ * MCP config writer for TOML format files.
+ * Uses marker-based insertion/replacement similar to rules connector.
+ */
+export class TomlMcpConfigWriter {
+    fileService;
+    serverName;
+    constructor(options) {
+        this.fileService = options.fileService;
+        this.serverName = options.serverName;
+    }
+    async exists(filePath) {
+        const fileExists = await this.fileService.exists(filePath);
+        if (!fileExists) {
+            return { fileExists: false, serverExists: false };
+        }
+        try {
+            const content = await this.fileService.read(filePath);
+            const hasMarkers = content.includes(BRV_MCP_TOML_MARKERS.START) && content.includes(BRV_MCP_TOML_MARKERS.END);
+            return {
+                fileExists: true,
+                serverExists: hasMarkers,
+            };
+        }
+        catch {
+            return { fileExists: true, serverExists: false };
+        }
+    }
+    async remove(filePath) {
+        const fileExists = await this.fileService.exists(filePath);
+        if (!fileExists) {
+            return false;
+        }
+        const content = await this.fileService.read(filePath);
+        const hasMarkers = content.includes(BRV_MCP_TOML_MARKERS.START) && content.includes(BRV_MCP_TOML_MARKERS.END);
+        if (!hasMarkers) {
+            return false;
+        }
+        const newContent = this.removeMarkerSection(content);
+        // eslint-disable-next-line unicorn/prefer-ternary
+        if (newContent.trim() === '') {
+            await this.fileService.delete(filePath);
+        }
+        else {
+            await this.fileService.write(newContent, filePath, 'overwrite');
+        }
+        return true;
+    }
+    async write(filePath, serverConfig) {
+        const fileExists = await this.fileService.exists(filePath);
+        const mcpSection = this.buildMcpSection(serverConfig);
+        if (!fileExists) {
+            await this.fileService.write(mcpSection, filePath, 'overwrite');
+            return;
+        }
+        const content = await this.fileService.read(filePath);
+        const hasMarkers = content.includes(BRV_MCP_TOML_MARKERS.START) && content.includes(BRV_MCP_TOML_MARKERS.END);
+        if (hasMarkers) {
+            // Replace existing section
+            const newContent = this.replaceMarkerSection(content, mcpSection);
+            await this.fileService.write(newContent, filePath, 'overwrite');
+        }
+        else {
+            // Append to file
+            const newContent = content.trimEnd() + '\n\n' + mcpSection;
+            await this.fileService.write(newContent, filePath, 'overwrite');
+        }
+    }
+    /**
+     * Build the MCP section with markers.
+     */
+    buildMcpSection(serverConfig) {
+        const tomlContent = toTomlSection(`mcp_servers.${this.serverName}`, serverConfig);
+        return `${BRV_MCP_TOML_MARKERS.START}\n${tomlContent}\n${BRV_MCP_TOML_MARKERS.END}`;
+    }
+    /**
+     * Remove the section between markers (inclusive).
+     */
+    removeMarkerSection(content) {
+        const startIndex = content.indexOf(BRV_MCP_TOML_MARKERS.START);
+        const endIndex = content.indexOf(BRV_MCP_TOML_MARKERS.END);
+        if (startIndex === -1 || endIndex === -1) {
+            return content;
+        }
+        const before = content.slice(0, startIndex);
+        const after = content.slice(endIndex + BRV_MCP_TOML_MARKERS.END.length);
+        // Clean up extra newlines
+        return (before + after).replaceAll(/\n{3,}/g, '\n\n').trim();
+    }
+    /**
+     * Replace the section between markers with new content.
+     */
+    replaceMarkerSection(content, newSection) {
+        const startIndex = content.indexOf(BRV_MCP_TOML_MARKERS.START);
+        const endIndex = content.indexOf(BRV_MCP_TOML_MARKERS.END);
+        if (startIndex === -1 || endIndex === -1) {
+            return content;
+        }
+        const before = content.slice(0, startIndex);
+        const after = content.slice(endIndex + BRV_MCP_TOML_MARKERS.END.length);
+        return before + newSection + after;
+    }
+}

package/dist/infra/{rule → connectors/rules}/legacy-rule-detector.d.ts

@@ -1,5 +1,5 @@
-import type { Agent } from '../../core/domain/entities/agent.js';
-import type { ILegacyRuleDetector, LegacyRuleDetectionResult } from '../../core/interfaces/i-legacy-rule-detector.js';
+import type { Agent } from '../../../core/domain/entities/agent.js';
+import type { ILegacyRuleDetector, LegacyRuleDetectionResult } from '../../../core/interfaces/i-legacy-rule-detector.js';
 export declare class LegacyRuleDetector implements ILegacyRuleDetector {
     private static readonly SECTION_SEPARATOR_PATTERN;
     private static readonly WORKFLOW_HEADER_PATTERN;

package/dist/infra/{rule → connectors/rules}/legacy-rule-detector.js

@@ -1,4 +1,4 @@
-import { BRV_RULE_TAG } from './constants.js';
+import { BRV_RULE_TAG } from '../shared/constants.js';
 export class LegacyRuleDetector {
     static SECTION_SEPARATOR_PATTERN = /^---\s*$/;
     static WORKFLOW_HEADER_PATTERN = /^#\sWorkflow Instruction$/;

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

@@ -0,0 +1,95 @@
+import type { WriteMode } from '../../../core/interfaces/i-file-service.js';
+/**
+ * Configuration for agent-specific rule files.
+ */
+export type RulesConnectorConfig = {
+    /**
+     * The file path where the agent's rules should be written.
+     */
+    filePath: string;
+    /**
+     * The write mode to use when writing the rule file.
+     */
+    writeMode: WriteMode;
+};
+/**
+ * Mapping of agents to their rule file configurations.
+ */
+export declare const RULES_CONNECTOR_CONFIGS: {
+    readonly Amp: {
+        readonly filePath: "AGENTS.md";
+        readonly writeMode: "append";
+    };
+    readonly 'Augment Code': {
+        readonly filePath: ".augment/rules/agent-context.md";
+        readonly writeMode: "overwrite";
+    };
+    readonly 'Claude Code': {
+        readonly filePath: "CLAUDE.md";
+        readonly writeMode: "append";
+    };
+    readonly Cline: {
+        readonly filePath: ".clinerules/agent-context.md";
+        readonly writeMode: "overwrite";
+    };
+    readonly Codex: {
+        readonly filePath: "AGENTS.md";
+        readonly writeMode: "append";
+    };
+    readonly Cursor: {
+        readonly filePath: ".cursor/rules/agent-context.mdc";
+        readonly writeMode: "overwrite";
+    };
+    readonly 'Gemini CLI': {
+        readonly filePath: "GEMINI.md";
+        readonly writeMode: "append";
+    };
+    readonly 'Github Copilot': {
+        readonly filePath: ".github/copilot-instructions.md";
+        readonly writeMode: "append";
+    };
+    readonly Junie: {
+        readonly filePath: ".junie/guidelines.md";
+        readonly writeMode: "append";
+    };
+    readonly 'Kilo Code': {
+        readonly filePath: ".kilocode/rules/agent-context.md";
+        readonly writeMode: "overwrite";
+    };
+    readonly Kiro: {
+        readonly filePath: ".kiro/steering/agent-context.md";
+        readonly writeMode: "overwrite";
+    };
+    readonly Qoder: {
+        readonly filePath: ".qoder/rules/agent-context.md";
+        readonly writeMode: "overwrite";
+    };
+    readonly 'Qwen Code': {
+        readonly filePath: "QWEN.md";
+        readonly writeMode: "append";
+    };
+    readonly 'Roo Code': {
+        readonly filePath: ".roo/rules/agent-context.md";
+        readonly writeMode: "overwrite";
+    };
+    readonly 'Trae.ai': {
+        readonly filePath: "project_rules.md";
+        readonly writeMode: "append";
+    };
+    readonly Warp: {
+        readonly filePath: "WARP.md";
+        readonly writeMode: "append";
+    };
+    readonly Windsurf: {
+        readonly filePath: ".windsurf/rules/agent-context.md";
+        readonly writeMode: "overwrite";
+    };
+    readonly Zed: {
+        readonly filePath: "agent-context.rules";
+        readonly writeMode: "overwrite";
+    };
+};
+/**
+ * Type for agents that have rules connector configurations.
+ */
+export type RulesSupportedAgent = keyof typeof RULES_CONNECTOR_CONFIGS;

package/dist/infra/{rule/agent-rule-config.js → connectors/rules/rules-connector-config.js}

@@ -1,13 +1,13 @@
 /**
  * Mapping of agents to their rule file configurations.
  */
-export const AGENT_RULE_CONFIGS = {
+export const RULES_CONNECTOR_CONFIGS = {
     Amp: {
         filePath: 'AGENTS.md',
         writeMode: 'append',
     },
     'Augment Code': {
-        filePath: '.augment/rules/agent-context-engineering.md',
+        filePath: '.augment/rules/agent-context.md',
         writeMode: 'overwrite',
     },
     'Claude Code': {
@@ -15,7 +15,7 @@ export const AGENT_RULE_CONFIGS = {
         writeMode: 'append',
     },
     Cline: {
-        filePath: '.clinerules/agent-context-engineering.md',
+        filePath: '.clinerules/agent-context.md',
         writeMode: 'overwrite',
     },
     Codex: {
@@ -23,7 +23,7 @@ export const AGENT_RULE_CONFIGS = {
         writeMode: 'append',
     },
     Cursor: {
-        filePath: '.cursor/rules/agent-context-engineering.mdc',
+        filePath: '.cursor/rules/agent-context.mdc',
         writeMode: 'overwrite',
     },
     'Gemini CLI': {
@@ -39,15 +39,15 @@ export const AGENT_RULE_CONFIGS = {
         writeMode: 'append',
     },
     'Kilo Code': {
-        filePath: '.kilocode/rules/agent-context-engineering.md',
+        filePath: '.kilocode/rules/agent-context.md',
         writeMode: 'overwrite',
     },
     Kiro: {
-        filePath: '.kiro/steering/agent-context-engineering.md',
+        filePath: '.kiro/steering/agent-context.md',
         writeMode: 'overwrite',
     },
     Qoder: {
-        filePath: '.qoder/rules/agent-context-engineering.md',
+        filePath: '.qoder/rules/agent-context.md',
         writeMode: 'overwrite',
     },
     'Qwen Code': {
@@ -55,7 +55,7 @@ export const AGENT_RULE_CONFIGS = {
         writeMode: 'append',
     },
     'Roo Code': {
-        filePath: '.roo/rules/agent-context-engineering.md',
+        filePath: '.roo/rules/agent-context.md',
         writeMode: 'overwrite',
     },
     'Trae.ai': {
@@ -67,11 +67,11 @@ export const AGENT_RULE_CONFIGS = {
         writeMode: 'append',
     },
     Windsurf: {
-        filePath: '.windsurf/rules/agent-context-engineering.md',
+        filePath: '.windsurf/rules/agent-context.md',
         writeMode: 'overwrite',
     },
     Zed: {
-        filePath: 'agent-context-engineering.rules',
+        filePath: 'agent-context.rules',
         writeMode: 'overwrite',
     },
 };

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

@@ -0,0 +1,34 @@
+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 { IRuleTemplateService } from '../../../core/interfaces/i-rule-template-service.js';
+/**
+ * Options for constructing RulesConnector.
+ */
+type RulesConnectorOptions = {
+    fileService: IFileService;
+    projectRoot: string;
+    templateService: IRuleTemplateService;
+};
+/**
+ * Connector that integrates BRV with coding agents via rule files.
+ * Manages the installation, uninstallation, and status of rule files.
+ */
+export declare class RulesConnector implements IConnector {
+    readonly type: ConnectorType;
+    private readonly fileService;
+    private readonly projectRoot;
+    private readonly ruleFileManager;
+    private readonly supportedAgents;
+    private readonly templateService;
+    constructor(options: RulesConnectorOptions);
+    getConfigPath(agent: Agent): string;
+    getSupportedAgents(): Agent[];
+    install(agent: Agent): Promise<ConnectorInstallResult>;
+    isSupported(agent: Agent): boolean;
+    status(agent: Agent): Promise<ConnectorStatus>;
+    uninstall(agent: Agent): Promise<ConnectorUninstallResult>;
+}
+export {};

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

@@ -0,0 +1,139 @@
+import path from 'node:path';
+import { AGENT_CONNECTOR_CONFIG } from '../../../core/domain/entities/agent.js';
+import { RuleFileManager } from '../shared/rule-file-manager.js';
+import { RULES_CONNECTOR_CONFIGS } from './rules-connector-config.js';
+/**
+ * Connector that integrates BRV with coding agents via rule files.
+ * Manages the installation, uninstallation, and status of rule files.
+ */
+export class RulesConnector {
+    type = 'rules';
+    fileService;
+    projectRoot;
+    ruleFileManager;
+    supportedAgents;
+    templateService;
+    constructor(options) {
+        this.fileService = options.fileService;
+        this.projectRoot = options.projectRoot;
+        this.templateService = options.templateService;
+        this.ruleFileManager = new RuleFileManager({
+            fileService: options.fileService,
+            projectRoot: options.projectRoot,
+        });
+        this.supportedAgents = Object.entries(AGENT_CONNECTOR_CONFIG)
+            .filter(([_, config]) => config.supported.includes(this.type))
+            .map(([agent]) => agent);
+    }
+    getConfigPath(agent) {
+        return RULES_CONNECTOR_CONFIGS[agent].filePath;
+    }
+    getSupportedAgents() {
+        return this.supportedAgents;
+    }
+    async install(agent) {
+        const config = RULES_CONNECTOR_CONFIGS[agent];
+        try {
+            const ruleContent = await this.templateService.generateRuleContent(agent, this.type);
+            // Write the rule content to the file
+            await this.ruleFileManager.install(config.filePath, config.writeMode, ruleContent);
+            return {
+                alreadyInstalled: false,
+                configPath: config.filePath,
+                message: `Rules connector installed for ${agent} (created ${config.filePath})`,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                alreadyInstalled: false,
+                configPath: config.filePath,
+                message: `Failed to install rules connector for ${agent}: ${error instanceof Error ? error.message : String(error)}`,
+                success: false,
+            };
+        }
+    }
+    isSupported(agent) {
+        return AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.type);
+    }
+    async status(agent) {
+        const config = RULES_CONNECTOR_CONFIGS[agent];
+        const fullPath = path.join(this.projectRoot, config.filePath);
+        try {
+            const { fileExists, hasMarkers } = await this.ruleFileManager.status(config.filePath);
+            if (!fileExists) {
+                return {
+                    configExists: false,
+                    configPath: config.filePath,
+                    installed: false,
+                };
+            }
+            const content = await this.fileService.read(fullPath);
+            const hasMcpTools = content.includes('brv-query') || content.includes('brv-curate');
+            // For overwrite files, any BRV content means installed
+            // For append files, need both markers and agent tag
+            const installed = hasMarkers && !hasMcpTools;
+            return {
+                configExists: true,
+                configPath: config.filePath,
+                installed,
+            };
+        }
+        catch (error) {
+            return {
+                configExists: true,
+                configPath: config.filePath,
+                error: error instanceof Error ? error.message : String(error),
+                installed: false,
+            };
+        }
+    }
+    async uninstall(agent) {
+        const config = RULES_CONNECTOR_CONFIGS[agent];
+        try {
+            const { fileExists, hasLegacyTag, hasMarkers } = await this.ruleFileManager.status(config.filePath);
+            if (!fileExists) {
+                return {
+                    configPath: config.filePath,
+                    message: `Rule file does not exist: ${config.filePath}`,
+                    success: true,
+                    wasInstalled: false,
+                };
+            }
+            if (!hasMarkers) {
+                if (!hasLegacyTag) {
+                    return {
+                        configPath: config.filePath,
+                        message: `Rules connector is not installed for ${agent}`,
+                        success: true,
+                        wasInstalled: false,
+                    };
+                }
+                // Legacy format detected - cannot safely uninstall
+                return {
+                    configPath: config.filePath,
+                    message: `Legacy rules detected for ${agent}. Please manually remove the old rules section.`,
+                    success: false,
+                    wasInstalled: true,
+                };
+            }
+            const result = await this.ruleFileManager.uninstall(config.filePath, config.writeMode);
+            return {
+                configPath: config.filePath,
+                message: result.wasInstalled
+                    ? `Rules connector uninstalled for ${agent}`
+                    : `Rules connector is not installed for ${agent}`,
+                success: true,
+                wasInstalled: result.wasInstalled,
+            };
+        }
+        catch (error) {
+            return {
+                configPath: config.filePath,
+                message: `Failed to uninstall rules connector for ${agent}: ${error instanceof Error ? error.message : String(error)}`,
+                success: false,
+                wasInstalled: true,
+            };
+        }
+    }
+}

package/dist/infra/connectors/shared/rule-file-manager.d.ts

@@ -0,0 +1,72 @@
+import type { IFileService, WriteMode } from '../../../core/interfaces/i-file-service.js';
+/**
+ * Result of a rule file installation operation.
+ */
+export type RuleFileInstallResult = {
+    /** Whether the content was newly installed (false if replaced existing) */
+    isNew: boolean;
+    /** Whether the operation succeeded */
+    success: boolean;
+};
+/**
+ * Result of a rule file uninstallation operation.
+ */
+export type RuleFileUninstallResult = {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Whether there was content to remove */
+    wasInstalled: boolean;
+};
+/**
+ * Result of a rule file status check.
+ */
+export type RuleFileStatusResult = {
+    /** Whether the file exists */
+    fileExists: boolean;
+    /** Whether the file contains legacy BRV tag (without markers) */
+    hasLegacyTag: boolean;
+    /** Whether the file contains BRV markers */
+    hasMarkers: boolean;
+};
+/**
+ * Manages rule file operations including installation, uninstallation,
+ * and marker section manipulation.
+ *
+ * This class centralizes the logic for working with rule files that use
+ * BRV markers to delimit managed content sections.
+ */
+export declare class RuleFileManager {
+    private readonly fileService;
+    private readonly projectRoot;
+    constructor(options: {
+        fileService: IFileService;
+        projectRoot: string;
+    });
+    /**
+     * Install rule content into a file.
+     *
+     * @param filePath - Relative path to the rule file
+     * @param writeMode - How to write the content ('overwrite' or 'append')
+     * @param ruleContent - The rule content to write (should include markers)
+     */
+    install(filePath: string, writeMode: WriteMode, ruleContent: string): Promise<RuleFileInstallResult>;
+    /**
+     * Removes the section between BRV markers (inclusive).
+     */
+    removeMarkerSection(content: string): string;
+    /**
+     * Replaces the section between BRV markers with new content.
+     */
+    replaceMarkerSection(content: string, newRuleContent: string): string;
+    /**
+     * Check the status of rule content in a file.
+     */
+    status(filePath: string): Promise<RuleFileStatusResult>;
+    /**
+     * Uninstall rule content from a file.
+     *
+     * @param filePath - Relative path to the rule file
+     * @param writeMode - How the content was written ('overwrite' or 'append')
+     */
+    uninstall(filePath: string, writeMode: WriteMode): Promise<RuleFileUninstallResult>;
+}

package/dist/infra/connectors/shared/rule-file-manager.js

@@ -0,0 +1,119 @@
+import path from 'node:path';
+import { BRV_RULE_MARKERS, BRV_RULE_TAG } from './constants.js';
+/**
+ * Manages rule file operations including installation, uninstallation,
+ * and marker section manipulation.
+ *
+ * This class centralizes the logic for working with rule files that use
+ * BRV markers to delimit managed content sections.
+ */
+export class RuleFileManager {
+    fileService;
+    projectRoot;
+    constructor(options) {
+        this.fileService = options.fileService;
+        this.projectRoot = options.projectRoot;
+    }
+    /**
+     * Install rule content into a file.
+     *
+     * @param filePath - Relative path to the rule file
+     * @param writeMode - How to write the content ('overwrite' or 'append')
+     * @param ruleContent - The rule content to write (should include markers)
+     */
+    async install(filePath, writeMode, ruleContent) {
+        const fullPath = path.join(this.projectRoot, filePath);
+        const exists = await this.fileService.exists(fullPath);
+        if (exists) {
+            const content = await this.fileService.read(fullPath);
+            const hasMarkers = content.includes(BRV_RULE_MARKERS.START) && content.includes(BRV_RULE_MARKERS.END);
+            if (writeMode === 'overwrite') {
+                await this.fileService.write(ruleContent, fullPath, 'overwrite');
+            }
+            else if (hasMarkers) {
+                // Replace existing markers section
+                const newContent = this.replaceMarkerSection(content, ruleContent);
+                await this.fileService.write(newContent, fullPath, 'overwrite');
+            }
+            else {
+                // Append to file
+                await this.fileService.write(ruleContent, fullPath, 'append');
+            }
+            return { isNew: !hasMarkers, success: true };
+        }
+        // File doesn't exist - create it
+        await this.fileService.write(ruleContent, fullPath, 'overwrite');
+        return { isNew: true, success: true };
+    }
+    /**
+     * Removes the section between BRV markers (inclusive).
+     */
+    removeMarkerSection(content) {
+        const startIndex = content.indexOf(BRV_RULE_MARKERS.START);
+        const endIndex = content.indexOf(BRV_RULE_MARKERS.END);
+        if (startIndex === -1 || endIndex === -1) {
+            return content;
+        }
+        const before = content.slice(0, startIndex);
+        const after = content.slice(endIndex + BRV_RULE_MARKERS.END.length);
+        // Clean up extra newlines
+        return (before + after).replaceAll(/\n{3,}/g, '\n\n').trim();
+    }
+    /**
+     * Replaces the section between BRV markers with new content.
+     */
+    replaceMarkerSection(content, newRuleContent) {
+        const startIndex = content.indexOf(BRV_RULE_MARKERS.START);
+        const endIndex = content.indexOf(BRV_RULE_MARKERS.END);
+        if (startIndex === -1 || endIndex === -1) {
+            return content;
+        }
+        const before = content.slice(0, startIndex);
+        const after = content.slice(endIndex + BRV_RULE_MARKERS.END.length);
+        return before + newRuleContent + after;
+    }
+    /**
+     * Check the status of rule content in a file.
+     */
+    async status(filePath) {
+        const fullPath = path.join(this.projectRoot, filePath);
+        const fileExists = await this.fileService.exists(fullPath);
+        if (!fileExists) {
+            return { fileExists: false, hasLegacyTag: false, hasMarkers: false };
+        }
+        const content = await this.fileService.read(fullPath);
+        const hasMarkers = content.includes(BRV_RULE_MARKERS.START) && content.includes(BRV_RULE_MARKERS.END);
+        const hasLegacyTag = content.includes(BRV_RULE_TAG);
+        return { fileExists: true, hasLegacyTag, hasMarkers };
+    }
+    /**
+     * Uninstall rule content from a file.
+     *
+     * @param filePath - Relative path to the rule file
+     * @param writeMode - How the content was written ('overwrite' or 'append')
+     */
+    async uninstall(filePath, writeMode) {
+        const fullPath = path.join(this.projectRoot, filePath);
+        const exists = await this.fileService.exists(fullPath);
+        if (!exists) {
+            return { success: true, wasInstalled: false };
+        }
+        const content = await this.fileService.read(fullPath);
+        const hasMarkers = content.includes(BRV_RULE_MARKERS.START) && content.includes(BRV_RULE_MARKERS.END);
+        if (!hasMarkers) {
+            return { success: true, wasInstalled: false };
+        }
+        if (writeMode === 'overwrite') {
+            // For dedicated files, delete the entire file
+            await this.fileService.delete(fullPath);
+        }
+        else {
+            // For shared files, remove only the BRV section
+            const newContent = this.removeMarkerSection(content);
+            await (newContent.trim() === ''
+                ? this.fileService.delete(fullPath)
+                : this.fileService.write(newContent, fullPath, 'overwrite'));
+        }
+        return { success: true, wasInstalled: true };
+    }
+}