@akanjs/cli 3.0.0-alpha.9 → 3.0.0-alpha.91

package/subspace.command-kqzqtk0p.js

@@ -0,0 +1,755 @@
+// @bun
+import {
+  Workspace,
+  runner,
+  script,
+  command
+} from "./index-cezy7yb3.js";
+import {
+  FileSys
+} from "./index-q0y2jq9j.js";
+import {
+  Executor,
+  WorkspaceExecutor,
+  AppExecutor
+} from "./index-q8sn827n.js";
+import"./index-6wwzs1bc.js";
+import {
+  SlicePlanner
+} from "./index-pvb4vdwr.js";
+import {
+  LibSource
+} from "./index-3d9y066c.js";
+
+// pkgs/@akanjs/devkit/subspace.ts
+import { mkdir, readdir, rename, rm } from "fs/promises";
+import path from "path";
+class Subspace {
+  static anchorFile = "akan.subspace.json";
+  static workspaceOnlyEntries = ["akan.subspace.ts"];
+  static memberDirs = ["apps", "libs"];
+  static subspaceOwnedDirs = ["env"];
+  static secretsMarkers = ["# akan:secrets (managed by akan.config.ts \u2014 do not edit)", "# akan:secrets:end"];
+  static holdDir = ".akan-subspace-hold";
+  #workspace;
+  #config;
+  #declaration;
+  constructor(workspace, config, declaration) {
+    this.#workspace = workspace;
+    this.#config = config;
+    this.#declaration = declaration;
+  }
+  get name() {
+    return this.#declaration.name;
+  }
+  get apps() {
+    return this.#declaration.apps;
+  }
+  get #remote() {
+    return `subspace-${this.#declaration.name}`;
+  }
+  get #clonePath() {
+    return path.join(this.#workspace.workspaceRoot, ".akan/subspace", this.#declaration.name);
+  }
+  async#git(args) {
+    return await this.#workspace.spawn("git", args);
+  }
+  async branch() {
+    return (await this.#git(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  }
+  async headSha() {
+    return (await this.#git(["rev-parse", "--short", "HEAD"])).trim();
+  }
+  async fetch(branch) {
+    const remotes = (await this.#git(["remote"])).split(`
+`).map((line) => line.trim());
+    if (remotes.includes(this.#remote))
+      await this.#git(["remote", "set-url", this.#remote, this.#declaration.repo]);
+    else
+      await this.#git(["remote", "add", this.#remote, this.#declaration.repo]);
+    try {
+      await this.#git(["fetch", "--quiet", this.#remote, branch]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async anchor(branch) {
+    const ref = `${this.#remote}/${branch}`;
+    const commit = (await this.#git(["log", "-1", "--format=%H", ref, "--", Subspace.anchorFile])).trim();
+    if (!commit)
+      return { commit: null, incoming: [] };
+    const log = await this.#git(["log", "--format=%H%x09%an%x09%s", `${commit}..${ref}`]);
+    const incoming = log.split(`
+`).filter((line) => !!line.trim()).map((line) => {
+      const [sha = "", author = "", ...subject] = line.split("\t");
+      return { sha: sha.slice(0, 12), author, subject: subject.join("\t") };
+    });
+    return { commit, incoming };
+  }
+  async slice() {
+    const plans = await Promise.all(this.#declaration.apps.map(async (appName) => await new SlicePlanner(AppExecutor.from(this.#workspace, appName)).plan()));
+    const libs = [...new Set(plans.flatMap((plan) => plan.libs))].sort();
+    const paths = [...this.#declaration.apps.map((app) => `apps/${app}`), ...libs.map((lib) => `libs/${lib}`)];
+    return { plans, libs, paths };
+  }
+  #isSubspaceOwned(file) {
+    const segments = file.split("/");
+    if (!Subspace.memberDirs.includes(segments[0] ?? ""))
+      return false;
+    return Subspace.subspaceOwnedDirs.includes(segments[2] ?? "");
+  }
+  #isStamped(file) {
+    return /^libs\/[^/]+\/package\.json$/.test(file);
+  }
+  async#differsBeyondStamp(ref, file) {
+    const [theirs, ours] = await Promise.all([
+      this.#git(["show", `${ref}:${file}`]).catch(() => ""),
+      this.#git(["show", `HEAD:${file}`]).catch(() => "")
+    ]);
+    if (!theirs || !ours)
+      return true;
+    const normalize = (content) => {
+      try {
+        const manifest = JSON.parse(content);
+        delete manifest[LibSource.manifestKey];
+        return JSON.stringify(manifest);
+      } catch {
+        return content;
+      }
+    };
+    return normalize(theirs) !== normalize(ours);
+  }
+  async#meaningfulFiles(ref, files) {
+    const kept = await Promise.all(files.map(async (file) => this.#isStamped(file) ? await this.#differsBeyondStamp(ref, file) : true));
+    return files.filter((_, index) => kept[index]);
+  }
+  async status(branch) {
+    const hasBranch = await this.fetch(branch);
+    const [{ paths, libs }, anchor] = await Promise.all([
+      this.slice(),
+      hasBranch ? this.anchor(branch) : Promise.resolve({ commit: null, incoming: [] })
+    ]);
+    if (!hasBranch)
+      return { name: this.name, branch, hasBranch, anchor, behindPaths: [], driftedLibs: [] };
+    const ref = `${this.#remote}/${branch}`;
+    const diff = await this.#git(["diff", "--name-only", "HEAD", ref, "--", ...paths]);
+    const behindPaths = await this.#meaningfulFiles(ref, diff.split(`
+`).filter((file) => !!file.trim()).filter((file) => !this.#isSubspaceOwned(file)));
+    const driftedLibs = libs.filter((lib) => behindPaths.some((file) => file.startsWith(`libs/${lib}/`)));
+    return { name: this.name, branch, hasBranch, anchor, behindPaths, driftedLibs };
+  }
+  async#ensureClone(branch) {
+    if (!await FileSys.dirExists(path.join(this.#clonePath, ".git"))) {
+      await rm(this.#clonePath, { recursive: true, force: true });
+      await mkdir(path.dirname(this.#clonePath), { recursive: true });
+      await this.#workspace.spawn("git", ["clone", "--quiet", this.#declaration.repo, this.#clonePath]);
+    }
+    const clone = new Executor(`subspace-${this.name}`, this.#clonePath);
+    await clone.spawn("git", ["fetch", "--quiet", "origin", branch]);
+    await clone.spawn("git", ["checkout", "--quiet", "-B", branch, `origin/${branch}`]);
+    await clone.spawn("git", ["clean", "-qfd"]);
+    return clone;
+  }
+  async#holdSubspaceOwned() {
+    const held = [];
+    const holdRoot = path.join(this.#clonePath, Subspace.holdDir);
+    await rm(holdRoot, { recursive: true, force: true });
+    for (const member of Subspace.memberDirs) {
+      const memberRoot = path.join(this.#clonePath, member);
+      if (!await FileSys.dirExists(memberRoot))
+        continue;
+      for (const name of await readdir(memberRoot)) {
+        for (const owned of Subspace.subspaceOwnedDirs) {
+          const from = path.join(memberRoot, name, owned);
+          if (!await FileSys.dirExists(from))
+            continue;
+          const to = path.join(holdRoot, member, name, owned);
+          await mkdir(path.dirname(to), { recursive: true });
+          await rename(from, to);
+          held.push({ from, to });
+        }
+      }
+    }
+    return held;
+  }
+  async#restoreSubspaceOwned(held) {
+    for (const { from, to } of held)
+      await Subspace.#copyMissing(to, from);
+    await rm(path.join(this.#clonePath, Subspace.holdDir), { recursive: true, force: true });
+  }
+  static async#copyMissing(from, to) {
+    await mkdir(to, { recursive: true });
+    for (const entry of await readdir(from, { withFileTypes: true })) {
+      const source = path.join(from, entry.name);
+      const target = path.join(to, entry.name);
+      if (entry.isDirectory())
+        await Subspace.#copyMissing(source, target);
+      else if (!await FileSys.entryExists(target))
+        await rename(source, target);
+    }
+  }
+  async#extract(paths, excludes = []) {
+    const pathspec = paths.map((entry) => `'${entry}'`).join(" ");
+    const excludeArgs = excludes.map((entry) => `--exclude='${entry}'`).join(" ");
+    await this.#workspace.exec(`git archive HEAD -- ${pathspec} | tar -x -C '${this.#clonePath}' ${excludeArgs}`.trim());
+  }
+  #localEnv() {
+    const { serveDomain } = WorkspaceExecutor.getBaseDevEnv();
+    return {
+      AKAN_WORKSPACE_ID: "local",
+      AKAN_PUBLIC_REPO_NAME: this.name,
+      AKAN_PUBLIC_SERVE_DOMAIN: serveDomain,
+      AKAN_PUBLIC_ENV: "local",
+      AKAN_PUBLIC_OPERATION_MODE: "local",
+      AKAN_PUBLIC_LOG_LEVEL: "warn"
+    };
+  }
+  async#writeLocalEnv() {
+    const excludePath = path.join(this.#clonePath, ".git/info/exclude");
+    const exclude = await FileSys.fileExists(excludePath) ? await FileSys.readText(excludePath) : "";
+    if (!exclude.split(`
+`).includes("/.env")) {
+      await mkdir(path.dirname(excludePath), { recursive: true });
+      await FileSys.writeText(excludePath, exclude.trim() ? `${exclude.replace(/\n*$/, `
+`)}/.env
+` : `/.env
+`);
+    }
+    const envPath = path.join(this.#clonePath, ".env");
+    if (await FileSys.fileExists(envPath))
+      return;
+    const lines = Object.entries(this.#localEnv()).map(([key, value]) => `${key}=${value}`);
+    await FileSys.writeText(envPath, `${lines.join(`
+`)}
+`);
+  }
+  async#rewriteManifest(plans) {
+    const manifestPath = path.join(this.#clonePath, "package.json");
+    if (!await FileSys.fileExists(manifestPath))
+      return [];
+    const rootPackageJson = await FileSys.readJson(manifestPath);
+    const { packageJson, pruned, warnings } = await SlicePlanner.pruneDependencies(this.#workspace, rootPackageJson, plans.flatMap((plan) => plan.requiredDependencies));
+    for (const warning of warnings)
+      this.#workspace.logger.warn(warning);
+    await FileSys.writeJson(manifestPath, {
+      ...packageJson,
+      name: this.name,
+      description: `${this.name} workspace`
+    });
+    return pruned;
+  }
+  async#applySlice(clone, branch) {
+    const { libs, paths, plans } = await this.slice();
+    const held = await this.#holdSubspaceOwned();
+    for (const member of Subspace.memberDirs)
+      await rm(path.join(this.#clonePath, member), { recursive: true, force: true });
+    await this.#extract(["."], ["apps/*", "libs/*", "pkgs/*"]);
+    await this.#extract(paths);
+    await this.#restoreSubspaceOwned(held);
+    for (const entry of [...Subspace.workspaceOnlyEntries, ...this.#config.exclude])
+      await rm(path.join(this.#clonePath, entry), { recursive: true, force: true });
+    await this.#rewriteGitignore();
+    const pruned = await this.#rewriteManifest(plans);
+    await this.#rewriteWorkspaceSection(libs);
+    await this.#writeLocalEnv();
+    for (const lib of libs)
+      await this.#stampLib(clone, lib, branch);
+    return { libs, pruned };
+  }
+  async#rewriteGitignore() {
+    const gitignorePath = path.join(this.#clonePath, ".gitignore");
+    if (!await FileSys.fileExists(gitignorePath))
+      return;
+    const [begin = "", end = ""] = Subspace.secretsMarkers;
+    const lines = (await FileSys.readText(gitignorePath)).split(`
+`);
+    const beginIdx = lines.indexOf(begin);
+    const endIdx = lines.indexOf(end);
+    const filtered = beginIdx >= 0 && endIdx > beginIdx ? [
+      ...lines.slice(0, beginIdx + 1),
+      ...lines.slice(beginIdx + 1, endIdx).filter((line) => this.#declaration.apps.some((app) => line.startsWith(`apps/${app}/`))),
+      ...lines.slice(endIdx)
+    ] : lines;
+    await FileSys.writeText(gitignorePath, filtered.filter((line) => line.trim() !== "**/bun.lock").join(`
+`));
+  }
+  async#rewriteWorkspaceSection(libs) {
+    const replacements = [
+      [/^- Repo: .*$/m, `- Repo: ${this.name}`],
+      [/^- Apps: .*$/m, `- Apps: ${this.#declaration.apps.join(", ")}`],
+      [/^- Libraries: .*$/m, `- Libraries: ${libs.length ? libs.join(", ") : "(none)"}`]
+    ];
+    for (const file of ["AGENTS.md", "CLAUDE.md"]) {
+      const filePath = path.join(this.#clonePath, file);
+      if (!await FileSys.fileExists(filePath))
+        continue;
+      const content = await FileSys.readText(filePath);
+      const rewritten = replacements.reduce((text, [pattern, value]) => text.replace(pattern, value), content);
+      if (rewritten !== content)
+        await FileSys.writeText(filePath, rewritten);
+    }
+  }
+  async#stampLib(clone, lib, branch) {
+    const manifestPath = path.join(this.#clonePath, "libs", lib, "package.json");
+    if (!await FileSys.fileExists(manifestPath))
+      return;
+    const origin = `${this.#workspace.repoName}#${branch}`;
+    const sha = await this.headSha();
+    const [hash, previous] = await Promise.all([this.#hashLib(clone, lib), this.#committedStamp(clone, lib)]);
+    const manifest = await FileSys.readJson(manifestPath);
+    const akan = manifest[LibSource.manifestKey] ?? {};
+    const unchanged = previous?.origin === origin && previous.sha === sha && previous.hash === hash;
+    const syncedAt = unchanged ? previous.syncedAt : new Date().toISOString();
+    manifest[LibSource.manifestKey] = { ...akan, source: { origin, sha, hash, syncedAt } };
+    await FileSys.writeJson(manifestPath, manifest);
+  }
+  async#committedStamp(clone, lib) {
+    try {
+      const committed = await clone.spawn("git", ["show", `HEAD:libs/${lib}/package.json`]);
+      const manifest = JSON.parse(committed);
+      const akan = manifest[LibSource.manifestKey] ?? {};
+      return akan.source;
+    } catch {
+      return;
+    }
+  }
+  async#hashLib(clone, lib) {
+    const listed = await clone.spawn("git", [
+      "ls-files",
+      "-z",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "--",
+      `libs/${lib}`
+    ]);
+    const files = listed.split("\x00").filter((file) => !!file && !this.#isSubspaceOwned(file)).sort();
+    const hasher = new Bun.CryptoHasher("sha256");
+    for (const file of files) {
+      const content = await FileSys.readText(path.join(this.#clonePath, file));
+      hasher.update(file);
+      hasher.update("\x00");
+      if (file === `libs/${lib}/package.json`) {
+        const manifest = JSON.parse(content);
+        delete manifest[LibSource.manifestKey];
+        hasher.update(JSON.stringify(manifest));
+      } else
+        hasher.update(content);
+      hasher.update("\x00");
+    }
+    return hasher.digest("hex").slice(0, 32);
+  }
+  async diff(branch, filter) {
+    if (!await this.fetch(branch))
+      throw new Error(`Subspace "${this.name}" has no branch "${branch}"`);
+    const { libs, paths } = await this.slice();
+    const libPaths = libs.map((lib) => `libs/${lib}`);
+    const appPaths = paths.filter((entry) => !libPaths.includes(entry));
+    const [app, libSection] = await Promise.all([
+      this.#diffSection(branch, appPaths, filter),
+      this.#diffSection(branch, libPaths, filter)
+    ]);
+    return { name: this.name, branch, app, libs: libSection };
+  }
+  async#diffSection(branch, paths, filter) {
+    const scoped = filter ? paths.filter((entry) => entry.startsWith(filter) || filter.startsWith(entry)) : paths;
+    if (!scoped.length)
+      return { files: [], patch: "" };
+    const from = `${this.#remote}/${branch}`;
+    const pathspec = filter ? [filter] : scoped;
+    const names = await this.#git(["diff", "--name-only", from, "HEAD", "--", ...pathspec]);
+    const files = await this.#meaningfulFiles(from, names.split(`
+`).filter((file) => !!file.trim()).filter((file) => !this.#isSubspaceOwned(file)));
+    if (!files.length)
+      return { files: [], patch: "" };
+    return { files, patch: await this.#git(["diff", from, "HEAD", "--", ...files]) };
+  }
+  async#verify(clone) {
+    const env = { ...process.env, ...this.#localEnv() };
+    try {
+      await clone.spawn("bun", ["install"], { env });
+      for (const app of this.#declaration.apps)
+        await clone.spawn("bunx", ["akan", "sync", app], { env });
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error.message : String(error);
+    }
+  }
+  async push(branch, { verify = true } = {}) {
+    this.#config.assertPushable(branch);
+    if (await this.#workspace.hasChanges())
+      return { name: this.name, outcome: "refused", reason: "workspace working tree is dirty", changedFiles: 0 };
+    if (!await this.fetch(branch))
+      return { name: this.name, outcome: "refused", reason: `subspace has no branch "${branch}"`, changedFiles: 0 };
+    const clone = await this.#ensureClone(branch);
+    const { pruned } = await this.#applySlice(clone, branch);
+    const dirty = (await clone.spawn("git", ["status", "--porcelain"])).trim();
+    if (!dirty)
+      return {
+        name: this.name,
+        outcome: "skipped",
+        reason: "already up to date",
+        changedFiles: 0,
+        prunedDependencies: pruned
+      };
+    const changedFiles = dirty.split(`
+`).length;
+    if (verify) {
+      const failure = await this.#verify(clone);
+      if (failure)
+        return { name: this.name, outcome: "refused", reason: failure, changedFiles };
+    }
+    await this.#writeAnchorFile(branch);
+    await clone.spawn("git", ["add", "-A"]);
+    const message = `chore(subspace): sync from ${this.#workspace.repoName}@${await this.headSha()}`;
+    await clone.spawn("git", ["commit", "--quiet", "-m", message]);
+    await clone.spawn("git", ["push", "--quiet", "origin", branch]);
+    return {
+      name: this.name,
+      outcome: "pushed",
+      commit: (await clone.spawn("git", ["rev-parse", "--short", "HEAD"])).trim(),
+      changedFiles,
+      prunedDependencies: pruned
+    };
+  }
+  async#writeAnchorFile(branch) {
+    await FileSys.writeJson(path.join(this.#clonePath, Subspace.anchorFile), {
+      workspace: this.#workspace.repoName,
+      hubSha: await this.headSha(),
+      branch,
+      apps: this.#declaration.apps,
+      syncedAt: new Date().toISOString()
+    });
+  }
+  async pull(branch, { adoptLibs = false } = {}) {
+    if (!await this.fetch(branch))
+      throw new Error(`Subspace "${this.name}" has no branch "${branch}"`);
+    const anchor = await this.anchor(branch);
+    if (!anchor.commit)
+      throw new Error(`Subspace "${this.name}" carries no ${Subspace.anchorFile} \u2014 it has never received a push`);
+    if (!anchor.incoming.length)
+      return { name: this.name, applied: [], libPatch: null, ignored: [], incoming: [] };
+    const range = `${anchor.commit}..${this.#remote}/${branch}`;
+    const changed = (await this.#git(["diff", "--name-only", range])).split(`
+`).filter((file) => !!file.trim());
+    const appPrefixes = this.#declaration.apps.map((app) => `apps/${app}/`);
+    const appFiles = changed.filter((file) => appPrefixes.some((prefix) => file.startsWith(prefix)) && !this.#isSubspaceOwned(file));
+    const libFiles = changed.filter((file) => file.startsWith("libs/") && !this.#isSubspaceOwned(file));
+    const ignored = changed.filter((file) => !appFiles.includes(file) && !libFiles.includes(file));
+    const applied = adoptLibs ? [...appFiles, ...libFiles] : appFiles;
+    if (applied.length)
+      await this.#applyPatch(range, applied, "incoming");
+    const saved = !adoptLibs && libFiles.length ? await this.#savePatch(range, libFiles, "libs") : null;
+    const libPatch = saved ? { path: saved.path, files: saved.files } : null;
+    return { name: this.name, applied, libPatch, ignored, incoming: anchor.incoming };
+  }
+  async#applyPatch(range, files, label) {
+    const { absolute } = await this.#savePatch(range, files, label);
+    await this.#git(["apply", "--3way", absolute]);
+  }
+  async#savePatch(range, files, label) {
+    const patchPath = path.join(this.#workspace.workspaceRoot, ".akan/subspace", `${this.name}-${label}.patch`);
+    await mkdir(path.dirname(patchPath), { recursive: true });
+    await FileSys.writeText(patchPath, await this.#git(["diff", range, "--", ...files]));
+    return { path: path.relative(this.#workspace.workspaceRoot, patchPath), absolute: patchPath, files };
+  }
+}
+function formatSubspaceStatuses(statuses) {
+  const sections = [
+    "Akan Subspace Status",
+    `branch: ${statuses[0]?.branch ?? "(none)"}`,
+    "",
+    ...statuses.flatMap((status) => {
+      if (!status.hasBranch)
+        return [`  ${status.name}: no such branch in the subspace \u2014 push is refused`];
+      const behind = status.behindPaths.length ? `${status.behindPaths.length} file(s) behind` : "up to date";
+      const incoming = status.anchor.incoming.length ? `${status.anchor.incoming.length} customer commit(s) to pull` : "no customer commits";
+      const drift = status.driftedLibs.length ? `  DRIFTED LIBS: ${status.driftedLibs.join(", ")}` : null;
+      return [
+        `  ${status.name}: ${behind}, ${incoming}`,
+        ...status.anchor.incoming.map((commit) => `    ${commit.sha}  ${commit.author}  ${commit.subject}`),
+        ...drift ? [drift] : []
+      ];
+    })
+  ];
+  return sections.join(`
+`);
+}
+function formatSubspacePushResults(results) {
+  const sections = [
+    "Akan Subspace Push",
+    "",
+    ...results.flatMap((result) => {
+      const detail = result.outcome === "pushed" ? `${result.commit} (${result.changedFiles} files)` : result.reason ?? "";
+      const [first = "", ...rest] = detail.split(`
+`);
+      const pruned = result.prunedDependencies?.length ? [`    ${result.prunedDependencies.length} unused root dependenc(ies) left out of package.json`] : [];
+      return [
+        `  ${result.outcome.padEnd(8)} ${result.name}  ${first}`,
+        ...rest.map((line) => `    ${line}`),
+        ...pruned
+      ];
+    })
+  ];
+  return sections.join(`
+`);
+}
+function formatSubspacePullResult(result) {
+  const sections = [
+    `Akan Subspace Pull \u2014 ${result.name}`,
+    "",
+    `Customer commits since the last push (${result.incoming.length}):`,
+    "",
+    ...result.incoming.length ? result.incoming.map((commit) => `  ${commit.sha}  ${commit.author}  ${commit.subject}`) : ["  (none \u2014 nothing to pull)"],
+    "",
+    `Applied to the working tree, uncommitted (${result.applied.length}):`,
+    "",
+    ...result.applied.length ? result.applied.map((file) => `  ${file}`) : ["  (none)"],
+    ...result.libPatch ? [
+      "",
+      `Library edits NOT applied (${result.libPatch.files.length}) \u2014 review before adopting:`,
+      "",
+      ...result.libPatch.files.map((file) => `  ${file}`),
+      "",
+      `  patch: ${result.libPatch.path}`,
+      "  adopt with: akan subspace pull <name> --adopt-libs"
+    ] : [],
+    ...result.ignored.length ? ["", `Ignored (workspace-owned or subspace-owned): ${result.ignored.length} file(s)`] : []
+  ];
+  return sections.join(`
+`);
+}
+function formatSubspaceDiff(result) {
+  const total = result.app.files.length + result.libs.files.length;
+  const sections = [
+    `Akan Subspace Diff \u2014 ${result.name} (${result.branch})`,
+    "what `akan subspace push` would change in the subspace",
+    "",
+    ...total ? [] : ["  subspace is identical to the workspace for this slice."],
+    ...result.libs.files.length ? [
+      `LIBRARY changes (${result.libs.files.length}) \u2014 the subspace edited shared code:`,
+      "",
+      ...result.libs.files.map((file) => `  ${file}`),
+      "",
+      result.libs.patch
+    ] : [],
+    ...result.app.files.length ? [
+      `App changes (${result.app.files.length}):`,
+      "",
+      ...result.app.files.map((file) => `  ${file}`),
+      "",
+      result.app.patch
+    ] : []
+  ];
+  return sections.join(`
+`);
+}
+
+// pkgs/@akanjs/cli/subspace/subspace.script.ts
+import { Logger } from "akanjs/common";
+
+// pkgs/@akanjs/devkit/subspaceConfig.ts
+import path2 from "path";
+class SubspaceConfig {
+  static fileName = "akan.subspace.ts";
+  static defaultPushableBranches = ["main", "develop", "debug"];
+  static async from(workspace) {
+    const configPath = path2.join(workspace.workspaceRoot, SubspaceConfig.fileName);
+    if (!await FileSys.fileExists(configPath))
+      return null;
+    const input = await import(configPath).then((mod) => mod.default);
+    return new SubspaceConfig(input);
+  }
+  pushableBranches;
+  exclude;
+  subspaces;
+  constructor(input) {
+    this.pushableBranches = input.pushableBranches ?? SubspaceConfig.defaultPushableBranches;
+    this.exclude = input.exclude ?? [];
+    this.subspaces = input.subspaces ?? [];
+    this.#assertValid();
+  }
+  #assertValid() {
+    const seenNames = new Set;
+    const appOwners = new Map;
+    for (const subspace of this.subspaces) {
+      if (!subspace.name || !subspace.repo)
+        throw new Error(`${SubspaceConfig.fileName}: every subspace needs a name and a repo`);
+      if (seenNames.has(subspace.name))
+        throw new Error(`${SubspaceConfig.fileName}: duplicate subspace "${subspace.name}"`);
+      seenNames.add(subspace.name);
+      if (!subspace.apps?.length)
+        throw new Error(`${SubspaceConfig.fileName}: subspace "${subspace.name}" declares no apps`);
+      for (const app of subspace.apps) {
+        const owner = appOwners.get(app);
+        if (owner)
+          throw new Error(`${SubspaceConfig.fileName}: app "${app}" is claimed by both "${owner}" and "${subspace.name}"`);
+        appOwners.set(app, subspace.name);
+      }
+    }
+  }
+  select(names) {
+    if (!names.length)
+      return this.subspaces;
+    return names.map((name) => {
+      const subspace = this.subspaces.find((candidate) => candidate.name === name);
+      if (!subspace)
+        throw new Error(`${SubspaceConfig.fileName}: unknown subspace "${name}"`);
+      return subspace;
+    });
+  }
+  assertPushable(branch) {
+    if (this.pushableBranches.includes(branch))
+      return;
+    throw new Error(`Branch "${branch}" is not pushable. ${SubspaceConfig.fileName} allows: ${this.pushableBranches.join(", ")}`);
+  }
+}
+
+// pkgs/@akanjs/cli/subspace/subspace.runner.ts
+var loadPrompts = async () => await import("@inquirer/prompts");
+
+class SubspaceRunner extends runner("subspace") {
+  static multiTargetActions = ["status", "push"];
+  async config(workspace) {
+    const config = await SubspaceConfig.from(workspace);
+    if (!config)
+      throw new Error(`No ${SubspaceConfig.fileName} at the workspace root. Declare the customer repos there first.`);
+    return config;
+  }
+  async subspaces(workspace, names) {
+    const config = await this.config(workspace);
+    const subspaces = config.select(names).map((declaration) => new Subspace(workspace, config, declaration));
+    const branch = (await workspace.spawn("git", ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    return { config, subspaces, branch };
+  }
+  async selectNames(workspace, action) {
+    const config = await this.config(workspace);
+    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    return await SubspaceRunner.chooseNames(config, action, { interactive });
+  }
+  static async chooseNames(config, action, { interactive, prompts }) {
+    const multiple = SubspaceRunner.multiTargetActions.includes(action);
+    if (!config.subspaces.length)
+      throw new Error(`${SubspaceConfig.fileName} declares no subspaces.`);
+    if (!interactive) {
+      throw new Error(multiple ? `\`akan subspace ${action}\` needs a subspace name when it cannot prompt. Pass one, or run \`akan subspace ${action}-all\` for every subspace.` : `\`akan subspace ${action}\` needs a subspace name when it cannot prompt \u2014 it is reviewed one repo at a time.`);
+    }
+    const { checkbox, select } = prompts ?? await loadPrompts();
+    const choices = config.subspaces.map((subspace) => ({
+      name: subspace.name,
+      value: subspace.name,
+      description: `${subspace.repo} \xB7 ${subspace.apps.join(", ")}`
+    }));
+    if (multiple)
+      return await checkbox({ message: `Select subspaces to ${action}`, choices, required: true });
+    return [await select({ message: `Select a subspace to ${action}`, choices })];
+  }
+  async status(workspace, names) {
+    const { subspaces, branch } = await this.subspaces(workspace, names);
+    const statuses = [];
+    for (const subspace of subspaces)
+      statuses.push(await subspace.status(branch));
+    return statuses;
+  }
+  async push(workspace, names, { verify } = {}) {
+    const { config, subspaces, branch } = await this.subspaces(workspace, names);
+    config.assertPushable(branch);
+    const results = [];
+    for (const subspace of subspaces)
+      results.push(await subspace.push(branch, { verify }));
+    return results;
+  }
+  async diff(workspace, name, filter) {
+    const { subspaces, branch } = await this.subspaces(workspace, [name]);
+    const [subspace] = subspaces;
+    if (!subspace)
+      throw new Error(`Unknown subspace "${name}"`);
+    return await subspace.diff(branch, filter);
+  }
+  async pull(workspace, name, { adoptLibs } = {}) {
+    const { subspaces, branch } = await this.subspaces(workspace, [name]);
+    const [subspace] = subspaces;
+    if (!subspace)
+      throw new Error(`Unknown subspace "${name}"`);
+    return await subspace.pull(branch, { adoptLibs });
+  }
+}
+
+// pkgs/@akanjs/cli/subspace/subspace.script.ts
+class SubspaceScript extends script("subspace", [SubspaceRunner]) {
+  async select(workspace, action) {
+    return await this.subspaceRunner.selectNames(workspace, action);
+  }
+  async status(workspace, names, format = "text") {
+    const spinner = workspace.spinning("Checking subspaces...");
+    const statuses = await this.subspaceRunner.status(workspace, names);
+    const drifted = statuses.filter((status) => status.driftedLibs.length).length;
+    spinner.succeed(`Checked ${statuses.length} subspace(s) (${drifted} with library drift)`);
+    Logger.rawLog(format === "json" ? JSON.stringify(statuses, null, 2) : formatSubspaceStatuses(statuses));
+  }
+  async push(workspace, names, { verify, format }) {
+    const spinner = workspace.spinning("Pushing to subspaces...");
+    const results = await this.subspaceRunner.push(workspace, names, { verify });
+    const pushed = results.filter((result) => result.outcome === "pushed").length;
+    spinner.succeed(`Pushed ${pushed} of ${results.length} subspace(s)`);
+    Logger.rawLog(format === "json" ? JSON.stringify(results, null, 2) : formatSubspacePushResults(results));
+    if (results.some((result) => result.outcome === "refused"))
+      process.exitCode = 1;
+  }
+  async diff(workspace, name, filter, format = "text") {
+    const spinner = workspace.spinning(`Diffing ${name}...`);
+    const result = await this.subspaceRunner.diff(workspace, name, filter);
+    const total = result.app.files.length + result.libs.files.length;
+    spinner.succeed(`${total} file(s) differ (${result.libs.files.length} in shared libraries)`);
+    Logger.rawLog(format === "json" ? JSON.stringify(result, null, 2) : formatSubspaceDiff(result));
+  }
+  async pull(workspace, name, { adoptLibs, format }) {
+    const spinner = workspace.spinning(`Pulling customer commits from ${name}...`);
+    const result = await this.subspaceRunner.pull(workspace, name, { adoptLibs });
+    spinner.succeed(`${result.incoming.length} customer commit(s), ${result.applied.length} file(s) applied`);
+    Logger.rawLog(format === "json" ? JSON.stringify(result, null, 2) : formatSubspacePullResult(result));
+  }
+}
+
+// pkgs/@akanjs/cli/subspace/subspace.command.ts
+class SubspaceCommand extends command("subspace", [SubspaceScript], ({ public: target }) => ({
+  subspace: target({ desc: "Mirror apps and libraries between this workspace and the customer repos it serves" }).arg("action", String, {
+    desc: "subspace action; status-all and push-all take every declared subspace",
+    default: "status",
+    enum: ["status", "status-all", "diff", "push", "push-all", "pull"]
+  }).arg("subspace", String, {
+    desc: "subspace name; asks which one(s) when omitted, and is refused by status-all / push-all",
+    nullable: true
+  }).with(Workspace).option("format", String, { desc: "output format", default: "text", enum: ["text", "json"] }).option("verify", Boolean, {
+    flag: "y",
+    desc: "run bun install + akan sync in the subspace before committing",
+    default: true
+  }).option("adoptLibs", Boolean, { desc: "pull: also apply the subspace's library edits", default: false }).option("path", String, { desc: "diff: limit to one path", nullable: true }).exec(async function(action, subspace, workspace, format, verify, adoptLibs, filePath) {
+    const output = format;
+    const all = action === "status-all" || action === "push-all";
+    const base = all ? action.slice(0, -"-all".length) : action;
+    if (base !== "status" && base !== "diff" && base !== "push" && base !== "pull")
+      throw new Error(`Unknown subspace action: ${action}. Use status, status-all, diff, push, push-all or pull.`);
+    if (all && subspace)
+      throw new Error(`\`akan subspace ${action}\` takes no name. Run \`akan subspace ${base} ${subspace}\` instead.`);
+    const names = subspace ? [subspace] : all ? [] : await this.subspaceScript.select(workspace, base);
+    if (base === "status")
+      await this.subspaceScript.status(workspace, names, output);
+    else if (base === "push")
+      await this.subspaceScript.push(workspace, names, { verify, format: output });
+    else {
+      const [name] = names;
+      if (!name)
+        throw new Error(`\`akan subspace ${base}\` needs a name \u2014 it is reviewed one repo at a time.`);
+      if (base === "diff")
+        await this.subspaceScript.diff(workspace, name, filePath, output);
+      else
+        await this.subspaceScript.pull(workspace, name, { adoptLibs, format: output });
+    }
+  })
+})) {
+}
+export {
+  SubspaceCommand
+};