@ephemushroom/opencode-claude-mem 0.7.0 → 0.7.1

package/dist/server.d.ts

@@ -0,0 +1,70 @@
+/**
+ * OpenCode V2 server plugin: one package entry that brings claude-mem to OpenCode.
+ *
+ * Capture and context injection stay upstream code: this plugin downloads the official
+ * claude-mem OpenCode plugin at the running Worker's version and runs its `setup` with
+ * this plugin's context. On top of that it registers the memory tools the official plugin
+ * leaves to claude-mem's MCP server, starts the Worker when it is not running, and reports
+ * what happened to the sidebar. Loaded from `opencode.json`:
+ *
+ * ```json
+ * { "plugins": ["@ephemushroom/opencode-claude-mem"] }
+ * ```
+ *
+ * `{ "package": "...", "options": { "mcp": true } }` registers claude-mem's MCP server
+ * (all of its tools, in a separate process) instead of this plugin's own tools.
+ */
+import { type CaptureStatusWriter } from './capture-status';
+import type { Plugin } from '@opencode/plugin';
+type Cleanup = () => Promise<void> | void;
+/** What a capture pass needs from the host; `Plugin.Context` satisfies it. */
+export interface CaptureContext {
+    readonly mcp: Pick<Plugin.Context['mcp'], 'transform'>;
+    /** The host's plugins for this checkout; its result is read defensively. */
+    readonly plugin: {
+        readonly list: () => Promise<unknown>;
+    };
+}
+/**
+ * What the host says about a plugin with the official id: loaded and running, loaded and
+ * failed, not among its plugins, or `unknown` while its list is still empty.
+ */
+export type OfficialPluginState = 'active' | 'failed' | 'absent' | 'unknown';
+export declare function officialPluginState(ctx: CaptureContext): Promise<OfficialPluginState>;
+/** One `setup` call: the host runs it once per checkout it serves. */
+export interface CaptureSession {
+    readonly ctx: CaptureContext;
+    readonly directory: string;
+    readonly status: CaptureStatusWriter;
+    readonly useMcp: boolean;
+    readonly keep: (cleanup: Cleanup) => void;
+    readonly disposed: () => boolean;
+    /** Something records this checkout's sessions: the copy loaded here, or a standalone one the host confirmed. */
+    capturing: boolean;
+    mcpRegistered: boolean;
+}
+/**
+ * True when the official plugin exists as a standalone file, the way
+ * `npx claude-mem install --ide opencode` leaves it in the config directory, or a project
+ * keeps it under `.opencode` in the checkout or a directory above it. OpenCode normally
+ * loads that file by itself, and a second copy here would record every prompt and tool
+ * call twice. The file alone proves nothing: whether it runs is the host's to say
+ * (`officialPluginState`).
+ */
+export declare function standalonePluginInstalled(env: Record<string, string | undefined>, home: string, directory: string): boolean;
+/** claude-mem's MCP server is a Node script; without Node the host binary runs it as Bun. */
+export declare function mcpServerCommand(script: string, node: string | null, host: string): {
+    command: string[];
+    environment?: Record<string, string>;
+};
+/**
+ * One pass over what is still missing: a running Worker, the official files at exactly its
+ * version, capture, and the MCP server when asked for. Resolves true when nothing is left
+ * to do. Each step is recorded only after it succeeded, so a later pass never repeats it:
+ * a second `setup` of the official plugin would record everything twice. Only the first
+ * pass starts the Worker; later ones look at what is there, so a Worker that crashes on
+ * start is not launched again every minute.
+ */
+export declare function attemptCapture(session: CaptureSession, first: boolean): Promise<boolean>;
+declare const plugin: Plugin.Plugin;
+export default plugin;