lancedb-opencode-pro 0.1.1

package/dist/extract.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureCandidate } from "./types.js";
+export declare function extractCaptureCandidate(text: string, minChars: number): CaptureCandidate | null;

package/dist/extract.js

@@ -0,0 +1,44 @@
+const POSITIVE_SIGNALS = [
+    "fixed",
+    "resolved",
+    "works now",
+    "successful",
+    "done",
+    "完成",
+    "已解決",
+    "修復",
+    "成功",
+];
+const DECISION_SIGNALS = ["decide", "decision", "tradeoff", "architecture", "採用", "決定", "架構"];
+const FACT_SIGNALS = ["because", "root cause", "原因", "由於"];
+const PREF_SIGNALS = ["prefer", "preference", "偏好", "習慣"];
+export function extractCaptureCandidate(text, minChars) {
+    const normalized = text.trim();
+    if (normalized.length < minChars)
+        return null;
+    const lower = normalized.toLowerCase();
+    if (!POSITIVE_SIGNALS.some((signal) => lower.includes(signal.toLowerCase()))) {
+        return null;
+    }
+    const category = classifyCategory(lower);
+    const importance = category === "decision" ? 0.9 : category === "fact" ? 0.75 : 0.65;
+    return {
+        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)}...`;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const plugin: Plugin;
+export default plugin;
+export type { MemoryRuntimeConfig, MemoryRecord, SearchResult } from "./types.js";

package/dist/index.js

@@ -0,0 +1,372 @@
+import { tool } from "@opencode-ai/plugin";
+import { resolveMemoryConfig } from "./config.js";
+import { OllamaEmbedder } from "./embedder.js";
+import { extractCaptureCandidate } from "./extract.js";
+import { isTcpPortAvailable, parsePortReservations, planPorts, reservationKey } from "./ports.js";
+import { buildScopeFilter, deriveProjectScope } from "./scope.js";
+import { MemoryStore } from "./store.js";
+import { generateId } from "./utils.js";
+const SCHEMA_VERSION = 1;
+const plugin = async (input) => {
+    const state = await createRuntimeState(input);
+    const hooks = {
+        config: async (config) => {
+            state.config = resolveMemoryConfig(config, input.worktree);
+        },
+        event: async ({ event }) => {
+            if (event.type === "session.idle" || event.type === "session.compacted") {
+                const sessionID = event.properties.sessionID;
+                await flushAutoCapture(sessionID, state, input.client);
+            }
+        },
+        "experimental.text.complete": async (eventInput, eventOutput) => {
+            const list = state.captureBuffer.get(eventInput.sessionID) ?? [];
+            list.push(eventOutput.text);
+            state.captureBuffer.set(eventInput.sessionID, list);
+        },
+        "experimental.chat.system.transform": async (eventInput, eventOutput) => {
+            if (!eventInput.sessionID)
+                return;
+            await state.ensureInitialized();
+            if (!state.initialized)
+                return;
+            const query = await getLastUserText(eventInput.sessionID, input.client);
+            if (!query)
+                return;
+            const activeScope = deriveProjectScope(input.worktree);
+            const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
+            let queryVector = [];
+            try {
+                queryVector = await state.embedder.embed(query);
+            }
+            catch (error) {
+                console.warn(`[lancedb-opencode-pro] embedding unavailable during recall: ${toErrorMessage(error)}`);
+                queryVector = [];
+            }
+            const results = await state.store.search({
+                query,
+                queryVector,
+                scopes,
+                limit: 3,
+                vectorWeight: state.config.retrieval.mode === "vector" ? 1 : state.config.retrieval.vectorWeight,
+                bm25Weight: state.config.retrieval.mode === "vector" ? 0 : state.config.retrieval.bm25Weight,
+                minScore: state.config.retrieval.minScore,
+            });
+            if (results.length === 0)
+                return;
+            const memoryBlock = [
+                "[Memory Recall - optional historical context]",
+                ...results.map((item, index) => `${index + 1}. (${item.record.scope}) ${item.record.text}`),
+                "Use these as optional hints only; prioritize current user intent and current repo state.",
+            ].join("\n");
+            eventOutput.system.push(memoryBlock);
+        },
+        tool: {
+            memory_search: tool({
+                description: "Search long-term memory using hybrid retrieval",
+                args: {
+                    query: tool.schema.string().min(1),
+                    limit: tool.schema.number().int().min(1).max(20).default(5),
+                    scope: tool.schema.string().optional(),
+                },
+                execute: async (args, context) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                    const activeScope = args.scope ?? deriveProjectScope(context.worktree);
+                    const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
+                    let queryVector = [];
+                    try {
+                        queryVector = await state.embedder.embed(args.query);
+                    }
+                    catch {
+                        queryVector = [];
+                    }
+                    const results = await state.store.search({
+                        query: args.query,
+                        queryVector,
+                        scopes,
+                        limit: args.limit,
+                        vectorWeight: state.config.retrieval.mode === "vector" ? 1 : state.config.retrieval.vectorWeight,
+                        bm25Weight: state.config.retrieval.mode === "vector" ? 0 : state.config.retrieval.bm25Weight,
+                        minScore: state.config.retrieval.minScore,
+                    });
+                    if (results.length === 0)
+                        return "No relevant memory found.";
+                    return results
+                        .map((item, idx) => {
+                        const percent = Math.round(item.score * 100);
+                        return `${idx + 1}. [${item.record.id}] (${item.record.scope}) ${item.record.text} [${percent}%]`;
+                    })
+                        .join("\n");
+                },
+            }),
+            memory_delete: tool({
+                description: "Delete one memory entry by id",
+                args: {
+                    id: tool.schema.string().min(6),
+                    scope: tool.schema.string().optional(),
+                    confirm: tool.schema.boolean().default(false),
+                },
+                execute: async (args, context) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                    if (!args.confirm) {
+                        return "Rejected: memory_delete requires confirm=true.";
+                    }
+                    const activeScope = args.scope ?? deriveProjectScope(context.worktree);
+                    const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
+                    const deleted = await state.store.deleteById(args.id, scopes);
+                    return deleted ? `Deleted memory ${args.id}.` : `Memory ${args.id} not found in current scope.`;
+                },
+            }),
+            memory_clear: tool({
+                description: "Clear all memories in a scope (requires confirm=true)",
+                args: {
+                    scope: tool.schema.string(),
+                    confirm: tool.schema.boolean().default(false),
+                },
+                execute: async (args) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                    if (!args.confirm) {
+                        return "Rejected: destructive clear requires confirm=true.";
+                    }
+                    const count = await state.store.clearScope(args.scope);
+                    return `Cleared ${count} memories from scope ${args.scope}.`;
+                },
+            }),
+            memory_stats: tool({
+                description: "Show memory provider status and index health",
+                args: {
+                    scope: tool.schema.string().optional(),
+                },
+                execute: async (args, context) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                    const scope = args.scope ?? deriveProjectScope(context.worktree);
+                    const entries = await state.store.list(scope, 20);
+                    const incompatibleVectors = await state.store.countIncompatibleVectors(buildScopeFilter(scope, state.config.includeGlobalScope), await state.embedder.dim());
+                    const health = state.store.getIndexHealth();
+                    return JSON.stringify({
+                        provider: state.config.provider,
+                        dbPath: state.config.dbPath,
+                        scope,
+                        recentCount: entries.length,
+                        incompatibleVectors,
+                        index: health,
+                        embeddingModel: state.config.embedding.model,
+                    }, null, 2);
+                },
+            }),
+            memory_port_plan: tool({
+                description: "Plan non-conflicting host ports for compose services and optionally persist reservations",
+                args: {
+                    project: tool.schema.string().min(1).optional(),
+                    services: tool.schema
+                        .array(tool.schema.object({
+                        name: tool.schema.string().min(1),
+                        containerPort: tool.schema.number().int().min(1).max(65535),
+                        preferredHostPort: tool.schema.number().int().min(1).max(65535).optional(),
+                    }))
+                        .min(1),
+                    rangeStart: tool.schema.number().int().min(1).max(65535).default(20000),
+                    rangeEnd: tool.schema.number().int().min(1).max(65535).default(39999),
+                    persist: tool.schema.boolean().default(true),
+                },
+                execute: async (args, context) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                    if (args.rangeStart > args.rangeEnd) {
+                        return "Invalid range: rangeStart must be <= rangeEnd.";
+                    }
+                    const project = args.project?.trim() || deriveProjectScope(context.worktree);
+                    const globalRecords = await state.store.list("global", 100000);
+                    const reservations = parsePortReservations(globalRecords);
+                    const assignments = await planPorts({
+                        project,
+                        services: args.services,
+                        rangeStart: args.rangeStart,
+                        rangeEnd: args.rangeEnd,
+                        reservations,
+                    }, isTcpPortAvailable);
+                    let persisted = 0;
+                    const warnings = [];
+                    if (args.persist) {
+                        const keyToOldIds = new Map();
+                        for (const reservation of reservations) {
+                            const key = reservationKey(reservation.project, reservation.service, reservation.protocol);
+                            if (!keyToOldIds.has(key)) {
+                                keyToOldIds.set(key, []);
+                            }
+                            keyToOldIds.get(key)?.push(reservation.id);
+                        }
+                        for (const assignment of assignments) {
+                            const key = reservationKey(assignment.project, assignment.service, assignment.protocol);
+                            const oldIds = keyToOldIds.get(key) ?? [];
+                            const text = `PORT_RESERVATION ${assignment.project} ${assignment.service} host=${assignment.hostPort} container=${assignment.containerPort} protocol=${assignment.protocol}`;
+                            try {
+                                const vector = await state.embedder.embed(text);
+                                if (vector.length === 0) {
+                                    warnings.push(`Skipped persistence for ${assignment.service}: empty embedding vector.`);
+                                    continue;
+                                }
+                                await state.store.put({
+                                    id: generateId(),
+                                    text,
+                                    vector,
+                                    category: "entity",
+                                    scope: "global",
+                                    importance: 0.8,
+                                    timestamp: Date.now(),
+                                    schemaVersion: SCHEMA_VERSION,
+                                    embeddingModel: state.config.embedding.model,
+                                    vectorDim: vector.length,
+                                    metadataJson: JSON.stringify({
+                                        source: "port-plan",
+                                        type: "port-reservation",
+                                        project: assignment.project,
+                                        service: assignment.service,
+                                        hostPort: assignment.hostPort,
+                                        containerPort: assignment.containerPort,
+                                        protocol: assignment.protocol,
+                                    }),
+                                });
+                                for (const id of oldIds) {
+                                    await state.store.deleteById(id, ["global"]);
+                                }
+                                persisted += 1;
+                            }
+                            catch (error) {
+                                warnings.push(`Failed to persist ${assignment.service}: ${toErrorMessage(error)}`);
+                            }
+                        }
+                    }
+                    return JSON.stringify({
+                        project,
+                        persistRequested: args.persist,
+                        persisted,
+                        assignments,
+                        warnings,
+                    }, null, 2);
+                },
+            }),
+        },
+    };
+    return hooks;
+};
+async function createRuntimeState(input) {
+    const resolved = resolveMemoryConfig(undefined, input.worktree);
+    const embedder = new OllamaEmbedder(resolved.embedding);
+    const store = new MemoryStore(resolved.dbPath);
+    const state = {
+        config: resolved,
+        embedder,
+        store,
+        defaultScope: deriveProjectScope(input.worktree),
+        initialized: false,
+        captureBuffer: new Map(),
+        ensureInitialized: async () => {
+            if (state.initialized)
+                return;
+            try {
+                const dim = await state.embedder.dim();
+                await state.store.init(dim);
+                state.initialized = true;
+            }
+            catch (error) {
+                console.warn(`[lancedb-opencode-pro] initialization deferred: ${toErrorMessage(error)}`);
+            }
+        },
+    };
+    return state;
+}
+async function getLastUserText(sessionID, client) {
+    try {
+        const response = await client.session.messages({ path: { id: sessionID } });
+        const payload = unwrapData(response);
+        if (!Array.isArray(payload))
+            return "";
+        for (let i = payload.length - 1; i >= 0; i -= 1) {
+            const item = payload[i];
+            if (item.info?.role !== "user" || !Array.isArray(item.parts))
+                continue;
+            const textParts = item.parts.filter((part) => part.type === "text" && typeof part.text === "string");
+            const text = textParts.map((part) => part.text).join("\n").trim();
+            if (text.length > 0)
+                return text;
+        }
+        return "";
+    }
+    catch {
+        return "";
+    }
+}
+async function flushAutoCapture(sessionID, state, client) {
+    const fragments = state.captureBuffer.get(sessionID) ?? [];
+    if (fragments.length === 0)
+        return;
+    state.captureBuffer.delete(sessionID);
+    const combined = fragments.join("\n").trim();
+    const candidate = extractCaptureCandidate(combined, state.config.minCaptureChars);
+    if (!candidate)
+        return;
+    await state.ensureInitialized();
+    if (!state.initialized)
+        return;
+    let vector = [];
+    try {
+        vector = await state.embedder.embed(candidate.text);
+    }
+    catch (error) {
+        console.warn(`[lancedb-opencode-pro] embedding unavailable during auto-capture: ${toErrorMessage(error)}`);
+        vector = [];
+    }
+    if (vector.length === 0) {
+        console.warn("[lancedb-opencode-pro] auto-capture skipped because embedding vector is empty");
+        return;
+    }
+    const activeScope = await resolveSessionScope(sessionID, client, state.defaultScope);
+    await state.store.put({
+        id: generateId(),
+        text: candidate.text,
+        vector,
+        category: candidate.category,
+        scope: activeScope,
+        importance: candidate.importance,
+        timestamp: Date.now(),
+        schemaVersion: SCHEMA_VERSION,
+        embeddingModel: state.config.embedding.model,
+        vectorDim: vector.length,
+        metadataJson: JSON.stringify({
+            source: "auto-capture",
+            sessionID,
+        }),
+    });
+    await state.store.pruneScope(activeScope, state.config.maxEntriesPerScope);
+}
+async function resolveSessionScope(sessionID, client, fallback) {
+    try {
+        const response = await client.session.get({ path: { id: sessionID } });
+        const payload = unwrapData(response);
+        if (payload?.directory && payload.directory.trim().length > 0) {
+            return deriveProjectScope(payload.directory);
+        }
+    }
+    catch { }
+    return fallback;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function unwrapData(value) {
+    if (value && typeof value === "object" && "data" in value) {
+        return value.data;
+    }
+    return value;
+}
+export default plugin;

package/dist/ports.d.ts

@@ -0,0 +1,34 @@
+import type { MemoryRecord } from "./types.js";
+export interface PortServiceRequest {
+    name: string;
+    containerPort: number;
+    preferredHostPort?: number;
+}
+export interface PortReservation {
+    id: string;
+    project: string;
+    service: string;
+    hostPort: number;
+    containerPort: number;
+    protocol: "tcp";
+}
+export interface PortAssignment {
+    project: string;
+    service: string;
+    hostPort: number;
+    containerPort: number;
+    protocol: "tcp";
+}
+export interface PlanPortsInput {
+    project: string;
+    services: PortServiceRequest[];
+    rangeStart: number;
+    rangeEnd: number;
+    reservations: PortReservation[];
+}
+type PortChecker = (port: number) => Promise<boolean>;
+export declare function parsePortReservations(records: MemoryRecord[]): PortReservation[];
+export declare function planPorts(input: PlanPortsInput, checker?: PortChecker): Promise<PortAssignment[]>;
+export declare function reservationKey(project: string, service: string, protocol: "tcp"): string;
+export declare function isTcpPortAvailable(port: number): Promise<boolean>;
+export {};

package/dist/ports.js

@@ -0,0 +1,129 @@
+import { createServer } from "node:net";
+export function parsePortReservations(records) {
+    const parsed = [];
+    for (const record of records) {
+        let metadata;
+        try {
+            metadata = JSON.parse(record.metadataJson);
+        }
+        catch {
+            continue;
+        }
+        if (!isPortReservationMetadata(metadata))
+            continue;
+        parsed.push({
+            id: record.id,
+            project: metadata.project,
+            service: metadata.service,
+            hostPort: metadata.hostPort,
+            containerPort: metadata.containerPort,
+            protocol: "tcp",
+        });
+    }
+    return parsed;
+}
+export async function planPorts(input, checker = isTcpPortAvailable) {
+    const reservedByPort = new Map();
+    for (const reservation of input.reservations) {
+        const key = reservationKey(reservation.project, reservation.service, reservation.protocol);
+        if (!reservedByPort.has(reservation.hostPort)) {
+            reservedByPort.set(reservation.hostPort, new Set());
+        }
+        reservedByPort.get(reservation.hostPort)?.add(key);
+    }
+    const occupied = new Set();
+    const planUsed = new Set();
+    const checked = new Map();
+    const assignments = [];
+    for (const service of input.services) {
+        const serviceKey = reservationKey(input.project, service.name, "tcp");
+        const preferred = Number.isInteger(service.preferredHostPort) ? Number(service.preferredHostPort) : undefined;
+        const candidate = await pickCandidatePort({
+            preferredHostPort: preferred,
+            rangeStart: input.rangeStart,
+            rangeEnd: input.rangeEnd,
+            serviceKey,
+            reservedByPort,
+            occupied,
+            planUsed,
+            checked,
+            checker,
+        });
+        if (candidate === null) {
+            throw new Error(`No available host port for service '${service.name}' in range ${input.rangeStart}-${input.rangeEnd}.`);
+        }
+        planUsed.add(candidate);
+        occupied.add(candidate);
+        assignments.push({
+            project: input.project,
+            service: service.name,
+            hostPort: candidate,
+            containerPort: service.containerPort,
+            protocol: "tcp",
+        });
+    }
+    return assignments;
+}
+export function reservationKey(project, service, protocol) {
+    return `${project}\u0000${service}\u0000${protocol}`;
+}
+export async function isTcpPortAvailable(port) {
+    if (!isValidPort(port))
+        return false;
+    return new Promise((resolve) => {
+        const server = createServer();
+        const finish = (result) => {
+            server.removeAllListeners();
+            server.close(() => resolve(result));
+        };
+        server.once("error", () => finish(false));
+        server.once("listening", () => finish(true));
+        server.listen({ host: "0.0.0.0", port, exclusive: true });
+    });
+}
+function isPortReservationMetadata(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const data = value;
+    return data.type === "port-reservation"
+        && typeof data.project === "string"
+        && typeof data.service === "string"
+        && Number.isInteger(data.hostPort)
+        && Number.isInteger(data.containerPort)
+        && (data.protocol === undefined || data.protocol === "tcp");
+}
+async function pickCandidatePort(input) {
+    const candidates = [];
+    if (input.preferredHostPort !== undefined) {
+        candidates.push(input.preferredHostPort);
+    }
+    for (let port = input.rangeStart; port <= input.rangeEnd; port += 1) {
+        if (port === input.preferredHostPort)
+            continue;
+        candidates.push(port);
+    }
+    for (const port of candidates) {
+        if (!isValidPort(port))
+            continue;
+        if (input.planUsed.has(port) || input.occupied.has(port))
+            continue;
+        const owners = input.reservedByPort.get(port);
+        if (owners && (owners.size > 1 || !owners.has(input.serviceKey))) {
+            continue;
+        }
+        let free = input.checked.get(port);
+        if (free === undefined) {
+            free = await input.checker(port);
+            input.checked.set(port, free);
+        }
+        if (!free) {
+            input.occupied.add(port);
+            continue;
+        }
+        return port;
+    }
+    return null;
+}
+function isValidPort(port) {
+    return Number.isInteger(port) && port >= 1 && port <= 65535;
+}

package/dist/scope.d.ts

@@ -0,0 +1,2 @@
+export declare function deriveProjectScope(worktree: string): string;
+export declare function buildScopeFilter(activeScope: string, includeGlobal: boolean): string[];

package/dist/scope.js

@@ -0,0 +1,24 @@
+import { execFileSync } from "node:child_process";
+import { stableHash } from "./utils.js";
+export function deriveProjectScope(worktree) {
+    const remote = tryGetGitRemote(worktree);
+    if (remote) {
+        return `project:${stableHash(remote).slice(0, 16)}`;
+    }
+    return `project:local:${stableHash(worktree).slice(0, 16)}`;
+}
+export function buildScopeFilter(activeScope, includeGlobal) {
+    return includeGlobal ? [activeScope, "global"] : [activeScope];
+}
+function tryGetGitRemote(worktree) {
+    try {
+        const output = execFileSync("git", ["-C", worktree, "config", "--get", "remote.origin.url"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return output.length > 0 ? output : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,36 @@
+import type { MemoryRecord, SearchResult } from "./types.js";
+export declare class MemoryStore {
+    private readonly dbPath;
+    private lancedb;
+    private connection;
+    private table;
+    private indexState;
+    private scopeCache;
+    constructor(dbPath: string);
+    init(vectorDim: number): Promise<void>;
+    put(record: MemoryRecord): Promise<void>;
+    search(params: {
+        query: string;
+        queryVector: number[];
+        scopes: string[];
+        limit: number;
+        vectorWeight: number;
+        bm25Weight: number;
+        minScore: number;
+    }): Promise<SearchResult[]>;
+    deleteById(id: string, scopes: string[]): Promise<boolean>;
+    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>;
+    getIndexHealth(): {
+        vector: boolean;
+        fts: boolean;
+        ftsError?: string;
+    };
+    private invalidateScope;
+    private getCachedScopes;
+    private requireTable;
+    private readByScopes;
+    private ensureIndexes;
+}