fleetlens 0.13.0 → 0.13.1

package/app/apps/web/app/api/digest/_shared/digest-route-helpers.ts

@@ -0,0 +1,178 @@
+import "server-only";
+import type {
+  DayDigest, MonthDigest, WeekDigest,
+} from "@claude-lens/entries";
+import type { PipelineEvent } from "@claude-lens/entries/node";
+import { InflightCoalescer } from "@/lib/inflight-coalesce";
+import {
+  type JobKind,
+  registerJob, updateJob, completeJob, failJob,
+} from "@/lib/jobs";
+
+type AnyDigest = DayDigest | WeekDigest | MonthDigest;
+
+// Shared coalescer instance for all digest periods. Per-period keys are
+// already prefixed (day|/week|/month|) so a single instance is equivalent
+// to the previous one-per-route setup.
+const coalescer = new InflightCoalescer<string, void>();
+
+export 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 } });
+  }
+}
+
+function jsonResponse(body: unknown, status: number): Response {
+  return new Response(JSON.stringify(body), {
+    status, headers: { "content-type": "application/json" },
+  });
+}
+
+// 400 without content-type header — preserves byte-equality for the routes
+// whose POST validation paths historically omitted it.
+function jsonResponseBare(body: unknown, status: number): Response {
+  return new Response(JSON.stringify(body), { status });
+}
+
+export type DigestGetSpec = {
+  // Parsed/validated key for cache reads. null = invalid input.
+  key: string | null;
+  // Validation error response when key is null.
+  invalidResponse: Response;
+  // True if the key represents a future date/period.
+  isFuture: boolean;
+  futureResponse: Response;
+  // True if the key represents the current (in-progress) period.
+  isCurrent: boolean;
+  // Lookup for the in-memory current-period cache (only consulted when isCurrent).
+  readCurrentCache: () => AnyDigest | null | undefined;
+  // Persisted-disk lookup (consulted for past periods, and as a fallback for
+  // current periods that have already been persisted — week uses this fallback,
+  // day and month do not).
+  readPersisted: () => AnyDigest | null | undefined;
+  // Payload shape for the "no cache yet" current-period response. Day uses
+  // {pending:true, today:true}; week and month use {pending:true, current:true}.
+  pendingCurrentPayload: Record<string, unknown>;
+  // True if the current-period branch should also fall back to readPersisted
+  // when the in-memory cache is empty. Week does this; day and month do not.
+  currentFallsBackToPersisted: boolean;
+};
+
+export function handleDigestGet(spec: DigestGetSpec): Response {
+  if (spec.key === null) return spec.invalidResponse;
+  if (spec.isFuture) return spec.futureResponse;
+
+  if (spec.isCurrent) {
+    const cached = spec.currentFallsBackToPersisted
+      ? (spec.readCurrentCache() ?? spec.readPersisted())
+      : spec.readCurrentCache();
+    if (cached) return jsonResponse(cached, 200);
+    return jsonResponse(spec.pendingCurrentPayload, 200);
+  }
+
+  const cached = spec.readPersisted();
+  if (cached) return jsonResponse(cached, 200);
+  return jsonResponse({ pending: true }, 200);
+}
+
+export type DigestPostSpec = {
+  // Parsed/validated key — feeds cache key, job target, resultUrl. null = invalid.
+  key: string | null;
+  invalidResponse: Response;
+  isFuture: boolean;
+  futureResponse: Response;
+  // Coalescer key prefix: "day" / "week" / "month".
+  coalesceScope: string;
+  // ?force=1
+  force: boolean;
+  // Job-tracking fields.
+  jobKind: JobKind;
+  jobLabel: string;
+  // resultUrl for completeJob.
+  resultUrl: string;
+  // Pre-bound pipeline factory — the helper never sees the per-period option shape.
+  runPipeline: () => AsyncIterable<PipelineEvent>;
+  // Fallback to deliver a final digest to a request that coalesced onto an
+  // in-flight run. Returns the digest if available, else null/undefined.
+  readDigestForCoalescedRequest: () => AnyDigest | null | undefined;
+};
+
+export function handleDigestPost(spec: DigestPostSpec): Response {
+  if (spec.key === null) return spec.invalidResponse;
+  if (spec.isFuture) return spec.futureResponse;
+
+  const coalesceKey = `${spec.coalesceScope}|${spec.key}|${spec.force ? 1 : 0}`;
+  const encoder = new TextEncoder();
+
+  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 { /* already */ }
+          closed = true;
+        }
+      }
+
+      const alreadyInflight = coalescer.inflight(coalesceKey);
+      let jobId: string | null = null;
+
+      try {
+        await coalescer.run(coalesceKey, async () => {
+          if (alreadyInflight) return;
+          jobId = registerJob({
+            kind: spec.jobKind,
+            label: spec.jobLabel,
+            target: spec.key as string,
+            caller: "user",
+          });
+          updateJob(jobId, { status: "running" });
+          for await (const ev of spec.runPipeline()) {
+            send(ev);
+            if (jobId) updateJobFromEvent(jobId, ev);
+          }
+          if (jobId) completeJob(jobId, spec.resultUrl);
+        });
+
+        if (alreadyInflight) {
+          const d = spec.readDigestForCoalescedRequest();
+          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",
+    },
+  });
+}
+
+// Re-export so route files can build their own validation responses without
+// duplicating the JSON-body Response idiom.
+export { jsonResponse, jsonResponseBare };

package/app/apps/web/app/api/digest/day/[date]/route.ts

@@ -1,152 +1,58 @@
 import {
   runDayDigestPipeline, readSettings, getTodayDigestFromCache,
 } from "@claude-lens/entries/node";
-import type { PipelineEvent } from "@claude-lens/entries/node";
 import { readDayDigest } from "@claude-lens/entries/fs";
-import { InflightCoalescer } from "@/lib/inflight-coalesce";
 import { isValidDate, 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<{ date: string }> };
 
-// Keyed by `${date}|${force ? 1 : 0}` — force=1 requests never coalesce
-// with force=0 (different key), matching spec §S2.
-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 { date } = await ctx.params;
-  if (!isValidDate(date)) {
-    return new Response(JSON.stringify({ error: "invalid date" }), {
-      status: 400, headers: { "content-type": "application/json" },
-    });
-  }
-  if (date > todayLocal()) {
-    return new Response(JSON.stringify({ error: "future date" }), {
-      status: 400, headers: { "content-type": "application/json" },
-    });
-  }
-
-  if (date === todayLocal()) {
-    const cached = getTodayDigestFromCache(date, Date.now());
-    if (cached) {
-      return new Response(JSON.stringify(cached), {
-        status: 200, headers: { "content-type": "application/json" },
-      });
-    }
-    return new Response(JSON.stringify({ pending: true, today: true }), {
-      status: 200, headers: { "content-type": "application/json" },
-    });
-  }
-
-  const cached = readDayDigest(date);
-  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 = isValidDate(date);
+  const isFuture = valid && date > todayLocal();
+  return handleDigestGet({
+    key: valid ? date : null,
+    invalidResponse: jsonResponse({ error: "invalid date" }, 400),
+    isFuture,
+    futureResponse: jsonResponse({ error: "future date" }, 400),
+    isCurrent: valid && date === todayLocal(),
+    readCurrentCache: () => getTodayDigestFromCache(date, Date.now()),
+    readPersisted: () => readDayDigest(date),
+    pendingCurrentPayload: { pending: true, today: true },
+    currentFallsBackToPersisted: false,
   });
 }
 
 export async function POST(req: Request, ctx: Params) {
   const { date } = await ctx.params;
-  if (!isValidDate(date)) {
-    return new Response(JSON.stringify({ error: "invalid date" }), { status: 400 });
-  }
-  if (date > todayLocal()) {
-    return new Response(JSON.stringify({ error: "future date" }), { status: 400 });
-  }
-
+  const valid = isValidDate(date);
+  const isFuture = valid && date > todayLocal();
   const url = new URL(req.url);
   const force = url.searchParams.get("force") === "1";
-  const key = `day|${date}|${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 { /* already */ }
-          closed = true;
-        }
-      }
-
-      const alreadyInflight = coalescer.inflight(key);
-      let jobId: string | null = null;
-
-      try {
-        await coalescer.run(key, async () => {
-          if (alreadyInflight) return;
-          jobId = registerJob({
-            kind: "digest.day",
-            label: `Day digest · ${date}`,
-            target: date,
-            caller: "user",
-          });
-          updateJob(jobId, { status: "running" });
-          for await (const ev of runDayDigestPipeline(date, {
-            settings: settings.ai_features,
-            force,
-            todayLocalDay: todayLocal(),
-          })) {
-            send(ev);
-            if (jobId) updateJobFromEvent(jobId, ev);
-          }
-          if (jobId) completeJob(jobId, `/day/${date}`);
-        });
-
-        if (alreadyInflight) {
-          const d = readDayDigest(date) ?? getTodayDigestFromCache(date, 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 ? date : null,
+    invalidResponse: jsonResponseBare({ error: "invalid date" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future date" }, 400),
+    coalesceScope: "day",
+    force,
+    jobKind: "digest.day",
+    jobLabel: `Day digest · ${date}`,
+    resultUrl: `/day/${date}`,
+    runPipeline: () => runDayDigestPipeline(date, {
+      settings: settings.ai_features,
+      force,
+      todayLocalDay: todayLocal(),
+    }),
+    readDigestForCoalescedRequest: () =>
+      readDayDigest(date) ?? getTodayDigestFromCache(date, Date.now()),
   });
 }

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()),
   });
 }