ai-pipe 1.0.0

package/src/__tests__/completions.test.ts

@@ -0,0 +1,100 @@
+import { test, expect, describe } from "bun:test";
+import { generateCompletions } from "../completions.ts";
+import { SUPPORTED_PROVIDERS } from "../provider.ts";
+
+describe("generateCompletions", () => {
+  // ── bash ─────────────────────────────────────────────────────────
+
+  describe("bash", () => {
+    test("generates valid bash completions", () => {
+      const result = generateCompletions("bash");
+      expect(result).toContain("_ai_pipe_completions");
+      expect(result).toContain("complete -F _ai_pipe_completions ai-pipe");
+    });
+
+    test("includes all flags", () => {
+      const result = generateCompletions("bash");
+      expect(result).toContain("--model");
+      expect(result).toContain("--system");
+      expect(result).toContain("--json");
+      expect(result).toContain("--no-stream");
+      expect(result).toContain("--temperature");
+      expect(result).toContain("--max-output-tokens");
+      expect(result).toContain("--config");
+      expect(result).toContain("--providers");
+      expect(result).toContain("--completions");
+      expect(result).toContain("--version");
+      expect(result).toContain("--help");
+    });
+
+    test("includes all providers", () => {
+      const result = generateCompletions("bash");
+      for (const p of SUPPORTED_PROVIDERS) {
+        expect(result).toContain(p);
+      }
+    });
+
+    test("includes install instructions", () => {
+      const result = generateCompletions("bash");
+      expect(result).toContain('eval "$(ai-pipe --completions bash)"');
+    });
+  });
+
+  // ── zsh ──────────────────────────────────────────────────────────
+
+  describe("zsh", () => {
+    test("generates valid zsh completions", () => {
+      const result = generateCompletions("zsh");
+      expect(result).toContain("compdef _ai_pipe ai-pipe");
+      expect(result).toContain("_arguments");
+    });
+
+    test("includes provider suggestions with trailing slash", () => {
+      const result = generateCompletions("zsh");
+      for (const p of SUPPORTED_PROVIDERS) {
+        expect(result).toContain(`'${p}/'`);
+      }
+    });
+
+    test("includes install instructions", () => {
+      const result = generateCompletions("zsh");
+      expect(result).toContain('eval "$(ai-pipe --completions zsh)"');
+    });
+  });
+
+  // ── fish ─────────────────────────────────────────────────────────
+
+  describe("fish", () => {
+    test("generates valid fish completions", () => {
+      const result = generateCompletions("fish");
+      expect(result).toContain("complete -c ai-pipe");
+    });
+
+    test("includes all flags", () => {
+      const result = generateCompletions("fish");
+      expect(result).toContain("-l model");
+      expect(result).toContain("-l system");
+      expect(result).toContain("-l json");
+      expect(result).toContain("-l no-stream");
+      expect(result).toContain("-l temperature");
+      expect(result).toContain("-l max-output-tokens");
+      expect(result).toContain("-l config");
+      expect(result).toContain("-l providers");
+      expect(result).toContain("-l completions");
+      expect(result).toContain("-l version");
+      expect(result).toContain("-l help");
+    });
+
+    test("includes provider suggestions with trailing slash", () => {
+      const result = generateCompletions("fish");
+      for (const p of SUPPORTED_PROVIDERS) {
+        expect(result).toContain(`${p}/`);
+      }
+    });
+
+    test("includes install instructions", () => {
+      const result = generateCompletions("fish");
+      expect(result).toContain("~/.config/fish/completions/ai-pipe.fish");
+    });
+  });
+});

package/src/__tests__/config.test.ts

@@ -0,0 +1,280 @@
+import { test, expect, describe } from "bun:test";
+import { loadConfig, ConfigSchema } from "../config.ts";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdirSync } from "node:fs";
+
+const tmpDir = tmpdir();
+const uid = () => `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+
+function makeTmpDir(): string {
+  const dir = join(tmpDir, `ai-cfg-${uid()}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+describe("ConfigSchema", () => {
+  test("accepts empty object", () => {
+    expect(ConfigSchema.parse({})).toEqual({});
+  });
+
+  test("accepts full valid config", () => {
+    const result = ConfigSchema.parse({
+      model: "anthropic/claude-sonnet-4-5",
+      system: "Be concise.",
+      temperature: 0.7,
+      maxOutputTokens: 500,
+    });
+    expect(result.model).toBe("anthropic/claude-sonnet-4-5");
+    expect(result.system).toBe("Be concise.");
+    expect(result.temperature).toBe(0.7);
+    expect(result.maxOutputTokens).toBe(500);
+  });
+
+  test("accepts temperature at lower bound (0)", () => {
+    expect(ConfigSchema.parse({ temperature: 0 }).temperature).toBe(0);
+  });
+
+  test("accepts temperature at upper bound (2)", () => {
+    expect(ConfigSchema.parse({ temperature: 2 }).temperature).toBe(2);
+  });
+
+  test("accepts temperature at midpoint (1)", () => {
+    expect(ConfigSchema.parse({ temperature: 1 }).temperature).toBe(1);
+  });
+
+  test("rejects temperature below 0", () => {
+    expect(() => ConfigSchema.parse({ temperature: -0.1 })).toThrow();
+  });
+
+  test("rejects temperature above 2", () => {
+    expect(() => ConfigSchema.parse({ temperature: 2.1 })).toThrow();
+  });
+
+  test("rejects non-number temperature", () => {
+    expect(() => ConfigSchema.parse({ temperature: "hot" })).toThrow();
+  });
+
+  test("accepts maxOutputTokens = 1", () => {
+    expect(ConfigSchema.parse({ maxOutputTokens: 1 }).maxOutputTokens).toBe(1);
+  });
+
+  test("rejects maxOutputTokens = 0", () => {
+    expect(() => ConfigSchema.parse({ maxOutputTokens: 0 })).toThrow();
+  });
+
+  test("rejects negative maxOutputTokens", () => {
+    expect(() => ConfigSchema.parse({ maxOutputTokens: -100 })).toThrow();
+  });
+
+  test("rejects float maxOutputTokens", () => {
+    expect(() => ConfigSchema.parse({ maxOutputTokens: 99.5 })).toThrow();
+  });
+
+  test("rejects non-number maxOutputTokens", () => {
+    expect(() => ConfigSchema.parse({ maxOutputTokens: "many" })).toThrow();
+  });
+
+  test("rejects non-string model", () => {
+    expect(() => ConfigSchema.parse({ model: 123 })).toThrow();
+  });
+
+  test("rejects non-string system", () => {
+    expect(() => ConfigSchema.parse({ system: true })).toThrow();
+  });
+
+  test("strips unknown properties", () => {
+    const result = ConfigSchema.parse({ model: "openai/gpt-4o", unknown: true });
+    expect((result as Record<string, unknown>).unknown).toBeUndefined();
+  });
+
+  test("does not accept apiKeys (moved to separate file)", () => {
+    const result = ConfigSchema.parse({
+      model: "openai/gpt-4o",
+      apiKeys: { openai: "sk-test" },
+    });
+    expect((result as Record<string, unknown>).apiKeys).toBeUndefined();
+  });
+});
+
+describe("loadConfig", () => {
+  test("returns empty object when directory does not exist", async () => {
+    const config = await loadConfig("/nonexistent/path/config-dir");
+    expect(config).toEqual({});
+  });
+
+  test("returns empty object for empty directory", async () => {
+    const dir = makeTmpDir();
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("loads config.json only", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(
+      join(dir, "config.json"),
+      JSON.stringify({
+        model: "anthropic/claude-sonnet-4-5",
+        system: "Be concise.",
+        temperature: 0.7,
+        maxOutputTokens: 500,
+      })
+    );
+
+    const config = await loadConfig(dir);
+    expect(config.model).toBe("anthropic/claude-sonnet-4-5");
+    expect(config.system).toBe("Be concise.");
+    expect(config.temperature).toBe(0.7);
+    expect(config.maxOutputTokens).toBe(500);
+    expect(config.apiKeys).toBeUndefined();
+  });
+
+  test("loads apiKeys.json only", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(
+      join(dir, "apiKeys.json"),
+      JSON.stringify({ anthropic: "sk-ant-test", openai: "sk-test" })
+    );
+
+    const config = await loadConfig(dir);
+    expect(config.model).toBeUndefined();
+    expect(config.apiKeys).toEqual({ anthropic: "sk-ant-test", openai: "sk-test" });
+  });
+
+  test("loads both config.json and apiKeys.json", async () => {
+    const dir = makeTmpDir();
+    await Promise.all([
+      Bun.write(
+        join(dir, "config.json"),
+        JSON.stringify({ model: "anthropic/claude-sonnet-4-5" })
+      ),
+      Bun.write(
+        join(dir, "apiKeys.json"),
+        JSON.stringify({ anthropic: "sk-ant-test" })
+      ),
+    ]);
+
+    const config = await loadConfig(dir);
+    expect(config.model).toBe("anthropic/claude-sonnet-4-5");
+    expect(config.apiKeys).toEqual({ anthropic: "sk-ant-test" });
+  });
+
+  test("loads partial config.json (only model)", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(join(dir, "config.json"), JSON.stringify({ model: "google/gemini-2.5-flash" }));
+
+    const config = await loadConfig(dir);
+    expect(config.model).toBe("google/gemini-2.5-flash");
+    expect(config.system).toBeUndefined();
+    expect(config.temperature).toBeUndefined();
+    expect(config.maxOutputTokens).toBeUndefined();
+  });
+
+  test("loads empty JSON object config.json", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(join(dir, "config.json"), "{}");
+
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("ignores invalid JSON in config.json", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(join(dir, "config.json"), "not valid json {{{");
+
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("ignores invalid JSON in apiKeys.json", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(join(dir, "apiKeys.json"), "not valid json");
+
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("ignores zod-invalid config.json (temperature out of range)", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(join(dir, "config.json"), JSON.stringify({ temperature: 5 }));
+
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("ignores zod-invalid config.json (bad type)", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(join(dir, "config.json"), JSON.stringify({ model: 42 }));
+
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("ignores array JSON in config.json", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(join(dir, "config.json"), "[1, 2, 3]");
+
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("ignores apiKeys.json with unknown provider", async () => {
+    const dir = makeTmpDir();
+    await Bun.write(
+      join(dir, "apiKeys.json"),
+      JSON.stringify({ fakeprovider: "sk-test" })
+    );
+
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("valid apiKeys.json with all providers", async () => {
+    const dir = makeTmpDir();
+    const keys = {
+      openai: "sk-1",
+      anthropic: "sk-2",
+      google: "sk-3",
+      perplexity: "sk-4",
+      xai: "sk-5",
+      mistral: "sk-6",
+      groq: "sk-7",
+      deepseek: "sk-8",
+      cohere: "sk-9",
+      openrouter: "sk-10",
+    };
+    await Bun.write(join(dir, "apiKeys.json"), JSON.stringify(keys));
+
+    const config = await loadConfig(dir);
+    expect(config.apiKeys).toEqual(keys);
+  });
+
+  test("invalid config.json does not affect valid apiKeys.json", async () => {
+    const dir = makeTmpDir();
+    await Promise.all([
+      Bun.write(join(dir, "config.json"), "bad json"),
+      Bun.write(join(dir, "apiKeys.json"), JSON.stringify({ openai: "sk-test" })),
+    ]);
+
+    const config = await loadConfig(dir);
+    expect(config.model).toBeUndefined();
+    expect(config.apiKeys).toEqual({ openai: "sk-test" });
+  });
+
+  test("invalid apiKeys.json does not affect valid config.json", async () => {
+    const dir = makeTmpDir();
+    await Promise.all([
+      Bun.write(join(dir, "config.json"), JSON.stringify({ model: "openai/gpt-4o" })),
+      Bun.write(join(dir, "apiKeys.json"), "bad json"),
+    ]);
+
+    const config = await loadConfig(dir);
+    expect(config.model).toBe("openai/gpt-4o");
+    expect(config.apiKeys).toBeUndefined();
+  });
+
+  test("uses default directory when none specified", async () => {
+    const config = await loadConfig(undefined);
+    expect(config).toBeDefined();
+  });
+});

package/src/__tests__/constants.test.ts

@@ -0,0 +1,67 @@
+import { test, expect, describe } from "bun:test";
+import { APP, AppSchema, ShellSchema, type Shell, type AppConfig } from "../constants.ts";
+
+describe("APP", () => {
+  test("validates against AppSchema", () => {
+    expect(AppSchema.parse(APP)).toEqual(APP);
+  });
+
+  test("has expected name", () => {
+    expect(APP.name).toBe("ai-pipe");
+  });
+
+  test("has expected default model", () => {
+    expect(APP.defaultModel).toBe("openai/gpt-4o");
+  });
+
+  test("has expected default provider", () => {
+    expect(APP.defaultProvider).toBe("openai");
+  });
+
+  test("temperature has valid range", () => {
+    expect(APP.temperature.min).toBeLessThan(APP.temperature.max);
+    expect(APP.temperature.min).toBe(0);
+    expect(APP.temperature.max).toBe(2);
+  });
+
+  test("has config directory and file names", () => {
+    expect(APP.configDirName).toBe(".ai-pipe");
+    expect(APP.configFile).toBe("config.json");
+    expect(APP.apiKeysFile).toBe("apiKeys.json");
+  });
+
+  test("has supported shells", () => {
+    expect(APP.supportedShells).toContain("bash");
+    expect(APP.supportedShells).toContain("zsh");
+    expect(APP.supportedShells).toContain("fish");
+    expect(APP.supportedShells).toHaveLength(3);
+  });
+});
+
+describe("ShellSchema", () => {
+  for (const shell of APP.supportedShells) {
+    test(`accepts "${shell}"`, () => {
+      expect(ShellSchema.parse(shell)).toBe(shell);
+    });
+  }
+
+  test("rejects unknown shell", () => {
+    expect(ShellSchema.safeParse("powershell").success).toBe(false);
+  });
+
+  test("rejects empty string", () => {
+    expect(ShellSchema.safeParse("").success).toBe(false);
+  });
+});
+
+describe("AppSchema", () => {
+  test("rejects invalid config", () => {
+    const result = AppSchema.safeParse({ name: 123 });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects missing fields", () => {
+    const result = AppSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,241 @@
+import { test, expect, describe } from "bun:test";
+import { buildPrompt, resolveOptions, CLIOptionsSchema, JsonOutputSchema, type CLIOptions } from "../index.ts";
+import type { Config } from "../config.ts";
+
+// ── buildPrompt ────────────────────────────────────────────────────────
+
+describe("buildPrompt", () => {
+  test("returns arg prompt when only args provided", () => {
+    expect(buildPrompt("explain monads", null)).toBe("explain monads");
+  });
+
+  test("returns stdin when only stdin provided", () => {
+    expect(buildPrompt(null, "hello world")).toBe("hello world");
+  });
+
+  test("combines arg prompt and stdin with double newline", () => {
+    const result = buildPrompt("review this code", "const x = 1;");
+    expect(result).toBe("review this code\n\nconst x = 1;");
+  });
+
+  test("returns null when neither provided", () => {
+    expect(buildPrompt(null, null)).toBeNull();
+  });
+
+  test("arg prompt comes first in combined output", () => {
+    const result = buildPrompt("summarize", "long document text")!;
+    expect(result.startsWith("summarize")).toBe(true);
+    expect(result.endsWith("long document text")).toBe(true);
+  });
+
+  test("preserves multiline stdin content", () => {
+    const result = buildPrompt("review", "line1\nline2\nline3");
+    expect(result).toBe("review\n\nline1\nline2\nline3");
+  });
+
+  test("preserves multiline arg prompt", () => {
+    const result = buildPrompt("do this\nand that", null);
+    expect(result).toBe("do this\nand that");
+  });
+});
+
+// ── resolveOptions ─────────────────────────────────────────────────────
+
+describe("resolveOptions", () => {
+  const defaultOpts: CLIOptions = { json: false, stream: true };
+  const emptyConfig: Config = {};
+
+  test("uses built-in defaults when no flags or config", () => {
+    const result = resolveOptions(defaultOpts, emptyConfig);
+    expect(result.modelString).toBe("openai/gpt-4o");
+    expect(result.system).toBeUndefined();
+    expect(result.temperature).toBeUndefined();
+    expect(result.maxOutputTokens).toBeUndefined();
+  });
+
+  test("config overrides built-in defaults", () => {
+    const config: Config = {
+      model: "anthropic/claude-sonnet-4-5",
+      system: "Be concise.",
+      temperature: 0.5,
+      maxOutputTokens: 200,
+    };
+    const result = resolveOptions(defaultOpts, config);
+    expect(result.modelString).toBe("anthropic/claude-sonnet-4-5");
+    expect(result.system).toBe("Be concise.");
+    expect(result.temperature).toBe(0.5);
+    expect(result.maxOutputTokens).toBe(200);
+  });
+
+  test("CLI flags override config", () => {
+    const config: Config = {
+      model: "anthropic/claude-sonnet-4-5",
+      system: "config system",
+      temperature: 0.5,
+    };
+    const opts: CLIOptions = {
+      ...defaultOpts,
+      model: "google/gemini-2.5-flash",
+      system: "cli system",
+      temperature: 0.9,
+      maxOutputTokens: 1000,
+    };
+    const result = resolveOptions(opts, config);
+    expect(result.modelString).toBe("google/gemini-2.5-flash");
+    expect(result.system).toBe("cli system");
+    expect(result.temperature).toBe(0.9);
+    expect(result.maxOutputTokens).toBe(1000);
+  });
+
+  test("partial CLI flags merge with config", () => {
+    const config: Config = {
+      model: "anthropic/claude-sonnet-4-5",
+      system: "config system",
+      temperature: 0.5,
+    };
+    const opts: CLIOptions = { ...defaultOpts, temperature: 0.9 };
+    const result = resolveOptions(opts, config);
+    expect(result.modelString).toBe("anthropic/claude-sonnet-4-5");
+    expect(result.system).toBe("config system");
+    expect(result.temperature).toBe(0.9);
+  });
+
+  test("all undefined opts fall through to config", () => {
+    const config: Config = { model: "xai/grok-3", system: "sys", temperature: 1.5, maxOutputTokens: 300 };
+    const result = resolveOptions(defaultOpts, config);
+    expect(result.modelString).toBe("xai/grok-3");
+    expect(result.system).toBe("sys");
+    expect(result.temperature).toBe(1.5);
+    expect(result.maxOutputTokens).toBe(300);
+  });
+});
+
+// ── CLIOptionsSchema ───────────────────────────────────────────────────
+
+describe("CLIOptionsSchema", () => {
+  test("accepts minimal valid options", () => {
+    const result = CLIOptionsSchema.parse({ json: false, stream: true });
+    expect(result.json).toBe(false);
+    expect(result.stream).toBe(true);
+  });
+
+  test("accepts full valid options", () => {
+    const result = CLIOptionsSchema.parse({
+      model: "anthropic/claude-sonnet-4-5",
+      system: "be concise",
+      json: true,
+      stream: false,
+      temperature: 1.0,
+      maxOutputTokens: 500,
+      config: "/path/to/config.json",
+      providers: true,
+      completions: "bash",
+    });
+    expect(result.model).toBe("anthropic/claude-sonnet-4-5");
+    expect(result.maxOutputTokens).toBe(500);
+  });
+
+  test("rejects temperature below 0", () => {
+    expect(
+      CLIOptionsSchema.safeParse({ json: false, stream: true, temperature: -1 }).success
+    ).toBe(false);
+  });
+
+  test("rejects temperature above 2", () => {
+    expect(
+      CLIOptionsSchema.safeParse({ json: false, stream: true, temperature: 3 }).success
+    ).toBe(false);
+  });
+
+  test("rejects negative maxOutputTokens", () => {
+    expect(
+      CLIOptionsSchema.safeParse({ json: false, stream: true, maxOutputTokens: -5 }).success
+    ).toBe(false);
+  });
+
+  test("rejects float maxOutputTokens", () => {
+    expect(
+      CLIOptionsSchema.safeParse({ json: false, stream: true, maxOutputTokens: 10.5 }).success
+    ).toBe(false);
+  });
+
+  test("rejects non-boolean json", () => {
+    expect(
+      CLIOptionsSchema.safeParse({ json: "yes", stream: true }).success
+    ).toBe(false);
+  });
+});
+
+// ── JsonOutputSchema ───────────────────────────────────────────────────
+
+describe("JsonOutputSchema", () => {
+  test("accepts valid output", () => {
+    const result = JsonOutputSchema.parse({
+      text: "hello",
+      model: "openai/gpt-4o",
+      usage: { inputTokens: 5, outputTokens: 10, totalTokens: 15 },
+      finishReason: "stop",
+    });
+    expect(result.text).toBe("hello");
+    expect(result.finishReason).toBe("stop");
+  });
+
+  test("accepts output with optional token fields", () => {
+    const result = JsonOutputSchema.parse({
+      text: "",
+      model: "openai/gpt-4o",
+      usage: {},
+      finishReason: "length",
+    });
+    expect(result.usage.inputTokens).toBeUndefined();
+    expect(result.usage.inputTokenDetails).toBeUndefined();
+    expect(result.usage.outputTokenDetails).toBeUndefined();
+  });
+
+  test("accepts output with full token details", () => {
+    const result = JsonOutputSchema.parse({
+      text: "hi",
+      model: "openai/gpt-4o",
+      usage: {
+        inputTokens: 5,
+        outputTokens: 10,
+        totalTokens: 15,
+        inputTokenDetails: { noCacheTokens: 3, cacheReadTokens: 2, cacheWriteTokens: 0 },
+        outputTokenDetails: { textTokens: 8, reasoningTokens: 2 },
+      },
+      finishReason: "stop",
+    });
+    expect(result.usage.inputTokenDetails?.cacheReadTokens).toBe(2);
+    expect(result.usage.outputTokenDetails?.reasoningTokens).toBe(2);
+  });
+
+  test("rejects missing text", () => {
+    expect(
+      JsonOutputSchema.safeParse({
+        model: "openai/gpt-4o",
+        usage: {},
+        finishReason: "stop",
+      }).success
+    ).toBe(false);
+  });
+
+  test("rejects missing model", () => {
+    expect(
+      JsonOutputSchema.safeParse({
+        text: "hi",
+        usage: {},
+        finishReason: "stop",
+      }).success
+    ).toBe(false);
+  });
+
+  test("rejects missing finishReason", () => {
+    expect(
+      JsonOutputSchema.safeParse({
+        text: "hi",
+        model: "m",
+        usage: {},
+      }).success
+    ).toBe(false);
+  });
+});