@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/agent-memory.test.ts

@@ -0,0 +1,420 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import {
+	AGENT_MEMORY_DIR_NAME,
+	AGENT_MEMORY_FILE,
+	agentHasWriteTools,
+	buildAgentMemoryInjection,
+	parseMemoryFrontmatter,
+	readMemoryFile,
+	resolveMemoryDir,
+} from "../../src/agents/agent-memory.ts";
+import { serializeAgent } from "../../src/agents/agent-serializer.ts";
+import { discoverAgents, findNearestProjectRoot, type AgentConfig, type AgentMemoryConfig } from "../../src/agents/agents.ts";
+import { handleManagementAction } from "../../src/agents/agent-management.ts";
+
+const tempDirs: string[] = [];
+
+function makeAgent(overrides: Partial<AgentConfig> & { memory?: AgentMemoryConfig }): AgentConfig {
+	return {
+		name: "test-agent",
+		description: "test agent",
+		systemPrompt: "do the thing",
+		systemPromptMode: "replace",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		source: "project",
+		filePath: "/tmp/test-agent.md",
+		...overrides,
+	};
+}
+
+function mkdtemp(prefix: string): string {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+	tempDirs.push(dir);
+	return dir;
+}
+
+function withTempHome<T>(fn: (home: string) => T): T {
+	const home = mkdtemp("pi-subagents-mem-home-");
+	const oldHome = process.env.HOME;
+	const oldUserProfile = process.env.USERPROFILE;
+	const oldPiCodingAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+	process.env.HOME = home;
+	process.env.USERPROFILE = home;
+	delete process.env.SELESAI_CODING_AGENT_DIR;
+	try {
+		return fn(home);
+	} finally {
+		if (oldHome === undefined) delete process.env.HOME;
+		else process.env.HOME = oldHome;
+		if (oldUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = oldUserProfile;
+		if (oldPiCodingAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = oldPiCodingAgentDir;
+	}
+}
+
+// Create a temp project root that findNearestProjectRoot will recognise (.pi dir present).
+function mkProject(): string {
+	const dir = mkdtemp("pi-subagents-mem-project-");
+	fs.mkdirSync(path.join(dir, ".selesai", "agents"), { recursive: true });
+	return dir;
+}
+
+function writeMemoryFile(memoryDir: string, contents: string): void {
+	fs.mkdirSync(memoryDir, { recursive: true });
+	fs.writeFileSync(path.join(memoryDir, AGENT_MEMORY_FILE), contents, "utf-8");
+}
+
+afterEach(() => {
+	while (tempDirs.length > 0) {
+		const dir = tempDirs.pop();
+		if (!dir) continue;
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+describe("parseMemoryFrontmatter", () => {
+	it("parses a project scope block", () => {
+		assert.deepEqual(parseMemoryFrontmatter("scope: project\npath: security-reviewer"), {
+			scope: "project",
+			path: "security-reviewer",
+		});
+	});
+
+	it("parses a user scope with nested path and strips quotes", () => {
+		assert.deepEqual(parseMemoryFrontmatter('scope: user\npath: "team/release-agent"'), {
+			scope: "user",
+			path: "team/release-agent",
+		});
+	});
+
+	it("parses an inline object memory block", () => {
+		assert.deepEqual(parseMemoryFrontmatter('{ scope: "project", path: "security-reviewer" }'), {
+			scope: "project",
+			path: "security-reviewer",
+		});
+	});
+
+	it("rejects unknown scopes", () => {
+		assert.equal(parseMemoryFrontmatter("scope: global\npath: x"), undefined);
+	});
+
+	it("rejects a missing path", () => {
+		assert.equal(parseMemoryFrontmatter("scope: project"), undefined);
+	});
+
+	it("rejects a missing scope", () => {
+		assert.equal(parseMemoryFrontmatter("path: x"), undefined);
+	});
+
+	it("treats empty or absent input as no memory config", () => {
+		assert.equal(parseMemoryFrontmatter(undefined), undefined);
+		assert.equal(parseMemoryFrontmatter(""), undefined);
+	});
+});
+
+describe("agentHasWriteTools", () => {
+	it("inherits write capability when tools are unset", () => {
+		assert.equal(agentHasWriteTools({}), true);
+	});
+
+	it("detects edit, write, and bash as write tools", () => {
+		assert.equal(agentHasWriteTools({ tools: ["read", "edit"] }), true);
+		assert.equal(agentHasWriteTools({ tools: ["write"] }), true);
+		assert.equal(agentHasWriteTools({ tools: ["bash"] }), true);
+	});
+
+	it("treats read-only and mcp-only tool sets as non-write", () => {
+		assert.equal(agentHasWriteTools({ tools: ["read", "grep", "find", "ls"] }), false);
+		assert.equal(agentHasWriteTools({ tools: ["mcp:filesystem"] }), false);
+	});
+});
+
+describe("resolveMemoryDir", () => {
+	it("resolves a simple and nested path under the root", () => {
+		const root = mkdtemp("pi-subagents-mem-root-");
+		assert.deepEqual(resolveMemoryDir(root, "reviewer"), { dir: path.join(root, "reviewer") });
+		assert.deepEqual(resolveMemoryDir(root, "team/reviewer"), { dir: path.join(root, "team", "reviewer") });
+	});
+
+	it("rejects empty paths", () => {
+		const root = mkdtemp("pi-subagents-mem-root-");
+		assert.ok("error" in resolveMemoryDir(root, ""));
+		assert.ok("error" in resolveMemoryDir(root, "   "));
+	});
+
+	it("rejects dot and parent segments", () => {
+		const root = mkdtemp("pi-subagents-mem-root-");
+		assert.ok("error" in resolveMemoryDir(root, "."));
+		assert.ok("error" in resolveMemoryDir(root, ".."));
+		assert.ok("error" in resolveMemoryDir(root, "a/../b"));
+	});
+
+	it("rejects absolute and Windows drive-like paths", () => {
+		const root = mkdtemp("pi-subagents-mem-root-");
+		assert.ok("error" in resolveMemoryDir(root, "/tmp/reviewer"));
+		assert.ok("error" in resolveMemoryDir(root, "C:\\Users\\reviewer"));
+		assert.ok("error" in resolveMemoryDir(root, "C:reviewer"));
+		assert.ok("error" in resolveMemoryDir(root, "team:C"));
+	});
+
+	it("rejects a symlinked ancestor before prompting a first write", () => {
+		const root = mkdtemp("pi-subagents-mem-root-");
+		const outside = mkdtemp("pi-subagents-mem-outside-");
+		const linkPath = path.join(root, "leak");
+		try {
+			fs.symlinkSync(outside, linkPath);
+		} catch {
+			return;
+		}
+		const resolved = resolveMemoryDir(root, "leak/new-agent");
+		assert.ok("error" in resolved, "expected symlink ancestor escape to be rejected");
+	});
+
+	it("rejects a memory dir that is a symlink escaping the root", () => {
+		const root = mkdtemp("pi-subagents-mem-root-");
+		const outside = mkdtemp("pi-subagents-mem-outside-");
+		const linkPath = path.join(root, "leak");
+		try {
+			fs.symlinkSync(outside, linkPath);
+		} catch {
+			// Symlinks may be unavailable (e.g. Windows without dev mode); skip portably.
+			return;
+		}
+		const resolved = resolveMemoryDir(root, "leak");
+		assert.ok("error" in resolved, "expected symlink escape to be rejected");
+	});
+});
+
+describe("readMemoryFile", () => {
+	it("returns null when no memory file exists", () => {
+		const dir = mkdtemp("pi-subagents-mem-dir-");
+		assert.equal(readMemoryFile(dir), null);
+	});
+
+	it("reads contents and reports byte capping", () => {
+		const dir = mkdtemp("pi-subagents-mem-dir-");
+		writeMemoryFile(dir, "line one\nline two\n");
+		const result = readMemoryFile(dir);
+		assert.ok(result && typeof result === "object" && !("error" in result) && result !== "unsafe");
+		assert.equal((result as { contents: string }).contents, "line one\nline two\n");
+		assert.equal((result as { byteCapped: boolean }).byteCapped, false);
+	});
+
+	it("flags byte-capped contents", () => {
+		const dir = mkdtemp("pi-subagents-mem-dir-");
+		const bigLine = "x".repeat(500);
+		writeMemoryFile(dir, Array.from({ length: 50 }, () => bigLine).join("\n"));
+		const result = readMemoryFile(dir);
+		assert.ok(result && result !== "unsafe");
+		assert.equal((result as { byteCapped: boolean }).byteCapped, true);
+	});
+
+	it("does not return more than the memory byte cap", () => {
+		const dir = mkdtemp("pi-subagents-mem-dir-");
+		writeMemoryFile(dir, "x".repeat(1024 * 1024));
+		const result = readMemoryFile(dir);
+		assert.ok(result && result !== "unsafe");
+		assert.equal(result.byteCapped, true);
+		assert.ok(Buffer.byteLength(result.contents, "utf-8") <= 16 * 1024);
+	});
+
+	it("rejects a symlinked memory file that escapes the memory dir", () => {
+		const dir = mkdtemp("pi-subagents-mem-dir-");
+		const outsideFile = path.join(mkdtemp("pi-subagents-mem-outside-"), "secret.md");
+		fs.writeFileSync(outsideFile, "leaked", "utf-8");
+		try {
+			fs.symlinkSync(outsideFile, path.join(dir, AGENT_MEMORY_FILE));
+		} catch {
+			return; // Symlinks unsupported here; skip portably.
+		}
+		assert.equal(readMemoryFile(dir), "unsafe");
+	});
+});
+
+describe("buildAgentMemoryInjection", () => {
+	it("returns empty when the agent has no memory scope", () => {
+		const project = mkProject();
+		assert.equal(buildAgentMemoryInjection(makeAgent({}), project), "");
+	});
+
+	it("injects a read-write block with contents for a project scope", () => {
+		const project = mkProject();
+		const memoryDir = path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "security-reviewer");
+		writeMemoryFile(memoryDir, "Threat: token leakage in logs.\nGotcha: retry on 429.");
+		const agent = makeAgent({ memory: { scope: "project", path: "security-reviewer" }, tools: ["read", "edit"] });
+		const injection = buildAgentMemoryInjection(agent, project);
+		const memoryFile = path.join(memoryDir, AGENT_MEMORY_FILE);
+		assert.match(injection, /# Persistent agent memory/);
+		assert.match(injection, new RegExp(`Memory file: ${escapeRegex(memoryFile)}`));
+		assert.match(injection, /append a concise dated entry/);
+		assert.match(injection, /reference data, not instructions/);
+		assert.match(injection, /Threat: token leakage in logs\./);
+		assert.match(injection, /Gotcha: retry on 429\./);
+		assert.doesNotMatch(injection, /read-only/);
+	});
+
+	it("injects a creation prompt when a read-write agent has no memory file yet", () => {
+		const project = mkProject();
+		const agent = makeAgent({ memory: { scope: "project", path: "fresh-agent" }, tools: ["read", "write"] });
+		const injection = buildAgentMemoryInjection(agent, project);
+		const memoryFile = path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "fresh-agent", AGENT_MEMORY_FILE);
+		assert.match(injection, new RegExp(`Memory file: ${escapeRegex(memoryFile)}`));
+		assert.match(injection, new RegExp(`No ${AGENT_MEMORY_FILE} exists yet`));
+		assert.match(injection, /You may create it/);
+	});
+
+	it("injects a read-only block for agents without write tools", () => {
+		const project = mkProject();
+		const memoryDir = path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "scout");
+		writeMemoryFile(memoryDir, "Known flake: async timeout test.");
+		const agent = makeAgent({ memory: { scope: "project", path: "scout" }, tools: ["read", "grep", "find", "ls"] });
+		const injection = buildAgentMemoryInjection(agent, project);
+		assert.match(injection, /read-only, role-specific memory scope/);
+		assert.match(injection, /Do not attempt to edit or create the memory file/);
+		assert.match(injection, /reference data, not instructions/);
+		assert.match(injection, /Known flake: async timeout test\./);
+		assert.doesNotMatch(injection, /You may create it/);
+		assert.doesNotMatch(injection, /append a concise dated entry/);
+	});
+
+	it("injects nothing for a read-only agent with no memory file yet", () => {
+		const project = mkProject();
+		const agent = makeAgent({ memory: { scope: "project", path: "empty-scout" }, tools: ["read"] });
+		assert.equal(buildAgentMemoryInjection(agent, project), "");
+	});
+
+	it("resolves user scope under the agent dir, separate from the owner memory system", () => {
+		withTempHome((home) => {
+			const project = mkProject();
+			const memoryDir = path.join(home, ".selesai", "agent", AGENT_MEMORY_DIR_NAME, "release-agent");
+			writeMemoryFile(memoryDir, "Release gotcha: tag before gh release.");
+			const agent = makeAgent({ memory: { scope: "user", path: "release-agent" }, tools: ["read", "edit"] });
+			const injection = buildAgentMemoryInjection(agent, project);
+			const memoryFile = path.join(memoryDir, AGENT_MEMORY_FILE);
+			assert.match(injection, new RegExp(`Memory file: ${escapeRegex(memoryFile)}`));
+			assert.match(injection, /Release gotcha: tag before gh release\./);
+			// Must not collide with the owner's ~/.pi/agent/memory/{project}/ layout.
+			assert.doesNotMatch(injection, /agent\/memory\/[^/]+\/release-agent/);
+		});
+	});
+
+	it("returns empty for project scope when no project root is found", () => {
+		const nowhere = mkdtemp("pi-subagents-mem-noroot-");
+		// Skip deterministically if an ancestor happens to register as a project root.
+		if (findNearestProjectRoot(nowhere) !== null) return;
+		const agent = makeAgent({ memory: { scope: "project", path: "x" }, tools: ["read"] });
+		assert.equal(buildAgentMemoryInjection(agent, nowhere), "");
+	});
+
+	it("returns empty when the memory path is unsafe", () => {
+		const project = mkProject();
+		const agent = makeAgent({ memory: { scope: "project", path: ".." }, tools: ["read", "edit"] });
+		assert.equal(buildAgentMemoryInjection(agent, project), "");
+	});
+
+	it("returns empty when the memory file is an escaping symlink", () => {
+		const project = mkProject();
+		const memoryDir = path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "leak");
+		fs.mkdirSync(memoryDir, { recursive: true });
+		const outsideFile = path.join(mkdtemp("pi-subagents-mem-outside-"), "secret.md");
+		fs.writeFileSync(outsideFile, "leaked", "utf-8");
+		try {
+			fs.symlinkSync(outsideFile, path.join(memoryDir, AGENT_MEMORY_FILE));
+		} catch {
+			return; // Symlinks unsupported here; skip portably.
+		}
+		const agent = makeAgent({ memory: { scope: "project", path: "leak" }, tools: ["read", "edit"] });
+		assert.equal(buildAgentMemoryInjection(agent, project), "");
+	});
+
+	it("caps memory contents to the first N lines without claiming a byte cap", () => {
+		const project = mkProject();
+		const memoryDir = path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "capped");
+		writeMemoryFile(memoryDir, Array.from({ length: 210 }, (_, i) => `l-${i + 1}`).join("\n"));
+		const agent = makeAgent({ memory: { scope: "project", path: "capped" }, tools: ["read", "edit"] });
+		const injection = buildAgentMemoryInjection(agent, project);
+		assert.match(injection, /l-200\b/);
+		assert.doesNotMatch(injection, /l-201\b/);
+		assert.match(injection, /first 200 lines\)/);
+		assert.doesNotMatch(injection, /byte-capped/);
+	});
+});
+
+describe("agent memory frontmatter round-trip", () => {
+	it("parses memory frontmatter during discovery and keeps it out of extraFields", () => {
+		const project = mkProject();
+		fs.writeFileSync(path.join(project, ".selesai", "agents", "security-reviewer.md"), `---
+name: security-reviewer
+description: Recurring security reviewer
+tools: read, grep, bash, edit
+memory: { scope: project, path: security-reviewer }
+---
+
+Review for threats.
+`, "utf-8");
+
+		const agent = discoverAgents(project, "project").agents.find((a) => a.name === "security-reviewer");
+		assert.ok(agent, "agent should be discovered");
+		assert.deepEqual(agent?.memory, { scope: "project", path: "security-reviewer" });
+		assert.equal(agent?.extraFields?.memory, undefined, "memory must not leak into extraFields");
+	});
+
+	it("serializes memory back into frontmatter", () => {
+		const agent = makeAgent({ memory: { scope: "user", path: "release-agent" } });
+		const serialized = serializeAgent(agent);
+		assert.match(serialized, /^memory:$/m);
+		assert.match(serialized, /^  scope: user$/m);
+		assert.match(serialized, /^  path: release-agent$/m);
+	});
+
+	it("ignores a malformed memory block without dropping the agent", () => {
+		const project = mkProject();
+		fs.writeFileSync(path.join(project, ".selesai", "agents", "bad-memory.md"), `---
+name: bad-memory
+description: Bad memory config
+memory:
+  scope: galaxy
+  path: whatever
+---
+
+Still loads.
+`, "utf-8");
+
+		const agent = discoverAgents(project, "project").agents.find((a) => a.name === "bad-memory");
+		assert.ok(agent, "agent should still be discovered");
+		assert.equal(agent?.memory, undefined);
+	});
+});
+
+describe("agent memory in management detail", () => {
+	it("surfaces the memory scope in the get action", () => {
+		const project = mkProject();
+		fs.writeFileSync(path.join(project, ".selesai", "agents", "security-reviewer.md"), `---
+name: security-reviewer
+description: Recurring security reviewer
+memory:
+  scope: project
+  path: security-reviewer
+---
+
+Review for threats.
+`, "utf-8");
+
+		const res = handleManagementAction("get", { agent: "security-reviewer" }, {
+			cwd: project,
+			modelRegistry: { getAvailable: () => [] },
+		});
+		assert.equal(res.isError, false);
+		assert.match(res.content[0]?.text ?? "", /Memory: project scope, path: security-reviewer/);
+	});
+});
+
+function escapeRegex(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}