acp-visualizer-tui 0.1.0

package/dist/cli.js

@@ -0,0 +1,1505 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { render } from "ink";
+import meow from "meow";
+import fs4 from "fs";
+import path2 from "path";
+
+// src/lib/yaml-loader.ts
+import yaml from "js-yaml";
+var TASK_ALIASES = {
+  est_hours: "estimated_hours",
+  hours: "estimated_hours",
+  estimate: "estimated_hours",
+  completed: "completed_date",
+  done_date: "completed_date",
+  filename: "file",
+  path: "file"
+};
+function extractKnown(obj, knownKeys) {
+  if (!obj || typeof obj !== "object") return { known: {}, extra: {} };
+  const known = {};
+  const extra = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const resolved = TASK_ALIASES[key] ?? key;
+    if (knownKeys.includes(resolved)) {
+      known[resolved] = value;
+    } else {
+      extra[key] = value;
+    }
+  }
+  return { known, extra };
+}
+function normalizeStatus(value) {
+  const s = String(value || "not_started").toLowerCase().replace(/[\s-]/g, "_");
+  if (s === "completed" || s === "done" || s === "complete") return "completed";
+  if (s === "in_progress" || s === "active" || s === "wip") return "in_progress";
+  return "not_started";
+}
+function normalizeStringArray(value) {
+  if (!value) return [];
+  if (typeof value === "string") return [value];
+  if (!Array.isArray(value)) return [];
+  return value.map(String);
+}
+function safeString(value, fallback = "") {
+  if (value == null) return fallback;
+  return String(value);
+}
+function safeNumber(value, fallback = 0) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+function normalizeProject(raw) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  const { known, extra } = extractKnown(obj, [
+    "name",
+    "version",
+    "started",
+    "status",
+    "current_milestone",
+    "description"
+  ]);
+  return {
+    name: safeString(known.name, "Unknown Project"),
+    version: safeString(known.version, "0.0.0"),
+    started: safeString(known.started),
+    status: normalizeStatus(known.status),
+    current_milestone: known.current_milestone ? safeString(known.current_milestone) : void 0,
+    description: safeString(known.description),
+    extra
+  };
+}
+function normalizeMilestone(raw) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  const { known, extra } = extractKnown(obj, [
+    "id",
+    "name",
+    "status",
+    "progress",
+    "started",
+    "completed",
+    "estimated_weeks",
+    "tasks_completed",
+    "tasks_total",
+    "notes"
+  ]);
+  return {
+    id: safeString(known.id),
+    name: safeString(known.name),
+    status: normalizeStatus(known.status),
+    progress: safeNumber(known.progress),
+    started: known.started ? safeString(known.started) : null,
+    completed: known.completed ? safeString(known.completed) : null,
+    estimated_weeks: safeString(known.estimated_weeks),
+    tasks_completed: safeNumber(known.tasks_completed),
+    tasks_total: safeNumber(known.tasks_total),
+    notes: safeString(known.notes),
+    extra
+  };
+}
+function normalizeMilestones(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(normalizeMilestone);
+}
+function normalizeTask(raw, milestoneId) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  const { known, extra } = extractKnown(obj, [
+    "id",
+    "name",
+    "status",
+    "file",
+    "estimated_hours",
+    "completed_date",
+    "notes"
+  ]);
+  return {
+    id: safeString(known.id),
+    name: safeString(known.name),
+    status: normalizeStatus(known.status),
+    milestone_id: milestoneId,
+    file: safeString(known.file),
+    estimated_hours: safeString(known.estimated_hours),
+    completed_date: known.completed_date ? safeString(known.completed_date) : null,
+    notes: safeString(known.notes),
+    extra
+  };
+}
+function normalizeTasks(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const result = {};
+  for (const [milestoneId, tasks] of Object.entries(raw)) {
+    if (Array.isArray(tasks)) {
+      result[milestoneId] = tasks.map((t) => normalizeTask(t, milestoneId));
+    }
+  }
+  return result;
+}
+function normalizeWorkEntry(raw) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  const { known, extra } = extractKnown(obj, ["date", "description", "items"]);
+  return {
+    date: safeString(known.date),
+    description: safeString(known.description),
+    items: normalizeStringArray(known.items),
+    extra
+  };
+}
+function normalizeWorkEntries(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(normalizeWorkEntry);
+}
+function normalizeDocStats(raw) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  return {
+    design_documents: safeNumber(obj?.design_documents),
+    milestone_documents: safeNumber(obj?.milestone_documents),
+    pattern_documents: safeNumber(obj?.pattern_documents),
+    task_documents: safeNumber(obj?.task_documents)
+  };
+}
+function normalizeProgress(raw) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  return {
+    planning: safeNumber(obj?.planning),
+    implementation: safeNumber(obj?.implementation),
+    overall: safeNumber(obj?.overall)
+  };
+}
+function parseProgressYaml(raw) {
+  try {
+    const doc = yaml.load(raw);
+    if (!doc || typeof doc !== "object") {
+      return emptyProgressData();
+    }
+    const milestones = normalizeMilestones(doc.milestones);
+    const tasks = normalizeTasks(doc.tasks);
+    for (const milestone of milestones) {
+      const milestoneTasks = tasks[milestone.id];
+      if (milestoneTasks && milestoneTasks.length > 0) {
+        const completed = milestoneTasks.filter((t) => t.status === "completed").length;
+        const total = milestoneTasks.length;
+        if (milestone.tasks_total === 0) milestone.tasks_total = total;
+        if (milestone.tasks_completed === 0) milestone.tasks_completed = completed;
+        if (milestone.progress === 0 && total > 0) {
+          milestone.progress = Math.round(completed / total * 100);
+        }
+      }
+    }
+    return {
+      project: normalizeProject(doc.project),
+      milestones,
+      tasks,
+      recent_work: normalizeWorkEntries(doc.recent_work),
+      next_steps: normalizeStringArray(doc.next_steps),
+      notes: normalizeStringArray(doc.notes),
+      current_blockers: normalizeStringArray(doc.current_blockers),
+      documentation: normalizeDocStats(doc.documentation),
+      progress: normalizeProgress(doc.progress)
+    };
+  } catch {
+    return emptyProgressData();
+  }
+}
+function emptyProgressData() {
+  return {
+    project: {
+      name: "Unknown",
+      version: "0.0.0",
+      started: "",
+      status: "not_started",
+      description: "",
+      extra: {}
+    },
+    milestones: [],
+    tasks: {},
+    recent_work: [],
+    next_steps: [],
+    notes: [],
+    current_blockers: [],
+    documentation: { design_documents: 0, milestone_documents: 0, pattern_documents: 0, task_documents: 0 },
+    progress: { planning: 0, implementation: 0, overall: 0 }
+  };
+}
+
+// src/app.tsx
+import { useState as useState8, useCallback as useCallback5 } from "react";
+import { Box as Box12, Text as Text15, useApp, useInput as useInput6 } from "ink";
+
+// src/hooks/useProgressData.ts
+import { useState, useCallback } from "react";
+import fs from "fs";
+function useProgressData(filePath2) {
+  const [state, setState] = useState(() => {
+    try {
+      const raw = fs.readFileSync(filePath2, "utf-8");
+      return { data: parseProgressYaml(raw), error: null, loading: false };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { data: null, error: msg, loading: false };
+    }
+  });
+  const reload = useCallback(() => {
+    try {
+      const raw = fs.readFileSync(filePath2, "utf-8");
+      const data = parseProgressYaml(raw);
+      setState({ data, error: null, loading: false });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      setState((prev) => ({ data: prev.data, error: msg, loading: false }));
+    }
+  }, [filePath2]);
+  return { ...state, reload };
+}
+
+// src/hooks/useWatchMode.ts
+import { useEffect, useRef } from "react";
+import fs2 from "fs";
+function useWatchMode(filePath2, enabled, onReload) {
+  const timerRef = useRef(null);
+  useEffect(() => {
+    if (!enabled) return;
+    let watcher = null;
+    try {
+      watcher = fs2.watch(filePath2, () => {
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => {
+          onReload();
+        }, 300);
+      });
+      watcher.on("error", () => {
+      });
+    } catch {
+    }
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      if (watcher) watcher.close();
+    };
+  }, [filePath2, enabled, onReload]);
+}
+
+// src/hooks/useNavigation.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+var VIEW_ORDER = ["dashboard", "milestones", "tasks", "activity", "blockers"];
+var VIEW_LABELS = {
+  dashboard: "Dashboard",
+  milestones: "Milestones",
+  tasks: "Tasks",
+  activity: "Activity",
+  blockers: "Blockers"
+};
+function useNavigation(initialView) {
+  const initial = VIEW_ORDER.includes(initialView) ? initialView : "dashboard";
+  const [currentView, setCurrentView] = useState2(initial);
+  const [viewStack, setViewStack] = useState2([]);
+  const nextView = useCallback2(() => {
+    setCurrentView((prev) => {
+      const idx = VIEW_ORDER.indexOf(prev);
+      return VIEW_ORDER[(idx + 1) % VIEW_ORDER.length];
+    });
+  }, []);
+  const prevView = useCallback2(() => {
+    setCurrentView((prev) => {
+      const idx = VIEW_ORDER.indexOf(prev);
+      return VIEW_ORDER[(idx - 1 + VIEW_ORDER.length) % VIEW_ORDER.length];
+    });
+  }, []);
+  const goToView = useCallback2((view) => {
+    setCurrentView(view);
+  }, []);
+  const pushView = useCallback2((view) => {
+    setCurrentView((prev) => {
+      setViewStack((stack) => [...stack, prev]);
+      return view;
+    });
+  }, []);
+  const popView = useCallback2(() => {
+    setViewStack((stack) => {
+      if (stack.length === 0) return stack;
+      const newStack = [...stack];
+      const prev = newStack.pop();
+      setCurrentView(prev);
+      return newStack;
+    });
+  }, []);
+  return {
+    currentView,
+    viewStack,
+    views: VIEW_ORDER,
+    labels: VIEW_LABELS,
+    nextView,
+    prevView,
+    goToView,
+    pushView,
+    popView
+  };
+}
+
+// src/hooks/useFilter.ts
+import { useState as useState3, useCallback as useCallback3 } from "react";
+var FILTER_ORDER = ["all", "in_progress", "completed", "not_started"];
+var FILTER_LABELS = {
+  all: "All",
+  in_progress: "In Progress",
+  completed: "Completed",
+  not_started: "Not Started"
+};
+function useFilter() {
+  const [filter, setFilter] = useState3("all");
+  const cycleFilter = useCallback3(() => {
+    setFilter((prev) => {
+      const idx = FILTER_ORDER.indexOf(prev);
+      return FILTER_ORDER[(idx + 1) % FILTER_ORDER.length];
+    });
+  }, []);
+  const matches = useCallback3(
+    (status) => filter === "all" || filter === status,
+    [filter]
+  );
+  return {
+    filter,
+    label: FILTER_LABELS[filter],
+    cycleFilter,
+    matches
+  };
+}
+
+// src/components/Header.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Header({
+  projectName,
+  projectVersion,
+  currentView,
+  views,
+  labels,
+  filterLabel
+}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+      projectName,
+      " ",
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "v",
+        projectVersion
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { gap: 1, children: views.map((view) => /* @__PURE__ */ jsx(
+      Text,
+      {
+        bold: view === currentView,
+        color: view === currentView ? "cyan" : void 0,
+        dimColor: view !== currentView,
+        children: labels[view]
+      },
+      view
+    )) }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "Filter: ",
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: filterLabel })
+    ] })
+  ] });
+}
+
+// src/components/HelpBar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var COMMON_KEYS = "Tab:View  f:Filter  r:Refresh  q:Quit  ?:Help";
+var VIEW_KEYS = {
+  dashboard: `j/k:Scroll  ${COMMON_KEYS}`,
+  milestones: `j/k:Navigate  s:Sort  Enter:Detail  ${COMMON_KEYS}`,
+  tasks: `j/k:Navigate  Enter:Expand  ${COMMON_KEYS}`,
+  activity: `j/k:Scroll  ${COMMON_KEYS}`,
+  blockers: `j/k:Scroll  ${COMMON_KEYS}`
+};
+function HelpBar({ currentView }) {
+  return /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: VIEW_KEYS[currentView] }) });
+}
+
+// src/components/Dashboard.tsx
+import { Box as Box3, Text as Text5 } from "ink";
+
+// src/components/StatusBadge.tsx
+import { Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var STATUS_CONFIG = {
+  completed: { dot: "\u2713", label: "Completed", color: "green" },
+  in_progress: { dot: "\u25CF", label: "In Progress", color: "cyan" },
+  not_started: { dot: "\u25CB", label: "Not Started", color: "gray" }
+};
+function StatusBadge({ status, compact }) {
+  const { dot, label, color } = STATUS_CONFIG[status];
+  if (compact) {
+    return /* @__PURE__ */ jsx3(Text3, { color, children: dot });
+  }
+  return /* @__PURE__ */ jsxs2(Text3, { color, children: [
+    dot,
+    " ",
+    label
+  ] });
+}
+
+// src/components/ProgressBar.tsx
+import { Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function ProgressBar({ percent, width = 20, label }) {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round(clamped / 100 * width);
+  const empty = width - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  const color = clamped >= 80 ? "green" : clamped >= 40 ? "cyan" : "gray";
+  return /* @__PURE__ */ jsxs3(Text4, { children: [
+    label && /* @__PURE__ */ jsxs3(Text4, { children: [
+      label,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { color, children: bar }),
+    /* @__PURE__ */ jsxs3(Text4, { children: [
+      " ",
+      clamped,
+      "%"
+    ] })
+  ] });
+}
+
+// src/components/Dashboard.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function Dashboard({ data }) {
+  const { project, milestones, next_steps, current_blockers } = data;
+  const completed = milestones.filter((m) => m.status === "completed").length;
+  const inProgress = milestones.filter((m) => m.status === "in_progress").length;
+  const notStarted = milestones.filter((m) => m.status === "not_started").length;
+  const currentMilestone = milestones.find((m) => m.id === project.current_milestone);
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: " Project" }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        project.name,
+        " ",
+        /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+          "v",
+          project.version
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs4(Box3, { gap: 2, children: [
+        /* @__PURE__ */ jsx5(StatusBadge, { status: project.status }),
+        /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+          "Started: ",
+          project.started || "N/A"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx5(ProgressBar, { percent: data.progress.overall, label: "Progress:" }),
+      currentMilestone && /* @__PURE__ */ jsxs4(Text5, { children: [
+        "Current: ",
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: currentMilestone.name })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: " Milestones" }),
+      /* @__PURE__ */ jsxs4(Box3, { gap: 3, children: [
+        /* @__PURE__ */ jsxs4(Text5, { color: "green", children: [
+          "\u2713 Completed: ",
+          completed
+        ] }),
+        /* @__PURE__ */ jsxs4(Text5, { color: "cyan", children: [
+          "\u25CF In Progress: ",
+          inProgress
+        ] }),
+        /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+          "\u25CB Not Started: ",
+          notStarted
+        ] })
+      ] })
+    ] }),
+    current_blockers.length > 0 && /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: "red", children: " Blockers" }),
+      current_blockers.map((b, i) => /* @__PURE__ */ jsxs4(Text5, { color: "red", children: [
+        "  \u2022 ",
+        b
+      ] }, i))
+    ] }),
+    next_steps.length > 0 && /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: " Next Steps" }),
+      next_steps.map((step, i) => /* @__PURE__ */ jsxs4(Text5, { children: [
+        "  ",
+        i + 1,
+        ". ",
+        step
+      ] }, i))
+    ] })
+  ] });
+}
+
+// src/components/MilestoneTable.tsx
+import { useState as useState4 } from "react";
+import { Box as Box4, Text as Text6, useInput } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var SORT_KEYS = ["name", "status", "progress", "tasks", "started", "estimated_weeks"];
+var STATUS_ORDER = {
+  in_progress: 0,
+  not_started: 1,
+  completed: 2
+};
+function sortMilestones(milestones, key, asc) {
+  return [...milestones].sort((a, b) => {
+    let cmp = 0;
+    switch (key) {
+      case "name":
+        cmp = a.name.localeCompare(b.name);
+        break;
+      case "status":
+        cmp = STATUS_ORDER[a.status] - STATUS_ORDER[b.status];
+        break;
+      case "progress":
+        cmp = a.progress - b.progress;
+        break;
+      case "tasks":
+        cmp = a.tasks_completed - b.tasks_completed;
+        break;
+      case "started":
+        cmp = (a.started || "").localeCompare(b.started || "");
+        break;
+      case "estimated_weeks":
+        cmp = parseFloat(a.estimated_weeks || "0") - parseFloat(b.estimated_weeks || "0");
+        break;
+    }
+    return asc ? cmp : -cmp;
+  });
+}
+function MilestoneTable({ milestones, filterMatch, active, onSelect }) {
+  const [selectedIdx, setSelectedIdx] = useState4(0);
+  const [sortKey, setSortKey] = useState4("status");
+  const [sortAsc, setSortAsc] = useState4(true);
+  const filtered = milestones.filter((m) => filterMatch(m.status));
+  const sorted = sortMilestones(filtered, sortKey, sortAsc);
+  useInput((input, key) => {
+    if (!active) return;
+    if (input === "j" || key.downArrow) {
+      setSelectedIdx((i) => Math.min(i + 1, sorted.length - 1));
+    } else if (input === "k" || key.upArrow) {
+      setSelectedIdx((i) => Math.max(i - 1, 0));
+    } else if (input === "s") {
+      setSortKey((prev) => {
+        const idx = SORT_KEYS.indexOf(prev);
+        const next = SORT_KEYS[(idx + 1) % SORT_KEYS.length];
+        if (next === prev) setSortAsc((a) => !a);
+        return next;
+      });
+    } else if (key.return && sorted[selectedIdx] && onSelect) {
+      onSelect(sorted[selectedIdx]);
+    }
+  });
+  if (sorted.length === 0) {
+    return /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "No milestones match current filter." });
+  }
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs5(Box4, { gap: 1, children: [
+      /* @__PURE__ */ jsx6(Box4, { width: 30, children: /* @__PURE__ */ jsxs5(Text6, { bold: true, dimColor: true, children: [
+        colLabel("name", sortKey),
+        " Name"
+      ] }) }),
+      /* @__PURE__ */ jsx6(Box4, { width: 14, children: /* @__PURE__ */ jsxs5(Text6, { bold: true, dimColor: true, children: [
+        colLabel("status", sortKey),
+        " Status"
+      ] }) }),
+      /* @__PURE__ */ jsx6(Box4, { width: 10, children: /* @__PURE__ */ jsxs5(Text6, { bold: true, dimColor: true, children: [
+        colLabel("progress", sortKey),
+        " Prog"
+      ] }) }),
+      /* @__PURE__ */ jsx6(Box4, { width: 8, children: /* @__PURE__ */ jsxs5(Text6, { bold: true, dimColor: true, children: [
+        colLabel("tasks", sortKey),
+        " Tasks"
+      ] }) }),
+      /* @__PURE__ */ jsx6(Box4, { width: 12, children: /* @__PURE__ */ jsxs5(Text6, { bold: true, dimColor: true, children: [
+        colLabel("started", sortKey),
+        " Started"
+      ] }) }),
+      /* @__PURE__ */ jsx6(Box4, { width: 6, children: /* @__PURE__ */ jsxs5(Text6, { bold: true, dimColor: true, children: [
+        colLabel("estimated_weeks", sortKey),
+        " Est"
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u2500".repeat(80) }),
+    sorted.map((m, i) => {
+      const isSelected = i === selectedIdx && active;
+      return /* @__PURE__ */ jsxs5(Box4, { gap: 1, children: [
+        /* @__PURE__ */ jsx6(Box4, { width: 30, children: /* @__PURE__ */ jsx6(Text6, { bold: isSelected, inverse: isSelected, children: truncate(m.name, 28) }) }),
+        /* @__PURE__ */ jsx6(Box4, { width: 14, children: /* @__PURE__ */ jsx6(StatusBadge, { status: m.status }) }),
+        /* @__PURE__ */ jsx6(Box4, { width: 10, children: /* @__PURE__ */ jsxs5(Text6, { children: [
+          m.progress,
+          "%"
+        ] }) }),
+        /* @__PURE__ */ jsx6(Box4, { width: 8, children: /* @__PURE__ */ jsxs5(Text6, { children: [
+          m.tasks_completed,
+          "/",
+          m.tasks_total
+        ] }) }),
+        /* @__PURE__ */ jsx6(Box4, { width: 12, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: m.started ? shortDate(m.started) : "\u2014" }) }),
+        /* @__PURE__ */ jsx6(Box4, { width: 6, children: /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
+          m.estimated_weeks,
+          "w"
+        ] }) })
+      ] }, m.id);
+    })
+  ] });
+}
+function colLabel(col, active) {
+  return col === active ? "\u25BC" : " ";
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+}
+function shortDate(d) {
+  try {
+    const date = new Date(d);
+    return date.toISOString().slice(0, 10);
+  } catch {
+    return d.slice(0, 10);
+  }
+}
+
+// src/components/TaskTree.tsx
+import { useState as useState5, useMemo } from "react";
+import { Box as Box5, Text as Text7, useInput as useInput2 } from "ink";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function TaskTree({ milestones, tasks, filterMatch, active, onSelectTask }) {
+  const [expanded, setExpanded] = useState5(() => {
+    const set = /* @__PURE__ */ new Set();
+    for (const m of milestones) {
+      if (m.status === "in_progress") set.add(m.id);
+    }
+    return set;
+  });
+  const [cursorIdx, setCursorIdx] = useState5(0);
+  const flatItems = useMemo(() => {
+    const items = [];
+    for (const m of milestones) {
+      const milestoneTasks = (tasks[m.id] || []).filter((t) => filterMatch(t.status));
+      if (milestoneTasks.length === 0 && !filterMatch(m.status)) continue;
+      items.push({ type: "milestone", milestone: m });
+      if (expanded.has(m.id)) {
+        for (const t of milestoneTasks) {
+          items.push({ type: "task", milestone: m, task: t });
+        }
+      }
+    }
+    return items;
+  }, [milestones, tasks, filterMatch, expanded]);
+  useInput2((input, key) => {
+    if (!active) return;
+    if (input === "j" || key.downArrow) {
+      setCursorIdx((i) => Math.min(i + 1, flatItems.length - 1));
+    } else if (input === "k" || key.upArrow) {
+      setCursorIdx((i) => Math.max(i - 1, 0));
+    } else if (key.return || input === " ") {
+      const item = flatItems[cursorIdx];
+      if (!item) return;
+      if (item.type === "milestone") {
+        setExpanded((prev) => {
+          const next = new Set(prev);
+          if (next.has(item.milestone.id)) {
+            next.delete(item.milestone.id);
+          } else {
+            next.add(item.milestone.id);
+          }
+          return next;
+        });
+      } else if (item.task && onSelectTask) {
+        onSelectTask(item.task);
+      }
+    }
+  });
+  if (flatItems.length === 0) {
+    return /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "No items match current filter." });
+  }
+  return /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", children: flatItems.map((item, i) => {
+    const isSelected = i === cursorIdx && active;
+    if (item.type === "milestone") {
+      const m = item.milestone;
+      const icon = expanded.has(m.id) ? "\u25BC" : "\u25BA";
+      const taskCount = (tasks[m.id] || []).filter((t2) => filterMatch(t2.status)).length;
+      return /* @__PURE__ */ jsxs6(Box5, { gap: 1, children: [
+        /* @__PURE__ */ jsxs6(Text7, { bold: isSelected, inverse: isSelected, children: [
+          icon,
+          " ",
+          m.name
+        ] }),
+        /* @__PURE__ */ jsx7(StatusBadge, { status: m.status, compact: true }),
+        /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+          "[",
+          m.progress,
+          "%]"
+        ] }),
+        /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+          "(",
+          taskCount,
+          " tasks)"
+        ] })
+      ] }, m.id);
+    }
+    const t = item.task;
+    return /* @__PURE__ */ jsxs6(Box5, { gap: 1, marginLeft: 4, children: [
+      /* @__PURE__ */ jsxs6(Text7, { bold: isSelected, inverse: isSelected, children: [
+        /* @__PURE__ */ jsx7(StatusBadge, { status: t.status, compact: true }),
+        " ",
+        t.name
+      ] }),
+      t.estimated_hours && /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+        t.estimated_hours,
+        "h"
+      ] })
+    ] }, t.id);
+  }) });
+}
+
+// src/components/ActivityLog.tsx
+import { Box as Box6, Text as Text8 } from "ink";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function ActivityLog({ entries }) {
+  if (entries.length === 0) {
+    return /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "No recent work entries." });
+  }
+  return /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", gap: 1, children: entries.map((entry, i) => /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs7(Text8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: entry.date }),
+      /* @__PURE__ */ jsxs7(Text8, { dimColor: true, children: [
+        " \u2014 ",
+        entry.description
+      ] })
+    ] }),
+    entry.items.map((item, j) => /* @__PURE__ */ jsxs7(Text8, { dimColor: true, children: [
+      "  \u2022 ",
+      item
+    ] }, j))
+  ] }, i)) });
+}
+
+// src/components/BlockersNextSteps.tsx
+import { Box as Box7, Text as Text9 } from "ink";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function BlockersNextSteps({ blockers, nextSteps }) {
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx9(Text9, { bold: true, color: blockers.length > 0 ? "red" : void 0, children: " Current Blockers" }),
+      blockers.length === 0 ? /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "  (none)" }) : blockers.map((b, i) => /* @__PURE__ */ jsxs8(Text9, { color: "red", children: [
+        "  \u2022 ",
+        b
+      ] }, i))
+    ] }),
+    /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx9(Text9, { bold: true, children: " Next Steps" }),
+      nextSteps.length === 0 ? /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "  (none)" }) : nextSteps.map((s, i) => /* @__PURE__ */ jsxs8(Text9, { children: [
+        "  ",
+        i + 1,
+        ". ",
+        s
+      ] }, i))
+    ] })
+  ] });
+}
+
+// src/components/MilestoneDetail.tsx
+import React4, { useMemo as useMemo3 } from "react";
+import { Box as Box9, Text as Text12, useInput as useInput3 } from "ink";
+
+// src/lib/markdown-loader.ts
+import fs3 from "fs";
+import path from "path";
+function getBasePath(progressYamlPath) {
+  const dir = path.dirname(progressYamlPath);
+  if (path.basename(dir) === "agent") {
+    return path.dirname(dir);
+  }
+  return dir;
+}
+function loadMarkdownFile(basePath, relativePath) {
+  const fullPath = path.resolve(basePath, relativePath);
+  try {
+    const content = fs3.readFileSync(fullPath, "utf-8");
+    return { content, filePath: relativePath };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("ENOENT")) {
+      return { error: `No document found at ${relativePath}` };
+    }
+    if (msg.includes("EACCES")) {
+      return { error: `Cannot read ${relativePath}: permission denied` };
+    }
+    return { error: `Error reading ${relativePath}: ${msg}` };
+  }
+}
+function resolveMilestoneFile(basePath, milestoneId) {
+  const match = milestoneId.match(/(\d+)/);
+  if (!match) return null;
+  const num = match[1];
+  const milestonesDir = path.join(basePath, "agent", "milestones");
+  try {
+    const files = fs3.readdirSync(milestonesDir);
+    const pattern = `milestone-${num}-`;
+    const found = files.find(
+      (f) => f.startsWith(pattern) && f.endsWith(".md") && !f.includes("template")
+    );
+    return found ? path.join("agent", "milestones", found) : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/components/Breadcrumb.tsx
+import { Text as Text10 } from "ink";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+function Breadcrumb({ items }) {
+  return /* @__PURE__ */ jsx10(Text10, { children: items.map((item, i) => /* @__PURE__ */ jsx10(Text10, { children: i < items.length - 1 ? /* @__PURE__ */ jsxs9(Text10, { dimColor: true, children: [
+    item.label,
+    " > "
+  ] }) : /* @__PURE__ */ jsx10(Text10, { bold: true, children: item.label }) }, i)) });
+}
+
+// src/components/MarkdownRenderer.tsx
+import { useMemo as useMemo2 } from "react";
+import { Text as Text11, Box as Box8 } from "ink";
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { jsx as jsx11 } from "react/jsx-runtime";
+function MarkdownRenderer({ content }) {
+  const rendered = useMemo2(() => {
+    try {
+      const marked = new Marked(markedTerminal());
+      return marked.parse(content);
+    } catch {
+      return content;
+    }
+  }, [content]);
+  return /* @__PURE__ */ jsx11(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsx11(Text11, { children: rendered }) });
+}
+
+// src/components/MilestoneDetail.tsx
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+function MilestoneDetail({
+  milestone,
+  tasks,
+  filePath: filePath2,
+  active,
+  onBack,
+  onSelectTask
+}) {
+  const markdownResult = useMemo3(() => {
+    const basePath = getBasePath(filePath2);
+    const resolved = resolveMilestoneFile(basePath, milestone.id);
+    if (!resolved) return { error: `No milestone document found for ${milestone.id}` };
+    return loadMarkdownFile(basePath, resolved);
+  }, [filePath2, milestone.id]);
+  const [taskIdx, setTaskIdx] = React4.useState(0);
+  useInput3((input, key) => {
+    if (!active) return;
+    if (key.escape || key.backspace || key.delete) {
+      onBack();
+    } else if (input === "j" || key.downArrow) {
+      setTaskIdx((i) => Math.min(i + 1, tasks.length - 1));
+    } else if (input === "k" || key.upArrow) {
+      setTaskIdx((i) => Math.max(i - 1, 0));
+    } else if (key.return && tasks[taskIdx] && onSelectTask) {
+      onSelectTask(tasks[taskIdx]);
+    }
+  });
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx12(Breadcrumb, { items: [{ label: "Milestones" }, { label: milestone.name }] }),
+    /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsxs10(Box9, { gap: 2, children: [
+        /* @__PURE__ */ jsx12(StatusBadge, { status: milestone.status }),
+        /* @__PURE__ */ jsx12(ProgressBar, { percent: milestone.progress, width: 15 })
+      ] }),
+      /* @__PURE__ */ jsxs10(Box9, { gap: 2, children: [
+        /* @__PURE__ */ jsxs10(Text12, { dimColor: true, children: [
+          "Started: ",
+          milestone.started || "\u2014"
+        ] }),
+        /* @__PURE__ */ jsxs10(Text12, { dimColor: true, children: [
+          "Est: ",
+          milestone.estimated_weeks,
+          "w"
+        ] }),
+        /* @__PURE__ */ jsxs10(Text12, { dimColor: true, children: [
+          "Tasks: ",
+          milestone.tasks_completed,
+          "/",
+          milestone.tasks_total
+        ] })
+      ] }),
+      milestone.notes && /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: milestone.notes })
+    ] }),
+    "content" in markdownResult ? /* @__PURE__ */ jsx12(MarkdownRenderer, { content: markdownResult.content }) : /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "error" in markdownResult ? markdownResult.error : "No content" }),
+    tasks.length > 0 && /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx12(Text12, { bold: true, children: " Tasks" }),
+      tasks.map((t, i) => /* @__PURE__ */ jsxs10(Text12, { bold: i === taskIdx && active, inverse: i === taskIdx && active, children: [
+        /* @__PURE__ */ jsx12(StatusBadge, { status: t.status, compact: true }),
+        " ",
+        t.name
+      ] }, t.id))
+    ] }),
+    /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Backspace:Back  j/k:Navigate tasks  Enter:Open task" })
+  ] });
+}
+
+// src/components/TaskDetail.tsx
+import { useMemo as useMemo4 } from "react";
+import { Box as Box10, Text as Text13, useInput as useInput4 } from "ink";
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+function TaskDetail({
+  task,
+  milestone,
+  siblings,
+  filePath: filePath2,
+  active,
+  onBack,
+  onNavigateSibling
+}) {
+  const markdownResult = useMemo4(() => {
+    if (!task.file) return { error: `No file path for ${task.id}` };
+    const basePath = getBasePath(filePath2);
+    return loadMarkdownFile(basePath, task.file);
+  }, [filePath2, task.file, task.id]);
+  const siblingIdx = siblings.findIndex((t) => t.id === task.id);
+  const prevTask = siblingIdx > 0 ? siblings[siblingIdx - 1] : null;
+  const nextTask = siblingIdx < siblings.length - 1 ? siblings[siblingIdx + 1] : null;
+  useInput4((input, key) => {
+    if (!active) return;
+    if (key.escape || key.backspace || key.delete) {
+      onBack();
+    } else if (input === "[" && prevTask && onNavigateSibling) {
+      onNavigateSibling(prevTask);
+    } else if (input === "]" && nextTask && onNavigateSibling) {
+      onNavigateSibling(nextTask);
+    }
+  });
+  return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx13(
+      Breadcrumb,
+      {
+        items: [
+          { label: "Milestones" },
+          { label: milestone.name },
+          { label: task.name }
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx13(StatusBadge, { status: task.status }),
+      /* @__PURE__ */ jsxs11(Box10, { gap: 2, children: [
+        task.estimated_hours && /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
+          "Est: ",
+          task.estimated_hours,
+          "h"
+        ] }),
+        task.completed_date && /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
+          "Completed: ",
+          task.completed_date
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
+        "Milestone: ",
+        milestone.name
+      ] }),
+      task.notes && /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: task.notes })
+    ] }),
+    "content" in markdownResult ? /* @__PURE__ */ jsx13(MarkdownRenderer, { content: markdownResult.content }) : /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "error" in markdownResult ? markdownResult.error : "No content" }),
+    /* @__PURE__ */ jsxs11(Box10, { gap: 2, children: [
+      prevTask ? /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
+        "[: \u2190 ",
+        prevTask.name
+      ] }) : /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "[: (first task)" }),
+      nextTask ? /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
+        "]: \u2192 ",
+        nextTask.name
+      ] }) : /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "]: (last task)" })
+    ] }),
+    /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "Backspace:Back  [/]:Prev/Next task" })
+  ] });
+}
+
+// src/components/SearchResults.tsx
+import { useState as useState6 } from "react";
+import { Box as Box11, Text as Text14, useInput as useInput5 } from "ink";
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function SearchResults({
+  query,
+  results,
+  active,
+  onSelectMilestone,
+  onSelectTask,
+  onCancel
+}) {
+  const [selectedIdx, setSelectedIdx] = useState6(0);
+  useInput5((input, key) => {
+    if (!active) return;
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (input === "j" || key.downArrow) {
+      setSelectedIdx((i) => Math.min(i + 1, results.length - 1));
+    } else if (input === "k" || key.upArrow) {
+      setSelectedIdx((i) => Math.max(i - 1, 0));
+    } else if (key.return && results[selectedIdx]) {
+      const r = results[selectedIdx];
+      if (r.type === "milestone" && r.milestone && onSelectMilestone) {
+        onSelectMilestone(r.milestone);
+      } else if (r.type === "task" && r.task && onSelectTask) {
+        onSelectTask(r.task);
+      }
+    }
+  });
+  const milestoneResults = results.filter((r) => r.type === "milestone");
+  const taskResults = results.filter((r) => r.type === "task");
+  let flatIdx = 0;
+  return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs12(Text14, { children: [
+      "Search: ",
+      /* @__PURE__ */ jsx14(Text14, { bold: true, children: query }),
+      query && /* @__PURE__ */ jsxs12(Text14, { dimColor: true, children: [
+        " (",
+        results.length,
+        " results)"
+      ] })
+    ] }),
+    results.length === 0 && query.trim() && /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "No results found." }),
+    milestoneResults.length > 0 && /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs12(Text14, { bold: true, dimColor: true, children: [
+        "Milestones (",
+        milestoneResults.length,
+        ")"
+      ] }),
+      milestoneResults.map((r) => {
+        const idx = flatIdx++;
+        const m = r.milestone;
+        return /* @__PURE__ */ jsxs12(Text14, { bold: idx === selectedIdx, inverse: idx === selectedIdx, children: [
+          "  ",
+          /* @__PURE__ */ jsx14(StatusBadge, { status: m.status, compact: true }),
+          " ",
+          m.name
+        ] }, r.id);
+      })
+    ] }),
+    taskResults.length > 0 && /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs12(Text14, { bold: true, dimColor: true, children: [
+        "Tasks (",
+        taskResults.length,
+        ")"
+      ] }),
+      taskResults.map((r) => {
+        const idx = flatIdx++;
+        const t = r.task;
+        return /* @__PURE__ */ jsxs12(Text14, { bold: idx === selectedIdx, inverse: idx === selectedIdx, children: [
+          "  ",
+          /* @__PURE__ */ jsx14(StatusBadge, { status: t.status, compact: true }),
+          " ",
+          t.name
+        ] }, r.id);
+      })
+    ] }),
+    /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "j/k:Navigate  Enter:Open  Esc:Cancel" })
+  ] });
+}
+
+// src/hooks/useSearch.ts
+import { useState as useState7, useMemo as useMemo5, useCallback as useCallback4 } from "react";
+import Fuse from "fuse.js";
+function useSearch(data) {
+  const [query, setQuery] = useState7("");
+  const [isSearching, setIsSearching] = useState7(false);
+  const fuse = useMemo5(() => {
+    if (!data) return null;
+    const items = [];
+    for (const m of data.milestones) {
+      items.push({ type: "milestone", milestone: m, name: m.name, id: m.id });
+    }
+    for (const [, tasks] of Object.entries(data.tasks)) {
+      for (const t of tasks) {
+        items.push({ type: "task", task: t, name: t.name, id: t.id });
+      }
+    }
+    return new Fuse(items, {
+      keys: [
+        { name: "name", weight: 0.7 },
+        { name: "task.notes", weight: 0.2 },
+        { name: "milestone.notes", weight: 0.1 }
+      ],
+      threshold: 0.4,
+      includeScore: true
+    });
+  }, [data]);
+  const results = useMemo5(() => {
+    if (!fuse || !query.trim()) return [];
+    return fuse.search(query).map((r) => r.item);
+  }, [fuse, query]);
+  const startSearch = useCallback4(() => {
+    setIsSearching(true);
+    setQuery("");
+  }, []);
+  const cancelSearch = useCallback4(() => {
+    setIsSearching(false);
+    setQuery("");
+  }, []);
+  return { query, setQuery, results, isSearching, startSearch, cancelSearch };
+}
+
+// src/app.tsx
+import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+function App({ filePath: filePath2, watch, initialView }) {
+  const { data, error, reload } = useProgressData(filePath2);
+  useWatchMode(filePath2, watch, reload);
+  const nav = useNavigation(initialView);
+  const filter = useFilter();
+  const { exit } = useApp();
+  const [showHelp, setShowHelp] = useState8(false);
+  const [detail, setDetail] = useState8({ type: "none" });
+  const search = useSearch(data);
+  const openMilestoneDetail = useCallback5((milestone) => {
+    setDetail({ type: "milestone", milestone });
+  }, []);
+  const openTaskDetail = useCallback5((task) => {
+    if (!data) return;
+    const milestone = data.milestones.find((m) => m.id === task.milestone_id);
+    if (milestone) {
+      setDetail({ type: "task", task, milestone });
+    }
+  }, [data]);
+  const closeDetail = useCallback5(() => {
+    setDetail((prev) => {
+      if (prev.type === "task") {
+        return { type: "milestone", milestone: prev.milestone };
+      }
+      return { type: "none" };
+    });
+  }, []);
+  const navigateToSiblingTask = useCallback5((task) => {
+    if (!data) return;
+    const milestone = data.milestones.find((m) => m.id === task.milestone_id);
+    if (milestone) {
+      setDetail({ type: "task", task, milestone });
+    }
+  }, [data]);
+  useInput6((input, key) => {
+    if (showHelp) {
+      setShowHelp(false);
+      return;
+    }
+    if (search.isSearching) {
+      if (key.escape) {
+        search.cancelSearch();
+        return;
+      }
+      if (key.backspace || key.delete) {
+        search.setQuery(search.query.slice(0, -1));
+        return;
+      }
+      if (search.query && (input === "j" || input === "k" || key.return || key.downArrow || key.upArrow)) {
+        return;
+      }
+      if (input && !key.ctrl && !key.meta && input.length === 1 && input !== "q") {
+        search.setQuery(search.query + input);
+        return;
+      }
+      return;
+    }
+    if (detail.type !== "none") {
+      if (input === "q") {
+        exit();
+        return;
+      }
+      if (input === "?") {
+        setShowHelp(true);
+        return;
+      }
+      if (input === "r") {
+        reload();
+        return;
+      }
+      return;
+    }
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (input === "?") {
+      setShowHelp(true);
+      return;
+    }
+    if (input === "f") {
+      filter.cycleFilter();
+      return;
+    }
+    if (input === "r") {
+      reload();
+      return;
+    }
+    if (input === "/") {
+      search.startSearch();
+      return;
+    }
+    if (key.tab) {
+      if (key.shift) {
+        nav.prevView();
+      } else {
+        nav.nextView();
+      }
+    }
+  });
+  if (error && !data) {
+    return /* @__PURE__ */ jsx15(Box12, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs13(Text15, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) });
+  }
+  if (!data) {
+    return /* @__PURE__ */ jsx15(Box12, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "Loading..." }) });
+  }
+  if (showHelp) {
+    return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Keyboard Shortcuts" }),
+      /* @__PURE__ */ jsx15(Text15, {}),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Tab" }),
+        " / ",
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Shift+Tab" }),
+        "  Switch views"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "j/k" }),
+        " or ",
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "\u2191/\u2193" }),
+        "       Navigate"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Enter" }),
+        "              Expand / open detail"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Backspace/Esc" }),
+        "      Back from detail"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "[/]" }),
+        "                Prev/next task (in detail)"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "s" }),
+        "                  Cycle sort (table)"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "f" }),
+        "                  Cycle status filter"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "r" }),
+        "                  Refresh data"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "q" }),
+        "                  Quit"
+      ] }),
+      /* @__PURE__ */ jsxs13(Text15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { bold: true, children: "?" }),
+        "                  Toggle this help"
+      ] }),
+      /* @__PURE__ */ jsx15(Text15, {}),
+      /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "Press any key to dismiss" })
+    ] });
+  }
+  if (search.isSearching) {
+    return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx15(
+        Header,
+        {
+          projectName: data.project.name,
+          projectVersion: data.project.version,
+          currentView: nav.currentView,
+          views: nav.views,
+          labels: nav.labels,
+          filterLabel: filter.label
+        }
+      ),
+      /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "\u2500".repeat(80) }),
+      /* @__PURE__ */ jsx15(Box12, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: /* @__PURE__ */ jsx15(
+        SearchResults,
+        {
+          query: search.query,
+          results: search.results,
+          active: true,
+          onSelectMilestone: (m) => {
+            search.cancelSearch();
+            openMilestoneDetail(m);
+          },
+          onSelectTask: (t) => {
+            search.cancelSearch();
+            openTaskDetail(t);
+          },
+          onCancel: search.cancelSearch
+        }
+      ) })
+    ] });
+  }
+  if (detail.type === "milestone") {
+    const milestoneTasks = data.tasks[detail.milestone.id] || [];
+    return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx15(
+        Header,
+        {
+          projectName: data.project.name,
+          projectVersion: data.project.version,
+          currentView: nav.currentView,
+          views: nav.views,
+          labels: nav.labels,
+          filterLabel: filter.label
+        }
+      ),
+      /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "\u2500".repeat(80) }),
+      /* @__PURE__ */ jsx15(Box12, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: /* @__PURE__ */ jsx15(
+        MilestoneDetail,
+        {
+          milestone: detail.milestone,
+          tasks: milestoneTasks,
+          data,
+          filePath: filePath2,
+          active: true,
+          onBack: closeDetail,
+          onSelectTask: openTaskDetail
+        }
+      ) })
+    ] });
+  }
+  if (detail.type === "task") {
+    const siblings = data.tasks[detail.milestone.id] || [];
+    return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx15(
+        Header,
+        {
+          projectName: data.project.name,
+          projectVersion: data.project.version,
+          currentView: nav.currentView,
+          views: nav.views,
+          labels: nav.labels,
+          filterLabel: filter.label
+        }
+      ),
+      /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "\u2500".repeat(80) }),
+      /* @__PURE__ */ jsx15(Box12, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: /* @__PURE__ */ jsx15(
+        TaskDetail,
+        {
+          task: detail.task,
+          milestone: detail.milestone,
+          siblings,
+          data,
+          filePath: filePath2,
+          active: true,
+          onBack: closeDetail,
+          onNavigateSibling: navigateToSiblingTask
+        }
+      ) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx15(
+      Header,
+      {
+        projectName: data.project.name,
+        projectVersion: data.project.version,
+        currentView: nav.currentView,
+        views: nav.views,
+        labels: nav.labels,
+        filterLabel: filter.label
+      }
+    ),
+    /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "\u2500".repeat(80) }),
+    /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: [
+      nav.currentView === "dashboard" && /* @__PURE__ */ jsx15(Dashboard, { data }),
+      nav.currentView === "milestones" && /* @__PURE__ */ jsx15(
+        MilestoneTable,
+        {
+          milestones: data.milestones,
+          filterMatch: filter.matches,
+          active: true,
+          onSelect: openMilestoneDetail
+        }
+      ),
+      nav.currentView === "tasks" && /* @__PURE__ */ jsx15(
+        TaskTree,
+        {
+          milestones: data.milestones,
+          tasks: data.tasks,
+          filterMatch: filter.matches,
+          active: true,
+          onSelectTask: openTaskDetail
+        }
+      ),
+      nav.currentView === "activity" && /* @__PURE__ */ jsx15(ActivityLog, { entries: data.recent_work }),
+      nav.currentView === "blockers" && /* @__PURE__ */ jsx15(
+        BlockersNextSteps,
+        {
+          blockers: data.current_blockers,
+          nextSteps: data.next_steps
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "\u2500".repeat(80) }),
+    /* @__PURE__ */ jsx15(HelpBar, { currentView: nav.currentView })
+  ] });
+}
+
+// src/cli.tsx
+import { jsx as jsx16 } from "react/jsx-runtime";
+var cli = meow(`
+  Usage
+    $ acp-visualizer-tui [path]
+
+  Arguments
+    path    Path to progress.yaml (default: ./agent/progress.yaml)
+
+  Options
+    -w, --watch       Watch mode: auto-refresh on file changes
+    -v, --view        Initial view: dashboard|milestones|tasks|activity|blockers
+    --json            Output parsed data as JSON (non-interactive)
+    --no-color        Disable colors
+    -h, --help        Show help
+    -V, --version     Show version
+`, {
+  importMeta: import.meta,
+  flags: {
+    watch: { type: "boolean", shortFlag: "w", default: false },
+    view: { type: "string", shortFlag: "v", default: "dashboard" },
+    json: { type: "boolean", default: false }
+  }
+});
+var filePath = cli.input[0] || "./agent/progress.yaml";
+var resolvedPath = path2.resolve(filePath);
+if (!fs4.existsSync(resolvedPath)) {
+  console.error(`Error: File not found: ${resolvedPath}`);
+  console.error(`
+Make sure progress.yaml exists at the specified path.`);
+  console.error(`Default path: ./agent/progress.yaml`);
+  process.exit(1);
+}
+if (cli.flags.json) {
+  try {
+    const raw = fs4.readFileSync(resolvedPath, "utf-8");
+    const data = parseProgressYaml(raw);
+    console.log(JSON.stringify(data, null, 2));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error reading file: ${msg}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+render(
+  /* @__PURE__ */ jsx16(
+    App,
+    {
+      filePath: resolvedPath,
+      watch: cli.flags.watch,
+      initialView: cli.flags.view
+    }
+  )
+);
+//# sourceMappingURL=cli.js.map