fleetlens 0.4.0 → 0.6.0

package/app/apps/web/app/api/digest/month-index/route.ts

@@ -0,0 +1,103 @@
+import { calendarMonth, priorCalendarMonth } from "@claude-lens/parser";
+import { listEntryKeys, listMonthDigestKeys, readMonthDigest } from "@claude-lens/entries/fs";
+import { parseEntryKey } from "@claude-lens/entries";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+type MonthRow = {
+  year: number;
+  month: number;
+  start: string;
+  end: string;
+  label: string;
+  active_days: number;
+  in_progress: boolean;
+  saved_key: string | null;
+  headline: string | null;
+  shipped_count: number;
+  agent_min: number;
+};
+
+function isoDay(d: Date): string {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+function yearMonthKey(start: Date): string {
+  const y = start.getFullYear();
+  const m = String(start.getMonth() + 1).padStart(2, "0");
+  return `${y}-${m}`;
+}
+
+function label(start: Date): string {
+  return start.toLocaleDateString("en-US", { month: "long", year: "numeric" });
+}
+
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const count = Math.min(12, Math.max(1, parseInt(url.searchParams.get("count") ?? "6", 10)));
+
+  const cachedKeys = new Set(listMonthDigestKeys());
+
+  const entryDays = new Set<string>();
+  for (const key of listEntryKeys()) {
+    const parsed = parseEntryKey(key);
+    if (parsed) entryDays.add(parsed.local_day);
+  }
+
+  const current = calendarMonth();
+  const prior = priorCalendarMonth();
+
+  const months: MonthRow[] = [];
+  for (let i = 0; i < count; i++) {
+    let start: Date, end: Date, in_progress: boolean;
+    if (i === 0) {
+      start = current.start; end = current.end; in_progress = true;
+    } else {
+      const refMonth = new Date(prior.start);
+      refMonth.setMonth(refMonth.getMonth() - (i - 1));
+      start = new Date(refMonth.getFullYear(), refMonth.getMonth(), 1);
+      end = new Date(refMonth.getFullYear(), refMonth.getMonth() + 1, 0);
+      in_progress = false;
+    }
+    let active_days = 0;
+    const cursor = new Date(start);
+    while (cursor.getTime() <= end.getTime()) {
+      if (entryDays.has(isoDay(cursor))) active_days++;
+      cursor.setDate(cursor.getDate() + 1);
+    }
+    const ymKey = yearMonthKey(start);
+    const savedKey = cachedKeys.has(ymKey) ? `month-${ymKey}` : null;
+
+    let headline: string | null = null;
+    let shipped_count = 0;
+    let agent_min = 0;
+    if (savedKey) {
+      const digest = readMonthDigest(ymKey);
+      if (digest) {
+        headline = digest.headline;
+        shipped_count = digest.shipped.length;
+        agent_min = Math.round(digest.agent_min_total);
+      }
+    }
+
+    months.push({
+      year: start.getFullYear(),
+      month: start.getMonth() + 1,
+      start: isoDay(start),
+      end: isoDay(end),
+      label: label(start),
+      active_days,
+      in_progress,
+      saved_key: savedKey,
+      headline,
+      shipped_count,
+      agent_min,
+    });
+  }
+
+  return Response.json({ months });
+}

package/app/apps/web/app/api/digest/week/[startDate]/route.ts

@@ -0,0 +1,149 @@
+import {
+  runWeekDigestPipeline, readSettings,
+  readWeekDigest, getCurrentWeekDigestFromCache,
+} from "@claude-lens/entries/node";
+import type { PipelineEvent } from "@claude-lens/entries/node";
+import { InflightCoalescer } from "@/lib/inflight-coalesce";
+import { asMonday, currentWeekMonday, todayLocal } from "@/lib/entries";
+import { registerJob, updateJob, completeJob, failJob } from "@/lib/jobs";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ startDate: string }> };
+
+const coalescer = new InflightCoalescer<string, void>();
+
+function updateJobFromEvent(jobId: string, ev: PipelineEvent): void {
+  if (ev.type === "status") {
+    updateJob(jobId, { progress: { phase: ev.phase, text: ev.text } });
+  } else if (ev.type === "entry") {
+    updateJob(jobId, { progress: { phase: "enrich", index: ev.index, total: ev.total } });
+  } else if (ev.type === "progress") {
+    updateJob(jobId, { progress: { phase: ev.phase, bytes: ev.bytes } });
+  }
+}
+
+export async function GET(_req: Request, ctx: Params) {
+  const { startDate } = await ctx.params;
+  const monday = asMonday(startDate);
+  if (!monday) {
+    return new Response(JSON.stringify({ error: "invalid Monday date" }), {
+      status: 400, headers: { "content-type": "application/json" },
+    });
+  }
+  const today = todayLocal();
+  if (monday > today) {
+    return new Response(JSON.stringify({ error: "future date" }), { status: 400 });
+  }
+
+  const isCurrent = monday === currentWeekMonday();
+  if (isCurrent) {
+    const cached = getCurrentWeekDigestFromCache(monday, Date.now());
+    if (cached) {
+      return new Response(JSON.stringify(cached), {
+        status: 200, headers: { "content-type": "application/json" },
+      });
+    }
+    return new Response(JSON.stringify({ pending: true, current: true }), {
+      status: 200, headers: { "content-type": "application/json" },
+    });
+  }
+
+  const cached = readWeekDigest(monday);
+  if (cached) {
+    return new Response(JSON.stringify(cached), {
+      status: 200, headers: { "content-type": "application/json" },
+    });
+  }
+  return new Response(JSON.stringify({ pending: true }), {
+    status: 200, headers: { "content-type": "application/json" },
+  });
+}
+
+export async function POST(req: Request, ctx: Params) {
+  const { startDate } = await ctx.params;
+  const monday = asMonday(startDate);
+  if (!monday) {
+    return new Response(JSON.stringify({ error: "invalid Monday date" }), { status: 400 });
+  }
+  if (monday > todayLocal()) {
+    return new Response(JSON.stringify({ error: "future date" }), { status: 400 });
+  }
+
+  const url = new URL(req.url);
+  const force = url.searchParams.get("force") === "1";
+  const key = `week|${monday}|${force ? 1 : 0}`;
+
+  const encoder = new TextEncoder();
+  const settings = readSettings();
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      let closed = false;
+      function send(event: PipelineEvent) {
+        if (closed) return;
+        try {
+          controller.enqueue(
+            encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`),
+          );
+        } catch {
+          closed = true;
+        }
+      }
+      function finish() {
+        if (!closed) {
+          try { controller.close(); } catch { /* ignore */ }
+          closed = true;
+        }
+      }
+
+      const alreadyInflight = coalescer.inflight(key);
+      let jobId: string | null = null;
+
+      try {
+        await coalescer.run(key, async () => {
+          if (alreadyInflight) return;
+          jobId = registerJob({
+            kind: "weekly.synth",
+            label: `Week digest · ${monday}`,
+            target: monday,
+            caller: "user",
+          });
+          updateJob(jobId, { status: "running" });
+          for await (const ev of runWeekDigestPipeline(monday, {
+            settings: settings.ai_features,
+            force,
+            currentWeekMonday: currentWeekMonday(),
+            todayLocalDay: todayLocal(),
+          })) {
+            send(ev);
+            if (jobId) updateJobFromEvent(jobId, ev);
+          }
+          if (jobId) completeJob(jobId, `/insights/week-${monday}`);
+        });
+
+        if (alreadyInflight) {
+          const d = readWeekDigest(monday) ?? getCurrentWeekDigestFromCache(monday, Date.now());
+          if (d) send({ type: "digest", digest: d });
+          send({ type: "status", phase: "persist", text: "coalesced with in-flight request" });
+        }
+      } catch (err) {
+        send({ type: "error", message: (err as Error).message });
+        if (jobId) failJob(jobId, (err as Error).message);
+      } finally {
+        try { controller.enqueue(encoder.encode(`event: done\ndata: {}\n\n`)); } catch { /* ignore */ }
+        finish();
+      }
+    },
+  });
+
+  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/{insights/weeks-index → digest/week-index}/route.ts

@@ -1,31 +1,24 @@
-/**
- * Weeks index — drives the week picker in /insights.
- *
- * Returns the last N calendar weeks (Mon-Sun, newest first) with:
- *   - isoweek + period label
- *   - session count observed in that window (raw SessionMeta filter)
- *   - in_progress flag for this week
- *   - saved_key when a report exists on disk
- *   - archetype_label + sessions_used from the saved report, for display
- */
-import { listSessions } from "@claude-lens/parser/fs";
 import { calendarWeek, priorCalendarWeek } from "@claude-lens/parser";
-import { listSavedReports, type SavedReportMeta } from "@/lib/ai/saved-reports";
+import { listEntryKeys, listWeekDigestKeys, readWeekDigest } from "@claude-lens/entries/fs";
+import { parseEntryKey } from "@claude-lens/entries";
 
 export const dynamic = "force-dynamic";
 export const runtime = "nodejs";
 
 type WeekRow = {
   iso_week: number;
-  start: string;       // "2026-04-13"
+  start: string;
   end: string;
-  label: string;       // "Apr 13 – Apr 19"
-  sessions: number;
+  label: string;
+  /** Distinct local-days with at least one entry in this window.
+   *  More accurate than session-firstTimestamp counts: a session that crosses
+   *  midnight produces entries on both sides and counts in both periods. */
+  active_days: number;
   in_progress: boolean;
   saved_key: string | null;
-  archetype_label?: string;
-  sessions_used?: number;
-  prs?: number;
+  headline: string | null;
+  shipped_count: number;
+  agent_min: number;
 };
 
 function isoDay(d: Date): string {
@@ -51,8 +44,15 @@ export async function GET(req: Request) {
   const url = new URL(req.url);
   const count = Math.min(26, Math.max(1, parseInt(url.searchParams.get("count") ?? "12", 10)));
 
-  const [metas, saved] = await Promise.all([listSessions({ limit: 10000 }), listSavedReports()]);
-  const savedByKey = new Map<string, SavedReportMeta>(saved.map((s) => [s.key, s]));
+  const cachedKeys = new Set(listWeekDigestKeys());
+
+  // Bucket entry keys by local_day once so each window can sum in O(window_days)
+  // rather than re-scanning all entries.
+  const entryDays = new Set<string>();
+  for (const key of listEntryKeys()) {
+    const parsed = parseEntryKey(key);
+    if (parsed) entryDays.add(parsed.local_day);
+  }
 
   const current = calendarWeek();
   const prior = priorCalendarWeek();
@@ -68,26 +68,38 @@ export async function GET(req: Request) {
       end = new Date(prior.end); end.setDate(prior.end.getDate() - offset);
       in_progress = false;
     }
-    const startMs = start.getTime();
-    const endMs = new Date(end).setHours(23, 59, 59, 999);
-    const sessions = metas.filter((m) => {
-      if (!m.firstTimestamp) return false;
-      const t = Date.parse(m.firstTimestamp);
-      return !Number.isNaN(t) && t >= startMs && t <= endMs;
-    }).length;
+    let active_days = 0;
+    const cursor = new Date(start);
+    while (cursor.getTime() <= end.getTime()) {
+      if (entryDays.has(isoDay(cursor))) active_days++;
+      cursor.setDate(cursor.getDate() + 1);
+    }
     const startKey = isoDay(start);
-    const savedMeta = savedByKey.get(`week-${startKey}`);
+    const savedKey = cachedKeys.has(startKey) ? `week-${startKey}` : null;
+
+    let headline: string | null = null;
+    let shipped_count = 0;
+    let agent_min = 0;
+    if (savedKey) {
+      const digest = readWeekDigest(startKey);
+      if (digest) {
+        headline = digest.headline;
+        shipped_count = digest.shipped.length;
+        agent_min = Math.round(digest.agent_min_total);
+      }
+    }
+
     weeks.push({
       iso_week: isoWeekNo(start),
       start: startKey,
       end: isoDay(end),
       label: label(start, end),
-      sessions,
+      active_days,
       in_progress,
-      saved_key: savedMeta ? savedMeta.key : null,
-      archetype_label: savedMeta?.archetype_label,
-      sessions_used: savedMeta?.sessions_used,
-      prs: savedMeta?.prs,
+      saved_key: savedKey,
+      headline,
+      shipped_count,
+      agent_min,
     });
   }
 

package/app/apps/web/app/api/jobs/route.ts

@@ -0,0 +1,8 @@
+import { listRecentJobs } from "@/lib/jobs";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  const jobs = listRecentJobs(30);
+  return Response.json({ jobs });
+}

package/app/apps/web/app/api/runs/[runId]/route.ts

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const RUNS_DIR = join(homedir(), ".cclens", "llm-runs");
+
+/**
+ * GET /api/runs/<runId>           dump the full event trace
+ * GET /api/runs/latest            shorthand: most recent trace
+ * GET /api/runs/<prefix>          unique-prefix match if no exact runId match
+ */
+export async function GET(_req: Request, ctx: { params: Promise<{ runId: string }> }): Promise<Response> {
+  const { runId } = await ctx.params;
+  if (!existsSync(RUNS_DIR)) {
+    return new Response(JSON.stringify({ error: "no traces" }), { status: 404, headers: { "content-type": "application/json" } });
+  }
+
+  let path: string | null = null;
+  let resolvedId = runId;
+
+  if (runId === "latest") {
+    const all = readdirSync(RUNS_DIR)
+      .filter(f => f.endsWith(".jsonl"))
+      .map(f => ({ id: f.replace(/\.jsonl$/, ""), path: join(RUNS_DIR, f), mtime: statSync(join(RUNS_DIR, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime);
+    if (all.length === 0) {
+      return new Response(JSON.stringify({ error: "no traces" }), { status: 404, headers: { "content-type": "application/json" } });
+    }
+    path = all[0]!.path;
+    resolvedId = all[0]!.id;
+  } else {
+    const exact = join(RUNS_DIR, `${runId}.jsonl`);
+    if (existsSync(exact)) {
+      path = exact;
+    } else {
+      const matches = readdirSync(RUNS_DIR)
+        .filter(f => f.endsWith(".jsonl") && f.includes(runId))
+        .map(f => f.replace(/\.jsonl$/, ""));
+      if (matches.length === 1) {
+        path = join(RUNS_DIR, `${matches[0]}.jsonl`);
+        resolvedId = matches[0]!;
+      } else if (matches.length > 1) {
+        return new Response(JSON.stringify({ error: "ambiguous", matches }), { status: 400, headers: { "content-type": "application/json" } });
+      }
+    }
+  }
+
+  if (!path) {
+    return new Response(JSON.stringify({ error: "not found", runId }), { status: 404, headers: { "content-type": "application/json" } });
+  }
+
+  const lines = readFileSync(path, "utf-8").split("\n").filter(l => l.trim());
+  const events: unknown[] = lines.map(l => {
+    try { return JSON.parse(l); } catch { return { _raw: l }; }
+  });
+
+  return new Response(JSON.stringify({ run_id: resolvedId, events }, null, 2), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}

package/app/apps/web/app/api/runs/[runId]/stream/route.ts

@@ -0,0 +1,154 @@
+import { existsSync, readdirSync, statSync, watch, openSync, readSync, closeSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const RUNS_DIR = join(homedir(), ".cclens", "llm-runs");
+
+/**
+ * GET /api/runs/<runId>/stream  → SSE tail of a per-run trace file
+ * GET /api/runs/latest/stream
+ * GET /api/runs/<prefix>/stream
+ *
+ * Emits one SSE message per JSONL line as the file grows, then closes when
+ * an end record (`_meta.type === "end"`) appears. Falls back to closing on
+ * 30s of inactivity if the writer dies.
+ */
+
+function resolvePath(runId: string): { path: string; resolvedId: string } | { error: string; status: number; matches?: string[] } {
+  if (!existsSync(RUNS_DIR)) return { error: "no traces", status: 404 };
+
+  if (runId === "latest") {
+    const all = readdirSync(RUNS_DIR)
+      .filter(f => f.endsWith(".jsonl"))
+      .map(f => ({ id: f.replace(/\.jsonl$/, ""), path: join(RUNS_DIR, f), mtime: statSync(join(RUNS_DIR, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime);
+    if (all.length === 0) return { error: "no traces", status: 404 };
+    return { path: all[0]!.path, resolvedId: all[0]!.id };
+  }
+
+  const exact = join(RUNS_DIR, `${runId}.jsonl`);
+  if (existsSync(exact)) return { path: exact, resolvedId: runId };
+
+  const matches = readdirSync(RUNS_DIR)
+    .filter(f => f.endsWith(".jsonl") && f.includes(runId))
+    .map(f => f.replace(/\.jsonl$/, ""));
+  if (matches.length === 1) {
+    return { path: join(RUNS_DIR, `${matches[0]}.jsonl`), resolvedId: matches[0]! };
+  }
+  if (matches.length > 1) return { error: "ambiguous", status: 400, matches };
+  return { error: "not found", status: 404 };
+}
+
+export async function GET(_req: Request, ctx: { params: Promise<{ runId: string }> }): Promise<Response> {
+  const { runId } = await ctx.params;
+  const r = resolvePath(runId);
+  if ("error" in r) {
+    return new Response(JSON.stringify({ error: r.error, ...("matches" in r ? { matches: r.matches } : {}) }), {
+      status: r.status, headers: { "content-type": "application/json" },
+    });
+  }
+  const { path, resolvedId } = r;
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    start(controller) {
+      let closed = false;
+      let buf = "";
+      let pos = 0;
+      let watcher: ReturnType<typeof watch> | null = null;
+      let idleTimer: NodeJS.Timeout | null = null;
+
+      const send = (event: string, data: unknown) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+        } catch {
+          closed = true;
+        }
+      };
+
+      const close = (reason: string) => {
+        if (closed) return;
+        send("done", { reason });
+        if (watcher) try { watcher.close(); } catch { /* ignore */ }
+        if (idleTimer) clearTimeout(idleTimer);
+        try { controller.close(); } catch { /* ignore */ }
+        closed = true;
+      };
+
+      const resetIdle = () => {
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => close("idle-30s"), 30_000);
+      };
+
+      // Drain any new bytes from `pos` to current EOF, parsing complete lines and
+      // streaming each as either a `meta` (for `_meta.*` records) or `event` SSE
+      // message. Anything past the last newline goes back into `buf`.
+      const drain = () => {
+        if (closed || !existsSync(path)) return;
+        const fd = openSync(path, "r");
+        try {
+          const stat = statSync(path);
+          const end = stat.size;
+          if (end <= pos) return;
+          const chunk = Buffer.alloc(end - pos);
+          readSync(fd, chunk, 0, chunk.length, pos);
+          pos = end;
+          buf += chunk.toString("utf-8");
+          let nl: number;
+          while ((nl = buf.indexOf("\n")) !== -1) {
+            const line = buf.slice(0, nl).trim();
+            buf = buf.slice(nl + 1);
+            if (!line) continue;
+            let parsed: unknown;
+            try { parsed = JSON.parse(line); } catch { send("raw", { line }); continue; }
+            const obj = parsed as { _meta?: { type?: string } };
+            if (obj._meta && obj._meta.type) {
+              send("meta", obj);
+              if (obj._meta.type === "end" || obj._meta.type === "spawn_error") {
+                close(obj._meta.type);
+                return;
+              }
+            } else {
+              send("event", obj);
+            }
+          }
+          resetIdle();
+        } finally {
+          closeSync(fd);
+        }
+      };
+
+      // Avoid SSE event names that collide with EventSource's built-in DOM
+      // events (`open`, `error`). The DOM event fires with no `data`, which
+      // crashes any client `JSON.parse(e.data)` listener.
+      send("connected", { run_id: resolvedId, path: path.replace(homedir(), "~") });
+      drain();
+      if (closed) return;
+
+      try {
+        watcher = watch(path, () => drain());
+      } catch (e) {
+        send("stream_error", { message: `watch failed: ${(e as Error).message}` });
+        close("watch-error");
+        return;
+      }
+      resetIdle();
+    },
+    cancel() {
+      // client disconnected; nothing to clean up on our side beyond the watcher
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}