From e794512d5e58e992303473dbb299f1c9ef319efd Mon Sep 17 00:00:00 2001 From: Greg Anders Date: Thu, 8 Oct 2026 12:58:50 -0500 Subject: [PATCH] Resolve project memories to project root inside of workspaces --- agent/extensions/memory/index.ts | 84 ++++--- agent/extensions/memory/test/memory.test.ts | 247 +++++++++++++++++++- 2 files changed, 285 insertions(+), 46 deletions(-) diff --git a/agent/extensions/memory/index.ts b/agent/extensions/memory/index.ts index 10d101e..3d48d78 100644 --- a/agent/extensions/memory/index.ts +++ b/agent/extensions/memory/index.ts @@ -1,7 +1,7 @@ import { createHash, randomUUID } from "node:crypto"; import type { Dirent } from "node:fs"; import { mkdir, open, readFile, readdir, rename, rm, writeFile } from "node:fs/promises"; -import { basename, dirname, join, resolve } from "node:path"; +import { basename, dirname, isAbsolute, join, resolve } from "node:path"; import { contentText, getSupportedThinkingLevels, @@ -105,13 +105,22 @@ function isNodeError(cause: unknown, code: string): boolean { return cause instanceof Error && "code" in cause && cause.code === code; } -function projectDirectoryHash(cwd: string): string { - return createHash("sha256").update(resolve(cwd)).digest("hex"); -} - -function memoryDirectoryForScope(memoryDirectory: string, scope: MemoryScope, cwd: string): string { - const key = scope === "global" ? "global" : projectDirectoryHash(cwd); - return join(memoryDirectory, RECORDS_DIRECTORY, key); +async function projectIdentity(pi: ExtensionAPI, cwd: string): Promise { + for (const [command, args] of [ + ["jj", ["--ignore-working-copy", "git", "root"]], + ["git", ["rev-parse", "--path-format=absolute", "--git-common-dir"]], + ] as const) { + try { + const result = await pi.exec(command, [...args], { cwd, timeout: 5_000 }); + const root = result.stdout.replace(/\r?\n$/, ""); + if (result.code === 0 && !result.killed && isAbsolute(root)) { + return basename(root) === ".git" ? dirname(root) : root; + } + } catch { + // The next command can resolve the repository when this command is unavailable. + } + } + return resolve(cwd); } function memoryHeading(scope: MemoryScope): string { @@ -614,6 +623,25 @@ export function createMemoryExtension( const memoryDirectory = resolve(suppliedMemoryDirectory); const compact = suppliedCompact ?? runCompactionAgent; let toolsRegistered = false; + const projectIdentities = new Map>(); + + async function memoryDirectoryForScope(scope: MemoryScope, cwd: string): Promise { + if (scope === "global") { + return join(memoryDirectory, RECORDS_DIRECTORY, "global"); + } + let identity = projectIdentities.get(cwd); + if (!identity) { + identity = projectIdentity(pi, cwd); + projectIdentities.set(cwd, identity); + } + return join( + memoryDirectory, + RECORDS_DIRECTORY, + createHash("sha256") + .update(await identity) + .digest("hex"), + ); + } pi.registerCommand("memory", { description: "List and delete global and project memories", @@ -623,32 +651,23 @@ export function createMemoryExtension( return; } - const stores = MEMORY_SCOPES.map((scope) => ({ - scope, - directory: memoryDirectoryForScope(memoryDirectory, scope, ctx.cwd), - })); let readFailed = false; const memories: Array<{ scope: MemoryScope; directory: string; file: MemoryFile; }> = []; - for (const store of stores) { + for (const scope of MEMORY_SCOPES) { try { - const snapshot = await withFileMutationQueue(store.directory, () => - readSnapshot(store.directory), - ); - memories.push( - ...snapshot.files.map((file) => ({ - scope: store.scope, - directory: store.directory, - file, - })), + const directory = await memoryDirectoryForScope(scope, ctx.cwd); + const snapshot = await withFileMutationQueue(directory, () => + readSnapshot(directory), ); + memories.push(...snapshot.files.map((file) => ({ scope, directory, file }))); } catch (error) { readFailed = true; const message = error instanceof Error ? error.message : String(error); - ctx.ui.notify(`Could not read ${store.scope} memory: ${message}`, "warning"); + ctx.ui.notify(`Could not read ${scope} memory: ${message}`, "warning"); } } if (memories.length === 0) { @@ -710,9 +729,7 @@ export function createMemoryExtension( const sections: string[] = []; for (const scope of MEMORY_SCOPES) { try { - const snapshot = await readSnapshot( - memoryDirectoryForScope(memoryDirectory, scope, ctx.cwd), - ); + const snapshot = await readSnapshot(await memoryDirectoryForScope(scope, ctx.cwd)); const heading = memoryHeading(scope); ensureContextFits(snapshot, heading); const section = formatMemorySection(snapshot, heading); @@ -731,6 +748,7 @@ export function createMemoryExtension( }); pi.on("session_start", (_event, ctx) => { + projectIdentities.clear(); if (toolsRegistered) { return; } @@ -793,7 +811,7 @@ export function createMemoryExtension( // Project memories are more specific, so they come first. for (const scope of [...MEMORY_SCOPES].reverse()) { const snapshot = await readSnapshot( - memoryDirectoryForScope(memoryDirectory, scope, ctx.cwd), + await memoryDirectoryForScope(scope, ctx.cwd), ); for (const file of snapshot.files.filter((candidate) => params.names.includes(candidate.name), @@ -927,11 +945,7 @@ export function createMemoryExtension( ? "" : validateText(params.details, MAX_DETAILS_CHARACTERS, "Details"); const content = memoryContent(summary, details, ctx.sessionManager.getSessionId()); - const targetDirectory = memoryDirectoryForScope( - memoryDirectory, - params.scope, - ctx.cwd, - ); + const targetDirectory = await memoryDirectoryForScope(params.scope, ctx.cwd); const { snapshot, replaced } = await withFileMutationQueue( targetDirectory, @@ -1049,11 +1063,7 @@ export function createMemoryExtension( } signal?.throwIfAborted(); validateText(params.reason, MAX_SUMMARY_CHARACTERS, "Reason"); - const targetDirectory = memoryDirectoryForScope( - memoryDirectory, - params.scope, - ctx.cwd, - ); + const targetDirectory = await memoryDirectoryForScope(params.scope, ctx.cwd); const forgotten = await withFileMutationQueue(targetDirectory, async () => { const current = await readSnapshot(targetDirectory); const files = current.files.filter((file) => params.names.includes(file.name)); diff --git a/agent/extensions/memory/test/memory.test.ts b/agent/extensions/memory/test/memory.test.ts index 341b551..52cf30c 100644 --- a/agent/extensions/memory/test/memory.test.ts +++ b/agent/extensions/memory/test/memory.test.ts @@ -3,6 +3,7 @@ import { createHash } from "node:crypto"; import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { dirname, join, resolve } from "node:path"; +import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"; import test, { type TestContext } from "node:test"; import { type TSchema } from "typebox"; import { Check } from "typebox/value"; @@ -115,6 +116,8 @@ interface CapturedTool { } type TestCompactor = (memories: string) => Promise; +type ExecResult = Awaited>; +const unresolved: ExecResult = { code: 1, killed: false, stdout: "", stderr: "Not a repository." }; const theme = { bold: (text: string) => text, @@ -144,7 +147,17 @@ function setup( const commands = new Map(); const notifications: Array<[string, string]> = []; const settings: TestSettings = {}; + const execResults: Array = []; + const execCalls: Array<[string, string[], string | undefined]> = []; const pi = { + async exec(command: string, args: string[], options?: Parameters[2]) { + execCalls.push([command, args, options?.cwd]); + const result = execResults.shift() ?? unresolved; + if (result instanceof Error) { + throw result; + } + return result; + }, getSettings: () => settings, on(name: string, handler: Handler) { handlers.set(name, handler); @@ -164,7 +177,16 @@ function setup( // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- The fixture provides each extension API member used here. createMemoryExtension(pi as never, directory); } - return { commands, directory, handlers, notifications, settings, tools }; + return { + commands, + directory, + execCalls, + execResults, + handlers, + notifications, + settings, + tools, + }; } function runtimeContext(extension: ReturnType, mode: Mode): RuntimeContext { @@ -195,9 +217,12 @@ function scopeKey(scope: Scope, cwd: string): string { return scope === "global" ? "global" : createHash("sha256").update(resolve(cwd)).digest("hex"); } -function recordsDirectory(extension: ReturnType, scope: Scope = "global"): string { - const context = runtimeContext(extension, "tui"); - return join(extension.directory, "records", scopeKey(scope, context.cwd)); +function recordsDirectory( + extension: ReturnType, + scope: Scope = "global", + identity = runtimeContext(extension, "tui").cwd, +): string { + return join(extension.directory, "records", scopeKey(scope, identity)); } async function start(extension: ReturnType, mode: Mode): Promise { @@ -256,15 +281,13 @@ async function recordFiles(directory: string): Promise { async function prompt( extension: ReturnType, mode: Mode, + context = runtimeContext(extension, mode), ): Promise { const event = { systemPrompt: "base", systemPromptOptions: { sections: { persistent_memory: "stale", other: "keep" } }, }; - const result = await extension.handlers.get("before_agent_start")?.( - event, - runtimeContext(extension, mode), - ); + const result = await extension.handlers.get("before_agent_start")?.(event, context); assert.equal(result, undefined); assert.equal(event.systemPromptOptions.sections.other, "keep"); return event.systemPromptOptions.sections.persistent_memory; @@ -490,7 +513,7 @@ test("forget_memory archives named memories", async (t) => { assert.doesNotMatch(loaded ?? "", /preference-1|preference-3/); }); -test("project memories use a PWD hash without project trust or local files", async (t) => { +test("project memories outside repositories use a cwd hash without local files", async (t) => { const extension = setup(await memoryDirectory(t)); await start(extension, "tui"); const context = runtimeContext(extension, "tui"); @@ -536,6 +559,212 @@ test("project memories use a PWD hash without project trust or local files", asy assert.deepEqual(await recordFiles(recordsDirectory(extension, "project")), []); }); +function repositoryResult(root: string): ExecResult { + return { code: 0, killed: false, stdout: root + "\n", stderr: "" }; +} + +test("repository commands share memories across current and future workspaces", async (t) => { + for (const [backend, separate] of [ + ["jj", false], + ["git", false], + ["jj", true], + ] as const) { + await t.test(backend + (separate ? " separate Git directory" : ""), async (t) => { + const directory = await memoryDirectory(t); + const main = setup(directory); + const mainContext = runtimeContext(main, "tui"); + const gitDirectory = separate + ? join(dirname(directory), "shared-git") + : join(mainContext.cwd, ".git"); + const identity = separate ? gitDirectory : mainContext.cwd; + const results = + backend === "jj" + ? [repositoryResult(gitDirectory)] + : [unresolved, repositoryResult(gitDirectory)]; + main.execResults.push(...results); + await start(main, "tui"); + await run(main, "record_memory", { + scope: "project", + name: "validation", + summary: "Run validation.", + }); + await run(main, "record_memory", { + scope: "global", + name: "global-rule", + summary: "Use direct answers.", + }); + + const workspace = setup(directory); + const context = { + ...runtimeContext(workspace, "tui"), + cwd: join(dirname(directory), "workspace"), + }; + workspace.execResults.push(...results); + await start(workspace, "tui"); + await run( + workspace, + "record_memory", + { + scope: "project", + name: "release-checks", + summary: "Check each release.", + details: "Run the release checklist.", + }, + context, + ); + assert.deepEqual(await recordFiles(recordsDirectory(main, "project", identity)), [ + "release-checks.md", + "validation.md", + ]); + + const future = join(dirname(directory), "future-workspace"); + await mkdir(future); + for (const mode of ["tui", "rpc", "json", "print"] as const) { + const agent = setup(directory); + const futureContext = { ...runtimeContext(agent, mode), cwd: future }; + agent.execResults.push(...results); + await start(agent, mode); + const loaded = await prompt(agent, mode, futureContext); + assert.match(loaded ?? "", /Check each release/); + assert.doesNotMatch(loaded ?? "", /Run the release checklist/); + assert.match( + text( + await run( + agent, + "recall_memory", + { names: ["release-checks"] }, + futureContext, + ), + ), + /Run the release checklist/, + ); + } + const replaced = await run( + workspace, + "record_memory", + { + scope: "project", + name: "release-checks", + summary: "Check releases twice.", + }, + context, + ); + assert.match(text(replaced), /^Replaced project memory/); + assert.match((await prompt(main, "tui")) ?? "", /Check releases twice/); + await run(main, "forget_memory", { + scope: "project", + names: ["release-checks"], + reason: "Obsolete.", + }); + await assert.rejects( + run(workspace, "recall_memory", { names: ["release-checks"] }, context), + /No memory is named/, + ); + await command(workspace, "memory").handler("", { + ...context, + ui: { + async select(_title, options) { + assert.equal(options.length, 2); + return options.find((option) => option.includes("project ยท")); + }, + async confirm() { + return true; + }, + notify() {}, + }, + }); + assert.deepEqual(await recordFiles(recordsDirectory(main, "project", identity)), []); + assert.match( + text(await run(main, "recall_memory", { names: ["global-rule"] })), + /Use direct answers/, + ); + assert.deepEqual( + main.execCalls, + backend === "jj" + ? [["jj", ["--ignore-working-copy", "git", "root"], mainContext.cwd]] + : [ + ["jj", ["--ignore-working-copy", "git", "root"], mainContext.cwd], + [ + "git", + ["rev-parse", "--path-format=absolute", "--git-common-dir"], + mainContext.cwd, + ], + ], + ); + }); + } +}); + +test("Git resolves the project when jj fails, times out, or returns an invalid path", async (t) => { + for (const result of [ + new Error("Command unavailable."), + unresolved, + { ...repositoryResult("/unused"), killed: true }, + repositoryResult(""), + repositoryResult("relative"), + ]) { + const extension = setup(await memoryDirectory(t)); + await start(extension, "tui"); + const context = runtimeContext(extension, "tui"); + extension.execResults.push(result, repositoryResult(join(context.cwd, ".git"))); + await run(extension, "record_memory", { + scope: "project", + name: "project-rule", + summary: "Use project rules.", + }); + assert.deepEqual(await recordFiles(recordsDirectory(extension, "project")), [ + "project-rule.md", + ]); + assert.deepEqual( + extension.execCalls.map(([command]) => command), + ["jj", "git"], + ); + } +}); + +test("project resolution is cached per cwd and reset when a session starts", async (t) => { + const extension = setup(await memoryDirectory(t)); + await start(extension, "tui"); + await run(extension, "record_memory", { + scope: "global", + name: "global-rule", + summary: "Use global rules.", + }); + assert.deepEqual(extension.execCalls, []); + await Promise.all([prompt(extension, "tui"), prompt(extension, "tui")]); + assert.equal(extension.execCalls.length, 2); + await run(extension, "record_memory", { + scope: "project", + name: "project-rule", + summary: "Use project rules.", + }); + await run(extension, "recall_memory", { names: ["project-rule"] }); + assert.equal(extension.execCalls.length, 2); + const context = runtimeContext(extension, "tui"); + await prompt(extension, "tui", { ...context, cwd: join(context.cwd, "other") }); + assert.equal(extension.execCalls.length, 4); + await start(extension, "tui"); + extension.execResults.push(repositoryResult(join(context.cwd, ".git"))); + assert.match((await prompt(extension, "tui")) ?? "", /Use project rules/); + assert.equal(extension.execCalls.length, 5); +}); + +test("different repositories keep project memories separate", async (t) => { + const extension = setup(await memoryDirectory(t)); + await start(extension, "tui"); + const context = runtimeContext(extension, "tui"); + extension.execResults.push(repositoryResult(join(context.cwd, ".git"))); + await run(extension, "record_memory", { + scope: "project", + name: "parent-rule", + summary: "Use parent rules.", + }); + for (const cwd of [join(context.cwd, "nested"), join(dirname(extension.directory), "clone")]) { + extension.execResults.push(repositoryResult(join(cwd, ".git"))); + assert.equal(await prompt(extension, "tui", { ...context, cwd }), undefined); + } +}); + test("automatic compaction uses the model and reasoning from settings", async (t) => { const extension = setup(await memoryDirectory(t), null); const activeModel: TestModel = { -- knotmirror 0.0.1