@vib795/agent-memory 0.1.8 → 0.1.10

package/README.md

@@ -96,6 +96,7 @@ agent-memory get <id> [--depth N]          a note plus its neighborhood
                      [--budget N] [--include-archived]
 agent-memory search <terms> [--limit N]    full-text fallback when the tree misses
 agent-memory write --from-json <file>      validated upsert; used by the skills
+                     --from-json -         read the JSON from stdin instead
 agent-memory compact                       dedup, decay, reindex, regenerate
 agent-memory doctor                        preflight and health report
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vib795/agent-memory",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Durable cross-repo knowledge graph for GitHub Copilot and Claude Code. Markdown source of truth, disposable SQLite index, zero runtime dependencies.",
   "keywords": [
     "github-copilot",

package/skills/handoff/SKILL.md

@@ -274,8 +274,7 @@ Types are `system`, `decision`, `convention`, `constraint`. Edge relations are
 `depends-on`, `applies-to`, `supersedes`, `contradicts`, `evidence-for`.
 
 ```bash
-tmp="$(mktemp)"
-cat > "$tmp" <<'JSON'
+agent-memory write --from-json - --source handoff <<'JSON'
 {"nodes":[
   {"id":"use-sessions","type":"decision",
    "title":"Chose server sessions over JWT",
@@ -283,19 +282,21 @@ cat > "$tmp" <<'JSON'
    "edges":[{"rel":"evidence-for","dst":"auth-service"}]}
 ]}
 JSON
-agent-memory write --from-json "$tmp" --source handoff
-rm -f "$tmp"
 ```
 
 ```powershell
-$tmp = [System.IO.Path]::GetTempFileName()
 @'
 <the JSON>
-'@ | Set-Content -Path $tmp -Encoding UTF8
-agent-memory write --from-json $tmp --source handoff
-Remove-Item -Force $tmp
+'@ | Set-Content -Path .agent-memory-write.json -Encoding UTF8
+agent-memory write --from-json .agent-memory-write.json --source handoff
+Remove-Item -Force .agent-memory-write.json
 ```
 
+**Use these as written. Do not introduce a variable.** Some agent terminals rewrite
+`$`-prefixed lines before the shell sees them, corrupting the payload into malformed
+JSON. PowerShell writes a file rather than piping because Windows PowerShell pipes to
+a native command using `$OutputEncoding`, which is not UTF-8 by default.
+
 `write` redacts before anything reaches disk and reports every validation error at
 once. Surface its warnings verbatim; a `title collision` warning means two ids now
 describe the same thing and the user should know.

package/skills/remember/SKILL.md

@@ -98,25 +98,32 @@ Fields you may set: `id`, `type`, `title`, `body`, `repos`, `scope`, `confidence
 **bash (macOS / Linux):**
 
 ```bash
-tmp="$(mktemp)"
-cat > "$tmp" <<'JSON'
+agent-memory write --from-json - --source remember <<'JSON'
 <the JSON from Step 2>
 JSON
-agent-memory write --from-json "$tmp" --source remember
-rm -f "$tmp"
 ```
 
 **PowerShell (Windows / AVD):**
 
 ```powershell
-$tmp = [System.IO.Path]::GetTempFileName()
 @'
 <the JSON from Step 2>
-'@ | Set-Content -Path $tmp -Encoding UTF8
-agent-memory write --from-json $tmp --source remember
-Remove-Item -Force $tmp
+'@ | Set-Content -Path .agent-memory-write.json -Encoding UTF8
+agent-memory write --from-json .agent-memory-write.json --source remember
+Remove-Item -Force .agent-memory-write.json
 ```
 
+**Use these as written. Do not introduce a variable.** Some agent terminals rewrite
+`$`-prefixed lines before the shell sees them, which turns the payload into malformed
+JSON and costs you two retries diagnosing a corruption that never reached disk. Both
+recipes above are free of variables for that reason.
+
+PowerShell writes a file rather than piping, because Windows PowerShell pipes to a
+native command using `$OutputEncoding`, which is not UTF-8 by default and would mangle
+any non-ASCII character in a body. `-Encoding UTF8` on a file is explicit and safe. The
+file is written next to you and removed on the next line; if you see it left behind,
+the write failed and the JSON is still there to read.
+
 Redaction runs inside `write`, before any bytes reach disk, and cannot be turned
 off. You still must not paste a raw secret into the JSON: the guard is a backstop,
 not a licence.

package/src/cli.js

@@ -298,7 +298,11 @@ function cmdSearch(opts) {
 }
 
 function readNodesFrom(file) {
-  const raw = JSON.parse(readFileSync(file, 'utf8'));
+  // `-` means stdin. Naming a temp file takes a shell variable, and some agent
+  // terminals rewrite `$`-prefixed lines before the shell ever sees them, which
+  // corrupts the payload into malformed JSON with nothing to point at. Reading the
+  // document straight off the pipe removes the variable, and with it the failure.
+  const raw = JSON.parse(readFileSync(file === '-' ? 0 : file, 'utf8'));
   if (Array.isArray(raw)) return raw;
   if (Array.isArray(raw?.nodes)) return raw.nodes;
   return [raw];
@@ -306,11 +310,11 @@ function readNodesFrom(file) {
 
 function cmdWrite(opts) {
   const file = opts['from-json'];
-  if (!file || file === true || !existsSync(file)) {
+  if (!file || file === true || (file !== '-' && !existsSync(file))) {
     return {
       ok: false,
-      error: 'write requires --from-json <file>',
-      text: 'write requires --from-json <file>',
+      error: 'write requires --from-json <file>, or - to read stdin',
+      text: 'write requires --from-json <file>, or - to read stdin',
     };
   }
 
@@ -565,7 +569,20 @@ function main(argv) {
   try {
     result = fn(opts);
   } catch (err) {
-    result = { ok: false, error: err.message, text: `Error: ${err.message}` };
+    // err.message on its own loses the syscall and the path, which is the whole
+    // difference between "Path is a directory" and knowing which path and which
+    // operation. A user hitting this on a machine you cannot log into should be able
+    // to paste one line and have it be enough; a stack is one env var further.
+    const detail = [err.code, err.syscall, err.path].filter(Boolean).join(' ');
+    const line = detail ? `Error: ${err.message} [${detail}]` : `Error: ${err.message}`;
+    result = {
+      ok: false,
+      error: err.message,
+      code: err.code ?? null,
+      syscall: err.syscall ?? null,
+      path: err.path ?? null,
+      text: process.env.AGENT_MEMORY_DEBUG ? `${line}\n${err.stack}` : line,
+    };
   }
 
   if (opts.json) {

package/src/setup.js

@@ -1,5 +1,5 @@
 import {
-  mkdirSync, rmSync, existsSync, lstatSync, symlinkSync, cpSync, readlinkSync, readFileSync,
+  mkdirSync, rmSync, rmdirSync, existsSync, lstatSync, symlinkSync, cpSync, readlinkSync, readFileSync,
 } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -45,8 +45,19 @@ function isLink(path) {
 function clear(path) {
   // A stale symlink must be removed as a link rather than followed, or clearing it
   // would delete the packaged skills on the other end.
-  if (isLink(path)) rmSync(path, { force: true });
-  else if (existsSync(path)) rmSync(path, { recursive: true, force: true });
+  if (isLink(path)) {
+    try {
+      rmSync(path, { force: true });
+    } catch {
+      // A Windows directory junction reports as a symbolic link but deletes like a
+      // directory, and rmSync without `recursive` can reject it as EISDIR. rmdirSync
+      // removes the junction itself and never descends, so the skills on the other
+      // end stay put — which is exactly what passing `recursive` here would risk.
+      rmdirSync(path);
+    }
+  } else if (existsSync(path)) {
+    rmSync(path, { recursive: true, force: true });
+  }
 }
 
 /**