@north-light/crouter 0.3.201 → 0.3.202

package/dist/core/memory-resolver.js

@@ -11,6 +11,20 @@ import { effectiveDocKind, normalizeDocName, normalizeNameSegment, resolveDocNam
 import { loadProfileManifest, profileMemoryDir } from './profiles/manifest.js';
 import { memoryDir as nodeMemoryDir } from './runtime/memory.js';
 import { descendantStoreRoots } from './nested-stores.js';
+/** The native (non-plugin) store dirs in resolution precedence — node >
+ *  project stack > profile > user, builtin excluded as a read-only corpus.
+ *  Addresses a store directly when the document itself may be absent, which is
+ *  how a DELETED doc's revision log is still found: history outlives the doc,
+ *  so its lookup cannot go through document resolution. */
+export function nativeMemoryStoresInPrecedence(scope, includeDescendants = false) {
+    const out = [];
+    for (const source of memorySourcesInPrecedence(ambientTarget(), scope, includeDescendants)) {
+        if (source.scope === 'builtin' || source.memoryDir === null)
+            continue;
+        out.push({ scope: source.scope, memoryDir: source.memoryDir });
+    }
+    return out;
+}
 /** Canonical, unambiguous identifier for a memory document: `<scope>/<name>`. */
 export function memoryDocId(doc) {
     return `${doc.scope}/${doc.name}`;
@@ -109,9 +123,9 @@ function memorySourcesInPrecedence(target, scope, includeDescendants = false) {
     }
     return out;
 }
-function loadMemoryDoc(scope, path, fallbackName) {
+function loadMemoryDoc(scope, root, path, fallbackName) {
     const { data, body } = parseFrontmatterGeneric(readText(path));
-    return { name: resolveDocName(data, fallbackName), scope, path, frontmatter: data, body };
+    return { name: resolveDocName(data, fallbackName), scope, path, root, frontmatter: data, body };
 }
 /** All memory docs in one memory/ dir, scanned recursively for *.md (topical
  *  subdirs supported), sorted by resolver identity (explicit frontmatter name
@@ -157,7 +171,7 @@ function listMemoryDocsInDir(scope, dir, quiet = false) {
         // `quiet` suppresses the notice for a targeted resolve (a leaf-name read),
         // where another doc's health is irrelevant noise before the result.
         try {
-            docs.push(loadMemoryDoc(scope, path, name));
+            docs.push(loadMemoryDoc(scope, dir, path, name));
         }
         catch (e) {
             const msg = (e instanceof Error ? e.message : String(e)).split('\n')[0];
@@ -211,7 +225,7 @@ export function listPluginMemoryDocs(plugin, scope, quiet = false) {
             continue;
         const name = `${plugin.name}/${derived}`;
         try {
-            docs.push({ ...loadMemoryDoc(scope, file, name), plugin: plugin.name });
+            docs.push({ ...loadMemoryDoc(scope, dir, file, name), plugin: plugin.name });
         }
         catch (e) {
             const msg = (e instanceof Error ? e.message : String(e)).split('\n')[0];
@@ -250,13 +264,13 @@ export function listProjectMemoryDocs(startDir = process.cwd(), profileId = sele
 export function listAllMemoryDocs(scope, quiet = false, includeDescendants = false) {
     return memorySourcesInPrecedence(ambientTarget(), scope, includeDescendants).flatMap((source) => sourceMemoryDocs(source, quiet));
 }
-/** Find the direct child of `dir` — a `.md` file (matched on name minus
+/** Find the direct child of `dir` — an `ext` file (matched on name minus
  *  extension) or a directory — whose NORMALIZED display name equals
  *  `segment`. An exact literal match (no prefix to strip) wins over a
  *  normalized match, so a `spine` dir sitting beside a `01-spine` dir (a
  *  malformed corpus) never masks the literal one; a well-formed corpus has at
  *  most one candidate either way. Returns the absolute child path, or null. */
-function matchNormalizedChild(dir, segment, want) {
+function matchNormalizedChild(dir, segment, want, ext = '.md') {
     let entries;
     try {
         entries = readdirSync(dir, { withFileTypes: true });
@@ -276,9 +290,9 @@ function matchNormalizedChild(dir, segment, want) {
             }
         }
         else {
-            if (!(e.isFile() && e.name.endsWith('.md')))
+            if (!(e.isFile() && e.name.endsWith(ext)))
                 continue;
-            const base = e.name.slice(0, -3);
+            const base = e.name.slice(0, -ext.length);
             if (base === segment)
                 return join(dir, e.name);
             if (normalizedHit === null && normalizeNameSegment(base) === segment) {
@@ -297,20 +311,37 @@ function matchNormalizedChild(dir, segment, want) {
  *  `00-runtime-base.md` findable as `runtime-base` and `01-spine/00-has-manager`
  *  findable as `spine/has-manager` — the physical path keeps its pins, only
  *  lookup is prefix-blind. */
-function resolveNormalizedPath(baseDir, segments) {
+function resolveNormalizedPath(baseDir, segments, ext = '.md') {
     let curDir = baseDir;
     for (let i = 0; i < segments.length - 1; i++) {
-        const next = matchNormalizedChild(curDir, segments[i], 'dir');
+        const next = matchNormalizedChild(curDir, segments[i], 'dir', ext);
         if (!next)
             return { filePath: null, dirPath: null };
         curDir = next;
     }
     const last = segments[segments.length - 1];
     return {
-        filePath: matchNormalizedChild(curDir, last, 'file'),
-        dirPath: matchNormalizedChild(curDir, last, 'dir'),
+        filePath: matchNormalizedChild(curDir, last, 'file', ext),
+        dirPath: matchNormalizedChild(curDir, last, 'dir', ext),
     };
 }
+/** Resolve a document NAME against a `.history` tree, which mirrors the doc
+ *  tree segment for segment with `.jsonl` in place of `.md`. Reuses the doc
+ *  resolution rules so a log outlives its doc under the same name the doc had:
+ *  numeric prefixes stay prefix-blind (`00-topic.md` logged at
+ *  `.history/00-topic.jsonl` still answers to `topic`) and a bare directory
+ *  name falls back to its INDEX log. Returns null when nothing resolves. */
+export function resolveHistoryLogPath(historyDir, segments) {
+    const { filePath, dirPath } = resolveNormalizedPath(historyDir, segments, '.jsonl');
+    if (filePath)
+        return filePath;
+    if (dirPath) {
+        const index = matchNormalizedChild(dirPath, 'INDEX', 'file', '.jsonl');
+        if (index)
+            return index;
+    }
+    return null;
+}
 /** Direct full-path lookup of memory/<name>.md within ONE source. Returns that
  *  source's single hit, or undefined — a source can produce at most one direct
  *  match (native wins over plugin within the source, and at most one plugin's
@@ -333,11 +364,11 @@ function findMemoryMatchInSource(name, segments, source) {
     if (dir) {
         const { filePath, dirPath } = resolveNormalizedPath(dir, segments);
         if (!isLegacySkillDoc && filePath !== null)
-            return loadMemoryDoc(source.scope, filePath, name);
+            return loadMemoryDoc(source.scope, dir, filePath, name);
         if (dirPath !== null) {
             const indexPath = join(dirPath, 'INDEX.md');
             if (pathExists(indexPath))
-                return loadMemoryDoc(source.scope, indexPath, name);
+                return loadMemoryDoc(source.scope, dir, indexPath, name);
         }
     }
     // Plugin memory dir: a `<plugin>/<rest>` name resolves against that enabled
@@ -356,14 +387,14 @@ function findMemoryMatchInSource(name, segments, source) {
         if (rest) {
             const { filePath } = resolveNormalizedPath(pdir, restSegments);
             if (restSegments.at(-1) !== 'SKILL' && filePath !== null)
-                return loadMemoryDoc(source.scope, filePath, name);
+                return loadMemoryDoc(source.scope, pdir, filePath, name);
         }
         // Bare name -> <plugin>/memory/INDEX.md; slashed name -> dir INDEX.
         const pIndexDir = rest ? resolveNormalizedPath(pdir, restSegments).dirPath : pdir;
         if (pIndexDir !== null) {
             const pindex = join(pIndexDir, 'INDEX.md');
             if (pathExists(pindex))
-                return loadMemoryDoc(source.scope, pindex, name);
+                return loadMemoryDoc(source.scope, pdir, pindex, name);
         }
     }
     return undefined;

package/dist/core/preview-registry.js

@@ -114,6 +114,8 @@ const LEAF_ICON_CP = {
     'memory read': 0xf02d,
     'memory find': 0xf002,
     'memory write': 0xf040,
+    'memory edit': 0xf044,
+    'memory history': 0xf1da,
     'memory origin': 0xf1bb,
     'memory lint': 0xf14a,
     'node new': 0xf067,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.201",
+  "version": "0.3.202",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.201",
+  "version": "0.3.202",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.201",
+      "version": "0.3.202",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {