byterover-cli 1.2.1 → 1.4.0

package/dist/infra/cipher/file-system/pdf-extractor.js

@@ -0,0 +1,226 @@
+import { getDocumentProxy, getMeta } from 'unpdf';
+import { PdfExtractionError } from '../../../core/domain/cipher/errors/file-system-error.js';
+/**
+ * PDF magic bytes: %PDF-
+ */
+const PDF_MAGIC_BYTES = [0x25, 0x50, 0x44, 0x46, 0x2d];
+/**
+ * Default number of pages to extract when no limit specified.
+ */
+const DEFAULT_PAGE_LIMIT = 100;
+/**
+ * Maximum number of pages allowed per extraction.
+ */
+const MAX_PAGE_LIMIT = 200;
+/**
+ * PDF text extraction and metadata extraction utility.
+ * Provides page-by-page extraction with pagination support.
+ *
+ * Features:
+ * - Magic byte validation
+ * - Fast metadata-only extraction
+ * - Page-by-page text extraction with offset/limit
+ * - Default: 100 pages, max: 200 pages per extraction
+ */
+export class PdfExtractor {
+    /**
+     * Extracts metadata from a PDF buffer without extracting text.
+     * This is a fast path when you only need page count, title, author, etc.
+     *
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file (for error messages)
+     * @returns PDF metadata
+     */
+    static async extractMetadata(buffer, filePath) {
+        try {
+            const pdf = await getDocumentProxy(new Uint8Array(buffer));
+            const meta = await getMeta(pdf);
+            return PdfExtractor.buildMetadataFromInfo(pdf.numPages, meta.info);
+        }
+        catch (error) {
+            throw PdfExtractor.wrapExtractionError(error, filePath);
+        }
+    }
+    /**
+     * Extracts text from a PDF buffer with pagination support.
+     *
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file (for error messages)
+     * @param options - Extraction options (offset, limit)
+     * @returns Extraction result with pages, metadata, and continuation info
+     */
+    static async extractText(buffer, filePath, options = {}) {
+        // Validate PDF magic bytes
+        if (!PdfExtractor.isValidPdf(buffer)) {
+            throw new PdfExtractionError(filePath, 'Invalid PDF file format (missing PDF header)');
+        }
+        try {
+            const pdf = await getDocumentProxy(new Uint8Array(buffer));
+            const meta = await getMeta(pdf);
+            const totalPages = pdf.numPages;
+            const metaInfo = meta.info;
+            // Calculate pagination
+            const offset = Math.max(1, options.offset ?? 1);
+            const limit = Math.min(options.limit ?? DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT);
+            // Return empty result if offset is beyond total pages
+            if (offset > totalPages) {
+                return {
+                    hasMore: false,
+                    metadata: PdfExtractor.buildMetadataFromInfo(totalPages, metaInfo),
+                    pages: [],
+                };
+            }
+            // Calculate page range
+            const endPage = Math.min(offset + limit - 1, totalPages);
+            // Extract text only from requested pages using PDF.js page-level API
+            const pages = await PdfExtractor.extractPagesFromDocument(pdf, offset, endPage);
+            return {
+                hasMore: endPage < totalPages,
+                metadata: PdfExtractor.buildMetadataFromInfo(totalPages, metaInfo),
+                pages,
+            };
+        }
+        catch (error) {
+            throw PdfExtractor.wrapExtractionError(error, filePath);
+        }
+    }
+    /**
+     * Checks if a buffer contains valid PDF magic bytes.
+     * @param buffer - Buffer to check
+     * @returns true if buffer starts with %PDF-
+     */
+    static isValidPdf(buffer) {
+        if (buffer.length < PDF_MAGIC_BYTES.length) {
+            return false;
+        }
+        for (const [index, byte] of PDF_MAGIC_BYTES.entries()) {
+            if (buffer[index] !== byte) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Builds PdfMetadata from unpdf meta info object.
+     * @param pageCount - Total number of pages
+     * @param info - Optional info object from unpdf getMeta
+     * @returns PdfMetadata object
+     */
+    static buildMetadataFromInfo(pageCount, info) {
+        const metadata = { pageCount };
+        if (!info) {
+            return metadata;
+        }
+        if (typeof info.Title === 'string' && info.Title.trim()) {
+            metadata.title = info.Title.trim();
+        }
+        if (typeof info.Author === 'string' && info.Author.trim()) {
+            metadata.author = info.Author.trim();
+        }
+        if (info.CreationDate) {
+            const parsed = PdfExtractor.parsePdfDate(info.CreationDate);
+            if (parsed) {
+                metadata.creationDate = parsed;
+            }
+        }
+        return metadata;
+    }
+    /**
+     * Extracts text from specific pages of a PDF document.
+     * Uses PDF.js page-level API for efficient extraction of page ranges.
+     *
+     * @param pdf - PDF document proxy from unpdf
+     * @param startPage - Starting page number (1-based)
+     * @param endPage - Ending page number (1-based, inclusive)
+     * @returns Array of PdfPageContent with extracted text
+     */
+    static async extractPagesFromDocument(pdf, startPage, endPage) {
+        // Build array of page numbers to extract
+        const pageNumbers = [];
+        for (let pageNum = startPage; pageNum <= endPage; pageNum++) {
+            pageNumbers.push(pageNum);
+        }
+        // Extract all requested pages in parallel
+        const pages = await Promise.all(pageNumbers.map(async (pageNum) => {
+            const page = await pdf.getPage(pageNum);
+            const textContent = await page.getTextContent();
+            // Extract text from text items, handling EOL markers
+            // TextContent.items contains TextItem and TextMarkedContent - we only want TextItem (has 'str')
+            const text = textContent.items
+                .filter((item) => typeof item === 'object' && item !== null && 'str' in item)
+                .map((item) => item.str + (item.hasEOL ? '\n' : ''))
+                .join('');
+            return {
+                pageNumber: pageNum,
+                text: text.trim(),
+            };
+        }));
+        return pages;
+    }
+    /**
+     * Extracts a meaningful error message from an unknown error.
+     */
+    static getExtractionErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'string') {
+            return error;
+        }
+        return 'Unknown PDF extraction error';
+    }
+    /**
+     * Parses PDF date string format (D:YYYYMMDDHHmmSS) to Date object.
+     * @param dateStr - PDF date string
+     * @returns Parsed Date or undefined if invalid
+     */
+    static parsePdfDate(dateStr) {
+        if (!dateStr) {
+            return undefined;
+        }
+        // PDF date format: D:YYYYMMDDHHmmSS+HH'mm' or variations
+        const match = dateStr.match(/D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?/);
+        if (!match) {
+            return undefined;
+        }
+        const year = Number.parseInt(match[1], 10);
+        const month = match[2] ? Number.parseInt(match[2], 10) - 1 : 0;
+        const day = match[3] ? Number.parseInt(match[3], 10) : 1;
+        const hour = match[4] ? Number.parseInt(match[4], 10) : 0;
+        const minute = match[5] ? Number.parseInt(match[5], 10) : 0;
+        const second = match[6] ? Number.parseInt(match[6], 10) : 0;
+        return new Date(year, month, day, hour, minute, second);
+    }
+    /**
+     * Wraps extraction errors with appropriate PdfExtractionError.
+     * @param error - The caught error
+     * @param filePath - Path to the PDF file
+     * @returns PdfExtractionError with appropriate message
+     */
+    static wrapExtractionError(error, filePath) {
+        const errorMessage = PdfExtractor.getExtractionErrorMessage(error);
+        const lowerMessage = errorMessage.toLowerCase();
+        if (lowerMessage.includes('password') || lowerMessage.includes('encrypted')) {
+            return new PdfExtractionError(filePath, 'PDF is password-protected or encrypted');
+        }
+        return new PdfExtractionError(filePath, errorMessage);
+    }
+}
+/**
+ * Formats extracted PDF pages into a readable string with page separators.
+ * @param pages - Array of extracted page contents
+ * @param metadata - PDF metadata
+ * @param hasMore - Whether there are more pages
+ * @param nextOffset - Next offset for continuation (if hasMore is true)
+ * @returns Formatted string with page separators
+ */
+export function formatPdfContent(pages, metadata, hasMore, nextOffset) {
+    if (pages.length === 0) {
+        return '';
+    }
+    const formattedPages = pages.map((page) => `--- Page ${page.pageNumber} ---\n${page.text}`).join('\n\n');
+    const truncationNote = hasMore
+        ? `\n\n(PDF has more pages. Use offset=${nextOffset} to continue)`
+        : `\n\n(End of PDF - ${metadata.pageCount} pages)`;
+    return formattedPages + truncationNote;
+}

package/dist/infra/cipher/llm/context/context-manager.js

@@ -200,15 +200,13 @@ export class ContextManager {
             content,
             role: 'user',
         };
-        await this.mutex.withLock(async () => {
-            this.messages.push(message);
-            try {
-                await this.persistHistory();
-            }
-            catch (error) {
-                this.logger.error('Failed to persist history after user message', { error, sessionId: this.sessionId });
-            }
-        });
+        this.messages.push(message);
+        try {
+            await this.persistHistory();
+        }
+        catch (error) {
+            this.logger.error('Failed to persist history after user message', { error, sessionId: this.sessionId });
+        }
     }
     /**
      * Clear all messages from the conversation history.

package/dist/infra/cipher/llm/internal-llm-service.d.ts

@@ -72,6 +72,7 @@ export declare class ByteRoverLLMService implements ILLMService {
     private readonly loopDetector;
     private readonly memoryManager?;
     private readonly metadataHandler;
+    private readonly mutex;
     private readonly outputProcessor;
     private readonly providerType;
     private readonly sessionEventBus;
@@ -257,10 +258,13 @@ export declare class ByteRoverLLMService implements ILLMService {
      * Execute a single iteration of the agentic loop.
      *
      * @param options - Iteration options
+     * @param options.executionContext - Optional execution context
+     * @param options.fileData - Optional file data (only used on first iteration)
+     * @param options.imageData - Optional image data (only used on first iteration)
      * @param options.iterationCount - Current iteration number
      * @param options.taskId - Task ID from usecase for billing tracking
+     * @param options.textInput - User input text (only used on first iteration)
      * @param options.tools - Available tools for this iteration
-     * @param options.executionContext - Optional execution context
      * @returns Final response string if complete, null if more iterations needed
      */
     private executeAgenticIteration;

package/dist/infra/cipher/llm/internal-llm-service.js

@@ -6,6 +6,7 @@ import { NoOpLogger } from '../../../core/interfaces/cipher/i-logger.js';
 import { getErrorMessage } from '../../../utils/error-helpers.js';
 import { EnvironmentContextBuilder } from '../system-prompt/environment-context-builder.js';
 import { ToolMetadataHandler } from '../tools/streaming/metadata-handler.js';
+import { AsyncMutex } from './context/async-mutex.js';
 import { ContextManager } from './context/context-manager.js';
 import { LoopDetector } from './context/loop-detector.js';
 import { ClaudeMessageFormatter } from './formatters/claude-formatter.js';
@@ -44,6 +45,7 @@ export class ByteRoverLLMService {
     loopDetector;
     memoryManager;
     metadataHandler;
+    mutex = new AsyncMutex();
     outputProcessor;
     providerType;
     sessionEventBus;
@@ -147,8 +149,6 @@ export class ByteRoverLLMService {
     async completeTask(textInput, options) {
         // Extract options with defaults
         const { executionContext, fileData, imageData, signal, taskId } = options ?? {};
-        // Add user message to context
-        await this.contextManager.addUserMessage(textInput, imageData, fileData);
         // Get filtered tools based on command type (e.g., only read-only tools for 'query')
         const toolSet = this.toolManager.getToolsForCommand(options?.executionContext?.commandType);
         // Create state machine with configured limits
@@ -171,8 +171,11 @@ export class ByteRoverLLMService {
                 // eslint-disable-next-line no-await-in-loop -- Sequential iterations required for agentic loop
                 const result = await this.executeAgenticIteration({
                     executionContext,
+                    fileData,
+                    imageData,
                     iterationCount: stateMachine.getContext().turnCount,
                     taskId,
+                    textInput,
                     tools: toolSet,
                 });
                 if (result !== null) {
@@ -477,14 +480,17 @@ export class ByteRoverLLMService {
      * Execute a single iteration of the agentic loop.
      *
      * @param options - Iteration options
+     * @param options.executionContext - Optional execution context
+     * @param options.fileData - Optional file data (only used on first iteration)
+     * @param options.imageData - Optional image data (only used on first iteration)
      * @param options.iterationCount - Current iteration number
      * @param options.taskId - Task ID from usecase for billing tracking
+     * @param options.textInput - User input text (only used on first iteration)
      * @param options.tools - Available tools for this iteration
-     * @param options.executionContext - Optional execution context
      * @returns Final response string if complete, null if more iterations needed
      */
     async executeAgenticIteration(options) {
-        const { executionContext, iterationCount, taskId, tools } = options;
+        const { executionContext, fileData, imageData, iterationCount, taskId, textInput, tools } = options;
         // Build system prompt using SystemPromptManager (before compression for correct token accounting)
         // Use filtered tool names based on command type (e.g., only read-only tools for 'query')
         const availableTools = this.toolManager.getToolNamesForCommand(executionContext?.commandType);
@@ -533,54 +539,59 @@ export class ByteRoverLLMService {
                 reflectionType,
             });
         }
-        // Get token count for logging (using system prompt for token accounting)
-        const systemPromptTokens = this.generator.estimateTokensSync(systemPrompt);
-        const messages = this.contextManager.getMessages();
-        const messageTokenCounts = messages.map((msg) => this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)));
-        const maxMessageTokens = this.config.maxInputTokens - systemPromptTokens;
-        // Target utilization to leave headroom for response
-        const targetMessageTokens = Math.floor(maxMessageTokens * TARGET_MESSAGE_TOKEN_UTILIZATION);
-        this.contextManager.compressMessage(targetMessageTokens, messageTokenCounts);
-        // Calculate tokens after compression
-        const compressedMessagesTokens = this.contextManager
-            .getMessages()
-            .reduce((total, msg) => total +
-            this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)), 0);
-        const tokensUsed = systemPromptTokens + compressedMessagesTokens;
-        // Verbose: Log messages that will be sent to LLM
-        if (this.config.verbose) {
-            console.log('\n========== MESSAGES (Sent to LLM) ==========');
-            console.log(JSON.stringify(this.contextManager.getMessages(), null, 2));
-            console.log('========== END MESSAGES ==========\n');
-            // Log token usage for monitoring compression behavior
-            console.log(`[ByteRoverLLMService] [Iter ${iterationCount + 1}/${this.config.maxIterations}] Sending to LLM: ${tokensUsed} tokens (max: ${this.config.maxInputTokens})`);
-        }
         // Final iteration optimization for query: strip tools (reflection already added above)
         let toolsForThisIteration = tools;
         if (executionContext?.commandType === 'query' && iterationCount === this.config.maxIterations - 1) {
             toolsForThisIteration = {}; // Empty toolset forces text response
         }
-        // Build generation request
-        const request = this.buildGenerateContentRequest({
-            executionContext,
-            systemPrompt,
-            taskId,
-            tools: toolsForThisIteration,
-        });
-        // Call LLM via generator (retry + logging handled by decorators)
-        const lastMessage = await this.callLLMAndParseResponse(request);
-        // Check if there are tool calls
-        if (!lastMessage.toolCalls || lastMessage.toolCalls.length === 0) {
-            const response = await this.handleFinalResponse(lastMessage, taskId);
-            // Auto-compaction check after assistant response
+        // Get token count for logging (using system prompt for token accounting)
+        const systemPromptTokens = this.generator.estimateTokensSync(systemPrompt);
+        // Add user message and compress context within mutex lock
+        return this.mutex.withLock(async () => {
+            // Add user message to context only on the first iteration
+            await this.contextManager.addUserMessage(textInput, imageData, fileData);
+            const messages = this.contextManager.getMessages();
+            const messageTokenCounts = messages.map((msg) => this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)));
+            const maxMessageTokens = this.config.maxInputTokens - systemPromptTokens;
+            // Target utilization to leave headroom for response
+            const targetMessageTokens = Math.floor(maxMessageTokens * TARGET_MESSAGE_TOKEN_UTILIZATION);
+            this.contextManager.compressMessage(targetMessageTokens, messageTokenCounts);
+            // Calculate tokens after compression
+            const compressedMessagesTokens = this.contextManager
+                .getMessages()
+                .reduce((total, msg) => total +
+                this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)), 0);
+            const tokensUsed = systemPromptTokens + compressedMessagesTokens;
+            // Verbose: Log messages that will be sent to LLM
+            if (this.config.verbose) {
+                console.log('\n========== MESSAGES (Sent to LLM) ==========');
+                console.log(JSON.stringify(this.contextManager.getMessages(), null, 2));
+                console.log('========== END MESSAGES ==========\n');
+                // Log token usage for monitoring compression behavior
+                console.log(`[ByteRoverLLMService] [Iter ${iterationCount + 1}/${this.config.maxIterations}] Sending to LLM: ${tokensUsed} tokens (max: ${this.config.maxInputTokens})`);
+            }
+            // Build generation request
+            const request = this.buildGenerateContentRequest({
+                executionContext,
+                systemPrompt,
+                taskId,
+                tools: toolsForThisIteration,
+            });
+            // Call LLM via generator (retry + logging handled by decorators)
+            const lastMessage = await this.callLLMAndParseResponse(request);
+            // Check if there are tool calls
+            if (!lastMessage.toolCalls || lastMessage.toolCalls.length === 0) {
+                const response = await this.handleFinalResponse(lastMessage, taskId);
+                // Auto-compaction check after assistant response
+                await this.checkAndTriggerCompaction(taskId ?? '');
+                return response;
+            }
+            // Has tool calls - handle them (pass taskId for subagent billing)
+            await this.handleToolCalls(lastMessage, taskId);
+            // Auto-compaction check after tool execution batch
             await this.checkAndTriggerCompaction(taskId ?? '');
-            return response;
-        }
-        // Has tool calls - handle them (pass taskId for subagent billing)
-        await this.handleToolCalls(lastMessage, taskId);
-        // Auto-compaction check after tool execution batch
-        await this.checkAndTriggerCompaction(taskId ?? '');
-        return null;
+            return null;
+        });
     }
     /**
      * Execute a single tool call in parallel (without adding to context).

package/dist/infra/cipher/system-prompt/contributor-schemas.d.ts

@@ -12,14 +12,14 @@ export declare const StaticContributorConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"static">;
 }, "strict", z.ZodTypeAny, {
     type: "static";
-    content: string;
     id: string;
+    content: string;
     enabled: boolean;
     priority: number;
 }, {
     type: "static";
-    content: string;
     id: string;
+    content: string;
     priority: number;
     enabled?: boolean | undefined;
 }>;
@@ -179,14 +179,14 @@ export declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z
     type: z.ZodLiteral<"static">;
 }, "strict", z.ZodTypeAny, {
     type: "static";
-    content: string;
     id: string;
+    content: string;
     enabled: boolean;
     priority: number;
 }, {
     type: "static";
-    content: string;
     id: string;
+    content: string;
     priority: number;
     enabled?: boolean | undefined;
 }>, z.ZodObject<{
@@ -311,14 +311,14 @@ export declare const SystemPromptManagerConfigSchema: z.ZodObject<{
         type: z.ZodLiteral<"static">;
     }, "strict", z.ZodTypeAny, {
         type: "static";
-        content: string;
         id: string;
+        content: string;
         enabled: boolean;
         priority: number;
     }, {
         type: "static";
-        content: string;
         id: string;
+        content: string;
         priority: number;
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
@@ -433,8 +433,8 @@ export declare const SystemPromptManagerConfigSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     contributors: ({
         type: "static";
-        content: string;
         id: string;
+        content: string;
         enabled: boolean;
         priority: number;
     } | {
@@ -471,8 +471,8 @@ export declare const SystemPromptManagerConfigSchema: z.ZodObject<{
 }, {
     contributors: ({
         type: "static";
-        content: string;
         id: string;
+        content: string;
         priority: number;
         enabled?: boolean | undefined;
     } | {

package/dist/infra/cipher/system-prompt/schemas.d.ts

@@ -12,28 +12,28 @@ export declare const PromptConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
     prompt: z.ZodOptional<z.ZodString>;
     prompts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, "strict", z.ZodTypeAny, {
-    prompt?: string | undefined;
     description?: string | undefined;
+    prompt?: string | undefined;
     excludedTools?: string[] | undefined;
     prompts?: Record<string, string> | undefined;
 }, {
-    prompt?: string | undefined;
     description?: string | undefined;
+    prompt?: string | undefined;
     excludedTools?: string[] | undefined;
     prompts?: Record<string, string> | undefined;
 }>, {
-    prompt?: string | undefined;
     description?: string | undefined;
+    prompt?: string | undefined;
     excludedTools?: string[] | undefined;
     prompts?: Record<string, string> | undefined;
 }, {
-    prompt?: string | undefined;
     description?: string | undefined;
+    prompt?: string | undefined;
     excludedTools?: string[] | undefined;
     prompts?: Record<string, string> | undefined;
 }>, {
-    prompt?: string | undefined;
     description?: string | undefined;
+    prompt?: string | undefined;
     excludedTools?: string[] | undefined;
     prompts?: Record<string, string> | undefined;
 }, unknown>;

package/dist/infra/cipher/tools/implementations/read-file-tool.js

@@ -7,8 +7,23 @@ import { isImageFile } from '../../file-system/binary-utils.js';
 const ReadFileInputSchema = z
     .object({
     filePath: z.string().describe('Path to the file to read (absolute or relative to working directory)'),
-    limit: z.number().int().positive().optional().describe('Maximum number of lines to read (optional, default: 2000)'),
-    offset: z.number().int().min(1).optional().describe('Starting line number (1-based, optional)'),
+    limit: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Maximum number of lines to read for text files (default: 2000), or pages for PDFs in text mode (default: 100, max: 200)'),
+    offset: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe('Starting line number (1-based) for text files, or starting page number for PDFs. ' +
+        'If the file is truncated, you MUST set offset to the next line/page number to continue reading.'),
+    pdfMode: z
+        .enum(['text', 'base64'])
+        .optional()
+        .describe("PDF read mode: 'text' (default) extracts text page by page with pagination support, 'base64' returns raw PDF as attachment for multimodal analysis"),
 })
     .strict();
 /**
@@ -29,14 +44,18 @@ const ReadFileInputSchema = z
  */
 export function createReadFileTool(fileSystemService) {
     return {
-        description: 'Read the contents of a file. Supports relative/absolute paths, pagination, and returns images/PDFs as base64 attachments.',
+        description: 'Read the contents of a file. Supports relative/absolute paths and pagination. ' +
+            'For PDFs, defaults to text extraction with page-by-page pagination (use pdfMode="base64" for raw attachment). ' +
+            'Images are returned as base64 attachments. ' +
+            'Must continue running read_file tool with the correct offset to finish reading the file.',
         async execute(input, _context) {
-            const { filePath, limit, offset } = input;
+            const { filePath, limit, offset, pdfMode } = input;
             try {
                 // Call file system service
                 const result = await fileSystemService.readFile(filePath, {
                     limit,
                     offset,
+                    pdfMode,
                 });
                 // Transform attachment format (singular → plural array)
                 let attachments;
@@ -55,6 +74,7 @@ export function createReadFileTool(fileSystemService) {
                     content: result.formattedContent,
                     lines: result.lines,
                     message: result.message,
+                    pdfMetadata: result.pdfMetadata,
                     preview: result.preview,
                     size: result.size,
                     success: true,

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

@@ -3,6 +3,7 @@ import { CONNECTOR_TYPES } from '../../core/domain/entities/connector-type.js';
 import { HookConnector } from './hook/hook-connector.js';
 import { McpConnector } from './mcp/mcp-connector.js';
 import { RulesConnector } from './rules/rules-connector.js';
+import { SkillConnector } from './skill/skill-connector.js';
 /**
  * Factory and orchestration layer for connectors.
  * Creates connector instances and manages connector operations.
@@ -16,6 +17,7 @@ export class ConnectorManager {
             ['hook', new HookConnector({ fileService, projectRoot })],
             ['mcp', new McpConnector({ fileService, projectRoot, templateService })],
             ['rules', new RulesConnector({ fileService, projectRoot, templateService })],
+            ['skill', new SkillConnector({ fileService, projectRoot })],
         ]);
     }
     async getAllInstalledConnectors() {

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

@@ -21,7 +21,7 @@ type HookConnectorOptions = {
  * - Safe uninstall: Only removes ByteRover hooks by command match
  */
 export declare class HookConnector implements IConnector {
-    readonly type: ConnectorType;
+    readonly connectorType: ConnectorType;
     private readonly fileService;
     private readonly projectRoot;
     private readonly supportedAgents;

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

@@ -23,7 +23,7 @@ function parseJsonAsRecord(content) {
  * - Safe uninstall: Only removes ByteRover hooks by command match
  */
 export class HookConnector {
-    type = 'hook';
+    connectorType = 'hook';
     fileService;
     projectRoot;
     supportedAgents;
@@ -31,7 +31,7 @@ export class HookConnector {
         this.fileService = options.fileService;
         this.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) {
@@ -104,7 +104,7 @@ export class HookConnector {
         }
     }
     isSupported(agent) {
-        return AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.type);
+        return AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.connectorType);
     }
     async status(agent) {
         if (!this.isSupported(agent)) {

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

@@ -24,7 +24,7 @@ type McpConnectorOptions = {
  * - Safe uninstall: Only removes ByteRover's MCP server entry and rule content
  */
 export declare class McpConnector implements IConnector {
-    readonly type: ConnectorType;
+    readonly connectorType: ConnectorType;
     private readonly fileService;
     private readonly projectRoot;
     private readonly ruleFileManager;