@momomemory/opencode-momo 0.1.3 → 0.1.5

package/README.md

@@ -115,6 +115,14 @@ The `momo` tool supports 6 operational modes:
 - **list**: List recent memories for a given scope.
 - **forget**: Remove a specific memory by its ID.
 
+### Ingestion Tools (RAG Pipeline)
+For richer ingestion than plain `read`, the plugin also exposes dedicated tools that route through Momo's document pipeline:
+- **momo_ingest**: Ingest text, URLs, or local files into documents + retrieval index, with optional memory extraction.
+- **momo_ocr**: Ingest image files, run OCR, and optionally extract memories from recognized text.
+- **momo_transcribe**: Ingest audio/video files, run transcription, and optionally extract memories.
+
+These tools are especially useful with non-vision models: image/audio content is converted into searchable text in Momo.
+
 ### Codebase Indexing
 The `/momo-init` command provides a structured workflow for agents to explore a new codebase and store its architecture, conventions, and key facts into project memory.
 
@@ -138,6 +146,14 @@ Momo supports the `<private>` tag. Any content wrapped in `<private>` tags is au
 **Scopes**: `user` (cross-project), `project` (current project, default)  
 **Memory Types**: `fact`, `preference`, `episode`
 
+### Ingestion Tool Arguments (high-level)
+
+| Tool | Required Args | Optional Args |
+|------|--------------|---------------|
+| `momo_ingest` | `input` | `inputType`, `scope`, `extractMemories`, `metadataJson`, `contentType`, `wait`, `timeoutMs`, `pollIntervalMs` |
+| `momo_ocr` | `filePath` | `scope`, `extractMemories`, `contentType`, `wait`, `timeoutMs`, `pollIntervalMs` |
+| `momo_transcribe` | `filePath` | `scope`, `extractMemories`, `contentType`, `wait`, `timeoutMs`, `pollIntervalMs` |
+
 ## Memory Scoping
 
 Memories are isolated using container tags derived from your environment:

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AA2IA;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CA+CjE;AA0ID;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG;IACpD,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAWA;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,IAAI,CA6CN"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AA2IA;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CA+CjE;AA0ID;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG;IACpD,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAWA;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,IAAI,CAwDN"}

package/dist/cli.js

@@ -11,10 +11,38 @@ import {
 } from "node:fs";
 import { join as join2 } from "node:path";
 import { createInterface } from "node:readline";
-
-// src/config.ts
+// node_modules/@momomemory/sdk/dist/plugin-config.js
+import { homedir, hostname } from "node:os";
 import { join } from "node:path";
-import { homedir } from "node:os";
+var OPENCLAW_DEFAULTS = {
+  baseUrl: "http://localhost:3000",
+  containerTag: `oclw_${hostname()}`,
+  perAgentMemory: false,
+  autoRecall: true,
+  autoCapture: true,
+  maxRecallResults: 10,
+  profileFrequency: 50,
+  captureMode: "all",
+  debug: false
+};
+var OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode");
+var PI_DEFAULTS = {
+  baseUrl: "http://localhost:3000",
+  containerTag: `pi_${hostname()}`,
+  autoRecall: true,
+  autoCapture: true,
+  maxRecallResults: 10,
+  profileFrequency: 50,
+  debug: false
+};
+// src/config.ts
+function getConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) {
+    return `${xdg}/opencode`;
+  }
+  return `${process.env.HOME}/.config/opencode`;
+}
 
 // src/services/jsonc.ts
 function stripJsoncComments(input) {
@@ -86,15 +114,6 @@ function stripJsoncComments(input) {
   return out.join("").replace(/,\s*([}\]])/g, "$1");
 }
 
-// src/config.ts
-function getConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME;
-  if (xdg) {
-    return join(xdg, "opencode");
-  }
-  return join(homedir(), ".config", "opencode");
-}
-
 // src/cli.ts
 var PLUGIN_NAME = "@momomemory/opencode-momo@latest";
 var MOMO_INIT_MD = `---
@@ -156,10 +175,10 @@ bunx @momomemory/opencode-momo configure
 \`\`\`
 
 Or set environment variables:
-- \`MOMO_BASE_URL\` - Momo server URL (default: http://localhost:3000)
-- \`MOMO_API_KEY\` - API key for authentication
-- \`MOMO_CONTAINER_TAG_USER\` - Optional user container tag override
-- \`MOMO_CONTAINER_TAG_PROJECT\` - Optional project container tag override
+- \`MOMO_OPENCODE_BASE_URL\` - Momo server URL (default: http://localhost:3000)
+- \`MOMO_OPENCODE_API_KEY\` - API key for authentication
+- \`MOMO_OPENCODE_CONTAINER_TAG_USER\` - Optional user container tag override
+- \`MOMO_OPENCODE_CONTAINER_TAG_PROJECT\` - Optional project container tag override
 
 After configuration, restart OpenCode to activate.
 `;
@@ -409,10 +428,11 @@ function writeMomoConfig(configDir, options) {
       existing = {};
     }
   }
-  const priorBaseUrl = typeof existing.baseUrl === "string" ? existing.baseUrl : undefined;
-  const priorApiKey = typeof existing.apiKey === "string" ? existing.apiKey : undefined;
-  const priorContainerTagUser = typeof existing.containerTagUser === "string" ? existing.containerTagUser : undefined;
-  const priorContainerTagProject = typeof existing.containerTagProject === "string" ? existing.containerTagProject : undefined;
+  const existingOpenCode = existing.opencode && typeof existing.opencode === "object" && !Array.isArray(existing.opencode) ? existing.opencode : {};
+  const priorBaseUrl = typeof existingOpenCode.baseUrl === "string" ? existingOpenCode.baseUrl : undefined;
+  const priorApiKey = typeof existingOpenCode.apiKey === "string" ? existingOpenCode.apiKey : undefined;
+  const priorContainerTagUser = typeof existingOpenCode.containerTagUser === "string" ? existingOpenCode.containerTagUser : undefined;
+  const priorContainerTagProject = typeof existingOpenCode.containerTagProject === "string" ? existingOpenCode.containerTagProject : undefined;
   const config = {
     baseUrl: options.baseUrl ?? priorBaseUrl ?? "http://localhost:3000",
     apiKey: options.apiKey ?? priorApiKey ?? "",
@@ -420,16 +440,19 @@ function writeMomoConfig(configDir, options) {
     containerTagProject: priorContainerTagProject ?? ""
   };
   const lines = ["{"];
-  lines.push("  // Momo server URL (default: http://localhost:3000)");
-  lines.push(`  "baseUrl": ${JSON.stringify(config.baseUrl)},`);
-  lines.push("  // API key for authentication (leave empty if your server has auth disabled)");
-  lines.push(`  "apiKey": ${JSON.stringify(config.apiKey)},`);
-  lines.push("  // Optional override for user memory container tag (default: auto-derived from username)");
-  lines.push(`  "containerTagUser": ${JSON.stringify(config.containerTagUser)},`);
-  lines.push("  // Optional override for project memory container tag (default: auto-derived from project directory)");
-  lines.push(`  "containerTagProject": ${JSON.stringify(config.containerTagProject)}`);
-  lines.push("  // Note: project-local config files (.momo.jsonc / momo.jsonc) override this global file,");
-  lines.push("  // and MOMO_* environment variables override both.");
+  lines.push("  // OpenCode plugin config for Momo");
+  lines.push('  "opencode": {');
+  lines.push("    // Momo server URL (default: http://localhost:3000)");
+  lines.push(`    "baseUrl": ${JSON.stringify(config.baseUrl)},`);
+  lines.push("    // API key for authentication (leave empty if your server has auth disabled)");
+  lines.push(`    "apiKey": ${JSON.stringify(config.apiKey)},`);
+  lines.push("    // Optional override for user memory container tag (default: auto-derived from username)");
+  lines.push(`    "containerTagUser": ${JSON.stringify(config.containerTagUser)},`);
+  lines.push("    // Optional override for project memory container tag (default: auto-derived from project directory)");
+  lines.push(`    "containerTagProject": ${JSON.stringify(config.containerTagProject)}`);
+  lines.push("  }");
+  lines.push("  // Note: project-local config file (.momo.jsonc) overrides this global file,");
+  lines.push("  // and MOMO_OPENCODE_* environment variables override both.");
   lines.push("}");
   lines.push("");
   writeFileSync(configPath, lines.join(`
@@ -483,8 +506,8 @@ Next steps:
      $ opencode-momo configure --base-url http://localhost:3000 --api-key YOUR_KEY
 
      Or set environment variables:
-     $ export MOMO_API_KEY=your-key
-     $ export MOMO_BASE_URL=http://localhost:3000
+     $ export MOMO_OPENCODE_API_KEY=your-key
+     $ export MOMO_OPENCODE_BASE_URL=http://localhost:3000
 
   2. Restart OpenCode to activate the plugin.
 

package/dist/config.d.ts

@@ -1,9 +1,8 @@
-export interface MomoConfig {
-    apiKey?: string;
+import { type ResolvedOpenCodePluginConfig } from "@momomemory/sdk";
+export type { ResolvedOpenCodePluginConfig };
+export type MomoConfig = ResolvedOpenCodePluginConfig & {
     baseUrl: string;
-    containerTagUser?: string;
-    containerTagProject?: string;
-}
+};
 export declare function getConfigDir(): string;
 export declare function loadConfig(directory?: string): MomoConfig;
 export declare function isConfigured(directory?: string): boolean;

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAWD,wBAAgB,YAAY,IAAI,MAAM,CAMrC;AAiCD,wBAAgB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,CAmBzD;AAED,wBAAgB,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAGxD"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAE9F,YAAY,EAAE,4BAA4B,EAAE,CAAC;AAE7C,MAAM,MAAM,UAAU,GAAG,4BAA4B,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5E,wBAAgB,YAAY,IAAI,MAAM,CAMrC;AAED,wBAAgB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,CAMzD;AAED,wBAAgB,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAGxD"}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAoC/D,eAAO,MAAM,UAAU,EAAE,MAmSxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAuG/D,eAAO,MAAM,UAAU,EAAE,MAqpBxB,CAAC"}

package/dist/index.js

@@ -12329,6 +12329,10 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// src/index.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { basename as basename2 } from "node:path";
+
 // node_modules/openapi-fetch/dist/index.js
 var PATH_PARAM_RE = /\{[^{}]+\}/g;
 var supportsRequestInitExt = () => {
@@ -12354,7 +12358,7 @@ function createClient(clientOptions) {
   async function coreFetch(schemaPath, fetchOptions) {
     const {
       baseUrl: localBaseUrl,
-      fetch = baseFetch,
+      fetch: fetch2 = baseFetch,
       Request = CustomRequest,
       headers,
       params = {},
@@ -12399,7 +12403,7 @@ function createClient(clientOptions) {
       id = randomID();
       options = Object.freeze({
         baseUrl: finalBaseUrl,
-        fetch,
+        fetch: fetch2,
         parseAs,
         querySerializer,
         bodySerializer
@@ -12428,7 +12432,7 @@ function createClient(clientOptions) {
     }
     if (!response) {
       try {
-        response = await fetch(request, requestInitExt);
+        response = await fetch2(request, requestInitExt);
       } catch (error46) {
         let errorAfterMiddleware = error46;
         if (middlewares.length) {
@@ -12859,6 +12863,11 @@ class DocumentsGroup {
       formData.append("containerTag", containerTag);
     if (body?.metadata)
       formData.append("metadata", body.metadata);
+    if (body?.extractMemories !== undefined) {
+      formData.append("extractMemories", String(body.extractMemories));
+    }
+    if (body?.contentType)
+      formData.append("contentType", body.contentType);
     const headers = { ...opts?.headers ?? {} };
     const apiKey = this.config.getApiKey ? await this.config.getApiKey() : this.config.apiKey;
     if (apiKey)
@@ -13415,26 +13424,24 @@ class MomoClient {
     this.health = new HealthGroup(this.raw, config2);
   }
 }
-// src/config.ts
-import { readFileSync, existsSync } from "node:fs";
+// node_modules/@momomemory/sdk/dist/plugin-config.js
+import { homedir, hostname as hostname3 } from "node:os";
 import { join } from "node:path";
-import { homedir } from "node:os";
-
-// src/services/jsonc.ts
-function stripJsoncComments(input) {
-  var Mode;
-  ((Mode2) => {
+import { existsSync, readFileSync } from "node:fs";
+function stripJsoncComments(content) {
+  let Mode;
+  (function(Mode2) {
     Mode2[Mode2["Code"] = 0] = "Code";
     Mode2[Mode2["String"] = 1] = "String";
     Mode2[Mode2["LineComment"] = 2] = "LineComment";
     Mode2[Mode2["BlockComment"] = 3] = "BlockComment";
-  })(Mode ||= {});
+  })(Mode || (Mode = {}));
   const out = [];
-  let mode = 0 /* Code */;
-  for (let i = 0;i < input.length; i++) {
-    const ch = input[i];
-    const next = input[i + 1];
-    if (mode === 1 /* String */) {
+  let mode = Mode.Code;
+  for (let i = 0;i < content.length; i++) {
+    const ch = content[i];
+    const next = content[i + 1];
+    if (mode === Mode.String) {
       out.push(ch);
       if (ch === "\\") {
         if (next !== undefined) {
@@ -13444,22 +13451,22 @@ function stripJsoncComments(input) {
         continue;
       }
       if (ch === '"') {
-        mode = 0 /* Code */;
+        mode = Mode.Code;
       }
       continue;
     }
-    if (mode === 2 /* LineComment */) {
+    if (mode === Mode.LineComment) {
       if (ch === `
 `) {
-        mode = 0 /* Code */;
+        mode = Mode.Code;
         out.push(`
 `);
       }
       continue;
     }
-    if (mode === 3 /* BlockComment */) {
+    if (mode === Mode.BlockComment) {
       if (ch === "*" && next === "/") {
-        mode = 0 /* Code */;
+        mode = Mode.Code;
         i++;
         continue;
       }
@@ -13471,17 +13478,17 @@ function stripJsoncComments(input) {
       continue;
     }
     if (ch === '"') {
-      mode = 1 /* String */;
+      mode = Mode.String;
       out.push(ch);
       continue;
     }
     if (ch === "/" && next === "/") {
-      mode = 2 /* LineComment */;
+      mode = Mode.LineComment;
       i++;
       continue;
     }
     if (ch === "/" && next === "*") {
-      mode = 3 /* BlockComment */;
+      mode = Mode.BlockComment;
       i++;
       continue;
     }
@@ -13489,56 +13496,248 @@ function stripJsoncComments(input) {
   }
   return out.join("").replace(/,\s*([}\]])/g, "$1");
 }
-
-// src/config.ts
-var DEFAULT_BASE_URL = "http://localhost:3000";
-function getConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME;
-  if (xdg) {
-    return join(xdg, "opencode");
-  }
-  return join(homedir(), ".config", "opencode");
-}
-function readConfigFile() {
-  const configPath = join(getConfigDir(), "momo.jsonc");
-  return readJsoncConfigFile(configPath);
-}
-function readJsoncConfigFile(configPath) {
+function readJsoncFile(path) {
   try {
-    const raw = readFileSync(configPath, "utf-8");
+    if (!existsSync(path))
+      return null;
+    const raw = readFileSync(path, "utf-8");
     const stripped = stripJsoncComments(raw);
     return JSON.parse(stripped);
   } catch {
-    return {};
+    return null;
   }
 }
-function readProjectConfigFile(directory) {
-  if (!directory)
-    return {};
-  const dotPath = join(directory, ".momo.jsonc");
-  if (existsSync(dotPath)) {
-    return readJsoncConfigFile(dotPath);
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function sanitizeContainerTag(value) {
+  return value.replace(/[^A-Za-z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function interpolateEnvVars(value) {
+  return value.replace(/\$\{([^}]+)\}/g, (_chunk, key) => {
+    const envValue = process.env[key];
+    if (!envValue) {
+      throw new Error(`Environment variable ${key} is not set`);
+    }
+    return envValue;
+  });
+}
+function toBoolean(value, fallback, trueValues = ["true", "1", "yes"], falseValues = ["false", "0", "no"]) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string") {
+    const lower = value.toLowerCase();
+    if (trueValues.includes(lower))
+      return true;
+    if (falseValues.includes(lower))
+      return false;
   }
-  const plainPath = join(directory, "momo.jsonc");
-  if (existsSync(plainPath)) {
-    return readJsoncConfigFile(plainPath);
+  return fallback;
+}
+function toBoundedInt(value, fallback, min, max) {
+  let n;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    n = Math.round(value);
+  } else if (typeof value === "string") {
+    const parsed = parseInt(value, 10);
+    if (Number.isFinite(parsed)) {
+      n = Math.round(parsed);
+    } else {
+      return fallback;
+    }
+  } else {
+    return fallback;
+  }
+  if (n < min)
+    return min;
+  if (n > max)
+    return max;
+  return n;
+}
+function pickString(key, envKey, config2, fallback) {
+  const envValue = process.env[envKey];
+  if (envValue !== undefined)
+    return interpolateEnvVars(envValue);
+  if (hasOwn(config2, key) && typeof config2[key] === "string") {
+    return interpolateEnvVars(config2[key]);
+  }
+  return fallback;
+}
+function pickOptionalString(key, envKey, config2) {
+  const envValue = process.env[envKey];
+  if (envValue !== undefined)
+    return interpolateEnvVars(envValue);
+  if (hasOwn(config2, key) && typeof config2[key] === "string") {
+    return interpolateEnvVars(config2[key]);
+  }
+  return;
+}
+function pickBoolean(key, envKey, config2, fallback) {
+  const envValue = process.env[envKey];
+  if (envValue !== undefined) {
+    return toBoolean(envValue, fallback);
+  }
+  return toBoolean(config2[key], fallback);
+}
+function pickBoundedInt(key, envKey, config2, fallback, min, max) {
+  const envValue = process.env[envKey];
+  if (envValue !== undefined) {
+    return toBoundedInt(envValue, fallback, min, max);
+  }
+  return toBoundedInt(config2[key], fallback, min, max);
+}
+var OPENCLAW_DEFAULTS = {
+  baseUrl: "http://localhost:3000",
+  containerTag: `oclw_${hostname3()}`,
+  perAgentMemory: false,
+  autoRecall: true,
+  autoCapture: true,
+  maxRecallResults: 10,
+  profileFrequency: 50,
+  captureMode: "all",
+  debug: false
+};
+var OPENCLAW_ENV_PREFIX = "MOMO_OPENCLAW_";
+function loadOpenClawConfig(config2) {
+  const pluginConfig = config2.openclaw ?? {};
+  const prefix = OPENCLAW_ENV_PREFIX;
+  return {
+    baseUrl: pickString("baseUrl", `${prefix}BASE_URL`, pluginConfig, OPENCLAW_DEFAULTS.baseUrl),
+    apiKey: pickOptionalString("apiKey", `${prefix}API_KEY`, pluginConfig),
+    containerTag: sanitizeContainerTag(pickString("containerTag", `${prefix}CONTAINER_TAG`, pluginConfig, OPENCLAW_DEFAULTS.containerTag)),
+    perAgentMemory: toBoolean(pluginConfig.perAgentMemory, OPENCLAW_DEFAULTS.perAgentMemory),
+    autoRecall: toBoolean(pluginConfig.autoRecall, OPENCLAW_DEFAULTS.autoRecall),
+    autoCapture: toBoolean(pluginConfig.autoCapture, OPENCLAW_DEFAULTS.autoCapture),
+    maxRecallResults: toBoundedInt(pluginConfig.maxRecallResults, OPENCLAW_DEFAULTS.maxRecallResults, 1, 20),
+    profileFrequency: toBoundedInt(pluginConfig.profileFrequency, OPENCLAW_DEFAULTS.profileFrequency, 1, 500),
+    captureMode: pluginConfig.captureMode === "everything" ? "everything" : OPENCLAW_DEFAULTS.captureMode,
+    debug: toBoolean(pluginConfig.debug, OPENCLAW_DEFAULTS.debug)
+  };
+}
+var OPENCODE_DEFAULTS = {
+  baseUrl: "http://localhost:3000"
+};
+var OPENCODE_ENV_PREFIX = "MOMO_OPENCODE_";
+var OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode");
+function loadOpenCodeConfig(config2) {
+  const pluginConfig = config2.opencode ?? {};
+  const prefix = OPENCODE_ENV_PREFIX;
+  return {
+    baseUrl: pickString("baseUrl", `${prefix}BASE_URL`, pluginConfig, OPENCODE_DEFAULTS.baseUrl),
+    apiKey: pickOptionalString("apiKey", `${prefix}API_KEY`, pluginConfig),
+    containerTagUser: pickOptionalString("containerTagUser", `${prefix}CONTAINER_TAG_USER`, pluginConfig),
+    containerTagProject: pickOptionalString("containerTagProject", `${prefix}CONTAINER_TAG_PROJECT`, pluginConfig)
+  };
+}
+var PI_DEFAULTS = {
+  baseUrl: "http://localhost:3000",
+  containerTag: `pi_${hostname3()}`,
+  autoRecall: true,
+  autoCapture: true,
+  maxRecallResults: 10,
+  profileFrequency: 50,
+  debug: false
+};
+var PI_ENV_PREFIX = "MOMO_PI_";
+function loadPiConfig(config2) {
+  const pluginConfig = config2.pi ?? {};
+  const record2 = pluginConfig;
+  const prefix = PI_ENV_PREFIX;
+  return {
+    baseUrl: pickString("baseUrl", `${prefix}BASE_URL`, record2, PI_DEFAULTS.baseUrl),
+    apiKey: pickOptionalString("apiKey", `${prefix}API_KEY`, record2),
+    containerTag: sanitizeContainerTag(pickString("containerTag", `${prefix}CONTAINER_TAG`, record2, PI_DEFAULTS.containerTag)),
+    autoRecall: pickBoolean("autoRecall", `${prefix}AUTO_RECALL`, record2, PI_DEFAULTS.autoRecall),
+    autoCapture: pickBoolean("autoCapture", `${prefix}AUTO_CAPTURE`, record2, PI_DEFAULTS.autoCapture),
+    maxRecallResults: pickBoundedInt("maxRecallResults", `${prefix}MAX_RECALL_RESULTS`, record2, PI_DEFAULTS.maxRecallResults, 1, 20),
+    profileFrequency: pickBoundedInt("profileFrequency", `${prefix}PROFILE_FREQUENCY`, record2, PI_DEFAULTS.profileFrequency, 1, 500),
+    debug: pickBoolean("debug", `${prefix}DEBUG`, record2, PI_DEFAULTS.debug)
+  };
+}
+function getConfigPaths(plugin, cwd = process.cwd(), globalConfigDir) {
+  switch (plugin) {
+    case "opencode":
+      return {
+        project: join(cwd, ".momo.jsonc"),
+        global: join(globalConfigDir ?? OPENCODE_CONFIG_DIR, "momo.jsonc")
+      };
+    case "openclaw":
+      return {
+        project: join(cwd, ".momo.jsonc"),
+        global: join(globalConfigDir ?? join(homedir(), ".openclaw"), "momo.jsonc")
+      };
+    case "pi":
+      return {
+        project: join(cwd, ".momo.jsonc"),
+        global: join(globalConfigDir ?? join(homedir(), ".pi"), "momo.jsonc")
+      };
   }
-  return {};
 }
-function loadConfig(directory) {
-  const globalConfig2 = readConfigFile();
-  const projectConfig = readProjectConfigFile(directory);
-  const envApiKey = process.env.MOMO_API_KEY;
-  const envBaseUrl = process.env.MOMO_BASE_URL;
-  const envContainerTagUser = process.env.MOMO_CONTAINER_TAG_USER;
-  const envContainerTagProject = process.env.MOMO_CONTAINER_TAG_PROJECT;
+function mergeConfigs(...configs) {
+  const result = {};
+  for (const config2 of configs) {
+    if (!config2)
+      continue;
+    for (const [key, value] of Object.entries(config2)) {
+      if (value !== undefined) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function loadPluginConfig(plugin, options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const globalConfigDir = options?.globalConfigDir;
+  const paths = getConfigPaths(plugin, cwd, globalConfigDir);
+  const projectConfig = readJsoncFile(paths.project ?? "");
+  const globalConfig2 = readJsoncFile(paths.global ?? "");
+  const mergedConfig = {
+    openclaw: mergeConfigs(globalConfig2?.openclaw, projectConfig?.openclaw),
+    opencode: mergeConfigs(globalConfig2?.opencode, projectConfig?.opencode),
+    pi: mergeConfigs(globalConfig2?.pi, projectConfig?.pi)
+  };
+  let config2;
+  switch (plugin) {
+    case "openclaw":
+      config2 = loadOpenClawConfig(mergedConfig);
+      break;
+    case "opencode":
+      config2 = loadOpenCodeConfig(mergedConfig);
+      break;
+    case "pi":
+      config2 = loadPiConfig(mergedConfig);
+      break;
+  }
   return {
-    apiKey: envApiKey ?? projectConfig.apiKey ?? globalConfig2.apiKey,
-    baseUrl: envBaseUrl ?? projectConfig.baseUrl ?? globalConfig2.baseUrl ?? DEFAULT_BASE_URL,
-    containerTagUser: envContainerTagUser ?? projectConfig.containerTagUser ?? globalConfig2.containerTagUser,
-    containerTagProject: envContainerTagProject ?? projectConfig.containerTagProject ?? globalConfig2.containerTagProject
+    config: config2,
+    meta: {
+      cwd,
+      files: {
+        project: paths.project && existsSync(paths.project) ? paths.project : undefined,
+        global: paths.global && existsSync(paths.global) ? paths.global : undefined
+      }
+    }
   };
 }
+function loadOpenCodePluginConfig(options) {
+  return loadPluginConfig("opencode", options);
+}
+// src/config.ts
+function getConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) {
+    return `${xdg}/opencode`;
+  }
+  return `${process.env.HOME}/.config/opencode`;
+}
+function loadConfig(directory) {
+  const { config: config2 } = loadOpenCodePluginConfig({
+    cwd: directory ?? process.cwd(),
+    globalConfigDir: getConfigDir()
+  });
+  return config2;
+}
 function isConfigured(directory) {
   const config2 = loadConfig(directory);
   return config2.apiKey != null && config2.apiKey.length > 0;
@@ -13697,6 +13896,8 @@ async function handleCompactionEvent(event, momo, containerTag) {
 
 // src/index.ts
 var z = tool.schema;
+var DEFAULT_INGEST_TIMEOUT_MS = 120000;
+var DEFAULT_POLL_INTERVAL_MS = 1500;
 var injectedSessions = new Set;
 var HELP_TEXT = `**Momo Memory Commands**
 
@@ -13718,6 +13919,57 @@ var HELP_TEXT = `**Momo Memory Commands**
 - \`momo({ mode: "search", query: "database schema" })\`
 - \`momo({ mode: "forget", memoryId: "mem_abc123" })\`
 `;
+function truncate(value, max = 600) {
+  if (value.length <= max)
+    return value;
+  return `${value.slice(0, max)}...`;
+}
+function inferInputType(input, inputType) {
+  if (inputType && inputType !== "auto")
+    return inputType;
+  if (input.startsWith("http://") || input.startsWith("https://"))
+    return "url";
+  if (existsSync2(input))
+    return "file";
+  return "text";
+}
+function parseMetadataJson(metadataJson) {
+  if (!metadataJson)
+    return {};
+  try {
+    const parsed = JSON.parse(metadataJson);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { error: "metadataJson must be a JSON object" };
+    }
+    return parsed;
+  } catch (error45) {
+    const message = error45 instanceof Error ? error45.message : String(error45);
+    return { error: `Invalid metadataJson: ${message}` };
+  }
+}
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatSearchContent(result) {
+  if (result.type === "memory") {
+    if (result.content?.trim())
+      return result.content;
+    return result.memoryId ? `[memory:${result.memoryId}]` : "(empty memory)";
+  }
+  const fromContent = result.content?.trim();
+  if (fromContent)
+    return fromContent;
+  const fromChunk = result.chunks?.find((c) => c.content?.trim())?.content;
+  if (fromChunk)
+    return fromChunk;
+  const fromTitle = result.title?.trim();
+  if (fromTitle)
+    return fromTitle;
+  const fromSummary = result.summary?.trim();
+  if (fromSummary)
+    return fromSummary;
+  return result.documentId ? `[document:${result.documentId}]` : "(empty document match)";
+}
 var MomoPlugin = async (ctx) => {
   const config2 = loadConfig(ctx.directory);
   const configured = isConfigured(ctx.directory);
@@ -13734,7 +13986,7 @@ var MomoPlugin = async (ctx) => {
   });
   function requireMomo() {
     if (!momo) {
-      throw new Error("Momo is not configured. Set MOMO_API_KEY or configure ~/.config/opencode/momo.jsonc (or project-local .momo.jsonc).");
+      throw new Error("Momo is not configured. Set MOMO_OPENCODE_API_KEY or configure ~/.config/opencode/momo.jsonc (or project-local .momo.jsonc).");
     }
     return momo;
   }
@@ -13743,6 +13995,100 @@ var MomoPlugin = async (ctx) => {
       return tags.user;
     return tags.project;
   }
+  async function waitForIngestion(client, ingestionId, timeoutMs, pollIntervalMs) {
+    const start = Date.now();
+    let transientErrors = 0;
+    while (Date.now() - start < timeoutMs) {
+      let status;
+      try {
+        status = await client.documents.getIngestionStatus(ingestionId, {
+          timeoutMs
+        });
+      } catch (error45) {
+        const message = error45 instanceof Error ? error45.message.toLowerCase() : String(error45).toLowerCase();
+        const isTransient = message.includes("database is locked") || message.includes("internal error") || message.includes("timeout") || message.includes("503") || message.includes("502");
+        if (!isTransient)
+          throw error45;
+        transientErrors += 1;
+        if (transientErrors > 5) {
+          throw error45;
+        }
+        await delay(pollIntervalMs);
+        continue;
+      }
+      if (status.status === "completed" || status.status === "failed") {
+        return {
+          status: status.status,
+          title: status.title ?? undefined,
+          documentId: status.documentId
+        };
+      }
+      await delay(pollIntervalMs);
+    }
+    return { status: "processing" };
+  }
+  async function formatDocumentResult(client, documentId, scope, extractedBy) {
+    try {
+      const doc2 = await client.documents.get(documentId);
+      const lines = [
+        `Document ready (scope: ${scope}).`,
+        `- documentId: ${doc2.documentId}`,
+        `- docType: ${doc2.docType}`,
+        `- ingestionStatus: ${doc2.ingestionStatus}`
+      ];
+      if (extractedBy)
+        lines.push(`- extractor: ${extractedBy}`);
+      if (doc2.title)
+        lines.push(`- title: ${doc2.title}`);
+      if (doc2.errorMessage)
+        lines.push(`- notes: ${doc2.errorMessage}`);
+      if (doc2.content)
+        lines.push(`- extractedTextPreview: ${truncate(doc2.content, 800)}`);
+      return lines.join(`
+`);
+    } catch {
+      return [
+        `Document ready (scope: ${scope}).`,
+        `- documentId: ${documentId}`,
+        extractedBy ? `- extractor: ${extractedBy}` : undefined
+      ].filter(Boolean).join(`
+`);
+    }
+  }
+  async function uploadDocumentFromPath(filePath, params) {
+    const fs = await Function("return import('fs/promises')")();
+    const { buffer } = await fs.readFile(filePath);
+    const file2 = new File([new Blob([new Uint8Array(buffer)])], basename2(filePath));
+    const formData = new FormData;
+    formData.append("file", file2);
+    formData.append("containerTag", params.containerTag);
+    formData.append("extractMemories", String(params.extractMemories));
+    if (params.contentType)
+      formData.append("contentType", params.contentType);
+    if (params.metadata && Object.keys(params.metadata).length > 0) {
+      formData.append("metadata", JSON.stringify(params.metadata));
+    }
+    const headers = {};
+    if (config2.apiKey)
+      headers.Authorization = `Bearer ${config2.apiKey}`;
+    const response = await fetch(`${config2.baseUrl}/api/v1/documents:upload`, {
+      method: "POST",
+      body: formData,
+      headers,
+      signal: AbortSignal.timeout(params.timeoutMs)
+    });
+    const json2 = await response.json();
+    if (!response.ok || json2.error) {
+      const message = json2.error?.message ?? `Upload failed with status ${response.status}`;
+      throw new Error(message);
+    }
+    const documentId = json2.data?.documentId;
+    const ingestionId = json2.data?.ingestionId;
+    if (!documentId || !ingestionId) {
+      throw new Error("Upload response missing documentId/ingestionId");
+    }
+    return { documentId, ingestionId };
+  }
   const momoTool = tool({
     description: "Interact with Momo long-term memory. Modes: help, add, search, profile, list, forget.",
     args: {
@@ -13789,18 +14135,23 @@ var MomoPlugin = async (ctx) => {
             q: args.query,
             containerTags,
             limit: args.limit ?? 10,
-            scope: "hybrid"
+            scope: "hybrid",
+            include: {
+              documents: true,
+              chunks: true
+            }
           });
           if (!results.results || results.results.length === 0) {
-            return "No memories found matching your query.";
+            return "No results found matching your query.";
           }
           const formatted = results.results.map((r, i) => {
             const relevance = r.type === "memory" ? r.similarity : r.score;
             const scoreStr = ` (score: ${relevance.toFixed(2)})`;
-            return `${i + 1}. ${r.content ?? "(no content)"}${scoreStr}`;
+            const content = formatSearchContent(r);
+            return `${i + 1}. ${content}${scoreStr}`;
           }).join(`
 `);
-          return `Found ${results.results.length} memories:
+          return `Found ${results.results.length} results:
 
 ${formatted}`;
         }
@@ -13866,6 +14217,166 @@ ${formatted}`;
       }
     }
   });
+  const momoIngestTool = tool({
+    description: "Ingest text, URLs, and files through Momo's document pipeline (RAG + optional memory extraction).",
+    args: {
+      input: z.string().describe("Text, URL, or local file path to ingest"),
+      inputType: z.enum(["auto", "text", "url", "file"]).optional().describe("How to interpret input (default: auto)"),
+      scope: z.enum(["user", "project"]).optional().describe("Memory/document scope (default: project)"),
+      extractMemories: z.boolean().optional().describe("Whether to extract memories from ingested content (default: true)"),
+      metadataJson: z.string().optional().describe("Optional JSON object string attached as metadata"),
+      contentType: z.string().optional().describe("Optional content type hint (e.g. audio/mpeg, video/webm)"),
+      wait: z.boolean().optional().describe("Wait for ingestion to finish before returning (default: true)"),
+      timeoutMs: z.number().optional().describe("Max wait timeout in milliseconds (default: 120000)"),
+      pollIntervalMs: z.number().optional().describe("Polling interval while waiting (default: 1500)")
+    },
+    async execute(args, _context) {
+      const client = requireMomo();
+      const scope = args.scope ?? "project";
+      const containerTag = resolveContainerTag(scope);
+      const extractMemories = args.extractMemories ?? true;
+      const wait = args.wait ?? true;
+      const timeoutMs = args.timeoutMs ?? DEFAULT_INGEST_TIMEOUT_MS;
+      const pollIntervalMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+      const parsedMetadata = parseMetadataJson(args.metadataJson);
+      if ("error" in parsedMetadata)
+        return `Error: ${parsedMetadata.error}`;
+      const inferred = inferInputType(args.input, args.inputType);
+      const ingestResult = inferred === "file" ? await uploadDocumentFromPath(args.input, {
+        containerTag,
+        metadata: parsedMetadata,
+        extractMemories,
+        contentType: args.contentType,
+        timeoutMs
+      }) : await client.documents.create({
+        content: args.input,
+        containerTag,
+        extractMemories,
+        contentType: args.contentType,
+        metadata: parsedMetadata
+      }, { timeoutMs });
+      const documentId = ingestResult.documentId;
+      const ingestionId = ingestResult.ingestionId;
+      if (!wait) {
+        return [
+          `Ingestion queued (scope: ${scope}).`,
+          `- inputType: ${inferred}`,
+          `- documentId: ${documentId}`,
+          `- ingestionId: ${ingestionId}`,
+          `- extractMemories: ${extractMemories}`
+        ].join(`
+`);
+      }
+      const status = await waitForIngestion(client, ingestionId, timeoutMs, pollIntervalMs);
+      if (status.status !== "completed") {
+        return [
+          `Ingestion status: ${status.status} (scope: ${scope}).`,
+          `- inputType: ${inferred}`,
+          `- documentId: ${documentId}`,
+          `- ingestionId: ${ingestionId}`,
+          status.title ? `- title: ${status.title}` : undefined
+        ].filter(Boolean).join(`
+`);
+      }
+      return formatDocumentResult(client, documentId, scope);
+    }
+  });
+  const momoOcrTool = tool({
+    description: "OCR an image file via Momo ingestion, then return extracted text preview and memory extraction status.",
+    args: {
+      filePath: z.string().describe("Local path to an image file"),
+      scope: z.enum(["user", "project"]).optional().describe("Memory/document scope (default: project)"),
+      extractMemories: z.boolean().optional().describe("Extract memories from OCR text (default: true)"),
+      wait: z.boolean().optional().describe("Wait for OCR ingestion to finish (default: true)"),
+      timeoutMs: z.number().optional().describe("Max wait timeout in milliseconds"),
+      pollIntervalMs: z.number().optional().describe("Polling interval in milliseconds"),
+      contentType: z.string().optional().describe("Optional content type hint (e.g. image/png)")
+    },
+    async execute(args, _context) {
+      const client = requireMomo();
+      const scope = args.scope ?? "project";
+      const containerTag = resolveContainerTag(scope);
+      const extractMemories = args.extractMemories ?? true;
+      const wait = args.wait ?? true;
+      const timeoutMs = args.timeoutMs ?? DEFAULT_INGEST_TIMEOUT_MS;
+      const pollIntervalMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+      const ingest = await uploadDocumentFromPath(args.filePath, {
+        containerTag,
+        metadata: undefined,
+        extractMemories,
+        contentType: args.contentType,
+        timeoutMs
+      });
+      if (!wait) {
+        return [
+          `OCR ingestion queued (scope: ${scope}).`,
+          `- documentId: ${ingest.documentId}`,
+          `- ingestionId: ${ingest.ingestionId}`,
+          `- extractMemories: ${extractMemories}`
+        ].join(`
+`);
+      }
+      const status = await waitForIngestion(client, ingest.ingestionId, timeoutMs, pollIntervalMs);
+      if (status.status !== "completed") {
+        return [
+          `OCR ingestion status: ${status.status} (scope: ${scope}).`,
+          `- documentId: ${ingest.documentId}`,
+          `- ingestionId: ${ingest.ingestionId}`,
+          status.title ? `- title: ${status.title}` : undefined
+        ].filter(Boolean).join(`
+`);
+      }
+      return formatDocumentResult(client, ingest.documentId, scope, "ocr");
+    }
+  });
+  const momoTranscribeTool = tool({
+    description: "Transcribe audio/video files via Momo ingestion, then return transcript preview and memory extraction status.",
+    args: {
+      filePath: z.string().describe("Local path to an audio or video file"),
+      scope: z.enum(["user", "project"]).optional().describe("Memory/document scope (default: project)"),
+      extractMemories: z.boolean().optional().describe("Extract memories from transcript (default: true)"),
+      wait: z.boolean().optional().describe("Wait for transcription ingestion to finish (default: true)"),
+      timeoutMs: z.number().optional().describe("Max wait timeout in milliseconds"),
+      pollIntervalMs: z.number().optional().describe("Polling interval in milliseconds"),
+      contentType: z.string().optional().describe("Optional content type hint (e.g. audio/mpeg, video/mp4)")
+    },
+    async execute(args, _context) {
+      const client = requireMomo();
+      const scope = args.scope ?? "project";
+      const containerTag = resolveContainerTag(scope);
+      const extractMemories = args.extractMemories ?? true;
+      const wait = args.wait ?? true;
+      const timeoutMs = args.timeoutMs ?? DEFAULT_INGEST_TIMEOUT_MS;
+      const pollIntervalMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+      const ingest = await uploadDocumentFromPath(args.filePath, {
+        containerTag,
+        metadata: undefined,
+        extractMemories,
+        contentType: args.contentType,
+        timeoutMs
+      });
+      if (!wait) {
+        return [
+          `Transcription queued (scope: ${scope}).`,
+          `- documentId: ${ingest.documentId}`,
+          `- ingestionId: ${ingest.ingestionId}`,
+          `- extractMemories: ${extractMemories}`
+        ].join(`
+`);
+      }
+      const status = await waitForIngestion(client, ingest.ingestionId, timeoutMs, pollIntervalMs);
+      if (status.status !== "completed") {
+        return [
+          `Transcription status: ${status.status} (scope: ${scope}).`,
+          `- documentId: ${ingest.documentId}`,
+          `- ingestionId: ${ingest.ingestionId}`,
+          status.title ? `- title: ${status.title}` : undefined
+        ].filter(Boolean).join(`
+`);
+      }
+      return formatDocumentResult(client, ingest.documentId, scope, "transcription");
+    }
+  });
   const chatMessageHook = async (input, output) => {
     if (injectedSessions.has(input.sessionID))
       return;
@@ -13921,7 +14432,10 @@ ${formatted}`;
   };
   return {
     tool: {
-      momo: momoTool
+      momo: momoTool,
+      momo_ingest: momoIngestTool,
+      momo_ocr: momoOcrTool,
+      momo_transcribe: momoTranscribeTool
     },
     "chat.message": chatMessageHook,
     event: eventHook

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momomemory/opencode-momo",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "OpenCode plugin that gives coding agents persistent memory using Momo",
   "type": "module",
   "main": "dist/index.js",
@@ -29,7 +29,8 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.1.53",
-    "@momomemory/sdk": "^0.2.0"
+    "@opencode-ai/sdk": "^1.1.53",
+    "@momomemory/sdk": "^0.2.1"
   },
   "devDependencies": {
     "@types/bun": "latest",