my-pi/pi-tool-search/test/config.test.ts

import assert from "node:assert/strict";
import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { dirname, join } from "node:path";
import test from "node:test";

import {
  BUNDLE_TOOL_SEARCH_DEFAULTS,
  bundleFallbackConfig,
  getToolSearchCatalogPath,
  getToolSearchConfigPath,
  readToolSearchConfig,
} from "../extensions/config.ts";

async function withAgentDir(run: (agentDir: string) => Promise<void>): Promise<void> {
  const agentDir = await mkdtemp(join(tmpdir(), "my-pi-tool-search-"));
  try {
    await run(agentDir);
  } finally {
    await rm(agentDir, { recursive: true, force: true });
  }
}

/** Write a config file inside the temp dir; never touches the repo config/. */
async function writeConfig(agentDir: string, content: string): Promise<string> {
  const path = join(agentDir, "config.json");
  await mkdir(dirname(path), { recursive: true });
  await writeFile(path, content, "utf8");
  return path;
}

test("bundle defaults keep the committed tool list", () => {
  assert.deepEqual(BUNDLE_TOOL_SEARCH_DEFAULTS.alwaysEnabled, [
    "codegraph_explore",
    "lsp_diagnostics",
    "memory_search",
    "session_search",
    "memory_add",
    "memory_replace",
    "memory_remove",
    "skill_manage",
    "context_tree_query",
    "overflow_query",
    "codemode",
  ]);
  assert.deepEqual(bundleFallbackConfig(), {
    alwaysEnabled: [...BUNDLE_TOOL_SEARCH_DEFAULTS.alwaysEnabled],
    showToolSearchFooterStatus: false,
    maxActiveGroups: 5,
    maxToolsPerGroup: 8,
    maxDynamicTools: 28,
    groupOverrides: {},
  });
});

test("config resolves to the bundle config dir; catalog stays under my-pi", async () => {
  await withAgentDir(async (agentDir) => {
    assert.match(getToolSearchConfigPath(), /config[/\\]tool-search\.json$/);
    assert.equal(
      getToolSearchCatalogPath(agentDir),
      join(agentDir, "my-pi", "tool-search", "catalog-v1.json"),
    );
  });
});

test("falls back to bundle defaults when the config file is absent or invalid", async () => {
  await withAgentDir(async (agentDir) => {
    assert.deepEqual(
      readToolSearchConfig(join(agentDir, "missing.json")),
      bundleFallbackConfig(),
    );

    const badJson = await writeConfig(agentDir, "{not-json");
    assert.deepEqual(readToolSearchConfig(badJson), bundleFallbackConfig());

    const nonObject = await writeConfig(agentDir, '"a string, not an object"');
    assert.deepEqual(readToolSearchConfig(nonObject), bundleFallbackConfig());
  });
});

test("normalizes invalid runtime values without overwriting the file", async () => {
  await withAgentDir(async (agentDir) => {
    const original = JSON.stringify({
      alwaysEnabled: ["one", "one", 3],
      showToolSearchFooterStatus: "no",
      maxActiveGroups: 0,
      maxToolsPerGroup: 4,
      maxDynamicTools: -1,
      groupOverrides: { web: ["search", 2], empty: [] },
    });
    const path = await writeConfig(agentDir, original);
    assert.deepEqual(readToolSearchConfig(path), {
      alwaysEnabled: ["one"],
      showToolSearchFooterStatus: false,
      maxActiveGroups: 5,
      maxToolsPerGroup: 4,
      maxDynamicTools: 28,
      groupOverrides: { web: ["search"] },
    });
    assert.equal(await readFile(path, "utf8"), original);
  });
});

test("reads an explicit configuration verbatim", async () => {
  await withAgentDir(async (agentDir) => {
    const original = `${JSON.stringify({
      alwaysEnabled: ["codegraph_explore", "lsp_diagnostics"],
      showToolSearchFooterStatus: true,
      maxActiveGroups: 3,
      maxToolsPerGroup: 8,
      maxDynamicTools: 20,
      groupOverrides: { custom: ["some_tool"] },
    }, null, 2)}\n`;
    const path = await writeConfig(agentDir, original);
    assert.deepEqual(readToolSearchConfig(path), {
      alwaysEnabled: ["codegraph_explore", "lsp_diagnostics"],
      showToolSearchFooterStatus: true,
      maxActiveGroups: 3,
      maxToolsPerGroup: 8,
      maxDynamicTools: 20,
      groupOverrides: { custom: ["some_tool"] },
    });
    assert.equal(await readFile(path, "utf8"), original);
  });
});