byterover-cli 1.6.0 → 1.7.0

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

@@ -0,0 +1,72 @@
+import type { IFileService, WriteMode } from '../../../core/interfaces/services/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/server/infra/connectors/shared/template-service.d.ts

@@ -0,0 +1,27 @@
+import type { Agent } from '../../../core/domain/entities/agent.js';
+import type { ConnectorType } from '../../../core/domain/entities/connector-type.js';
+import type { IRuleTemplateService } from '../../../core/interfaces/services/i-rule-template-service.js';
+import type { ITemplateLoader } from '../../../core/interfaces/services/i-template-loader.js';
+/**
+ * Service for generating rule templates for different agents.
+ * Loads templates from external files and assembles them with agent-specific context.
+ */
+export declare class RuleTemplateService implements IRuleTemplateService {
+    private readonly templateLoader;
+    constructor(templateLoader: ITemplateLoader);
+    /**
+     * Generates rule content for the specified agent by loading and assembling templates.
+     * @param agent The agent for which to generate rules.
+     * @returns Promise resolving to the rule content as a string.
+     * @throws Error if templates cannot be loaded or assembled.
+     */
+    generateRuleContent(agent: Agent, type?: ConnectorType): Promise<string>;
+    /**
+     * Generates CLI mode content with full workflow and command reference.
+     */
+    private generateCliContent;
+    /**
+     * Generates MCP mode content with concise tool-focused instructions.
+     */
+    private generateMcpContent;
+}

package/dist/server/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 { ConnectorOperationOptions, IConnector } from '../../../core/interfaces/connectors/i-connector.js';
+import type { IFileService } from '../../../core/interfaces/services/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, options?: ConnectorOperationOptions): Promise<ConnectorStatus>;
+    uninstall(agent: Agent, options?: ConnectorOperationOptions): 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/server/infra/connectors/skill/skill-connector.js

@@ -0,0 +1,175 @@
+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, options) {
+        if (!options?.force && !this.isSupported(agent)) {
+            return {
+                configExists: false,
+                configPath: '',
+                error: `Skill connector does not support agent: ${agent}`,
+                installed: false,
+            };
+        }
+        if (!(agent in SKILL_CONNECTOR_CONFIGS)) {
+            return {
+                configExists: false,
+                configPath: '',
+                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, options) {
+        if (!options?.force && !this.isSupported(agent)) {
+            return {
+                configPath: '',
+                message: `Skill connector does not support agent: ${agent}`,
+                success: false,
+                wasInstalled: false,
+            };
+        }
+        if (!(agent in SKILL_CONNECTOR_CONFIGS)) {
+            return {
+                configPath: '',
+                message: `Skill connector has no config for agent: ${agent}`,
+                success: true,
+                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/server/infra/connectors/skill/skill-content-loader.d.ts

@@ -0,0 +1,18 @@
+import type { IFileService } from '../../../core/interfaces/services/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/server/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/server/infra/connectors/skill/ to src/server/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/server/infra/context-tree/file-context-file-reader.d.ts

@@ -0,0 +1,14 @@
+import type { ContextFileContent, IContextFileReader } from '../../core/interfaces/context-tree/i-context-file-reader.js';
+export type FileContextFileReaderConfig = {
+    baseDirectory?: string;
+};
+/**
+ * File-based implementation of IContextFileReader.
+ * Reads context.md files from the context tree and extracts their metadata.
+ */
+export declare class FileContextFileReader implements IContextFileReader {
+    private readonly config;
+    constructor(config?: FileContextFileReaderConfig);
+    read(relativePath: string, directory?: string): Promise<ContextFileContent | undefined>;
+    readMany(relativePaths: string[], directory?: string): Promise<ContextFileContent[]>;
+}

package/dist/server/infra/context-tree/file-context-tree-service.d.ts

@@ -0,0 +1,14 @@
+import type { IContextTreeService } from '../../core/interfaces/context-tree/i-context-tree-service.js';
+export type ContextTreeServiceConfig = {
+    baseDirectory?: string;
+};
+/**
+ * File-based implementation of IContextTreeService.
+ * Provides operations for managing the context tree structure.
+ */
+export declare class FileContextTreeService implements IContextTreeService {
+    private readonly config;
+    constructor(config?: ContextTreeServiceConfig);
+    exists(directory?: string): Promise<boolean>;
+    initialize(directory?: string): Promise<string>;
+}

package/dist/server/infra/context-tree/file-context-tree-snapshot-service.d.ts

@@ -0,0 +1,34 @@
+import type { IContextTreeSnapshotService } from '../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
+import { ContextTreeChanges, FileState } from '../../core/domain/entities/context-tree-snapshot.js';
+export type ContextTreeSnapshotServiceConfig = {
+    baseDirectory?: string;
+};
+/**
+ * File-based implementation of IContextTreeSnapshotService.
+ * Tracks context tree changes using content hashing.
+ */
+export declare class FileContextTreeSnapshotService implements IContextTreeSnapshotService {
+    private readonly config;
+    constructor(config?: ContextTreeSnapshotServiceConfig);
+    getChanges(directory?: string): Promise<ContextTreeChanges>;
+    getCurrentState(directory?: string): Promise<Map<string, FileState>>;
+    hasSnapshot(directory?: string): Promise<boolean>;
+    initEmptySnapshot(directory?: string): Promise<void>;
+    saveSnapshot(directory?: string): Promise<void>;
+    /**
+     * Computes SHA-256 hash of file content.
+     */
+    private computeHash;
+    /**
+     * Loads snapshot from file.
+     */
+    private loadSnapshot;
+    /**
+     * Processes a single file and adds it to the files map.
+     */
+    private processFile;
+    /**
+     * Recursively scans directory for files, excluding snapshot file.
+     */
+    private scanDirectory;
+}

package/dist/server/infra/context-tree/file-context-tree-writer-service.d.ts

@@ -0,0 +1,28 @@
+import type { IContextTreeSnapshotService } from '../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
+import type { IContextTreeWriterService, SyncParams, SyncResult } from '../../core/interfaces/context-tree/i-context-tree-writer-service.js';
+export type ContextTreeWriterServiceConfig = {
+    baseDirectory?: string;
+};
+export type ContextTreeWriterServiceDependencies = {
+    snapshotService: IContextTreeSnapshotService;
+};
+/**
+ * File-based implementation of IContextTreeWriterService.
+ * Synchronizes context tree files based on CoGit snapshot data.
+ */
+export declare class FileContextTreeWriterService implements IContextTreeWriterService {
+    private readonly config;
+    private readonly snapshotService;
+    constructor(dependencies: ContextTreeWriterServiceDependencies, config?: ContextTreeWriterServiceConfig);
+    sync(params: SyncParams): Promise<SyncResult>;
+    /**
+     * Builds a map of remote files with normalized paths.
+     * Filters out README.md at root level to match getCurrentState behavior.
+     */
+    private buildRemoteFilesMap;
+    /**
+     * Normalizes a file path by converting backslashes to forward slashes
+     * and removing leading slashes.
+     */
+    private normalizePath;
+}

package/dist/server/infra/context-tree/path-utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Path utilities for context tree operations.
+ *
+ * Provides cross-platform path normalization to ensure all context tree paths
+ * use forward slashes regardless of the operating system.
+ */
+export { normalizeForComparison as toUnixPath } from '../../../agent/infra/process/path-utils.js';

package/dist/server/infra/context-tree/path-utils.js

@@ -0,0 +1,7 @@
+/**
+ * Path utilities for context tree operations.
+ *
+ * Provides cross-platform path normalization to ensure all context tree paths
+ * use forward slashes regardless of the operating system.
+ */
+export { normalizeForComparison as toUnixPath } from '../../../agent/infra/process/path-utils.js';

package/dist/server/infra/executor/curate-executor.d.ts

@@ -0,0 +1,46 @@
+import type { ICipherAgent } from '../../../agent/core/interfaces/i-cipher-agent.js';
+import type { CurateExecuteOptions, ICurateExecutor } from '../../core/interfaces/executor/i-curate-executor.js';
+import { type FileContentReader } from '../../utils/file-content-reader.js';
+/**
+ * CurateExecutor - 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)
+ * - Transport handles task lifecycle (task:started, task:completed, task:error)
+ * - Executor focuses solely on curate execution
+ */
+export declare class CurateExecutor implements ICurateExecutor {
+    /** Maximum content length per file in characters */
+    private static readonly MAX_CONTENT_PER_FILE;
+    /** Maximum number of files allowed in --files flag */
+    private static readonly MAX_FILES;
+    /** Maximum lines to read for text files */
+    private static readonly MAX_LINES_PER_FILE;
+    /** Maximum pages to extract for PDFs */
+    private static readonly MAX_PDF_PAGES;
+    private readonly fileContentReader;
+    constructor(fileContentReader?: FileContentReader);
+    executeWithAgent(agent: ICipherAgent, options: CurateExecuteOptions): Promise<string>;
+    /**
+     * Format file contents for inclusion in the prompt.
+     */
+    private formatFileContentsForPrompt;
+    /**
+     * Get human-readable label for file type.
+     */
+    private getFileTypeLabel;
+    /**
+     * Process file paths from --files flag.
+     * Now reads file contents directly using FileContentReader.
+     *
+     * @param filePaths - Array of file paths (relative or absolute)
+     * @param clientCwd - Client's working directory for file validation (optional, defaults to process.cwd())
+     * @returns Formatted content with pre-read file contents
+     * @throws {FileValidationError} If all files fail validation
+     */
+    private processFileReferences;
+}

package/dist/server/infra/executor/curate-executor.js

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import { FileValidationError } from '../../core/domain/errors/task-error.js';
+import { createFileContentReader, } from '../../utils/file-content-reader.js';
+import { validateFileForCurate } from '../../utils/file-validator.js';
+/**
+ * CurateExecutor - 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)
+ * - Transport handles task lifecycle (task:started, task:completed, task:error)
+ * - Executor focuses solely on curate execution
+ */
+export class CurateExecutor {
+    /** Maximum content length per file in characters */
+    static MAX_CONTENT_PER_FILE = 40_000;
+    /** Maximum number of files allowed in --files flag */
+    static MAX_FILES = 5;
+    /** Maximum lines to read for text files */
+    static MAX_LINES_PER_FILE = 2000;
+    /** Maximum pages to extract for PDFs */
+    static MAX_PDF_PAGES = 50;
+    fileContentReader;
+    constructor(fileContentReader) {
+        this.fileContentReader = fileContentReader ?? createFileContentReader();
+    }
+    async executeWithAgent(agent, options) {
+        const { clientCwd, content, files, taskId } = options;
+        // Process file references - now reads file contents directly
+        const fileReferenceInstructions = await this.processFileReferences(files ?? [], clientCwd);
+        // Build prompt with optional file reference instructions
+        const prompt = fileReferenceInstructions ? `${content}\n${fileReferenceInstructions}` : content;
+        // Execute with curate commandType
+        // Agent uses its default session (created during start())
+        // Task lifecycle is managed by Transport (task:started, task:completed, task:error)
+        const response = await agent.execute(prompt, {
+            executionContext: { commandType: 'curate' },
+            taskId,
+        });
+        return response;
+    }
+    /**
+     * Format file contents for inclusion in the prompt.
+     */
+    formatFileContentsForPrompt(readResults, skippedFiles, projectRoot) {
+        const instructions = ['\n## File Contents (pre-loaded from --files flag)', ''];
+        // Separate successful and failed reads
+        const successfulReads = readResults.filter((r) => r.success);
+        const failedReads = readResults.filter((r) => !r.success);
+        // Add successful file contents
+        for (const result of successfulReads) {
+            const relativePath = path.relative(projectRoot, result.filePath);
+            const typeLabel = this.getFileTypeLabel(result.fileType);
+            const truncatedNote = result.metadata?.truncated ? ' [truncated]' : '';
+            instructions.push(`### File: ${relativePath} (${typeLabel}${truncatedNote})`, '```', result.content, '```', '');
+        }
+        // Add warnings for failed reads and skipped files
+        if (failedReads.length > 0 || skippedFiles.length > 0) {
+            instructions.push('### Files that could not be read:', ...failedReads.map((r) => `- ${path.relative(projectRoot, r.filePath)}: ${r.error}`), ...skippedFiles.map((f) => `- ${f.path}: ${f.reason}`), '', '**Note:** You may use `read_file` or `grep_content` tools to find additional context if needed.', '');
+        }
+        instructions.push('**INSTRUCTIONS:**', '- The file contents above have been pre-loaded for you', '- Use this content to understand the context and create comprehensive knowledge topics', '- DO NOT use read_file tool for the files above - the content is already provided', '- Proceed with the normal workflow: detect domains, find existing knowledge, create/update topics', '');
+        return instructions.join('\n');
+    }
+    /**
+     * Get human-readable label for file type.
+     */
+    getFileTypeLabel(fileType) {
+        switch (fileType) {
+            case 'office': {
+                return 'Office Document';
+            }
+            case 'pdf': {
+                return 'PDF';
+            }
+            case 'text': {
+                return 'Text';
+            }
+            default: {
+                return fileType;
+            }
+        }
+    }
+    /**
+     * Process file paths from --files flag.
+     * Now reads file contents directly using FileContentReader.
+     *
+     * @param filePaths - Array of file paths (relative or absolute)
+     * @param clientCwd - Client's working directory for file validation (optional, defaults to process.cwd())
+     * @returns Formatted content with pre-read file contents
+     * @throws {FileValidationError} If all files fail validation
+     */
+    async processFileReferences(filePaths, clientCwd) {
+        if (!filePaths || filePaths.length === 0) {
+            return '';
+        }
+        // Truncate if exceeds max files
+        let processedPaths = filePaths;
+        if (filePaths.length > CurateExecutor.MAX_FILES) {
+            processedPaths = filePaths.slice(0, CurateExecutor.MAX_FILES);
+        }
+        const projectRoot = clientCwd ?? process.cwd();
+        // Validate each file - skip non-existent files with warnings instead of failing
+        const validPaths = [];
+        const skippedFiles = [];
+        for (const filePath of processedPaths) {
+            const result = validateFileForCurate(filePath, projectRoot);
+            if (result.valid && result.normalizedPath) {
+                validPaths.push(result.normalizedPath);
+            }
+            else {
+                // Skip non-existent files instead of failing - agent can use grep to find alternatives
+                skippedFiles.push({ path: filePath, reason: result.error ?? 'Unknown error' });
+            }
+        }
+        // If all files were skipped, throw an error
+        if (validPaths.length === 0 && processedPaths.length > 0) {
+            const errorMessage = `All specified files are invalid or do not exist:\n${skippedFiles.map((f) => `  - ${f.path}: ${f.reason}`).join('\n')}\n\nTry using grep to find the correct file paths.`;
+            throw new FileValidationError(errorMessage);
+        }
+        // Read file contents using FileContentReader
+        const readResults = await this.fileContentReader.readFiles(validPaths, {
+            maxContentLength: CurateExecutor.MAX_CONTENT_PER_FILE,
+            maxLinesPerFile: CurateExecutor.MAX_LINES_PER_FILE,
+            maxPdfPages: CurateExecutor.MAX_PDF_PAGES,
+        });
+        // Format with actual content
+        return this.formatFileContentsForPrompt(readResults, skippedFiles, projectRoot);
+    }
+}