@polycode-projects/seonix 0.1.0 → 0.2.1

package/src/walk.mjs

@@ -1,6 +1,11 @@
 // Shared deterministic file walker. Mirrors extract_ast.py's SKIP_DIRS so the
 // spike extractors see the same source surface the Python path would.
-import { readdir } from "node:fs/promises";
+// Also owns the `.seonixignore` matcher — a documented SUBSET of gitignore:
+// blank lines and `#` comments skipped; `*` matches within a path segment,
+// `**` across segments; a pattern containing `/` is anchored to the repo root
+// (leading/trailing slashes stripped); one without `/` matches that name at
+// any depth. No negation (`!`). A matched directory excludes its whole subtree.
+import { readdir, readFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 
 export const SKIP_DIRS = new Set([
@@ -9,10 +14,48 @@ export const SKIP_DIRS = new Set([
   "bin", "obj", "out", "coverage", ".next", ".nuxt", ".angular", "wwwroot",
 ]);
 
+export const IGNORE_FILE = ".seonixignore";
+
+/** Parse `.seonixignore` text into compiled patterns (see header for semantics). */
+export function parseIgnorePatterns(text) {
+  const out = [];
+  for (const raw of String(text).split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const pat = line.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!pat) continue;
+    const body = pat
+      .replace(/[.+?^${}()|[\]\\]/g, "\\$&")
+      .replace(/\*\*/g, "\u0000")
+      .replace(/\*/g, "[^/]*")
+      .replace(/\u0000/g, ".*");
+    // Anchored (contains "/") → match from the root; bare name → any depth.
+    // Trailing `(/|$)` makes a directory match cover its whole subtree.
+    out.push(pat.includes("/") ? new RegExp(`^${body}(/|$)`) : new RegExp(`(^|/)${body}(/|$)`));
+  }
+  return out;
+}
+
+/** Build a matcher over compiled patterns: matcher(relPath) → true = ignored.
+ *  `relPath` is repo-relative, forward-slash (file or directory). */
+export function ignoreMatcher(patterns) {
+  if (!patterns || patterns.length === 0) return null;
+  return (rel) => patterns.some((re) => re.test(rel));
+}
+
+/** Load `<root>/.seonixignore` → matcher, or null when absent/empty. */
+export async function loadIgnores(root) {
+  let text;
+  try { text = await readFile(join(root, IGNORE_FILE), "utf8"); }
+  catch { return null; }
+  return ignoreMatcher(parseIgnorePatterns(text));
+}
+
 /** Recursively collect absolute file paths under `root` whose extension is in
  *  `exts` (lower-cased, with dot), skipping SKIP_DIRS and dot-dirs. Deterministic
- *  (sorted) so the emitted graph is byte-stable per commit. */
-export async function walk(root, exts) {
+ *  (sorted) so the emitted graph is byte-stable per commit. `ignore` (optional,
+ *  from loadIgnores) prunes matched files and whole directories. */
+export async function walk(root, exts, ignore = null) {
   const want = new Set(exts.map((e) => e.toLowerCase()));
   const out = [];
   async function rec(dir) {
@@ -21,13 +64,17 @@ export async function walk(root, exts) {
     catch { return; }
     entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
     for (const e of entries) {
+      const abs = join(dir, e.name);
       if (e.isDirectory()) {
         if (SKIP_DIRS.has(e.name) || e.name.startsWith(".")) continue;
-        await rec(join(dir, e.name));
+        if (ignore && ignore(relPath(root, abs))) continue;
+        await rec(abs);
       } else if (e.isFile()) {
         const dot = e.name.lastIndexOf(".");
         const ext = dot >= 0 ? e.name.slice(dot).toLowerCase() : "";
-        if (want.has(ext)) out.push(join(dir, e.name));
+        if (!want.has(ext)) continue;
+        if (ignore && ignore(relPath(root, abs))) continue;
+        out.push(abs);
       }
     }
   }