@hallaxius/forge 0.1.0

package/package.json

@@ -0,0 +1,65 @@
+{
+	"name": "@hallaxius/forge",
+	"version": "0.1.0",
+	"description": "A modern Git CLI with professional UX",
+	"author": "hallaxius",
+	"license": "MIT",
+	"type": "module",
+	"bin": {
+		"fg": "./dist/cli.js"
+	},
+	"main": "./dist/cli.js",
+	"types": "./dist/cli.d.ts",
+	"scripts": {
+		"dev": "bun --watch src/cli.ts",
+		"build": "bun build src/cli.ts --outdir dist --target node",
+		"start": "bun bin/forge.js",
+		"test": "bun test",
+		"lint": "biome check",
+		"format": "biome format --write",
+		"lint:fix": "biome check --write --unsafe",
+		"prepublishOnly": "bun test && bun run build",
+		"prepack": "bun run build"
+	},
+	"dependencies": {
+		"boxen": "^7.1.0",
+		"chalk": "^5.3.0",
+		"commander": "^12.0.0",
+		"conf": "^12.0.0",
+		"figures": "^5.0.0",
+		"inquirer": "^14.0.2",
+		"ora": "^8.0.0",
+		"simple-git": "^3.22.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.5.1",
+		"typescript": "^5.3.0"
+	},
+	"files": [
+		"bin",
+		"dist",
+		"src"
+	],
+	"engines": {
+		"node": ">=18.0.0",
+		"bun": ">=1.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/hallaxius/forge.git"
+	},
+	"bugs": {
+		"url": "https://github.com/hallaxius/forge/issues"
+	},
+	"homepage": "https://github.com/hallaxius/forge#readme",
+	"keywords": [
+		"git",
+		"cli",
+		"forge",
+		"git-cli",
+		"developer-tools",
+		"productivity",
+		"bun",
+		"command-line"
+	]
+}

package/src/cli.ts

@@ -0,0 +1,78 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const pkg = JSON.parse(
+	readFileSync(resolve(__dirname, "../package.json"), "utf-8"),
+);
+
+const program = new Command();
+
+program
+	.name("fg")
+	.description("Modern Git CLI for professional workflows")
+	.version(pkg.version);
+
+import registerAlias from "./commands/alias.js";
+import registerArchive from "./commands/archive.js";
+import registerBisect from "./commands/bisect.js";
+import registerBranch from "./commands/branch.js";
+import registerCherryPick from "./commands/cherry-pick.js";
+import registerClean from "./commands/clean.js";
+import registerClone from "./commands/clone.js";
+import registerCommit from "./commands/commit.js";
+import registerConfig from "./commands/config.js";
+import registerDiff from "./commands/diff.js";
+import registerFetch from "./commands/fetch.js";
+import registerHelp from "./commands/help.js";
+import registerInit from "./commands/init.js";
+import registerLog from "./commands/log.js";
+import registerMerge from "./commands/merge.js";
+import registerPush from "./commands/push.js";
+import registerRemote from "./commands/remote.js";
+import registerReset from "./commands/reset.js";
+import registerSetup from "./commands/setup.js";
+import registerStash from "./commands/stash.js";
+import registerStatus from "./commands/status.js";
+import registerSync from "./commands/sync.js";
+import registerTag from "./commands/tag.js";
+import registerUndo from "./commands/undo.js";
+import registerVersion from "./commands/version.js";
+import registerWorktree from "./commands/worktree.js";
+
+registerSetup(program);
+registerCommit(program);
+registerPush(program);
+registerStatus(program);
+registerSync(program);
+registerFetch(program);
+registerBranch(program);
+registerLog(program);
+registerDiff(program);
+registerStash(program);
+registerTag(program);
+registerAlias(program);
+registerConfig(program);
+registerUndo(program);
+registerReset(program);
+registerHelp(program);
+registerVersion(program);
+registerClone(program);
+registerInit(program);
+registerRemote(program);
+registerWorktree(program);
+registerMerge(program);
+registerCherryPick(program);
+registerClean(program);
+registerArchive(program);
+registerBisect(program);
+
+if (process.argv.length <= 2) {
+	program.outputHelp();
+} else {
+	program.parse(process.argv);
+}

package/src/commands/alias.ts

@@ -0,0 +1,66 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { Command } from "commander";
+import Conf from "conf";
+import { error, info, success } from "../lib/logger.js";
+import { createTable } from "../lib/ui.js";
+
+const aliasConfig = new Conf({
+	configName: "forge-aliases",
+	cwd: join(homedir(), ".forge"),
+});
+
+export default function register(program: Command): void {
+	const alias = program.command("alias").description("Manage aliases");
+
+	alias
+		.command("add <name> <command>")
+		.description("Create an alias")
+		.action(async (name, command) => {
+			try {
+				aliasConfig.set(name, command);
+				success(`Alias '${name}' created.`);
+			} catch (err) {
+				error(
+					`Failed to create alias: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	alias
+		.command("list")
+		.description("List all aliases")
+		.action(async () => {
+			try {
+				const store = aliasConfig.store as Record<string, string>;
+				const entries = Object.entries(store);
+
+				if (entries.length === 0) {
+					info("No aliases configured.");
+					return;
+				}
+
+				const rows = entries.map(([name, cmd]) => [name, cmd]);
+				info("Aliases:");
+				console.log(createTable(["Name", "Command"], rows));
+			} catch (err) {
+				error(
+					`Failed to list aliases: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	alias
+		.command("remove <name>")
+		.description("Delete an alias")
+		.action(async (name) => {
+			try {
+				aliasConfig.delete(name);
+				success(`Alias '${name}' removed.`);
+			} catch (err) {
+				error(
+					`Failed to remove alias: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/archive.ts

@@ -0,0 +1,35 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, success } from "../lib/logger.js";
+
+export default function register(program: Command): void {
+	program
+		.command("archive")
+		.description("Create an archive of the repository")
+		.argument("<format>", "Archive format (tar, tar.gz, zip)")
+		.option("--prefix <dir>", "Prepend prefix to archive paths")
+		.option("--output <file>", "Output file path")
+		.option("--tree-ish <ref>", "Tree or commit to archive")
+		.action(
+			async (
+				format: string,
+				options: { prefix?: string; output?: string; treeIsh?: string },
+			) => {
+				try {
+					const opts: { prefix?: string; output?: string; treeIsh?: string } =
+						{};
+					if (options.prefix) opts.prefix = options.prefix;
+					if (options.output) opts.output = options.output;
+					if (options.treeIsh) opts.treeIsh = options.treeIsh;
+
+					const _result = await git.archive(format, opts);
+					const outputPath = options.output || `archive.${format}`;
+					success(`Archive created: ${outputPath}`);
+				} catch (err) {
+					error(
+						`Archive failed: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
+			},
+		);
+}

package/src/commands/bisect.ts

@@ -0,0 +1,102 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, info, success, text } from "../lib/logger.js";
+
+export default function register(program: Command): void {
+	const cmd = program
+		.command("bisect")
+		.description("Bisect to find the commit that introduced a bug");
+
+	cmd
+		.command("start")
+		.description("Start a bisect session")
+		.argument("[bad]", "Bad commit (default: HEAD)")
+		.argument("[good...]", "Good commits")
+		.action(async (bad: string | undefined, good: string[]) => {
+			try {
+				await git.bisectStart(bad, good);
+				success("Bisect started.");
+			} catch (err) {
+				error(
+					`Bisect start failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	cmd
+		.command("bad")
+		.description("Mark a commit as bad")
+		.argument("[commit]", "Commit hash (default: HEAD)")
+		.action(async (commit: string | undefined) => {
+			try {
+				await git.bisectBad(commit);
+				success(`Commit ${commit || "HEAD"} marked as bad.`);
+			} catch (err) {
+				error(
+					`Bisect bad failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	cmd
+		.command("good")
+		.description("Mark commits as good")
+		.argument("[commits...]", "Commits to mark as good")
+		.action(async (commits: string[]) => {
+			try {
+				if (commits.length === 0) {
+					info("Provide at least one commit to mark as good.");
+					return;
+				}
+				await git.bisectGood(commits);
+				success(`Marked ${commits.join(", ")} as good.`);
+			} catch (err) {
+				error(
+					`Bisect good failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	cmd
+		.command("reset")
+		.description("Reset bisect state")
+		.action(async () => {
+			try {
+				await git.bisectReset();
+				success("Bisect reset.");
+			} catch (err) {
+				error(
+					`Bisect reset failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	cmd
+		.command("log")
+		.description("Show bisect log")
+		.action(async () => {
+			try {
+				const log = await git.bisectLog();
+				text(log);
+			} catch (err) {
+				error(
+					`Bisect log failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	cmd
+		.command("run")
+		.description("Run a script for bisect")
+		.argument("<cmd>", "Command to run")
+		.action(async (cmd: string) => {
+			try {
+				await git.bisectRun(cmd);
+				success("Bisect run completed.");
+			} catch (err) {
+				error(
+					`Bisect run failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/branch.ts

@@ -0,0 +1,46 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, info, success } from "../lib/logger.js";
+import { createTable } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("branch")
+		.description("Manage branches")
+		.option("-n, --new <name>", "Create new branch")
+		.option("-d, --delete <name>", "Delete branch")
+		.option("-s, --switch <name>", "Switch to branch")
+		.action(async (options) => {
+			try {
+				if (options.new) {
+					await git.createBranch(options.new);
+					success(`Branch '${options.new}' created.`);
+					return;
+				}
+
+				if (options.delete) {
+					await git.deleteBranch(options.delete);
+					success(`Branch '${options.delete}' deleted.`);
+					return;
+				}
+
+				if (options.switch) {
+					await git.switchBranch(options.switch);
+					success(`Switched to '${options.switch}'.`);
+					return;
+				}
+
+				const branches = await git.getBranches();
+				const rows = branches.all.map((b) => [
+					b === branches.current ? "*" : " ",
+					b,
+				]);
+				info("Branches:");
+				console.log(createTable(["", "Name"], rows));
+			} catch (err) {
+				error(
+					`Branch operation failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/cherry-pick.ts

@@ -0,0 +1,57 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, info, success } from "../lib/logger.js";
+
+export default function register(program: Command): void {
+	program
+		.command("cherry-pick")
+		.description("Cherry-pick commits")
+		.argument("[commits...]", "Commits to cherry-pick")
+		.option("--no-commit", "Apply changes without committing")
+		.option(
+			"--mainline <number>",
+			"Mainline parent for cherry-pick merge commits",
+		)
+		.option("--continue", "Continue after resolving conflicts")
+		.option("--abort", "Abort cherry-pick in progress")
+		.action(
+			async (
+				commits: string[],
+				options: {
+					noCommit?: boolean;
+					mainline?: number;
+					continue?: boolean;
+					abort?: boolean;
+				},
+			) => {
+				try {
+					if (options.continue) {
+						await git.cherryPickContinue();
+						success("Cherry-pick continued.");
+						return;
+					}
+
+					if (options.abort) {
+						await git.cherryPickAbort();
+						success("Cherry-pick aborted.");
+						return;
+					}
+
+					if (commits.length === 0) {
+						info("Provide at least one commit to cherry-pick.");
+						return;
+					}
+
+					await git.cherryPick(commits, {
+						noCommit: options.noCommit ?? undefined,
+						mainline: options.mainline ?? undefined,
+					});
+					success(`Cherry-pick applied: ${commits.join(", ")}`);
+				} catch (err) {
+					error(
+						`Cherry-pick failed: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
+			},
+		);
+}

package/src/commands/clean.ts

@@ -0,0 +1,76 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, info, success, warning } from "../lib/logger.js";
+import { confirm } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("clean")
+		.description("Clean untracked files")
+		.argument("[paths...]", "Paths to clean")
+		.option("--dry-run", "Show what would be removed")
+		.option("--force", "Skip confirmation prompt")
+		.option("--exclude <pattern>", "Exclude files matching pattern")
+		.action(
+			async (
+				_paths: string[],
+				options: { dryRun?: boolean; force?: boolean; exclude?: string },
+			) => {
+				try {
+					const opts: { dryRun?: boolean; force?: boolean; exclude?: string } =
+						{};
+					if (options.dryRun) opts.dryRun = true;
+					if (options.force) opts.force = true;
+					if (options.exclude) opts.exclude = options.exclude;
+
+					const wouldRemove = await git.clean(opts);
+
+					if (options.dryRun) {
+						if (wouldRemove.length === 0) {
+							info("Nothing would be removed.");
+							return;
+						}
+						info("Would remove:");
+						for (const line of wouldRemove) {
+							warning(line);
+						}
+						return;
+					}
+
+					if (wouldRemove.length === 0) {
+						info("Nothing to clean.");
+						return;
+					}
+
+					if (!options.force) {
+						const ok = await confirm(
+							`Remove ${wouldRemove.length} untracked file(s)?`,
+						);
+						if (!ok) {
+							info("Clean cancelled.");
+							return;
+						}
+					}
+
+					const result = await git.clean({
+						force: true,
+						...(options.exclude ? { exclude: options.exclude } : {}),
+					});
+
+					if (result.length === 0) {
+						info("Nothing cleaned.");
+						return;
+					}
+
+					for (const line of result) {
+						warning(line);
+					}
+					success(`Cleaned ${result.length} file(s).`);
+				} catch (err) {
+					error(
+						`Clean failed: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
+			},
+		);
+}

package/src/commands/clone.ts

@@ -0,0 +1,100 @@
+import type { Command } from "commander";
+import { ConfigManager } from "../lib/config.js";
+import * as git from "../lib/git.js";
+import { error, highlight, info } from "../lib/logger.js";
+import { createTable, showBox, withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("clone")
+		.description("Clone a repository")
+		.argument("[url]", "Repository URL or org/repo shorthand")
+		.argument("[dir]", "Target directory")
+		.option("--ssh", "Use SSH URL")
+		.option(
+			"--depth <n>",
+			"Create a shallow clone with history truncated to n commits",
+		)
+		.option("--branch <name>", "Clone a specific branch")
+		.option(
+			"--recurse-submodules",
+			"Initialize and clone submodules recursively",
+		)
+		.option("--cd", "Print cd command for eval")
+		.option("--list", "List recent clones")
+		.action(async (url, dir, options) => {
+			try {
+				if (options.list) {
+					const config = new ConfigManager();
+					const clones = config.getClones();
+
+					if (clones.length === 0) {
+						info("No recent clones found.");
+						return;
+					}
+
+					const rows = clones.map((c) => {
+						const [u, d] = c.split("|");
+						return [u || "", d || ""];
+					});
+
+					info("Recent clones:");
+					console.log(createTable(["URL", "Directory"], rows));
+					return;
+				}
+
+				if (!url) {
+					error("Repository URL or org/repo shorthand is required.");
+					return;
+				}
+
+				let resolvedUrl = url;
+
+				if (url.includes("/") && !url.includes(".") && !url.includes("://")) {
+					resolvedUrl = `https://github.com/${url}.git`;
+				}
+
+				if (options.ssh) {
+					const match = resolvedUrl.match(/https:\/\/github\.com\/(.+)\.git$/);
+					if (match) {
+						resolvedUrl = `git@github.com:${match[1]}.git`;
+					} else if (resolvedUrl.startsWith("https://")) {
+						const rest = resolvedUrl.replace("https://", "");
+						const slashIndex = rest.indexOf("/");
+						if (slashIndex !== -1) {
+							const host = rest.substring(0, slashIndex);
+							const path = rest.substring(slashIndex + 1).replace(/\.git$/, "");
+							resolvedUrl = `git@${host}:${path}.git`;
+						}
+					}
+				}
+
+				const cloneDir = await withSpinner("Cloning repository...", () =>
+					git.clone(resolvedUrl, dir, {
+						depth: options.depth ? Number(options.depth) : undefined,
+						branch: options.branch,
+						recurseSubmodules: options.recurseSubmodules,
+					}),
+				);
+
+				const content = [
+					`URL:       ${resolvedUrl}`,
+					`Directory: ${cloneDir}`,
+					`Branch:    ${options.branch || "default"}`,
+				].join("\n");
+
+				showBox("Clone Complete", content);
+
+				if (options.cd) {
+					highlight(`cd ${cloneDir}`);
+				}
+
+				const config = new ConfigManager();
+				config.addClone(`${resolvedUrl}|${cloneDir}`);
+			} catch (err) {
+				error(
+					`Clone failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}