codetrap 0.1.7 → 0.1.8

package/src/web/project-registry.ts

@@ -2,7 +2,9 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { CODETRAP_DIR } from "../lib/constants";
-import { findProjectRoot, resolveScopePath } from "../lib/scope";
+import { findProjectRoot } from "../lib/scope";
+import { resolveScopePath } from "../lib/scope-path";
+import { isRecord } from "../lib/value-types";
 
 export const WEB_PROJECTS_FILE = "web-projects.json";
 export const WEB_PROJECTS_VERSION = 1;
@@ -100,7 +102,3 @@ function uniqueProjects(projects: WebProject[]): WebProject[] {
   }
   return out;
 }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/web/server.ts

@@ -1,11 +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,
@@ -30,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");
@@ -145,8 +124,13 @@ 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, context.home).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") {
@@ -158,7 +142,7 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
     return jsonResponse({
       project_root: projectRoot,
       session,
-      candidates: webCandidates(document.candidates, ops.traps),
+      candidates: reviewedSessionCandidates(document.candidates, ops.traps),
     });
   }
 
@@ -188,6 +172,56 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
     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);
@@ -205,11 +239,12 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
     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,
@@ -254,7 +289,7 @@ async function routeApi(request: Request, url: URL, context: WebContext): Promis
       session: result.session,
       removed_count: result.removed_count,
       removed_candidate_ids: result.removed_candidate_ids,
-      candidates: webCandidates(result.candidates, ops.traps),
+      candidates: reviewedSessionCandidates(result.candidates, ops.traps),
     });
   }
 
@@ -270,65 +305,11 @@ function sessionOperations(projectRoot: string, home?: string): { traps: TrapOpe
 }
 
 function trapOperations(projectRoot: string, home?: string): TrapOperations {
-  return new TrapOperations(new TrapStore(projectRoot, undefined, home));
+  return new TrapOperations(trapStore(projectRoot, home));
 }
 
-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 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 {
@@ -441,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;
@@ -452,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 {
@@ -494,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);
-}