@xylabs/toolchain 7.10.0

package/dist/xy/common/repo/index.mjs

@@ -0,0 +1,1070 @@
+// src/pm/detectPackageManager.ts
+import { existsSync } from "fs";
+function detectPackageManager() {
+  if (existsSync("pnpm-lock.yaml") || existsSync("pnpm-workspace.yaml")) return "pnpm";
+  return "yarn";
+}
+
+// src/pm/registry.ts
+var implementations = /* @__PURE__ */ new Map();
+function getPackageManager(name) {
+  const pmName = name ?? detectPackageManager();
+  const pm = implementations.get(pmName);
+  if (!pm) {
+    throw new Error(
+      `No package manager implementation registered for "${pmName}". Ensure registerPackageManager() has been called before getPackageManager().`
+    );
+  }
+  return pm;
+}
+
+// src/lib/fillTemplate.ts
+function fillTemplate(template, data) {
+  return template.replaceAll(/\{\{(.*?)\}\}/g, (_, key) => data[key.trim()] ?? "");
+}
+
+// src/lib/initCwd.ts
+function INIT_CWD() {
+  return process.env.INIT_CWD ?? process.cwd();
+}
+
+// src/lib/latestVersions.ts
+var latestVersions = {
+  node: "24.14.1",
+  nodeLtsCodename: "Krypton",
+  npm: "11.11.0",
+  pnpm: "10.33.0",
+  yarn: "4.13.0"
+};
+
+// src/lib/repoTemplates.ts
+import { readdirSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import PATH from "path";
+var require2 = createRequire(import.meta.url);
+var packageRoot = PATH.dirname(require2.resolve("@xylabs/ts-scripts-common/package.json"));
+var repoTemplatesDir = PATH.resolve(packageRoot, "templates", "repo");
+function collectFiles(dir, prefix) {
+  const results = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(PATH.resolve(dir, entry.name), rel));
+    } else {
+      results.push({
+        content: readFileSync(PATH.resolve(dir, entry.name), "utf8"),
+        relativePath: rel
+      });
+    }
+  }
+  return results;
+}
+function loadRepoTemplateFiles(template, section) {
+  const dir = PATH.resolve(repoTemplatesDir, template, section);
+  return collectFiles(dir, "");
+}
+
+// src/lib/runInstall.ts
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+function runInstall(cwd) {
+  const pm = detectPackageManager();
+  console.log(chalk.gray(`Running ${pm} install...`));
+  const result = spawnSync(pm, ["install"], {
+    cwd,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.warn(chalk.yellow(`${pm} install failed`));
+    return false;
+  }
+  console.log(chalk.green("Dependencies installed"));
+  return true;
+}
+
+// src/actions/package-lint-deps.ts
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import PATH2 from "path";
+import chalk2 from "chalk";
+import semver from "semver";
+function readWorkspacePackageJson(cwd, location) {
+  const pkgPath = PATH2.resolve(cwd, location, "package.json");
+  try {
+    return JSON.parse(readFileSync2(pkgPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function writeWorkspacePackageJson(cwd, location, pkg) {
+  const pkgPath = PATH2.resolve(cwd, location, "package.json");
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function buildWorkspaceVersionMap(cwd, workspaces) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version) map.set(name, version);
+  }
+  return map;
+}
+function expectedPeerRange(devDepVersion, targetVersion) {
+  const parsed = semver.parse(targetVersion);
+  if (!parsed) return `~${targetVersion}`;
+  if (devDepVersion === "workspace:^") {
+    return `^${parsed.major}`;
+  }
+  return `~${parsed.major}.${parsed.minor}`;
+}
+function checkVersionConsistency(cwd, rootPkg, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  if (rootPkg.version !== void 0) {
+    result.fixable.push('Root package.json should not have a "version" field in a monorepo');
+  }
+  const versions = /* @__PURE__ */ new Map();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version) {
+      versions.set(name, version);
+    } else {
+      result.errors.push(`${name} (${location}) is missing a "version" field`);
+    }
+  }
+  const uniqueVersions = new Set(versions.values());
+  if (uniqueVersions.size > 1) {
+    const versionList = [...uniqueVersions].toSorted(semver.rcompare);
+    for (const [name, version] of versions) {
+      if (version !== versionList[0]) {
+        result.fixable.push(`${name} has version ${version} (expected ${versionList[0]})`);
+      }
+    }
+  }
+  return result;
+}
+function fixVersionConsistency(cwd, rootPkg, writeRootPackageJson2, workspaces) {
+  if (rootPkg.version !== void 0) {
+    delete rootPkg.version;
+    writeRootPackageJson2(cwd, rootPkg);
+    console.log(chalk2.green('  \u2714 Fixed: removed "version" from root package.json'));
+  }
+  const versions = [];
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version && semver.valid(version)) {
+      versions.push(version);
+    }
+  }
+  if (versions.length === 0) return;
+  const highest = versions.toSorted(semver.rcompare)[0];
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    if (pkg.version !== highest) {
+      pkg.version = highest;
+      writeWorkspacePackageJson(cwd, location, pkg);
+      console.log(chalk2.green(`  \u2714 Fixed: set version to ${highest} in ${name} (${location})`));
+    }
+  }
+}
+function expectedDepVersion(targetVersion) {
+  const parsed = semver.parse(targetVersion);
+  if (!parsed) return `~${targetVersion}`;
+  return `~${targetVersion}`;
+}
+function checkInternalDepVersions(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        const targetVersion = workspaceVersions.get(dep);
+        if (!targetVersion) continue;
+        const expected = expectedDepVersion(targetVersion);
+        if (version.startsWith("workspace:")) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should be "${expected}" (not workspace: protocol)`
+          );
+        } else if (version !== expected) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should be "${expected}"`
+          );
+        }
+      }
+    }
+  }
+  return result;
+}
+function fixInternalDepVersions(cwd, workspaces) {
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    let modified = false;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        const targetVersion = workspaceVersions.get(dep);
+        if (!targetVersion) continue;
+        const expected = expectedDepVersion(targetVersion);
+        if (version !== expected) {
+          deps[dep] = expected;
+          console.log(chalk2.green(`  \u2714 Fixed: set ${depField}.${dep} to "${expected}" in ${name} (${location})`));
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+function checkWorkspaceProtocol(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceNames = new Set(workspaces.map((w) => w.name));
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        if (!workspaceNames.has(dep)) continue;
+        if (!version.startsWith("workspace:")) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should use workspace: protocol`
+          );
+        }
+      }
+    }
+  }
+  return result;
+}
+function fixWorkspaceProtocol(cwd, workspaces) {
+  const workspaceNames = new Set(workspaces.map((w) => w.name));
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    let modified = false;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        if (!workspaceNames.has(dep)) continue;
+        if (!version.startsWith("workspace:")) {
+          deps[dep] = "workspace:~";
+          console.log(chalk2.green(`  \u2714 Fixed: set ${depField}.${dep} to "workspace:~" in ${name} (${location})`));
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+function checkInternalPeerVersions(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const peerDeps = pkg.peerDependencies;
+    if (!peerDeps) continue;
+    const devDeps = pkg.devDependencies;
+    for (const [dep, version] of Object.entries(peerDeps)) {
+      const targetVersion = workspaceVersions.get(dep);
+      if (!targetVersion) continue;
+      if (version.startsWith("workspace:")) {
+        const expected2 = expectedPeerRange(devDeps?.[dep], targetVersion);
+        result.fixable.push(
+          `${name} (${location}) peerDependencies.${dep} uses workspace: protocol \u2014 should be "${expected2}"`
+        );
+        continue;
+      }
+      const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
+      if (version !== expected && !semver.satisfies(targetVersion, version)) {
+        result.fixable.push(
+          `${name} (${location}) peerDependencies.${dep} is "${version}" \u2014 current version ${targetVersion} is not satisfied; expected "${expected}"`
+        );
+      }
+    }
+  }
+  return result;
+}
+function fixInternalPeerVersions(cwd, workspaces) {
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const peerDeps = pkg.peerDependencies;
+    if (!peerDeps) continue;
+    const devDeps = pkg.devDependencies;
+    let modified = false;
+    for (const [dep, version] of Object.entries(peerDeps)) {
+      const targetVersion = workspaceVersions.get(dep);
+      if (!targetVersion) continue;
+      const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
+      if (version !== expected) {
+        peerDeps[dep] = expected;
+        console.log(chalk2.green(`  \u2714 Fixed: set peerDependencies.${dep} to "${expected}" in ${name} (${location})`));
+        modified = true;
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+
+// src/actions/package-lint.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2
+} from "fs";
+import PATH3 from "path";
+import chalk3 from "chalk";
+import picomatch from "picomatch";
+import semver2 from "semver";
+function emptyResult() {
+  return {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+}
+function readRootPackageJson(cwd) {
+  const raw = readFileSync3(PATH3.resolve(cwd, "package.json"), "utf8");
+  return JSON.parse(raw);
+}
+function writeRootPackageJson(cwd, pkg) {
+  const path = PATH3.resolve(cwd, "package.json");
+  writeFileSync2(path, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function readPnpmWorkspaceGlobs(cwd) {
+  const wsPath = PATH3.resolve(cwd, "pnpm-workspace.yaml");
+  if (!existsSync2(wsPath)) return void 0;
+  const raw = readFileSync3(wsPath, "utf8");
+  const globs = [];
+  let inPackages = false;
+  for (const line of raw.split("\n")) {
+    if (/^packages\s*:/.test(line)) {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      const match = /^\s+-\s+['"]?([^'"]+)['"]?\s*$/.exec(line);
+      if (match) {
+        globs.push(match[1]);
+      } else if (/^\S/.test(line) && line.trim() !== "") {
+        break;
+      }
+    }
+  }
+  return globs.length > 0 ? globs : void 0;
+}
+function isMonorepo(pkg, cwd) {
+  const workspaces = pkg.workspaces;
+  if (Array.isArray(workspaces) && workspaces.length > 0) return true;
+  return readPnpmWorkspaceGlobs(cwd) !== void 0;
+}
+function checkPackagesFolder(workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    if (!location.startsWith("packages/") && !location.startsWith("packages\\")) {
+      result.errors.push(`${name} (${location}) is not inside a packages/ folder`);
+    }
+  }
+  return result;
+}
+function checkRootPrivate(pkg) {
+  const result = emptyResult();
+  if (!pkg.private) {
+    result.fixable.push("Root package.json must be private to prevent accidental publishing");
+  }
+  return result;
+}
+function fixRootPrivate(cwd, pkg) {
+  pkg.private = true;
+  writeRootPackageJson(cwd, pkg);
+  console.log(chalk3.green('  \u2714 Fixed: set "private": true in root package.json'));
+}
+function checkNoPublishConfigOnPrivate(pkg) {
+  const result = emptyResult();
+  if (pkg.private && pkg.publishConfig) {
+    result.fixable.push("Root package.json has publishConfig but is private \u2014 publishConfig is unnecessary");
+  }
+  return result;
+}
+function fixNoPublishConfigOnPrivate(cwd, pkg) {
+  delete pkg.publishConfig;
+  writeRootPackageJson(cwd, pkg);
+  console.log(chalk3.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
+}
+function checkNoPackageManagerInWorkspaces(cwd, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH3.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync3(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.packageManager) {
+        result.fixable.push(`${name} (${location}) has a packageManager field \u2014 only the root should define this`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixNoPackageManagerInWorkspaces(cwd, _pkg, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH3.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync3(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.packageManager) {
+        delete pkg.packageManager;
+        writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk3.green(`  \u2714 Fixed: removed packageManager from ${location}/package.json`));
+      }
+    } catch {
+    }
+  }
+}
+function checkWorkspacesFieldPlacement(cwd, pm, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (pm === "pnpm" ? true : location !== ".") {
+      const pkgPath = PATH3.resolve(cwd, location, "package.json");
+      try {
+        const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+        if (pkg.workspaces) {
+          const label = location === "." ? "Root" : `${name} (${location})`;
+          const reason = pm === "pnpm" ? "pnpm uses pnpm-workspace.yaml instead" : "only the root should define workspaces";
+          result.fixable.push(`${label} has a workspaces field \u2014 ${reason}`);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function fixWorkspacesFieldPlacement(cwd, pm, workspaces) {
+  for (const { location } of workspaces) {
+    if (pm === "pnpm" ? true : location !== ".") {
+      const pkgPath = PATH3.resolve(cwd, location, "package.json");
+      try {
+        const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+        if (pkg.workspaces) {
+          delete pkg.workspaces;
+          writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+          const label = location === "." ? "root" : location;
+          console.log(chalk3.green(`  \u2714 Fixed: removed workspaces from ${label}/package.json`));
+        }
+      } catch {
+      }
+    }
+  }
+}
+function checkWorkspaceGlobCoverage(pkg, cwd, pm, workspaces) {
+  const result = emptyResult();
+  const globs = pm === "pnpm" ? readPnpmWorkspaceGlobs(cwd) ?? [] : Array.isArray(pkg.workspaces) ? pkg.workspaces : [];
+  if (globs.length === 0) {
+    const source = pm === "pnpm" ? "pnpm-workspace.yaml" : "root package.json workspaces";
+    result.errors.push(`No workspace globs found in ${source}`);
+    return result;
+  }
+  const matchers = globs.map((glob) => picomatch(glob));
+  const isMatch = (location) => matchers.some((m) => m(location));
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    if (!isMatch(location)) {
+      const source = pm === "pnpm" ? "pnpm-workspace.yaml" : "root package.json workspaces";
+      result.errors.push(`${name} (${location}) is not matched by any glob in ${source}`);
+    }
+  }
+  return result;
+}
+function logResults(label, result, fix) {
+  let errors = 0;
+  let fixed = 0;
+  for (const error of result.errors) {
+    console.log(chalk3.red(`  \u2717 ${error}`));
+    errors++;
+  }
+  for (const fixable of result.fixable) {
+    if (fix) {
+      fixed++;
+    } else {
+      console.log(chalk3.red(`  \u2717 ${fixable} (fixable)`));
+      errors++;
+    }
+  }
+  for (const warning of result.warnings) {
+    console.log(chalk3.yellow(`  \u26A0 ${warning}`));
+  }
+  if (errors === 0 && fixed === 0 && result.warnings.length === 0) {
+    console.log(chalk3.green(`  \u2713 ${label}`));
+  }
+  return { errors, fixed };
+}
+function runChecks(entries, cwd, pkg, fix) {
+  let totalErrors = 0;
+  let totalFixed = 0;
+  for (const entry of entries) {
+    const result = entry.check();
+    const log = logResults(entry.label, result, fix);
+    if (fix && entry.fix && result.fixable.length > 0) {
+      entry.fix(cwd, pkg);
+    }
+    totalErrors += log.errors;
+    totalFixed += log.fixed;
+  }
+  return { errors: totalErrors, fixed: totalFixed };
+}
+function checkVoltaOnlyInRoot(cwd, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH3.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+      if (pkg.volta) {
+        result.fixable.push(`${name} (${location}) has a volta field \u2014 only the root should define this`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixVoltaOnlyInRoot(cwd, _pkg, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH3.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync3(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.volta) {
+        delete pkg.volta;
+        writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk3.green(`  \u2714 Fixed: removed volta from ${location}/package.json`));
+      }
+    } catch {
+    }
+  }
+}
+function isTerminalPackage(pkg) {
+  return pkg.private === true;
+}
+function checkEnginesOnlyInNonTerminal(cwd, workspaces) {
+  const result = emptyResult();
+  const rootPkg = JSON.parse(readFileSync3(PATH3.resolve(cwd, "package.json"), "utf8"));
+  if (rootPkg.engines) {
+    result.fixable.push("Root package.json has engines \u2014 terminal packages should not declare engines (use volta instead)");
+  }
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH3.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+      if (isTerminalPackage(pkg) && pkg.engines) {
+        result.fixable.push(`${name} (${location}) is terminal (private) but has engines \u2014 terminal packages should not declare engines`);
+      }
+      if (!isTerminalPackage(pkg) && !pkg.engines) {
+        result.fixable.push(`${name} (${location}) is a library but has no engines field`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixEnginesOnlyInNonTerminal(cwd, _pkg, workspaces) {
+  const rootPath = PATH3.resolve(cwd, "package.json");
+  const rootRaw = readFileSync3(rootPath, "utf8");
+  const rootPkg = JSON.parse(rootRaw);
+  if (rootPkg.engines) {
+    delete rootPkg.engines;
+    writeFileSync2(rootPath, `${JSON.stringify(rootPkg, null, 2)}
+`, "utf8");
+    console.log(chalk3.green("  \u2714 Fixed: removed engines from root package.json"));
+  }
+  const enginesTemplate = resolveEnginesTemplate(cwd, workspaces);
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH3.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync3(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (isTerminalPackage(pkg) && pkg.engines) {
+        delete pkg.engines;
+        writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk3.green(`  \u2714 Fixed: removed engines from ${location}/package.json`));
+      }
+      if (!isTerminalPackage(pkg) && !pkg.engines && enginesTemplate) {
+        pkg.engines = enginesTemplate;
+        writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk3.green(`  \u2714 Fixed: added engines to ${location}/package.json`));
+      }
+    } catch {
+    }
+  }
+}
+function resolveEnginesTemplate(cwd, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    try {
+      const pkg = JSON.parse(readFileSync3(PATH3.resolve(cwd, location, "package.json"), "utf8"));
+      if (!isTerminalPackage(pkg) && pkg.engines) {
+        return pkg.engines;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function checkVersionsIncludeLts(cwd, workspaces) {
+  const result = emptyResult();
+  const toolVersions = {
+    node: latestVersions.node,
+    npm: latestVersions.npm,
+    pnpm: latestVersions.pnpm,
+    yarn: latestVersions.yarn
+  };
+  for (const { location, name } of workspaces) {
+    const pkgPath = location === "." ? PATH3.resolve(cwd, "package.json") : PATH3.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+      const label = location === "." ? "root" : `${name} (${location})`;
+      const engines = pkg.engines;
+      if (engines) {
+        for (const [tool, range] of Object.entries(engines)) {
+          const latest = toolVersions[tool];
+          if (latest && !semver2.satisfies(latest, range)) {
+            result.errors.push(
+              `${label} engines.${tool} "${range}" does not include latest ${tool === "node" ? "LTS " : ""}version ${latest}`
+            );
+          }
+        }
+      }
+      const volta = pkg.volta;
+      if (volta) {
+        for (const [tool, pinnedVersion] of Object.entries(volta)) {
+          const latest = toolVersions[tool];
+          if (latest && semver2.lt(pinnedVersion, latest)) {
+            result.warnings.push(
+              `${label} volta.${tool} "${pinnedVersion}" is older than latest ${tool === "node" ? "LTS " : ""}version ${latest}`
+            );
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function logSummary(errors, fixed) {
+  if (fixed > 0) {
+    console.log(chalk3.green(`
+  Fixed ${fixed} issue(s)`));
+  }
+  if (errors > 0) {
+    console.log(chalk3.red(`
+  ${errors} error(s) found`));
+  } else if (fixed === 0) {
+    console.log(chalk3.green("\n  All checks passed"));
+  }
+}
+function packageLintMonorepo(fix = false) {
+  const cwd = INIT_CWD();
+  let pkg;
+  try {
+    pkg = readRootPackageJson(cwd);
+  } catch {
+    console.error(chalk3.red("Could not read package.json"));
+    return 1;
+  }
+  if (!isMonorepo(pkg, cwd)) {
+    console.log(chalk3.gray("Not a monorepo \u2014 skipping repo lint checks"));
+    return 0;
+  }
+  console.log(chalk3.green("Repo Lint"));
+  const pm = detectPackageManager();
+  const workspaces = getPackageManager().listWorkspaces();
+  const internalDepCheck = pm === "pnpm" ? {
+    check: () => checkWorkspaceProtocol(cwd, workspaces),
+    fix: () => fixWorkspaceProtocol(cwd, workspaces),
+    label: "Internal deps/devDeps use workspace: protocol"
+  } : {
+    check: () => checkInternalDepVersions(cwd, workspaces),
+    fix: () => fixInternalDepVersions(cwd, workspaces),
+    label: "Internal deps/devDeps use correct version ranges"
+  };
+  const checks = [
+    {
+      check: () => checkRootPrivate(pkg),
+      fix: fixRootPrivate,
+      label: "Root package is private"
+    },
+    {
+      check: () => checkNoPublishConfigOnPrivate(pkg),
+      fix: fixNoPublishConfigOnPrivate,
+      label: "No publishConfig on private root"
+    },
+    { check: () => checkPackagesFolder(workspaces), label: "All packages are in packages/ folder" },
+    {
+      check: () => checkWorkspacesFieldPlacement(cwd, pm, workspaces),
+      fix: () => fixWorkspacesFieldPlacement(cwd, pm, workspaces),
+      label: pm === "pnpm" ? "No workspaces field in package.json (use pnpm-workspace.yaml)" : "Workspaces field only in root package.json"
+    },
+    {
+      check: () => checkWorkspaceGlobCoverage(pkg, cwd, pm, workspaces),
+      label: "Workspace globs cover all packages"
+    },
+    {
+      check: () => checkNoPackageManagerInWorkspaces(cwd, workspaces),
+      fix: () => fixNoPackageManagerInWorkspaces(cwd, pkg, workspaces),
+      label: "No packageManager in workspace packages"
+    },
+    {
+      check: () => checkVoltaOnlyInRoot(cwd, workspaces),
+      fix: () => fixVoltaOnlyInRoot(cwd, pkg, workspaces),
+      label: "Volta only in root package.json"
+    },
+    {
+      check: () => checkEnginesOnlyInNonTerminal(cwd, workspaces),
+      fix: () => fixEnginesOnlyInNonTerminal(cwd, pkg, workspaces),
+      label: "Engines only in non-terminal (library) packages"
+    },
+    {
+      check: () => checkVersionsIncludeLts(cwd, workspaces),
+      label: "Engine/volta versions include latest LTS"
+    },
+    {
+      check: () => checkVersionConsistency(cwd, pkg, workspaces),
+      fix: () => fixVersionConsistency(cwd, pkg, writeRootPackageJson, workspaces),
+      label: "Consistent versions across packages"
+    },
+    internalDepCheck,
+    {
+      check: () => checkInternalPeerVersions(cwd, workspaces),
+      fix: () => fixInternalPeerVersions(cwd, workspaces),
+      label: "Internal peerDeps use semver ranges (not workspace: protocol)"
+    }
+  ];
+  const { errors, fixed } = runChecks(checks, cwd, pkg, fix);
+  logSummary(errors, fixed);
+  if (fix && fixed > 0) {
+    runInstall();
+  }
+  return errors > 0 ? 1 : 0;
+}
+
+// src/actions/repo-init.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import {
+  existsSync as existsSync3,
+  mkdirSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { createRequire as createRequire2 } from "module";
+import PATH4 from "path";
+import { createInterface } from "readline";
+import chalk4 from "chalk";
+function askQuestion(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function getConfigVersion() {
+  const require3 = createRequire2(import.meta.url);
+  const pkgPath = require3.resolve("@xylabs/ts-scripts-common/package.json");
+  const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+  return pkg.version.replace(/\.\d+$/, "");
+}
+function mapOutputPath(relativePath, variables) {
+  let result = relativePath;
+  if (result.endsWith(".tmpl")) {
+    result = result.slice(0, -5);
+  }
+  if (result === "gitignore") {
+    result = ".gitignore";
+  }
+  if (result.startsWith("github/")) {
+    result = `.${result}`;
+  }
+  result = result.replaceAll("__packageName__", variables.packageName);
+  return result;
+}
+function isPmSpecificFile(relativePath, pm) {
+  if (relativePath === "pnpm-workspace.yaml" && pm === "yarn") return true;
+  if (relativePath.includes("build-pnpm") && pm !== "pnpm") return true;
+  if (relativePath.includes("build-yarn") && pm !== "yarn") return true;
+  return false;
+}
+function mapBuildWorkflowName(outputPath) {
+  return outputPath.replace(/build-(pnpm|yarn)\.yml/, "build.yml");
+}
+function buildVariables(params) {
+  const {
+    description,
+    githubOrg,
+    packageName,
+    pm,
+    projectName,
+    scope
+  } = params;
+  const identifierName = packageName.replaceAll(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const pmPackage = pm === "pnpm" ? "@xylabs/ts-scripts-pnpm" : "@xylabs/ts-scripts-yarn3";
+  return {
+    configVersion: getConfigVersion(),
+    description,
+    githubOrg,
+    identifierName,
+    npmScope: scope,
+    packageName,
+    pmName: pm,
+    pmPackage,
+    projectName
+  };
+}
+function ensureEmptyDir(projectDir, name) {
+  if (existsSync3(projectDir)) {
+    const entries = readdirSync2(projectDir);
+    if (entries.length > 0) {
+      console.error(chalk4.red(`Directory '${name}' already exists and is not empty`));
+      return false;
+    }
+  }
+  mkdirSync(projectDir, { recursive: true });
+  return true;
+}
+function scaffoldFiles(templateName, layer, outputDir, pm, variables, verbose) {
+  const files = loadRepoTemplateFiles(templateName, layer);
+  let count = 0;
+  for (const file of files) {
+    if (isPmSpecificFile(file.relativePath, pm)) continue;
+    const content = fillTemplate(file.content, variables);
+    let outputPath = mapOutputPath(file.relativePath, variables);
+    if (!outputPath) continue;
+    if (layer === "root") outputPath = mapBuildWorkflowName(outputPath);
+    const fullPath = PATH4.resolve(outputDir, outputPath);
+    mkdirSync(PATH4.dirname(fullPath), { recursive: true });
+    writeFileSync3(fullPath, content);
+    count++;
+    if (verbose) console.log(chalk4.gray(`  ${layer === "root" ? outputPath : `packages/${variables.packageName}/${outputPath}`}`));
+  }
+  return count;
+}
+function initGitRepo(projectDir, verbose) {
+  if (verbose) console.log(chalk4.gray("Initializing git repository..."));
+  const result = spawnSync2("git", ["init", "-b", "main"], {
+    cwd: projectDir,
+    stdio: verbose ? "inherit" : "pipe"
+  });
+  if (result.status === 0) {
+    console.log(chalk4.green("Initialized git repository"));
+  } else {
+    console.warn(chalk4.yellow("git init failed, skipping"));
+  }
+}
+function installDependencies(projectDir, pm) {
+  console.log(chalk4.gray(`Running ${pm} install...`));
+  const result = spawnSync2(pm, ["install"], {
+    cwd: projectDir,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.warn(chalk4.yellow(`${pm} install failed`));
+    return false;
+  }
+  console.log(chalk4.green("Dependencies installed"));
+  return true;
+}
+async function repoInit(params) {
+  const {
+    description,
+    pm,
+    scope,
+    skipGit,
+    skipInstall,
+    template,
+    verbose
+  } = params;
+  let name = params.name;
+  if (!name) {
+    name = await askQuestion(chalk4.cyan("Project name: "));
+    if (!name) {
+      console.error(chalk4.red("Project name is required"));
+      return 1;
+    }
+  }
+  const projectName = PATH4.basename(name);
+  const packageName = params.packageName ?? projectName;
+  const githubOrg = params.githubOrg ?? scope.replace(/^@/, "");
+  const variables = buildVariables({
+    description,
+    githubOrg,
+    packageName,
+    pm,
+    projectName,
+    scope
+  });
+  if (verbose) {
+    console.log(chalk4.gray("Template variables:"));
+    for (const [key, value] of Object.entries(variables)) {
+      console.log(chalk4.gray(`  ${key}: ${value}`));
+    }
+  }
+  const projectDir = PATH4.resolve(process.cwd(), name);
+  if (!ensureEmptyDir(projectDir, name)) return 1;
+  const rootCount = scaffoldFiles(template, "root", projectDir, pm, variables, verbose);
+  const pkgDir = PATH4.resolve(projectDir, "packages", packageName);
+  const pkgCount = scaffoldFiles(template, "package", pkgDir, pm, variables, verbose);
+  console.log(chalk4.green(`Scaffolded ${rootCount + pkgCount} files into ${name}/`));
+  if (!skipGit) initGitRepo(projectDir, verbose);
+  if (!skipInstall && !installDependencies(projectDir, pm)) return 1;
+  console.log("");
+  console.log(chalk4.cyan(`Project ${name} created successfully!`));
+  console.log("");
+  console.log(chalk4.gray("Next steps:"));
+  console.log(chalk4.gray(`  cd ${name}`));
+  if (skipInstall) console.log(chalk4.gray(`  ${pm} install`));
+  console.log(chalk4.gray(`  ${pm} xy build`));
+  return 0;
+}
+
+// src/xy/common/repo/initCommand.ts
+var initCommand = {
+  command: "init <template> [name]",
+  describe: "Scaffold a new monorepo from a template",
+  builder: (yargs) => {
+    return yargs.positional("template", {
+      choices: ["cli"],
+      describe: "Template to use",
+      type: "string"
+    }).positional("name", {
+      describe: "Project name (also used as directory name)",
+      type: "string"
+    }).option("scope", {
+      default: "@xylabs",
+      describe: "npm scope for packages",
+      type: "string"
+    }).option("package", {
+      describe: "Package name within the monorepo (defaults to project name)",
+      type: "string"
+    }).option("description", {
+      default: "",
+      describe: "Project description",
+      type: "string"
+    }).option("github-org", {
+      describe: "GitHub organization (derived from scope if not set)",
+      type: "string"
+    }).option("pm", {
+      choices: ["pnpm", "yarn"],
+      default: "pnpm",
+      describe: "Package manager to configure",
+      type: "string"
+    }).option("skip-install", {
+      default: false,
+      describe: "Skip dependency installation after scaffolding",
+      type: "boolean"
+    }).option("skip-git", {
+      default: false,
+      describe: "Skip git init after scaffolding",
+      type: "boolean"
+    });
+  },
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Repo Init");
+    process.exitCode = await repoInit({
+      description: argv.description,
+      githubOrg: argv["github-org"],
+      name: argv.name,
+      packageName: argv.package,
+      pm: argv.pm,
+      scope: argv.scope,
+      skipGit: !!argv.skipGit,
+      skipInstall: !!argv.skipInstall,
+      template: argv.template,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/common/repo/lintCommand.ts
+var lintCommand = {
+  command: "lint",
+  describe: "Check monorepo package structure",
+  builder: (yargs) => {
+    return yargs.option("fix", {
+      default: false,
+      description: "Auto-fix fixable issues",
+      type: "boolean"
+    });
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log("Repo Lint");
+    process.exitCode = packageLintMonorepo(!!argv.fix);
+  }
+};
+
+// src/xy/common/repo/index.ts
+var repoCommand = {
+  builder: (yargs) => {
+    return yargs.command(initCommand).command(lintCommand).demandCommand(1, "Please specify a repo subcommand").strictCommands();
+  },
+  command: "repo",
+  describe: "Repo - Repository structure utilities",
+  handler: () => {
+  }
+};
+export {
+  repoCommand
+};
+//# sourceMappingURL=index.mjs.map