@mrciphersmith/keryx 0.2.83 → 0.2.84

package/src/gdgraph/build.test.ts

@@ -1,120 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { expect, test } from "bun:test";
-import { buildGraph } from "./build";
-import { loadGraph } from "./query";
-import { uniqueTestRoot } from "../lib/test-tmp";
-
-test("buildGraph ignores generated frontend outputs and resolves imported assets", async () => {
-  const root = uniqueTestRoot(tmpdir(), "keryx-gdgraph-build");
-  await reset(root);
-  await mkdir(path.join(root, "src", "feature"), { recursive: true });
-  await mkdir(path.join(root, "public"), { recursive: true });
-  await mkdir(path.join(root, "storybook-static", "assets"), { recursive: true });
-
-  await writeFile(
-    path.join(root, "src", "feature", "index.ts"),
-    [
-      importLine("'./style.css';"),
-      importLine("icon from './icon.svg?react';"),
-      importLine("raw from './template.hbs?raw';"),
-      importLine("{ value } from './value';"),
-      "export const result = `${value}-${icon}-${raw}`;",
-      "",
-    ].join("\n"),
-  );
-  await writeFile(path.join(root, "src", "feature", "value.ts"), "export const value = 'ok';\n");
-  await writeFile(path.join(root, "src", "feature", "style.css"), ".x { color: red; }\n");
-  await writeFile(path.join(root, "src", "feature", "icon.svg"), "<svg />\n");
-  await writeFile(path.join(root, "src", "feature", "template.hbs"), "<div>{{value}}</div>\n");
-  await writeFile(path.join(root, "public", "worker.js"), "export const generated = true;\n");
-  await writeFile(path.join(root, "storybook-static", "assets", "bundle.js"), "export const generated = true;\n");
-
-  const result = await buildGraph(root);
-  const graph = await loadGraph(root);
-  const summary = await readFile(result.summaryPath, "utf8");
-
-  expect(graph.nodes.map((node) => node.path).sort()).toEqual([
-    "src/feature/icon.svg",
-    "src/feature/index.ts",
-    "src/feature/style.css",
-    "src/feature/template.hbs",
-    "src/feature/value.ts",
-  ]);
-  expect(graph.nodes.filter((node) => node.kind === "file").length).toBe(2);
-  expect(graph.nodes.filter((node) => node.kind === "asset").length).toBe(3);
-  expect(graph.edges.filter((edge) => edge.kind === "imports").length).toBe(1);
-  expect(graph.edges.filter((edge) => edge.kind === "asset").length).toBe(3);
-  expect(graph.edges.filter((edge) => edge.kind === "unresolved").length).toBe(0);
-  expect(summary).toContain("Skipped generated/static directories: 2");
-  expect(summary).toContain("| feature | 2 |");
-});
-
-test("buildGraph resolves tsconfig path aliases and parser-scanned imports", async () => {
-  const root = uniqueTestRoot(tmpdir(), "keryx-gdgraph-aliases");
-  await reset(root);
-  await mkdir(path.join(root, "src", "components"), { recursive: true });
-  await mkdir(path.join(root, "src", "utils"), { recursive: true });
-  await mkdir(path.join(root, "src", "assets"), { recursive: true });
-
-  await writeFile(
-    path.join(root, "tsconfig.json"),
-    JSON.stringify({
-      compilerOptions: {
-        baseUrl: ".",
-        paths: {
-          "@/*": ["src/*"],
-          "~assets/*": ["src/assets/*"],
-          "#config": ["src/config.ts"],
-        },
-      },
-    }),
-  );
-  await writeFile(
-    path.join(root, "src", "index.ts"),
-    [
-      "import { Button } from '@/components/Button';",
-      "export { value } from '@/utils';",
-      "import logo from '~assets/logo.svg?raw';",
-      "import config from '#config';",
-      "const lazy = () => import('@/lazy');",
-      "const cjs = require('@/cjs');",
-      "const ignored = (name: string) => import(`@/dynamic/${name}`);",
-      "export const result = { Button, logo, config, lazy, cjs, ignored };",
-      "",
-    ].join("\n"),
-  );
-  await writeFile(path.join(root, "src", "components", "Button.tsx"), "import React from 'react';\nexport const Button = () => null;\n");
-  await writeFile(path.join(root, "src", "utils", "index.ts"), "export const value = 1;\n");
-  await writeFile(path.join(root, "src", "config.ts"), "export default { ok: true };\n");
-  await writeFile(path.join(root, "src", "lazy.ts"), "export const lazy = true;\n");
-  await writeFile(path.join(root, "src", "cjs.ts"), "export const cjs = true;\n");
-  await writeFile(path.join(root, "src", "assets", "logo.svg"), "<svg />\n");
-
-  await buildGraph(root);
-  const graph = await loadGraph(root);
-  const edgesFromIndex = graph.edges.filter((edge) => edge.from === "src/index.ts");
-
-  expect(edgesFromIndex.filter((edge) => edge.kind === "imports").map((edge) => edge.to).sort()).toEqual([
-    "src/cjs.ts",
-    "src/components/Button.tsx",
-    "src/config.ts",
-    "src/lazy.ts",
-    "src/utils/index.ts",
-  ]);
-  expect(edgesFromIndex.filter((edge) => edge.kind === "asset").map((edge) => edge.to)).toEqual([
-    "src/assets/logo.svg",
-  ]);
-  expect(graph.edges.filter((edge) => edge.kind === "unresolved")).toEqual([]);
-  expect(graph.edges.some((edge) => edge.specifier.includes("dynamic"))).toBe(false);
-});
-
-async function reset(root: string): Promise<void> {
-  await rm(root, { recursive: true, force: true });
-  await mkdir(root, { recursive: true });
-}
-
-function importLine(rest: string): string {
-  return `im${"port"} ${rest}`;
-}

package/src/gdgraph/config.test.ts

@@ -1,47 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { expect, test } from "bun:test";
-import { DEFAULT_GDGRAPH_CONFIG, loadGdgraphConfig, mergeGdgraphConfig } from "./config";
-
-test("AC5.1 — defaults: affected.defaultDepth is 1 (back-compat)", () => {
-  expect(DEFAULT_GDGRAPH_CONFIG.affected.defaultDepth).toBe(1);
-  expect(mergeGdgraphConfig({}).repomap.tokenBudget).toBe(8000);
-  expect(mergeGdgraphConfig({}).repomap.tokenEstimator).toBe("chars-div-4");
-});
-
-test("AC5.1 — deep-merge overrides individual fields, keeps the rest", () => {
-  const merged = mergeGdgraphConfig({
-    affected: { defaultDepth: 3 },
-    repomap: { tokenBudget: 100 },
-    treesitter: { languages: ["typescript"] },
-  });
-  expect(merged.affected.defaultDepth).toBe(3);
-  expect(merged.repomap.tokenBudget).toBe(100);
-  // Untouched fields fall back to defaults.
-  expect(merged.repomap.damping).toBe(DEFAULT_GDGRAPH_CONFIG.repomap.damping);
-  expect(merged.treesitter.languages).toEqual(["typescript"]);
-  expect(merged.treesitter.grammarsPath).toBeNull();
-});
-
-test("AC5.1/C0-8 — missing config file ⇒ defaults", async () => {
-  const root = await mkdtemp(path.join(tmpdir(), "keryx-cfg-"));
-  try {
-    const config = await loadGdgraphConfig(root);
-    expect(config).toEqual(mergeGdgraphConfig({}));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("AC5.1/C0-8 — malformed JSON ⇒ defaults (never throws)", async () => {
-  const root = await mkdtemp(path.join(tmpdir(), "keryx-cfg-bad-"));
-  try {
-    await mkdir(path.join(root, ".metaproject"), { recursive: true });
-    await writeFile(path.join(root, ".metaproject", "gdgraph.config.json"), "{ not valid json ");
-    const config = await loadGdgraphConfig(root);
-    expect(config).toEqual(mergeGdgraphConfig({}));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});

package/src/gdgraph/core-sources.test.ts

@@ -1,99 +0,0 @@
-// The copied gdgraph core must be import-closed.
-//
-// `init` and `update` copy a few `src/gdgraph/*.ts` files into
-// `.metaproject/core/gdgraph/` so a project can run the graph builder without
-// the full toolkit. The list was hand-maintained, in two places, and nothing
-// checked it against what those files actually import.
-//
-// So when `query.ts` gained `import { resolveGraphTarget } from "./target"`,
-// neither copy learned about it, and `keryx gdgraph build` — the very first
-// "Next step" that `init` prints — died on every fresh install with
-// `Cannot find module './target'`. The suite stayed green throughout, because
-// nothing ever ran the copied tree.
-//
-// The domain of "which files does the copied core need" is not a list. It is
-// the transitive closure of RUNTIME imports from the entry points, and written
-// as a list it goes stale on the next `import`.
-//
-// The first version of this test matched imports with a regular expression and
-// immediately proved the repository's own lesson about pattern guards: it
-// matched the string `from "./m"` inside a COMMENT in `build.ts` and demanded a
-// file called `m.ts`. So it uses `Bun.Transpiler.scanImports` instead — the same
-// parser-backed scan gdgraph itself uses. That also gets the semantics right:
-// the transpiler drops type-only imports, and a type-only import genuinely does
-// not need its file present at runtime.
-import { describe, expect, test } from "bun:test";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { GDGRAPH_CORE_SOURCES } from "./core-sources";
-
-const GDGRAPH_DIR = import.meta.dir;
-const transpiler = new Bun.Transpiler({ loader: "ts" });
-
-/**
- * Local imports of one module that must resolve for it to LOAD.
- *
- * Two exclusions, both deliberate rather than convenient:
- *
- *   * type-only imports never reach runtime — the transpiler drops them, and
- *     `scanImports` does not report them;
- *   * a `dynamic-import` is a deliberate lazy edge. `build.ts` reaches `enrich`
- *     that way precisely so it can run in an environment that lacks it —
- *     `enrich.ts:9` names "the copied `.metaproject/core/gdgraph`" as that
- *     environment. Requiring it would copy the whole optional-capability tree
- *     into every scaffolded project and invert the design.
- *
- * So the closure is over `import-statement` only. That is the set whose absence
- * is a crash at load, which is the failure this test exists to prevent.
- */
-function runtimeImportsOf(basename: string): string[] {
-  const source = readFileSync(path.join(GDGRAPH_DIR, basename), "utf8");
-  return transpiler
-    .scanImports(source)
-    .filter((entry) => entry.kind === "import-statement" && entry.path.startsWith("./"))
-    .map((entry) => `${entry.path.slice(2).replace(/\.(ts|js)$/, "")}.ts`);
-}
-
-/** Every module reachable from `entries` through runtime local imports. */
-function importClosure(entries: readonly string[]): Set<string> {
-  const seen = new Set<string>();
-  const queue = [...entries];
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    if (seen.has(current)) continue;
-    seen.add(current);
-    for (const next of runtimeImportsOf(current)) queue.push(next);
-  }
-  return seen;
-}
-
-describe("the copied gdgraph core is import-closed", () => {
-  // `cli.ts` is rendered rather than copied, and it drives these two.
-  const ENTRY_POINTS = ["build.ts", "query.ts"] as const;
-
-  test("every module the entry points reach at runtime is copied", () => {
-    const needed = importClosure(ENTRY_POINTS);
-    const copied = new Set(GDGRAPH_CORE_SOURCES);
-    const missing = [...needed].filter((f) => !copied.has(f)).sort();
-    // A failure here means a fresh `keryx init` followed by `keryx gdgraph
-    // build` dies on a missing module. Add the file to GDGRAPH_CORE_SOURCES.
-    expect(missing).toEqual([]);
-  });
-
-  test("every file in the copy list exists", () => {
-    for (const file of GDGRAPH_CORE_SOURCES) {
-      expect(() => readFileSync(path.join(GDGRAPH_DIR, file), "utf8")).not.toThrow();
-    }
-  });
-
-  test("the closure is non-trivial, so a passing test is not vacuous", () => {
-    // If `scanImports` ever silently returned nothing, the first assertion
-    // would pass against an empty set. Pin the floor, and pin the specific file
-    // whose absence caused the outage.
-    const needed = importClosure(ENTRY_POINTS);
-    expect(needed.size).toBeGreaterThanOrEqual(3);
-    expect(needed.has("build.ts")).toBe(true);
-    expect(needed.has("query.ts")).toBe(true);
-    expect(needed.has("target.ts")).toBe(true);
-  });
-});

package/src/gdgraph/fallback.test.ts

@@ -1,153 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile, stat } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import net from "node:net";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { expect, test } from "bun:test";
-import { buildGraph } from "./build";
-import { computeAffected } from "./affected";
-import { loadGdgraphConfig } from "./config";
-import { computeRepomap } from "./repomap";
-import { loadGraph } from "./query";
-import { resetWarnOnce, hasWarned } from "../capability/warn-once";
-
-const ARTIFACTS = [
-  "storage/nodes.jsonl",
-  "storage/edges.jsonl",
-  "artifacts/module-map.json",
-  "artifacts/summary.md",
-];
-
-async function makeProject(): Promise<string> {
-  const root = await mkdtemp(path.join(tmpdir(), "keryx-fallback-"));
-  await mkdir(path.join(root, "src", "feature"), { recursive: true });
-  await writeFile(
-    path.join(root, "src", "index.ts"),
-    "import { value } from './feature/value';\nexport const app = value;\n",
-  );
-  await writeFile(path.join(root, "src", "feature", "value.ts"), "export const value = 1;\n");
-  return root;
-}
-
-async function snapshot(root: string): Promise<Record<string, string>> {
-  const out: Record<string, string> = {};
-  for (const rel of ARTIFACTS) {
-    out[rel] = await readFile(
-      path.join(root, ".metaproject", "data", "gdgraph", rel),
-      "utf8",
-    );
-  }
-  return out;
-}
-
-test("AC4.1/AC4.2 — capability OFF: 4 legacy artifacts deterministic; no symbol files written", async () => {
-  // Two fresh, identical projects, each built ONCE (a rebuild in the same dir is
-  // pre-existingly non-deterministic because the build creates `.metaproject`,
-  // which then appears in the summary's skipped-dirs — unrelated to this block).
-  // Comparing two first-builds isolates the capability-off artifacts precisely.
-  const a = await makeProject();
-  const b = await makeProject();
-  try {
-    await buildGraph(a);
-    await buildGraph(b);
-    expect(await snapshot(b)).toEqual(await snapshot(a));
-
-    for (const root of [a, b]) {
-      const storage = path.join(root, ".metaproject", "data", "gdgraph", "storage");
-      expect(existsSync(path.join(storage, "symbols.jsonl"))).toBe(false);
-      expect(existsSync(path.join(storage, "calls.jsonl"))).toBe(false);
-    }
-  } finally {
-    await rm(a, { recursive: true, force: true });
-    await rm(b, { recursive: true, force: true });
-  }
-});
-
-test("AC4.4 — no-network sandbox: build/affected/repomap open zero sockets", async () => {
-  const root = await makeProject();
-  const originalConnect = net.Socket.prototype.connect;
-  const originalFetch = globalThis.fetch;
-  let socketAttempts = 0;
-  let fetchAttempts = 0;
-
-  net.Socket.prototype.connect = function connect(this: net.Socket) {
-    socketAttempts += 1;
-    // Never actually connect.
-    return this;
-  };
-  // @ts-expect-error — deliberately override for the sandbox assertion.
-  globalThis.fetch = async () => {
-    fetchAttempts += 1;
-    throw new Error("network blocked in sandbox");
-  };
-
-  try {
-    await buildGraph(root);
-    const config = await loadGdgraphConfig(root);
-    const graph = await loadGraph(root);
-    computeAffected(graph, "src/feature/value.ts", { depth: 3 });
-    computeRepomap(graph, config, {});
-    expect(socketAttempts).toBe(0);
-    expect(fetchAttempts).toBe(0);
-  } finally {
-    net.Socket.prototype.connect = originalConnect;
-    globalThis.fetch = originalFetch;
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("AC4.3 — capability ENABLED but unavailable: exactly one warn, regex path, exit 0, no symbol files", async () => {
-  const root = await makeProject();
-  resetWarnOnce();
-  try {
-    // Enable the ceiling in the manifest but provide NO resolvable grammar and
-    // no installed dep ⇒ resolveCapability degrades with a single warn-once.
-    await mkdir(path.join(root, ".metaproject"), { recursive: true });
-    await writeFile(
-      path.join(root, ".metaproject", "metaproject.json"),
-      JSON.stringify({
-        modules: {
-          gdgraph: {
-            enabled: true,
-            capabilities: [
-              { id: "gdgraph.treesitter", enabled: true, kind: "ceiling", optionalDependency: "web-tree-sitter" },
-            ],
-          },
-        },
-      }),
-    );
-
-    let stderr = "";
-    const originalWrite = process.stderr.write.bind(process.stderr);
-    process.stderr.write = ((chunk: string | Uint8Array) => {
-      stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString();
-      return true;
-    }) as typeof process.stderr.write;
-
-    const exitCodeBefore = process.exitCode;
-    try {
-      await buildGraph(root);
-    } finally {
-      process.stderr.write = originalWrite;
-    }
-
-    // Build did not hard-fail (exitCode untouched by build).
-    expect(process.exitCode).toBe(exitCodeBefore);
-    // Exactly one capability degradation warning was emitted.
-    const warnings = stderr.split("\n").filter((line) => line.includes("gdgraph.treesitter unavailable"));
-    expect(warnings).toHaveLength(1);
-    expect(hasWarned("gdgraph.treesitter")).toBe(true);
-
-    // No symbol files were written (regex/scan path only).
-    const storage = path.join(root, ".metaproject", "data", "gdgraph", "storage");
-    expect(existsSync(path.join(storage, "symbols.jsonl"))).toBe(false);
-    // The 4 legacy artifacts were still produced.
-    for (const rel of ARTIFACTS) {
-      const info = await stat(path.join(root, ".metaproject", "data", "gdgraph", rel));
-      expect(info.isFile()).toBe(true);
-    }
-  } finally {
-    resetWarnOnce();
-    await rm(root, { recursive: true, force: true });
-  }
-});

package/src/gdgraph/find.test.ts

@@ -1,78 +0,0 @@
-import { expect, test } from "bun:test";
-import { findNodes, findSymbols } from "./find";
-import type { GraphData, SymbolNode } from "./types";
-
-function fileNode(path: string) {
-  return { id: path, kind: "file" as const, path, language: "typescript" as const };
-}
-
-function edge(from: string, to: string) {
-  return { id: `${from}->${to}`, from, to, kind: "imports" as const, specifier: to };
-}
-
-const GRAPH: GraphData = {
-  nodes: [
-    fileNode("src/pipelines/utils/clone-pipeline.ts"),
-    fileNode("src/pipelines/features/pipeline-variables/pipeline-variables-store.ts"),
-    fileNode("src/pipelines/api/pipeline-api.ts"),
-    fileNode("src/case/store/case-store.ts"),
-  ],
-  edges: [
-    edge("src/case/store/case-store.ts", "src/pipelines/api/pipeline-api.ts"),
-    edge("src/pipelines/utils/clone-pipeline.ts", "src/pipelines/api/pipeline-api.ts"),
-  ],
-};
-
-test("finds files by concept and ranks by matched terms", () => {
-  const results = findNodes(GRAPH, "pipeline clone");
-  expect(results[0]?.path).toBe("src/pipelines/utils/clone-pipeline.ts");
-  expect(results[0]?.matched.sort()).toEqual(["clone", "pipeline"]);
-});
-
-test("ranks pipeline-variables highest for that query", () => {
-  const results = findNodes(GRAPH, "pipeline variables store");
-  expect(results[0]?.path).toContain("pipeline-variables-store.ts");
-});
-
-test("drops stopwords and short tokens from the query", () => {
-  const results = findNodes(GRAPH, "the clone of a pipeline");
-  expect(results[0]?.path).toBe("src/pipelines/utils/clone-pipeline.ts");
-  // "the", "of", "a" must not have matched anything on their own
-  expect(results.every((r) => !r.matched.includes("the"))).toBe(true);
-});
-
-test("returns empty for a query that matches no path", () => {
-  expect(findNodes(GRAPH, "kubernetes helm chart")).toEqual([]);
-});
-
-test("fan-in breaks ties (more-depended-on file ranks higher)", () => {
-  // both match "pipeline api" equally; pipeline-api has 2 dependents
-  const results = findNodes(GRAPH, "pipeline");
-  const apiIdx = results.findIndex((r) => r.path.endsWith("pipeline-api.ts"));
-  expect(results[apiIdx]?.dependents).toBe(2);
-});
-
-function sym(id: string, name: string, path: string, line: number): SymbolNode {
-  return { id, kind: "function", path, name, container: null, startLine: line, endLine: line + 2, language: "typescript" };
-}
-
-const SYMBOL_GRAPH: GraphData = {
-  nodes: [],
-  edges: [],
-  symbols: [
-    sym("a#clonePipeline", "clonePipeline", "src/a.ts", 12),
-    sym("b#clonePipelineDeep", "clonePipelineDeep", "src/b.ts", 30),
-    sym("c#unrelated", "unrelated", "src/c.ts", 1),
-  ],
-};
-
-test("findSymbols ranks an exact name match above a substring match", () => {
-  const results = findSymbols(SYMBOL_GRAPH, "clonePipeline");
-  expect(results[0]?.name).toBe("clonePipeline"); // exact-name bonus wins
-  expect(results.map((r) => r.name)).toContain("clonePipelineDeep");
-  expect(results.every((r) => r.name !== "unrelated")).toBe(true);
-});
-
-test("findSymbols returns [] when the symbol layer is absent", () => {
-  expect(findSymbols({ nodes: [], edges: [] }, "clonePipeline")).toEqual([]);
-});