specsmd 0.0.0-dev.85 → 0.0.0-dev.87

package/lib/dashboard/tui/sections.js

@@ -0,0 +1,45 @@
+function getSectionOrderForView(view, options = {}) {
+  const includeWorktrees = options.includeWorktrees === true;
+  const includeOtherWorktrees = options.includeOtherWorktrees === true;
+
+  if (view === 'intents') {
+    return ['intent-status'];
+  }
+  if (view === 'completed') {
+    return ['completed-runs'];
+  }
+  if (view === 'health') {
+    return ['standards', 'stats', 'warnings', 'error-details'];
+  }
+  if (view === 'git') {
+    return ['git-status', 'git-changes', 'git-commits', 'git-diff'];
+  }
+  const sections = [];
+  if (includeWorktrees) {
+    sections.push('worktrees');
+  }
+  sections.push('current-run', 'run-files');
+  if (includeOtherWorktrees) {
+    sections.push('other-worktrees-active');
+  }
+  return sections;
+}
+
+function cycleSection(view, currentSectionKey, direction = 1, availableSections = null) {
+  const order = Array.isArray(availableSections) && availableSections.length > 0
+    ? availableSections
+    : getSectionOrderForView(view);
+  if (order.length === 0) {
+    return currentSectionKey;
+  }
+
+  const currentIndex = order.indexOf(currentSectionKey);
+  const safeIndex = currentIndex >= 0 ? currentIndex : 0;
+  const nextIndex = (safeIndex + direction + order.length) % order.length;
+  return order[nextIndex];
+}
+
+module.exports = {
+  getSectionOrderForView,
+  cycleSection
+};

package/lib/dashboard/tui/store.js

@@ -0,0 +1,44 @@
+function createInitialUIState() {
+  return {
+    view: 'runs',
+    showHelp: false
+  };
+}
+
+function cycleView(current) {
+  if (current === 'runs') {
+    return 'intents';
+  }
+  if (current === 'intents') {
+    return 'completed';
+  }
+  if (current === 'completed') {
+    return 'health';
+  }
+  if (current === 'health') {
+    return 'git';
+  }
+  return 'runs';
+}
+
+function cycleViewBackward(current) {
+  if (current === 'runs') {
+    return 'git';
+  }
+  if (current === 'intents') {
+    return 'runs';
+  }
+  if (current === 'completed') {
+    return 'intents';
+  }
+  if (current === 'health') {
+    return 'completed';
+  }
+  return 'health';
+}
+
+module.exports = {
+  createInitialUIState,
+  cycleView,
+  cycleViewBackward
+};

package/lib/dashboard/tui/views/overview-view.js

@@ -0,0 +1,61 @@
+const { truncate } = require('../components/header');
+
+const STANDARD_TYPES = [
+  'constitution',
+  'tech-stack',
+  'coding-standards',
+  'testing-standards',
+  'system-architecture'
+];
+
+function renderOverviewViewLines(snapshot, width) {
+  const lines = ['Overview'];
+
+  if (!snapshot?.initialized) {
+    lines.push('FIRE project folder exists but state.yaml is missing.');
+    lines.push('Run initialization and the overview will appear automatically.');
+    return lines.map((line) => truncate(line, width));
+  }
+
+  const project = snapshot.project || {};
+  const workspace = snapshot.workspace || {};
+
+  lines.push(`Project: ${project.name || 'Unknown'} | FIRE version: ${project.fireVersion || snapshot.version || '0.0.0'}`);
+  lines.push(`Workspace: ${workspace.type || 'unknown'} / ${workspace.structure || 'unknown'} | autonomy: ${workspace.autonomyBias || 'unknown'} | run scope pref: ${workspace.runScopePreference || 'unknown'}`);
+  lines.push('');
+
+  lines.push('Intent Summary');
+  lines.push(`  total: ${snapshot.stats.totalIntents} | completed: ${snapshot.stats.completedIntents} | in_progress: ${snapshot.stats.inProgressIntents} | pending: ${snapshot.stats.pendingIntents} | blocked: ${snapshot.stats.blockedIntents}`);
+  lines.push('');
+
+  lines.push('Work Item Summary');
+  lines.push(`  total: ${snapshot.stats.totalWorkItems} | completed: ${snapshot.stats.completedWorkItems} | in_progress: ${snapshot.stats.inProgressWorkItems} | pending: ${snapshot.stats.pendingWorkItems} | blocked: ${snapshot.stats.blockedWorkItems}`);
+  lines.push('');
+
+  const standardSet = new Set((snapshot.standards || []).map((item) => item.type));
+  lines.push('Standards');
+  for (const type of STANDARD_TYPES) {
+    const marker = standardSet.has(type) ? '[x]' : '[ ]';
+    lines.push(`  ${marker} ${type}.md`);
+  }
+
+  lines.push('');
+  lines.push('Top Intents');
+
+  const intents = (snapshot.intents || []).slice(0, 6);
+  if (intents.length === 0) {
+    lines.push('  - none');
+  } else {
+    for (const intent of intents) {
+      const totalWorkItems = (intent.workItems || []).length;
+      const completedWorkItems = (intent.workItems || []).filter((item) => item.status === 'completed').length;
+      lines.push(`  - ${intent.id}: ${intent.status} (${completedWorkItems}/${totalWorkItems} work items completed)`);
+    }
+  }
+
+  return lines.map((line) => truncate(line, width));
+}
+
+module.exports = {
+  renderOverviewViewLines
+};

package/lib/dashboard/tui/views/runs-view.js

@@ -0,0 +1,93 @@
+const { truncate } = require('../components/header');
+
+function safeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function formatRunProgress(run) {
+  const workItems = safeArray(run.workItems);
+  const total = workItems.length;
+  const completed = workItems.filter((item) => item.status === 'completed').length;
+  const inProgress = workItems.filter((item) => item.status === 'in_progress').length;
+  return `${completed}/${total} completed${inProgress > 0 ? `, ${inProgress} in_progress` : ''}`;
+}
+
+function renderActiveRunLines(activeRuns, width) {
+  const lines = ['Active Runs'];
+  if (!activeRuns || activeRuns.length === 0) {
+    lines.push('  - none');
+    return lines.map((line) => truncate(line, width));
+  }
+
+  for (const run of activeRuns) {
+    const currentItem = run.currentItem || 'n/a';
+    const artifacts = [
+      run.hasPlan ? 'plan' : null,
+      run.hasWalkthrough ? 'walkthrough' : null,
+      run.hasTestReport ? 'test-report' : null
+    ].filter(Boolean).join(', ') || 'no artifacts yet';
+
+    lines.push(`  - ${run.id} [${run.scope}] current: ${currentItem}`);
+    lines.push(`    progress: ${formatRunProgress(run)} | artifacts: ${artifacts}`);
+  }
+
+  return lines.map((line) => truncate(line, width));
+}
+
+function renderPendingQueueLines(pendingItems, width) {
+  const lines = ['Pending Queue'];
+  if (!pendingItems || pendingItems.length === 0) {
+    lines.push('  - none');
+    return lines.map((line) => truncate(line, width));
+  }
+
+  for (const item of pendingItems.slice(0, 12)) {
+    const deps = item.dependencies && item.dependencies.length > 0
+      ? ` deps:${item.dependencies.join(',')}`
+      : '';
+    lines.push(`  - ${item.id} (${item.mode}/${item.complexity}) in ${item.intentTitle}${deps}`);
+  }
+
+  if (pendingItems.length > 12) {
+    lines.push(`  ... ${pendingItems.length - 12} more pending items`);
+  }
+
+  return lines.map((line) => truncate(line, width));
+}
+
+function renderCompletedRunLines(completedRuns, width) {
+  const lines = ['Recent Completed Runs'];
+  if (!completedRuns || completedRuns.length === 0) {
+    lines.push('  - none');
+    return lines.map((line) => truncate(line, width));
+  }
+
+  for (const run of completedRuns.slice(0, 5)) {
+    const completedAt = run.completedAt || 'unknown';
+    lines.push(`  - ${run.id} [${run.scope}] completed: ${completedAt} | ${formatRunProgress(run)}`);
+  }
+
+  return lines.map((line) => truncate(line, width));
+}
+
+function renderRunsViewLines(snapshot, width) {
+  const lines = [];
+
+  if (!snapshot?.initialized) {
+    lines.push('FIRE detected, but state.yaml is not initialized yet.');
+    lines.push('Initialize FIRE project context, then the dashboard will auto-populate.');
+    return lines.map((line) => truncate(line, width));
+  }
+
+  lines.push(...renderActiveRunLines(snapshot.activeRuns, width));
+  lines.push('');
+  lines.push(...renderPendingQueueLines(snapshot.pendingItems, width));
+  lines.push('');
+  lines.push(...renderCompletedRunLines(snapshot.completedRuns, width));
+
+  return lines.map((line) => truncate(line, width));
+}
+
+module.exports = {
+  renderRunsViewLines
+};

package/lib/dashboard/tui/worktree-builders.js

@@ -0,0 +1,229 @@
+const path = require('path');
+const { clampIndex } = require('./helpers');
+const { truncate } = require('./helpers');
+const { getEffectiveFlow, getCurrentBolt } = require('./flow-builders');
+const { collectAidlcBoltFiles } = require('./file-entries');
+const { collectFireRunFiles } = require('./file-entries');
+
+function getDashboardWorktreeMeta(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object') {
+    return null;
+  }
+  const meta = snapshot.dashboardWorktrees;
+  if (!meta || typeof meta !== 'object') {
+    return null;
+  }
+  const items = Array.isArray(meta.items) ? meta.items : [];
+  if (items.length === 0) {
+    return null;
+  }
+  return {
+    ...meta,
+    items
+  };
+}
+
+function getWorktreeItems(snapshot) {
+  return getDashboardWorktreeMeta(snapshot)?.items || [];
+}
+
+function getSelectedWorktree(snapshot) {
+  const meta = getDashboardWorktreeMeta(snapshot);
+  if (!meta) {
+    return null;
+  }
+  return meta.items.find((item) => item.id === meta.selectedWorktreeId) || null;
+}
+
+function hasMultipleWorktrees(snapshot) {
+  return getWorktreeItems(snapshot).length > 1;
+}
+
+function isSelectedWorktreeMain(snapshot) {
+  const selected = getSelectedWorktree(snapshot);
+  return Boolean(selected?.isMainBranch);
+}
+
+function getWorktreeDisplayName(worktree) {
+  if (!worktree || typeof worktree !== 'object') {
+    return 'unknown';
+  }
+  if (typeof worktree.displayBranch === 'string' && worktree.displayBranch.trim() !== '') {
+    return worktree.displayBranch;
+  }
+  if (typeof worktree.branch === 'string' && worktree.branch.trim() !== '') {
+    return worktree.branch;
+  }
+  if (typeof worktree.name === 'string' && worktree.name.trim() !== '') {
+    return worktree.name;
+  }
+  return path.basename(worktree.path || '') || 'unknown';
+}
+
+function buildWorktreeRows(snapshot, flow) {
+  const meta = getDashboardWorktreeMeta(snapshot);
+  if (!meta) {
+    return [{
+      kind: 'info',
+      key: 'worktrees:none',
+      label: 'No git worktrees detected',
+      selectable: false
+    }];
+  }
+
+  const effectiveFlow = getEffectiveFlow(flow, snapshot);
+  const entityLabel = effectiveFlow === 'aidlc'
+    ? 'active bolts'
+    : (effectiveFlow === 'simple' ? 'active specs' : 'active runs');
+
+  const rows = [];
+  for (const item of meta.items) {
+    const currentLabel = item.isSelected ? '[CURRENT] ' : '';
+    const mainLabel = item.isMainBranch && !item.detached ? '[MAIN] ' : '';
+    const availabilityLabel = item.flowAvailable ? '' : ' (flow unavailable)';
+    const statusLabel = item.status === 'loading'
+      ? ' loading...'
+      : (item.status === 'error' ? ' error' : ` ${item.activeCount || 0} ${entityLabel}`);
+    const scopeLabel = item.name ? ` (${item.name})` : '';
+
+    rows.push({
+      kind: 'info',
+      key: `worktree:item:${item.id}`,
+      label: `${currentLabel}${mainLabel}${getWorktreeDisplayName(item)}${scopeLabel}${availabilityLabel}${statusLabel}`,
+      color: item.isSelected ? 'green' : (item.flowAvailable ? 'gray' : 'red'),
+      bold: item.isSelected,
+      selectable: true
+    });
+  }
+
+  return rows;
+}
+
+function buildOtherWorktreeActiveGroups(snapshot, flow) {
+  const effectiveFlow = getEffectiveFlow(flow, snapshot);
+  if (effectiveFlow === 'simple') {
+    return [];
+  }
+
+  const meta = getDashboardWorktreeMeta(snapshot);
+  if (!meta) {
+    return [];
+  }
+
+  const selectedWorktree = getSelectedWorktree(snapshot);
+  if (!selectedWorktree || !selectedWorktree.isMainBranch) {
+    return [];
+  }
+
+  const groups = [];
+  const otherItems = meta.items.filter((item) => item.id !== meta.selectedWorktreeId);
+  for (const item of otherItems) {
+    if (!item.flowAvailable || item.status === 'unavailable' || item.status === 'error') {
+      continue;
+    }
+
+    if (effectiveFlow === 'aidlc') {
+      const activeBolts = Array.isArray(item.activity?.activeBolts) ? item.activity.activeBolts : [];
+      for (const bolt of activeBolts) {
+        const stages = Array.isArray(bolt?.stages) ? bolt.stages : [];
+        const completedStages = stages.filter((stage) => stage?.status === 'completed').length;
+        groups.push({
+          key: `other:wt:${item.id}:bolt:${bolt.id}`,
+          label: `[WT ${getWorktreeDisplayName(item)}] ${bolt.id} [${bolt.type || 'bolt'}] ${completedStages}/${stages.length || 0} stages`,
+          files: collectAidlcBoltFiles(bolt).map((file) => ({ ...file, scope: 'active' }))
+        });
+      }
+      continue;
+    }
+
+    const activeRuns = Array.isArray(item.activity?.activeRuns) ? item.activity.activeRuns : [];
+    for (const run of activeRuns) {
+      const workItems = Array.isArray(run?.workItems) ? run.workItems : [];
+      const completed = workItems.filter((workItem) => workItem?.status === 'completed').length;
+      groups.push({
+        key: `other:wt:${item.id}:run:${run.id}`,
+        label: `[WT ${getWorktreeDisplayName(item)}] ${run.id} [${run.scope || 'single'}] ${completed}/${workItems.length} items`,
+        files: collectFireRunFiles(run).map((file) => ({ ...file, scope: 'active' }))
+      });
+    }
+  }
+
+  return groups;
+}
+
+function getOtherWorktreeEmptyMessage(snapshot, flow) {
+  const effectiveFlow = getEffectiveFlow(flow, snapshot);
+  if (!hasMultipleWorktrees(snapshot)) {
+    return 'No additional worktrees';
+  }
+  if (!isSelectedWorktreeMain(snapshot)) {
+    return 'Switch to main worktree to view active items from other worktrees';
+  }
+  if (effectiveFlow === 'aidlc') {
+    return 'No active bolts in other worktrees';
+  }
+  if (effectiveFlow === 'simple') {
+    return 'No active specs in other worktrees';
+  }
+  return 'No active runs in other worktrees';
+}
+
+function buildWorktreeOverlayLines(snapshot, selectedIndex, width) {
+  const meta = getDashboardWorktreeMeta(snapshot);
+  if (!meta) {
+    return [{
+      text: truncate('No worktrees available', width),
+      color: 'gray',
+      bold: false
+    }];
+  }
+
+  const items = Array.isArray(meta.items) ? meta.items : [];
+  const clampedIndex = clampIndex(selectedIndex, items.length || 1);
+  const lines = [{
+    text: truncate('Use ↑/↓ and Enter to switch. Esc closes.', width),
+    color: 'gray',
+    bold: false
+  }];
+
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    const marker = index === clampedIndex ? '>' : ' ';
+    const current = item.isSelected ? '[CURRENT] ' : '';
+    const main = item.isMainBranch && !item.detached ? '[MAIN] ' : '';
+    const status = item.status === 'loading'
+      ? 'loading'
+      : (item.status === 'error'
+        ? 'error'
+        : (item.flowAvailable ? `${item.activeCount || 0} active` : 'flow unavailable'));
+    const pathLabel = item.path ? path.basename(item.path) : 'unknown';
+    lines.push({
+      text: truncate(`${marker} ${current}${main}${getWorktreeDisplayName(item)} (${pathLabel}) | ${status}`, width),
+      color: index === clampedIndex ? 'green' : (item.isSelected ? 'cyan' : 'gray'),
+      bold: index === clampedIndex || item.isSelected
+    });
+  }
+
+  if (meta.hasPendingScans) {
+    lines.push({
+      text: truncate('Background scan in progress for additional worktrees...', width),
+      color: 'yellow',
+      bold: false
+    });
+  }
+
+  return lines;
+}
+
+module.exports = {
+  getDashboardWorktreeMeta,
+  getWorktreeItems,
+  getSelectedWorktree,
+  hasMultipleWorktrees,
+  isSelectedWorktreeMain,
+  getWorktreeDisplayName,
+  buildWorktreeRows,
+  buildOtherWorktreeActiveGroups,
+  getOtherWorktreeEmptyMessage,
+  buildWorktreeOverlayLines
+};

package/lib/installers/CodexInstaller.js

@@ -1,4 +1,8 @@
 const ToolInstaller = require('./ToolInstaller');
+const fs = require('fs-extra');
+const path = require('path');
+const CLIUtils = require('../cli-utils');
+const { theme } = CLIUtils;
 
 class CodexInstaller extends ToolInstaller {
     get key() {
@@ -10,12 +14,79 @@ class CodexInstaller extends ToolInstaller {
     }
 
     get commandsDir() {
-        return '.codex';
+        return path.join('.codex', 'skills');
     }
 
     get detectPath() {
         return '.codex';
     }
+
+    async installCommands(flowPath, config) {
+        const targetSkillsDir = this.commandsDir;
+        console.log(theme.dim(`  Installing skills to ${targetSkillsDir}/...`));
+        await fs.ensureDir(targetSkillsDir);
+
+        const commandsSourceDir = path.join(flowPath, 'commands');
+        if (!await fs.pathExists(commandsSourceDir)) {
+            console.log(theme.warning(`  No commands folder found at ${commandsSourceDir}`));
+            return [];
+        }
+
+        const commandFiles = await fs.readdir(commandsSourceDir);
+        const installedFiles = [];
+
+        for (const cmdFile of commandFiles) {
+            if (!cmdFile.endsWith('.md')) continue;
+
+            try {
+                const sourcePath = path.join(commandsSourceDir, cmdFile);
+                const content = await fs.readFile(sourcePath, 'utf8');
+                const commandName = cmdFile.replace('.md', '');
+                const prefix = (config && config.command && config.command.prefix) ? `${config.command.prefix}-` : '';
+                const skillName = `specsmd-${prefix}${commandName}`;
+
+                const { description, body } = this.parseFrontmatter(content);
+
+                // Build SKILL.md with Codex frontmatter
+                const skillContent = [
+                    '---',
+                    `name: ${skillName}`,
+                    `description: "${description || 'specsmd agent'}"`,
+                    '---',
+                    '',
+                    body
+                ].join('\n');
+
+                // Write SKILL.md
+                const skillDir = path.join(targetSkillsDir, skillName);
+                await fs.ensureDir(skillDir);
+                await fs.writeFile(path.join(skillDir, 'SKILL.md'), skillContent, 'utf8');
+
+                installedFiles.push(skillName);
+            } catch (err) {
+                console.log(theme.warning(`  Failed to install ${cmdFile}: ${err.message}`));
+            }
+        }
+
+        CLIUtils.displayStatus('', `Installed ${installedFiles.length} skills for ${this.name}`, 'success');
+        return installedFiles;
+    }
+
+    /**
+     * Parse YAML frontmatter from a markdown file
+     */
+    parseFrontmatter(content) {
+        const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+        if (!match) return { description: '', body: content };
+
+        const frontmatter = match[1];
+        const body = match[2];
+        const descMatch = frontmatter.match(/description:\s*["']?(.+?)["']?\s*$/m);
+        return {
+            description: descMatch ? descMatch[1] : '',
+            body: body.trim()
+        };
+    }
 }
 
 module.exports = CodexInstaller;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specsmd",
-  "version": "0.0.0-dev.85",
+  "version": "0.0.0-dev.87",
   "description": "Multi-agent orchestration system for AI-native software development. Delivers AI-DLC, Agile, and custom SDLC flows as markdown-based agent systems.",
   "main": "lib/installer.js",
   "bin": {
@@ -40,18 +40,22 @@
     "README.md"
   ],
   "dependencies": {
+    "@inkjs/ui": "^2.0.0",
     "chalk": "^4.1.2",
+    "chokidar": "^4.0.3",
     "commander": "^11.1.0",
     "figlet": "^1.9.4",
     "fs-extra": "^11.1.1",
     "gradient-string": "^2.0.2",
+    "ink": "^5.2.1",
     "js-yaml": "^4.1.0",
     "mixpanel": "^0.18.0",
     "oh-my-logo": "^0.4.0",
-    "prompts": "^2.4.2"
+    "prompts": "^2.4.2",
+    "react": "^18.3.1"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=20.0.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",