@intentius/chant 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/lint/rule-loader.test.ts

@@ -64,4 +64,32 @@ describe("rule-loader", () => {
     // Clean up
     rmSync(join(RULES_DIR, "my-rule.test.ts"));
   });
+
+  test("walks up to find .chant/rules/ when invoked from a sub-stack dir", async () => {
+    // Project layout: TEST_DIR (root, has .chant/rules/) -> src/east/.
+    const subStack = join(TEST_DIR, "src", "east");
+    mkdirSync(subStack, { recursive: true });
+    writeFileSync(join(TEST_DIR, "package.json"), `{ "name": "fixture" }`);
+    try {
+      const rules = await loadLocalRules(subStack);
+      expect(rules).toHaveLength(1);
+      expect(rules[0].id).toBe("LOCAL001");
+    } finally {
+      rmSync(join(TEST_DIR, "src"), { recursive: true });
+      rmSync(join(TEST_DIR, "package.json"));
+    }
+  });
+
+  test("stops at the nearest package.json — does not climb into an unrelated parent", async () => {
+    const innerProject = join(TEST_DIR, "inner-proj");
+    const innerSubDir = join(innerProject, "src");
+    mkdirSync(innerSubDir, { recursive: true });
+    writeFileSync(join(innerProject, "package.json"), `{ "name": "inner" }`);
+    try {
+      const rules = await loadLocalRules(innerSubDir);
+      expect(rules).toHaveLength(0);
+    } finally {
+      rmSync(innerProject, { recursive: true });
+    }
+  });
 });

package/src/lint/rule-loader.ts

@@ -1,5 +1,5 @@
 import { readdirSync, existsSync } from "fs";
-import { join, resolve } from "path";
+import { dirname, join, resolve } from "path";
 import type { LintRule } from "./rule";
 
 /**
@@ -19,18 +19,51 @@ function isLintRule(value: unknown): value is LintRule {
 }
 
 /**
- * Load local lint rules from `.chant/rules/` directory.
+ * Walk up from `from` until a directory containing `.chant/rules/` is found,
+ * or until we hit the filesystem root or a non-project boundary (a directory
+ * with `package.json` but no `.chant/rules/` — that's the project root and
+ * we stop there even if no rules dir exists).
  *
- * Scans for `.ts` files, dynamically imports each, and collects
- * all exports that conform to the LintRule interface.
+ * Returns the absolute path to the discovered `.chant/rules/` directory, or
+ * null if none was found before we crossed the project root.
+ */
+function findRulesDir(from: string): string | null {
+  let cur = resolve(from);
+  while (true) {
+    const candidate = join(cur, ".chant", "rules");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    // Stop at the nearest project root (where package.json sits) — going
+    // above it would pick up rules belonging to an unrelated parent project.
+    if (existsSync(join(cur, "package.json"))) {
+      return null;
+    }
+    const parent = dirname(cur);
+    if (parent === cur) {
+      return null;
+    }
+    cur = parent;
+  }
+}
+
+/**
+ * Load local lint rules from `.chant/rules/`.
+ *
+ * Scans for `.ts` files in the nearest `.chant/rules/` directory found by
+ * walking up from `projectDir` (stopping at the closest `package.json` to
+ * avoid leaking into unrelated parent projects). Dynamically imports each
+ * file and collects all exports that conform to the LintRule interface.
  *
- * @param projectDir - Root directory of the project
- * @returns Array of LintRule objects found in `.chant/rules/`
+ * @param projectDir - Directory the lint command was invoked against. May be
+ *                     a sub-stack of a larger project — the rules dir is
+ *                     resolved by walking up.
+ * @returns Array of LintRule objects found in the discovered `.chant/rules/`.
  */
 export async function loadLocalRules(projectDir: string): Promise<LintRule[]> {
-  const rulesDir = join(projectDir, ".chant", "rules");
+  const rulesDir = findRulesDir(projectDir);
 
-  if (!existsSync(rulesDir)) {
+  if (rulesDir === null) {
     return [];
   }