@kirrosh/apitool 0.4.3

package/self-tests/auth.yaml

@@ -0,0 +1,18 @@
+name: Auth
+base_url: "http://localhost:8080"
+tests:
+  - name: Proxy login request and extract token
+    POST: /api/authorize
+    headers:
+      Content-Type: application/json
+      Accept: application/json
+    json:
+      base_url: "{{$randomString}}"
+      path: "{{$randomString}}"
+      username: "{{$randomString}}"
+      password: "{{$randomString}}"
+    expect:
+      status: 200
+      body:
+        token:
+          type: string

package/self-tests/collections-crud.yaml

@@ -0,0 +1,46 @@
+name: collections CRUD
+base_url: "http://localhost:8080"
+tests:
+  - name: Create collection
+    POST: /api/collections
+    headers:
+      Content-Type: application/json
+    json:
+      name: "{{$randomName}}"
+      test_path: "{{$randomString}}"
+      openapi_spec: "{{$randomString}}"
+    expect:
+      status: 201
+      body:
+        id:
+          capture: collection_id
+          type: number
+        name:
+          type: string
+        test_path:
+          type: string
+        openapi_spec:
+          type: string
+  - name: Get created collection
+    GET: /api/collections/{{collection_id}}
+    expect:
+      status: 200
+      body:
+        id:
+          equals: "{{collection_id}}"
+        name:
+          type: string
+        test_path:
+          type: string
+        openapi_spec:
+          type: string
+        created_at:
+          type: string
+  - name: Delete collection
+    DELETE: /api/collections/{{collection_id}}
+    expect:
+      status: 204
+  - name: Verify collection deleted
+    GET: /api/collections/{{collection_id}}
+    expect:
+      status: 404

package/self-tests/environments-crud.yaml

@@ -0,0 +1,48 @@
+name: environments CRUD
+base_url: "http://localhost:8080"
+tests:
+  - name: Create environment
+    POST: /api/environments
+    headers:
+      Content-Type: application/json
+    json:
+      name: "{{$randomName}}"
+    expect:
+      status: 201
+      body:
+        id:
+          capture: environment_id
+          type: number
+        name:
+          type: string
+        variables:
+          type: object
+  - name: Get created environment
+    GET: /api/environments/{{environment_id}}
+    expect:
+      status: 200
+      body:
+        id:
+          equals: "{{environment_id}}"
+        name:
+          type: string
+        variables:
+          type: object
+  - name: Update environment
+    PUT: /api/environments/{{environment_id}}
+    headers:
+      Content-Type: application/json
+    json:
+      variables:
+        key1: "{{$randomString}}"
+        key2: "{{$randomString}}"
+    expect:
+      status: 200
+  - name: Delete environment
+    DELETE: /api/environments/{{environment_id}}
+    expect:
+      status: 204
+  - name: Verify environment deleted
+    GET: /api/environments/{{environment_id}}
+    expect:
+      status: 404

package/self-tests/export.yaml

@@ -0,0 +1,32 @@
+name: Export
+base_url: "http://localhost:8080"
+tests:
+  - name: Export run results as JSON
+    GET: /api/export/{{$randomInt}}/json
+    headers:
+      Accept: application/json
+    expect:
+      status: 200
+      body:
+        suite_name:
+          type: string
+        started_at:
+          type: string
+        finished_at:
+          type: string
+        total:
+          type: number
+        passed:
+          type: number
+        failed:
+          type: number
+        skipped:
+          type: number
+        steps:
+          type: array
+  - name: Export run results as JUnit XML
+    GET: /api/export/{{$randomInt}}/junit
+    headers:
+      Accept: application/json
+    expect:
+      status: 200

package/self-tests/runs.yaml

@@ -0,0 +1,16 @@
+name: Runs
+base_url: "http://localhost:8080"
+tests:
+  - name: Run tests
+    POST: /api/run
+    headers:
+      Content-Type: application/json
+      Accept: application/json
+    json:
+      path: "{{$randomString}}"
+      env: "{{$randomString}}"
+    expect:
+      status: 200
+      body:
+        runId:
+          type: number

package/src/bun-types.d.ts

@@ -0,0 +1,5 @@
+declare module "*.css" {
+  const path: string;
+  export default path;
+}
+

package/src/cli/commands/add-api.ts

@@ -0,0 +1,51 @@
+import { setupApi } from "../../core/setup-api.ts";
+import { printError, printSuccess } from "../output.ts";
+
+export interface AddApiOptions {
+  name: string;
+  spec?: string;
+  dir?: string;
+  envPairs?: string[];
+  dbPath?: string;
+}
+
+export async function addApiCommand(options: AddApiOptions): Promise<number> {
+  const { name, spec, envPairs, dbPath, dir } = options;
+
+  // Parse --env key=value pairs into a record
+  const envVars: Record<string, string> = {};
+  if (envPairs) {
+    for (const pair of envPairs) {
+      const idx = pair.indexOf("=");
+      if (idx === -1) continue;
+      const key = pair.slice(0, idx).trim();
+      const value = pair.slice(idx + 1).trim();
+      if (key) envVars[key] = value;
+    }
+  }
+
+  try {
+    const result = await setupApi({
+      name,
+      spec,
+      dir,
+      envVars: Object.keys(envVars).length > 0 ? envVars : undefined,
+      dbPath,
+    });
+
+    printSuccess(`API '${name}' created (id=${result.collectionId})`);
+    console.log(`  Directory: ${result.testPath.replace(/\/tests$/, "")}`);
+    console.log(`  Tests:     ${result.testPath}/`);
+    if (spec) console.log(`  Spec:      ${spec}`);
+    if (result.baseUrl) console.log(`  Base URL:  ${result.baseUrl}`);
+    console.log();
+    console.log("Next steps:");
+    console.log(`  apitool ai-generate --api ${name} --prompt "test the user endpoints"`);
+    console.log(`  apitool run --api ${name}`);
+
+    return 0;
+  } catch (err) {
+    printError((err as Error).message);
+    return 1;
+  }
+}

package/src/cli/commands/ai-generate.ts

@@ -0,0 +1,106 @@
+import { resolve, dirname } from "path";
+import { generateWithAI } from "../../core/generator/ai/ai-generator.ts";
+import { resolveProviderConfig } from "../../core/generator/ai/types.ts";
+import type { AIProviderConfig } from "../../core/generator/ai/types.ts";
+import { printError, printSuccess } from "../output.ts";
+
+export interface AIGenerateCommandOptions {
+  from: string;
+  prompt: string;
+  provider: string;
+  model?: string;
+  apiKey?: string;
+  baseUrl?: string;
+  output?: string;
+}
+
+export async function aiGenerateCommand(options: AIGenerateCommandOptions): Promise<number> {
+  try {
+    const providerName = options.provider as AIProviderConfig["provider"];
+    if (!["ollama", "openai", "anthropic", "custom"].includes(providerName)) {
+      printError(`Unknown provider: ${options.provider}. Use: ollama, openai, anthropic, custom`);
+      return 2;
+    }
+
+    const provider = resolveProviderConfig({
+      provider: providerName,
+      model: options.model,
+      baseUrl: options.baseUrl,
+      apiKey: options.apiKey ?? process.env.APITOOL_AI_KEY,
+    });
+
+    console.log(`Provider: ${provider.provider} (${provider.model})`);
+    console.log(`Spec: ${options.from}`);
+    console.log(`Prompt: ${options.prompt}`);
+    console.log(`Generating...`);
+
+    const startTime = Date.now();
+    const result = await generateWithAI({
+      specPath: options.from,
+      prompt: options.prompt,
+      provider,
+    });
+    const durationMs = Date.now() - startTime;
+
+    console.log(`Done in ${(durationMs / 1000).toFixed(1)}s (model: ${result.model})`);
+    if (result.promptTokens) {
+      console.log(`Tokens: ${result.promptTokens} prompt + ${result.completionTokens} completion`);
+    }
+
+    // Write output
+    const outputDir = options.output ?? "./generated/ai/";
+    const { mkdir } = await import("node:fs/promises");
+    await mkdir(outputDir, { recursive: true });
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const fileName = `ai-generated-${timestamp}.yaml`;
+    const filePath = resolve(outputDir, fileName);
+
+    await Bun.write(filePath, result.yaml);
+    printSuccess(`Written: ${filePath}`);
+
+    // Auto-create collection if DB is available
+    try {
+      const { getDb } = await import("../../db/schema.ts");
+      getDb();
+      const { findCollectionByTestPath, findCollectionBySpec, createCollection, normalizePath, saveAIGeneration } = await import("../../db/queries.ts");
+      const { resolveSpecPath } = await import("../../core/generator/serializer.ts");
+      const normalizedOutput = normalizePath(outputDir);
+      const resolvedSpec = resolveSpecPath(options.from);
+
+      let collectionId: number | undefined;
+      const existing = findCollectionByTestPath(normalizedOutput) ?? findCollectionBySpec(resolvedSpec);
+      if (existing) {
+        collectionId = existing.id;
+      } else {
+        const specName = `AI Tests (${new Date().toLocaleDateString()})`;
+        collectionId = createCollection({
+          name: specName,
+          test_path: normalizedOutput,
+          openapi_spec: resolvedSpec,
+        });
+        printSuccess(`Created collection "${specName}" (id: ${collectionId})`);
+      }
+
+      saveAIGeneration({
+        collection_id: collectionId,
+        prompt: options.prompt,
+        model: result.model,
+        provider: providerName,
+        generated_yaml: result.yaml,
+        output_path: filePath,
+        status: "success",
+        prompt_tokens: result.promptTokens,
+        completion_tokens: result.completionTokens,
+        duration_ms: durationMs,
+      });
+    } catch {
+      // DB not critical
+    }
+
+    return 0;
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 2;
+  }
+}

package/src/cli/commands/chat.ts

@@ -0,0 +1,43 @@
+import { resolveProviderConfig, PROVIDER_DEFAULTS } from "../../core/generator/ai/types.ts";
+import type { AIProviderConfig } from "../../core/generator/ai/types.ts";
+import { printError } from "../output.ts";
+
+export interface ChatCommandOptions {
+  provider?: string;
+  model?: string;
+  apiKey?: string;
+  baseUrl?: string;
+  safe?: boolean;
+  dbPath?: string;
+}
+
+const VALID_PROVIDERS = new Set(["ollama", "openai", "anthropic", "custom"]);
+
+export async function chatCommand(options: ChatCommandOptions): Promise<number> {
+  const providerName = options.provider ?? "ollama";
+
+  if (!VALID_PROVIDERS.has(providerName)) {
+    printError(`Unknown provider: ${providerName}. Available: ollama, openai, anthropic, custom`);
+    return 2;
+  }
+
+  const providerConfig = resolveProviderConfig({
+    provider: providerName as AIProviderConfig["provider"],
+    model: options.model,
+    apiKey: options.apiKey ?? process.env["APITOOL_AI_KEY"],
+    baseUrl: options.baseUrl,
+  });
+
+  try {
+    const { startChatUI } = await import("../../tui/chat-ui.ts");
+    await startChatUI({
+      provider: providerConfig,
+      safeMode: options.safe,
+      dbPath: options.dbPath,
+    });
+    return 0;
+  } catch (err) {
+    printError(`Chat error: ${(err as Error).message}`);
+    return 2;
+  }
+}

package/src/cli/commands/ci-init.ts

@@ -0,0 +1,126 @@
+import { resolve, dirname } from "path";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { printSuccess, printError } from "../output.ts";
+
+export interface CiInitOptions {
+  platform?: "github" | "gitlab";
+  force: boolean;
+  dir?: string;
+}
+
+const GH_ACTIONS_TEMPLATE = `name: API Tests
+on:
+  push:
+    branches: [main]
+  pull_request:
+  schedule:
+    - cron: "0 */6 * * *"
+  workflow_dispatch:
+  repository_dispatch:
+    types: [api-updated]
+
+permissions:
+  contents: read
+  checks: write
+  pull-requests: write
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install apitool
+        run: curl -fsSL https://raw.githubusercontent.com/kirrosh/apitool/master/install.sh | sh
+
+      - name: Run tests
+        run: |
+          mkdir -p test-results
+          apitool run apis/ --report junit --no-db > test-results/junit.xml
+          # Add --env <name> to load .env.<name>.yaml from test directory
+        continue-on-error: true
+
+      - name: Publish test results
+        uses: EnricoMi/publish-unit-test-result-action@v2
+        if: always()
+        with:
+          files: test-results/junit.xml
+
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: test-results
+          path: test-results/junit.xml
+`;
+
+const GITLAB_CI_TEMPLATE = `# Trigger via API: curl -X POST --form ref=main --form token=TRIGGER_TOKEN $CI_API_V4_URL/projects/$CI_PROJECT_ID/trigger/pipeline
+
+api-tests:
+  image: ubuntu:latest
+  before_script:
+    - apt-get update -qq && apt-get install -y -qq curl
+    - curl -fsSL https://raw.githubusercontent.com/kirrosh/apitool/master/install.sh | sh
+  script:
+    - mkdir -p test-results
+    - apitool run apis/ --report junit --no-db > test-results/junit.xml
+    # Add --env <name> to load .env.<name>.yaml from test directory
+  allow_failure:
+    exit_codes: 1
+  artifacts:
+    when: always
+    reports:
+      junit: test-results/junit.xml
+`;
+
+function writeIfMissing(filePath: string, content: string, force: boolean): boolean {
+  if (!force && existsSync(filePath)) {
+    console.log(`  Skipped ${filePath} (already exists, use --force to overwrite)`);
+    return false;
+  }
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, content, "utf-8");
+  console.log(`  Created ${filePath}`);
+  return true;
+}
+
+function detectPlatform(cwd: string): "github" | "gitlab" | null {
+  if (existsSync(resolve(cwd, ".github"))) return "github";
+  if (existsSync(resolve(cwd, ".gitlab-ci.yml"))) return "gitlab";
+  return null;
+}
+
+export async function ciInitCommand(options: CiInitOptions): Promise<number> {
+  const cwd = options.dir ? resolve(options.dir) : process.cwd();
+  let platform = options.platform;
+
+  if (!platform) {
+    platform = detectPlatform(cwd);
+    if (!platform) {
+      platform = "github";
+      console.log("No CI platform detected, defaulting to GitHub Actions.\n");
+    } else {
+      console.log(`Detected ${platform === "github" ? "GitHub Actions" : "GitLab CI"}.\n`);
+    }
+  }
+
+  console.log(`Generating ${platform === "github" ? "GitHub Actions" : "GitLab CI"} workflow...\n`);
+
+  let created = false;
+
+  if (platform === "github") {
+    const targetPath = resolve(cwd, ".github/workflows/api-tests.yml");
+    created = writeIfMissing(targetPath, GH_ACTIONS_TEMPLATE, options.force);
+  } else {
+    const targetPath = resolve(cwd, ".gitlab-ci.yml");
+    created = writeIfMissing(targetPath, GITLAB_CI_TEMPLATE, options.force);
+  }
+
+  if (created) {
+    printSuccess("CI workflow created. Commit and push to activate.");
+  }
+
+  return 0;
+}

package/src/cli/commands/collections.ts

@@ -0,0 +1,41 @@
+import { getDb } from "../../db/schema.ts";
+import { listCollections } from "../../db/queries.ts";
+import { formatDuration } from "../../core/reporter/console.ts";
+
+export function collectionsCommand(dbPath?: string): number {
+  getDb(dbPath);
+  const collections = listCollections();
+
+  if (collections.length === 0) {
+    console.log("No collections found.");
+    console.log("Hint: use `apitool generate --from <spec>` to create a collection automatically.");
+    return 0;
+  }
+
+  // Print table header
+  const header = [
+    "ID".padEnd(5),
+    "Name".padEnd(30),
+    "Runs".padEnd(6),
+    "Pass Rate".padEnd(11),
+    "Last Run".padEnd(20),
+  ].join(" ");
+
+  console.log(header);
+  console.log("-".repeat(header.length));
+
+  for (const c of collections) {
+    const passRate = c.total_runs > 0 ? `${c.pass_rate}%` : "-";
+    const lastRun = c.last_run_at ?? "-";
+    const row = [
+      String(c.id).padEnd(5),
+      c.name.slice(0, 30).padEnd(30),
+      String(c.total_runs).padEnd(6),
+      passRate.padEnd(11),
+      lastRun.slice(0, 20).padEnd(20),
+    ].join(" ");
+    console.log(row);
+  }
+
+  return 0;
+}

package/src/cli/commands/coverage.ts

@@ -0,0 +1,65 @@
+import { readOpenApiSpec, extractEndpoints, scanCoveredEndpoints, filterUncoveredEndpoints } from "../../core/generator/index.ts";
+import { printError, printSuccess } from "../output.ts";
+
+export interface CoverageOptions {
+  spec: string;
+  tests: string;
+}
+
+const RESET = "\x1b[0m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+
+function useColor(): boolean {
+  return process.stdout.isTTY ?? false;
+}
+
+export async function coverageCommand(options: CoverageOptions): Promise<number> {
+  const { spec, tests } = options;
+
+  try {
+    const doc = await readOpenApiSpec(spec);
+    const allEndpoints = extractEndpoints(doc);
+
+    if (allEndpoints.length === 0) {
+      printError("No endpoints found in the OpenAPI spec");
+      return 1;
+    }
+
+    const covered = await scanCoveredEndpoints(tests);
+    const uncovered = filterUncoveredEndpoints(allEndpoints, covered);
+    const coveredCount = allEndpoints.length - uncovered.length;
+    const percentage = Math.round((coveredCount / allEndpoints.length) * 100);
+
+    const color = useColor();
+
+    // Summary
+    console.log(`Coverage: ${coveredCount}/${allEndpoints.length} endpoints (${percentage}%)`);
+    console.log("");
+
+    // Covered endpoints
+    if (coveredCount > 0) {
+      console.log(`${color ? GREEN : ""}Covered:${color ? RESET : ""}`);
+      for (const ep of allEndpoints) {
+        if (!uncovered.includes(ep)) {
+          console.log(`  ${color ? GREEN : ""}✓${color ? RESET : ""} ${ep.method.padEnd(7)} ${ep.path}`);
+        }
+      }
+      console.log("");
+    }
+
+    // Uncovered endpoints
+    if (uncovered.length > 0) {
+      console.log(`${color ? RED : ""}Uncovered:${color ? RESET : ""}`);
+      for (const ep of uncovered) {
+        console.log(`  ${color ? RED : ""}✗${color ? RESET : ""} ${ep.method.padEnd(7)} ${ep.path}`);
+      }
+    }
+
+    return uncovered.length > 0 ? 1 : 0;
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 2;
+  }
+}