fleetlens 0.15.7 → 0.16.0

package/app/apps/web/components/sidebar.tsx

@@ -12,12 +12,10 @@ import {
   PinOff,
   Search,
   Activity,
-  Gauge,
   Lightbulb,
-  Radio,
   Settings,
   CalendarDays,
-  Users,
+  Sparkles,
 } from "lucide-react";
 import { formatRelative, prettyProjectName } from "@/lib/format";
 import { ThemeToggle } from "@/components/theme-toggle";
@@ -204,13 +202,6 @@ export function Sidebar({
         >
           Day
         </NavLink>
-        <NavLink
-          href="/usage"
-          active={pathname === "/usage"}
-          icon={<Gauge size={15} />}
-        >
-          Usage
-        </NavLink>
         <NavLink
           href="/insights"
           active={pathname === "/insights"}
@@ -218,19 +209,15 @@ export function Sidebar({
         >
           Insights
         </NavLink>
+        {/* Usage and Team live in the sidebar widgets below (both already
+            link to their pages); Runs is reachable from the Agent
+            header. Keeping the nav to the primary destinations. */}
         <NavLink
-          href="/runs"
-          active={pathname === "/runs" || pathname.startsWith("/runs/")}
-          icon={<Radio size={15} />}
-        >
-          Runs
-        </NavLink>
-        <NavLink
-          href="/team"
-          active={pathname === "/team" || pathname.startsWith("/team/")}
-          icon={<Users size={15} />}
+          href="/agent"
+          active={pathname === "/agent" || pathname === "/runs" || pathname.startsWith("/runs/")}
+          icon={<Sparkles size={15} />}
         >
-          Team
+          Agent
         </NavLink>
       </nav>
 

package/app/apps/web/lib/agent/chat-model.ts

@@ -0,0 +1,125 @@
+
+export type TextSegment = { kind: "text"; text: string };
+export type ToolSegment = {
+  kind: "tool";
+  id: string;
+  name: string;
+  input: unknown;
+  brief?: string;
+  isError?: boolean;
+  done: boolean;
+};
+export type Segment = TextSegment | ToolSegment;
+
+export type StoredMessage =
+  | { role: "user"; text: string }
+  | { role: "assistant"; segments: Segment[] };
+
+export type ChatStatus = "idle" | "running" | "error";
+
+export type Chat = {
+  version: 1;
+  id: string;
+  title: string;
+  created_at: string;
+  updated_at: string;
+  status: ChatStatus;
+  /** Highest run-event seq folded into this chat — SSE clients resume after it. */
+  lastSeq: number;
+  messages: StoredMessage[];
+};
+
+export type ChatListItem = {
+  id: string;
+  title: string;
+  updated_at: string;
+  status: ChatStatus;
+  messageCount: number;
+};
+
+/** Normalized event emitted by a run. seq is per-run, starting at 1. */
+export type RunEvent =
+  | { seq: number; type: "delta"; text: string }
+  | { seq: number; type: "tool"; id: string; name: string; input: unknown }
+  | { seq: number; type: "tool_result"; id: string; name: string; brief: string; isError: boolean }
+  | { seq: number; type: "done"; totalTokens?: number }
+  | { seq: number; type: "error"; message: string };
+
+/** Omit<union, K> collapses to the common keys; this distributes instead so
+ *  emit sites can pass any variant sans seq. */
+export type RunEventBody = RunEvent extends infer E ? (E extends RunEvent ? Omit<E, "seq"> : never) : never;
+
+const TITLE_MAX = 80;
+
+export function chatTitle(firstUserText: string): string {
+  return firstUserText.replace(/\s+/g, " ").trim().slice(0, TITLE_MAX);
+}
+
+export function createChat(): Chat {
+  const now = new Date().toISOString();
+  return {
+    version: 1,
+    id: crypto.randomUUID(),
+    title: "New conversation",
+    created_at: now,
+    updated_at: now,
+    status: "idle",
+    lastSeq: 0,
+    messages: [],
+  };
+}
+
+export function newAssistantMessage(): StoredMessage {
+  return { role: "assistant", segments: [] };
+}
+
+/** Fold one run event into the chat. Pure; the same reducer runs on the
+ *  server (persistence) and could run client-side, so restore and live
+ *  rendering can never drift apart. Events at or below lastSeq are replays
+ *  and ignored. */
+export function applyRunEvent(chat: Chat, event: RunEvent): Chat {
+  if (event.seq <= chat.lastSeq) return chat;
+  const messages = [...chat.messages];
+  let last = messages[messages.length - 1];
+  if (!last || last.role !== "assistant") {
+    last = newAssistantMessage();
+    messages.push(last);
+  }
+  const assistant = { ...last, segments: [...(last as { segments: Segment[] }).segments] } as Extract<
+    StoredMessage,
+    { role: "assistant" }
+  >;
+  messages[messages.length - 1] = assistant;
+
+  let status: ChatStatus = chat.status;
+  switch (event.type) {
+    case "delta": {
+      const tail = assistant.segments[assistant.segments.length - 1];
+      if (tail?.kind === "text") {
+        assistant.segments[assistant.segments.length - 1] = { kind: "text", text: tail.text + event.text };
+      } else {
+        assistant.segments.push({ kind: "text", text: event.text });
+      }
+      break;
+    }
+    case "tool":
+      assistant.segments.push({ kind: "tool", id: event.id, name: event.name, input: event.input, done: false });
+      break;
+    case "tool_result":
+      assistant.segments = assistant.segments.map((s) =>
+        s.kind === "tool" && s.id === event.id ? { ...s, brief: event.brief, isError: event.isError, done: true } : s,
+      );
+      break;
+    case "done":
+      status = "idle";
+      assistant.segments = assistant.segments.map((s) => (s.kind === "tool" && !s.done ? { ...s, done: true } : s));
+      break;
+    case "error":
+      status = "error";
+      assistant.segments = assistant.segments.map((s) => (s.kind === "tool" && !s.done ? { ...s, done: true } : s));
+      assistant.segments.push({ kind: "text", text: `\n\n**Error:** ${event.message}` });
+      break;
+  }
+
+  return { ...chat, messages, status, lastSeq: event.seq, updated_at: new Date().toISOString() };
+}

package/app/apps/web/lib/agent/chat-store.test.ts

@@ -0,0 +1,125 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  applyRunEvent,
+  chatTitle,
+  createChat,
+  deleteChat,
+  listChats,
+  newAssistantMessage,
+  readChat,
+  writeChat,
+  type Chat,
+  type RunEvent,
+  type RunEventBody,
+} from "./chat-store";
+
+let dir: string;
+let prevHome: string | undefined;
+
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), "cclens-chat-test-"));
+  prevHome = process.env.CCLENS_HOME;
+  process.env.CCLENS_HOME = dir;
+});
+
+afterAll(() => {
+  if (prevHome === undefined) delete process.env.CCLENS_HOME;
+  else process.env.CCLENS_HOME = prevHome;
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function running(): Chat {
+  const chat = createChat();
+  chat.messages.push({ role: "user", text: "find my daemon work" });
+  chat.messages.push(newAssistantMessage());
+  chat.status = "running";
+  return chat;
+}
+
+const ev = (e: RunEventBody, seq = 1): RunEvent => ({ seq, ...e }) as RunEvent;
+
+describe("applyRunEvent", () => {
+  test("delta appends to the trailing text segment, creating one if needed", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "Hello" }));
+    chat = applyRunEvent(chat, ev({ type: "delta", text: " world" }, 2));
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role).toBe("assistant");
+    expect(last.role === "assistant" && last.segments).toEqual([{ kind: "text", text: "Hello world" }]);
+  });
+
+  test("tool events add tool segments; results resolve them by id", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "Searching. " }));
+    chat = applyRunEvent(chat, ev({ type: "tool", id: "t1", name: "search_sessions", input: { query: "x" } }, 2));
+    chat = applyRunEvent(chat, ev({ type: "tool_result", id: "t1", name: "search_sessions", brief: "3 matching sessions", isError: false }, 3));
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "Found it." }, 4));
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role === "assistant" && last.segments).toEqual([
+      { kind: "text", text: "Searching. " },
+      { kind: "tool", id: "t1", name: "search_sessions", input: { query: "x" }, brief: "3 matching sessions", isError: false, done: true },
+      { kind: "text", text: "Found it." },
+    ]);
+  });
+
+  test("done marks the chat idle and finalizes dangling tools", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "tool", id: "t1", name: "get_session", input: {} }));
+    chat = applyRunEvent(chat, ev({ type: "done", totalTokens: 123 }, 2));
+    expect(chat.status).toBe("idle");
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role === "assistant" && last.segments[0]).toMatchObject({ kind: "tool", done: true });
+    expect(chat.lastSeq).toBe(2);
+  });
+
+  test("error appends an error text segment and marks the chat error", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "error", message: "timed out" }));
+    expect(chat.status).toBe("error");
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role === "assistant" && last.segments.some((s) => s.kind === "text" && s.text.includes("timed out"))).toBe(true);
+  });
+
+  test("stale events (seq <= lastSeq) are ignored", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "a" }, 5));
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "b" }, 5));
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role === "assistant" && last.segments).toEqual([{ kind: "text", text: "a" }]);
+  });
+});
+
+describe("chatTitle", () => {
+  test("derives from the first user message, collapsed and clamped", () => {
+    expect(chatTitle("  find   my\ndaemon work  ")).toBe("find my daemon work");
+    expect(chatTitle("x".repeat(200)).length).toBeLessThanOrEqual(80);
+  });
+});
+
+describe("fs round-trip", () => {
+  test("create, write, read, list, delete", () => {
+    const a = createChat();
+    a.messages.push({ role: "user", text: "first chat" });
+    a.title = chatTitle("first chat");
+    writeChat(a);
+    const b = createChat();
+    b.messages.push({ role: "user", text: "second chat" });
+    b.title = chatTitle("second chat");
+    b.updated_at = new Date(Date.now() + 1000).toISOString();
+    writeChat(b);
+
+    expect(readChat(a.id)?.messages[0]).toEqual({ role: "user", text: "first chat" });
+    expect(readChat("nope")).toBeNull();
+
+    const listed = listChats();
+    expect(listed.map((c) => c.id)).toEqual([b.id, a.id]); // newest first
+    expect(listed[0]).toMatchObject({ title: "second chat", status: "idle", messageCount: 1 });
+
+    deleteChat(a.id);
+    expect(readChat(a.id)).toBeNull();
+    expect(listChats().map((c) => c.id)).toEqual([b.id]);
+  });
+});

package/app/apps/web/lib/agent/chat-store.ts

@@ -0,0 +1,59 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { cclensPath } from "@claude-lens/parser/fs";
+import type { Chat, ChatListItem } from "./chat-model";
+
+export * from "./chat-model";
+
+/* ── persistence: one JSON file per conversation ───────────────────── */
+
+function chatsDir(): string {
+  return cclensPath("agent-chats");
+}
+
+function chatPath(id: string): string {
+  return join(chatsDir(), `${id}.json`);
+}
+
+export function writeChat(chat: Chat): void {
+  mkdirSync(chatsDir(), { recursive: true });
+  const final = chatPath(chat.id);
+  const tmp = `${final}.tmp.${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(chat), "utf8");
+  renameSync(tmp, final);
+}
+
+export function readChat(id: string): Chat | null {
+  // Ids come from URLs — resolve strictly inside the chats dir.
+  if (!/^[a-zA-Z0-9-]+$/.test(id)) return null;
+  try {
+    const chat = JSON.parse(readFileSync(chatPath(id), "utf8")) as Chat;
+    return chat.version === 1 ? chat : null;
+  } catch {
+    return null;
+  }
+}
+
+export function listChats(): ChatListItem[] {
+  if (!existsSync(chatsDir())) return [];
+  const out: ChatListItem[] = [];
+  for (const f of readdirSync(chatsDir())) {
+    if (!f.endsWith(".json")) continue;
+    const chat = readChat(f.slice(0, -".json".length));
+    if (!chat) continue;
+    out.push({
+      id: chat.id,
+      title: chat.title,
+      updated_at: chat.updated_at,
+      status: chat.status,
+      messageCount: chat.messages.length,
+    });
+  }
+  out.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+  return out;
+}
+
+export function deleteChat(id: string): void {
+  if (!/^[a-zA-Z0-9-]+$/.test(id)) return;
+  rmSync(chatPath(id), { force: true });
+}

package/app/apps/web/lib/agent/extract.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "vitest";
+import type { SessionDetail, SessionEvent } from "@claude-lens/parser";
+import { extractIndexDoc } from "./extract";
+
+function ev(partial: Partial<SessionEvent> & { role: SessionEvent["role"] }): SessionEvent {
+  return {
+    index: 0,
+    rawType: partial.role,
+    preview: "",
+    blocks: [],
+    raw: null,
+    ...partial,
+  };
+}
+
+function session(events: SessionEvent[], meta: Partial<SessionDetail> = {}): SessionDetail {
+  return {
+    id: "abc-123",
+    filePath: "/tmp/abc-123.jsonl",
+    projectName: "/Users/me/Repo/foo",
+    projectDir: "-Users-me-Repo-foo",
+    sessionId: "abc-123",
+    eventCount: events.length,
+    totalUsage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    status: "idle",
+    firstTimestamp: "2026-07-01T10:00:00.000Z",
+    lastTimestamp: "2026-07-01T11:00:00.000Z",
+    events,
+    ...meta,
+  } as SessionDetail;
+}
+
+const FILE = { mtimeMs: 1000, sizeBytes: 2000 };
+
+describe("extractIndexDoc", () => {
+  test("extracts user and agent text blocks as chunks", () => {
+    const doc = extractIndexDoc(
+      session([
+        ev({ index: 0, role: "user", blocks: [{ type: "text", text: "fix the daemon crash" }] }),
+        ev({ index: 1, role: "agent", blocks: [{ type: "text", text: "Found the crash in pid.ts" }] }),
+        ev({ index: 2, role: "tool-call", blocks: [{ type: "tool_use", id: "t1", name: "Bash", input: { command: "ls secret" } }] }),
+        ev({ index: 3, role: "agent-thinking", blocks: [{ type: "thinking", thinking: "hmm private" }] }),
+      ]),
+      FILE,
+    );
+    expect(doc.chunks).toEqual([
+      { role: "user", text: "fix the daemon crash", idx: 0 },
+      { role: "agent", text: "Found the crash in pid.ts", idx: 1 },
+    ]);
+  });
+
+  test("fills metadata: canonical project, start day, title, agent default", () => {
+    const doc = extractIndexDoc(
+      session(
+        [ev({ index: 0, role: "user", blocks: [{ type: "text", text: "hello world" }] })],
+        { projectName: "/Users/me/Repo/foo/.worktrees/kip-1", firstUserPreview: "hello world" },
+      ),
+      FILE,
+    );
+    expect(doc.sessionId).toBe("abc-123");
+    expect(doc.agent).toBe("claude-code");
+    expect(doc.project).toBe("/Users/me/Repo/foo");
+    expect(doc.repoName).toBeUndefined();
+    expect(doc.day).toBe("2026-07-01");
+    expect(doc.title).toBe("hello world");
+    expect(doc.mtimeMs).toBe(1000);
+    expect(doc.sizeBytes).toBe(2000);
+  });
+
+  test("skips command wrappers, skill loads, and teammate deliveries", () => {
+    const doc = extractIndexDoc(
+      session([
+        ev({ index: 0, role: "user", blocks: [{ type: "text", text: "<command-name>/clear</command-name>" }] }),
+        ev({ index: 1, role: "user", blocks: [{ type: "text", text: "Base directory for this skill: /x\n# Skill" }] }),
+        ev({
+          index: 2,
+          role: "user",
+          blocks: [{ type: "text", text: "ignore me" }],
+          teammateMessage: { teammateId: "t", body: "ignore me", kind: "message" },
+        }),
+        ev({ index: 3, role: "user", blocks: [{ type: "text", text: "real question" }] }),
+      ]),
+      FILE,
+    );
+    expect(doc.chunks).toEqual([{ role: "user", text: "real question", idx: 3 }]);
+  });
+
+  test("strips system-reminder spans inside user text", () => {
+    const doc = extractIndexDoc(
+      session([
+        ev({
+          index: 0,
+          role: "user",
+          blocks: [{ type: "text", text: "before <system-reminder>injected</system-reminder> after" }],
+        }),
+      ]),
+      FILE,
+    );
+    expect(doc.chunks[0]!.text).toBe("before  after");
+  });
+
+  test("caps chunk length and total text, marking truncation", () => {
+    const long = "x".repeat(10_000);
+    const events: SessionEvent[] = [];
+    for (let i = 0; i < 200; i++) {
+      events.push(ev({ index: i, role: "agent", blocks: [{ type: "text", text: long }] }));
+    }
+    const doc = extractIndexDoc(session(events), FILE);
+    expect(Math.max(...doc.chunks.map((c) => c.text.length))).toBeLessThanOrEqual(4000);
+    const total = doc.chunks.reduce((s, c) => s + c.text.length, 0);
+    expect(total).toBeLessThanOrEqual(300_000);
+    expect(doc.truncated).toBe(true);
+  });
+
+  test("drops empty and whitespace-only text", () => {
+    const doc = extractIndexDoc(
+      session([
+        ev({ index: 0, role: "user", blocks: [{ type: "text", text: "  " }] }),
+        ev({ index: 1, role: "agent", blocks: [{ type: "text", text: "" }] }),
+      ]),
+      FILE,
+    );
+    expect(doc.chunks).toEqual([]);
+  });
+
+  test("carries the git repo name when the session has one", () => {
+    const doc = extractIndexDoc(
+      session([ev({ index: 0, role: "user", blocks: [{ type: "text", text: "hi" }] })], { repoName: "fleetlens" }),
+      FILE,
+    );
+    expect(doc.repoName).toBe("fleetlens");
+  });
+
+  test("title falls back to first user chunk when firstUserPreview is absent", () => {
+    const doc = extractIndexDoc(
+      session([ev({ index: 0, role: "user", blocks: [{ type: "text", text: "the actual ask" }] })]),
+      FILE,
+    );
+    expect(doc.title).toBe("the actual ask");
+  });
+});

package/app/apps/web/lib/agent/extract.ts

@@ -0,0 +1,75 @@
+import { canonicalProjectName, toLocalDay, type SessionDetail } from "@claude-lens/parser";
+import { INDEX_VERSION, type IndexChunk, type IndexDoc } from "./types";
+
+const CHUNK_MAX = 4000;
+const DOC_TEXT_MAX = 300_000;
+const TITLE_MAX = 120;
+
+/** Harness-injected user events that aren't real human input. */
+const SKIP_PREFIXES = [
+  "<command-name>",
+  "<local-command",
+  "Base directory for this skill:",
+  "<task-notification>",
+  "[SYSTEM NOTIFICATION",
+  "Caveat: the messages below",
+];
+
+function cleanText(text: string): string {
+  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trimEnd();
+}
+
+/** Tool calls, tool results, and thinking are deliberately excluded —
+ *  search should find what was said, not every file path a tool printed. */
+export function extractIndexDoc(
+  session: SessionDetail,
+  file: { mtimeMs: number; sizeBytes: number },
+): IndexDoc {
+  const chunks: IndexChunk[] = [];
+  let totalChars = 0;
+  let truncated = false;
+
+  for (const e of session.events) {
+    if (e.role !== "user" && e.role !== "agent") continue;
+    if (e.role === "user" && e.teammateMessage) continue;
+    for (const b of e.blocks) {
+      if (b.type !== "text" || typeof b.text !== "string") continue;
+      if (SKIP_PREFIXES.some((p) => b.text.startsWith(p))) continue;
+      let text = cleanText(b.text);
+      if (!text.trim()) continue;
+      if (text.length > CHUNK_MAX) {
+        text = text.slice(0, CHUNK_MAX);
+        truncated = true;
+      }
+      if (totalChars + text.length > DOC_TEXT_MAX) {
+        truncated = true;
+        break;
+      }
+      totalChars += text.length;
+      chunks.push({ role: e.role, text, idx: e.index });
+    }
+    if (totalChars >= DOC_TEXT_MAX) break;
+  }
+
+  const firstUser = chunks.find((c) => c.role === "user");
+  const rawTitle = session.firstUserPreview?.trim() || firstUser?.text.trim() || "(untitled session)";
+  const title = rawTitle.replace(/\s+/g, " ").slice(0, TITLE_MAX);
+
+  const startMs = session.firstTimestamp ? Date.parse(session.firstTimestamp) : NaN;
+
+  return {
+    version: INDEX_VERSION,
+    sessionId: session.id,
+    agent: session.agent ?? "claude-code",
+    project: canonicalProjectName(session.projectName),
+    ...(session.repoName ? { repoName: session.repoName } : {}),
+    day: Number.isNaN(startMs) ? "" : toLocalDay(startMs),
+    startIso: session.firstTimestamp,
+    endIso: session.lastTimestamp,
+    title,
+    chunks,
+    ...(truncated ? { truncated } : {}),
+    mtimeMs: file.mtimeMs,
+    sizeBytes: file.sizeBytes,
+  };
+}