@kirrosh/apitool 0.4.3

package/src/cli/commands/doctor.ts

@@ -0,0 +1,127 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { getDb, closeDb } from "../../db/schema.ts";
+
+export interface DoctorOptions {
+  dbPath?: string;
+}
+
+interface Check {
+  label: string;
+  ok: boolean;
+  detail: string;
+}
+
+export async function doctorCommand(options: DoctorOptions): Promise<number> {
+  const checks: Check[] = [];
+
+  // 1. Database
+  checks.push(checkDatabase(options.dbPath));
+
+  // 2. Test files
+  checks.push(checkTestFiles());
+
+  // 3. OpenAPI spec
+  checks.push(checkOpenApiSpec());
+
+  // 4. Environment files
+  checks.push(checkEnvFiles());
+
+  // 5. Ollama
+  checks.push(await checkOllama());
+
+  // Print results
+  console.log("\napitool doctor\n");
+
+  let hasFailure = false;
+  for (const check of checks) {
+    const icon = check.ok ? "\u2713" : "\u2717";
+    console.log(`  ${icon} ${check.label}: ${check.detail}`);
+    if (!check.ok) hasFailure = true;
+  }
+
+  console.log("");
+  if (hasFailure) {
+    console.log("Some checks failed. See details above.");
+  } else {
+    console.log("All checks passed.");
+  }
+
+  return hasFailure ? 1 : 0;
+}
+
+function checkDatabase(dbPath?: string): Check {
+  const path = dbPath ? resolve(dbPath) : resolve(process.cwd(), "apitool.db");
+  try {
+    const db = getDb(path);
+    const runs = (db.query("SELECT COUNT(*) as cnt FROM runs").get() as { cnt: number }).cnt;
+    const envs = (db.query("SELECT COUNT(*) as cnt FROM environments").get() as { cnt: number }).cnt;
+    closeDb();
+    return { label: "Database", ok: true, detail: `${path} (${runs} runs, ${envs} environments)` };
+  } catch (err) {
+    return { label: "Database", ok: false, detail: `Cannot open ${path}: ${(err as Error).message}` };
+  }
+}
+
+function checkTestFiles(): Check {
+  const dirs = [".", "tests", "test"];
+  const found: string[] = [];
+
+  for (const dir of dirs) {
+    const full = resolve(process.cwd(), dir);
+    if (!existsSync(full)) continue;
+    try {
+      const glob = new Bun.Glob("**/*.yaml");
+      for (const file of glob.scanSync({ cwd: full, absolute: false })) {
+        if (!file.startsWith(".env.")) {
+          found.push(`${dir}/${file}`);
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  if (found.length > 0) {
+    return { label: "Test files", ok: true, detail: `${found.length} YAML file(s) found` };
+  }
+  return { label: "Test files", ok: false, detail: "No YAML test files found in cwd or tests/" };
+}
+
+function checkOpenApiSpec(): Check {
+  const candidates = ["openapi.yaml", "openapi.json", "openapi.yml", "swagger.yaml", "swagger.json"];
+  for (const name of candidates) {
+    const full = resolve(process.cwd(), name);
+    if (existsSync(full)) {
+      return { label: "OpenAPI spec", ok: true, detail: name };
+    }
+  }
+  return { label: "OpenAPI spec", ok: false, detail: "No openapi.yaml/json found (optional)" };
+}
+
+function checkEnvFiles(): Check {
+  const found: string[] = [];
+  try {
+    const glob = new Bun.Glob(".env.*.yaml");
+    for (const file of glob.scanSync({ cwd: process.cwd(), absolute: false })) {
+      found.push(file);
+    }
+  } catch { /* ignore */ }
+
+  if (found.length > 0) {
+    return { label: "Environment files", ok: true, detail: found.join(", ") };
+  }
+  return { label: "Environment files", ok: false, detail: "No .env.*.yaml files found (optional)" };
+}
+
+async function checkOllama(): Promise<Check> {
+  try {
+    const res = await fetch("http://localhost:11434/api/tags", { signal: AbortSignal.timeout(3000) });
+    if (res.ok) {
+      const data = await res.json() as { models?: { name: string }[] };
+      const count = data.models?.length ?? 0;
+      return { label: "Ollama", ok: true, detail: `Running (${count} model(s) available)` };
+    }
+    return { label: "Ollama", ok: false, detail: `Responded with status ${res.status}` };
+  } catch {
+    return { label: "Ollama", ok: false, detail: "Not reachable at localhost:11434 (optional, needed for chat)" };
+  }
+}

package/src/cli/commands/envs.ts

@@ -0,0 +1,218 @@
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { getDb } from "../../db/schema.ts";
+import {
+  listEnvironmentRecords,
+  getEnvironment,
+  upsertEnvironment,
+  deleteEnvironment,
+  getEnvironmentById,
+  findCollectionByNameOrId,
+} from "../../db/queries.ts";
+import { printError, printSuccess } from "../output.ts";
+
+export interface EnvsOptions {
+  action: "list" | "get" | "set" | "delete" | "import" | "export";
+  name?: string;
+  pairs?: string[];
+  file?: string;
+  api?: string;
+  dbPath?: string;
+}
+
+export function parseKeyValuePairs(pairs: string[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const pair of pairs) {
+    const idx = pair.indexOf("=");
+    if (idx === -1) continue;
+    const key = pair.slice(0, idx).trim();
+    const value = pair.slice(idx + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+
+export function envsCommand(options: EnvsOptions): number {
+  const { action, name, pairs, dbPath } = options;
+
+  try {
+    getDb(dbPath);
+  } catch (err) {
+    printError(`Failed to open database: ${(err as Error).message}`);
+    return 2;
+  }
+
+  // Resolve --api to collection_id
+  let collectionId: number | undefined;
+  if (options.api) {
+    const col = findCollectionByNameOrId(options.api);
+    if (!col) {
+      printError(`API '${options.api}' not found`);
+      return 1;
+    }
+    collectionId = col.id;
+  }
+
+  switch (action) {
+    case "list": {
+      const envs = listEnvironmentRecords(collectionId);
+      if (envs.length === 0) {
+        console.log("No environments found.");
+        return 0;
+      }
+
+      // Print table
+      const nameWidth = Math.max(4, ...envs.map(e => e.name.length));
+      const scopeWidth = 8;
+      const header = `${"NAME".padEnd(nameWidth)}  ${"SCOPE".padEnd(scopeWidth)}  VARIABLES`;
+      console.log(header);
+      console.log("-".repeat(header.length + 10));
+      for (const env of envs) {
+        const scope = env.collection_id ? `api:${env.collection_id}` : "global";
+        const varKeys = Object.keys(env.variables).join(", ");
+        console.log(`${env.name.padEnd(nameWidth)}  ${scope.padEnd(scopeWidth)}  ${varKeys}`);
+      }
+      return 0;
+    }
+
+    case "get": {
+      if (!name) {
+        printError("Missing environment name. Usage: apitool envs get <name>");
+        return 2;
+      }
+      const variables = getEnvironment(name, collectionId);
+      if (!variables) {
+        printError(`Environment '${name}' not found`);
+        return 1;
+      }
+
+      const keyWidth = Math.max(3, ...Object.keys(variables).map(k => k.length));
+      for (const [k, v] of Object.entries(variables)) {
+        console.log(`${k.padEnd(keyWidth)}  ${v}`);
+      }
+      return 0;
+    }
+
+    case "set": {
+      if (!name) {
+        printError("Missing environment name. Usage: apitool envs set <name> KEY=VALUE ...");
+        return 2;
+      }
+      if (!pairs || pairs.length === 0) {
+        printError("Missing KEY=VALUE pairs. Usage: apitool envs set <name> KEY=VALUE ...");
+        return 2;
+      }
+      const variables = parseKeyValuePairs(pairs);
+      if (Object.keys(variables).length === 0) {
+        printError("No valid KEY=VALUE pairs provided");
+        return 2;
+      }
+
+      // Merge with existing (scoped if --api provided)
+      const existing = getEnvironment(name, collectionId) ?? {};
+      const merged = { ...existing, ...variables };
+      upsertEnvironment(name, merged, collectionId);
+      const scope = collectionId ? ` (scoped to api:${collectionId})` : "";
+      printSuccess(`Environment '${name}' updated${scope} (${Object.keys(variables).length} variable(s) set)`);
+      return 0;
+    }
+
+    case "delete": {
+      if (!name) {
+        printError("Missing environment name. Usage: apitool envs delete <name>");
+        return 2;
+      }
+      // Find by name (and scope) to get ID
+      const envs = listEnvironmentRecords(collectionId);
+      const env = collectionId
+        ? envs.find(e => e.name === name && e.collection_id === collectionId)
+        : envs.find(e => e.name === name && e.collection_id === null);
+      if (!env) {
+        printError(`Environment '${name}' not found`);
+        return 1;
+      }
+      deleteEnvironment(env.id);
+      printSuccess(`Environment '${name}' deleted`);
+      return 0;
+    }
+
+    case "import": {
+      if (!name) {
+        printError("Missing environment name. Usage: apitool envs import <name> <file>");
+        return 2;
+      }
+      const file = options.file;
+      if (!file) {
+        printError("Missing file path. Usage: apitool envs import <name> <file>");
+        return 2;
+      }
+      const filePath = resolve(file);
+      if (!existsSync(filePath)) {
+        printError(`File not found: ${filePath}`);
+        return 1;
+      }
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        const parsed = parseYamlEnv(content);
+        if (!parsed || Object.keys(parsed).length === 0) {
+          printError("No variables found in YAML file");
+          return 1;
+        }
+        upsertEnvironment(name, parsed, collectionId);
+        printSuccess(`Environment '${name}' imported (${Object.keys(parsed).length} variable(s))`);
+        return 0;
+      } catch (err) {
+        printError(`Failed to import: ${(err as Error).message}`);
+        return 1;
+      }
+    }
+
+    case "export": {
+      if (!name) {
+        printError("Missing environment name. Usage: apitool envs export <name>");
+        return 2;
+      }
+      const variables = getEnvironment(name, collectionId);
+      if (!variables) {
+        printError(`Environment '${name}' not found`);
+        return 1;
+      }
+      console.log(toYaml(variables));
+      return 0;
+    }
+
+    default:
+      printError(`Unknown action: ${action}`);
+      return 2;
+  }
+}
+
+/** Parse a simple YAML key:value file into a flat Record */
+export function parseYamlEnv(content: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const idx = trimmed.indexOf(":");
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    let value = trimmed.slice(idx + 1).trim();
+    // Strip surrounding quotes
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (key) result[key] = value;
+  }
+  return result;
+}
+
+/** Serialize a flat Record as simple YAML */
+export function toYaml(vars: Record<string, string>): string {
+  const lines: string[] = [];
+  for (const [k, v] of Object.entries(vars)) {
+    // Quote values that contain special chars
+    const needsQuote = /[:#\[\]{}&*!|>'"@`,%]/.test(v) || v.includes(" ") || v === "";
+    lines.push(`${k}: ${needsQuote ? `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : v}`);
+  }
+  return lines.join("\n");
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,84 @@
+import { resolve, dirname } from "path";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { printSuccess } from "../output.ts";
+
+export interface InitCommandOptions {
+  force: boolean;
+}
+
+const EXAMPLE_TEST = `name: Example Smoke Test
+base_url: "{{base_url}}"
+
+tests:
+  - name: "List posts"
+    GET: /posts
+    expect:
+      status: 200
+      body:
+        id: { type: integer }
+
+  - name: "Get single post"
+    GET: /posts/1
+    expect:
+      status: 200
+      body:
+        id: { equals: 1 }
+        title: { type: string }
+`;
+
+const ENV_DEV = `base_url: https://jsonplaceholder.typicode.com
+`;
+
+const MCP_CONFIG = `{
+  "mcpServers": {
+    "apitool": {
+      "command": "apitool",
+      "args": ["mcp"]
+    }
+  }
+}
+`;
+
+function writeIfMissing(filePath: string, content: string, force: boolean): boolean {
+  if (!force && existsSync(filePath)) {
+    console.log(`  Skipped ${filePath} (already exists)`);
+    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 isClaudeCodeAvailable(): boolean {
+  try {
+    const result = Bun.spawnSync(["claude", "--version"], {
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+export async function initCommand(options: InitCommandOptions): Promise<number> {
+  const cwd = process.cwd();
+
+  console.log("Initializing apitool project...\n");
+
+  writeIfMissing(resolve(cwd, "tests/example.yaml"), EXAMPLE_TEST, options.force);
+  writeIfMissing(resolve(cwd, ".env.dev.yaml"), ENV_DEV, options.force);
+
+  // Create .mcp.json if Claude Code is detected
+  if (isClaudeCodeAvailable()) {
+    writeIfMissing(resolve(cwd, ".mcp.json"), MCP_CONFIG, options.force);
+    printSuccess("Claude Code detected — .mcp.json created");
+  }
+
+  console.log("\nReady! Run: apitool run tests/");
+  return 0;
+}

package/src/cli/commands/mcp.ts

@@ -0,0 +1,16 @@
+import { startMcpServer } from "../../mcp/server.ts";
+import { resolve } from "node:path";
+
+export interface McpCommandOptions {
+  dbPath?: string;
+  dir?: string;
+}
+
+export async function mcpCommand(options: McpCommandOptions): Promise<number> {
+  if (options.dir) {
+    process.chdir(resolve(options.dir));
+  }
+  await startMcpServer({ dbPath: options.dbPath });
+  // Server runs until stdin closes — this promise never resolves during normal operation
+  return 0;
+}

package/src/cli/commands/run.ts

@@ -0,0 +1,137 @@
+import { dirname } from "path";
+import { parse } from "../../core/parser/yaml-parser.ts";
+import { loadEnvironment } from "../../core/parser/variables.ts";
+import { filterSuitesByTags } from "../../core/parser/filter.ts";
+import { runSuite } from "../../core/runner/executor.ts";
+import { getReporter } from "../../core/reporter/index.ts";
+import type { ReporterName } from "../../core/reporter/types.ts";
+import type { TestSuite } from "../../core/parser/types.ts";
+import type { TestRunResult } from "../../core/runner/types.ts";
+import { printError, printWarning } from "../output.ts";
+import { getDb } from "../../db/schema.ts";
+import { createRun, finalizeRun, saveResults, findCollectionByTestPath } from "../../db/queries.ts";
+
+export interface RunOptions {
+  path: string;
+  env?: string;
+  report: ReporterName;
+  timeout?: number;
+  bail: boolean;
+  noDb?: boolean;
+  dbPath?: string;
+  authToken?: string;
+  safe?: boolean;
+  tag?: string[];
+}
+
+export async function runCommand(options: RunOptions): Promise<number> {
+  // 1. Parse test files
+  let suites: TestSuite[];
+  try {
+    suites = await parse(options.path);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 2;
+  }
+
+  if (suites.length === 0) {
+    printWarning(`No test files found in ${options.path}`);
+    return 0;
+  }
+
+  // 1b. Tag filter
+  if (options.tag && options.tag.length > 0) {
+    suites = filterSuitesByTags(suites, options.tag);
+    if (suites.length === 0) {
+      printWarning("No suites match the specified tags");
+      return 0;
+    }
+  }
+
+  // 1c. Safe mode: filter to GET-only tests
+  if (options.safe) {
+    for (const suite of suites) {
+      suite.tests = suite.tests.filter(t => t.method === "GET");
+    }
+    suites = suites.filter(s => s.tests.length > 0);
+    if (suites.length === 0) {
+      printWarning("No GET tests found. Nothing to run in safe mode.");
+      return 0;
+    }
+  }
+
+  // 2. Load environment (resolve collection for scoped envs)
+  const searchDir = dirname(options.path);
+  let collectionForEnv: { id: number } | null = null;
+  try {
+    getDb(options.dbPath);
+    collectionForEnv = findCollectionByTestPath(options.path);
+  } catch { /* DB not available — OK */ }
+
+  let env: Record<string, string> = {};
+  try {
+    env = await loadEnvironment(options.env, searchDir, collectionForEnv?.id);
+  } catch (err) {
+    printError(`Failed to load environment: ${(err as Error).message}`);
+    return 2;
+  }
+
+  // Inject CLI auth token — overrides env file value
+  if (options.authToken) {
+    env.auth_token = options.authToken;
+  }
+
+  // Warn if --env was explicitly set but file was not found (empty env)
+  if (options.env && Object.keys(env).length === 0) {
+    printWarning(`Environment file .env.${options.env}.yaml not found in ${searchDir}`);
+  }
+
+  // 3. Apply timeout override
+  if (options.timeout !== undefined) {
+    for (const suite of suites) {
+      suite.config.timeout = options.timeout;
+    }
+  }
+
+  // 4. Run suites
+  const results: TestRunResult[] = [];
+  if (options.bail) {
+    // Sequential with bail at suite level
+    for (const suite of suites) {
+      const result = await runSuite(suite, env);
+      results.push(result);
+      if (result.failed > 0 || result.steps.some((s) => s.status === "error")) {
+        break;
+      }
+    }
+  } else {
+    // Parallel
+    const all = await Promise.all(suites.map((suite) => runSuite(suite, env)));
+    results.push(...all);
+  }
+
+  // 5. Report
+  const reporter = getReporter(options.report);
+  reporter.report(results);
+
+  // 6. Save to DB
+  if (!options.noDb) {
+    try {
+      getDb(options.dbPath);
+      const collection = findCollectionByTestPath(options.path);
+      const runId = createRun({
+        started_at: results[0]?.started_at ?? new Date().toISOString(),
+        environment: options.env,
+        collection_id: collection?.id,
+      });
+      finalizeRun(runId, results);
+      saveResults(runId, results);
+    } catch (err) {
+      printWarning(`Failed to save results to DB: ${(err as Error).message}`);
+    }
+  }
+
+  // 7. Exit code
+  const hasFailures = results.some((r) => r.failed > 0 || r.steps.some((s) => s.status === "error"));
+  return hasFailures ? 1 : 0;
+}

package/src/cli/commands/runs.ts

@@ -0,0 +1,108 @@
+import { getDb } from "../../db/schema.ts";
+import { listRuns, getRunById, getResultsByRunId } from "../../db/queries.ts";
+import { printError } from "../output.ts";
+
+export interface RunsOptions {
+  runId?: number;
+  limit?: number;
+  dbPath?: 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;
+}
+
+function statusIcon(passed: number, failed: number): string {
+  const color = useColor();
+  if (failed === 0) return color ? `${GREEN}PASS${RESET}` : "PASS";
+  return color ? `${RED}FAIL${RESET}` : "FAIL";
+}
+
+export function runsCommand(options: RunsOptions): number {
+  const { runId, limit = 20, dbPath } = options;
+
+  try {
+    getDb(dbPath);
+  } catch (err) {
+    printError(`Failed to open database: ${(err as Error).message}`);
+    return 2;
+  }
+
+  if (runId !== undefined) {
+    return showRunDetail(runId);
+  }
+  return showRunList(limit);
+}
+
+function showRunList(limit: number): number {
+  const runs = listRuns(limit);
+
+  if (runs.length === 0) {
+    console.log("No runs found.");
+    return 0;
+  }
+
+  // Print table
+  const header = "ID     STATUS  TOTAL  PASS  FAIL  ENV         DURATION  STARTED";
+  console.log(header);
+  console.log("-".repeat(header.length));
+
+  for (const run of runs) {
+    const status = statusIcon(run.passed, run.failed);
+    const env = (run.environment ?? "-").slice(0, 10).padEnd(10);
+    const duration = run.duration_ms != null ? `${run.duration_ms}ms` : "-";
+    const started = run.started_at.slice(0, 19).replace("T", " ");
+    console.log(
+      `${String(run.id).padEnd(6)} ${status.padEnd(useColor() ? 14 : 6)}  ${String(run.total).padEnd(5)}  ${String(run.passed).padEnd(4)}  ${String(run.failed).padEnd(4)}  ${env}  ${duration.padEnd(8)}  ${started}`,
+    );
+  }
+
+  return 0;
+}
+
+function showRunDetail(runId: number): number {
+  const run = getRunById(runId);
+  if (!run) {
+    printError(`Run #${runId} not found`);
+    return 1;
+  }
+
+  const color = useColor();
+
+  console.log(`Run #${run.id}`);
+  console.log(`  Started:     ${run.started_at}`);
+  if (run.finished_at) console.log(`  Finished:    ${run.finished_at}`);
+  if (run.environment) console.log(`  Environment: ${run.environment}`);
+  if (run.duration_ms != null) console.log(`  Duration:    ${run.duration_ms}ms`);
+  console.log(`  Total: ${run.total}  Passed: ${run.passed}  Failed: ${run.failed}  Skipped: ${run.skipped}`);
+
+  const results = getResultsByRunId(runId);
+  if (results.length === 0) {
+    console.log("\nNo step results recorded.");
+    return 0;
+  }
+
+  console.log("\nSteps:");
+  for (const r of results) {
+    let statusStr: string;
+    if (r.status === "pass") {
+      statusStr = color ? `${GREEN}PASS${RESET}` : "PASS";
+    } else if (r.status === "fail" || r.status === "error") {
+      statusStr = color ? `${RED}${r.status.toUpperCase()}${RESET}` : r.status.toUpperCase();
+    } else {
+      statusStr = color ? `${YELLOW}SKIP${RESET}` : "SKIP";
+    }
+
+    console.log(`  ${statusStr} ${r.test_name} (${r.duration_ms}ms)`);
+    if (r.error_message) {
+      console.log(`       ${color ? RED : ""}${r.error_message}${color ? RESET : ""}`);
+    }
+  }
+
+  return 0;
+}