opencode-memory-pro 1.3.0

package/dist/embedder.js

@@ -0,0 +1,260 @@
+import { log } from "./logger.js";
+let globalEmbedderHealth = {
+    status: "healthy",
+    lastError: null,
+    lastSuccess: null,
+    retryCount: 0,
+    fallbackActive: false,
+};
+export function getEmbedderHealth() {
+    return globalEmbedderHealth;
+}
+export function setEmbedderHealth(health) {
+    globalEmbedderHealth = { ...globalEmbedderHealth, ...health };
+}
+export function resetEmbedderHealth() {
+    globalEmbedderHealth = {
+        status: "healthy",
+        lastError: null,
+        lastSuccess: null,
+        retryCount: 0,
+        fallbackActive: false,
+    };
+}
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function embedWithRetry(embedder, config, text) {
+    const retry = config.retry ?? {
+        enabled: true,
+        maxAttempts: 3,
+        initialDelayMs: 1000,
+        backoffMultiplier: 2,
+    };
+    if (!retry.enabled) {
+        return embedder.embed(text);
+    }
+    let lastError = null;
+    let attempt = 0;
+    while (attempt < retry.maxAttempts) {
+        attempt++;
+        try {
+            const result = await embedder.embed(text);
+            globalEmbedderHealth.lastSuccess = Date.now();
+            globalEmbedderHealth.lastError = null;
+            if (globalEmbedderHealth.status === "degraded") {
+                globalEmbedderHealth.status = "healthy";
+                log("info", "Embedder recovered, resuming normal mode");
+            }
+            return result;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            globalEmbedderHealth.retryCount++;
+            globalEmbedderHealth.lastError = lastError.message;
+            if (attempt >= retry.maxAttempts) {
+                break;
+            }
+            const delay = Math.floor(retry.initialDelayMs * Math.pow(retry.backoffMultiplier, attempt - 1));
+            log("warn", `Embedder failed (attempt ${attempt}/${retry.maxAttempts}), retrying in ${delay}ms: ${lastError.message}`);
+            await sleep(delay);
+        }
+    }
+    globalEmbedderHealth.status = "degraded";
+    globalEmbedderHealth.fallbackActive = true;
+    log("warn", `Embedder unavailable after ${retry.maxAttempts} attempts, falling back to BM25-only search`);
+    throw lastError;
+}
+async function dimWithRetry(embedder, config) {
+    const retry = config.retry ?? {
+        enabled: true,
+        maxAttempts: 3,
+        initialDelayMs: 1000,
+        backoffMultiplier: 2,
+    };
+    if (!retry.enabled) {
+        return embedder.dim();
+    }
+    let lastError = null;
+    let attempt = 0;
+    while (attempt < retry.maxAttempts) {
+        attempt++;
+        try {
+            const result = await embedder.dim();
+            globalEmbedderHealth.lastSuccess = Date.now();
+            globalEmbedderHealth.lastError = null;
+            return result;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            globalEmbedderHealth.retryCount++;
+            globalEmbedderHealth.lastError = lastError.message;
+            if (attempt >= retry.maxAttempts) {
+                break;
+            }
+            const delay = Math.floor(retry.initialDelayMs * Math.pow(retry.backoffMultiplier, attempt - 1));
+            await sleep(delay);
+        }
+    }
+    globalEmbedderHealth.status = "degraded";
+    globalEmbedderHealth.fallbackActive = true;
+    throw lastError;
+}
+const KNOWN_MODEL_DIMS = {
+    "nomic-embed-text": 768,
+    "mxbai-embed-large": 1024,
+    "all-minilm": 384,
+    "snowflake-arctic-embed": 1024,
+    "text-embedding-3-small": 1536,
+    "text-embedding-3-large": 3072,
+    "text-embedding-ada-002": 1536,
+};
+function fallbackDim(model) {
+    const normalized = model.toLowerCase().replace(/:.*$/, "");
+    for (const [prefix, dim] of Object.entries(KNOWN_MODEL_DIMS)) {
+        if (normalized === prefix || normalized.startsWith(`${prefix}:`))
+            return dim;
+    }
+    return null;
+}
+export class OllamaEmbedder {
+    config;
+    model;
+    cachedDim = null;
+    constructor(config) {
+        this.config = config;
+        this.model = config.model;
+    }
+    async embed(text) {
+        const endpoint = `${this.config.baseUrl ?? "http://127.0.0.1:11434"}/api/embeddings`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 6000);
+        try {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: this.config.model,
+                    prompt: text,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama embedding request failed: HTTP ${response.status}`);
+            }
+            const data = (await response.json());
+            if (!Array.isArray(data.embedding) || data.embedding.length === 0) {
+                throw new Error("Ollama embedding response missing embedding vector");
+            }
+            if (this.cachedDim === null) {
+                this.cachedDim = data.embedding.length;
+            }
+            return data.embedding;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async dim() {
+        if (this.cachedDim !== null)
+            return this.cachedDim;
+        try {
+            const probe = await this.embed("dimension probe");
+            this.cachedDim = probe.length;
+            return this.cachedDim;
+        }
+        catch {
+            const fb = fallbackDim(this.model);
+            if (fb !== null) {
+                log("warn", `Ollama unreachable, using fallback dim ${fb} for model "${this.model}"`);
+                return fb;
+            }
+            throw new Error(`Ollama unreachable and no known fallback dimension for model "${this.model}"`);
+        }
+    }
+}
+export class OpenAIEmbedder {
+    config;
+    model;
+    cachedDim = null;
+    constructor(config) {
+        this.config = config;
+        this.model = config.model;
+    }
+    async embed(text) {
+        if (!this.config.apiKey) {
+            throw new Error("OpenAI embedding request failed: missing apiKey. Set embedding.apiKey or OPENCODE_MEMORY_PRO_OPENAI_API_KEY.");
+        }
+        const baseUrl = (this.config.baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+        const endpoint = `${baseUrl}/embeddings`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 6000);
+        try {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify({
+                    model: this.config.model,
+                    input: text,
+                    encoding_format: "float",
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const details = await response.text().catch(() => "");
+                const suffix = details ? ` - ${details.slice(0, 240)}` : "";
+                throw new Error(`OpenAI embedding request failed: HTTP ${response.status}${suffix}`);
+            }
+            const data = (await response.json());
+            const vector = data.data?.[0]?.embedding;
+            if (!Array.isArray(vector) || vector.length === 0) {
+                throw new Error("OpenAI embedding response missing embedding vector");
+            }
+            if (this.cachedDim === null) {
+                this.cachedDim = vector.length;
+            }
+            return vector;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async dim() {
+        if (this.cachedDim !== null)
+            return this.cachedDim;
+        try {
+            const probe = await this.embed("dimension probe");
+            this.cachedDim = probe.length;
+            return this.cachedDim;
+        }
+        catch {
+            const fb = fallbackDim(this.model);
+            if (fb !== null) {
+                log("warn", `OpenAI embedding probe failed, using fallback dim ${fb} for model "${this.model}"`);
+                return fb;
+            }
+            throw new Error(`OpenAI embedding probe failed and no known fallback dimension for model "${this.model}"`);
+        }
+    }
+}
+export function createEmbedder(config) {
+    const inner = config.provider === "openai"
+        ? new OpenAIEmbedder(config)
+        : new OllamaEmbedder(config);
+    return {
+        get model() {
+            return inner.model;
+        },
+        async embed(text) {
+            return embedWithRetry(inner, config, text);
+        },
+        async dim() {
+            return dimWithRetry(inner, config);
+        },
+    };
+}

package/dist/extract.d.ts

@@ -0,0 +1,4 @@
+import type { CaptureCandidateResult } from "./types.js";
+export declare function extractCaptureCandidate(text: string, minChars: number): CaptureCandidateResult;
+export declare function detectGlobalWorthiness(content: string): number;
+export declare function isGlobalCandidate(content: string, threshold: number): boolean;

package/dist/extract.js

@@ -0,0 +1,181 @@
+const POSITIVE_SIGNALS = [
+    // original
+    "fixed",
+    "resolved",
+    "works now",
+    "successful",
+    "done",
+    "完成",
+    "已解決",
+    "修復",
+    "成功",
+    // expanded: completion / success synonyms
+    "successfully",
+    "completed",
+    "complete",
+    "confirmed",
+    "verified",
+    "validated",
+    "passed",
+    "working now",
+    "corrected",
+    "solved",
+    "solution",
+    "addressed",
+    "implemented",
+    "configured",
+    "installed",
+    "deployed",
+    "updated",
+    "migrated",
+    "upgraded",
+    "enabled",
+    "operational",
+    "up and running",
+    "no errors",
+    "no issues",
+    "finished",
+    "ready",
+    "created",
+    "wrote the file",
+    "here's how",
+    "the reason",
+    "the cause",
+    "the answer is",
+    "in summary",
+    "to summarize",
+    "已完成",
+    "已修復",
+    "已驗證",
+    "已確認",
+    "已部署",
+];
+const DECISION_SIGNALS = ["decide", "decision", "tradeoff", "architecture", "採用", "決定", "架構"];
+const FACT_SIGNALS = ["because", "root cause", "原因", "由於"];
+const PREF_SIGNALS = ["prefer", "preference", "偏好", "習慣"];
+// Gate now considers every signal category, not just POSITIVE_SIGNALS,
+// so decisions/facts/preferences can also trigger auto-capture.
+const ALL_CAPTURE_SIGNALS = [
+    ...POSITIVE_SIGNALS,
+    ...DECISION_SIGNALS,
+    ...FACT_SIGNALS,
+    ...PREF_SIGNALS,
+];
+// Exported so graph.js can reuse the infra lexicon for entity extraction.
+export const GLOBAL_KEYWORDS = [
+    // Distributions
+    "alpine",
+    "debian",
+    "ubuntu",
+    "centos",
+    "fedora",
+    "arch",
+    // Containers
+    "docker",
+    "dockerfile",
+    "docker-compose",
+    "containerd",
+    // Orchestration
+    "kubernetes",
+    "k8s",
+    "helm",
+    "kubectl",
+    // Shells/Systems
+    "bash",
+    "shell",
+    "linux",
+    "unix",
+    "posix",
+    "busybox",
+    // Web servers
+    "nginx",
+    "apache",
+    "caddy",
+    // Databases
+    "postgres",
+    "postgresql",
+    "mysql",
+    "redis",
+    "mongodb",
+    "sqlite",
+    // Cloud
+    "aws",
+    "gcp",
+    "azure",
+    "digitalocean",
+    // VCS
+    "git",
+    "github",
+    "gitlab",
+    "bitbucket",
+    // Protocols
+    "api",
+    "rest",
+    "graphql",
+    "grpc",
+    "http",
+    "https",
+    // Package managers
+    "npm",
+    "yarn",
+    "pnpm",
+    "pip",
+    "cargo",
+    "make",
+    "cmake",
+    // GRAPH_STORE_PHASE2: high-frequency app/runtime terms so typed-relation
+    // extraction can anchor on the nouns this user actually writes about.
+    "opencode",
+    "lancedb",
+    "systemd",
+    "journalctl",
+    "plugin",
+    "graph",
+    "memory",
+];
+export function extractCaptureCandidate(text, minChars) {
+    const normalized = text.trim();
+    if (normalized.length < minChars) {
+        return { candidate: null, skipReason: "below-min-chars" };
+    }
+    const lower = normalized.toLowerCase();
+    if (!ALL_CAPTURE_SIGNALS.some((signal) => lower.includes(signal.toLowerCase()))) {
+        return { candidate: null, skipReason: "no-positive-signal" };
+    }
+    const category = classifyCategory(lower);
+    const importance = category === "decision" ? 0.9 : category === "fact" ? 0.75 : 0.65;
+    return {
+        candidate: {
+            text: clipText(normalized, 1200),
+            category,
+            importance,
+        },
+    };
+}
+function classifyCategory(text) {
+    if (DECISION_SIGNALS.some((signal) => text.includes(signal.toLowerCase())))
+        return "decision";
+    if (FACT_SIGNALS.some((signal) => text.includes(signal.toLowerCase())))
+        return "fact";
+    if (PREF_SIGNALS.some((signal) => text.includes(signal.toLowerCase())))
+        return "preference";
+    return "other";
+}
+function clipText(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return `${text.slice(0, maxLen - 3)}...`;
+}
+export function detectGlobalWorthiness(content) {
+    const lower = content.toLowerCase();
+    let matches = 0;
+    for (const keyword of GLOBAL_KEYWORDS) {
+        if (lower.includes(keyword)) {
+            matches += 1;
+        }
+    }
+    return matches;
+}
+export function isGlobalCandidate(content, threshold) {
+    return detectGlobalWorthiness(content) >= threshold;
+}