codetrap 0.1.3 → 0.1.4

package/src/lib/search-result-card.ts

@@ -15,14 +15,8 @@ export function toTrapActionCard(result: TrapSearchResult, scope: Scope): TrapAc
     severity: trap.severity,
     score: result.score ?? null,
     sources: result.sources ?? [],
+    ...(result.diagnostics ? { diagnostics: result.diagnostics } : {}),
     ...(result.ranking_signals ? { ranking_signals: result.ranking_signals } : {}),
-    next_action: {
-      details_tool: "get_trap",
-      details_args: {
-        id: trap.id,
-        scope,
-      },
-    },
   };
 }
 

package/src/lib/search-service.ts

@@ -1,5 +1,4 @@
 import type { Database } from "bun:sqlite";
-import * as embeddingQueries from "../db/embedding-queries";
 import * as queries from "../db/queries";
 import type { TrapSearchResult } from "../domain/trap";
 import type { SearchMode, TrapStatus } from "./constants";
@@ -13,7 +12,9 @@ import {
   DEFAULT_RANKING_CONFIG,
   TrapSearchPolicy,
   type RankingConfig,
+  type SearchRetrievalPlan,
 } from "./search-policy";
+import { DatabaseEmbeddingIndex } from "./embedding-index";
 
 export interface SearchOptions {
   category?: string;
@@ -32,6 +33,7 @@ const DEFAULT_LIMIT = 20;
 
 export class SearchService {
   private readonly policy: TrapSearchPolicy;
+  private readonly embeddingIndex: DatabaseEmbeddingIndex;
 
   constructor(
     private readonly db: Database,
@@ -39,6 +41,7 @@ export class SearchService {
     ranking: RankingConfig = DEFAULT_RANKING_CONFIG
   ) {
     this.policy = new TrapSearchPolicy(ranking);
+    this.embeddingIndex = new DatabaseEmbeddingIndex(db);
   }
 
   async search(query: string, opts: SearchOptions = {}): Promise<TrapSearchResult[]> {
@@ -58,20 +61,51 @@ export class SearchService {
   }
 
   ftsSearch(query: string, opts: SearchOptions = {}): TrapSearchResult[] {
-    const limit = opts.limit ?? DEFAULT_LIMIT;
-    const searchLimit = this.policy.candidateLimit(opts, limit);
+    const plan = this.policy.plan(opts, DEFAULT_LIMIT);
+    return this.policy.finalizeResults(this.retrieveFtsCandidates(query, plan), query, opts, plan);
+  }
+
+  async semanticSearch(query: string, opts: SearchOptions = {}): Promise<TrapSearchResult[]> {
+    const plan = this.policy.plan(opts, DEFAULT_LIMIT);
+    return this.policy.finalizeResults(await this.retrieveSemanticCandidates(query, plan), query, opts, plan);
+  }
+
+  async hybridSearch(query: string, opts: SearchOptions = {}): Promise<TrapSearchResult[]> {
+    const plan = this.policy.plan(opts, DEFAULT_LIMIT);
+    const ftsCandidates = this.retrieveFtsCandidates(query, plan);
+
+    try {
+      const semanticCandidates = await this.retrieveSemanticCandidates(query, plan);
+      if (semanticCandidates.length === 0) {
+        return this.policy.withDiagnostics(this.policy.finalizeResults(ftsCandidates, query, opts, plan), {
+          code: "semantic_no_candidates",
+          message: "Hybrid search used FTS results because no fresh semantic candidates passed the score threshold.",
+        });
+      }
+      return this.policy.fuseAndFinalize(ftsCandidates, semanticCandidates, query, opts, plan);
+    } catch (error) {
+      return this.policy.withDiagnostics(
+        this.policy.finalizeResults(ftsCandidates, query, opts, plan),
+        this.policy.semanticDiagnostic(error)
+      );
+    }
+  }
+
+  private retrieveFtsCandidates(query: string, plan: SearchRetrievalPlan): TrapSearchResult[] {
     const candidates = queries
-      .searchTraps(this.db, query, { ...opts, limit: searchLimit })
-      .filter((result) => this.policy.matchesTrap(result.trap, opts))
+      .searchTraps(this.db, query, plan.ftsStorageFilter)
       .map((result) => ({
         ...result,
         sources: ["fts"] as ("fts")[],
         score: ftsScore(result.rank),
       }));
-    return this.policy.rankResults(candidates, query, opts, limit);
+    return this.policy.prepareRetrievedResults(candidates, "fts", plan);
   }
 
-  async semanticSearch(query: string, opts: SearchOptions = {}): Promise<TrapSearchResult[]> {
+  private async retrieveSemanticCandidates(
+    query: string,
+    plan: SearchRetrievalPlan
+  ): Promise<TrapSearchResult[]> {
     if (!this.embedder) {
       throw new EmbeddingProviderUnavailableError();
     }
@@ -80,11 +114,7 @@ export class SearchService {
     if (!queryEmbedding) return [];
 
     const config = embeddingConfig(this.embedder);
-    const candidates = embeddingQueries.getAllFreshEmbeddings(this.db, config, {
-      category: opts.category,
-      scope: opts.scope,
-      status: opts.status,
-    });
+    const candidates = this.embeddingIndex.freshEmbeddings(config, plan.semanticStorageFilter);
 
     const results = candidates
       .map(({ trap, embedding }) => {
@@ -96,29 +126,8 @@ export class SearchService {
           score,
         };
       })
-      .filter((result) => this.policy.matchesTrap(result.trap, opts))
-      .filter((result) => (result.score ?? 0) >= this.policy.semanticMinScore())
-      .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
       .map((result) => result as TrapSearchResult);
-    return this.policy.rankResults(results, query, opts, opts.limit ?? DEFAULT_LIMIT);
-  }
-
-  async hybridSearch(query: string, opts: SearchOptions = {}): Promise<TrapSearchResult[]> {
-    const limit = opts.limit ?? DEFAULT_LIMIT;
-    const ftsResults = this.ftsSearch(query, { ...opts, limit });
-
-    try {
-      const semanticResults = await this.semanticSearch(query, { ...opts, limit });
-      if (semanticResults.length === 0) {
-        return this.policy.withDiagnostics(ftsResults, {
-          code: "semantic_no_candidates",
-          message: "Hybrid search used FTS results because no fresh semantic candidates passed the score threshold.",
-        });
-      }
-      return this.policy.fuse(ftsResults, semanticResults, query, opts, limit);
-    } catch (error) {
-      return this.policy.withDiagnostics(ftsResults, this.policy.semanticDiagnostic(error));
-    }
+    return this.policy.prepareRetrievedResults(results, "semantic", plan);
   }
 }
 

package/src/lib/store.ts

@@ -167,19 +167,51 @@ export class TrapStore {
     return this.scopes.repositoryFor(resolvedScope).top(resolvedScope, limit);
   }
 
-  stats(): { project: TrapStats | null; global: TrapStats } {
-    const project = this.scopes.repositoryEntry("project")?.repository.stats() ?? null;
-    return { project, global: this.scopes.repositoryFor("global").stats() };
+  stats(opts: { scope?: string } = {}): { project: TrapStats | null; global: TrapStats | null } {
+    const scope = opts.scope ? normalizeScope(opts.scope) : null;
+    const project = scope === "global"
+      ? null
+      : this.scopes.repositoryEntry("project")?.repository.stats({ scope: "project" }) ?? null;
+    const global = scope === "project"
+      ? null
+      : this.scopes.repositoryFor("global").stats({ scope: "global" });
+    return { project, global };
   }
 
-  embeddingStats(): TrapEmbeddingStats {
+  embeddingStats(opts: { scope?: string } = {}): TrapEmbeddingStats {
+    const scope = opts.scope ? normalizeScope(opts.scope) : null;
     const config = this.embeddingConfig();
-    const project = this.scopes.repositoryEntry("project")
-      ? summarizeEmbeddingState(this.scopes.repositoryFor("project").embeddingStats(config), config)
+    const project = scope === "global"
+      ? null
+      : this.scopes.repositoryEntry("project")
+      ? summarizeEmbeddingState(this.scopes.repositoryFor("project").embeddingStats(config, { scope: "project" }), config)
       : null;
+    const global = scope === "project"
+      ? null
+      : summarizeEmbeddingState(this.scopes.repositoryFor("global").embeddingStats(config, { scope: "global" }), config);
     return {
       project,
-      global: summarizeEmbeddingState(this.scopes.repositoryFor("global").embeddingStats(config), config),
+      global,
+    };
+  }
+
+  diagnostics(): {
+    mis_scoped_traps: {
+      global_db_project_traps: Pick<Trap, "id" | "title" | "scope" | "project_path" | "status">[];
+    };
+  } {
+    return {
+      mis_scoped_traps: {
+        global_db_project_traps: this.scopes.repositoryFor("global")
+          .listMisScoped("global")
+          .map((trap) => ({
+            id: trap.id,
+            title: trap.title,
+            scope: trap.scope,
+            project_path: trap.project_path,
+            status: trap.status,
+          })),
+      },
     };
   }
 

package/src/lib/trap-lifecycle.ts

@@ -0,0 +1,37 @@
+import type { Trap } from "../domain/trap";
+
+export type TrapLifecycleAdapter = {
+  get(id: number): Trap | null;
+  transaction<T>(callback: () => T): T;
+  markArchived(id: number): boolean;
+  markSuperseded(id: number, stateKey: string): boolean;
+  markSuperseding(id: number, supersedesId: number, stateKey: string): boolean;
+};
+
+export function archiveTrapLifecycle(adapter: TrapLifecycleAdapter, id: number): boolean {
+  return adapter.markArchived(id);
+}
+
+export function supersedeTrapLifecycle(
+  adapter: TrapLifecycleAdapter,
+  id: number,
+  supersededById: number,
+  stateKey?: string
+): boolean {
+  if (id === supersededById) return false;
+
+  const oldTrap = adapter.get(id);
+  const newTrap = adapter.get(supersededById);
+  if (!oldTrap || !newTrap) return false;
+
+  const key = lifecycleStateKey(oldTrap, newTrap, stateKey);
+  return adapter.transaction(() => {
+    adapter.markSuperseded(id, key);
+    adapter.markSuperseding(supersededById, id, key);
+    return true;
+  });
+}
+
+export function lifecycleStateKey(oldTrap: Trap, newTrap: Trap, requested?: string): string {
+  return requested ?? oldTrap.state_key ?? newTrap.state_key ?? `trap:${oldTrap.id}`;
+}

package/src/lib/trap-operations.ts

@@ -18,7 +18,7 @@ export type TrapListGroup = { traps: Trap[]; scope: string };
 export type TrapSearchGroup = { results: TrapSearchResult[]; scope: string };
 export type { AddTrapEvidenceResult, TrapMutationResult };
 
-export type TrapStatsResult = { project: TrapStats | null; global: TrapStats };
+export type TrapStatsResult = { project: TrapStats | null; global: TrapStats | null };
 export type EmbeddingStatsResult = ReturnType<TrapStore["embeddingStats"]>;
 
 export interface SearchTrapsArgs {
@@ -130,12 +130,12 @@ export class TrapOperations {
     return this.store.supersede(id, supersededById, scope, stateKey);
   }
 
-  getStats(): TrapStatsResult {
-    return this.store.stats();
+  getStats(scope?: string): TrapStatsResult {
+    return this.store.stats({ scope });
   }
 
-  getEmbeddingStats(): EmbeddingStatsResult {
-    return this.store.embeddingStats();
+  getEmbeddingStats(scope?: string): EmbeddingStatsResult {
+    return this.store.embeddingStats({ scope });
   }
 
   exportTraps(scope?: string): ReturnType<TrapStore["exportAll"]> {

package/src/mcp/server.ts

@@ -21,6 +21,11 @@ import {
   toTrapDetailsJson,
 } from "../lib/output-json";
 import { storeForScopeContext } from "../lib/scope-context";
+import {
+  listRequestFromArgs,
+  searchRequestFromArgs,
+  statsRequestFromArgs,
+} from "../lib/command-requests";
 
 type ToolArgs = Record<string, any>;
 
@@ -30,19 +35,8 @@ export async function handleToolCall(store: TrapStore, name: string, args: ToolA
   try {
     switch (name) {
       case "search_traps": {
-        const cards = await operations.searchTrapCards({
-          query: args.query,
-          scope: args.scope,
-          category: args.category,
-          mode: args.mode,
-          limit: args.limit ?? 20,
-          status: args.status,
-          path: args.path,
-          module: args.module,
-          owner: args.owner,
-          rerank: args.rerank,
-          includeRankingSignals: args.ranking_signals,
-        });
+        const defaults = { mode: "hybrid" as const, limit: args.limit ?? 20, rerank: true };
+        const cards = await operations.searchTrapCards(searchRequestFromArgs(args.query, args, defaults));
         return toMcpTextJson(toMcpSearchJson(cards));
       }
 
@@ -60,15 +54,7 @@ export async function handleToolCall(store: TrapStore, name: string, args: ToolA
       }
 
       case "list_traps": {
-        const groups = operations.listTraps({
-          scope: args.scope,
-          category: args.category,
-          status: args.status,
-          limit: args.limit ?? 50,
-          path: args.path,
-          module: args.module,
-          owner: args.owner,
-        });
+        const groups = operations.listTraps(listRequestFromArgs(args));
         return toMcpTextJson(toListJson(groups));
       }
 
@@ -98,8 +84,9 @@ export async function handleToolCall(store: TrapStore, name: string, args: ToolA
       }
 
       case "get_stats": {
-        const stats = operations.getStats();
-        return toMcpTextJson(toStatsJson(stats, operations.getEmbeddingStats()));
+        const request = statsRequestFromArgs(args);
+        const stats = operations.getStats(request.scope);
+        return toMcpTextJson(toStatsJson(stats, operations.getEmbeddingStats(request.scope)));
       }
 
       default: