@jmoak/vibrissa 0.1.0 → 2.0.0

package/dist/chunk-FTVETYUK.js

@@ -1,656 +0,0 @@
-// src/mcp-session.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
-var CLIENT_INFO = { name: "vibrissa", version: "0.1.0" };
-function inheritedEnv(overrides) {
-  const env = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (typeof value === "string") env[key] = value;
-  }
-  return { ...env, ...overrides };
-}
-function errorCodeName(code) {
-  const name = ErrorCode[code];
-  return typeof name === "string" ? name : void 0;
-}
-function textFromContent(content) {
-  if (!Array.isArray(content)) return "";
-  return content.filter((item) => {
-    return typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string";
-  }).map((item) => item.text).join("\n");
-}
-function stripMcpErrorPrefix(message) {
-  return message.replace(/^MCP error -?\d+:\s*/, "");
-}
-async function withTimeout(promise, timeoutMs, message) {
-  let handle;
-  const timeout = new Promise((_, reject) => {
-    handle = setTimeout(() => reject(new Error(message)), timeoutMs);
-  });
-  try {
-    return await Promise.race([promise, timeout]);
-  } finally {
-    if (handle) clearTimeout(handle);
-  }
-}
-var McpSession = class _McpSession {
-  constructor(client) {
-    this.client = client;
-  }
-  static async start(server, timeoutMs) {
-    const transport = new StdioClientTransport({
-      command: server.cmd,
-      args: server.args ?? [],
-      cwd: server.cwd ?? ".",
-      env: inheritedEnv(server.env ?? {}),
-      stderr: "inherit"
-    });
-    const client = new Client(CLIENT_INFO, { capabilities: {} });
-    try {
-      await withTimeout(client.connect(transport), timeoutMs, "Server spawn timeout");
-    } catch (err) {
-      await transport.close().catch(() => {
-      });
-      if (err instanceof McpError && err.code === ErrorCode.ConnectionClosed) {
-        throw new Error(`Server exited early before completing MCP initialization: ${err.message}`);
-      }
-      throw err;
-    }
-    return new _McpSession(client);
-  }
-  async callTool(name, args, timeoutMs) {
-    try {
-      const result = await this.client.callTool({ name, arguments: args }, void 0, {
-        timeout: timeoutMs
-      });
-      if (result.isError) {
-        return {
-          kind: "error",
-          error: { kind: "tool", message: textFromContent(result.content) }
-        };
-      }
-      return { kind: "result", result };
-    } catch (err) {
-      if (err instanceof McpError) {
-        return {
-          kind: "error",
-          error: {
-            kind: "protocol",
-            code: err.code,
-            codeName: errorCodeName(err.code),
-            message: stripMcpErrorPrefix(err.message)
-          }
-        };
-      }
-      throw err;
-    }
-  }
-  async listTools() {
-    const { tools } = await this.client.listTools();
-    return tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      inputSchema: tool.inputSchema
-    }));
-  }
-  async close() {
-    await this.client.close().catch(() => {
-    });
-  }
-};
-
-// src/defaults.ts
-var defaultRunCasesOptions = {
-  server: { cmd: "node", args: ["dist/index.js"], cwd: ".", env: {} },
-  globs: ["tests/integration/**/*.json"],
-  timeoutMs: 15e3,
-  failFast: false,
-  display: "pretty",
-  allowEmpty: false
-};
-
-// src/display.ts
-import { diffStringsUnified } from "jest-diff";
-var ConsoleResultsDisplay = class {
-  onStart(_total) {
-  }
-  onCasePass(_name) {
-  }
-  onCaseFail(name, error) {
-    console.error(`Case failed: ${name}${error ? ` - ${error}` : ""}`);
-  }
-  onComplete(_summary) {
-  }
-};
-var RESET = "\x1B[0m";
-var BOLD = "\x1B[1m";
-var FG_RED = "\x1B[31m";
-var FG_GREEN = "\x1B[32m";
-var FG_CYAN = "\x1B[36m";
-var FG_GRAY = "\x1B[90m";
-function color(text, code) {
-  return `${code}${text}${RESET}`;
-}
-function visibleLength(text) {
-  return text.replace(/\x1b\[[0-9;]*m/g, "").length;
-}
-function boxLine(content, width) {
-  const pad = Math.max(0, width - 2 - visibleLength(content));
-  return `|${content}${" ".repeat(pad)}|`;
-}
-function padCenter(text, width) {
-  if (text.length >= width) return text.slice(0, width);
-  const totalPad = width - text.length;
-  const left = Math.floor(totalPad / 2);
-  const right = totalPad - left;
-  return `${" ".repeat(left)}${text}${" ".repeat(right)}`;
-}
-function formatDuration(ms) {
-  if (ms < 1e3) return `${ms}ms`;
-  return `${(ms / 1e3).toFixed(2)}s`;
-}
-var PrettyConsoleResultsDisplay = class {
-  total = 0;
-  startedAt = 0;
-  passed = [];
-  failed = [];
-  cases = [];
-  onStart(total) {
-    this.total = total;
-    this.startedAt = Date.now();
-  }
-  onCasePass(name) {
-    this.passed.push(name);
-    this.cases.push({ name, status: "pass" });
-    const badge = color("[OK]", FG_GREEN);
-    const nameColored = color(name, FG_CYAN);
-    console.log(`${badge} ${nameColored}`);
-  }
-  onCaseFail(name, error) {
-    this.failed.push({ name, error });
-    this.cases.push({ name, status: "fail", error });
-    const badge = color("[!!]", FG_RED);
-    const nameColored = color(name, FG_CYAN);
-    console.log(`${badge} ${nameColored}`);
-  }
-  onComplete(summary) {
-    const width = 64;
-    const top = `+${"=".repeat(width - 2)}+`;
-    const mid = `+${"-".repeat(width - 2)}+`;
-    const title = boxLine(color(padCenter("vib-test results", width - 2), BOLD + FG_CYAN), width);
-    const totals = [
-      ` Total: ${color(String(summary.total), FG_CYAN)} `,
-      ` Passed: ${color(String(summary.passed), FG_GREEN)} `,
-      ` Failed: ${color(String(summary.failed), FG_RED)} `,
-      ` Duration: ${color(formatDuration(summary.durationMs), FG_GRAY)}`
-    ].join(" |");
-    console.log(top);
-    console.log(title);
-    console.log(mid);
-    console.log(boxLine(totals, width));
-    if (this.failed.length > 0) {
-      console.log(mid);
-      console.log(color(boxLine(` Failures (${this.failed.length}):`, width), FG_RED));
-      const maxList = 10;
-      for (let i = 0; i < Math.min(this.failed.length, maxList); i++) {
-        const f = this.failed[i];
-        const lineRaw = ` - ${f.name}`;
-        const maxContent = width - 3;
-        const trimmed = lineRaw.length > maxContent ? `${lineRaw.slice(0, maxContent - 3)}...` : lineRaw;
-        console.log(color(boxLine(` ${trimmed}`, width), FG_RED));
-        if (f.error?.includes("::")) {
-          const idx = f.error.indexOf("::");
-          try {
-            const json = f.error.slice(idx + 2).trim();
-            const parsed = JSON.parse(json);
-            const expectedStr = JSON.stringify(parsed.expected, null, 2);
-            const actualStr = JSON.stringify(parsed.actual, null, 2);
-            const unified = diffStringsUnified(expectedStr, actualStr, {
-              aAnnotation: "expected",
-              bAnnotation: "actual",
-              expand: false,
-              contextLines: 3
-            });
-            const diffLines = (unified ?? "").split(/\r?\n/);
-            for (const d of diffLines) console.log(`|${d}`);
-          } catch {
-          }
-        }
-      }
-      if (this.failed.length > maxList) {
-        console.log(color(boxLine(` ...and ${this.failed.length - maxList} more`, width), FG_RED));
-      }
-    }
-    console.log(top);
-  }
-};
-
-// src/match.ts
-var MAX_MISMATCHES = 25;
-function matchValue(expected, actual) {
-  const ctx = { partial: false, mismatches: [] };
-  matchNode(expected, actual, "", ctx);
-  return ctx.mismatches;
-}
-function matches(expected, actual) {
-  return matchValue(expected, actual).length === 0;
-}
-function report(ctx, mismatch) {
-  if (ctx.mismatches.length < MAX_MISMATCHES) ctx.mismatches.push(mismatch);
-}
-function displayPath(path3) {
-  return path3 === "" ? "(root)" : path3;
-}
-function describeType(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  return typeof value;
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function matchNode(expected, actual, path3, ctx) {
-  if (isPlainObject(expected)) {
-    if ("$regex" in expected) {
-      matchRegexDirective(expected, actual, path3, ctx);
-      return;
-    }
-    if ("$wildcard" in expected) {
-      matchWildcardDirective(expected, actual, path3, ctx);
-      return;
-    }
-    if (expected.$unordered === true && Array.isArray(expected.value)) {
-      matchUnordered(expected.value, actual, path3, ctx);
-      return;
-    }
-    matchObject(expected, actual, path3, ctx);
-    return;
-  }
-  if (Array.isArray(expected)) {
-    matchArray(expected, actual, path3, ctx);
-    return;
-  }
-  if (!Object.is(expected, actual)) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,
-      expected,
-      actual
-    });
-  }
-}
-function matchRegexDirective(directive, actual, path3, ctx) {
-  const pattern = directive.$regex;
-  const flags = directive.flags;
-  if (typeof pattern !== "string" || flags !== void 0 && typeof flags !== "string") {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `invalid $regex directive: ${JSON.stringify(directive)}`,
-      expected: directive,
-      actual
-    });
-    return;
-  }
-  if (typeof actual !== "string") {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected a string matching /${pattern}/${flags ?? ""}, got ${describeType(actual)}`,
-      expected: directive,
-      actual
-    });
-    return;
-  }
-  let regex;
-  try {
-    regex = new RegExp(pattern, flags);
-  } catch (err) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `invalid $regex pattern /${pattern}/${flags ?? ""}: ${err instanceof Error ? err.message : String(err)}`,
-      expected: directive,
-      actual
-    });
-    return;
-  }
-  if (!regex.test(actual)) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected string matching /${pattern}/${flags ?? ""}, got ${JSON.stringify(actual)}`,
-      expected: directive,
-      actual
-    });
-  }
-}
-function wildcardToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  const body = escaped.replace(/\*/g, "[\\s\\S]*").replace(/\?/g, "[\\s\\S]");
-  return new RegExp(`^${body}$`);
-}
-function matchWildcardDirective(directive, actual, path3, ctx) {
-  const pattern = directive.$wildcard;
-  if (typeof pattern !== "string") {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `invalid $wildcard directive: ${JSON.stringify(directive)}`,
-      expected: directive,
-      actual
-    });
-    return;
-  }
-  if (typeof actual !== "string") {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected a string matching wildcard "${pattern}", got ${describeType(actual)}`,
-      expected: directive,
-      actual
-    });
-    return;
-  }
-  if (!wildcardToRegex(pattern).test(actual)) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected string matching wildcard "${pattern}", got ${JSON.stringify(actual)}`,
-      expected: directive,
-      actual
-    });
-  }
-}
-function matchObject(expected, actual, path3, ctx) {
-  if (!isPlainObject(actual)) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected an object, got ${describeType(actual)}`,
-      expected,
-      actual
-    });
-    return;
-  }
-  const partial = ctx.partial || expected.$partial === true;
-  const expectedKeys = Object.keys(expected).filter((key) => key !== "$partial");
-  if (!partial) {
-    const actualKeys = Object.keys(actual);
-    const extra = actualKeys.filter((key) => !expectedKeys.includes(key));
-    if (extra.length > 0) {
-      report(ctx, {
-        path: displayPath(path3),
-        message: `unexpected key${extra.length > 1 ? "s" : ""} ${extra.map((k) => JSON.stringify(k)).join(", ")} (use "$partial": true to allow extra fields)`,
-        expected,
-        actual
-      });
-    }
-  }
-  for (const key of expectedKeys) {
-    const childPath = path3 === "" ? key : `${path3}.${key}`;
-    if (!(key in actual)) {
-      report(ctx, {
-        path: displayPath(childPath),
-        message: `missing expected key (expected ${JSON.stringify(expected[key])})`,
-        expected: expected[key],
-        actual: void 0
-      });
-      continue;
-    }
-    const childCtx = { partial, mismatches: ctx.mismatches };
-    matchNode(expected[key], actual[key], childPath, childCtx);
-  }
-}
-function matchArray(expected, actual, path3, ctx) {
-  if (!Array.isArray(actual)) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected an array, got ${describeType(actual)}`,
-      expected,
-      actual
-    });
-    return;
-  }
-  const lengthOk = ctx.partial ? actual.length >= expected.length : actual.length === expected.length;
-  if (!lengthOk) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected array of length ${ctx.partial ? `>= ${expected.length}` : expected.length}, got ${actual.length}`,
-      expected,
-      actual
-    });
-    return;
-  }
-  for (let i = 0; i < expected.length; i++) {
-    matchNode(expected[i], actual[i], `${path3}[${i}]`, ctx);
-  }
-}
-function matchesQuietly(expected, actual, partial) {
-  const scratch = { partial, mismatches: [] };
-  matchNode(expected, actual, "", scratch);
-  return scratch.mismatches.length === 0;
-}
-function matchUnordered(expected, actual, path3, ctx) {
-  if (!Array.isArray(actual)) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected an array (unordered), got ${describeType(actual)}`,
-      expected,
-      actual
-    });
-    return;
-  }
-  if (ctx.partial ? actual.length < expected.length : actual.length !== expected.length) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `expected unordered array of length ${ctx.partial ? `>= ${expected.length}` : expected.length}, got ${actual.length}`,
-      expected,
-      actual
-    });
-    return;
-  }
-  const used = new Array(actual.length).fill(false);
-  const assign = (index) => {
-    if (index === expected.length) return true;
-    for (let j = 0; j < actual.length; j++) {
-      if (used[j]) continue;
-      if (matchesQuietly(expected[index], actual[j], ctx.partial)) {
-        used[j] = true;
-        if (assign(index + 1)) return true;
-        used[j] = false;
-      }
-    }
-    return false;
-  };
-  if (!assign(0)) {
-    report(ctx, {
-      path: displayPath(path3),
-      message: `no arrangement of the actual array satisfies the expected elements (unordered${ctx.partial ? ", partial" : ""})`,
-      expected,
-      actual
-    });
-  }
-}
-
-// src/runner.ts
-import fs from "fs";
-import path2 from "path";
-import fg from "fast-glob";
-
-// src/paths.ts
-import path from "path";
-function resolveRootDir(options) {
-  return options.rootDir ? path.resolve(options.rootDir) : process.cwd();
-}
-function resolveServerConfig(options) {
-  const rootDir = resolveRootDir(options);
-  const cwd = options.server.cwd ?? ".";
-  return {
-    ...options.server,
-    cwd: path.isAbsolute(cwd) ? cwd : path.resolve(rootDir, cwd)
-  };
-}
-
-// src/runner.ts
-async function resolveCaseFiles(globs, cwd) {
-  const patterns = globs.map((g) => {
-    const isNegative = g.startsWith("!");
-    const body = isNegative ? g.slice(1) : g;
-    const resolved = (path2.isAbsolute(body) ? body : path2.join(cwd, body)).replace(/\\/g, "/");
-    return isNegative ? `!${resolved}` : resolved;
-  });
-  return await fg(patterns, { dot: false, onlyFiles: true, unique: true });
-}
-function summarizeMismatches(mismatches, label) {
-  const first = mismatches[0];
-  const suffix = mismatches.length > 1 ? ` (+${mismatches.length - 1} more)` : "";
-  return `${label} at ${first.path}: ${first.message}${suffix}`;
-}
-function matchExpectedError(expected, actual) {
-  const observed = {
-    code: actual.codeName ?? (actual.code !== void 0 ? String(actual.code) : void 0),
-    message: actual.message
-  };
-  if (expected.code !== void 0) {
-    const codeMatches = expected.code === actual.codeName || expected.code === String(actual.code ?? "");
-    if (!codeMatches) {
-      return {
-        ok: false,
-        error: `Error code mismatch: expected ${JSON.stringify(expected.code)}, got ${JSON.stringify(observed.code)}`,
-        expected,
-        actual: observed
-      };
-    }
-  }
-  if (expected.message !== void 0) {
-    const mismatches = matchValue(expected.message, actual.message);
-    if (mismatches.length > 0) {
-      return {
-        ok: false,
-        error: summarizeMismatches(mismatches, "Error message mismatch"),
-        expected,
-        actual: observed
-      };
-    }
-  }
-  return { ok: true };
-}
-async function executeCase(session, testCase, timeoutMs) {
-  if (!testCase.tool) {
-    return { ok: false, error: 'Case is missing required "tool" field' };
-  }
-  const outcome = await session.callTool(testCase.tool, testCase.args ?? {}, timeoutMs);
-  if (testCase.expectError !== void 0) {
-    if (outcome.kind === "result") {
-      return {
-        ok: false,
-        error: "Expected an error but tool call succeeded",
-        expected: testCase.expectError,
-        actual: outcome.result
-      };
-    }
-    return matchExpectedError(testCase.expectError, outcome.error);
-  }
-  if (outcome.kind === "error") {
-    const label = outcome.error.codeName ? ` [${outcome.error.codeName}]` : "";
-    return { ok: false, error: `Tool call failed${label}: ${outcome.error.message}` };
-  }
-  if (testCase.expect !== void 0) {
-    const mismatches = matchValue(testCase.expect, outcome.result);
-    if (mismatches.length > 0) {
-      return {
-        ok: false,
-        error: summarizeMismatches(mismatches, "Expectation failed"),
-        expected: testCase.expect,
-        actual: outcome.result
-      };
-    }
-  }
-  return { ok: true };
-}
-async function runWithTimeout(fn, timeoutMs) {
-  let timeoutHandle;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutHandle = setTimeout(() => reject(new Error("Case timeout exceeded")), timeoutMs);
-  });
-  try {
-    return await Promise.race([fn(), timeoutPromise]);
-  } finally {
-    if (timeoutHandle) clearTimeout(timeoutHandle);
-  }
-}
-var Runner = class {
-  options;
-  display;
-  constructor(options, display = new ConsoleResultsDisplay()) {
-    this.options = options;
-    this.display = display;
-  }
-  async run() {
-    const rootDir = resolveRootDir(this.options);
-    const files = await resolveCaseFiles(this.options.globs, rootDir);
-    if (files.length === 0) {
-      const pattern = this.options.globs.join(", ");
-      const message = `No test cases matched globs: ${pattern} (from ${rootDir})`;
-      if (this.options.allowEmpty) {
-        console.warn(message);
-        return 0;
-      }
-      console.error(message);
-      return 1;
-    }
-    this.display.onStart(files.length);
-    const spawnTimeoutMs = Math.max(2e3, Math.min(1e4, this.options.timeoutMs));
-    const server = resolveServerConfig(this.options);
-    const session = await McpSession.start(server, spawnTimeoutMs);
-    try {
-      let failures = 0;
-      const startedAt = Date.now();
-      let processed = 0;
-      for (const file of files) {
-        let data;
-        try {
-          data = JSON.parse(fs.readFileSync(file, "utf8"));
-        } catch (err) {
-          failures++;
-          const reason = err instanceof Error ? err.message : String(err);
-          this.display.onCaseFail(path2.basename(file), `Failed to load case file: ${reason}`);
-          processed++;
-          if (this.options.failFast) break;
-          continue;
-        }
-        const { ok, error, expected, actual } = await runWithTimeout(
-          () => executeCase(session, data, this.options.timeoutMs),
-          this.options.timeoutMs
-        );
-        if (!ok) {
-          failures++;
-          const caseName = data.name ?? path2.basename(file);
-          const details = expected !== void 0 ? ` :: ${JSON.stringify({ expected, actual })}` : "";
-          this.display.onCaseFail(caseName, `${error ?? "Error"}${details}`);
-          if (this.options.failFast) break;
-        } else {
-          const caseName = data.name ?? path2.basename(file);
-          this.display.onCasePass(caseName);
-        }
-        processed++;
-      }
-      this.display.onComplete({
-        total: processed,
-        passed: processed - failures,
-        failed: failures,
-        durationMs: Date.now() - startedAt
-      });
-      return failures === 0 ? 0 : 1;
-    } finally {
-      await session.close();
-    }
-  }
-};
-
-export {
-  McpSession,
-  defaultRunCasesOptions,
-  resolveRootDir,
-  resolveServerConfig,
-  ConsoleResultsDisplay,
-  PrettyConsoleResultsDisplay,
-  matchValue,
-  matches,
-  Runner
-};
-//# sourceMappingURL=chunk-FTVETYUK.js.map