@poncho-ai/harness 0.23.0 → 0.25.0

package/test/harness.test.ts

@@ -1,10 +1,11 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { tmpdir } from "node:os";
 import { join } from "path";
 import { describe, expect, it } from "vitest";
 import type { ToolContext } from "@poncho-ai/sdk";
 import { AgentHarness } from "../src/harness.js";
+import { createEditTool } from "../src/default-tools.js";
 import { loadSkillMetadata } from "../src/skill-context.js";
 
 const stubContext: ToolContext = {
@@ -39,6 +40,7 @@ model:
     expect(names).toContain("list_directory");
     expect(names).toContain("read_file");
     expect(names).toContain("write_file");
+    expect(names).toContain("edit_file");
   });
 
   it("disables write_file by default in production environment", async () => {
@@ -64,6 +66,7 @@ model:
     expect(names).toContain("list_directory");
     expect(names).toContain("read_file");
     expect(names).not.toContain("write_file");
+    expect(names).not.toContain("edit_file");
   });
 
   it("allows disabling built-in tools via poncho.config.js", async () => {
@@ -364,7 +367,7 @@ description: Beta skill
     });
   });
 
-  it("clears active skills when skill metadata changes in development mode", async () => {
+  it("preserves active skills when skill metadata changes in development mode", async () => {
     const dir = await mkdtemp(join(tmpdir(), "poncho-harness-skill-refresh-clear-active-"));
     await writeFile(
       join(dir, "AGENT.md"),
@@ -402,6 +405,7 @@ description: Alpha skill
     await activate!.handler({ name: "alpha" }, {} as any);
     expect(await listActive!.handler({}, {} as any)).toEqual({ activeSkills: ["alpha"] });
 
+    // Update the skill metadata — the skill keeps the same name so it stays active
     await writeFile(
       join(dir, "skills", "alpha", "SKILL.md"),
       `---
@@ -414,7 +418,7 @@ description: Alpha skill updated
       "utf8",
     );
     await (harness as any).refreshSkillsIfChanged();
-    expect(await listActive!.handler({}, {} as any)).toEqual({ activeSkills: [] });
+    expect(await listActive!.handler({}, {} as any)).toEqual({ activeSkills: ["alpha"] });
   });
 
   it("lists skill scripts through list_skill_scripts", async () => {
@@ -907,6 +911,132 @@ allowed-tools:
     await new Promise<void>((resolveClose) => mcpServer.close(() => resolveClose()));
   });
 
+  it("agent-level MCP tools persist when a skill is activated (additive)", async () => {
+    process.env.LINEAR_TOKEN = "token-123";
+    const mcpServer = createServer(async (req, res) => {
+      if (req.method === "DELETE") {
+        res.statusCode = 200;
+        res.end();
+        return;
+      }
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) chunks.push(Buffer.from(chunk));
+      const body = Buffer.concat(chunks).toString("utf8");
+      const payload = body.trim().length > 0 ? (JSON.parse(body) as any) : {};
+      if (payload.method === "initialize") {
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Mcp-Session-Id", "sess");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: {
+              protocolVersion: "2025-03-26",
+              capabilities: { tools: { listChanged: true } },
+              serverInfo: { name: "remote", version: "1.0.0" },
+            },
+          }),
+        );
+        return;
+      }
+      if (payload.method === "notifications/initialized") {
+        res.statusCode = 202;
+        res.end();
+        return;
+      }
+      if (payload.method === "tools/list") {
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: {
+              tools: [
+                { name: "a", inputSchema: { type: "object", properties: {} } },
+                { name: "b", inputSchema: { type: "object", properties: {} } },
+              ],
+            },
+          }),
+        );
+        return;
+      }
+      if (payload.method === "tools/call") {
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: { result: { ok: true } },
+          }),
+        );
+        return;
+      }
+      res.statusCode = 404;
+      res.end();
+    });
+    await new Promise<void>((resolveOpen) => mcpServer.listen(0, () => resolveOpen()));
+    const address = mcpServer.address();
+    if (!address || typeof address === "string") throw new Error("Unexpected address");
+    const dir = await mkdtemp(join(tmpdir(), "poncho-harness-additive-mcp-"));
+    await writeFile(
+      join(dir, "AGENT.md"),
+      `---
+name: additive-agent
+model:
+  provider: anthropic
+  name: claude-opus-4-5
+allowed-tools:
+  - mcp:remote/a
+---
+
+# Additive Agent
+`,
+      "utf8",
+    );
+    await writeFile(
+      join(dir, "poncho.config.js"),
+      `export default {
+  mcp: [
+    {
+      name: "remote",
+      url: "http://127.0.0.1:${address.port}/mcp",
+      auth: { type: "bearer", tokenEnv: "LINEAR_TOKEN" }
+    }
+  ]
+};
+`,
+      "utf8",
+    );
+    await mkdir(join(dir, "skills", "skill-b"), { recursive: true });
+    await writeFile(
+      join(dir, "skills", "skill-b", "SKILL.md"),
+      `---
+name: skill-b
+description: B
+allowed-tools:
+  - mcp:remote/b
+---
+# B
+`,
+      "utf8",
+    );
+    const harness = new AgentHarness({ workingDir: dir });
+    await harness.initialize();
+    const toolNames = () => harness.listTools().map((t) => t.name);
+    expect(toolNames()).toContain("remote/a");
+    expect(toolNames()).not.toContain("remote/b");
+    const activate = harness.listTools().find((t) => t.name === "activate_skill")!;
+    const deactivate = harness.listTools().find((t) => t.name === "deactivate_skill")!;
+    await activate.handler({ name: "skill-b" }, {} as any);
+    expect(toolNames()).toContain("remote/a");
+    expect(toolNames()).toContain("remote/b");
+    await deactivate.handler({ name: "skill-b" }, {} as any);
+    expect(toolNames()).toContain("remote/a");
+    expect(toolNames()).not.toContain("remote/b");
+    await harness.shutdown();
+    await new Promise<void>((resolveClose) => mcpServer.close(() => resolveClose()));
+  });
+
   it("supports flat tool access config format", async () => {
     const dir = await mkdtemp(join(tmpdir(), "poncho-harness-flat-tool-access-"));
     await writeFile(
@@ -1230,3 +1360,63 @@ allowed-tools:
   });
 
 });
+
+describe("edit_file tool", () => {
+  it("replaces a unique string match in a file", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "poncho-edit-tool-"));
+    const filePath = join(dir, "test.txt");
+    await writeFile(filePath, "hello world\nfoo bar\nbaz qux\n", "utf8");
+
+    const tool = createEditTool(dir);
+    const result = await tool.handler(
+      { path: "test.txt", old_str: "foo bar", new_str: "replaced" },
+      stubContext,
+    );
+
+    expect(result).toEqual({ path: "test.txt", edited: true });
+    const content = await readFile(filePath, "utf8");
+    expect(content).toBe("hello world\nreplaced\nbaz qux\n");
+  });
+
+  it("errors when old_str is not found in the file", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "poncho-edit-tool-notfound-"));
+    await writeFile(join(dir, "test.txt"), "hello world\n", "utf8");
+
+    const tool = createEditTool(dir);
+    await expect(
+      tool.handler({ path: "test.txt", old_str: "nonexistent", new_str: "x" }, stubContext),
+    ).rejects.toThrow("old_str not found in file");
+  });
+
+  it("errors when old_str matches multiple locations", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "poncho-edit-tool-multi-"));
+    await writeFile(join(dir, "test.txt"), "aaa\nbbb\naaa\n", "utf8");
+
+    const tool = createEditTool(dir);
+    await expect(
+      tool.handler({ path: "test.txt", old_str: "aaa", new_str: "ccc" }, stubContext),
+    ).rejects.toThrow("old_str appears multiple times");
+  });
+
+  it("deletes matched content when new_str is empty", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "poncho-edit-tool-delete-"));
+    const filePath = join(dir, "test.txt");
+    await writeFile(filePath, "keep this\nremove this\nkeep this too\n", "utf8");
+
+    const tool = createEditTool(dir);
+    await tool.handler({ path: "test.txt", old_str: "remove this\n", new_str: "" }, stubContext);
+
+    const content = await readFile(filePath, "utf8");
+    expect(content).toBe("keep this\nkeep this too\n");
+  });
+
+  it("errors when old_str is empty", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "poncho-edit-tool-empty-"));
+    await writeFile(join(dir, "test.txt"), "content\n", "utf8");
+
+    const tool = createEditTool(dir);
+    await expect(
+      tool.handler({ path: "test.txt", old_str: "", new_str: "x" }, stubContext),
+    ).rejects.toThrow("old_str must not be empty");
+  });
+});

package/test/memory.test.ts

@@ -5,7 +5,6 @@ describe("memory store factory", () => {
   it("uses memory provider by default", async () => {
     const store = createMemoryStore("agent-test");
     const updated = await store.updateMainMemory({
-      mode: "replace",
       content: "Cesar prefers short bullet points.",
     });
     expect(updated.content).toContain("short bullet points");
@@ -13,24 +12,17 @@ describe("memory store factory", () => {
     expect(fetched.content).toContain("short bullet points");
   });
 
-  it("supports append updates", async () => {
-    const store = createMemoryStore("agent-append");
-    await store.updateMainMemory({
-      mode: "replace",
-      content: "Initial memory.",
-    });
-    const result = await store.updateMainMemory({
-      mode: "append",
-      content: "Appended line.",
-    });
-    expect(result.content).toContain("Initial memory.");
-    expect(result.content).toContain("Appended line.");
+  it("overwrites previous content on update", async () => {
+    const store = createMemoryStore("agent-overwrite");
+    await store.updateMainMemory({ content: "First version." });
+    const result = await store.updateMainMemory({ content: "Second version." });
+    expect(result.content).toBe("Second version.");
+    expect(result.content).not.toContain("First version.");
   });
 
   it("falls back gracefully when upstash is not configured", async () => {
     const store = createMemoryStore("agent-fallback", { provider: "upstash" });
     const updated = await store.updateMainMemory({
-      mode: "replace",
       content: "Fallback path still stores memory",
     });
     expect(updated.content).toContain("Fallback path");
@@ -43,8 +35,101 @@ describe("memory tools", () => {
     const tools = createMemoryTools(store);
     expect(tools.map((tool) => tool.name)).toEqual([
       "memory_main_get",
-      "memory_main_update",
+      "memory_main_write",
+      "memory_main_edit",
       "conversation_recall",
     ]);
   });
+
+  describe("memory_main_write", () => {
+    it("writes content to memory", async () => {
+      const store = createMemoryStore("agent-write");
+      const tools = createMemoryTools(store);
+      const writeTool = tools.find((t) => t.name === "memory_main_write")!;
+      const result = await writeTool.handler(
+        { content: "User prefers dark mode." },
+        { runId: "r1", agentId: "a1", step: 0, workingDir: ".", parameters: {} },
+      );
+      expect(result).toEqual({
+        ok: true,
+        memory: expect.objectContaining({ content: "User prefers dark mode." }),
+      });
+    });
+
+    it("errors when content is empty", async () => {
+      const store = createMemoryStore("agent-write-empty");
+      const tools = createMemoryTools(store);
+      const writeTool = tools.find((t) => t.name === "memory_main_write")!;
+      await expect(
+        writeTool.handler(
+          { content: "  " },
+          { runId: "r1", agentId: "a1", step: 0, workingDir: ".", parameters: {} },
+        ),
+      ).rejects.toThrow("content is required");
+    });
+  });
+
+  describe("memory_main_edit", () => {
+    const setupMemory = async () => {
+      const store = createMemoryStore("agent-edit-" + Math.random());
+      await store.updateMainMemory({
+        content: "- prefers dark mode\n- likes TypeScript\n- uses vim",
+      });
+      const tools = createMemoryTools(store);
+      const editTool = tools.find((t) => t.name === "memory_main_edit")!;
+      const ctx = { runId: "r1", agentId: "a1", step: 0, workingDir: ".", parameters: {} };
+      return { store, editTool, ctx };
+    };
+
+    it("replaces a unique string match in memory", async () => {
+      const { store, editTool, ctx } = await setupMemory();
+      const result = await editTool.handler(
+        { old_str: "likes TypeScript", new_str: "loves TypeScript" },
+        ctx,
+      );
+      expect(result).toEqual({
+        ok: true,
+        memory: expect.objectContaining({
+          content: "- prefers dark mode\n- loves TypeScript\n- uses vim",
+        }),
+      });
+      const fetched = await store.getMainMemory();
+      expect(fetched.content).toContain("loves TypeScript");
+    });
+
+    it("deletes matched content when new_str is empty", async () => {
+      const { store, editTool, ctx } = await setupMemory();
+      await editTool.handler(
+        { old_str: "\n- likes TypeScript", new_str: "" },
+        ctx,
+      );
+      const fetched = await store.getMainMemory();
+      expect(fetched.content).toBe("- prefers dark mode\n- uses vim");
+    });
+
+    it("errors when old_str is empty", async () => {
+      const { editTool, ctx } = await setupMemory();
+      await expect(
+        editTool.handler({ old_str: "", new_str: "anything" }, ctx),
+      ).rejects.toThrow("old_str must not be empty");
+    });
+
+    it("errors when old_str is not found in memory", async () => {
+      const { editTool, ctx } = await setupMemory();
+      await expect(
+        editTool.handler({ old_str: "nonexistent text", new_str: "x" }, ctx),
+      ).rejects.toThrow("old_str not found in memory");
+    });
+
+    it("errors when old_str matches multiple locations", async () => {
+      const store = createMemoryStore("agent-edit-dup");
+      await store.updateMainMemory({ content: "foo bar foo" });
+      const tools = createMemoryTools(store);
+      const editTool = tools.find((t) => t.name === "memory_main_edit")!;
+      const ctx = { runId: "r1", agentId: "a1", step: 0, workingDir: ".", parameters: {} };
+      await expect(
+        editTool.handler({ old_str: "foo", new_str: "baz" }, ctx),
+      ).rejects.toThrow("old_str appears multiple times");
+    });
+  });
 });