fleetlens 0.15.7 → 0.16.0

package/app/apps/web/app/api/agent/index/route.ts

@@ -0,0 +1,56 @@
+/**
+ * Search-index maintenance.
+ *
+ * GET  → current index stats (session count, last refresh, building flag)
+ * POST → run an incremental refresh, streaming progress as SSE
+ */
+
+import { ensureIndex, indexStats } from "@/lib/agent/index-store";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function GET() {
+  return Response.json(indexStats());
+}
+
+export async function POST() {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      let closed = false;
+      const send = (data: unknown) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+        } catch {
+          closed = true;
+        }
+      };
+      void (async () => {
+        try {
+          // Explicit refresh always rescans — the 15s freshness window is
+          // for tool calls piggybacking mid-turn, not the refresh button.
+          const docs = await ensureIndex((p) => send({ type: "progress", ...p }), { force: true });
+          send({ type: "done", sessions: docs.length });
+        } catch (err) {
+          send({ type: "error", message: (err as Error).message });
+        }
+        if (!closed) {
+          try {
+            controller.close();
+          } catch {}
+          closed = true;
+        }
+      })();
+    },
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}

package/app/apps/web/app/api/agent/mcp/route.ts

@@ -0,0 +1,31 @@
+/** MCP tool server the spawned claude subprocess calls back into
+ *  (streamable-HTTP), so tools run in-process sharing the session index.
+ *  Unauthenticated by design — localhost-only threat model like the rest
+ *  of the dashboard; do NOT port to team-server without adding auth. */
+
+import { handleMcpMessage } from "@/lib/agent/mcp";
+import { agentTools } from "@/lib/agent/tools";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export async function POST(request: Request) {
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return Response.json(
+      { jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } },
+      { status: 400 },
+    );
+  }
+  const res = await handleMcpMessage(body, agentTools);
+  if (res === null) return new Response(null, { status: 202 });
+  return Response.json(res);
+}
+
+/** The streamable-HTTP transport probes GET for an event stream; we don't
+ *  push server-initiated messages, so decline politely. */
+export function GET() {
+  return new Response(null, { status: 405 });
+}

package/app/apps/web/app/api/agent/suggestions/route.ts

@@ -0,0 +1,150 @@
+/** Personalized empty-state suggestion chips. GET answers immediately from
+ *  the best tier (cached LLM chips → deterministic template-fill → static
+ *  fallback; AI off ⇒ deterministic) and, when stale, fires one background
+ *  haiku regeneration — the client re-fetches while `refreshing` is true. */
+
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { cclensPath } from "@claude-lens/parser/fs";
+import { interactiveLockFresh, readSettings, runClaudeSubprocess } from "@claude-lens/entries/node";
+import { ensureIndex, indexIsEmpty, indexStats, peekDocs } from "@/lib/agent/index-store";
+import {
+  FALLBACK_SUGGESTIONS,
+  SUGGESTION_SYSTEM_PROMPT,
+  buildSuggestionContext,
+  deterministicSuggestions,
+  parseSuggestions,
+  suggestionInputKey,
+  type Suggestion,
+} from "@/lib/agent/suggestions";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+const CACHE_TTL_MS = 24 * 3_600_000;
+
+type Cache = {
+  version: 1;
+  generated_at: string;
+  input_key: string;
+  model: string;
+  suggestions: Suggestion[];
+};
+
+function cachePath(): string {
+  return cclensPath("agent-suggestions.json");
+}
+
+function readCache(): Cache | null {
+  try {
+    const c = JSON.parse(readFileSync(cachePath(), "utf8")) as Cache;
+    return c.version === 1 && Array.isArray(c.suggestions) && c.suggestions.length === 4 ? c : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(c: Cache): void {
+  const p = cachePath();
+  mkdirSync(dirname(p), { recursive: true });
+  const tmp = `${p}.tmp.${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(c, null, 2), "utf8");
+  renameSync(tmp, p);
+}
+
+// Cross-route/cross-compile latch — see the globalThis note in index-store.
+type Latch = { refreshing: Promise<void> | null; lastAttemptMs: number };
+const latch: Latch = ((globalThis as Record<string, unknown>).__fleetlensAgentSuggestions ??= {
+  refreshing: null,
+  lastAttemptMs: 0,
+}) as Latch;
+
+/** Minimum spacing between generation attempts. Success short-circuits via
+ *  the fresh cache; this floor is what stops a persistently-unparseable
+ *  model from being re-spawned by every polling client. */
+const RETRY_FLOOR_MS = 5 * 60_000;
+
+function kickRefresh(context: string, inputKey: string): void {
+  if (latch.refreshing) return;
+  if (Date.now() - latch.lastAttemptMs < RETRY_FLOOR_MS) return;
+  // A digest pipeline mid-run owns the LLM budget; suggestions can wait for
+  // the next visit rather than pile on.
+  if (interactiveLockFresh(Date.now())) return;
+  latch.lastAttemptMs = Date.now();
+  latch.refreshing = (async () => {
+    try {
+      const res = await runClaudeSubprocess({
+        systemPrompt: SUGGESTION_SYSTEM_PROMPT,
+        model: "haiku",
+        userPrompt: context,
+      });
+      const parsed = parseSuggestions(res.content);
+      if (parsed) {
+        writeCache({
+          version: 1,
+          generated_at: new Date().toISOString(),
+          input_key: inputKey,
+          model: res.model,
+          suggestions: parsed,
+        });
+      }
+    } catch {
+      /* stay on the deterministic tier; next visit retries */
+    }
+  })().finally(() => {
+    latch.refreshing = null;
+  });
+}
+
+/** Always answers in milliseconds: chips come from cache/memory only. Index
+ *  warm-up and LLM generation both happen off the request path; the client
+ *  re-fetches while `refreshing` is true. */
+export function GET() {
+  const cache = readCache();
+
+  // Never trigger the expensive first index build just for chips — the page
+  // kicks that off explicitly with visible progress.
+  if (indexIsEmpty()) {
+    return Response.json({
+      suggestions: cache?.suggestions ?? FALLBACK_SUGGESTIONS,
+      source: cache ? "llm-stale" : "fallback",
+      refreshing: false,
+    });
+  }
+
+  const docs = peekDocs();
+  if (docs.length === 0 || indexStats().building) {
+    // Index warming up (or mid-rebuild): serve what we have and DON'T
+    // generate — chips written from a partially-filled store describe a
+    // user who barely codes. Kick the warm-up if nothing is running.
+    if (docs.length === 0) void ensureIndex().catch(() => {});
+    return Response.json({
+      suggestions: cache?.suggestions ?? (docs.length ? deterministicSuggestions(docs, Date.now()) : FALLBACK_SUGGESTIONS),
+      source: cache ? "llm-stale" : "fallback",
+      refreshing: true,
+    });
+  }
+
+  const deterministic = deterministicSuggestions(docs, Date.now());
+  if (!readSettings().ai_features.enabled) {
+    return Response.json({ suggestions: deterministic, source: "deterministic", refreshing: false });
+  }
+
+  const inputKey = suggestionInputKey(docs);
+  const cacheFresh =
+    cache !== null &&
+    cache.input_key === inputKey &&
+    Date.now() - Date.parse(cache.generated_at) < CACHE_TTL_MS;
+
+  if (cacheFresh) {
+    return Response.json({ suggestions: cache.suggestions, source: "llm", refreshing: false });
+  }
+
+  kickRefresh(buildSuggestionContext(docs, Date.now()), inputKey);
+  return Response.json({
+    // A stale LLM set still beats templates — it was written for this user.
+    suggestions: cache?.suggestions ?? deterministic,
+    source: cache ? "llm-stale" : "deterministic",
+    refreshing: latch.refreshing !== null,
+  });
+}