@art-work/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2098 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/private/git/createOrSwitchBranch.ts
+import simpleGit2 from "simple-git";
+
+// src/private/git/hasLocalBranch.ts
+import simpleGit from "simple-git";
+async function hasLocalBranch(dir, branch) {
+  const git = simpleGit(dir);
+  try {
+    const out = await git.raw(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]);
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/private/git/createOrSwitchBranch.ts
+async function createOrSwitchBranch(dir, branch) {
+  const git = simpleGit2(dir);
+  if (await hasLocalBranch(dir, branch)) {
+    await git.checkout(branch);
+    return "switched";
+  }
+  await git.checkoutLocalBranch(branch);
+  return "created";
+}
+
+// src/private/operations/createOperationFailure.ts
+function formatRawError(raw) {
+  const lines = raw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  return lines.map((l) => "  " + l).join("\n");
+}
+function extractReason(raw) {
+  const match = raw.match(/\(([^)]+)\)/);
+  return match ? match[1] : raw.split("\n")[0]?.trim() ?? "unknown error";
+}
+var errorLabels = {
+  clone: "CloneError",
+  push: "PushError",
+  pull: "PullError",
+  publish: "PublishError",
+  branch: "BranchError",
+  linked: "LinkedError",
+  unlink: "UnlinkError",
+  run: "CheckoutRunError"
+};
+function createOperationFailure(pending, error) {
+  const rawError = error instanceof Error ? error.message : String(error);
+  const label = errorLabels[pending.operation] ?? "OperationError";
+  return {
+    ...pending,
+    outcome: "failure",
+    finishedTs: /* @__PURE__ */ new Date(),
+    error: rawError,
+    message() {
+      return extractReason(this.error);
+    },
+    errorSerialized() {
+      return `${label}: ${pending.checkout?.repo?.name} \u2014 ${this.message()}
+
+${formatRawError(this.error)}`;
+    }
+  };
+}
+
+// src/private/operations/createOperationSuccess.ts
+function createOperationSuccess(pending, message) {
+  return {
+    ...pending,
+    outcome: "success",
+    finishedTs: /* @__PURE__ */ new Date(),
+    message: message ? () => message : pending.message
+  };
+}
+
+// src/private/resources/checkout/saveCheckoutRecord.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+
+// src/private/resources/checkout/private/makeCheckoutFilename.ts
+import { join } from "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`);
+}
+
+// src/private/resources/checkout/saveCheckoutRecord.ts
+var HARDCODED_TEMPLATE = `# Module
+
+## Checkout: {{ name }}
+
+**Repository:** {{ repository }}
+
+**Location:** \`{{ location }}\`
+
+**Branch:** \`{{ branch }}\`
+`;
+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 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);
+  return fileName;
+}
+
+// src/private/commands/operations/createBranchOperation.ts
+function createBranchOperation(checkout, branch) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    checkout,
+    outcome: "pending",
+    operation: "branch",
+    branch,
+    message() {
+      return `branch ${branch}`;
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// src/private/commands/checkouts/doBranchCheckout.ts
+async function doBranchCheckout(ctx, checkout, branch) {
+  const pending = createBranchOperation(checkout, branch);
+  try {
+    ctx.log.log(pending);
+    const outcome = await createOrSwitchBranch(checkout.path, branch);
+    ctx.log.log(
+      createOperationSuccess(
+        pending,
+        outcome === "created" ? `created ${branch}` : `switched to ${branch}`
+      )
+    );
+    const updated = { ...checkout, record: { ...checkout.record, branch } };
+    ctx.store.updateCheckout(updated);
+    await saveCheckoutRecord(ctx.config, updated.record, updated.filename);
+    return updated;
+  } catch (error) {
+    ctx.log.log(createOperationFailure(createBranchOperation(checkout, branch), error));
+    return null;
+  }
+}
+
+// src/private/operations/createGenericOperation.ts
+function formatData(data) {
+  return data ? JSON.stringify(data) : "";
+}
+function createGenericOperation(operation, data) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    outcome: "pending",
+    operation,
+    data,
+    message() {
+      return formatData(data);
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// src/private/present/presentCheckoutReport.ts
+import { join as join3 } from "node:path";
+
+// src/private/present/formatTable.ts
+function formatTable(rows, headers) {
+  const allRows = [headers, ...rows];
+  const colWidths = headers.map(
+    (_, colIdx) => Math.max(...allRows.map((row) => String(row[colIdx]).length))
+  );
+  const lines = allRows.map(
+    (row) => row.map((cell, i) => String(cell).padEnd(colWidths[i])).join("  ")
+  );
+  return lines.join("\n");
+}
+
+// src/private/present/presentCheckoutReport.ts
+function presentCheckoutReport(config, checkouts) {
+  const items = [...checkouts];
+  items.sort((a, b) => {
+    if (a.repo?.remote === "" && b.repo?.remote !== "") return 1;
+    if (a.repo?.remote !== "" && b.repo?.remote === "") return -1;
+    return a.repo?.name.localeCompare(b.repo?.name || "") || -1;
+  });
+  const headers = ["repo", "location", "branch", "states"];
+  const rows = items.map((c) => [
+    c.repo?.name || "-",
+    join3(config.clone.path, c.record.location),
+    c.scan?.state("remote").branch || c.record.branch,
+    c.scan?.issues().join("; ") || "-"
+  ]);
+  console.info("Checkouts:");
+  console.info(formatTable(rows, headers));
+  console.info("");
+}
+
+// src/private/present/private/truncateMiddle.ts
+function truncateMiddle(str, limit) {
+  if (str.length <= limit) {
+    return str;
+  }
+  const keep = limit - 3;
+  const left = Math.ceil(keep / 2);
+  const right = Math.floor(keep / 2);
+  return `${str.slice(0, left)}[...]${str.slice(str.length - right)}`;
+}
+
+// src/private/present/makeOperationLogLine.ts
+function makeOperationLogLine(op, options = {}) {
+  const { standalone } = options;
+  const timing = standalone ? `(${op.timing()}ms)` : String(op.timing());
+  return [
+    op.outcome === "pending" ? "\u23F3" : op.outcome === "success" ? "\u{1F7E2}" : "\u{1F534}",
+    op.checkout?.repo?.name,
+    op.checkout?.record.location,
+    op.operation,
+    truncateMiddle(op.message(), 50),
+    op.finishedTs ? timing : ""
+  ].filter(Boolean);
+}
+
+// src/private/present/presentOperationsReport.ts
+function presentOperationsReport(log) {
+  const operations = log.all();
+  if (operations.length === 0) {
+    return;
+  }
+  const headers = ["", "repo", "checkout", "operation", "message", "ms"];
+  const rows = operations.map((op) => makeOperationLogLine(op));
+  console.info("Operations Report:");
+  console.info(formatTable(rows, headers));
+  console.info("");
+}
+
+// src/private/resources/checkout/loadCheckoutRecords.ts
+import { findRecordFiles } from "@art-cli/lib-records";
+
+// src/private/resources/checkout/readCheckoutRecord.ts
+import { readRecordFileContent } from "@art-cli/lib-records";
+async function readCheckoutRecord(file) {
+  const fileWithContents = file.content ? file : await readRecordFileContent(file);
+  if (!fileWithContents.content) {
+    return null;
+  }
+  const content = fileWithContents.content;
+  const nameMatch = content.match(/## Checkout:\s*(.+)/);
+  if (!nameMatch) {
+    return null;
+  }
+  const repositoryMatch = content.match(/\*\*Repository:\*\*\s*(.+)/);
+  const locationMatch = content.match(/\*\*Location:\*\*\s*`([^`]+)`/);
+  const branchMatch = content.match(/\*\*Branch:\*\*\s*`([^`]+)`/);
+  if (!locationMatch) {
+    console.warn(`checkout record ${file.filename}: missing location, using default`);
+  }
+  if (!branchMatch) {
+    console.warn(`checkout record ${file.filename}: missing branch, using default`);
+  }
+  return {
+    name: nameMatch[1]?.trim() ?? "",
+    repository: repositoryMatch?.[1]?.trim(),
+    location: locationMatch?.[1]?.trim() ?? "",
+    branch: branchMatch?.[1]?.trim() ?? "main"
+  };
+}
+
+// src/private/resources/checkout/loadCheckoutRecords.ts
+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 checkouts = await Promise.all(
+    recordFiles.map(async (file) => {
+      const record = await readCheckoutRecord(file);
+      if (!record) {
+        return null;
+      }
+      if (!record.name) {
+        console.warn("checkout record with empty name, skipped");
+        return null;
+      }
+      const repo = repos.find((r) => r.name === record.repository);
+      if (repo) {
+        return {
+          repo,
+          checkout: record,
+          filename: file.filename
+        };
+      }
+      return {
+        checkout: record,
+        filename: file.filename
+      };
+    })
+  );
+  return checkouts.filter((checkout) => checkout !== null);
+}
+
+// src/private/resources/repository/loadRepositoryRecords.ts
+import { findRecordFiles as findRecordFiles2 } from "@art-cli/lib-records";
+
+// src/private/resources/repository/readRepositoryRecord.ts
+import { readRecordFileContent as readRecordFileContent2 } from "@art-cli/lib-records";
+async function readRepositoryRecord(file) {
+  const fileWithContents = file.content ? file : await readRecordFileContent2(file);
+  if (!fileWithContents.content) {
+    return null;
+  }
+  const content = fileWithContents.content;
+  const nameMatch = content.match(/## Repository:\s*(.+)/);
+  if (!nameMatch) {
+    return null;
+  }
+  const remoteMatch = content.match(/\*\*Remote:\*\*\s*`([^`]+)`/);
+  const purposeMatch = content.match(/\*\*Purpose:\*\*\s*(.+)/);
+  const descriptionMatch = content.match(/\*\*Description:\*\*\s*(.+)/);
+  const consumersMatch = content.match(/\*\*Consumers:\*\*\s*(.+)/);
+  if (!remoteMatch) {
+    console.warn(`repository record ${file.filename}: missing remote, using default`);
+  }
+  return {
+    name: nameMatch[1]?.trim() ?? "",
+    remote: remoteMatch?.[1]?.trim() ?? "",
+    ...purposeMatch ? { purpose: purposeMatch[1].trim() } : {},
+    ...descriptionMatch ? { description: descriptionMatch[1].trim() } : {},
+    ...consumersMatch ? { consumers: consumersMatch[1].trim() } : {}
+  };
+}
+
+// src/private/resources/repository/loadRepositoryRecords.ts
+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 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";
+
+// src/private/git/getBehindAheadCount.ts
+import simpleGit3 from "simple-git";
+async function getBehindAheadCount(dir, remoteBranch) {
+  const git = simpleGit3(dir);
+  try {
+    if (!remoteBranch) {
+      const ahead2 = await git.raw(["rev-list", "--count", "HEAD", "--not", "--remotes=origin"]);
+      return { ahead: Number.parseInt(ahead2.trim(), 10) || 0, behind: 0 };
+    }
+    const counts = await git.raw(["rev-list", "--left-right", "--count", `${remoteBranch}...HEAD`]);
+    const [behind, ahead] = counts.trim().split(/\s+/).map(Number);
+    return { ahead, behind };
+  } catch {
+    return { ahead: 0, behind: 0 };
+  }
+}
+
+// src/private/git/getCurrentBranch.ts
+import simpleGit4 from "simple-git";
+async function getCurrentBranch(dir) {
+  const git = simpleGit4(dir);
+  try {
+    const status = await git.status();
+    const branch = status.current ?? "HEAD";
+    if (!status.current || status.current === "HEAD") {
+      try {
+        const refOutput = await git.raw(["symbolic-ref", "-q", "HEAD"]);
+        if (!refOutput.trim()) {
+          return "HEAD";
+        }
+      } catch {
+        return "HEAD";
+      }
+    }
+    return branch;
+  } catch {
+    return "-";
+  }
+}
+
+// src/private/git/getRemoteBranch.ts
+import simpleGit5 from "simple-git";
+async function getRemoteBranch(dir) {
+  const git = simpleGit5(dir);
+  try {
+    const branches = await git.branch();
+    const current = branches.current;
+    if (!current || current === "HEAD") {
+      return null;
+    }
+    const tracking = branches.all.find(
+      (b) => b === `origin/${current}` || b === `remotes/origin/${current}`
+    );
+    return tracking ? tracking.replace(/^remotes\//, "") : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/private/git/getRemoteUrl.ts
+import simpleGit6 from "simple-git";
+async function getRemoteUrl(dir) {
+  const git = simpleGit6(dir);
+  try {
+    const config = await git.listConfig();
+    const url = config.all["remote.origin.url"];
+    if (typeof url === "string") return url;
+    if (Array.isArray(url) && url.length > 0) return url[0];
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/private/git/hasMergeConflicts.ts
+import simpleGit7 from "simple-git";
+async function hasMergeConflicts(dir) {
+  const git = simpleGit7(dir);
+  try {
+    const status = await git.status();
+    return status.conflicted.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/private/git/hasRemote.ts
+import simpleGit8 from "simple-git";
+async function hasRemote(dir) {
+  const git = simpleGit8(dir);
+  try {
+    const remotes = await git.getRemotes(false);
+    return remotes.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/private/git/isDetachedHead.ts
+import simpleGit9 from "simple-git";
+async function isDetachedHead(dir) {
+  const git = simpleGit9(dir);
+  try {
+    const status = await git.status();
+    if (status.current && status.current !== "HEAD") {
+      return false;
+    }
+    try {
+      const refOutput = await git.raw(["symbolic-ref", "-q", "HEAD"]);
+      return !refOutput.trim();
+    } catch {
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+
+// src/private/git/isDirty.ts
+import simpleGit10 from "simple-git";
+async function isDirty(dir) {
+  const git = simpleGit10(dir);
+  try {
+    const status = await git.status();
+    return status.files.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/private/git/remoteFetch.ts
+import simpleGit11 from "simple-git";
+async function remoteFetch(dir) {
+  const git = simpleGit11(dir);
+  try {
+    await git.fetch("origin");
+  } catch {
+  }
+}
+
+// src/private/scan/states/createCommittedState.ts
+var createCommittedState = (clean) => ({
+  type: "committed",
+  clean
+});
+
+// src/private/scan/states/createExistsState.ts
+var createExistsState = (exists) => ({
+  type: "exists",
+  exists
+});
+
+// src/private/scan/states/createNoConflictsState.ts
+var createNoConflictsState = (clear) => ({
+  type: "no-conflicts",
+  clear
+});
+
+// src/private/scan/states/createNoDetachedState.ts
+var createNoDetachedState = (attached) => ({
+  type: "no-detached",
+  attached
+});
+
+// src/private/scan/states/createRemoteState.ts
+var createRemoteState = (branch, expectedBranch, hasRemote2) => ({ type: "remote", branch, expectedBranch, hasRemote: hasRemote2 });
+
+// src/private/scan/states/createRepoState.ts
+var createRepoState = (known) => ({ type: "repo", known });
+
+// src/private/scan/states/createSyncState.ts
+var createSyncState = (delta, ahead = Math.max(delta, 0), behind = Math.max(-delta, 0)) => ({
+  type: "sync",
+  delta,
+  ahead,
+  behind
+});
+
+// src/private/scan/states/createWrongRemoteState.ts
+var createWrongRemoteState = (wrong) => ({
+  type: "wrong-remote",
+  wrong
+});
+
+// src/private/scan/private/createStateAccessor.ts
+function createStateAccessor(states) {
+  return (type) => {
+    const state = states.find((item) => item.type === type);
+    if (!state) throw new Error(`missing checkout state: ${type}`);
+    return state;
+  };
+}
+
+// src/private/scan/private/createCheckoutScan.ts
+function createCheckoutScan(states) {
+  const state = createStateAccessor(states);
+  const issues = () => {
+    const result = [];
+    const repo = state("repo");
+    const exists = state("exists");
+    const remote = state("remote");
+    const sync = state("sync");
+    if (!repo.known) result.push("unknown project");
+    if (!exists.exists) return [...result, "not cloned"];
+    if (!state("no-detached").attached) result.push("detached HEAD");
+    if (remote.expectedBranch !== "" && remote.branch !== remote.expectedBranch && state("no-detached").attached) {
+      result.push("wrong branch");
+    }
+    if (!state("no-conflicts").clear) result.push("merge conflicts");
+    if (!remote.hasRemote) result.push("no remote");
+    if (remote.hasRemote && state("wrong-remote").wrong) result.push("wrong remote");
+    if (!state("committed").clean) result.push("uncommitted files");
+    if (sync.ahead > 0) result.push(`${sync.ahead} commit${sync.ahead === 1 ? "" : "s"} ahead`);
+    if (sync.behind > 0) {
+      const count = sync.behind;
+      result.push(`${count} commit${count === 1 ? "" : "s"} behind`);
+    }
+    return result;
+  };
+  return {
+    states,
+    state,
+    issues,
+    can: (op) => {
+      if (op === "clone") return !state("exists").exists;
+      if (op === "branch") return state("exists").exists && state("no-detached").attached;
+      const exists = state("exists");
+      const remote = state("remote");
+      return exists.exists && remote.branch === remote.expectedBranch && state("committed").clean && state("no-conflicts").clear && state("no-detached").attached && remote.hasRemote;
+    },
+    should: (op) => {
+      if (op === "clone") return !state("exists").exists;
+      if (op === "pull") return state("sync").behind > 0;
+      if (op === "push") return state("sync").ahead > 0;
+      return false;
+    }
+  };
+}
+
+// src/private/scan/private/createCheckoutNoClonedScan.ts
+function createCheckoutNoClonedScan(known) {
+  return createCheckoutScan([
+    createRepoState(known),
+    createExistsState(false),
+    createRemoteState(null, "", false),
+    createSyncState(0),
+    createCommittedState(true),
+    createNoConflictsState(true),
+    createNoDetachedState(true)
+  ]);
+}
+
+// src/private/scan/scanCheckoutState.ts
+async function scanCheckoutState(ctx, checkout, refetch = false) {
+  try {
+    await access(checkout.path);
+  } catch {
+    return { ...checkout, scan: createCheckoutNoClonedScan(Boolean(checkout.repo)) };
+  }
+  ctx.log.log(createGenericOperation("scan-checkout-state", checkout.record.location));
+  let branch = null;
+  let remoteBranch = null;
+  let remote = false;
+  let dirty = false;
+  let conflicts = false;
+  let detached = false;
+  let ahead = 0;
+  let behind = 0;
+  let wrongRemote = false;
+  try {
+    branch = await getCurrentBranch(checkout.path);
+    remote = await hasRemote(checkout.path);
+    detached = await isDetachedHead(checkout.path);
+    conflicts = await hasMergeConflicts(checkout.path);
+    dirty = await isDirty(checkout.path);
+    if (remote && branch !== "-" && branch !== "HEAD") {
+      remoteBranch = await getRemoteBranch(checkout.path);
+      if (refetch) await remoteFetch(checkout.path);
+      const { ahead: aheadCount, behind: behindCount } = await getBehindAheadCount(
+        checkout.path,
+        remoteBranch
+      );
+      ahead = aheadCount;
+      behind = behindCount;
+    }
+    if (remote && checkout.repo?.remote) {
+      const actualUrl = await getRemoteUrl(checkout.path);
+      if (actualUrl && actualUrl !== checkout.repo.remote) {
+        wrongRemote = true;
+      }
+    }
+  } catch (error) {
+    ctx.log.log(
+      createOperationFailure(
+        createGenericOperation("scan-checkout-state", checkout.record.location),
+        error
+      )
+    );
+  }
+  const remoteState = createRemoteState(branch, checkout.record.branch, remote);
+  const scan = createCheckoutScan([
+    createRepoState(Boolean(checkout.repo)),
+    createExistsState(true),
+    remoteState,
+    createSyncState(ahead - behind, ahead, behind),
+    createCommittedState(!dirty),
+    createNoConflictsState(!conflicts),
+    createNoDetachedState(!detached),
+    createWrongRemoteState(wrongRemote)
+  ]);
+  return { ...checkout, scan };
+}
+
+// src/private/store/createCheckout.ts
+import path, { join as join4 } from "node:path";
+
+// src/private/store/safePath.ts
+function safePath(pathStr) {
+  return pathStr.toLowerCase().replace(/[^a-z-]/g, "-").replace(/-+/g, "-");
+}
+
+// src/private/store/createCheckout.ts
+function createCheckout(config, target, repo, branch, name) {
+  const basePath = join4(config.root.path, config.clone.path);
+  const l = safePath(target);
+  const r = repo;
+  const b = branch ?? "main";
+  const n = name || (r?.name ? r?.name + " @ " + target : target);
+  return {
+    repo: r,
+    record: { name: n, location: l, branch: b, repository: r?.name },
+    path: path.join(basePath, l)
+  };
+}
+
+// src/private/store/hydrateStoreFromRecords.ts
+function hydrateStoreFromRecords(config, store, records) {
+  for (const record of records) {
+    const checkout = createCheckout(
+      config,
+      record.checkout.location,
+      record.repo,
+      record.checkout.branch,
+      record.checkout.name
+    );
+    store.addCheckout({ ...checkout, filename: record.filename });
+  }
+}
+
+// src/private/async/runWithConcurrency.ts
+async function runWithConcurrency(items, limit, task) {
+  let index = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (index < items.length) {
+      const i = index++;
+      await task(items[i]);
+    }
+  });
+  await Promise.all(workers);
+}
+
+// src/private/store/scanAllCheckoutsStates.ts
+async function scanAllCheckoutsStates(ctx, refetch = false) {
+  ctx.log.log(createGenericOperation("scan-all-checkouts"));
+  await runWithConcurrency(ctx.store.getAllCheckouts(), 4, async (checkout) => {
+    const updated = await scanCheckoutState(ctx, checkout, refetch);
+    ctx.store.updateCheckout(updated);
+  });
+}
+
+// src/commands/branch/runBranch.ts
+async function runBranch(ctx, options) {
+  const repos = await loadRepositoryRecords(ctx);
+  const records = await loadCheckoutRecords(ctx, repos);
+  hydrateStoreFromRecords(ctx.config, ctx.store, records);
+  ctx.log.log(createGenericOperation("command", ["branch", options.branch, options.checkouts]));
+  if (!options.all && (!options.checkouts || options.checkouts.length === 0)) {
+    console.error("No checkouts matched.");
+    console.error(
+      `Usage: Use \`art-workspace branch [options] -c <pattern>\` or \`art-workspace branch [options] --all\` if you want to apply the branch to all checkouts.`
+    );
+    return;
+  }
+  const { branch, checkouts } = options;
+  const resolvedCheckouts = options.all ? ctx.store.getAllCheckouts() : ctx.store.getCheckoutsByPattern(checkouts ?? []);
+  for (const checkout of resolvedCheckouts) {
+    const scanned = await scanCheckoutState(ctx, checkout);
+    ctx.store.updateCheckout(scanned);
+    if (!scanned.scan?.can?.("branch")) {
+      ctx.log.log(
+        createOperationFailure(createBranchOperation(scanned, branch), "checkout not cloned")
+      );
+      continue;
+    }
+    await doBranchCheckout(ctx, scanned, branch);
+  }
+  await scanAllCheckoutsStates(ctx);
+  presentCheckoutReport(ctx.config, ctx.store.getAllCheckouts());
+  presentOperationsReport(ctx.log);
+}
+
+// src/private/exec/runCommandInDirectory.ts
+import { spawn } from "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 });
+    let output = "";
+    let error = "";
+    child.stdout?.on("data", (chunk) => output += chunk);
+    child.stderr?.on("data", (chunk) => error += chunk);
+    child.on("error", (err) => resolve({ code: null, output, error: err.message }));
+    child.on("exit", (code) => resolve({ code, output, error }));
+  });
+}
+
+// src/private/commands/operations/createCheckoutRunOperation.ts
+function createCheckoutRunOperation(checkout, command) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    checkout,
+    outcome: "pending",
+    operation: "run",
+    command,
+    message() {
+      return command;
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// 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),
+      new Error("checkout not cloned")
+    );
+    ctx.log.log(op);
+    return null;
+  }
+  const pending = createCheckoutRunOperation(checkout, commandLine);
+  try {
+    ctx.log.log(pending);
+    const runOutcome = await runCommandInDirectory(checkout.path, command);
+    if (runOutcome.code === 0) {
+      ctx.log.log(createOperationSuccess(pending));
+    } else {
+      ctx.log.log(createOperationFailure(pending, new Error(`Exit code: ${runOutcome.code}`)));
+    }
+    if (!runOutcome.output.trim() && !runOutcome.error.trim()) {
+      console.info("\n--- [No output]\n");
+    } else {
+      if (runOutcome.output) {
+        console.info("\n--- Output:\n");
+        console.info(runOutcome.output);
+        console.info("");
+      }
+      if (runOutcome.error) {
+        console.error("\n--- Error:\n");
+        console.error(runOutcome.error);
+        console.error("");
+      }
+    }
+    return checkout;
+  } catch (error) {
+    ctx.log.log(createOperationFailure(pending, error));
+    return null;
+  }
+}
+
+// src/commands/checkouts/runCheckoutsRun.ts
+async function runCheckoutsRun(ctx, options) {
+  const repos = await loadRepositoryRecords(ctx);
+  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(
+      `Usage: Use \`art-workspace checkouts run [options] -c <pattern>\` or \`art-workspace checkouts run [options] --all\` if you want to run the command in all checkouts.`
+    );
+    return;
+  }
+  const checkouts = options.all ? ctx.store.getAllCheckouts() : ctx.store.getCheckoutsByPattern(options.checkouts ?? []);
+  await runWithConcurrency(checkouts, 4, async (checkout) => {
+    await doCheckoutRun(ctx, checkout, options.command);
+  });
+  presentCheckoutReport(ctx.config, checkouts);
+  presentOperationsReport(ctx.log);
+}
+
+// src/private/git/cloneCheckout.ts
+import simpleGit12 from "simple-git";
+async function cloneCheckout(checkout) {
+  const recordedBranch = checkout.record.branch;
+  const git = simpleGit12("");
+  if (!checkout.repo?.remote) {
+    throw new Error(``);
+  }
+  await git.clone(checkout.repo.remote, checkout.path);
+  if (recordedBranch) {
+    try {
+      const repoGit = simpleGit12(checkout.path);
+      await repoGit.checkout(recordedBranch);
+    } catch {
+    }
+  }
+}
+
+// src/private/commands/operations/createCloneOperation.ts
+function createCloneOperation(checkout) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    checkout,
+    outcome: "pending",
+    operation: "clone",
+    location: checkout?.record.location ?? "unknown",
+    message() {
+      return checkout ? `to ${checkout.record.location}` : "clone";
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// src/private/commands/doClone.ts
+async function doClone(ctx, checkout) {
+  if (!checkout.repo) return null;
+  const pending = createCloneOperation(checkout);
+  try {
+    ctx.log.log(pending);
+    await cloneCheckout(checkout);
+    const rescan = await scanCheckoutState(ctx, checkout);
+    ctx.store.updateCheckout(rescan);
+    ctx.log.log(createOperationSuccess(createCloneOperation(rescan)));
+    const actualBranch = await getCurrentBranch(checkout.path);
+    await saveCheckoutRecord(ctx.config, {
+      name: rescan.record.name,
+      repository: rescan.repo?.name,
+      location: rescan.record.location,
+      branch: actualBranch || rescan.record.branch || "main"
+    });
+    return rescan;
+  } catch (error) {
+    ctx.log.log(createOperationFailure(pending, error));
+    return null;
+  }
+}
+
+// src/commands/clone/private/cloneIfMissing.ts
+async function cloneIfMissing(ctx, checkout) {
+  const scanned = await scanCheckoutState(ctx, checkout);
+  if (!scanned.scan?.should?.("clone")) {
+    return scanned;
+  }
+  if (!scanned.repo) {
+    return null;
+  }
+  return doClone(ctx, scanned);
+}
+
+// src/commands/clone/cloneAll.ts
+async function cloneAll(ctx, repos) {
+  for (const repo of repos) {
+    if (!ctx.store.getCheckoutOfRepo(repo.name)) {
+      const checkout = createCheckout(ctx.config, repo.name, repo);
+      ctx.store.addCheckout(checkout);
+    }
+  }
+  for (const checkout of ctx.store.getAllCheckouts()) {
+    await cloneIfMissing(ctx, checkout);
+  }
+  await scanAllCheckoutsStates(ctx);
+  presentCheckoutReport(ctx.config, ctx.store.getAllCheckouts());
+  presentOperationsReport(ctx.log);
+}
+
+// src/commands/clone/cloneSpecific.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+
+// src/private/store/createCheckoutLocation.ts
+function createCheckoutLocation(repo, target) {
+  return safePath(target ? repo.name + " " + target : repo.name);
+}
+
+// src/commands/clone/cloneSpecific.ts
+async function cloneSpecific(ctx, repos, repoName, checkoutInput) {
+  const canonical = repoName.startsWith("@") ? repoName.split("/")[1] : repoName;
+  const repo = repos.find((r) => r.name.toLowerCase() === canonical.toLowerCase());
+  if (!repo) {
+    ctx.log.log(
+      createOperationFailure(createCloneOperation(void 0), `unknown repo "${repoName}"`)
+    );
+    presentOperationsReport(ctx.log);
+    return;
+  }
+  const location = createCheckoutLocation(repo, checkoutInput);
+  const existing = ctx.store.getCheckoutForLocation(location);
+  if (existing && existing.repo?.name !== repo.name) {
+    const msg = `location ${location} is already used by checkout '${existing.record.name}'.`;
+    ctx.log.log(createOperationFailure(createCloneOperation(existing), msg));
+    presentOperationsReport(ctx.log);
+    return;
+  }
+  if (existing) {
+    await cloneIfMissing(ctx, existing);
+  } else {
+    const targetDir = join5(ctx.config.root.path, ctx.config.clone.path, location);
+    if (existsSync2(targetDir)) {
+      const msg = `directory already exists at ${targetDir}`;
+      ctx.log.log(createOperationFailure(createCloneOperation(void 0), msg));
+      presentOperationsReport(ctx.log);
+      return;
+    }
+    const checkoutName = checkoutInput ? `${repo.name} @ ${checkoutInput}` : repo.name;
+    const created = createCheckout(ctx.config, location, repo, "main", checkoutName);
+    ctx.store.addCheckout(created);
+    await saveCheckoutRecord(ctx.config, created.record);
+    await cloneIfMissing(ctx, created);
+  }
+  await scanAllCheckoutsStates(ctx);
+  presentCheckoutReport(ctx.config, ctx.store.getAllCheckouts());
+  presentOperationsReport(ctx.log);
+}
+
+// src/commands/clone/cloneStatus.ts
+async function cloneStatus(ctx) {
+  await scanAllCheckoutsStates(ctx);
+  presentCheckoutReport(ctx.config, ctx.store.getAllCheckouts());
+}
+
+// src/commands/clone/runClone.ts
+async function runClone(ctx, { all, repoName, checkoutInput }) {
+  const repos = await loadRepositoryRecords(ctx);
+  const records = await loadCheckoutRecords(ctx, repos);
+  hydrateStoreFromRecords(ctx.config, ctx.store, records);
+  ctx.log.log(createGenericOperation("command", ["clone", { all, repoName, checkoutInput }]));
+  if (all) {
+    await cloneAll(ctx, repos);
+  } else if (repoName) {
+    await cloneSpecific(ctx, repos, repoName, checkoutInput);
+  } else {
+    await cloneStatus(ctx);
+  }
+  return ctx;
+}
+
+// src/private/commands/operations/createLinkedOperation.ts
+function createLinkedOperation(checkout, pkg, target) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    checkout,
+    outcome: "pending",
+    operation: "linked",
+    package: pkg,
+    target,
+    message() {
+      return `linking ${pkg}`;
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// src/commands/link/runLink.ts
+async function runLink(ctx, _options) {
+  ctx.log.log(createGenericOperation("command", ["link"]));
+  ctx.log.log(createLinkedOperation(ctx.workspace, "", ""));
+  console.info("link command - TODO");
+}
+
+// src/private/commands/operations/createPublishOperation.ts
+function createPublishOperation(checkout, pkg, version) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    checkout,
+    outcome: "pending",
+    operation: "publish",
+    package: pkg,
+    version,
+    message() {
+      return `publishing ${pkg}@${version}`;
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// src/commands/publish/runPublish.ts
+async function runPublish(ctx, _options) {
+  ctx.log.log(createGenericOperation("command", ["publish", _options.auto]));
+  ctx.log.log(createPublishOperation(ctx.workspace, "", ""));
+  console.info("publish command - TODO");
+}
+
+// src/private/git/pullCheckout.ts
+import simpleGit13 from "simple-git";
+async function pullCheckout(checkout) {
+  const git = simpleGit13(checkout.path);
+  await git.pull("origin", checkout.record.branch);
+}
+
+// src/private/commands/operations/createPullOperation.ts
+function createPullOperation(checkout, branch) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    checkout,
+    outcome: "pending",
+    operation: "pull",
+    branch,
+    message() {
+      return `from origin/${branch}`;
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// src/private/commands/checkouts/doPullCheckout.ts
+async function doPullCheckout(ctx, checkout) {
+  const pending = createPullOperation(checkout, checkout.record.branch);
+  try {
+    ctx.log.log(pending);
+    await pullCheckout(checkout);
+    const updated = await scanCheckoutState(ctx, checkout, true);
+    ctx.store.updateCheckout(updated);
+    ctx.log.log(createOperationSuccess(pending));
+    return updated;
+  } catch (error) {
+    ctx.log.log(createOperationFailure(pending, error));
+    return null;
+  }
+}
+
+// src/private/commands/workspaces/doPullWorkspaceCheckout.ts
+import simpleGit14 from "simple-git";
+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);
+  try {
+    ctx.log.log(pending);
+    await git.pull("origin", workspace.record.branch);
+    const updated = await scanCheckoutState(ctx, workspace, true);
+    ctx.workspace = updated;
+    ctx.log.log(createOperationSuccess(pending));
+    return updated;
+  } catch (error) {
+    ctx.log.log(
+      createOperationFailure(createPullOperation(workspace, workspace.record.branch), error)
+    );
+    return null;
+  }
+}
+
+// src/private/commands/workspaces/scanWorkspaceCheckout.ts
+async function scanWorkspaceCheckout(ctx, refetch = false) {
+  const workspaceCheckout = {
+    ...createCheckout(ctx.config, ".", void 0, "main", "Workspace"),
+    path: ctx.config.root.path
+  };
+  const workspace = await scanCheckoutState(ctx, workspaceCheckout, refetch);
+  ctx.workspace = workspace;
+  return workspace;
+}
+
+// src/commands/pull/runPull.ts
+async function runPull(ctx, options = {}) {
+  const repos = await loadRepositoryRecords(ctx);
+  const records = await loadCheckoutRecords(ctx, repos);
+  hydrateStoreFromRecords(ctx.config, ctx.store, records);
+  ctx.log.log(createGenericOperation("command", ["pull", options.checkouts]));
+  await scanAllCheckoutsStates(ctx);
+  if (!options.all && (!options.checkouts || options.checkouts.length === 0)) {
+    console.error("No checkouts matched.");
+    console.error(
+      `Usage: Use \`art-workspace pull [options] -c <pattern>\` or \`art-workspace pull [options] --all\` if you want to apply the pull to all checkouts.`
+    );
+    return;
+  }
+  const checkouts = options.all ? ctx.store.getAllCheckouts() : ctx.store.getCheckoutsByPattern(options.checkouts ?? []);
+  await runWithConcurrency(checkouts, 4, async (checkout) => {
+    if (checkout.scan?.can?.("pull") && checkout.scan.should?.("pull")) {
+      await doPullCheckout(ctx, checkout);
+    }
+  });
+  await scanWorkspaceCheckout(ctx);
+  await doPullWorkspaceCheckout(ctx);
+  presentCheckoutReport(ctx.config, checkouts);
+  presentOperationsReport(ctx.log);
+}
+
+// src/private/git/pushCheckout.ts
+import simpleGit15 from "simple-git";
+async function pushCheckout(checkout) {
+  const git = simpleGit15(checkout.path);
+  await git.push("origin", checkout.record.branch);
+}
+
+// src/private/commands/operations/createPushOperation.ts
+function createPushOperation(checkout, branch) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    checkout,
+    outcome: "pending",
+    operation: "push",
+    branch,
+    message() {
+      return `to origin/${branch}`;
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// src/private/commands/checkouts/doPushCheckout.ts
+async function doPushCheckout(ctx, checkout) {
+  const pending = createPushOperation(checkout, checkout.record.branch);
+  try {
+    ctx.log.log(pending);
+    await pushCheckout(checkout);
+    const updated = await scanCheckoutState(ctx, checkout, true);
+    ctx.store.updateCheckout(updated);
+    ctx.log.log(createOperationSuccess(pending));
+    return updated;
+  } catch (error) {
+    ctx.log.log(createOperationFailure(pending, error));
+    return null;
+  }
+}
+
+// src/private/commands/workspaces/doPushWorkspaceCheckout.ts
+import simpleGit16 from "simple-git";
+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);
+  try {
+    ctx.log.log(pending);
+    await git.push("origin", workspace.record.branch);
+    const updated = await scanCheckoutState(ctx, workspace, true);
+    ctx.workspace = updated;
+    ctx.log.log(createOperationSuccess(pending));
+    return updated;
+  } catch (error) {
+    ctx.log.log(createOperationFailure(pending, error));
+    return null;
+  }
+}
+
+// src/commands/push/runPush.ts
+async function runPush(ctx, options = {}) {
+  const repos = await loadRepositoryRecords(ctx);
+  const records = await loadCheckoutRecords(ctx, repos);
+  hydrateStoreFromRecords(ctx.config, ctx.store, records);
+  ctx.log.log(createGenericOperation("command", ["push", options.checkouts]));
+  await scanAllCheckoutsStates(ctx);
+  if (!options.all && (!options.checkouts || options.checkouts.length === 0)) {
+    console.error("No checkouts matched.");
+    console.error(
+      `Usage: Use \`art-workspace push [options] -c <pattern>\` or \`art-workspace push [options] --all\` if you want to apply the push to all checkouts.`
+    );
+    return;
+  }
+  const checkouts = options.all ? ctx.store.getAllCheckouts() : ctx.store.getCheckoutsByPattern(options.checkouts ?? []);
+  await runWithConcurrency(checkouts, 4, async (checkout) => {
+    if (checkout.scan?.can?.("push") && checkout.scan.should?.("push")) {
+      await doPushCheckout(ctx, checkout);
+    }
+  });
+  await scanWorkspaceCheckout(ctx);
+  await doPushWorkspaceCheckout(ctx);
+  presentCheckoutReport(ctx.config, checkouts);
+  presentOperationsReport(ctx.log);
+}
+
+// src/private/present/presentCheckoutRepositoryState.ts
+function presentCheckoutRepositoryState(state) {
+  console.info(`Repository:`);
+  console.info(`  name: ${state.target.repo?.name || "(unknown)"}`);
+  console.info(`  name: ${state.target.repo?.remote || "(unknown)"}`);
+  if (state.issues.length > 0) {
+    console.info(`  issues: ${state.issues.join("; ")}`);
+  }
+  console.info("");
+  console.info(`Checkout:`);
+  console.info(`  record: ${state.target.filename || "(unknown)"}`);
+  console.info(`  location: ${state.target.record.location || "(unknown)"}`);
+  console.info(`  branch: ${state.branch || state.target.record.branch}`);
+  if (state.target.scan && state.target.scan.issues().length > 0) {
+    console.info(`  states: ${state.target.scan.issues().join("; ")}`);
+  }
+  console.info("");
+}
+
+// src/private/present/presentPackageStateReport.ts
+function presentPackageStateReport(checkout, packageStates) {
+  if (packageStates.length === 0) {
+    return;
+  }
+  const headers = ["package", "version", "published", "states"];
+  const rows = packageStates.map((ps) => [
+    ps.canonicalName,
+    ps.version ?? "-",
+    ps.publishedVersion ?? "-",
+    ps.states.join("; ") || "-"
+  ]);
+  console.info(`Packages for ${checkout.record.name}:`);
+  console.info(formatTable(rows, headers));
+  console.info("");
+}
+
+// src/private/repositories/createPackageStateRecord.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { join as join6 } from "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)) {
+      pkgPath = altPath;
+      pkgJsonPath = altPkgJsonPath;
+    }
+  }
+  const record = {
+    canonicalName: pkg.canonicalName,
+    version: null,
+    publishedVersion: null,
+    directory: pkgPath,
+    states: []
+  };
+  if (existsSync3(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+      record.version = pkgJson.version ?? null;
+    } catch {
+      record.states.push("no package.json");
+    }
+  } else {
+    record.states.push("no package.json");
+  }
+  return { pkgPath, record };
+}
+
+// src/private/repositories/scanPackageStateRecord.ts
+import { execSync } from "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`, {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+      record.publishedVersion = output.trim() || null;
+    } catch {
+      record.publishedVersion = "unknown";
+    }
+  }
+}
+
+// src/private/repositories/getRepositoryCheckoutPackages.ts
+function getRepositoryCheckoutPackages(checkoutPath, graph) {
+  const packageStates = [];
+  for (const project of graph.projects) {
+    for (const nsName of project.namespaceNames) {
+      const ns = graph.namespaces.get(nsName);
+      if (!ns) continue;
+      for (const pkgName of ns.packageNames) {
+        const pkg = graph.packages.get(pkgName);
+        if (!pkg) continue;
+        const { record } = createPackageStateRecord(checkoutPath, project.path, ns.path, pkg);
+        scanPackageStateRecord(pkg, record);
+        packageStates.push(record);
+      }
+    }
+  }
+  return packageStates;
+}
+
+// src/private/resources/namespace/loadNamespaceRecords.ts
+import { findRecordFiles as findRecordFiles3 } from "@art-cli/lib-records";
+
+// src/private/resources/namespace/readNamespaceRecord.ts
+import { readRecordFileContent as readRecordFileContent3 } from "@art-cli/lib-records";
+async function readNamespaceRecord(file) {
+  const fileWithContents = file.content ? file : await readRecordFileContent3(file);
+  if (!fileWithContents.content) {
+    return null;
+  }
+  const content = fileWithContents.content;
+  const nameMatch = content.match(/## Namespace:\s*(.+)/);
+  if (!nameMatch) {
+    console.warn(`namespace record ${file.filename}: missing name, skipped`);
+    return null;
+  }
+  const pathMatch = content.match(/\*\*Path:\*\*\s*`([^`]+)`/);
+  const packagesMatch = content.match(/\*\*Packages:\*\*\s*([\s\S]*?)(?=\n\n|\n\*\*|$)/);
+  let packageNames = [];
+  if (packagesMatch) {
+    packageNames = packagesMatch[1].split("\n").map((line) => line.replace(/^-\s*Package:\s*/, "").trim()).filter(Boolean);
+  }
+  return {
+    kind: "namespace",
+    name: nameMatch[1].trim(),
+    path: pathMatch?.[1]?.trim() ?? ".",
+    packageNames
+  };
+}
+
+// src/private/resources/namespace/loadNamespaceRecords.ts
+async function loadNamespaceRecords(config, checkoutPath) {
+  const recordFiles = await findRecordFiles3(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-cli/lib-records";
+
+// src/private/resources/package/readPackageRecord.ts
+import { readRecordFileContent as readRecordFileContent4 } from "@art-cli/lib-records";
+async function readPackageRecord(file) {
+  const fileWithContents = file.content ? file : await readRecordFileContent4(file);
+  if (!fileWithContents.content) {
+    return null;
+  }
+  const content = fileWithContents.content;
+  const nameMatch = content.match(/## Package:\s*(.+)/);
+  if (!nameMatch) {
+    console.warn(`package record ${file.filename}: missing name, skipped`);
+    return null;
+  }
+  const canonicalNameMatch = content.match(/\*\*Canonical Name:\*\*\s*`([^`]+)`/);
+  const pathMatch = content.match(/\*\*Path:\*\*\s*`([^`]+)`/);
+  return {
+    kind: "package",
+    name: nameMatch[1].trim(),
+    canonicalName: canonicalNameMatch?.[1]?.trim() ?? "",
+    path: pathMatch?.[1]?.trim() ?? ""
+  };
+}
+
+// src/private/resources/package/loadPackageRecords.ts
+async function loadPackageRecords(config, checkoutPath) {
+  const recordFiles = await findRecordFiles4(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-cli/lib-records";
+
+// src/private/resources/project/readProjectRecord.ts
+import { readRecordFileContent as readRecordFileContent5 } from "@art-cli/lib-records";
+async function readProjectRecord(file) {
+  const fileWithContents = file.content ? file : await readRecordFileContent5(file);
+  if (!fileWithContents.content) {
+    return null;
+  }
+  const content = fileWithContents.content;
+  const nameMatch = content.match(/## Project:\s*(.+)/);
+  if (!nameMatch) {
+    console.warn(`project record ${file.filename}: missing name, skipped`);
+    return null;
+  }
+  const pathMatch = content.match(/\*\*Path:\*\*\s*`([^`]+)`/);
+  const namespacesMatch = content.match(/\*\*Namespaces:\*\*\s*([\s\S]*?)(?=\n\n|\n\*\*|$)/);
+  let namespaceNames = [];
+  if (namespacesMatch) {
+    namespaceNames = namespacesMatch[1].split("\n").map((line) => line.replace(/^-\s*Namespace:\s*/, "").trim()).filter(Boolean);
+  }
+  return {
+    kind: "project",
+    name: nameMatch[1].trim(),
+    path: pathMatch?.[1]?.trim() ?? ".",
+    namespaceNames
+  };
+}
+
+// src/private/resources/project/loadProjectRecords.ts
+async function loadProjectRecords(config, checkoutPath) {
+  const recordFiles = await findRecordFiles5(config.records, checkoutPath, ["Project"]);
+  const records = await Promise.all(recordFiles.map((file) => readProjectRecord(file)));
+  return records.filter((record) => record !== null);
+}
+
+// src/private/resources/projectGraph/consolidateProjectGraph.ts
+function consolidateProjectGraph(projects, namespaces, packages) {
+  const warnings = [];
+  const nsMap = /* @__PURE__ */ new Map();
+  const pkgMap = /* @__PURE__ */ new Map();
+  for (const ns of namespaces) {
+    nsMap.set(ns.name, ns);
+  }
+  for (const pkg of packages) {
+    pkgMap.set(pkg.name, pkg);
+  }
+  for (const project of projects) {
+    for (const nsName of project.namespaceNames) {
+      if (!nsMap.has(nsName)) {
+        warnings.push(`unknown namespace: ${nsName}`);
+      }
+    }
+    for (const ns of namespaces) {
+      if (!project.namespaceNames.includes(ns.name)) continue;
+      for (const pkgName of ns.packageNames) {
+        if (!pkgMap.has(pkgName)) {
+          warnings.push(`unknown package: ${pkgName}`);
+        }
+      }
+    }
+  }
+  return { projects, namespaces: nsMap, packages: pkgMap, warnings };
+}
+
+// src/private/resources/projectGraph/loadProjectGraph.ts
+async function loadProjectGraph(config, checkoutPath) {
+  const [projects, namespaces, packages] = await Promise.all([
+    loadProjectRecords(config, checkoutPath),
+    loadNamespaceRecords(config, checkoutPath),
+    loadPackageRecords(config, checkoutPath)
+  ]);
+  return consolidateProjectGraph(projects, namespaces, packages);
+}
+
+// src/commands/repo/runRepo.ts
+async function runRepo(ctx, options) {
+  const repos = await loadRepositoryRecords(ctx);
+  const records = await loadCheckoutRecords(ctx, repos);
+  hydrateStoreFromRecords(ctx.config, ctx.store, records);
+  ctx.log.log(createGenericOperation("command", ["repo", options.locations]));
+  await scanAllCheckoutsStates(ctx);
+  const { locations = [] } = options;
+  const checkouts = /* @__PURE__ */ new Map();
+  if (locations.length === 0) {
+    const all = ctx.store.getAllCheckouts();
+    all.forEach((checkout) => checkouts.set(checkout.record.location, checkout));
+  } else {
+    for (const name of locations) {
+      const checkout = ctx.store.getCheckoutByName(name) ?? ctx.store.getCheckoutForLocation(name);
+      if (!checkout) {
+        console.warn(`unknown checkout: ${name}`);
+        continue;
+      }
+      checkouts.set(checkout.record.location, checkout);
+    }
+  }
+  const repositoryCheckoutStates = /* @__PURE__ */ new Map();
+  const repositoryCheckoutPackages = /* @__PURE__ */ new Map();
+  for (const [location, checkout] of checkouts) {
+    const graph = await loadProjectGraph(ctx.config, checkout.path);
+    const repositoryState = {
+      target: checkout,
+      branch: checkout.scan?.state("remote").branch ?? checkout.record.branch,
+      issues: [],
+      graph
+    };
+    repositoryCheckoutStates.set(location, repositoryState);
+    for (const w of graph.warnings) {
+      console.warn(w);
+    }
+    if (graph.projects.length === 0) {
+      repositoryState.issues.push("no project records");
+      continue;
+    }
+    const packageStates = getRepositoryCheckoutPackages(checkout.path, graph);
+    repositoryCheckoutPackages.set(location, packageStates);
+  }
+  for (const [location, state] of repositoryCheckoutStates) {
+    presentCheckoutRepositoryState(state);
+    const packageStates = repositoryCheckoutPackages.get(location) ?? [];
+    presentPackageStateReport(state.target, packageStates);
+  }
+}
+
+// src/private/present/presentExtraneousReport.ts
+function presentExtraneousReport(extraneous) {
+  if (extraneous.length === 0) {
+    return;
+  }
+  const headers = ["directory", "branch", "states"];
+  const rows = extraneous.map((c) => [
+    c.record.location,
+    c.scan?.state("remote").branch || c.record.branch,
+    c.scan?.issues().join("; ") || "clean"
+  ]);
+  console.info("Untracked:");
+  console.info(formatTable(rows, headers));
+  console.info("");
+}
+
+// src/private/present/presentWorkspaceReport.ts
+function presentWorkspaceReport(workspace) {
+  if (!workspace) {
+    return;
+  }
+  const remote = workspace.scan?.state("remote").hasRemote ? workspace.scan.state("remote").branch || workspace.record.branch : void 0;
+  const issues = workspace.scan?.issues().join("; ");
+  const branch = workspace.scan?.state("remote").branch || workspace.record.branch;
+  console.info("Workspace:");
+  console.info(`  remote: ${remote ?? "none"}`);
+  console.info(`  path:   ${workspace.path}`);
+  console.info(`  branch: ${branch}`);
+  console.info(`  issues: ${issues || "-"}`);
+  console.info("");
+}
+
+// src/commands/sanity/private/scanExtraneousCheckouts.ts
+import { readdir } from "node:fs/promises";
+import { join as join7, relative } from "node:path";
+
+// src/private/scan/private/createExtraneousCheckout.ts
+function createExtraneousCheckout(config, location) {
+  return createCheckout(config, location, void 0, "", location);
+}
+
+// src/commands/sanity/private/scanExtraneousCheckouts.ts
+async function scanExtraneousCheckouts(ctx, store) {
+  const checkoutsPath = join7(ctx.config.root.path, ctx.config.clone.path);
+  const result = [];
+  try {
+    const entries = await 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 known = store.getCheckoutForLocation(location);
+      if (known) {
+        continue;
+      }
+      const checkout = { ...createExtraneousCheckout(ctx.config, location), path: dir };
+      const scanned = await scanCheckoutState(ctx, checkout);
+      result.push(scanned);
+    }
+  } catch {
+  }
+  return result;
+}
+
+// src/commands/sanity/private/syncCheckouts.ts
+async function syncCheckouts(ctx) {
+  await runWithConcurrency(ctx.store.getAllCheckouts(), 4, async (checkout) => {
+    if (!checkout.scan?.can?.("push") || !checkout.scan.should?.("push")) return;
+    await doPushCheckout(ctx, checkout);
+  });
+}
+
+// src/commands/sanity/runSanity.ts
+async function runSanity(ctx, options) {
+  const repos = await loadRepositoryRecords(ctx);
+  const records = await loadCheckoutRecords(ctx, repos);
+  hydrateStoreFromRecords(ctx.config, ctx.store, records);
+  ctx.log.log(createGenericOperation("command", ["sanity", options.auto]));
+  await scanWorkspaceCheckout(ctx, options.refetch);
+  await scanAllCheckoutsStates(ctx, options.refetch);
+  if (options.auto) {
+    await doPullWorkspaceCheckout(ctx);
+    await syncCheckouts(ctx);
+  }
+  const extraneous = await scanExtraneousCheckouts(ctx, ctx.store);
+  const workspaceIssues = ctx.workspace?.scan ? ctx.workspace.scan.issues().filter((i) => i !== "unknown project" && i !== "no remote" && i !== "wrong remote") : [];
+  const filteredWorkspace = ctx.workspace ? {
+    ...ctx.workspace,
+    scan: ctx.workspace.scan ? { ...ctx.workspace.scan, issues: () => workspaceIssues } : void 0
+  } : void 0;
+  presentWorkspaceReport(filteredWorkspace);
+  presentCheckoutReport(ctx.config, ctx.store.getAllCheckouts());
+  presentExtraneousReport(extraneous);
+  presentOperationsReport(ctx.log);
+}
+
+// src/private/commands/workspaces/syncWorkspaceCheckout.ts
+import simpleGit17 from "simple-git";
+async function syncWorkspaceCheckout(ctx) {
+  let workspace = ctx.workspace;
+  if (!workspace) {
+    workspace = {
+      ...createCheckout(ctx.config, ".", void 0, "main", "Workspace"),
+      path: ctx.config.root.path
+    };
+    const scanned = await scanCheckoutState(ctx, workspace, true);
+    ctx.workspace = scanned;
+    workspace = scanned;
+  }
+  const git = simpleGit17(workspace.path);
+  if (workspace.scan?.can?.("pull")) {
+    const pending = createPullOperation(workspace, workspace.record.branch);
+    try {
+      ctx.log.log(pending);
+      await git.pull("origin", workspace.record.branch);
+      ctx.log.log(createOperationSuccess(pending));
+    } catch (error) {
+      const op = createOperationFailure(pending, error);
+      ctx.log.log(op);
+      return null;
+    }
+  }
+  if (workspace.scan?.can?.("push")) {
+    const pending = createPushOperation(workspace, workspace.record.branch);
+    try {
+      ctx.log.log(pending);
+      await git.push("origin", workspace.record.branch);
+      ctx.log.log(createOperationSuccess(pending));
+    } catch (error) {
+      const op = createOperationFailure(pending, error);
+      ctx.log.log(op);
+      return null;
+    }
+  }
+  const updated = await scanCheckoutState(ctx, workspace, true);
+  ctx.workspace = updated;
+  return updated;
+}
+
+// src/commands/sync/runSync.ts
+async function runSync(ctx, options = {}) {
+  const repos = await loadRepositoryRecords(ctx);
+  const records = await loadCheckoutRecords(ctx, repos);
+  hydrateStoreFromRecords(ctx.config, ctx.store, records);
+  ctx.log.log(createGenericOperation("command", ["sync", options.checkouts]));
+  await scanAllCheckoutsStates(ctx);
+  if (!options.all && (!options.checkouts || options.checkouts.length === 0)) {
+    console.error("No checkouts matched.");
+    console.error(
+      `Usage: Use \`art-workspace sync [options] -c <pattern>\` or \`art-workspace sync [options] --all\` if you want to apply the sync to all checkouts.`
+    );
+    return;
+  }
+  const checkouts = options.all ? ctx.store.getAllCheckouts() : ctx.store.getCheckoutsByPattern(options.checkouts ?? []);
+  await runWithConcurrency(checkouts, 4, async (checkout) => {
+    if (checkout.scan?.can?.("pull")) {
+      const pulled = checkout.scan.should?.("pull") ? await doPullCheckout(ctx, checkout) : checkout;
+      if (pulled?.scan?.can?.("push") && pulled.scan.should?.("push")) {
+        await doPushCheckout(ctx, pulled);
+      }
+    }
+  });
+  await syncWorkspaceCheckout(ctx);
+  presentCheckoutReport(ctx.config, checkouts);
+  presentOperationsReport(ctx.log);
+}
+
+// src/private/commands/operations/createUnlinkOperation.ts
+function createUnlinkOperation(checkout, pkg, source) {
+  return {
+    ts: /* @__PURE__ */ new Date(),
+    checkout,
+    outcome: "pending",
+    operation: "unlink",
+    package: pkg,
+    source,
+    message() {
+      return `unlinking ${pkg}`;
+    },
+    timing() {
+      return this.finishedTs ? this.finishedTs.getTime() - this.ts.getTime() : NaN;
+    }
+  };
+}
+
+// src/commands/unlink/runUnlink.ts
+async function runUnlink(ctx, _options) {
+  ctx.log.log(createGenericOperation("command", ["unlink"]));
+  ctx.log.log(createUnlinkOperation(ctx.workspace, "", ""));
+  console.info("unlink command - TODO");
+}
+
+// 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";
+
+// src/config/private/normalizeRecordPaths.ts
+var DEFAULTS = {
+  base: ".",
+  pattern: "*.art",
+  ignored: ["node_modules/", ".git/", "dist/"],
+  excluded: [],
+  gitignore: true
+};
+function normalizeRecordPaths(records) {
+  const paths = records?.paths;
+  if (!paths || paths.length === 0) {
+    return [
+      {
+        base: records?.base ?? DEFAULTS.base,
+        pattern: records?.pattern ?? DEFAULTS.pattern,
+        ignored: records?.ignored ?? DEFAULTS.ignored,
+        excluded: records?.excluded ?? DEFAULTS.excluded,
+        gitignore: records?.gitignore ?? DEFAULTS.gitignore
+      }
+    ];
+  }
+  return paths.map((p) => ({
+    base: p.base ?? records?.base ?? DEFAULTS.base,
+    pattern: p.pattern ?? records?.pattern ?? DEFAULTS.pattern,
+    ignored: p.ignored ?? records?.ignored ?? DEFAULTS.ignored,
+    excluded: [...p.excluded ?? [], ...records?.excluded ?? []],
+    gitignore: p.gitignore ?? records?.gitignore ?? DEFAULTS.gitignore
+  }));
+}
+
+// src/config/defineConfig.ts
+function defineConfig(config) {
+  const clonePath = config.clone?.path || "checkouts";
+  const rootPath = config.root?.path || process.cwd();
+  const checkoutsPath = config.checkouts?.path || "_records/";
+  const checkoutTemplatePath = config.checkouts?.template || ".agents/domains/workspace/templates/checkout.art.njk";
+  const recordsPaths = normalizeRecordPaths(config.records);
+  return {
+    clone: {
+      path: clonePath
+    },
+    root: {
+      path: rootPath
+    },
+    checkouts: {
+      path: checkoutsPath,
+      template: checkoutTemplatePath
+    },
+    records: {
+      paths: recordsPaths
+    }
+  };
+}
+
+// src/config/loadWorkspaceConfig.ts
+var MANIFEST_FILE = ".art-workspace.mts";
+var TEMP_FILE = ".art-workspace-bundle.mjs";
+var DEFAULT_CONFIG = {
+  clone: { path: "checkouts" },
+  checkouts: {
+    path: "_records/",
+    template: ".agents/domains/workspace/templates/checkout.art.njk"
+  },
+  records: {
+    base: ".",
+    pattern: "*.art",
+    ignored: ["node_modules/", ".git/", "dist/"],
+    excluded: [],
+    gitignore: true
+  }
+};
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function loadWorkspaceConfig(rootPath) {
+  const manifestPath = join8(rootPath, MANIFEST_FILE);
+  if (!existsSync4(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({
+      entryPoints: [manifestPath],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "node",
+      external: [
+        "node:fs",
+        "node:os",
+        "node:path",
+        "node:url",
+        "fs",
+        "os",
+        "path",
+        "url",
+        "esbuild",
+        "simple-git"
+      ]
+    });
+  } catch (error) {
+    throw new Error(
+      `Failed to bundle workspace manifest at ${manifestPath}: ${formatError(error)}`
+    );
+  }
+  const tempFile = join8(rootPath, TEMP_FILE);
+  writeFileSync2(tempFile, output.outputFiles[0].text);
+  try {
+    const loaded = await import(pathToFileURL(tempFile).href);
+    const config = loaded.default;
+    return defineConfig({ ...config, root: { path: rootPath } });
+  } catch (error) {
+    throw new Error(`Failed to load workspace manifest at ${manifestPath}: ${formatError(error)}`);
+  }
+}
+
+// src/private/context/createWorkspaceContext.ts
+function createWorkspaceContext(config, store, log, workspace) {
+  return { config, store, log, workspace };
+}
+
+// src/private/log/createOperationsLog.ts
+function createOperationsLog(logger2 = () => {
+}) {
+  const operations = [];
+  return {
+    log(operation) {
+      logger2(operation);
+      if (operation.outcome !== "pending") {
+        operations.push(operation);
+      }
+    },
+    all() {
+      return [...operations];
+    },
+    since(ts) {
+      return operations.filter((op) => op.ts > ts);
+    },
+    latest(n) {
+      return operations.slice(-n);
+    }
+  };
+}
+
+// src/private/store/createCheckoutStore.ts
+function matchCheckoutByName(checkouts, name) {
+  const n = name.toLowerCase();
+  return Array.from(checkouts.values()).find((checkout) => checkout.record.name.toLowerCase() === n);
+}
+function matchCheckoutByLocation(checkouts, location) {
+  return checkouts.get(location);
+}
+function patternToRegex(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const globbed = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${globbed}$`, "i");
+}
+function isWildcardPattern(pattern) {
+  return pattern.includes("*");
+}
+function createCheckoutStore() {
+  const checkouts = /* @__PURE__ */ new Map();
+  function addCheckout(checkout) {
+    const existing = checkouts.get(checkout.record.location);
+    if (existing) {
+      const msg = `Duplicate location: "${checkout.record.location}", existing: "${existing.record.name}" duplicate: "${checkout.record.name}".`;
+      console.error(msg);
+    } else {
+      checkouts.set(checkout.record.location, checkout);
+    }
+  }
+  return {
+    addCheckout,
+    getCheckoutForLocation(location) {
+      return matchCheckoutByLocation(checkouts, location);
+    },
+    getCheckoutOfRepo(name) {
+      const n = name.toLowerCase();
+      return Array.from(checkouts.values()).find(
+        (checkout) => checkout.repo?.name.toLowerCase() === n
+      );
+    },
+    getCheckoutByName(name) {
+      return matchCheckoutByName(checkouts, name);
+    },
+    getCheckoutsByPattern(patterns) {
+      const matched = /* @__PURE__ */ new Map();
+      for (const pattern of patterns) {
+        let patternMatched = false;
+        for (const checkout of checkouts.values()) {
+          let nameMatch = false;
+          let locationMatch = false;
+          if (isWildcardPattern(pattern)) {
+            const regex = patternToRegex(pattern);
+            nameMatch = regex.test(checkout.record.name);
+            locationMatch = regex.test(checkout.record.location);
+          } else {
+            nameMatch = matchCheckoutByName(checkouts, pattern) === checkout;
+            locationMatch = matchCheckoutByLocation(checkouts, pattern) === checkout;
+          }
+          if (nameMatch || locationMatch) {
+            matched.set(checkout.record.location, checkout);
+            patternMatched = true;
+          }
+        }
+        if (!patternMatched) {
+          console.warn(`no checkout matches pattern: "${pattern}"`);
+        }
+      }
+      return Array.from(matched.values());
+    },
+    updateCheckout(checkout) {
+      checkouts.set(checkout.record.location, checkout);
+    },
+    getAllCheckouts() {
+      return Array.from(checkouts.values());
+    }
+  };
+}
+
+// src/index.ts
+var program = new Command();
+var logger = (op) => {
+  console.info(makeOperationLogLine(op, { standalone: true }).join(" | "));
+};
+program.name("art-workspace").description("Workspace orchestration CLI").version("0.0.18");
+program.command("sanity").description("Check git status across all repos").option("-a, --auto", "push clean unpushed repos").option("-r, --refetch", "fetch ahead/behind data from remote").action(async (options) => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  const auto = options.auto ?? false;
+  const refetch = options.refetch ?? false;
+  await runSanity(ctx, { auto, refetch });
+});
+program.command("clone").description("Clone repos from manifest").option("-a, --all", "clone all repos").argument("[name]", "repo name to clone").argument("[target]", "target location (relative to checkouts path)").action(
+  async (repoName, checkoutInput, options) => {
+    const root = process.cwd();
+    logger(createGenericOperation("boot"));
+    const config = await loadWorkspaceConfig(root);
+    const store = createCheckoutStore();
+    const log = createOperationsLog(logger);
+    const ctx = createWorkspaceContext(config, store, log);
+    await runClone(ctx, { all: options.all, repoName, checkoutInput });
+  }
+);
+program.command("branch").description("Branch across checkouts").argument("<branch>", "branch name to create or switch to").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 (branch, options) => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  await runBranch(ctx, { branch, checkouts: options.checkouts, all: options.all });
+});
+program.command("pull").description("Pull clean checkouts that are behind").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 (options) => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  await runPull(ctx, { checkouts: options.checkouts, all: options.all });
+});
+program.command("push").description("Push clean checkouts that are ahead").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 (options) => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  await runPush(ctx, { checkouts: options.checkouts, all: options.all });
+});
+program.command("sync").description("Pull and push clean checkouts").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 (options) => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  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(
+  "-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) => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  await runCheckoutsRun(ctx, { command, checkouts: options.checkouts, all: options.all });
+});
+program.command("repo").description("List checkout resources").argument("[checkouts...]", "checkout locations to list (default: all checkouts)").action(async (locations) => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  await runRepo(ctx, { locations });
+});
+program.command("link").description("Link packages for local dev").action(async () => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  await runLink(ctx, { root });
+});
+program.command("unlink").description("Unlink packages").action(async () => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  await runUnlink(ctx, { root });
+});
+program.command("publish").description("Publish packages").option("-a, --auto", "auto-publish").action(async (options) => {
+  const root = process.cwd();
+  logger(createGenericOperation("boot"));
+  const config = await loadWorkspaceConfig(root);
+  const store = createCheckoutStore();
+  const log = createOperationsLog(logger);
+  const ctx = createWorkspaceContext(config, store, log);
+  await runPublish(ctx, { root, auto: options.auto });
+});
+program.parse();
+export {
+  defineConfig,
+  loadWorkspaceConfig
+};