@ctxo/cli 0.13.1 → 0.14.0

package/dist/chunk-7HSA5JVP.js

@@ -0,0 +1,1049 @@
+#!/usr/bin/env node
+import {
+  compareCodepoint
+} from "./chunk-72CEQEQD.js";
+import {
+  createLogger
+} from "./chunk-5DSKZJNN.js";
+
+// src/core/co-change/co-change-window.ts
+var SINCE_PATTERN = /^(\d+)([dwmy])$/;
+var SECONDS_PER_DAY = 86400;
+function parseCoChangeSince(value) {
+  const match = SINCE_PATTERN.exec(value);
+  if (!match) return void 0;
+  const amount = Number.parseInt(match[1], 10);
+  if (!Number.isSafeInteger(amount)) return void 0;
+  return { amount, unit: match[2] };
+}
+function sinceCutoff(headCommittedAt, since) {
+  const cutoff = subtractSince(headCommittedAt, since);
+  return Number.isFinite(cutoff) ? cutoff : Number.NEGATIVE_INFINITY;
+}
+function subtractSince(headCommittedAt, since) {
+  switch (since.unit) {
+    case "d":
+      return headCommittedAt - since.amount * SECONDS_PER_DAY;
+    case "w":
+      return headCommittedAt - since.amount * 7 * SECONDS_PER_DAY;
+    case "m":
+      return subtractUtcMonths(headCommittedAt, since.amount);
+    case "y":
+      return subtractUtcMonths(headCommittedAt, since.amount * 12);
+  }
+}
+function subtractUtcMonths(epochSeconds, months) {
+  const date = new Date(epochSeconds * 1e3);
+  const dayOfMonth = date.getUTCDate();
+  date.setUTCDate(1);
+  date.setUTCMonth(date.getUTCMonth() - months);
+  date.setUTCDate(Math.min(dayOfMonth, daysInUtcMonth(date)));
+  return date.getTime() / 1e3;
+}
+function daysInUtcMonth(date) {
+  const lastDay = new Date(date.getTime());
+  lastDay.setUTCMonth(lastDay.getUTCMonth() + 1, 0);
+  return lastDay.getUTCDate();
+}
+function windowCutoff(coChange, headCommittedAt) {
+  const since = coChange.since !== void 0 ? parseCoChangeSince(coChange.since) : void 0;
+  return since !== void 0 ? sinceCutoff(headCommittedAt, since) : void 0;
+}
+function selectWindow(commits, maxCommits, cutoff) {
+  const newest = maxCommits === "all" ? [...commits] : commits.slice(0, wholeCommitCount(maxCommits));
+  return cutoff === void 0 ? newest : newest.filter((commit) => commit.committedAt >= cutoff);
+}
+function wholeCommitCount(maxCommits) {
+  return maxCommits >= 1 ? Math.floor(maxCommits) : 0;
+}
+
+// src/core/config/load-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+import picomatch from "picomatch";
+
+// src/core/config/config-schema.ts
+import { z } from "zod";
+var StatsConfigSchema = z.object({
+  enabled: z.boolean().optional()
+}).strict();
+var IndexConfigSchema = z.object({
+  ignore: z.array(z.string().min(1)).optional(),
+  ignoreProjects: z.array(z.string().min(1)).optional(),
+  facts: z.boolean().optional(),
+  tests: z.array(z.string().min(1)).optional()
+}).strict();
+var MaskingConfigSchema = z.object({
+  /**
+   * Glob patterns matched against community cluster labels. Matching labels
+   * are replaced with `[masked-cluster-N]` in MCP tool responses so
+   * org-sensitive folder names (e.g. `src/payment-vault`, `internal-*`)
+   * never surface to AI agents over the stdio channel.
+   */
+  clusterLabels: z.array(z.string().min(1)).optional()
+}).strict();
+var WatchConfigSchema = z.object({
+  /**
+   * Minimum number of files that must be re-indexed since the last
+   * community snapshot before `ctxo watch` recomputes one. Default: 5.
+   * On large monorepos Louvain + PageRank cost ~1 s of blocking CPU;
+   * bumping this (e.g. 25) avoids recomputing on every save.
+   */
+  snapshotMinFileChanges: z.number().int().min(1).optional()
+}).strict();
+var GateConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  sensitivity: z.enum(["strict", "balanced", "lenient"]).optional(),
+  /** Absolute floor: minimum confirmed+likely dependents before the gate can fire. */
+  minDependents: z.number().int().min(0).optional(),
+  /** Repo-relative significance: symbol must be in the top `percentile`% by PageRank. */
+  percentile: z.number().int().min(1).max(100).optional()
+}).strict();
+var CoChangeConfigSchema = z.object({
+  /**
+   * Size of the co-change window: the last N non-merge commits from HEAD, or "all".
+   * Default: 2000. Independent of `ctxo index --max-history`, which only sets how much
+   * per-file commit history is kept.
+   */
+  maxCommits: z.union([z.number().int().min(1), z.literal("all")], { error: 'must be a positive integer or "all"' }).optional(),
+  /**
+   * Narrows the window to a duration counted back from HEAD's committer date (never the wall
+   * clock): `30d`, `2w`, `12m` or `1y`. Applies together with `maxCommits`.
+   */
+  since: z.string().refine((value) => parseCoChangeSince(value) !== void 0, {
+    error: "must be a duration such as 30d, 2w, 12m or 1y"
+  }).optional(),
+  /** Commits touching more analysed files than this are skipped as mass changes. Default: 30. */
+  maxFilesPerCommit: z.number().int().min(1).optional(),
+  /** A file pair becomes an entry only after this many shared commits. Default: 2. */
+  minShared: z.number().int().min(1).optional(),
+  /** Extra tracked files to analyse that no language plugin indexes, such as SQL scripts (globs). */
+  include: z.array(z.string().min(1)).optional(),
+  /** Indexed files to leave out of the analysis (globs). */
+  exclude: z.array(z.string().min(1)).optional()
+}).strict();
+var CommunitiesConfigSchema = z.object({
+  /** Louvain resolution: higher gives more, smaller communities. Default: 1.0. */
+  resolution: z.number().positive().optional(),
+  /** Minimum number of communities a symbol must bridge to count as a god node. Default: 3. */
+  godNodeMinBridged: z.number().int().min(1).optional(),
+  /** Maximum number of god nodes reported. Default: 25. */
+  godNodeMaxResults: z.number().int().min(0).optional()
+}).strict();
+var ContextsViewConfigSchema = z.object({
+  /** Blend of the file-edge signals. Defaults: dependency 1.0, coChange 1.0, data 0 (shared tables are a finding, not a clustering weight). */
+  weights: z.object({
+    dependency: z.number().min(0).optional(),
+    coChange: z.number().min(0).optional(),
+    data: z.number().min(0).optional()
+  }).strict().optional(),
+  /** Files to leave out of the file graph (globs). */
+  exclude: z.array(z.string().min(1)).optional(),
+  hubs: z.object({
+    /** Detect hubs automatically (fan-in and god nodes). Default: true. */
+    auto: z.boolean().optional(),
+    /** A file is a fan-in hub when it is in the top `topPercent`% by dependents. Default: 1. */
+    topPercent: z.number().positive().max(100).optional(),
+    /** Minimum distinct dependent files for a fan-in hub. Default: 10. */
+    minDependents: z.number().int().min(1).optional(),
+    /** Files that lose all their edges (globs). */
+    paths: z.array(z.string().min(1)).optional()
+  }).strict().optional(),
+  /** Louvain resolution for the file graph. Default: 1.0. */
+  resolution: z.number().positive().optional(),
+  /** Candidates with fewer files fold into a neighbour. Default: 3. */
+  minCandidateFiles: z.number().int().min(1).optional(),
+  /** Words dropped from candidate terms; replaces the default list. */
+  technicalTerms: z.array(z.string().min(1)).optional()
+}).strict();
+var CtxoConfigSchema = z.object({
+  version: z.union([z.string(), z.number()]).optional(),
+  stats: StatsConfigSchema.optional(),
+  index: IndexConfigSchema.optional(),
+  masking: MaskingConfigSchema.optional(),
+  watch: WatchConfigSchema.optional(),
+  gate: GateConfigSchema.optional(),
+  cochange: CoChangeConfigSchema.optional(),
+  communities: CommunitiesConfigSchema.optional(),
+  contextsView: ContextsViewConfigSchema.optional()
+}).passthrough();
+var DEFAULT_WATCH_SNAPSHOT_MIN_FILE_CHANGES = 5;
+var DEFAULT_COCHANGE_MAX_COMMITS = 2e3;
+var DEFAULT_COCHANGE_MAX_FILES_PER_COMMIT = 30;
+var DEFAULT_COCHANGE_MIN_SHARED = 2;
+var DEFAULT_TECHNICAL_TERMS = [
+  "Service",
+  "Repository",
+  "Controller",
+  "Handler",
+  "Manager",
+  "Dto",
+  "Impl",
+  "Async"
+];
+var DEFAULT_CONFIG = {
+  version: "1.0",
+  stats: { enabled: true },
+  index: { ignore: [], ignoreProjects: [] },
+  masking: { clusterLabels: [] },
+  watch: { snapshotMinFileChanges: DEFAULT_WATCH_SNAPSHOT_MIN_FILE_CHANGES },
+  gate: { enabled: true, sensitivity: "balanced" },
+  cochange: {
+    maxCommits: DEFAULT_COCHANGE_MAX_COMMITS,
+    maxFilesPerCommit: DEFAULT_COCHANGE_MAX_FILES_PER_COMMIT,
+    minShared: DEFAULT_COCHANGE_MIN_SHARED,
+    include: [],
+    exclude: []
+  }
+};
+
+// src/core/config/load-config.ts
+var log = createLogger("ctxo:config");
+function isValidGlob(pattern) {
+  try {
+    picomatch(pattern);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateGlobs(patterns, field, invalid) {
+  if (!patterns) return;
+  for (const p of patterns) {
+    if (!isValidGlob(p)) invalid.push(`${field}: ${p}`);
+  }
+}
+function loadConfig(ctxoRoot) {
+  const path = join(ctxoRoot, "config.yaml");
+  const errors = [];
+  const invalidGlobs = [];
+  if (!existsSync(path)) {
+    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: false };
+  }
+  let raw;
+  try {
+    raw = readFileSync(path, "utf-8");
+  } catch (err) {
+    errors.push(`Cannot read ${path}: ${err.message}`);
+    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: true };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(raw);
+  } catch (err) {
+    errors.push(`Invalid YAML in ${path}: ${err.message}`);
+    log.warn(`Invalid YAML in config.yaml, falling back to defaults: ${err.message}`);
+    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: true };
+  }
+  if (parsed === null || parsed === void 0) {
+    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: true };
+  }
+  const result = CtxoConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      errors.push(`${issue.path.join(".") || "<root>"}: ${issue.message}`);
+    }
+    log.warn(`Invalid config.yaml (${errors.length} issue(s)), falling back to defaults`);
+    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: true };
+  }
+  validateGlobs(result.data.index?.ignore, "index.ignore", invalidGlobs);
+  validateGlobs(result.data.index?.ignoreProjects, "index.ignoreProjects", invalidGlobs);
+  validateGlobs(result.data.index?.tests, "index.tests", invalidGlobs);
+  validateGlobs(result.data.cochange?.include, "cochange.include", invalidGlobs);
+  validateGlobs(result.data.cochange?.exclude, "cochange.exclude", invalidGlobs);
+  validateGlobs(result.data.contextsView?.exclude, "contextsView.exclude", invalidGlobs);
+  validateGlobs(result.data.contextsView?.hubs?.paths, "contextsView.hubs.paths", invalidGlobs);
+  for (const pattern of invalidGlobs) {
+    log.warn(`Invalid glob pattern in config.yaml \u2014 ${pattern}`);
+  }
+  return { config: result.data, errors, invalidGlobs, path, exists: true };
+}
+function statsEnabled(config) {
+  return config.stats?.enabled !== false;
+}
+function indexIgnorePatterns(config) {
+  return (config.index?.ignore ?? []).filter(isValidGlob);
+}
+function indexIgnoreProjectPatterns(config) {
+  return (config.index?.ignoreProjects ?? []).filter(isValidGlob);
+}
+function factsRequested(config) {
+  return config.index?.facts === true;
+}
+function indexTestPatterns(config) {
+  return (config.index?.tests ?? []).filter(isValidGlob);
+}
+function communityDetectorOptions(config) {
+  const section = config.communities;
+  const resolution = section?.resolution;
+  const minBridged = section?.godNodeMinBridged;
+  const maxResults = section?.godNodeMaxResults;
+  return {
+    ...typeof resolution === "number" && Number.isFinite(resolution) && resolution > 0 ? { resolution } : {},
+    ...typeof minBridged === "number" && Number.isInteger(minBridged) && minBridged >= 1 ? { godNodeMinBridged: minBridged } : {},
+    ...typeof maxResults === "number" && Number.isInteger(maxResults) && maxResults >= 0 ? { godNodeMaxResults: maxResults } : {}
+  };
+}
+function maskingClusterLabelPatterns(config) {
+  return (config.masking?.clusterLabels ?? []).filter(isValidGlob);
+}
+function watchSnapshotMinFileChanges(config) {
+  const value = config.watch?.snapshotMinFileChanges;
+  if (typeof value === "number" && Number.isFinite(value) && value >= 1) return value;
+  return DEFAULT_WATCH_SNAPSHOT_MIN_FILE_CHANGES;
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+function positiveIntegerOr(value, fallback) {
+  return isPositiveInteger(value) ? value : fallback;
+}
+function validMaxCommits(value) {
+  if (value === "all") return "all";
+  return isPositiveInteger(value) ? value : void 0;
+}
+function validSince(value) {
+  return typeof value === "string" && parseCoChangeSince(value) !== void 0 ? value : void 0;
+}
+function resolveCoChangeConfig(config, overrides = {}) {
+  const section = config.cochange;
+  const since = validSince(overrides.since) ?? validSince(section?.since);
+  return {
+    maxCommits: validMaxCommits(overrides.maxCommits) ?? validMaxCommits(section?.maxCommits) ?? DEFAULT_COCHANGE_MAX_COMMITS,
+    ...since !== void 0 ? { since } : {},
+    maxFilesPerCommit: positiveIntegerOr(section?.maxFilesPerCommit, DEFAULT_COCHANGE_MAX_FILES_PER_COMMIT),
+    minShared: positiveIntegerOr(section?.minShared, DEFAULT_COCHANGE_MIN_SHARED),
+    include: (section?.include ?? []).filter(isValidGlob),
+    exclude: (section?.exclude ?? []).filter(isValidGlob)
+  };
+}
+function nonNegativeOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function positiveOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function resolveContextsViewConfig(config) {
+  const section = config.contextsView;
+  const hubs = section?.hubs;
+  const topPercent = hubs?.topPercent;
+  return {
+    weights: {
+      dependency: nonNegativeOr(section?.weights?.dependency, 1),
+      coChange: nonNegativeOr(section?.weights?.coChange, 1),
+      data: nonNegativeOr(section?.weights?.data, 0)
+    },
+    exclude: (section?.exclude ?? []).filter(isValidGlob),
+    hubs: {
+      auto: hubs?.auto !== false,
+      topPercent: typeof topPercent === "number" && topPercent > 0 && topPercent <= 100 ? topPercent : 1,
+      minDependents: positiveIntegerOr(hubs?.minDependents, 10),
+      paths: (hubs?.paths ?? []).filter(isValidGlob)
+    },
+    resolution: positiveOr(section?.resolution, 1),
+    minCandidateFiles: positiveIntegerOr(section?.minCandidateFiles, 3),
+    technicalTerms: section?.technicalTerms ? [...section.technicalTerms] : [...DEFAULT_TECHNICAL_TERMS]
+  };
+}
+function makeGlobMatcher(patterns) {
+  if (patterns.length === 0) return () => false;
+  const matchers = patterns.map((p) => picomatch(p, { dot: true }));
+  return (input) => {
+    const normalised = input.replace(/\\/g, "/");
+    return matchers.some((m) => m(normalised));
+  };
+}
+
+// src/core/test-files/test-file-classifier.ts
+var DEFAULT_TEST_GLOBS = [
+  "**/__tests__/**",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/test/**",
+  "**/tests/**",
+  "**/*_test.go",
+  "**/src/test/**",
+  "**/*.Tests/**",
+  "**/*.Test/**",
+  "**/*Tests.cs",
+  "**/*Test.cs",
+  "**/test_*.py",
+  "**/*_test.py"
+];
+var NAME_ONLY_TEST_GLOBS = ["**/*Tests.cs", "**/*Test.cs"];
+var TEST_FRAMEWORK_ANNOTATIONS = [
+  "Fact",
+  "Theory",
+  "SkippableFact",
+  "SkippableTheory",
+  "Test",
+  "TestCase",
+  "TestCaseSource",
+  "TestFixture",
+  "TestMethod",
+  "DataTestMethod",
+  "TestClass"
+];
+function normalisePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function filesWithTestAnnotations(indices) {
+  const names = new Set(TEST_FRAMEWORK_ANNOTATIONS);
+  const files = /* @__PURE__ */ new Set();
+  for (const index of indices) {
+    const marked = index.symbols.some((symbol) => symbol.annotations?.some((annotation) => names.has(annotation.name)));
+    if (marked) files.add(normalisePath(index.file));
+  }
+  return files;
+}
+function hasCSharpAnnotations(indices) {
+  return indices.some(
+    (index) => index.file.endsWith(".cs") && index.symbols.some((symbol) => symbol.annotations && symbol.annotations.length > 0)
+  );
+}
+function createTestFileClassifier(extraGlobs = [], annotatedFiles, options = {}) {
+  const nameOnly = new Set(NAME_ONLY_TEST_GLOBS);
+  const defaults = options.annotationAware === true ? DEFAULT_TEST_GLOBS.filter((glob) => !nameOnly.has(glob)) : DEFAULT_TEST_GLOBS;
+  const matchesGlob = makeGlobMatcher([...defaults, ...extraGlobs]);
+  return (path) => annotatedFiles?.has(normalisePath(path)) === true || matchesGlob(path);
+}
+
+// src/adapters/git/simple-git-adapter.ts
+import { spawnSync } from "child_process";
+import { simpleGit } from "simple-git";
+var log2 = createLogger("ctxo:git");
+var NUL = "\0";
+var RECORD_SEPARATOR = "";
+var FIELD_SEPARATOR = "";
+var CHANGE_LOG_FORMAT = "--format=%x1e%H%x1f%aI%x1f%ct%x1f%an%x1f%s";
+var STABLE_OUTPUT_CONFIG = [
+  "-c",
+  "core.quotepath=off",
+  "-c",
+  "log.showSignature=false"
+];
+function toForwardSlashes(path) {
+  return path.replace(/\\/g, "/");
+}
+function isFileChangeStatus(value) {
+  return value === "A" || value === "M" || value === "D" || value === "R" || value === "C" || value === "T";
+}
+function parseNameStatus(tokens) {
+  const changes = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const kind = (tokens[i] ?? "").trim().charAt(0);
+    if (kind === "") {
+      i += 1;
+    } else if (kind === "R" || kind === "C") {
+      const oldPath = tokens[i + 1];
+      const path = tokens[i + 2];
+      i += 3;
+      if (oldPath !== void 0 && path !== void 0) {
+        changes.push({ status: kind, path: toForwardSlashes(path), oldPath: toForwardSlashes(oldPath) });
+      }
+    } else {
+      const path = tokens[i + 1];
+      i += 2;
+      if (path !== void 0 && isFileChangeStatus(kind)) {
+        changes.push({ status: kind, path: toForwardSlashes(path) });
+      }
+    }
+  }
+  return changes;
+}
+function parseSkipWorktree(raw) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const record of raw.split(NUL)) {
+    if (record.length > 2 && record.charAt(0) === "S" && record.charAt(1) === " ") {
+      paths.add(toForwardSlashes(record.slice(2)));
+    }
+  }
+  return paths;
+}
+function parseChangeLog(raw) {
+  const commits = [];
+  for (const record of raw.split(RECORD_SEPARATOR)) {
+    const [header = "", ...tokens] = record.split(NUL);
+    const [hash, date, time, author, ...subject] = header.split(FIELD_SEPARATOR);
+    const committedAt = Number.parseInt(time ?? "", 10);
+    if (!hash || date === void 0 || author === void 0 || Number.isNaN(committedAt)) continue;
+    commits.push({
+      hash,
+      message: subject.join(FIELD_SEPARATOR).trim(),
+      date,
+      author,
+      committedAt,
+      changes: parseNameStatus(tokens)
+    });
+  }
+  return commits;
+}
+function rangeLogFormat(trailerKey) {
+  const trailers = trailerKey === void 0 ? "" : `%(trailers:key=${trailerKey},valueonly)`;
+  return `--format=%x1e%H%x1f%P%x1f%s%x1f${trailers}%x1f`;
+}
+function parseRangeLog(raw) {
+  const commits = [];
+  for (const record of raw.split(RECORD_SEPARATOR)) {
+    const [header = "", ...tokens] = record.split(NUL);
+    const [hash, parents, subject, trailerText] = header.split(FIELD_SEPARATOR);
+    if (!hash || parents === void 0 || subject === void 0) continue;
+    const isMerge = parents.trim().split(" ").filter((p) => p.length > 0).length > 1;
+    commits.push({
+      hash,
+      subject,
+      isMerge,
+      trailers: (trailerText ?? "").split("\n").map((t) => t.trim()).filter((t) => t.length > 0),
+      changes: isMerge ? [] : parseNameStatus(tokens)
+    });
+  }
+  return commits;
+}
+function parseStatus(raw) {
+  const tokens = raw.split(NUL);
+  const changes = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const entry = tokens[i] ?? "";
+    if (entry.length < 4) continue;
+    const x = entry.charAt(0);
+    const y = entry.charAt(1);
+    const path = toForwardSlashes(entry.slice(3));
+    if (x === "R" || x === "C" || y === "R" || y === "C") {
+      const oldPath = tokens[++i];
+      if (oldPath === void 0) continue;
+      const status = x === "R" || y === "R" ? "R" : "C";
+      changes.push({ status, path, oldPath: toForwardSlashes(oldPath) });
+    } else if (x === "?") {
+      changes.push({ status: "A", path });
+    } else if (x === "D" || y === "D") {
+      changes.push({ status: "D", path });
+    } else if (x === "A" || y === "A") {
+      changes.push({ status: "A", path });
+    } else {
+      changes.push({ status: "M", path });
+    }
+  }
+  return changes;
+}
+function parseBranchNames(raw) {
+  const local = /* @__PURE__ */ new Set();
+  const remote = /* @__PURE__ */ new Set();
+  for (const line of raw.split("\n")) {
+    const ref = line.trim();
+    if (ref.startsWith("refs/heads/")) {
+      local.add(ref.slice("refs/heads/".length));
+    } else if (ref.startsWith("refs/remotes/") && !/^refs\/remotes\/[^/]+\/HEAD$/.test(ref)) {
+      remote.add(ref.slice("refs/remotes/".length));
+    }
+  }
+  const sorted = (set) => [...set].sort(compareCodepoint);
+  return { local: sorted(local), remote: sorted(remote), all: sorted(/* @__PURE__ */ new Set([...local, ...remote])) };
+}
+var TRAILER_KEY = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
+var SimpleGitAdapter = class {
+  git;
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.git = simpleGit(projectRoot);
+    log2.debug("Initialized with root: %s", projectRoot);
+  }
+  async isAvailable() {
+    try {
+      await this.git.version();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getCommitHistory(filePath, maxCount) {
+    try {
+      const log3 = await this.git.log({
+        file: filePath,
+        "--follow": null,
+        ...maxCount ? { maxCount } : {}
+      });
+      return log3.all.map((entry) => ({
+        hash: entry.hash,
+        message: entry.message,
+        date: entry.date,
+        author: entry.author_name
+      }));
+    } catch (err) {
+      log2.error(` Failed to get history for ${filePath}: ${err.message}`);
+      return [];
+    }
+  }
+  async getChangedFiles(since) {
+    try {
+      const diff = await this.git.diffSummary([since]);
+      return diff.files.map((f) => f.file.replace(/\\/g, "/"));
+    } catch (err) {
+      log2.error(` Failed to get changed files since ${since}: ${err.message}`);
+      return [];
+    }
+  }
+  async getFileChurn(filePath) {
+    try {
+      const log3 = await this.git.log({ file: filePath, "--follow": null });
+      return {
+        filePath,
+        commitCount: log3.total
+      };
+    } catch (err) {
+      log2.error(` Failed to get churn for ${filePath}: ${err.message}`);
+      return { filePath, commitCount: 0 };
+    }
+  }
+  async getHeadSha() {
+    try {
+      const raw = await this.git.revparse(["--short", "HEAD"]);
+      const sha = raw.trim();
+      return sha.length > 0 ? sha : void 0;
+    } catch (err) {
+      log2.error(`Failed to resolve HEAD: ${err.message}`);
+      return void 0;
+    }
+  }
+  async countCommitsBetween(base) {
+    try {
+      const raw = await this.git.raw(["rev-list", "--count", `${base}..HEAD`]);
+      const n = parseInt(raw.trim(), 10);
+      return Number.isFinite(n) && n >= 0 ? n : void 0;
+    } catch (err) {
+      log2.error(`Failed to count commits since ${base}: ${err.message}`);
+      return void 0;
+    }
+  }
+  async getChangeLog(maxCommits) {
+    try {
+      const headRaw = await this.git.raw([...STABLE_OUTPUT_CONFIG, "log", "-1", "--format=%h%x1f%ct", "HEAD"]);
+      const [head, headTime] = headRaw.trim().split(FIELD_SEPARATOR);
+      const headCommittedAt = Number.parseInt(headTime ?? "", 10);
+      if (!head || Number.isNaN(headCommittedAt)) {
+        throw new Error(`unexpected HEAD description ${JSON.stringify(headRaw)}`);
+      }
+      const args = [...STABLE_OUTPUT_CONFIG, "log", "--no-merges", "-M", "--name-status", "-z", CHANGE_LOG_FORMAT];
+      if (maxCommits !== "all") args.push(`--max-count=${maxCommits}`);
+      args.push("HEAD");
+      return { head, headCommittedAt, commits: parseChangeLog(await this.git.raw(args)) };
+    } catch (err) {
+      log2.error(`Failed to read change log: ${err.message}`);
+      return void 0;
+    }
+  }
+  async getSkipWorktreePaths() {
+    try {
+      return parseSkipWorktree(await this.git.raw([...STABLE_OUTPUT_CONFIG, "ls-files", "-t", "-z"]));
+    } catch (err) {
+      log2.error(`Failed to list skip-worktree paths: ${err.message}`);
+      return void 0;
+    }
+  }
+  async getIgnoredPaths(paths) {
+    if (paths.length === 0) return /* @__PURE__ */ new Set();
+    const result = spawnSync("git", [...STABLE_OUTPUT_CONFIG, "check-ignore", "-z", "--stdin"], {
+      cwd: this.projectRoot,
+      input: paths.map((path) => `${path}${NUL}`).join(""),
+      encoding: "utf-8",
+      maxBuffer: 64 * 1024 * 1024
+    });
+    if (result.error === void 0 && result.status === 1) return /* @__PURE__ */ new Set();
+    if (result.error !== void 0 || result.status !== 0) {
+      const reason = (result.error?.message ?? result.stderr ?? "").replace(/\s+/g, " ").trim();
+      log2.error(`Failed to check ignored paths: ${reason}`);
+      return void 0;
+    }
+    return new Set(
+      result.stdout.split(NUL).filter((path) => path.length > 0).map(toForwardSlashes)
+    );
+  }
+  async resolveCommit(ref) {
+    if (this.refuseOptionLike("resolve", [ref])) return void 0;
+    try {
+      const sha = (await this.git.raw([...STABLE_OUTPUT_CONFIG, "rev-parse", "--verify", "--quiet", `${ref}^{commit}`])).trim();
+      return sha.length > 0 ? sha : void 0;
+    } catch (err) {
+      log2.debug(`Cannot resolve ${ref}: ${err.message}`);
+      return void 0;
+    }
+  }
+  async mergeBase(a, b) {
+    if (this.refuseOptionLike("merge-base", [a, b])) return void 0;
+    try {
+      const sha = (await this.git.raw([...STABLE_OUTPUT_CONFIG, "merge-base", a, b])).trim();
+      return sha.length > 0 ? sha : void 0;
+    } catch (err) {
+      log2.debug(`No merge base for ${a} and ${b}: ${err.message}`);
+      return void 0;
+    }
+  }
+  async isAncestor(ancestor, descendant) {
+    if (this.refuseOptionLike("is-ancestor", [ancestor, descendant])) return void 0;
+    const result = spawnSync("git", [...STABLE_OUTPUT_CONFIG, "merge-base", "--is-ancestor", ancestor, descendant], {
+      cwd: this.projectRoot,
+      encoding: "utf-8"
+    });
+    if (result.error === void 0 && result.status === 0) return true;
+    if (result.error === void 0 && result.status === 1) return false;
+    log2.debug(`Cannot tell whether ${ancestor} is an ancestor of ${descendant}`);
+    return void 0;
+  }
+  async getRangeLog(range, options) {
+    if (this.refuseOptionLike("range log", [range.head, ...range.exclude])) return void 0;
+    const trailerKey = options?.trailerKey;
+    if (trailerKey !== void 0 && !TRAILER_KEY.test(trailerKey)) {
+      log2.error(`Refusing to read trailers for invalid key ${JSON.stringify(trailerKey)}`);
+      return void 0;
+    }
+    try {
+      const raw = await this.git.raw([
+        ...STABLE_OUTPUT_CONFIG,
+        "log",
+        "-M",
+        "--name-status",
+        "-z",
+        rangeLogFormat(trailerKey),
+        range.head,
+        ...range.exclude.map((ref) => `^${ref}`),
+        "--"
+      ]);
+      return parseRangeLog(raw);
+    } catch (err) {
+      log2.error(`Failed to read range log of ${range.head}: ${err.message}`);
+      return void 0;
+    }
+  }
+  async getWorkingTreeChanges(scope) {
+    try {
+      if (scope === "staged") {
+        const raw2 = await this.git.raw([...STABLE_OUTPUT_CONFIG, "diff", "--cached", "-M", "--name-status", "-z"]);
+        return parseNameStatus(raw2.split(NUL));
+      }
+      const raw = await this.git.raw([...STABLE_OUTPUT_CONFIG, "-c", "status.renames=true", "status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+      return parseStatus(raw);
+    } catch (err) {
+      log2.error(`Failed to read ${scope} working-tree changes: ${err.message}`);
+      return void 0;
+    }
+  }
+  async getRefs() {
+    let names;
+    try {
+      names = parseBranchNames(
+        await this.git.raw([...STABLE_OUTPUT_CONFIG, "for-each-ref", "--format=%(refname)", "refs/heads", "refs/remotes"])
+      );
+    } catch (err) {
+      log2.error(`Failed to list branches: ${err.message}`);
+      return void 0;
+    }
+    const currentBranch = await this.tryRaw(["symbolic-ref", "--quiet", "--short", "HEAD"]);
+    const upstream = await this.tryRaw(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
+    const originHead = await this.tryRaw(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
+    return {
+      ...currentBranch !== void 0 ? { currentBranch } : {},
+      ...upstream !== void 0 ? { upstream } : {},
+      ...originHead !== void 0 ? { originHead } : {},
+      branches: names.all,
+      localBranches: names.local,
+      remoteBranches: names.remote
+    };
+  }
+  async listTrackedFiles() {
+    try {
+      const raw = await this.git.raw([...STABLE_OUTPUT_CONFIG, "ls-files", "-z"]);
+      return raw.split(NUL).filter((path) => path.length > 0).map(toForwardSlashes);
+    } catch (err) {
+      log2.error(`Failed to list tracked files: ${err.message}`);
+      return void 0;
+    }
+  }
+  /** Runs one git call whose failure only means "no such fact"; logged at debug, not error. */
+  async tryRaw(args) {
+    try {
+      const out = (await this.git.raw([...STABLE_OUTPUT_CONFIG, ...args])).trim();
+      return out.length > 0 ? out : void 0;
+    } catch (err) {
+      log2.debug(`git ${args[0]} unavailable: ${err.message}`);
+      return void 0;
+    }
+  }
+  /** A ref is never an option; true (and logged) when one would be parsed as such. */
+  refuseOptionLike(what, refs) {
+    const bad = refs.find((ref) => ref.startsWith("-"));
+    if (bad === void 0) return false;
+    log2.error(`Refusing ${what} for option-like ref ${bad}`);
+    return true;
+  }
+  async getCommitFileChanges(rev) {
+    if (rev.startsWith("-")) {
+      log2.error(`Refusing to read file changes for option-like revision ${rev}`);
+      return void 0;
+    }
+    try {
+      const raw = await this.git.raw([
+        ...STABLE_OUTPUT_CONFIG,
+        "diff-tree",
+        "--root",
+        "--no-commit-id",
+        "-r",
+        "-M",
+        "--name-status",
+        "-z",
+        rev
+      ]);
+      return parseNameStatus(raw.split(NUL));
+    } catch (err) {
+      log2.error(`Failed to read file changes of ${rev}: ${err.message}`);
+      return void 0;
+    }
+  }
+};
+
+// src/core/data-coupling/data-kinds.ts
+import { DATA_RESOURCE_KINDS } from "@ctxo/plugin-api";
+var DATA_EDGE_KINDS = /* @__PURE__ */ new Set(["reads", "writes", "executes"]);
+var PROCEDURE_KINDS = ["procedure"];
+function isDataResourceKind(kind) {
+  return DATA_RESOURCE_KINDS.includes(kind);
+}
+function dataReferenceKinds(kind) {
+  if (isDataResourceKind(kind)) return DATA_RESOURCE_KINDS;
+  if (kind === "procedure") return PROCEDURE_KINDS;
+  return void 0;
+}
+
+// src/core/graph/symbol-graph.ts
+var isDefaultTestFile = createTestFileClassifier();
+var DOCUMENTATION_FOLDERS = /* @__PURE__ */ new Set(["docs", "doc", "documentation"]);
+function asciiLower(text) {
+  return text.replace(/[A-Z]/g, (c) => String.fromCharCode(c.charCodeAt(0) + 32));
+}
+function isUnderDocumentationFolder(file) {
+  const folders = file.replace(/\\/g, "/").split("/").slice(0, -1);
+  return folders.some((folder) => DOCUMENTATION_FOLDERS.has(asciiLower(folder)));
+}
+function definitionRank(symbolId) {
+  const at = symbolId.indexOf("::");
+  const file = at < 0 ? symbolId : symbolId.slice(0, at);
+  return (isDefaultTestFile(file) ? 2 : 0) + (isUnderDocumentationFolder(file) ? 1 : 0);
+}
+var SymbolGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  nodesByFileAndName = /* @__PURE__ */ new Map();
+  nodesByNameAndKind = /* @__PURE__ */ new Map();
+  forwardEdges = /* @__PURE__ */ new Map();
+  reverseEdges = /* @__PURE__ */ new Map();
+  definitionRanks = /* @__PURE__ */ new Map();
+  edgeSet = /* @__PURE__ */ new Set();
+  addNode(node) {
+    this.nodes.set(node.symbolId, node);
+    const parts = node.symbolId.split("::");
+    const [p0, p1] = parts;
+    if (p0 !== void 0 && p1 !== void 0) {
+      this.nodesByFileAndName.set(`${p0}::${p1}`, node);
+    }
+    if (parts.length === 3) {
+      const nk = `${parts[1]}::${parts[2]}`;
+      const list = this.nodesByNameAndKind.get(nk);
+      if (list) list.push(node);
+      else this.nodesByNameAndKind.set(nk, [node]);
+    }
+  }
+  addEdge(edge) {
+    const resolvedFrom = this.resolveNodeId(edge.from);
+    const resolvedTo = this.resolveNodeId(edge.to);
+    const resolvedEdge = { from: resolvedFrom, to: resolvedTo, kind: edge.kind };
+    const edgeKey = `${resolvedEdge.from}|${resolvedEdge.to}|${resolvedEdge.kind}`;
+    if (this.edgeSet.has(edgeKey)) return;
+    this.edgeSet.add(edgeKey);
+    const forward = this.forwardEdges.get(resolvedEdge.from) ?? [];
+    forward.push(resolvedEdge);
+    this.forwardEdges.set(resolvedEdge.from, forward);
+    const reverse = this.reverseEdges.get(resolvedEdge.to) ?? [];
+    reverse.push(resolvedEdge);
+    this.reverseEdges.set(resolvedEdge.to, reverse);
+  }
+  getNode(symbolId) {
+    return this.nodes.get(symbolId) ?? this.resolveNodeFuzzy(symbolId);
+  }
+  resolveNodeId(id) {
+    if (this.nodes.has(id)) return id;
+    const segs = id.split("::");
+    const [p0, p1] = segs;
+    if (p0 !== void 0 && p1 !== void 0) {
+      const fuzzyKey = `${p0}::${p1}`;
+      const match = this.nodesByFileAndName.get(fuzzyKey);
+      if (match) return match.symbolId;
+      const jsToTs = p0.replace(/\.js$/, ".ts");
+      if (jsToTs !== p0) {
+        const altKey = `${jsToTs}::${p1}`;
+        const altMatch = this.nodesByFileAndName.get(altKey);
+        if (altMatch) return altMatch.symbolId;
+      }
+    }
+    const dataMatch = this.resolveDataReference(segs);
+    if (dataMatch) return dataMatch.symbolId;
+    const nameKind = this.extractNameKind(segs);
+    if (nameKind) {
+      const candidates = this.nodesByNameAndKind.get(nameKind);
+      if (candidates && candidates.length === 1) return candidates[0].symbolId;
+    }
+    return id;
+  }
+  resolveNodeFuzzy(id) {
+    const segs = id.split("::");
+    const [p0, p1] = segs;
+    if (p0 !== void 0 && p1 !== void 0) {
+      const match = this.nodesByFileAndName.get(`${p0}::${p1}`);
+      if (match) return match;
+      const jsToTs = p0.replace(/\.js$/, ".ts");
+      if (jsToTs !== p0) {
+        const tsMatch = this.nodesByFileAndName.get(`${jsToTs}::${p1}`);
+        if (tsMatch) return tsMatch;
+      }
+    }
+    const dataMatch = this.resolveDataReference(segs);
+    if (dataMatch) return dataMatch;
+    const nameKind = this.extractNameKind(segs);
+    if (nameKind) {
+      const candidates = this.nodesByNameAndKind.get(nameKind);
+      if (candidates && candidates.length === 1) return candidates[0];
+    }
+    return void 0;
+  }
+  /**
+   * Resolves a 2-part data reference (`dbo.loans::table`). A table or view reference is kind-agnostic
+   * across data resource kinds, a procedure reference matches procedures only. Several definitions
+   * resolve by `definitionRank` (a production copy before a documentation copy before a test copy), then
+   * to the codepoint-smallest symbolId, which is the first file in sorted path order. The result does
+   * not depend on insertion order.
+   */
+  resolveDataReference(segs) {
+    if (segs.length !== 2) return void 0;
+    const [name, kind] = segs;
+    const kinds = dataReferenceKinds(kind);
+    if (!kinds) return void 0;
+    let best;
+    for (const k of kinds) {
+      for (const node of this.nodesByNameAndKind.get(`${name}::${k}`) ?? []) {
+        if (!best || this.compareDefinitions(node, best) < 0) best = node;
+      }
+    }
+    return best;
+  }
+  /** The tie-break order of same-name definitions: `definitionRank`, then the codepoint-smaller symbolId. */
+  compareDefinitions = (a, b) => this.definitionRankOf(a.symbolId) - this.definitionRankOf(b.symbolId) || compareCodepoint(a.symbolId, b.symbolId);
+  /**
+   * The identity of the table, view or procedure that `id` names: a full id of any of its definitions, or a
+   * 2-part reference such as `dbo.loans::table`. Undefined when `id` names no node, or a node of another
+   * kind. A table or view identity spans both kinds, as a 2-part `::table` reference does.
+   */
+  dataResourceIdentity(id) {
+    const node = this.getNode(id);
+    return node ? this.identityOf(node) : void 0;
+  }
+  identityOf(node) {
+    const segs = node.symbolId.split("::");
+    if (segs.length !== 3) return void 0;
+    const [, name, kind] = segs;
+    const kinds = dataReferenceKinds(kind);
+    if (!kinds) return void 0;
+    const byId = /* @__PURE__ */ new Map();
+    for (const k of kinds) {
+      for (const definition of this.nodesByNameAndKind.get(`${name}::${k}`) ?? []) {
+        byId.set(definition.symbolId, this.nodes.get(definition.symbolId) ?? definition);
+      }
+    }
+    const definitions = [...byId.values()].sort(this.compareDefinitions);
+    const winner = definitions[0] ?? node;
+    const production = definitions.filter((definition) => this.definitionRankOf(definition.symbolId) === 0);
+    return { canonicalId: `${name}::${winner.kind}`, winner, definitions, production };
+  }
+  /** `definitionRank`, cached per symbolId (the glob match runs once per definition). */
+  definitionRankOf(symbolId) {
+    let rank = this.definitionRanks.get(symbolId);
+    if (rank === void 0) {
+      rank = definitionRank(symbolId);
+      this.definitionRanks.set(symbolId, rank);
+    }
+    return rank;
+  }
+  /**
+   * Extracts a `name::kind` key from the segments of a reference ID, supporting:
+   *   - 2-part: `Bar::class`                  → `Bar::class`
+   *   - 3-part: `pkg.Bar::helper::method`      → `helper::method`
+   * Returns undefined for 1-part IDs (no kind information available).
+   */
+  extractNameKind(segs) {
+    if (segs.length === 3) return `${segs[1]}::${segs[2]}`;
+    if (segs.length === 2) return `${segs[0]}::${segs[1]}`;
+    return void 0;
+  }
+  getForwardEdges(symbolId) {
+    return this.forwardEdges.get(symbolId) ?? [];
+  }
+  getReverseEdges(symbolId) {
+    return this.reverseEdges.get(symbolId) ?? [];
+  }
+  /**
+   * The dependents of a resolved symbolId, as the impact tools read them. For a definition of a table, view
+   * or procedure these are the incoming edges of every same-name definition, which in practice are the
+   * winner's: any copy then reports the dependents of the resource. For every other id they are its own
+   * incoming edges, as `getReverseEdges` gives them.
+   */
+  getDependentEdges(symbolId) {
+    const node = this.nodes.get(symbolId);
+    const definitions = node ? this.identityOf(node)?.definitions : void 0;
+    if (!definitions || definitions.length < 2) return this.getReverseEdges(symbolId);
+    return definitions.flatMap((definition) => this.getReverseEdges(definition.symbolId));
+  }
+  hasNode(symbolId) {
+    return this.nodes.has(symbolId) || this.resolveNodeFuzzy(symbolId) !== void 0;
+  }
+  get nodeCount() {
+    return this.nodes.size;
+  }
+  get edgeCount() {
+    return this.edgeSet.size;
+  }
+  allNodes() {
+    return [...this.nodes.values()];
+  }
+  allEdges() {
+    const edges = [];
+    for (const list of this.forwardEdges.values()) {
+      edges.push(...list);
+    }
+    return edges;
+  }
+};
+
+export {
+  parseCoChangeSince,
+  windowCutoff,
+  selectWindow,
+  loadConfig,
+  statsEnabled,
+  indexIgnorePatterns,
+  indexIgnoreProjectPatterns,
+  factsRequested,
+  indexTestPatterns,
+  communityDetectorOptions,
+  maskingClusterLabelPatterns,
+  watchSnapshotMinFileChanges,
+  resolveCoChangeConfig,
+  resolveContextsViewConfig,
+  makeGlobMatcher,
+  TEST_FRAMEWORK_ANNOTATIONS,
+  filesWithTestAnnotations,
+  hasCSharpAnnotations,
+  createTestFileClassifier,
+  SimpleGitAdapter,
+  DATA_EDGE_KINDS,
+  isDataResourceKind,
+  SymbolGraph
+};
+//# sourceMappingURL=chunk-7HSA5JVP.js.map