@a5c-ai/babysitter-observer-dashboard 5.0.1-staging.05ee168a

package/src/lib/services/run-query-service.ts

@@ -0,0 +1,286 @@
+import { getConfig as defaultGetConfig } from "@/lib/config-loader";
+import { discoverAllRunDirs as defaultDiscoverAllRunDirs } from "@/lib/source-discovery";
+import {
+  getProjectSummaries as defaultGetProjectSummaries,
+  getRunCached as defaultGetRunCached,
+  discoverAndCacheAll as defaultDiscoverAndCacheAll,
+} from "@/lib/run-cache";
+import type { Run, ProjectSummary } from "@/types";
+import type { ObserverConfig, WatchSource } from "@/lib/config-loader";
+import type { DiscoveredRun } from "@/lib/source-discovery";
+
+// ---------------------------------------------------------------------------
+// Query parameter types
+// ---------------------------------------------------------------------------
+
+export type SortMode = "status" | "activity";
+
+export interface RunQueryParams {
+  limit: number;
+  offset: number;
+  search: string;
+  status: string;
+  sort: SortMode;
+}
+
+export type ProjectsQueryParams = Record<string, never>;
+
+export interface ProjectRunsQueryParams extends RunQueryParams {
+  project: string;
+}
+
+// ---------------------------------------------------------------------------
+// Response types
+// ---------------------------------------------------------------------------
+
+/** A run with events stripped to reduce payload size. */
+export interface LightRun extends Omit<Run, "events"> {
+  events: never[];
+  totalEvents: number;
+}
+
+export interface ProjectsResponse {
+  projects: ProjectSummary[];
+  recentCompletionWindowMs: number;
+}
+
+export interface RunsListResponse {
+  runs: LightRun[];
+  totalCount: number;
+  project?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Shared utilities
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns a numeric sort priority for a run:
+ *   0 = Active non-stale (waiting/pending where !isStale)
+ *   1 = Stale runs (isStale === true)
+ *   2 = Failed runs
+ *   3 = Completed runs
+ */
+export function runSortPriority(run: Run): number {
+  const isActive = run.status === "waiting" || run.status === "pending";
+  if (isActive && !run.isStale) return 0;
+  if (run.isStale) return 1;
+  if (run.status === "failed") return 2;
+  return 3;
+}
+
+/** Sort runs in-place based on the chosen sort mode.
+ *
+ * Uses runId as a final tiebreaker to guarantee deterministic ordering
+ * even when multiple runs share the same priority and updatedAt timestamp.
+ * This prevents list items from visually jumping positions during rapid
+ * updates (the "morning chaos" scenario).
+ */
+export function sortRuns(runs: Run[], sort: SortMode): void {
+  if (sort === "activity") {
+    // Simple updatedAt DESC -- most recent activity first, no tier grouping.
+    // runId tiebreaker ensures stable order for runs with identical timestamps.
+    runs.sort((a, b) => {
+      const cmp = (b.updatedAt || "").localeCompare(a.updatedAt || "");
+      if (cmp !== 0) return cmp;
+      return a.runId.localeCompare(b.runId);
+    });
+  } else {
+    // Default: sort by priority tier, then by updatedAt DESC within tier,
+    // with runId as a final tiebreaker for deterministic ordering.
+    runs.sort((a, b) => {
+      const pa = runSortPriority(a);
+      const pb = runSortPriority(b);
+      if (pa !== pb) return pa - pb;
+      const cmp = (b.updatedAt || "").localeCompare(a.updatedAt || "");
+      if (cmp !== 0) return cmp;
+      return a.runId.localeCompare(b.runId);
+    });
+  }
+}
+
+/** Apply search filter -- returns a new array. */
+export function filterBySearch(runs: Run[], search: string): Run[] {
+  if (!search) return runs;
+  const searchLower = search.toLowerCase();
+  return runs.filter(
+    (r) =>
+      r.runId.toLowerCase().includes(searchLower) ||
+      r.processId.toLowerCase().includes(searchLower) ||
+      (r.projectName || "").toLowerCase().includes(searchLower) ||
+      r.status.toLowerCase().includes(searchLower) ||
+      r.tasks.some(
+        (t) =>
+          t.title.toLowerCase().includes(searchLower) ||
+          t.label.toLowerCase().includes(searchLower) ||
+          (t.error?.message || "").toLowerCase().includes(searchLower) ||
+          (t.error?.name || "").toLowerCase().includes(searchLower)
+      )
+  );
+}
+
+/** Apply status filter -- returns a new array. */
+export function filterByStatus(runs: Run[], status: string): Run[] {
+  if (!status) return runs;
+  return runs.filter((r) => {
+    if (status === "waiting") return r.status === "waiting" || r.status === "pending";
+    return r.status === status;
+  });
+}
+
+/** Apply retention filter -- keeps active/stale runs regardless of age. */
+export function filterByRetention(runs: Run[], retentionDays: number): Run[] {
+  const retentionCutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+  return runs.filter((r) => {
+    const isActive = r.status === "waiting" || r.status === "pending" || r.isStale;
+    if (isActive) return true;
+    return new Date(r.updatedAt || "").getTime() >= retentionCutoff;
+  });
+}
+
+/** Paginate an array: returns a new slice. */
+export function paginate<T>(items: T[], offset: number, limit: number): T[] {
+  if (limit > 0) {
+    return items.slice(offset, offset + limit);
+  }
+  return items;
+}
+
+/** Strip events from runs to reduce payload. */
+export function toLightRuns(runs: Run[]): LightRun[] {
+  return runs.map(({ events, ...rest }) => ({
+    ...rest,
+    events: [] as never[],
+    totalEvents: events.length,
+  }));
+}
+
+// ---------------------------------------------------------------------------
+// Dependency injection interface
+// ---------------------------------------------------------------------------
+
+export interface RunQueryDeps {
+  getConfig: () => Promise<ObserverConfig>;
+  discoverAllRunDirs: () => Promise<DiscoveredRun[]>;
+  getProjectSummaries: () => ProjectSummary[];
+  getRunCached: (runDir: string, source: WatchSource, projectName: string) => Promise<Run>;
+  discoverAndCacheAll: () => Promise<void>;
+}
+
+const defaultDeps: RunQueryDeps = {
+  getConfig: defaultGetConfig,
+  discoverAllRunDirs: defaultDiscoverAllRunDirs,
+  getProjectSummaries: defaultGetProjectSummaries,
+  getRunCached: defaultGetRunCached,
+  discoverAndCacheAll: defaultDiscoverAndCacheAll,
+};
+
+// ---------------------------------------------------------------------------
+// RunQueryService
+// ---------------------------------------------------------------------------
+
+export class RunQueryService {
+  private deps: RunQueryDeps;
+
+  constructor(deps?: Partial<RunQueryDeps>) {
+    this.deps = { ...defaultDeps, ...deps };
+  }
+
+  /**
+   * Mode: "projects" -- return lightweight project summaries.
+   * Always re-discovers to ensure all projects appear (debounced internally).
+   */
+  async listProjects(_params?: ProjectsQueryParams): Promise<ProjectsResponse> {
+    await this.deps.discoverAndCacheAll();
+    const config = await this.deps.getConfig();
+    const projects = this.deps.getProjectSummaries();
+
+    // Filter out hidden projects
+    const hiddenSet = new Set(config.hiddenProjects);
+    const visibleProjects = projects.filter((p) => !hiddenSet.has(p.projectName));
+
+    // Apply retention filter: exclude projects whose latest update is older than retentionDays
+    const retentionCutoff = Date.now() - config.retentionDays * 24 * 60 * 60 * 1000;
+    const retainedProjects = visibleProjects.filter(
+      (p) =>
+        // Always keep projects with active or stale runs regardless of age
+        p.activeRuns > 0 ||
+        p.staleRuns > 0 ||
+        new Date(p.latestUpdate).getTime() >= retentionCutoff
+    );
+
+    // Sort projects: active runs first, then by latest update, with
+    // projectName tiebreaker for deterministic ordering during rapid updates.
+    retainedProjects.sort((a, b) => {
+      if (a.activeRuns > 0 && b.activeRuns === 0) return -1;
+      if (a.activeRuns === 0 && b.activeRuns > 0) return 1;
+      const cmp = b.latestUpdate.localeCompare(a.latestUpdate);
+      if (cmp !== 0) return cmp;
+      return a.projectName.localeCompare(b.projectName);
+    });
+
+    return {
+      projects: retainedProjects,
+      recentCompletionWindowMs: config.recentCompletionWindowMs,
+    };
+  }
+
+  /**
+   * Mode: "project" -- return paginated runs for a specific project.
+   */
+  async listProjectRuns(params: ProjectRunsQueryParams): Promise<RunsListResponse> {
+    const { project, sort, status, search, limit, offset } = params;
+    const config = await this.deps.getConfig();
+    const allRuns = await this.deps.discoverAllRunDirs();
+
+    // Use cached runs for better performance
+    const runs = await Promise.all(
+      allRuns
+        .filter((r) => r.projectName === project)
+        .map(async ({ runDir, source, projectName }) => {
+          return await this.deps.getRunCached(runDir, source, projectName);
+        })
+    );
+
+    // Apply retention, sort, status filter, search, paginate
+    let filtered = filterByRetention(runs, config.retentionDays);
+    sortRuns(filtered, sort);
+    filtered = filterByStatus(filtered, status);
+    filtered = filterBySearch(filtered, search);
+
+    const totalCount = filtered.length;
+    const page = paginate(filtered, offset, limit);
+
+    return {
+      runs: toLightRuns(page),
+      totalCount,
+      project,
+    };
+  }
+
+  /**
+   * Default mode -- return all runs with totalCount.
+   */
+  async listAllRuns(params: RunQueryParams): Promise<RunsListResponse> {
+    const { sort, search, limit, offset } = params;
+    const allRuns = await this.deps.discoverAllRunDirs();
+
+    const runs = await Promise.all(
+      allRuns.map(async ({ runDir, source, projectName }) => {
+        return await this.deps.getRunCached(runDir, source, projectName);
+      })
+    );
+
+    // Sort, search, paginate (no retention filter on "all runs" -- matches original)
+    sortRuns(runs, sort);
+    let filtered = filterBySearch(runs, search);
+
+    const totalCount = filtered.length;
+    filtered = paginate(filtered, offset, limit);
+
+    return {
+      runs: toLightRuns(filtered),
+      totalCount,
+    };
+  }
+}

package/src/lib/source-discovery.ts

@@ -0,0 +1,216 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { isNotFoundError, getConfig, type WatchSource } from "./config-loader";
+
+export interface DiscoveredRun {
+  runDir: string;
+  source: WatchSource;
+  projectName: string; // e.g. "hockey_7_shifts", "podcast-intel"
+  projectPath: string; // full path to the project directory
+}
+
+// Discover all .a5c/runs/ directories within a source
+async function discoverRunsInSource(source: WatchSource): Promise<string[]> {
+  const results: string[] = [];
+
+  async function scan(dir: string, currentDepth: number) {
+    try {
+      // Check if this directory itself IS an .a5c/runs dir (depth=0 means direct path)
+      if (source.depth === 0) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        return entries
+          .filter((e) => e.isDirectory())
+          .map((e) => path.join(dir, e.name));
+      }
+
+      // Check for .a5c/runs/ at this level
+      const runsPath = path.join(dir, ".a5c", "runs");
+      try {
+        const stat = await fs.stat(runsPath);
+        if (stat.isDirectory()) {
+          results.push(runsPath);
+        }
+      } catch {
+        // Expected: no .a5c/runs directory at this level — skip silently
+      }
+
+      // Recurse into subdirectories if within depth
+      if (currentDepth < source.depth) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (
+            entry.isDirectory() &&
+            !entry.name.startsWith(".") &&
+            entry.name !== "node_modules"
+          ) {
+            await scan(path.join(dir, entry.name), currentDepth + 1);
+          }
+        }
+      }
+    } catch (err) {
+      if (!isNotFoundError(err)) {
+        console.warn(`[config] Cannot scan directory ${dir} (depth=${currentDepth}):`, err);
+      }
+    }
+  }
+
+  if (source.depth === 0) {
+    // Direct .a5c/runs path — just return runs inside it
+    try {
+      const entries = await fs.readdir(source.path, { withFileTypes: true });
+      return entries
+        .filter((e) => e.isDirectory())
+        .map((e) => path.join(source.path, e.name));
+    } catch (err) {
+      console.warn(`[config] Cannot list runs in direct source ${source.path}:`, err);
+      return [];
+    }
+  }
+
+  await scan(source.path, 0);
+  return results;
+}
+
+// Extract project name from a .a5c/runs/ path
+function extractProjectName(runsDir: string): { projectName: string; projectPath: string } {
+  // runsDir is like /path/to/project/.a5c/runs
+  // projectPath is /path/to/project
+  const a5cDir = path.dirname(runsDir); // .a5c
+  const projectPath = path.dirname(a5cDir); // project dir
+  const projectName = path.basename(projectPath);
+  return { projectName, projectPath };
+}
+
+// Cache discovery results to avoid repeated filesystem scanning
+let discoveryCache: DiscoveredRun[] = [];
+let discoveryCacheTime = 0;
+const DISCOVERY_CACHE_TTL = 10000; // 10s — watcher handles real-time changes
+
+// Force re-discovery on next call (called when new runs are detected by watcher)
+export function invalidateDiscoveryCache(): void {
+  discoveryCache = [];
+  discoveryCacheTime = 0;
+}
+
+// Get all run directories across all sources
+export async function discoverAllRunDirs(): Promise<DiscoveredRun[]> {
+  const now = Date.now();
+  if (discoveryCache.length > 0 && now - discoveryCacheTime < DISCOVERY_CACHE_TTL) {
+    return discoveryCache;
+  }
+
+  const config = await getConfig();
+  const allRuns: DiscoveredRun[] = [];
+
+  for (const source of config.sources) {
+    if (source.depth === 0) {
+      // Direct runs directory — list subdirs as individual runs
+      // Project name: prefer run.json's projectName, fall back to source label or path
+      const fallbackProjectName = source.label || path.basename(source.path);
+      try {
+        const entries = await fs.readdir(source.path, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            // Try to read projectName from run.json for more accurate project grouping
+            let projectName = fallbackProjectName;
+            try {
+              const runJsonPath = path.join(source.path, entry.name, "run.json");
+              const content = await fs.readFile(runJsonPath, "utf-8");
+              const json = JSON.parse(content);
+              if (json.projectName) {
+                projectName = json.projectName;
+              }
+            } catch (err) {
+              // run.json missing is expected for new runs; warn only on parse/permission errors
+              if (!isNotFoundError(err)) {
+                console.warn(`[config] Failed to read run.json in ${path.join(source.path, entry.name)} — using fallback project name:`, err);
+              }
+            }
+            allRuns.push({
+              runDir: path.join(source.path, entry.name),
+              source,
+              projectName,
+              projectPath: source.path,
+            });
+          }
+        }
+      } catch (err) {
+        console.warn(`[config] Source directory not accessible ${source.path}:`, err);
+      }
+    } else {
+      // Discover .a5c/runs/ directories within depth
+      const runsDirs = await discoverRunsInSource(source);
+      for (const runsDir of runsDirs) {
+        const { projectName, projectPath } = extractProjectName(runsDir);
+        try {
+          const entries = await fs.readdir(runsDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              allRuns.push({
+                runDir: path.join(runsDir, entry.name),
+                source,
+                projectName,
+                projectPath,
+              });
+            }
+          }
+        } catch (err) {
+          console.warn(`[config] Cannot read runs directory ${runsDir}:`, err);
+        }
+      }
+    }
+  }
+
+  // Deduplicate by runId (basename of runDir). When the same run ID appears
+  // under multiple .a5c/runs/ directories (e.g. a "ghost" .a5c created by a
+  // task execution in a subdirectory), keep the first occurrence — which is
+  // the shallowest/earliest discovered and typically the one with full data
+  // (run.json + journal).
+  const seenRunIds = new Map<string, DiscoveredRun>();
+  for (const run of allRuns) {
+    const runId = path.basename(run.runDir);
+    if (!seenRunIds.has(runId)) {
+      seenRunIds.set(runId, run);
+    } else {
+      // Prefer the run directory that has a run.json (i.e. the real one)
+      const existing = seenRunIds.get(runId)!;
+      const existingHasRunJson = await fs.access(path.join(existing.runDir, "run.json")).then(() => true, () => false);
+      if (!existingHasRunJson) {
+        const candidateHasRunJson = await fs.access(path.join(run.runDir, "run.json")).then(() => true, () => false);
+        if (candidateHasRunJson) {
+          seenRunIds.set(runId, run);
+        }
+      }
+    }
+  }
+
+  const result = Array.from(seenRunIds.values());
+  discoveryCache = result;
+  discoveryCacheTime = Date.now();
+  return result;
+}
+
+// Discover all .a5c/runs/ parent directories (including empty ones).
+// Used by the watcher to set up watches on directories that don't have runs yet,
+// so that the very first run in a new project is detected immediately.
+export async function discoverAllRunsParentDirs(): Promise<string[]> {
+  const config = await getConfig();
+  const allDirs: string[] = [];
+
+  for (const source of config.sources) {
+    if (source.depth === 0) {
+      // Direct runs path — watch the source path itself
+      try {
+        await fs.access(source.path);
+        allDirs.push(source.path);
+      } catch (err) {
+        console.warn(`[config] Watch source path not accessible ${source.path}:`, err);
+      }
+    } else {
+      const runsDirs = await discoverRunsInSource(source);
+      allDirs.push(...runsDirs);
+    }
+  }
+
+  return allDirs;
+}

package/src/lib/utils.ts

@@ -0,0 +1,103 @@
+export function formatDuration(ms: number | undefined | null): string {
+  if (ms == null || ms < 0) return "\u2014";
+  if (ms === 0) return "<1s";
+  if (ms < 1000) return `${ms}ms`;
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+
+export function formatTimestamp(iso: string | undefined): string {
+  if (!iso) return "\u2014";
+  try {
+    const d = new Date(iso);
+    return d.toLocaleTimeString("en-US", {
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+    });
+  } catch {
+    return "\u2014";
+  }
+}
+
+export function formatRelativeTime(iso: string | undefined): string {
+  if (!iso) return "";
+  try {
+    const diff = Date.now() - new Date(iso).getTime();
+    if (diff < 0) return "just now";
+    if (diff < 5000) return "just now";
+    if (diff < 60000) return `${Math.floor(diff / 1000)}s ago`;
+    if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
+    if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`;
+    return `${Math.floor(diff / 86400000)}d ago`;
+  } catch {
+    return "";
+  }
+}
+
+export function truncateId(id: string, len: number = 12): string {
+  if (!id) return "\u2014";
+  if (id.length <= len) return id;
+  return id.slice(0, len) + "...";
+}
+
+export function getStatusColor(status: string): string {
+  switch (status) {
+    case "completed":
+    case "resolved":
+    case "ok":
+      return "text-success";
+    case "failed":
+    case "error":
+      return "text-error";
+    case "waiting":
+    case "pending":
+      return "text-pending";
+    case "running":
+    case "requested":
+      return "text-info";
+    default:
+      return "text-foreground-muted";
+  }
+}
+
+export function getStatusBg(status: string): string {
+  switch (status) {
+    case "completed":
+    case "resolved":
+    case "ok":
+      return "bg-success-muted";
+    case "failed":
+    case "error":
+      return "bg-error-muted";
+    case "waiting":
+    case "pending":
+      return "bg-pending-muted";
+    case "running":
+    case "requested":
+      return "bg-info-muted";
+    default:
+      return "bg-muted";
+  }
+}
+
+export function formatShortId(id: string, chars: number = 4): string {
+  if (!id) return '—';
+  if (id.length <= chars) return id;
+  return '...' + id.slice(-chars);
+}
+
+export function friendlyProcessName(processId: string): string {
+  if (!processId) return '';
+  return processId
+    .split(/[-/]/)
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(' ');
+}