@eleboucher/opencode-memini 0.5.11 → 0.6.0

package/memini.js

@@ -16,6 +16,11 @@
  * the environment. See the options/env table in ../README.md.
  */
 
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { homedir } from "node:os";
+
 const DEFAULT_BASE_URL = "http://localhost:8080";
 const DEFAULT_TIMEOUT_MS = 30000;
 const DEFAULT_RECALL_LIMIT = 3;
@@ -44,13 +49,113 @@ export function deriveNamespace(worktree) {
   return sanitizeNamespace(base);
 }
 
+// gitProject derives {project} the way the other integrations do when a config
+// file is present: git remote repo name > git toplevel basename > cwd basename.
+// Used whenever a config file is present (tenant-matched or not) — without a
+// config file the namespace stays the legacy cwd basename.
+function gitProject(cwd) {
+  const gitOut = (args) => {
+    try {
+      return execSync(`git ${args}`, { cwd, stdio: ["ignore", "pipe", "ignore"], timeout: 500 })
+        .toString()
+        .trim();
+    } catch {
+      return "";
+    }
+  };
+  const remote = gitOut("remote get-url origin");
+  if (remote) {
+    const cleaned = remote.replace(/\/+$/, "").replace(/\.git$/i, "");
+    const scpMatch = cleaned.match(/^[^/:]+:[^/]/);
+    const p = scpMatch ? cleaned.slice(scpMatch[0].indexOf(":") + 1) : cleaned;
+    const name = sanitizeNamespace(p.split("/").filter(Boolean).pop() || "");
+    if (name) return name;
+  }
+  const toplevel = gitOut("rev-parse --show-toplevel");
+  if (toplevel) return deriveNamespace(toplevel);
+  return deriveNamespace(cwd);
+}
+
+// matchTenant returns the tenant name if cwd is under a configured tenant root,
+// else "". Each segment stays header-safe on its own so the tenant path keeps
+// its "/" separator (work/memini must not flatten to work-memini).
+function matchTenant(cwd, config) {
+  if (!Array.isArray(config.tenantRoots)) return "";
+  const resolvedCwd = resolve(cwd);
+  for (const root of config.tenantRoots) {
+    if (!root || typeof root !== "object") continue;
+    let rootPath = root.path;
+    // An empty/missing path would startsWith-match every cwd; skip it.
+    if (typeof rootPath !== "string" || !rootPath) continue;
+    if (rootPath === "~") rootPath = homedir();
+    else if (rootPath.startsWith("~/")) rootPath = join(homedir(), rootPath.slice(2));
+    rootPath = resolve(rootPath);
+    if (resolvedCwd === rootPath || resolvedCwd.startsWith(rootPath + sep)) {
+      const tenant = String(root.tenant || "")
+        .replace(/[^A-Za-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+      if (tenant) return tenant;
+    }
+  }
+  return "";
+}
+
+// resolveConfigNamespace reads ~/.config/memini/config.json and renders the
+// config template over the resolved segments. Returns null only when no config
+// file exists (or it's unreadable/malformed), so the caller falls back to the
+// legacy deriveNamespace chain. When a config file is present, {project} is
+// always the git-derived name (repo name > toplevel > cwd basename), matching
+// pi/the shared resolver — even when cwd is under no tenant root.
+function resolveConfigNamespace(cwd) {
+  let config;
+  try {
+    const xdg = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    const configPath = join(xdg, "memini", "config.json");
+    config = JSON.parse(readFileSync(configPath, "utf8"));
+  } catch {
+    return null; // no config file -> today's behavior, zero migration
+  }
+  if (!config || typeof config !== "object") return null;
+  const tenant = matchTenant(cwd, config);
+  const project = gitProject(cwd);
+  const agent = (process.env.MEMINI_AGENT || "")
+    .trim()
+    .replace(/[^A-Za-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  const template =
+    typeof config.template === "string" && config.template
+      ? config.template
+      : "{tenant}/{project}/{agent}";
+  const ns = template
+    .replace(/\{tenant\}/g, tenant)
+    .replace(/\{project\}/g, project)
+    .replace(/\{agent\}/g, agent)
+    .replace(/\{namespace\}/g, "")
+    .replace(/\/{2,}/g, "/")
+    .replace(/^\/+|\/+$/g, "");
+  return ns || null;
+}
+
 // resolveConfig merges env vars with the options object (options win), filling
 // in defaults. Exported for testing.
 export function resolveConfig(env, options, worktree) {
   const e = env || {};
   const o = options || {};
-  const namespace =
-    o.namespace || e.MEMINI_NAMESPACE || deriveNamespace(worktree) || DEFAULT_NAMESPACE;
+  // An explicit namespace (option or MEMINI_NAMESPACE env) wins and is used
+  // raw-trimmed: the server validates the header, and flattening "/" here would
+  // split a tenant path like work/memini from the other integrations.
+  const explicit = o.namespace || e.MEMINI_NAMESPACE;
+  let namespace;
+  if (explicit && String(explicit).trim()) {
+    namespace = String(explicit).trim();
+  } else {
+    // Config present -> render the config template (tenant segments already
+    // sanitized, "/" preserved); otherwise fall back to the legacy cwd chain.
+    namespace =
+      resolveConfigNamespace(worktree || process.cwd()) ||
+      deriveNamespace(worktree) ||
+      DEFAULT_NAMESPACE;
+  }
   // Number.isFinite guard: malformed env / option falls through to the next
   // source instead of NaN flowing into the request body.
   const recall_limit = (() => {
@@ -62,7 +167,10 @@ export function resolveConfig(env, options, worktree) {
   })();
   return {
     base_url: o.base_url || e.MEMINI_BASE_URL || e.MEMINI_URL || DEFAULT_BASE_URL,
-    namespace: sanitizeNamespace(namespace) || DEFAULT_NAMESPACE,
+    // namespace is already resolved above (explicit raw-trimmed, or a
+    // per-segment-sanitized config/derived value); re-sanitizing here would
+    // flatten tenant "/" separators.
+    namespace: namespace || DEFAULT_NAMESPACE,
     recall: o.recall !== undefined ? o.recall !== false : envBool(e.MEMINI_RECALL, true),
     capture: o.capture !== undefined ? o.capture !== false : envBool(e.MEMINI_CAPTURE, true),
     recall_limit,
@@ -446,6 +554,12 @@ export const MeminiPlugin = async ({ client, worktree, directory }, options) =>
           `current workspace state and the user's instructions):`,
         ...fit.items,
       ];
+      // /v1/search sets `degraded: "keyword_only"` (plus a `note`) when the
+      // query embed was unavailable and it fell back to keyword-only matching;
+      // both are already on `result`, so surfacing them is a one-line addition.
+      if (result && result.degraded) {
+        lines.push(`[memini: ${result.note || "semantic search unavailable — results are keyword-only and may be incomplete"}]`);
+      }
       if (fit.dropped > 0) lines.push(`[... ${fit.dropped} item(s) truncated by token budget]`);
       // opencode's part schema requires ids to start with `prt`.
       output.parts.unshift({
@@ -470,7 +584,6 @@ export const MeminiPlugin = async ({ client, worktree, directory }, options) =>
       if (lastAssistantFailed(res && res.data)) metadata.failed = true;
       const stored = await rest.postJson("/v1/memories", {
         content: `${userText.slice(0, 1000)}\n\n${assistantText.slice(0, 3000)}`,
-        tier: "episodic",
         tags: ["opencode"],
         metadata,
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleboucher/opencode-memini",
-  "version": "0.5.11",
+  "version": "0.6.0",
   "description": "Automatic cross-session memory for opencode via memini — recall before each turn, capture after.",
   "keywords": [
     "memini",