ag-toolkit 0.1.0

package/dist/git.js

@@ -0,0 +1,418 @@
+import { simpleGit } from "simple-git";
+import { isValidBranchName } from "./lib/isValidBranchName.js";
+const BRANCH_LIST_FORMAT = "%(refname)%00%(committerdate:iso8601)%00%(objectname)%00%(contents:subject)";
+export class GitOperations {
+    git;
+    constructor(workingDir) {
+        const options = {
+            baseDir: workingDir || process.cwd(),
+            binary: "git",
+            maxConcurrentProcesses: 10,
+            config: [],
+            trimmed: false,
+        };
+        this.git = simpleGit(options);
+    }
+    async getCurrentBranch() {
+        const status = await this.git.status();
+        return status.current || "HEAD";
+    }
+    async isWorkdirClean() {
+        const status = await this.git.status();
+        return status.isClean();
+    }
+    async fetchAll() {
+        await this.git.fetch(["--all"]);
+    }
+    async getBranchInfos(options = {}) {
+        const includeRemote = options.includeRemote === true;
+        const [localMerged, remoteMerged, baseBranch] = await Promise.all([
+            this.getMergedSet("local"),
+            includeRemote
+                ? this.getMergedSet("remote")
+                : Promise.resolve(new Set()),
+            this.getBaseBranch(),
+        ]);
+        const localBranches = await this.listBranches("refs/heads/", "local");
+        const remoteBranches = includeRemote
+            ? await this.listBranches("refs/remotes/", "remote")
+            : [];
+        const allBranches = [...localBranches, ...remoteBranches];
+        const withCommitCounts = await Promise.all(allBranches.map(async (branch) => {
+            const { ahead, behind } = baseBranch
+                ? await this.getAheadBehind(branch.ref, baseBranch)
+                : { ahead: 0, behind: 0 };
+            const isMerged = branch.type === "local"
+                ? localMerged.has(branch.ref)
+                : remoteMerged.has(branch.ref);
+            return { ...branch, isMerged, ahead, behind };
+        }));
+        return withCommitCounts.sort((a, b) => {
+            if (a.type !== b.type) {
+                return a.type === "local" ? -1 : 1;
+            }
+            const dateA = a.lastCommitDate?.getTime() ?? 0;
+            const dateB = b.lastCommitDate?.getTime() ?? 0;
+            return dateB - dateA;
+        });
+    }
+    async deleteLocalBranch(branch, options = {}) {
+        if (!isValidBranchName(branch)) {
+            throw new Error(`Invalid branch name: ${branch}`);
+        }
+        const args = ["branch", options.force ? "-D" : "-d", branch];
+        await this.git.raw(args);
+    }
+    async deleteRemoteBranch(branch) {
+        const { remote, name } = branch;
+        if (!isValidBranchName(name)) {
+            throw new Error(`Invalid branch name: ${name}`);
+        }
+        await this.git.push([remote, "--delete", name]);
+    }
+    async detectDefaultBranch(remote = "origin") {
+        try {
+            const remoteInfo = await this.git.raw(["remote", "show", remote]);
+            const match = remoteInfo.match(/HEAD branch:\s*(.+)/);
+            if (match?.[1]) {
+                return match[1].trim();
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("No such remote")) {
+                throw error;
+            }
+        }
+        try {
+            await this.git.raw(["remote", "set-head", remote, "--auto"]);
+            const symbolicRef = await this.git.raw([
+                "symbolic-ref",
+                `refs/remotes/${remote}/HEAD`,
+            ]);
+            const ref = symbolicRef.trim();
+            if (!ref) {
+                return null;
+            }
+            const parts = ref.split("/");
+            const branchName = parts.at(-1);
+            return branchName ?? null;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("No such remote")) {
+                throw error;
+            }
+            return null;
+        }
+    }
+    async getBaseBranch() {
+        const { all: remoteBranches } = await this.git.branch(["-r"]);
+        const defaultRemoteBranches = [
+            "origin/main",
+            "origin/master",
+            "origin/develop",
+        ];
+        for (const branch of defaultRemoteBranches) {
+            if (remoteBranches.includes(branch.trim())) {
+                return branch.trim();
+            }
+        }
+        const { all: localBranches } = await this.git.branchLocal();
+        const defaultLocalBranches = ["main", "master", "develop"];
+        for (const branch of defaultLocalBranches) {
+            if (localBranches.includes(branch)) {
+                return branch;
+            }
+        }
+        return null;
+    }
+    async getAheadBehind(branch, base) {
+        if (branch === base) {
+            return { ahead: 0, behind: 0 };
+        }
+        try {
+            // `git rev-list --left-right --count base...branch` returns "behind ahead"
+            const result = await this.git.raw([
+                "rev-list",
+                "--left-right",
+                "--count",
+                `${base}...${branch}`,
+            ]);
+            const [behind, ahead] = result.trim().split("\t").map(Number);
+            return { ahead: ahead ?? 0, behind: behind ?? 0 };
+        }
+        catch {
+            return { ahead: 0, behind: 0 };
+        }
+    }
+    async getMergedSet(type) {
+        const args = type === "local" ? ["branch", "--merged"] : ["branch", "-r", "--merged"];
+        const output = await this.git.raw(args);
+        const lines = output
+            .split("\n")
+            .map((line) => line.replace("*", "").trim());
+        const filtered = lines
+            .filter(Boolean)
+            .filter((name) => !name.includes(" -> "))
+            .map((name) => (type === "remote" ? name : name));
+        return new Set(filtered);
+    }
+    async listBranches(refPrefix, type) {
+        const output = await this.git.raw([
+            "for-each-ref",
+            `--format=${BRANCH_LIST_FORMAT.replace("%(refname:short)", "%(refname)")}`,
+            refPrefix,
+        ]);
+        return output
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => this.parseBranchLine(line, type))
+            .filter((branch) => branch !== null);
+    }
+    parseBranchLine(line, type) {
+        const [ref, dateStr, sha, subject] = line.split("\u0000");
+        const shortRef = ref?.replace(/^refs\/heads\//, "").replace(/^refs\/remotes\//, "") ?? "";
+        if (!shortRef || shortRef.endsWith("/HEAD")) {
+            return null;
+        }
+        let lastCommitDate = null;
+        if (dateStr) {
+            const parsed = new Date(dateStr);
+            if (!Number.isNaN(parsed.getTime())) {
+                lastCommitDate = parsed;
+            }
+        }
+        const trimmedSubject = subject?.trim() ?? null;
+        const lastCommitSubject = trimmedSubject?.length ? trimmedSubject : null;
+        const lastCommitSha = sha?.trim()?.length ? sha.trim() : null;
+        if (type === "remote") {
+            const [remote, ...nameParts] = shortRef.split("/");
+            const name = nameParts.join("/");
+            if (!(remote && name) || name === "HEAD") {
+                return null;
+            }
+            return {
+                ref: shortRef,
+                name,
+                type,
+                remote,
+                lastCommitDate,
+                lastCommitSha,
+                lastCommitSubject,
+            };
+        }
+        return {
+            ref: shortRef,
+            name: shortRef,
+            type,
+            lastCommitDate,
+            lastCommitSha,
+            lastCommitSubject,
+        };
+    }
+    async getAllBranches() {
+        const branches = await this.git.branch(["-r"]);
+        return branches.all
+            .filter((branch) => typeof branch === "string" &&
+            branch.startsWith("origin/") &&
+            !branch.includes("HEAD"))
+            .map((branch) => branch.replace("origin/", ""));
+    }
+    async getLocalBranches() {
+        const branches = await this.git.branch(["-l"]);
+        return branches.all
+            .filter((branch) => typeof branch === "string" && !branch.includes("HEAD"))
+            .map((branch) => branch.replace("* ", ""));
+    }
+    async branchExists(branch) {
+        if (!isValidBranchName(branch)) {
+            throw new Error(`Invalid branch name: ${branch}`);
+        }
+        try {
+            await this.git.raw([
+                "show-ref",
+                "--verify",
+                "--quiet",
+                `refs/remotes/origin/${branch}`,
+            ]);
+            return true;
+        }
+        catch {
+            try {
+                await this.git.raw([
+                    "show-ref",
+                    "--verify",
+                    "--quiet",
+                    `refs/heads/${branch}`,
+                ]);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    async resolveBranchRef(branch) {
+        try {
+            await this.git.raw([
+                "show-ref",
+                "--verify",
+                "--quiet",
+                `refs/remotes/origin/${branch}`,
+            ]);
+            return `origin/${branch}`;
+        }
+        catch {
+            return branch;
+        }
+    }
+    async setupCherryPick(targetBranch) {
+        if (!isValidBranchName(targetBranch)) {
+            throw new Error(`Invalid branch name: ${targetBranch}`);
+        }
+        const tempBranchName = `temp-rebase-${process.pid}`;
+        const checkoutTarget = await this.resolveBranchRef(targetBranch);
+        await this.git.checkout(["-b", tempBranchName, checkoutTarget]);
+        return tempBranchName;
+    }
+    async getMergeBase(branch1, branch2) {
+        if (!isValidBranchName(branch1)) {
+            throw new Error(`Invalid branch name: ${branch1}`);
+        }
+        if (!isValidBranchName(branch2)) {
+            throw new Error(`Invalid branch name: ${branch2}`);
+        }
+        const baseBranch = await this.resolveBranchRef(branch1);
+        const result = await this.git.raw(["merge-base", baseBranch, branch2]);
+        return result.trim();
+    }
+    async getCommitsToCherryPick(from, to) {
+        const result = await this.git.raw([
+            "rev-list",
+            "--reverse",
+            "--no-merges",
+            `${from}..${to}`,
+        ]);
+        return result.trim().split("\n").filter(Boolean);
+    }
+    async cherryPick(commitSha, options) {
+        const args = ["cherry-pick"];
+        if (options?.allowEmpty) {
+            args.push("--allow-empty");
+        }
+        args.push(commitSha);
+        await this.git.raw(args);
+    }
+    async continueCherryPick() {
+        await this.git.raw(["cherry-pick", "--continue"]);
+    }
+    async skipCherryPick() {
+        await this.git.raw(["cherry-pick", "--skip"]);
+    }
+    async abortCherryPick() {
+        try {
+            await this.git.raw(["cherry-pick", "--abort"]);
+        }
+        catch { }
+    }
+    async resolveConflictWithStrategy(strategy) {
+        await this.git.checkout([`--${strategy}`, "."]);
+        await this.git.add(".");
+    }
+    async finishCherryPick(currentBranch, tempBranchName, options) {
+        await this.git.checkout(currentBranch);
+        if (options?.createBackup) {
+            try {
+                const currentSha = (await this.git.revparse([currentBranch])).trim();
+                const safeBranch = currentBranch.replace(/\//g, "-");
+                const tagName = `agrb-backup-${safeBranch}-${Date.now()}`;
+                await this.git.addAnnotatedTag(tagName, `Backup before agrb reset: ${currentBranch} @ ${currentSha}`);
+            }
+            catch (error) {
+                throw new Error(`Failed to create backup tag: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        await this.git.raw(["reset", "--hard", tempBranchName]);
+    }
+    async cleanupCherryPick(tempBranchName, originalBranch) {
+        try {
+            const current = await this.getCurrentBranch();
+            if (current === tempBranchName) {
+                await this.git.checkout(originalBranch);
+            }
+            await this.git.branch(["-D", tempBranchName]);
+        }
+        catch { }
+    }
+    async performLinearRebase(currentBranch, targetBranch, progressCallback, options) {
+        if (!isValidBranchName(targetBranch)) {
+            throw new Error(`Invalid branch name: ${targetBranch}`);
+        }
+        try {
+            progressCallback?.("Fetching all branches...");
+            await this.fetchAll();
+            progressCallback?.("Checking if target branch exists...");
+            if (!(await this.branchExists(targetBranch))) {
+                throw new Error(`Target branch '${targetBranch}' does not exist`);
+            }
+            progressCallback?.("Starting linear rebase...");
+            await this.git.checkout(currentBranch);
+            const rebaseTarget = await this.resolveBranchRef(targetBranch);
+            const rebaseArgs = ["rebase", rebaseTarget];
+            if (options?.continueOnConflict) {
+                rebaseArgs.push("-X", "ours");
+            }
+            await this.git.raw(rebaseArgs);
+            progressCallback?.("Linear rebase completed successfully");
+        }
+        catch (error) {
+            if (options?.continueOnConflict) {
+                try {
+                    progressCallback?.("Conflicts detected, auto-resolving and continuing...");
+                    await this.git.checkout(["--ours", "."]);
+                    await this.git.add(".");
+                    await this.git.raw(["rebase", "--continue"]);
+                    progressCallback?.("Linear rebase completed with conflicts auto-resolved");
+                }
+                catch (e) {
+                    try {
+                        await this.git.raw(["rebase", "--abort"]);
+                    }
+                    catch { }
+                    throw new Error(`Linear rebase failed during continue: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            else {
+                try {
+                    await this.git.raw(["rebase", "--abort"]);
+                }
+                catch { }
+                throw new Error(`Linear rebase failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async getCommitSubject(sha) {
+        const out = await this.git.raw(["show", "-s", "--format=%s", sha]);
+        return out.trim();
+    }
+    async startAutostash() {
+        const label = `agrb-${process.pid}`;
+        await this.git.raw(["stash", "push", "-u", "-m", label]);
+        const list = await this.git.raw(["stash", "list", "--format=%gd %gs"]);
+        const line = list
+            .split("\n")
+            .map((l) => l.trim())
+            .find((l) => l.includes(label));
+        if (!line) {
+            return null;
+        }
+        const ref = line.split(" ")[0];
+        return ref || null;
+    }
+    async popStash(stashRef) {
+        await this.git.raw(["stash", "pop", stashRef]);
+    }
+    async pushWithLease(branch) {
+        await this.git.push(["-u", "origin", branch, "--force-with-lease"]);
+    }
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from "./useSearchFilter.js";

package/dist/hooks/index.js

@@ -0,0 +1 @@
+export * from "./useSearchFilter.js";

package/dist/hooks/useSearchFilter.d.ts

@@ -0,0 +1 @@
+export declare const useSearchFilter: <T extends Record<string, string | number | boolean | null | undefined>>(items: T[], searchTerm: string, searchableFields: (keyof T)[]) => T[];

package/dist/hooks/useSearchFilter.js

@@ -0,0 +1,22 @@
+import { useMemo } from "react";
+export const useSearchFilter = (items, searchTerm, searchableFields) => {
+    return useMemo(() => {
+        if (!searchTerm.trim()) {
+            return items;
+        }
+        const terms = searchTerm
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((term) => term.length > 0);
+        if (terms.length === 0) {
+            return items;
+        }
+        return items.filter((item) => terms.every((term) => searchableFields.some((field) => {
+            const value = item[field];
+            if (typeof value === "string") {
+                return value.toLowerCase().includes(term);
+            }
+            return false;
+        })));
+    }, [items, searchTerm, searchableFields]);
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./components/index.js";
+export * from "./git.js";
+export * from "./hooks/index.js";
+export * from "./lib/index.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./components/index.js";
+export * from "./git.js";
+export * from "./hooks/index.js";
+export * from "./lib/index.js";

package/dist/lib/arg-parser.d.ts

@@ -0,0 +1,30 @@
+interface FlagConfig {
+    type: "string" | "boolean";
+    shortFlag?: string;
+}
+type FlagsSchema = {
+    [key: string]: FlagConfig;
+};
+type Flags<T extends FlagsSchema> = {
+    [K in keyof T]: T[K]["type"] extends "string" ? string | undefined : boolean | undefined;
+};
+interface ParsedArgs<T extends FlagsSchema> {
+    flags: Flags<T>;
+    input: string[];
+    help?: string;
+    version?: string;
+}
+export declare class ArgParser<T extends FlagsSchema> {
+    private readonly schema;
+    private readonly helpMessage;
+    private readonly version;
+    private readonly aliases;
+    private readonly longFlagMap;
+    constructor(config: {
+        schema: T;
+        helpMessage: string;
+        version: string;
+    });
+    parse(args: readonly string[]): ParsedArgs<T>;
+}
+export {};

package/dist/lib/arg-parser.js

@@ -0,0 +1,84 @@
+export class ArgParser {
+    schema;
+    helpMessage;
+    version;
+    aliases = {};
+    longFlagMap = {};
+    constructor(config) {
+        this.schema = config.schema;
+        this.helpMessage = config.helpMessage;
+        this.version = config.version;
+        const camelToKebab = (str) => str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+        for (const longFlag in this.schema) {
+            if (Object.hasOwn(this.schema, longFlag)) {
+                const flagConfig = this.schema[longFlag];
+                const kebabCaseFlag = camelToKebab(longFlag);
+                this.longFlagMap[`--${kebabCaseFlag}`] = longFlag;
+                if (flagConfig?.shortFlag) {
+                    this.aliases[`-${flagConfig.shortFlag}`] = `--${kebabCaseFlag}`;
+                }
+            }
+        }
+    }
+    parse(args) {
+        const flags = {};
+        const input = [];
+        const remainingArgs = [...args];
+        for (const longFlag in this.schema) {
+            if (Object.hasOwn(this.schema, longFlag)) {
+                flags[longFlag] = undefined;
+            }
+        }
+        if (remainingArgs.includes("-h") || remainingArgs.includes("--help")) {
+            return { flags: flags, input, help: this.helpMessage };
+        }
+        if (remainingArgs.includes("-v") || remainingArgs.includes("--version")) {
+            return { flags: flags, input, version: this.version };
+        }
+        let parsingFlags = true;
+        while (remainingArgs.length > 0) {
+            const arg = remainingArgs.shift();
+            if (arg === "--") {
+                parsingFlags = false;
+                input.push(...remainingArgs);
+                break;
+            }
+            if (parsingFlags) {
+                let argName = arg;
+                let argValue;
+                if (arg.includes("=")) {
+                    const parts = arg.split("=");
+                    if (parts[0] !== undefined) {
+                        argName = parts[0];
+                    }
+                    argValue = parts[1];
+                }
+                const longFlagArg = this.aliases[argName] ?? argName;
+                const longFlag = this.longFlagMap[longFlagArg];
+                if (longFlag) {
+                    const flagConfig = this.schema[longFlag];
+                    if (flagConfig?.type === "boolean") {
+                        flags[longFlag] = true;
+                    }
+                    else if (flagConfig?.type === "string") {
+                        const value = argValue ?? remainingArgs.shift();
+                        if (value === undefined) {
+                            throw new Error(`Flag --${String(longFlag)} requires a value.`);
+                        }
+                        flags[longFlag] = value;
+                    }
+                }
+                else {
+                    if (argName.startsWith("-")) {
+                        throw new Error(`Unknown option: ${argName}`);
+                    }
+                    input.push(arg);
+                }
+            }
+            else {
+                input.push(arg);
+            }
+        }
+        return { flags: flags, input };
+    }
+}

package/dist/lib/cli.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentType } from "react";
+import type { Config, ConfigResult } from "./config.js";
+export declare const handleVersionAndHelp: (version: string | null | undefined, help: string | null | undefined, packageName: string, packageVersion: string) => void;
+type ConfigCommands<T extends Config> = {
+    getConfig: () => Promise<ConfigResult<T>>;
+    getGlobalConfigPath: () => string;
+    resetGlobalConfig: () => Promise<void>;
+    ConfigEditorComponent: ComponentType;
+};
+export declare const handleConfigCommand: <T extends Config>(command: string, commands: ConfigCommands<T>) => Promise<void>;
+export {};

package/dist/lib/cli.js

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+import { render } from "ink";
+import { createElement } from "react";
+export const handleVersionAndHelp = (version, help, packageName, packageVersion) => {
+    if (help) {
+        console.log(help);
+        process.exit(0);
+    }
+    if (version) {
+        console.log(`${packageName} version: ${packageVersion}`);
+        process.exit(0);
+    }
+};
+export const handleConfigCommand = async (command, commands) => {
+    const { getConfig, getGlobalConfigPath, resetGlobalConfig, ConfigEditorComponent, } = commands;
+    switch (command) {
+        case "show": {
+            const { config, sources } = await getConfig();
+            console.log("Current configuration:");
+            const sourceColors = {
+                default: chalk.gray,
+                global: chalk.blue,
+                local: chalk.green,
+            };
+            for (const key in config) {
+                const k = key;
+                const source = sources[k] || "default";
+                const color = sourceColors[source] ?? chalk.white;
+                console.log(`  ${chalk.cyan(k)}: ${chalk.yellow(String(config[k]))} ${color(`(${source})`)}`);
+            }
+            break;
+        }
+        case "edit": {
+            // biome-ignore lint/complexity/useLiteralKeys: ProcessEnv requires bracket access
+            const editor = process.env["EDITOR"] || "vim";
+            const { spawn } = await import("node:child_process");
+            const child = spawn(editor, [getGlobalConfigPath()], {
+                stdio: "inherit",
+                env: process.env,
+            });
+            child.on("exit", (code) => {
+                process.exit(code ?? 0);
+            });
+            return;
+        }
+        case "reset": {
+            await resetGlobalConfig();
+            console.log(`Configuration reset to default: ${getGlobalConfigPath()}`);
+            break;
+        }
+        case "set": {
+            render(createElement(ConfigEditorComponent));
+            return;
+        }
+        default:
+            console.error(`Unknown config command: ${command}`);
+            console.log("Available commands: show, edit, reset, set");
+            process.exit(1);
+    }
+};

package/dist/lib/config.d.ts

@@ -0,0 +1,25 @@
+export type Config = Record<string, unknown>;
+export declare const findUp: (name: string, startDir: string) => Promise<string | null>;
+export declare const readConfigFile: <T extends Config>(filePath: string, validate: (config: unknown) => T) => Promise<T | null>;
+export declare const writeConfig: <T extends Config>(filePath: string, config: T) => Promise<void>;
+export interface ConfigResult<T extends Config> {
+    config: T;
+    sources: Partial<Record<keyof T, "default" | "global" | "local">>;
+}
+export declare const loadConfig: <T extends Config>(options: {
+    toolName: string;
+    configFile: string;
+    localConfigFile: string;
+    defaultConfig: T;
+    validate: (config: unknown) => T;
+}, cwd?: string) => Promise<ConfigResult<T>>;
+export declare const getGlobalConfigPath: (toolName: string, configFile: string) => string;
+export declare const findLocalConfigPath: (localConfigFile: string, cwd?: string) => Promise<string | null>;
+export declare const writeLocalConfig: <T extends Config>(localConfigPath: string, config: T) => Promise<void>;
+export declare const loadLocalConfig: <T extends Config>(localConfigFile: string, validate: (config: unknown) => T, cwd?: string) => Promise<{
+    path: string;
+    config: T | null;
+    exists: boolean;
+}>;
+export declare const writeGlobalConfig: <T extends Config>(config: T, toolName: string, configFile: string) => Promise<void>;
+export declare const resetGlobalConfig: <T extends Config>(defaultConfig: T, toolName: string, configFile: string) => Promise<void>;