codetrap 0.1.6 → 0.1.8

package/src/lib/embedding-management.ts

@@ -0,0 +1,65 @@
+import type { ConfigWriteResult, EmbeddingSettings } from "./config";
+import type { EmbeddingScopeStatus, TrapEmbeddingProfiles, TrapEmbeddingStatus } from "./store";
+import type { EmbeddingProfileSummary } from "../db/embedding-queries";
+
+export type EmbeddingsUseResult = ConfigWriteResult & {
+  embeddings: EmbeddingSettings;
+  next_action: {
+    command: string;
+    reason: string;
+  };
+};
+
+export function formatEmbeddingStatusText(status: TrapEmbeddingStatus): string {
+  const runtime = status.runtime.provider
+    ? `${status.runtime.provider}/${status.runtime.model} (${status.runtime.dimensions}d)`
+    : "unconfigured";
+  const lines = [
+    `Runtime: ${runtime}`,
+    `Available: ${status.runtime.available ? "yes" : "no"}`,
+    `Active profile: ${status.runtime.profile_id ?? "(none)"}`,
+  ];
+
+  if (status.runtime.setup_action) {
+    lines.push(`Next setup: ${status.runtime.setup_action.command}`);
+  }
+
+  lines.push(...scopeStatusLines("Project", status.project));
+  lines.push(...scopeStatusLines("Global", status.global));
+  return lines.join("\n");
+}
+
+export function formatEmbeddingProfilesText(profiles: TrapEmbeddingProfiles): string {
+  const lines = [
+    ...profileSectionLines("Project", profiles.project),
+    ...profileSectionLines("Global", profiles.global),
+  ];
+  return lines.length > 0 ? lines.join("\n") : "No stored embedding profiles.";
+}
+
+export function formatEmbeddingsUseText(result: EmbeddingsUseResult): string {
+  return [
+    `Configured embeddings provider: ${result.embeddings.provider}`,
+    `Config: ${result.path}`,
+    `Next: ${result.next_action.command}`,
+  ].join("\n");
+}
+
+function scopeStatusLines(label: string, status: EmbeddingScopeStatus | null): string[] {
+  if (!status) return [];
+  return [
+    "",
+    `${label}: total ${status.total}, fresh ${status.fresh}, stale ${status.stale}, missing ${status.missing}`,
+    ...profileSectionLines("Stored profiles", status.profiles),
+  ];
+}
+
+function profileSectionLines(label: string, profiles: EmbeddingProfileSummary[] | null): string[] {
+  if (!profiles || profiles.length === 0) return [];
+  return [
+    `${label}:`,
+    ...profiles.map((profile) =>
+      `  - ${profile.id} (${profile.embedding_count} embeddings, updated ${profile.updated_at ?? "unknown"})`
+    ),
+  ];
+}

package/src/lib/embedding-runtime.ts

@@ -0,0 +1,177 @@
+import {
+  DEFAULT_OLLAMA_DIMENSIONS,
+  DEFAULT_OLLAMA_ENDPOINT,
+  DEFAULT_OLLAMA_MODEL,
+  EmbeddingProviderUnavailableError,
+  JinaEmbedder,
+  OllamaEmbedder,
+  embeddingConfig,
+  embeddingProfileId,
+  type EmbeddingConfig,
+  type EmbeddingProvider,
+} from "./embedder";
+import { loadCodetrapConfig, type CodetrapConfig, type EmbeddingProviderSetting } from "./config";
+
+export type EmbeddingRuntimeInput = EmbeddingRuntime | EmbeddingProvider | undefined;
+
+export type EmbeddingRuntimeAction = {
+  command: string;
+  reason: string;
+};
+
+export type EmbeddingRuntimeStatus = {
+  available: boolean;
+  provider: string | null;
+  model: string | null;
+  dimensions: number | null;
+  passage_version: number | null;
+  profile_id: string | null;
+  setup_action: EmbeddingRuntimeAction | null;
+};
+
+export class EmbeddingRuntime {
+  constructor(
+    private readonly adapter?: EmbeddingProvider,
+    private readonly setupProvider: EmbeddingProviderSetting = "ollama",
+    private readonly configuredConfig: EmbeddingConfig | null = null
+  ) {}
+
+  static fromEnvironment(
+    env: NodeJS.ProcessEnv = process.env,
+    config: CodetrapConfig = loadCodetrapConfig()
+  ): EmbeddingRuntime {
+    const provider = configuredProvider(env, config);
+    if (provider === "ollama") {
+      return new EmbeddingRuntime(new OllamaEmbedder(ollamaOptions(env, config)), "ollama");
+    }
+    if (provider === "jina") {
+      const apiKey = env.JINA_API_KEY;
+      const configuredConfig = embeddingConfig(new JinaEmbedder(apiKey ?? ""));
+      return new EmbeddingRuntime(apiKey ? new JinaEmbedder(apiKey) : undefined, "jina", configuredConfig);
+    }
+
+    const apiKey = env.JINA_API_KEY;
+    if (apiKey) return new EmbeddingRuntime(new JinaEmbedder(apiKey), "jina");
+    return new EmbeddingRuntime(undefined, "ollama");
+  }
+
+  provider(): EmbeddingProvider | undefined {
+    return this.adapter;
+  }
+
+  available(): boolean {
+    return this.adapter !== undefined;
+  }
+
+  config(): EmbeddingConfig | null {
+    return this.adapter ? embeddingConfig(this.adapter) : this.configuredConfig;
+  }
+
+  requireProvider(message?: string): EmbeddingProvider {
+    if (!this.adapter) throw this.unavailableError(message);
+    return this.adapter;
+  }
+
+  unavailableError(message?: string): EmbeddingProviderUnavailableError {
+    return new EmbeddingProviderUnavailableError(
+      message ?? "Embedding provider is unavailable. Configure an embedding provider or use --mode fts."
+    );
+  }
+
+  setupAction(): EmbeddingRuntimeAction | null {
+    if (this.adapter) return null;
+    if (this.setupProvider === "jina") {
+      return {
+        command: "export JINA_API_KEY=<your-jina-api-key>",
+        reason: "Enable Jina semantic and hybrid search; otherwise use --mode fts.",
+      };
+    }
+    return {
+      command: "export CODETRAP_EMBEDDING_PROVIDER=ollama",
+      reason: "Enable local semantic and hybrid search after installing Ollama and pulling qwen3-embedding:0.6b; otherwise use --mode fts.",
+    };
+  }
+
+  status(): EmbeddingRuntimeStatus {
+    const config = this.config();
+    return {
+      available: this.available(),
+      provider: config?.provider ?? null,
+      model: config?.model ?? null,
+      dimensions: config?.dimensions ?? null,
+      passage_version: config?.passageVersion ?? null,
+      profile_id: config ? embeddingProfileId(config) : null,
+      setup_action: this.setupAction(),
+    };
+  }
+
+  async health(): Promise<EmbeddingRuntimeStatus> {
+    const status = this.status();
+    if (!this.adapter || !(this.adapter instanceof OllamaEmbedder)) return status;
+
+    const health = await this.adapter.health();
+    if (health.ok) return status;
+    return {
+      ...status,
+      available: false,
+      setup_action: {
+        command: health.command ?? `ollama pull ${this.adapter.model}`,
+        reason: health.message ?? "Ollama embedding provider is unavailable.",
+      },
+    };
+  }
+}
+
+export function defaultEmbeddingRuntime(
+  env: NodeJS.ProcessEnv = process.env,
+  config?: CodetrapConfig
+): EmbeddingRuntime {
+  return EmbeddingRuntime.fromEnvironment(env, config);
+}
+
+export function embeddingRuntimeFrom(input: EmbeddingRuntimeInput): EmbeddingRuntime {
+  return input instanceof EmbeddingRuntime ? input : new EmbeddingRuntime(input);
+}
+
+function configuredProvider(
+  env: NodeJS.ProcessEnv,
+  config: CodetrapConfig
+): EmbeddingProviderSetting | undefined {
+  if (config.embeddings?.provider) return config.embeddings.provider;
+  if (env.CODETRAP_EMBEDDING_PROVIDER) return parseProviderEnv(env.CODETRAP_EMBEDDING_PROVIDER);
+  if (config.embeddings?.endpoint || config.embeddings?.model || config.embeddings?.dimensions) return "ollama";
+  if (env.CODETRAP_OLLAMA_ENDPOINT || env.CODETRAP_OLLAMA_MODEL || env.CODETRAP_OLLAMA_DIMENSIONS) {
+    return "ollama";
+  }
+  return undefined;
+}
+
+function ollamaOptions(env: NodeJS.ProcessEnv, config: CodetrapConfig) {
+  return {
+    endpoint: normalizeEndpointSetting(
+      config.embeddings?.endpoint ?? env.CODETRAP_OLLAMA_ENDPOINT ?? env.OLLAMA_HOST ?? DEFAULT_OLLAMA_ENDPOINT
+    ),
+    model: config.embeddings?.model ?? env.CODETRAP_OLLAMA_MODEL ?? DEFAULT_OLLAMA_MODEL,
+    dimensions:
+      config.embeddings?.dimensions ??
+      parseOptionalPositiveInt(env.CODETRAP_OLLAMA_DIMENSIONS, "CODETRAP_OLLAMA_DIMENSIONS") ??
+      DEFAULT_OLLAMA_DIMENSIONS,
+  };
+}
+
+function parseProviderEnv(value: string): EmbeddingProviderSetting {
+  if (value === "ollama" || value === "jina") return value;
+  throw new Error(`Invalid CODETRAP_EMBEDDING_PROVIDER: ${value}. Expected ollama or jina.`);
+}
+
+function parseOptionalPositiveInt(value: string | undefined, label: string): number | undefined {
+  if (!value) return undefined;
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isInteger(parsed) && parsed > 0) return parsed;
+  throw new Error(`Invalid ${label}: expected a positive integer.`);
+}
+
+function normalizeEndpointSetting(endpoint: string): string {
+  if (/^https?:\/\//.test(endpoint)) return endpoint;
+  return `http://${endpoint}`;
+}

package/src/lib/output-json.ts

@@ -137,5 +137,3 @@ export function toStatsJson(stats: TrapStatsResult, embeddings?: EmbeddingStatsR
 export function toDoctorJson(input: DoctorReport): DoctorReport {
   return input;
 }
-
-export { toTrapEvidenceJson, toTrapJson, type JsonTrap, type JsonTrapEvidence };

package/src/lib/scope-context.ts

@@ -2,9 +2,10 @@ import { openGlobal, openProject } from "../db/connection";
 import { TrapRepository } from "../db/repository";
 import { CODETRAP_DIR, TRAPS_DB_FILE } from "./constants";
 import type { Scope } from "./constants";
-import type { EmbeddingProvider } from "./embedder";
-import { findProjectRoot, getGlobalDB, resolveScopePath } from "./scope";
-import { ScopePathResolver } from "./scope-path";
+import type { EmbeddingRuntime } from "./embedding-runtime";
+import type { RankingConfig } from "./search-policy";
+import { findProjectRoot, getGlobalDB } from "./scope";
+import { resolveScopePath, ScopePathResolver } from "./scope-path";
 
 const scopePath = new ScopePathResolver();
 
@@ -15,14 +16,14 @@ export type ScopeContext = {
   global_db: string;
 };
 
-export function createScopeContext(cwd = process.cwd()): ScopeContext {
-  const resolvedCwd = resolveScopePath(cwd);
-  const projectRoot = findProjectRoot(resolvedCwd);
+export function createScopeContext(cwd = process.cwd(), home?: string): ScopeContext {
+  const resolvedCwd = resolveScopePath(cwd, home ?? cwd);
+  const projectRoot = findProjectRoot(resolvedCwd, home);
   return {
     cwd: resolvedCwd,
     project_root: projectRoot,
     project_db: projectRoot ? scopePath.join(projectRoot, CODETRAP_DIR, TRAPS_DB_FILE) : null,
-    global_db: getGlobalDB(),
+    global_db: getGlobalDB(home),
   };
 }
 
@@ -36,8 +37,13 @@ export class ScopedRepositoryContext {
   private globalRepository?: TrapRepository;
   private projectRepository?: TrapRepository;
 
-  constructor(cwd = process.cwd(), private readonly embedder?: EmbeddingProvider) {
-    this.context = createScopeContext(cwd);
+  constructor(
+    cwd = process.cwd(),
+    private readonly embeddings?: EmbeddingRuntime,
+    private readonly home?: string,
+    private readonly ranking?: RankingConfig
+  ) {
+    this.context = createScopeContext(cwd, home);
   }
 
   hasProject(): boolean {
@@ -87,14 +93,14 @@ export class ScopedRepositoryContext {
       throw new Error("Not in a project. Run 'codetrap init' first, or use --scope global.");
     }
     if (!this.projectRepository) {
-      this.projectRepository = new TrapRepository(openProject(projectRoot), this.embedder);
+      this.projectRepository = new TrapRepository(openProject(projectRoot), this.embeddings, this.ranking);
     }
     return this.projectRepository;
   }
 
   private globalRepo(): TrapRepository {
     if (!this.globalRepository) {
-      this.globalRepository = new TrapRepository(openGlobal(), this.embedder);
+      this.globalRepository = new TrapRepository(openGlobal(this.home), this.embeddings, this.ranking);
     }
     return this.globalRepository;
   }

package/src/lib/scope-migration.ts

@@ -3,7 +3,8 @@ import { homedir } from "node:os";
 import { openDatabase } from "../db/connection";
 import { TrapRepository } from "../db/repository";
 import type { TrapExportRecord } from "../domain/trap";
-import { findProjectRoot, resolveScopePath } from "./scope";
+import { findProjectRoot } from "./scope";
+import { resolveScopePath } from "./scope-path";
 import {
   backupScopeDatabase,
   buildScopeMaintenancePaths,

package/src/lib/scope.ts

@@ -3,16 +3,14 @@ import { homedir } from "node:os";
 import { CODETRAP_DIR, TRAPS_DB_FILE } from "./constants";
 import { defaultScopePathResolver, resolveScopePath, ScopePathResolver } from "./scope-path";
 
-export { resolveScopePath, ScopePathResolver } from "./scope-path";
-
-export function getGlobalDir(): string {
-  const dir = defaultScopePathResolver.join(homedir(), CODETRAP_DIR);
+export function getGlobalDir(homeDir = homedir()): string {
+  const dir = defaultScopePathResolver.join(homeDir, CODETRAP_DIR);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   return dir;
 }
 
-export function getGlobalDB(): string {
-  return defaultScopePathResolver.join(getGlobalDir(), TRAPS_DB_FILE);
+export function getGlobalDB(homeDir = homedir()): string {
+  return defaultScopePathResolver.join(getGlobalDir(homeDir), TRAPS_DB_FILE);
 }
 
 export function findProjectRoot(

package/src/lib/search-eval.ts

@@ -3,13 +3,19 @@ import { openDatabase } from "../db/connection";
 import { TrapRepository } from "../db/repository";
 import type { TrapInput, TrapSearchResult } from "../domain/trap";
 import { SEARCH_MODES, type SearchMode } from "./constants";
+import { isRecord } from "./value-types";
 import {
-  createDefaultEmbeddingProvider,
-  embeddingConfig,
   type EmbeddingConfig,
   type EmbeddingProvider,
   type EmbeddingTask,
 } from "./embedder";
+import {
+  EmbeddingRuntime,
+  defaultEmbeddingRuntime,
+  embeddingRuntimeFrom,
+  type EmbeddingRuntimeInput,
+} from "./embedding-runtime";
+import type { RankingConfig } from "./search-policy";
 
 export type PhaseGate = "phase0" | "phase1" | "phase4" | "dogfood";
 export const DOGFOOD_JUDGMENTS = ["useful_hit", "miss", "noisy_hit", "no_relevant_trap"] as const;
@@ -56,6 +62,11 @@ export type SearchEvalMetrics = {
   semantic_error_count: number;
 };
 
+export type SearchEvalNextAction = {
+  command: string;
+  reason: string;
+};
+
 export type SearchEvalReport = {
   mode: "deterministic" | "live";
   fixture: string;
@@ -71,6 +82,11 @@ export type SearchEvalReport = {
   failures: EvalCaseReport[];
   misses: EvalCaseReport[];
   noisy_hits: EvalCaseReport[];
+  next_actions: SearchEvalNextAction[];
+};
+
+export type SearchEvalDetailedReport = Omit<SearchEvalReport, "mode" | "fixture" | "next_actions"> & {
+  cases: EvalCaseReport[];
 };
 
 export type RecordDogfoodResult = {
@@ -109,30 +125,46 @@ export function recordDogfoodCase(fixturePath: string, jsonInput: string | undef
 
 export async function reportDogfood(fixturePath: string, live: boolean): Promise<SearchEvalReport> {
   const fixture = readEvalFixture(fixturePath);
-  const provider = live ? createDefaultEmbeddingProvider() : new EvalEmbedder();
-  const evaluated = await evaluateSearchFixture(fixture, provider);
-  return {
-    mode: live ? "live" : "deterministic",
+  const runtime = live ? defaultEmbeddingRuntime() : new EmbeddingRuntime(new EvalEmbedder());
+  const evaluated = await evaluateSearchFixture(fixture, runtime);
+  const mode: SearchEvalReport["mode"] = live ? "live" : "deterministic";
+  const report: Omit<SearchEvalReport, "next_actions"> = {
+    mode,
     fixture: fixturePath,
     ...evaluated,
   };
+  return {
+    ...report,
+    next_actions: buildSearchEvalNextActions(report),
+  };
 }
 
 export async function evaluateSearchFixture(
   fixture: EvalFixture,
-  provider: EmbeddingProvider | undefined
-): Promise<Omit<SearchEvalReport, "mode" | "fixture">> {
-  const repo = fixtureRepository(fixture, provider);
+  embeddings: EmbeddingRuntimeInput,
+  ranking?: RankingConfig
+): Promise<Omit<SearchEvalReport, "mode" | "fixture" | "next_actions">> {
+  const { cases: _cases, ...report } = await evaluateSearchFixtureCases(fixture, embeddings, ranking);
+  return report;
+}
+
+export async function evaluateSearchFixtureCases(
+  fixture: EvalFixture,
+  embeddings: EmbeddingRuntimeInput,
+  ranking?: RankingConfig
+): Promise<SearchEvalDetailedReport> {
+  const runtime = embeddingRuntimeFrom(embeddings);
+  const repo = fixtureRepository(fixture, runtime, ranking);
 
   let providerError: string | null = null;
-  if (provider) {
+  if (runtime.available()) {
     try {
       await repo.ensureEmbeddings();
     } catch (error) {
       providerError = errorMessage(error);
     }
   }
-  const searchRepo = providerError ? fixtureRepository(fixture, undefined) : repo;
+  const searchRepo = providerError ? fixtureRepository(fixture, undefined, ranking) : repo;
 
   const cases: EvalCaseReport[] = [];
   let hybridFallbackCount = 0;
@@ -143,7 +175,7 @@ export async function evaluateSearchFixture(
       const results = await searchRepo.search(item.query, { mode: item.mode, limit: 5 });
       const report = caseReport(item, fixture, results);
       cases.push(report);
-      if (item.mode === "hybrid" && (!provider || hasSemanticFallback(results))) {
+      if (item.mode === "hybrid" && (!runtime.available() || hasSemanticFallback(results))) {
         hybridFallbackCount++;
       }
     } catch (error) {
@@ -153,10 +185,13 @@ export async function evaluateSearchFixture(
   }
 
   const dogfoodCases = cases.filter((item) => item.phaseGate === "dogfood" || item.judgment !== undefined);
+  const failures = cases.filter((item) => !item.passed);
+  const misses = cases.filter((item) => item.judgment === "miss" || item.recallAt5 < (fixtureQuery(item, fixture)?.minRecallAt5 ?? 1));
+  const noisyHits = cases.filter((item) => item.judgment === "noisy_hit");
   const metrics = aggregateMetrics(cases);
   return {
-    provider: provider ? embeddingConfig(provider) : null,
-    semantic_available: Boolean(provider && providerError === null),
+    provider: runtime.config(),
+    semantic_available: runtime.available() && providerError === null,
     provider_error: providerError,
     total_cases: cases.length,
     metrics: {
@@ -173,9 +208,10 @@ export async function evaluateSearchFixture(
         no_relevant_trap: dogfoodCases.filter((item) => item.judgment === "no_relevant_trap").length,
       },
     },
-    failures: cases.filter((item) => !item.passed),
-    misses: cases.filter((item) => item.judgment === "miss" || item.recallAt5 < (fixtureQuery(item, fixture)?.minRecallAt5 ?? 1)),
-    noisy_hits: cases.filter((item) => item.judgment === "noisy_hit"),
+    failures,
+    misses,
+    noisy_hits: noisyHits,
+    cases,
   };
 }
 
@@ -211,13 +247,93 @@ export function formatSearchEvalReport(report: SearchEvalReport): string {
     `MRR: ${report.metrics.mrr}`,
     `Hybrid fallback count: ${report.metrics.hybrid_fallback_count}`,
     `Semantic error count: ${report.metrics.semantic_error_count}`,
-    `Dogfood cases: ${report.dogfood.total}`
+    `Dogfood cases: ${report.dogfood.total}`,
+    `Judgments: ${formatJudgmentCounts(report.dogfood.judgment_counts)}`
   );
+  appendCaseSection(lines, "Failures", report.failures);
+  appendCaseSection(lines, "Misses to inspect", report.misses);
+  appendCaseSection(lines, "Noisy hits to inspect", report.noisy_hits);
+  lines.push("Next actions:", ...formatNextActions(report.next_actions));
   return lines.join("\n");
 }
 
-function fixtureRepository(fixture: EvalFixture, provider: EmbeddingProvider | undefined): TrapRepository {
-  const repo = new TrapRepository(openDatabase(":memory:"), provider);
+function buildSearchEvalNextActions(
+  report: Omit<SearchEvalReport, "next_actions">
+): SearchEvalNextAction[] {
+  const actions: SearchEvalNextAction[] = [];
+  if (report.mode === "live" && !report.semantic_available) {
+    const action = defaultEmbeddingRuntime().setupAction();
+    if (action) actions.push({
+      command: action.command,
+      reason: "Enable live semantic checks, then rerun bun run eval:dogfood -- report --live.",
+    });
+  }
+  if (report.failures.length > 0) {
+    actions.push({
+      command: "bun run eval:dogfood -- report --json",
+      reason: "Inspect expected ids, top results, and errors before changing search behavior or fixture expectations.",
+    });
+  }
+  if (report.misses.length > 0) {
+    actions.push({
+      command: 'codetrap search "<miss query>" --mode hybrid --ranking-signals --json',
+      reason: "Replay a miss with ranking signals before deciding whether to tune search or promote a fixture case.",
+    });
+  }
+  if (report.noisy_hits.length > 0) {
+    actions.push({
+      command: 'codetrap search "<noisy query>" --mode hybrid --ranking-signals --json',
+      reason: "Inspect why noisy results ranked before deciding whether the case belongs in dogfood eval.",
+    });
+  }
+  if (actions.length === 0) {
+    actions.push({
+      command: 'codetrap search "<task keywords>" --mode hybrid --json',
+      reason: "Keep logging real pre-edit searches in dogfood-log.md before automating promotion.",
+    });
+  }
+  return actions;
+}
+
+function formatJudgmentCounts(counts: Record<DogfoodJudgment, number>): string {
+  return DOGFOOD_JUDGMENTS.map((judgment) => `${judgment}=${counts[judgment]}`).join(", ");
+}
+
+function appendCaseSection(lines: string[], title: string, cases: EvalCaseReport[]): void {
+  if (cases.length === 0) return;
+  lines.push(`${title}:`);
+  for (const item of cases.slice(0, 5)) {
+    lines.push(`  - [${item.mode}] ${item.query}`);
+    if (item.goldTrapIds.length > 0) {
+      lines.push(`    expected: ${formatExpected(item)}`);
+    }
+    lines.push(`    top: ${formatTopResults(item)}`);
+    if (item.error) lines.push(`    error: ${item.error}`);
+  }
+  if (cases.length > 5) lines.push(`  ... ${cases.length - 5} more`);
+}
+
+function formatExpected(item: EvalCaseReport): string {
+  return item.goldTrapIds
+    .map((id, index) => `#${id} ${item.expectedTitles[index] ?? ""}`.trim())
+    .join(", ");
+}
+
+function formatTopResults(item: EvalCaseReport): string {
+  if (item.topResults.length === 0) return "(none)";
+  return item.topResults
+    .slice(0, 3)
+    .map((result) => `#${result.id} ${result.title}`)
+    .join("; ");
+}
+
+function formatNextActions(actions: SearchEvalNextAction[]): string[] {
+  if (actions.length === 0) return ["  (none)"];
+  return actions.map((action) => `  - ${action.command} # ${action.reason}`);
+}
+
+function fixtureRepository(fixture: EvalFixture, embeddings: EmbeddingRuntimeInput, ranking?: RankingConfig): TrapRepository {
+  const repo = new TrapRepository(openDatabase(":memory:"), embeddings, ranking);
   for (const trap of fixture.traps) repo.add(trap);
   return repo;
 }
@@ -378,9 +494,6 @@ function providerLabel(provider: EmbeddingConfig | null): string {
   return `${provider.provider}/${provider.model}`;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 function round(value: number): number {
   return Math.round(value * 10000) / 10000;