monomind 1.17.1 → 1.18.0

package/packages/@monomind/cli/dist/src/capabilities/cap-data.js

@@ -0,0 +1,165 @@
+import fs from 'fs';
+const DATA_EXTENSIONS = new Set(['.csv', '.tsv', '.json', '.jsonl', '.sqlite', '.parquet', '.xlsx', '.xls']);
+const MAX_INDEX_FILE_SIZE = 50 * 1024 * 1024; // 50MB — skip oversized files
+const indexedData = new Map();
+// Splits a single CSV/TSV line on `delimiter`, respecting basic RFC 4180 quoting:
+// fields starting with `"` are read until the matching closing `"` before the
+// delimiter is honored again. Does not handle escaped ("") quotes within a field.
+function splitCSVLine(line, delimiter) {
+    const fields = [];
+    let i = 0;
+    while (i <= line.length) {
+        if (line[i] === '"') {
+            const end = line.indexOf('"', i + 1);
+            const closeIdx = end === -1 ? line.length : end;
+            fields.push(line.slice(i + 1, closeIdx));
+            // advance past the closing quote and the following delimiter (if any)
+            const next = line.indexOf(delimiter, closeIdx + 1);
+            i = next === -1 ? line.length + 1 : next + 1;
+        }
+        else {
+            const next = line.indexOf(delimiter, i);
+            const closeIdx = next === -1 ? line.length : next;
+            fields.push(line.slice(i, closeIdx));
+            i = next === -1 ? line.length + 1 : next + 1;
+        }
+    }
+    return fields;
+}
+function parseCSV(content, delimiter = ',') {
+    const lines = content.trim().split('\n');
+    if (lines.length === 0)
+        return { columns: [], rows: [], totalRows: 0 };
+    const columns = splitCSVLine(lines[0], delimiter).map((c) => c.trim());
+    // Only parse first 3 data rows for samples — avoids wasting CPU on large files
+    const sampleLines = lines.slice(1, 4);
+    const rows = sampleLines.map((line) => splitCSVLine(line, delimiter).map((c) => c.trim()));
+    return { columns, rows, totalRows: lines.length - 1 };
+}
+function parseJSON(content) {
+    try {
+        const parsed = JSON.parse(content);
+        const arr = Array.isArray(parsed) ? parsed : [parsed];
+        if (arr.length === 0)
+            return { columns: [], rowCount: 0, sampleValues: Object.create(null) };
+        const columns = Object.keys(arr[0]).filter(k => k !== '__proto__' && k !== 'constructor' && k !== 'prototype');
+        const sampleValues = Object.create(null);
+        for (const col of columns) {
+            sampleValues[col] = arr.slice(0, 3).map((row) => String(row[col] ?? ''));
+        }
+        return { columns, rowCount: arr.length, sampleValues };
+    }
+    catch {
+        return { columns: [], rowCount: 0, sampleValues: Object.create(null) };
+    }
+}
+function parseJSONL(content) {
+    const lines = content.trim().split('\n').filter(l => l.trim());
+    if (lines.length === 0)
+        return { columns: [], rowCount: 0, sampleValues: Object.create(null) };
+    const rows = [];
+    for (const line of lines) {
+        try {
+            const obj = JSON.parse(line);
+            if (obj && typeof obj === 'object' && !Array.isArray(obj))
+                rows.push(obj);
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    if (rows.length === 0)
+        return { columns: [], rowCount: 0, sampleValues: Object.create(null) };
+    const columns = Object.keys(rows[0]).filter(k => k !== '__proto__' && k !== 'constructor' && k !== 'prototype');
+    const sampleValues = Object.create(null);
+    for (const col of columns) {
+        sampleValues[col] = rows.slice(0, 3).map(row => String(row[col] ?? ''));
+    }
+    return { columns, rowCount: rows.length, sampleValues };
+}
+export const dataCapability = {
+    name: 'data',
+    detect(scan) {
+        return scan.capabilities.data.confidence;
+    },
+    async activate(_rootDir) {
+        indexedData.clear();
+    },
+    async index(files) {
+        let indexed = 0;
+        let skipped = 0;
+        const errors = [];
+        for (const file of files) {
+            if (!DATA_EXTENSIONS.has(file.extension)) {
+                skipped++;
+                continue;
+            }
+            if (file.size > MAX_INDEX_FILE_SIZE) {
+                skipped++;
+                continue;
+            }
+            try {
+                let columns = [];
+                let rowCount = 0;
+                let sampleValues = {};
+                if (file.extension === '.csv' || file.extension === '.tsv') {
+                    const content = fs.readFileSync(file.absolutePath, 'utf-8');
+                    const parsed = parseCSV(content, file.extension === '.tsv' ? '\t' : ',');
+                    columns = parsed.columns;
+                    rowCount = parsed.totalRows;
+                    for (let colIdx = 0; colIdx < columns.length; colIdx++) {
+                        sampleValues[columns[colIdx]] = parsed.rows.map((row) => row[colIdx] ?? '');
+                    }
+                }
+                else if (file.extension === '.jsonl') {
+                    const content = fs.readFileSync(file.absolutePath, 'utf-8');
+                    const parsed = parseJSONL(content);
+                    columns = parsed.columns;
+                    rowCount = parsed.rowCount;
+                    sampleValues = parsed.sampleValues;
+                }
+                else if (file.extension === '.json') {
+                    const content = fs.readFileSync(file.absolutePath, 'utf-8');
+                    const parsed = parseJSON(content);
+                    columns = parsed.columns;
+                    rowCount = parsed.rowCount;
+                    sampleValues = parsed.sampleValues;
+                }
+                else {
+                    // .sqlite, .parquet, .xlsx — metadata only (no content extraction without heavy deps)
+                    columns = [];
+                    rowCount = 0;
+                }
+                const description = columns.length > 0
+                    ? `${file.path}: ${rowCount} rows, columns: ${columns.join(', ')}`
+                    : `${file.path}: structured data file`;
+                indexedData.set(file.path, { path: file.path, columns, rowCount, sampleValues, description });
+                indexed++;
+            }
+            catch (err) {
+                errors.push(`${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return { indexed, skipped, errors };
+    },
+    async search(query, limit = 20) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const [dataPath, entry] of indexedData) {
+            const descLower = entry.description.toLowerCase();
+            const colMatch = entry.columns.some((c) => c.toLowerCase().includes(queryLower));
+            const valMatch = Object.values(entry.sampleValues).flat().some((v) => v.toLowerCase().includes(queryLower));
+            if (descLower.includes(queryLower) || colMatch || valMatch) {
+                results.push({
+                    path: dataPath,
+                    score: colMatch ? 1.0 : valMatch ? 0.8 : 0.5,
+                    snippet: entry.description,
+                    type: 'data',
+                    metadata: { columns: entry.columns, rowCount: entry.rowCount },
+                });
+            }
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    },
+};
+//# sourceMappingURL=cap-data.js.map

package/packages/@monomind/cli/dist/src/capabilities/cap-documents.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityModule } from './types.js';
+export declare const documentsCapability: CapabilityModule;
+//# sourceMappingURL=cap-documents.d.ts.map

package/packages/@monomind/cli/dist/src/capabilities/cap-documents.js

@@ -0,0 +1,139 @@
+import fs from 'fs';
+const DOC_EXTENSIONS = new Set([
+    '.pdf',
+    '.docx',
+    '.doc',
+    '.md',
+    '.txt',
+    '.rtf',
+    '.rst',
+    '.tex',
+    '.odt',
+    '.pages',
+    '.epub',
+]);
+const MAX_INDEX_FILE_SIZE = 50 * 1024 * 1024; // 50MB — skip oversized text files
+// In-memory index for T0 (metadata) and T1 (content) — replaced by memory DB in production
+const indexedDocs = new Map();
+async function extractText(file) {
+    if (file.size > MAX_INDEX_FILE_SIZE)
+        return '';
+    const ext = file.extension;
+    if (ext === '.md' || ext === '.txt' || ext === '.rst' || ext === '.tex') {
+        return fs.readFileSync(file.absolutePath, 'utf-8');
+    }
+    if (ext === '.pdf') {
+        try {
+            // monolean: pdf-parse is an optional dependency — degrade to metadata-only if missing
+            const pdfParse = (await import('pdf-parse')).default;
+            const buffer = fs.readFileSync(file.absolutePath);
+            const data = await pdfParse(buffer);
+            return data.text;
+        }
+        catch {
+            return ''; // pdf-parse not installed or file unreadable
+        }
+    }
+    if (ext === '.docx') {
+        try {
+            // monolean: mammoth is an optional dependency — degrade to metadata-only if missing
+            const mammoth = await import('mammoth');
+            const result = await mammoth.extractRawText({ path: file.absolutePath });
+            return result.value;
+        }
+        catch {
+            return ''; // mammoth not installed or file unreadable
+        }
+    }
+    return '';
+}
+export const documentsCapability = {
+    name: 'documents',
+    detect(scan) {
+        return scan.capabilities.documents.confidence;
+    },
+    async activate(_rootDir) {
+        indexedDocs.clear();
+    },
+    async index(files) {
+        let indexed = 0;
+        let skipped = 0;
+        const errors = [];
+        for (const file of files) {
+            if (!DOC_EXTENSIONS.has(file.extension)) {
+                skipped++;
+                continue;
+            }
+            try {
+                const content = await extractText(file);
+                indexedDocs.set(file.path, {
+                    path: file.path,
+                    content,
+                    metadata: {
+                        size: file.size,
+                        modified: file.modified.toISOString(),
+                        created: file.created.toISOString(),
+                        extension: file.extension,
+                    },
+                });
+                indexed++;
+            }
+            catch (err) {
+                errors.push(`${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return { indexed, skipped, errors };
+    },
+    async search(query, limit = 20) {
+        // monolean: simple substring search for T0/T1 — vector search added when memory integration lands
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const [docPath, doc] of indexedDocs) {
+            const contentLower = doc.content.toLowerCase();
+            const idx = contentLower.indexOf(queryLower);
+            if (idx !== -1) {
+                const start = Math.max(0, idx - 40);
+                const end = Math.min(doc.content.length, idx + query.length + 40);
+                results.push({
+                    path: docPath,
+                    score: 1 / (idx + 1), // closer to start = higher score
+                    snippet: doc.content.slice(start, end).trim(),
+                    type: 'documents',
+                    metadata: doc.metadata,
+                });
+            }
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    },
+    async healthChecks() {
+        const checks = [];
+        // Check if PDF extraction is available
+        try {
+            await import('pdf-parse');
+            checks.push({ name: 'PDF Extraction', status: 'pass', message: 'pdf-parse available' });
+        }
+        catch {
+            checks.push({
+                name: 'PDF Extraction',
+                status: 'warn',
+                message: 'pdf-parse not installed',
+                hint: 'pnpm add pdf-parse',
+            });
+        }
+        // Check if docx extraction is available
+        try {
+            await import('mammoth');
+            checks.push({ name: 'DOCX Extraction', status: 'pass', message: 'mammoth available' });
+        }
+        catch {
+            checks.push({
+                name: 'DOCX Extraction',
+                status: 'warn',
+                message: 'mammoth not installed',
+                hint: 'pnpm add mammoth',
+            });
+        }
+        return checks;
+    },
+};
+//# sourceMappingURL=cap-documents.js.map

package/packages/@monomind/cli/dist/src/capabilities/cap-graph.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityModule } from './types.js';
+export declare const graphCapability: CapabilityModule;
+//# sourceMappingURL=cap-graph.d.ts.map

package/packages/@monomind/cli/dist/src/capabilities/cap-graph.js

@@ -0,0 +1,84 @@
+import path from 'path';
+const nodes = new Map();
+// Cap neighbors per node to keep memory bounded on large flat directories
+const MAX_NEIGHBORS = 50;
+function buildRelationships() {
+    // Relationship 1: same directory = siblings (capped to avoid O(n²) on huge flat dirs)
+    const byDir = new Map();
+    for (const [filePath, node] of nodes) {
+        const dir = node.directory;
+        if (!byDir.has(dir))
+            byDir.set(dir, []);
+        byDir.get(dir).push(filePath);
+    }
+    for (const siblings of byDir.values()) {
+        // For large directories, only link first MAX_NEIGHBORS items to each other
+        const capped = siblings.length > MAX_NEIGHBORS ? siblings.slice(0, MAX_NEIGHBORS) : siblings;
+        for (const a of capped) {
+            for (const b of capped) {
+                if (a !== b) {
+                    nodes.get(a).neighbors.add(b);
+                }
+            }
+        }
+    }
+    // Relationship 2: same date (within 1 day) = temporal neighbors
+    const sorted = [...nodes.entries()].sort((a, b) => a[1].modified.getTime() - b[1].modified.getTime());
+    for (let i = 0; i < sorted.length; i++) {
+        if (sorted[i][1].neighbors.size >= MAX_NEIGHBORS)
+            continue;
+        for (let j = i + 1; j < sorted.length; j++) {
+            const diffMs = sorted[j][1].modified.getTime() - sorted[i][1].modified.getTime();
+            if (diffMs >= 86400000)
+                break; // sorted — no further matches possible
+            if (sorted[i][1].directory !== sorted[j][1].directory) {
+                if (sorted[i][1].neighbors.size < MAX_NEIGHBORS)
+                    sorted[i][1].neighbors.add(sorted[j][0]);
+                if (sorted[j][1].neighbors.size < MAX_NEIGHBORS)
+                    sorted[j][1].neighbors.add(sorted[i][0]);
+            }
+        }
+    }
+}
+export const graphCapability = {
+    name: 'graph',
+    detect(_scan) {
+        return 0; // cross-cutting — activated by manager
+    },
+    async activate(_rootDir) {
+        nodes.clear();
+    },
+    async index(files) {
+        for (const file of files) {
+            nodes.set(file.path, {
+                path: file.path,
+                extension: file.extension,
+                directory: path.dirname(file.path),
+                modified: file.modified,
+                neighbors: new Set(),
+            });
+        }
+        buildRelationships();
+        return { indexed: files.length, skipped: 0, errors: [] };
+    },
+    async search(query, limit = 20) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const [filePath, node] of nodes) {
+            if (filePath.toLowerCase().includes(queryLower)) {
+                const neighborList = [...node.neighbors].slice(0, 3);
+                results.push({
+                    path: filePath,
+                    score: 1.0,
+                    snippet: neighborList.length > 0
+                        ? `Related: ${neighborList.join(', ')}`
+                        : `Standalone file in ${node.directory}`,
+                    type: 'graph',
+                    metadata: { neighbors: [...node.neighbors], directory: node.directory },
+                });
+            }
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    },
+};
+//# sourceMappingURL=cap-graph.js.map

package/packages/@monomind/cli/dist/src/capabilities/cap-media.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityModule } from './types.js';
+export declare const mediaCapability: CapabilityModule;
+//# sourceMappingURL=cap-media.d.ts.map

package/packages/@monomind/cli/dist/src/capabilities/cap-media.js

@@ -0,0 +1,147 @@
+import fs from 'fs';
+const IMAGE_EXTENSIONS = new Set([
+    '.jpg',
+    '.jpeg',
+    '.png',
+    '.gif',
+    '.bmp',
+    '.heic',
+    '.heif',
+    '.webp',
+    '.svg',
+    '.raw',
+    '.cr2',
+    '.nef',
+    '.tiff',
+    '.tif',
+]);
+const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.avi', '.mkv', '.wmv', '.flv', '.webm']);
+const AUDIO_EXTENSIONS = new Set(['.mp3', '.wav', '.flac', '.aac', '.ogg', '.m4a', '.wma']);
+const ALL_MEDIA = new Set([...IMAGE_EXTENSIONS, ...VIDEO_EXTENSIONS, ...AUDIO_EXTENSIONS]);
+// In-memory index for T0 (metadata) — replaced by memory DB in production
+const indexedMedia = new Map();
+const MAX_EXIF_FILE_SIZE = 100 * 1024 * 1024; // 100MB — avoid OOM on large files
+async function extractExif(file) {
+    if (file.size > MAX_EXIF_FILE_SIZE)
+        return {};
+    try {
+        // monolean: exifreader is an optional dependency — degrade to metadata-only if missing
+        const mod = await import('exifreader');
+        const ExifReader = mod.default ?? mod;
+        const buffer = fs.readFileSync(file.absolutePath);
+        const tags = ExifReader.load(buffer, { expanded: true });
+        const result = {};
+        if (tags.exif) {
+            if (tags.exif.DateTimeOriginal)
+                result.dateTaken = tags.exif.DateTimeOriginal.description;
+            if (tags.exif.Make)
+                result.cameraMake = tags.exif.Make.description;
+            if (tags.exif.Model)
+                result.cameraModel = tags.exif.Model.description;
+            if (tags.exif.ImageWidth)
+                result.width = tags.exif.ImageWidth.value;
+            if (tags.exif.ImageLength)
+                result.height = tags.exif.ImageLength.value;
+        }
+        if (tags.gps) {
+            if (tags.gps.Latitude)
+                result.latitude = tags.gps.Latitude;
+            if (tags.gps.Longitude)
+                result.longitude = tags.gps.Longitude;
+        }
+        return result;
+    }
+    catch {
+        return {}; // exifreader not installed or file has no EXIF
+    }
+}
+function mediaType(ext) {
+    if (IMAGE_EXTENSIONS.has(ext))
+        return 'image';
+    if (VIDEO_EXTENSIONS.has(ext))
+        return 'video';
+    return 'audio';
+}
+export const mediaCapability = {
+    name: 'media',
+    detect(scan) {
+        return scan.capabilities.media.confidence;
+    },
+    async activate(_rootDir) {
+        indexedMedia.clear();
+    },
+    async index(files) {
+        let indexed = 0;
+        let skipped = 0;
+        const errors = [];
+        for (const file of files) {
+            if (!ALL_MEDIA.has(file.extension)) {
+                skipped++;
+                continue;
+            }
+            try {
+                const type = mediaType(file.extension);
+                // Video/audio: never readFileSync (multi-GB files) — metadata comes from fs.stat only
+                const exif = type === 'image' && file.extension !== '.svg' ? await extractExif(file) : {};
+                // Build searchable description from metadata + filename
+                const descParts = [file.path.replace(/[_-]/g, ' ')];
+                if (exif.dateTaken)
+                    descParts.push(`taken ${exif.dateTaken}`);
+                if (exif.cameraMake)
+                    descParts.push(`${exif.cameraMake} ${exif.cameraModel ?? ''}`);
+                indexedMedia.set(file.path, {
+                    path: file.path,
+                    type,
+                    metadata: {
+                        ...exif,
+                        size: file.size,
+                        modified: file.modified.toISOString(),
+                        created: file.created.toISOString(),
+                        extension: file.extension,
+                    },
+                    description: descParts.join(' '),
+                });
+                indexed++;
+            }
+            catch (err) {
+                errors.push(`${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return { indexed, skipped, errors };
+    },
+    async search(query, limit = 20) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const [mediaPath, entry] of indexedMedia) {
+            const descLower = entry.description.toLowerCase();
+            const pathLower = mediaPath.toLowerCase();
+            if (descLower.includes(queryLower) || pathLower.includes(queryLower)) {
+                results.push({
+                    path: mediaPath,
+                    score: pathLower.includes(queryLower) ? 1.0 : 0.5,
+                    snippet: entry.description,
+                    type: 'media',
+                    metadata: entry.metadata,
+                });
+            }
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    },
+    async healthChecks() {
+        const checks = [];
+        try {
+            await import('exifreader');
+            checks.push({ name: 'EXIF Extraction', status: 'pass', message: 'exifreader available' });
+        }
+        catch {
+            checks.push({
+                name: 'EXIF Extraction',
+                status: 'warn',
+                message: 'exifreader not installed',
+                hint: 'pnpm add exifreader',
+            });
+        }
+        return checks;
+    },
+};
+//# sourceMappingURL=cap-media.js.map

package/packages/@monomind/cli/dist/src/capabilities/cap-timeline.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityModule } from './types.js';
+export declare const timelineCapability: CapabilityModule;
+//# sourceMappingURL=cap-timeline.d.ts.map

package/packages/@monomind/cli/dist/src/capabilities/cap-timeline.js

@@ -0,0 +1,90 @@
+const timelineIndex = new Map();
+const MONTH_NAMES = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december'];
+const MONTH_SHORT = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+const MONTH_NAME_REGEXPS = MONTH_NAMES.map(m => new RegExp(`\\b${m}\\b`));
+const MONTH_SHORT_REGEXPS = MONTH_SHORT.map(m => new RegExp(`\\b${m}\\b`));
+function extractDatesFromFilename(filename) {
+    const dates = [];
+    // Match YYYY-MM-DD or YYYY-MM
+    const isoMatch = filename.match(/(\d{4})-(\d{2})(?:-(\d{2}))?/);
+    if (isoMatch) {
+        const d = new Date(`${isoMatch[1]}-${isoMatch[2]}-${isoMatch[3] ?? '01'}`);
+        if (!isNaN(d.getTime()))
+            dates.push(d);
+    }
+    // Match month names (word-boundary — avoid 'mar' matching 'marketplace', 'may' matching 'payment', etc.)
+    const lower = filename.toLowerCase();
+    for (let i = 0; i < MONTH_NAMES.length; i++) {
+        if (MONTH_NAME_REGEXPS[i].test(lower) || MONTH_SHORT_REGEXPS[i].test(lower)) {
+            const yearMatch = filename.match(/(\d{4})/);
+            if (yearMatch) {
+                const year = parseInt(yearMatch[1]);
+                if (year >= 1900 && year <= 2100) {
+                    dates.push(new Date(year, i, 1));
+                }
+            }
+        }
+    }
+    return dates;
+}
+export const timelineCapability = {
+    name: 'timeline',
+    detect(_scan) {
+        return 0; // cross-cutting — activated by manager, not by detection
+    },
+    async activate(_rootDir) {
+        timelineIndex.clear();
+    },
+    async index(files) {
+        let indexed = 0;
+        const errors = [];
+        for (const file of files) {
+            const dates = [];
+            dates.push({ label: 'modified', date: file.modified });
+            dates.push({ label: 'created', date: file.created });
+            const filenameDates = extractDatesFromFilename(file.path);
+            for (const d of filenameDates) {
+                dates.push({ label: 'filename', date: d });
+            }
+            timelineIndex.set(file.path, { path: file.path, dates });
+            indexed++;
+        }
+        return { indexed, skipped: 0, errors };
+    },
+    async search(query, limit = 20) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        // Parse date hints from query
+        let targetMonth = -1;
+        let targetYear = -1;
+        for (let i = 0; i < MONTH_NAMES.length; i++) {
+            if (MONTH_NAME_REGEXPS[i].test(queryLower) || MONTH_SHORT_REGEXPS[i].test(queryLower)) {
+                targetMonth = i;
+                break;
+            }
+        }
+        const yearMatch = query.match(/(\d{4})/);
+        if (yearMatch)
+            targetYear = parseInt(yearMatch[1]);
+        if (targetMonth === -1 && targetYear === -1)
+            return [];
+        for (const [filePath, entry] of timelineIndex) {
+            for (const { label, date } of entry.dates) {
+                const monthMatch = targetMonth === -1 || date.getMonth() === targetMonth;
+                const yearMatches = targetYear === -1 || date.getFullYear() === targetYear;
+                if (monthMatch && yearMatches) {
+                    results.push({
+                        path: filePath,
+                        score: label === 'filename' ? 1.0 : 0.7,
+                        snippet: `📅 ${date.toISOString().slice(0, 10)}: ${filePath} (${label})`,
+                        type: 'timeline',
+                        metadata: { date: date.toISOString(), dateSource: label },
+                    });
+                    break; // one result per file
+                }
+            }
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    },
+};
+//# sourceMappingURL=cap-timeline.js.map