@ephemushroom/opencode-claude-mem 0.6.2 → 0.7.1

package/dist/official-sync.d.ts

@@ -0,0 +1,29 @@
+export interface OfficialFiles {
+    readonly version: string;
+    /** The official OpenCode plugin: default export `{ id, server, setup }`. */
+    readonly plugin: string;
+    readonly mcpServer: string;
+}
+export type SyncResult = {
+    readonly ok: true;
+    readonly files: OfficialFiles;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export interface SyncOptions {
+    /** Directory holding one sub-directory per version. */
+    readonly root?: string;
+    readonly registry?: string;
+}
+export declare function officialRoot(): string;
+/** `CLAUDE_MEM_NPM_REGISTRY`, then npm's own registry setting, then the public registry. */
+export declare function npmRegistry(env?: Record<string, string | undefined>): string;
+/**
+ * Reads the named regular files out of a gzipped tar. npm tarballs are ustar; a path longer
+ * than the name field uses the prefix field, and anything else (pax records, directories)
+ * is skipped by its size. No `tar` binary is needed, which Windows may not have on PATH.
+ */
+export declare function extractTarFiles(archive: Uint8Array, members: readonly string[]): Map<string, Uint8Array>;
+/** The official files for `version`, downloading them once when they are not on disk. */
+export declare function syncOfficial(version: string, options?: SyncOptions): Promise<SyncResult>;

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;