mono-pilot 0.2.9 → 0.2.12

package/dist/src/memory/config/defaults.js

@@ -0,0 +1,55 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const memorySearchDefaults = {
+    enabled: true,
+    provider: "local",
+    sources: ["memory"],
+    extraPaths: [],
+    local: {
+        modelPath: "hf:gpustack/bge-m3-GGUF/bge-m3-Q8_0.gguf",
+        modelCacheDir: join(homedir(), ".mono-pilot", "models"),
+    },
+    store: {
+        vector: {
+            enabled: true,
+        },
+    },
+    chunking: {
+        tokens: 400,
+        overlap: 80,
+    },
+    query: {
+        maxResults: 6,
+        minScore: 0.35,
+        hybrid: {
+            enabled: true,
+            vectorWeight: 0.7,
+            textWeight: 0.3,
+            candidateMultiplier: 4,
+            mmr: {
+                enabled: false,
+                lambda: 0.7,
+            },
+            temporalDecay: {
+                enabled: false,
+                halfLifeDays: 30,
+            },
+        },
+    },
+    flush: {
+        onSessionSwitch: true,
+        onSessionCompact: true,
+        deltaBytes: 100_000,
+        deltaMessages: 50,
+    },
+    sync: {
+        onSessionStart: true,
+        onSearch: true,
+        watch: true,
+        watchDebounceMs: 1500,
+        intervalMinutes: 10,
+    },
+    cache: {
+        enabled: true,
+    },
+};

package/dist/src/memory/config/loader.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolveMemorySearchConfig } from "./resolve.js";
+import { getUserConfigPath } from "./paths.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export async function loadMonoPilotConfig() {
+    const configPath = getUserConfigPath();
+    if (!existsSync(configPath))
+        return undefined;
+    const raw = await readFile(configPath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON in mono-pilot config: ${message}`);
+    }
+    if (!isRecord(parsed)) {
+        throw new Error("MonoPilot config root must be a JSON object.");
+    }
+    return parsed;
+}
+export async function loadResolvedMemorySearchConfig() {
+    const config = await loadMonoPilotConfig();
+    return resolveMemorySearchConfig(config?.memorySearch);
+}

package/dist/src/memory/config/paths.js

@@ -0,0 +1,9 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export const MONO_PILOT_CONFIG_FILENAME = "config.json";
+export function getUserConfigDir() {
+    return join(homedir(), ".mono-pilot");
+}
+export function getUserConfigPath() {
+    return resolve(getUserConfigDir(), MONO_PILOT_CONFIG_FILENAME);
+}

package/dist/src/memory/config/resolve.js

@@ -0,0 +1,90 @@
+import { memorySearchDefaults } from "./defaults.js";
+export function resolveMemorySearchConfig(overrides) {
+    if (!overrides) {
+        return {
+            ...memorySearchDefaults,
+            sources: [...memorySearchDefaults.sources],
+            extraPaths: [...memorySearchDefaults.extraPaths],
+            chunking: { ...memorySearchDefaults.chunking },
+            query: {
+                ...memorySearchDefaults.query,
+                hybrid: {
+                    ...memorySearchDefaults.query.hybrid,
+                    mmr: { ...memorySearchDefaults.query.hybrid.mmr },
+                    temporalDecay: { ...memorySearchDefaults.query.hybrid.temporalDecay },
+                },
+            },
+            flush: {
+                ...memorySearchDefaults.flush,
+            },
+            sync: {
+                ...memorySearchDefaults.sync,
+            },
+        };
+    }
+    const chunking = overrides.chunking;
+    const query = overrides.query;
+    const hybrid = query?.hybrid;
+    const flush = overrides.flush;
+    const sync = overrides.sync;
+    const store = overrides.store;
+    const vector = store?.vector;
+    const cache = overrides.cache;
+    return {
+        enabled: overrides.enabled ?? memorySearchDefaults.enabled,
+        provider: overrides.provider ?? memorySearchDefaults.provider,
+        sources: overrides.sources ? [...overrides.sources] : [...memorySearchDefaults.sources],
+        extraPaths: overrides.extraPaths ? [...overrides.extraPaths] : [...memorySearchDefaults.extraPaths],
+        local: {
+            modelPath: overrides.local?.modelPath ?? memorySearchDefaults.local.modelPath,
+            modelCacheDir: overrides.local?.modelCacheDir ?? memorySearchDefaults.local.modelCacheDir,
+        },
+        store: {
+            vector: {
+                enabled: vector?.enabled ?? memorySearchDefaults.store.vector.enabled,
+                extensionPath: vector?.extensionPath ?? memorySearchDefaults.store.vector.extensionPath,
+            },
+        },
+        chunking: {
+            tokens: chunking?.tokens ?? memorySearchDefaults.chunking.tokens,
+            overlap: chunking?.overlap ?? memorySearchDefaults.chunking.overlap,
+        },
+        query: {
+            maxResults: query?.maxResults ?? memorySearchDefaults.query.maxResults,
+            minScore: query?.minScore ?? memorySearchDefaults.query.minScore,
+            hybrid: {
+                enabled: hybrid?.enabled ?? memorySearchDefaults.query.hybrid.enabled,
+                vectorWeight: hybrid?.vectorWeight ?? memorySearchDefaults.query.hybrid.vectorWeight,
+                textWeight: hybrid?.textWeight ?? memorySearchDefaults.query.hybrid.textWeight,
+                candidateMultiplier: hybrid?.candidateMultiplier ?? memorySearchDefaults.query.hybrid.candidateMultiplier,
+                mmr: {
+                    enabled: hybrid?.mmr?.enabled ?? memorySearchDefaults.query.hybrid.mmr.enabled,
+                    lambda: hybrid?.mmr?.lambda ?? memorySearchDefaults.query.hybrid.mmr.lambda,
+                },
+                temporalDecay: {
+                    enabled: hybrid?.temporalDecay?.enabled ??
+                        memorySearchDefaults.query.hybrid.temporalDecay.enabled,
+                    halfLifeDays: hybrid?.temporalDecay?.halfLifeDays ??
+                        memorySearchDefaults.query.hybrid.temporalDecay.halfLifeDays,
+                },
+            },
+        },
+        flush: {
+            onSessionSwitch: flush?.onSessionSwitch ?? memorySearchDefaults.flush.onSessionSwitch,
+            onSessionCompact: flush?.onSessionCompact ?? memorySearchDefaults.flush.onSessionCompact,
+            deltaBytes: flush?.deltaBytes ?? memorySearchDefaults.flush.deltaBytes,
+            deltaMessages: flush?.deltaMessages ?? memorySearchDefaults.flush.deltaMessages,
+        },
+        sync: {
+            onSessionStart: sync?.onSessionStart ?? memorySearchDefaults.sync.onSessionStart,
+            onSearch: sync?.onSearch ?? memorySearchDefaults.sync.onSearch,
+            watch: sync?.watch ?? memorySearchDefaults.sync.watch,
+            watchDebounceMs: sync?.watchDebounceMs ?? memorySearchDefaults.sync.watchDebounceMs,
+            intervalMinutes: sync?.intervalMinutes ?? memorySearchDefaults.sync.intervalMinutes,
+        },
+        cache: {
+            enabled: cache?.enabled ?? memorySearchDefaults.cache.enabled,
+            maxEntries: cache?.maxEntries ?? memorySearchDefaults.cache.maxEntries,
+        },
+    };
+}

package/dist/src/memory/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/memory/embeddings/batch-runner.js

@@ -0,0 +1,39 @@
+export async function runEmbeddingBatches(params) {
+    const { items } = params;
+    if (items.length === 0)
+        return [];
+    const batches = splitIntoBatches(items, Math.max(1, params.maxBatchSize));
+    const results = Array.from({ length: items.length });
+    const tasks = batches.map((batch, batchIndex) => async () => {
+        const embeddings = await params.runBatch(batch);
+        const start = batchIndex * params.maxBatchSize;
+        for (let i = 0; i < batch.length; i += 1) {
+            results[start + i] = embeddings[i] ?? [];
+        }
+    });
+    await runWithConcurrency(tasks, Math.max(1, params.concurrency));
+    return results;
+}
+function splitIntoBatches(items, maxBatchSize) {
+    const batches = [];
+    for (let i = 0; i < items.length; i += maxBatchSize) {
+        batches.push(items.slice(i, i + maxBatchSize));
+    }
+    return batches;
+}
+async function runWithConcurrency(tasks, limit) {
+    if (tasks.length === 0)
+        return;
+    const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+    let next = 0;
+    const workers = Array.from({ length: resolvedLimit }, async () => {
+        while (true) {
+            const index = next;
+            next += 1;
+            if (index >= tasks.length)
+                return;
+            await tasks[index]();
+        }
+    });
+    await Promise.all(workers);
+}

package/dist/src/memory/embeddings/cache.js

@@ -0,0 +1,47 @@
+import { EMBEDDING_CACHE_TABLE } from "../store/schema.js";
+export function readEmbeddingCache(params) {
+    const row = params.db
+        .prepare(`SELECT embedding FROM ${EMBEDDING_CACHE_TABLE} WHERE provider = ? AND model = ? AND provider_key = ? AND hash = ?`)
+        .get(params.provider, params.model, params.providerKey, params.hash);
+    if (!row?.embedding)
+        return null;
+    try {
+        const parsed = JSON.parse(row.embedding);
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeEmbeddingCache(params) {
+    const now = Date.now();
+    params.db
+        .prepare(`INSERT INTO ${EMBEDDING_CACHE_TABLE} (provider, model, provider_key, hash, embedding, dims, updated_at)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)
+			 ON CONFLICT(provider, model, provider_key, hash) DO UPDATE SET
+			   embedding=excluded.embedding,
+			   dims=excluded.dims,
+			   updated_at=excluded.updated_at`)
+        .run(params.provider, params.model, params.providerKey, params.hash, JSON.stringify(params.embedding), params.embedding.length, now);
+}
+export function pruneEmbeddingCache(params) {
+    const maxEntries = params.maxEntries;
+    if (!maxEntries || maxEntries <= 0)
+        return;
+    const countRow = params.db
+        .prepare(`SELECT COUNT(*) AS count FROM ${EMBEDDING_CACHE_TABLE} WHERE provider = ? AND model = ? AND provider_key = ?`)
+        .get(params.provider, params.model, params.providerKey);
+    const count = countRow?.count ?? 0;
+    if (count <= maxEntries)
+        return;
+    const toDelete = count - maxEntries;
+    params.db
+        .prepare(`DELETE FROM ${EMBEDDING_CACHE_TABLE}
+			 WHERE rowid IN (
+				SELECT rowid FROM ${EMBEDDING_CACHE_TABLE}
+				 WHERE provider = ? AND model = ? AND provider_key = ?
+				 ORDER BY updated_at ASC
+				 LIMIT ?
+			 )`)
+        .run(params.provider, params.model, params.providerKey, toDelete);
+}

package/dist/src/memory/embeddings/chunk-limits.js

@@ -0,0 +1,26 @@
+import { estimateUtf8Bytes, splitTextToUtf8ByteLimit } from "./input-limits.js";
+import { hashText } from "../indexing/files.js";
+export function enforceEmbeddingMaxInputTokens(provider, chunks, hardMaxInputTokens) {
+    const providerMaxInputTokens = typeof provider.maxInputTokens === "number"
+        ? provider.maxInputTokens
+        : 2048;
+    const maxInputTokens = typeof hardMaxInputTokens === "number" && hardMaxInputTokens > 0
+        ? Math.min(providerMaxInputTokens, hardMaxInputTokens)
+        : providerMaxInputTokens;
+    const out = [];
+    for (const chunk of chunks) {
+        if (estimateUtf8Bytes(chunk.text) <= maxInputTokens) {
+            out.push(chunk);
+            continue;
+        }
+        for (const text of splitTextToUtf8ByteLimit(chunk.text, maxInputTokens)) {
+            out.push({
+                startLine: chunk.startLine,
+                endLine: chunk.endLine,
+                text,
+                hash: hashText(text),
+            });
+        }
+    }
+    return out;
+}

package/dist/src/memory/embeddings/input-limits.js

@@ -0,0 +1,48 @@
+// Helpers for enforcing embedding model input size limits.
+// Tokenizers operate over bytes; token_count <= utf8_byte_length.
+export function estimateUtf8Bytes(text) {
+    if (!text)
+        return 0;
+    return Buffer.byteLength(text, "utf8");
+}
+export function splitTextToUtf8ByteLimit(text, maxUtf8Bytes) {
+    if (maxUtf8Bytes <= 0)
+        return [text];
+    if (estimateUtf8Bytes(text) <= maxUtf8Bytes)
+        return [text];
+    const parts = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        let low = cursor + 1;
+        let high = Math.min(text.length, cursor + maxUtf8Bytes);
+        let best = cursor;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const bytes = estimateUtf8Bytes(text.slice(cursor, mid));
+            if (bytes <= maxUtf8Bytes) {
+                best = mid;
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        if (best <= cursor) {
+            best = Math.min(text.length, cursor + 1);
+        }
+        if (best < text.length &&
+            best > cursor &&
+            text.charCodeAt(best - 1) >= 0xd800 &&
+            text.charCodeAt(best - 1) <= 0xdbff &&
+            text.charCodeAt(best) >= 0xdc00 &&
+            text.charCodeAt(best) <= 0xdfff) {
+            best -= 1;
+        }
+        const part = text.slice(cursor, best);
+        if (!part)
+            break;
+        parts.push(part);
+        cursor = best;
+    }
+    return parts;
+}

package/dist/src/memory/embeddings/local.js

@@ -0,0 +1,108 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+function normalizeEmbedding(vector) {
+    const sanitized = vector.map((value) => (Number.isFinite(value) ? value : 0));
+    const magnitude = Math.sqrt(sanitized.reduce((sum, value) => sum + value * value, 0));
+    if (magnitude < 1e-10) {
+        return sanitized;
+    }
+    return sanitized.map((value) => value / magnitude);
+}
+export async function createLocalEmbeddingProvider(params) {
+    const modelPath = params.modelPath?.trim() || "hf:gpustack/bge-m3-GGUF/bge-m3-Q8_0.gguf";
+    const modelCacheDir = params.modelCacheDir?.trim() || join(homedir(), ".mono-pilot", "models");
+    const nodeLlamaCpp = await import("node-llama-cpp");
+    const { getLlama, resolveModelFile } = nodeLlamaCpp;
+    const logLevel = nodeLlamaCpp.LlamaLogLevel?.error;
+    let llama = null;
+    let model = null;
+    let context = null;
+    let closing = false;
+    let inFlightRequests = 0;
+    let disposePromise = null;
+    const idleWaiters = new Set();
+    const notifyIfIdle = () => {
+        if (inFlightRequests !== 0) {
+            return;
+        }
+        for (const resolve of idleWaiters) {
+            resolve();
+        }
+        idleWaiters.clear();
+    };
+    const waitForIdle = async () => {
+        if (inFlightRequests === 0) {
+            return;
+        }
+        await new Promise((resolve) => {
+            idleWaiters.add(resolve);
+        });
+    };
+    const runWithInFlightTracking = async (operation) => {
+        if (closing) {
+            throw new Error("embedding provider is closing");
+        }
+        inFlightRequests += 1;
+        try {
+            return await operation();
+        }
+        finally {
+            inFlightRequests = Math.max(0, inFlightRequests - 1);
+            notifyIfIdle();
+        }
+    };
+    const ensureContext = async () => {
+        if (!llama) {
+            llama = await getLlama({ logLevel: logLevel ?? "error" });
+        }
+        if (!model) {
+            const resolved = await resolveModelFile(modelPath, modelCacheDir);
+            model = await llama.loadModel({ modelPath: resolved });
+        }
+        if (!context) {
+            context = await model.createEmbeddingContext();
+        }
+        return context;
+    };
+    return {
+        id: "local",
+        model: modelPath,
+        embedQuery: async (text) => {
+            return runWithInFlightTracking(async () => {
+                const ctx = await ensureContext();
+                const embedding = await ctx.getEmbeddingFor(text);
+                return normalizeEmbedding(Array.from(embedding.vector));
+            });
+        },
+        embedBatch: async (texts) => {
+            return runWithInFlightTracking(async () => {
+                const ctx = await ensureContext();
+                const embeddings = await Promise.all(texts.map(async (text) => {
+                    const embedding = await ctx.getEmbeddingFor(text);
+                    return normalizeEmbedding(Array.from(embedding.vector));
+                }));
+                return embeddings;
+            });
+        },
+        dispose: async () => {
+            if (disposePromise) {
+                await disposePromise;
+                return;
+            }
+            closing = true;
+            disposePromise = (async () => {
+                await waitForIdle();
+                if (context) {
+                    await context.dispose();
+                    context = null;
+                }
+                if (model) {
+                    await model.dispose();
+                    model = null;
+                }
+                llama = null;
+            })();
+            await disposePromise;
+        },
+    };
+}

package/dist/src/memory/embeddings/types.js

@@ -0,0 +1 @@
+export {};