byterover-cli 1.5.0 → 1.7.0

package/dist/server/core/interfaces/connectors/connector-types.d.ts

@@ -0,0 +1,83 @@
+import type { Agent } from '../../domain/entities/agent.js';
+import type { ConnectorType } from '../../domain/entities/connector-type.js';
+/**
+ * Instructions for manual MCP setup when automatic configuration is not possible.
+ */
+export type ManualInstallInstructions = {
+    /** The config content to copy (JSON or TOML formatted) */
+    configContent: string;
+    /** Guide URL or step-by-step instructions */
+    guide: string;
+};
+/**
+ * Result of a connector installation operation.
+ */
+export type ConnectorInstallResult = {
+    /** Whether the connector was already installed (no action taken) */
+    alreadyInstalled: boolean;
+    /** Path to the configuration/rule file */
+    configPath: string;
+    /** Instructions for manual setup (present when requiresManualSetup is true) */
+    manualInstructions?: ManualInstallInstructions;
+    /** Human-readable message describing the result */
+    message: string;
+    /** Whether this requires manual setup by the user */
+    requiresManualSetup?: boolean;
+    /** Whether the installation was successful */
+    success: boolean;
+};
+/**
+ * Result of a connector uninstallation operation.
+ */
+export type ConnectorUninstallResult = {
+    /** Path to the configuration/rule file */
+    configPath: string;
+    /** Human-readable message describing the result */
+    message: string;
+    /** Whether the uninstallation was successful */
+    success: boolean;
+    /** Whether the connector was installed before uninstall */
+    wasInstalled: boolean;
+};
+/**
+ * Status of a connector installation.
+ */
+export type ConnectorStatus = {
+    /** Whether the configuration/rule file exists */
+    configExists: boolean;
+    /** Path to the configuration/rule file */
+    configPath: string;
+    /** Error message if status check failed */
+    error?: string;
+    /** Whether the connector is currently installed */
+    installed: boolean;
+};
+/**
+ * Result of migrating an orphaned connector for an agent
+ * that no longer supports the connector type.
+ */
+export type OrphanedConnectorMigrationResult = {
+    /** The agent that had an orphaned connector */
+    agent: Agent;
+    /** Path to the configuration that was cleaned up */
+    configPath: string;
+    /** Whether the cleanup was successful */
+    success: boolean;
+};
+/**
+ * Result of switching from one connector type to another.
+ */
+export type ConnectorSwitchResult = {
+    /** The connector type that was uninstalled (if any) */
+    fromType: ConnectorType | null;
+    /** Result of the installation operation */
+    installResult: ConnectorInstallResult;
+    /** Human-readable message describing the result */
+    message: string;
+    /** Whether the switch was successful */
+    success: boolean;
+    /** The connector type that was installed */
+    toType: ConnectorType;
+    /** Result of the uninstallation operation (if switching) */
+    uninstallResult?: ConnectorUninstallResult;
+};

package/dist/server/core/interfaces/connectors/i-connector-manager.d.ts

@@ -0,0 +1,79 @@
+import type { Agent } from '../../domain/entities/agent.js';
+import type { ConnectorType } from '../../domain/entities/connector-type.js';
+import type { ConnectorInstallResult, ConnectorStatus, ConnectorSwitchResult, OrphanedConnectorMigrationResult } from './connector-types.js';
+import type { IConnector } from './i-connector.js';
+/**
+ * Interface for managing connectors.
+ * Acts as a factory for creating connectors and orchestrates connector operations.
+ */
+export interface IConnectorManager {
+    /**
+     * Get all installed connectors across all agents.
+     * Iterates over all agents and checks which have connectors installed.
+     *
+     * @returns Map of agent to installed connector type (only includes agents with connectors)
+     */
+    getAllInstalledConnectors(): Promise<Map<Agent, ConnectorType>>;
+    /**
+     * Get a connector instance for the specified type.
+     *
+     * @param type - The connector type
+     * @returns The connector instance
+     * @throws Error if the connector type is not supported
+     */
+    getConnector(type: ConnectorType): IConnector;
+    /**
+     * Get the default connector type for the specified agent.
+     *
+     * @param agent - The agent to get the default connector for
+     * @returns The default connector type
+     */
+    getDefaultConnectorType(agent: Agent): ConnectorType;
+    /**
+     * Get the currently installed connector type for the specified agent.
+     * Checks all connector types and returns the first one that is installed.
+     *
+     * @param agent - The agent to check
+     * @returns The installed connector type, or null if none installed
+     */
+    getInstalledConnectorType(agent: Agent): Promise<ConnectorType | null>;
+    /**
+     * Get list of connector types that support the specified agent.
+     *
+     * @param agent - The agent to check
+     * @returns Array of supported connector types
+     */
+    getSupportedConnectorTypes(agent: Agent): ConnectorType[];
+    /**
+     * Install the default connector for the specified agent.
+     *
+     * @param agent - The agent to install for
+     * @returns Installation result
+     */
+    installDefault(agent: Agent): Promise<ConnectorInstallResult>;
+    /**
+     * Detect and clean up orphaned connectors for agents that no longer support them.
+     * Returns results only for agents where orphaned configs were found and cleaned.
+     *
+     * @returns Array of migration results for agents that were cleaned up
+     */
+    migrateOrphanedConnectors(): Promise<OrphanedConnectorMigrationResult[]>;
+    /**
+     * Get the status of a specific connector type for an agent.
+     *
+     * @param type - The connector type
+     * @param agent - The agent to check
+     * @returns Connector status
+     */
+    status(type: ConnectorType, agent: Agent): Promise<ConnectorStatus>;
+    /**
+     * Switch from one connector type to another for the specified agent.
+     * Uninstalls the current connector (if any) and installs the new one.
+     * This ensures only one connector is active per agent.
+     *
+     * @param agent - The agent to switch connectors for
+     * @param toType - The connector type to switch to
+     * @returns Switch result with details of uninstall and install operations
+     */
+    switchConnector(agent: Agent, toType: ConnectorType): Promise<ConnectorSwitchResult>;
+}

package/dist/server/core/interfaces/connectors/i-connector.d.ts

@@ -0,0 +1,63 @@
+import type { Agent } from '../../domain/entities/agent.js';
+import type { ConnectorType } from '../../domain/entities/connector-type.js';
+import type { ConnectorInstallResult, ConnectorStatus, ConnectorUninstallResult } from './connector-types.js';
+/**
+ * Options for connector operations that may need to bypass support checks.
+ */
+export type ConnectorOperationOptions = {
+    /** When true, bypasses the isSupported() check. Used for migration of orphaned connectors. */
+    force?: boolean;
+};
+/**
+ * Interface for a connector that integrates BRV with a coding agent.
+ * Each connector type (rules, hook, mcp) has its own implementation.
+ */
+export interface IConnector {
+    /** The type of this connector */
+    readonly connectorType: ConnectorType;
+    /**
+     * Get the path to the configuration/rule file for a specific agent.
+     *
+     * @param agent - The agent to get the config path for
+     * @returns The path relative to project root
+     */
+    getConfigPath(agent: Agent): string;
+    /**
+     * Get list of agents supported by this connector type.
+     *
+     * @returns Array of supported agent names
+     */
+    getSupportedAgents(): Agent[];
+    /**
+     * Install the connector for the specified agent.
+     * If already installed, returns alreadyInstalled: true.
+     *
+     * @param agent - The coding agent to install for
+     * @returns Installation result with success status and message
+     */
+    install(agent: Agent): Promise<ConnectorInstallResult>;
+    /**
+     * Check if this connector supports the specified agent.
+     *
+     * @param agent - The agent to check
+     * @returns True if the agent is supported
+     */
+    isSupported(agent: Agent): boolean;
+    /**
+     * Check the installation status for the specified agent.
+     *
+     * @param agent - The coding agent to check status for
+     * @param options - Optional settings; use { force: true } to bypass isSupported() check
+     * @returns Status including installed state and config file existence
+     */
+    status(agent: Agent, options?: ConnectorOperationOptions): Promise<ConnectorStatus>;
+    /**
+     * Uninstall the connector for the specified agent.
+     * Only removes BRV content, preserves user's other configurations.
+     *
+     * @param agent - The coding agent to uninstall from
+     * @param options - Optional settings; use { force: true } to bypass isSupported() check
+     * @returns Uninstallation result with success status and message
+     */
+    uninstall(agent: Agent, options?: ConnectorOperationOptions): Promise<ConnectorUninstallResult>;
+}

package/dist/server/core/interfaces/context-tree/i-context-file-reader.d.ts

@@ -0,0 +1,35 @@
+import type { Narrative, RawConcept } from '../../domain/knowledge/markdown-writer.js';
+/**
+ * Represents the content of a context file with extracted metadata.
+ */
+export type ContextFileContent = {
+    /** The raw content of the file */
+    content: string;
+    narrative?: Narrative;
+    /** Relative path within the context tree (e.g., "structure/context.md") */
+    path: string;
+    rawConcept?: RawConcept;
+    /** Title extracted from the first heading, or the relative path if no heading found */
+    title: string;
+};
+/**
+ * Interface for reading context files and extracting their metadata.
+ * Used to prepare context files for the CoGit API.
+ */
+export interface IContextFileReader {
+    /**
+     * Reads a single context file and extracts its metadata.
+     * @param relativePath - Relative path within the context tree (e.g., "structure/context.md")
+     * @param directory - Optional base directory (defaults to current working directory)
+     * @returns ContextFileContent if file exists and can be read, undefined otherwise
+     */
+    read(relativePath: string, directory?: string): Promise<ContextFileContent | undefined>;
+    /**
+     * Reads multiple context files and extracts their metadata.
+     * Files that cannot be read are silently skipped.
+     * @param relativePaths - Array of relative paths within the context tree
+     * @param directory - Optional base directory (defaults to current working directory)
+     * @returns Array of ContextFileContent for successfully read files
+     */
+    readMany(relativePaths: string[], directory?: string): Promise<ContextFileContent[]>;
+}

package/dist/server/core/interfaces/context-tree/i-context-tree-snapshot-service.d.ts

@@ -0,0 +1,36 @@
+import type { ContextTreeChanges, FileState } from '../../domain/entities/context-tree-snapshot.js';
+/**
+ * Interface for context tree snapshot operations.
+ * Provides change tracking by comparing current file states against saved snapshots.
+ */
+export interface IContextTreeSnapshotService {
+    /**
+     * Compares current context tree state against the saved snapshot.
+     * @param directory - Optional base directory (defaults to current working directory)
+     * @returns Changes detected (added, modified, deleted files)
+     */
+    getChanges(directory?: string): Promise<ContextTreeChanges>;
+    /**
+     * Gets the current state of all files in the context tree.
+     * @param directory - Optional base directory (defaults to current working directory)
+     * @returns Map of relative file paths to their current state (hash and size)
+     */
+    getCurrentState(directory?: string): Promise<Map<string, FileState>>;
+    /**
+     * Checks if a snapshot file exists.
+     * @param directory - Optional base directory (defaults to current working directory)
+     * @returns True if snapshot exists
+     */
+    hasSnapshot(directory?: string): Promise<boolean>;
+    /**
+     * Creates an empty snapshot (no files tracked).
+     * Use this to establish a baseline where all current files will appear as "added".
+     * @param directory - Optional base directory (defaults to current working directory)
+     */
+    initEmptySnapshot(directory?: string): Promise<void>;
+    /**
+     * Creates or updates the snapshot from current context tree state.
+     * @param directory - Optional base directory (defaults to current working directory)
+     */
+    saveSnapshot(directory?: string): Promise<void>;
+}

package/dist/server/core/interfaces/context-tree/i-context-tree-writer-service.d.ts

@@ -0,0 +1,32 @@
+import type { CogitSnapshotFile } from '../../domain/entities/cogit-snapshot-file.js';
+/**
+ * Result of a sync operation.
+ */
+export type SyncResult = {
+    added: string[];
+    deleted: string[];
+    edited: string[];
+};
+/**
+ * Parameters for the sync operation.
+ */
+export type SyncParams = {
+    directory?: string;
+    files: readonly CogitSnapshotFile[];
+};
+/**
+ * Interface for context tree writer operations.
+ * This should be used to process pull response from Cogit.
+ * Provides file synchronization capabilities for the context tree.
+ */
+export interface IContextTreeWriterService {
+    /**
+     * Synchronizes the context tree with the provided files.
+     * - Files present in params but not locally are added
+     * - Files present in both are edited
+     * - Files present locally but not in params are deleted
+     * @param params - Sync parameters including files and optional directory
+     * @returns Result containing arrays of added, edited, and deleted file paths
+     */
+    sync: (params: SyncParams) => Promise<SyncResult>;
+}

package/dist/server/core/interfaces/executor/i-curate-executor.d.ts

@@ -0,0 +1,36 @@
+import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+/**
+ * Options for executing curate with an injected agent.
+ * Agent uses its default session (Single-Session pattern).
+ */
+export interface CurateExecuteOptions {
+    /** Client's working directory for file validation (defaults to process.cwd() if not provided) */
+    clientCwd?: string;
+    /** Context content to curate */
+    content: string;
+    /** Optional file paths for --files flag */
+    files?: string[];
+    /** Task ID for event routing (required for concurrent task isolation) */
+    taskId: string;
+}
+/**
+ * ICurateExecutor - Executes curate tasks with an injected CipherAgent.
+ *
+ * This is NOT a UseCase (which orchestrates business logic).
+ * It's an Executor that wraps agent.execute() with curate-specific options.
+ *
+ * Architecture:
+ * - TaskProcessor injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Executor focuses solely on curate execution
+ */
+export interface ICurateExecutor {
+    /**
+     * Execute curate with an injected agent.
+     *
+     * @param agent - Long-lived CipherAgent (managed by caller)
+     * @param options - Execution options (content, file references)
+     * @returns Result string from agent execution
+     */
+    executeWithAgent(agent: ICipherAgent, options: CurateExecuteOptions): Promise<string>;
+}

package/dist/server/core/interfaces/executor/i-folder-pack-executor.d.ts

@@ -0,0 +1,39 @@
+import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+/**
+ * Options for executing folder pack with an injected agent.
+ * Agent uses its default session (Single-Session pattern).
+ */
+export interface FolderPackExecuteOptions {
+    /** Client's working directory for resolving relative paths */
+    clientCwd?: string;
+    /** Optional context to guide the analysis */
+    content?: string;
+    /** Folder path to pack (relative to clientCwd or absolute) */
+    folderPath: string;
+    /** Task ID for event routing (required for concurrent task isolation) */
+    taskId: string;
+}
+/**
+ * IFolderPackExecutor - Executes folder pack + curate tasks with an injected CipherAgent.
+ *
+ * This executor:
+ * 1. Packs the folder using FolderPackService
+ * 2. Generates XML from the pack result
+ * 3. Builds a prompt for the agent to analyze and curate the folder
+ * 4. Executes with the agent
+ *
+ * Architecture:
+ * - TaskProcessor injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Executor focuses solely on folder pack + curate execution
+ */
+export interface IFolderPackExecutor {
+    /**
+     * Execute folder pack + curate with an injected agent.
+     *
+     * @param agent - Long-lived CipherAgent (managed by caller)
+     * @param options - Execution options (folderPath, context)
+     * @returns Result string from agent execution
+     */
+    executeWithAgent(agent: ICipherAgent, options: FolderPackExecuteOptions): Promise<string>;
+}

package/dist/server/core/interfaces/executor/i-query-executor.d.ts

@@ -0,0 +1,32 @@
+import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+/**
+ * Options for executing query with an injected agent.
+ * Agent uses its default session (Single-Session pattern).
+ */
+export interface QueryExecuteOptions {
+    /** Query content to search in context tree */
+    query: string;
+    /** Task ID for event routing (required for concurrent task isolation) */
+    taskId: string;
+}
+/**
+ * IQueryExecutor - Executes query tasks with an injected CipherAgent.
+ *
+ * This is NOT a UseCase (which orchestrates business logic).
+ * It's an Executor that wraps agent.execute() with query-specific options.
+ *
+ * Architecture:
+ * - TaskProcessor injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Executor focuses solely on query execution
+ */
+export interface IQueryExecutor {
+    /**
+     * Execute query with an injected agent.
+     *
+     * @param agent - Long-lived CipherAgent (managed by caller)
+     * @param options - Execution options (query)
+     * @returns Result string from agent execution
+     */
+    executeWithAgent(agent: ICipherAgent, options: QueryExecuteOptions): Promise<string>;
+}

package/dist/server/core/interfaces/executor/index.d.ts

@@ -0,0 +1,3 @@
+export * from './i-curate-executor.js';
+export * from './i-folder-pack-executor.js';
+export * from './i-query-executor.js';

package/dist/server/core/interfaces/executor/index.js

@@ -0,0 +1,3 @@
+export * from './i-curate-executor.js';
+export * from './i-folder-pack-executor.js';
+export * from './i-query-executor.js';

package/dist/server/core/interfaces/noop-implementations.d.ts

@@ -0,0 +1,53 @@
+/**
+ * NoOp Implementations for Core Interfaces
+ *
+ * These are used by CoreProcess when creating UseCases for Transport mode.
+ * Transport mode receives auth/config directly and doesn't use these stores,
+ * so NoOp implementations are sufficient.
+ */
+import type { AuthToken } from '../domain/entities/auth-token.js';
+import type { BrvConfig } from '../domain/entities/brv-config.js';
+import type { EventName, PropertyDict } from '../domain/entities/event.js';
+import type { ITokenStore } from './auth/i-token-store.js';
+import type { ConfirmOptions, FileSelectorItem, FileSelectorOptions, InputOptions, ITerminal, SearchOptions, SelectOptions } from './services/i-terminal.js';
+import type { ITrackingService } from './services/i-tracking-service.js';
+import type { IProjectConfigStore } from './storage/i-project-config-store.js';
+/**
+ * NoOp Terminal - Does nothing, used for headless Transport mode.
+ */
+export declare class NoOpTerminal implements ITerminal {
+    actionStart(_message: string): void;
+    actionStop(_message?: string): void;
+    confirm(_options: ConfirmOptions): Promise<boolean>;
+    error(_message: string): void;
+    fileSelector(_options: FileSelectorOptions): Promise<FileSelectorItem | null>;
+    input(_options: InputOptions): Promise<string>;
+    log(_message?: string): void;
+    search<T>(_options: SearchOptions<T>): Promise<T>;
+    select<T>(_options: SelectOptions<T>): Promise<T>;
+    warn(_message: string): void;
+}
+/**
+ * NoOp Tracking Service - Does nothing, used for headless Transport mode.
+ */
+export declare class NoOpTrackingService implements ITrackingService {
+    track(_eventName: EventName, _properties?: PropertyDict): Promise<void>;
+}
+/**
+ * NoOp Token Store - Always returns undefined, used when Core loads auth separately.
+ * In Transport mode, auth is passed directly to UseCases.
+ */
+export declare class NoOpTokenStore implements ITokenStore {
+    clear(): Promise<void>;
+    load(): Promise<AuthToken | undefined>;
+    save(_token: AuthToken): Promise<void>;
+}
+/**
+ * NoOp Project Config Store - Always returns undefined, used when Core loads config separately.
+ * In Transport mode, brvConfig is passed directly to UseCases.
+ */
+export declare class NoOpProjectConfigStore implements IProjectConfigStore {
+    exists(_directory?: string): Promise<boolean>;
+    read(_directory?: string): Promise<BrvConfig | undefined>;
+    write(_config: BrvConfig, _directory?: string): Promise<void>;
+}

package/dist/server/core/interfaces/services/i-cogit-pull-service.d.ts

@@ -0,0 +1,23 @@
+import type { CogitSnapshot } from '../../domain/entities/cogit-snapshot.js';
+/**
+ * Parameters for pulling a snapshot from CoGit.
+ */
+export type PullParams = {
+    branch: string;
+    sessionKey: string;
+    spaceId: string;
+    teamId: string;
+};
+/**
+ * Interface for pulling context tree snapshots from the CoGit service.
+ * Retrieves the complete state of context files from a CoGit repository.
+ */
+export interface ICogitPullService {
+    /**
+     * Pulls the latest snapshot from the CoGit repository.
+     * @param params Pull parameters including auth and branch
+     * @returns CogitSnapshot containing files and metadata
+     * @throws Error if pull fails
+     */
+    pull: (params: PullParams) => Promise<CogitSnapshot>;
+}

package/dist/server/core/interfaces/services/i-cogit-push-service.d.ts

@@ -0,0 +1,27 @@
+import type { CogitPushContext } from '../../domain/entities/cogit-push-context.js';
+import type { CogitPushResponse } from '../../domain/entities/cogit-push-response.js';
+/**
+ * Parameters for pushing context files to CoGit.
+ */
+export type PushParams = {
+    accessToken: string;
+    branch: string;
+    contexts: CogitPushContext[];
+    sessionKey: string;
+    spaceId: string;
+    teamId: string;
+};
+/**
+ * Interface for pushing context files to the CoGit service.
+ * Handles the push operation to store context files in the CoGit repository.
+ */
+export interface ICogitPushService {
+    /**
+     * Pushes context files to the CoGit repository.
+     * Implements a two-request SHA flow to handle concurrent updates.
+     * @param params Push parameters including auth, branch, and context files
+     * @returns CogitPushResponse containing commit SHA and status
+     * @throws Error if push fails
+     */
+    push: (params: PushParams) => Promise<CogitPushResponse>;
+}

package/dist/server/core/interfaces/services/i-http-client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Configuration options for HTTP requests.
+ */
+export type HttpRequestConfig = {
+    headers?: Record<string, string>;
+    timeout?: number;
+};
+/**
+ * Interface for HTTP client operations.
+ * Provides abstraction over HTTP libraries (axios, fetch, etc.) following Clean Architecture principles.
+ *
+ * Implementations should handle:
+ * - Request configuration (headers, timeout)
+ * - Error handling and transformation
+ * - Response parsing
+ */
+export interface IHttpClient {
+    /**
+     * Performs an HTTP GET request.
+     * @param url The URL to request
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     */
+    get: <T>(url: string, config?: HttpRequestConfig) => Promise<T>;
+    /**
+     * Performs an HTTP POST request.
+     * @param url The URL to request
+     * @param data The data to send in the request body
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     */
+    post: <TResponse, TData = unknown>(url: string, data?: TData, config?: HttpRequestConfig) => Promise<TResponse>;
+    /**
+     * Performs an HTTP PUT request.
+     * @param url The URL to request
+     * @param data The data to send in the request body
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     */
+    put: <TResponse, TData = unknown>(url: string, data?: TData, config?: HttpRequestConfig) => Promise<TResponse>;
+}

package/dist/server/core/interfaces/services/i-legacy-rule-detector.d.ts

@@ -0,0 +1,56 @@
+import type { Agent } from '../../domain/entities/agent.js';
+/**
+ * Represents a reliably detected legacy ByteRover rule section.
+ */
+export type LegacyRuleMatch = {
+    /**
+     * Content of the detected section.
+     */
+    content: string;
+    /**
+     * Ending line number (1-indexed)
+     */
+    endLine: number;
+    /**
+     * Starting line number (1-indexed)
+     */
+    startLine: number;
+};
+/**
+ * Represents an uncertain detection where the footer was found but start couldn't be reliably determined.
+ */
+export type UncertainMatch = {
+    /**
+     * Line number where the footer tag was found (1-indexed).
+     */
+    footerLine: number;
+    /**
+     * Reason why the start couldn't be determined.
+     */
+    reason: string;
+};
+/**
+ * Result of detecting legacy ByteRover rules in a file.
+ */
+export type LegacyRuleDetectionResult = {
+    /**
+     * Reliably detected rule sections with known start and end positions.
+     */
+    reliableMatches: LegacyRuleMatch[];
+    /**
+     * Uncertain matches where only the footer was found.
+     */
+    uncertainMatches: UncertainMatch[];
+};
+/**
+ * Service for detecting legacy ByteRover rules (without boundary markers) in instruction files.
+ */
+export interface ILegacyRuleDetector {
+    /**
+     * Detects legacy ByteRover rule sections in file content.
+     * @param content The file content to analyze.
+     * @param agentName The agent name to look for in the footer tag.
+     * @returns Detection result with reliable and uncertain matches.
+     */
+    detectLegacyRules: (content: string, agentName: Agent) => LegacyRuleDetectionResult;
+}