monopoly-repo 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Itay Mendelawy
+
+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,52 @@
+# monopoly-repo
+
+> Move code between git repos without losing history.
+
+A small CLI that extracts a file or directory from one git repo and stages it
+into another, carrying its full commit history along with it. Built on
+[`git-filter-repo`](https://github.com/newren/git-filter-repo).
+
+## Install
+
+```sh
+npm install -g monopoly-repo
+```
+
+Or run it on demand without installing:
+
+```sh
+npx monopoly-repo move <source> --to <repo> [--as <path>] [--dry-run]
+```
+
+The installed command is `monopoly`.
+
+## Usage
+
+```sh
+monopoly move <source> --to <repo> [--as <path>] [--dry-run]
+```
+
+### Examples
+
+```sh
+# Move a package from a monorepo to a dedicated repo
+monopoly move packages/auth --to ../auth-service --as auth
+
+# Move a dedicated repo back into a monorepo
+monopoly move auth --to ../my-monorepo --as packages/auth
+
+# Preview without making changes
+monopoly move src/utils/logger.ts --to ../shared --as logger.ts --dry-run
+```
+
+All changes are staged locally. Nothing is committed or pushed — you review
+`git status` in the target repo and commit when ready.
+
+## Requirements
+
+- Node.js >= 18
+- `git` and [`git-filter-repo`](https://github.com/newren/git-filter-repo) on your PATH
+
+## License
+
+MIT — see [LICENSE](./LICENSE). Learn more at [monopoly-repo.dev](https://monopoly-repo.dev).

package/dist/cli.js

@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+// src/args.ts
+import path from "path";
+function parseArgs(argv) {
+  if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
+    return { kind: "help" };
+  }
+  if (argv.includes("-v") || argv.includes("--version")) {
+    return { kind: "version" };
+  }
+  const command = argv[0];
+  if (command !== "move") {
+    throw usageError(`Unknown command: ${command}.`);
+  }
+  const rest = argv.slice(1);
+  let source;
+  let to;
+  let as;
+  let dryRun = false;
+  for (let i = 0;i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--to") {
+      to = takeValue("--to", rest, ++i);
+    } else if (arg === "--as") {
+      as = takeValue("--as", rest, ++i);
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg.startsWith("-")) {
+      throw usageError(`Unknown option: ${arg}.`);
+    } else if (!source) {
+      source = arg;
+    } else {
+      throw usageError(`Unexpected argument: ${arg}.`);
+    }
+  }
+  if (!source)
+    throw usageError("Missing <source> argument.");
+  if (!to)
+    throw usageError("Missing --to <repo> option.");
+  return {
+    kind: "move",
+    source,
+    to,
+    as: as ?? path.basename(source),
+    dryRun
+  };
+}
+function usageError(msg) {
+  return new Error(`${msg} Run monopoly --help for usage.`);
+}
+function takeValue(name, rest, i) {
+  const value = rest[i];
+  if (!value)
+    throw usageError(`${name} requires a value.`);
+  return value;
+}
+
+// src/validate.ts
+import fs2 from "fs";
+import path4 from "path";
+
+// src/git.ts
+import { spawnSync } from "child_process";
+import path2 from "path";
+function run(cmd, args, cwd) {
+  const result = spawnSync(cmd, args, {
+    cwd,
+    encoding: "utf-8",
+    maxBuffer: 50 * 1024 * 1024
+  });
+  return {
+    stdout: (result.stdout ?? "").trimEnd(),
+    stderr: (result.stderr ?? "").trimEnd(),
+    exitCode: result.status ?? 1,
+    success: result.status === 0
+  };
+}
+function toGitPath(p) {
+  return p.split(path2.sep).join("/");
+}
+function git(args, cwd) {
+  return run("git", args, cwd);
+}
+function requireSuccess(result, message) {
+  if (!result.success) {
+    throw new Error(`${message}: ${result.stderr}`);
+  }
+}
+function getGitVersion() {
+  const result = git(["--version"]);
+  if (!result.success)
+    throw new Error("git is not installed or not in PATH.");
+  return result.stdout.replace(/^git version\s+/, "").trim();
+}
+function parseGitVersion(version) {
+  const parts = version.split(".");
+  return [parseInt(parts[0] ?? "0", 10), parseInt(parts[1] ?? "0", 10)];
+}
+function isGitRepo(dir) {
+  return git(["rev-parse", "--git-dir"], dir).success;
+}
+function hasUncommittedChanges(dir) {
+  const status = git(["status", "--porcelain"], dir);
+  return status.success && status.stdout.length > 0;
+}
+function getCurrentBranch(dir) {
+  const result = git(["symbolic-ref", "--short", "HEAD"], dir);
+  if (result.success)
+    return result.stdout;
+  return git(["rev-parse", "--short", "HEAD"], dir).stdout;
+}
+function getHeadHash(dir) {
+  const result = git(["rev-parse", "HEAD"], dir);
+  return result.success ? result.stdout : "";
+}
+function countCommitsForPath(filePath, cwd) {
+  const result = git(["rev-list", "--count", "--full-history", "HEAD", "--", filePath], cwd);
+  return result.success ? parseInt(result.stdout, 10) : 0;
+}
+function countCommits(cwd) {
+  const result = git(["rev-list", "--count", "HEAD"], cwd);
+  return result.success ? parseInt(result.stdout, 10) : 0;
+}
+function hasAnyCommits(dir) {
+  return countCommits(dir) > 0;
+}
+function findRepoRoot(startPath) {
+  const result = git(["rev-parse", "--show-toplevel"], startPath);
+  return result.success ? result.stdout : null;
+}
+
+// src/filter-repo.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import fs from "fs";
+import os from "os";
+import path3 from "path";
+var FILTER_REPO_URL = "https://raw.githubusercontent.com/newren/git-filter-repo/main/git-filter-repo";
+var cachedCmd;
+function filterRepo(args, cwd) {
+  const resolved = resolveFilterRepo();
+  if (!resolved) {
+    return {
+      stdout: "",
+      stderr: "git-filter-repo not found and could not be auto-installed",
+      exitCode: 1,
+      success: false
+    };
+  }
+  return run(resolved.command, [...resolved.prefixArgs, ...args], cwd);
+}
+function isFilterRepoInstalled() {
+  return resolveFilterRepo() !== null;
+}
+function resolveFilterRepo() {
+  if (cachedCmd !== undefined)
+    return cachedCmd;
+  const existing = findFilterRepoOnDisk();
+  if (existing) {
+    cachedCmd = { command: existing, prefixArgs: [] };
+    return cachedCmd;
+  }
+  cachedCmd = provisionFilterRepo();
+  return cachedCmd;
+}
+function findFilterRepoOnDisk() {
+  const envPath = process.env.GIT_FILTER_REPO;
+  if (envPath && fs.existsSync(envPath))
+    return envPath;
+  const check = spawnSync2("git-filter-repo", ["--version"], {
+    stdio: "ignore",
+    timeout: 5000
+  });
+  if (check.status === 0)
+    return "git-filter-repo";
+  const home = os.homedir();
+  const candidates = [
+    path3.join(home, ".local", "bin", "git-filter-repo"),
+    "/usr/local/bin/git-filter-repo",
+    "/opt/homebrew/bin/git-filter-repo"
+  ];
+  const pyLibDir = path3.join(home, "Library", "Python");
+  try {
+    for (const ver of fs.readdirSync(pyLibDir)) {
+      candidates.push(path3.join(pyLibDir, ver, "bin", "git-filter-repo"));
+    }
+  } catch {}
+  return candidates.find((c) => {
+    try {
+      return fs.existsSync(c);
+    } catch {
+      return false;
+    }
+  }) ?? null;
+}
+function provisionFilterRepo() {
+  const python = findPython();
+  if (!python)
+    return null;
+  const cacheDir = path3.join(os.homedir(), ".cache", "monopoly");
+  const scriptPath = path3.join(cacheDir, "git-filter-repo");
+  if (fs.existsSync(scriptPath)) {
+    const check2 = spawnSync2(python, [scriptPath, "--version"], {
+      stdio: "ignore",
+      timeout: 5000
+    });
+    if (check2.status === 0)
+      return { command: python, prefixArgs: [scriptPath] };
+    try {
+      fs.unlinkSync(scriptPath);
+    } catch {}
+  }
+  process.stderr.write(`git-filter-repo not found, downloading...
+`);
+  try {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  } catch {
+    return null;
+  }
+  if (!downloadFile(FILTER_REPO_URL, scriptPath))
+    return null;
+  const check = spawnSync2(python, [scriptPath, "--version"], {
+    stdio: "ignore",
+    timeout: 5000
+  });
+  if (check.status !== 0) {
+    try {
+      fs.unlinkSync(scriptPath);
+    } catch {}
+    return null;
+  }
+  process.stderr.write(`git-filter-repo ready.
+`);
+  return { command: python, prefixArgs: [scriptPath] };
+}
+function downloadFile(url, dest) {
+  const curlResult = spawnSync2("curl", ["-fsSL", "-o", dest, url], {
+    stdio: "ignore",
+    timeout: 30000
+  });
+  if (curlResult.status === 0)
+    return true;
+  const wgetResult = spawnSync2("wget", ["-q", "-O", dest, url], {
+    stdio: "ignore",
+    timeout: 30000
+  });
+  return wgetResult.status === 0;
+}
+function findPython() {
+  const py3 = spawnSync2("python3", ["--version"], {
+    stdio: "ignore",
+    timeout: 5000
+  });
+  if (py3.status === 0)
+    return "python3";
+  const py = spawnSync2("python", ["--version"], {
+    encoding: "utf-8",
+    timeout: 5000
+  });
+  if (py.status === 0 && (py.stdout ?? "").includes("Python 3")) {
+    return "python";
+  }
+  return null;
+}
+
+// src/validate.ts
+function validate(args) {
+  assertGitVersion();
+  assertFilterRepoInstalled();
+  const resolvedSource = path4.resolve(args.source);
+  const sourceStat = safeStat(resolvedSource);
+  if (!sourceStat) {
+    throw new Error(`Source path does not exist: ${args.source}`);
+  }
+  const realSource = fs2.realpathSync(resolvedSource);
+  const isDirectory = sourceStat.isDirectory();
+  const sourceDir = isDirectory ? realSource : path4.dirname(realSource);
+  const sourceRepoRoot = findRepoRoot(sourceDir);
+  if (!sourceRepoRoot) {
+    throw new Error(`Source path is not inside a git repository: ${args.source}`);
+  }
+  const extractionPath = toGitPath(path4.relative(sourceRepoRoot, realSource));
+  if (!extractionPath || extractionPath.startsWith("..")) {
+    throw new Error(`Source path is outside the repository root: ${args.source}`);
+  }
+  const sourceCommitCount = countCommitsForPath(extractionPath, sourceRepoRoot);
+  if (sourceCommitCount === 0) {
+    throw new Error(`No commits found for ${args.source}. The path exists but has no git history.`);
+  }
+  const resolvedTarget = path4.resolve(args.to);
+  if (!isGitRepo(resolvedTarget)) {
+    throw new Error(`Target is not a git repository: ${args.to}`);
+  }
+  const targetRepoRoot = findRepoRoot(resolvedTarget) ?? resolvedTarget;
+  if (hasUncommittedChanges(targetRepoRoot)) {
+    throw new Error(`Target repo has uncommitted changes: ${args.to}. Commit or stash them first.`);
+  }
+  const targetFullPath = path4.join(targetRepoRoot, args.as);
+  if (fs2.existsSync(targetFullPath)) {
+    throw new Error(`Target path already exists: ${args.to}/${args.as}. Remove it or choose a different --as path.`);
+  }
+  return {
+    sourceRepoRoot,
+    extractionPath,
+    targetRepoRoot,
+    sourceBranch: getCurrentBranch(sourceRepoRoot),
+    sourceHead: getHeadHash(sourceRepoRoot),
+    commitCount: sourceCommitCount,
+    isDirectory
+  };
+}
+function assertGitVersion() {
+  const version = getGitVersion();
+  const [major, minor] = parseGitVersion(version);
+  if (major < 2 || major === 2 && minor < 22) {
+    throw new Error(`git >= 2.22.0 is required (found ${version}).`);
+  }
+}
+function assertFilterRepoInstalled() {
+  if (!isFilterRepoInstalled()) {
+    throw new Error("git-filter-repo is required and could not be auto-installed (needs Python 3 + network). " + "Install manually: pip install git-filter-repo");
+  }
+}
+function safeStat(p) {
+  try {
+    return fs2.statSync(p);
+  } catch {
+    return null;
+  }
+}
+
+// src/move.ts
+import fs3 from "fs";
+import path5 from "path";
+import os2 from "os";
+function executeMove(args, ctx) {
+  const tmpDir = fs3.mkdtempSync(path5.join(os2.tmpdir(), "monopoly-"));
+  const targetAs = toGitPath(args.as);
+  try {
+    const extractDir = cloneAndFilter(tmpDir, ctx);
+    const commitCount = countCommits(extractDir);
+    if (ctx.isDirectory) {
+      restructureDirectory(extractDir, targetAs);
+    } else {
+      restructureFile(extractDir, ctx.extractionPath, targetAs);
+    }
+    mergeIntoTarget(extractDir, targetAs, ctx, commitCount);
+    return {
+      sourcePath: args.source,
+      targetRepo: args.to,
+      targetFullPath: `${args.to}/${targetAs}`,
+      commitCount
+    };
+  } finally {
+    fs3.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+function cloneAndFilter(tmpDir, ctx) {
+  requireSuccess(git(["clone", "--single-branch", ctx.sourceRepoRoot, "extract"], tmpDir), "Failed to clone source repo");
+  const extractDir = path5.join(tmpDir, "extract");
+  requireSuccess(git(["config", "user.email", "monopoly@local"], extractDir), "Failed to configure git identity");
+  requireSuccess(git(["config", "user.name", "monopoly"], extractDir), "Failed to configure git identity");
+  const filterFlag = ctx.isDirectory ? "--subdirectory-filter" : "--path";
+  requireSuccess(filterRepo([filterFlag, ctx.extractionPath, "--force", "--quiet"], extractDir), "git-filter-repo failed");
+  return extractDir;
+}
+function restructureDirectory(extractDir, targetPath) {
+  fs3.mkdirSync(path5.join(extractDir, targetPath), { recursive: true });
+  const topLevel = targetPath.split("/")[0];
+  const entries = fs3.readdirSync(extractDir).filter((e) => e !== ".git" && e !== topLevel);
+  if (entries.length > 0) {
+    requireSuccess(git(["mv", ...entries, targetPath], extractDir), "Failed to restructure files");
+  }
+  requireSuccess(git(["commit", "-m", "chore(monopoly): restructure for target path"], extractDir), "Failed to commit restructured files");
+}
+function restructureFile(extractDir, originalPath, targetName) {
+  if (originalPath === targetName)
+    return;
+  const targetDir = path5.dirname(targetName);
+  if (targetDir !== ".") {
+    fs3.mkdirSync(path5.join(extractDir, targetDir), { recursive: true });
+  }
+  requireSuccess(git(["mv", originalPath, targetName], extractDir), "Failed to restructure file");
+  requireSuccess(git(["commit", "-m", "chore(monopoly): restructure for target path"], extractDir), "Failed to commit restructured file");
+}
+function mergeIntoTarget(extractDir, targetAs, ctx, commitCount) {
+  if (!hasAnyCommits(ctx.targetRepoRoot)) {
+    git(["commit", "--allow-empty", "-m", "chore: initialize repository"], ctx.targetRepoRoot);
+  }
+  const remoteName = "monopoly-temp";
+  requireSuccess(git(["remote", "add", remoteName, extractDir], ctx.targetRepoRoot), "Failed to add temp remote");
+  try {
+    requireSuccess(git(["fetch", remoteName], ctx.targetRepoRoot), "Failed to fetch from temp clone");
+    const extractBranch = getCurrentBranch(extractDir);
+    const mergeResult = git([
+      "merge",
+      `${remoteName}/${extractBranch}`,
+      "--allow-unrelated-histories",
+      "--no-commit"
+    ], ctx.targetRepoRoot);
+    if (mergeResult.stderr.includes("CONFLICT")) {
+      git(["merge", "--abort"], ctx.targetRepoRoot);
+      throw new Error(`Merge conflict: ${mergeResult.stderr}. Resolve manually or choose a different --as path.`);
+    }
+  } finally {
+    git(["remote", "remove", remoteName], ctx.targetRepoRoot);
+  }
+  writeMergeMessage(targetAs, ctx, commitCount);
+}
+function writeMergeMessage(targetAs, ctx, commitCount) {
+  const sourceRepoName = path5.basename(ctx.sourceRepoRoot);
+  const msg = `monopoly: move ${sourceRepoName}:${ctx.extractionPath} → ${targetAs}
+
+Source repo:   ${ctx.sourceRepoRoot}
+Source path:   ${ctx.extractionPath}
+Source HEAD:   ${ctx.sourceHead}
+Extracted:     ${commitCount} commits
+`;
+  const gitDirResult = git(["rev-parse", "--git-dir"], ctx.targetRepoRoot);
+  const gitDir = gitDirResult.success ? path5.resolve(ctx.targetRepoRoot, gitDirResult.stdout) : path5.join(ctx.targetRepoRoot, ".git");
+  fs3.writeFileSync(path5.join(gitDir, "MERGE_MSG"), msg, "utf-8");
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/output.ts
+var tty = process.stdout.isTTY;
+var style = {
+  green: (s) => tty ? `\x1B[32m${s}\x1B[0m` : s,
+  red: (s) => tty ? `\x1B[31m${s}\x1B[0m` : s,
+  cyan: (s) => tty ? `\x1B[36m${s}\x1B[0m` : s,
+  bold: (s) => tty ? `\x1B[1m${s}\x1B[0m` : s
+};
+function printHelp() {
+  console.log(`monopoly - Move code between git repos without losing history.
+
+Usage:
+  monopoly move <source> --to <repo> [--as <path>] [--dry-run]
+
+Commands:
+  move    Extract a file or directory from one repo and stage it
+          into another, carrying its full git history.
+
+Arguments:
+  <source>              File or directory to move (e.g. packages/auth)
+
+Options:
+  --to <repo>           Path to locally cloned target repository
+  --as <path>           Target path inside the repo (default: source basename)
+  --dry-run             Show what would happen without making changes
+  -h, --help            Show this help message
+  -v, --version         Show version
+
+Examples:
+  monopoly move packages/auth --to ../stable --as auth
+  monopoly move ../stable/auth --to . --as packages/auth
+  monopoly move src/utils/logger.ts --to ../shared --as logger.ts
+
+All changes are staged locally. Nothing is committed or pushed.`);
+}
+function printVersion() {
+  console.log(`monopoly ${VERSION}`);
+}
+function printSuccess(result) {
+  console.log(`${style.green("✓")} Move staged in ${result.targetRepo}
+
+  Source:  ${result.sourcePath} (${result.commitCount} commits extracted)
+  Target:  ${result.targetFullPath}
+  Seam:    staged (not yet committed)
+
+  Review the staged changes:
+    cd ${result.targetRepo} && git status
+
+  When ready:
+    git commit
+    git push
+
+  To remove the source from this repo:
+    git rm -r ${result.sourcePath}
+    git commit -m "chore: remove ${result.sourcePath} (graduated to ${result.targetRepo})"
+
+  Don't forget to replace direct usage of ${result.sourcePath} with
+  an external dependency (package, subtree, runtime import, etc).`);
+}
+function printDryRun(args, ctx) {
+  console.log(`${style.cyan("[dry-run]")} Would perform the following:
+
+  1. Clone source repo to temp directory
+  2. Run git-filter-repo to extract ${args.source}
+  3. Restructure extracted files for target path: ${args.as}
+  4. Fetch into ${args.to} and merge with --allow-unrelated-histories
+  5. Write seam metadata to .git/MERGE_MSG
+  6. Stage all changes (no commit)
+
+  Source repo:     ${ctx.sourceRepoRoot}
+  Source path:     ${ctx.extractionPath}
+  Target repo:     ${ctx.targetRepoRoot}
+  Target path:     ${args.as}
+  Source branch:   ${ctx.sourceBranch}
+  Source HEAD:     ${ctx.sourceHead}
+  Commits:         ~${ctx.commitCount} (estimate from source history)
+  Is directory:    ${ctx.isDirectory}
+
+  ${style.bold("No changes were made.")}`);
+}
+function printError(msg) {
+  console.error(`${style.red("Error:")} ${msg}`);
+}
+
+// src/main.ts
+function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.kind === "help") {
+      printHelp();
+      return;
+    }
+    if (args.kind === "version") {
+      printVersion();
+      return;
+    }
+    const ctx = validate(args);
+    if (args.dryRun) {
+      printDryRun(args, ctx);
+      return;
+    }
+    const result = executeMove(args, ctx);
+    printSuccess(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    printError(msg);
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "monopoly-repo",
+  "version": "0.1.0",
+  "description": "Move code between git repos without losing history",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://monopoly-repo.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/itaymendel/monopoly-repo.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/itaymendel/monopoly-repo/issues"
+  },
+  "keywords": [
+    "git",
+    "monorepo",
+    "polyrepo",
+    "git-filter-repo",
+    "history",
+    "cli"
+  ],
+  "bin": {
+    "monopoly": "dist/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/cli.js"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "bun run src/main.ts",
+    "build": "bun build src/main.ts --compile --outfile dist/monopoly",
+    "build:npm": "bun scripts/build-npm.ts",
+    "prepublishOnly": "bun scripts/build-npm.ts",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "bun-types": "^1.3.13"
+  }
+}