@pi-harness/pi-harness 0.1.13 → 0.1.15

package/packages/core/test/dependency-checker.test.ts

@@ -1,60 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, test } from "vitest";
-import { inspectManifest, parseRequirements } from "../src/plugins/dependency-checker.js";
-
-const temporaryDirectories: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
-});
-
-describe("dependency checker", () => {
-  test("parses Python requirements, detects conflicts, and checks a local virtualenv", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-dependency-checker-"));
-    temporaryDirectories.push(root);
-    await writeFile(join(root, "requirements.txt"), "requests==2.31.0\nrequests>=2.32\nflask>=3.0\n# comment\n-r base.txt\n");
-    await mkdir(join(root, ".venv/lib/python3.12/site-packages/requests"), { recursive: true });
-
-    expect(parseRequirements("requests==2.31.0\nrequests>=2.32\n")).toEqual({
-      names: ["requests"],
-      constraints: [{ name: "requests", constraints: ["==2.31.0", ">=2.32"] }],
-    });
-    await expect(inspectManifest(root, "requirements.txt")).resolves.toMatchObject({
-      ecosystem: "python",
-      declared: 2,
-      installed: 1,
-      missing: ["flask"],
-      invalid: [],
-      conflicts: [{ name: "requests", constraints: ["==2.31.0", ">=2.32"] }],
-    });
-  });
-
-  test("reports conflicting npm declarations while preserving installed checks", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-dependency-checker-"));
-    temporaryDirectories.push(root);
-    await writeFile(join(root, "package.json"), JSON.stringify({ dependencies: { react: "18.3.1" }, devDependencies: { react: "19.0.0", vite: "6.0.0" } }));
-    await mkdir(join(root, "node_modules/react"), { recursive: true });
-    await mkdir(join(root, "node_modules/vite"), { recursive: true });
-    await expect(inspectManifest(root)).resolves.toMatchObject({
-      ecosystem: "npm",
-      declared: 2,
-      installed: 2,
-      missing: [],
-      conflicts: [{ name: "react", constraints: ["18.3.1", "19.0.0"] }],
-    });
-
-    await writeFile(join(root, "package.json"), JSON.stringify({ dependencies: { react: "^18.0.0" }, devDependencies: { react: ">=18" } }));
-    await expect(inspectManifest(root)).resolves.toMatchObject({ conflicts: [] });
-  });
-
-  test("checks dependencies relative to a nested package manifest", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-dependency-checker-nested-"));
-    temporaryDirectories.push(root);
-    await mkdir(join(root, "apps/example/node_modules/local-only"), { recursive: true });
-    await writeFile(join(root, "apps/example/package.json"), JSON.stringify({ dependencies: { "local-only": "1.0.0" } }));
-
-    await expect(inspectManifest(root, "apps/example/package.json")).resolves.toMatchObject({ installed: 1, missing: [] });
-  });
-});

package/packages/core/test/git-time-capsule.test.ts

@@ -1,115 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { promisify } from "node:util";
-import { Context } from "@deepseek-ai/cordis";
-import { afterEach, describe, expect, test } from "vitest";
-import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
-import { applyCapsule } from "../src/plugins/git-time-capsule.js";
-import gitTimeCapsulePlugin from "../src/plugins/git-time-capsule.js";
-
-const execFileAsync = promisify(execFile);
-const temporaryDirectories: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
-});
-
-describe("git time capsule restore", () => {
-  test("checks and applies a capsule to a real git workspace", async () => {
-    const workspace = await mkdtemp(join(tmpdir(), "pi-harness-capsule-workspace-"));
-    const capsules = await mkdtemp(join(tmpdir(), "pi-harness-capsules-"));
-    temporaryDirectories.push(workspace, capsules);
-    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: workspace });
-    await execFileAsync("git", ["config", "user.email", "test@example.invalid"], { cwd: workspace });
-    await execFileAsync("git", ["config", "user.name", "Pi Harness Test"], { cwd: workspace });
-    await writeFile(join(workspace, "note.txt"), "before\n", "utf8");
-    await execFileAsync("git", ["add", "note.txt"], { cwd: workspace });
-    await execFileAsync("git", ["commit", "-qm", "fixture"], { cwd: workspace });
-    await writeFile(join(workspace, "note.txt"), "after\n", "utf8");
-    const { stdout: patch } = await execFileAsync("git", ["diff", "--binary"], { cwd: workspace });
-    const capsule = join(capsules, "restore.patch");
-    await writeFile(capsule, patch, "utf8");
-
-    await applyCapsule(workspace, capsule);
-
-    await expect(readFile(join(workspace, "note.txt"), "utf8")).resolves.toBe("before\n");
-  });
-
-  test("rejects a capsule that does not apply cleanly", async () => {
-    const workspace = await mkdtemp(join(tmpdir(), "pi-harness-capsule-conflict-"));
-    const capsules = await mkdtemp(join(tmpdir(), "pi-harness-capsules-conflict-"));
-    temporaryDirectories.push(workspace, capsules);
-    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: workspace });
-    await writeFile(join(workspace, "note.txt"), "current\n", "utf8");
-    const capsule = join(capsules, "conflict.patch");
-    await writeFile(capsule, "diff --git a/note.txt b/note.txt\n--- a/note.txt\n+++ b/note.txt\n@@ -1 +1 @@\n-old\n+restored\n", "utf8");
-
-    await expect(applyCapsule(workspace, capsule)).rejects.toThrow("does not apply cleanly");
-    await expect(readFile(join(workspace, "note.txt"), "utf8")).resolves.toBe("current\n");
-  });
-
-  test("requires explicit confirmation through the restore tool", async () => {
-    const workspace = await mkdtemp(join(tmpdir(), "pi-harness-capsule-tool-"));
-    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-capsule-agent-"));
-    temporaryDirectories.push(workspace, agentDir);
-    const capsuleDirectory = join(agentDir, "capsules");
-    await mkdir(capsuleDirectory, { recursive: true });
-    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: workspace });
-    await execFileAsync("git", ["config", "user.email", "test@example.invalid"], { cwd: workspace });
-    await execFileAsync("git", ["config", "user.name", "Pi Harness Test"], { cwd: workspace });
-    await writeFile(join(workspace, "note.txt"), "before\n", "utf8");
-    await execFileAsync("git", ["add", "note.txt"], { cwd: workspace });
-    await execFileAsync("git", ["commit", "-qm", "fixture"], { cwd: workspace });
-    await writeFile(join(workspace, "note.txt"), "after\n", "utf8");
-    const { stdout: patch } = await execFileAsync("git", ["diff", "--binary"], { cwd: workspace });
-    await writeFile(join(capsuleDirectory, "restore.patch"), patch, "utf8");
-    const context = new Context();
-    const tools = new PiToolRegistry();
-    const panels = new PiPluginUiRegistry();
-    context.provide("piHarnessLaunch", { cwd: workspace, agentDir, args: [], requestExit() {} });
-    context.provide("piTools", tools);
-    context.provide("piPluginUi", panels);
-    try {
-      await context.plugin(gitTimeCapsulePlugin);
-      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "git_restore");
-      expect(tool).toBeDefined();
-      await expect(tool!.execute("call-1", { name: "restore.patch", confirm: false }, undefined, undefined, {} as never)).rejects.toThrow("confirm=true");
-      await expect(tool!.execute("call-2", { name: "restore.patch", confirm: true }, undefined, undefined, {} as never)).resolves.toMatchObject({
-        details: { restored: true },
-      });
-      await expect(readFile(join(workspace, "note.txt"), "utf8")).resolves.toBe("before\n");
-    } finally {
-      await context.fiber.dispose();
-    }
-  });
-
-  test("creates distinct capsules and excludes untracked files from the recoverable count", async () => {
-    const workspace = await mkdtemp(join(tmpdir(), "pi-harness-capsule-distinct-workspace-"));
-    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-capsule-distinct-agent-"));
-    temporaryDirectories.push(workspace, agentDir);
-    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: workspace });
-    await execFileAsync("git", ["config", "user.email", "test@example.invalid"], { cwd: workspace });
-    await execFileAsync("git", ["config", "user.name", "Pi Harness Test"], { cwd: workspace });
-    await writeFile(join(workspace, "tracked.txt"), "before\n", "utf8");
-    await execFileAsync("git", ["add", "tracked.txt"], { cwd: workspace });
-    await execFileAsync("git", ["commit", "-qm", "fixture"], { cwd: workspace });
-    await writeFile(join(workspace, "tracked.txt"), "after\n", "utf8");
-    await writeFile(join(workspace, "untracked.txt"), "not in the patch\n", "utf8");
-    const context = new Context();
-    const tools = new PiToolRegistry();
-    context.provide("piHarnessLaunch", { cwd: workspace, agentDir, args: [], requestExit() {} });
-    context.provide("piTools", tools);
-    context.provide("piPluginUi", new PiPluginUiRegistry());
-    try {
-      await context.plugin(gitTimeCapsulePlugin);
-      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "git_snapshot");
-      await expect(tool!.execute("call-1", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { files: 1 } });
-      await expect(tool!.execute("call-2", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { files: 1 } });
-      await expect(readdir(join(agentDir, "capsules"))).resolves.toHaveLength(2);
-    } finally {
-      await context.fiber.dispose();
-    }
-  });
-});

package/packages/core/test/http.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { configureHttpProxy } from "../src/http.js";
-
-function globalDispatcherNames(): string[] {
-  return Object.getOwnPropertySymbols(globalThis)
-    .filter((symbol) => String(symbol).includes("undici.globalDispatcher"))
-    .map((symbol) => (globalThis as unknown as Record<symbol, { constructor?: { name?: string } }>)[symbol]?.constructor?.name ?? "unknown");
-}
-
-describe("configureHttpProxy", () => {
-  test("installs Pi's proxy-aware dispatcher so provider calls honour HTTP(S)_PROXY", async () => {
-    await expect(configureHttpProxy()).resolves.toBeUndefined();
-
-    expect(globalDispatcherNames()).toContain("EnvHttpProxyAgent");
-  });
-
-  test("applies the httpProxy setting to the environment Pi's dispatcher reads", async () => {
-    const previousHttp = process.env.HTTP_PROXY;
-    const previousHttps = process.env.HTTPS_PROXY;
-    delete process.env.HTTP_PROXY;
-    delete process.env.HTTPS_PROXY;
-    const services = { settingsManager: { getGlobalSettings: () => ({ httpProxy: "http://127.0.0.1:9999" }), getHttpIdleTimeoutMs: () => 30_000 } };
-
-    try {
-      await expect(configureHttpProxy(services as never)).resolves.toBeUndefined();
-
-      expect(process.env.HTTPS_PROXY).toBe("http://127.0.0.1:9999");
-      expect(process.env.HTTP_PROXY).toBe("http://127.0.0.1:9999");
-    } finally {
-      if (previousHttp === undefined) delete process.env.HTTP_PROXY;
-      else process.env.HTTP_PROXY = previousHttp;
-      if (previousHttps === undefined) delete process.env.HTTPS_PROXY;
-      else process.env.HTTPS_PROXY = previousHttps;
-    }
-  });
-});

package/packages/core/test/llm-verifier.test.ts

@@ -1,72 +0,0 @@
-import { Context } from "@deepseek-ai/cordis";
-import { describe, expect, test } from "vitest";
-import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
-import { parseVerifierResponse, summarizeVerifierHistory } from "../src/plugins/llm-verifier.js";
-import llmVerifierPlugin from "../src/plugins/llm-verifier.js";
-
-describe("llm verifier", () => {
-  test("summarizes verdict history for audit panels", () => {
-    expect(summarizeVerifierHistory([{ verdict: "pass" }, { verdict: "fail" }, { verdict: "unknown" }, { verdict: "pass" }] as never)).toEqual({
-      total: 4,
-      counts: { pass: 2, fail: 1, unknown: 1 },
-      recent: [{ verdict: "pass" }, { verdict: "fail" }, { verdict: "unknown" }, { verdict: "pass" }],
-    });
-  });
-
-  test("parses a bounded verdict and rationale from model output", () => {
-    expect(parseVerifierResponse("VERDICT: pass\nRATIONALE: The test output covers the claimed behavior.")).toEqual({
-      verdict: "pass",
-      rationale: "The test output covers the claimed behavior.",
-    });
-    expect(parseVerifierResponse("not a structured answer")).toEqual({
-      verdict: "unknown",
-      rationale: "Model did not return a structured verification verdict.",
-    });
-  });
-
-  test("verifies evidence through the configured model runtime", async () => {
-    const context = new Context();
-    const tools = new PiToolRegistry();
-    const panels = new PiPluginUiRegistry();
-    const model = { provider: "everyapi", id: "verifier-model" };
-    context.provide("piModelRuntime", {
-      provider: "everyapi",
-      model: "verifier-model",
-      runtime: {
-        getModel: () => model,
-        complete: () => Promise.resolve({ content: [{ type: "text", text: "VERDICT: pass\nRATIONALE: Evidence matches the claim." }] }),
-      },
-    } as never);
-    context.provide("piTools", tools);
-    context.provide("piPluginUi", panels);
-    try {
-      await context.plugin(llmVerifierPlugin, {});
-      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "llm_verify");
-      expect(tool).toBeDefined();
-      await expect(
-        tool!.execute("call-1", { claim: "The change is covered", evidence: "npx vitest run: 3 passed" }, undefined, undefined, {} as never),
-      ).resolves.toMatchObject({ details: { verdict: "pass", model: { provider: "everyapi", id: "verifier-model" } } });
-      const batchTool = tools.snapshot().customTools.find((candidate) => candidate.name === "llm_verify_batch");
-      expect(batchTool).toBeDefined();
-      await expect(
-        batchTool!.execute(
-          "call-2",
-          {
-            items: [
-              { claim: "The unit suite passes", evidence: "75 tests passed" },
-              { claim: "The build passes", evidence: "tsc exited 0" },
-            ],
-          },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).resolves.toMatchObject({ details: { results: [{ verdict: "pass" }, { verdict: "pass" }], summary: { total: 3, counts: { pass: 3 } } } });
-      await expect(panels.snapshot()).resolves.toMatchObject([
-        { id: "llm-verifier-panel", data: { latest: { verdict: "pass" }, history: { total: 3, counts: { pass: 3 } } } },
-      ]);
-    } finally {
-      await context.fiber.dispose();
-    }
-  });
-});

package/packages/core/test/mirage-bridge.test.ts

@@ -1,54 +0,0 @@
-import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { Context } from "@deepseek-ai/cordis";
-import { afterEach, describe, expect, test } from "vitest";
-import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
-import mirageBridgePlugin from "../src/plugins/mirage-bridge.js";
-
-const temporaryDirectories: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
-});
-
-describe("mirage bridge", () => {
-  test("checks the official CLI and executes inside the configured virtual workspace", async () => {
-    const directory = await mkdtemp(join(tmpdir(), "pi-harness-mirage-"));
-    temporaryDirectories.push(directory);
-    const executable = join(directory, "mirage-stub.mjs");
-    await writeFile(
-      executable,
-      `#!/usr/bin/env node
-if (process.argv[2] === "--version") console.log("mirage 0.9.0");
-else console.log(JSON.stringify(process.argv.slice(2)));
-`,
-      "utf8",
-    );
-    await chmod(executable, 0o755);
-    const context = new Context();
-    const tools = new PiToolRegistry();
-    const panels = new PiPluginUiRegistry();
-    context.provide("piHarnessLaunch", { cwd: directory, agentDir: directory } as never);
-    context.provide("piTools", tools);
-    context.provide("piPluginUi", panels);
-    try {
-      await context.plugin(mirageBridgePlugin, { executable, workspaceId: "review-sandbox" });
-      const doctor = tools.snapshot().customTools.find((tool) => tool.name === "mirage_doctor");
-      const execute = tools.snapshot().customTools.find((tool) => tool.name === "mirage_execute");
-      expect(doctor).toBeDefined();
-      expect(execute).toBeDefined();
-      await expect(doctor!.execute("doctor-1", {}, undefined, undefined, {} as never)).resolves.toMatchObject({
-        details: { available: true, version: "mirage 0.9.0", workspaceId: "review-sandbox" },
-      });
-      await expect(execute!.execute("run-1", { command: "grep -r TODO /workspace" }, undefined, undefined, {} as never)).resolves.toMatchObject({
-        details: { exitCode: 0, workspaceId: "review-sandbox", command: "grep -r TODO /workspace" },
-      });
-      await expect(panels.snapshot()).resolves.toMatchObject([
-        { id: "mirage-bridge-panel", data: { available: true, workspaceId: "review-sandbox", lastRun: { exitCode: 0 } } },
-      ]);
-    } finally {
-      await context.fiber.dispose();
-    }
-  });
-});

package/packages/core/test/module-search.test.ts

@@ -1,78 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { Context } from "@deepseek-ai/cordis";
-import { describe, expect, test } from "vitest";
-import { PiPluginUiRegistry, PiToolRegistry, provideLaunchContext } from "../src/services.js";
-import { extractModuleMatches } from "../src/plugins/module-search.js";
-import moduleSearchPlugin from "../src/plugins/module-search.js";
-
-describe("module search", () => {
-  test("extracts matching imports and exports with line numbers", () => {
-    expect(
-      extractModuleMatches(
-        'import { readFile } from "node:fs/promises";\nexport function readConfig() { return readFile; }\nconst ignored = 1;',
-        "config.ts",
-        "read",
-        "all",
-      ),
-    ).toEqual([
-      { kind: "import", name: "readFile", path: "config.ts", line: 1, text: 'import { readFile } from "node:fs/promises";' },
-      { kind: "export", name: "readConfig", path: "config.ts", line: 2, text: "export function readConfig() { return readFile; }" },
-    ]);
-    expect(extractModuleMatches('import { readFile, writeFile } from "node:fs/promises";', "config.ts", "readFile", "import")).toEqual([
-      { kind: "import", name: "readFile", path: "config.ts", line: 1, text: 'import { readFile, writeFile } from "node:fs/promises";' },
-    ]);
-  });
-
-  test("searches source files without traversing dependency directories", async () => {
-    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-module-search-"));
-    await writeFile(join(cwd, "module.ts"), 'import { readFile } from "node:fs";\nexport const readConfig = readFile;\n', "utf8");
-    await writeFile(join(cwd, "ignored.js"), "export const readIgnored = true;\n", "utf8");
-    await mkdir(join(cwd, "node_modules", "dependency"), { recursive: true });
-    await writeFile(join(cwd, "node_modules", "dependency", "index.ts"), "export const readDependency = true;\n", "utf8");
-    const context = new Context();
-    const tools = new PiToolRegistry();
-    const panels = new PiPluginUiRegistry();
-    provideLaunchContext(context, { cwd, agentDir: cwd, args: [], requestExit() {} });
-    context.provide("piTools", tools);
-    context.provide("piPluginUi", panels);
-    try {
-      await context.plugin(moduleSearchPlugin);
-      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "module_search");
-      expect(tool).toBeDefined();
-      await expect(tool!.execute("call-1", { query: "read", kind: "export" }, undefined, undefined, {} as never)).resolves.toMatchObject({
-        details: {
-          matches: [
-            { name: "readIgnored", path: "ignored.js" },
-            { name: "readConfig", path: "module.ts" },
-          ],
-          scannedFiles: 2,
-        },
-      });
-    } finally {
-      await context.fiber.dispose();
-      await rm(cwd, { recursive: true, force: true });
-    }
-  });
-
-  test("reports truncation when one file contains more matches than the limit", async () => {
-    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-module-search-limit-"));
-    await writeFile(join(cwd, "module.ts"), "export const readOne = 1; export const readTwo = 2;\n", "utf8");
-    const context = new Context();
-    const tools = new PiToolRegistry();
-    provideLaunchContext(context, { cwd, agentDir: cwd, args: [], requestExit() {} });
-    context.provide("piTools", tools);
-    context.provide("piPluginUi", new PiPluginUiRegistry());
-    try {
-      await context.plugin(moduleSearchPlugin);
-      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "module_search");
-      await expect(tool!.execute("call-1", { query: "read", kind: "export", maxResults: 1 }, undefined, undefined, {} as never)).resolves.toMatchObject({
-        details: { matches: [{ name: "readOne" }], truncated: true },
-      });
-    } finally {
-      await context.fiber.dispose();
-      await rm(cwd, { recursive: true, force: true });
-    }
-  });
-});

package/packages/core/test/plugin-check.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { isPluginRepositoryName } from "../src/plugins/plugin-check.js";
-
-describe("plugin repository discovery", () => {
-  test("accepts Pi Harness and legacy DSH plugin directory names", () => {
-    expect(isPluginRepositoryName("pi-colleague-skill")).toBe(true);
-    expect(isPluginRepositoryName("dsh-vision-toolkit")).toBe(true);
-    expect(isPluginRepositoryName("example-plugin")).toBe(true);
-  });
-
-  test("does not scan dependency or hidden directories", () => {
-    expect(isPluginRepositoryName("node_modules")).toBe(false);
-    expect(isPluginRepositoryName(".git")).toBe(false);
-    expect(isPluginRepositoryName("workspace")).toBe(false);
-  });
-});

package/packages/core/test/plugin-stars.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { Context } from "@deepseek-ai/cordis";
-import { provideLaunchContext } from "../src/services.js";
-import { parsePluginStarsPayload, searchPluginStars } from "../src/plugins/plugin-stars.js";
-import pluginStars from "../src/plugins/plugin-stars.js";
-import toolsPlugin from "../src/plugins/tools.js";
-
-describe("plugin stars", () => {
-  test("normalizes curated ranking data and filters by query", () => {
-    const report = parsePluginStarsPayload({
-      generatedAt: "2026-09-02T12:00:00Z",
-      source: "dsh-plugin-stars",
-      plugins: [
-        {
-          id: "1",
-          name: "ModLens",
-          fullName: "liustack/modlens",
-          description: "Vision bridge",
-          htmlUrl: "https://github.com/liustack/modlens",
-          stars: 3835,
-          topics: ["dsh-plugin", "vision"],
-        },
-        {
-          id: "2",
-          name: "Other",
-          fullName: "owner/other",
-          description: "Task board",
-          htmlUrl: "https://github.com/owner/other",
-          stars: 281,
-          topics: ["taskboard"],
-        },
-      ],
-    });
-
-    expect(searchPluginStars(report, "vision")).toEqual([
-      expect.objectContaining({ name: "ModLens", fullName: "liustack/modlens", stars: 3835, topics: ["dsh-plugin", "vision"] }),
-    ]);
-    expect(report).toMatchObject({ generatedAt: "2026-09-02T12:00:00Z", source: "dsh-plugin-stars" });
-  });
-
-  test("drops malformed or non-GitHub entries", () => {
-    const report = parsePluginStarsPayload({ plugins: [{ name: "bad", fullName: "bad", htmlUrl: "https://example.com", stars: -1 }, null] });
-    expect(report.plugins).toEqual([]);
-  });
-
-  test("registers a read-only search tool and panel", async () => {
-    const context = new Context();
-    provideLaunchContext(context, { cwd: "/tmp", agentDir: "/tmp", args: [], requestExit() {} });
-    await context.plugin(toolsPlugin, { names: [] });
-    await context.plugin(pluginStars, { sourceUrl: "https://raw.githubusercontent.com/ywsldxk/dsh-plugin-stars/main/data/plugins.json" });
-    expect(context.piTools.snapshot().customTools.map((tool) => tool.name)).toContain("plugin_stars_search");
-    await expect(context.piPluginUi.snapshot()).resolves.toEqual([expect.objectContaining({ id: "plugin-stars-panel", title: "Plugin Stars" })]);
-    await context.fiber.dispose();
-  });
-});

package/packages/core/test/profile.test.ts

@@ -1,39 +0,0 @@
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { describe, expect, test } from "vitest";
-import { resolveProfileConfig } from "../src/profile.js";
-
-async function createProfiles(): Promise<string> {
-  const root = await mkdtemp(join(tmpdir(), "pi-harness-profiles-"));
-  await mkdir(join(root, "default"));
-  await writeFile(join(root, "default", "cordis.yml"), "[]\n", "utf8");
-  return root;
-}
-
-describe("resolveProfileConfig", () => {
-  test("resolves the default built-in profile", async () => {
-    const profilesDir = await createProfiles();
-
-    await expect(resolveProfileConfig({ profilesDir })).resolves.toBe(join(profilesDir, "default", "cordis.yml"));
-  });
-
-  test("resolves an explicit config path from the invoking directory", async () => {
-    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-config-"));
-    await writeFile(join(cwd, "custom.yml"), "[]\n", "utf8");
-
-    await expect(resolveProfileConfig({ configPath: "custom.yml", cwd })).resolves.toBe(resolve(cwd, "custom.yml"));
-  });
-
-  test("rejects profile names that can escape the profiles directory", async () => {
-    const profilesDir = await createProfiles();
-
-    await expect(resolveProfileConfig({ profile: "../outside", profilesDir })).rejects.toThrow(/invalid profile name/i);
-  });
-
-  test("rejects a missing profile with its resolved path", async () => {
-    const profilesDir = await createProfiles();
-
-    await expect(resolveProfileConfig({ profile: "missing", profilesDir })).rejects.toThrow(join(profilesDir, "missing", "cordis.yml"));
-  });
-});