oh-my-space 0.7.0 → 0.7.1

package/dist/build-info.json

@@ -1 +1 @@
-{"commit":"23dd80c9eef2a1ba62b193a9497f564dbe116739"}
+{"commit":"b3b6890088ebe3eb5dd965d2fdd730a60b5a0a01"}

package/dist/oms.js

@@ -238,10 +238,10 @@ function submodulePath(alias) {
 function isGitRepo(repoRoot) {
     return runGit(repoRoot, ["rev-parse", "--is-inside-work-tree"]).stdout.trim() === "true";
 }
-/** True when .gitmodules registers a submodule at the given path (sources/<alias> or oms/<alias>). */
-function isRegisteredSubmodule(repoRoot, sourcePath) {
+/** Every submodule path registered in .gitmodules (empty when the file is absent or registers none). */
+function registeredSubmodulePaths(repoRoot) {
     if (!existsSync(join(repoRoot, ".gitmodules")))
-        return false;
+        return [];
     const result = runGit(repoRoot, [
         "config",
         "--file",
@@ -250,10 +250,19 @@ function isRegisteredSubmodule(repoRoot, sourcePath) {
         "^submodule\\..*\\.path$",
     ]);
     if (!result.success)
-        return false;
+        return [];
     return result.stdout
         .split("\n")
-        .some((line) => line.trim().split(/\s+/)[1] === sourcePath);
+        .map((line) => line.trim().split(/\s+/)[1])
+        .filter((p) => Boolean(p));
+}
+/** True when .gitmodules registers a submodule at the given path (sources/<alias> or oms/<alias>). */
+function isRegisteredSubmodule(repoRoot, sourcePath) {
+    return registeredSubmodulePaths(repoRoot).includes(sourcePath);
+}
+/** True when .gitmodules still registers at least one submodule. */
+function hasRegisteredSubmodules(repoRoot) {
+    return registeredSubmodulePaths(repoRoot).length > 0;
 }
 /** A submodule is initialized when its working tree has a .git gitlink file/dir. */
 function submoduleInitialized(repoRoot, alias) {
@@ -512,22 +521,34 @@ function unsyncRepo(repo, repoRoot, force) {
     if (!registered && !exists)
         return "nothing-to-remove";
     if (!force && submoduleInitialized(repoRoot, alias) && isDirty(aliasDir(repoRoot, alias))) {
-        log.error(`${alias}: ${path} has uncommitted changes. Commit, stash, or pass --force.`);
+        log.error(`${alias}: ${path} has uncommitted or untracked changes. Commit, stash, remove them, or pass --force.`);
         return "failed";
     }
     runGit(repoRoot, ["submodule", "deinit", ...(force ? ["-f"] : []), "--", path]);
     const rm = runGit(repoRoot, ["rm", "-f", "--", path], true);
     if (!rm.success) {
-        // Fall back to manual unregistration (e.g. the submodule was never initialized).
+        // git rm couldn't stage the removal (e.g. the submodule was never initialized).
         runGit(repoRoot, ["rm", "-f", "--cached", "--", path]);
-        runGit(repoRoot, ["config", "--file", ".gitmodules", "--remove-section", `submodule.${path}`]);
-        if (existsSync(join(repoRoot, ".gitmodules")))
-            runGit(repoRoot, ["add", ".gitmodules"]);
     }
+    // Always strip the registration explicitly: git rm's implicit .gitmodules edit is unreliable
+    // across git versions/states, and when it silently no-ops the section is orphaned for good.
+    // A missing section just makes these exit non-zero — harmless, output stays captured.
+    runGit(repoRoot, ["config", "--file", ".gitmodules", "--remove-section", `submodule.${path}`]);
+    if (existsSync(join(repoRoot, ".gitmodules")))
+        runGit(repoRoot, ["add", ".gitmodules"]);
+    // Drop the matching .git/config section too, in case deinit was skipped or failed.
+    runGit(repoRoot, ["config", "--remove-section", `submodule.${path}`]);
     try {
         rmSync(join(repoRoot, ".git", "modules", DATA_DIRNAME, alias), { recursive: true, force: true });
     }
     catch { }
+    // Drop the now-empty .git/modules/oms/ container so no stale gitdir scaffolding lingers.
+    try {
+        const modulesParent = join(repoRoot, ".git", "modules", DATA_DIRNAME);
+        if (existsSync(modulesParent) && readdirSync(modulesParent).length === 0)
+            rmdirSync(modulesParent);
+    }
+    catch { }
     if (existsSync(aliasDir(repoRoot, alias))) {
         rmSync(aliasDir(repoRoot, alias), { recursive: true, force: true });
     }
@@ -538,9 +559,9 @@ function unsyncRepo(repo, repoRoot, force) {
             rmdirSync(parent);
     }
     catch { }
-    // Drop a .gitmodules that no longer registers any submodule (git rm leaves it empty).
+    // Drop .gitmodules once it no longer registers any submodule (judged by content, not byte-emptiness).
     const gitmodules = join(repoRoot, ".gitmodules");
-    if (existsSync(gitmodules) && readFileSync(gitmodules, "utf8").trim().length === 0) {
+    if (existsSync(gitmodules) && !hasRegisteredSubmodules(repoRoot)) {
         if (!runGit(repoRoot, ["rm", "-f", "--", ".gitmodules"]).success) {
             rmSync(gitmodules, { force: true });
         }
@@ -764,6 +785,11 @@ async function runUnsync(aliases, options) {
     });
     if (results.length > 1 || options.all)
         printSummary(results);
+    // Name the failed aliases so a buried failure among several isn't read as "all unsynced".
+    const failed = picked.filter((_, i) => results[i] === "failed").map((r) => r.alias);
+    if (failed.length > 0) {
+        log.error(`Not unsynced: ${failed.join(", ")}. The submodule had uncommitted or untracked changes — commit/stash/remove them, or re-run with --force.`);
+    }
     return exitFromResults(results);
 }
 async function runCheckout(alias, branch, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-space",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "CLI for managing external source repositories declared in oms.yaml.",
   "license": "MIT",
   "homepage": "https://github.com/divlook/oh-my-space",