amxx-builder 1.5.1

package/src/compiler.js

@@ -0,0 +1,228 @@
+const fs    = require('fs');
+const path  = require('path');
+const glob       = require('fast-glob');
+const micromatch = require('micromatch');
+const logger = require('./logger');
+const { emit, EVENTS } = require('./events');
+const { spawnCompiler, buildIncludeArgs, buildDefineArgs } = require('./compile-utils');
+
+/**
+ * Applies plugin rules to a local .sma file path (relative to scripting/).
+ * Returns null if the plugin should be skipped (enabled: false),
+ * or { postfix, skipIni } where postfix is the INI postfix (false = skip INI).
+ */
+function applyPluginRule(smaRelPath, rules, defaultPostfix) {
+  const normalized = smaRelPath.split(path.sep).join('/');
+  for (const rule of rules) {
+    if (micromatch.isMatch(normalized, rule.match, { dot: true })) {
+      if (!rule.enabled) return null;
+      const postfix = rule.ini !== null ? rule.ini : defaultPostfix;
+      return { postfix, skipIni: rule.ini === false };
+    }
+  }
+  return { postfix: defaultPostfix, skipIni: false };
+}
+
+async function compilePlugins(manifest, repoLocalDirs, compilerPath, includeDirs, buildDir) {
+  const pluginsDir = path.join(buildDir, 'amxmodx', 'plugins');
+  fs.mkdirSync(pluginsDir, { recursive: true });
+
+  const collectedIncDir = path.join(buildDir, 'amxmodx', 'scripting', 'include');
+
+  // ── Build unified source list ──────────────────────────────────────────────
+  const sources = manifest.repos.map((repoConfig) => ({
+    label:        repoConfig.repo,
+    ref:          repoConfig._resolvedRef || repoConfig.ref || 'HEAD',
+    scriptingDir: path.join(
+      repoLocalDirs[`${repoConfig.repo}@${repoConfig._resolvedRef || repoConfig.ref || 'HEAD'}`],
+      repoConfig.amxmodx_dir,
+      'scripting'
+    ),
+    exclude: repoConfig.exclude,
+    postfix: repoConfig.plugins_ini_postfix,
+  }));
+
+  const localScriptingDir = path.join(path.dirname(manifest._path), manifest.amxmodx.dir, 'scripting');
+  if (fs.existsSync(localScriptingDir)) {
+    sources.push({
+      label: '(local)', ref: 'local', isLocal: true, scriptingDir: localScriptingDir,
+      exclude: [], postfix: manifest.globalPostfix,
+    });
+  }
+
+  // ── Collect all .sma tasks ─────────────────────────────────────────────────
+  const onConflict = manifest.output.on_conflict || 'last_wins';
+  const tasksByOut = new Map(); // outPath → task (dedupe cross-source collisions)
+  for (const src of sources) {
+    const { scriptingDir, exclude, postfix, label, ref, isLocal = false } = src;
+
+    if (!fs.existsSync(scriptingDir)) {
+      logger.dim(`  ${label}: no scripting/ dir`);
+      continue;
+    }
+
+    const excludePatterns = exclude.map((e) => `!${e}`);
+    const smaFiles = await glob(['**/*.sma', ...excludePatterns], { cwd: scriptingDir, dot: false });
+
+    const excluded = await findExcluded(scriptingDir, exclude);
+    for (const ex of excluded) logger.skip(`Skipped (excluded): ${ex}`);
+
+    const localIncDir = path.join(scriptingDir, 'include');
+    const includes = buildIncludeArgs({ scriptingDir, localIncDir, collectedIncDir, includeDirs });
+
+    const defines = buildDefineArgs(manifest.amxmodx.defines);
+
+    if (logger.isVerbose()) {
+      logger.verbose(`  includes: ${includes.join(', ') || '(none)'}`);
+      if (defines.length) logger.verbose(`  defines: ${defines.join(', ')}`);
+    }
+
+    for (const smaRel of smaFiles) {
+      let taskPostfix = postfix;
+      let skipIni     = false;
+
+      if (isLocal) {
+        const ruleResult = applyPluginRule(smaRel, manifest.pluginRules, postfix);
+        if (!ruleResult) {
+          logger.skip(`Skipped (plugin rule): ${smaRel}`);
+          continue;
+        }
+        taskPostfix = ruleResult.postfix;
+        skipIni     = ruleResult.skipIni;
+      }
+
+      const baseName = path.basename(smaRel);
+      const outName  = smaRel.replace(/\.sma$/, '.amxx').split(path.sep).join('/');
+      const task = {
+        label, ref, postfix: taskPostfix, skipIni, baseName,
+        srcPath: path.join(scriptingDir, smaRel),
+        outName,
+        outPath: path.join(pluginsDir, ...outName.split('/')),
+        includes,
+        defines,
+      };
+      const prev = tasksByOut.get(task.outPath);
+      if (prev) {
+        if (onConflict === 'error') {
+          throw new Error(`Plugin output conflict: "${outName}" — provided by both "${prev.label}" and "${label}"`);
+        }
+        if (onConflict === 'first_wins') {
+          logger.warn(`Plugin conflict (kept "${prev.label}"): ${outName}`);
+          continue;
+        }
+        logger.warn(`Plugin conflict (overwriting "${prev.label}"): ${outName}`);
+      }
+      tasksByOut.set(task.outPath, task);
+    }
+  }
+
+  const tasks = [...tasksByOut.values()];
+
+  if (!tasks.length) return [];
+
+  logger.info(`Compiling ${tasks.length} plugin(s)...`);
+
+  // ── Run compilations with a bounded worker pool ───────────────────────────
+  const settled = await mapLimit(tasks, 8, (task) => runCompile(compilerPath, task)
+    .then((value) => ({ status: 'fulfilled', value }))
+    .catch((reason) => ({ status: 'rejected', reason }))
+  );
+
+  const compiled = [];
+  const failed   = [];
+
+  for (let i = 0; i < settled.length; i++) {
+    if (settled[i].status === 'fulfilled') {
+      compiled.push(settled[i].value);
+    } else {
+      failed.push({ task: tasks[i], err: settled[i].reason });
+    }
+  }
+
+  if (failed.length) {
+    // Per-plugin FAILED rendering is handled by the CLI renderer via EVENTS.COMPILED.
+    throw new Error(
+      `Compilation failed (${failed.length}/${tasks.length}): ` +
+      failed.map(({ task }) => task.baseName).join(', ')
+    );
+  }
+
+  return compiled;
+}
+
+async function mapLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i], i);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+async function runCompile(compilerPath, task) {
+  const { srcPath, outPath, outName, includes, defines, baseName, postfix, skipIni, label, ref } = task;
+
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  const args = [srcPath, `-o${outPath}`, ...includes, ...defines];
+  logger.verbose(`  cmd: ${compilerPath} ${args.join(' ')}`);
+
+  const { status, output } = await spawnCompiler(compilerPath, args);
+
+  if (status !== 0) {
+    emit(EVENTS.COMPILED, { baseName, ok: false, output, amxxName: null, repo: label, ref, outName });
+    const err = new Error(`Compilation failed: ${baseName}`);
+    err.compilerOutput = output;
+    throw err;
+  }
+
+  emit(EVENTS.COMPILED, { baseName, ok: true, output, amxxName: outName, repo: label, ref, outName });
+
+  return { amxxName: outName, plugins_ini_postfix: postfix, skipIni: skipIni || false, repo: label, ref };
+}
+
+async function findExcluded(dir, patterns) {
+  if (!patterns.length) return [];
+  const all  = await glob('**/*.sma', { cwd: dir });
+  const kept = new Set(await glob(['**/*.sma', ...patterns.map((e) => `!${e}`)], { cwd: dir }));
+  return all.filter((f) => !kept.has(f)).map((f) => path.basename(f));
+}
+
+/**
+ * Compiles a single .sma file. Used by watch mode.
+ * Returns the .amxx filename on success, null on failure.
+ */
+async function compileSingle(manifest, smaPath, compilerPath, includeDirs, buildDir, scriptingRootDir) {
+  const pluginsDir      = path.join(buildDir, 'amxmodx', 'plugins');
+  const collectedIncDir = path.join(buildDir, 'amxmodx', 'scripting', 'include');
+
+  const baseName = path.basename(smaPath);
+  const rel      = scriptingRootDir
+    ? path.relative(scriptingRootDir, smaPath)
+    : baseName;
+  const outName  = rel.replace(/\.sma$/, '.amxx').split(path.sep).join('/');
+  const outPath  = path.join(pluginsDir, ...outName.split('/'));
+
+  const scriptingDir = scriptingRootDir || path.dirname(smaPath);
+  const localIncDir  = path.join(scriptingDir, 'include');
+  const includes = buildIncludeArgs({ scriptingDir, localIncDir, collectedIncDir, includeDirs });
+
+  const defines = buildDefineArgs(manifest.amxmodx.defines);
+
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+
+  const { status, output } = await spawnCompiler(compilerPath, [smaPath, `-o${outPath}`, ...includes, ...defines]);
+
+  if (status !== 0) {
+    emit(EVENTS.COMPILED, { baseName, ok: false, output, amxxName: null, repo: null, ref: null, outName });
+    return null;
+  }
+
+  emit(EVENTS.COMPILED, { baseName, ok: true, output, amxxName: outName, repo: null, ref: null, outName });
+  return outName;
+}
+
+module.exports = { compilePlugins, compileSingle, applyPluginRule };

package/src/dep-graph.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+// Matches: #include <file>  #include "file"  #tryinclude variants
+const RE_INCLUDE = /^[ \t]*#(?:try)?include[ \t]+([<"])([^>"]+)[>"][ \t]*(?:\/\/.*)?$/gm;
+
+function extractIncludes(filePath) {
+  let content;
+  try { content = fs.readFileSync(filePath, 'utf8'); } catch { return []; }
+  const result = [];
+  let m;
+  RE_INCLUDE.lastIndex = 0;
+  while ((m = RE_INCLUDE.exec(content)) !== null) {
+    result.push({ name: m[2].trim(), isAngle: m[1] === '<' });
+  }
+  return result;
+}
+
+class DepGraph {
+  constructor(includeDirs) {
+    // includeDirs: ordered list of dirs to search for <angle> includes
+    this._includeDirs = includeDirs;
+    // absPath → Set<absPath>: direct includes of each file
+    this._deps = new Map();
+    this._parsed = new Set();
+  }
+
+  // Parse a file and all its includes recursively. Safe to call multiple times.
+  parseFile(absPath) {
+    if (this._parsed.has(absPath)) return;
+    this._parsed.add(absPath);
+    if (!fs.existsSync(absPath)) return;
+
+    const directs = new Set();
+    for (const { name, isAngle } of extractIncludes(absPath)) {
+      const resolved = this._resolve(absPath, name, isAngle);
+      if (resolved) {
+        directs.add(resolved);
+        this.parseFile(resolved);
+      }
+    }
+    this._deps.set(absPath, directs);
+  }
+
+  // Re-parse a changed file (drops stale edges, keeps the rest of the graph).
+  update(absPath) {
+    this._parsed.delete(absPath);
+    this._deps.delete(absPath);
+    this.parseFile(absPath);
+  }
+
+  // Returns Set<absPath> of .sma files that transitively depend on incPath.
+  getSmasDependingOn(incPath) {
+    const smas    = new Set();
+    const visited = new Set();
+
+    const visit = (target) => {
+      if (visited.has(target)) return;
+      visited.add(target);
+      for (const [file, deps] of this._deps) {
+        if (!deps.has(target)) continue;
+        if (file.endsWith('.sma')) smas.add(file);
+        else visit(file); // .inc depending on .inc — traverse upward
+      }
+    };
+
+    visit(incPath);
+    return smas;
+  }
+
+  _resolve(fromFile, name, isAngle) {
+    const withExt = /\.inc$/i.test(name) ? name : name + '.inc';
+
+    if (!isAngle) {
+      // "quoted" → relative to current file's directory first
+      const rel = path.resolve(path.dirname(fromFile), withExt);
+      if (fs.existsSync(rel)) return rel;
+    }
+
+    // <angle> or fallback: search include dirs in order
+    for (const dir of this._includeDirs) {
+      const full = path.join(dir, withExt);
+      if (fs.existsSync(full)) return full;
+    }
+
+    return null; // system / external include — not tracked
+  }
+}
+
+module.exports = { DepGraph };

package/src/deployer.js

@@ -0,0 +1,197 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const logger = require('./logger');
+
+function expand(manifest, tpl) {
+  return tpl
+    .replaceAll('{name}',    manifest.name)
+    .replaceAll('{version}', manifest.version);
+}
+
+function resolveDeployDirs(manifest) {
+  const deploy = manifest.deploy;
+  const out    = manifest.output;
+
+  // Absolute root: exclusion matching (isExcluded) compares against the deploy
+  // root, so a relative deploy.path would break path.relative on every dest.
+  const deployRoot = path.resolve(deploy.path);
+
+  const amxmodxDest = path.join(
+    deployRoot,
+    expand(manifest, deploy.amxmodx_path)
+  );
+
+  const assetsDest = deploy.assets_path != null
+    ? path.join(deployRoot, expand(manifest, deploy.assets_path))
+    : out.assets_path
+      ? path.join(deployRoot, expand(manifest, out.assets_path))
+      : deployRoot; // root
+
+  return { amxmodxDest, assetsDest, deployRoot };
+}
+
+/**
+ * Full deploy: copies build/amxmodx/ and build/assets/ to the deploy path.
+ * Returns number of files copied.
+ */
+async function deployBuild(manifest, buildDir, { incremental = false } = {}) {
+  assertDeployPath(manifest);
+
+  const { amxmodxDest, assetsDest, deployRoot } = resolveDeployDirs(manifest);
+
+  logger.step(`Deploying to ${manifest.deploy.path}${incremental ? ' (incremental)' : ''}...`);
+
+  let count = 0;
+
+  const excludePatterns = manifest.deploy.exclude || [];
+
+  const amxmodxSrc = path.join(buildDir, 'amxmodx');
+  if (fs.existsSync(amxmodxSrc)) {
+    count += copyDir(amxmodxSrc, amxmodxDest, incremental, deployRoot, excludePatterns);
+  }
+
+  const assetsSrc = path.join(buildDir, 'assets');
+  if (fs.existsSync(assetsSrc)) {
+    count += copyDir(assetsSrc, assetsDest, incremental, deployRoot, excludePatterns);
+  }
+
+  logger.success(`Deployed ${count} file(s) → ${manifest.deploy.path}`);
+  return count;
+}
+
+/**
+ * Deploy a single compiled .amxx file (watch mode after recompile).
+ * Returns the dest path or null if not deployed.
+ */
+function deployPlugin(manifest, buildDir, amxxName) {
+  if (!manifest.deploy.path) return null;
+
+  const { amxmodxDest, deployRoot } = resolveDeployDirs(manifest);
+  const src  = path.join(buildDir, 'amxmodx', 'plugins', amxxName);
+  const dest = path.join(amxmodxDest, 'plugins', amxxName);
+
+  if (!fs.existsSync(src)) {
+    logger.warn(`Deploy: plugin not found in build: ${amxxName}`);
+    return null;
+  }
+
+  if (isExcluded(dest, deployRoot, manifest.deploy.exclude || [])) {
+    logger.verbose(`  skip (excluded): ${amxxName}`);
+    return null;
+  }
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+  logger.success(`Deployed: ${amxxName}`);
+  logger.verbose(`  → ${dest}`);
+  return dest;
+}
+
+/**
+ * Deploy a single changed local file (watch mode for amxmodx/ or assets/).
+ * relPath is relative to the section root (amxmodx/ or assets/).
+ */
+function deployFile(manifest, buildDir, relPath, section) {
+  if (!manifest.deploy.path) return;
+
+  const { amxmodxDest, assetsDest, deployRoot } = resolveDeployDirs(manifest);
+
+  const srcBase  = path.join(buildDir, section === 'assets' ? 'assets' : 'amxmodx');
+  const destBase = section === 'assets' ? assetsDest : amxmodxDest;
+
+  const src  = path.join(srcBase, relPath);
+  const dest = path.join(destBase, relPath);
+
+  if (!fs.existsSync(src)) return;
+  if (isExcluded(dest, deployRoot, manifest.deploy.exclude || [])) {
+    logger.verbose(`  skip (excluded): ${relPath}`);
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+  logger.success(`Deployed: ${relPath}`);
+  logger.verbose(`  → ${dest}`);
+}
+
+/**
+ * Removes a deployed file that was deleted locally (watch mode).
+ * relPath is relative to the section root. Honours deploy.exclude.
+ */
+function removeDeployedFile(manifest, buildDir, relPath, section) {
+  if (!manifest.deploy.path) return;
+
+  const { amxmodxDest, assetsDest, deployRoot } = resolveDeployDirs(manifest);
+
+  const destBase = section === 'assets' ? assetsDest : amxmodxDest;
+  const dest     = path.join(destBase, relPath);
+
+  if (isExcluded(dest, deployRoot, manifest.deploy.exclude || [])) {
+    logger.verbose(`  skip delete (excluded): ${relPath}`);
+    return;
+  }
+
+  if (!fs.existsSync(dest)) return;
+  fs.rmSync(dest, { force: true });
+  logger.success(`Removed: ${relPath}`);
+}
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function isExcluded(absDestPath, deployRoot, patterns) {
+  if (!patterns.length) return false;
+  const rel = path.relative(deployRoot, absDestPath).split(path.sep).join('/');
+  return patterns.some((pat) => {
+    const np = pat.replace(/\\/g, '/').replace(/\/$/, '');
+    return rel === np || rel.startsWith(np + '/');
+  });
+}
+
+function copyDir(srcDir, destDir, incremental, deployRoot, excludePatterns) {
+  if (!fs.existsSync(srcDir)) return 0;
+  fs.mkdirSync(destDir, { recursive: true });
+  let count = 0;
+
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath  = path.join(srcDir,  entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (isExcluded(destPath, deployRoot, excludePatterns)) {
+      logger.verbose(`  skip (excluded): ${path.relative(deployRoot, destPath)}`);
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      count += copyDir(srcPath, destPath, incremental, deployRoot, excludePatterns);
+    } else {
+      if (incremental && isUpToDate(srcPath, destPath)) continue;
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      logger.verbose(`  → ${destPath}`);
+      count++;
+    }
+  }
+  return count;
+}
+
+function isUpToDate(src, dest) {
+  if (!fs.existsSync(dest)) return false;
+  const s = fs.statSync(src);
+  const d = fs.statSync(dest);
+  // Equal mtimes (coarse FAT/exFAT granularity) must NOT be treated as
+  // up-to-date — a recompiled file in the same 2s tick would be skipped.
+  return s.size === d.size && s.mtimeMs < d.mtimeMs;
+}
+
+function assertDeployPath(manifest) {
+  if (!manifest.deploy.path) {
+    throw new Error(
+      'Deploy path not configured.\n' +
+      '  → Set AMXB_DEPLOY_PATH in .env, or add deploy.path to your manifest'
+    );
+  }
+}
+
+module.exports = { deployBuild, deployPlugin, deployFile, removeDeployedFile };

package/src/deps-resolver.js

@@ -0,0 +1,127 @@
+const fs   = require('fs');
+const path = require('path');
+const glob = require('fast-glob');
+const logger = require('./logger');
+const { parseDepsLines, resolveGithubToken } = require('./manifest');
+const { fetchRepo, resolveRefIfLatest } = require('./repo-fetcher');
+const { fetchReleaseDep } = require('./release-fetcher');
+
+/**
+ * Resolves all deps, clones them, copies .inc files to build/_includes/,
+ * and returns an array of include-dir paths to pass to the compiler (-i flags).
+ *
+ * Priority: manifest.globalDeps > repo.deps_override > DEPS_LIST file in repo root
+ */
+async function resolveDeps(manifest, repoLocalDirs, noFetch, buildDir) {
+  const merged = new Map(); // normalised "owner/repo" → dep entry
+
+  // Add repo-level deps first (lowest priority)
+  for (const repoConfig of manifest.repos) {
+    const localDir = repoLocalDirs[repoKey(repoConfig)];
+    let repoDeps;
+
+    if (repoConfig.deps_override) {
+      repoDeps = repoConfig.deps_override;
+      logger.info(`Deps for ${shortName(repoConfig.repo)}: deps_override (${repoDeps.length} entries)`);
+    } else {
+      repoDeps = readDepsListFile(localDir, repoConfig.repo);
+    }
+
+    for (const dep of repoDeps) {
+      const k = normalize(dep.repo);
+      if (!merged.has(k)) merged.set(k, { ...dep, _from: 'repo' });
+    }
+  }
+
+  // manifest.globalDeps win over everything
+  for (const dep of manifest.globalDeps) {
+    merged.set(normalize(dep.repo), { ...dep, _from: 'manifest' });
+  }
+
+  if (merged.size === 0) return [];
+
+  const overridden = [...merged.values()].filter((d) => d._from === 'manifest').length;
+  logger.info(
+    `Merged deps: ${merged.size} unique` +
+    (overridden ? ` (${overridden} overridden by manifest)` : '')
+  );
+
+  const includesRoot = path.join(buildDir, '_includes');
+  fs.mkdirSync(includesRoot, { recursive: true });
+
+  const includeDirs = [];
+
+  for (const [k, dep] of merged) {
+    const token = resolveGithubToken(manifest, dep.repo);
+    let srcDir;
+    if (dep.source === 'release') {
+      srcDir = await fetchReleaseDep(dep, token, noFetch);
+    } else {
+      const resolvedDepRef = await resolveRefIfLatest(dep.ref, dep.repo, token);
+      const depDir = await fetchRepo(dep.repo, resolvedDepRef, token, noFetch, manifest.github.ssh);
+      srcDir = resolveIncludePath(depDir, dep.include_path, dep.repo);
+    }
+
+    const destDir = path.join(includesRoot, k.replace('/', '__'));
+    fs.mkdirSync(destDir, { recursive: true });
+
+    const files = await glob('**/*.inc', { cwd: srcDir, dot: false });
+    for (const f of files) {
+      const dest = path.join(destDir, f);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(path.join(srcDir, f), dest);
+    }
+
+    logger.dim(`  ${dep.repo}@${dep.ref}: ${files.length} .inc files`);
+    includeDirs.push(destDir);
+  }
+
+  const total = includeDirs.reduce((s, d) => s + countIncFiles(d), 0);
+  logger.info(`Includes collected: ${total} .inc files → build/_includes/`);
+
+  return includeDirs;
+}
+
+function readDepsListFile(repoDir, repoName) {
+  const p = path.join(repoDir, 'DEPS_LIST');
+  if (!fs.existsSync(p)) {
+    logger.dim(`  Deps for ${shortName(repoName)}: no DEPS_LIST file`);
+    return [];
+  }
+  const deps = parseDepsLines(fs.readFileSync(p, 'utf8').split(/\r?\n/));
+  logger.info(`Deps for ${shortName(repoName)}: DEPS_LIST found (${deps.length} entries)`);
+  return deps;
+}
+
+function resolveIncludePath(repoDir, explicitPath, repoName) {
+  if (explicitPath) {
+    const full = path.join(repoDir, explicitPath);
+    if (!fs.existsSync(full)) throw new Error(`Include path "${explicitPath}" not found in ${repoName}`);
+    return full;
+  }
+  for (const candidate of ['scripting/include', 'amxmodx/scripting/include', 'include', '.']) {
+    const full = path.join(repoDir, candidate);
+    if (fs.existsSync(full)) return full;
+  }
+  return repoDir;
+}
+
+// Single source of truth for repo-name normalization (used for cache keys
+// and dedup by core modules that previously inlined repo.toLowerCase()).
+function normalize(repo) { return repo.toLowerCase(); }
+
+function repoKey(repoConfig) {
+  return `${repoConfig.repo}@${repoConfig._resolvedRef || repoConfig.ref || 'HEAD'}`;
+}
+function shortName(repo)  { return repo.split('/').pop(); }
+
+function countIncFiles(dir) {
+  let n = 0;
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (e.isDirectory()) n += countIncFiles(path.join(dir, e.name));
+    else if (e.name.endsWith('.inc')) n++;
+  }
+  return n;
+}
+
+module.exports = { resolveDeps, readDepsListFile, normalize, repoKey };