lancedb-opencode-pro 0.1.6 → 0.2.0

package/README.md

@@ -48,6 +48,9 @@ If you already use other plugins, keep them and append `"lancedb-opencode-pro"`.
     "importanceWeight": 0.4
   },
   "includeGlobalScope": true,
+  "globalDetectionThreshold": 2,
+  "globalDiscountFactor": 0.7,
+  "unusedDaysThreshold": 30,
   "minCaptureChars": 80,
   "maxEntriesPerScope": 3000
 }
@@ -184,6 +187,9 @@ Create `~/.config/opencode/lancedb-opencode-pro.json`:
     "importanceWeight": 0.4
   },
   "includeGlobalScope": true,
+  "globalDetectionThreshold": 2,
+  "globalDiscountFactor": 0.7,
+  "unusedDaysThreshold": 30,
   "minCaptureChars": 80,
   "maxEntriesPerScope": 3000
 }
@@ -229,6 +235,9 @@ Supported environment variables:
 - `LANCEDB_OPENCODE_PRO_RECENCY_HALF_LIFE_HOURS`
 - `LANCEDB_OPENCODE_PRO_IMPORTANCE_WEIGHT`
 - `LANCEDB_OPENCODE_PRO_INCLUDE_GLOBAL_SCOPE`
+- `LANCEDB_OPENCODE_PRO_GLOBAL_DETECTION_THRESHOLD`
+- `LANCEDB_OPENCODE_PRO_GLOBAL_DISCOUNT_FACTOR`
+- `LANCEDB_OPENCODE_PRO_UNUSED_DAYS_THRESHOLD`
 - `LANCEDB_OPENCODE_PRO_MIN_CAPTURE_CHARS`
 - `LANCEDB_OPENCODE_PRO_MAX_ENTRIES_PER_SCOPE`
 
@@ -237,6 +246,7 @@ Supported environment variables:
 - Auto-capture of durable outcomes from completed assistant responses.
 - Hybrid retrieval (vector + lexical) for future context injection.
 - Project-scope memory isolation (`project:*` + optional `global`).
+- Cross-project memory sharing via global scope with automatic detection.
 - Memory tools:
   - `memory_search`
   - `memory_delete`
@@ -246,6 +256,9 @@ Supported environment variables:
   - `memory_feedback_wrong`
   - `memory_feedback_useful`
   - `memory_effectiveness`
+  - `memory_scope_promote`
+  - `memory_scope_demote`
+  - `memory_global_list`
   - `memory_port_plan`
 
 ## Memory Effectiveness Feedback
@@ -371,6 +384,9 @@ Example sidecar:
     "importanceWeight": 0.4
   },
   "includeGlobalScope": true,
+  "globalDetectionThreshold": 2,
+  "globalDiscountFactor": 0.7,
+  "unusedDaysThreshold": 30,
   "minCaptureChars": 80,
   "maxEntriesPerScope": 3000
 }

package/dist/config.js

@@ -59,6 +59,9 @@ export function resolveMemoryConfig(config, worktree) {
             importanceWeight,
         },
         includeGlobalScope: toBoolean(process.env.LANCEDB_OPENCODE_PRO_INCLUDE_GLOBAL_SCOPE ?? raw.includeGlobalScope, true),
+        globalDetectionThreshold: Math.max(1, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_GLOBAL_DETECTION_THRESHOLD ?? raw.globalDetectionThreshold, 2))),
+        globalDiscountFactor: clamp(toNumber(process.env.LANCEDB_OPENCODE_PRO_GLOBAL_DISCOUNT_FACTOR ?? raw.globalDiscountFactor, 0.7), 0, 1),
+        unusedDaysThreshold: Math.max(1, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_UNUSED_DAYS_THRESHOLD ?? raw.unusedDaysThreshold, 30))),
         minCaptureChars: Math.max(30, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_MIN_CAPTURE_CHARS ?? raw.minCaptureChars, 80))),
         maxEntriesPerScope: Math.max(50, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_MAX_ENTRIES_PER_SCOPE ?? raw.maxEntriesPerScope, 3000))),
     };
@@ -83,6 +86,9 @@ function validateEmbeddingConfig(embedding) {
     }
 }
 function loadSidecarConfig(worktree) {
+    if (process.env.LANCEDB_OPENCODE_PRO_SKIP_SIDECAR === "true") {
+        return {};
+    }
     const configPath = firstString(process.env.LANCEDB_OPENCODE_PRO_CONFIG_PATH);
     const candidates = [
         join(expandHomePath("~/.opencode"), SIDECAR_FILE),

package/dist/extract.d.ts

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

@@ -12,6 +12,68 @@ const POSITIVE_SIGNALS = [
 const DECISION_SIGNALS = ["decide", "decision", "tradeoff", "architecture", "採用", "決定", "架構"];
 const FACT_SIGNALS = ["because", "root cause", "原因", "由於"];
 const PREF_SIGNALS = ["prefer", "preference", "偏好", "習慣"];
+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",
+];
 export function extractCaptureCandidate(text, minChars) {
     const normalized = text.trim();
     if (normalized.length < minChars) {
@@ -45,3 +107,16 @@ function clipText(text, 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;
+}

package/dist/index.js

@@ -60,6 +60,7 @@ const plugin = async (input) => {
                 recencyBoost: state.config.retrieval.recencyBoost,
                 recencyHalfLifeHours: state.config.retrieval.recencyHalfLifeHours,
                 importanceWeight: state.config.retrieval.importanceWeight,
+                globalDiscountFactor: state.config.globalDiscountFactor,
             });
             await state.store.putEvent({
                 id: generateId(),
@@ -77,6 +78,9 @@ const plugin = async (input) => {
             });
             if (results.length === 0)
                 return;
+            for (const result of results) {
+                state.store.updateMemoryUsage(result.record.id, activeScope, scopes).catch(() => { });
+            }
             const memoryBlock = [
                 "[Memory Recall - optional historical context]",
                 ...results.map((item, index) => `${index + 1}. [${item.record.id}] (${item.record.scope}) ${item.record.text}`),
@@ -117,6 +121,7 @@ const plugin = async (input) => {
                         recencyBoost: state.config.retrieval.recencyBoost,
                         recencyHalfLifeHours: state.config.retrieval.recencyHalfLifeHours,
                         importanceWeight: state.config.retrieval.importanceWeight,
+                        globalDiscountFactor: state.config.globalDiscountFactor,
                     });
                     await state.store.putEvent({
                         id: generateId(),
@@ -131,6 +136,9 @@ const plugin = async (input) => {
                     });
                     if (results.length === 0)
                         return "No relevant memory found.";
+                    for (const result of results) {
+                        state.store.updateMemoryUsage(result.record.id, activeScope, scopes).catch(() => { });
+                    }
                     return results
                         .map((item, idx) => {
                         const percent = Math.round(item.score * 100);
@@ -302,6 +310,110 @@ const plugin = async (input) => {
                     return JSON.stringify(summary, null, 2);
                 },
             }),
+            memory_scope_promote: tool({
+                description: "Promote a memory from project scope to global scope for cross-project sharing",
+                args: {
+                    id: tool.schema.string().min(6),
+                    confirm: tool.schema.boolean().default(false),
+                },
+                execute: async (args, context) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return unavailableMessage(state.config.embedding.provider);
+                    if (!args.confirm) {
+                        return "Rejected: memory_scope_promote requires confirm=true.";
+                    }
+                    const activeScope = deriveProjectScope(context.worktree);
+                    const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
+                    const exists = await state.store.hasMemory(args.id, scopes);
+                    if (!exists) {
+                        return `Memory ${args.id} not found in current scope.`;
+                    }
+                    const updated = await state.store.updateMemoryScope(args.id, "global", scopes);
+                    if (!updated) {
+                        return `Failed to promote memory ${args.id}.`;
+                    }
+                    return `Promoted memory ${args.id} to global scope.`;
+                },
+            }),
+            memory_scope_demote: tool({
+                description: "Demote a memory from global scope to project scope",
+                args: {
+                    id: tool.schema.string().min(6),
+                    confirm: tool.schema.boolean().default(false),
+                    scope: tool.schema.string().optional(),
+                },
+                execute: async (args, context) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return unavailableMessage(state.config.embedding.provider);
+                    if (!args.confirm) {
+                        return "Rejected: memory_scope_demote requires confirm=true.";
+                    }
+                    const projectScope = args.scope ?? deriveProjectScope(context.worktree);
+                    const globalExists = await state.store.hasMemory(args.id, ["global"]);
+                    if (!globalExists) {
+                        return `Memory ${args.id} not found in global scope or is not a global memory.`;
+                    }
+                    const updated = await state.store.updateMemoryScope(args.id, projectScope, ["global"]);
+                    if (!updated) {
+                        return `Failed to demote memory ${args.id}.`;
+                    }
+                    return `Demoted memory ${args.id} from global to ${projectScope}.`;
+                },
+            }),
+            memory_global_list: tool({
+                description: "List all global-scoped memories, optionally filtered by search query or unused status",
+                args: {
+                    query: tool.schema.string().optional(),
+                    filter: tool.schema.string().optional(),
+                    limit: tool.schema.number().int().min(1).max(100).default(20),
+                },
+                execute: async (args) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return unavailableMessage(state.config.embedding.provider);
+                    let records;
+                    if (args.filter === "unused") {
+                        records = await state.store.getUnusedGlobalMemories(state.config.unusedDaysThreshold, args.limit);
+                    }
+                    else if (args.query) {
+                        let queryVector = [];
+                        try {
+                            queryVector = await state.embedder.embed(args.query);
+                        }
+                        catch {
+                            queryVector = [];
+                        }
+                        records = await state.store.search({
+                            query: args.query,
+                            queryVector,
+                            scopes: ["global"],
+                            limit: args.limit,
+                            vectorWeight: 0.7,
+                            bm25Weight: 0.3,
+                            minScore: 0.2,
+                            globalDiscountFactor: 1.0,
+                        }).then((results) => results.map((r) => r.record));
+                    }
+                    else {
+                        records = await state.store.readGlobalMemories(args.limit);
+                    }
+                    if (records.length === 0) {
+                        return "No global memories found.";
+                    }
+                    return records
+                        .map((record, idx) => {
+                        const date = new Date(record.timestamp).toISOString().split("T")[0];
+                        const lastRecalled = record.lastRecalled > 0
+                            ? new Date(record.lastRecalled).toISOString().split("T")[0]
+                            : "never";
+                        return `${idx + 1}. [${record.id}] ${record.text.slice(0, 80)}...
+  Stored: ${date} | Recalled: ${lastRecalled} | Count: ${record.recallCount} | Projects: ${record.projectCount}`;
+                    })
+                        .join("\n");
+                },
+            }),
             memory_port_plan: tool({
                 description: "Plan non-conflicting host ports for compose services and optionally persist reservations",
                 args: {
@@ -363,6 +475,9 @@ const plugin = async (input) => {
                                     scope: "global",
                                     importance: 0.8,
                                     timestamp: Date.now(),
+                                    lastRecalled: 0,
+                                    recallCount: 0,
+                                    projectCount: 0,
                                     schemaVersion: SCHEMA_VERSION,
                                     embeddingModel: state.config.embedding.model,
                                     vectorDim: vector.length,
@@ -517,6 +632,9 @@ async function flushAutoCapture(sessionID, state, client) {
         scope: activeScope,
         importance: result.candidate.importance,
         timestamp: Date.now(),
+        lastRecalled: 0,
+        recallCount: 0,
+        projectCount: 0,
         schemaVersion: SCHEMA_VERSION,
         embeddingModel: state.config.embedding.model,
         vectorDim: vector.length,

package/dist/store.d.ts

@@ -23,13 +23,18 @@ export declare class MemoryStore {
         recencyBoost?: boolean;
         recencyHalfLifeHours?: number;
         importanceWeight?: number;
+        globalDiscountFactor?: number;
     }): Promise<SearchResult[]>;
     deleteById(id: string, scopes: string[]): Promise<boolean>;
+    updateMemoryScope(id: string, newScope: string, scopes: string[]): Promise<boolean>;
+    readGlobalMemories(limit?: number): Promise<MemoryRecord[]>;
+    getUnusedGlobalMemories(unusedDaysThreshold: number, limit?: number): Promise<MemoryRecord[]>;
     clearScope(scope: string): Promise<number>;
     list(scope: string, limit: number): Promise<MemoryRecord[]>;
     pruneScope(scope: string, maxEntries: number): Promise<number>;
     countIncompatibleVectors(scopes: string[], expectedDim: number): Promise<number>;
     hasMemory(id: string, scopes: string[]): Promise<boolean>;
+    updateMemoryUsage(id: string, projectScope: string, scopes: string[]): Promise<void>;
     listEvents(scopes: string[], limit: number): Promise<MemoryEffectivenessEvent[]>;
     summarizeEvents(scope: string, includeGlobalScope: boolean): Promise<EffectivenessSummary>;
     getIndexHealth(): {

package/dist/store.js

@@ -36,6 +36,9 @@ export class MemoryStore {
                 scope: "global",
                 importance: 0,
                 timestamp: 0,
+                lastRecalled: 0,
+                recallCount: 0,
+                projectCount: 0,
                 schemaVersion: 1,
                 embeddingModel: "bootstrap",
                 vectorDim,
@@ -114,13 +117,15 @@ export class MemoryStore {
         const recencyBoostEnabled = params.recencyBoost ?? true;
         const recencyHalfLifeHours = Math.max(1, params.recencyHalfLifeHours ?? 72);
         const importanceWeight = clampImportanceWeight(params.importanceWeight ?? 0.4);
+        const globalDiscountFactor = params.globalDiscountFactor ?? 1.0;
         const candidates = cached.records
             .filter((record) => params.queryVector.length === 0 || record.vector.length === params.queryVector.length)
             .map((record, index) => {
             const recordNorm = cached.norms.get(record.id) ?? vecNorm(record.vector);
             const vectorScore = useVectorChannel ? fastCosine(params.queryVector, record.vector, queryNorm, recordNorm) : 0;
             const bm25Score = useBm25Channel ? bm25LikeScore(queryTokens, cached.tokenized[index], cached.idf) : 0;
-            return { record, vectorScore, bm25Score };
+            const isGlobal = record.scope === "global";
+            return { record, vectorScore, bm25Score, isGlobal };
         });
         if (candidates.length === 0)
             return [];
@@ -144,7 +149,8 @@ export class MemoryStore {
                 ? computeRecencyMultiplier(item.record.timestamp, recencyHalfLifeHours)
                 : 1;
             const importanceFactor = 1 + importanceWeight * clampImportance(item.record.importance);
-            const score = rrfScore * recencyFactor * importanceFactor;
+            const scopeFactor = item.isGlobal ? globalDiscountFactor : 1.0;
+            const score = rrfScore * recencyFactor * importanceFactor * scopeFactor;
             return {
                 record: item.record,
                 score,
@@ -166,6 +172,26 @@ export class MemoryStore {
         this.invalidateScope(match.scope);
         return true;
     }
+    async updateMemoryScope(id, newScope, scopes) {
+        const rows = await this.readByScopes(scopes);
+        const match = rows.find((row) => row.id === id);
+        if (!match)
+            return false;
+        await this.requireTable().delete(`id = '${escapeSql(id)}'`);
+        this.invalidateScope(match.scope);
+        await this.requireTable().add([{ ...match, scope: newScope }]);
+        this.invalidateScope(newScope);
+        return true;
+    }
+    async readGlobalMemories(limit = 100) {
+        const rows = await this.readByScopes(["global"]);
+        return rows.sort((a, b) => b.timestamp - a.timestamp).slice(0, limit);
+    }
+    async getUnusedGlobalMemories(unusedDaysThreshold, limit = 100) {
+        const cutoffTime = Date.now() - unusedDaysThreshold * 24 * 60 * 60 * 1000;
+        const rows = await this.readByScopes(["global"]);
+        return rows.filter((row) => row.lastRecalled > 0 && row.lastRecalled < cutoffTime).slice(0, limit);
+    }
     async clearScope(scope) {
         const rows = await this.readByScopes([scope]);
         if (rows.length === 0)
@@ -194,8 +220,51 @@ export class MemoryStore {
         return rows.filter((row) => row.vectorDim !== expectedDim).length;
     }
     async hasMemory(id, scopes) {
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const rows = await this.readByScopes(scopes);
+            if (rows.some((row) => row.id === id)) {
+                return true;
+            }
+            if (attempt < 2) {
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+        }
+        return false;
+    }
+    async updateMemoryUsage(id, projectScope, scopes) {
         const rows = await this.readByScopes(scopes);
-        return rows.some((row) => row.id === id);
+        const match = rows.find((row) => row.id === id);
+        if (!match)
+            return;
+        const now = Date.now();
+        const newRecallCount = match.recallCount + 1;
+        let newProjectCount = match.projectCount;
+        let metadataJson = match.metadataJson;
+        if (match.scope === "global" && projectScope) {
+            const projects = extractRecalledProjects(metadataJson);
+            if (!projects.has(projectScope)) {
+                projects.add(projectScope);
+                if (projects.size > 100) {
+                    const arr = Array.from(projects);
+                    arr.splice(0, arr.length - 100);
+                    metadataJson = JSON.stringify({ recalledProjects: arr });
+                }
+                else {
+                    metadataJson = JSON.stringify({ recalledProjects: Array.from(projects) });
+                }
+                newProjectCount = projects.size;
+            }
+        }
+        await this.requireTable().delete(`id = '${escapeSql(id)}'`);
+        this.invalidateScope(match.scope);
+        await this.requireTable().add([{
+                ...match,
+                lastRecalled: now,
+                recallCount: newRecallCount,
+                projectCount: newProjectCount,
+                metadataJson,
+            }]);
+        this.invalidateScope(match.scope);
     }
     async listEvents(scopes, limit) {
         const rows = await this.readEventsByScopes(scopes);
@@ -410,6 +479,9 @@ export class MemoryStore {
             "scope",
             "importance",
             "timestamp",
+            "lastRecalled",
+            "recallCount",
+            "projectCount",
             "schemaVersion",
             "embeddingModel",
             "vectorDim",
@@ -477,6 +549,9 @@ function normalizeRow(row) {
         scope: row.scope,
         importance: Number(row.importance ?? 0.5),
         timestamp: Number(row.timestamp ?? Date.now()),
+        lastRecalled: Number(row.lastRecalled ?? 0),
+        recallCount: Number(row.recallCount ?? 0),
+        projectCount: Number(row.projectCount ?? 0),
         schemaVersion: Number(row.schemaVersion ?? 1),
         embeddingModel: String(row.embeddingModel ?? "unknown"),
         vectorDim: Number(row.vectorDim ?? vector.length),
@@ -628,3 +703,15 @@ function bm25LikeScore(query, doc, idf) {
     }
     return 1 - Math.exp(-score);
 }
+function extractRecalledProjects(metadataJson) {
+    try {
+        const metadata = JSON.parse(metadataJson);
+        if (metadata && Array.isArray(metadata.recalledProjects)) {
+            return new Set(metadata.recalledProjects);
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return new Set();
+}

package/dist/types.d.ts

@@ -5,6 +5,7 @@ export type CaptureOutcome = "considered" | "skipped" | "stored";
 export type CaptureSkipReason = "empty-buffer" | "below-min-chars" | "no-positive-signal" | "initialization-unavailable" | "embedding-unavailable" | "empty-embedding";
 export type FeedbackType = "missing" | "wrong" | "useful";
 export type RecallSource = "system-transform" | "manual-search";
+export type MemoryScope = "project" | "global";
 export interface EmbeddingConfig {
     provider: EmbeddingProvider;
     model: string;
@@ -28,6 +29,9 @@ export interface MemoryRuntimeConfig {
     embedding: EmbeddingConfig;
     retrieval: RetrievalConfig;
     includeGlobalScope: boolean;
+    globalDetectionThreshold: number;
+    globalDiscountFactor: number;
+    unusedDaysThreshold: number;
     minCaptureChars: number;
     maxEntriesPerScope: number;
 }
@@ -39,6 +43,9 @@ export interface MemoryRecord {
     scope: string;
     importance: number;
     timestamp: number;
+    lastRecalled: number;
+    recallCount: number;
+    projectCount: number;
     schemaVersion: number;
     embeddingModel: string;
     vectorDim: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lancedb-opencode-pro",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "LanceDB-backed long-term memory provider for OpenCode",
   "type": "module",
   "main": "dist/index.js",