specsmd 0.1.46 → 0.1.47

package/lib/dashboard/index.js

@@ -1,10 +1,13 @@
+const fs = require('fs');
 const path = require('path');
-const { detectFlow } = require('./flow-detect');
+const yaml = require('js-yaml');
+const { detectFlow, detectAvailableFlows } = require('./flow-detect');
 const { parseFireDashboard } = require('./fire/parser');
 const { parseAidlcDashboard } = require('./aidlc/parser');
 const { parseSimpleDashboard } = require('./simple/parser');
 const { formatDashboardText } = require('./tui/renderer');
 const { createDashboardApp } = require('./tui/app');
+const { discoverGitWorktrees, pickWorktree, pathExistsAsDirectory } = require('./git/worktrees');
 
 function parseRefreshMs(raw) {
   const parsed = Number.parseInt(String(raw || '1000'), 10);
@@ -66,6 +69,8 @@ const FLOW_CONFIG = {
   }
 };
 
+const MAX_WORKTREE_WATCH_ROOTS = 12;
+
 function resolveRootPathForFlow(workspacePath, flow) {
   const config = FLOW_CONFIG[flow];
   if (!config) {
@@ -74,6 +79,316 @@ function resolveRootPathForFlow(workspacePath, flow) {
   return path.join(workspacePath, config.markerDir);
 }
 
+function readFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function parseFrontmatter(content) {
+  const match = String(content || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) {
+    return {};
+  }
+  try {
+    const parsed = yaml.load(match[1]);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function listSubdirectories(dirPath) {
+  try {
+    return fs.readdirSync(dirPath, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+
+function listMarkdownFiles(dirPath) {
+  try {
+    return fs.readdirSync(dirPath, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+      .map((entry) => entry.name)
+      .sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+
+function normalizeAidlcStatus(rawStatus) {
+  if (typeof rawStatus !== 'string') {
+    return 'unknown';
+  }
+
+  const normalized = rawStatus.toLowerCase().trim().replace(/[\s_]+/g, '-');
+  if (['complete', 'completed', 'done', 'finished', 'closed', 'resolved'].includes(normalized)) {
+    return 'completed';
+  }
+  if (['blocked'].includes(normalized)) {
+    return 'blocked';
+  }
+  if (['in-progress', 'inprogress', 'active', 'started', 'wip', 'working', 'ready', 'construction'].includes(normalized)) {
+    return 'in_progress';
+  }
+  if (['draft', 'pending', 'planned', 'todo', 'new', 'queued'].includes(normalized)) {
+    return 'pending';
+  }
+  return 'unknown';
+}
+
+function normalizeFlowId(flow) {
+  return String(flow || '').toLowerCase().trim();
+}
+
+function normalizeFireRunWorkItem(raw) {
+  if (!raw || typeof raw !== 'object') {
+    return null;
+  }
+  const id = typeof raw.id === 'string' ? raw.id : '';
+  if (id === '') {
+    return null;
+  }
+  return {
+    id,
+    intentId: typeof raw.intent === 'string' ? raw.intent : (typeof raw.intentId === 'string' ? raw.intentId : ''),
+    mode: typeof raw.mode === 'string' ? raw.mode : 'confirm',
+    status: typeof raw.status === 'string' ? raw.status : 'pending',
+    currentPhase: typeof raw.current_phase === 'string' ? raw.current_phase : (typeof raw.currentPhase === 'string' ? raw.currentPhase : undefined),
+    checkpointState: typeof raw.checkpoint_state === 'string'
+      ? raw.checkpoint_state
+      : (typeof raw.checkpointState === 'string'
+        ? raw.checkpointState
+        : undefined),
+    currentCheckpoint: typeof raw.current_checkpoint === 'string'
+      ? raw.current_checkpoint
+      : (typeof raw.currentCheckpoint === 'string' ? raw.currentCheckpoint : undefined)
+  };
+}
+
+function probeFireWorktreeActivity(worktreePath) {
+  const rootPath = path.join(worktreePath, '.specs-fire');
+  const statePath = path.join(rootPath, 'state.yaml');
+  const stateContent = readFileSafe(statePath);
+  if (stateContent == null) {
+    return { activeRuns: [] };
+  }
+
+  let state;
+  try {
+    state = yaml.load(stateContent) || {};
+  } catch {
+    return { activeRuns: [] };
+  }
+
+  const activeRuns = Array.isArray(state?.runs?.active) ? state.runs.active : [];
+  return {
+    activeRuns: activeRuns.map((run) => {
+      const runId = typeof run?.id === 'string' ? run.id : '';
+      if (runId === '') {
+        return null;
+      }
+      const folderPath = path.join(rootPath, 'runs', runId);
+      const workItemsRaw = Array.isArray(run?.work_items)
+        ? run.work_items
+        : (Array.isArray(run?.workItems) ? run.workItems : []);
+      const workItems = workItemsRaw.map((item) => normalizeFireRunWorkItem(item)).filter(Boolean);
+      return {
+        id: runId,
+        scope: typeof run?.scope === 'string' ? run.scope : 'single',
+        currentItem: typeof run?.current_item === 'string'
+          ? run.current_item
+          : (typeof run?.currentItem === 'string' ? run.currentItem : ''),
+        workItems,
+        startedAt: typeof run?.started === 'string' ? run.started : '',
+        folderPath,
+        hasPlan: fs.existsSync(path.join(folderPath, 'plan.md')),
+        hasWalkthrough: fs.existsSync(path.join(folderPath, 'walkthrough.md')),
+        hasTestReport: fs.existsSync(path.join(folderPath, 'test-report.md'))
+      };
+    }).filter(Boolean)
+  };
+}
+
+function probeAidlcWorktreeActivity(worktreePath) {
+  const rootPath = path.join(worktreePath, 'memory-bank');
+  const boltsPath = path.join(rootPath, 'bolts');
+  const boltIds = listSubdirectories(boltsPath);
+  if (boltIds.length === 0) {
+    return { activeBolts: [] };
+  }
+
+  const activeBolts = boltIds.map((boltId) => {
+    const boltPath = path.join(boltsPath, boltId);
+    const boltFilePath = path.join(boltPath, 'bolt.md');
+    const content = readFileSafe(boltFilePath);
+    if (content == null) {
+      return null;
+    }
+
+    const frontmatter = parseFrontmatter(content);
+    const status = normalizeAidlcStatus(frontmatter.status);
+    if (status !== 'in_progress') {
+      return null;
+    }
+
+    const currentStage = typeof frontmatter.current_stage === 'string'
+      ? frontmatter.current_stage
+      : (typeof frontmatter.currentStage === 'string' ? frontmatter.currentStage : null);
+
+    return {
+      id: boltId,
+      intent: typeof frontmatter.intent === 'string' ? frontmatter.intent : '',
+      unit: typeof frontmatter.unit === 'string' ? frontmatter.unit : '',
+      type: typeof frontmatter.type === 'string' ? frontmatter.type : 'simple-construction-bolt',
+      status,
+      currentStage,
+      path: boltPath,
+      filePath: boltFilePath,
+      files: listMarkdownFiles(boltPath),
+      startedAt: typeof frontmatter.started === 'string' ? frontmatter.started : undefined
+    };
+  }).filter(Boolean);
+
+  return { activeBolts };
+}
+
+function probeSimpleWorktreeActivity(worktreePath) {
+  const rootPath = path.join(worktreePath, 'specs');
+  if (!pathExistsAsDirectory(rootPath)) {
+    return { activeSpecs: [] };
+  }
+
+  const specFolders = listSubdirectories(rootPath);
+  const activeSpecs = specFolders.map((name) => {
+    const specPath = path.join(rootPath, name);
+    const tasksPath = path.join(specPath, 'tasks.md');
+    if (!fs.existsSync(tasksPath)) {
+      return null;
+    }
+    return {
+      name,
+      path: specPath
+    };
+  }).filter(Boolean);
+
+  return { activeSpecs };
+}
+
+function probeWorktreeActivity(flow, worktreePath) {
+  const normalizedFlow = normalizeFlowId(flow);
+  if (normalizedFlow === 'aidlc') {
+    return probeAidlcWorktreeActivity(worktreePath);
+  }
+  if (normalizedFlow === 'simple') {
+    return probeSimpleWorktreeActivity(worktreePath);
+  }
+  return probeFireWorktreeActivity(worktreePath);
+}
+
+function extractActivityFromSnapshot(flow, snapshot) {
+  const normalizedFlow = normalizeFlowId(flow);
+  if (normalizedFlow === 'aidlc') {
+    return {
+      activeBolts: Array.isArray(snapshot?.activeBolts) ? snapshot.activeBolts : []
+    };
+  }
+  if (normalizedFlow === 'simple') {
+    return {
+      activeSpecs: Array.isArray(snapshot?.activeSpecs) ? snapshot.activeSpecs : []
+    };
+  }
+  return {
+    activeRuns: Array.isArray(snapshot?.activeRuns) ? snapshot.activeRuns : []
+  };
+}
+
+function getActivityCount(flow, activity) {
+  const normalizedFlow = normalizeFlowId(flow);
+  if (normalizedFlow === 'aidlc') {
+    return Array.isArray(activity?.activeBolts) ? activity.activeBolts.length : 0;
+  }
+  if (normalizedFlow === 'simple') {
+    return Array.isArray(activity?.activeSpecs) ? activity.activeSpecs.length : 0;
+  }
+  return Array.isArray(activity?.activeRuns) ? activity.activeRuns.length : 0;
+}
+
+function buildWorktreeEnvelope(flow, worktrees, selectedWorktreeId, cache, discovery) {
+  const normalizedFlow = normalizeFlowId(flow);
+  const items = (Array.isArray(worktrees) ? worktrees : []).map((worktree) => {
+    const availableFlows = detectAvailableFlows(worktree.path);
+    const flowAvailable = availableFlows.includes(normalizedFlow);
+    const cacheKey = `${normalizedFlow}:${worktree.id}`;
+    const cached = cache.get(cacheKey);
+    const status = flowAvailable
+      ? (cached?.status || 'loading')
+      : 'unavailable';
+    const activity = cached?.activity || null;
+    const activeCount = getActivityCount(normalizedFlow, activity);
+
+    return {
+      ...worktree,
+      isSelected: worktree.id === selectedWorktreeId,
+      flowAvailable,
+      status,
+      activeCount,
+      activity,
+      error: cached?.error || null
+    };
+  });
+
+  return {
+    flow: normalizedFlow,
+    source: discovery?.source || 'fallback',
+    isGitRepo: Boolean(discovery?.isGitRepo),
+    selectedWorktreeId,
+    hasPendingScans: items.some((item) => item.status === 'loading'),
+    error: discovery?.error,
+    items
+  };
+}
+
+function getWatchRootsForEnvelope(flow, envelope) {
+  const normalizedFlow = normalizeFlowId(flow);
+  const config = FLOW_CONFIG[normalizedFlow];
+  if (!config) {
+    return [];
+  }
+
+  const roots = [];
+  const items = Array.isArray(envelope?.items) ? envelope.items : [];
+  const selectedId = envelope?.selectedWorktreeId;
+  const selectedItem = items.find((item) => item.id === selectedId);
+
+  if (selectedItem) {
+    roots.push(resolveRootPathForFlow(selectedItem.path, normalizedFlow));
+  }
+
+  for (const item of items) {
+    if (item.id === selectedId) {
+      continue;
+    }
+    if (!item.flowAvailable) {
+      continue;
+    }
+    if (item.activeCount <= 0 && item.status !== 'loading') {
+      continue;
+    }
+    roots.push(resolveRootPathForFlow(item.path, normalizedFlow));
+  }
+
+  return Array.from(new Set(roots))
+    .filter((rootPath) => pathExistsAsDirectory(rootPath))
+    .slice(0, MAX_WORKTREE_WATCH_ROOTS);
+}
+
 function formatStaticFlowText(flow, snapshot, error) {
   if (flow === 'fire') {
     return formatDashboardText({
@@ -141,21 +456,160 @@ async function runFlowDashboard(options, flow, availableFlows = []) {
 
   const watchEnabled = options.watch !== false;
   const refreshMs = parseRefreshMs(options.refreshMs);
-  const parseSnapshotForFlow = async (flowId) => {
-    const flowConfig = FLOW_CONFIG[flowId];
+  const explicitWorktreeSelection = typeof options.worktree === 'string' ? options.worktree.trim() : '';
+  let selectedWorktreeId = explicitWorktreeSelection || null;
+  let lastWorktreeEnvelope = null;
+  const activityCache = new Map();
+  const pendingProbes = new Map();
+
+  const parseSnapshotForFlow = async (flowId, context = {}) => {
+    const normalizedFlow = normalizeFlowId(flowId);
+    const flowConfig = FLOW_CONFIG[normalizedFlow];
     if (!flowConfig) {
       return {
         ok: false,
         error: {
           code: 'UNSUPPORTED_FLOW',
-          message: `Flow \"${flowId}\" is not supported.`
+          message: `Flow \"${normalizedFlow}\" is not supported.`
+        }
+      };
+    }
+
+    const discovery = discoverGitWorktrees(workspacePath);
+    const worktrees = Array.isArray(discovery?.worktrees) ? discovery.worktrees : [];
+    const requestedWorktreeSelector = String(context.selectedWorktreeId || selectedWorktreeId || explicitWorktreeSelection || '').trim();
+    const selectedWorktree = pickWorktree(worktrees, requestedWorktreeSelector, workspacePath)
+      || pickWorktree(worktrees, workspacePath, workspacePath)
+      || worktrees[0];
+
+    selectedWorktreeId = selectedWorktree?.id || selectedWorktreeId;
+
+    const selectedResult = selectedWorktree
+      ? await flowConfig.parse(selectedWorktree.path)
+      : {
+        ok: false,
+        error: {
+          code: 'WORKTREE_NOT_FOUND',
+          message: 'No selectable worktree was found for dashboard parsing.'
+        }
+      };
+
+    if (selectedWorktree) {
+      const cacheKey = `${normalizedFlow}:${selectedWorktree.id}`;
+      if (selectedResult?.ok) {
+        activityCache.set(cacheKey, {
+          status: 'ready',
+          activity: extractActivityFromSnapshot(normalizedFlow, selectedResult.snapshot),
+          error: null,
+          updatedAt: Date.now()
+        });
+      } else {
+        activityCache.set(cacheKey, {
+          status: 'error',
+          activity: null,
+          error: selectedResult?.error || null,
+          updatedAt: Date.now()
+        });
+      }
+    }
+
+    for (const worktree of worktrees) {
+      if (!worktree || worktree.id === selectedWorktreeId) {
+        continue;
+      }
+
+      const availableFlowsForWorktree = detectAvailableFlows(worktree.path);
+      const flowAvailable = availableFlowsForWorktree.includes(normalizedFlow);
+      const cacheKey = `${normalizedFlow}:${worktree.id}`;
+
+      if (!flowAvailable) {
+        activityCache.set(cacheKey, {
+          status: 'unavailable',
+          activity: null,
+          error: null,
+          updatedAt: Date.now()
+        });
+        continue;
+      }
+
+      const cached = activityCache.get(cacheKey);
+      const shouldRefreshProbe = !cached || (Date.now() - (cached.updatedAt || 0)) > 2000;
+      if (!shouldRefreshProbe || pendingProbes.has(cacheKey)) {
+        continue;
+      }
+
+      activityCache.set(cacheKey, {
+        status: 'loading',
+        activity: cached?.activity || null,
+        error: null,
+        updatedAt: Date.now()
+      });
+
+      const probePromise = Promise.resolve()
+        .then(() => probeWorktreeActivity(normalizedFlow, worktree.path))
+        .then((activity) => {
+          activityCache.set(cacheKey, {
+            status: 'ready',
+            activity,
+            error: null,
+            updatedAt: Date.now()
+          });
+        })
+        .catch((probeError) => {
+          activityCache.set(cacheKey, {
+            status: 'error',
+            activity: null,
+            error: {
+              code: 'WORKTREE_PROBE_ERROR',
+              message: probeError?.message || String(probeError)
+            },
+            updatedAt: Date.now()
+          });
+        })
+        .finally(() => {
+          pendingProbes.delete(cacheKey);
+        });
+
+      pendingProbes.set(cacheKey, probePromise);
+    }
+
+    const envelope = buildWorktreeEnvelope(
+      normalizedFlow,
+      worktrees,
+      selectedWorktreeId,
+      activityCache,
+      discovery
+    );
+    lastWorktreeEnvelope = envelope;
+
+    if (!selectedResult?.ok) {
+      return {
+        ok: false,
+        error: {
+          ...(selectedResult?.error || {
+            code: 'PARSE_ERROR',
+            message: 'Unable to parse selected worktree snapshot.'
+          }),
+          details: selectedWorktree
+            ? `worktree: ${selectedWorktree.displayBranch} (${selectedWorktree.path})`
+            : undefined
         }
       };
     }
-    return flowConfig.parse(workspacePath);
+
+    return {
+      ok: true,
+      snapshot: {
+        ...selectedResult.snapshot,
+        workspacePath: selectedWorktree?.path || selectedResult.snapshot?.workspacePath || workspacePath,
+        dashboardWorktrees: envelope
+      }
+    };
   };
 
-  const initialResult = await parseSnapshotForFlow(flow);
+  const initialResult = await parseSnapshotForFlow(flow, {
+    selectedWorktreeId: selectedWorktreeId || explicitWorktreeSelection || workspacePath
+  });
   clearTerminalOutput();
 
   if (!watchEnabled) {
@@ -190,6 +644,16 @@ async function runFlowDashboard(options, flow, availableFlows = []) {
     flow,
     availableFlows: flowIds,
     resolveRootPathForFlow: (flowId) => resolveRootPathForFlow(workspacePath, flowId),
+    resolveRootPathsForFlow: (flowId) => {
+      if (!lastWorktreeEnvelope) {
+        return [resolveRootPathForFlow(workspacePath, flowId)];
+      }
+      const roots = getWatchRootsForEnvelope(flowId, lastWorktreeEnvelope);
+      if (roots.length > 0) {
+        return roots;
+      }
+      return [resolveRootPathForFlow(workspacePath, flowId)];
+    },
     refreshMs,
     watchEnabled,
     initialSnapshot: initialResult.ok ? initialResult.snapshot : null,
@@ -236,5 +700,7 @@ module.exports = {
   parseRefreshMs,
   formatStaticFlowText,
   clearTerminalOutput,
-  createInkStdout
+  createInkStdout,
+  probeWorktreeActivity,
+  getWatchRootsForEnvelope
 };

package/lib/dashboard/runtime/watch-runtime.js

@@ -32,13 +32,19 @@ function createDebouncedTrigger(callback, delayMs) {
 function createWatchRuntime(options) {
   const {
     rootPath,
+    rootPaths,
     onRefresh,
     onError,
     debounceMs = 250
   } = options;
 
-  if (!rootPath || typeof rootPath !== 'string') {
-    throw new Error('rootPath is required for watch runtime');
+  const roots = Array.from(new Set([
+    ...(Array.isArray(rootPaths) ? rootPaths : []),
+    ...(typeof rootPath === 'string' ? [rootPath] : [])
+  ].filter((value) => typeof value === 'string' && value.trim() !== '')));
+
+  if (roots.length === 0) {
+    throw new Error('rootPath or rootPaths is required for watch runtime');
   }
 
   if (typeof onRefresh !== 'function') {
@@ -51,12 +57,14 @@ function createWatchRuntime(options) {
   let started = false;
   const debounced = createDebouncedTrigger(onRefresh, debounceMs);
 
-  const watchTargets = [
-    path.join(rootPath, 'state.yaml'),
-    path.join(rootPath, 'intents'),
-    path.join(rootPath, 'runs'),
-    path.join(rootPath, 'standards')
-  ];
+  const watchTargets = roots.flatMap((baseRoot) => ([
+    path.join(baseRoot, 'state.yaml'),
+    path.join(baseRoot, 'intents'),
+    path.join(baseRoot, 'runs'),
+    path.join(baseRoot, 'standards'),
+    path.join(baseRoot, 'bolts'),
+    path.join(baseRoot, 'specs')
+  ]));
 
   function start() {
     if (started) {
@@ -103,7 +111,8 @@ function createWatchRuntime(options) {
     start,
     close,
     isActive: () => started,
-    hasPendingRefresh: () => debounced.isPending()
+    hasPendingRefresh: () => debounced.isPending(),
+    getRoots: () => [...roots]
   };
 }