oh-my-space 0.11.3 → 0.11.5

package/dist/build-info.json

@@ -1 +1 @@
-{"commit":"1c33003a35ff5de34f10fe4341a38338fa927f95"}
+{"commit":"022ade8884c62e549770e73407066671e8caa50a"}

package/dist/oms.js

@@ -14014,6 +14014,8 @@ function readJson(path) {
 }
 __name(readJson, "readJson");
 function readPackageVersion() {
+  const mocked = testEnv("OMS_TEST_PACKAGE_VERSION");
+  if (mocked !== void 0) return mocked;
   const pkg = readJson(join(packageRoot, "package.json"));
   return pkg?.version ?? "0.0.0";
 }
@@ -14546,7 +14548,7 @@ function loadForSubmodules() {
 __name(loadForSubmodules, "loadForSubmodules");
 
 // scripts/lib/status.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync5, lstatSync, readdirSync } from "node:fs";
 import { relative, resolve as resolve4 } from "node:path";
 function pinState(repoRoot, alias) {
   const r = runGit(repoRoot, ["submodule", "status", "--", submodulePath(alias)]);
@@ -14699,6 +14701,55 @@ function partialRemovalTopology(s) {
   return s.headOid !== null && !s.pathExists !== !s.gitmodulesEntry;
 }
 __name(partialRemovalTopology, "partialRemovalTopology");
+function readAliasDirEntries(repoRoot, alias) {
+  const dir = aliasDir(repoRoot, alias);
+  try {
+    if (!lstatSync(dir).isDirectory()) return { exists: true, kind: "file" };
+    return { exists: true, kind: "dir", entries: readdirSync(dir) };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return { exists: false };
+    }
+    return { exists: true, kind: "unreadable" };
+  }
+}
+__name(readAliasDirEntries, "readAliasDirEntries");
+function unreadablePathReason(alias) {
+  return `oms/${alias} could not be read (permission or I/O error). Resolve access to it, then retry.`;
+}
+__name(unreadablePathReason, "unreadablePathReason");
+var TOPOLOGY_REASON = {
+  conflict: "the root gitlink is conflicted. Resolve the root repository conflict first.",
+  inProgressOp: /* @__PURE__ */ __name((op) => `the root repository has a ${op} in progress. Resolve, continue, or abort it first.`, "inProgressOp"),
+  occupiedPath: /* @__PURE__ */ __name((alias) => `oms/${alias} is occupied by a non-submodule path. Move or remove it manually, then retry.`, "occupiedPath"),
+  unreadable: /* @__PURE__ */ __name((alias) => unreadablePathReason(alias), "unreadable")
+};
+function occupiedByNonSubmodule(repoRoot, alias) {
+  if (isRegisteredSubmodule(repoRoot, submodulePath(alias))) return "clear";
+  const dirState = readAliasDirEntries(repoRoot, alias);
+  if (!dirState.exists) return "clear";
+  if (dirState.kind === "unreadable") return "unreadable";
+  if (dirState.kind === "file") return "occupied";
+  return dirState.entries.length > 0 ? "occupied" : "clear";
+}
+__name(occupiedByNonSubmodule, "occupiedByNonSubmodule");
+function assertRootTopologySafe(repoRoot, alias, checks = ["conflict", "inProgressOp", "occupiedPath"]) {
+  const applies = new Set(checks);
+  if (applies.has("conflict") && gitlinkState(repoRoot, alias).conflict) {
+    return { safe: false, reason: TOPOLOGY_REASON.conflict };
+  }
+  if (applies.has("inProgressOp")) {
+    const op = gitOperationInProgress(repoRoot);
+    if (op) return { safe: false, reason: TOPOLOGY_REASON.inProgressOp(op) };
+  }
+  if (applies.has("occupiedPath")) {
+    const occupied = occupiedByNonSubmodule(repoRoot, alias);
+    if (occupied === "unreadable") return { safe: false, reason: TOPOLOGY_REASON.unreadable(alias) };
+    if (occupied === "occupied") return { safe: false, reason: TOPOLOGY_REASON.occupiedPath(alias) };
+  }
+  return { safe: true };
+}
+__name(assertRootTopologySafe, "assertRootTopologySafe");
 function rootFollowupHint(alias, s) {
   if (s.headOid !== null && s.pathExists && !s.conflict && s.moved) {
     return `Run "oms record ${alias}" to record the root pointer update.`;
@@ -15152,13 +15203,9 @@ async function runRecord(alias) {
   const selected = resolution.alias;
   const path = submodulePath(selected);
   const state = gitlinkState(repoRoot, selected);
-  if (state.conflict) {
-    R2.error(`${selected}: the root gitlink is conflicted. Resolve the root repository conflict first.`);
-    return 1;
-  }
-  const rootOp = gitOperationInProgress(repoRoot);
-  if (rootOp) {
-    R2.error(`Root repository has a ${rootOp} in progress. Resolve, continue, or abort it before recording.`);
+  const safety = assertRootTopologySafe(repoRoot, selected, ["conflict", "inProgressOp"]);
+  if (!safety.safe) {
+    R2.error(`${selected}: ${safety.reason}`);
     return 1;
   }
   if (currentBranch(repoRoot) === null) {
@@ -15764,7 +15811,7 @@ async function runInit(options) {
 __name(runInit, "runInit");
 
 // scripts/lib/repo-ops.ts
-import { existsSync as existsSync8, readdirSync, rmSync as rmSync2, rmdirSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4, readdirSync as readdirSync2, rmSync as rmSync2, rmdirSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join7 } from "node:path";
 function cleanupFailedAdd(repoRoot, alias) {
   const path = submodulePath(alias);
@@ -15782,12 +15829,160 @@ function cleanupFailedAdd(repoRoot, alias) {
   }
 }
 __name(cleanupFailedAdd, "cleanupFailedAdd");
+function headGitmodulesSection(repoRoot, alias) {
+  const path = submodulePath(alias);
+  const r = runGit(repoRoot, ["show", "HEAD:.gitmodules"]);
+  if (!r.success) return null;
+  const lines = r.stdout.split("\n");
+  const start = lines.findIndex((line) => line.trim() === `[submodule "${path}"]`);
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^\s*\[submodule ".+"\]\s*$/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  return `${lines.slice(start, end).join("\n").replace(/\n*$/, "\n")}`;
+}
+__name(headGitmodulesSection, "headGitmodulesSection");
+function headFollowingGitmodulesHeaders(repoRoot, alias) {
+  const path = submodulePath(alias);
+  const r = runGit(repoRoot, ["show", "HEAD:.gitmodules"]);
+  if (!r.success) return [];
+  const lines = r.stdout.split("\n");
+  const start = lines.findIndex((line) => line.trim() === `[submodule "${path}"]`);
+  if (start === -1) return [];
+  const headers = [];
+  for (let i = start + 1; i < lines.length; i++) {
+    const match = lines[i].trim().match(/^\[submodule "(.+)"\]$/);
+    if (match) headers.push(`[submodule "${match[1]}"]`);
+  }
+  return headers;
+}
+__name(headFollowingGitmodulesHeaders, "headFollowingGitmodulesHeaders");
+function currentGitmodulesHasSameAliasSection(repoRoot, alias) {
+  const gitmodules = join7(repoRoot, ".gitmodules");
+  if (!existsSync8(gitmodules)) return false;
+  return readFileSync4(gitmodules, "utf8").split("\n").some((line) => line.trim() === `[submodule "${submodulePath(alias)}"]`);
+}
+__name(currentGitmodulesHasSameAliasSection, "currentGitmodulesHasSameAliasSection");
+function insertGitmodulesSection(repoRoot, alias, section) {
+  const gitmodules = join7(repoRoot, ".gitmodules");
+  const existing = existsSync8(gitmodules) ? readFileSync4(gitmodules, "utf8") : "";
+  const followingHeaders = headFollowingGitmodulesHeaders(repoRoot, alias);
+  const lines = existing.split("\n");
+  for (const followingHeader of followingHeaders) {
+    const insertAt = lines.findIndex((line) => line.trim() === followingHeader);
+    if (insertAt !== -1) {
+      lines.splice(insertAt, 0, ...section.replace(/\n$/, "").split("\n"));
+      writeFileSync4(gitmodules, lines.join("\n"));
+      return;
+    }
+  }
+  const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+  writeFileSync4(gitmodules, `${existing}${separator}${section}`);
+}
+__name(insertGitmodulesSection, "insertGitmodulesSection");
+function gitmoduleValue(repoRoot, alias, key) {
+  const r = runGit(repoRoot, ["config", "--file", ".gitmodules", "--get", `submodule.${submodulePath(alias)}.${key}`]);
+  const value = r.stdout.trim();
+  return r.success && value.length > 0 ? value : null;
+}
+__name(gitmoduleValue, "gitmoduleValue");
+function reconcileGitmodulesMetadata(repoRoot, repo) {
+  const path = submodulePath(repo.alias);
+  let changed = false;
+  if (gitmoduleValue(repoRoot, repo.alias, "url") !== repo.remotes.origin) {
+    runGit(repoRoot, ["config", "--file", ".gitmodules", `submodule.${path}.url`, repo.remotes.origin]);
+    changed = true;
+  }
+  const currentBranchValue = gitmoduleValue(repoRoot, repo.alias, "branch");
+  if (repo.branch) {
+    if (currentBranchValue !== repo.branch) {
+      runGit(repoRoot, ["config", "--file", ".gitmodules", `submodule.${path}.branch`, repo.branch]);
+      changed = true;
+    }
+  } else if (currentBranchValue !== null) {
+    runGit(repoRoot, ["config", "--file", ".gitmodules", "--unset", `submodule.${path}.branch`]);
+    changed = true;
+  }
+  return changed;
+}
+__name(reconcileGitmodulesMetadata, "reconcileGitmodulesMetadata");
+function cleanupRestorableAliasDir(repoRoot, alias) {
+  if (submoduleInitialized(repoRoot, alias)) return "ok";
+  const dirState = readAliasDirEntries(repoRoot, alias);
+  if (!dirState.exists) return "ok";
+  if (dirState.kind === "unreadable") return "unreadable";
+  if (dirState.kind === "file") return "occupied";
+  const entries = dirState.entries;
+  if (entries.length > 0 && entries.some((entry) => entry !== ".DS_Store")) return "occupied";
+  try {
+    rmSync2(aliasDir(repoRoot, alias), { recursive: true, force: true });
+  } catch {
+    return "unremovable";
+  }
+  return "ok";
+}
+__name(cleanupRestorableAliasDir, "cleanupRestorableAliasDir");
+function restorePendingRemoval(repo, repoRoot) {
+  const alias = repo.alias;
+  const path = submodulePath(alias);
+  const state = gitlinkState(repoRoot, alias);
+  const shouldRestore = state.headOid !== null && (pendingRemovalTopology(state) || partialRemovalTopology(state));
+  if (!shouldRestore) return { result: "failed", restored: false };
+  const unsafe = /* @__PURE__ */ __name((detail) => {
+    R2.error(`${alias}: cannot restore pending removal safely (${detail}). Resolve or commit the pending removal before syncing.`);
+    return { result: "failed", restored: true };
+  }, "unsafe");
+  if (state.conflict) return unsafe("root gitlink is conflicted");
+  const rootOp = gitOperationInProgress(repoRoot);
+  if (rootOp) return unsafe(`root repository has a ${rootOp} in progress`);
+  if (currentGitmodulesHasSameAliasSection(repoRoot, alias) && !state.gitmodulesEntry) {
+    return unsafe("current .gitmodules has an incomplete same-alias section");
+  }
+  const section = headGitmodulesSection(repoRoot, alias);
+  if (!section) return unsafe(".gitmodules metadata is not recoverable from HEAD");
+  const cleanup = cleanupRestorableAliasDir(repoRoot, alias);
+  if (cleanup === "unreadable") return unsafe(`${path} could not be read (permission or I/O error)`);
+  if (cleanup === "unremovable") return unsafe(`${path} could not be removed (permission or I/O error)`);
+  if (cleanup === "occupied") return unsafe(`${path} is occupied by a non-submodule path`);
+  runGit(repoRoot, ["restore", "--source=HEAD", "--staged", "--", ".gitmodules"]);
+  if (!state.gitmodulesEntry) insertGitmodulesSection(repoRoot, alias, section);
+  const metadataUpdated = reconcileGitmodulesMetadata(repoRoot, repo);
+  const restorePath = runGit(repoRoot, ["restore", "--source=HEAD", "--staged", "--worktree", "--", path], true);
+  if (!restorePath.success) return unsafe(`failed to restore ${path} from HEAD`);
+  runGit(repoRoot, ["submodule", "sync", "--", path]);
+  R2.step(`${alias}: git submodule update --init ${path}`);
+  const upd = runGit(repoRoot, ["submodule", "update", "--init", "--", path], true);
+  if (!upd.success) {
+    R2.error(`${alias}: git submodule update --init failed (exit ${upd.exitCode})`);
+    return { result: "failed", restored: true };
+  }
+  ensureRemotes(repoRoot, alias, repo.remotes);
+  const branch = gitmodulesBranch(repoRoot, alias) ?? repo.branch;
+  if (branch) attachBranch(repoRoot, alias, branch);
+  R2.success(`${alias}: restored pending removal${metadataUpdated ? " and updated .gitmodules metadata" : ""}`);
+  return { result: "added", restored: true };
+}
+__name(restorePendingRemoval, "restorePendingRemoval");
 function syncRepo(repo, repoRoot) {
   const alias = repo.alias;
   const path = submodulePath(alias);
   const registered = isRegisteredSubmodule(repoRoot, path);
+  const state = gitlinkState(repoRoot, alias);
+  if (!registered && state.headOid !== null) {
+    const restore = restorePendingRemoval(repo, repoRoot);
+    if (restore.restored) return restore.result;
+  }
   if (!registered) {
-    if (existsSync8(aliasDir(repoRoot, alias)) && readdirSync(aliasDir(repoRoot, alias)).length > 0) {
+    const dirState = readAliasDirEntries(repoRoot, alias);
+    if (dirState.exists && dirState.kind === "unreadable") {
+      R2.error(`${alias}: ${unreadablePathReason(alias)}`);
+      return "failed";
+    }
+    if (dirState.exists && (dirState.kind === "file" || dirState.entries.length > 0)) {
       R2.error(
         `${alias}: ${path}/ already exists but is not a registered submodule. Move or remove it manually, then retry.`
       );
@@ -15861,6 +16056,11 @@ function unsyncRepo(repo, repoRoot, force) {
   const registered = isRegisteredSubmodule(repoRoot, path);
   const exists = existsSync8(aliasDir(repoRoot, alias));
   if (!registered && !exists) return "nothing-to-remove";
+  const safety = assertRootTopologySafe(repoRoot, alias);
+  if (!safety.safe) {
+    R2.error(`${alias}: ${safety.reason}`);
+    return "failed";
+  }
   if (!force && submoduleInitialized(repoRoot, alias) && isDirty(aliasDir(repoRoot, alias))) {
     R2.error(
       `${alias}: ${path} has uncommitted or untracked changes. Commit, stash, remove them, or pass --force.`
@@ -15881,7 +16081,7 @@ function unsyncRepo(repo, repoRoot, force) {
   }
   try {
     const modulesParent = join7(repoRoot, ".git", "modules", DATA_DIRNAME);
-    if (existsSync8(modulesParent) && readdirSync(modulesParent).length === 0) rmdirSync(modulesParent);
+    if (existsSync8(modulesParent) && readdirSync2(modulesParent).length === 0) rmdirSync(modulesParent);
   } catch {
   }
   if (existsSync8(aliasDir(repoRoot, alias))) {
@@ -15889,7 +16089,7 @@ function unsyncRepo(repo, repoRoot, force) {
   }
   try {
     const parent = join7(repoRoot, DATA_DIRNAME);
-    if (existsSync8(parent) && readdirSync(parent).length === 0) rmdirSync(parent);
+    if (existsSync8(parent) && readdirSync2(parent).length === 0) rmdirSync(parent);
   } catch {
   }
   const gitmodules = join7(repoRoot, ".gitmodules");
@@ -16088,9 +16288,7 @@ async function runUnsync(aliases, options) {
   if (results.length > 1 || options.all) printSummary(results);
   const failed = picked.filter((_, i) => results[i] === "failed").map((r) => r.alias);
   if (failed.length > 0) {
-    R2.error(
-      `Not unsynced: ${failed.join(", ")}. The submodule had uncommitted or untracked changes \u2014 commit/stash/remove them, or re-run with --force.`
-    );
+    R2.error(`Not unsynced: ${failed.join(", ")}. See the per-alias error above for each.`);
   }
   return exitFromResults(results) || topoExit;
 }
@@ -16249,6 +16447,12 @@ function compareVersions(currentVersion, latestVersion) {
   return import_semver.default.compare(current, latest);
 }
 __name(compareVersions, "compareVersions");
+function isPrereleaseVersion(version) {
+  const parsed = import_semver.default.valid(version);
+  if (!parsed) throw new Error(`Installed version is not valid semver: ${version}`);
+  return import_semver.default.prerelease(parsed) !== null;
+}
+__name(isPrereleaseVersion, "isPrereleaseVersion");
 function printUpdateHeader(currentVersion, latestVersion) {
   R2.info(`Current version: ${currentVersion}`);
   R2.info(`Latest version: ${latestVersion}`);
@@ -16266,6 +16470,36 @@ function printGuidance(context) {
   for (const command of context.guidance) R2.message(`  ${command}`);
 }
 __name(printGuidance, "printGuidance");
+function channelInstallCommand(manager, tag) {
+  if (manager === "npm") return `npm install -g ${PACKAGE_NAME}@${tag}`;
+  if (manager === "pnpm") return `pnpm add -g ${PACKAGE_NAME}@${tag}`;
+  if (manager === "yarn") return `yarn global add ${PACKAGE_NAME}@${tag}`;
+  return `bun add -g ${PACKAGE_NAME}@${tag}`;
+}
+__name(channelInstallCommand, "channelInstallCommand");
+function prereleaseGuidanceManager(context) {
+  return context.manager ?? context.updateCommand?.executable ?? null;
+}
+__name(prereleaseGuidanceManager, "prereleaseGuidanceManager");
+function printPrereleaseGuidance(context) {
+  const manager = prereleaseGuidanceManager(context);
+  R2.info("Prerelease channel guidance:");
+  if (manager) {
+    R2.message(`  Stay on beta manually: ${channelInstallCommand(manager, "beta")}`);
+    R2.message(`  Return to stable: ${channelInstallCommand(manager, "latest")}`);
+    return;
+  }
+  for (const fallbackManager of ["npm", "pnpm", "yarn", "bun"]) {
+    R2.message(`  ${fallbackManager} beta: ${channelInstallCommand(fallbackManager, "beta")}`);
+    R2.message(`  ${fallbackManager} stable: ${channelInstallCommand(fallbackManager, "latest")}`);
+  }
+}
+__name(printPrereleaseGuidance, "printPrereleaseGuidance");
+function printPrereleaseStatus(currentVersion, latestVersion) {
+  R2.info(`Installed prerelease version: ${currentVersion}`);
+  R2.info(`Stable latest version: ${latestVersion}`);
+}
+__name(printPrereleaseStatus, "printPrereleaseStatus");
 function commandAvailability(command) {
   const mocked = testEnv("OMS_TEST_MANAGER_AVAILABLE");
   if (mocked !== void 0) return mocked === "1" || mocked === "true";
@@ -16324,12 +16558,16 @@ async function runUpdate(options) {
   try {
     latestVersion = await fetchLatestPackageVersion();
     const comparison = compareVersions(currentVersion, latestVersion);
+    const prerelease2 = isPrereleaseVersion(currentVersion);
     printUpdateHeader(currentVersion, latestVersion);
+    if (prerelease2) printPrereleaseStatus(currentVersion, latestVersion);
     if (comparison === 0) {
+      if (prerelease2) printPrereleaseGuidance(detectInstallContext());
       R2.success("oms is up to date.");
       return 0;
     }
     if (comparison > 0) {
+      if (prerelease2) printPrereleaseGuidance(detectInstallContext());
       R2.info("Installed version is newer than the npm registry latest; no downgrade will be performed.");
       return 0;
     }
@@ -16340,6 +16578,11 @@ async function runUpdate(options) {
   R2.warn("Update available.");
   const context = detectInstallContext();
   printInstallContext(context);
+  const prerelease = isPrereleaseVersion(currentVersion);
+  if (prerelease) {
+    R2.info("Selected update channel: stable latest (oh-my-space@latest).");
+    printPrereleaseGuidance(context);
+  }
   if (options.check) {
     if (!context.updateCommand) printGuidance(context);
     return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-space",
-  "version": "0.11.3",
+  "version": "0.11.5",
   "description": "Manage multi-repo workspaces with Git submodules.",
   "license": "MIT",
   "homepage": "https://github.com/divlook/oh-my-space",
@@ -13,9 +13,18 @@
   },
   "keywords": [
     "oms",
-    "submodule",
+    "oh-my-space",
     "git",
-    "cli"
+    "cli",
+    "git-submodule",
+    "submodule",
+    "workspace",
+    "multi-repo",
+    "monorepo",
+    "repository-management",
+    "developer-tools",
+    "ai",
+    "agent"
   ],
   "author": {
     "name": "divlook",
@@ -40,7 +49,8 @@
     "prepack": "npm test",
     "changeset": "changeset",
     "version": "changeset version",
-    "release": "changeset publish"
+    "release": "changeset publish",
+    "release:beta": "node scripts/publish-beta.mjs"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.7.0",