syntaur 0.16.2 → 0.16.3

package/dist/launch/index.js

@@ -1715,6 +1715,10 @@ var init_overviewCopy = __esm({
 // src/dashboard/api.ts
 import { readdir as readdir6, readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
 import { resolve as resolve11, dirname as dirname2, basename } from "path";
+function accumulatePhase(traces, label, ms) {
+  if (!traces) return;
+  traces.subPhases.set(label, (traces.subPhases.get(label) ?? 0) + ms);
+}
 async function listStandaloneRecords(assignmentsDir) {
   if (!assignmentsDir) return [];
   if (!await fileExists(assignmentsDir)) return [];
@@ -2169,7 +2173,7 @@ async function buildStandaloneAssignmentDetail(resolved) {
   };
   return detail;
 }
-async function listProjectRecords(projectsDir) {
+async function listProjectRecords(projectsDir, traces) {
   if (!await fileExists(projectsDir)) {
     return [];
   }
@@ -2179,61 +2183,75 @@ async function listProjectRecords(projectsDir) {
   }
   const entries = await readdir6(projectsDir, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
-  const records = [];
-  for (const entry of projectDirs) {
-    const projectPath = resolve11(projectsDir, entry.name);
-    const projectMdPath = resolve11(projectPath, "project.md");
-    if (!await fileExists(projectMdPath)) {
-      continue;
-    }
-    const projectContent = await readFile8(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 = resolve11(projectsDir, entry.name);
+      const projectMdPath = resolve11(projectPath, "project.md");
+      if (!await fileExists(projectMdPath)) {
+        return null;
       }
-    });
-  }
+      const t0 = traces ? performance.now() : 0;
+      const projectContent = await readFile8(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 assignmentsDir = resolve11(projectPath, "assignments");
   if (!await fileExists(assignmentsDir)) {
     return [];
   }
   const entries = await readdir6(assignmentsDir, { withFileTypes: true });
-  const records = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const assignmentMd = resolve11(assignmentsDir, entry.name, "assignment.md");
-    if (!await fileExists(assignmentMd)) {
-      continue;
-    }
-    const content = await readFile8(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 = resolve11(assignmentsDir, entry.name, "assignment.md");
+      if (!await fileExists(assignmentMd)) {
+        return null;
+      }
+      const t0 = traces ? performance.now() : 0;
+      const content = await readFile8(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;
 }
@@ -2249,13 +2267,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,
@@ -2308,18 +2333,26 @@ function buildDependencyGraph(assignments) {
 function findAssignmentStatus(assignments, slug) {
   return assignments.find((assignment) => assignment.slug === slug)?.status ?? "pending";
 }
-async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug, assignment) {
+async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug, assignment, options) {
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
   const projectPath = resolve11(projectsDir, 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(", ")}.`;
       }
@@ -2338,10 +2371,19 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   }
   return actions;
 }
-async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses) {
+async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses, dependencyStatusMap) {
   const terminals = terminalStatuses ?? /* @__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 = resolve11(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);