fleetlens 0.15.2 → 0.15.4

package/app/apps/web/app/projects/[slug]/local-folders-button.tsx

@@ -0,0 +1,406 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { FolderOpen, Github, X } from "lucide-react";
+import { formatRelative } from "@/lib/format";
+
+export type ProjectLocalFolder = {
+  path: string;
+  canonicalProject: string;
+  reasons: string[];
+  worktreeNames: string[];
+  agents: string[];
+  projectDirs: string[];
+  sessionCount: number;
+  lastTimestamp?: string;
+  canOpen: boolean;
+  exists: boolean;
+  isWorktree: boolean;
+  branch?: string;
+  defaultBranch?: string;
+  remote?: { host: string; owner: string; name: string; url: string; webUrl: string };
+};
+
+const chip = {
+  border: "1px solid var(--af-border-subtle)",
+  borderRadius: 999,
+  padding: "1px 7px",
+  fontSize: 10,
+  whiteSpace: "nowrap" as const,
+};
+
+type OpenState =
+  | { kind: "idle" }
+  | { kind: "opening"; path: string }
+  | { kind: "opened"; path: string }
+  | { kind: "error"; path: string; message: string };
+
+function shortPath(path: string): string {
+  const parts = path.split("/").filter(Boolean);
+  return parts.length >= 2 ? `${parts.at(-2)}/${parts.at(-1)}` : path;
+}
+
+export function ProjectLocalFoldersButton({
+  projectKey,
+  folders,
+}: {
+  projectKey: string;
+  folders: ProjectLocalFolder[];
+}) {
+  const [open, setOpen] = useState(false);
+  const [state, setState] = useState<OpenState>({ kind: "idle" });
+
+  useEffect(() => {
+    if (!open) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") setOpen(false);
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [open]);
+
+  async function openFolder(path: string) {
+    setState({ kind: "opening", path });
+    const res = await fetch("/api/projects/open-folder", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ projectKey, path }),
+    });
+    const body = (await res.json().catch(() => null)) as { error?: string } | null;
+    if (!res.ok) {
+      setState({
+        kind: "error",
+        path,
+        message: body?.error ?? "Could not open this folder.",
+      });
+      return;
+    }
+    setState({ kind: "opened", path });
+  }
+
+  return (
+    <>
+      <button
+        type="button"
+        className="af-btn"
+        onClick={() => setOpen(true)}
+        style={{
+          display: "inline-flex",
+          alignItems: "center",
+          gap: 7,
+          whiteSpace: "nowrap",
+        }}
+      >
+        <FolderOpen size={14} />
+        Local folders
+        <span
+          style={{
+            fontFamily: "var(--font-mono)",
+            fontSize: 11,
+            color: "var(--af-text-tertiary)",
+          }}
+        >
+          {folders.length}
+        </span>
+      </button>
+
+      {open && (
+        <div
+          role="dialog"
+          aria-modal="true"
+          aria-labelledby="local-folders-title"
+          onClick={() => setOpen(false)}
+          style={{
+            position: "fixed",
+            inset: 0,
+            zIndex: 220,
+            background: "rgba(0, 0, 0, 0.5)",
+            backdropFilter: "blur(4px)",
+            WebkitBackdropFilter: "blur(4px)",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            padding: 20,
+          }}
+        >
+          <div
+            onClick={(e) => e.stopPropagation()}
+            style={{
+              background: "var(--af-surface-elevated)",
+              border: "1px solid var(--af-border-subtle)",
+              borderRadius: 10,
+              width: "min(860px, 100%)",
+              maxHeight: "86vh",
+              display: "flex",
+              flexDirection: "column",
+              boxShadow: "0 18px 54px rgba(0, 0, 0, 0.35)",
+            }}
+          >
+            <div
+              style={{
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "space-between",
+                gap: 16,
+                padding: "16px 20px",
+                borderBottom: "1px solid var(--af-border-subtle)",
+              }}
+            >
+              <div style={{ minWidth: 0 }}>
+                <h2
+                  id="local-folders-title"
+                  style={{
+                    margin: 0,
+                    fontSize: 16,
+                    fontWeight: 700,
+                    letterSpacing: "-0.01em",
+                  }}
+                >
+                  Aggregated local folders
+                </h2>
+                <p
+                  style={{
+                    margin: "4px 0 0",
+                    fontSize: 12,
+                    color: "var(--af-text-tertiary)",
+                  }}
+                >
+                  Folders from sessions that currently roll up into this project.
+                </p>
+              </div>
+              <button
+                type="button"
+                onClick={() => setOpen(false)}
+                aria-label="Close"
+                style={{
+                  background: "transparent",
+                  border: "none",
+                  color: "var(--af-text-tertiary)",
+                  cursor: "pointer",
+                  padding: 4,
+                  lineHeight: 0,
+                }}
+              >
+                <X size={18} />
+              </button>
+            </div>
+
+            <div style={{ overflow: "auto", padding: 14 }}>
+              {folders.length === 0 ? (
+                <div className="af-empty">No local folders were found for this project.</div>
+              ) : (
+                <div style={{ display: "flex", flexDirection: "column", gap: 10 }}>
+                  {folders.map((folder) => {
+                    const isBusy = state.kind === "opening" && state.path === folder.path;
+                    const isOpened = state.kind === "opened" && state.path === folder.path;
+                    const isError = state.kind === "error" && state.path === folder.path;
+                    return (
+                      <div
+                        key={folder.path}
+                        style={{
+                          border: "1px solid var(--af-border-subtle)",
+                          borderRadius: 8,
+                          background: "var(--af-surface)",
+                          padding: 12,
+                          display: "grid",
+                          gridTemplateColumns: "minmax(0, 1fr) auto",
+                          gap: 12,
+                          alignItems: "start",
+                        }}
+                      >
+                        <div style={{ minWidth: 0 }}>
+                          <div
+                            style={{
+                              display: "flex",
+                              alignItems: "center",
+                              gap: 8,
+                              marginBottom: 6,
+                            }}
+                          >
+                            <span
+                              style={{
+                                fontSize: 12,
+                                fontWeight: 700,
+                                color: "var(--af-text)",
+                              }}
+                            >
+                              {shortPath(folder.path)}
+                            </span>
+                            {folder.worktreeNames.map((name) => (
+                              <span
+                                key={name}
+                                style={{ ...chip, color: "var(--af-text-secondary)" }}
+                              >
+                                worktree: {name}
+                              </span>
+                            ))}
+                            {folder.branch && (
+                              <span
+                                title={
+                                  folder.branch === folder.defaultBranch
+                                    ? "on the default branch"
+                                    : `default branch is ${folder.defaultBranch ?? "unknown"}`
+                                }
+                                style={{
+                                  ...chip,
+                                  fontFamily: "var(--font-mono)",
+                                  color:
+                                    folder.branch === folder.defaultBranch
+                                      ? "var(--af-text-tertiary)"
+                                      : "var(--af-text)",
+                                }}
+                              >
+                                {folder.branch}
+                              </span>
+                            )}
+                            {!folder.exists && (
+                              <span
+                                title="This folder is gone from disk. Its sessions still count toward the project."
+                                style={{ ...chip, color: "var(--af-danger)", borderColor: "var(--af-danger)" }}
+                              >
+                                gone
+                              </span>
+                            )}
+                          </div>
+                          <div
+                            title={folder.path}
+                            style={{
+                              fontFamily: "var(--font-mono)",
+                              fontSize: 11,
+                              color: "var(--af-text-secondary)",
+                              overflow: "hidden",
+                              textOverflow: "ellipsis",
+                              whiteSpace: "nowrap",
+                              marginBottom: 8,
+                            }}
+                          >
+                            {folder.path}
+                          </div>
+                          <div
+                            style={{
+                              display: "grid",
+                              gridTemplateColumns: "92px minmax(0, 1fr)",
+                              rowGap: 5,
+                              columnGap: 10,
+                              fontSize: 11,
+                              color: "var(--af-text-tertiary)",
+                            }}
+                          >
+                            <span>Grouped via</span>
+                            <span style={{ color: "var(--af-text-secondary)" }}>
+                              {folder.reasons.join(", ")}
+                            </span>
+                            <span>Into</span>
+                            <span
+                              title={folder.canonicalProject}
+                              style={{
+                                fontFamily: "var(--font-mono)",
+                                color: "var(--af-text-secondary)",
+                                overflow: "hidden",
+                                textOverflow: "ellipsis",
+                                whiteSpace: "nowrap",
+                              }}
+                            >
+                              {folder.canonicalProject}
+                            </span>
+                            <span>Sessions</span>
+                            <span style={{ color: "var(--af-text-secondary)" }}>
+                              {folder.sessionCount} session{folder.sessionCount === 1 ? "" : "s"}
+                              {" | "}
+                              {folder.agents.join(", ")}
+                              {folder.lastTimestamp ? ` | ${formatRelative(folder.lastTimestamp)}` : ""}
+                            </span>
+                            {folder.remote && (
+                              <>
+                                <span>Remote</span>
+                                <span
+                                  style={{
+                                    fontFamily: "var(--font-mono)",
+                                    overflow: "hidden",
+                                    textOverflow: "ellipsis",
+                                    whiteSpace: "nowrap",
+                                  }}
+                                >
+                                  <a
+                                    href={folder.remote.webUrl}
+                                    target="_blank"
+                                    rel="noreferrer"
+                                    title={folder.remote.url}
+                                    style={{
+                                      color: "var(--af-text-secondary)",
+                                      display: "inline-flex",
+                                      alignItems: "center",
+                                      gap: 5,
+                                    }}
+                                  >
+                                    {folder.remote.host === "github.com" && (
+                                      <Github size={11} aria-label="GitHub" />
+                                    )}
+                                    {folder.remote.owner}/{folder.remote.name}
+                                  </a>
+                                  {folder.remote.host !== "github.com" && (
+                                    <span style={{ color: "var(--af-text-tertiary)" }}>
+                                      {" \u00b7 "}{folder.remote.host}
+                                    </span>
+                                  )}
+                                </span>
+                              </>
+                            )}
+                            <span>Transcript dir</span>
+                            <span
+                              title={folder.projectDirs.join(", ")}
+                              style={{
+                                fontFamily: "var(--font-mono)",
+                                color: "var(--af-text-secondary)",
+                                overflow: "hidden",
+                                textOverflow: "ellipsis",
+                                whiteSpace: "nowrap",
+                              }}
+                            >
+                              {folder.projectDirs.join(", ")}
+                            </span>
+                          </div>
+                          {isError && (
+                            <div
+                              style={{
+                                marginTop: 8,
+                                fontSize: 11,
+                                color: "var(--af-danger)",
+                              }}
+                            >
+                              {state.message}
+                            </div>
+                          )}
+                          {isOpened && (
+                            <div
+                              style={{
+                                marginTop: 8,
+                                fontSize: 11,
+                                color: "var(--af-accent)",
+                              }}
+                            >
+                              Folder opened.
+                            </div>
+                          )}
+                        </div>
+                        <button
+                          type="button"
+                          className="af-btn"
+                          disabled={!folder.canOpen || isBusy}
+                          onClick={() => openFolder(folder.path)}
+                          style={{ whiteSpace: "nowrap" }}
+                        >
+                          {isBusy ? "Opening..." : "Open folder"}
+                        </button>
+                      </div>
+                    );
+                  })}
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+      )}
+    </>
+  );
+}

package/app/apps/web/app/projects/[slug]/page.tsx

@@ -1,11 +1,14 @@
 import { notFound } from "next/navigation";
 import Link from "next/link";
+import { isAbsolute } from "node:path";
 import { listSessions, getSession } from "@/lib/data";
+import { readGitFolder } from "@claude-lens/parser/fs";
 import {
-  projectRepoName,
+  buildProjectKeyResolver,
   detectPrMarkers,
   sessionAirTimeMs,
 } from "@claude-lens/parser";
+import type { SessionMeta } from "@claude-lens/parser";
 import type { DayOutcome, DayHelpfulness } from "@claude-lens/entries";
 import { DashboardView } from "@/components/dashboard-view";
 import { LiveBadge } from "@/components/live-badge";
@@ -14,7 +17,8 @@ import { OutcomePill, OUTCOME_STYLES } from "@/components/outcome-pill";
 import { HelpfulnessSparkline } from "@/components/helpfulness-sparkline";
 import { buildEntriesIndex, listCachedDayDigests } from "@/lib/entries-index";
 import { formatDuration, formatRelative, prettyProjectName } from "@/lib/format";
-import { ArrowLeft } from "lucide-react";
+import { ArrowLeft, Github } from "lucide-react";
+import { ProjectLocalFoldersButton, type ProjectLocalFolder } from "./local-folders-button";
 
 function lastNDays(n: number): string[] {
   const out: string[] = [];
@@ -34,17 +38,110 @@ const OUTCOME_PRI: Record<DayOutcome, number> = {
   shipped: 6, partial: 5, blocked: 4, exploratory: 3, trivial: 2, idle: 1,
 };
 
+function agentLabel(agent: SessionMeta["agent"]): string {
+  return agent ?? "claude-code";
+}
+
+function folderPathForSession(s: SessionMeta): string | undefined {
+  if (s.cwd) return s.cwd;
+  return isAbsolute(s.projectName) ? s.projectName : undefined;
+}
+
+function aggregationReason(s: SessionMeta, folderPath: string): string {
+  if (s.worktreeName) return `worktree "${s.worktreeName}" -> project root`;
+  if (folderPath === s.projectName) return "project root";
+  return "cwd inside git project -> project root";
+}
+
+function buildProjectLocalFolders(sessions: SessionMeta[]): ProjectLocalFolder[] {
+  const rows = new Map<string, {
+    path: string;
+    canonicalProject: string;
+    reasons: Set<string>;
+    worktreeNames: Set<string>;
+    agents: Set<string>;
+    projectDirs: Set<string>;
+    sessionCount: number;
+    lastActivityMs: number;
+    lastTimestamp?: string;
+    canOpen: boolean;
+  }>();
+
+  for (const s of sessions) {
+    const folderPath = folderPathForSession(s);
+    if (!folderPath) continue;
+    const timestampMs = s.lastTimestamp ? Date.parse(s.lastTimestamp) : 0;
+    const lastActivityMs = s.lastActivityMs
+      ?? (Number.isFinite(timestampMs) ? timestampMs : 0);
+    const existing = rows.get(folderPath);
+    if (existing) {
+      existing.reasons.add(aggregationReason(s, folderPath));
+      if (s.worktreeName) existing.worktreeNames.add(s.worktreeName);
+      existing.agents.add(agentLabel(s.agent));
+      existing.projectDirs.add(s.projectDir);
+      existing.sessionCount += 1;
+      if (lastActivityMs > existing.lastActivityMs) {
+        existing.lastActivityMs = lastActivityMs;
+        existing.lastTimestamp = s.lastTimestamp;
+      }
+      continue;
+    }
+    rows.set(folderPath, {
+      path: folderPath,
+      canonicalProject: s.projectName,
+      reasons: new Set([aggregationReason(s, folderPath)]),
+      worktreeNames: new Set(s.worktreeName ? [s.worktreeName] : []),
+      agents: new Set([agentLabel(s.agent)]),
+      projectDirs: new Set([s.projectDir]),
+      sessionCount: 1,
+      lastActivityMs,
+      lastTimestamp: s.lastTimestamp,
+      canOpen: isAbsolute(folderPath),
+    });
+  }
+
+  return [...rows.values()]
+    .map((row) => {
+      const git = readGitFolder(row.path);
+      return {
+        path: row.path,
+        canonicalProject: row.canonicalProject,
+        reasons: [...row.reasons].sort(),
+        worktreeNames: [...row.worktreeNames].sort(),
+        agents: [...row.agents].sort(),
+        projectDirs: [...row.projectDirs].sort(),
+        sessionCount: row.sessionCount,
+        lastTimestamp: row.lastTimestamp,
+        exists: git.exists,
+        isWorktree: git.isWorktree,
+        branch: git.branch,
+        defaultBranch: git.defaultBranch,
+        remote: git.remote,
+        // A pruned worktree still owns history; it just can't be opened.
+        canOpen: git.exists,
+      };
+    })
+    .sort((a, b) => {
+      const aIsRoot = a.path === a.canonicalProject ? 0 : 1;
+      const bIsRoot = b.path === b.canonicalProject ? 0 : 1;
+      if (aIsRoot !== bIsRoot) return aIsRoot - bIsRoot;
+      const aLast = a.lastTimestamp ? Date.parse(a.lastTimestamp) : 0;
+      const bLast = b.lastTimestamp ? Date.parse(b.lastTimestamp) : 0;
+      return bLast - aLast || a.path.localeCompare(b.path);
+    });
+}
+
 export const dynamic = "force-dynamic";
 
 export default async function ProjectDetail({ params }: { params: Promise<{ slug: string }> }) {
   const { slug } = await params;
-  // Slugs are repo names (e.g. `claude-lens`) — see projectRepoName. Match any
-  // session in that repo, which folds the parent repo, every `/.worktrees/<name>`
-  // subdir, and the same repo reached via Conductor / Superset into one view.
+  // Slugs are Fleetlens project keys (e.g. `claude-lens`). Parser adapters
+  // resolve each session to one canonical project before this page filters.
   const decodedCanonical = decodeURIComponent(slug);
   const all = await listSessions();
+  const keyOf = buildProjectKeyResolver(all);
   const projectSessions = all.filter(
-    (s) => projectRepoName(s.projectName) === decodedCanonical,
+    (s) => keyOf(s) === decodedCanonical,
   );
   if (projectSessions.length === 0) return notFound();
 
@@ -67,6 +164,8 @@ export default async function ProjectDetail({ params }: { params: Promise<{ slug
     .reduce((a, d) => a + sessionAirTimeMs(d.events), 0);
 
   const recentSessions = projectSessions.slice(0, 12);
+  const localFolders = buildProjectLocalFolders(projectSessions);
+  const projectRemote = localFolders.find((f) => f.remote)?.remote;
   const hasPrs = prMarkers.length > 0;
 
   // Build the recent-7-days strip + helpfulness sparkline.
@@ -139,20 +238,56 @@ export default async function ProjectDetail({ params }: { params: Promise<{ slug
       </div>
 
       {/* Header */}
-      <header>
-        <h1 style={{ fontSize: 26, fontWeight: 700, letterSpacing: "-0.02em", margin: 0 }}>
-          {prettyProjectName(projectName)}
-        </h1>
-        <p
-          style={{
-            fontSize: 12,
-            color: "var(--af-text-tertiary)",
-            marginTop: 4,
-            fontFamily: "var(--font-mono)",
-          }}
-        >
-          {projectName}
-        </p>
+      <header
+        style={{
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "flex-start",
+          flexWrap: "wrap",
+          gap: 16,
+        }}
+      >
+        <div style={{ minWidth: 0 }}>
+          <h1 style={{ fontSize: 26, fontWeight: 700, letterSpacing: "-0.02em", margin: 0 }}>
+            {prettyProjectName(projectName)}
+          </h1>
+          <p
+            style={{
+              fontSize: 12,
+              color: "var(--af-text-tertiary)",
+              marginTop: 4,
+              fontFamily: "var(--font-mono)",
+              overflow: "hidden",
+              textOverflow: "ellipsis",
+              whiteSpace: "nowrap",
+            }}
+          >
+            {projectRemote ? (
+              <a
+                href={projectRemote.webUrl}
+                target="_blank"
+                rel="noreferrer"
+                title={projectRemote.url}
+                style={{
+                  color: "var(--af-text-secondary)",
+                  textDecoration: "none",
+                  display: "inline-flex",
+                  alignItems: "center",
+                  gap: 5,
+                }}
+              >
+                {projectRemote.host === "github.com" && <Github size={12} aria-label="GitHub" />}
+                {projectRemote.host === "github.com"
+                  ? `${projectRemote.owner}/${projectRemote.name}`
+                  : `${projectRemote.host}/${projectRemote.owner}/${projectRemote.name}`}
+                {" \u2197"}
+              </a>
+            ) : (
+              projectName
+            )}
+          </p>
+        </div>
+        <ProjectLocalFoldersButton projectKey={decodedCanonical} folders={localFolders} />
       </header>
 
       <DashboardView

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

@@ -1,5 +1,5 @@
 import { listSessions } from "@/lib/data";
-import { projectRepoName, groupByProject } from "@claude-lens/parser";
+import { projectKey, groupByProject } from "@claude-lens/parser";
 import type { DayOutcome } from "@claude-lens/entries";
 import { ProjectsView, type ProjectRow } from "./projects-view";
 import { buildEntriesIndex } from "@/lib/entries-index";
@@ -26,7 +26,7 @@ export default async function ProjectsPage() {
   const days = lastNDays(7);
 
   const rows: ProjectRow[] = projects.map((p) => {
-    const projectEntries = index.byProject.get(projectRepoName(p.projectName)) ?? [];
+    const projectEntries = index.byProject.get(projectKey(p.projectName)) ?? [];
     const byDay = new Map<string, typeof projectEntries>();
     for (const e of projectEntries) {
       const arr = byDay.get(e.local_day);

package/app/apps/web/app/sessions/[id]/page.tsx

@@ -1,6 +1,6 @@
 import { notFound } from "next/navigation";
 import { getSession } from "@/lib/data";
-import { loadTeamForSession, findTeamLead } from "@claude-lens/parser/fs";
+import { loadTeamForSession, findTeamLead, readGitFolder } from "@claude-lens/parser/fs";
 import { listEntriesForSession } from "@claude-lens/entries/fs";
 import {
   teamViewToTimelineData,
@@ -54,9 +54,12 @@ export default async function SessionDetailPage({
     events: session.events.map((e) => ({ ...e, raw: undefined })),
   };
 
+  const git = session.cwd ? readGitFolder(session.cwd) : undefined;
+
   return (
     <SessionView
       session={stripped}
+      git={git}
       team={teamProps}
       teamLead={teamLeadInfo}
       entries={entries}