@elench/testkit 0.1.83 → 0.1.85

package/node_modules/@elench/ts-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "workspaces": [
@@ -66,7 +66,8 @@
   "files": [
     "bin/",
     "lib/",
-    "vendor/"
+    "vendor/",
+    "!lib/**/*.test.*"
   ],
   "bundleDependencies": [
     "@elench/next-analysis",
@@ -81,10 +82,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.83",
-    "@elench/testkit-bridge": "0.1.83",
-    "@elench/testkit-protocol": "0.1.83",
-    "@elench/ts-analysis": "0.1.83",
+    "@elench/next-analysis": "0.1.85",
+    "@elench/testkit-bridge": "0.1.85",
+    "@elench/testkit-protocol": "0.1.85",
+    "@elench/ts-analysis": "0.1.85",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",

package/lib/app/configs.test.mjs

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  collectRequiredConfigs,
-  filterConfigsByService,
-  resolveTargetConfig,
-  topologicallySortConfigs,
-} from "./configs.mjs";
-
-function makeConfig(name, dependsOn = [], provider = null) {
-  return {
-    name,
-    testkit: {
-      dependsOn,
-      database: provider ? { provider } : undefined,
-    },
-  };
-}
-
-describe("app config helpers", () => {
-  it("filters and resolves target configs", () => {
-    const configs = [makeConfig("api"), makeConfig("frontend", ["api"], "local")];
-
-    expect(filterConfigsByService(configs, "api")).toEqual([configs[0]]);
-    expect(resolveTargetConfig(configs)).toBe(configs[1]);
-    expect(() => filterConfigsByService(configs, "missing")).toThrow('Service "missing" not found');
-  });
-
-  it("collects dependencies and sorts them topologically", () => {
-    const configs = [makeConfig("frontend", ["api"]), makeConfig("api"), makeConfig("worker", ["api"])];
-
-    expect(collectRequiredConfigs(configs, "frontend").map((config) => config.name).sort()).toEqual(["api", "frontend"]);
-    expect(topologicallySortConfigs(configs).map((config) => config.name)).toEqual(["api", "frontend", "worker"]);
-  });
-});

package/lib/app/typecheck.test.mjs

@@ -1,24 +0,0 @@
-import path from "path";
-import { describe, expect, it } from "vitest";
-import { buildTypecheckCompilerOptions } from "./typecheck.mjs";
-
-describe("typecheck app helpers", () => {
-  it("preserves inherited service alias paths when generating next-service configs", () => {
-    const fixtureRoot = "/home/georgedlr/workspace/elench/bourne";
-    const extendsPath = path.join(fixtureRoot, "frontend", "tsconfig.json");
-    const generatedTsconfig = path.join(fixtureRoot, ".testkit", "_typecheck", "frontend.tsconfig.json");
-
-    const compilerOptions = buildTypecheckCompilerOptions({
-      tsconfigPath: generatedTsconfig,
-      extendsPath,
-    });
-
-    expect(compilerOptions.paths?.["@/*"]).toEqual(["../../frontend/src/*"]);
-    expect(compilerOptions.paths?.["@playwright-fixtures/*"]).toEqual([
-      "../../frontend/tests/playwright-fixtures/*",
-    ]);
-    expect(compilerOptions.paths?.["@elench/testkit/config"]?.[0]).toMatch(
-      /(?:\.\.\/)+(?:node_modules\/@elench\/testkit|testkit)\/lib\/config-api\/index\.d\.ts$/
-    );
-  });
-});

package/lib/bundler/index.test.mjs

@@ -1,164 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { pathToFileURL } from "url";
-import { afterEach, describe, expect, it } from "vitest";
-import { bundleK6File } from "./index.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-describe("runtime bundler", () => {
-  it("bundles root and runtime package imports for execution", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-bundle-"));
-    cleanups.push(() => fs.rmSync(tmpDir, { force: true, recursive: true }));
-
-    const sourceFile = path.join(tmpDir, "health.js");
-    fs.writeFileSync(
-      sourceFile,
-      [
-        'import { defineHttpSuite } from "@elench/testkit";',
-        'import { check, json } from "@elench/testkit/runtime";',
-        "const suite = defineHttpSuite(({ rawReq }) => {",
-        '  const res = rawReq("GET", "/health");',
-        "  check(json(res), {",
-        '    "has status": (body) => typeof body.status === "string",',
-        "  });",
-        "});",
-        "export default suite;",
-        "",
-      ].join("\n")
-    );
-
-    const bundledFile = await bundleK6File({
-      productDir: tmpDir,
-      serviceName: "api",
-      sourceFile,
-    });
-
-    const bundled = fs.readFileSync(bundledFile, "utf8");
-    expect(bundled).toContain("defineHttpSuite");
-    expect(bundled).toContain('import { check');
-    expect(bundled).toContain('from "k6"');
-  });
-
-  it("bundles DAL execution through the public package surface", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-bundle-"));
-    cleanups.push(() => fs.rmSync(tmpDir, { force: true, recursive: true }));
-
-    const sourceFile = path.join(tmpDir, "dal.js");
-    fs.writeFileSync(
-      sourceFile,
-      [
-        'import { defineDalSuite } from "@elench/testkit";',
-        "const suite = defineDalSuite(({ db }) => {",
-        '  db.query("SELECT 1");',
-        "});",
-        "export default suite;",
-        "",
-      ].join("\n")
-    );
-
-    const bundledFile = await bundleK6File({
-      productDir: tmpDir,
-      serviceName: "api",
-      sourceFile,
-    });
-
-    const bundled = fs.readFileSync(bundledFile, "utf8");
-    expect(bundled).toContain("defineDalSuite");
-    expect(bundled).toContain('import sql from "k6/x/sql"');
-  });
-
-  it("bundles scenario execution through the public package surface", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-bundle-"));
-    cleanups.push(() => fs.rmSync(tmpDir, { force: true, recursive: true }));
-
-    const sourceFile = path.join(tmpDir, "scenario.js");
-    fs.writeFileSync(
-      sourceFile,
-      [
-        'import { defineScenarioSuite } from "@elench/testkit";',
-        "const suite = defineScenarioSuite(({ scenario }) => {",
-        "  const plan = scenario.choose('journey', { endpoint: scenario.pick('endpoint', ['/a', '/b']) });",
-        "  scenario.step('record choice', () => plan.endpoint);",
-        "});",
-        "export default suite;",
-        "",
-      ].join("\n")
-    );
-
-    const bundledFile = await bundleK6File({
-      productDir: tmpDir,
-      serviceName: "api",
-      sourceFile,
-    });
-
-    const bundled = fs.readFileSync(bundledFile, "utf8");
-    expect(bundled).toContain("defineScenarioSuite");
-    expect(bundled).toContain("createScenarioRuntime");
-  });
-
-  it("normalizes a default-exported suite object with no setup override", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-bundle-"));
-    cleanups.push(() => fs.rmSync(tmpDir, { force: true, recursive: true }));
-
-    const sourceFile = path.join(tmpDir, "no-setup.js");
-    fs.writeFileSync(
-      sourceFile,
-      [
-        "const suite = {",
-        "  options: { vus: 1, iterations: 1 },",
-        "  exec() {",
-        "    return 'ok';",
-        "  },",
-        "};",
-        "export default suite;",
-        "",
-      ].join("\n")
-    );
-
-    const bundledFile = await bundleK6File({
-      productDir: tmpDir,
-      serviceName: "api",
-      sourceFile,
-    });
-
-    const bundled = await import(`${pathToFileURL(bundledFile).href}?v=${Date.now()}`);
-    expect(typeof bundled.setup).toBe("function");
-    expect(bundled.setup()).toBeNull();
-    expect(typeof bundled.default).toBe("function");
-    expect(bundled.default()).toBe("ok");
-  });
-
-  it("throws a clear error when the default export is not a suite object", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-bundle-"));
-    cleanups.push(() => fs.rmSync(tmpDir, { force: true, recursive: true }));
-
-    const sourceFile = path.join(tmpDir, "legacy-shape.js");
-    fs.writeFileSync(
-      sourceFile,
-      [
-        "export default function exec() {",
-        "  return 'legacy';",
-        "}",
-        "",
-      ].join("\n")
-    );
-
-    const bundledFile = await bundleK6File({
-      productDir: tmpDir,
-      serviceName: "api",
-      sourceFile,
-    });
-
-    await expect(
-      import(`${pathToFileURL(bundledFile).href}?v=${Date.now()}`)
-    ).rejects.toThrow(/default-export the suite object/);
-  });
-});

package/lib/cli/agents/investigation-context.test.mjs

@@ -1,144 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  formatInvestigationTranscriptContext,
-  loadInvestigationContext,
-} from "./investigation-context.mjs";
-import { buildInvestigationPrompt, defaultInvestigationMessage } from "./prompt-builder.mjs";
-
-const tempDirs = [];
-
-afterEach(() => {
-  while (tempDirs.length > 0) {
-    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
-  }
-});
-
-function makeTempProduct() {
-  const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-investigation-"));
-  tempDirs.push(productDir);
-  fs.mkdirSync(path.join(productDir, ".testkit", "results"), { recursive: true });
-  return productDir;
-}
-
-function writeJson(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
-}
-
-describe("investigation context", () => {
-  it("loads the selected failure, artifacts, logs, and formatted detail lines", () => {
-    const productDir = makeTempProduct();
-    writeJson(path.join(productDir, "artifacts", "failure.json"), {
-      source: "testkit-runtime-artifact",
-      data: { message: "artifact payload" },
-    });
-    fs.mkdirSync(path.join(productDir, "logs"), { recursive: true });
-    fs.writeFileSync(path.join(productDir, "logs", "api.log"), "first line\nsecond line\n");
-
-    writeJson(path.join(productDir, ".testkit", "results", "latest.json"), {
-      services: [
-        {
-          name: "api",
-          suites: [
-            {
-              name: "users",
-              type: "integration",
-              files: [
-                {
-                  path: "tests/api/users.int.testkit.ts",
-                  status: "failed",
-                  durationMs: 1000,
-                  error: "status 500",
-                  failureDetails: [
-                    {
-                      kind: "http-assertion",
-                      title: "status is 200",
-                      message: "GET /users expected 200, got 500",
-                      response: { status: 500, bodyPreview: "{\"error\":\"boom\"}" },
-                    },
-                  ],
-                  artifacts: [
-                    {
-                      name: "failure-artifact",
-                      kind: "example",
-                      summary: "captured payload",
-                      path: "artifacts/failure.json",
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      ],
-      logs: {
-        services: [
-          {
-            serviceName: "api",
-            runtimeLabel: "api",
-            path: "logs/api.log",
-          },
-        ],
-      },
-      setup: {
-        operations: [
-          {
-            serviceName: "api",
-            stage: "runtime:prepare",
-            status: "passed",
-            summary: "prepared runtime",
-            durationMs: 1200,
-            logRef: { path: "logs/api.log" },
-          },
-        ],
-      },
-    });
-
-    const context = loadInvestigationContext({
-      productDir,
-      serviceName: "api",
-      filePath: "tests/api/users.int.testkit.ts",
-    });
-
-    expect(context.summary).toMatchObject({
-      service: "api",
-      suite: "integration:users",
-      file: "tests/api/users.int.testkit.ts",
-      status: "failed",
-      error: "status 500",
-    });
-    expect(context.artifacts[0]).toMatchObject({
-      name: "failure-artifact",
-      kind: "example",
-      path: "artifacts/failure.json",
-    });
-    expect(context.backendLogs[0].lines).toContain("second line");
-    expect(context.detailLines.join("\n")).toContain("GET /users expected 200, got 500");
-    expect(formatInvestigationTranscriptContext(context)).toContain("Artifacts:");
-  });
-
-  it("builds the default investigation prompt with contextual evidence", () => {
-    const context = {
-      summary: {
-        service: "api",
-        suite: "integration:users",
-        file: "tests/api/users.int.testkit.ts",
-        status: "failed",
-        error: "status 500",
-      },
-      artifacts: [],
-      backendLogs: [],
-      detailLines: ["File: tests/api/users.int.testkit.ts", "Error: status 500"],
-    };
-
-    const prompt = buildInvestigationPrompt({ context });
-
-    expect(defaultInvestigationMessage()).toContain("Investigate");
-    expect(prompt).toContain("User request:");
-    expect(prompt).toContain("Service: api");
-    expect(prompt).toContain("Detailed Failure View:");
-  });
-});

package/lib/cli/agents/providers/claude.test.mjs

@@ -1,95 +0,0 @@
-import { PassThrough } from "stream";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const execaMock = vi.fn();
-
-vi.mock("execa", () => ({
-  execa: execaMock,
-}));
-
-function createChildHandle() {
-  const stdout = new PassThrough();
-  const stderr = new PassThrough();
-  let resolveChild;
-  const promise = new Promise((resolve) => {
-    resolveChild = resolve;
-  });
-  promise.stdout = stdout;
-  promise.stderr = stderr;
-  promise.kill = vi.fn(() => {
-    stdout.end();
-    stderr.end();
-  });
-  return {
-    child: promise,
-    finish(result = {}) {
-      stdout.end();
-      stderr.end();
-      resolveChild({
-        exitCode: 0,
-        stdout: "",
-        stderr: "",
-        ...result,
-      });
-    },
-  };
-}
-
-afterEach(() => {
-  execaMock.mockReset();
-});
-
-describe("Claude hosted session", () => {
-  it("normalizes streamed tool, delta, status, and final events", async () => {
-    const { startClaudeHostedSession } = await import("./claude.mjs");
-    const handle = createChildHandle();
-    execaMock.mockReturnValue(handle.child);
-    const events = [];
-
-    const session = startClaudeHostedSession({
-      cwd: "/tmp/project",
-      prompt: "Investigate this failure",
-      onEvent(event) {
-        events.push(event);
-      },
-    });
-
-    handle.child.stdout.write(`${JSON.stringify({ type: "tool_use", name: "Bash", detail: "rg failure" })}\n`);
-    handle.child.stdout.write(`${JSON.stringify({ type: "message_delta", delta: "Likely root cause." })}\n`);
-    handle.child.stderr.write("stderr note\n");
-    handle.finish({ exitCode: 0 });
-
-    const result = await session.completion;
-
-    expect(execaMock).toHaveBeenCalledWith(
-      "claude",
-      expect.arrayContaining(["-p", "--output-format", "stream-json", "--include-partial-messages"]),
-      expect.objectContaining({ cwd: "/tmp/project", reject: false })
-    );
-    expect(events[0]).toMatchObject({ provider: "claude", type: "start" });
-    expect(events).toContainEqual(expect.objectContaining({ provider: "claude", type: "tool", name: "Bash" }));
-    expect(events).toContainEqual(expect.objectContaining({ provider: "claude", type: "delta", text: "Likely root cause." }));
-    expect(events).toContainEqual(expect.objectContaining({ provider: "claude", type: "status", message: "stderr note" }));
-    expect(events.at(-2)).toMatchObject({ provider: "claude", type: "final", text: "Likely root cause." });
-    expect(events.at(-1)).toMatchObject({ provider: "claude", type: "exit", code: 0 });
-    expect(result.finalText).toBe("Likely root cause.");
-  });
-
-  it("cancels the child process", async () => {
-    const { startClaudeHostedSession } = await import("./claude.mjs");
-    const handle = createChildHandle();
-    execaMock.mockReturnValue(handle.child);
-
-    const session = startClaudeHostedSession({
-      cwd: "/tmp/project",
-      prompt: "Investigate this failure",
-    });
-
-    session.cancel();
-    handle.finish({ exitCode: 130 });
-    const result = await session.completion;
-
-    expect(handle.child.kill).toHaveBeenCalledWith("SIGTERM");
-    expect(result.cancelled).toBe(true);
-  });
-});

package/lib/cli/agents/providers/codex.test.mjs

@@ -1,93 +0,0 @@
-import { PassThrough } from "stream";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const execaMock = vi.fn();
-
-vi.mock("execa", () => ({
-  execa: execaMock,
-}));
-
-function createChildHandle() {
-  const stdout = new PassThrough();
-  const stderr = new PassThrough();
-  let resolveChild;
-  const promise = new Promise((resolve) => {
-    resolveChild = resolve;
-  });
-  promise.stdout = stdout;
-  promise.stderr = stderr;
-  promise.kill = vi.fn(() => {
-    stdout.end();
-    stderr.end();
-  });
-  return {
-    child: promise,
-    finish(result = {}) {
-      stdout.end();
-      stderr.end();
-      resolveChild({
-        exitCode: 0,
-        stdout: "",
-        stderr: "",
-        ...result,
-      });
-    },
-  };
-}
-
-afterEach(() => {
-  execaMock.mockReset();
-});
-
-describe("Codex hosted session", () => {
-  it("normalizes streamed tool, delta, and final output", async () => {
-    const { startCodexHostedSession } = await import("./codex.mjs");
-    const handle = createChildHandle();
-    execaMock.mockReturnValue(handle.child);
-    const events = [];
-
-    const session = startCodexHostedSession({
-      cwd: "/tmp/project",
-      prompt: "Investigate this failure",
-      onEvent(event) {
-        events.push(event);
-      },
-    });
-
-    handle.child.stdout.write(`${JSON.stringify({ type: "command", command: "rg", status: "done" })}\n`);
-    handle.child.stdout.write(`${JSON.stringify({ type: "assistant_delta", text: "Check the migration step." })}\n`);
-    handle.finish({ exitCode: 0, stdout: "Check the migration step." });
-
-    const result = await session.completion;
-
-    expect(execaMock).toHaveBeenCalledWith(
-      "codex",
-      expect.arrayContaining(["exec", "--json", "-s", "read-only", "-a", "never"]),
-      expect.objectContaining({ cwd: "/tmp/project", reject: false })
-    );
-    expect(events[0]).toMatchObject({ provider: "codex", type: "start" });
-    expect(events).toContainEqual(expect.objectContaining({ provider: "codex", type: "tool", name: "rg" }));
-    expect(events).toContainEqual(expect.objectContaining({ provider: "codex", type: "delta", text: "Check the migration step." }));
-    expect(events.at(-2)).toMatchObject({ provider: "codex", type: "final", text: "Check the migration step." });
-    expect(events.at(-1)).toMatchObject({ provider: "codex", type: "exit", code: 0 });
-    expect(result.finalText).toBe("Check the migration step.");
-  });
-
-  it("cancels the child process", async () => {
-    const { startCodexHostedSession } = await import("./codex.mjs");
-    const handle = createChildHandle();
-    execaMock.mockReturnValue(handle.child);
-
-    const session = startCodexHostedSession({
-      cwd: "/tmp/project",
-      prompt: "Investigate this failure",
-    });
-
-    session.cancel();
-    handle.finish({ exitCode: 130 });
-    const result = await session.completion;
-
-    expect(handle.child.kill).toHaveBeenCalledWith("SIGTERM");
-    expect(result.cancelled).toBe(true);
-  });
-});