@zenera/neo 1.1.10 → 1.1.12

package/dist/tools/workspace.js

@@ -358,6 +358,10 @@ function toLines(body) {
     }
     return lines;
 }
+/** Whether every line of the file ends CRLF, so converting the lot is lossless. */
+function isCrlf(body) {
+    return body.includes('\r\n') && !/(^|[^\r])\n/.test(body);
+}
 // ---------------------------------------------------------------------------
 // The patch format
 //
@@ -476,7 +480,9 @@ function parsePatch(text) {
                         chunk = undefined;
                     }
                     const heading = body.slice(2).trim();
-                    if (heading) {
+                    // `@@ ...` is a model eliding the lines between chunks, not
+                    // naming a block, and there is no such line to find.
+                    if (heading && !/^[.\u2026]+$/.test(heading)) {
                         open().headings.push(heading);
                     }
                     else {
@@ -557,26 +563,143 @@ function locate(lines, want, from) {
     }
     return { index: -1, fuzz: 0 };
 }
+/**
+ * Finds the line a `@@ heading` names. Exact, then trimmed, then any line that
+ * contains it: a model writes `@@ check_risk` where the file says
+ * `def check_risk(entry):`, and the worked example in the tool description —
+ * `@@ class Server` — teaches exactly that. Separate sweeps, so an exact match
+ * anywhere beats a loose one earlier.
+ */
 function findHeading(lines, heading, from) {
-    for (let i = from; i < lines.length; i++) {
-        if (lines[i] === heading || lines[i].trim() === heading.trim()) {
-            return i;
+    const want = heading.trim();
+    const passes = [
+        (line) => line === heading,
+        (line) => line.trim() === want,
+        (line) => line.includes(want),
+    ];
+    for (const same of passes) {
+        for (let i = from; i < lines.length; i++) {
+            if (same(lines[i])) {
+                return i;
+            }
         }
     }
     return -1;
 }
+function indentOf(line) {
+    return line.slice(0, line.length - line.trimStart().length);
+}
+/**
+ * The single shift that turns the patch's indentation into the file's, replayed
+ * onto `after`. Null when the lines disagree about it: that is not a
+ * mis-indented chunk, it is a chunk matched in the wrong place.
+ *
+ * Prefix arithmetic rather than column counts, because a tab and four spaces
+ * are different bytes and Python does not treat them alike.
+ */
+function reindent(after, file, want, at) {
+    let add;
+    let drop;
+    for (let k = 0; k < want.length; k++) {
+        if (want[k].trim() === '') {
+            continue;
+        }
+        const have = indentOf(file[at + k]);
+        const said = indentOf(want[k]);
+        const step = have.startsWith(said)
+            ? { add: have.slice(said.length), drop: '' }
+            : said.startsWith(have)
+                ? { add: '', drop: said.slice(have.length) }
+                : undefined;
+        if (!step || (add !== undefined && (add !== step.add || drop !== step.drop))) {
+            return null;
+        }
+        add = step.add;
+        drop = step.drop;
+    }
+    if (!add && !drop) {
+        return after;
+    }
+    return after.map((line) => {
+        if (line.trim() === '') {
+            return line;
+        }
+        const bare = drop && line.startsWith(drop) ? line.slice(drop.length) : line;
+        return add ? add + bare : bare;
+    });
+}
+/**
+ * How many lines of `want` the closest near-miss got through, so an error can
+ * name the line that actually diverged. Naming the first line of the block
+ * instead sends the model to verify a line that was never the problem.
+ */
+function matchedUpTo(lines, want, from) {
+    let best = 0;
+    for (let start = from; start < lines.length; start++) {
+        let k = 0;
+        while (k < want.length && start + k < lines.length) {
+            if (lines[start + k].trim() !== want[k].trim()) {
+                break;
+            }
+            k++;
+        }
+        if (k > best) {
+            best = k;
+        }
+    }
+    return best;
+}
+/** How many places `want` occurs at or after `from`, counted no further than two. */
+function countMatches(lines, want, from) {
+    if (want.length === 0) {
+        return 2;
+    }
+    let found = 0;
+    let at = from;
+    while (found < 2) {
+        const hit = locate(lines, want, at);
+        if (hit.index < 0) {
+            break;
+        }
+        found++;
+        at = hit.index + 1;
+    }
+    return found;
+}
 /** Applies one file's chunks to its lines. Throws `PatchError` on a miss. */
 function patchLines(lines, chunks, file) {
     const out = lines.slice();
     let cursor = 0;
     let fuzz = 0;
+    let ignored = 0;
     for (const chunk of chunks) {
+        // Nothing to search for and no marker to append after: the top of the file
+        // is a guess, and a guess that reports success is worse than a refusal.
+        if (chunk.before.length === 0 && !chunk.eof && chunk.headings.length === 0) {
+            throw new PatchError(`${file}: the chunk at patch line ${chunk.at} adds lines without any context, ` +
+                'so there is nowhere to put them — keep a line of the file above the ' +
+                'insertion, or end the chunk with *** End of File to append');
+        }
         for (const heading of chunk.headings) {
             const at = findHeading(out, heading, cursor);
             if (at < 0) {
-                throw new PatchError(`${file}: no line matching '@@ ${heading}' after the previous chunk`);
+                // A heading only narrows the search. Models invent them —
+                // `@@ class DfwRiskScanner` for a file of plain functions — and
+                // when the context occurs once the heading was never needed, so
+                // refusing spends a turn to learn nothing.
+                if (countMatches(out, chunk.before, cursor) === 1) {
+                    ignored++;
+                    break;
+                }
+                throw new PatchError(`${file}: no line matching '@@ ${heading}' after the previous chunk` +
+                    (countMatches(out, chunk.before, cursor) === 0
+                        ? ", and the chunk's context is not in the file either"
+                        : ", and the chunk's context occurs more than once, so a heading " +
+                            'that matches a line of the file is needed'));
             }
-            cursor = at + 1;
+            // Not `at + 1`: models routinely repeat the heading as the first
+            // context line, and consuming it makes that line unfindable.
+            cursor = at;
         }
         // An end-of-file chunk is tried against the tail first; failing that it
         // is an ordinary search, because the marker is often optimistic.
@@ -597,15 +720,42 @@ function patchLines(lines, chunks, file) {
             found = locate(out, chunk.before, cursor);
         }
         if (found.index < 0) {
-            const first = chunk.before[0] ?? '';
-            throw new PatchError(`${file}: the context of the chunk at patch line ${chunk.at} is not in the file` +
-                (first ? ` — looked for: ${first.trim()}` : ''));
+            // Saying "not in the file" about a line that is plainly in it, just
+            // above the cursor, sends the model back to re-read and retry the
+            // same patch. Look once more from the top to tell the two apart.
+            if (cursor > 0 && locate(out, chunk.before, 0).index >= 0) {
+                throw new PatchError(`${file}: the chunk at patch line ${chunk.at} matches earlier in the file ` +
+                    `than the previous chunk — chunks must be in file order`);
+            }
+            const k = matchedUpTo(out, chunk.before, cursor);
+            const missed = chunk.before[k] ?? chunk.before[0] ?? '';
+            throw new PatchError(`${file}: the chunk at patch line ${chunk.at} does not match — line ${k + 1} of ` +
+                `its context is not in the file` +
+                (missed ? `: ${missed.trim()}` : '') +
+                // A model that has been reading escaped tool output writes
+                // one patch line where the file has two.
+                (missed.includes('\\n')
+                    ? " — that line holds a literal '\\n'; each line of a patch is one line " +
+                        'of the file'
+                    : ''));
         }
         fuzz += found.fuzz > 0 ? 1 : 0;
-        out.splice(found.index, chunk.before.length, ...chunk.after);
-        cursor = found.index + chunk.after.length;
+        // Pass 2 matched by ignoring indentation, so writing `after` as the
+        // patch spelled it would put the model's wrong indentation in the file
+        // — a syntax error in Python, and silent, since the chunk "applied".
+        let after = chunk.after;
+        if (found.fuzz === 2 && after.length > 0) {
+            const fixed = reindent(after, out, chunk.before, found.index);
+            if (!fixed) {
+                throw new PatchError(`${file}: the chunk at patch line ${chunk.at} matches only when indentation ` +
+                    `is ignored, and its lines disagree about how far out they are`);
+            }
+            after = fixed;
+        }
+        out.splice(found.index, chunk.before.length, ...after);
+        cursor = found.index + after.length;
     }
-    return { lines: out, fuzz };
+    return { lines: out, fuzz, ignored };
 }
 // ---------------------------------------------------------------------------
 // The tools
@@ -713,7 +863,10 @@ export function workspaceTools(opts) {
                 lines: total,
                 start_line: from,
                 end_line: from + taken.length - 1,
-                truncated: cut || !whole || to < total || from > 1 ? true : undefined,
+                // Where the range started is not truncation: a read that ends
+                // on the last line withheld nothing, and saying otherwise
+                // teaches the model to distrust every ranged read it makes.
+                truncated: cut || !whole || to < total ? true : undefined,
                 content: taken.join('\n'),
             };
         },
@@ -1046,7 +1199,15 @@ async function runPatch(ws, patch) {
     const steps = [];
     const touched = [];
     const seen = new Set();
+    // Where a move lands is a path this patch writes as surely as one it names,
+    // and `rename` overwrites: without this, the last step to touch a path wins
+    // and the others are lost with the patch still reporting them applied.
+    const targets = new Set();
+    // Steps run in patch order, so a path deleted by an earlier op is free by the
+    // time a later move lands on it, however occupied it still looks on disk.
+    const removed = new Set();
     let fuzz = 0;
+    let ignored = 0;
     for (const op of ops) {
         const at = patchPath(ws, op.path);
         if (ws.isRoot(at)) {
@@ -1055,6 +1216,9 @@ async function runPatch(ws, patch) {
         if (seen.has(at)) {
             throw new PatchError(`${ws.show(at)} appears twice in the patch`);
         }
+        if (targets.has(at)) {
+            throw new PatchError(`${ws.show(at)} is where an earlier part of this patch moves a file`);
+        }
         seen.add(at);
         if (op.kind === 'delete') {
             const info = await statOrNull(at);
@@ -1065,6 +1229,7 @@ async function runPatch(ws, patch) {
                 throw new PatchError(`${ws.show(at)} is a directory`);
             }
             steps.push({ kind: 'delete', at });
+            removed.add(at);
             touched.push({ path: ws.show(at), action: 'deleted' });
             continue;
         }
@@ -1100,12 +1265,18 @@ async function runPatch(ws, patch) {
             throw new PatchError(`${ws.show(at)} is a ${shape.format} file, not text`);
         }
         const body = await readFile(at, 'utf8');
-        const patched = patchLines(toLines(body), op.chunks, ws.show(at));
+        // Matched against LF-only lines. A patch never carries a CR, so a CRLF
+        // file would miss exactly, match on the trailing-whitespace pass, and be
+        // spliced with bare LF — mixed endings behind a successful apply.
+        const eol = isCrlf(body) ? '\r\n' : '\n';
+        const flat = eol === '\n' ? body : body.split(eol).join('\n');
+        const patched = patchLines(toLines(flat), op.chunks, ws.show(at));
         fuzz += patched.fuzz;
+        ignored += patched.ignored;
         // Whether the file ended in a newline is a property of the file, not of
         // the patch, so it survives the edit.
-        const trailing = body === '' || body.endsWith('\n');
-        const content = patched.lines.length === 0 ? '' : patched.lines.join('\n') + (trailing ? '\n' : '');
+        const trailing = flat === '' || flat.endsWith('\n');
+        const content = patched.lines.length === 0 ? '' : patched.lines.join(eol) + (trailing ? eol : '');
         if (Buffer.byteLength(content) > MAX_WRITE) {
             throw new PatchError(`${ws.show(at)} would exceed ${MAX_WRITE} bytes`);
         }
@@ -1123,9 +1294,13 @@ async function runPatch(ws, patch) {
                 throw new PatchError('cannot move a file onto the workspace root');
             }
             if (to !== at) {
-                if (await statOrNull(to)) {
+                if (targets.has(to) || (seen.has(to) && !removed.has(to))) {
+                    throw new PatchError(`${ws.show(to)} is already written by another part of this patch`);
+                }
+                if (!removed.has(to) && (await statOrNull(to))) {
                     throw new PatchError(`${ws.show(to)} already exists`);
                 }
+                targets.add(to);
                 steps.push({ kind: 'move', from: at, to });
                 entry.action = 'moved';
                 entry.to = ws.show(to);
@@ -1155,6 +1330,9 @@ async function runPatch(ws, patch) {
         // ignored landed where the tool thinks it should, not where the patch
         // said, and that is a thing to check.
         fuzzy: fuzz > 0 ? fuzz : undefined,
+        // A heading that named nothing, applied anyway because the context was
+        // unique. Says the heading was wrong without having refused the edit.
+        ignoredHeadings: ignored > 0 ? ignored : undefined,
     };
 }
 async function statOrNull(at) {

package/dist/trajectory.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryQuery } from './memory.ts';
+import type { MemoryEdge, MemoryQuery } from './memory/types.ts';
 import type { Payload, PayloadResolver } from './payload.ts';
 import type { PromptSource } from './prompt.ts';
 import { type MediaKind, type Message, type TokenUsage } from './types.ts';
@@ -53,28 +53,30 @@ export interface LoadSkillsNode extends NodeBase {
 }
 export interface MemoryRecallNode extends NodeBase {
     type: 'memory_recall';
-    store: string;
-    scope: string;
     query: MemoryQuery;
+    /** the matches; the rest of `nodes` is the subgraph stitched around them */
+    seeds: string[];
     /** ids, not bodies — the rendered block is the payload */
-    hits: {
+    nodes: {
         id: string;
+        kind: string;
         score: number;
-        revision: number;
     }[];
+    edges: MemoryEdge[];
     content: Payload;
 }
 export interface MemoryOpNode extends NodeBase {
     type: 'memory_op';
-    op: 'write' | 'update' | 'delete';
-    store: string;
-    scope: string;
+    op: 'commit' | 'forget';
     /** sha256(runId, callId) — deterministic, so a replay is deduplicated */
     opId: string;
-    recordId: string;
-    revision: number;
-    before?: Payload;
-    after?: Payload;
+    nodes: {
+        id: string;
+        kind: string;
+        revision: number;
+    }[];
+    edges: MemoryEdge[];
+    files: number;
 }
 export interface LlmCallNode extends NodeBase {
     type: 'llm_call';

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { Agent } from './agent.ts';
-import type { MemoryOpSpec } from './memory.ts';
+import type { MemoryOpSpec, MemoryRecallSpec } from './memory/types.ts';
 import type { Services } from './services.ts';
 import type { SkillLoadSpec } from './skills.ts';
 import type { AgentState } from './state.ts';
@@ -126,7 +126,7 @@ export interface ToolOutcome {
 }
 export type ToolEffect = {
     kind: 'memory_op';
-    spec: MemoryOpSpec;
+    spec: MemoryOpSpec | MemoryRecallSpec;
 } | {
     kind: 'skill_load';
     spec: SkillLoadSpec;
@@ -184,9 +184,9 @@ export declare const HANDOFF_PREFIX = "transfer_to_";
 export declare const FORK_TOOL = "fork";
 export declare const FINAL_OUTPUT_TOOL = "final_output";
 export declare const MEMORY_SEARCH_TOOL = "memory_search";
-export declare const MEMORY_WRITE_TOOL = "memory_write";
-export declare const MEMORY_UPDATE_TOOL = "memory_update";
-export declare const MEMORY_DELETE_TOOL = "memory_delete";
+export declare const MEMORY_LOAD_TOOL = "memory_load";
+export declare const MEMORY_COMMIT_TOOL = "memory_commit";
+export declare const MEMORY_FORGET_TOOL = "memory_forget";
 export declare const SKILL_SEARCH_TOOL = "skill_search";
 export declare const SKILL_LOAD_TOOL = "skill_load";
 export declare function parseArgs(raw: string): Record<string, unknown>;

package/dist/types.js

@@ -129,9 +129,9 @@ export const HANDOFF_PREFIX = 'transfer_to_';
 export const FORK_TOOL = 'fork';
 export const FINAL_OUTPUT_TOOL = 'final_output';
 export const MEMORY_SEARCH_TOOL = 'memory_search';
-export const MEMORY_WRITE_TOOL = 'memory_write';
-export const MEMORY_UPDATE_TOOL = 'memory_update';
-export const MEMORY_DELETE_TOOL = 'memory_delete';
+export const MEMORY_LOAD_TOOL = 'memory_load';
+export const MEMORY_COMMIT_TOOL = 'memory_commit';
+export const MEMORY_FORGET_TOOL = 'memory_forget';
 export const SKILL_SEARCH_TOOL = 'skill_search';
 export const SKILL_LOAD_TOOL = 'skill_load';
 export function parseArgs(raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/neo",
-    "version": "1.1.10",
+    "version": "1.1.12",
     "description": "A multi-agent runtime for Node.js: agents, models, tools, skills, memory and an append-only trajectory.",
     "keywords": [
         "agents",
@@ -38,10 +38,6 @@
             "types": "./dist/payload-stores/index.d.ts",
             "default": "./dist/payload-stores/index.js"
         },
-        "./memory-stores": {
-            "types": "./dist/memory-stores/index.d.ts",
-            "default": "./dist/memory-stores/index.js"
-        },
         "./skill-providers": {
             "types": "./dist/skill-providers/index.d.ts",
             "default": "./dist/skill-providers/index.js"
@@ -66,6 +62,7 @@
         "prepack": "tsc -b"
     },
     "dependencies": {
+        "graphology": "^0.26.0",
         "yaml": "^2.9.0",
         "zod": "^4.4.3"
     },

package/dist/memory-stores/factory.d.ts

@@ -1,15 +0,0 @@
-import type { MemoryStore } from '../memory.ts';
-import { type FileMemoryStoreOptions } from './file.ts';
-export interface MemoryMemoryStoreSpec {
-    kind: 'memory';
-    id?: string;
-}
-export interface FileMemoryStoreSpec extends FileMemoryStoreOptions {
-    kind: 'file';
-}
-/** Grows a member per backend (`pgvector`, `redis`, …). */
-export type MemoryStoreSpec = MemoryMemoryStoreSpec | FileMemoryStoreSpec;
-/** Shorthand: `mem`, `memory`, `file:./.data/memory`. */
-export type MemoryStoreRef = MemoryStoreSpec | string;
-export declare function createMemoryStore(ref: MemoryStoreRef): MemoryStore;
-//# sourceMappingURL=factory.d.ts.map

package/dist/memory-stores/factory.js

@@ -1,29 +0,0 @@
-import { FileMemoryStore } from "./file.js";
-import { InMemoryMemoryStore } from "./in-memory.js";
-export function createMemoryStore(ref) {
-    const spec = typeof ref === 'string' ? parseRef(ref) : ref;
-    switch (spec.kind) {
-        case 'memory':
-            return new InMemoryMemoryStore(spec.id);
-        case 'file':
-            return new FileMemoryStore(spec);
-        default:
-            throw new TypeError(`unknown memory store kind: ${spec.kind}`);
-    }
-}
-function parseRef(ref) {
-    if (ref === 'mem' || ref === 'memory') {
-        return { kind: 'memory' };
-    }
-    const colon = ref.indexOf(':');
-    const scheme = colon < 0 ? ref : ref.slice(0, colon);
-    const rest = colon < 0 ? '' : ref.slice(colon + 1);
-    if (scheme === 'file') {
-        if (!rest) {
-            throw new TypeError(`missing directory in "${ref}" (expected file:<dir>)`);
-        }
-        return { kind: 'file', dir: rest };
-    }
-    throw new TypeError(`unknown memory store ref: "${ref}"`);
-}
-//# sourceMappingURL=factory.js.map

package/dist/memory-stores/file.d.ts

@@ -1,37 +0,0 @@
-import { type MemoryDraft, type MemoryHit, type MemoryPatch, type MemoryQuery, type MemoryRecord, type MemoryStore } from '../memory.ts';
-export interface FileMemoryStoreOptions {
-    /** root directory; created on demand */
-    dir: string;
-    /** logical store id agents bind to; defaults to `file` */
-    id?: string;
-}
-/**
- * One JSON file per record, under one directory per scope:
- *
- * ```
- * <dir>/<scope>/scope.json        the unescaped scope name, for humans
- * <dir>/<scope>/records/<id>.json
- * <dir>/<scope>/ops/<opId>.json   idempotency ledger
- * ```
- *
- * A file per record (rather than one appended log) keeps writes atomic and
- * deletes cheap without a compaction step. Search reads the whole scope and
- * ranks in process, which is exactly the trade this backend makes: no server,
- * no index, fine up to a few thousand records per scope.
- *
- * There is no cross-process lock. Concurrent writers to the *same* record can
- * lose an update; `expectedRevision` narrows that window, and a deployment
- * that needs real isolation should use a database-backed store.
- */
-export declare class FileMemoryStore implements MemoryStore {
-    #private;
-    readonly id: string;
-    constructor(opts: FileMemoryStoreOptions | string);
-    get dir(): string;
-    search(scope: string, q: MemoryQuery): Promise<MemoryHit[]>;
-    get(scope: string, id: string): Promise<MemoryRecord | undefined>;
-    write(scope: string, rec: MemoryDraft, opId: string): Promise<MemoryRecord>;
-    update(scope: string, id: string, patch: MemoryPatch, opId: string): Promise<MemoryRecord>;
-    delete(scope: string, id: string, opId: string): Promise<void>;
-}
-//# sourceMappingURL=file.d.ts.map