claude-eidetic 0.1.0

package/dist/format.js

@@ -0,0 +1,97 @@
+import { listProjects } from './state/registry.js';
+export function textResult(text) {
+    return { content: [{ type: 'text', text }] };
+}
+export function formatIndexResult(result, normalizedPath) {
+    const lines = [
+        `Indexing complete for ${normalizedPath}`,
+        '',
+        `| Metric | Value |`,
+        `|--------|-------|`,
+        `| Total files | ${result.totalFiles} |`,
+        `| Total chunks | ${result.totalChunks} |`,
+        `| Added files | ${result.addedFiles} |`,
+        `| Modified files | ${result.modifiedFiles} |`,
+        `| Removed files | ${result.removedFiles} |`,
+        `| Skipped (unchanged) | ${result.skippedFiles} |`,
+        `| Parse failures | ${result.parseFailures.length} |`,
+        `| Estimated tokens | ~${(result.estimatedTokens / 1000).toFixed(0)}K |`,
+        `| Estimated cost | $${result.estimatedCostUsd.toFixed(4)} |`,
+        `| Duration | ${(result.durationMs / 1000).toFixed(1)}s |`,
+    ];
+    if (result.parseFailures.length > 0) {
+        lines.push('');
+        lines.push('**Parse Failures:**');
+        const toShow = result.parseFailures.slice(0, 10);
+        for (const file of toShow) {
+            lines.push(`- ${file}`);
+        }
+        if (result.parseFailures.length > 10) {
+            lines.push(`- ... and ${result.parseFailures.length - 10} more`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatPreview(preview, rootPath) {
+    const lines = [`Preview for ${rootPath}:`, ''];
+    // Extension table
+    const sorted = Object.entries(preview.byExtension)
+        .sort((a, b) => b[1] - a[1]);
+    if (sorted.length > 0) {
+        lines.push('| Extension | Files |');
+        lines.push('|-----------|-------|');
+        for (const [ext, count] of sorted) {
+            lines.push(`| ${ext} | ${count.toLocaleString()} |`);
+        }
+    }
+    lines.push(`Total: ${preview.totalFiles.toLocaleString()} files`, '');
+    // Top directories
+    if (preview.topDirectories.length > 0) {
+        lines.push('Top directories:');
+        for (const { dir, count } of preview.topDirectories) {
+            lines.push(`  ${dir}/: ${count.toLocaleString()} files`);
+        }
+        lines.push('');
+    }
+    // Cost estimate
+    const tokenStr = preview.estimatedTokens >= 1_000_000
+        ? `~${(preview.estimatedTokens / 1_000_000).toFixed(1)}M`
+        : `~${(preview.estimatedTokens / 1000).toFixed(0)}K`;
+    lines.push(`Estimated: ${tokenStr} tokens (~$${preview.estimatedCostUsd.toFixed(4)})`, '');
+    // Warnings
+    lines.push('Warnings:');
+    if (preview.warnings.length === 0) {
+        lines.push('- None');
+    }
+    else {
+        for (const w of preview.warnings) {
+            lines.push(`- ${w}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatListIndexed(states) {
+    const registry = listProjects();
+    const pathToProject = new Map(Object.entries(registry).map(([name, p]) => [p, name]));
+    const lines = [`## Indexed Codebases (${states.length})\n`];
+    for (const s of states) {
+        const projectName = pathToProject.get(s.path);
+        const heading = projectName ? `${s.path} (project: \`${projectName}\`)` : s.path;
+        lines.push(`### ${heading}`);
+        lines.push(`- **Status:** ${s.status}`);
+        if (s.totalFiles)
+            lines.push(`- **Files:** ${s.totalFiles}`);
+        if (s.totalChunks)
+            lines.push(`- **Chunks:** ${s.totalChunks}`);
+        if (s.lastIndexed)
+            lines.push(`- **Last indexed:** ${s.lastIndexed}`);
+        if (s.status === 'indexing' && s.progress !== undefined) {
+            lines.push(`- **Progress:** ${s.progress}% — ${s.progressMessage ?? ''}`);
+        }
+        if (s.error)
+            lines.push(`- **Error:** ${s.error}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=format.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// CRITICAL: Redirect console outputs to stderr BEFORE any imports
+// Only MCP protocol messages should go to stdout
+console.log = (...args) => {
+    process.stderr.write('[LOG] ' + args.join(' ') + '\n');
+};
+console.warn = (...args) => {
+    process.stderr.write('[WARN] ' + args.join(' ') + '\n');
+};
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { loadConfig } from './config.js';
+import { createEmbedding } from './embedding/factory.js';
+import { QdrantVectorDB } from './vectordb/qdrant.js';
+import { bootstrapQdrant } from './infra/qdrant-bootstrap.js';
+import { StateManager, cleanupOrphanedSnapshots } from './state/snapshot.js';
+import { ToolHandlers } from './tools.js';
+import { TOOL_DEFINITIONS } from './tool-schemas.js';
+const WORKFLOW_GUIDANCE = `# Eidetic Code Search Workflow
+
+**Before searching:** Ensure the codebase is indexed.
+- \`list_indexed\` → see what's already indexed
+- \`index_codebase(path="...", dryRun=true)\` → preview before indexing
+- \`index_codebase(path="...")\` → index (incremental, only re-embeds changed files)
+
+**Searching efficiently:**
+- \`search_code(query="...")\` → returns compact table by default (~20 tokens/result)
+- Review the table, then use Read tool to fetch full code for interesting results
+- Add \`compact=false\` only when you need all code snippets immediately
+- Use \`extensionFilter\` to narrow by file type
+- Use \`project\` param instead of \`path\` for convenience
+- Start with specific queries, broaden if no results
+
+**After first index:**
+- Re-indexing is incremental (only changed files re-embedded)
+- Use \`project\` param instead of \`path\` for convenience
+- Use \`get_indexing_status\` to check progress during long indexes
+
+**Cross-project search:**
+- Index multiple projects, each with its own path
+- Search across any indexed project regardless of current working directory`;
+async function main() {
+    const config = loadConfig();
+    console.log(`Config loaded. Provider: ${config.vectordbProvider}, Model: ${config.embeddingModel}`);
+    const embedding = createEmbedding(config);
+    await embedding.initialize();
+    let vectordb;
+    if (config.vectordbProvider === 'milvus') {
+        const { MilvusVectorDB } = await import('./vectordb/milvus.js');
+        vectordb = new MilvusVectorDB();
+        console.log(`Using Milvus at ${config.milvusAddress}`);
+    }
+    else {
+        const qdrantUrl = await bootstrapQdrant();
+        vectordb = new QdrantVectorDB(qdrantUrl);
+        console.log(`Using Qdrant at ${qdrantUrl}`);
+    }
+    const cleaned = await cleanupOrphanedSnapshots(vectordb);
+    if (cleaned > 0) {
+        console.log(`Cleaned ${cleaned} orphaned snapshot(s).`);
+    }
+    const state = new StateManager();
+    const handlers = new ToolHandlers(embedding, vectordb, state);
+    const server = new Server({ name: 'claude-eidetic', version: '0.1.0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [...TOOL_DEFINITIONS],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        switch (name) {
+            case 'index_codebase':
+                return handlers.handleIndexCodebase(args ?? {});
+            case 'search_code':
+                return handlers.handleSearchCode(args ?? {});
+            case 'clear_index':
+                return handlers.handleClearIndex(args ?? {});
+            case 'get_indexing_status':
+                return handlers.handleGetIndexingStatus(args ?? {});
+            case 'list_indexed':
+                return handlers.handleListIndexed();
+            case '__IMPORTANT':
+                return {
+                    content: [{ type: 'text', text: WORKFLOW_GUIDANCE }],
+                };
+            default:
+                return {
+                    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.log('Claude Eidetic MCP server started on stdio.');
+}
+process.on('SIGINT', () => {
+    console.error('Received SIGINT, shutting down...');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    console.error('Received SIGTERM, shutting down...');
+    process.exit(0);
+});
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/infra/qdrant-bootstrap.d.ts

@@ -0,0 +1,2 @@
+export declare function bootstrapQdrant(): Promise<string>;
+//# sourceMappingURL=qdrant-bootstrap.d.ts.map

package/dist/infra/qdrant-bootstrap.js

@@ -0,0 +1,94 @@
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { BootstrapError } from '../errors.js';
+import { getConfig } from '../config.js';
+import { getDataDir } from '../paths.js';
+const CONTAINER_NAME = 'eidetic-qdrant';
+const HEALTH_TIMEOUT_MS = 30_000;
+const HEALTH_POLL_MS = 500;
+export async function bootstrapQdrant() {
+    const config = getConfig();
+    const url = config.qdrantUrl;
+    if (await isQdrantHealthy(url)) {
+        console.log(`Qdrant reachable at ${url}`);
+        return url;
+    }
+    console.log(`Qdrant not reachable at ${url}. Attempting Docker auto-provision...`);
+    if (!isDockerAvailable()) {
+        throw new BootstrapError(`Qdrant not reachable at ${url} and Docker not found.\n` +
+            `Either: (a) install Docker and retry, or (b) set QDRANT_URL to your Qdrant instance.`);
+    }
+    const containerState = getContainerState();
+    if (containerState === 'running') {
+        console.log(`Container "${CONTAINER_NAME}" is running. Waiting for health...`);
+    }
+    else if (containerState === 'stopped') {
+        console.log(`Container "${CONTAINER_NAME}" exists but stopped. Starting...`);
+        execFileSync('docker', ['start', CONTAINER_NAME], { stdio: 'pipe' });
+    }
+    else {
+        const dataDir = path.join(getDataDir(), 'qdrant-data').replace(/\\/g, '/');
+        console.log(`Creating new Qdrant container "${CONTAINER_NAME}"...`);
+        execFileSync('docker', [
+            'run', '-d',
+            '--name', CONTAINER_NAME,
+            '--restart', 'unless-stopped',
+            '-p', '6333:6333',
+            '-p', '6334:6334',
+            '-v', `${dataDir}:/qdrant/storage`,
+            'qdrant/qdrant',
+        ], { stdio: 'pipe' });
+    }
+    const healthy = await waitForHealth(url, HEALTH_TIMEOUT_MS);
+    if (!healthy) {
+        throw new BootstrapError(`Qdrant container started but failed health check after ${HEALTH_TIMEOUT_MS / 1000}s. ` +
+            `Check: docker logs ${CONTAINER_NAME}`);
+    }
+    console.log(`Qdrant auto-provisioned and healthy at ${url}`);
+    return url;
+}
+async function isQdrantHealthy(url) {
+    try {
+        const resp = await fetch(`${url}/healthz`, { signal: AbortSignal.timeout(3000) });
+        return resp.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function isDockerAvailable() {
+    try {
+        execFileSync('docker', ['info'], { stdio: 'pipe', timeout: 10_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getContainerState() {
+    try {
+        const output = execFileSync('docker', [
+            'ps', '-a',
+            '--filter', `name=^/${CONTAINER_NAME}$`,
+            '--format', '{{.State}}',
+        ], { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (!output)
+            return 'none';
+        if (output === 'running')
+            return 'running';
+        return 'stopped';
+    }
+    catch {
+        return 'none';
+    }
+}
+async function waitForHealth(url, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await isQdrantHealthy(url))
+            return true;
+        await new Promise(r => setTimeout(r, HEALTH_POLL_MS));
+    }
+    return false;
+}
+//# sourceMappingURL=qdrant-bootstrap.js.map

package/dist/paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Normalize a path to forward slashes, resolve to absolute, remove trailing slash.
+ * This is the single source of truth for path handling — called at every boundary.
+ */
+export declare function normalizePath(inputPath: string): string;
+export declare function getDataDir(): string;
+export declare function getSnapshotDir(): string;
+export declare function getCacheDir(): string;
+export declare function getRegistryPath(): string;
+export declare function pathToCollectionName(absolutePath: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import os from 'node:os';
+import { getConfig } from './config.js';
+/**
+ * Normalize a path to forward slashes, resolve to absolute, remove trailing slash.
+ * This is the single source of truth for path handling — called at every boundary.
+ */
+export function normalizePath(inputPath) {
+    let resolved = inputPath;
+    if (resolved.startsWith('~')) {
+        resolved = path.join(os.homedir(), resolved.slice(1));
+    }
+    resolved = path.resolve(resolved);
+    resolved = resolved.replace(/\\/g, '/');
+    if (resolved.length > 1 && resolved.endsWith('/')) {
+        resolved = resolved.slice(0, -1);
+    }
+    return resolved;
+}
+export function getDataDir() {
+    return normalizePath(getConfig().eideticDataDir);
+}
+export function getSnapshotDir() {
+    return `${getDataDir()}/snapshots`;
+}
+export function getCacheDir() {
+    return `${getDataDir()}/cache`;
+}
+export function getRegistryPath() {
+    return `${getDataDir()}/registry.json`;
+}
+export function pathToCollectionName(absolutePath) {
+    const normalized = normalizePath(absolutePath);
+    const safe = normalized
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '');
+    return `eidetic_${safe}`;
+}
+//# sourceMappingURL=paths.js.map

package/dist/splitter/ast.d.ts

@@ -0,0 +1,13 @@
+import type { Splitter, CodeChunk } from './types.js';
+export declare class AstSplitter implements Splitter {
+    private parser;
+    private currentLang;
+    private static langCache;
+    private static resolveLanguage;
+    split(code: string, language: string, filePath: string): CodeChunk[];
+    static isSupported(language: string): boolean;
+    private extractChunks;
+    private refineChunks;
+    private splitLargeChunk;
+}
+//# sourceMappingURL=ast.d.ts.map

package/dist/splitter/ast.js

@@ -0,0 +1,169 @@
+import { createRequire } from 'node:module';
+// tree-sitter and language parsers are native CommonJS modules
+const require = createRequire(import.meta.url);
+const Parser = require('tree-sitter');
+// Lazy-load language parsers to avoid startup cost for unused languages
+const languageParsers = {
+    javascript: () => require('tree-sitter-javascript'),
+    js: () => require('tree-sitter-javascript'),
+    typescript: () => require('tree-sitter-typescript').typescript,
+    ts: () => require('tree-sitter-typescript').typescript,
+    tsx: () => require('tree-sitter-typescript').tsx,
+    python: () => require('tree-sitter-python'),
+    py: () => require('tree-sitter-python'),
+    go: () => require('tree-sitter-go'),
+    java: () => require('tree-sitter-java'),
+    rust: () => require('tree-sitter-rust'),
+    rs: () => require('tree-sitter-rust'),
+    cpp: () => require('tree-sitter-cpp'),
+    'c++': () => require('tree-sitter-cpp'),
+    c: () => require('tree-sitter-cpp'),
+    csharp: () => require('tree-sitter-c-sharp'),
+    cs: () => require('tree-sitter-c-sharp'),
+};
+// AST node types that represent logical code units per language
+const SPLITTABLE_TYPES = {
+    javascript: ['function_declaration', 'arrow_function', 'class_declaration', 'method_definition', 'export_statement'],
+    typescript: ['function_declaration', 'arrow_function', 'class_declaration', 'method_definition', 'export_statement', 'interface_declaration', 'type_alias_declaration'],
+    tsx: ['function_declaration', 'arrow_function', 'class_declaration', 'method_definition', 'export_statement', 'interface_declaration', 'type_alias_declaration'],
+    python: ['function_definition', 'class_definition', 'decorated_definition', 'async_function_definition'],
+    java: ['method_declaration', 'class_declaration', 'interface_declaration', 'constructor_declaration'],
+    cpp: ['function_definition', 'class_specifier', 'namespace_definition', 'declaration'],
+    go: ['function_declaration', 'method_declaration', 'type_declaration', 'var_declaration', 'const_declaration'],
+    rust: ['function_item', 'impl_item', 'struct_item', 'enum_item', 'trait_item', 'mod_item'],
+    csharp: ['method_declaration', 'class_declaration', 'interface_declaration', 'struct_declaration', 'enum_declaration'],
+};
+// Map aliases to canonical language names for node type lookup
+const LANG_CANONICAL = {
+    js: 'javascript', ts: 'typescript', py: 'python',
+    rs: 'rust', 'c++': 'cpp', c: 'cpp', cs: 'csharp',
+};
+const MAX_CHUNK_CHARS = 2500;
+export class AstSplitter {
+    parser = new Parser();
+    currentLang = '';
+    // Shared across all AstSplitter instances — one cache per process
+    static langCache = new Map();
+    static resolveLanguage(lang) {
+        // Resolve alias to canonical name first — prevents duplicate cache entries
+        const canonical = LANG_CANONICAL[lang] ?? lang;
+        const cached = AstSplitter.langCache.get(canonical);
+        if (cached)
+            return cached;
+        const factory = languageParsers[canonical] ?? languageParsers[lang];
+        if (!factory)
+            return null;
+        try {
+            const mod = factory();
+            AstSplitter.langCache.set(canonical, mod);
+            return mod;
+        }
+        catch (err) {
+            console.warn(`Failed to load tree-sitter parser for "${lang}": ${err}`);
+            return null;
+        }
+    }
+    split(code, language, filePath) {
+        const lang = language.toLowerCase();
+        const canonical = LANG_CANONICAL[lang] ?? lang;
+        const langModule = AstSplitter.resolveLanguage(lang);
+        if (!langModule) {
+            return []; // Caller should fall back to line splitter
+        }
+        try {
+            // Skip setLanguage() if parser is already configured for this language
+            if (canonical !== this.currentLang) {
+                this.parser.setLanguage(langModule);
+                this.currentLang = canonical;
+            }
+            const tree = this.parser.parse(code);
+            if (!tree.rootNode)
+                return [];
+            const nodeTypes = SPLITTABLE_TYPES[canonical] ?? [];
+            const rawChunks = this.extractChunks(tree.rootNode, code, nodeTypes, language, filePath);
+            // If no meaningful chunks found, return empty (caller will use line splitter)
+            if (rawChunks.length === 0)
+                return [];
+            return this.refineChunks(rawChunks);
+        }
+        catch (err) {
+            console.warn(`AST parse failed for "${filePath}" (${language}): ${err}`);
+            return []; // Caller should fall back to line splitter
+        }
+    }
+    static isSupported(language) {
+        return language.toLowerCase() in languageParsers;
+    }
+    extractChunks(node, code, splittableTypes, language, filePath) {
+        const chunks = [];
+        const traverse = (current) => {
+            if (splittableTypes.includes(current.type)) {
+                const text = code.slice(current.startIndex, current.endIndex);
+                if (text.trim().length > 0) {
+                    chunks.push({
+                        content: text,
+                        startLine: current.startPosition.row + 1,
+                        endLine: current.endPosition.row + 1,
+                        language,
+                        filePath,
+                    });
+                }
+            }
+            for (const child of current.children) {
+                traverse(child);
+            }
+        };
+        traverse(node);
+        return chunks;
+    }
+    refineChunks(chunks) {
+        const result = [];
+        for (const chunk of chunks) {
+            if (chunk.content.length <= MAX_CHUNK_CHARS) {
+                result.push(chunk);
+            }
+            else {
+                result.push(...this.splitLargeChunk(chunk));
+            }
+        }
+        return result;
+    }
+    splitLargeChunk(chunk) {
+        const lines = chunk.content.split('\n');
+        const subChunks = [];
+        let current = '';
+        let startLine = chunk.startLine;
+        let lineCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const addition = i < lines.length - 1 ? line + '\n' : line;
+            if (current.length + addition.length > MAX_CHUNK_CHARS && current.length > 0) {
+                subChunks.push({
+                    content: current,
+                    startLine,
+                    endLine: startLine + lineCount - 1,
+                    language: chunk.language,
+                    filePath: chunk.filePath,
+                });
+                current = addition;
+                startLine = chunk.startLine + i;
+                lineCount = 1;
+            }
+            else {
+                current += addition;
+                lineCount++;
+            }
+        }
+        if (current.trim().length > 0) {
+            subChunks.push({
+                content: current,
+                startLine,
+                endLine: startLine + lineCount - 1,
+                language: chunk.language,
+                filePath: chunk.filePath,
+            });
+        }
+        return subChunks;
+    }
+}
+//# sourceMappingURL=ast.js.map

package/dist/splitter/line.d.ts

@@ -0,0 +1,14 @@
+import type { Splitter, CodeChunk } from './types.js';
+/**
+ * Simple line-based splitter. Used as fallback when tree-sitter
+ * doesn't support the language or fails to parse.
+ */
+export declare class LineSplitter implements Splitter {
+    private chunkLines;
+    private overlapLines;
+    constructor(chunkLines?: number, overlapLines?: number);
+    split(code: string, language: string, filePath: string): CodeChunk[];
+    private refineChunks;
+    private splitLargeChunk;
+}
+//# sourceMappingURL=line.d.ts.map

package/dist/splitter/line.js

@@ -0,0 +1,109 @@
+const DEFAULT_CHUNK_LINES = 60;
+const OVERLAP_LINES = 5;
+const MAX_CHUNK_CHARS = 2500;
+/**
+ * Simple line-based splitter. Used as fallback when tree-sitter
+ * doesn't support the language or fails to parse.
+ */
+export class LineSplitter {
+    chunkLines;
+    overlapLines;
+    constructor(chunkLines = DEFAULT_CHUNK_LINES, overlapLines = OVERLAP_LINES) {
+        this.chunkLines = chunkLines;
+        this.overlapLines = Math.min(overlapLines, chunkLines - 1);
+    }
+    split(code, language, filePath) {
+        const lines = code.split('\n');
+        if (lines.length === 0)
+            return [];
+        const raw = [];
+        let start = 0;
+        while (start < lines.length) {
+            const end = Math.min(start + this.chunkLines, lines.length);
+            const content = lines.slice(start, end).join('\n');
+            if (content.trim().length > 0) {
+                raw.push({
+                    content,
+                    startLine: start + 1,
+                    endLine: end,
+                    language,
+                    filePath,
+                });
+            }
+            start = Math.max(start + 1, end - this.overlapLines);
+        }
+        return this.refineChunks(raw);
+    }
+    refineChunks(chunks) {
+        const result = [];
+        for (const chunk of chunks) {
+            if (chunk.content.length <= MAX_CHUNK_CHARS) {
+                result.push(chunk);
+            }
+            else {
+                result.push(...this.splitLargeChunk(chunk));
+            }
+        }
+        return result;
+    }
+    splitLargeChunk(chunk) {
+        const lines = chunk.content.split('\n');
+        const subChunks = [];
+        let current = '';
+        let startLine = chunk.startLine;
+        let lineCount = 0;
+        const flush = () => {
+            if (current.trim().length > 0) {
+                subChunks.push({
+                    content: current,
+                    startLine,
+                    endLine: startLine + lineCount - 1,
+                    language: chunk.language,
+                    filePath: chunk.filePath,
+                });
+            }
+        };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const addition = i < lines.length - 1 ? line + '\n' : line;
+            if (current.length + addition.length > MAX_CHUNK_CHARS && current.length > 0) {
+                flush();
+                current = '';
+                startLine = chunk.startLine + i;
+                lineCount = 0;
+            }
+            // If a single line exceeds the limit, hard-split it by characters
+            if (addition.length > MAX_CHUNK_CHARS) {
+                // Flush anything accumulated before this line
+                if (current.length > 0) {
+                    flush();
+                    current = '';
+                    startLine = chunk.startLine + i;
+                    lineCount = 0;
+                }
+                const lineNum = chunk.startLine + i;
+                for (let offset = 0; offset < addition.length; offset += MAX_CHUNK_CHARS) {
+                    const slice = addition.slice(offset, offset + MAX_CHUNK_CHARS);
+                    if (slice.trim().length > 0) {
+                        subChunks.push({
+                            content: slice,
+                            startLine: lineNum,
+                            endLine: lineNum,
+                            language: chunk.language,
+                            filePath: chunk.filePath,
+                        });
+                    }
+                }
+                startLine = chunk.startLine + i + 1;
+                lineCount = 0;
+            }
+            else {
+                current += addition;
+                lineCount++;
+            }
+        }
+        flush();
+        return subChunks;
+    }
+}
+//# sourceMappingURL=line.js.map