ag-toolkit 0.4.1 → 0.6.0

package/dist/components/ConfigEditor.js

@@ -3,8 +3,8 @@ import { Box, Text, useApp, useInput } from "ink";
 import SelectInput from "ink-select-input";
 import Spinner from "ink-spinner";
 import { useEffect, useMemo, useState } from "react";
+import { isDeepEqual } from "umt/Validate";
 import { formatConfigValue } from "../lib/format.js";
-import { isDeepEqual } from "../lib/isDeepEqual.js";
 import { BooleanItem, Item } from "./ConfigEditorItem.js";
 export const ConfigEditor = ({ toolName, configItems, defaultConfig, loadConfig, writeConfig, }) => {
     const { exit } = useApp();

package/dist/git.d.ts

@@ -1,16 +1,30 @@
-export type BranchType = "local" | "remote";
-export interface BranchInfo {
+import { type SchemaToInterface } from "umt/Validate";
+export declare const BranchTypeSchema: (value: string) => import("umt/Validate").OneOfReturnType<"local" | "remote">;
+export type BranchType = SchemaToInterface<typeof BranchTypeSchema>;
+declare const BranchInfoSchema: import("umt/Validate").ObjectValidator<{
+    ref: (value: string) => import("umt/Validate").ValidateCoreReturnType<string>;
+    name: (value: string) => import("umt/Validate").ValidateCoreReturnType<string>;
+    type: (value: string) => import("umt/Validate").OneOfReturnType<"local" | "remote">;
+    remote: import("umt/Validate").OptionalValidator<string, import("umt/Validate").ValidateCoreReturnType<string>>;
+    lastCommitDate: (value: Date | null) => import("umt/Validate").NullReturn | import("umt/Validate").ValidateCoreReturnType<Date>;
+    lastCommitSha: (value: string | null) => import("umt/Validate").ValidateCoreReturnType<string> | import("umt/Validate").NullReturn;
+    lastCommitSubject: (value: string | null) => import("umt/Validate").ValidateCoreReturnType<string> | import("umt/Validate").NullReturn;
+    isMerged: (value: boolean) => import("umt/Validate").ValidateCoreReturnType<boolean>;
+    ahead: (value: number) => import("umt/Validate").ValidateCoreReturnType<number>;
+    behind: (value: number) => import("umt/Validate").ValidateCoreReturnType<number>;
+}, {
     ref: string;
     name: string;
-    type: BranchType;
-    remote?: string;
+    type: "local" | "remote";
+    remote: string | undefined;
     lastCommitDate: Date | null;
     lastCommitSha: string | null;
     lastCommitSubject: string | null;
     isMerged: boolean;
     ahead: number;
     behind: number;
-}
+}>;
+export type BranchInfo = SchemaToInterface<typeof BranchInfoSchema>;
 export declare class GitOperations {
     private git;
     constructor(workingDir?: string);
@@ -59,3 +73,4 @@ export declare class GitOperations {
     popStash(stashRef: string): Promise<void>;
     pushWithLease(branch: string): Promise<void>;
 }
+export {};

package/dist/git.js

@@ -1,5 +1,19 @@
 import { simpleGit } from "simple-git";
+import { boolean, date, nullable, number, object, oneOf, optional, string, } from "umt/Validate";
 import { isValidBranchName } from "./lib/isValidBranchName.js";
+export const BranchTypeSchema = oneOf(["local", "remote"]);
+const BranchInfoSchema = object({
+    ref: string(),
+    name: string(),
+    type: BranchTypeSchema,
+    remote: optional(string()),
+    lastCommitDate: nullable(date()),
+    lastCommitSha: nullable(string()),
+    lastCommitSubject: nullable(string()),
+    isMerged: boolean(),
+    ahead: number(),
+    behind: number(),
+});
 const BRANCH_LIST_FORMAT = "%(refname)%00%(committerdate:iso8601)%00%(objectname)%00%(contents:subject)";
 export class GitOperations {
     git;

package/dist/lib/index.d.ts

@@ -3,7 +3,6 @@ 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";

package/dist/lib/index.js

@@ -3,7 +3,6 @@ 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";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ag-toolkit",
-	"version": "0.4.1",
+	"version": "0.6.0",
 	"description": "Shared library for agbd and agrb",
 	"license": "MIT",
 	"type": "module",
@@ -33,20 +33,27 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"ink": "6.6.0",
-		"ink-select-input": "6.2.0",
-		"ink-spinner": "5.0.0",
-		"react": "19.2.3",
-		"simple-git": "3.30.0"
+		"simple-git": "3.36.0",
+		"umt": "3.1.0"
+	},
+	"peerDependencies": {
+		"ink": ">=6.0.0",
+		"ink-select-input": ">=6.0.0",
+		"ink-spinner": ">=5.0.0",
+		"react": ">=18.0.0"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.3.11",
+		"@biomejs/biome": "2.4.15",
 		"@sindresorhus/tsconfig": "8.1.0",
-		"@types/bun": "1.3.5",
-		"@types/react": "19.2.8",
+		"@types/bun": "1.3.13",
+		"@types/react": "19.2.14",
 		"chalk": "5.6.2",
+		"ink": "7.0.2",
+		"ink-select-input": "6.2.0",
+		"ink-spinner": "5.0.0",
 		"ink-testing-library": "4.0.0",
+		"react": "19.2.6",
 		"ts-node": "10.9.2",
-		"typescript": "5.9.3"
+		"typescript": "6.0.3"
 	}
 }

package/dist/lib/isDeepEqual.d.ts

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,147 +0,0 @@
-/**
- * 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/tests/arg-parser.test.d.ts

@@ -1 +0,0 @@
-export {};