oh-my-space 0.11.3 → 0.11.4

package/dist/build-info.json

@@ -1 +1 @@
-{"commit":"1c33003a35ff5de34f10fe4341a38338fa927f95"}
+{"commit":"60bbfdfcc5f72dce2b2b74508715ddbc723aa3ff"}

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";
 }
@@ -15764,7 +15766,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, lstatSync, readFileSync as readFileSync4, readdirSync, 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 +15784,167 @@ 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 readAliasDirEntries(repoRoot, alias) {
+  const dir = aliasDir(repoRoot, alias);
+  try {
+    if (!lstatSync(dir).isDirectory()) return { exists: true, entries: null };
+    return { exists: true, entries: readdirSync(dir) };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return { exists: false };
+    }
+    return { exists: true, entries: null };
+  }
+}
+__name(readAliasDirEntries, "readAliasDirEntries");
+function cleanupRestorableAliasDir(repoRoot, alias) {
+  if (submoduleInitialized(repoRoot, alias)) return true;
+  const dirState = readAliasDirEntries(repoRoot, alias);
+  if (!dirState.exists) return true;
+  if (dirState.entries === null) return false;
+  const entries = dirState.entries;
+  if (entries.length > 0 && entries.some((entry) => entry !== ".DS_Store")) return false;
+  try {
+    rmSync2(aliasDir(repoRoot, alias), { recursive: true, force: true });
+  } catch {
+    return false;
+  }
+  return true;
+}
+__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");
+  if (!cleanupRestorableAliasDir(repoRoot, alias)) {
+    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.entries === null || dirState.entries.length > 0)) {
       R2.error(
         `${alias}: ${path}/ already exists but is not a registered submodule. Move or remove it manually, then retry.`
       );
@@ -16249,6 +16406,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 +16429,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 +16517,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 +16537,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.4",
   "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",