codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/project-config-service.js

@@ -0,0 +1,474 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_config_service_exports = {};
+__export(project_config_service_exports, {
+  getEffectiveAttachmentLocation: () => getEffectiveAttachmentLocation,
+  getEffectiveDefaultVisibility: () => getEffectiveDefaultVisibility,
+  getEffectiveSensorConfig: () => getEffectiveSensorConfig,
+  getProjectConfig: () => getProjectConfig,
+  invalidateProjectConfigCache: () => invalidateProjectConfigCache,
+  listChannelRoutingRules: () => listChannelRoutingRules,
+  matchChannelRoutingRules: () => matchChannelRoutingRules,
+  parsePlansFolderRef: () => parsePlansFolderRef,
+  resetProjectConfigCache: () => resetProjectConfigCache,
+  startProjectConfigWatcher: () => startProjectConfigWatcher,
+  stopProjectConfigWatcher: () => stopProjectConfigWatcher,
+  updateProjectConfig: () => updateProjectConfig
+});
+module.exports = __toCommonJS(project_config_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_types = require("../../shared/types");
+var import_settings_service = require("./settings-service");
+var import_recurrence_rule = require("./recurrence-rule");
+var import_architecture_rule = require("./architecture-rule");
+const CONFIG_DIR = ".codetrellis";
+const CONFIG_FILE = "config.json";
+const cache = /* @__PURE__ */ new Map();
+function configPath(projectRoot) {
+  return import_node_path.default.join(projectRoot, CONFIG_DIR, CONFIG_FILE);
+}
+function normaliseProjectRoot(projectRoot) {
+  return import_node_path.default.resolve(projectRoot);
+}
+function getProjectConfig(projectRoot) {
+  const key = normaliseProjectRoot(projectRoot);
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const filePath = configPath(key);
+  if (!import_node_fs.default.existsSync(filePath)) {
+    cache.set(key, import_types.EMPTY_PROJECT_CONFIG);
+    return import_types.EMPTY_PROJECT_CONFIG;
+  }
+  try {
+    const raw = JSON.parse(import_node_fs.default.readFileSync(filePath, "utf-8"));
+    const parsed = parseProjectConfig(raw);
+    cache.set(key, parsed);
+    return parsed;
+  } catch (err) {
+    console.warn(`[ProjectConfig] Failed to read ${filePath} \u2014 falling back to empty config:`, err);
+    cache.set(key, import_types.EMPTY_PROJECT_CONFIG);
+    return import_types.EMPTY_PROJECT_CONFIG;
+  }
+}
+function parsePlansFolderRef(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const r = raw;
+  if (r.kind === "git") {
+    const remote = typeof r.remote === "string" ? r.remote.trim() : "";
+    if (!remote || remote.length > 400 || /\s/.test(remote)) return null;
+    if (/^[a-z][a-z0-9+.-]*:\/\/[^/@]*:[^/@]*@/i.test(remote)) return null;
+    return { kind: "git", remote };
+  }
+  if (r.kind === "synced") {
+    const provider = r.provider === "onedrive" || r.provider === "sharepoint" || r.provider === "folder" ? r.provider : null;
+    const place = typeof r.place === "string" ? r.place.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "") : "";
+    if (!provider || !place || place.length > 512) return null;
+    if (/^[a-z]:/i.test(place) || place.split("/").some((seg) => seg === "" || seg === "." || seg === "..")) return null;
+    return { kind: "synced", provider, place };
+  }
+  return null;
+}
+function updateProjectConfig(projectRoot, patch) {
+  const key = normaliseProjectRoot(projectRoot);
+  const current = getProjectConfig(key);
+  const next = {
+    plans: { ...current.plans ?? {}, ...patch.plans ?? {} },
+    channels: {
+      ...current.channels ?? {},
+      ...patch.channels ?? {},
+      // Routing rules replaced wholesale when present.
+      ...patch.channels?.routing !== void 0 ? { routing: patch.channels.routing } : {}
+    },
+    // Phase 4.1 — sensors: deep-merge per-sensor group.
+    sensors: mergeSensorConfig(current.sensors, patch.sensors),
+    // Phase 3.6 — repoRole is a flat scalar; patch wins when present.
+    repoRole: patch.repoRole !== void 0 ? patch.repoRole : current.repoRole,
+    // Phase 31 §10.1 — also a flat scalar.
+    defaultSurface: patch.defaultSurface !== void 0 ? patch.defaultSurface : current.defaultSurface,
+    // Phase 6.5 — freeze periods: replace wholesale when present.
+    freeze: patch.freeze !== void 0 ? patch.freeze : current.freeze,
+    // Phase 32 C4 — recurring playbooks: replaced wholesale, like routing.
+    recurring: patch.recurring !== void 0 ? patch.recurring : current.recurring,
+    // Phase 32 A7 — architecture rules: replaced wholesale, like recurring.
+    rules: patch.rules !== void 0 ? patch.rules : current.rules,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (next.plans) {
+    for (const k of Object.keys(next.plans)) {
+      if (next.plans[k] === void 0) delete next.plans[k];
+    }
+  }
+  if (next.plans && Object.keys(next.plans).length === 0) {
+    delete next.plans;
+  }
+  if (next.channels && Object.keys(next.channels).length === 0) {
+    delete next.channels;
+  }
+  if (next.sensors && Object.keys(next.sensors).length === 0) {
+    delete next.sensors;
+  }
+  if (next.freeze && !next.freeze.active && !next.freeze.reason) {
+    delete next.freeze;
+  }
+  if (next.repoRole === void 0 || next.repoRole === "mixed") {
+    delete next.repoRole;
+  }
+  if (!next.recurring || next.recurring.length === 0) delete next.recurring;
+  if (!next.rules || next.rules.length === 0) delete next.rules;
+  if (next.defaultSurface === void 0 || next.defaultSurface === "graph") {
+    delete next.defaultSurface;
+  }
+  saveProjectConfig(key, next);
+  cache.set(key, next);
+  return next;
+}
+function invalidateProjectConfigCache(projectRoot) {
+  if (projectRoot) {
+    cache.delete(normaliseProjectRoot(projectRoot));
+  } else {
+    cache.clear();
+  }
+}
+function resetProjectConfigCache() {
+  cache.clear();
+}
+function getEffectiveDefaultVisibility(projectRoot) {
+  const projectOverride = getProjectConfig(projectRoot).plans?.defaultVisibility;
+  return projectOverride ?? (0, import_settings_service.getSettings)().plans.defaultVisibility;
+}
+function getEffectiveAttachmentLocation(projectRoot) {
+  const projectOverride = getProjectConfig(projectRoot).plans?.attachmentLocation;
+  return projectOverride ?? (0, import_settings_service.getSettings)().plans.attachmentLocation;
+}
+function listChannelRoutingRules(projectRoot) {
+  const cfg = getProjectConfig(projectRoot);
+  const rules = cfg.channels?.routing ?? [];
+  return rules.filter((r) => r.enabled !== false);
+}
+function matchChannelRoutingRules(projectRoot, event) {
+  const rules = listChannelRoutingRules(projectRoot);
+  return rules.filter((r) => matches(r.when, event));
+}
+function matches(when, event) {
+  if (when.eventType && when.eventType !== event.eventType) return false;
+  if (when.status && when.status !== event.status) return false;
+  if (when.planUid && when.planUid !== event.planUid) return false;
+  if (when.itemUid && when.itemUid !== event.itemUid) return false;
+  return true;
+}
+function mergeSensorConfig(current, patch) {
+  if (!patch) return current;
+  if (!current) return patch;
+  const merged = {};
+  if (current.drift || patch.drift) {
+    merged.drift = { ...current.drift ?? {}, ...patch.drift ?? {} };
+  }
+  if (current.docs || patch.docs) {
+    merged.docs = { ...current.docs ?? {}, ...patch.docs ?? {} };
+  }
+  if (current.stuck || patch.stuck) {
+    merged.stuck = { ...current.stuck ?? {}, ...patch.stuck ?? {} };
+  }
+  if (current.awareness || patch.awareness) {
+    merged.awareness = { ...current.awareness ?? {}, ...patch.awareness ?? {} };
+  }
+  if (merged.drift && Object.keys(merged.drift).length === 0) delete merged.drift;
+  if (merged.docs && Object.keys(merged.docs).length === 0) delete merged.docs;
+  if (merged.stuck && Object.keys(merged.stuck).length === 0) delete merged.stuck;
+  if (merged.awareness && Object.keys(merged.awareness).length === 0) delete merged.awareness;
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function getEffectiveSensorConfig(projectRoot) {
+  const cfg = getProjectConfig(projectRoot).sensors;
+  return {
+    drift: {
+      enabled: cfg?.drift?.enabled ?? import_types.SENSOR_DEFAULTS.drift.enabled,
+      channelEvents: cfg?.drift?.channelEvents ?? import_types.SENSOR_DEFAULTS.drift.channelEvents,
+      debounceMs: cfg?.drift?.debounceMs ?? import_types.SENSOR_DEFAULTS.drift.debounceMs
+    },
+    docs: {
+      enabled: cfg?.docs?.enabled ?? import_types.SENSOR_DEFAULTS.docs.enabled,
+      channelEvents: cfg?.docs?.channelEvents ?? import_types.SENSOR_DEFAULTS.docs.channelEvents
+    },
+    stuck: {
+      enabled: cfg?.stuck?.enabled ?? import_types.SENSOR_DEFAULTS.stuck.enabled,
+      repetitionThreshold: cfg?.stuck?.repetitionThreshold ?? import_types.SENSOR_DEFAULTS.stuck.repetitionThreshold,
+      errorLoopThreshold: cfg?.stuck?.errorLoopThreshold ?? import_types.SENSOR_DEFAULTS.stuck.errorLoopThreshold,
+      idleMinutes: cfg?.stuck?.idleMinutes ?? import_types.SENSOR_DEFAULTS.stuck.idleMinutes
+    },
+    awareness: {
+      branchWindowDays: validDays(cfg?.awareness?.branchWindowDays) ?? import_types.SENSOR_DEFAULTS.awareness.branchWindowDays,
+      // Only an explicit false turns them off: a hand-edited value that is not a boolean keeps the default.
+      inlineNotices: cfg?.awareness?.inlineNotices === false ? false : import_types.SENSOR_DEFAULTS.awareness.inlineNotices,
+      // Opt-in: only an explicit true holds sign-off.
+      holdSignOffOnHighSignals: cfg?.awareness?.holdSignOffOnHighSignals === true
+    }
+  };
+}
+function validDays(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : void 0;
+}
+const watchersByProject = /* @__PURE__ */ new Map();
+function startProjectConfigWatcher(projectRoot) {
+  const key = normaliseProjectRoot(projectRoot);
+  if (watchersByProject.has(key)) return;
+  const filePath = configPath(key);
+  const dir = import_node_path.default.dirname(filePath);
+  try {
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    console.warn(`[ProjectConfig] Could not pre-create ${dir}:`, err);
+  }
+  const watcher = import_chokidar.default.watch(dir, {
+    ignoreInitial: true,
+    persistent: true,
+    depth: 0,
+    // only watch the .codetrellis/ root, not subdirectories
+    awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 }
+  });
+  watcher.on("all", (event, changedPath) => {
+    if (!changedPath) return;
+    if (import_node_path.default.basename(changedPath) !== CONFIG_FILE) return;
+    if (event !== "add" && event !== "change" && event !== "unlink") return;
+    invalidateProjectConfigCache(key);
+  });
+  watcher.on("error", (err) => {
+    console.warn(`[ProjectConfig] Watcher error for ${dir} (continuing):`, err);
+  });
+  watchersByProject.set(key, watcher);
+}
+async function stopProjectConfigWatcher(projectRoot) {
+  const key = normaliseProjectRoot(projectRoot);
+  const watcher = watchersByProject.get(key);
+  if (!watcher) return;
+  watchersByProject.delete(key);
+  await watcher.close();
+}
+function saveProjectConfig(projectRoot, config) {
+  const filePath = configPath(projectRoot);
+  try {
+    const dir = import_node_path.default.dirname(filePath);
+    if (!import_node_fs.default.existsSync(dir)) {
+      import_node_fs.default.mkdirSync(dir, { recursive: true });
+    }
+    const tmpPath = `${filePath}.tmp`;
+    import_node_fs.default.writeFileSync(tmpPath, JSON.stringify(config, null, 2));
+    import_node_fs.default.renameSync(tmpPath, filePath);
+  } catch (err) {
+    console.error(`[ProjectConfig] Failed to save ${filePath}:`, err);
+  }
+}
+function parseProjectConfig(raw) {
+  if (!raw || typeof raw !== "object") return import_types.EMPTY_PROJECT_CONFIG;
+  const r = raw;
+  const result = {};
+  const plansRaw = r.plans;
+  if (plansRaw && typeof plansRaw === "object") {
+    const p = plansRaw;
+    const plansOut = {};
+    if (p.defaultVisibility === "shared" || p.defaultVisibility === "local") {
+      plansOut.defaultVisibility = p.defaultVisibility;
+    }
+    if (p.attachmentLocation === "project" || p.attachmentLocation === "user") {
+      plansOut.attachmentLocation = p.attachmentLocation;
+    }
+    const folder = parsePlansFolderRef(p.folder);
+    if (folder) plansOut.folder = folder;
+    if (Object.keys(plansOut).length > 0) result.plans = plansOut;
+  }
+  const channelsRaw = r.channels;
+  if (channelsRaw && typeof channelsRaw === "object") {
+    const c = channelsRaw;
+    const channelsOut = {};
+    if (Array.isArray(c.routing)) {
+      const rules = [];
+      for (const item of c.routing) {
+        const rule = parseRoutingRule(item);
+        if (rule) rules.push(rule);
+      }
+      if (rules.length > 0) channelsOut.routing = rules;
+    }
+    if (Object.keys(channelsOut).length > 0) result.channels = channelsOut;
+  }
+  const sensorsRaw = r.sensors;
+  if (sensorsRaw && typeof sensorsRaw === "object") {
+    const s = sensorsRaw;
+    const sensors = parseSensorConfig(s);
+    if (sensors && Object.keys(sensors).length > 0) result.sensors = sensors;
+  }
+  if (r.repoRole === "planning" || r.repoRole === "code" || r.repoRole === "mixed") {
+    result.repoRole = r.repoRole;
+  }
+  if (r.defaultSurface === "code" || r.defaultSurface === "brief") {
+    result.defaultSurface = r.defaultSurface;
+  }
+  if (Array.isArray(r.recurring)) {
+    const rules = r.recurring.map((x) => (0, import_recurrence_rule.parseRecurrenceRule)(x).rule).filter((x) => !!x);
+    if (rules.length > 0) result.recurring = rules;
+  }
+  if (Array.isArray(r.rules)) {
+    const rules = r.rules.map((x) => (0, import_architecture_rule.parseArchitectureRule)(x).rule).filter((x) => !!x);
+    if (rules.length > 0) result.rules = rules;
+  }
+  const freezeRaw = r.freeze;
+  if (freezeRaw && typeof freezeRaw === "object") {
+    const f = freezeRaw;
+    const freeze = {
+      active: typeof f.active === "boolean" ? f.active : false
+    };
+    if (typeof f.reason === "string") freeze.reason = f.reason;
+    if (typeof f.since === "string") freeze.since = f.since;
+    if (typeof f.until === "string") freeze.until = f.until;
+    else if (f.until === null) freeze.until = null;
+    if (Array.isArray(f.allowedPlanUids)) {
+      freeze.allowedPlanUids = f.allowedPlanUids.filter((u) => typeof u === "string");
+    }
+    result.freeze = freeze;
+  }
+  if (typeof r.updatedAt === "string") {
+    result.updatedAt = r.updatedAt;
+  }
+  return result;
+}
+function parseRoutingRule(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const whenRaw = r.when;
+  const when = {};
+  if (whenRaw && typeof whenRaw === "object") {
+    const w = whenRaw;
+    if (typeof w.eventType === "string" && import_types.CHANNEL_EVENT_TYPES.includes(w.eventType)) {
+      when.eventType = w.eventType;
+    }
+    if (typeof w.status === "string" && import_types.CHANNEL_EVENT_STATUSES.includes(w.status)) {
+      when.status = w.status;
+    }
+    if (typeof w.planUid === "string") when.planUid = w.planUid;
+    if (typeof w.itemUid === "string") when.itemUid = w.itemUid;
+    if (typeof w.minAgeMs === "number" && Number.isFinite(w.minAgeMs)) when.minAgeMs = w.minAgeMs;
+  }
+  const notifyRaw = r.notify;
+  if (!notifyRaw || typeof notifyRaw !== "object") return null;
+  const n = notifyRaw;
+  if (n.target !== "in-app-toast" && n.target !== "webhook") return null;
+  const notify = n.target === "webhook" ? (() => {
+    if (typeof n.url !== "string" || !n.url) return null;
+    const out = {
+      target: "webhook",
+      url: n.url
+    };
+    if (n.headers && typeof n.headers === "object") {
+      const hs = {};
+      for (const [k, v] of Object.entries(n.headers)) {
+        if (typeof v === "string") hs[k] = v;
+      }
+      if (Object.keys(hs).length > 0) out.headers = hs;
+    }
+    return out;
+  })() : (() => {
+    const out = {
+      target: "in-app-toast"
+    };
+    if (n.tone === "info" || n.tone === "warning" || n.tone === "error") out.tone = n.tone;
+    if (typeof n.sticky === "boolean") out.sticky = n.sticky;
+    return out;
+  })();
+  if (!notify) return null;
+  const rule = { when, notify };
+  if (typeof r.id === "string") rule.id = r.id;
+  if (typeof r.description === "string") rule.description = r.description;
+  if (typeof r.enabled === "boolean") rule.enabled = r.enabled;
+  return rule;
+}
+function parseSensorConfig(raw) {
+  const result = {};
+  const driftRaw = raw.drift;
+  if (driftRaw && typeof driftRaw === "object") {
+    const d = driftRaw;
+    const drift = {};
+    if (typeof d.enabled === "boolean") drift.enabled = d.enabled;
+    if (typeof d.channelEvents === "boolean") drift.channelEvents = d.channelEvents;
+    if (typeof d.debounceMs === "number" && Number.isFinite(d.debounceMs) && d.debounceMs >= 0) {
+      drift.debounceMs = d.debounceMs;
+    }
+    if (Object.keys(drift).length > 0) result.drift = drift;
+  }
+  const docsRaw = raw.docs;
+  if (docsRaw && typeof docsRaw === "object") {
+    const d = docsRaw;
+    const docs = {};
+    if (typeof d.enabled === "boolean") docs.enabled = d.enabled;
+    if (typeof d.channelEvents === "boolean") docs.channelEvents = d.channelEvents;
+    if (Object.keys(docs).length > 0) result.docs = docs;
+  }
+  const stuckRaw = raw.stuck;
+  if (stuckRaw && typeof stuckRaw === "object") {
+    const s = stuckRaw;
+    const stuck = {};
+    if (typeof s.enabled === "boolean") stuck.enabled = s.enabled;
+    if (typeof s.repetitionThreshold === "number" && Number.isFinite(s.repetitionThreshold) && s.repetitionThreshold > 0) {
+      stuck.repetitionThreshold = s.repetitionThreshold;
+    }
+    if (typeof s.errorLoopThreshold === "number" && Number.isFinite(s.errorLoopThreshold) && s.errorLoopThreshold > 0) {
+      stuck.errorLoopThreshold = s.errorLoopThreshold;
+    }
+    if (typeof s.idleMinutes === "number" && Number.isFinite(s.idleMinutes) && s.idleMinutes > 0) {
+      stuck.idleMinutes = s.idleMinutes;
+    }
+    if (Object.keys(stuck).length > 0) result.stuck = stuck;
+  }
+  const awarenessRaw = raw.awareness;
+  if (awarenessRaw && typeof awarenessRaw === "object") {
+    const a = awarenessRaw;
+    const awareness = {};
+    if (typeof a.branchWindowDays === "number" && Number.isFinite(a.branchWindowDays) && a.branchWindowDays > 0) {
+      awareness.branchWindowDays = a.branchWindowDays;
+    }
+    if (typeof a.inlineNotices === "boolean") awareness.inlineNotices = a.inlineNotices;
+    if (typeof a.holdSignOffOnHighSignals === "boolean") awareness.holdSignOffOnHighSignals = a.holdSignOffOnHighSignals;
+    if (Object.keys(awareness).length > 0) result.awareness = awareness;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEffectiveAttachmentLocation,
+  getEffectiveDefaultVisibility,
+  getEffectiveSensorConfig,
+  getProjectConfig,
+  invalidateProjectConfigCache,
+  listChannelRoutingRules,
+  matchChannelRoutingRules,
+  parsePlansFolderRef,
+  resetProjectConfigCache,
+  startProjectConfigWatcher,
+  stopProjectConfigWatcher,
+  updateProjectConfig
+});

package/src/backend/services/project-scanner.js

@@ -0,0 +1,184 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_scanner_exports = {};
+__export(project_scanner_exports, {
+  collectFilePaths: () => collectFilePaths,
+  countFiles: () => countFiles,
+  listTaggedExtensions: () => listTaggedExtensions,
+  listTaggedLanguages: () => listTaggedLanguages,
+  scanDirectory: () => scanDirectory
+});
+module.exports = __toCommonJS(project_scanner_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_ignore = __toESM(require("ignore"));
+var import_git_checkout = require("./git-checkout");
+const ALWAYS_IGNORED = /* @__PURE__ */ new Set([
+  // JS / Node
+  "node_modules",
+  // Python
+  "__pycache__",
+  "venv",
+  "env",
+  // Rust
+  "target",
+  // PHP / Go vendored deps
+  "vendor",
+  // Go — `testdata` is the language's convention for fixture input that
+  // is deliberately not valid source. Parsing it produces pure noise.
+  "testdata"
+]);
+const LANG_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".php": "php",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".cs": "csharp",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".swift": "swift",
+  ".json": "json",
+  ".css": "css",
+  ".scss": "css",
+  ".html": "html",
+  ".md": "markdown",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".sql": "sql"
+};
+function listTaggedLanguages() {
+  return [...new Set(Object.values(LANG_MAP))];
+}
+function listTaggedExtensions() {
+  return Object.keys(LANG_MAP);
+}
+function isSourceFile(name) {
+  return import_node_path.default.extname(name).toLowerCase() in LANG_MAP;
+}
+function getLanguage(name) {
+  return LANG_MAP[import_node_path.default.extname(name).toLowerCase()];
+}
+function loadIgnoreFiles(dirPath) {
+  const ig = (0, import_ignore.default)();
+  let any = false;
+  for (const filename of [".gitignore", ".codetrellis-ignore"]) {
+    const filePath = import_node_path.default.join(dirPath, filename);
+    try {
+      const content = import_node_fs.default.readFileSync(filePath, "utf-8");
+      ig.add(content);
+      any = true;
+    } catch {
+    }
+  }
+  return any ? ig : null;
+}
+function isIgnoredByPatterns(absolutePath, isDir, ctx) {
+  for (const { baseDir, ig } of ctx.matchers) {
+    let rel = import_node_path.default.relative(baseDir, absolutePath);
+    if (!rel || rel.startsWith("..")) continue;
+    if (isDir) rel = rel.replace(/\/?$/, "/");
+    if (ig.ignores(rel)) return true;
+  }
+  return false;
+}
+function scanDirectory(dirPath, parent, maxDepth = 10) {
+  const ctx = parent ?? { root: dirPath, matchers: [] };
+  if (maxDepth <= 0) return [];
+  let entries;
+  try {
+    entries = import_node_fs.default.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const localIgnore = loadIgnoreFiles(dirPath);
+  const childCtx = localIgnore ? { root: ctx.root, matchers: [...ctx.matchers, { baseDir: dirPath, ig: localIgnore }] } : ctx;
+  const nodes = [];
+  entries.sort((a, b) => {
+    if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (const entry of entries) {
+    if (entry.name === ".git") continue;
+    if (entry.isDirectory() && ALWAYS_IGNORED.has(entry.name)) continue;
+    const fullPath = import_node_path.default.join(dirPath, entry.name);
+    if (isIgnoredByPatterns(fullPath, entry.isDirectory(), childCtx)) continue;
+    if (entry.isDirectory()) {
+      if ((0, import_git_checkout.isLinkedWorktreeDir)(fullPath)) continue;
+      const children = scanDirectory(fullPath, childCtx, maxDepth - 1);
+      if (children.length === 0) continue;
+      nodes.push({
+        name: entry.name,
+        path: fullPath,
+        type: "directory",
+        children
+      });
+    } else if (isSourceFile(entry.name)) {
+      nodes.push({
+        name: entry.name,
+        path: fullPath,
+        type: "file",
+        language: getLanguage(entry.name)
+      });
+    }
+  }
+  return nodes;
+}
+function countFiles(nodes) {
+  let count = 0;
+  for (const node of nodes) {
+    if (node.type === "file") count++;
+    if (node.children) count += countFiles(node.children);
+  }
+  return count;
+}
+function collectFilePaths(nodes) {
+  const paths = [];
+  for (const node of nodes) {
+    if (node.type === "file") paths.push(node.path);
+    if (node.children) paths.push(...collectFilePaths(node.children));
+  }
+  return paths;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectFilePaths,
+  countFiles,
+  listTaggedExtensions,
+  listTaggedLanguages,
+  scanDirectory
+});