appmaker-git-remote-origin-fixer 0.1.0

package/README.md

@@ -0,0 +1,99 @@
+# appmaker-git-remote-origin-fixer
+
+A small recovery CLI that repairs a local git `origin` remote after a GitHub
+**organization migration**.
+
+When repositories are transferred from one GitHub organization to another and
+then deleted from the old one, every developer's local clone still points at the
+old remote — so `git push` fails. Run this tool once, after that first failed
+push, and it repoints `origin` at the new organization for you.
+
+```
+git push                            # ❌ fails — repo no longer exists in the old org
+appmaker-git-remote-origin-fixer    # 🔧 diagnoses and fixes origin
+git push                            # ✅ works
+```
+
+## Install
+
+```bash
+npm install -g appmaker-git-remote-origin-fixer
+# or run without installing:
+npx appmaker-git-remote-origin-fixer
+```
+
+## Usage
+
+Run it from inside the affected repository:
+
+```bash
+appmaker-git-remote-origin-fixer [options]
+
+  -c, --config <path>   Use a specific migrations config file
+  -n, --dry-run         Diagnose only; do not modify the remote
+  -h, --help            Show help
+  -v, --version         Show version
+```
+
+## How it works
+
+```
+Read origin URL  →  parse org + repo
+       │
+       ▼
+Is the org a "source" in the migration config?
+       │  no → "No migration configured" → exit
+       ▼ yes
+Is the repo still reachable in the SOURCE org?      (git ls-remote)
+       ├─ reachable      → "still exists, nothing to do"
+       ├─ no permission  → permission error
+       └─ not found ↓
+Is the repo reachable in the DESTINATION org?       (git ls-remote)
+       ├─ reachable      → rewrite origin → "run git push"
+       ├─ no permission  → "exists, contact admin" (remote left unchanged)
+       └─ not found      → "not found in either org"
+```
+
+Repository existence is verified with `git ls-remote` using your **existing git
+credentials** — no GitHub token or API access is required. The remote is only
+rewritten once the destination is confirmed reachable.
+
+> **Note:** verification is most reliable with **SSH remotes**
+> (`git@github.com:Org/repo.git`), where GitHub returns a clear
+> "Repository not found" for missing repos. Over HTTPS without cached
+> credentials, git may be unable to determine existence; in that case the tool
+> reports that it could not verify and leaves your remote untouched.
+
+## Configuration
+
+Migrations are data-driven — a simple map of `source-org → destination-org`:
+
+```json
+{
+  "migrations": {
+    "Appmaker-HQ": "Appmaker-xyz",
+    "Appmaker-Partners": "Appmaker-Partners-HQ"
+  }
+}
+```
+
+The config is resolved in this order (first found wins):
+
+1. `--config <path>`
+2. `./migrations.json` (current directory)
+3. `~/.appmaker-git-remote-origin-fixer.json` (per-user override)
+4. the `migrations.json` bundled with the package
+
+To support a new migration, update the config — no code change needed.
+
+## Development
+
+```bash
+npm install
+npm run build      # compile TypeScript -> dist/
+npm start          # run dist/cli.js
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point: parse arguments, run the fixer, set the exit code.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point: parse arguments, run the fixer, set the exit code.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { run } from "./index.js";
+function readVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = resolve(here, "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+const VERSION = readVersion();
+const HELP = `appmaker-git-remote-origin-fixer
+
+Repairs a local git "origin" remote after a GitHub organization migration.
+Run it from inside your repository after a push fails.
+
+USAGE
+  appmaker-git-remote-origin-fixer [options]
+
+OPTIONS
+  -c, --config <path>   Use a specific migrations config file.
+  -n, --dry-run         Diagnose only; do not modify the remote.
+  -h, --help            Show this help.
+  -v, --version         Show the version.
+`;
+function main() {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            options: {
+                config: { type: "string", short: "c" },
+                "dry-run": { type: "boolean", short: "n" },
+                help: { type: "boolean", short: "h" },
+                version: { type: "boolean", short: "v" },
+            },
+            allowPositionals: false,
+        });
+    }
+    catch (err) {
+        console.error(err.message);
+        console.error(`\nRun with --help for usage.`);
+        return 2;
+    }
+    const { values } = parsed;
+    if (values.help) {
+        console.log(HELP);
+        return 0;
+    }
+    if (values.version) {
+        console.log(VERSION);
+        return 0;
+    }
+    try {
+        return run({
+            configPath: values.config,
+            dryRun: values["dry-run"],
+        });
+    }
+    catch (err) {
+        console.error(`✖ ${err.message}`);
+        return 1;
+    }
+}
+process.exit(main());

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Loading and validation of the migration configuration.
+ *
+ * Resolution order (first found wins):
+ *   1. --config <path>           (explicit flag)
+ *   2. ./migrations.json         (current working directory)
+ *   3. ~/.appmaker-git-remote-origin-fixer.json   (per-user home override)
+ *   4. bundled migrations.json   (shipped with the package)
+ */
+export interface MigrationConfig {
+    /** Map of source organization -> destination organization. */
+    migrations: Record<string, string>;
+}
+export interface LoadedConfig extends MigrationConfig {
+    /** Absolute path the config was loaded from (for diagnostics). */
+    source: string;
+}
+/**
+ * Load the first available config file. Throws only on a malformed file that
+ * exists; missing files are skipped. The bundled config always exists, so this
+ * resolves unless the package install is broken.
+ */
+export declare function loadConfig(explicit?: string): LoadedConfig;

package/dist/config.js

@@ -0,0 +1,73 @@
+/**
+ * Loading and validation of the migration configuration.
+ *
+ * Resolution order (first found wins):
+ *   1. --config <path>           (explicit flag)
+ *   2. ./migrations.json         (current working directory)
+ *   3. ~/.appmaker-git-remote-origin-fixer.json   (per-user home override)
+ *   4. bundled migrations.json   (shipped with the package)
+ */
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const here = dirname(fileURLToPath(import.meta.url));
+// dist/config.js -> package root
+const BUNDLED = resolve(here, "..", "migrations.json");
+function candidatePaths(explicit) {
+    const paths = [];
+    if (explicit)
+        paths.push(resolve(explicit));
+    paths.push(resolve(process.cwd(), "migrations.json"));
+    paths.push(join(homedir(), ".appmaker-git-remote-origin-fixer.json"));
+    paths.push(BUNDLED);
+    return paths;
+}
+function parseConfig(text, path) {
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Config file is not valid JSON: ${path}`);
+    }
+    if (typeof data !== "object" ||
+        data === null ||
+        typeof data.migrations !== "object" ||
+        data.migrations === null) {
+        throw new Error(`Config file must contain a "migrations" object: ${path}`);
+    }
+    const migrations = data.migrations;
+    for (const [from, to] of Object.entries(migrations)) {
+        if (typeof to !== "string" || to.length === 0) {
+            throw new Error(`Migration destination for "${from}" must be a non-empty string: ${path}`);
+        }
+    }
+    return { migrations };
+}
+/**
+ * Load the first available config file. Throws only on a malformed file that
+ * exists; missing files are skipped. The bundled config always exists, so this
+ * resolves unless the package install is broken.
+ */
+export function loadConfig(explicit) {
+    const paths = candidatePaths(explicit);
+    for (const path of paths) {
+        let text;
+        try {
+            text = readFileSync(path, "utf8");
+        }
+        catch {
+            // Not found / unreadable -> try the next candidate.
+            // An explicit --config that is missing is a hard error, though.
+            if (explicit && path === resolve(explicit)) {
+                throw new Error(`Config file not found: ${path}`);
+            }
+            continue;
+        }
+        const config = parseConfig(text, path);
+        return { ...config, source: path };
+    }
+    // Should be unreachable because BUNDLED ships with the package.
+    throw new Error("No migration configuration could be loaded.");
+}

package/dist/git.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Thin wrappers around the local `git` executable.
+ */
+export type RemoteStatus = "reachable" | "not_found" | "forbidden" | "unknown";
+export interface ProbeResult {
+    status: RemoteStatus;
+    /** Raw stderr from git, for diagnostics on "unknown". */
+    detail: string;
+}
+/** True if the current directory is inside a git work tree. */
+export declare function isGitRepo(): boolean;
+/**
+ * Read the raw URL of the `origin` remote, or null if it has none.
+ *
+ * Uses `git config --get` rather than `git remote get-url` so the value is the
+ * one literally stored in config — not an `insteadOf`-rewritten variant. This
+ * is the value we parse and later overwrite with `set-url`.
+ */
+export declare function getOriginUrl(): string | null;
+/** Point the `origin` remote at a new URL. */
+export declare function setOriginUrl(url: string): void;
+/**
+ * Probe whether a remote URL is reachable using `git ls-remote`, relying on the
+ * developer's existing SSH/HTTPS credentials. Classifies the failure so callers
+ * can distinguish "missing" from "no permission".
+ */
+export declare function probeRemote(url: string): ProbeResult;

package/dist/git.js

@@ -0,0 +1,89 @@
+/**
+ * Thin wrappers around the local `git` executable.
+ */
+import { execFileSync } from "node:child_process";
+function runGit(args) {
+    try {
+        const stdout = execFileSync("git", args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { ok: true, stdout: stdout.trim(), stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            ok: false,
+            stdout: e.stdout?.toString().trim() ?? "",
+            stderr: e.stderr?.toString().trim() ?? "",
+        };
+    }
+}
+/** True if the current directory is inside a git work tree. */
+export function isGitRepo() {
+    return runGit(["rev-parse", "--is-inside-work-tree"]).ok;
+}
+/**
+ * Read the raw URL of the `origin` remote, or null if it has none.
+ *
+ * Uses `git config --get` rather than `git remote get-url` so the value is the
+ * one literally stored in config — not an `insteadOf`-rewritten variant. This
+ * is the value we parse and later overwrite with `set-url`.
+ */
+export function getOriginUrl() {
+    const result = runGit(["config", "--get", "remote.origin.url"]);
+    return result.ok && result.stdout ? result.stdout : null;
+}
+/** Point the `origin` remote at a new URL. */
+export function setOriginUrl(url) {
+    const result = runGit(["remote", "set-url", "origin", url]);
+    if (!result.ok) {
+        throw new Error(`Failed to update origin: ${result.stderr || "unknown error"}`);
+    }
+}
+/**
+ * Probe whether a remote URL is reachable using `git ls-remote`, relying on the
+ * developer's existing SSH/HTTPS credentials. Classifies the failure so callers
+ * can distinguish "missing" from "no permission".
+ */
+export function probeRemote(url) {
+    // GIT_TERMINAL_PROMPT=0 prevents git from blocking on a username/password
+    // prompt when credentials are missing; it fails fast instead.
+    const prevPrompt = process.env.GIT_TERMINAL_PROMPT;
+    process.env.GIT_TERMINAL_PROMPT = "0";
+    try {
+        // No --exit-code: a reachable repo with zero refs still exits 0, which is
+        // what we want. Only connection/permission/missing errors are non-zero.
+        const result = runGit(["ls-remote", "-h", url]);
+        if (result.ok)
+            return { status: "reachable", detail: "" };
+        const stderr = result.stderr.toLowerCase();
+        if (stderr.includes("repository not found") ||
+            stderr.includes("not found") ||
+            stderr.includes("does not exist") ||
+            stderr.includes("could not read from remote repository")) {
+            // Note: GitHub returns "Repository not found" for both a missing repo and
+            // a private repo you can't see. Permission patterns below take priority.
+            if (stderr.includes("permission denied") ||
+                stderr.includes("authentication failed") ||
+                stderr.includes("access denied") ||
+                stderr.includes("403")) {
+                return { status: "forbidden", detail: result.stderr };
+            }
+            return { status: "not_found", detail: result.stderr };
+        }
+        if (stderr.includes("permission denied") ||
+            stderr.includes("authentication failed") ||
+            stderr.includes("access denied") ||
+            stderr.includes("403")) {
+            return { status: "forbidden", detail: result.stderr };
+        }
+        return { status: "unknown", detail: result.stderr };
+    }
+    finally {
+        if (prevPrompt === undefined)
+            delete process.env.GIT_TERMINAL_PROMPT;
+        else
+            process.env.GIT_TERMINAL_PROMPT = prevPrompt;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Orchestrates the diagnose-and-fix flow.
+ *
+ *   1. Read origin remote
+ *   2. Parse org + repo
+ *   3. Look up destination org in config
+ *   4. Probe source org   -> still exists? permission? gone?
+ *   5. Probe destination  -> found -> rewrite origin; else explain
+ */
+export interface RunOptions {
+    /** Explicit config path from --config. */
+    configPath?: string;
+    /** Diagnose only; never modify the remote. */
+    dryRun?: boolean;
+}
+/** Returns a process exit code. */
+export declare function run(options?: RunOptions): number;

package/dist/index.js

@@ -0,0 +1,75 @@
+/**
+ * Orchestrates the diagnose-and-fix flow.
+ *
+ *   1. Read origin remote
+ *   2. Parse org + repo
+ *   3. Look up destination org in config
+ *   4. Probe source org   -> still exists? permission? gone?
+ *   5. Probe destination  -> found -> rewrite origin; else explain
+ */
+import { loadConfig } from "./config.js";
+import { getOriginUrl, isGitRepo, probeRemote, setOriginUrl, } from "./git.js";
+import { parseRemote, rewriteOrg } from "./remote-url.js";
+import * as ui from "./ui.js";
+/** Returns a process exit code. */
+export function run(options = {}) {
+    if (!isGitRepo()) {
+        ui.notAGitRepo();
+        return 1;
+    }
+    const originUrl = getOriginUrl();
+    if (!originUrl) {
+        ui.noOrigin();
+        return 1;
+    }
+    const parsed = parseRemote(originUrl);
+    if (!parsed) {
+        ui.unparseableRemote(originUrl);
+        return 1;
+    }
+    const config = loadConfig(options.configPath);
+    const destOrg = config.migrations[parsed.org];
+    if (!destOrg) {
+        ui.noMigration(parsed.org);
+        return 0; // Not an error — just nothing to do.
+    }
+    // Step 4 — is the repo still in the source org?
+    const source = probeRemote(originUrl);
+    if (source.status === "reachable") {
+        ui.stillExists(parsed.org, parsed.repo);
+        return 0;
+    }
+    if (source.status === "forbidden") {
+        ui.permissionDenied(parsed.org, parsed.repo);
+        return 1;
+    }
+    if (source.status === "unknown") {
+        ui.probeFailed(originUrl, source.detail);
+        return 1;
+    }
+    // status === "not_found" -> continue to the destination.
+    // Step 5 — is the repo in the destination org?
+    const destUrl = rewriteOrg(parsed, destOrg);
+    const dest = probeRemote(destUrl);
+    if (dest.status === "reachable") {
+        if (options.dryRun) {
+            ui.info("(dry run) Would update origin:");
+            ui.info(`  ${originUrl}  ->  ${destUrl}`);
+            return 0;
+        }
+        setOriginUrl(destUrl);
+        ui.updated(destOrg, originUrl, destUrl);
+        return 0;
+    }
+    if (dest.status === "forbidden") {
+        ui.permissionDenied(destOrg, parsed.repo);
+        return 1;
+    }
+    if (dest.status === "unknown") {
+        ui.probeFailed(destUrl, dest.detail);
+        return 1;
+    }
+    // Not found in either org.
+    ui.notFoundAnywhere(parsed.repo, [parsed.org, destOrg]);
+    return 1;
+}

package/dist/remote-url.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Parsing and rewriting of git remote URLs.
+ *
+ * Supports the two forms developers actually use with GitHub:
+ *   - SCP-like SSH:  git@github.com:Org/repo.git
+ *   - URL form:      https://github.com/Org/repo.git
+ *                    ssh://git@github.com/Org/repo.git
+ */
+export interface ParsedRemote {
+    /** Original, unmodified URL. */
+    raw: string;
+    /** Host, e.g. "github.com". */
+    host: string;
+    /** Owning organization / user. */
+    org: string;
+    /** Repository name, without the trailing ".git". */
+    repo: string;
+}
+/**
+ * Parse a git remote URL into its components, or return null if the URL is not
+ * a shape we recognize.
+ */
+export declare function parseRemote(url: string): ParsedRemote | null;
+/**
+ * Produce a new remote URL identical to `parsed` but pointing at `destOrg`.
+ * The original URL format (SSH vs HTTPS, with/without ".git") is preserved.
+ */
+export declare function rewriteOrg(parsed: ParsedRemote, destOrg: string): string;

package/dist/remote-url.js

@@ -0,0 +1,44 @@
+/**
+ * Parsing and rewriting of git remote URLs.
+ *
+ * Supports the two forms developers actually use with GitHub:
+ *   - SCP-like SSH:  git@github.com:Org/repo.git
+ *   - URL form:      https://github.com/Org/repo.git
+ *                    ssh://git@github.com/Org/repo.git
+ */
+// git@github.com:Org/repo(.git)
+const SCP_LIKE = /^(?<user>[^@\s]+@)?(?<host>[^:/\s]+):(?<org>[^/\s]+)\/(?<repo>[^/\s]+?)(?:\.git)?\/?$/;
+// scheme://[user@]github.com/Org/repo(.git)
+const URL_LIKE = /^(?<scheme>[a-z][a-z0-9+.-]*:\/\/)(?<user>[^@/\s]+@)?(?<host>[^/\s]+)\/(?<org>[^/\s]+)\/(?<repo>[^/\s]+?)(?:\.git)?\/?$/i;
+/**
+ * Parse a git remote URL into its components, or return null if the URL is not
+ * a shape we recognize.
+ */
+export function parseRemote(url) {
+    const trimmed = url.trim();
+    const match = trimmed.match(URL_LIKE) ?? trimmed.match(SCP_LIKE);
+    if (!match?.groups)
+        return null;
+    const { host, org, repo } = match.groups;
+    if (!host || !org || !repo)
+        return null;
+    return { raw: trimmed, host, org, repo };
+}
+/**
+ * Produce a new remote URL identical to `parsed` but pointing at `destOrg`.
+ * The original URL format (SSH vs HTTPS, with/without ".git") is preserved.
+ */
+export function rewriteOrg(parsed, destOrg) {
+    // Replace the first "<org>/<repo>" occurrence to preserve the original format.
+    const needle = `${parsed.org}/${parsed.repo}`;
+    const replacement = `${destOrg}/${parsed.repo}`;
+    const idx = parsed.raw.indexOf(needle);
+    if (idx === -1) {
+        // Should not happen given parsing succeeded, but fail loudly rather than
+        // returning a malformed URL.
+        throw new Error(`Could not rewrite remote URL: ${parsed.raw}`);
+    }
+    return (parsed.raw.slice(0, idx) +
+        replacement +
+        parsed.raw.slice(idx + needle.length));
+}

package/dist/ui.d.ts

@@ -0,0 +1,25 @@
+/**
+ * All user-facing output, centralized so wording is easy to audit and tweak.
+ * Colors degrade gracefully when stdout is not a TTY or NO_COLOR is set.
+ */
+export declare function info(message: string): void;
+export declare function detail(message: string): void;
+export declare function error(message: string): void;
+/** Step 0: not a git repo. */
+export declare function notAGitRepo(): void;
+/** Step 0: origin remote missing. */
+export declare function noOrigin(): void;
+/** Step 1: could not parse the remote URL. */
+export declare function unparseableRemote(url: string): void;
+/** Step 2: no migration configured for this org. */
+export declare function noMigration(org: string): void;
+/** Step 3: repository still exists in the source org. */
+export declare function stillExists(org: string, repo: string): void;
+/** Step 3/4: permission denied on a repository. */
+export declare function permissionDenied(org: string, repo: string): void;
+/** Step 4: found in destination -> updated. */
+export declare function updated(destOrg: string, from: string, to: string): void;
+/** Step 4: not found anywhere. */
+export declare function notFoundAnywhere(repo: string, checked: string[]): void;
+/** A git probe returned an unclassifiable error. */
+export declare function probeFailed(url: string, detailText: string): void;

package/dist/ui.js

@@ -0,0 +1,83 @@
+/**
+ * All user-facing output, centralized so wording is easy to audit and tweak.
+ * Colors degrade gracefully when stdout is not a TTY or NO_COLOR is set.
+ */
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const paint = (code, s) => useColor ? `[${code}m${s}` : s;
+const green = (s) => paint("32", s);
+const red = (s) => paint("31", s);
+const yellow = (s) => paint("33", s);
+const dim = (s) => paint("2", s);
+const bold = (s) => paint("1", s);
+const CHECK = green("✔");
+const CROSS = red("✖");
+export function info(message) {
+    console.log(message);
+}
+export function detail(message) {
+    console.log(dim(message));
+}
+export function error(message) {
+    console.error(`${CROSS} ${red(message)}`);
+}
+/** Step 0: not a git repo. */
+export function notAGitRepo() {
+    error("This is not a git repository.");
+    console.error(dim("Run this command from inside your project folder."));
+}
+/** Step 0: origin remote missing. */
+export function noOrigin() {
+    error("No 'origin' remote is configured.");
+    console.error(dim("Nothing to fix — add a remote first with `git remote add origin <url>`."));
+}
+/** Step 1: could not parse the remote URL. */
+export function unparseableRemote(url) {
+    error("Could not understand the current origin URL:");
+    console.error(`  ${url}`);
+    console.error(dim("Only github.com SSH and HTTPS URLs are supported."));
+}
+/** Step 2: no migration configured for this org. */
+export function noMigration(org) {
+    info(`No migration configured for organization:\n\n  ${bold(org)}`);
+}
+/** Step 3: repository still exists in the source org. */
+export function stillExists(org, repo) {
+    info(`${CHECK} Repository ${bold(`${org}/${repo}`)} still exists.`);
+    info("No changes required.");
+}
+/** Step 3/4: permission denied on a repository. */
+export function permissionDenied(org, repo) {
+    info(`Repository ${bold(`${org}/${repo}`)} exists.`);
+    info(yellow("You do not have permission to access this repository."));
+    info("Please contact your administrator.");
+}
+/** Step 4: found in destination -> updated. */
+export function updated(destOrg, from, to) {
+    info(`${CHECK} Repository found in ${bold(destOrg)}.`);
+    info(`${CHECK} Updated origin successfully.`);
+    info("");
+    info(dim(`  ${from}`));
+    info(dim("  ↓"));
+    info(`  ${green(to)}`);
+    info("");
+    info("Please run:");
+    info("");
+    info(bold("  git push"));
+}
+/** Step 4: not found anywhere. */
+export function notFoundAnywhere(repo, checked) {
+    error(`Repository '${repo}' not found in either organization.`);
+    info("");
+    info("Checked:");
+    for (const org of checked)
+        info(`  • ${org}`);
+    info("");
+    info("Please verify that the repository has been migrated.");
+}
+/** A git probe returned an unclassifiable error. */
+export function probeFailed(url, detailText) {
+    error("Could not reach the remote to verify it:");
+    console.error(`  ${url}`);
+    if (detailText)
+        console.error(dim(detailText));
+}

package/migrations.json

@@ -0,0 +1,7 @@
+{
+  "migrations": {
+    "AppMakerHQ": "Appmaker-xyz",
+    "AppMakerPartnersHQ": "Appmaker-Partners",
+    "TestorOrg": "TestorOrg2"
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "appmaker-git-remote-origin-fixer",
+  "version": "0.1.0",
+  "description": "Recovery CLI that repairs a local git origin remote after a GitHub organization migration.",
+  "type": "module",
+  "bin": {
+    "appmaker-git-remote-origin-fixer": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "migrations.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "git",
+    "remote",
+    "origin",
+    "github",
+    "organization",
+    "migration",
+    "cli"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3"
+  }
+}