monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/browser/workflow/types.d.ts

@@ -1,48 +0,0 @@
-export interface WorkflowDef {
-    id: string;
-    name: string;
-    nodes: NodeDef[];
-    connections: ConnectionDef[];
-}
-export interface NodeDef {
-    id: string;
-    type: string;
-    name?: string;
-    config: Record<string, unknown>;
-    onError?: 'skip' | 'stop';
-}
-export interface ConnectionDef {
-    from: string;
-    to: string;
-    handle?: string;
-}
-export interface Item {
-    data: Record<string, unknown>;
-    binary?: string;
-}
-export type RunStatus = 'running' | 'completed' | 'failed' | 'stopped';
-export interface RunRecord {
-    id: string;
-    workflowId: string;
-    workflowName: string;
-    status: RunStatus;
-    startedAt: number;
-    completedAt?: number;
-    itemsProcessed: number;
-    itemsTotal: number;
-    error?: string;
-}
-export interface StepEvent {
-    runId: string;
-    workflowId: string;
-    workflowName: string;
-    nodeId: string;
-    nodeName: string;
-    eventType: 'run_started' | 'step_started' | 'step_completed' | 'step_failed' | 'run_completed' | 'run_stopped';
-    itemIndex?: number;
-    itemTotal?: number;
-    durationMs?: number;
-    error?: string;
-    timestamp: number;
-}
-//# sourceMappingURL=types.d.ts.map

package/packages/@monomind/cli/dist/src/browser/workflow/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

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

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

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

@@ -1,20 +0,0 @@
-export const codeCapability = {
-    name: 'code',
-    detect(scan) {
-        return scan.capabilities.code.confidence;
-    },
-    async activate(_rootDir) {
-        // monolean: no-op — existing init/monograph handles code projects
-        // This module exists so the manager can track code as a capability
-    },
-    async index(_files) {
-        // monolean: existing monograph handles code indexing
-        return { indexed: 0, skipped: 0, errors: [] };
-    },
-    async healthChecks() {
-        // monolean: delegates to existing doctor checks when cap/code is active
-        // The doctor command checks isActive('code') to decide which checks to run
-        return [];
-    },
-};
-//# sourceMappingURL=cap-code.js.map

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

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

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

@@ -1,165 +0,0 @@
-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

@@ -1,5 +0,0 @@
-import type { CapabilityModule, FileEntry } from './types.js';
-export declare const DOC_EXTENSIONS: Set<string>;
-export declare function extractText(file: FileEntry): Promise<string>;
-export declare const documentsCapability: CapabilityModule;
-//# sourceMappingURL=cap-documents.d.ts.map

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

@@ -1,139 +0,0 @@
-import fs from 'fs';
-export 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();
-export 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

@@ -1,3 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

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