ag-toolkit 0.1.3 → 0.2.0

package/dist/tests/match.test.js

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test";
+import { matchPattern } from "../lib/match.js";
+describe("matchPattern", () => {
+    describe("exact string matching", () => {
+        test("should match identical strings", () => {
+            expect(matchPattern("hello", "hello")).toBe(true);
+            expect(matchPattern("test123", "test123")).toBe(true);
+        });
+        test("should not match different strings", () => {
+            expect(matchPattern("hello", "world")).toBe(false);
+            expect(matchPattern("test", "test123")).toBe(false);
+        });
+        test("should be case-sensitive for exact matches", () => {
+            expect(matchPattern("Hello", "hello")).toBe(false);
+            expect(matchPattern("TEST", "test")).toBe(false);
+        });
+        test("should handle empty strings", () => {
+            expect(matchPattern("", "")).toBe(true);
+            expect(matchPattern("test", "")).toBe(false);
+            expect(matchPattern("", "test")).toBe(false);
+        });
+    });
+    describe("regex pattern matching", () => {
+        test("should match regex patterns with delimiters", () => {
+            expect(matchPattern("hello", "/hello/")).toBe(true);
+            expect(matchPattern("test123", "/test\\d+/")).toBe(true);
+            expect(matchPattern("abc", "/[a-z]+/")).toBe(true);
+        });
+        test("should not match when regex pattern doesn't match", () => {
+            expect(matchPattern("hello", "/world/")).toBe(false);
+            expect(matchPattern("abc", "/\\d+/")).toBe(false);
+        });
+        test("should support regex flags", () => {
+            expect(matchPattern("Hello", "/hello/i")).toBe(true);
+            expect(matchPattern("TEST", "/test/i")).toBe(true);
+            expect(matchPattern("Hello", "/hello/")).toBe(false);
+        });
+        test("should support global flag", () => {
+            expect(matchPattern("test test", "/test/g")).toBe(true);
+        });
+        test("should support multiline flag", () => {
+            expect(matchPattern("line1\nline2", "/^line2/m")).toBe(true);
+        });
+        test("should handle complex regex patterns", () => {
+            expect(matchPattern("email@example.com", "/^[\\w.-]+@[\\w.-]+\\.\\w+$/")).toBe(true);
+            expect(matchPattern("2024-01-01", "/^\\d{4}-\\d{2}-\\d{2}$/")).toBe(true);
+            expect(matchPattern("invalid-date", "/^\\d{4}-\\d{2}-\\d{2}$/")).toBe(false);
+        });
+        test("should handle patterns with special characters", () => {
+            expect(matchPattern("(test)", "/\\(test\\)/")).toBe(true);
+            expect(matchPattern("[abc]", "/\\[abc\\]/")).toBe(true);
+            expect(matchPattern("a.b", "/a\\.b/")).toBe(true);
+        });
+        test("should return false for invalid regex patterns", () => {
+            expect(matchPattern("test", "/(/")).toBe(false);
+            expect(matchPattern("test", "/[/")).toBe(false);
+            expect(matchPattern("test", "/*/")).toBe(false);
+        });
+        test("should handle patterns with multiple slashes", () => {
+            expect(matchPattern("path/to/file", "/path\\/to\\/file/")).toBe(true);
+        });
+    });
+    describe("edge cases", () => {
+        test("should treat patterns without proper delimiters as exact strings", () => {
+            expect(matchPattern("/test", "/test")).toBe(true);
+            expect(matchPattern("test/", "test/")).toBe(true);
+        });
+        test("should handle patterns that look like regex but aren't properly formatted", () => {
+            expect(matchPattern("/test", "/test")).toBe(true);
+            expect(matchPattern("test/", "test/")).toBe(true);
+        });
+        test("should handle empty regex pattern", () => {
+            expect(matchPattern("test", "//")).toBe(true);
+            expect(matchPattern("", "//")).toBe(true);
+        });
+        test("should handle patterns with only opening slash", () => {
+            expect(matchPattern("/hello", "/hello")).toBe(true);
+            expect(matchPattern("hello", "/hello")).toBe(false);
+        });
+        test("should handle anchored patterns", () => {
+            expect(matchPattern("hello world", "/^hello/")).toBe(true);
+            expect(matchPattern("hello world", "/world$/")).toBe(true);
+            expect(matchPattern("hello world", "/^world/")).toBe(false);
+        });
+    });
+});

package/dist/tests/package.test.d.ts

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

package/dist/tests/package.test.js

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadPackageJson } from "../lib/package.js";
+describe("loadPackageJson", () => {
+    let testDir;
+    let testScriptPath;
+    beforeEach(() => {
+        testDir = join(tmpdir(), `package-test-${Date.now()}`);
+        const scriptDir = join(testDir, "lib");
+        Bun.spawnSync(["mkdir", "-p", scriptDir]);
+        testScriptPath = join(scriptDir, "test-script.js");
+    });
+    afterEach(() => {
+        Bun.spawnSync(["rm", "-rf", testDir]);
+    });
+    test("should load and parse package.json", () => {
+        const packageJson = {
+            name: "test-package",
+            version: "1.0.0",
+            description: "Test package",
+        };
+        writeFileSync(join(testDir, "package.json"), JSON.stringify(packageJson));
+        writeFileSync(testScriptPath, "");
+        const scriptUrl = `file://${testScriptPath}`;
+        const result = loadPackageJson(scriptUrl);
+        expect(result.name).toBe("test-package");
+        expect(result.version).toBe("1.0.0");
+        // biome-ignore lint/complexity/useLiteralKeys: ignore
+        expect(result["description"]).toBe("Test package");
+    });
+    test("should handle package.json with additional properties", () => {
+        const packageJson = {
+            name: "test-package",
+            version: "2.0.0",
+            author: "Test Author",
+            license: "MIT",
+            dependencies: {
+                "some-package": "^1.0.0",
+            },
+        };
+        writeFileSync(join(testDir, "package.json"), JSON.stringify(packageJson));
+        writeFileSync(testScriptPath, "");
+        const scriptUrl = `file://${testScriptPath}`;
+        const result = loadPackageJson(scriptUrl);
+        expect(result.name).toBe("test-package");
+        expect(result.version).toBe("2.0.0");
+        // biome-ignore lint/complexity/useLiteralKeys: ignore
+        expect(result["author"]).toBe("Test Author");
+        // biome-ignore lint/complexity/useLiteralKeys: ignore
+        expect(result["license"]).toBe("MIT");
+    });
+    test("should throw error when package.json doesn't exist", () => {
+        writeFileSync(testScriptPath, "");
+        const scriptUrl = `file://${testScriptPath}`;
+        expect(() => loadPackageJson(scriptUrl)).toThrow();
+    });
+    test("should throw error for invalid JSON in package.json", () => {
+        writeFileSync(join(testDir, "package.json"), "{ invalid json }");
+        writeFileSync(testScriptPath, "");
+        const scriptUrl = `file://${testScriptPath}`;
+        expect(() => loadPackageJson(scriptUrl)).toThrow();
+    });
+    test("should handle package.json with minimal required fields", () => {
+        const packageJson = {
+            name: "minimal-package",
+            version: "0.0.1",
+        };
+        writeFileSync(join(testDir, "package.json"), JSON.stringify(packageJson));
+        writeFileSync(testScriptPath, "");
+        const scriptUrl = `file://${testScriptPath}`;
+        const result = loadPackageJson(scriptUrl);
+        expect(result.name).toBe("minimal-package");
+        expect(result.version).toBe("0.0.1");
+    });
+});

package/dist/tests/sanitizeString.test.d.ts

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

package/dist/tests/sanitizeString.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test";
+import { sanitizeString } from "../lib/sanitizeString.js";
+describe("sanitizeString", () => {
+    test("should return unchanged string for printable ASCII characters", () => {
+        expect(sanitizeString("Hello World")).toBe("Hello World");
+        expect(sanitizeString("ABC123")).toBe("ABC123");
+        expect(sanitizeString("!@#$%^&*()")).toBe("!@#$%^&*()");
+    });
+    test("should preserve newlines", () => {
+        expect(sanitizeString("line1\nline2")).toBe("line1\nline2");
+        expect(sanitizeString("first\nsecond\nthird")).toBe("first\nsecond\nthird");
+    });
+    test("should preserve carriage returns", () => {
+        expect(sanitizeString("line1\rline2")).toBe("line1\rline2");
+    });
+    test("should preserve tabs", () => {
+        expect(sanitizeString("column1\tcolumn2")).toBe("column1\tcolumn2");
+        expect(sanitizeString("\tindented")).toBe("\tindented");
+    });
+    test("should remove non-printable characters", () => {
+        expect(sanitizeString("test\x00string")).toBe("teststring");
+        expect(sanitizeString("hello\x01world")).toBe("helloworld");
+        expect(sanitizeString("test\x1Bstring")).toBe("teststring");
+    });
+    test("should remove ANSI escape codes", () => {
+        expect(sanitizeString("\x1b[31mRed Text\x1b[0m")).toBe("[31mRed Text[0m");
+        expect(sanitizeString("\x1b[1;32mGreen\x1b[0m")).toBe("[1;32mGreen[0m");
+    });
+    test("should handle empty strings", () => {
+        expect(sanitizeString("")).toBe("");
+    });
+    test("should handle strings with only non-printable characters", () => {
+        expect(sanitizeString("\x00\x01\x02")).toBe("");
+    });
+    test("should handle mixed printable and non-printable characters", () => {
+        expect(sanitizeString("Hello\x00World\x01!")).toBe("HelloWorld!");
+    });
+    test("should preserve spaces", () => {
+        expect(sanitizeString("  spaces  ")).toBe("  spaces  ");
+    });
+    test("should handle unicode characters outside printable ASCII", () => {
+        expect(sanitizeString("Hello 世界")).toBe("Hello ");
+        expect(sanitizeString("Emoji 😀 test")).toBe("Emoji  test");
+    });
+    test("should handle strings with newlines, tabs, and carriage returns mixed", () => {
+        expect(sanitizeString("line1\nline2\tcolumn\rend")).toBe("line1\nline2\tcolumn\rend");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ag-toolkit",
-	"version": "0.1.3",
+	"version": "0.2.0",
 	"description": "Shared library for agbd and agrb",
 	"license": "MIT",
 	"type": "module",
@@ -20,9 +20,10 @@
 	"scripts": {
 		"build": "tsc",
 		"dev": "tsc --watch",
-		"test": "biome check .",
+		"test": "bun test",
+		"test:watch": "bun test --watch",
 		"lint": "biome check . --write",
-		"ci": "biome ci .",
+		"ci": "biome ci . && bun test",
 		"prepublishOnly": "npm run build"
 	},
 	"files": [
@@ -35,18 +36,18 @@
 		"ink": "6.3.1",
 		"ink-select-input": "6.2.0",
 		"ink-spinner": "5.0.0",
-		"react": "19.1.1",
+		"react": "19.2.0",
 		"simple-git": "3.28.0",
 		"valibot": "1.1.0"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.2.4",
+		"@biomejs/biome": "2.2.5",
 		"@sindresorhus/tsconfig": "8.0.1",
-		"@types/bun": "1.2.22",
-		"@types/react": "19.1.13",
+		"@types/bun": "1.2.23",
+		"@types/react": "19.2.0",
 		"chalk": "5.6.2",
 		"ink-testing-library": "4.0.0",
 		"ts-node": "10.9.2",
-		"typescript": "5.9.2"
+		"typescript": "5.9.3"
 	}
 }