@intentius/chant 0.22.0 → 0.24.0

package/src/project-root.test.ts

@@ -0,0 +1,105 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { findProjectConfig, findProjectRoot } from "./project-root";
+
+// Every test builds its own isolated directory tree under a fresh tmpdir —
+// never reused across tests, and never anywhere near the real repo's own
+// .git/package.json — so the boundary-stop behavior is exercised
+// deterministically instead of depending on where this file happens to sit
+// in the real chant checkout.
+let root: string;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "chant-project-root-"));
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe("findProjectConfig / findProjectRoot (chant #1117)", () => {
+  test("found at root — chant.config.ts in the start dir itself", () => {
+    writeFileSync(join(root, "chant.config.ts"), "export default {};");
+
+    const result = findProjectConfig(root);
+
+    expect(result.dir).toBe(root);
+    expect(result.configPath).toBe(join(root, "chant.config.ts"));
+    expect(findProjectRoot(root)).toBe(root);
+  });
+
+  test("found at an intermediate ancestor — several levels below the config", () => {
+    writeFileSync(join(root, "chant.config.json"), "{}");
+    const stackDir = join(root, "src", "stacks", "shared-foundation");
+    mkdirSync(stackDir, { recursive: true });
+
+    const result = findProjectConfig(stackDir);
+
+    expect(result.dir).toBe(root);
+    expect(result.configPath).toBe(join(root, "chant.config.json"));
+    expect(findProjectRoot(stackDir)).toBe(root);
+  });
+
+  test("not found — no chant.config, no .git, no package.json anywhere above start dir: falls back to start dir, not the filesystem root", () => {
+    const deep = join(root, "a", "b", "c");
+    mkdirSync(deep, { recursive: true });
+
+    const result = findProjectConfig(deep);
+
+    // Nothing between `deep` and the real filesystem root declares a chant
+    // config or a boundary marker (this mkdtemp tree carries none). Rather
+    // than adopting "/" as the project root — which would make a downstream
+    // caller that scopes a directory walk off this result (e.g.
+    // `resolveProjectLexicons` -> `findInfraFiles`) scan the entire disk —
+    // the walk gives up and returns `deep` itself unchanged.
+    expect(result.configPath).toBeUndefined();
+    expect(result.dir).toBe(deep);
+    expect(findProjectRoot(deep)).toBe(deep);
+  });
+
+  test("boundary stop — a .git/package.json ancestor halts the walk before an outer chant.config.ts", () => {
+    // An unrelated chant.config.ts two levels above this project's own git
+    // root must never be picked up — the boundary marker (.git here) stops
+    // the walk at the project's own root first.
+    writeFileSync(join(root, "chant.config.ts"), "export default { unrelated: true };");
+    const projectRoot = join(root, "project");
+    mkdirSync(join(projectRoot, ".git"), { recursive: true });
+    const stackDir = join(projectRoot, "src", "stack");
+    mkdirSync(stackDir, { recursive: true });
+
+    const result = findProjectConfig(stackDir);
+
+    expect(result.dir).toBe(projectRoot);
+    expect(result.configPath).toBeUndefined();
+    expect(findProjectRoot(stackDir)).toBe(projectRoot);
+  });
+
+  test("boundary stop — package.json (no .git) halts the walk the same way", () => {
+    writeFileSync(join(root, "chant.config.json"), "{}");
+    const projectRoot = join(root, "project");
+    mkdirSync(projectRoot, { recursive: true });
+    writeFileSync(join(projectRoot, "package.json"), "{}");
+    const stackDir = join(projectRoot, "src", "stack");
+    mkdirSync(stackDir, { recursive: true });
+
+    const result = findProjectConfig(stackDir);
+
+    expect(result.dir).toBe(projectRoot);
+    expect(result.configPath).toBeUndefined();
+  });
+
+  test("a config living exactly at the boundary dir is still found — boundary check never wins over a real config", () => {
+    const projectRoot = join(root, "project");
+    mkdirSync(join(projectRoot, ".git"), { recursive: true });
+    writeFileSync(join(projectRoot, "chant.config.ts"), "export default {};");
+    const stackDir = join(projectRoot, "src", "stack");
+    mkdirSync(stackDir, { recursive: true });
+
+    const result = findProjectConfig(stackDir);
+
+    expect(result.dir).toBe(projectRoot);
+    expect(result.configPath).toBe(join(projectRoot, "chant.config.ts"));
+  });
+});

package/src/project-root.ts

@@ -0,0 +1,78 @@
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+
+/**
+ * Shared upward config-discovery walk (chant #1117).
+ *
+ * Before this, `chant build <subdir>` and `lint.policies`
+ * (`./lint/policy.ts`'s `evaluateProjectPolicies`) each searched only the
+ * build directory and its immediate parent for `chant.config.ts`/`.json`,
+ * while `chant lint`/`chant graph` (`./lint/config.ts`'s old, file-local
+ * `findProjectRoot`) already walked all the way up. A project with a deeper
+ * `src/<stack>` layout — `chant build src/<stack>` two or more levels below
+ * the project root — silently never found the root config: `buildParams`'
+ * declared `env:` mappings went inert, `ownership`/`lint.policies`/etc quietly
+ * fell back to defaults, and nothing warned (loomster#162: `LOOM_TIER`/
+ * `LOOM_ENV` inert under every `npm run synth:*` for two releases).
+ *
+ * `findProjectConfig` is the one walk every config-discovery call site now
+ * shares. It stops at the first of:
+ *
+ * 1. A directory holding `chant.config.ts` or `chant.config.json` — found.
+ * 2. A directory holding `.git` or `package.json` with no chant config of its
+ *    own — the project boundary. Discovery must never wander past the actual
+ *    project into an unrelated ancestor directory just because this project
+ *    happens not to declare a config (a stray `chant.config.ts` two levels
+ *    above an unrelated git repo must never be picked up).
+ * 3. `startDir` itself, unchanged, if the walk reaches the filesystem root
+ *    without ever finding a config OR a boundary marker. This is not just a
+ *    "give up gracefully" nicety — several callers (`resolveProjectLexicons`
+ *    -> `findInfraFiles`) scope a real directory walk off this function's
+ *    result; if a rootless/marker-less start dir (a bare tmpdir, as chant's
+ *    own test suites use) resolved all the way to `/`, that downstream walk
+ *    would scan the entire filesystem instead of failing fast. Falling back
+ *    to `startDir` keeps every caller's blast radius local no matter how far
+ *    up the walk had to look.
+ */
+export interface ProjectConfigSearch {
+  /** The resolved project root: the config's directory, the boundary directory, or the (resolved) `startDir` when neither was found. */
+  dir: string;
+  /** Absolute path to the discovered `chant.config.ts`/`.json`, if any. */
+  configPath?: string;
+}
+
+/** Walk up from `startDir` (inclusive) to the nearest chant config or project boundary. See {@link ProjectConfigSearch}. */
+export function findProjectConfig(startDir: string): ProjectConfigSearch {
+  const resolvedStart = resolve(startDir);
+  let dir = resolvedStart;
+  for (;;) {
+    const tsPath = join(dir, "chant.config.ts");
+    if (existsSync(tsPath)) return { dir, configPath: tsPath };
+    const jsonPath = join(dir, "chant.config.json");
+    if (existsSync(jsonPath)) return { dir, configPath: jsonPath };
+
+    if (existsSync(join(dir, ".git")) || existsSync(join(dir, "package.json"))) {
+      return { dir };
+    }
+
+    const parent = dirname(dir);
+    if (parent === dir) {
+      // Filesystem root, no config, no boundary ever seen — give up rather
+      // than adopting "/" as the project root (see the module doc above).
+      return { dir: resolvedStart };
+    }
+    dir = parent;
+  }
+}
+
+/**
+ * Walk up from `startDir` to the nearest ancestor holding a chant project
+ * config (`chant.config.ts` or `chant.config.json`), the `.git`/`package.json`
+ * project boundary, or `startDir` itself when neither is found. Thin wrapper
+ * over {@link findProjectConfig} for callers that only need the directory
+ * (e.g. `chant lint`'s rule/plugin resolution, which just needs *a* stable
+ * root to resolve relative paths against).
+ */
+export function findProjectRoot(startDir: string): string {
+  return findProjectConfig(startDir).dir;
+}