opencode-swarm-plugin 0.32.0 → 0.34.0

package/src/swarm-research.test.ts

@@ -0,0 +1,698 @@
+/**
+ * Tests for swarm-research module
+ *
+ * TDD approach:
+ * 1. RED - Write failing tests first
+ * 2. GREEN - Implement minimal code to pass
+ * 3. REFACTOR - Clean up
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+import { discoverDocTools } from "./swarm-research";
+import { resetToolCache } from "./tool-availability";
+
+describe("discoverDocTools", () => {
+  beforeEach(() => {
+    // Reset cache for fresh checks
+    resetToolCache();
+  });
+
+  test("returns structured tool list", async () => {
+    const tools = await discoverDocTools();
+
+    expect(Array.isArray(tools)).toBe(true);
+    expect(tools.length).toBeGreaterThan(0);
+
+    // Check structure of each tool
+    for (const tool of tools) {
+      expect(tool).toHaveProperty("name");
+      expect(tool).toHaveProperty("type");
+      expect(tool).toHaveProperty("capabilities");
+      expect(tool).toHaveProperty("available");
+      expect(typeof tool.name).toBe("string");
+      expect(["skill", "mcp", "cli"].includes(tool.type)).toBe(true);
+      expect(Array.isArray(tool.capabilities)).toBe(true);
+      expect(typeof tool.available).toBe("boolean");
+    }
+  });
+
+  test("discovers skills", async () => {
+    const tools = await discoverDocTools();
+    const skillTools = tools.filter((t) => t.type === "skill");
+
+    // Skills should be discoverable via skills_list
+    expect(skillTools.length).toBeGreaterThanOrEqual(0);
+  });
+
+  test("marks tools as available or unavailable", async () => {
+    const tools = await discoverDocTools();
+
+    // Every tool should have a clear availability status
+    for (const tool of tools) {
+      expect(typeof tool.available).toBe("boolean");
+    }
+  });
+
+  test("includes expected documentation tools", async () => {
+    const tools = await discoverDocTools();
+    const toolNames = tools.map((t) => t.name);
+
+    // Should include known doc-fetching capabilities
+    // Note: We don't assert these are available, just that we check for them
+    const expectedTools = [
+      "next-devtools",
+      "context7",
+      "fetch",
+      "pdf-brain",
+      "semantic-memory",
+    ];
+
+    for (const expected of expectedTools) {
+      expect(toolNames).toContain(expected);
+    }
+  });
+
+  test("returns capabilities for each tool", async () => {
+    const tools = await discoverDocTools();
+
+    for (const tool of tools) {
+      expect(Array.isArray(tool.capabilities)).toBe(true);
+      expect(tool.capabilities.length).toBeGreaterThan(0);
+
+      // Capabilities should be strings
+      for (const cap of tool.capabilities) {
+        expect(typeof cap).toBe("string");
+      }
+    }
+  });
+
+  test("handles missing tools gracefully", async () => {
+    // discoverDocTools should never throw even if tools are missing
+    await expect(discoverDocTools()).resolves.toBeDefined();
+  });
+
+  test("differentiates tool types correctly", async () => {
+    const tools = await discoverDocTools();
+
+    // Skills have 'skill' type
+    const skills = tools.filter((t) => t.type === "skill");
+    for (const skill of skills) {
+      expect(skill.type).toBe("skill");
+    }
+
+    // MCP tools have 'mcp' type
+    const mcpTools = tools.filter((t) => t.type === "mcp");
+    for (const mcp of mcpTools) {
+      expect(mcp.type).toBe("mcp");
+    }
+
+    // CLI tools have 'cli' type
+    const cliTools = tools.filter((t) => t.type === "cli");
+    for (const cli of cliTools) {
+      expect(cli.type).toBe("cli");
+    }
+  });
+
+  test("assigns correct capabilities to known tools", async () => {
+    const tools = await discoverDocTools();
+    const toolMap = new Map(tools.map((t) => [t.name, t]));
+
+    // next-devtools should have Next.js-specific capabilities
+    const nextDevtools = toolMap.get("next-devtools");
+    if (nextDevtools) {
+      expect(nextDevtools.capabilities).toContain("nextjs-docs");
+    }
+
+    // fetch should have general web capabilities
+    const fetchTool = toolMap.get("fetch");
+    if (fetchTool) {
+      expect(fetchTool.capabilities).toContain("http-fetch");
+    }
+
+    // semantic-memory should have storage capabilities
+    const semMem = toolMap.get("semantic-memory");
+    if (semMem) {
+      expect(semMem.capabilities).toContain("storage");
+    }
+  });
+
+  test("marks semantic-memory availability based on ollama", async () => {
+    const tools = await discoverDocTools();
+    const semMem = tools.find((t) => t.name === "semantic-memory");
+
+    expect(semMem).toBeDefined();
+    // Availability depends on runtime env - just check it's defined
+    expect(typeof semMem?.available).toBe("boolean");
+  });
+});
+
+// =============================================================================
+// Version Detection from Lockfiles (TDD Phase 1: RED)
+// =============================================================================
+
+import { getInstalledVersions, type VersionInfo } from "./swarm-research";
+import { mkdir, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+
+describe("getInstalledVersions", () => {
+  const testDir = "/tmp/swarm-research-lockfile-tests";
+
+  beforeEach(async () => {
+    // Clean slate for each test
+    await rm(testDir, { recursive: true, force: true });
+    await mkdir(testDir, { recursive: true });
+  });
+
+  test("parses npm package-lock.json", async () => {
+    // Create fixture
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            "zod": "^3.22.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "3.22.4",
+          resolved: "https://registry.npmjs.org/zod/-/zod-3.22.4.tgz",
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, ["zod"]);
+
+    expect(versions).toHaveLength(1);
+    expect(versions[0]).toEqual({
+      name: "zod",
+      version: "3.22.4",
+      source: "lockfile",
+    });
+  });
+
+  test("parses pnpm pnpm-lock.yaml", async () => {
+    const lockfile = `lockfileVersion: '6.0'
+
+dependencies:
+  zod:
+    specifier: ^3.22.0
+    version: 3.22.4
+
+packages:
+  /zod@3.22.4:
+    resolution: {integrity: sha512-example}
+    dev: false
+`;
+
+    await writeFile(join(testDir, "pnpm-lock.yaml"), lockfile);
+
+    const versions = await getInstalledVersions(testDir, ["zod"]);
+
+    expect(versions).toHaveLength(1);
+    expect(versions[0]).toEqual({
+      name: "zod",
+      version: "3.22.4",
+      source: "lockfile",
+    });
+  });
+
+  test("parses yarn yarn.lock", async () => {
+    const lockfile = `# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+zod@^3.22.0:
+  version "3.22.4"
+  resolved "https://registry.yarnpkg.com/zod/-/zod-3.22.4.tgz"
+  integrity sha512-example"
+`;
+
+    await writeFile(join(testDir, "yarn.lock"), lockfile);
+
+    const versions = await getInstalledVersions(testDir, ["zod"]);
+
+    expect(versions).toHaveLength(1);
+    expect(versions[0]).toEqual({
+      name: "zod",
+      version: "3.22.4",
+      source: "lockfile",
+    });
+  });
+
+  test("falls back to package.json when no lockfile present", async () => {
+    const packageJson = {
+      name: "test-project",
+      dependencies: {
+        zod: "^3.22.4",
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package.json"),
+      JSON.stringify(packageJson, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, ["zod"]);
+
+    expect(versions).toHaveLength(1);
+    expect(versions[0]).toEqual({
+      name: "zod",
+      version: "3.22.4", // Stripped semver constraint
+      source: "package.json",
+      constraint: "^3.22.4", // Original constraint preserved
+    });
+  });
+
+  test("handles missing packages gracefully", async () => {
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            zod: "^3.22.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "3.22.4",
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, [
+      "zod",
+      "nonexistent-package",
+    ]);
+
+    expect(versions).toHaveLength(1); // Only zod found
+    expect(versions[0].name).toBe("zod");
+  });
+
+  test("handles multiple packages", async () => {
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            zod: "^3.22.0",
+            typescript: "^5.3.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "3.22.4",
+        },
+        "node_modules/typescript": {
+          version: "5.3.3",
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, [
+      "zod",
+      "typescript",
+    ]);
+
+    expect(versions).toHaveLength(2);
+    expect(versions.find((v) => v.name === "zod")?.version).toBe("3.22.4");
+    expect(versions.find((v) => v.name === "typescript")?.version).toBe(
+      "5.3.3",
+    );
+  });
+
+  test("prefers lockfile over package.json when both exist", async () => {
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            zod: "^3.22.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "3.22.4",
+        },
+      },
+    };
+
+    const packageJson = {
+      name: "test-project",
+      dependencies: {
+        zod: "^3.99.99", // Different version range
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+    await writeFile(
+      join(testDir, "package.json"),
+      JSON.stringify(packageJson, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, ["zod"]);
+
+    expect(versions[0].version).toBe("3.22.4"); // From lockfile, not package.json
+    expect(versions[0].source).toBe("lockfile");
+  });
+
+  test("handles bun.lock by falling back to package.json", async () => {
+    // bun.lock is binary format, fallback to package.json
+    const packageJson = {
+      name: "test-project",
+      dependencies: {
+        zod: "^3.22.4",
+      },
+    };
+
+    await writeFile(join(testDir, "bun.lock"), "binary data here");
+    await writeFile(
+      join(testDir, "package.json"),
+      JSON.stringify(packageJson, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, ["zod"]);
+
+    expect(versions).toHaveLength(1);
+    expect(versions[0]).toEqual({
+      name: "zod",
+      version: "3.22.4",
+      source: "package.json",
+      constraint: "^3.22.4",
+    });
+  });
+
+  test("returns empty array when no package info found", async () => {
+    // No lockfile, no package.json
+    const versions = await getInstalledVersions(testDir, ["zod"]);
+
+    expect(versions).toEqual([]);
+  });
+
+  test("plugin tool swarm_get_versions works", async () => {
+    // Create fixture
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            zod: "^3.22.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "3.22.4",
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    const { swarm_get_versions } = await import("./swarm-research");
+
+    const result = await swarm_get_versions.execute({
+      projectPath: testDir,
+      packages: ["zod", "nonexistent"],
+    });
+
+    const parsed = JSON.parse(result);
+
+    expect(parsed.versions).toHaveLength(1);
+    expect(parsed.versions[0].name).toBe("zod");
+    expect(parsed.versions[0].version).toBe("3.22.4");
+    expect(parsed.summary.found).toBe(1);
+    expect(parsed.summary.requested).toBe(2);
+    expect(parsed.summary.missing).toEqual(["nonexistent"]);
+  });
+
+  test("strips semver constraints from package.json versions", async () => {
+    const packageJson = {
+      name: "test-project",
+      dependencies: {
+        exact: "3.22.4",
+        caret: "^3.22.4",
+        tilde: "~3.22.4",
+        range: ">=3.22.0 <4.0.0",
+        latest: "latest",
+        url: "git+https://github.com/example/repo.git",
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package.json"),
+      JSON.stringify(packageJson, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, [
+      "exact",
+      "caret",
+      "tilde",
+      "range",
+      "latest",
+      "url",
+    ]);
+
+    expect(versions.find((v) => v.name === "exact")?.version).toBe("3.22.4");
+    expect(versions.find((v) => v.name === "caret")?.version).toBe("3.22.4");
+    expect(versions.find((v) => v.name === "tilde")?.version).toBe("3.22.4");
+    expect(versions.find((v) => v.name === "range")?.version).toBe("3.22.0"); // Extracts first version from range
+    expect(versions.find((v) => v.name === "latest")).toBeUndefined(); // Not a version
+    expect(versions.find((v) => v.name === "url")).toBeUndefined(); // URLs not supported
+  });
+});
+
+// =============================================================================
+// Latest Version Fetching (TDD Phase 2: Check Upgrades)
+// =============================================================================
+
+import { getLatestVersion } from "./swarm-research";
+
+describe("getLatestVersion", () => {
+  test("fetches latest version from npm registry", async () => {
+    // Test with a stable package (zod)
+    const version = await getLatestVersion("zod");
+    
+    expect(version).toBeDefined();
+    expect(typeof version).toBe("string");
+    // Should be a valid semver
+    expect(version).toMatch(/^\d+\.\d+\.\d+/);
+  });
+
+  test("handles package not found gracefully", async () => {
+    const version = await getLatestVersion("this-package-definitely-does-not-exist-12345");
+    
+    expect(version).toBeUndefined();
+  });
+
+  test("handles network errors gracefully", async () => {
+    // Mock a network failure scenario - package with invalid name
+    const version = await getLatestVersion("@invalid/package/name");
+    
+    expect(version).toBeUndefined();
+  });
+
+  test("handles scoped packages", async () => {
+    // Test with a real scoped package
+    const version = await getLatestVersion("@types/node");
+    
+    expect(version).toBeDefined();
+    expect(typeof version).toBe("string");
+    expect(version).toMatch(/^\d+\.\d+\.\d+/);
+  });
+});
+
+describe("getInstalledVersions with checkUpgrades", () => {
+  const testDir = "/tmp/swarm-research-upgrades-tests";
+
+  beforeEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+    await mkdir(testDir, { recursive: true });
+  });
+
+  test("includes latest version when checkUpgrades=true", async () => {
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            "zod": "^3.0.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "3.0.0",
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, ["zod"], true);
+
+    expect(versions).toHaveLength(1);
+    expect(versions[0].name).toBe("zod");
+    expect(versions[0].version).toBe("3.0.0");
+    expect(versions[0].latest).toBeDefined();
+    expect(typeof versions[0].latest).toBe("string");
+    expect(versions[0].latest).toMatch(/^\d+\.\d+\.\d+/);
+    expect(versions[0].updateAvailable).toBe(true); // 3.0.0 is old, update should be available
+  });
+
+  test("does not include latest when checkUpgrades=false (default)", async () => {
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            "zod": "^3.22.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "3.22.4",
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, ["zod"], false);
+
+    expect(versions).toHaveLength(1);
+    expect(versions[0].latest).toBeUndefined();
+    expect(versions[0].updateAvailable).toBeUndefined();
+  });
+
+  test("sets updateAvailable=false when installed equals latest", async () => {
+    // This test will fetch actual latest - may be flaky if package updates
+    // But demonstrates the logic
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            "zod": "^3.22.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "999.999.999", // Fake version higher than any real one
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    const versions = await getInstalledVersions(testDir, ["zod"], true);
+
+    expect(versions[0].latest).toBeDefined();
+    // Can't assert exact equality without knowing npm state
+    // But structure should be correct
+    expect(typeof versions[0].updateAvailable).toBe("boolean");
+  });
+
+  test("handles network failures gracefully during upgrade check", async () => {
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            "nonexistent-package-xyz": "^1.0.0",
+          },
+        },
+        "node_modules/nonexistent-package-xyz": {
+          version: "1.0.0",
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    // Should not throw, should return data without latest
+    const versions = await getInstalledVersions(testDir, ["nonexistent-package-xyz"], true);
+
+    expect(versions).toHaveLength(1);
+    expect(versions[0].version).toBe("1.0.0");
+    // latest should be undefined if fetch failed
+    expect(versions[0].latest).toBeUndefined();
+    expect(versions[0].updateAvailable).toBeUndefined();
+  });
+
+  test("swarm_get_versions respects checkUpgrades parameter", async () => {
+    const lockfile = {
+      name: "test-project",
+      lockfileVersion: 3,
+      packages: {
+        "": {
+          name: "test-project",
+          dependencies: {
+            "zod": "^3.0.0",
+          },
+        },
+        "node_modules/zod": {
+          version: "3.0.0",
+        },
+      },
+    };
+
+    await writeFile(
+      join(testDir, "package-lock.json"),
+      JSON.stringify(lockfile, null, 2),
+    );
+
+    const { swarm_get_versions } = await import("./swarm-research");
+
+    const result = await swarm_get_versions.execute({
+      projectPath: testDir,
+      packages: ["zod"],
+      checkUpgrades: true,
+    });
+
+    const parsed = JSON.parse(result);
+
+    expect(parsed.versions[0].latest).toBeDefined();
+    expect(parsed.versions[0].updateAvailable).toBe(true);
+  });
+});