@zilliz/memsearch-opencode 0.3.10 → 0.3.12

package/index.ts

@@ -13,13 +13,15 @@
 
 import type { Plugin } from "@opencode-ai/plugin";
 import { tool } from "@opencode-ai/plugin";
-import { execSync, exec, spawnSync } from "node:child_process";
+import { execSync, exec, spawn, spawnSync } from "node:child_process";
 import {
   readFileSync,
   existsSync,
   mkdirSync,
   readdirSync,
   realpathSync,
+  unlinkSync,
+  writeFileSync,
 } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -107,7 +109,11 @@ function recentMemoryPreviewLines(content: string, maxLines: number): string[] {
   return sections.flat().slice(-maxLines);
 }
 
-function getRecentMemories(
+export function isDailyJournalFile(file: string): boolean {
+  return /^\d{4}-\d{2}-\d{2}\.md$/.test(file);
+}
+
+export function getRecentMemories(
   memDir: string,
   count = 2,
   maxLinesPerFile = 30
@@ -115,7 +121,7 @@ function getRecentMemories(
   if (!existsSync(memDir)) return "";
 
   const files = readdirSync(memDir)
-    .filter((f) => f.endsWith(".md"))
+    .filter(isDailyJournalFile)
     .sort()
     .slice(-count);
 
@@ -144,6 +150,51 @@ function shellEscape(s: string): string {
   return s.replace(/'/g, "'\\''");
 }
 
+export function getSkillCandidateHint(memsearchDir: string, memsearchCmd: string): string {
+  try {
+    const result = spawnSync(
+      "bash",
+      [
+        "-c",
+        `MEMSEARCH_DIR='${shellEscape(memsearchDir)}' ${memsearchCmd} skills status --hint`,
+      ],
+      { encoding: "utf-8", timeout: 5000 }
+    );
+    if (result.status !== 0) return "";
+    return (result.stdout || "").trim().split("\n")[0] || "";
+  } catch {
+    return "";
+  }
+}
+
+/** Marks the start of memsearch's injected block within a system message. */
+export const MEMSEARCH_SYSTEM_MARKER = "[memsearch] Memory available.";
+
+/**
+ * Merge memsearch's memory context into an `output.system` array without
+ * growing it. Some backends (litellm/vllm serving e.g. Qwen models) reject a
+ * multi-entry `output.system` array with "system message must be first", so
+ * the memory block is folded into the first entry instead of pushed as a new
+ * one. If a memsearch block from a previous transform call is already present
+ * (identified by MEMSEARCH_SYSTEM_MARKER), it is replaced in place rather than
+ * appended again, so repeated calls against the same output stay idempotent.
+ */
+export function mergeSystemMemoryContext(
+  system: string[] | undefined,
+  memoryText: string
+): string[] {
+  if (!Array.isArray(system) || system.length === 0) {
+    return [memoryText];
+  }
+  const result = [...system];
+  const existing = result[0];
+  const markerIndex = existing.indexOf(MEMSEARCH_SYSTEM_MARKER);
+  const base =
+    markerIndex === -1 ? existing : existing.slice(0, markerIndex).replace(/\n+$/, "");
+  result[0] = base ? `${base}\n\n${memoryText}` : memoryText;
+  return result;
+}
+
 /**
  * Start the capture daemon as a background process.
  * The daemon polls OpenCode's SQLite for completed turns and writes to daily .md files.
@@ -153,6 +204,7 @@ function startCaptureDaemon(
   collectionName: string,
   memsearchCmd: string
 ): void {
+  const stateDir = join(projectDir, ".memsearch");
   const pidFile = join(projectDir, ".memsearch", ".capture.pid");
   const daemonScript = join(PLUGIN_DIR, "scripts", "capture-daemon.py");
 
@@ -167,21 +219,40 @@ function startCaptureDaemon(
           return; // Already running
         } catch {
           // Process is dead, clean up stale PID file
+          try { unlinkSync(pidFile); } catch { /* ignore */ }
         }
       }
     } catch { /* ignore */ }
   }
 
-  // Start daemon in background
-  exec(
-    `python3 "${daemonScript}" "${projectDir}" "${collectionName}" ` +
-      `--memsearch-cmd "${shellEscape(memsearchCmd)}" --poll-interval 10 &`,
-    {
-      timeout: 5000,
-      env: { ...process.env, MEMSEARCH_NO_WATCH: "1" },
-    },
-    () => { /* ignore */ }
-  );
+  try {
+    mkdirSync(stateDir, { recursive: true });
+    const child = spawn(
+      "python3",
+      [
+        daemonScript,
+        projectDir,
+        collectionName,
+        "--memsearch-cmd",
+        memsearchCmd,
+        "--poll-interval",
+        "10",
+        "--parent-pid",
+        String(process.pid),
+      ],
+      {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, MEMSEARCH_NO_WATCH: "1" },
+      }
+    );
+    child.unref();
+    if (child.pid) {
+      try { writeFileSync(pidFile, String(child.pid), "utf-8"); } catch { /* ignore */ }
+    }
+  } catch {
+    // Capture is best-effort; tools still work without the background daemon.
+  }
 }
 
 /**
@@ -223,6 +294,7 @@ const MemsearchPlugin: Plugin = async ({ project, directory, worktree }) => {
   const collectionName = deriveCollectionName(projectDir);
   const memsearchDir = join(projectDir, ".memsearch");
   const memoryDir = join(memsearchDir, "memory");
+  const skillCandidateHint = getSkillCandidateHint(memsearchDir, memsearchCmd);
   const home = process.env.HOME || "~";
 
   // Skip capture/recall in child processes to prevent recursion
@@ -379,10 +451,13 @@ const MemsearchPlugin: Plugin = async ({ project, directory, worktree }) => {
           "experimental.chat.system.transform": async (_input: any, output: any) => {
             try {
               const context = getRecentMemories(memoryDir);
-              if (context) {
-                output.system.push(
-                  `[memsearch] Memory available. You have access to memory_search, memory_get, and memory_transcript tools for recalling past sessions.\n\n${context}`
-                );
+              if (context || skillCandidateHint) {
+                const memoryText =
+                  `${MEMSEARCH_SYSTEM_MARKER} You have access to memory_search, ` +
+                  `memory_get, and memory_transcript tools for recalling past sessions.` +
+                  `${skillCandidateHint ? `\n${skillCandidateHint}` : ""}` +
+                  `${context ? `\n\n${context}` : ""}`;
+                output.system = mergeSystemMemoryContext(output.system, memoryText);
               }
             } catch { /* ignore */ }
           },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zilliz/memsearch-opencode",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "memsearch plugin for OpenCode — semantic memory search across sessions",
   "type": "module",
   "main": "index.ts",
@@ -23,6 +23,9 @@
     "semantic-search",
     "milvus"
   ],
+  "scripts": {
+    "test": "node --test"
+  },
   "author": "memsearch contributors",
   "license": "MIT",
   "peerDependencies": {

package/scripts/capture-daemon.py

@@ -481,6 +481,21 @@ def wake_maintenance(project_dir: str) -> None:
     )
 
 
+def process_is_alive(pid: int) -> bool:
+    """Return whether a process exists without sending it a signal."""
+    if pid <= 0:
+        return True
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return True
+    return True
+
+
 def get_session_ids(conn: sqlite3.Connection, project_dir: str) -> list[str]:
     """Find OpenCode sessions that belong to the given project directory."""
     sessions = conn.execute(
@@ -764,6 +779,7 @@ def main() -> None:
     parser.add_argument("collection_name", help="Milvus collection name")
     parser.add_argument("--memsearch-cmd", default="memsearch", help="memsearch command")
     parser.add_argument("--poll-interval", type=int, default=10, help="Poll interval in seconds")
+    parser.add_argument("--parent-pid", type=int, default=0, help="Exit when this parent process is gone")
     args = parser.parse_args()
 
     db_path = get_db_path()
@@ -791,6 +807,9 @@ def main() -> None:
     tail_turn_cache: dict[str, TailTurnObservation] = {}
 
     while True:
+        if args.parent_pid and not process_is_alive(args.parent_pid):
+            cleanup()
+
         any_new = False
         conn = None
         try:
@@ -820,6 +839,8 @@ def main() -> None:
             if conn is not None:
                 conn.close()
 
+        if args.parent_pid and not process_is_alive(args.parent_pid):
+            cleanup()
         time.sleep(args.poll_interval)
 
 

package/skills/memory-config/SKILL.md

@@ -93,6 +93,8 @@ Check index health:
 
 ```bash
 memsearch stats
+STATE_DIR="${MEMSEARCH_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.memsearch}"
+test -f "$STATE_DIR/.index-state.json" && cat "$STATE_DIR/.index-state.json"
 ```
 
 OpenCode transcript recall reads from OpenCode's SQLite database, while captured MemSearch memory lives as markdown under `.memsearch/memory/`.
@@ -208,6 +210,11 @@ Model guidance:
 
 Advanced maintenance runs after the plugin wakes it, only when enabled, journal input changed, and `min_interval_hours` elapsed. `PROJECT.md` and `USER.md` are maintenance artifacts by default and are not automatically indexed.
 
+If indexing seems silent or search looks stale, check `.memsearch/.index-state.json`
+for `status`, `last_error`, and `failed_files`. `status: degraded` means the
+scan completed but one or more files failed; `status: error` means the index run
+did not complete.
+
 If advanced maintenance or `memory_to_skill` seems silent, check
 `.memsearch/.maintenance-state.json` for `<plugin>.<task>.last_error` and
 `last_failed_at`; background hook errors may not surface in the chat.

package/skills/memory-to-skill/SKILL.md

@@ -47,10 +47,16 @@ captured automatically going forward) — do not force it.
 ## B. Review & install candidates (1→2)
 
 ```bash
+memsearch skills status          # pending candidate versions needing install
 memsearch skills list            # add -j for sources / installed paths
 git -C .memsearch/skill-candidates log --oneline -5 2>/dev/null || true
 ```
 
+`skills status` compares each candidate's current `SKILL.md` content hash with
+the hash recorded by the last `skills install`. It does not inspect live agent
+skill directories. A pending installed skill means the candidate source evolved
+after the last deliberate install; reinstall only after reviewing the candidate.
+
 Before recommending or installing, skim the candidate's body: if a step looks uncertain or loosely summarized, re-check it against the source (open the transcript if needed) or flag it to the user and let them decide — installing copies the candidate as-is, so this is the last chance to catch a wrong step.
 When showing candidates, mention the store's recent git history when it helps
 explain whether a candidate is new, evolved, removed, or re-created.