syntaur 0.16.2 → 0.16.3

package/dist/index.js

@@ -5829,6 +5829,30 @@ function setUpdatedField(content, value) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function createTraces() {
+  return { entries: [], subPhases: /* @__PURE__ */ new Map() };
+}
+async function timed(traces, label, fn) {
+  if (!traces) return fn();
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    traces.entries.push({ label, ms: performance.now() - start });
+  }
+}
+function accumulatePhase(traces, label, ms) {
+  if (!traces) return;
+  traces.subPhases.set(label, (traces.subPhases.get(label) ?? 0) + ms);
+}
+function emitTrace(traces, meta) {
+  if (process.env.SYNTAUR_PERF_TRACE !== "1") return;
+  const totalMs = traces.entries.reduce((sum, entry) => sum + entry.ms, 0);
+  const subPhases = Object.fromEntries(traces.subPhases);
+  console.log(
+    JSON.stringify({ kind: "overview-trace", totalMs, phases: traces.entries, subPhases, ...meta })
+  );
+}
 async function listStandaloneRecords(assignmentsDir2) {
   if (!assignmentsDir2) return [];
   if (!await fileExists(assignmentsDir2)) return [];
@@ -5994,8 +6018,19 @@ async function deleteWorkspace(projectsDir2, name, opts = {}) {
   return { rewroteFiles };
 }
 async function getOverview(projectsDir2, serversDir2, assignmentsDir2, options = {}) {
-  const projectRecords = await listProjectRecords(projectsDir2);
-  const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  const traceEnabled = process.env.SYNTAUR_PERF_TRACE === "1";
+  const traces = traceEnabled ? createTraces() : void 0;
+  const overallStart = traceEnabled ? performance.now() : 0;
+  const projectRecords = await timed(
+    traces,
+    "list-project-records",
+    () => listProjectRecords(projectsDir2, traces)
+  );
+  const standaloneRecords = await timed(
+    traces,
+    "list-standalone-records",
+    () => listStandaloneRecords(assignmentsDir2)
+  );
   const recentActivity = buildRecentActivity(projectRecords, standaloneRecords);
   const staleLimit = clamp(
     Number.isFinite(options.staleLimit) ? Number(options.staleLimit) : STALE_LIMIT_DEFAULT,
@@ -6003,12 +6038,16 @@ async function getOverview(projectsDir2, serversDir2, assignmentsDir2, options =
     STALE_LIMIT_MAX
   );
   const staleOffset = Math.max(0, Number.isFinite(options.staleOffset) ? Number(options.staleOffset) : 0);
-  const buckets = await buildOverviewSegmentBuckets(projectsDir2, projectRecords, standaloneRecords);
+  const buckets = await timed(
+    traces,
+    "build-segment-buckets",
+    () => buildOverviewSegmentBuckets(projectsDir2, projectRecords, standaloneRecords, traces)
+  );
   const segments = toOverviewSegments(buckets, { staleLimit, staleOffset });
   const hero = pickOverviewHero(buckets);
   let recentSessions = [];
   try {
-    const all = await listAllSessions(projectsDir2);
+    const all = await timed(traces, "list-recent-sessions", () => listAllSessions(projectsDir2));
     recentSessions = all.slice(0, RECENT_SESSIONS_LIMIT);
   } catch {
   }
@@ -6016,7 +6055,11 @@ async function getOverview(projectsDir2, serversDir2, assignmentsDir2, options =
   if (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir2, projectsDir2, { assignmentsDir: assignmentsDir2 });
+      const servers = await timed(
+        traces,
+        "scan-tmux-sessions",
+        () => scanAllSessions2(serversDir2, projectsDir2, { assignmentsDir: assignmentsDir2 })
+      );
       if (servers.tmuxAvailable) {
         const alive = servers.sessions.filter((s) => s.alive).length;
         const totalPorts = servers.sessions.reduce((sum, s) => sum + s.windows.reduce((ws, w) => ws + w.panes.reduce((ps, p) => ps + p.ports.length, 0), 0), 0);
@@ -6030,6 +6073,14 @@ async function getOverview(projectsDir2, serversDir2, assignmentsDir2, options =
     } catch {
     }
   }
+  if (traces) {
+    const wallMs = performance.now() - overallStart;
+    const totalAssignments = projectRecords.reduce((sum, r) => sum + r.assignments.length, 0) + standaloneRecords.length;
+    emitTrace(traces, {
+      wallMs,
+      fixture: { projects: projectRecords.length, assignments: totalAssignments }
+    });
+  }
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     firstRun: projectRecords.length === 0 && standaloneRecords.length === 0,
@@ -6560,7 +6611,7 @@ async function buildStandaloneAssignmentDetail(resolved) {
   };
   return detail;
 }
-async function listProjectRecords(projectsDir2) {
+async function listProjectRecords(projectsDir2, traces) {
   if (!await fileExists(projectsDir2)) {
     return [];
   }
@@ -6570,61 +6621,75 @@ async function listProjectRecords(projectsDir2) {
   }
   const entries = await readdir9(projectsDir2, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
-  const records = [];
-  for (const entry of projectDirs) {
-    const projectPath = resolve16(projectsDir2, entry.name);
-    const projectMdPath = resolve16(projectPath, "project.md");
-    if (!await fileExists(projectMdPath)) {
-      continue;
-    }
-    const projectContent = await readFile11(projectMdPath, "utf-8");
-    const project = parseProject(projectContent);
-    const assignments = await listAssignmentRecords(projectPath);
-    const rollup = await buildProjectRollup(projectPath, project, assignments);
-    const updated = getProjectActivityTimestamp(project.updated, assignments);
-    records.push({
-      projectPath,
-      project,
-      assignments,
-      dependencyGraph: await loadDependencyGraph(projectPath, assignments),
-      summary: {
-        slug: project.slug || entry.name,
-        title: project.title,
-        status: rollup.status,
-        statusOverride: project.statusOverride,
-        archived: project.archived,
-        archivedAt: project.archivedAt,
-        archivedReason: project.archivedReason,
-        created: project.created,
-        updated,
-        tags: project.tags,
-        progress: rollup.progress,
-        needsAttention: rollup.needsAttention,
-        workspace: project.workspace
+  const maybeRecords = await Promise.all(
+    projectDirs.map(async (entry) => {
+      const projectPath = resolve16(projectsDir2, entry.name);
+      const projectMdPath = resolve16(projectPath, "project.md");
+      if (!await fileExists(projectMdPath)) {
+        return null;
       }
-    });
-  }
+      const t0 = traces ? performance.now() : 0;
+      const projectContent = await readFile11(projectMdPath, "utf-8");
+      const project = parseProject(projectContent);
+      if (traces) accumulatePhase(traces, "parse-project-md", performance.now() - t0);
+      const t1 = traces ? performance.now() : 0;
+      const assignments = await listAssignmentRecords(projectPath, traces);
+      if (traces) accumulatePhase(traces, "list-assignments", performance.now() - t1);
+      const t2 = traces ? performance.now() : 0;
+      const rollup = await buildProjectRollup(projectPath, project, assignments, traces);
+      if (traces) accumulatePhase(traces, "build-rollup", performance.now() - t2);
+      const updated = getProjectActivityTimestamp(project.updated, assignments);
+      const t3 = traces ? performance.now() : 0;
+      const dependencyGraph = await loadDependencyGraph(projectPath, assignments);
+      if (traces) accumulatePhase(traces, "load-dep-graph", performance.now() - t3);
+      return {
+        projectPath,
+        project,
+        assignments,
+        dependencyGraph,
+        summary: {
+          slug: project.slug || entry.name,
+          title: project.title,
+          status: rollup.status,
+          statusOverride: project.statusOverride,
+          archived: project.archived,
+          archivedAt: project.archivedAt,
+          archivedReason: project.archivedReason,
+          created: project.created,
+          updated,
+          tags: project.tags,
+          progress: rollup.progress,
+          needsAttention: rollup.needsAttention,
+          workspace: project.workspace
+        }
+      };
+    })
+  );
+  const records = maybeRecords.filter((r) => r !== null);
   records.sort((left, right) => compareTimestamps(right.summary.updated, left.summary.updated));
   return records;
 }
-async function listAssignmentRecords(projectPath) {
+async function listAssignmentRecords(projectPath, traces) {
   const assignmentsDir2 = resolve16(projectPath, "assignments");
   if (!await fileExists(assignmentsDir2)) {
     return [];
   }
   const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
-  const records = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const assignmentMd = resolve16(assignmentsDir2, entry.name, "assignment.md");
-    if (!await fileExists(assignmentMd)) {
-      continue;
-    }
-    const content = await readFile11(assignmentMd, "utf-8");
-    records.push(parseAssignmentFull(content));
-  }
+  const dirEntries = entries.filter((entry) => entry.isDirectory());
+  const maybeRecords = await Promise.all(
+    dirEntries.map(async (entry) => {
+      const assignmentMd = resolve16(assignmentsDir2, entry.name, "assignment.md");
+      if (!await fileExists(assignmentMd)) {
+        return null;
+      }
+      const t0 = traces ? performance.now() : 0;
+      const content = await readFile11(assignmentMd, "utf-8");
+      const parsed = parseAssignmentFull(content);
+      if (traces) accumulatePhase(traces, "read-assignment-md", performance.now() - t0);
+      return parsed;
+    })
+  );
+  const records = maybeRecords.filter((r) => r !== null);
   records.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return records;
 }
@@ -6782,13 +6847,20 @@ async function loadDependencyGraph(projectPath, assignments) {
   }
   return buildDependencyGraph(assignments);
 }
-async function buildProjectRollup(projectPath, project, assignments) {
+async function buildProjectRollup(projectPath, project, assignments, traces) {
   const progress = { total: assignments.length };
+  const perAssignment = await Promise.all(
+    assignments.map(async (assignment) => {
+      const t0 = traces ? performance.now() : 0;
+      const openQuestions2 = await countOpenQuestions(projectPath, assignment.slug);
+      if (traces) accumulatePhase(traces, "count-open-questions", performance.now() - t0);
+      return { status: assignment.status, openQuestions: openQuestions2 };
+    })
+  );
   let openQuestions = 0;
-  for (const assignment of assignments) {
-    const s = assignment.status;
-    progress[s] = (progress[s] ?? 0) + 1;
-    openQuestions += await countOpenQuestions(projectPath, assignment.slug);
+  for (const entry of perAssignment) {
+    progress[entry.status] = (progress[entry.status] ?? 0) + 1;
+    openQuestions += entry.openQuestions;
   }
   const needsAttention = {
     blockedCount: progress["blocked"] ?? 0,
@@ -6869,18 +6941,26 @@ function buildDependencyGraph(assignments) {
 function findAssignmentStatus(assignments, slug) {
   return assignments.find((assignment) => assignment.slug === slug)?.status ?? "pending";
 }
-async function getAvailableTransitions(projectsDir2, projectSlug, assignmentSlug, assignment) {
+async function getAvailableTransitions(projectsDir2, projectSlug, assignmentSlug, assignment, options) {
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
   const projectPath = resolve16(projectsDir2, projectSlug);
+  const traces = options?.traces;
   for (const definition of transitionDefs) {
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
       warning = "No assignee set \u2014 consider assigning before starting.";
     }
     if (definition.command === "start" && assignment.dependsOn.length > 0) {
-      const unmetDependencies = await getUnmetDependencies(projectPath, assignment.dependsOn, config.terminalStatuses);
+      const t0 = traces ? performance.now() : 0;
+      const unmetDependencies = await getUnmetDependencies(
+        projectPath,
+        assignment.dependsOn,
+        config.terminalStatuses,
+        options?.dependencyStatusMap
+      );
+      if (traces) accumulatePhase(traces, "get-unmet-dependencies", performance.now() - t0);
       if (unmetDependencies.length > 0) {
         warning = `Unmet dependencies: ${unmetDependencies.join(", ")}.`;
       }
@@ -6899,10 +6979,19 @@ async function getAvailableTransitions(projectsDir2, projectSlug, assignmentSlug
   }
   return actions;
 }
-async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses3) {
+async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses3, dependencyStatusMap) {
   const terminals = terminalStatuses3 ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const dependency of dependsOn) {
+    if (dependencyStatusMap) {
+      const mappedStatus = dependencyStatusMap.get(dependency);
+      if (mappedStatus !== void 0) {
+        if (!terminals.has(mappedStatus)) {
+          unmet.push(`${dependency} (${mappedStatus})`);
+        }
+        continue;
+      }
+    }
     const dependencyPath = resolve16(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
@@ -6940,23 +7029,35 @@ function segmentSeverity(segment) {
       return "medium";
   }
 }
-async function buildOverviewSegmentBuckets(projectsDir2, projectRecords, standaloneRecords) {
+async function buildOverviewSegmentBuckets(projectsDir2, projectRecords, standaloneRecords, traces) {
   const now = Date.now();
   const buckets = emptyBuckets();
   const newestPool = [];
   for (const record of projectRecords) {
-    for (const assignment of record.assignments) {
+    const depMap = /* @__PURE__ */ new Map();
+    for (const a of record.assignments) {
+      depMap.set(a.slug, a.status);
+    }
+    const resolvedTransitions = await Promise.all(
+      record.assignments.map(async (assignment) => {
+        const t0 = traces ? performance.now() : 0;
+        const availableTransitions = await getAvailableTransitions(
+          projectsDir2,
+          record.summary.slug,
+          assignment.slug,
+          assignment,
+          { traces, dependencyStatusMap: depMap }
+        );
+        if (traces) accumulatePhase(traces, "get-available-transitions", performance.now() - t0);
+        return { assignment, availableTransitions };
+      })
+    );
+    for (const { assignment, availableTransitions } of resolvedTransitions) {
       const segmentId = STATUS_TO_SEGMENT[assignment.status];
       const stale = isStale(assignment.updated);
       const isTerminal = TERMINAL_STATUSES2.has(assignment.status);
       const agingMs = Math.max(0, now - parseTimestamp(assignment.updated));
       const baseId = `${record.summary.slug}:${assignment.slug}`;
-      const availableTransitions = await getAvailableTransitions(
-        projectsDir2,
-        record.summary.slug,
-        assignment.slug,
-        assignment
-      );
       const shared = {
         projectSlug: record.summary.slug,
         projectTitle: record.summary.title,
@@ -7006,14 +7107,21 @@ async function buildOverviewSegmentBuckets(projectsDir2, projectRecords, standal
       }
     }
   }
-  for (const sr of standaloneRecords) {
+  const resolvedStandaloneTransitions = await Promise.all(
+    standaloneRecords.map(async (sr) => {
+      const t0 = traces ? performance.now() : 0;
+      const availableTransitions = await getStandaloneAvailableTransitions(sr.record);
+      if (traces) accumulatePhase(traces, "get-available-transitions", performance.now() - t0);
+      return { sr, availableTransitions };
+    })
+  );
+  for (const { sr, availableTransitions } of resolvedStandaloneTransitions) {
     const assignment = sr.record;
     const segmentId = STATUS_TO_SEGMENT[assignment.status];
     const stale = isStale(assignment.updated);
     const isTerminal = TERMINAL_STATUSES2.has(assignment.status);
     const agingMs = Math.max(0, now - parseTimestamp(assignment.updated));
     const baseId = `standalone:${sr.id}`;
-    const availableTransitions = await getStandaloneAvailableTransitions(assignment);
     const shared = {
       projectSlug: null,
       projectTitle: null,