@hallaxius/forge 0.1.0

package/src/commands/commit.ts

@@ -0,0 +1,93 @@
+import type { Command } from "commander";
+import simpleGit from "simple-git";
+import { commitTypes } from "../constants/messages.js";
+import * as git from "../lib/git.js";
+import { error, info, newline, success, text, warning } from "../lib/logger.js";
+import { checkbox, confirm, input, select, withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("commit")
+		.description("Create a commit (interactive or quick)")
+		.option("-m, --message <message>", "Quick commit message")
+		.option("--amend", "Amend last commit")
+		.action(async (options) => {
+			try {
+				if (options.amend) {
+					const sg = simpleGit();
+					await sg.commit("", { "--amend": null, "--no-edit": null });
+					success("Last commit amended.");
+					return;
+				}
+
+				if (options.message) {
+					const hash = await git.commit(options.message);
+					success(`Committed: ${hash}`);
+					return;
+				}
+
+				const status = await git.getStatus();
+
+				if (status.files.length === 0) {
+					warning(
+						"No files to commit. Stage files first or use -m for quick commit.",
+					);
+					return;
+				}
+
+				const fileChoices = status.files.map((f) => ({
+					name: `${f.path} (${f.working_dir || f.index})`,
+					value: f.path,
+					checked: f.index !== " " || f.working_dir !== " ",
+				}));
+
+				const selectedFiles = await checkbox(
+					"Select files to stage",
+					fileChoices,
+				);
+
+				if (selectedFiles.length === 0) {
+					warning("No files selected. Commit cancelled.");
+					return;
+				}
+
+				const sg = simpleGit();
+				await withSpinner("Staging files...", async () => {
+					await sg.add(selectedFiles);
+				});
+
+				newline();
+				const typeChoices = commitTypes.map((t) => ({
+					name: `${t.value.padEnd(10)} ${t.description}`,
+					value: t.value,
+				}));
+				const type = await select("Commit type", typeChoices);
+
+				const scope = await input("Scope (optional)");
+
+				const description = await input("Description");
+
+				const fullMessage = scope
+					? `${type}(${scope}): ${description}`
+					: `${type}: ${description}`;
+
+				newline();
+				info("Commit preview:");
+				text(`  ${fullMessage}`);
+				newline();
+
+				const proceed = await confirm("Proceed with commit?");
+				if (!proceed) {
+					info("Commit cancelled.");
+					return;
+				}
+
+				const hash = await git.commit(fullMessage);
+				success(`Committed: ${hash}`);
+			} catch (err) {
+				error(
+					`Commit failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/config.ts

@@ -0,0 +1,48 @@
+import { spawnSync } from "node:child_process";
+import type { Command } from "commander";
+import { ConfigManager } from "../lib/config.js";
+import { info } from "../lib/logger.js";
+import { showBox } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("config")
+		.description("Manage configuration")
+		.option("--show", "Show config")
+		.option("--edit", "Edit config in editor")
+		.action(async (options) => {
+			try {
+				const config = new ConfigManager();
+
+				if (options.edit) {
+					const editor = process.env.EDITOR || "vim";
+					const configPath = config.getPath();
+					spawnSync(editor, [configPath], { stdio: "inherit" });
+					info("Config edited.");
+					return;
+				}
+
+				const user = config.get("user");
+				const github = config.get("github");
+				const prefs = config.get("preferences");
+
+				const content = [
+					`User:`,
+					`  Name:  ${user.name || "(not set)"}`,
+					`  Email: ${user.email || "(not set)"}`,
+					``,
+					`GitHub:`,
+					`  Token: ${github.token ? (github.token.includes(":") ? "*** (encrypted)" : "***") : "(not set)"}`,
+					``,
+					`Preferences:`,
+					`  Auto Push:       ${prefs.autoPush}`,
+					`  Commit Template: ${prefs.commitTemplate || "(default)"}`,
+					`  Editor:          ${prefs.editor}`,
+				].join("\n");
+
+				showBox("Configuration", content);
+			} catch (err) {
+				info(`Config: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		});
+}

package/src/commands/diff.ts

@@ -0,0 +1,26 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { info, text } from "../lib/logger.js";
+
+export default function register(program: Command): void {
+	program
+		.command("diff")
+		.description("Show changes")
+		.option("--staged", "Show staged changes")
+		.action(async (options) => {
+			try {
+				const output = options.staged
+					? await git.diffStaged()
+					: await git.diff();
+
+				if (!output) {
+					info("No changes.");
+					return;
+				}
+
+				text(output);
+			} catch (err) {
+				info(`Diff: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		});
+}

package/src/commands/fetch.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, success } from "../lib/logger.js";
+import { withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("fetch")
+		.description("Fetch from remote")
+		.action(async () => {
+			try {
+				const result = await withSpinner("Fetching...", () => git.fetch());
+				success(`Fetch complete: ${result}`);
+			} catch (err) {
+				error(
+					`Fetch failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/help.ts

@@ -0,0 +1,58 @@
+import type { Command } from "commander";
+import { newline, text } from "../lib/logger.js";
+import { createTable, showHeader } from "../lib/ui.js";
+
+const commands: { name: string; description: string }[] = [
+	{ name: "setup", description: "Interactive setup wizard" },
+	{ name: "commit", description: "Create a commit (interactive or quick)" },
+	{ name: "push", description: "Push to remote" },
+	{ name: "sync", description: "Pull with rebase" },
+	{ name: "fetch", description: "Fetch from remote" },
+	{ name: "status", description: "Show detailed repository status" },
+	{ name: "log", description: "Show commit history" },
+	{ name: "diff", description: "Show changes" },
+	{ name: "branch", description: "Manage branches" },
+	{ name: "stash", description: "Manage stashes" },
+	{ name: "tag", description: "Manage tags" },
+	{ name: "alias", description: "Manage aliases" },
+	{ name: "config", description: "Manage configuration" },
+	{ name: "undo", description: "Undo last commit (soft reset)" },
+	{ name: "reset", description: "Reset all configuration" },
+	{ name: "help", description: "Show this help" },
+	{ name: "version", description: "Show version" },
+];
+
+export default function register(program: Command): void {
+	program
+		.command("help")
+		.description("Show comprehensive help")
+		.action(async () => {
+			showHeader("Forge - Git CLI");
+
+			const rows = commands.map((c) => [c.name, c.description]);
+			text(createTable(["Command", "Description"], rows));
+
+			newline();
+			showHeader("Usage Examples");
+			text("");
+			text("  fg setup                          Start interactive setup");
+			text('  fg commit -m "fix: resolve issue"  Quick commit with message');
+			text("  fg commit                         Interactive commit");
+			text("  fg push                           Push current branch");
+			text(
+				"  fg push --force                   Force push (with confirmation)",
+			);
+			text("  fg status                         Show repository status");
+			text("  fg log -n 20                      Show last 20 commits");
+			text("  fg branch -n feature-x            Create a new branch");
+			text("  fg branch -s feature-x            Switch to a branch");
+			text("  fg sync                           Pull with rebase");
+			text("  fg diff --staged                  Show staged changes");
+			text("  fg stash                          Stash changes");
+			text("  fg stash --pop                    Apply latest stash");
+			text("  fg alias add co checkout           Create an alias");
+			text("  fg config --show                  View configuration");
+			text("  fg config --edit                  Edit configuration");
+			newline();
+		});
+}

package/src/commands/init.ts

@@ -0,0 +1,37 @@
+import { resolve } from "node:path";
+import type { Command } from "commander";
+import simpleGit from "simple-git";
+import * as git from "../lib/git.js";
+import { error, success } from "../lib/logger.js";
+import { showBox } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("init")
+		.description("Initialize a new Git repository")
+		.argument("[dir]", "Target directory")
+		.option("--initial-commit", "Create an initial commit")
+		.option("--branch <name>", "Set initial branch name")
+		.action(async (dir, options) => {
+			try {
+				const targetDir = dir || ".";
+
+				await git.init(dir, { initialBranch: options.branch });
+
+				if (options.initialCommit) {
+					const sg = simpleGit(resolve(targetDir));
+					await sg.raw(["commit", "--allow-empty", "-m", "Initial commit"]);
+				}
+
+				const absPath = resolve(targetDir);
+				const content = [`Path: ${absPath}`].join("\n");
+				showBox("Repository Initialized", content);
+
+				success(`Git repository initialized at ${absPath}.`);
+			} catch (err) {
+				error(
+					`Init failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/log.ts

@@ -0,0 +1,29 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { info } from "../lib/logger.js";
+import { createTable } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("log")
+		.description("Show commit history")
+		.option("-n, --number <count>", "Number of commits", "10")
+		.action(async (options) => {
+			try {
+				const count = parseInt(options.number, 10) || 10;
+				const commits = await git.log(count);
+
+				const rows = commits.map((c) => [
+					c.hash.substring(0, 7),
+					c.date.substring(0, 10),
+					c.author,
+					c.message.substring(0, 60),
+				]);
+
+				info(`Last ${commits.length} commits:`);
+				console.log(createTable(["Hash", "Date", "Author", "Message"], rows));
+			} catch (err) {
+				info(`Log: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		});
+}

package/src/commands/merge.ts

@@ -0,0 +1,37 @@
+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("merge")
+		.description("Merge branches")
+		.argument("<branch>", "Branch to merge into current")
+		.option(
+			"--no-ff",
+			"Create a merge commit even when fast-forward is possible",
+		)
+		.option("--squash", "Squash commits into one")
+		.option("--no-commit", "Perform merge but do not commit")
+		.action(
+			async (
+				branch: string,
+				options: { noFF?: boolean; squash?: boolean; noCommit?: boolean },
+			) => {
+				try {
+					const currentBranch = await git.getCurrentBranch();
+					info(`Merging '${branch}' into '${currentBranch}'...`);
+					const result = await git.merge(branch, {
+						noFF: options.noFF ?? undefined,
+						squash: options.squash ?? undefined,
+						noCommit: options.noCommit ?? undefined,
+					});
+					success(`Merge completed: ${result}`);
+				} catch (err) {
+					error(
+						`Merge failed: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
+			},
+		);
+}

package/src/commands/push.ts

@@ -0,0 +1,35 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, info, success, warning } from "../lib/logger.js";
+import { confirm, withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("push")
+		.description("Push to remote")
+		.option("--force", "Force push (with warning)")
+		.action(async (options) => {
+			try {
+				const branch = await git.getCurrentBranch();
+				info(`Pushing to origin/${branch}`);
+
+				if (options.force) {
+					warning("Force push will overwrite remote history.");
+					const proceed = await confirm("Are you sure you want to force push?");
+					if (!proceed) {
+						info("Push cancelled.");
+						return;
+					}
+				}
+
+				const result = await withSpinner("Pushing...", () =>
+					git.push(!!options.force),
+				);
+				success(`Push complete: ${result}`);
+			} catch (err) {
+				error(
+					`Push failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/remote.ts

@@ -0,0 +1,107 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, info, success } from "../lib/logger.js";
+import { confirm, createTable } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	const remote = program.command("remote").description("Manage remotes");
+
+	remote
+		.command("add <name> <url>")
+		.description("Add a new remote")
+		.action(async (name, url) => {
+			try {
+				await git.remoteAdd(name, url);
+				success(`Remote '${name}' added (${url}).`);
+			} catch (err) {
+				error(
+					`Failed to add remote: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	remote
+		.command("remove <name>")
+		.description("Remove a remote")
+		.action(async (name) => {
+			try {
+				const confirmed = await confirm(
+					`Are you sure you want to remove remote '${name}'?`,
+					false,
+				);
+
+				if (!confirmed) {
+					info("Canceled.");
+					return;
+				}
+
+				await git.remoteRemove(name);
+				success(`Remote '${name}' removed.`);
+			} catch (err) {
+				error(
+					`Failed to remove remote: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	remote
+		.command("set-url <name> <new-url>")
+		.description("Change a remote URL")
+		.action(async (name, newUrl) => {
+			try {
+				await git.remoteSetUrl(name, newUrl);
+				success(`Remote '${name}' URL updated to ${newUrl}.`);
+			} catch (err) {
+				error(
+					`Failed to update remote URL: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	remote
+		.command("rename <old-name> <new-name>")
+		.description("Rename a remote")
+		.action(async (oldName, newName) => {
+			try {
+				await git.remoteRename(oldName, newName);
+				success(`Remote '${oldName}' renamed to '${newName}'.`);
+			} catch (err) {
+				error(
+					`Failed to rename remote: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	remote
+		.command("get-url <name>")
+		.description("Get the URL of a remote")
+		.action(async (name) => {
+			try {
+				const url = await git.remoteGetUrl(name);
+				info(`Remote '${name}': ${url}`);
+			} catch (err) {
+				error(
+					`Failed to get remote URL: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	remote.action(async () => {
+		try {
+			const remotes = await git.remoteList();
+
+			if (remotes.length === 0) {
+				info("No remotes configured.");
+				return;
+			}
+
+			const rows = remotes.map((r) => [r.name, r.url]);
+			info("Remotes:");
+			console.log(createTable(["Name", "URL"], rows));
+		} catch (err) {
+			error(
+				`Failed to list remotes: ${err instanceof Error ? err.message : String(err)}`,
+			);
+		}
+	});
+}

package/src/commands/reset.ts

@@ -0,0 +1,30 @@
+import type { Command } from "commander";
+import { ConfigManager } from "../lib/config.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("reset")
+		.description("Reset all configuration")
+		.action(async () => {
+			try {
+				warning("This will delete all Forge configuration.");
+				const proceed = await confirm(
+					"Are you sure? This will delete all configuration",
+				);
+				if (!proceed) {
+					info("Reset cancelled.");
+					return;
+				}
+
+				const config = new ConfigManager();
+				config.clear();
+				success("Configuration reset successfully.");
+			} catch (err) {
+				error(
+					`Reset failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/setup.ts

@@ -0,0 +1,95 @@
+import type { Command } from "commander";
+import { encryptToken } from "../lib/auth.js";
+import { ConfigManager } from "../lib/config.js";
+import { error, info, newline, success, warning } from "../lib/logger.js";
+import { confirm, input, password, showBox } from "../lib/ui.js";
+import {
+	validateEmail,
+	validateGitHubToken,
+	validateGitInstalled,
+} from "../lib/validators.js";
+
+export default function register(program: Command): void {
+	program
+		.command("setup")
+		.description("Interactive setup wizard")
+		.action(async () => {
+			try {
+				const config = new ConfigManager();
+
+				if (config.isConfigured()) {
+					warning("Forge is already configured. You are about to reconfigure.");
+					const proceed = await confirm("Continue with reconfiguration?");
+					if (!proceed) {
+						info("Setup cancelled.");
+						return;
+					}
+				}
+
+				const gitInstalled = await validateGitInstalled();
+				if (!gitInstalled) {
+					error("Git is not installed. Please install Git first.");
+					return;
+				}
+
+				newline();
+				info("Starting setup...");
+				newline();
+
+				const name = await input("Your name");
+
+				let email = await input("Your email");
+				while (!validateEmail(email)) {
+					error("Invalid email format.");
+					email = await input("Your email");
+				}
+
+				let token = await input("GitHub token (optional)");
+				if (token && !validateGitHubToken(token)) {
+					warning("Token format looks unusual. It will be saved as-is.");
+				}
+
+				if (token) {
+					const encrypt = await confirm(
+						"Encrypt token with a master password?",
+						false,
+					);
+					if (encrypt) {
+						const masterPassword = await password("Master password:");
+						token = await encryptToken(token, masterPassword);
+						success("Token encrypted successfully.");
+					}
+				}
+
+				config.set("user", { name, email });
+				config.set("github", { token });
+				config.set("preferences", {
+					autoPush: false,
+					commitTemplate: "",
+					editor: process.env.EDITOR || "vim",
+				});
+
+				newline();
+				const tokenStatus = token
+					? token.includes(":")
+						? "Set (encrypted)"
+						: "Set"
+					: "Not set";
+				showBox(
+					"Configuration Complete",
+					[
+						`User:     ${name} <${email}>`,
+						`Token:    ${tokenStatus}`,
+						`Git:      Installed`,
+						`Config:   ${config.getPath()}`,
+					].join("\n"),
+				);
+
+				success("Forge is ready to use!");
+			} catch (err) {
+				error(
+					`Setup failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/stash.ts

@@ -0,0 +1,44 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { error, info, success } from "../lib/logger.js";
+import { createTable, input, withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("stash")
+		.description("Manage stashes")
+		.option("--pop", "Apply and remove latest stash")
+		.option("--list", "List all stashes")
+		.action(async (options) => {
+			try {
+				if (options.pop) {
+					const result = await withSpinner("Applying stash...", () =>
+						git.stashPop(),
+					);
+					success(`Stash popped: ${result}`);
+					return;
+				}
+
+				if (options.list) {
+					const stashes = await git.stashList();
+					if (stashes.length === 0) {
+						info("No stashes found.");
+						return;
+					}
+
+					const rows = stashes.map((s) => [String(s.index), s.description]);
+					info("Stashes:");
+					console.log(createTable(["#", "Description"], rows));
+					return;
+				}
+
+				const _message = await input("Stash message (optional)");
+				const result = await withSpinner("Stashing...", () => git.stash());
+				success(`Stash saved: ${result}`);
+			} catch (err) {
+				error(
+					`Stash operation failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}