@art-work/cli 0.1.1 → 0.1.3

package/dist/{index.js → cjs/index.js}

@@ -1,15 +1,49 @@
 #!/usr/bin/env node
+"use strict";
+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);
 
 // src/index.ts
-import { Command } from "commander";
+var index_exports = {};
+__export(index_exports, {
+  defineConfig: () => defineConfig,
+  loadWorkspaceConfig: () => loadWorkspaceConfig
+});
+module.exports = __toCommonJS(index_exports);
+var import_commander = require("commander");
 
 // src/private/git/createOrSwitchBranch.ts
-import simpleGit2 from "simple-git";
+var import_simple_git2 = __toESM(require("simple-git"), 1);
 
 // src/private/git/hasLocalBranch.ts
-import simpleGit from "simple-git";
+var import_simple_git = __toESM(require("simple-git"), 1);
 async function hasLocalBranch(dir, branch) {
-  const git = simpleGit(dir);
+  const git = (0, import_simple_git.default)(dir);
   try {
     const out = await git.raw(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]);
     return out.trim().length > 0;
@@ -20,7 +54,7 @@ async function hasLocalBranch(dir, branch) {
 
 // src/private/git/createOrSwitchBranch.ts
 async function createOrSwitchBranch(dir, branch) {
-  const git = simpleGit2(dir);
+  const git = (0, import_simple_git2.default)(dir);
   if (await hasLocalBranch(dir, branch)) {
     await git.checkout(branch);
     return "switched";
@@ -78,14 +112,14 @@ function createOperationSuccess(pending, message) {
 }
 
 // src/private/resources/checkout/saveCheckoutRecord.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
 
 // src/private/resources/checkout/private/makeCheckoutFilename.ts
-import { join } from "node:path";
+var import_node_path = require("node:path");
 function makeCheckoutFilename(config, data) {
   const slug = data.name.toLowerCase().replace(/\s+/g, "-");
-  return join(config.root.path, config.checkouts.path, `${slug}-checkout.art`);
+  return (0, import_node_path.join)(config.root.path, config.checkouts.path, `${slug}-checkout.art`);
 }
 
 // src/private/resources/checkout/saveCheckoutRecord.ts
@@ -101,17 +135,17 @@ var HARDCODED_TEMPLATE = `# Module
 `;
 async function saveCheckoutRecord(config, data, filename) {
   let template = HARDCODED_TEMPLATE;
-  const templatePath = join2(config.root.path, config.checkouts.template);
-  if (existsSync(templatePath)) {
-    template = readFileSync(templatePath, "utf-8");
+  const templatePath = (0, import_node_path2.join)(config.root.path, config.checkouts.template);
+  if ((0, import_node_fs.existsSync)(templatePath)) {
+    template = (0, import_node_fs.readFileSync)(templatePath, "utf-8");
   }
   const fileName = filename ?? makeCheckoutFilename(config, data);
   let content = template.replace("{{ name }}", data.name).replace("{{ repository }}", data.repository ?? "").replace("{{ location }}", data.location).replace("{{ branch }}", data.branch);
   if (!data.repository) {
     content = content.replace(/\*\*Repository:\*\*\s*\n\n?/g, "");
   }
-  mkdirSync(dirname(fileName), { recursive: true });
-  writeFileSync(fileName, content);
+  (0, import_node_fs.mkdirSync)((0, import_node_path2.dirname)(fileName), { recursive: true });
+  (0, import_node_fs.writeFileSync)(fileName, content);
   return fileName;
 }
 
@@ -174,7 +208,7 @@ function createGenericOperation(operation, data) {
 }
 
 // src/private/present/presentCheckoutReport.ts
-import { join as join3 } from "node:path";
+var import_node_path3 = require("node:path");
 
 // src/private/present/formatTable.ts
 function formatTable(rows, headers) {
@@ -199,7 +233,7 @@ function presentCheckoutReport(config, checkouts) {
   const headers = ["repo", "location", "branch", "states"];
   const rows = items.map((c) => [
     c.repo?.name || "-",
-    join3(config.clone.path, c.record.location),
+    (0, import_node_path3.join)(config.clone.path, c.record.location),
     c.scan?.state("remote").branch || c.record.branch,
     c.scan?.issues().join("; ") || "-"
   ]);
@@ -247,12 +281,12 @@ function presentOperationsReport(log) {
 }
 
 // src/private/resources/checkout/loadCheckoutRecords.ts
-import { findRecordFiles } from "@art-lib/fs-records";
+var import_fs_records2 = require("@art-lib/fs-records");
 
 // src/private/resources/checkout/readCheckoutRecord.ts
-import { readRecordFileContent } from "@art-lib/fs-records";
+var import_fs_records = require("@art-lib/fs-records");
 async function readCheckoutRecord(file) {
-  const fileWithContents = file.content ? file : await readRecordFileContent(file);
+  const fileWithContents = file.content ? file : await (0, import_fs_records.readRecordFileContent)(file);
   if (!fileWithContents.content) {
     return null;
   }
@@ -282,7 +316,7 @@ async function readCheckoutRecord(file) {
 async function loadCheckoutRecords(ctx, repos) {
   const searchPath = ctx.config.root.path;
   ctx.log.log(createGenericOperation("load-checkout-records", searchPath));
-  const recordFiles = await findRecordFiles(ctx.config.records, searchPath, ["Checkout"]);
+  const recordFiles = await (0, import_fs_records2.findRecordFiles)(ctx.config.records, searchPath, ["Checkout"]);
   const checkouts = await Promise.all(
     recordFiles.map(async (file) => {
       const record = await readCheckoutRecord(file);
@@ -311,12 +345,12 @@ async function loadCheckoutRecords(ctx, repos) {
 }
 
 // src/private/resources/repository/loadRepositoryRecords.ts
-import { findRecordFiles as findRecordFiles2 } from "@art-lib/fs-records";
+var import_fs_records4 = require("@art-lib/fs-records");
 
 // src/private/resources/repository/readRepositoryRecord.ts
-import { readRecordFileContent as readRecordFileContent2 } from "@art-lib/fs-records";
+var import_fs_records3 = require("@art-lib/fs-records");
 async function readRepositoryRecord(file) {
-  const fileWithContents = file.content ? file : await readRecordFileContent2(file);
+  const fileWithContents = file.content ? file : await (0, import_fs_records3.readRecordFileContent)(file);
   if (!fileWithContents.content) {
     return null;
   }
@@ -345,18 +379,18 @@ async function readRepositoryRecord(file) {
 async function loadRepositoryRecords(ctx) {
   const searchPath = ctx.config.root.path;
   ctx.log.log(createGenericOperation("load-repository-records", searchPath));
-  const recordFiles = await findRecordFiles2(ctx.config.records, searchPath, ["Repository"]);
+  const recordFiles = await (0, import_fs_records4.findRecordFiles)(ctx.config.records, searchPath, ["Repository"]);
   const records = await Promise.all(recordFiles.map((file) => readRepositoryRecord(file)));
   return records.filter((record) => record !== null);
 }
 
 // src/private/scan/scanCheckoutState.ts
-import { access } from "node:fs/promises";
+var import_promises = require("node:fs/promises");
 
 // src/private/git/getBehindAheadCount.ts
-import simpleGit3 from "simple-git";
+var import_simple_git3 = __toESM(require("simple-git"), 1);
 async function getBehindAheadCount(dir, remoteBranch) {
-  const git = simpleGit3(dir);
+  const git = (0, import_simple_git3.default)(dir);
   try {
     if (!remoteBranch) {
       const ahead2 = await git.raw(["rev-list", "--count", "HEAD", "--not", "--remotes=origin"]);
@@ -371,9 +405,9 @@ async function getBehindAheadCount(dir, remoteBranch) {
 }
 
 // src/private/git/getCurrentBranch.ts
-import simpleGit4 from "simple-git";
+var import_simple_git4 = __toESM(require("simple-git"), 1);
 async function getCurrentBranch(dir) {
-  const git = simpleGit4(dir);
+  const git = (0, import_simple_git4.default)(dir);
   try {
     const status = await git.status();
     const branch = status.current ?? "HEAD";
@@ -394,9 +428,9 @@ async function getCurrentBranch(dir) {
 }
 
 // src/private/git/getRemoteBranch.ts
-import simpleGit5 from "simple-git";
+var import_simple_git5 = __toESM(require("simple-git"), 1);
 async function getRemoteBranch(dir) {
-  const git = simpleGit5(dir);
+  const git = (0, import_simple_git5.default)(dir);
   try {
     const branches = await git.branch();
     const current = branches.current;
@@ -413,9 +447,9 @@ async function getRemoteBranch(dir) {
 }
 
 // src/private/git/getRemoteUrl.ts
-import simpleGit6 from "simple-git";
+var import_simple_git6 = __toESM(require("simple-git"), 1);
 async function getRemoteUrl(dir) {
-  const git = simpleGit6(dir);
+  const git = (0, import_simple_git6.default)(dir);
   try {
     const config = await git.listConfig();
     const url = config.all["remote.origin.url"];
@@ -428,9 +462,9 @@ async function getRemoteUrl(dir) {
 }
 
 // src/private/git/hasMergeConflicts.ts
-import simpleGit7 from "simple-git";
+var import_simple_git7 = __toESM(require("simple-git"), 1);
 async function hasMergeConflicts(dir) {
-  const git = simpleGit7(dir);
+  const git = (0, import_simple_git7.default)(dir);
   try {
     const status = await git.status();
     return status.conflicted.length > 0;
@@ -440,9 +474,9 @@ async function hasMergeConflicts(dir) {
 }
 
 // src/private/git/hasRemote.ts
-import simpleGit8 from "simple-git";
+var import_simple_git8 = __toESM(require("simple-git"), 1);
 async function hasRemote(dir) {
-  const git = simpleGit8(dir);
+  const git = (0, import_simple_git8.default)(dir);
   try {
     const remotes = await git.getRemotes(false);
     return remotes.length > 0;
@@ -452,9 +486,9 @@ async function hasRemote(dir) {
 }
 
 // src/private/git/isDetachedHead.ts
-import simpleGit9 from "simple-git";
+var import_simple_git9 = __toESM(require("simple-git"), 1);
 async function isDetachedHead(dir) {
-  const git = simpleGit9(dir);
+  const git = (0, import_simple_git9.default)(dir);
   try {
     const status = await git.status();
     if (status.current && status.current !== "HEAD") {
@@ -472,9 +506,9 @@ async function isDetachedHead(dir) {
 }
 
 // src/private/git/isDirty.ts
-import simpleGit10 from "simple-git";
+var import_simple_git10 = __toESM(require("simple-git"), 1);
 async function isDirty(dir) {
-  const git = simpleGit10(dir);
+  const git = (0, import_simple_git10.default)(dir);
   try {
     const status = await git.status();
     return status.files.length > 0;
@@ -484,9 +518,9 @@ async function isDirty(dir) {
 }
 
 // src/private/git/remoteFetch.ts
-import simpleGit11 from "simple-git";
+var import_simple_git11 = __toESM(require("simple-git"), 1);
 async function remoteFetch(dir) {
-  const git = simpleGit11(dir);
+  const git = (0, import_simple_git11.default)(dir);
   try {
     await git.fetch("origin");
   } catch {
@@ -608,7 +642,7 @@ function createCheckoutNoClonedScan(known) {
 // src/private/scan/scanCheckoutState.ts
 async function scanCheckoutState(ctx, checkout, refetch = false) {
   try {
-    await access(checkout.path);
+    await (0, import_promises.access)(checkout.path);
   } catch {
     return { ...checkout, scan: createCheckoutNoClonedScan(Boolean(checkout.repo)) };
   }
@@ -667,7 +701,7 @@ async function scanCheckoutState(ctx, checkout, refetch = false) {
 }
 
 // src/private/store/createCheckout.ts
-import path, { join as join4 } from "node:path";
+var import_node_path4 = __toESM(require("node:path"), 1);
 
 // src/private/store/safePath.ts
 function safePath(pathStr) {
@@ -676,7 +710,7 @@ function safePath(pathStr) {
 
 // src/private/store/createCheckout.ts
 function createCheckout(config, target, repo, branch, name) {
-  const basePath = join4(config.root.path, config.clone.path);
+  const basePath = (0, import_node_path4.join)(config.root.path, config.clone.path);
   const l = safePath(target);
   const r = repo;
   const b = branch ?? "main";
@@ -684,7 +718,7 @@ function createCheckout(config, target, repo, branch, name) {
   return {
     repo: r,
     record: { name: n, location: l, branch: b, repository: r?.name },
-    path: path.join(basePath, l)
+    path: import_node_path4.default.join(basePath, l)
   };
 }
 
@@ -755,11 +789,10 @@ async function runBranch(ctx, options) {
 }
 
 // src/private/exec/runCommandInDirectory.ts
-import { spawn } from "node:child_process";
+var import_node_child_process = require("node:child_process");
 function runCommandInDirectory(dir, command) {
   return new Promise((resolve) => {
-    const [cmd, ...args] = command.length === 1 ? command[0].split(/\s+/) : command;
-    const child = spawn(cmd, args, { cwd: dir });
+    const child = (0, import_node_child_process.spawn)(command, { cwd: dir, shell: true });
     let output = "";
     let error = "";
     child.stdout?.on("data", (chunk) => output += chunk);
@@ -788,16 +821,15 @@ function createCheckoutRunOperation(checkout, command) {
 
 // src/private/commands/checkouts/doCheckoutRun.ts
 async function doCheckoutRun(ctx, checkout, command) {
-  const commandLine = command.join(" ");
   if (!checkout.scan?.state("exists").exists) {
     const op = createOperationFailure(
-      createCheckoutRunOperation(checkout, commandLine),
+      createCheckoutRunOperation(checkout, command),
       new Error("checkout not cloned")
     );
     ctx.log.log(op);
     return null;
   }
-  const pending = createCheckoutRunOperation(checkout, commandLine);
+  const pending = createCheckoutRunOperation(checkout, command);
   try {
     ctx.log.log(pending);
     const runOutcome = await runCommandInDirectory(checkout.path, command);
@@ -815,7 +847,10 @@ async function doCheckoutRun(ctx, checkout, command) {
         console.info("");
       }
       if (runOutcome.error) {
-        console.error("\n--- Error:\n");
+        const maybeErrorLabel = runOutcome.code === 0 ? "" : " Error:";
+        console.error(`
+---${maybeErrorLabel}
+`);
         console.error(runOutcome.error);
         console.error("");
       }
@@ -833,7 +868,6 @@ async function runCheckoutsRun(ctx, options) {
   const records = await loadCheckoutRecords(ctx, repos);
   hydrateStoreFromRecords(ctx.config, ctx.store, records);
   ctx.log.log(createGenericOperation("command", ["checkouts", "run", options.command]));
-  await scanAllCheckoutsStates(ctx);
   if (!options.all && (!options.checkouts || options.checkouts.length === 0)) {
     console.error("No checkouts matched.");
     console.error(
@@ -841,6 +875,7 @@ async function runCheckoutsRun(ctx, options) {
     );
     return;
   }
+  await scanAllCheckoutsStates(ctx);
   const checkouts = options.all ? ctx.store.getAllCheckouts() : ctx.store.getCheckoutsByPattern(options.checkouts ?? []);
   await runWithConcurrency(checkouts, 4, async (checkout) => {
     await doCheckoutRun(ctx, checkout, options.command);
@@ -850,17 +885,17 @@ async function runCheckoutsRun(ctx, options) {
 }
 
 // src/private/git/cloneCheckout.ts
-import simpleGit12 from "simple-git";
+var import_simple_git12 = __toESM(require("simple-git"), 1);
 async function cloneCheckout(checkout) {
   const recordedBranch = checkout.record.branch;
-  const git = simpleGit12("");
+  const git = (0, import_simple_git12.default)("");
   if (!checkout.repo?.remote) {
     throw new Error(``);
   }
   await git.clone(checkout.repo.remote, checkout.path);
   if (recordedBranch) {
     try {
-      const repoGit = simpleGit12(checkout.path);
+      const repoGit = (0, import_simple_git12.default)(checkout.path);
       await repoGit.checkout(recordedBranch);
     } catch {
     }
@@ -937,8 +972,8 @@ async function cloneAll(ctx, repos) {
 }
 
 // src/commands/clone/cloneSpecific.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+var import_node_fs2 = require("node:fs");
+var import_node_path5 = require("node:path");
 
 // src/private/store/createCheckoutLocation.ts
 function createCheckoutLocation(repo, target) {
@@ -967,8 +1002,8 @@ async function cloneSpecific(ctx, repos, repoName, checkoutInput) {
   if (existing) {
     await cloneIfMissing(ctx, existing);
   } else {
-    const targetDir = join5(ctx.config.root.path, ctx.config.clone.path, location);
-    if (existsSync2(targetDir)) {
+    const targetDir = (0, import_node_path5.join)(ctx.config.root.path, ctx.config.clone.path, location);
+    if ((0, import_node_fs2.existsSync)(targetDir)) {
       const msg = `directory already exists at ${targetDir}`;
       ctx.log.log(createOperationFailure(createCloneOperation(void 0), msg));
       presentOperationsReport(ctx.log);
@@ -1058,9 +1093,9 @@ async function runPublish(ctx, _options) {
 }
 
 // src/private/git/pullCheckout.ts
-import simpleGit13 from "simple-git";
+var import_simple_git13 = __toESM(require("simple-git"), 1);
 async function pullCheckout(checkout) {
-  const git = simpleGit13(checkout.path);
+  const git = (0, import_simple_git13.default)(checkout.path);
   await git.pull("origin", checkout.record.branch);
 }
 
@@ -1098,13 +1133,13 @@ async function doPullCheckout(ctx, checkout) {
 }
 
 // src/private/commands/workspaces/doPullWorkspaceCheckout.ts
-import simpleGit14 from "simple-git";
+var import_simple_git14 = __toESM(require("simple-git"), 1);
 async function doPullWorkspaceCheckout(ctx) {
   const workspace = ctx.workspace;
   if (!workspace) return null;
   if (!workspace.scan?.can?.("pull") || !workspace.scan.should?.("pull")) return null;
   const pending = createPullOperation(workspace, workspace.record.branch);
-  const git = simpleGit14(workspace.path);
+  const git = (0, import_simple_git14.default)(workspace.path);
   try {
     ctx.log.log(pending);
     await git.pull("origin", workspace.record.branch);
@@ -1158,9 +1193,9 @@ async function runPull(ctx, options = {}) {
 }
 
 // src/private/git/pushCheckout.ts
-import simpleGit15 from "simple-git";
+var import_simple_git15 = __toESM(require("simple-git"), 1);
 async function pushCheckout(checkout) {
-  const git = simpleGit15(checkout.path);
+  const git = (0, import_simple_git15.default)(checkout.path);
   await git.push("origin", checkout.record.branch);
 }
 
@@ -1198,13 +1233,13 @@ async function doPushCheckout(ctx, checkout) {
 }
 
 // src/private/commands/workspaces/doPushWorkspaceCheckout.ts
-import simpleGit16 from "simple-git";
+var import_simple_git16 = __toESM(require("simple-git"), 1);
 async function doPushWorkspaceCheckout(ctx) {
   const workspace = ctx.workspace;
   if (!workspace) return null;
   if (!workspace.scan?.can?.("push") || !workspace.scan.should?.("push")) return null;
   const pending = createPushOperation(workspace, workspace.record.branch);
-  const git = simpleGit16(workspace.path);
+  const git = (0, import_simple_git16.default)(workspace.path);
   try {
     ctx.log.log(pending);
     await git.push("origin", workspace.record.branch);
@@ -1281,15 +1316,15 @@ function presentPackageStateReport(checkout, packageStates) {
 }
 
 // src/private/repositories/createPackageStateRecord.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+var import_node_fs3 = require("node:fs");
+var import_node_path6 = require("node:path");
 function createPackageStateRecord(checkoutPath, projectPath, nsPath, pkg) {
-  let pkgPath = join6(checkoutPath, projectPath, nsPath, pkg.path);
-  let pkgJsonPath = join6(pkgPath, "package.json");
-  if (!existsSync3(pkgJsonPath)) {
-    const altPath = join6(checkoutPath, projectPath, pkg.path);
-    const altPkgJsonPath = join6(altPath, "package.json");
-    if (existsSync3(altPkgJsonPath)) {
+  let pkgPath = (0, import_node_path6.join)(checkoutPath, projectPath, nsPath, pkg.path);
+  let pkgJsonPath = (0, import_node_path6.join)(pkgPath, "package.json");
+  if (!(0, import_node_fs3.existsSync)(pkgJsonPath)) {
+    const altPath = (0, import_node_path6.join)(checkoutPath, projectPath, pkg.path);
+    const altPkgJsonPath = (0, import_node_path6.join)(altPath, "package.json");
+    if ((0, import_node_fs3.existsSync)(altPkgJsonPath)) {
       pkgPath = altPath;
       pkgJsonPath = altPkgJsonPath;
     }
@@ -1301,9 +1336,9 @@ function createPackageStateRecord(checkoutPath, projectPath, nsPath, pkg) {
     directory: pkgPath,
     states: []
   };
-  if (existsSync3(pkgJsonPath)) {
+  if ((0, import_node_fs3.existsSync)(pkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse((0, import_node_fs3.readFileSync)(pkgJsonPath, "utf-8"));
       record.version = pkgJson.version ?? null;
     } catch {
       record.states.push("no package.json");
@@ -1315,11 +1350,11 @@ function createPackageStateRecord(checkoutPath, projectPath, nsPath, pkg) {
 }
 
 // src/private/repositories/scanPackageStateRecord.ts
-import { execSync } from "node:child_process";
+var import_node_child_process2 = require("node:child_process");
 function scanPackageStateRecord(pkg, record) {
   if (record.version !== null && record.version !== "0.0.0") {
     try {
-      const output = execSync(`npm info ${pkg.canonicalName} version`, {
+      const output = (0, import_node_child_process2.execSync)(`npm info ${pkg.canonicalName} version`, {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "ignore"]
@@ -1351,12 +1386,12 @@ function getRepositoryCheckoutPackages(checkoutPath, graph) {
 }
 
 // src/private/resources/namespace/loadNamespaceRecords.ts
-import { findRecordFiles as findRecordFiles3 } from "@art-lib/fs-records";
+var import_fs_records6 = require("@art-lib/fs-records");
 
 // src/private/resources/namespace/readNamespaceRecord.ts
-import { readRecordFileContent as readRecordFileContent3 } from "@art-lib/fs-records";
+var import_fs_records5 = require("@art-lib/fs-records");
 async function readNamespaceRecord(file) {
-  const fileWithContents = file.content ? file : await readRecordFileContent3(file);
+  const fileWithContents = file.content ? file : await (0, import_fs_records5.readRecordFileContent)(file);
   if (!fileWithContents.content) {
     return null;
   }
@@ -1382,18 +1417,18 @@ async function readNamespaceRecord(file) {
 
 // src/private/resources/namespace/loadNamespaceRecords.ts
 async function loadNamespaceRecords(config, checkoutPath) {
-  const recordFiles = await findRecordFiles3(config.records, checkoutPath, ["Namespace"]);
+  const recordFiles = await (0, import_fs_records6.findRecordFiles)(config.records, checkoutPath, ["Namespace"]);
   const records = await Promise.all(recordFiles.map((file) => readNamespaceRecord(file)));
   return records.filter((record) => record !== null);
 }
 
 // src/private/resources/package/loadPackageRecords.ts
-import { findRecordFiles as findRecordFiles4 } from "@art-lib/fs-records";
+var import_fs_records8 = require("@art-lib/fs-records");
 
 // src/private/resources/package/readPackageRecord.ts
-import { readRecordFileContent as readRecordFileContent4 } from "@art-lib/fs-records";
+var import_fs_records7 = require("@art-lib/fs-records");
 async function readPackageRecord(file) {
-  const fileWithContents = file.content ? file : await readRecordFileContent4(file);
+  const fileWithContents = file.content ? file : await (0, import_fs_records7.readRecordFileContent)(file);
   if (!fileWithContents.content) {
     return null;
   }
@@ -1415,18 +1450,18 @@ async function readPackageRecord(file) {
 
 // src/private/resources/package/loadPackageRecords.ts
 async function loadPackageRecords(config, checkoutPath) {
-  const recordFiles = await findRecordFiles4(config.records, checkoutPath, ["Package"]);
+  const recordFiles = await (0, import_fs_records8.findRecordFiles)(config.records, checkoutPath, ["Package"]);
   const records = await Promise.all(recordFiles.map((file) => readPackageRecord(file)));
   return records.filter((record) => record !== null);
 }
 
 // src/private/resources/project/loadProjectRecords.ts
-import { findRecordFiles as findRecordFiles5 } from "@art-lib/fs-records";
+var import_fs_records10 = require("@art-lib/fs-records");
 
 // src/private/resources/project/readProjectRecord.ts
-import { readRecordFileContent as readRecordFileContent5 } from "@art-lib/fs-records";
+var import_fs_records9 = require("@art-lib/fs-records");
 async function readProjectRecord(file) {
-  const fileWithContents = file.content ? file : await readRecordFileContent5(file);
+  const fileWithContents = file.content ? file : await (0, import_fs_records9.readRecordFileContent)(file);
   if (!fileWithContents.content) {
     return null;
   }
@@ -1452,7 +1487,7 @@ async function readProjectRecord(file) {
 
 // src/private/resources/project/loadProjectRecords.ts
 async function loadProjectRecords(config, checkoutPath) {
-  const recordFiles = await findRecordFiles5(config.records, checkoutPath, ["Project"]);
+  const recordFiles = await (0, import_fs_records10.findRecordFiles)(config.records, checkoutPath, ["Project"]);
   const records = await Promise.all(recordFiles.map((file) => readProjectRecord(file)));
   return records.filter((record) => record !== null);
 }
@@ -1579,8 +1614,8 @@ function presentWorkspaceReport(workspace) {
 }
 
 // src/commands/sanity/private/scanExtraneousCheckouts.ts
-import { readdir } from "node:fs/promises";
-import { join as join7, relative } from "node:path";
+var import_promises2 = require("node:fs/promises");
+var import_node_path7 = require("node:path");
 
 // src/private/scan/private/createExtraneousCheckout.ts
 function createExtraneousCheckout(config, location) {
@@ -1589,16 +1624,16 @@ function createExtraneousCheckout(config, location) {
 
 // src/commands/sanity/private/scanExtraneousCheckouts.ts
 async function scanExtraneousCheckouts(ctx, store) {
-  const checkoutsPath = join7(ctx.config.root.path, ctx.config.clone.path);
+  const checkoutsPath = (0, import_node_path7.join)(ctx.config.root.path, ctx.config.clone.path);
   const result = [];
   try {
-    const entries = await readdir(checkoutsPath, { withFileTypes: true });
+    const entries = await (0, import_promises2.readdir)(checkoutsPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const dir = join7(checkoutsPath, entry.name);
-      const location = relative(checkoutsPath, dir);
+      const dir = (0, import_node_path7.join)(checkoutsPath, entry.name);
+      const location = (0, import_node_path7.relative)(checkoutsPath, dir);
       const known = store.getCheckoutForLocation(location);
       if (known) {
         continue;
@@ -1645,7 +1680,7 @@ async function runSanity(ctx, options) {
 }
 
 // src/private/commands/workspaces/syncWorkspaceCheckout.ts
-import simpleGit17 from "simple-git";
+var import_simple_git17 = __toESM(require("simple-git"), 1);
 async function syncWorkspaceCheckout(ctx) {
   let workspace = ctx.workspace;
   if (!workspace) {
@@ -1657,7 +1692,7 @@ async function syncWorkspaceCheckout(ctx) {
     ctx.workspace = scanned;
     workspace = scanned;
   }
-  const git = simpleGit17(workspace.path);
+  const git = (0, import_simple_git17.default)(workspace.path);
   if (workspace.scan?.can?.("pull")) {
     const pending = createPullOperation(workspace, workspace.record.branch);
     try {
@@ -1741,10 +1776,10 @@ async function runUnlink(ctx, _options) {
 }
 
 // src/config/loadWorkspaceConfig.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join8 } from "node:path";
-import { pathToFileURL } from "node:url";
-import { build } from "esbuild";
+var import_node_fs4 = require("node:fs");
+var import_node_path8 = require("node:path");
+var import_node_url = require("node:url");
+var import_esbuild = require("esbuild");
 
 // src/config/private/normalizeRecordPaths.ts
 var DEFAULTS = {
@@ -1821,14 +1856,14 @@ function formatError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function loadWorkspaceConfig(rootPath) {
-  const manifestPath = join8(rootPath, MANIFEST_FILE);
-  if (!existsSync4(manifestPath)) {
+  const manifestPath = (0, import_node_path8.join)(rootPath, MANIFEST_FILE);
+  if (!(0, import_node_fs4.existsSync)(manifestPath)) {
     console.warn(`${MANIFEST_FILE} not found at ${rootPath}; Using default config.`);
     return defineConfig({ ...DEFAULT_CONFIG, root: { path: rootPath } });
   }
   let output;
   try {
-    output = await build({
+    output = await (0, import_esbuild.build)({
       entryPoints: [manifestPath],
       bundle: true,
       write: false,
@@ -1852,10 +1887,10 @@ async function loadWorkspaceConfig(rootPath) {
       `Failed to bundle workspace manifest at ${manifestPath}: ${formatError(error)}`
     );
   }
-  const tempFile = join8(rootPath, TEMP_FILE);
-  writeFileSync2(tempFile, output.outputFiles[0].text);
+  const tempFile = (0, import_node_path8.join)(rootPath, TEMP_FILE);
+  (0, import_node_fs4.writeFileSync)(tempFile, output.outputFiles[0].text);
   try {
-    const loaded = await import(pathToFileURL(tempFile).href);
+    const loaded = await import((0, import_node_url.pathToFileURL)(tempFile).href);
     const config = loaded.default;
     return defineConfig({ ...config, root: { path: rootPath } });
   } catch (error) {
@@ -1968,7 +2003,7 @@ function createCheckoutStore() {
 }
 
 // src/index.ts
-var program = new Command();
+var program = new import_commander.Command();
 var logger = (op) => {
   console.info(makeOperationLogLine(op, { standalone: true }).join(" | "));
 };
@@ -2043,7 +2078,7 @@ program.command("sync").description("Pull and push clean checkouts").option(
   const ctx = createWorkspaceContext(config, store, log);
   await runSync(ctx, { checkouts: options.checkouts, all: options.all });
 });
-program.command("checkouts").description("Checkout operations").command("run").description("Run a command in selected checkouts").argument("<command...>", "command to run").option(
+program.command("checkouts").description("Checkout operations").command("run").description("Run a command in selected checkouts").argument("<command>", "command to run").option(
   "-c, --checkouts <PATTERN...>",
   'One or more. Matches checkout name and location. Wildcard asterisk * supported. Example: -c "* @ refactor" "lib-*"'
 ).option("-A, --all", "Apply to all checkouts").action(async (command, options) => {
@@ -2092,7 +2127,9 @@ program.command("publish").description("Publish packages").option("-a, --auto",
   await runPublish(ctx, { root, auto: options.auto });
 });
 program.parse();
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   defineConfig,
   loadWorkspaceConfig
-};
+});
+//# sourceMappingURL=index.js.map