@hallaxius/forge 0.1.0

package/src/commands/status.ts

@@ -0,0 +1,74 @@
+import type { Command } from "commander";
+import * as git from "../lib/git.js";
+import { info, newline, text } from "../lib/logger.js";
+import { createTable, showHeader, showSeparator } from "../lib/ui.js";
+
+function statusIcon(code: string): string {
+	switch (code) {
+		case "M":
+			return "M";
+		case "A":
+			return "A";
+		case "D":
+			return "D";
+		case "?":
+			return "?";
+		default:
+			return " ";
+	}
+}
+
+export default function register(program: Command): void {
+	program
+		.command("status")
+		.description("Show detailed repository status")
+		.action(async () => {
+			try {
+				const status = await git.getStatus();
+
+				showHeader(`Branch: ${status.current}`);
+				if (status.tracking) {
+					info(`Tracking: ${status.tracking}`);
+				}
+
+				if (status.ahead > 0 || status.behind > 0) {
+					const ahead = status.ahead > 0 ? `${status.ahead} ahead` : "";
+					const behind = status.behind > 0 ? `${status.behind} behind` : "";
+					const sep = ahead && behind ? " | " : "";
+					info(`${ahead}${sep}${behind}`);
+				}
+
+				newline();
+
+				if (status.files.length > 0) {
+					info("Files:");
+					const fileRows = status.files.map((f) => [
+						f.path,
+						statusIcon(f.index),
+						statusIcon(f.working_dir),
+					]);
+					text(createTable(["File", "Index", "Working"], fileRows));
+				} else {
+					info("Working tree clean.");
+				}
+
+				newline();
+				showSeparator();
+				newline();
+
+				if (status.recentCommits.length > 0) {
+					info("Recent commits:");
+					const commitRows = status.recentCommits
+						.slice(0, 3)
+						.map((c) => [
+							c.hash.substring(0, 7),
+							c.date.substring(0, 10),
+							c.message.substring(0, 50),
+						]);
+					text(createTable(["Hash", "Date", "Message"], commitRows));
+				}
+			} catch (err) {
+				info(`Status: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		});
+}

package/src/commands/sync.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("sync")
+		.description("Pull with rebase")
+		.action(async () => {
+			try {
+				const result = await withSpinner("Syncing...", () => git.pullRebase());
+				success(`Sync complete: ${result}`);
+			} catch (err) {
+				error(
+					`Sync failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/tag.ts

@@ -0,0 +1,41 @@
+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("tag")
+		.description("Manage tags")
+		.option("-n, --name <name>", "Create tag")
+		.option("-m, --message <message>", "Tag message")
+		.option("--list", "List tags")
+		.action(async (options) => {
+			try {
+				if (options.list) {
+					const tags = await git.tagList();
+					if (tags.length === 0) {
+						info("No tags found.");
+						return;
+					}
+
+					const rows = tags.map((t) => [t]);
+					info("Tags:");
+					console.log(createTable(["Name"], rows));
+					return;
+				}
+
+				if (options.name) {
+					const tagName = await git.tag(options.name, options.message);
+					success(`Tag '${tagName}' created.`);
+					return;
+				}
+
+				info("Use --name to create a tag or --list to list tags.");
+			} catch (err) {
+				error(
+					`Tag operation failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/undo.ts

@@ -0,0 +1,27 @@
+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("undo")
+		.description("Undo last commit (soft reset)")
+		.action(async () => {
+			try {
+				warning("This will undo the last commit using a soft reset.");
+				const proceed = await confirm("Are you sure?");
+				if (!proceed) {
+					info("Undo cancelled.");
+					return;
+				}
+
+				const result = await git.undo();
+				success(`Undo complete: ${result}`);
+			} catch (err) {
+				error(
+					`Undo failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/commands/version.ts

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Command } from "commander";
+import { info } from "../lib/logger.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(
+	readFileSync(join(__dirname, "../../package.json"), "utf-8"),
+);
+
+export default function register(program: Command): void {
+	program
+		.command("version")
+		.description("Show version")
+		.action(async () => {
+			info(`Forge v${pkg.version}`);
+		});
+}

package/src/commands/worktree.ts

@@ -0,0 +1,92 @@
+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 {
+	const cmd = program.command("worktree").description("Manage worktrees");
+
+	cmd
+		.command("add")
+		.description("Add a new worktree")
+		.argument("<path>", "Path for the new worktree")
+		.argument("[branch]", "Branch to checkout")
+		.option("--new", "Create and checkout a new branch")
+		.option("--detach", "Checkout detached HEAD")
+		.action(
+			async (
+				path: string,
+				branch: string | undefined,
+				options: { new?: boolean; detach?: boolean },
+			) => {
+				try {
+					await git.worktreeAdd(path, branch, {
+						new: options.new,
+						detach: options.detach,
+					});
+					success(`Worktree added at '${path}'.`);
+				} catch (err) {
+					error(
+						`Worktree add failed: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
+			},
+		);
+
+	cmd
+		.command("list")
+		.description("List all worktrees")
+		.action(async () => {
+			try {
+				const entries = await git.worktreeList();
+				if (entries.length === 0) {
+					info("No worktrees found.");
+					return;
+				}
+				const rows = entries.map((e) => [e.path, e.branch, e.hash]);
+				console.log(createTable(["Path", "Branch", "Hash"], rows));
+			} catch (err) {
+				error(
+					`Worktree list failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	cmd
+		.command("remove")
+		.description("Remove a worktree")
+		.argument("<path>", "Path of the worktree to remove")
+		.option("--force", "Force removal")
+		.action(async (path: string, options: { force?: boolean }) => {
+			try {
+				await git.worktreeRemove(path, options.force);
+				success(`Worktree '${path}' removed.`);
+			} catch (err) {
+				error(
+					`Worktree remove failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+
+	cmd
+		.command("prune")
+		.description("Prune stale worktree references")
+		.option("--dry-run", "Only show what would be pruned")
+		.action(async (options: { dryRun?: boolean }) => {
+			try {
+				const result = await git.worktreePrune(options.dryRun);
+				if (result.length === 0) {
+					info("Nothing to prune.");
+					return;
+				}
+				for (const line of result) {
+					info(line);
+				}
+				success(`Pruned ${result.length} reference(s).`);
+			} catch (err) {
+				error(
+					`Worktree prune failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		});
+}

package/src/constants/colors.ts

@@ -0,0 +1,7 @@
+export const colors = {
+	success: "#00ff87",
+	warning: "#ffd700",
+	error: "#ff4444",
+	info: "#00d4ff",
+	highlight: "#ff6bff",
+} as const;

package/src/constants/commit-types.ts

@@ -0,0 +1,24 @@
+export const CommitType = {
+	FEAT: "feat",
+	FIX: "fix",
+	DOCS: "docs",
+	STYLE: "style",
+	REFACTOR: "refactor",
+	TEST: "test",
+	CHORE: "chore",
+} as const;
+
+export type CommitType = (typeof CommitType)[keyof typeof CommitType];
+
+export const commitTypes: { value: CommitType; description: string }[] = [
+	{ value: CommitType.FEAT, description: "A new feature" },
+	{ value: CommitType.FIX, description: "A bug fix" },
+	{ value: CommitType.DOCS, description: "Documentation only changes" },
+	{
+		value: CommitType.STYLE,
+		description: "Code style changes (formatting, etc)",
+	},
+	{ value: CommitType.REFACTOR, description: "Code refactoring" },
+	{ value: CommitType.TEST, description: "Adding or fixing tests" },
+	{ value: CommitType.CHORE, description: "Build process or tool changes" },
+];

package/src/constants/messages.ts

@@ -0,0 +1,23 @@
+export const icons = {
+	success: "\u2713",
+	error: "\u2717",
+	warning: "\u26A0",
+	info: "\u25CB",
+	highlight: "\u00BB",
+};
+
+export const formatting = {
+	header: "\u2550".repeat(30),
+	separator: "\u2500".repeat(25),
+	indent: "  ",
+};
+
+export const commitTypes = [
+	{ value: "feat", description: "A new feature" },
+	{ value: "fix", description: "A bug fix" },
+	{ value: "docs", description: "Documentation only changes" },
+	{ value: "style", description: "Code style changes (formatting, etc)" },
+	{ value: "refactor", description: "Code refactoring" },
+	{ value: "test", description: "Adding or fixing tests" },
+	{ value: "chore", description: "Build process or tool changes" },
+] as const;

package/src/lib/auth.ts

@@ -0,0 +1,95 @@
+const ITERATIONS = 100000;
+const KEY_LENGTH = 256;
+const SALT_LENGTH = 32;
+const IV_LENGTH = 12;
+
+function base64Encode(buf: Uint8Array): string {
+	return btoa(String.fromCharCode(...buf));
+}
+
+function base64Decode(str: string): Uint8Array {
+	return Uint8Array.from(atob(str), (c) => c.charCodeAt(0));
+}
+
+export function generateSalt(length: number = SALT_LENGTH): Uint8Array {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+
+export function generateIV(): Uint8Array {
+	return crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+}
+
+async function deriveKey(
+	password: string,
+	salt: Uint8Array,
+): Promise<CryptoKey> {
+	const encoder = new TextEncoder();
+	const keyMaterial = await crypto.subtle.importKey(
+		"raw",
+		encoder.encode(password),
+		"PBKDF2",
+		false,
+		["deriveKey"],
+	);
+
+	return crypto.subtle.deriveKey(
+		{
+			name: "PBKDF2",
+			salt,
+			iterations: ITERATIONS,
+			hash: "SHA-256",
+		},
+		keyMaterial,
+		{ name: "AES-GCM", length: KEY_LENGTH },
+		false,
+		["encrypt", "decrypt"],
+	);
+}
+
+export async function encryptToken(
+	token: string,
+	password: string,
+): Promise<string> {
+	const salt = generateSalt();
+	const iv = generateIV();
+	const key = await deriveKey(password, salt);
+	const encoder = new TextEncoder();
+	const encrypted = await crypto.subtle.encrypt(
+		{ name: "AES-GCM", iv },
+		key,
+		encoder.encode(token),
+	);
+
+	const parts = [
+		base64Encode(salt),
+		base64Encode(iv),
+		base64Encode(new Uint8Array(encrypted)),
+	];
+
+	return parts.join(":");
+}
+
+export async function decryptToken(
+	encryptedData: string,
+	password: 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 decrypted = await crypto.subtle.decrypt(
+		{ name: "AES-GCM", iv },
+		key,
+		ciphertext,
+	);
+
+	const decoder = new TextDecoder();
+	return decoder.decode(decrypted);
+}

package/src/lib/config.ts

@@ -0,0 +1,99 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import Conf from "conf";
+
+export interface ForgeConfig {
+	user: {
+		name: string;
+		email: string;
+	};
+	github: {
+		token: string;
+	};
+	preferences: {
+		autoPush: boolean;
+		commitTemplate: string;
+		editor: string;
+	};
+	clones: string[];
+}
+
+const DEFAULTS: ForgeConfig = {
+	user: { name: "", email: "" },
+	github: { token: "" },
+	preferences: {
+		autoPush: false,
+		commitTemplate: "",
+		editor: process.env.EDITOR || "vim",
+	},
+	clones: [],
+};
+
+const configPath = join(homedir(), ".forge");
+
+export class ConfigManager {
+	private conf: Conf<ForgeConfig>;
+
+	constructor(options?: { configName?: string; cwd?: string }) {
+		this.conf = new Conf<ForgeConfig>({
+			configName: options?.configName || "forge",
+			cwd: options?.cwd || configPath,
+			defaults: DEFAULTS,
+		});
+	}
+
+	get(key: string): any {
+		return this.conf.get(key);
+	}
+
+	set(key: string, value: any): void {
+		this.conf.set(key, value);
+	}
+
+	delete(key: string): void {
+		this.conf.delete(key);
+	}
+
+	clear(): void {
+		this.conf.clear();
+	}
+
+	getPath(): string {
+		return this.conf.path;
+	}
+
+	getAll(): ForgeConfig & { clones: string[] } {
+		return {
+			user: {
+				name: this.conf.get("user.name") as string,
+				email: this.conf.get("user.email") as string,
+			},
+			github: {
+				token: this.conf.get("github.token") as string,
+			},
+			preferences: {
+				autoPush: this.conf.get("preferences.autoPush") as boolean,
+				commitTemplate: this.conf.get("preferences.commitTemplate") as string,
+				editor: this.conf.get("preferences.editor") as string,
+			},
+			clones: this.getClones(),
+		};
+	}
+
+	addClone(entry: string): void {
+		const clones = (this.conf.get("clones") as string[]) || [];
+		clones.unshift(entry);
+		if (clones.length > 10) clones.length = 10;
+		this.conf.set("clones", clones);
+	}
+
+	getClones(): string[] {
+		return (this.conf.get("clones") as string[]) || [];
+	}
+
+	isConfigured(): boolean {
+		const name = this.conf.get("user.name") as string;
+		const email = this.conf.get("user.email") as string;
+		return !!(name && email);
+	}
+}