codetrap 0.1.6 → 0.1.8

package/src/web/server.ts

@@ -1,10 +1,17 @@
 import { randomBytes } from "node:crypto";
+import { DEFAULT_OLLAMA_DIMENSIONS, DEFAULT_OLLAMA_ENDPOINT, DEFAULT_OLLAMA_MODEL, EmbeddingProviderUnavailableError } from "../lib/embedder";
 import { CATEGORIES, SCOPES, SEVERITIES } from "../lib/constants";
-import type { CandidateTrap } from "../domain/session";
+import { loadCodetrapConfig, type EmbeddingProviderSetting, type EmbeddingSettings } from "../lib/config";
 import { TrapStore } from "../lib/store";
 import { TrapOperations } from "../lib/trap-operations";
-import { SessionOperations, type SessionAcceptResult } from "../lib/session-operations";
+import { SessionOperations } from "../lib/session-operations";
 import { SessionStore } from "../lib/session-store";
+import { toListJson, toTrapDetailsJson } from "../lib/output-json";
+import { isRecord } from "../lib/value-types";
+import {
+  reviewedSessionCandidates,
+  sessionConflictPayload,
+} from "../lib/session-review";
 import { WEB_INDEX_HTML } from "./static";
 import {
   addWebProject,
@@ -29,33 +36,6 @@ type WebContext = {
   currentProjectRoot: string | null;
 };
 
-type WebCandidateReview =
-  | { status: "pending"; label: string }
-  | {
-      status: "accepted";
-      label: string;
-      trap_id: number;
-      scope: string;
-      trap_present: true;
-      trap_status: string;
-      trap_title: string;
-    }
-  | {
-      status: "accepted_missing";
-      label: string;
-      trap_id?: number;
-      scope?: string;
-      trap_present: false;
-    }
-  | {
-      status: "rejected";
-      label: string;
-      rejected_at?: string;
-      rejection_reason?: string;
-    };
-
-type WebCandidate = CandidateTrap & { review: WebCandidateReview };
-
 export async function startWebServerFromArgs(args: string[], cwd = process.cwd()): Promise<void> {
   const options = webServerOptionsFromArgs(args, cwd);
   const token = options.token ?? randomBytes(18).toString("base64url");
@@ -89,6 +69,9 @@ export function createWebHandler(context: WebContext): (request: Request) => Pro
       if (url.pathname === "/" || url.pathname === "/index.html") {
         return htmlResponse(WEB_INDEX_HTML);
       }
+      if (url.pathname === "/favicon.ico") {
+        return new Response(null, { status: 204 });
+      }
       return jsonResponse({ error: "Not found" }, 404);
     } catch (error) {
       const status = error instanceof WebHttpError || error instanceof WebPayloadError ? error.status : 500;
@@ -141,20 +124,42 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
 
   if (request.method === "GET" && url.pathname === "/api/sessions") {
     const projectRoot = projectRootFromQuery(url, context);
-    const sessions = sessionOperations(projectRoot).sessions.listSessions({ status: "all", limit: 100 });
-    return jsonResponse({ project_root: projectRoot, sessions });
+    const ops = sessionOperations(projectRoot, context.home);
+    const sessions = ops.sessions.listSessions({ status: "all", limit: 100 });
+    return jsonResponse({
+      project_root: projectRoot,
+      candidate_review: ops.sessions.candidateReviewSummary(),
+      sessions,
+    });
   }
 
   if (request.method === "GET" && url.pathname === "/api/candidates") {
     const projectRoot = projectRootFromQuery(url, context);
     const sessionId = requiredQuery(url, "session");
-    const ops = sessionOperations(projectRoot);
+    const ops = sessionOperations(projectRoot, context.home);
     const session = ops.sessions.showSession(sessionId).session;
     const document = ops.sessions.candidateDocument(sessionId);
     return jsonResponse({
       project_root: projectRoot,
       session,
-      candidates: webCandidates(document.candidates, ops.traps),
+      candidates: reviewedSessionCandidates(document.candidates, ops.traps),
+    });
+  }
+
+  if (request.method === "GET" && url.pathname === "/api/traps") {
+    const projectRoot = projectRootFromQuery(url, context);
+    const groups = trapOperations(projectRoot, context.home).listTraps({
+      category: optionalQuery(url, "category"),
+      scope: optionalQuery(url, "scope"),
+      status: optionalQuery(url, "status"),
+      module: optionalQuery(url, "module"),
+      owner: optionalQuery(url, "owner"),
+      limit: optionalNumberQuery(url, "limit"),
+      offset: optionalNumberQuery(url, "offset"),
+    });
+    return jsonResponse({
+      project_root: projectRoot,
+      traps: toListJson(groups),
     });
   }
 
@@ -162,15 +167,65 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
     const projectRoot = projectRootFromQuery(url, context);
     const id = numberQuery(url, "id");
     const scope = url.searchParams.get("scope") ?? undefined;
-    const details = trapOperations(projectRoot).getTrapDetails(id, scope);
+    const details = trapOperations(projectRoot, context.home).getTrapDetails(id, scope);
     if (!details) throw new WebHttpError(404, `Trap #${id} not found.`);
-    return jsonResponse(details);
+    return jsonResponse(toTrapDetailsJson(details));
+  }
+
+  if (request.method === "GET" && url.pathname === "/api/embeddings") {
+    const projectRoot = projectRootFromQuery(url, context);
+    const status = await trapStore(projectRoot, context.home).embeddingStatus();
+    return jsonResponse({
+      project_root: projectRoot,
+      settings: loadCodetrapConfig(context.home).embeddings ?? null,
+      ...status,
+    });
+  }
+
+  if (request.method === "POST" && url.pathname === "/api/embeddings/use") {
+    const body = await readJsonBody(request);
+    const projectRoot = projectRootFromBody(body, context);
+    const embeddings = embeddingSettingsFromBody(body);
+    const written = trapStore(projectRoot, context.home).configureEmbeddings(embeddings);
+    const refreshed = await trapStore(projectRoot, context.home).embeddingStatus();
+    return jsonResponse({
+      success: true,
+      project_root: projectRoot,
+      path: written.path,
+      config: written.config,
+      embeddings: written.config.embeddings ?? embeddings,
+      settings: written.config.embeddings ?? embeddings,
+      next_actions: embeddingReindexActions(projectRoot),
+      status: refreshed,
+    });
+  }
+
+  if (request.method === "POST" && url.pathname === "/api/embeddings/reindex") {
+    const body = await readJsonBody(request);
+    const projectRoot = projectRootFromBody(body, context);
+    const scope = scopeBodyField(body, "scope");
+    const store = trapStore(projectRoot, context.home);
+    try {
+      const result = await store.ensureEmbeddings({ scope });
+      return jsonResponse({
+        success: true,
+        project_root: projectRoot,
+        scope,
+        result,
+        status: await store.embeddingStatus(),
+      });
+    } catch (error) {
+      if (error instanceof EmbeddingProviderUnavailableError) {
+        throw new WebHttpError(400, error.message);
+      }
+      throw error;
+    }
   }
 
   if (request.method === "POST" && url.pathname === "/api/candidate/save") {
     const body = await readJsonBody(request);
     const projectRoot = projectRootFromBody(body, context);
-    const result = sessionOperations(projectRoot).sessions.saveCandidate({
+    const result = sessionOperations(projectRoot, context.home).sessions.saveCandidate({
       candidateId: stringBodyField(body, "candidateId"),
       sessionId: optionalStringBodyField(body, "sessionId"),
       edit: recordBodyField(body, "trap"),
@@ -181,14 +236,15 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
   if (request.method === "POST" && url.pathname === "/api/candidate/accept") {
     const body = await readJsonBody(request);
     const projectRoot = projectRootFromBody(body, context);
-    const result = await sessionOperations(projectRoot).sessions.acceptCandidate({
+    const result = await sessionOperations(projectRoot, context.home).sessions.acceptCandidate({
       candidateId: stringBodyField(body, "candidateId"),
       sessionId: optionalStringBodyField(body, "sessionId"),
+      edit: optionalRecordBodyField(body, "trap"),
       acceptAnyway: booleanBodyField(body, "acceptAnyway"),
       supersedesId: optionalNumberBodyField(body, "supersedesId"),
     });
     if (!result.success) {
-      throw new WebPayloadError(409, conflictPayload(result));
+      throw new WebPayloadError(409, sessionConflictPayload(result));
     }
     return jsonResponse({
       success: true,
@@ -204,7 +260,7 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
   if (request.method === "POST" && url.pathname === "/api/candidate/reject") {
     const body = await readJsonBody(request);
     const projectRoot = projectRootFromBody(body, context);
-    const result = sessionOperations(projectRoot).sessions.rejectCandidate({
+    const result = sessionOperations(projectRoot, context.home).sessions.rejectCandidate({
       candidateId: stringBodyField(body, "candidateId"),
       sessionId: optionalStringBodyField(body, "sessionId"),
       reason: optionalStringBodyField(body, "reason"),
@@ -212,77 +268,48 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
     return jsonResponse({ success: true, session: result.session, candidate: result.candidate });
   }
 
+  if (request.method === "POST" && url.pathname === "/api/session/delete") {
+    const body = await readJsonBody(request);
+    const projectRoot = projectRootFromBody(body, context);
+    const result = sessionOperations(projectRoot, context.home).sessions.deleteSession(
+      stringBodyField(body, "sessionId")
+    );
+    return jsonResponse({ success: true, ...result });
+  }
+
+  if (request.method === "POST" && url.pathname === "/api/session/cleanup") {
+    const body = await readJsonBody(request);
+    const projectRoot = projectRootFromBody(body, context);
+    const ops = sessionOperations(projectRoot, context.home);
+    const result = ops.sessions.cleanupDeletedTrapCandidates(
+      optionalStringBodyField(body, "sessionId")
+    );
+    return jsonResponse({
+      success: true,
+      session: result.session,
+      removed_count: result.removed_count,
+      removed_candidate_ids: result.removed_candidate_ids,
+      candidates: reviewedSessionCandidates(result.candidates, ops.traps),
+    });
+  }
+
   throw new WebHttpError(404, "Not found");
 }
 
-function sessionOperations(projectRoot: string): { traps: TrapOperations; sessions: SessionOperations } {
-  const traps = trapOperations(projectRoot);
+function sessionOperations(projectRoot: string, home?: string): { traps: TrapOperations; sessions: SessionOperations } {
+  const traps = trapOperations(projectRoot, home);
   return {
     traps,
     sessions: new SessionOperations(new SessionStore(projectRoot), traps),
   };
 }
 
-function trapOperations(projectRoot: string): TrapOperations {
-  return new TrapOperations(new TrapStore(projectRoot));
-}
-
-function webCandidates(candidates: CandidateTrap[], traps: TrapOperations): WebCandidate[] {
-  return candidates.map((candidate) => ({
-    ...candidate,
-    review: candidateReview(candidate, traps),
-  }));
-}
-
-function candidateReview(candidate: CandidateTrap, traps: TrapOperations): WebCandidateReview {
-  if (candidate.status === "proposed") {
-    return { status: "pending", label: "pending review" };
-  }
-
-  if (candidate.status === "rejected") {
-    return {
-      status: "rejected",
-      label: "rejected",
-      rejected_at: candidate.rejected_at,
-      rejection_reason: candidate.rejection_reason,
-    };
-  }
-
-  const trapId = candidate.accepted_trap_id;
-  const scope = candidate.accepted_scope ?? acceptedScopeFallback(candidate);
-  if (trapId === undefined) {
-    return {
-      status: "accepted_missing",
-      label: "accepted -> trap link missing",
-      scope,
-      trap_present: false,
-    };
-  }
-
-  const details = traps.getTrapDetails(trapId, scope);
-  if (!details) {
-    return {
-      status: "accepted_missing",
-      label: `accepted -> trap #${trapId} deleted`,
-      trap_id: trapId,
-      scope,
-      trap_present: false,
-    };
-  }
-
-  return {
-    status: "accepted",
-    label: `accepted -> trap #${trapId}`,
-    trap_id: trapId,
-    scope: details.scope,
-    trap_present: true,
-    trap_status: details.trap.status,
-    trap_title: details.trap.title,
-  };
+function trapOperations(projectRoot: string, home?: string): TrapOperations {
+  return new TrapOperations(trapStore(projectRoot, home));
 }
 
-function acceptedScopeFallback(candidate: CandidateTrap): string {
-  return candidate.trap.scope === "global" ? "global" : "project";
+function trapStore(projectRoot: string, home?: string): TrapStore {
+  return new TrapStore(projectRoot, undefined, home);
 }
 
 function registerInitialProject(options: WebServerOptions): string | null {
@@ -353,6 +380,19 @@ function numberQuery(url: URL, key: string): number {
   return value;
 }
 
+function optionalQuery(url: URL, key: string): string | undefined {
+  const value = url.searchParams.get(key)?.trim();
+  return value || undefined;
+}
+
+function optionalNumberQuery(url: URL, key: string): number | undefined {
+  const value = optionalQuery(url, key);
+  if (!value) return undefined;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) throw new WebHttpError(400, `${key} must be a positive integer.`);
+  return parsed;
+}
+
 function stringBodyField(body: Record<string, unknown>, key: string): string {
   const value = optionalStringBodyField(body, key);
   if (!value) throw new WebHttpError(400, `${key} is required.`);
@@ -382,6 +422,46 @@ function optionalNumberBodyField(body: Record<string, unknown>, key: string): nu
   return value;
 }
 
+function scopeBodyField(body: Record<string, unknown>, key: string): "project" | "global" {
+  const value = stringBodyField(body, key);
+  if (value === "project" || value === "global") return value;
+  throw new WebHttpError(400, `${key} must be project or global.`);
+}
+
+function embeddingSettingsFromBody(body: Record<string, unknown>): EmbeddingSettings {
+  const provider = embeddingProviderBodyField(body, "provider");
+  if (provider === "jina") {
+    return { provider };
+  }
+  return {
+    provider,
+    endpoint: optionalStringBodyField(body, "endpoint") ?? DEFAULT_OLLAMA_ENDPOINT,
+    model: optionalStringBodyField(body, "model") ?? DEFAULT_OLLAMA_MODEL,
+    dimensions: optionalNumberBodyField(body, "dimensions") ?? DEFAULT_OLLAMA_DIMENSIONS,
+  };
+}
+
+function embeddingProviderBodyField(body: Record<string, unknown>, key: string): EmbeddingProviderSetting {
+  const value = stringBodyField(body, key);
+  if (value === "ollama" || value === "jina") return value;
+  throw new WebHttpError(400, `${key} must be ollama or jina.`);
+}
+
+function embeddingReindexActions(_projectRoot: string): { scope: "project" | "global"; command: string; reason: string }[] {
+  return [
+    {
+      scope: "project",
+      command: "codetrap embeddings reindex --scope project",
+      reason: "Generate project embeddings for the selected profile.",
+    },
+    {
+      scope: "global",
+      command: "codetrap embeddings reindex --scope global",
+      reason: "Generate global embeddings for the selected profile.",
+    },
+  ];
+}
+
 function booleanBodyField(body: Record<string, unknown>, key: string): boolean {
   const value = body[key];
   return typeof value === "boolean" ? value : false;
@@ -393,14 +473,11 @@ function recordBodyField(body: Record<string, unknown>, key: string): Record<str
   return value;
 }
 
-function conflictPayload(result: Exclude<SessionAcceptResult, { success: true }>): Record<string, unknown> {
-  return {
-    success: false,
-    error: "Possible active trap conflict found.",
-    session_id: result.session_id,
-    candidate_id: result.candidate_id,
-    possible_conflicts: result.possible_conflicts,
-  };
+function optionalRecordBodyField(body: Record<string, unknown>, key: string): Record<string, unknown> | undefined {
+  const value = body[key];
+  if (value === undefined || value === null) return undefined;
+  if (!isRecord(value)) throw new WebHttpError(400, `${key} must be an object.`);
+  return value;
 }
 
 function parsePort(value: string): number {
@@ -435,7 +512,3 @@ class WebPayloadError extends Error {
     super(String(payload.error ?? "Request failed"));
   }
 }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}