opc-agent 3.0.1 → 4.0.1

package/dist/tools/builtin/rl-tools.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rlTools = exports.rlResetEpisode = exports.rlGetStatistics = exports.rlUpdatePolicy = exports.rlExplorationSuggest = exports.rlRewardSignal = exports.rlGenerateTrainingData = exports.rlCompareStrategies = exports.rlGetBestStrategy = exports.rlEvaluateOutcome = exports.rlRecordTrajectory = void 0;
+const trajectories = [];
+const policies = new Map();
+let currentEpisode = null;
+function getOrCreateEpisode(taskType) {
+    if (!currentEpisode || currentEpisode.taskType !== taskType) {
+        currentEpisode = {
+            id: `ep_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            taskType,
+            actions: [],
+            totalReward: 0,
+        };
+        trajectories.push(currentEpisode);
+    }
+    return currentEpisode;
+}
+exports.rlRecordTrajectory = {
+    name: 'rl_record_trajectory',
+    description: 'Record action sequences and outcomes for RL training',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            taskType: { type: 'string' },
+            action: { type: 'string' },
+            outcome: { type: 'string', enum: ['success', 'partial', 'failure'] },
+        },
+        required: ['taskType', 'action'],
+    },
+    async execute(input) {
+        const ep = getOrCreateEpisode(input.taskType);
+        ep.actions.push({ action: input.action, timestamp: Date.now() });
+        if (input.outcome)
+            ep.outcome = input.outcome;
+        return { content: JSON.stringify({ episodeId: ep.id, actionsRecorded: ep.actions.length }) };
+    },
+};
+exports.rlEvaluateOutcome = {
+    name: 'rl_evaluate_outcome',
+    description: "Score an action's outcome (success/partial/failure)",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            episodeId: { type: 'string' },
+            outcome: { type: 'string', enum: ['success', 'partial', 'failure'] },
+        },
+        required: ['outcome'],
+    },
+    async execute(input) {
+        const ep = input.episodeId
+            ? trajectories.find(t => t.id === input.episodeId)
+            : currentEpisode;
+        if (!ep)
+            return { content: 'No active episode found', isError: true };
+        ep.outcome = input.outcome;
+        const score = ep.outcome === 'success' ? 1 : ep.outcome === 'partial' ? 0.5 : 0;
+        return { content: JSON.stringify({ episodeId: ep.id, outcome: ep.outcome, score }) };
+    },
+};
+exports.rlGetBestStrategy = {
+    name: 'rl_get_best_strategy',
+    description: 'Retrieve best-performing strategy for a task type',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' } },
+        required: ['taskType'],
+    },
+    async execute(input) {
+        const taskType = input.taskType;
+        const relevant = trajectories.filter(t => t.taskType === taskType && t.outcome === 'success');
+        if (relevant.length === 0)
+            return { content: JSON.stringify({ strategy: null, message: 'No successful strategies found' }) };
+        const best = relevant.reduce((a, b) => a.totalReward >= b.totalReward ? a : b);
+        return { content: JSON.stringify({ strategy: best.actions.map(a => a.action), totalReward: best.totalReward }) };
+    },
+};
+exports.rlCompareStrategies = {
+    name: 'rl_compare_strategies',
+    description: 'Compare multiple strategies by success rate',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' } },
+        required: ['taskType'],
+    },
+    async execute(input) {
+        const taskType = input.taskType;
+        const relevant = trajectories.filter(t => t.taskType === taskType && t.outcome);
+        const total = relevant.length;
+        const successes = relevant.filter(t => t.outcome === 'success').length;
+        const partials = relevant.filter(t => t.outcome === 'partial').length;
+        const failures = relevant.filter(t => t.outcome === 'failure').length;
+        return {
+            content: JSON.stringify({
+                taskType, total, successRate: total ? successes / total : 0,
+                breakdown: { successes, partials, failures },
+            }),
+        };
+    },
+};
+exports.rlGenerateTrainingData = {
+    name: 'rl_generate_training_data',
+    description: 'Export trajectories as fine-tuning JSONL',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' }, minReward: { type: 'number' } },
+    },
+    async execute(input) {
+        let data = trajectories;
+        if (input.taskType)
+            data = data.filter(t => t.taskType === input.taskType);
+        if (input.minReward != null)
+            data = data.filter(t => t.totalReward >= input.minReward);
+        const jsonl = data.map(t => JSON.stringify({
+            messages: [
+                { role: 'system', content: `Task: ${t.taskType}` },
+                ...t.actions.map(a => ({ role: 'assistant', content: a.action })),
+            ],
+            outcome: t.outcome,
+            reward: t.totalReward,
+        })).join('\n');
+        return { content: jsonl || '(no data)' };
+    },
+};
+exports.rlRewardSignal = {
+    name: 'rl_reward_signal',
+    description: 'Record positive/negative reward for last action',
+    inputSchema: {
+        type: 'object',
+        properties: { reward: { type: 'number' }, reason: { type: 'string' } },
+        required: ['reward'],
+    },
+    async execute(input) {
+        if (!currentEpisode || currentEpisode.actions.length === 0) {
+            return { content: 'No current episode or actions to reward', isError: true };
+        }
+        const lastAction = currentEpisode.actions[currentEpisode.actions.length - 1];
+        lastAction.reward = input.reward;
+        currentEpisode.totalReward += input.reward;
+        return { content: JSON.stringify({ action: lastAction.action, reward: input.reward, totalReward: currentEpisode.totalReward }) };
+    },
+};
+exports.rlExplorationSuggest = {
+    name: 'rl_exploration_suggest',
+    description: 'Suggest alternative approaches (exploration)',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' }, currentAction: { type: 'string' } },
+        required: ['taskType'],
+    },
+    async execute(input) {
+        const taskType = input.taskType;
+        const allActions = new Set();
+        trajectories.filter(t => t.taskType === taskType).forEach(t => t.actions.forEach(a => allActions.add(a.action)));
+        const suggestions = Array.from(allActions).filter(a => a !== input.currentAction).slice(0, 5);
+        if (suggestions.length === 0) {
+            return { content: JSON.stringify({ suggestions: [], message: 'No alternative actions found. Try a completely new approach.' }) };
+        }
+        return { content: JSON.stringify({ suggestions }) };
+    },
+};
+exports.rlUpdatePolicy = {
+    name: 'rl_update_policy',
+    description: "Update agent's action preferences based on rewards",
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' }, action: { type: 'string' }, weight: { type: 'number' } },
+        required: ['taskType', 'action', 'weight'],
+    },
+    async execute(input) {
+        const taskType = input.taskType;
+        let policy = policies.get(taskType);
+        if (!policy) {
+            policy = { taskType, preferredActions: [], weights: {} };
+            policies.set(taskType, policy);
+        }
+        const action = input.action;
+        policy.weights[action] = (policy.weights[action] || 0) + input.weight;
+        policy.preferredActions = Object.entries(policy.weights)
+            .sort(([, a], [, b]) => b - a)
+            .map(([k]) => k);
+        return { content: JSON.stringify({ taskType, preferredActions: policy.preferredActions.slice(0, 5), weights: policy.weights }) };
+    },
+};
+exports.rlGetStatistics = {
+    name: 'rl_get_statistics',
+    description: 'Get success/failure stats by task type',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' } },
+    },
+    async execute(input) {
+        let data = trajectories;
+        if (input.taskType)
+            data = data.filter(t => t.taskType === input.taskType);
+        const stats = {};
+        for (const t of data) {
+            if (!stats[t.taskType])
+                stats[t.taskType] = { total: 0, success: 0, partial: 0, failure: 0, avgReward: 0 };
+            const s = stats[t.taskType];
+            s.total++;
+            if (t.outcome === 'success')
+                s.success++;
+            else if (t.outcome === 'partial')
+                s.partial++;
+            else if (t.outcome === 'failure')
+                s.failure++;
+            s.avgReward = (s.avgReward * (s.total - 1) + t.totalReward) / s.total;
+        }
+        return { content: JSON.stringify(stats) };
+    },
+};
+exports.rlResetEpisode = {
+    name: 'rl_reset_episode',
+    description: 'Clear current episode state',
+    inputSchema: { type: 'object', properties: {} },
+    async execute() {
+        const had = currentEpisode != null;
+        currentEpisode = null;
+        return { content: JSON.stringify({ reset: true, hadActiveEpisode: had }) };
+    },
+};
+exports.rlTools = [
+    exports.rlRecordTrajectory, exports.rlEvaluateOutcome, exports.rlGetBestStrategy, exports.rlCompareStrategies,
+    exports.rlGenerateTrainingData, exports.rlRewardSignal, exports.rlExplorationSuggest, exports.rlUpdatePolicy,
+    exports.rlGetStatistics, exports.rlResetEpisode,
+];
+//# sourceMappingURL=rl-tools.js.map

package/dist/tools/builtin/vision.d.ts

@@ -0,0 +1,6 @@
+import type { MCPTool } from '../mcp';
+export declare const visionAnalyzeTool: MCPTool;
+export declare const visionExtractTextTool: MCPTool;
+export declare const visionCompareTool: MCPTool;
+export declare const visionTools: MCPTool[];
+//# sourceMappingURL=vision.d.ts.map

package/dist/tools/builtin/vision.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visionTools = exports.visionCompareTool = exports.visionExtractTextTool = exports.visionAnalyzeTool = void 0;
+const vision_1 = require("../../core/vision");
+const manager = new vision_1.VisionManager();
+exports.visionAnalyzeTool = {
+    name: 'vision_analyze',
+    description: 'Analyze an image using vision AI. Provide image as URL or base64.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            image_url: { type: 'string', description: 'URL of the image to analyze' },
+            image_base64: { type: 'string', description: 'Base64-encoded image data' },
+            prompt: { type: 'string', description: 'Optional prompt for analysis' },
+        },
+    },
+    async execute(input) {
+        const imgInput = input.image_url
+            ? { type: 'url', data: input.image_url }
+            : { type: 'base64', data: input.image_base64 };
+        const result = await manager.analyze(imgInput, input.prompt);
+        return { content: JSON.stringify(result) };
+    },
+};
+exports.visionExtractTextTool = {
+    name: 'vision_extract_text',
+    description: 'Extract text (OCR) from an image.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            image_url: { type: 'string', description: 'URL of the image' },
+            image_base64: { type: 'string', description: 'Base64-encoded image data' },
+        },
+    },
+    async execute(input) {
+        const imgInput = input.image_url
+            ? { type: 'url', data: input.image_url }
+            : { type: 'base64', data: input.image_base64 };
+        const text = await manager.extractText(imgInput);
+        return { content: text };
+    },
+};
+exports.visionCompareTool = {
+    name: 'vision_compare',
+    description: 'Compare multiple images.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            image_urls: { type: 'array', items: { type: 'string' }, description: 'URLs of images to compare' },
+            prompt: { type: 'string', description: 'Optional comparison prompt' },
+        },
+    },
+    async execute(input) {
+        const urls = input.image_urls;
+        const images = urls.map(url => ({ type: 'url', data: url }));
+        const result = await manager.compareImages(images, input.prompt);
+        return { content: result };
+    },
+};
+exports.visionTools = [exports.visionAnalyzeTool, exports.visionExtractTextTool, exports.visionCompareTool];
+//# sourceMappingURL=vision.js.map

package/dist/tools/builtin/web-search.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Web Search & Read Built-in Tools - v0.10.0
+ * Registers web_search and web_read as agent-callable tools.
+ */
+import type { MCPTool } from '../mcp';
+export declare const webSearchTool: MCPTool;
+export declare const webReadTool: MCPTool;
+export declare const webSearchTools: MCPTool[];
+//# sourceMappingURL=web-search.d.ts.map

package/dist/tools/builtin/web-search.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * Web Search & Read Built-in Tools - v0.10.0
+ * Registers web_search and web_read as agent-callable tools.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSearchTools = exports.webReadTool = exports.webSearchTool = void 0;
+const web_search_1 = require("../web-search");
+const web_scraper_1 = require("../web-scraper");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os = __importStar(require("os"));
+function loadSearchConfig() {
+    try {
+        const cfgPath = (0, path_1.join)(os.homedir(), '.opc', 'config.json');
+        if ((0, fs_1.existsSync)(cfgPath)) {
+            const cfg = JSON.parse((0, fs_1.readFileSync)(cfgPath, 'utf-8'));
+            if (cfg.webSearch) {
+                return { ...web_search_1.DEFAULT_SEARCH_CONFIG, ...cfg.webSearch };
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return web_search_1.DEFAULT_SEARCH_CONFIG;
+}
+exports.webSearchTool = {
+    name: 'web_search',
+    description: 'Search the internet for information. Returns titles, URLs, and snippets from search results. Use when you need current information or facts you\'re unsure about.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Search query string',
+            },
+            maxResults: {
+                type: 'number',
+                description: 'Maximum number of results to return (default: 5)',
+            },
+            engine: {
+                type: 'string',
+                enum: ['duckduckgo', 'brave', 'searxng', 'google'],
+                description: 'Search engine to use (default: configured engine)',
+            },
+        },
+        required: ['query'],
+    },
+    async execute(input) {
+        const query = String(input.query ?? '');
+        if (!query.trim()) {
+            return { content: 'Error: empty search query', isError: true };
+        }
+        const config = loadSearchConfig();
+        if (!config.enabled) {
+            return { content: 'Web search is disabled in settings.', isError: true };
+        }
+        try {
+            const results = await (0, web_search_1.webSearch)(query, config, {
+                maxResults: input.maxResults || 5,
+                engine: input.engine,
+            });
+            if (results.length === 0) {
+                return { content: `No results found for: ${query}` };
+            }
+            const formatted = results.map((r, i) => `${i + 1}. **${r.title}**\n   ${r.url}\n   ${r.snippet}`).join('\n\n');
+            return {
+                content: `Search results for "${query}":\n\n${formatted}`,
+                metadata: { resultCount: results.length, query },
+            };
+        }
+        catch (err) {
+            return {
+                content: `Search error: ${err instanceof Error ? err.message : String(err)}`,
+                isError: true,
+            };
+        }
+    },
+};
+exports.webReadTool = {
+    name: 'web_read',
+    description: 'Read and extract the main content from a web page URL. Returns clean markdown text. Use to get detailed information from a specific page.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            url: {
+                type: 'string',
+                description: 'URL of the web page to read',
+            },
+            maxLength: {
+                type: 'number',
+                description: 'Maximum content length in characters (default: 5000)',
+            },
+        },
+        required: ['url'],
+    },
+    async execute(input) {
+        const url = String(input.url ?? '');
+        if (!url.trim()) {
+            return { content: 'Error: empty URL', isError: true };
+        }
+        try {
+            const result = await (0, web_scraper_1.scrapeUrl)(url, input.maxLength || 5000);
+            return {
+                content: `# ${result.title}\n\nSource: ${result.url}\nWords: ${result.wordCount}\n\n---\n\n${result.content}`,
+                metadata: { title: result.title, url: result.url, wordCount: result.wordCount },
+            };
+        }
+        catch (err) {
+            return {
+                content: `Scrape error: ${err instanceof Error ? err.message : String(err)}`,
+                isError: true,
+            };
+        }
+    },
+};
+exports.webSearchTools = [exports.webSearchTool, exports.webReadTool];
+//# sourceMappingURL=web-search.js.map

package/dist/tools/document-processor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Document Processor - Parse and chunk documents for knowledge learning
+ * Supports: PDF, TXT, MD, DOCX, CSV, JSON
+ */
+export interface DocumentChunk {
+    title: string;
+    content: string;
+    metadata: {
+        source: string;
+        format: string;
+        chunkIndex: number;
+        totalChunks?: number;
+        page?: number;
+    };
+}
+export interface ProcessedDocument {
+    id: string;
+    filename: string;
+    format: string;
+    size: number;
+    chunks: DocumentChunk[];
+    processedAt: string;
+}
+export declare class DocumentProcessor {
+    /**
+     * Process a file buffer into chunks
+     */
+    process(buffer: Buffer, filename: string): Promise<ProcessedDocument>;
+    private parsePDF;
+    private parseDOCX;
+    private parseCSV;
+    private parseCSVLine;
+    private parseJSON;
+    /**
+     * Smart chunking: split by headings/paragraphs, respecting size limits
+     */
+    private chunkText;
+}
+//# sourceMappingURL=document-processor.d.ts.map

package/dist/tools/document-processor.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Document Processor - Parse and chunk documents for knowledge learning
+ * Supports: PDF, TXT, MD, DOCX, CSV, JSON
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentProcessor = void 0;
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+const CHUNK_TARGET_CHARS = 2000; // ~500 tokens
+const CHUNK_MAX_CHARS = 4000; // ~1000 tokens
+class DocumentProcessor {
+    /**
+     * Process a file buffer into chunks
+     */
+    async process(buffer, filename) {
+        if (buffer.length > MAX_FILE_SIZE) {
+            throw new Error(`File too large: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (max 50MB)`);
+        }
+        const ext = filename.split('.').pop()?.toLowerCase() || '';
+        let rawText;
+        switch (ext) {
+            case 'pdf':
+                rawText = await this.parsePDF(buffer);
+                break;
+            case 'docx':
+                rawText = await this.parseDOCX(buffer);
+                break;
+            case 'csv':
+                rawText = this.parseCSV(buffer.toString('utf-8'));
+                break;
+            case 'json':
+                rawText = this.parseJSON(buffer.toString('utf-8'));
+                break;
+            case 'txt':
+            case 'md':
+            case 'markdown':
+                rawText = buffer.toString('utf-8');
+                break;
+            default:
+                // Try as plain text
+                rawText = buffer.toString('utf-8');
+        }
+        const chunks = this.chunkText(rawText, filename, ext);
+        return {
+            id: `doc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            filename,
+            format: ext,
+            size: buffer.length,
+            chunks,
+            processedAt: new Date().toISOString(),
+        };
+    }
+    async parsePDF(buffer) {
+        try {
+            const pdfParse = require('pdf-parse');
+            const data = await pdfParse(buffer);
+            return data.text || '';
+        }
+        catch (e) {
+            throw new Error(`PDF parse failed: ${e.message}`);
+        }
+    }
+    async parseDOCX(buffer) {
+        try {
+            const mammoth = require('mammoth');
+            const result = await mammoth.extractRawText({ buffer });
+            return result.value || '';
+        }
+        catch (e) {
+            throw new Error(`DOCX parse failed: ${e.message}`);
+        }
+    }
+    parseCSV(text) {
+        const lines = text.split('\n').filter(l => l.trim());
+        if (lines.length === 0)
+            return '';
+        const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
+        const rows = lines.slice(1);
+        // Convert CSV to readable text
+        return rows.map((row, i) => {
+            const values = this.parseCSVLine(row);
+            const pairs = headers.map((h, j) => `${h}: ${values[j] || ''}`);
+            return `Record ${i + 1}:\n${pairs.join('\n')}`;
+        }).join('\n\n');
+    }
+    parseCSVLine(line) {
+        const result = [];
+        let current = '';
+        let inQuotes = false;
+        for (const ch of line) {
+            if (ch === '"') {
+                inQuotes = !inQuotes;
+            }
+            else if (ch === ',' && !inQuotes) {
+                result.push(current.trim());
+                current = '';
+            }
+            else {
+                current += ch;
+            }
+        }
+        result.push(current.trim());
+        return result;
+    }
+    parseJSON(text) {
+        try {
+            const data = JSON.parse(text);
+            if (Array.isArray(data)) {
+                return data.map((item, i) => `Item ${i + 1}:\n${JSON.stringify(item, null, 2)}`).join('\n\n');
+            }
+            return JSON.stringify(data, null, 2);
+        }
+        catch {
+            return text;
+        }
+    }
+    /**
+     * Smart chunking: split by headings/paragraphs, respecting size limits
+     */
+    chunkText(text, filename, format) {
+        if (!text.trim())
+            return [];
+        // Split by markdown headings or double newlines
+        const sections = text.split(/\n(?=#{1,3}\s)|(?:\n\s*\n)/).filter(s => s.trim());
+        const chunks = [];
+        let currentChunk = '';
+        let currentTitle = filename;
+        for (const section of sections) {
+            const headingMatch = section.match(/^(#{1,3})\s+(.+)/);
+            if (headingMatch) {
+                currentTitle = headingMatch[2].trim();
+            }
+            if (currentChunk.length + section.length > CHUNK_MAX_CHARS && currentChunk.length > 0) {
+                chunks.push({
+                    title: currentTitle,
+                    content: currentChunk.trim(),
+                    metadata: { source: filename, format, chunkIndex: chunks.length },
+                });
+                currentChunk = '';
+            }
+            currentChunk += section + '\n\n';
+            if (currentChunk.length >= CHUNK_TARGET_CHARS) {
+                chunks.push({
+                    title: currentTitle,
+                    content: currentChunk.trim(),
+                    metadata: { source: filename, format, chunkIndex: chunks.length },
+                });
+                currentChunk = '';
+            }
+        }
+        if (currentChunk.trim()) {
+            chunks.push({
+                title: currentTitle,
+                content: currentChunk.trim(),
+                metadata: { source: filename, format, chunkIndex: chunks.length },
+            });
+        }
+        // If we got no chunks from section splitting (e.g. dense text), force-split
+        if (chunks.length === 0 && text.trim()) {
+            const words = text.split(/\s+/);
+            let buf = '';
+            for (const w of words) {
+                if (buf.length + w.length + 1 > CHUNK_MAX_CHARS && buf) {
+                    chunks.push({
+                        title: filename,
+                        content: buf.trim(),
+                        metadata: { source: filename, format, chunkIndex: chunks.length },
+                    });
+                    buf = '';
+                }
+                buf += w + ' ';
+            }
+            if (buf.trim()) {
+                chunks.push({
+                    title: filename,
+                    content: buf.trim(),
+                    metadata: { source: filename, format, chunkIndex: chunks.length },
+                });
+            }
+        }
+        // Set totalChunks
+        for (const c of chunks)
+            c.metadata.totalChunks = chunks.length;
+        return chunks;
+    }
+}
+exports.DocumentProcessor = DocumentProcessor;
+//# sourceMappingURL=document-processor.js.map