@kitsy/coop-ui 0.0.1 → 1.0.0

package/src/server/__tests__/snapshot.test.ts

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { readCoopSnapshot } from "../snapshot";
+
+const tempRoots: string[] = [];
+
+function makeRepo(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "coop-ui-"));
+  tempRoots.push(root);
+  fs.mkdirSync(path.join(root, ".coop", "tasks"), { recursive: true });
+  fs.mkdirSync(path.join(root, ".coop", "deliveries"), { recursive: true });
+  fs.mkdirSync(path.join(root, ".coop", "resources"), { recursive: true });
+  fs.writeFileSync(path.join(root, ".coop", "config.yml"), "project:\n  name: Demo\n", "utf8");
+  return root;
+}
+
+afterEach(() => {
+  while (tempRoots.length > 0) {
+    const next = tempRoots.pop();
+    if (!next) continue;
+    fs.rmSync(next, { recursive: true, force: true });
+  }
+});
+
+describe("readCoopSnapshot", () => {
+  it("builds a dashboard snapshot from .coop index and source files", () => {
+    const root = makeRepo();
+    fs.writeFileSync(
+      path.join(root, ".coop", "tasks", "PM-1.md"),
+      [
+        "---",
+        "id: PM-1",
+        "title: API foundation",
+        "status: done",
+        "type: feature",
+        "priority: p1",
+        "track: backend",
+        "created: 2026-03-01",
+        "updated: 2026-03-02",
+        "depends_on: []",
+        "---",
+        "Body"
+      ].join("\n"),
+      "utf8"
+    );
+    fs.writeFileSync(
+      path.join(root, ".coop", "tasks", "PM-2.md"),
+      [
+        "---",
+        "id: PM-2",
+        "title: UI dashboard",
+        "status: in_progress",
+        "type: feature",
+        "priority: p0",
+        "track: frontend",
+        "created: 2026-03-03",
+        "updated: 2026-03-04",
+        "depends_on:",
+        "  - PM-1",
+        "estimate:",
+        "  optimistic_hours: 8",
+        "  expected_hours: 12",
+        "  pessimistic_hours: 16",
+        "---",
+        "Body"
+      ].join("\n"),
+      "utf8"
+    );
+    fs.writeFileSync(
+      path.join(root, ".coop", "resources", "team.yml"),
+      [
+        "id: team",
+        "type: human",
+        "members:",
+        "  - id: dev1",
+        "    hours_per_week: 40",
+        "  - id: dev2",
+        "    hours_per_week: 40",
+        "overhead:",
+        "  meetings_percent: 10",
+        "  context_switch_percent: 10"
+      ].join("\n"),
+      "utf8"
+    );
+    fs.writeFileSync(
+      path.join(root, ".coop", "deliveries", "mvp.yml"),
+      [
+        "id: MVP",
+        "name: MVP",
+        "status: committed",
+        "target_date: 2026-04-15",
+        "capacity_profiles:",
+        "  - team",
+        "scope:",
+        "  include:",
+        "    - PM-1",
+        "    - PM-2",
+        "  exclude: []"
+      ].join("\n"),
+      "utf8"
+    );
+    fs.mkdirSync(path.join(root, ".coop", "runs"), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, ".coop", "runs", "run-1.yml"),
+      [
+        "id: run-1",
+        "task: PM-1",
+        "executor: mock",
+        "status: completed",
+        "started: 2026-03-01T10:00:00.000Z",
+        "completed: 2026-03-01T11:00:00.000Z",
+        "steps: []",
+        "resources_consumed:",
+        "  ai_tokens: 0",
+        "  compute_minutes: 0",
+        "  file_changes: 0"
+      ].join("\n"),
+      "utf8"
+    );
+
+    const snapshot = readCoopSnapshot(root, "2026-03-18");
+
+    expect(snapshot.tasks).toHaveLength(2);
+    expect(snapshot.deliveries).toHaveLength(1);
+    expect(snapshot.graph.edges).toEqual([{ from: "PM-1", to: "PM-2" }]);
+    expect(snapshot.statusCounts.some((entry) => entry.status === "done" && entry.count === 1)).toBe(true);
+    expect(snapshot.deliveries[0]?.criticalPath).toContain("PM-2");
+  });
+});

package/src/server/snapshot.ts

@@ -0,0 +1,214 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  IndexManager,
+  analyze_feasibility,
+  compute_velocity,
+  detect_delivery_risks,
+  load_completed_runs,
+  type Delivery,
+  type Task,
+  type TaskGraph
+} from "@kitsy/coop-core";
+
+import type { UiCapacityProfile, UiDelivery, UiSnapshot, UiTask } from "../types";
+
+type TasksIndexRow = {
+  readiness?: string;
+  depth?: number;
+};
+
+type CapacityIndexProfile = {
+  id?: string;
+  type?: string;
+  members?: number;
+  total_weekly_hours?: number;
+  effective_weekly_hours?: number;
+};
+
+function readJsonFile<T>(filePath: string, fallback: T): T {
+  if (!fs.existsSync(filePath)) return fallback;
+  return JSON.parse(fs.readFileSync(filePath, "utf8")) as T;
+}
+
+function percent(part: number, whole: number): number {
+  if (whole <= 0) return 0;
+  return Number(((part / whole) * 100).toFixed(1));
+}
+
+function activeScope(delivery: Delivery, graph: TaskGraph) {
+  const include = new Set(delivery.scope.include);
+  for (const excluded of delivery.scope.exclude) include.delete(excluded);
+  return Array.from(include)
+    .map((id) => graph.nodes.get(id))
+    .filter((task): task is Task => Boolean(task));
+}
+
+function deliveryHealth(status: string, riskCount: number): "healthy" | "warning" | "at-risk" {
+  if (status !== "FEASIBLE" || riskCount >= 3) return "at-risk";
+  if (riskCount > 0) return "warning";
+  return "healthy";
+}
+
+function buildBurndown(deliveryTaskIds: Set<string>, runs: ReturnType<typeof load_completed_runs>, currentRemaining: number) {
+  const seen = new Set<string>();
+  const daily = new Map<string, number>();
+
+  for (const run of runs) {
+    const taskId = String(run.task ?? "");
+    if (!deliveryTaskIds.has(taskId) || seen.has(taskId)) continue;
+    seen.add(taskId);
+    const completed = typeof run.completed === "string" ? run.completed : typeof run.started === "string" ? run.started : null;
+    if (!completed) continue;
+    const label = completed.slice(0, 10);
+    daily.set(label, (daily.get(label) ?? 0) + 1);
+  }
+
+  const total = deliveryTaskIds.size;
+  let remaining = total;
+  const points = [{ label: "Start", remaining }];
+  for (const label of Array.from(daily.keys()).sort((a, b) => a.localeCompare(b))) {
+    remaining = Math.max(0, remaining - (daily.get(label) ?? 0));
+    points.push({ label, remaining });
+  }
+  if (points[points.length - 1]?.remaining !== currentRemaining) {
+    points.push({ label: "Now", remaining: currentRemaining });
+  }
+  return points;
+}
+
+function loadGraph(coopDir: string): TaskGraph {
+  const manager = new IndexManager(coopDir);
+  const indexed = manager.load_indexed_graph();
+  if (!indexed || manager.is_stale()) {
+    return manager.build_full_index();
+  }
+  return indexed;
+}
+
+export function readCoopSnapshot(repoRoot: string, today = new Date().toISOString().slice(0, 10)): UiSnapshot {
+  const coopDir = path.join(path.resolve(repoRoot), ".coop");
+  if (!fs.existsSync(coopDir)) {
+    throw new Error(`Missing .coop directory at ${coopDir}. Run 'coop init' and 'coop index build' first.`);
+  }
+
+  const manager = new IndexManager(coopDir);
+  const graph = loadGraph(coopDir);
+  const tasksIndex = readJsonFile<Record<string, TasksIndexRow>>(manager.tasksPath, {});
+  const capacityIndex = readJsonFile<{ profiles?: Record<string, CapacityIndexProfile> }>(manager.capacityPath, {});
+  const runs = load_completed_runs(coopDir);
+  const velocity = compute_velocity(runs, 4, { today, graph });
+
+  const deliveryMembership = new Map<string, string[]>();
+  for (const delivery of graph.deliveries.values()) {
+    for (const task of activeScope(delivery, graph)) {
+      const ids = deliveryMembership.get(task.id) ?? [];
+      ids.push(delivery.id);
+      deliveryMembership.set(task.id, ids);
+    }
+  }
+
+  const tasks: UiTask[] = Array.from(graph.nodes.values())
+    .map((task) => ({
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      priority: task.priority ?? null,
+      track: task.track ?? null,
+      assignee: task.assignee ?? null,
+      readiness: tasksIndex[task.id]?.readiness ?? "unknown",
+      depth: Number(tasksIndex[task.id]?.depth ?? 0),
+      dependsOn: [...(graph.forward.get(task.id) ?? new Set<string>())].sort((a, b) => a.localeCompare(b)),
+      blocks: [...(graph.reverse.get(task.id) ?? new Set<string>())].sort((a, b) => a.localeCompare(b)),
+      deliveryIds: (deliveryMembership.get(task.id) ?? []).sort((a, b) => a.localeCompare(b)),
+      riskLevel: task.risk?.level ?? null
+    }))
+    .sort((a, b) => a.id.localeCompare(b.id));
+
+  const statusCounts = Array.from(
+    tasks.reduce((map, task) => map.set(task.status, (map.get(task.status) ?? 0) + 1), new Map<string, number>()).entries()
+  )
+    .map(([status, count]) => ({ status, count }))
+    .sort((a, b) => a.status.localeCompare(b.status));
+
+  const deliveries: UiDelivery[] = Array.from(graph.deliveries.values())
+    .map((delivery) => {
+      const scopedTasks = activeScope(delivery, graph);
+      const taskIds = new Set(scopedTasks.map((task) => task.id));
+      const completedTasks = scopedTasks.filter((task) => task.status === "done").length;
+      const remainingTasks = scopedTasks.filter((task) => task.status !== "done" && task.status !== "canceled").length;
+      const feasibility = analyze_feasibility(delivery.id, graph, today);
+      const risks = detect_delivery_risks(delivery, graph, velocity, { today });
+      return {
+        id: delivery.id,
+        name: delivery.name,
+        status: delivery.status,
+        targetDate: delivery.target_date,
+        projectedDate: feasibility.summary.dates.projected,
+        health: deliveryHealth(feasibility.status, risks.length),
+        completionPercent: percent(completedTasks, scopedTasks.length),
+        totalTasks: scopedTasks.length,
+        completedTasks,
+        remainingTasks,
+        requiredHours: Number(feasibility.summary.effort_hours.required.toFixed(1)),
+        budgetHours:
+          Number.isFinite(feasibility.summary.effort_hours.budget) ? Number(feasibility.summary.effort_hours.budget.toFixed(1)) : null,
+        riskMessages: risks.map((risk) => risk.message),
+        criticalPath: [...feasibility.summary.critical_path],
+        utilization: feasibility.simulation.utilization_by_track.map((entry) => ({
+          track: entry.track,
+          allocatedHours: Number(entry.allocated_hours.toFixed(1)),
+          capacityHours: Number(entry.capacity_hours.toFixed(1)),
+          utilization: Number((entry.utilization * 100).toFixed(1))
+        })),
+        burndown: buildBurndown(taskIds, runs, remainingTasks)
+      } satisfies UiDelivery;
+    })
+    .sort((a, b) => a.id.localeCompare(b.id));
+
+  const capacityProfiles: UiCapacityProfile[] = Object.values(capacityIndex.profiles ?? {})
+    .map((profile) => ({
+      id: profile.id ?? "unknown",
+      type: profile.type ?? "unknown",
+      totalWeeklyHours: typeof profile.total_weekly_hours === "number" ? profile.total_weekly_hours : null,
+      effectiveWeeklyHours: typeof profile.effective_weekly_hours === "number" ? profile.effective_weekly_hours : null,
+      members: typeof profile.members === "number" ? profile.members : null
+    }))
+    .sort((a, b) => a.id.localeCompare(b.id));
+
+  const edges = Array.from(graph.forward.entries())
+    .flatMap(([taskId, deps]) => Array.from(deps).map((dep) => ({ from: dep, to: taskId })))
+    .sort((a, b) => `${a.from}:${a.to}`.localeCompare(`${b.from}:${b.to}`));
+
+  return {
+    generatedAt: new Date().toISOString(),
+    repoRoot: path.resolve(repoRoot),
+    statusCounts,
+    velocity: {
+      completedRuns: velocity.completed_runs,
+      tasksPerWeek: Number(velocity.tasks_completed_per_week.toFixed(2)),
+      hoursPerWeek: Number(velocity.hours_delivered_per_week.toFixed(2)),
+      accuracyRatio: Number((velocity.accuracy_ratio ?? 0).toFixed(2)),
+      trend: velocity.trend,
+      points: velocity.points.map((point) => ({
+        label: point.week_start,
+        tasksCompleted: point.completed_tasks,
+        hoursDelivered: Number(point.delivered_hours.toFixed(2))
+      }))
+    },
+    tasks,
+    deliveries,
+    graph: {
+      nodes: tasks.map((task) => ({
+        id: task.id,
+        title: task.title,
+        status: task.status,
+        track: task.track,
+        depth: task.depth
+      })),
+      edges
+    },
+    capacityProfiles
+  };
+}

package/src/styles.css

@@ -0,0 +1,30 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+:root {
+  color: #111318;
+  background:
+    radial-gradient(circle at top left, rgba(217, 107, 43, 0.18), transparent 34%),
+    radial-gradient(circle at top right, rgba(41, 89, 74, 0.15), transparent 28%),
+    linear-gradient(180deg, #f4efe2 0%, #f7f4eb 100%);
+  font-family: "IBM Plex Sans", "Segoe UI", sans-serif;
+}
+
+body {
+  margin: 0;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+#root {
+  min-height: 100vh;
+}
+
+.card-grid {
+  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+}
+
+.metric-grid {
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+}

package/src/types.ts

@@ -0,0 +1,82 @@
+export type UiStatusCount = {
+  status: string;
+  count: number;
+};
+
+export type UiVelocity = {
+  completedRuns: number;
+  tasksPerWeek: number;
+  hoursPerWeek: number;
+  accuracyRatio: number;
+  trend: string;
+  points: Array<{ label: string; tasksCompleted: number; hoursDelivered: number }>;
+};
+
+export type UiTask = {
+  id: string;
+  title: string;
+  status: string;
+  priority: string | null;
+  track: string | null;
+  assignee: string | null;
+  readiness: string;
+  depth: number;
+  dependsOn: string[];
+  blocks: string[];
+  deliveryIds: string[];
+  riskLevel: string | null;
+};
+
+export type UiDelivery = {
+  id: string;
+  name: string;
+  status: string;
+  targetDate: string | null;
+  projectedDate: string | null;
+  health: "healthy" | "warning" | "at-risk";
+  completionPercent: number;
+  totalTasks: number;
+  completedTasks: number;
+  remainingTasks: number;
+  requiredHours: number;
+  budgetHours: number | null;
+  riskMessages: string[];
+  criticalPath: string[];
+  utilization: Array<{ track: string; allocatedHours: number; capacityHours: number; utilization: number }>;
+  burndown: Array<{ label: string; remaining: number }>;
+};
+
+export type UiGraphNode = {
+  id: string;
+  title: string;
+  status: string;
+  track: string | null;
+  depth: number;
+};
+
+export type UiGraphEdge = {
+  from: string;
+  to: string;
+};
+
+export type UiCapacityProfile = {
+  id: string;
+  type: string;
+  totalWeeklyHours: number | null;
+  effectiveWeeklyHours: number | null;
+  members: number | null;
+};
+
+export type UiSnapshot = {
+  generatedAt: string;
+  repoRoot: string;
+  statusCounts: UiStatusCount[];
+  velocity: UiVelocity;
+  tasks: UiTask[];
+  deliveries: UiDelivery[];
+  graph: {
+    nodes: UiGraphNode[];
+    edges: UiGraphEdge[];
+  };
+  capacityProfiles: UiCapacityProfile[];
+};

package/tailwind.config.ts

@@ -0,0 +1,25 @@
+import type { Config } from "tailwindcss";
+
+export default {
+  content: ["./index.html", "./src/**/*.{ts,tsx}"],
+  theme: {
+    extend: {
+      colors: {
+        ink: "#111318",
+        paper: "#f7f4eb",
+        accent: "#d96b2b",
+        moss: "#29594a",
+        steel: "#44505f",
+        sand: "#d6c4a8"
+      },
+      fontFamily: {
+        sans: ['"IBM Plex Sans"', '"Segoe UI"', 'sans-serif'],
+        mono: ['"IBM Plex Mono"', '"Cascadia Code"', 'monospace']
+      },
+      boxShadow: {
+        panel: "0 18px 45px rgba(17, 19, 24, 0.12)"
+      }
+    }
+  },
+  plugins: []
+} satisfies Config;

package/vite.config.ts

@@ -0,0 +1,39 @@
+import { defineConfig, type Plugin } from "vite";
+import react from "@vitejs/plugin-react";
+
+import { readCoopSnapshot } from "./src/server/snapshot";
+
+function coopDataPlugin(): Plugin {
+  return {
+    name: "coop-data-plugin",
+    configureServer(server) {
+      server.middlewares.use("/__coop/data", (_req, res) => {
+        try {
+          const repoRoot = process.env.COOP_REPO_ROOT ?? process.cwd();
+          const snapshot = readCoopSnapshot(repoRoot);
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(snapshot));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          res.statusCode = 500;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ message }));
+        }
+      });
+    }
+  };
+}
+
+export default defineConfig({
+  plugins: [react(), coopDataPlugin()],
+  server: {
+    host: process.env.COOP_UI_HOST ?? "127.0.0.1",
+    port: Number(process.env.COOP_UI_PORT ?? "4173"),
+    open: false
+  },
+  preview: {
+    host: process.env.COOP_UI_HOST ?? "127.0.0.1",
+    port: Number(process.env.COOP_UI_PORT ?? "4173")
+  }
+});

package/dist/index.cjs

@@ -1,33 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  coopUi: () => coopUi
-});
-module.exports = __toCommonJS(index_exports);
-var coopUi = {
-  package: "@kitsy/coop-ui",
-  status: "planned"
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  coopUi
-});

package/dist/index.d.cts

@@ -1,7 +0,0 @@
-type CoopUiPlaceholder = {
-    readonly package: "@kitsy/coop-ui";
-    readonly status: "planned";
-};
-declare const coopUi: CoopUiPlaceholder;
-
-export { type CoopUiPlaceholder, coopUi };

package/dist/index.d.ts

@@ -1,7 +0,0 @@
-type CoopUiPlaceholder = {
-    readonly package: "@kitsy/coop-ui";
-    readonly status: "planned";
-};
-declare const coopUi: CoopUiPlaceholder;
-
-export { type CoopUiPlaceholder, coopUi };

package/dist/index.js

@@ -1,8 +0,0 @@
-// src/index.ts
-var coopUi = {
-  package: "@kitsy/coop-ui",
-  status: "planned"
-};
-export {
-  coopUi
-};

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist"
-  },
-  "include": ["src/**/*.ts"]
-}