@stevecastaneda/paseo-progress 0.1.6 → 0.1.8

package/client/attachments.tsx

@@ -16,10 +16,11 @@ export function isPreviewable(attachment: Attachment): boolean {
   return canPreview(attachment, { browser: Platform.OS === "web" });
 }
 
-// Full path on the daemon host for a stored path.
-export function absolutePath(path: string, workspaceDirectory: string): string {
+// Full path on the daemon host for a stored path. `root` is the worktree
+// root the dashboard was read from, not the workspace directory.
+export function absolutePath(path: string, root: string): string {
   if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path)) return path;
-  const base = workspaceDirectory.replace(/[\\/]+$/, "");
+  const base = root.replace(/[\\/]+$/, "");
   return path === "./" ? `${base}/` : `${base}/${path}`;
 }
 

package/client/panel.tsx

@@ -10,7 +10,7 @@ import { raised } from "./surfaces";
 import { When } from "./when";
 import React, { useEffect, useRef, useState } from "react";
 import { ActivityIndicator, Animated, Platform, Pressable, ScrollView, Text, View } from "react-native";
-import { finishedAtTop, shortTitle, type Activity, type Dashboard, type FileIssue, type ProgressSegment, type StuckItem, type Ticket } from "../shared/dashboard";
+import { finishedToFold, isFinished, shortTitle, type Activity, type Dashboard, type FileIssue, type ProgressSegment, type StuckItem, type Ticket } from "../shared/dashboard";
 import { PROGRESS_FILE, type TicketStatus } from "../shared/events";
 import { formatEstimate, formatMinutes, formatWorkDone, minutesSince } from "../shared/format";
 import { markPanelOpened } from "../shared/rpc";
@@ -54,7 +54,7 @@ function WorkspaceProgress({ theme, workspaceId, host, layout, navigation }: Plu
       <Presence show={Boolean(result && !result.configured)}>{result && !result.configured ? <EmptyState colors={colors} /> : null}</Presence>
       {/* Keyed by run: a new run starts with fresh tabs, pages and dialogs. */}
       {result?.configured ? <DashboardView key={result.dashboard.run?.startedAt ?? "none"} colors={colors} dashboard={result.dashboard} agentRunning={agentRunning} compact={layout.compact}
-        workspaceId={workspaceId} workspaceDirectory={directory ?? ""} navigation={navigation} /> : null}
+        workspaceId={workspaceId} workspaceDirectory={result.root} navigation={navigation} /> : null}
     </ScrollView>
   );
 }
@@ -416,26 +416,25 @@ function StuckSection({ colors, items, now }: { colors: Colors; items: StuckItem
 // the app session like the history tab.
 const finishedShown = new Map<string, boolean>();
 
-// Finished tickets at the top fold into one row, so the work still ahead is
-// near the top without scrolling (see finishedAtTop).
+// Finished tickets fold into one row at the top, so the work still ahead is
+// near the top without scrolling (see finishedToFold).
 function TicketList({ colors, dashboard, live, now, workspaceId, onOpen }: { colors: Colors; dashboard: Dashboard; live: boolean; now: number; workspaceId: string; onOpen(id: string): void }) {
   const [shown, setShown] = useState(() => finishedShown.get(workspaceId) ?? false);
   const toggle = () => {
     finishedShown.set(workspaceId, !shown);
     setShown(!shown);
   };
-  const folded = finishedAtTop(dashboard.tickets);
+  const finished = finishedToFold(dashboard.tickets);
   const row = (ticket: Ticket) => (
     <TicketRow key={ticket.id} colors={colors} ticket={ticket} live={live} now={now} onOpen={() => onOpen(ticket.id)}
       deliverables={dashboard.deliverables.filter((deliverable) => deliverable.ticketId === ticket.id).length} />
   );
-  if (!folded) return <>{dashboard.tickets.map(row)}</>;
-  const finished = dashboard.tickets.slice(0, folded);
+  if (!finished.length) return <>{dashboard.tickets.map(row)}</>;
   return (
     <>
       <FinishedRow colors={colors} tickets={finished} shown={shown} onPress={toggle} />
       {shown ? finished.map(row) : null}
-      {dashboard.tickets.slice(folded).map(row)}
+      {dashboard.tickets.filter((ticket) => !isFinished(ticket)).map(row)}
     </>
   );
 }

package/client/pill-popover.tsx

@@ -28,12 +28,14 @@ export function AttentionPopover({ theme, host, layout, workspaceId, close, open
   const directory = useWorkspace(workspaceId, (workspace) => workspace.directory);
   const query = useDashboard(host.id, workspaceId, directory);
   const dashboard = query.data?.configured ? query.data.dashboard : null;
+  // Stored paths are relative to the worktree root, which can sit above the workspace directory.
+  const root = query.data?.root ?? directory ?? "";
   const copy = useCopy();
   // Previews open in a dialog over the popover, which stays open to return to.
   // Links and other files leave Paseo, so the popover closes for those.
   const [previewing, setPreviewing] = useState<{ attachment: Attachment; group: Attachment[] } | null>(null);
   const group = useRef<Attachment[]>([]);
-  const opener = useAttachmentOpener({ workspaceId, workspaceDirectory: directory ?? "", onPreview: (attachment) => setPreviewing({ attachment, group: previewable(group.current) }) });
+  const opener = useAttachmentOpener({ workspaceId, workspaceDirectory: root, onPreview: (attachment) => setPreviewing({ attachment, group: previewable(group.current) }) });
   return (
     <View style={{ width: 360, maxWidth: "100%", gap: 8 }}>
       {dashboard ? (
@@ -52,7 +54,7 @@ export function AttentionPopover({ theme, host, layout, workspaceId, close, open
           {query.error ? `Could not read progress: ${query.error.message}` : "Loading…"}
         </Text>
       )}
-      <PreviewDialog colors={colors} attachment={previewing?.attachment ?? null} workspaceId={workspaceId} workspaceDirectory={directory ?? ""}
+      <PreviewDialog colors={colors} attachment={previewing?.attachment ?? null} workspaceId={workspaceId} workspaceDirectory={root}
         onClose={() => setPreviewing(null)} onOpenOnHost={(attachment) => void opener.openOnHost(attachment)}
         gallery={previewing ? { items: previewing.group, onSelect: (attachment) => setPreviewing({ ...previewing, attachment }) } : undefined} />
       <View style={{ paddingTop: touch ? 12 : 8, borderTopWidth: 1, borderTopColor: colors.border }}>

package/dist/server/cli.js

@@ -1,13 +1,13 @@
 // The command agents run to record progress. Each command appends one event
 // to the worktree's progress file and prints what it recorded.
-import { existsSync, realpathSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { realpathSync, statSync } from "node:fs";
+import { relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { isSettled } from "../shared/dashboard.js";
 import { DELIVERABLE_KINDS, PROGRESS_FILE, TICKET_STATUSES } from "../shared/events.js";
 import { appendProgress, InvalidEvent, readProgress } from "./progress-file.js";
-import { outside } from "./paths.js";
+import { findRoot, outside } from "./paths.js";
 import { installLauncher } from "./launcher.js";
 import { dashboardText } from "../shared/show.js";
 import { imageMimeType } from "../shared/attachments.js";
@@ -436,19 +436,6 @@ function help() {
         `      ${INSTALL_SUMMARY}`,
     ].join("\n");
 }
-// The worktree root is the nearest directory with a `.git` entry (a folder in
-// a checkout, a file in a linked worktree). Outside git, use the directory.
-export function findRoot(cwd) {
-    let directory = resolve(cwd);
-    while (true) {
-        if (existsSync(join(directory, ".git")))
-            return directory;
-        const parent = dirname(directory);
-        if (parent === directory)
-            return resolve(cwd);
-        directory = parent;
-    }
-}
 export async function runCli(argv, options) {
     const out = options.out ?? ((line) => console.log(line));
     const now = options.now ?? (() => new Date());

package/dist/server/paths.js

@@ -1,6 +1,22 @@
-import { isAbsolute, sep } from "node:path";
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 // Whether a path from relative(root, target) leaves the root. "..notes" is a
 // name inside it, not a step out.
 export function outside(inside) {
     return inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside);
 }
+// The worktree root is the nearest directory with a `.git` entry (a folder in
+// a checkout, a file in a linked worktree). Outside git, use the directory.
+// The command and the panel both start from here, so a Paseo project set at a
+// subfolder of the repo still reads the file the agent writes.
+export function findRoot(cwd) {
+    let directory = resolve(cwd);
+    while (true) {
+        if (existsSync(join(directory, ".git")))
+            return directory;
+        const parent = dirname(directory);
+        if (parent === directory)
+            return resolve(cwd);
+        directory = parent;
+    }
+}

package/dist/shared/dashboard.js

@@ -328,15 +328,17 @@ export function shortTitle(title) {
     const index = title.indexOf(":");
     return index > 0 && index <= 24 ? title.slice(0, index) : title;
 }
-// How many tickets at the top of the list are finished (done or skipped), so
-// the panel can fold them into one row and the work still ahead sits near the
-// top. Only the leading run folds: a ticket finished out of order stays in
-// place, so the plan's order never looks shuffled. A single one isn't worth a
-// fold row. Once every ticket is finished nothing is ahead, and the whole list
-// is the record of the run, so nothing folds.
-export function finishedAtTop(tickets) {
-    const index = tickets.findIndex((ticket) => ticket.status !== "done" && ticket.status !== "skipped");
-    return index >= 2 ? index : 0;
+// The finished tickets (done or skipped) the panel folds into one row at the
+// top, in plan order, so the work still ahead sits near the top. A ticket
+// finished out of order folds too. A single one isn't worth a fold row. Once
+// every ticket is finished nothing is ahead, and the whole list is the record
+// of the run, so nothing folds.
+export function finishedToFold(tickets) {
+    const finished = tickets.filter(isFinished);
+    return finished.length >= 2 && finished.length < tickets.length ? finished : [];
+}
+export function isFinished(ticket) {
+    return ticket.status === "done" || ticket.status === "skipped";
 }
 function plural(count, noun) {
     return `${count} ${count === 1 ? noun : `${noun}s`}`;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@stevecastaneda/paseo-progress",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@stevecastaneda/paseo-progress",
-      "version": "0.1.6",
+      "version": "0.1.8",
       "license": "MIT",
       "dependencies": {
         "@getpaseo/client": "^0.9.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stevecastaneda/paseo-progress",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "A live progress dashboard per worktree for Paseo, drawn from a file agents write with the paseo-progress command.",
   "license": "MIT",
   "author": "Steve Castaneda",

package/server/cli.ts

@@ -1,13 +1,13 @@
 // The command agents run to record progress. Each command appends one event
 // to the worktree's progress file and prints what it recorded.
-import { existsSync, realpathSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { realpathSync, statSync } from "node:fs";
+import { relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { isSettled, type Dashboard, type NextIds } from "../shared/dashboard.ts";
 import { DELIVERABLE_KINDS, PROGRESS_FILE, TICKET_STATUSES } from "../shared/events.ts";
 import { appendProgress, InvalidEvent, readProgress, type EventDraft } from "./progress-file.ts";
-import { outside } from "./paths.ts";
+import { findRoot, outside } from "./paths.ts";
 import { installLauncher } from "./launcher.ts";
 import { dashboardText } from "../shared/show.ts";
 import { imageMimeType } from "../shared/attachments.ts";
@@ -449,18 +449,6 @@ function help(): string {
   ].join("\n");
 }
 
-// The worktree root is the nearest directory with a `.git` entry (a folder in
-// a checkout, a file in a linked worktree). Outside git, use the directory.
-export function findRoot(cwd: string): string {
-  let directory = resolve(cwd);
-  while (true) {
-    if (existsSync(join(directory, ".git"))) return directory;
-    const parent = dirname(directory);
-    if (parent === directory) return resolve(cwd);
-    directory = parent;
-  }
-}
-
 export async function runCli(argv: string[], options: CliOptions): Promise<number> {
   const out = options.out ?? ((line: string) => console.log(line));
   const now = options.now ?? (() => new Date());

package/server/dashboard.ts

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import type { Dashboard } from "../shared/dashboard.ts";
 import type { AttentionResult, DashboardResult } from "../shared/rpc.ts";
 import { markPanelOpened, readProgress } from "./progress-file.ts";
+import { findRoot } from "./paths.ts";
 
 const versions = new WeakMap<Dashboard, { panelOpened: boolean; version: string }>();
 
@@ -10,7 +11,7 @@ export async function handleMarkPanelOpened(
   input: { workspaceId: string; workspaceDirectory: string },
   _context: PluginHandlerContext,
 ) {
-  await markPanelOpened(input.workspaceDirectory);
+  await markPanelOpened(findRoot(input.workspaceDirectory));
   return {};
 }
 
@@ -20,14 +21,15 @@ export async function handleGetDashboard(
   input: { workspaceId: string; workspaceDirectory: string; since?: string },
   _context: PluginHandlerContext,
 ): Promise<DashboardResult | { unchanged: true; version: string }> {
-  const result = await readProgress(input.workspaceDirectory);
+  const root = findRoot(input.workspaceDirectory);
+  const result = await readProgress(root);
   let cached = versions.get(result.dashboard);
   if (!cached || cached.panelOpened !== result.panelOpened) {
     cached = { panelOpened: result.panelOpened, version: createHash("sha1").update(JSON.stringify(result)).digest("base64url") };
     versions.set(result.dashboard, cached);
   }
   const { version } = cached;
-  return input.since === version ? { unchanged: true, version } : { ...result, version };
+  return input.since === version ? { unchanged: true, version } : { ...result, root, version };
 }
 
 // Just what a message-box pill needs, so polling every workspace stays small.
@@ -35,7 +37,7 @@ export async function handleGetAttention(
   input: { workspaceId: string; workspaceDirectory: string },
   _context: PluginHandlerContext,
 ): Promise<AttentionResult> {
-  const { configured, dashboard, panelOpened } = await readProgress(input.workspaceDirectory);
+  const { configured, dashboard, panelOpened } = await readProgress(findRoot(input.workspaceDirectory));
   return {
     configured,
     questions: dashboard.questions.open.length,

package/server/open.ts

@@ -6,7 +6,7 @@ import { join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import { findAttachment, imageMimeType, previewKind } from "../shared/attachments.ts";
 import { readProgress } from "./progress-file.ts";
-import { outside } from "./paths.ts";
+import { findRoot, outside } from "./paths.ts";
 
 export type Opener = (path: string) => Promise<void>;
 
@@ -43,10 +43,11 @@ export const systemOpener: Opener = async (path) => {
 // so the panel can never reach an arbitrary path. Only files inside the
 // worktree resolve.
 async function resolveAttachment(directory: string, ref: string, verb: string): Promise<{ path: string; target: string }> {
-  const { dashboard } = await readProgress(directory);
+  const worktree = findRoot(directory);
+  const { dashboard } = await readProgress(worktree);
   const path = findAttachment(dashboard, ref)?.path;
   if (!path) throw new Error(`No local ${ref.startsWith("Q") ? "attachment" : "deliverable"} ${ref} in this worktree.`);
-  const root = await realpath(directory);
+  const root = await realpath(worktree);
   const target = await realpath(resolve(root, path)).catch(() => null);
   if (!target) throw new Error(`${path} no longer exists.`);
   const inside = relative(root, target);

package/server/paths.ts

@@ -1,7 +1,22 @@
-import { isAbsolute, sep } from "node:path";
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 
 // Whether a path from relative(root, target) leaves the root. "..notes" is a
 // name inside it, not a step out.
 export function outside(inside: string): boolean {
   return inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside);
 }
+
+// The worktree root is the nearest directory with a `.git` entry (a folder in
+// a checkout, a file in a linked worktree). Outside git, use the directory.
+// The command and the panel both start from here, so a Paseo project set at a
+// subfolder of the repo still reads the file the agent writes.
+export function findRoot(cwd: string): string {
+  let directory = resolve(cwd);
+  while (true) {
+    if (existsSync(join(directory, ".git"))) return directory;
+    const parent = dirname(directory);
+    if (parent === directory) return resolve(cwd);
+    directory = parent;
+  }
+}

package/shared/dashboard.ts

@@ -449,15 +449,18 @@ export function shortTitle(title: string): string {
   return index > 0 && index <= 24 ? title.slice(0, index) : title;
 }
 
-// How many tickets at the top of the list are finished (done or skipped), so
-// the panel can fold them into one row and the work still ahead sits near the
-// top. Only the leading run folds: a ticket finished out of order stays in
-// place, so the plan's order never looks shuffled. A single one isn't worth a
-// fold row. Once every ticket is finished nothing is ahead, and the whole list
-// is the record of the run, so nothing folds.
-export function finishedAtTop(tickets: Ticket[]): number {
-  const index = tickets.findIndex((ticket) => ticket.status !== "done" && ticket.status !== "skipped");
-  return index >= 2 ? index : 0;
+// The finished tickets (done or skipped) the panel folds into one row at the
+// top, in plan order, so the work still ahead sits near the top. A ticket
+// finished out of order folds too. A single one isn't worth a fold row. Once
+// every ticket is finished nothing is ahead, and the whole list is the record
+// of the run, so nothing folds.
+export function finishedToFold(tickets: Ticket[]): Ticket[] {
+  const finished = tickets.filter(isFinished);
+  return finished.length >= 2 && finished.length < tickets.length ? finished : [];
+}
+
+export function isFinished(ticket: Ticket): boolean {
+  return ticket.status === "done" || ticket.status === "skipped";
 }
 
 function plural(count: number, noun: string): string {

package/shared/rpc.ts

@@ -3,8 +3,10 @@ import { z } from "zod";
 import type { Dashboard } from "./dashboard.ts";
 
 // `panelOpened`: the Progress panel has been opened for this worktree before.
+// `root`: the worktree root the file was read from, which stored paths are
+// relative to. It can sit above the workspace directory.
 // `version` changes whenever anything else in the result does.
-export type DashboardResult = { configured: boolean; dashboard: Dashboard; panelOpened: boolean; version: string };
+export type DashboardResult = { configured: boolean; dashboard: Dashboard; panelOpened: boolean; root: string; version: string };
 
 export const getDashboard = defineRpc({
   name: "progress.get",