fleetlens 0.13.0 → 0.13.2

package/app/apps/web/app/api/digest/month/[yearMonth]/route.ts

@@ -2,146 +2,61 @@ import {
   runMonthDigestPipeline, readSettings,
   readMonthDigest, getCurrentMonthDigestFromCache,
 } from "@claude-lens/entries/node";
-import type { PipelineEvent } from "@claude-lens/entries/node";
-import { InflightCoalescer } from "@/lib/inflight-coalesce";
 import {
   isValidYearMonth, currentYearMonth, currentWeekMonday, todayLocal,
 } from "@/lib/entries";
-import { registerJob, updateJob, completeJob, failJob } from "@/lib/jobs";
+import {
+  handleDigestGet, handleDigestPost, jsonResponse, jsonResponseBare,
+} from "../../_shared/digest-route-helpers";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
 type Params = { params: Promise<{ yearMonth: 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 { yearMonth } = await ctx.params;
-  if (!isValidYearMonth(yearMonth)) {
-    return new Response(JSON.stringify({ error: "invalid year-month" }), {
-      status: 400, headers: { "content-type": "application/json" },
-    });
-  }
-  if (yearMonth > currentYearMonth()) {
-    return new Response(JSON.stringify({ error: "future month" }), { status: 400 });
-  }
-
-  const isCurrent = yearMonth === currentYearMonth();
-  if (isCurrent) {
-    const cached = getCurrentMonthDigestFromCache(yearMonth, 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 = readMonthDigest(yearMonth);
-  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" },
+  const valid = isValidYearMonth(yearMonth);
+  const isFuture = valid && yearMonth > currentYearMonth();
+  return handleDigestGet({
+    key: valid ? yearMonth : null,
+    invalidResponse: jsonResponse({ error: "invalid year-month" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future month" }, 400),
+    isCurrent: valid && yearMonth === currentYearMonth(),
+    readCurrentCache: () => getCurrentMonthDigestFromCache(yearMonth, Date.now()),
+    readPersisted: () => readMonthDigest(yearMonth),
+    pendingCurrentPayload: { pending: true, current: true },
+    currentFallsBackToPersisted: false,
   });
 }
 
 export async function POST(req: Request, ctx: Params) {
   const { yearMonth } = await ctx.params;
-  if (!isValidYearMonth(yearMonth)) {
-    return new Response(JSON.stringify({ error: "invalid year-month" }), { status: 400 });
-  }
-  if (yearMonth > currentYearMonth()) {
-    return new Response(JSON.stringify({ error: "future month" }), { status: 400 });
-  }
-
+  const valid = isValidYearMonth(yearMonth);
+  const isFuture = valid && yearMonth > currentYearMonth();
   const url = new URL(req.url);
   const force = url.searchParams.get("force") === "1";
-  const key = `month|${yearMonth}|${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: "monthly.synth",
-            label: `Month digest · ${yearMonth}`,
-            target: yearMonth,
-            caller: "user",
-          });
-          updateJob(jobId, { status: "running" });
-          for await (const ev of runMonthDigestPipeline(yearMonth, {
-            settings: settings.ai_features,
-            force,
-            currentYearMonth: currentYearMonth(),
-            currentWeekMonday: currentWeekMonday(),
-            todayLocalDay: todayLocal(),
-          })) {
-            send(ev);
-            if (jobId) updateJobFromEvent(jobId, ev);
-          }
-          if (jobId) completeJob(jobId, `/insights/month-${yearMonth}`);
-        });
-
-        if (alreadyInflight) {
-          const d = readMonthDigest(yearMonth) ?? getCurrentMonthDigestFromCache(yearMonth, 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",
-    },
+  return handleDigestPost({
+    key: valid ? yearMonth : null,
+    invalidResponse: jsonResponseBare({ error: "invalid year-month" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future month" }, 400),
+    coalesceScope: "month",
+    force,
+    jobKind: "monthly.synth",
+    jobLabel: `Month digest · ${yearMonth}`,
+    resultUrl: `/insights/month-${yearMonth}`,
+    runPipeline: () => runMonthDigestPipeline(yearMonth, {
+      settings: settings.ai_features,
+      force,
+      currentYearMonth: currentYearMonth(),
+      currentWeekMonday: currentWeekMonday(),
+      todayLocalDay: todayLocal(),
+    }),
+    readDigestForCoalescedRequest: () =>
+      readMonthDigest(yearMonth) ?? getCurrentMonthDigestFromCache(yearMonth, Date.now()),
   });
 }

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

@@ -2,149 +2,62 @@ 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";
+import {
+  handleDigestGet, handleDigestPost, jsonResponse, jsonResponseBare,
+} from "../../_shared/digest-route-helpers";
 
 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()) ?? readWeekDigest(monday);
-    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" },
+  const isFuture = monday !== null && monday > today;
+  return handleDigestGet({
+    key: monday,
+    invalidResponse: jsonResponse({ error: "invalid Monday date" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future date" }, 400),
+    isCurrent: monday !== null && monday === currentWeekMonday(),
+    readCurrentCache: () =>
+      monday !== null ? getCurrentWeekDigestFromCache(monday, Date.now()) : null,
+    readPersisted: () => (monday !== null ? readWeekDigest(monday) : null),
+    pendingCurrentPayload: { pending: true, current: true },
+    currentFallsBackToPersisted: true,
   });
 }
 
 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 isFuture = monday !== null && monday > todayLocal();
   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",
-    },
+  return handleDigestPost({
+    key: monday,
+    invalidResponse: jsonResponseBare({ error: "invalid Monday date" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future date" }, 400),
+    coalesceScope: "week",
+    force,
+    jobKind: "weekly.synth",
+    jobLabel: `Week digest · ${monday}`,
+    resultUrl: `/insights/week-${monday}`,
+    runPipeline: () => runWeekDigestPipeline(monday as string, {
+      settings: settings.ai_features,
+      force,
+      currentWeekMonday: currentWeekMonday(),
+      todayLocalDay: todayLocal(),
+    }),
+    readDigestForCoalescedRequest: () =>
+      monday !== null
+        ? (readWeekDigest(monday) ?? getCurrentWeekDigestFromCache(monday, Date.now()))
+        : null,
   });
 }

package/app/apps/web/app/insights/page.tsx

@@ -1,6 +1,8 @@
 import Link from "next/link";
 import { readSettings, readWeekDigest, interactiveLockFresh } from "@claude-lens/entries/node";
-import { lastCompletedWeekMonday, currentWeekMonday, listEntriesForDay } from "@/lib/entries";
+import { listEntryKeys } from "@claude-lens/entries/fs";
+import { parseEntryKey } from "@claude-lens/entries";
+import { lastCompletedWeekMonday, currentWeekMonday } from "@/lib/entries";
 import { WeekDigestView } from "@/components/week-digest-view";
 import { InsightsTopBar } from "@/components/insights-top-bar";
 
@@ -24,9 +26,21 @@ function weekDates(monday: string): string[] {
   return out;
 }
 
-function hasAnyEntries(monday: string): boolean {
+// Build once from the entries dir, then test the 7 weekdays against it.
+// Earlier this called listEntriesForDay per day per render, which opened
+// and parsed every matching entry file 14× before deciding the week is empty.
+function presentDays(): Set<string> {
+  const out = new Set<string>();
+  for (const key of listEntryKeys()) {
+    const parsed = parseEntryKey(key);
+    if (parsed) out.add(parsed.local_day);
+  }
+  return out;
+}
+
+function hasAnyEntries(monday: string, present: Set<string>): boolean {
   for (const d of weekDates(monday)) {
-    if (listEntriesForDay(d).length > 0) return true;
+    if (present.has(d)) return true;
   }
   return false;
 }
@@ -45,7 +59,8 @@ export default async function InsightsPage() {
   const lastWeek = lastCompletedWeekMonday();
   const cached = readWeekDigest(lastWeek);
   const prior = readWeekDigest(priorMonday(lastWeek));
-  const hasData = !!cached || hasAnyEntries(lastWeek);
+  const present = presentDays();
+  const hasData = !!cached || hasAnyEntries(lastWeek, present);
 
   // Auto-fire when AI is on and the digest isn't already cached. The interactive
   // pipeline lock (heartbeat-refreshed) suppresses concurrent fires from the
@@ -58,7 +73,7 @@ export default async function InsightsPage() {
   const prevMonday = priorMonday(lastWeek);
   const currentMonday = currentWeekMonday();
   const nextMonday = currentMonday > lastWeek ? currentMonday : null;
-  const nextHasData = nextMonday ? hasAnyEntries(nextMonday) : false;
+  const nextHasData = nextMonday ? hasAnyEntries(nextMonday, present) : false;
 
   return (
     <div style={{ paddingBottom: 64 }}>