ag-toolkit 0.1.0

package/dist/lib/config.js

@@ -0,0 +1,103 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+export const findUp = async (name, startDir) => {
+    let dir = resolve(startDir);
+    const stopDir = resolve(homedir(), "..");
+    while (dir !== stopDir) {
+        const filePath = join(dir, name);
+        try {
+            await fs.access(filePath);
+            return filePath;
+        }
+        catch {
+            dir = dirname(dir);
+        }
+    }
+    return null;
+};
+export const readConfigFile = async (filePath, validate) => {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        return validate(JSON.parse(content));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        throw new Error(`Error reading or parsing config file at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+export const writeConfig = async (filePath, config) => {
+    try {
+        await fs.mkdir(dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, JSON.stringify(config, null, 2), "utf-8");
+    }
+    catch (error) {
+        throw new Error(`Failed to write config file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+export const loadConfig = async (options, cwd = process.cwd()) => {
+    const { toolName, configFile, localConfigFile, defaultConfig, validate } = options;
+    const globalConfigPath = join(homedir(), ".config", toolName, configFile);
+    const globalConfig = await readConfigFile(globalConfigPath, validate);
+    const localConfigPath = await findUp(localConfigFile, cwd);
+    const localConfig = localConfigPath
+        ? await readConfigFile(localConfigPath, validate)
+        : null;
+    const config = {
+        ...defaultConfig,
+        ...(globalConfig || {}),
+        ...(localConfig || {}),
+    };
+    const sources = {};
+    for (const key in config) {
+        if (Object.hasOwn(config, key)) {
+            const k = key;
+            if (localConfig && Object.hasOwn(localConfig, k)) {
+                sources[k] = "local";
+            }
+            else if (globalConfig && Object.hasOwn(globalConfig, k)) {
+                sources[k] = "global";
+            }
+            else if (Object.hasOwn(defaultConfig, k)) {
+                sources[k] = "default";
+            }
+        }
+    }
+    return {
+        config,
+        sources,
+    };
+};
+export const getGlobalConfigPath = (toolName, configFile) => {
+    return join(homedir(), ".config", toolName, configFile);
+};
+export const findLocalConfigPath = async (localConfigFile, cwd = process.cwd()) => {
+    return findUp(localConfigFile, cwd);
+};
+export const writeLocalConfig = async (localConfigPath, config) => {
+    await writeConfig(localConfigPath, config);
+};
+export const loadLocalConfig = async (localConfigFile, validate, cwd = process.cwd()) => {
+    const existingPath = await findLocalConfigPath(localConfigFile, cwd);
+    if (existingPath) {
+        return {
+            path: existingPath,
+            config: await readConfigFile(existingPath, validate),
+            exists: true,
+        };
+    }
+    return {
+        path: join(cwd, localConfigFile),
+        config: null,
+        exists: false,
+    };
+};
+export const writeGlobalConfig = async (config, toolName, configFile) => {
+    const globalConfigPath = getGlobalConfigPath(toolName, configFile);
+    await writeConfig(globalConfigPath, config);
+};
+export const resetGlobalConfig = async (defaultConfig, toolName, configFile) => {
+    await writeGlobalConfig(defaultConfig, toolName, configFile);
+};

package/dist/lib/format.d.ts

@@ -0,0 +1,2 @@
+export declare const formatDate: (date: Date | null) => string;
+export declare const formatConfigValue: (value: unknown) => string;

package/dist/lib/format.js

@@ -0,0 +1,15 @@
+export const formatDate = (date) => {
+    if (!date) {
+        return "--";
+    }
+    return date.toISOString().split("T")[0] ?? "--";
+};
+export const formatConfigValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.length > 0 ? value.join(", ") : "(not set)";
+    }
+    if (value === undefined || value === null || value === "") {
+        return "(not set)";
+    }
+    return String(value);
+};

package/dist/lib/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./arg-parser.js";
+export * from "./cli.js";
+export * from "./config.js";
+export * from "./format.js";
+export * from "./index.js";
+export * from "./isDeepEqual.js";
+export * from "./isValidBranchName.js";
+export * from "./match.js";
+export * from "./package.js";
+export * from "./sanitizeString.js";

package/dist/lib/index.js

@@ -0,0 +1,10 @@
+export * from "./arg-parser.js";
+export * from "./cli.js";
+export * from "./config.js";
+export * from "./format.js";
+export * from "./index.js";
+export * from "./isDeepEqual.js";
+export * from "./isValidBranchName.js";
+export * from "./match.js";
+export * from "./package.js";
+export * from "./sanitizeString.js";

package/dist/lib/isDeepEqual.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Options for isDeepEqual comparison
+ */
+export interface IsDeepEqualOptions {
+    /**
+     * Whether to ignore array order when comparing arrays
+     * @default true
+     */
+    strictOrder?: boolean;
+}
+/**
+ * Performs a deep equality comparison between two values
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @param options - Comparison options
+ * @returns true if values are deeply equal, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isDeepEqual({ a: 1, b: [2, 3] }, { b: [2, 3], a: 1 }); // true
+ * isDeepEqual([1, 2, 3], [3, 2, 1]); // false
+ * isDeepEqual([1, 2, 3], [3, 2, 1], { strictOrder: false }); // true
+ * isDeepEqual(new Set([1, 2]), new Set([2, 1])); // true
+ * isDeepEqual(new Map([['a', 1]]), new Map([['a', 1]])); // true
+ * ```
+ */
+export declare function isDeepEqual(a: unknown, b: unknown, options?: IsDeepEqualOptions): boolean;

package/dist/lib/isDeepEqual.js

@@ -0,0 +1,147 @@
+/**
+ * Performs a deep equality comparison between two values
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @param options - Comparison options
+ * @returns true if values are deeply equal, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isDeepEqual({ a: 1, b: [2, 3] }, { b: [2, 3], a: 1 }); // true
+ * isDeepEqual([1, 2, 3], [3, 2, 1]); // false
+ * isDeepEqual([1, 2, 3], [3, 2, 1], { strictOrder: false }); // true
+ * isDeepEqual(new Set([1, 2]), new Set([2, 1])); // true
+ * isDeepEqual(new Map([['a', 1]]), new Map([['a', 1]])); // true
+ * ```
+ */
+export function isDeepEqual(a, b, options = {}) {
+    const { strictOrder = true } = options;
+    const visited = new WeakSet();
+    function compare(x, y) {
+        if (Object.is(x, y)) {
+            return true;
+        }
+        if (x == null || y == null) {
+            return false;
+        }
+        if (typeof x !== typeof y) {
+            return false;
+        }
+        if (typeof x !== "object" || typeof y !== "object") {
+            return false;
+        }
+        if (visited.has(x) || visited.has(y)) {
+            return true;
+        }
+        visited.add(x);
+        visited.add(y);
+        const ctorX = x.constructor;
+        const ctorY = y.constructor;
+        if (ctorX !== ctorY) {
+            return false;
+        }
+        if (x instanceof Date && y instanceof Date) {
+            return x.getTime() === y.getTime();
+        }
+        if (x instanceof RegExp && y instanceof RegExp) {
+            return x.toString() === y.toString();
+        }
+        if (Array.isArray(x) && Array.isArray(y)) {
+            if (x.length !== y.length) {
+                return false;
+            }
+            if (strictOrder) {
+                for (const [index, element] of x.entries()) {
+                    if (!compare(element, y[index])) {
+                        return false;
+                    }
+                }
+            }
+            else {
+                const yCopy = [...y];
+                for (const itemX of x) {
+                    let found = false;
+                    for (let index = 0; index < yCopy.length; index++) {
+                        if (compare(itemX, yCopy[index])) {
+                            yCopy.splice(index, 1);
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        return false;
+                    }
+                }
+                return yCopy.length === 0;
+            }
+            return true;
+        }
+        if (x instanceof Set && y instanceof Set) {
+            if (x.size !== y.size) {
+                return false;
+            }
+            for (const item of x) {
+                let found = false;
+                for (const otherItem of y) {
+                    if (compare(item, otherItem)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (x instanceof Map && y instanceof Map) {
+            if (x.size !== y.size) {
+                return false;
+            }
+            for (const [key, value] of x) {
+                let found = false;
+                for (const [otherKey, otherValue] of y) {
+                    if (compare(key, otherKey) && compare(value, otherValue)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (ArrayBuffer.isView(x) && ArrayBuffer.isView(y)) {
+            const xArray = x;
+            const yArray = y;
+            if (xArray.byteLength !== yArray.byteLength) {
+                return false;
+            }
+            for (let index = 0; index < xArray.byteLength; index++) {
+                if (xArray[index] !== yArray[index]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        const keysX = Object.keys(x);
+        const keysY = Object.keys(y);
+        if (keysX.length !== keysY.length) {
+            return false;
+        }
+        for (const key of keysX) {
+            if (!(key in y)) {
+                return false;
+            }
+        }
+        for (const key of keysX) {
+            if (!compare(x[key], y[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return compare(a, b);
+}

package/dist/lib/isValidBranchName.d.ts

@@ -0,0 +1 @@
+export declare function isValidBranchName(branchName: string): boolean;

package/dist/lib/isValidBranchName.js

@@ -0,0 +1,28 @@
+export function isValidBranchName(branchName) {
+    if (!branchName || branchName.length === 0) {
+        return false;
+    }
+    if (!/^[a-zA-Z0-9-._/]+$/.test(branchName)) {
+        return false;
+    }
+    if (branchName.includes("..")) {
+        return false;
+    }
+    if (branchName.startsWith("/") || branchName.endsWith("/")) {
+        return false;
+    }
+    if (branchName.includes("//")) {
+        return false;
+    }
+    if (branchName.endsWith(".")) {
+        return false;
+    }
+    const components = branchName.split("/");
+    for (const component of components) {
+        if (component.length > 0 &&
+            (component.startsWith(".") || component.endsWith(".lock"))) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/lib/match.d.ts

@@ -0,0 +1 @@
+export declare const matchPattern: (text: string, pattern: string) => boolean;

package/dist/lib/match.js

@@ -0,0 +1,12 @@
+export const matchPattern = (text, pattern) => {
+    if (pattern.startsWith("/") && pattern.lastIndexOf("/") > 0) {
+        try {
+            const regex = new RegExp(pattern.slice(1, pattern.lastIndexOf("/")), pattern.slice(pattern.lastIndexOf("/") + 1));
+            return regex.test(text);
+        }
+        catch {
+            return false;
+        }
+    }
+    return text === pattern;
+};

package/dist/lib/package.d.ts

@@ -0,0 +1,7 @@
+interface PackageJson {
+    name: string;
+    version: string;
+    [key: string]: unknown;
+}
+export declare const loadPackageJson: (importMetaUrl: string) => PackageJson;
+export {};

package/dist/lib/package.js

@@ -0,0 +1,10 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+export const loadPackageJson = (importMetaUrl) => {
+    const filename = fileURLToPath(importMetaUrl);
+    const scriptDir = dirname(filename);
+    const packageJsonPath = join(scriptDir, "..", "package.json");
+    const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
+    return JSON.parse(packageJsonContent);
+};

package/dist/lib/sanitizeString.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sanitizes a string by removing non-printable characters.
+ * This is useful for cleaning up output from external commands before displaying it in the terminal.
+ * It allows printable ASCII characters (space to tilde), newlines, carriage returns, and tabs.
+ * @param str The string to sanitize.
+ * @returns The sanitized string.
+ */
+export declare const sanitizeString: (str: string) => string;

package/dist/lib/sanitizeString.js

@@ -0,0 +1,10 @@
+/**
+ * Sanitizes a string by removing non-printable characters.
+ * This is useful for cleaning up output from external commands before displaying it in the terminal.
+ * It allows printable ASCII characters (space to tilde), newlines, carriage returns, and tabs.
+ * @param str The string to sanitize.
+ * @returns The sanitized string.
+ */
+export const sanitizeString = (str) => {
+    return str.replace(/[^ -~\n\r\t]/g, "");
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+	"name": "ag-toolkit",
+	"version": "0.1.0",
+	"description": "Shared library for agbd and agrb",
+	"license": "MIT",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/riya-amemiya/ag-toolkit.git"
+	},
+	"homepage": "https://github.com/riya-amemiya/ag-toolkit#readme",
+	"bugs": {
+		"url": "https://github.com/riya-amemiya/ag-toolkit/issues"
+	},
+	"exports": {
+		".": "./dist/index.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"test": "biome check .",
+		"lint": "biome check . --write",
+		"ci": "biome ci ."
+	},
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"ink": "6.3.1",
+		"ink-select-input": "6.2.0",
+		"ink-spinner": "5.0.0",
+		"react": "19.1.1",
+		"simple-git": "3.28.0",
+		"valibot": "1.1.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.2.4",
+		"@sindresorhus/tsconfig": "8.0.1",
+		"@types/bun": "1.2.22",
+		"@types/react": "19.1.13",
+		"chalk": "5.6.2",
+		"ink-testing-library": "4.0.0",
+		"ts-node": "10.9.2",
+		"typescript": "5.9.2"
+	}
+}