ag-toolkit 0.5.0 → 0.6.0

package/dist/tests/arg-parser.test.js

@@ -1,404 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ArgParser, defineSchema } from "../lib/arg-parser.js";
-describe("ArgParser", () => {
-    const schema = defineSchema({
-        verbose: { type: "boolean", shortFlag: "v" },
-        output: { type: "string", shortFlag: "o" },
-        force: { type: "boolean" },
-        configFile: { type: "string" },
-    });
-    describe("help and version flags", () => {
-        test("should return help message when -h is passed", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "Test help message",
-                version: "1.0.0",
-            });
-            const result = parser.parse(["-h"]);
-            expect(result.help).toBe("Test help message");
-        });
-        test("should return help message when --help is passed", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "Test help message",
-                version: "1.0.0",
-            });
-            const result = parser.parse(["--help"]);
-            expect(result.help).toBe("Test help message");
-        });
-        test("should return version when -v is passed (not short flag conflict)", () => {
-            const schemaWithoutVerbose = {
-                output: { type: "string", shortFlag: "o" },
-            };
-            const parser = new ArgParser({
-                schema: schemaWithoutVerbose,
-                helpMessage: "Test help",
-                version: "1.0.0",
-            });
-            const result = parser.parse(["-v"]);
-            expect(result.version).toBe("1.0.0");
-        });
-        test("should return version when --version is passed", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "Test help",
-                version: "1.0.0",
-            });
-            const result = parser.parse(["--version"]);
-            expect(result.version).toBe("1.0.0");
-        });
-    });
-    describe("boolean flags", () => {
-        test("should parse long boolean flags", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--verbose", "--force"]);
-            expect(result.flags.verbose).toBe(true);
-            expect(result.flags.force).toBe(true);
-        });
-        test("should parse short boolean flags", () => {
-            const schemaWithDifferentShortFlag = {
-                ...schema,
-                verbose: { type: "boolean", shortFlag: "V" },
-            };
-            const parser = new ArgParser({
-                schema: schemaWithDifferentShortFlag,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["-V"]);
-            expect(result.flags.verbose).toBe(true);
-        });
-        test("should handle camelCase to kebab-case conversion", () => {
-            const parser = new ArgParser({
-                schema: { myLongFlag: { type: "boolean" } },
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--my-long-flag"]);
-            expect(result.flags.myLongFlag).toBe(true);
-        });
-        test("should leave undefined flags as undefined", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse([]);
-            expect(result.flags.verbose).toBeUndefined();
-            expect(result.flags.force).toBeUndefined();
-        });
-    });
-    describe("enum flags", () => {
-        const schemaWithEnum = defineSchema({
-            logLevel: {
-                type: "enum",
-                enumValues: ["debug", "info", "warn", "error"],
-                shortFlag: "l",
-            },
-            environment: {
-                type: "enum",
-                enumValues: ["development", "staging", "production"],
-            },
-        });
-        test("should parse long enum flags with space", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--log-level", "info"]);
-            expect(result.flags.logLevel).toBe("info");
-        });
-        test("should parse long enum flags with equals", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--log-level=error"]);
-            expect(result.flags.logLevel).toBe("error");
-        });
-        test("should parse short enum flags", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["-l", "debug"]);
-            expect(result.flags.logLevel).toBe("debug");
-        });
-        test("should parse short enum flags with equals", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["-l=warn"]);
-            expect(result.flags.logLevel).toBe("warn");
-        });
-        test("should handle camelCase to kebab-case for enum flags", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--log-level", "info"]);
-            expect(result.flags.logLevel).toBe("info");
-        });
-        test("should throw error when enum flag has invalid value", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            expect(() => parser.parse(["--log-level", "invalid"])).toThrow("Flag --logLevel must be one of: debug, info, warn, error");
-        });
-        test("should throw error when enum flag has no value", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            expect(() => parser.parse(["--log-level"])).toThrow("Flag --logLevel requires a value");
-        });
-        test("should parse multiple enum flags", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse([
-                "--log-level",
-                "debug",
-                "--environment",
-                "production",
-            ]);
-            expect(result.flags.logLevel).toBe("debug");
-            expect(result.flags.environment).toBe("production");
-        });
-        test("should leave undefined enum flags as undefined", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse([]);
-            expect(result.flags.logLevel).toBeUndefined();
-            expect(result.flags.environment).toBeUndefined();
-        });
-        test("should handle multiple occurrences of same enum flag (last wins)", () => {
-            const parser = new ArgParser({
-                schema: schemaWithEnum,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse([
-                "--log-level",
-                "debug",
-                "--log-level",
-                "error",
-            ]);
-            expect(result.flags.logLevel).toBe("error");
-        });
-    });
-    describe("string flags", () => {
-        test("should parse long string flags with space", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--output", "file.txt"]);
-            expect(result.flags.output).toBe("file.txt");
-        });
-        test("should parse long string flags with equals", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--output=file.txt"]);
-            expect(result.flags.output).toBe("file.txt");
-        });
-        test("should parse short string flags", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["-o", "file.txt"]);
-            expect(result.flags.output).toBe("file.txt");
-        });
-        test("should parse short string flags with equals", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["-o=file.txt"]);
-            expect(result.flags.output).toBe("file.txt");
-        });
-        test("should handle camelCase to kebab-case for string flags", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--config-file", "config.json"]);
-            expect(result.flags.configFile).toBe("config.json");
-        });
-        test("should throw error when string flag has no value", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            expect(() => parser.parse(["--output"])).toThrow();
-        });
-    });
-    describe("input arguments", () => {
-        test("should collect non-flag arguments as input", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["arg1", "arg2", "arg3"]);
-            expect(result.input).toEqual(["arg1", "arg2", "arg3"]);
-        });
-        test("should collect input after flags", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--verbose", "arg1", "arg2"]);
-            expect(result.flags.verbose).toBe(true);
-            expect(result.input).toEqual(["arg1", "arg2"]);
-        });
-        test("should handle -- separator", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--verbose", "--", "--output", "file.txt"]);
-            expect(result.flags.verbose).toBe(true);
-            expect(result.flags.output).toBeUndefined();
-            expect(result.input).toEqual(["--output", "file.txt"]);
-        });
-        test("should collect everything after -- as input", () => {
-            const schemaWithoutConflicts = defineSchema({
-                force: { type: "boolean" },
-            });
-            const parser = new ArgParser({
-                schema: schemaWithoutConflicts,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--", "--force"]);
-            expect(result.input).toEqual(["--force"]);
-        });
-    });
-    describe("mixed arguments", () => {
-        test("should parse mixed flags and input", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse([
-                "--verbose",
-                "--output",
-                "file.txt",
-                "input1",
-                "--force",
-                "input2",
-            ]);
-            expect(result.flags.verbose).toBe(true);
-            expect(result.flags.output).toBe("file.txt");
-            expect(result.flags.force).toBe(true);
-            expect(result.input).toEqual(["input1", "input2"]);
-        });
-        test("should handle multiple flags with equals syntax", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse([
-                "--verbose",
-                "--output=out.txt",
-                "--config-file=config.json",
-            ]);
-            expect(result.flags.verbose).toBe(true);
-            expect(result.flags.output).toBe("out.txt");
-            expect(result.flags.configFile).toBe("config.json");
-        });
-    });
-    describe("error handling", () => {
-        test("should throw error for unknown long flags", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            expect(() => parser.parse(["--unknown"])).toThrow("Unknown option: --unknown");
-        });
-        test("should throw error for unknown short flags", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            expect(() => parser.parse(["-x"])).toThrow("Unknown option: -x");
-        });
-        test("should throw error when string flag requires value", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            expect(() => parser.parse(["--output"])).toThrow("Flag --output requires a value");
-        });
-    });
-    describe("edge cases", () => {
-        test("should handle empty args array", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse([]);
-            expect(result.input).toEqual([]);
-            expect(result.flags.verbose).toBeUndefined();
-        });
-        test("should handle flags with empty string values", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse(["--output="]);
-            expect(result.flags.output).toBe("");
-        });
-        test("should handle multiple occurrences of same flag (last wins)", () => {
-            const parser = new ArgParser({
-                schema,
-                helpMessage: "",
-                version: "",
-            });
-            const result = parser.parse([
-                "--output",
-                "first.txt",
-                "--output",
-                "second.txt",
-            ]);
-            expect(result.flags.output).toBe("second.txt");
-        });
-    });
-});

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

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

package/dist/tests/config.test.js

@@ -1,234 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { promises as fs } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { findLocalConfigPath, findUp, getGlobalConfigPath, loadConfig, loadLocalConfig, readConfigFile, resetGlobalConfig, writeConfig, writeGlobalConfig, writeLocalConfig, } from "../lib/config.js";
-describe("config", () => {
-    let testDir;
-    beforeEach(async () => {
-        testDir = await fs.mkdtemp(join(tmpdir(), "config-test-"));
-    });
-    afterEach(async () => {
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    describe("findUp", () => {
-        test("should find file in current directory", async () => {
-            const testFile = "test-config.json";
-            await fs.writeFile(join(testDir, testFile), "{}");
-            const result = await findUp(testFile, testDir);
-            expect(result).toBe(join(testDir, testFile));
-        });
-        test("should find file in parent directory", async () => {
-            const testFile = "test-config.json";
-            const subDir = join(testDir, "subdir");
-            await fs.mkdir(subDir);
-            await fs.writeFile(join(testDir, testFile), "{}");
-            const result = await findUp(testFile, subDir);
-            expect(result).toBe(join(testDir, testFile));
-        });
-        test("should return null when file is not found", async () => {
-            const subDir = join(process.cwd(), "src", "tests");
-            const result = await findUp("nonexistent-file-that-should-not-exist.json", subDir);
-            expect(result).toBeNull();
-        });
-        test("should find file in nested parent directories", async () => {
-            const testFile = "test-config.json";
-            const deepDir = join(testDir, "a", "b", "c");
-            await fs.mkdir(deepDir, { recursive: true });
-            await fs.writeFile(join(testDir, testFile), "{}");
-            const result = await findUp(testFile, deepDir);
-            expect(result).toBe(join(testDir, testFile));
-        });
-    });
-    describe("readConfigFile", () => {
-        test("should read and parse valid JSON config file", async () => {
-            const configPath = join(testDir, "config.json");
-            const config = { key: "value", number: 42 };
-            await fs.writeFile(configPath, JSON.stringify(config));
-            const validate = (c) => c;
-            const result = await readConfigFile(configPath, validate);
-            expect(result).toEqual(config);
-        });
-        test("should return null for non-existent file", async () => {
-            const validate = (c) => c;
-            const result = await readConfigFile(join(testDir, "nonexistent.json"), validate);
-            expect(result).toBeNull();
-        });
-        test("should throw error for invalid JSON", async () => {
-            const configPath = join(testDir, "invalid.json");
-            await fs.writeFile(configPath, "{ invalid json }");
-            const validate = (c) => c;
-            await expect(readConfigFile(configPath, validate)).rejects.toThrow();
-        });
-    });
-    describe("writeConfig", () => {
-        test("should write config to file", async () => {
-            const configPath = join(testDir, "config.json");
-            const config = { key: "value", nested: { prop: 123 } };
-            await writeConfig(configPath, config);
-            const content = await fs.readFile(configPath, "utf-8");
-            expect(JSON.parse(content)).toEqual(config);
-        });
-        test("should create parent directories if they don't exist", async () => {
-            const configPath = join(testDir, "nested", "deep", "config.json");
-            const config = { key: "value" };
-            await writeConfig(configPath, config);
-            const content = await fs.readFile(configPath, "utf-8");
-            expect(JSON.parse(content)).toEqual(config);
-        });
-        test("should format JSON with 2-space indentation", async () => {
-            const configPath = join(testDir, "config.json");
-            const config = { key: "value" };
-            await writeConfig(configPath, config);
-            const content = await fs.readFile(configPath, "utf-8");
-            expect(content).toBe('{\n  "key": "value"\n}');
-        });
-        test("should throw error when write fails", async () => {
-            const invalidPath = "/invalid/path/that/cannot/be/created/config.json";
-            const config = { key: "value" };
-            expect(writeConfig(invalidPath, config)).rejects.toThrow("Failed to write config file");
-        });
-    });
-    describe("loadConfig", () => {
-        test("should return default config when no config files exist", async () => {
-            const defaultConfig = { option1: "default", option2: 42 };
-            const validate = (c) => c;
-            const cwdDir = join(process.cwd(), "src", "tests");
-            const result = await loadConfig({
-                toolName: "test-tool-nonexistent",
-                configFile: "config-nonexistent.json",
-                localConfigFile: ".testrc-nonexistent",
-                defaultConfig,
-                validate,
-            }, cwdDir);
-            expect(result.config).toEqual(defaultConfig);
-            expect(result.sources.option1).toBe("default");
-            expect(result.sources.option2).toBe("default");
-        });
-        test("should merge local config over default", async () => {
-            const defaultConfig = { option1: "default", option2: 42 };
-            const localConfig = { option1: "local" };
-            const validate = (c) => c;
-            await fs.writeFile(join(testDir, ".testrc"), JSON.stringify(localConfig));
-            const result = await loadConfig({
-                toolName: "test-tool",
-                configFile: "config.json",
-                localConfigFile: ".testrc",
-                defaultConfig,
-                validate,
-            }, testDir);
-            expect(result.config.option1).toBe("local");
-            expect(result.config.option2).toBe(42);
-            expect(result.sources.option1).toBe("local");
-            expect(result.sources.option2).toBe("default");
-        });
-        test("should merge global config over default", async () => {
-            const defaultConfig = { option1: "default", option2: 42 };
-            const globalConfig = { option1: "global" };
-            const validate = (c) => c;
-            const globalConfigPath = getGlobalConfigPath("test-tool-global", "config.json");
-            try {
-                await writeGlobalConfig(globalConfig, "test-tool-global", "config.json");
-                const cwdDir = join(process.cwd(), "src", "tests");
-                const result = await loadConfig({
-                    toolName: "test-tool-global",
-                    configFile: "config.json",
-                    localConfigFile: ".testrc-nonexistent",
-                    defaultConfig,
-                    validate,
-                }, cwdDir);
-                expect(result.config.option1).toBe("global");
-                expect(result.config.option2).toBe(42);
-                expect(result.sources.option1).toBe("global");
-                expect(result.sources.option2).toBe("default");
-            }
-            finally {
-                fs.rm(globalConfigPath, { force: true });
-                const dir = join(globalConfigPath, "..");
-                fs.rm(dir, { force: true, recursive: true });
-            }
-        });
-    });
-    describe("getGlobalConfigPath", () => {
-        test("should return correct global config path", () => {
-            const path = getGlobalConfigPath("my-tool", "config.json");
-            expect(path).toContain(".config");
-            expect(path).toContain("my-tool");
-            expect(path).toContain("config.json");
-        });
-    });
-    describe("findLocalConfigPath", () => {
-        test("should find local config file", async () => {
-            await fs.writeFile(join(testDir, ".testrc"), "{}");
-            const result = await findLocalConfigPath(".testrc", testDir);
-            expect(result).toBe(join(testDir, ".testrc"));
-        });
-        test("should return null when local config doesn't exist", async () => {
-            const cwdDir = join(process.cwd(), "src", "tests");
-            const result = await findLocalConfigPath(".testrc-nonexistent", cwdDir);
-            expect(result).toBeNull();
-        });
-    });
-    describe("writeLocalConfig", () => {
-        test("should write local config", async () => {
-            const configPath = join(testDir, ".testrc");
-            const config = { key: "value" };
-            await writeLocalConfig(configPath, config);
-            const content = await fs.readFile(configPath, "utf-8");
-            expect(JSON.parse(content)).toEqual(config);
-        });
-    });
-    describe("loadLocalConfig", () => {
-        test("should load existing local config", async () => {
-            const config = { key: "value" };
-            const configPath = join(testDir, ".testrc");
-            await fs.writeFile(configPath, JSON.stringify(config));
-            const validate = (c) => c;
-            const result = await loadLocalConfig(".testrc", validate, testDir);
-            expect(result.exists).toBe(true);
-            expect(result.config).toEqual(config);
-            expect(result.path).toBe(configPath);
-        });
-        test("should return null config when file doesn't exist", async () => {
-            const validate = (c) => c;
-            const cwdDir = join(process.cwd(), "src", "tests");
-            const result = await loadLocalConfig(".testrc-nonexistent", validate, cwdDir);
-            expect(result.exists).toBe(false);
-            expect(result.config).toBeNull();
-            expect(result.path).toBe(join(cwdDir, ".testrc-nonexistent"));
-        });
-    });
-    describe("writeGlobalConfig", () => {
-        test("should write global config", async () => {
-            const config = { key: "value" };
-            const globalPath = getGlobalConfigPath("test-tool-temp", "config.json");
-            try {
-                await writeGlobalConfig(config, "test-tool-temp", "config.json");
-                const content = await fs.readFile(globalPath, "utf-8");
-                expect(JSON.parse(content)).toEqual(config);
-            }
-            finally {
-                fs.rm(globalPath, { force: true });
-                const dir = join(globalPath, "..");
-                fs.rm(dir, { force: true, recursive: true });
-            }
-        });
-    });
-    describe("resetGlobalConfig", () => {
-        test("should reset global config to defaults", async () => {
-            const defaultConfig = { key: "default" };
-            const globalPath = getGlobalConfigPath("test-tool-reset", "config.json");
-            try {
-                await writeGlobalConfig({ key: "modified" }, "test-tool-reset", "config.json");
-                await resetGlobalConfig(defaultConfig, "test-tool-reset", "config.json");
-                const content = await fs.readFile(globalPath, "utf-8");
-                expect(JSON.parse(content)).toEqual(defaultConfig);
-            }
-            finally {
-                fs.rm(globalPath, { force: true });
-                const dir = join(globalPath, "..");
-                fs.rm(dir, { force: true, recursive: true });
-            }
-        });
-    });
-});

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

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