opencode-memory-pro 1.3.0

package/dist/tools/feedback.js

@@ -0,0 +1,112 @@
+import { tool } from "@opencode-ai/plugin";
+import { deriveProjectScope, buildScopeFilter } from "../scope.js";
+import { generateId } from "../utils.js";
+function unavailableMessage(provider) {
+    return `Memory store unavailable (${provider} embedding may be offline). Will retry automatically.`;
+}
+export function createFeedbackTools(state) {
+    return {
+        memory_feedback_missing: tool({
+            description: "Record feedback for memory that should have been stored",
+            args: {
+                text: tool.schema.string().min(1),
+                labels: tool.schema.array(tool.schema.string().min(1)).default([]),
+                scope: tool.schema.string().optional(),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                await state.store.putEvent({
+                    id: generateId(),
+                    type: "feedback",
+                    feedbackType: "missing",
+                    scope,
+                    sessionID: context.sessionID,
+                    timestamp: Date.now(),
+                    text: args.text,
+                    labels: args.labels ?? [],
+                    metadataJson: JSON.stringify({ source: "memory_feedback_missing" }),
+                });
+                return "Recorded missing-memory feedback.";
+            },
+        }),
+        memory_feedback_wrong: tool({
+            description: "Record feedback for memory that should not be stored",
+            args: {
+                id: tool.schema.string().min(8),
+                reason: tool.schema.string().optional(),
+                scope: tool.schema.string().optional(),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scopes = buildScopeFilter(scope, state.config.includeGlobalScope);
+                const exists = await state.store.hasMemory(args.id, scopes);
+                if (!exists) {
+                    return `Memory ${args.id} not found in current scope.`;
+                }
+                await state.store.putEvent({
+                    id: generateId(),
+                    type: "feedback",
+                    feedbackType: "wrong",
+                    scope,
+                    sessionID: context.sessionID,
+                    timestamp: Date.now(),
+                    memoryId: args.id,
+                    reason: args.reason,
+                    metadataJson: JSON.stringify({ source: "memory_feedback_wrong" }),
+                });
+                return `Recorded wrong-memory feedback for ${args.id}.`;
+            },
+        }),
+        memory_feedback_useful: tool({
+            description: "Record whether a recalled memory was helpful",
+            args: {
+                id: tool.schema.string().min(8),
+                helpful: tool.schema.boolean(),
+                scope: tool.schema.string().optional(),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scopes = buildScopeFilter(scope, state.config.includeGlobalScope);
+                const exists = await state.store.hasMemory(args.id, scopes);
+                if (!exists) {
+                    return `Memory ${args.id} not found in current scope.`;
+                }
+                await state.store.putEvent({
+                    id: generateId(),
+                    type: "feedback",
+                    feedbackType: "useful",
+                    scope,
+                    sessionID: context.sessionID,
+                    timestamp: Date.now(),
+                    memoryId: args.id,
+                    helpful: args.helpful,
+                    metadataJson: JSON.stringify({ source: "memory_feedback_useful" }),
+                });
+                return `Recorded recall usefulness feedback for ${args.id}.`;
+            },
+        }),
+        memory_effectiveness: tool({
+            description: "Show effectiveness metrics for capture recall and feedback",
+            args: {
+                scope: tool.schema.string().optional(),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const summary = await state.store.summarizeEvents(scope, state.config.includeGlobalScope);
+                return JSON.stringify(summary, null, 2);
+            },
+        }),
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { createMemoryTools, type ToolRuntimeState, type ToolContext } from "./memory.js";
+export { createFeedbackTools } from "./feedback.js";
+export { createEpisodicTools } from "./episodic.js";

package/dist/tools/index.js

@@ -0,0 +1,3 @@
+export { createMemoryTools } from "./memory.js";
+export { createFeedbackTools } from "./feedback.js";
+export { createEpisodicTools } from "./episodic.js";

package/dist/tools/memory.d.ts

@@ -0,0 +1,293 @@
+import { type Embedder } from "../embedder.js";
+import type { MemoryStore } from "../store.js";
+import type { MemoryRuntimeConfig, CitationStatus } from "../types.js";
+export interface ToolRuntimeState {
+    config: MemoryRuntimeConfig;
+    embedder: Embedder;
+    store: MemoryStore;
+    defaultScope: string;
+    initialized: boolean;
+    lastRecall: {
+        timestamp: number;
+        query: string;
+        results: {
+            memoryId: string;
+            score: number;
+            factors: {
+                relevance: {
+                    overall: number;
+                    vectorScore: number;
+                    bm25Score: number;
+                };
+                recency: {
+                    timestamp: number;
+                    ageHours: number;
+                    withinHalfLife: boolean;
+                    decayFactor: number;
+                };
+                citation?: {
+                    source: string;
+                    status: CitationStatus;
+                };
+                importance: number;
+                scope: {
+                    memoryScope: string;
+                    matchesCurrentScope: boolean;
+                    isGlobal: boolean;
+                };
+            };
+        }[];
+    } | null;
+    consolidationInProgress: Map<string, boolean>;
+    ensureInitialized: () => Promise<void>;
+}
+export type ToolContext = {
+    worktree: string;
+    sessionID: string;
+};
+export declare function createMemoryTools(state: ToolRuntimeState): {
+    memory_search: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            query: string;
+            limit: number;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_delete: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+            confirm: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            id: string;
+            confirm: boolean;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_clear: {
+        description: string;
+        args: {
+            scope: import("zod").ZodString;
+            confirm: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            scope: string;
+            confirm: boolean;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_stats: {
+        description: string;
+        args: {
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_event_cleanup: {
+        description: string;
+        args: {
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+            dryRun: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            archivePath: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            dryRun: boolean;
+            scope?: string | undefined;
+            archivePath?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_remember: {
+        description: string;
+        args: {
+            text: import("zod").ZodString;
+            category: import("zod").ZodOptional<import("zod").ZodString>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            text: string;
+            category?: string | undefined;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_forget: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            force: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            id: string;
+            force: boolean;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_citation: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            status: import("zod").ZodOptional<import("zod").ZodString>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            id: string;
+            status?: string | undefined;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_validate_citation: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            id: string;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_what_did_you_learn: {
+        description: string;
+        args: {
+            days: import("zod").ZodDefault<import("zod").ZodNumber>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            days: number;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_why: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            id: string;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_explain_recall: {
+        description: string;
+        args: {
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_scope_promote: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            confirm: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            id: string;
+            confirm: boolean;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_scope_demote: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            confirm: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            id: string;
+            confirm: boolean;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_global_list: {
+        description: string;
+        args: {
+            query: import("zod").ZodOptional<import("zod").ZodString>;
+            filter: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            limit: number;
+            query?: string | undefined;
+            filter?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_consolidate: {
+        description: string;
+        args: {
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+            confirm: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            confirm: boolean;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_consolidate_all: {
+        description: string;
+        args: {
+            confirm: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            confirm: boolean;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_port_plan: {
+        description: string;
+        args: {
+            project: import("zod").ZodOptional<import("zod").ZodString>;
+            services: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                containerPort: import("zod").ZodNumber;
+                preferredHostPort: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            rangeStart: import("zod").ZodDefault<import("zod").ZodNumber>;
+            rangeEnd: import("zod").ZodDefault<import("zod").ZodNumber>;
+            persist: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            services: {
+                name: string;
+                containerPort: number;
+                preferredHostPort?: number | undefined;
+            }[];
+            rangeStart: number;
+            rangeEnd: number;
+            persist: boolean;
+            project?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_dashboard: {
+        description: string;
+        args: {
+            days: import("zod").ZodDefault<import("zod").ZodNumber>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            days: number;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_kpi: {
+        description: string;
+        args: {
+            days: import("zod").ZodDefault<import("zod").ZodNumber>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            days: number;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};