@aria-cli/tools 1.0.8 → 1.0.10

package/tests/e2e/memory-tool-discovery-contract.e2e.test.ts

@@ -1,81 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { Memoria } from "@aria-cli/memoria";
-import { createToolRegistry } from "../../src/index.js";
-import type { ToolContext } from "../../src/types.js";
-
-async function createRealMemoria(): Promise<Memoria> {
-  const memoria = new Memoria({
-    path: ":memory:",
-    embeddings: {
-      provider: "custom" as const,
-      model: "mock-embedding",
-      dimensions: 384,
-    },
-  });
-  await memoria.initialize();
-  return memoria;
-}
-
-function createContext(memoria: Memoria): ToolContext {
-  return {
-    workingDir: "/test",
-    env: {},
-    memoria: memoria as any,
-    confirm: async () => true,
-  };
-}
-
-describe("Memory tool discovery contract (E2E)", () => {
-  let memoria: Memoria;
-
-  afterEach(async () => {
-    if (memoria) {
-      await memoria.close();
-    }
-  });
-
-  it("[CRITICAL] recall schema should NOT expose tags (intentionally removed)", () => {
-    const registry = createToolRegistry();
-    const recallInfo = registry.getToolInfos().find((t) => t.name === "recall");
-    expect(recallInfo).toBeDefined();
-    expect(recallInfo!.parameters.map((p) => p.name)).not.toContain("tags");
-  });
-
-  it("🔴 discovery metadata should not expose forget.query", () => {
-    const registry = createToolRegistry();
-    const forgetInfo = registry.getToolInfos().find((t) => t.name === "forget");
-    expect(forgetInfo).toBeDefined();
-    expect(forgetInfo!.parameters.map((p) => p.name)).not.toContain("query");
-  });
-
-  it("recall through real Memoria should work without tags", async () => {
-    memoria = await createRealMemoria();
-    const registry = createToolRegistry();
-
-    await memoria.remember("Blue team deployment runbook", {
-      network: "world",
-    });
-
-    const recall = registry.get("recall");
-    expect(recall).toBeDefined();
-
-    const result = await recall!.execute({ query: "runbook" }, createContext(memoria));
-    expect(result.success).toBe(true);
-
-    const memories = ((result.data as any)?.memories ?? []) as Array<{
-      content: string;
-    }>;
-    expect(
-      memories.some((memory) => memory.content.toLowerCase().includes("deployment runbook")),
-    ).toBe(true);
-  });
-
-  it("recall_knowledge schema should expose kind and limit instead of depth", () => {
-    const registry = createToolRegistry();
-    const rkInfo = registry.getToolInfos().find((t) => t.name === "recall_knowledge");
-    expect(rkInfo).toBeDefined();
-    expect(rkInfo!.parameters.map((p) => p.name)).not.toContain("depth");
-    expect(rkInfo!.parameters.map((p) => p.name)).toContain("kind");
-    expect(rkInfo!.parameters.map((p) => p.name)).toContain("limit");
-  });
-});

package/tests/executors/apply-patch.test.ts

@@ -1,538 +0,0 @@
-/**
- * @aria/tools - Apply Patch executor tests
- *
- * Tests for unified diff patch application including:
- * - Happy path: single/multi-file, create, delete
- * - Security: path traversal, absolute paths, system paths
- * - Error handling: context mismatch, binary diff, empty patch
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import type { ToolContext } from "../../src/types.js";
-import { executeApplyPatch } from "../../src/executors/apply-patch.js";
-
-// Helper to create a unique temp directory
-const createTempDir = async (): Promise<string> => {
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-patch-test-"));
-  return tempDir;
-};
-
-// Helper to clean up temp directory
-const cleanupTempDir = async (dir: string): Promise<void> => {
-  await fs.rm(dir, { recursive: true, force: true });
-};
-
-// Helper to create a context
-const createContext = (workingDir: string): ToolContext => ({
-  workingDir,
-  env: {},
-  confirm: async () => true,
-});
-
-describe("Apply Patch Executor", () => {
-  let tempDir: string;
-  let ctx: ToolContext;
-
-  beforeEach(async () => {
-    tempDir = await createTempDir();
-    ctx = createContext(tempDir);
-  });
-
-  afterEach(async () => {
-    await cleanupTempDir(tempDir);
-  });
-
-  describe("happy path", () => {
-    it("applies a single-file patch correctly", async () => {
-      // Create source file
-      const filePath = path.join(tempDir, "hello.txt");
-      await fs.writeFile(filePath, "Hello\nWorld\nFoo\n");
-
-      const patch = [
-        "--- a/hello.txt",
-        "+++ b/hello.txt",
-        "@@ -1,3 +1,3 @@",
-        " Hello",
-        "-World",
-        "+Universe",
-        " Foo",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain("Patch applied");
-
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toContain("Universe");
-      expect(content).not.toContain("World");
-    });
-
-    it("applies a multi-file patch correctly", async () => {
-      // Create source files
-      const file1 = path.join(tempDir, "a.txt");
-      const file2 = path.join(tempDir, "b.txt");
-      await fs.writeFile(file1, "line1\nline2\n");
-      await fs.writeFile(file2, "alpha\nbeta\n");
-
-      const patch = [
-        "diff --git a/a.txt b/a.txt",
-        "--- a/a.txt",
-        "+++ b/a.txt",
-        "@@ -1,2 +1,2 @@",
-        " line1",
-        "-line2",
-        "+line2_modified",
-        "diff --git a/b.txt b/b.txt",
-        "--- a/b.txt",
-        "+++ b/b.txt",
-        "@@ -1,2 +1,2 @@",
-        " alpha",
-        "-beta",
-        "+gamma",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { filesChanged: number; modified: number };
-      expect(data.filesChanged).toBe(2);
-      expect(data.modified).toBe(2);
-
-      const content1 = await fs.readFile(file1, "utf-8");
-      expect(content1).toContain("line2_modified");
-      const content2 = await fs.readFile(file2, "utf-8");
-      expect(content2).toContain("gamma");
-    });
-
-    it("applies consecutive unified-diff file blocks without diff --git separators", async () => {
-      const file1 = path.join(tempDir, "a.txt");
-      const file2 = path.join(tempDir, "b.txt");
-      await fs.writeFile(file1, "old-a\n");
-      await fs.writeFile(file2, "old-b\n");
-
-      const patch = [
-        "--- a/a.txt",
-        "+++ b/a.txt",
-        "@@ -1 +1 @@",
-        "-old-a",
-        "+new-a",
-        "--- a/b.txt",
-        "+++ b/b.txt",
-        "@@ -1 +1 @@",
-        "-old-b",
-        "+new-b",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(await fs.readFile(file1, "utf-8")).toContain("new-a");
-      expect(await fs.readFile(file2, "utf-8")).toContain("new-b");
-    });
-
-    it("handles unified diffs with no-newline markers", async () => {
-      const filePath = path.join(tempDir, "noeol.txt");
-      await fs.writeFile(filePath, "old", "utf-8");
-
-      const patch = [
-        "--- a/noeol.txt",
-        "+++ b/noeol.txt",
-        "@@ -1 +1 @@",
-        "-old",
-        "\",
-        "+new",
-        "\",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(await fs.readFile(filePath, "utf-8")).toBe("new");
-    });
-
-    it("creates a new file (--- /dev/null)", async () => {
-      const patch = [
-        "--- /dev/null",
-        "+++ b/newfile.txt",
-        "@@ -0,0 +1,2 @@",
-        "+Hello new file",
-        "+Second line",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { created: number };
-      expect(data.created).toBe(1);
-
-      const content = await fs.readFile(path.join(tempDir, "newfile.txt"), "utf-8");
-      expect(content).toContain("Hello new file");
-      expect(content).toContain("Second line");
-    });
-
-    it("deletes a file (+++ /dev/null)", async () => {
-      const filePath = path.join(tempDir, "doomed.txt");
-      await fs.writeFile(filePath, "goodbye\n");
-
-      const patch = ["--- a/doomed.txt", "+++ /dev/null", "@@ -1,1 +0,0 @@", "-goodbye"].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { deleted: number };
-      expect(data.deleted).toBe(1);
-
-      await expect(fs.stat(filePath)).rejects.toThrow();
-    });
-
-    it("applies Claude-style *** Begin Patch format", async () => {
-      const filePath = path.join(tempDir, "begin-format.txt");
-      await fs.writeFile(filePath, "alpha\nbeta\ngamma\n");
-
-      const patch = [
-        "*** Begin Patch",
-        "*** Update File: begin-format.txt",
-        "@@",
-        " alpha",
-        "-beta",
-        "+BETA",
-        " gamma",
-        "*** End Patch",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-      expect(result.success).toBe(true);
-
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toContain("BETA");
-      expect(content).not.toContain("beta");
-    });
-
-    it("supports move/rename in *** Begin Patch format", async () => {
-      const source = path.join(tempDir, "src.txt");
-      const target = path.join(tempDir, "dst.txt");
-      await fs.writeFile(source, "one\ntwo\n");
-
-      const patch = [
-        "*** Begin Patch",
-        "*** Update File: src.txt",
-        "*** Move to: dst.txt",
-        "@@",
-        " one",
-        "-two",
-        "+TWO",
-        "*** End Patch",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-      expect(result.success).toBe(true);
-
-      await expect(fs.stat(source)).rejects.toThrow();
-      const moved = await fs.readFile(target, "utf-8");
-      expect(moved).toContain("TWO");
-    });
-  });
-
-  describe("security (path traversal)", () => {
-    it("rejects path traversal with ../", async () => {
-      const patch = [
-        "--- a/../escape/bad.txt",
-        "+++ b/../escape/bad.txt",
-        "@@ -1 +1 @@",
-        "-old",
-        "+new",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("traversal");
-    });
-
-    it("rejects absolute path /etc/passwd", async () => {
-      const patch = [
-        "--- a//etc/passwd",
-        "+++ b//etc/passwd",
-        "@@ -1 +1 @@",
-        "-root:x:0:0",
-        "+hacked",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      // Will be caught either as absolute path or system path
-      expect(result.message).toMatch(/Absolute path|System path|traversal/i);
-    });
-
-    it("rejects system path /dev/shm/test", async () => {
-      const patch = ["--- /dev/null", "+++ b//dev/shm/test", "@@ -0,0 +1 @@", "+bad"].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      // Either absolute or system path rejection
-      expect(result.message).toMatch(/Absolute path|System path/i);
-    });
-
-    it("rejects paths with .. after resolution", async () => {
-      const patch = [
-        "--- a/subdir/../../escape.txt",
-        "+++ b/subdir/../../escape.txt",
-        "@@ -1 +1 @@",
-        "-old",
-        "+new",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("..");
-    });
-  });
-
-  describe("error handling", () => {
-    it("returns error for context mismatch (wrong context lines)", async () => {
-      const filePath = path.join(tempDir, "mismatch.txt");
-      await fs.writeFile(filePath, "actual line 1\nactual line 2\n");
-
-      const patch = [
-        "--- a/mismatch.txt",
-        "+++ b/mismatch.txt",
-        "@@ -1,2 +1,2 @@",
-        " wrong context line",
-        "-actual line 2",
-        "+replaced line",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Hunk");
-      expect(result.message).toContain("failed");
-    });
-
-    it("rejects binary diffs", async () => {
-      const patch = ["Binary files a/image.png and b/image.png differ"].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Binary");
-    });
-
-    it("returns error for empty patch", async () => {
-      const result = await executeApplyPatch({ patch: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("empty");
-    });
-
-    it("returns error for whitespace-only patch", async () => {
-      const result = await executeApplyPatch({ patch: "   \n  \n  " }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("empty");
-    });
-
-    it("returns error for patch with no valid diffs", async () => {
-      const patch = ["This is not a valid patch", "Just some random text"].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("No file diffs");
-    });
-
-    it("returns error for malformed hunk line counts", async () => {
-      const filePath = path.join(tempDir, "bad-counts.txt");
-      await fs.writeFile(filePath, "a\nb\n");
-
-      const patch = [
-        "--- a/bad-counts.txt",
-        "+++ b/bad-counts.txt",
-        "@@ -1,2 +1,2 @@",
-        " a",
-        "-b",
-        "+B",
-        "+C",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Malformed hunk");
-    });
-
-    it("does not leave partial writes when delete source is missing", async () => {
-      const targetPath = path.join(tempDir, "keep.txt");
-      await fs.writeFile(targetPath, "hello\n");
-
-      const patch = [
-        "diff --git a/keep.txt b/keep.txt",
-        "--- a/keep.txt",
-        "+++ b/keep.txt",
-        "@@ -1 +1 @@",
-        "-hello",
-        "+HELLO",
-        "diff --git a/missing.txt b/missing.txt",
-        "--- a/missing.txt",
-        "+++ /dev/null",
-        "@@ -1 +0,0 @@",
-        "-gone",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Cannot delete missing path");
-      expect(await fs.readFile(targetPath, "utf-8")).toBe("hello\n");
-    });
-  });
-
-  describe("security — review fixes (aria-8kp.4)", () => {
-    it("rejects patch targeting symlink that escapes working directory", async () => {
-      // Create a directory outside tempDir
-      const outsideDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-patch-outside-"));
-      const outsideFile = path.join(outsideDir, "secret.txt");
-      await fs.writeFile(outsideFile, "secret content\n");
-
-      // Create a symlink inside tempDir pointing to outsideDir
-      const symlinkPath = path.join(tempDir, "sneaky");
-      await fs.symlink(outsideDir, symlinkPath);
-
-      const patch = [
-        "--- a/sneaky/secret.txt",
-        "+++ b/sneaky/secret.txt",
-        "@@ -1 +1 @@",
-        "-secret content",
-        "+pwned",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("escapes working directory");
-
-      // Verify original file is untouched
-      const content = await fs.readFile(outsideFile, "utf-8");
-      expect(content).toBe("secret content\n");
-
-      // Cleanup
-      await fs.rm(outsideDir, { recursive: true, force: true });
-    });
-
-    it("rejects patch with nested .. path components", async () => {
-      const patch = [
-        "--- a/../../etc/passwd",
-        "+++ b/../../etc/passwd",
-        "@@ -1 +1 @@",
-        "-root:x:0:0",
-        "+pwned:x:0:0",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("traversal");
-    });
-
-    it("rejects Windows-style absolute paths", async () => {
-      const patch = [
-        "--- a/C:\\Windows\\System32\\config",
-        "+++ b/C:\\Windows\\System32\\config",
-        "@@ -1 +1 @@",
-        "-original",
-        "+pwned",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Absolute path not allowed");
-    });
-
-    it("handles CRLF line endings correctly", async () => {
-      // Create file with CRLF endings
-      const filePath = path.join(tempDir, "crlf.txt");
-      await fs.writeFile(filePath, "Line1\r\nLine2\r\nLine3\r\n");
-
-      const patch = [
-        "--- a/crlf.txt",
-        "+++ b/crlf.txt",
-        "@@ -1,3 +1,3 @@",
-        " Line1",
-        "-Line2",
-        "+Modified",
-        " Line3",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch }, ctx);
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toContain("Modified");
-      expect(content).not.toContain("Line2");
-    });
-
-    it("rejects cwd that escapes the working directory", async () => {
-      const patch = ["--- a/hello.txt", "+++ b/hello.txt", "@@ -1 +1 @@", "-old", "+new"].join(
-        "\n",
-      );
-
-      const result = await executeApplyPatch({ patch, cwd: "/tmp" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("cwd must be within the working directory");
-    });
-
-    it("rejects cwd with .. that escapes working directory", async () => {
-      const patch = ["--- a/hello.txt", "+++ b/hello.txt", "@@ -1 +1 @@", "-old", "+new"].join(
-        "\n",
-      );
-
-      const result = await executeApplyPatch({ patch, cwd: "../../../tmp" }, ctx);
-
-      expect(result.success).toBe(false);
-      // The resolved path may not exist (triggering "does not exist") or may resolve
-      // outside the working directory (triggering "cwd must be within"). Both correctly
-      // reject the traversal attempt.
-      expect(result.message).toMatch(/cwd must be within the working directory|does not exist/);
-    });
-
-    it("accepts cwd that is a subdirectory of working directory", async () => {
-      const subDir = path.join(tempDir, "subdir");
-      await fs.mkdir(subDir, { recursive: true });
-      const filePath = path.join(subDir, "test.txt");
-      await fs.writeFile(filePath, "original\n");
-
-      const patch = [
-        "--- a/test.txt",
-        "+++ b/test.txt",
-        "@@ -1 +1 @@",
-        "-original",
-        "+modified",
-      ].join("\n");
-
-      const result = await executeApplyPatch({ patch, cwd: "subdir" }, ctx);
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toContain("modified");
-    });
-
-    it("rejects patch exceeding 1MB size limit", async () => {
-      const largePatch =
-        "--- a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+" + "x".repeat(1_100_000);
-
-      const result = await executeApplyPatch({ patch: largePatch }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Patch too large");
-    });
-  });
-});