@hallaxius/forge 0.1.0

package/src/lib/git.ts

@@ -0,0 +1,382 @@
+import simpleGit from "simple-git";
+
+const git = simpleGit();
+
+interface StatusResult {
+	current: string;
+	tracking: string;
+	ahead: number;
+	behind: number;
+	files: { path: string; working_dir: string; index: string }[];
+	recentCommits: { hash: string; date: string; message: string }[];
+}
+
+interface LogEntry {
+	hash: string;
+	date: string;
+	message: string;
+	author: string;
+}
+
+interface BranchesResult {
+	current: string;
+	branches: string[];
+	all: string[];
+}
+
+interface StashEntry {
+	index: number;
+	description: string;
+}
+
+export async function getStatus(): Promise<StatusResult> {
+	const status = await git.status();
+	const log = await git.log({ maxCount: 5 });
+
+	return {
+		current: status.current || "",
+		tracking: status.tracking || "",
+		ahead: status.ahead,
+		behind: status.behind,
+		files: status.files.map((f) => ({
+			path: f.path,
+			working_dir: f.working_dir,
+			index: f.index,
+		})),
+		recentCommits: log.all.map((c) => ({
+			hash: c.hash,
+			date: c.date,
+			message: c.message,
+		})),
+	};
+}
+
+export async function commit(message: string): Promise<string> {
+	const result = await git.commit(message);
+	return result.commit || "";
+}
+
+export async function push(force: boolean = false): Promise<string> {
+	const args = force ? (["-f"] as any) : undefined;
+	const result = await git.push("origin", undefined as any, args);
+	return result;
+}
+
+export async function pullRebase(): Promise<string> {
+	const result = await git.pull(["--rebase"]);
+	return result;
+}
+
+export async function log(maxCount: number = 10): Promise<LogEntry[]> {
+	const result = await git.log({ maxCount });
+	return result.all.map((c) => ({
+		hash: c.hash,
+		date: c.date,
+		message: c.message,
+		author: c.author_name,
+	}));
+}
+
+export async function diff(): Promise<string> {
+	const result = await git.diff();
+	return result;
+}
+
+export async function diffStaged(): Promise<string> {
+	const result = await git.diff(["--cached"]);
+	return result;
+}
+
+export async function getBranches(): Promise<BranchesResult> {
+	const result = await git.branch();
+	return {
+		current: result.current,
+		branches: result.branches
+			? Object.keys(result.branches).filter((b) => b !== result.current)
+			: [],
+		all: result.all || [],
+	};
+}
+
+export async function createBranch(name: string): Promise<void> {
+	await git.branch([name]);
+}
+
+export async function deleteBranch(
+	name: string,
+	force: boolean = false,
+): Promise<void> {
+	const args = force ? ["-D", name] : ["-d", name];
+	await git.branch(args);
+}
+
+export async function switchBranch(name: string): Promise<void> {
+	await git.checkout(name);
+}
+
+export async function stash(): Promise<string> {
+	const result = await git.stash();
+	return result;
+}
+
+export async function stashPop(): Promise<string> {
+	const result = await git.stash(["pop"]);
+	return result;
+}
+
+export async function stashList(): Promise<StashEntry[]> {
+	const result = await git.stashList();
+	return result.all.map((s, i) => ({
+		index: i + 1,
+		description: s.message,
+	}));
+}
+
+export async function tag(name: string, message?: string): Promise<string> {
+	if (message) {
+		await git.tag(["-a", name, "-m", message]);
+	} else {
+		await git.tag([name]);
+	}
+	return name;
+}
+
+export async function tagList(): Promise<string[]> {
+	const result = await git.tag();
+	return result.split("\n").filter(Boolean);
+}
+
+export async function fetch(): Promise<string> {
+	const result = await git.fetch();
+	return result;
+}
+
+export async function undo(): Promise<string> {
+	const result = await git.reset(["--soft", "HEAD~1"]);
+	return result;
+}
+
+export async function getCurrentBranch(): Promise<string> {
+	const result = await git.branch();
+	return result.current;
+}
+
+export async function clone(
+	url: string,
+	dir?: string,
+	options?: {
+		ssh?: boolean;
+		depth?: number;
+		branch?: string;
+		recurseSubmodules?: boolean;
+	},
+): Promise<string> {
+	const args: string[] = [];
+	if (options?.depth) args.push("--depth", String(options.depth));
+	if (options?.branch) args.push("--branch", options.branch);
+	if (options?.recurseSubmodules) args.push("--recurse-submodules");
+	const targetDir = dir || url.split("/").pop()?.replace(".git", "") || "repo";
+	await git.clone(url, targetDir, args);
+	return targetDir;
+}
+
+export async function init(
+	dir?: string,
+	options?: { initialBranch?: string },
+): Promise<void> {
+	const opts: string[] = [];
+	if (options?.initialBranch)
+		opts.push("--initial-branch", options.initialBranch);
+	if (dir) opts.push(dir);
+	await git.init(opts.length > 0 ? opts : (true as any));
+}
+
+interface RemoteEntry {
+	name: string;
+	url: string;
+}
+
+export async function remoteAdd(name: string, url: string): Promise<void> {
+	await git.addRemote(name, url);
+}
+
+export async function remoteRemove(name: string): Promise<void> {
+	await git.removeRemote(name);
+}
+
+export async function remoteSetUrl(
+	name: string,
+	newUrl: string,
+): Promise<void> {
+	await git.raw(["remote", "set-url", name, newUrl]);
+}
+
+export async function remoteRename(
+	oldName: string,
+	newName: string,
+): Promise<void> {
+	await git.raw(["remote", "rename", oldName, newName]);
+}
+
+export async function remoteGetUrl(name: string): Promise<string> {
+	const result = await git.raw(["remote", "get-url", name]);
+	return result.trim();
+}
+
+export async function remoteList(): Promise<RemoteEntry[]> {
+	const result = await git.getRemotes(true);
+	return result.map((r) => ({ name: r.name, url: r.refs.fetch }));
+}
+
+interface WorktreeEntry {
+	path: string;
+	branch: string;
+	hash: string;
+}
+
+export async function worktreeAdd(
+	path: string,
+	branch?: string,
+	options?: { new?: boolean; detach?: boolean },
+): Promise<void> {
+	const args = ["worktree", "add"];
+	if (options?.detach) args.push("--detach");
+	args.push(path);
+	if (branch) {
+		if (options?.new) args.push(branch);
+		else args.push(branch);
+	}
+	await git.raw(args);
+}
+
+export async function worktreeList(): Promise<WorktreeEntry[]> {
+	const result = await git.raw(["worktree", "list", "--porcelain"]);
+	const entries: WorktreeEntry[] = [];
+	const lines = result.split("\n");
+	let current: Partial<WorktreeEntry> = {};
+	for (const line of lines) {
+		if (line.startsWith("worktree ")) {
+			current.path = line.slice(9).trim();
+		} else if (line.startsWith("HEAD ")) {
+			current.hash = line.slice(5).trim();
+		} else if (line.startsWith("branch ")) {
+			current.branch = line.slice(7).trim().replace("refs/heads/", "");
+		} else if (line === "") {
+			if (current.path) entries.push(current as WorktreeEntry);
+			current = {};
+		}
+	}
+	if (current.path) entries.push(current as WorktreeEntry);
+	return entries;
+}
+
+export async function worktreeRemove(
+	path: string,
+	force: boolean = false,
+): Promise<void> {
+	const args = ["worktree", "remove"];
+	if (force) args.push("--force");
+	args.push(path);
+	await git.raw(args);
+}
+
+export async function worktreePrune(
+	dryRun: boolean = false,
+): Promise<string[]> {
+	const args = ["worktree", "prune"];
+	if (dryRun) args.push("--dry-run");
+	const result = await git.raw(args);
+	return result.split("\n").filter(Boolean);
+}
+
+export async function merge(
+	branch: string,
+	options?: { noFF?: boolean; squash?: boolean; noCommit?: boolean },
+): Promise<string> {
+	const args = ["merge"];
+	if (options?.noFF) args.push("--no-ff");
+	if (options?.squash) args.push("--squash");
+	if (options?.noCommit) args.push("--no-commit");
+	args.push(branch);
+	const result = await git.raw(args);
+	return result;
+}
+
+export async function cherryPick(
+	commits: string[],
+	options?: { noCommit?: boolean; mainline?: number },
+): Promise<void> {
+	const args = ["cherry-pick"];
+	if (options?.noCommit) args.push("--no-commit");
+	if (options?.mainline) args.push("-m", String(options.mainline));
+	args.push(...commits);
+	await git.raw(args);
+}
+
+export async function cherryPickContinue(): Promise<void> {
+	await git.raw(["cherry-pick", "--continue"]);
+}
+
+export async function cherryPickAbort(): Promise<void> {
+	await git.raw(["cherry-pick", "--abort"]);
+}
+
+export async function clean(options?: {
+	dryRun?: boolean;
+	force?: boolean;
+	exclude?: string;
+}): Promise<string[]> {
+	const args = ["clean", "-d"];
+	if (options?.dryRun) args.push("-n");
+	if (options?.force) args.push("-f");
+	else args.push("-f");
+	if (options?.exclude) args.push("-x", options.exclude);
+	const result = await git.raw(args);
+	return result.split("\n").filter(Boolean);
+}
+
+export async function archive(
+	format: string,
+	options?: { prefix?: string; output?: string; treeIsh?: string },
+): Promise<string> {
+	const args = ["archive", `--format=${format}`];
+	if (options?.prefix) args.push(`--prefix=${options.prefix}`);
+	if (options?.output) args.push(`--output=${options.output}`);
+	if (options?.treeIsh) args.push(options.treeIsh);
+	else args.push("HEAD");
+	const result = await git.raw(args);
+	return result;
+}
+
+export async function bisectStart(
+	bad?: string,
+	good?: string[],
+): Promise<void> {
+	await git.raw(["bisect", "start"]);
+	if (bad) await git.raw(["bisect", "bad", bad]);
+	if (good && good.length > 0) {
+		for (const g of good) await git.raw(["bisect", "good", g]);
+	}
+}
+
+export async function bisectBad(commit?: string): Promise<void> {
+	const args = ["bisect", "bad"];
+	if (commit) args.push(commit);
+	await git.raw(args);
+}
+
+export async function bisectGood(commits: string[]): Promise<void> {
+	for (const c of commits) await git.raw(["bisect", "good", c]);
+}
+
+export async function bisectReset(): Promise<void> {
+	await git.raw(["bisect", "reset"]);
+}
+
+export async function bisectLog(): Promise<string> {
+	return await git.raw(["bisect", "log"]);
+}
+
+export async function bisectRun(cmd: string): Promise<void> {
+	await git.raw(["bisect", "run", cmd]);
+}

package/src/lib/logger.ts

@@ -0,0 +1,31 @@
+import chalk from "chalk";
+import { colors } from "../constants/colors.js";
+import { icons } from "../constants/messages.js";
+
+export function success(msg: string): void {
+	console.log(chalk.hex(colors.success)(`${icons.success} ${msg}`));
+}
+
+export function error(msg: string): void {
+	console.error(chalk.hex(colors.error)(`${icons.error} ${msg}`));
+}
+
+export function warning(msg: string): void {
+	console.warn(chalk.hex(colors.warning)(`${icons.warning} ${msg}`));
+}
+
+export function info(msg: string): void {
+	console.log(chalk.hex(colors.info)(`${icons.info} ${msg}`));
+}
+
+export function highlight(msg: string): void {
+	console.log(chalk.hex(colors.highlight)(`${icons.highlight} ${msg}`));
+}
+
+export function text(msg: string): void {
+	console.log(msg);
+}
+
+export function newline(): void {
+	console.log();
+}

package/src/lib/ui.ts

@@ -0,0 +1,162 @@
+import boxen from "boxen";
+import chalk from "chalk";
+import ora from "ora";
+import { colors } from "../constants/colors.js";
+import { formatting } from "../constants/messages.js";
+
+function stripAnsi(str: string): string {
+	return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+}
+
+function padEnd(str: string, len: number): string {
+	const visibleLen = stripAnsi(str).length;
+	const diff = len - visibleLen;
+	return diff > 0 ? str + " ".repeat(diff) : str;
+}
+
+export function showBox(
+	title: string,
+	content: string,
+	options?: Record<string, unknown>,
+): void {
+	const boxContent = `${chalk.bold(title)}\n\n${content}`;
+	console.log(
+		boxen(boxContent, {
+			padding: 1,
+			borderColor: "cyan",
+			borderStyle: "round",
+			...options,
+		}),
+	);
+}
+
+export function createTable(headers: string[], rows: string[][]): string {
+	const _colCount = headers.length;
+	const colWidths: number[] = headers.map((h, i) => {
+		const maxRow = Math.max(...rows.map((r) => stripAnsi(r[i] || "").length));
+		return Math.max(stripAnsi(h).length, maxRow);
+	});
+
+	const separator = `+${colWidths.map((w) => "-".repeat(w + 2)).join("+")}+`;
+	const headerRow = `| ${headers.map((h, i) => padEnd(h, colWidths[i])).join(" | ")} |`;
+	const dataRows = rows.map(
+		(row) =>
+			"| " +
+			row.map((cell, i) => padEnd(cell, colWidths[i])).join(" | ") +
+			" |",
+	);
+
+	return [separator, headerRow, separator, ...dataRows, separator].join("\n");
+}
+
+export async function withSpinner<T>(
+	text: string,
+	fn: () => Promise<T>,
+): Promise<T> {
+	const spinner = ora({
+		text,
+		color: "cyan",
+	}).start();
+
+	try {
+		const result = await fn();
+		spinner.succeed();
+		return result;
+	} catch (err) {
+		spinner.fail();
+		throw err;
+	}
+}
+
+export function showHeader(text: string): void {
+	console.log(chalk.hex(colors.highlight)(text));
+	console.log(chalk.hex(colors.info)(formatting.header));
+}
+
+export function showSeparator(): void {
+	console.log(chalk.dim(formatting.separator));
+}
+
+async function getInquirer() {
+	return await import("inquirer");
+}
+
+export async function confirm(
+	msg: string,
+	defaultValue: boolean = true,
+): Promise<boolean> {
+	const inquirer = await getInquirer();
+	const { value } = await inquirer.prompt([
+		{
+			type: "confirm",
+			name: "value",
+			message: msg,
+			default: defaultValue,
+		},
+	]);
+	return value;
+}
+
+export async function select<T>(
+	message: string,
+	choices: { name: string; value: T }[],
+): Promise<T> {
+	const inquirer = await getInquirer();
+	const { value } = await inquirer.prompt([
+		{
+			type: "list",
+			name: "value",
+			message,
+			choices,
+		},
+	]);
+	return value;
+}
+
+export async function input(
+	message: string,
+	defaultValue?: string,
+): Promise<string> {
+	const inquirer = await getInquirer();
+	const { value } = await inquirer.prompt([
+		{
+			type: "input",
+			name: "value",
+			message,
+			default: defaultValue,
+		},
+	]);
+	return value;
+}
+
+export async function password(
+	message: string,
+	mask: string = "*",
+): Promise<string> {
+	const inquirer = await getInquirer();
+	const { value } = await inquirer.prompt([
+		{
+			type: "password",
+			name: "value",
+			message,
+			mask,
+		},
+	]);
+	return value;
+}
+
+export async function checkbox(
+	message: string,
+	choices: { name: string; value: string; checked?: boolean }[],
+): Promise<string[]> {
+	const inquirer = await getInquirer();
+	const { value } = await inquirer.prompt([
+		{
+			type: "checkbox",
+			name: "value",
+			message,
+			choices,
+		},
+	]);
+	return value;
+}

package/src/lib/validators.ts

@@ -0,0 +1,27 @@
+import { execSync } from "node:child_process";
+
+export function validateEmail(email: string): boolean {
+	const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+	return emailRegex.test(email);
+}
+
+export function validateGitHubToken(token: string): boolean {
+	const tokenRegex = /^(ghp_|gho_|ghu_|ghs_|ghr_|github_pat_)[a-zA-Z0-9]{4,}$/;
+	return tokenRegex.test(token);
+}
+
+export function validateNotEmpty(input: string): boolean | string {
+	if (input.length === 0) {
+		return "Value cannot be empty";
+	}
+	return true;
+}
+
+export async function validateGitInstalled(): Promise<boolean> {
+	try {
+		execSync("git --version", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/templates/commit-types.json

@@ -0,0 +1,9 @@
+[
+	{ "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" }
+]

package/src/utils/files.ts

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export async function ensureDir(dirPath: string): Promise<void> {
+	if (!existsSync(dirPath)) {
+		await mkdir(dirPath, { recursive: true });
+	}
+}
+
+export async function readJSON(path: string): Promise<any> {
+	const content = await readFile(path, "utf-8");
+	return JSON.parse(content);
+}
+
+export async function writeJSON(path: string, data: any): Promise<void> {
+	const directory = dirname(path);
+	await ensureDir(directory);
+	const content = JSON.stringify(data, null, 2);
+	await writeFile(path, content, "utf-8");
+}

package/src/utils/strings.ts

@@ -0,0 +1,19 @@
+export function capitalize(str: string): string {
+	if (str.length === 0) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function truncate(str: string, maxLength: number): string {
+	if (str.length <= maxLength) return str;
+	return `${str.slice(0, maxLength - 3)}...`;
+}
+
+export function formatTimestamp(date: Date): string {
+	const year = date.getFullYear();
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	const hours = String(date.getHours()).padStart(2, "0");
+	const minutes = String(date.getMinutes()).padStart(2, "0");
+	const seconds = String(date.getSeconds()).padStart(2, "0");
+	return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}