@hallaxius/forge 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hallaxius/forge",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"description": "A modern Git CLI with professional UX",
 	"author": "hallaxius",
 	"license": "MIT",
@@ -26,14 +26,16 @@
 		"major": "npm version major && npm publish"
 	},
 	"dependencies": {
+		"@octokit/rest": "^21.1.0",
 		"boxen": "^7.1.0",
 		"chalk": "^5.3.0",
 		"commander": "^12.0.0",
 		"conf": "^12.0.0",
+		"diff": "^7.0.0",
 		"figures": "^5.0.0",
 		"inquirer": "^14.0.2",
-		"ora": "^8.0.0",
-		"simple-git": "^3.22.0"
+		"isomorphic-git": "^1.38.0",
+		"ora": "^8.0.0"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.1",
@@ -67,6 +69,7 @@
 		"developer-tools",
 		"productivity",
 		"bun",
-		"command-line"
+		"command-line",
+		"github-api"
 	]
 }

package/src/cli.ts

@@ -18,11 +18,9 @@ program
 	.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 registerCi from "./commands/ci.js";
 import registerClone from "./commands/clone.js";
 import registerCommit from "./commands/commit.js";
 import registerConfig from "./commands/config.js";
@@ -30,9 +28,12 @@ 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 registerIssue from "./commands/issue.js";
 import registerLog from "./commands/log.js";
 import registerMerge from "./commands/merge.js";
+import registerPr from "./commands/pr.js";
 import registerPush from "./commands/push.js";
+import registerRelease from "./commands/release.js";
 import registerRemote from "./commands/remote.js";
 import registerReset from "./commands/reset.js";
 import registerSetup from "./commands/setup.js";
@@ -42,7 +43,6 @@ 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);
@@ -64,12 +64,12 @@ registerVersion(program);
 registerClone(program);
 registerInit(program);
 registerRemote(program);
-registerWorktree(program);
+
+registerCi(program);
+registerIssue(program);
 registerMerge(program);
-registerCherryPick(program);
-registerClean(program);
-registerArchive(program);
-registerBisect(program);
+registerPr(program);
+registerRelease(program);
 
 if (process.argv.length <= 2) {
 	program.outputHelp();

package/src/commands/ci.ts

@@ -0,0 +1,28 @@
+import type { Command } from "commander";
+import { getCIStatus } from "../lib/github.js";
+import { error, info } from "../lib/logger.js";
+import { createTable, withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("ci")
+		.description("Check CI status")
+		.action(async () => {
+			try {
+				const checks = await withSpinner("Fetching CI status...", () =>
+					getCIStatus(),
+				);
+				if (checks.length === 0) {
+					info("No CI checks found.");
+					return;
+				}
+				const rows = checks.map((c) => [c.name, c.conclusion, c.branch]);
+				info("CI Checks:");
+				console.log(createTable(["Name", "Status", "Branch"], rows));
+			} catch (err) {
+				error(
+					`CI check failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/commit.ts

@@ -1,5 +1,4 @@
 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";
@@ -14,8 +13,7 @@ export default function register(program: Command): void {
 		.action(async (options) => {
 			try {
 				if (options.amend) {
-					const sg = simpleGit();
-					await sg.commit("", { "--amend": null, "--no-edit": null });
+					await git.amendCommit();
 					success("Last commit amended.");
 					return;
 				}
@@ -51,10 +49,7 @@ export default function register(program: Command): void {
 					return;
 				}
 
-				const sg = simpleGit();
-				await withSpinner("Staging files...", async () => {
-					await sg.add(selectedFiles);
-				});
+				await withSpinner("Staging files...", () => git.add(selectedFiles));
 
 				newline();
 				const typeChoices = commitTypes.map((t) => ({

package/src/commands/init.ts

@@ -1,6 +1,4 @@
-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";
@@ -19,15 +17,13 @@ export default function register(program: Command): void {
 				await git.init(dir, { initialBranch: options.branch });
 
 				if (options.initialCommit) {
-					const sg = simpleGit(resolve(targetDir));
-					await sg.raw(["commit", "--allow-empty", "-m", "Initial commit"]);
+					await git.commit("Initial commit");
 				}
 
-				const absPath = resolve(targetDir);
-				const content = [`Path: ${absPath}`].join("\n");
+				const content = [`Path: ${targetDir}`].join("\n");
 				showBox("Repository Initialized", content);
 
-				success(`Git repository initialized at ${absPath}.`);
+				success(`Git repository initialized at ${targetDir}.`);
 			} catch (err) {
 				error(
 					`Init failed: ${err instanceof Error ? err.message : String(err)}`,

package/src/commands/issue.ts

@@ -0,0 +1,63 @@
+import type { Command } from "commander";
+import { createIssue, listIssues } from "../lib/github.js";
+import { error, info, success } from "../lib/logger.js";
+import { createTable, input, withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	const issue = program.command("issue").description("Manage issues");
+
+	issue
+		.command("create")
+		.description("Create an issue")
+		.option("-t, --title <title>", "Issue title")
+		.action(async (options) => {
+			try {
+				const title = options.title || (await input("Issue title"));
+				if (!title) {
+					error("Title is required.");
+					return;
+				}
+				const body = await input("Description (optional)");
+				const result = await withSpinner("Creating issue...", () =>
+					createIssue(title, body),
+				);
+				success(`Issue #${result.number} created: ${result.url}`);
+			} catch (err) {
+				error(
+					`Issue creation failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	issue
+		.command("list")
+		.description("List issues")
+		.option(
+			"-s, --state <state>",
+			"Filter by state (open, closed, all)",
+			"open",
+		)
+		.action(async (options) => {
+			try {
+				const issues = await withSpinner("Fetching issues...", () =>
+					listIssues(options.state),
+				);
+				if (issues.length === 0) {
+					info("No issues found.");
+					return;
+				}
+				const rows = issues.map((i) => [
+					`#${i.number}`,
+					i.title.substring(0, 60),
+					i.state,
+					i.author,
+				]);
+				info("Issues:");
+				console.log(createTable(["#", "Title", "State", "Author"], rows));
+			} catch (err) {
+				error(
+					`Failed to list issues: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/pr.ts

@@ -0,0 +1,65 @@
+import type { Command } from "commander";
+import { createPR, listPRs } from "../lib/github.js";
+import { error, info, success } from "../lib/logger.js";
+import { createTable, input, withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	const pr = program.command("pr").description("Manage pull requests");
+
+	pr.command("create")
+		.description("Create a pull request")
+		.option("-t, --title <title>", "PR title")
+		.option("-H, --head <branch>", "Source branch (default: current branch)")
+		.option("-B, --base <branch>", "Target branch (default: main)")
+		.action(async (options) => {
+			try {
+				const title = options.title || (await input("PR title"));
+				if (!title) {
+					error("Title is required.");
+					return;
+				}
+				const head = options.head || (await input("Source branch"));
+				const base = options.base || (await input("Target branch", "main"));
+				const body = await input("Description (optional)");
+				const result = await withSpinner("Creating PR...", () =>
+					createPR(title, body, head, base),
+				);
+				success(`PR #${result.number} created: ${result.url}`);
+			} catch (err) {
+				error(
+					`PR creation failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	pr.command("list")
+		.description("List pull requests")
+		.option(
+			"-s, --state <state>",
+			"Filter by state (open, closed, all)",
+			"open",
+		)
+		.action(async (options) => {
+			try {
+				const prs = await withSpinner("Fetching PRs...", () =>
+					listPRs(options.state),
+				);
+				if (prs.length === 0) {
+					info("No pull requests found.");
+					return;
+				}
+				const rows = prs.map((p) => [
+					`#${p.number}`,
+					p.title.substring(0, 60),
+					p.state,
+					p.author,
+				]);
+				info("Pull Requests:");
+				console.log(createTable(["#", "Title", "State", "Author"], rows));
+			} catch (err) {
+				error(
+					`Failed to list PRs: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/release.ts

@@ -0,0 +1,26 @@
+import type { Command } from "commander";
+import { createRelease } from "../lib/github.js";
+import { error, success } from "../lib/logger.js";
+import { input, withSpinner } from "../lib/ui.js";
+
+export default function register(program: Command): void {
+	program
+		.command("release")
+		.description("Create a GitHub release")
+		.argument("<tag>", "Git tag name")
+		.option("-n, --name <name>", "Release name")
+		.action(async (tag, options) => {
+			try {
+				const name = options.name || (await input("Release name", tag));
+				const body = await input("Release description (optional)");
+				const result = await withSpinner("Creating release...", () =>
+					createRelease(tag, name, body),
+				);
+				success(`Release created: ${result.url}`);
+			} catch (err) {
+				error(
+					`Release creation failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/setup.ts

@@ -1,13 +1,9 @@
 import type { Command } from "commander";
-import { encryptToken } from "../lib/auth.js";
+import { encryptToken, generateMachineKey } 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";
+import { validateEmail } from "../lib/validators.js";
 
 export default function register(program: Command): void {
 	program
@@ -26,12 +22,6 @@ export default function register(program: Command): void {
 					}
 				}
 
-				const gitInstalled = await validateGitInstalled();
-				if (!gitInstalled) {
-					error("Git is not installed. Please install Git first.");
-					return;
-				}
-
 				newline();
 				info("Starting setup...");
 				newline();
@@ -44,25 +34,39 @@ export default function register(program: Command): void {
 					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.");
+				const rawToken = await input(
+					"GitHub token (required for remote operations)",
+				);
+				if (!rawToken) {
+					error(
+						"GitHub token is required. Get one at https://github.com/settings/tokens",
+					);
+					return;
 				}
 
-				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.");
-					}
+				const useMasterPassword = await confirm(
+					"Protect token with a master password? (recommended)",
+					true,
+				);
+
+				const machineKey = generateMachineKey();
+				let hasMasterPassword = false;
+
+				if (useMasterPassword) {
+					const mp = await password("Master password:");
+					const encryptedKey = await encryptToken(machineKey, mp);
+					config.set("auth.machineKey", encryptedKey);
+					config.set("auth.hasMasterPassword", true);
+					hasMasterPassword = true;
+				} else {
+					config.set("auth.machineKey", machineKey);
+					config.set("auth.hasMasterPassword", false);
 				}
 
+				const encryptedToken = await encryptToken(rawToken, machineKey);
+				config.set("github.encryptedToken", encryptedToken);
+
 				config.set("user", { name, email });
-				config.set("github", { token });
 				config.set("preferences", {
 					autoPush: false,
 					commitTemplate: "",
@@ -70,17 +74,12 @@ export default function register(program: Command): void {
 				});
 
 				newline();
-				const tokenStatus = token
-					? token.includes(":")
-						? "Set (encrypted)"
-						: "Set"
-					: "Not set";
 				showBox(
 					"Configuration Complete",
 					[
 						`User:     ${name} <${email}>`,
-						`Token:    ${tokenStatus}`,
-						`Git:      Installed`,
+						`Token:    Set (encrypted)`,
+						`Security: ${hasMasterPassword ? "Master password protected" : "Machine key"}`,
 						`Config:   ${config.getPath()}`,
 					].join("\n"),
 				);

package/src/lib/auth.ts

@@ -1,8 +1,13 @@
+import { createInterface } from "node:readline";
+import { ConfigManager } from "./config.js";
+
 const ITERATIONS = 100000;
 const KEY_LENGTH = 256;
 const SALT_LENGTH = 32;
 const IV_LENGTH = 12;
 
+let cachedToken: string | null = null;
+
 function base64Encode(buf: Uint8Array): string {
 	return btoa(String.fromCharCode(...buf));
 }
@@ -19,6 +24,10 @@ export function generateIV(): Uint8Array {
 	return crypto.getRandomValues(new Uint8Array(IV_LENGTH));
 }
 
+export function generateMachineKey(): string {
+	return base64Encode(crypto.getRandomValues(new Uint8Array(32)));
+}
+
 async function deriveKey(
 	password: string,
 	salt: Uint8Array,
@@ -31,14 +40,8 @@ async function deriveKey(
 		false,
 		["deriveKey"],
 	);
-
 	return crypto.subtle.deriveKey(
-		{
-			name: "PBKDF2",
-			salt,
-			iterations: ITERATIONS,
-			hash: "SHA-256",
-		},
+		{ name: "PBKDF2", salt, iterations: ITERATIONS, hash: "SHA-256" },
 		keyMaterial,
 		{ name: "AES-GCM", length: KEY_LENGTH },
 		false,
@@ -48,48 +51,122 @@ async function deriveKey(
 
 export async function encryptToken(
 	token: string,
-	password: string,
+	key: string,
 ): Promise<string> {
 	const salt = generateSalt();
 	const iv = generateIV();
-	const key = await deriveKey(password, salt);
+	const derivedKey = await deriveKey(key, salt);
 	const encoder = new TextEncoder();
 	const encrypted = await crypto.subtle.encrypt(
 		{ name: "AES-GCM", iv },
-		key,
+		derivedKey,
 		encoder.encode(token),
 	);
-
 	const parts = [
 		base64Encode(salt),
 		base64Encode(iv),
 		base64Encode(new Uint8Array(encrypted)),
 	];
-
 	return parts.join(":");
 }
 
 export async function decryptToken(
 	encryptedData: string,
-	password: string,
+	key: string,
 ): Promise<string> {
 	const parts = encryptedData.split(":");
 	if (parts.length !== 3) {
 		throw new Error("Invalid encrypted data format");
 	}
-
 	const [saltB64, ivB64, ciphertextB64] = parts;
 	const salt = base64Decode(saltB64);
 	const iv = base64Decode(ivB64);
 	const ciphertext = base64Decode(ciphertextB64);
-	const key = await deriveKey(password, salt);
-
+	const derivedKey = await deriveKey(key, salt);
 	const decrypted = await crypto.subtle.decrypt(
 		{ name: "AES-GCM", iv },
-		key,
+		derivedKey,
 		ciphertext,
 	);
-
 	const decoder = new TextDecoder();
 	return decoder.decode(decrypted);
 }
+
+export function cacheToken(token: string): void {
+	cachedToken = token;
+}
+
+export function getCachedToken(): string | null {
+	return cachedToken;
+}
+
+export function clearTokenCache(): void {
+	cachedToken = null;
+}
+
+function promptPassword(): Promise<string> {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+	return new Promise((resolve) => {
+		rl.question("Master password: ", (answer: string) => {
+			rl.close();
+			resolve(answer);
+		});
+	});
+}
+
+export async function resolveToken(): Promise<string> {
+	if (cachedToken) return cachedToken;
+
+	const config = new ConfigManager();
+	const encryptedToken = config.get("github.encryptedToken") as string;
+	if (!encryptedToken) {
+		throw new Error("No GitHub token configured. Run 'fg setup' first.");
+	}
+
+	const hasMasterPassword = config.get("auth.hasMasterPassword") as boolean;
+
+	let machineKey: string;
+	if (hasMasterPassword) {
+		const encryptedKey = config.get("auth.machineKey") as string;
+		const password = await promptPassword();
+		machineKey = await decryptToken(encryptedKey, password);
+	} else {
+		machineKey = config.get("auth.machineKey") as string;
+	}
+
+	const token = await decryptToken(encryptedToken, machineKey);
+	cachedToken = token;
+	return token;
+}
+
+export async function resolveTokenWithPassword(
+	password?: string,
+): Promise<string> {
+	if (cachedToken) return cachedToken;
+
+	const config = new ConfigManager();
+	const encryptedToken = config.get("github.encryptedToken") as string;
+	if (!encryptedToken) {
+		throw new Error("No GitHub token configured. Run 'fg setup' first.");
+	}
+
+	const hasMasterPassword = config.get("auth.hasMasterPassword") as boolean;
+
+	let machineKey: string;
+	if (hasMasterPassword) {
+		const encryptedKey = config.get("auth.machineKey") as string;
+		if (!password) {
+			throw new Error("Master password required to decrypt token.");
+		}
+		machineKey = await decryptToken(encryptedKey, password);
+	} else {
+		machineKey = config.get("auth.machineKey") as string;
+	}
+
+	const token = await decryptToken(encryptedToken, machineKey);
+	cachedToken = token;
+	return token;
+}

package/src/lib/config.ts

@@ -8,7 +8,11 @@ export interface ForgeConfig {
 		email: string;
 	};
 	github: {
-		token: string;
+		encryptedToken: string;
+	};
+	auth: {
+		machineKey: string;
+		hasMasterPassword: boolean;
 	};
 	preferences: {
 		autoPush: boolean;
@@ -20,7 +24,8 @@ export interface ForgeConfig {
 
 const DEFAULTS: ForgeConfig = {
 	user: { name: "", email: "" },
-	github: { token: "" },
+	github: { encryptedToken: "" },
+	auth: { machineKey: "", hasMasterPassword: false },
 	preferences: {
 		autoPush: false,
 		commitTemplate: "",
@@ -69,7 +74,11 @@ export class ConfigManager {
 				email: this.conf.get("user.email") as string,
 			},
 			github: {
-				token: this.conf.get("github.token") as string,
+				encryptedToken: this.conf.get("github.encryptedToken") as string,
+			},
+			auth: {
+				machineKey: this.conf.get("auth.machineKey") as string,
+				hasMasterPassword: this.conf.get("auth.hasMasterPassword") as boolean,
 			},
 			preferences: {
 				autoPush: this.conf.get("preferences.autoPush") as boolean,