oh-my-space 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 divlook
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# oh-my-space
+
+`oh-my-space` provides the `oms` CLI for managing external source repositories declared in `sources.yaml`. It syncs those entries into Git submodules under `sources/<alias>/` and runs safe fetch/pull/push operations inside selected source worktrees.
+
+Package name: `oh-my-space`
+
+Command name: `oms`
+
+## Requirements
+
+- [Node.js](https://nodejs.org) `>=20.19.0` for running `oms`; development uses the version in `.nvmrc` (`24`)
+- git
+
+For local development:
+
+```bash
+nvm use
+npm ci
+npm test
+```
+
+## Install
+
+Install globally with your package manager of choice:
+
+```bash
+npm install -g oh-my-space
+pnpm add -g oh-my-space
+yarn global add oh-my-space
+bun install -g oh-my-space
+```
+
+## Quick start
+
+Create a `sources.yaml` in your project root:
+
+```yaml
+repos:
+  - alias: api
+    url: git@github.com:example/api.git
+    branch: main
+  - alias: web
+    url: git@github.com:example/web.git
+```
+
+List, sync, and unsync registered source repositories:
+
+```bash
+oms doctor              # check sources.yaml and git availability
+oms sync --list         # list registered source repos
+oms sync <alias>...     # add/init/update submodules by alias
+oms sync --all          # add/init/update every registered source repo
+oms sync                # interactive multi-select
+oms unsync <alias>...   # remove submodule + worktree (sources.yaml entry kept)
+oms unsync --all        # unsync every registered source repo
+oms unsync --force ...  # discard uncommitted changes in the source worktree
+```
+
+## Managing source repositories
+
+`sources.yaml` declares each source repo with `alias`, `url`, and optional `branch`. Checkouts live as Git submodules under `sources/<alias>/`.
+
+| Command | Runs in | Does | Notes |
+| --- | --- | --- | --- |
+| `oms doctor` | project root or child path | Validates `sources.yaml` and checks `git --version`. | Fails when `sources.yaml` is missing or invalid. |
+| `oms sync <alias>` / `--all` | workspace root | Adds missing submodules and initializes/updates registered ones. | Syncs `sources.yaml` to `sources/<alias>/`. |
+| `oms unsync <alias>` / `--all` | workspace root | Deinits the submodule and removes `sources/<alias>/` (leaves the staged change to commit). | Keeps the entry in `sources.yaml`; pass `--force` to discard uncommitted changes in the worktree. |
+| `oms fetch ...` | selected checked-out submodule worktree | `git fetch --all --prune` | Does not change the superproject gitlink. |
+| `oms pull ...` | selected checked-out submodule worktree | `git pull --ff-only` | Requires a branch with upstream; detached HEAD/no-upstream states fail. |
+| `oms push <alias>...` | explicitly selected checked-out submodule worktree | `git push` | No `--all`, force push, or automatic upstream setup. |
+
+To add a repo, add it under `repos:` in `sources.yaml`, run `oms sync <alias>`, then commit `sources.yaml`, `.gitmodules`, and the gitlink change.
+
+Standard Git submodule commands still work, for example:
+
+```bash
+git submodule update --init --recursive
+```
+
+## `sources.yaml` format
+
+```yaml
+repos:
+  - alias: service-a
+    url: git@github.com:example/service-a.git
+    branch: main
+  - alias: docs
+    url: https://github.com/example/docs.git
+```
+
+Rules:
+
+- `repos` must be a non-empty array.
+- `alias` must be unique and match `/^[a-z0-9][a-z0-9-]*$/`.
+- `url` is required.
+- `branch` is optional and is passed to `git submodule add --branch` only when adding a new submodule.
+
+## Release and versioning
+
+`oh-my-space` uses SemVer:
+
+- Patch: bug fixes and documentation changes.
+- Minor: new commands/options or backward-compatible behavior additions.
+- Major: removed/renamed CLI behavior, incompatible `sources.yaml` semantics, or a higher required runtime.
+
+GitHub Releases are the user-facing release notes. `CHANGELOG.md` is auto-generated by Changesets and committed by the release workflow; do not edit it manually.
+
+Publishing is automated from `main` through Changesets. Feature branches and pull requests run tests on Node.js `20.19.0` and the `.nvmrc` development line (`24`), plus `npm pack --dry-run`; publish only happens through the release workflow after the release PR is merged. The release job builds and publishes on Node.js `20.19.0` so the package is verified against the minimum supported runtime.
+
+## License
+
+[MIT](./LICENSE)

package/dist/oms.js

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { cancel, isCancel, log, multiselect } from "@clack/prompts";
+import { parse as parseYaml } from "yaml";
+const ALIAS_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+const ALLOWED_TOP_KEYS = new Set(["repos"]);
+const ALLOWED_ITEM_KEYS = new Set(["alias", "url", "branch"]);
+const MANAGE_GIT_ARGS = {
+    fetch: ["fetch", "--all", "--prune"],
+    pull: ["pull", "--ff-only"],
+    push: ["-c", "push.autoSetupRemote=false", "push"],
+};
+const RESULT_BY_COMMAND = {
+    fetch: "fetched",
+    pull: "pulled",
+    push: "pushed",
+};
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const useColor = process.stdout.isTTY;
+const dim = (s) => (useColor ? `\x1b[2m${s}\x1b[0m` : s);
+function validateSources(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+        throw new Error("sources.yaml: root must be a mapping");
+    }
+    const obj = data;
+    for (const key of Object.keys(obj)) {
+        if (!ALLOWED_TOP_KEYS.has(key)) {
+            throw new Error(`sources.yaml: unknown top-level key "${key}"`);
+        }
+    }
+    const { repos } = obj;
+    if (!Array.isArray(repos)) {
+        throw new Error('sources.yaml: "repos" must be an array');
+    }
+    if (repos.length === 0) {
+        throw new Error('sources.yaml: "repos" must have at least one item');
+    }
+    const validated = [];
+    const seen = new Set();
+    repos.forEach((item, idx) => {
+        const where = `repos[${idx}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw new Error(`sources.yaml: ${where} must be a mapping`);
+        }
+        const r = item;
+        for (const key of Object.keys(r)) {
+            if (!ALLOWED_ITEM_KEYS.has(key)) {
+                throw new Error(`sources.yaml: ${where} has unknown key "${key}"`);
+            }
+        }
+        if (typeof r.alias !== "string" || r.alias.length === 0) {
+            throw new Error(`sources.yaml: ${where} missing required "alias"`);
+        }
+        if (!ALIAS_PATTERN.test(r.alias)) {
+            throw new Error(`sources.yaml: ${where}.alias "${r.alias}" must match ${ALIAS_PATTERN}`);
+        }
+        if (seen.has(r.alias)) {
+            throw new Error(`sources.yaml: duplicate alias "${r.alias}"`);
+        }
+        seen.add(r.alias);
+        if (typeof r.url !== "string" || r.url.length === 0) {
+            throw new Error(`sources.yaml: ${where} missing required "url"`);
+        }
+        let branch;
+        if (r.branch !== undefined) {
+            if (typeof r.branch !== "string" || r.branch.length === 0) {
+                throw new Error(`sources.yaml: ${where}.branch must be a non-empty string`);
+            }
+            branch = r.branch;
+        }
+        validated.push({ alias: r.alias, url: r.url, branch });
+    });
+    return validated;
+}
+function pad(s, width) {
+    return s + " ".repeat(Math.max(0, width - s.length));
+}
+function printList(repos) {
+    const aliasW = Math.max("ALIAS".length, ...repos.map((r) => r.alias.length));
+    const urlW = Math.max("URL".length, ...repos.map((r) => r.url.length));
+    console.log(dim(`${pad("ALIAS", aliasW)}  ${pad("URL", urlW)}  BRANCH`));
+    for (const r of repos) {
+        console.log(`${pad(r.alias, aliasW)}  ${pad(r.url, urlW)}  ${r.branch ?? ""}`);
+    }
+}
+async function selectInteractive(repos, actionLabel) {
+    const choice = await multiselect({
+        message: `Select source repos to ${actionLabel} (space to toggle, enter to confirm)`,
+        options: repos.map((r) => ({
+            value: r.alias,
+            label: r.alias,
+            hint: r.branch ? `branch: ${r.branch}` : undefined,
+        })),
+        required: true,
+    });
+    if (isCancel(choice)) {
+        cancel("Cancelled.");
+        return null;
+    }
+    return choice
+        .map((alias) => repos.find((r) => r.alias === alias))
+        .filter((r) => r !== undefined);
+}
+function runGit(cwd, args, inheritOutput = false) {
+    const result = spawnSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: inheritOutput ? "inherit" : ["ignore", "pipe", "pipe"],
+    });
+    return {
+        exitCode: result.status,
+        success: result.status === 0,
+        stdout: inheritOutput ? "" : (result.stdout ?? ""),
+    };
+}
+function findWorkspaceRoot(options = {}) {
+    let current = resolve(options.cwd ?? process.cwd());
+    while (true) {
+        if (existsSync(join(current, "sources.yaml")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function isRegisteredSubmodule(repoRoot, sourcePath) {
+    if (!existsSync(join(repoRoot, ".gitmodules")))
+        return false;
+    const result = runGit(repoRoot, [
+        "config",
+        "--file",
+        ".gitmodules",
+        "--get-regexp",
+        "^submodule\\..*\\.path$",
+    ]);
+    if (!result.success)
+        return false;
+    return result.stdout
+        .split("\n")
+        .some((line) => line.trim().split(/\s+/)[1] === sourcePath);
+}
+function isCheckedOutGitRepo(repoRoot, sourcePath) {
+    const dest = join(repoRoot, sourcePath);
+    if (!existsSync(dest))
+        return false;
+    const result = runGit(dest, ["rev-parse", "--is-inside-work-tree"]);
+    return result.success && result.stdout.trim() === "true";
+}
+function removeSubmoduleArtifacts(repo, repoRoot, options = {}) {
+    const sourcePath = `sources/${repo.alias}`;
+    const dest = join(repoRoot, sourcePath);
+    const modulesDir = join(repoRoot, ".git", "modules", repo.alias);
+    const registered = isRegisteredSubmodule(repoRoot, sourcePath);
+    const worktreeExists = existsSync(dest);
+    const worktreeIsGitRepo = worktreeExists && isCheckedOutGitRepo(repoRoot, sourcePath);
+    const moduleDirExists = existsSync(modulesDir);
+    if (!registered && !worktreeExists && !moduleDirExists) {
+        return "nothing-to-remove";
+    }
+    if (worktreeExists && !registered && !moduleDirExists && !worktreeIsGitRepo) {
+        log.error(`${repo.alias}: ${sourcePath} exists but is not a git submodule. Remove it manually if intended.`);
+        return "failed";
+    }
+    if (!options.force && worktreeIsGitRepo) {
+        const status = runGit(dest, ["status", "--porcelain"]);
+        if (status.success && status.stdout.trim().length > 0) {
+            log.error(`${repo.alias}: ${sourcePath} has uncommitted changes. Commit or stash them, or pass --force to discard.`);
+            return "failed";
+        }
+    }
+    let didSomething = false;
+    if (registered) {
+        const deinit = runGit(repoRoot, ["submodule", "deinit", "-f", sourcePath]);
+        if (!deinit.success) {
+            log.error(`${repo.alias}: git submodule deinit failed (exit ${deinit.exitCode}) for ${sourcePath}`);
+            return "failed";
+        }
+        didSomething = true;
+    }
+    if (registered || worktreeIsGitRepo) {
+        const rm = runGit(repoRoot, ["rm", "-f", sourcePath]);
+        if (!rm.success) {
+            log.error(`${repo.alias}: git rm failed (exit ${rm.exitCode}) for ${sourcePath}`);
+            return "failed";
+        }
+        didSomething = true;
+    }
+    runGit(repoRoot, [
+        "config",
+        "--file",
+        ".gitmodules",
+        "--remove-section",
+        `submodule.${repo.alias}`,
+    ]);
+    if (moduleDirExists) {
+        rmSync(modulesDir, { recursive: true, force: true });
+        didSomething = true;
+    }
+    return didSomething ? "removed" : "nothing-to-remove";
+}
+function syncSubmodule(repo, repoRoot) {
+    const sourcePath = `sources/${repo.alias}`;
+    const dest = join(repoRoot, sourcePath);
+    const registered = isRegisteredSubmodule(repoRoot, sourcePath);
+    if (!registered && existsSync(dest)) {
+        log.error(`${repo.alias}: ${sourcePath} already exists but is not registered as a git submodule. Move or remove it manually, then retry.`);
+        return "failed";
+    }
+    if (!registered && repo.branch) {
+        const lsRemote = runGit(repoRoot, [
+            "ls-remote",
+            "--exit-code",
+            "--heads",
+            repo.url,
+            repo.branch,
+        ]);
+        if (lsRemote.exitCode === 2) {
+            log.error(`${repo.alias}: branch "${repo.branch}" not found on ${repo.url}. Push the branch upstream or fix the alias, then retry.`);
+            return "failed";
+        }
+        if (!lsRemote.success && lsRemote.exitCode !== 2) {
+            log.warn(`${repo.alias}: branch existence check failed (exit ${lsRemote.exitCode}); proceeding with submodule add.`);
+        }
+    }
+    const args = registered
+        ? ["submodule", "update", "--init", "--recursive", sourcePath]
+        : [
+            "submodule",
+            "add",
+            "--name",
+            repo.alias,
+            ...(repo.branch ? ["--branch", repo.branch] : []),
+            repo.url,
+            sourcePath,
+        ];
+    log.step(`git ${args.join(" ")}`);
+    const result = runGit(repoRoot, args, true);
+    if (result.success) {
+        log.success(`${repo.alias}: ${registered ? "updated" : "added"}`);
+        return registered ? "updated" : "added";
+    }
+    log.error(`${repo.alias}: submodule ${registered ? "update" : "add"} failed (exit ${result.exitCode})`);
+    if (!registered) {
+        const cleanup = removeSubmoduleArtifacts(repo, repoRoot, { force: true });
+        if (cleanup === "removed") {
+            log.info(`${repo.alias}: cleaned up partial submodule state. Retry once the upstream issue is resolved.`);
+        }
+    }
+    return "failed";
+}
+function manageSubmodule(repo, repoRoot, command) {
+    const sourcePath = `sources/${repo.alias}`;
+    if (!isRegisteredSubmodule(repoRoot, sourcePath) || !isCheckedOutGitRepo(repoRoot, sourcePath)) {
+        log.error(`${repo.alias}: ${sourcePath} is not a checked-out source submodule. Run "oms sync ${repo.alias}" first.`);
+        return "failed";
+    }
+    const sourceWorktree = join(repoRoot, sourcePath);
+    if (command === "push") {
+        const upstream = runGit(sourceWorktree, [
+            "rev-parse",
+            "--abbrev-ref",
+            "--symbolic-full-name",
+            "@{u}",
+        ]);
+        if (!upstream.success) {
+            log.error(`${repo.alias}: git push requires the current branch to have an upstream. Set it manually before pushing.`);
+            return "failed";
+        }
+    }
+    const args = MANAGE_GIT_ARGS[command];
+    log.step(`${repo.alias}: git ${args.join(" ")}`);
+    const result = runGit(sourceWorktree, args, true);
+    if (result.success) {
+        const operation = RESULT_BY_COMMAND[command];
+        log.success(`${repo.alias}: ${operation}`);
+        return operation;
+    }
+    log.error(`${repo.alias}: git ${command} failed (exit ${result.exitCode})`);
+    return "failed";
+}
+function printSummary(results) {
+    const counts = {
+        added: 0,
+        updated: 0,
+        fetched: 0,
+        pulled: 0,
+        pushed: 0,
+        unsynced: 0,
+        failed: 0,
+    };
+    for (const r of results)
+        counts[r]++;
+    const parts = Object.entries(counts)
+        .filter(([, count]) => count > 0)
+        .map(([name, count]) => `${name} ${count}`);
+    log.message(`Summary: ${parts.join(", ")}`);
+}
+function exitFromResults(results) {
+    return results.includes("failed") ? 2 : 0;
+}
+function loadRepos(options = {}) {
+    const repoRoot = findWorkspaceRoot(options);
+    if (!repoRoot) {
+        log.error("Could not find sources.yaml in the current directory or its parents. Create a sources.yaml in this project, then retry.");
+        return null;
+    }
+    try {
+        const sourcesPath = join(repoRoot, "sources.yaml");
+        return { repos: validateSources(parseYaml(readFileSync(sourcesPath, "utf8"))), repoRoot };
+    }
+    catch (e) {
+        log.error(e instanceof Error ? e.message : String(e));
+        return null;
+    }
+}
+function uniqueAliases(aliases) {
+    const seen = new Set();
+    return aliases.filter((alias) => {
+        if (seen.has(alias))
+            return false;
+        seen.add(alias);
+        return true;
+    });
+}
+async function selectRepos(repos, aliases, options, actionLabel) {
+    if (options.all)
+        return repos;
+    if (aliases.length === 0) {
+        return selectInteractive(repos, actionLabel);
+    }
+    const unknown = aliases.filter((a) => !repos.some((r) => r.alias === a));
+    if (unknown.length > 0) {
+        log.error(`Unknown alias(es): ${unknown.join(", ")}. Use "oms sync --list" to see available aliases.`);
+        return null;
+    }
+    const byAlias = new Map(repos.map((repo) => [repo.alias, repo]));
+    return uniqueAliases(aliases).map((alias) => byAlias.get(alias));
+}
+async function runSync(aliases, options) {
+    const loaded = loadRepos();
+    if (!loaded)
+        return 1;
+    const { repos, repoRoot } = loaded;
+    if (options.list) {
+        printList(repos);
+        return 0;
+    }
+    const picked = await selectRepos(repos, aliases, options, "sync");
+    if (!picked || picked.length === 0)
+        return 1;
+    const results = picked.map((repo) => syncSubmodule(repo, repoRoot));
+    if (results.length > 1 || options.all)
+        printSummary(results);
+    return exitFromResults(results);
+}
+async function runManage(command, aliases, options) {
+    const loaded = loadRepos();
+    if (!loaded)
+        return 1;
+    const { repos, repoRoot } = loaded;
+    const picked = await selectRepos(repos, aliases, options, command);
+    if (!picked || picked.length === 0)
+        return 1;
+    const results = picked.map((repo) => manageSubmodule(repo, repoRoot, command));
+    if (results.length > 1 || options.all)
+        printSummary(results);
+    return exitFromResults(results);
+}
+async function runUnsync(aliases, options) {
+    const loaded = loadRepos();
+    if (!loaded)
+        return 1;
+    const { repos, repoRoot } = loaded;
+    const picked = await selectRepos(repos, aliases, options, "unsync");
+    if (!picked || picked.length === 0)
+        return 1;
+    const results = picked.map((repo) => {
+        log.step(`${repo.alias}: unsync`);
+        const outcome = removeSubmoduleArtifacts(repo, repoRoot, { force: options.force });
+        if (outcome === "removed") {
+            log.success(`${repo.alias}: unsynced (commit staged changes in .gitmodules and sources/${repo.alias} to finalize)`);
+            return "unsynced";
+        }
+        if (outcome === "nothing-to-remove") {
+            log.info(`${repo.alias}: nothing to remove`);
+            return "unsynced";
+        }
+        return "failed";
+    });
+    if (results.length > 1 || options.all)
+        printSummary(results);
+    return exitFromResults(results);
+}
+async function runDoctor() {
+    const loaded = loadRepos();
+    if (!loaded)
+        return 1;
+    log.success(`Workspace root: ${loaded.repoRoot}`);
+    log.success(`sources.yaml: ${loaded.repos.length} repo(s) configured`);
+    const git = spawnSync("git", ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    if (git.status === 0) {
+        log.success(`git: ${git.stdout.trim()}`);
+        return 0;
+    }
+    log.error("git: not found");
+    return 1;
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return null;
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function readPackageVersion() {
+    const pkg = readJson(join(packageRoot, "package.json"));
+    return pkg?.version ?? "0.0.0";
+}
+async function exitWith(action) {
+    try {
+        process.exit(await action);
+    }
+    catch (e) {
+        log.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+    }
+}
+const exitHelp = "\nExit codes: 0 ok | 1 usage/config error | 2 one or more git operations failed.";
+const commandNames = new Set(["doctor", "sync", "fetch", "pull", "push", "unsync", "help"]);
+const program = new Command();
+program
+    .name("oms")
+    .description("Manage source repositories listed in sources.yaml under sources/<alias>/.")
+    .version(readPackageVersion())
+    .addHelpText("after", exitHelp);
+program
+    .command("doctor")
+    .description("Check sources.yaml configuration and git availability.")
+    .addHelpText("after", exitHelp)
+    .action(async () => {
+    await exitWith(runDoctor());
+});
+program
+    .command("sync")
+    .description("Sync sources.yaml entries into git submodules under sources/<alias>/.")
+    .argument("[aliases...]", "repo aliases to sync (omit for interactive multi-select)")
+    .option("--all", "sync every registered source repo")
+    .option("--list", "print registered repos")
+    .addHelpText("after", exitHelp)
+    .action(async (aliases, options) => {
+    await exitWith(runSync(aliases, options));
+});
+program
+    .command("fetch")
+    .description("Run git fetch --all --prune inside checked-out source submodule worktrees.")
+    .argument("[aliases...]", "repo aliases to fetch (omit for interactive multi-select)")
+    .option("--all", "fetch every registered source repo")
+    .addHelpText("after", exitHelp)
+    .action(async (aliases, options) => {
+    await exitWith(runManage("fetch", aliases, options));
+});
+program
+    .command("pull")
+    .description("Run git pull --ff-only inside checked-out source submodule worktrees; requires branch/upstream.")
+    .argument("[aliases...]", "repo aliases to pull (omit for interactive multi-select)")
+    .option("--all", "pull every registered source repo")
+    .addHelpText("after", exitHelp)
+    .action(async (aliases, options) => {
+    await exitWith(runManage("pull", aliases, options));
+});
+program
+    .command("push")
+    .description("Run git push inside explicit source submodule worktrees; no --all, force, or upstream setup.")
+    .argument("<aliases...>", "repo aliases to push")
+    .addHelpText("after", exitHelp)
+    .action(async (aliases) => {
+    await exitWith(runManage("push", aliases, {}));
+});
+program
+    .command("unsync")
+    .description("Remove submodule registration and worktree (keeps sources.yaml entry). Leaves staged changes in .gitmodules and the submodule path to commit.")
+    .argument("[aliases...]", "repo aliases to unsync (omit for interactive multi-select)")
+    .option("--all", "unsync every registered source repo")
+    .option("--force", "discard uncommitted changes in the source worktree")
+    .addHelpText("after", exitHelp)
+    .action(async (aliases, options) => {
+    await exitWith(runUnsync(aliases, options));
+});
+const requestedCommand = process.argv[2];
+if (requestedCommand && !requestedCommand.startsWith("-") && !commandNames.has(requestedCommand)) {
+    console.error(`error: unknown command '${requestedCommand}'`);
+    process.exit(1);
+}
+await program.parseAsync();

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "oh-my-space",
+  "version": "0.1.0",
+  "description": "CLI for managing external source repositories declared in sources.yaml.",
+  "license": "MIT",
+  "homepage": "https://github.com/divlook/oh-my-space",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/divlook/oh-my-space.git"
+  },
+  "bugs": {
+    "url": "https://github.com/divlook/oh-my-space/issues"
+  },
+  "keywords": [
+    "sources",
+    "submodule",
+    "git",
+    "cli"
+  ],
+  "author": {
+    "name": "divlook",
+    "email": "uihyeon.cha@gmail.com",
+    "url": "https://github.com/divlook"
+  },
+  "type": "module",
+  "bin": {
+    "oms": "dist/oms.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').chmodSync('dist/oms.js', 0o755)\"",
+    "test": "npm run build && node --test tests/*.test.js",
+    "prepack": "npm test",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "npm test && npm publish --provenance --access public"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.7.0",
+    "@changesets/cli": "^2.29.7",
+    "@types/node": "^20.19.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.4.0",
+    "commander": "^14.0.3",
+    "yaml": "^2.8.1"
+  }
+}