@aria-cli/tools 1.0.9 → 1.0.11

package/tests/executors/search-unified.test.ts

@@ -1,381 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { promises as fs } from "node:fs";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { SearchProviderRouter } from "../../src/providers/index.js";
-import { CORE_TOOL_DEFINITIONS } from "../../src/definitions/core.js";
-import {
-  executeSearchKnowledge,
-  searchLocalSkills,
-  searchSkillRegistries,
-  searchWeb,
-  settleWithDeadline,
-} from "../../src/executors/learning-meta.js";
-import { dedupSearchResults, type SearchResult } from "../../src/executors/search-types.js";
-
-const originalSkillDirs = process.env.ARIA_SKILL_DIRS;
-
-async function createSkillFile(dir: string, name: string, description: string): Promise<void> {
-  const skillDir = path.join(dir, name);
-  await fs.mkdir(skillDir, { recursive: true });
-  await fs.writeFile(
-    path.join(skillDir, "SKILL.md"),
-    `---\nname: ${name}\ndescription: ${description}\n---\n${description}\n`,
-    "utf-8",
-  );
-}
-
-describe("unified search contracts", () => {
-  afterEach(() => {
-    if (originalSkillDirs === undefined) {
-      delete process.env.ARIA_SKILL_DIRS;
-    } else {
-      process.env.ARIA_SKILL_DIRS = originalSkillDirs;
-    }
-    vi.restoreAllMocks();
-  });
-
-  it("dedupSearchResults normalizes names case-insensitively", () => {
-    const out = dedupSearchResults(
-      [
-        {
-          kind: "tool",
-          name: "Grep",
-          description: "fallback",
-          source: "web",
-          runnable: false,
-          action: "install",
-        },
-        {
-          kind: "tool",
-          name: "grep",
-          description: "builtin",
-          source: "builtin",
-          runnable: true,
-          action: "call",
-        },
-      ],
-      10,
-    );
-
-    expect(out).toHaveLength(1);
-    expect(out[0]?.source).toBe("builtin");
-  });
-
-  it("dedupSearchResults prioritizes higher-value sources before applying global limit", () => {
-    const out = dedupSearchResults(
-      [
-        {
-          kind: "skill",
-          name: "alpha",
-          description: "local only",
-          source: "local",
-          runnable: true,
-          action: "read_skill",
-        },
-        {
-          kind: "skill",
-          name: "beta",
-          description: "local only",
-          source: "local",
-          runnable: true,
-          action: "read_skill",
-        },
-        {
-          kind: "tool",
-          name: "builtin-tool",
-          description: "deferred builtin",
-          source: "builtin",
-          runnable: true,
-          action: "call",
-        },
-      ],
-      2,
-    );
-
-    expect(out).toHaveLength(2);
-    expect(out[0]?.source).toBe("builtin");
-    expect(out.some((item) => item.name === "builtin-tool")).toBe(true);
-  });
-
-  it("base search tool metadata remains read-only in @aria/tools", () => {
-    const searchTool = CORE_TOOL_DEFINITIONS.find((tool) => tool.name === "search");
-    expect(searchTool).toBeDefined();
-    expect(searchTool!.riskLevel).toBe("safe");
-    expect(searchTool!.isReadOnly).toBe(true);
-    expect(searchTool!.skipApprovalForInput).toBeUndefined();
-    const props = (searchTool!.parameters as { properties?: Record<string, unknown> }).properties;
-    expect(props?.adopt).toBeUndefined();
-  });
-
-  it("executeSearchKnowledge returns explicit error when memoria source is unavailable", async () => {
-    const result = await executeSearchKnowledge(
-      { query: "anything", sources: ["memoria"] },
-      { workingDir: process.cwd(), env: {} },
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.message).toMatch(/Memoria not available/i);
-  });
-
-  it("searchLocalSkills enforces per-source limit", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-search-local-"));
-    try {
-      process.env.ARIA_SKILL_DIRS = tempDir;
-      const marker = "unique-limit-marker-9af";
-
-      await createSkillFile(tempDir, "alpha", marker);
-      await createSkillFile(tempDir, "beta", marker);
-      await createSkillFile(tempDir, "gamma", marker);
-
-      const results = await searchLocalSkills(marker, tempDir, 1);
-      expect(results).toHaveLength(1);
-      expect(results[0]?.source).toBe("local");
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it("executeSearchKnowledge honors ctx.env ARIA_SKILL_DIRS overrides", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-search-ctx-env-"));
-    const priorEnv = process.env.ARIA_SKILL_DIRS;
-    try {
-      delete process.env.ARIA_SKILL_DIRS;
-      const marker = "ctx-env-marker-c4f";
-      await createSkillFile(tempDir, "ctx-env-skill", marker);
-
-      const result = await executeSearchKnowledge(
-        { query: marker, sources: ["local"], limit: 5 },
-        { workingDir: process.cwd(), env: { ARIA_SKILL_DIRS: tempDir } },
-      );
-
-      expect(result.success).toBe(true);
-      const data = result.data as { results: Array<{ source: string; name: string }> };
-      expect(data.results.length).toBeGreaterThan(0);
-      expect(data.results).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({ source: "local", name: "ctx-env-skill" }),
-        ]),
-      );
-    } finally {
-      if (priorEnv === undefined) {
-        delete process.env.ARIA_SKILL_DIRS;
-      } else {
-        process.env.ARIA_SKILL_DIRS = priorEnv;
-      }
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it("searchLocalSkills discovers SKILL.md at workspace root", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-search-root-skill-"));
-    const marker = "unique-root-skill-marker-0f3d2e0a";
-    const rootSkillPath = path.join(tempDir, "SKILL.md");
-    try {
-      await fs.writeFile(
-        rootSkillPath,
-        `---\nname: workspace-root\ndescription: ${marker}\n---\n${marker}\n`,
-        "utf-8",
-      );
-
-      const results = await searchLocalSkills(marker, tempDir, 10);
-      expect(results).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            source: "local",
-            path: rootSkillPath,
-            name: "workspace-root",
-          }),
-        ]),
-      );
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it("searchLocalSkills invalidates cache when new skills are added", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-search-cache-invalidate-"));
-    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), "aria-search-home-"));
-    const marker = "unique-cache-invalidate-marker-6ce7b0";
-    const expectedPath = path.join(tempDir, "new-skill", "SKILL.md");
-    try {
-      vi.spyOn(os, "homedir").mockReturnValue(fakeHome);
-      process.env.ARIA_SKILL_DIRS = tempDir;
-
-      const first = await searchLocalSkills(marker, tempDir, 10);
-      expect(first).toEqual([]);
-
-      await createSkillFile(tempDir, "new-skill", marker);
-      const second = await searchLocalSkills(marker, tempDir, 10);
-
-      expect(second).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({ name: "new-skill", source: "local", path: expectedPath }),
-        ]),
-      );
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-      await fs.rm(fakeHome, { recursive: true, force: true });
-    }
-  });
-
-  it("searchLocalSkills uses cache between repeated calls", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-search-cache-"));
-    const readdirSpy = vi.spyOn(fs, "readdir");
-    try {
-      process.env.ARIA_SKILL_DIRS = tempDir;
-      const marker = "unique-cache-marker-3as";
-      await createSkillFile(tempDir, "cached", marker);
-
-      const first = await searchLocalSkills(marker, tempDir, 10);
-      const readdirCountAfterFirst = readdirSpy.mock.calls.length;
-      const second = await searchLocalSkills(marker, tempDir, 10);
-      const readdirCountAfterSecond = readdirSpy.mock.calls.length;
-
-      expect(first.length).toBeGreaterThan(0);
-      expect(second.length).toBeGreaterThan(0);
-      expect(readdirCountAfterSecond).toBe(readdirCountAfterFirst);
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it("searchWeb includes npm install suggestions", async () => {
-    vi.spyOn(SearchProviderRouter.prototype, "search").mockResolvedValue([]);
-    vi.spyOn(globalThis, "fetch").mockImplementation(async (url: string | URL | Request) => {
-      const href = typeof url === "string" ? url : url instanceof URL ? url.toString() : url.url;
-      if (!href.includes("registry.npmjs.org/-/v1/search")) {
-        return {
-          ok: false,
-          json: async () => ({}),
-        } as Response;
-      }
-      return {
-        ok: true,
-        json: async () => ({
-          objects: [
-            {
-              package: {
-                name: "eslint",
-                description: "An AST-based linting utility",
-                version: "9.0.0",
-              },
-            },
-          ],
-        }),
-      } as Response;
-    });
-
-    const results = await searchWeb("eslint", 5, { os: "linux", arch: "x64" });
-    expect(results).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          source: "npm",
-          name: "eslint",
-          action: "install",
-          installCmd: "npm install -g eslint",
-        }),
-      ]),
-    );
-  });
-
-  it("searchWeb forwards caller abort signal to provider router", async () => {
-    const callerController = new AbortController();
-    const routerSpy = vi.spyOn(SearchProviderRouter.prototype, "search").mockResolvedValue([]);
-    vi.spyOn(globalThis, "fetch").mockResolvedValue({
-      ok: true,
-      json: async () => ({ objects: [] }),
-    } as Response);
-
-    await searchWeb("eslint", 5, { os: "linux", arch: "x64" }, callerController.signal);
-
-    expect(routerSpy).toHaveBeenCalledWith(
-      expect.stringContaining("eslint"),
-      expect.objectContaining({
-        limit: 5,
-        signal: callerController.signal,
-      }),
-    );
-  });
-
-  it("searchSkillRegistries marks registry hits as install-only non-runnable results", async () => {
-    vi.spyOn(globalThis, "fetch").mockImplementation(async (url: string | URL | Request) => {
-      const href = typeof url === "string" ? url : url instanceof URL ? url.toString() : url.url;
-
-      if (href.includes("skills.sh/api/search")) {
-        return {
-          ok: true,
-          json: async () => ({
-            skills: [
-              {
-                id: "skill-1",
-                name: "fmt-skill",
-                source: "skills.sh",
-                installs: 42,
-              },
-            ],
-          }),
-        } as Response;
-      }
-
-      if (href.includes("clawhub.ai/api/search")) {
-        return {
-          ok: true,
-          json: async () => ({
-            results: [
-              {
-                slug: "claw-fmt",
-                displayName: "Claw Fmt",
-                summary: "formatter skill",
-                version: "1.0.0",
-              },
-            ],
-          }),
-        } as Response;
-      }
-
-      return {
-        ok: false,
-        json: async () => ({}),
-      } as Response;
-    });
-
-    const results = await searchSkillRegistries("fmt", 10);
-
-    expect(results).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          source: "skills.sh",
-          action: "install",
-          runnable: false,
-        }),
-        expect.objectContaining({
-          source: "clawhub",
-          action: "install",
-          runnable: false,
-        }),
-      ]),
-    );
-  });
-
-  it("settleWithDeadline aborts pending tasks at deadline", async () => {
-    let aborted = false;
-    const neverSettlesTask = (signal: AbortSignal) =>
-      new Promise<SearchResult[]>((_resolve, reject) => {
-        signal.addEventListener(
-          "abort",
-          () => {
-            aborted = true;
-            reject(new Error("aborted"));
-          },
-          { once: true },
-        );
-      });
-
-    const out = await settleWithDeadline([neverSettlesTask], 5);
-
-    expect(out.timedOut).toBe(1);
-    expect(out.settled).toHaveLength(0);
-    expect(aborted).toBe(true);
-  });
-});