@cue-dev/retrieval-core 0.1.3

package/src/indexing-ignore.ts

@@ -0,0 +1,179 @@
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+export const INDEXING_IGNORE_FILENAMES = [".contextignore", ".cueignore"] as const;
+
+const INDEXING_CONTROL_FILENAMES = new Set(INDEXING_IGNORE_FILENAMES.map((name) => name.toLowerCase()));
+
+type IndexingPathKind = "file" | "dir";
+
+interface CompiledIgnoreRule {
+  directory_only: boolean;
+  has_slash: boolean;
+  regex: RegExp;
+}
+
+export interface IndexingIgnoreMatcher {
+  patterns: string[];
+  shouldIgnorePath(path: string, kind: IndexingPathKind): boolean;
+}
+
+function escapeRegexChar(char: string): string {
+  return /[\\^$+?.()|[\]{}]/.test(char) ? `\\${char}` : char;
+}
+
+function compileGlobPattern(pattern: string): RegExp {
+  let output = "";
+  for (let i = 0; i < pattern.length; i += 1) {
+    const char = pattern[i];
+    if (char === undefined) {
+      continue;
+    }
+    if (char === "*") {
+      const next = pattern[i + 1];
+      if (next === "*") {
+        const afterDouble = pattern[i + 2];
+        if (afterDouble === "/") {
+          output += "(?:.*/)?";
+          i += 2;
+          continue;
+        }
+        output += ".*";
+        i += 1;
+        continue;
+      }
+      output += "[^/]*";
+      continue;
+    }
+    if (char === "?") {
+      output += "[^/]";
+      continue;
+    }
+    output += escapeRegexChar(char);
+  }
+  return new RegExp(`^${output}$`);
+}
+
+export function normalizeRepoRelativePath(path: string): string {
+  const normalized = path
+    .replace(/\\/g, "/")
+    .replace(/^\.\/+/, "")
+    .replace(/^\/+/, "")
+    .replace(/\/+/g, "/")
+    .replace(/\/+$/, "");
+  return normalized;
+}
+
+function basename(path: string): string {
+  const normalized = normalizeRepoRelativePath(path);
+  if (normalized.length === 0) {
+    return "";
+  }
+  const lastSlash = normalized.lastIndexOf("/");
+  return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
+}
+
+function listAncestorDirectories(path: string, kind: IndexingPathKind): string[] {
+  const normalized = normalizeRepoRelativePath(path);
+  if (normalized.length === 0) {
+    return [];
+  }
+
+  const segments = normalized.split("/");
+  const depth = kind === "dir" ? segments.length : Math.max(segments.length - 1, 0);
+  const output: string[] = [];
+  let current = "";
+  for (let i = 0; i < depth; i += 1) {
+    current = current.length === 0 ? segments[i]! : `${current}/${segments[i]!}`;
+    output.push(current);
+  }
+  return output;
+}
+
+function parseIgnorePatterns(content: string): string[] {
+  const lines = content.split(/\r?\n/);
+  const output: string[] = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    // v1 is exclude-only; ignore negation directives for deterministic behavior.
+    if (trimmed.startsWith("!")) {
+      continue;
+    }
+    const normalized = normalizeRepoRelativePath(trimmed);
+    if (normalized.length === 0) {
+      continue;
+    }
+    output.push(trimmed.endsWith("/") ? `${normalized}/` : normalized);
+  }
+  return output;
+}
+
+function compileIgnoreRules(patterns: string[]): CompiledIgnoreRule[] {
+  return patterns
+    .map((pattern) => {
+      const directoryOnly = pattern.endsWith("/");
+      const normalizedPattern = directoryOnly ? pattern.slice(0, -1) : pattern;
+      const normalized = normalizeRepoRelativePath(normalizedPattern);
+      if (normalized.length === 0) {
+        return undefined;
+      }
+      return {
+        directory_only: directoryOnly,
+        has_slash: normalized.includes("/"),
+        regex: compileGlobPattern(normalized)
+      } satisfies CompiledIgnoreRule;
+    })
+    .filter((rule): rule is CompiledIgnoreRule => rule !== undefined);
+}
+
+function matchesRule(rule: CompiledIgnoreRule, path: string, kind: IndexingPathKind): boolean {
+  const normalized = normalizeRepoRelativePath(path);
+  if (normalized.length === 0) {
+    return false;
+  }
+
+  if (!rule.directory_only) {
+    if (rule.has_slash) {
+      return rule.regex.test(normalized);
+    }
+    return rule.regex.test(basename(normalized));
+  }
+
+  const ancestors = listAncestorDirectories(normalized, kind);
+  if (rule.has_slash) {
+    return ancestors.some((ancestor) => rule.regex.test(ancestor));
+  }
+  return ancestors.some((ancestor) => rule.regex.test(basename(ancestor)));
+}
+
+export async function loadIndexingIgnoreMatcher(projectRootPath: string): Promise<IndexingIgnoreMatcher> {
+  const root = resolve(projectRootPath);
+  const patterns: string[] = [];
+
+  for (const filename of INDEXING_IGNORE_FILENAMES) {
+    try {
+      const content = await readFile(join(root, filename), "utf8");
+      patterns.push(...parseIgnorePatterns(content));
+    } catch {
+      continue;
+    }
+  }
+
+  const rules = compileIgnoreRules(patterns);
+  return {
+    patterns,
+    shouldIgnorePath(path: string, kind: IndexingPathKind): boolean {
+      const normalized = normalizeRepoRelativePath(path);
+      if (normalized.length === 0) {
+        return false;
+      }
+      if (kind === "file" && INDEXING_CONTROL_FILENAMES.has(basename(normalized).toLowerCase())) {
+        return true;
+      }
+      return rules.some((rule) => matchesRule(rule, normalized, kind));
+    }
+  };
+}