specsmd 0.0.0-dev.86 → 0.0.0-dev.87

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

@@ -0,0 +1,218 @@
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { fileExists } = require('./helpers');
+
+function getGitChangesSnapshot(snapshot) {
+  const gitChanges = snapshot?.gitChanges;
+  if (!gitChanges || typeof gitChanges !== 'object') {
+    return {
+      available: false,
+      branch: '(unavailable)',
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      counts: {
+        total: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0
+      },
+      staged: [],
+      unstaged: [],
+      untracked: [],
+      conflicted: [],
+      clean: true
+    };
+  }
+  return {
+    ...gitChanges,
+    counts: gitChanges.counts || {
+      total: 0,
+      staged: 0,
+      unstaged: 0,
+      untracked: 0,
+      conflicted: 0
+    },
+    staged: Array.isArray(gitChanges.staged) ? gitChanges.staged : [],
+    unstaged: Array.isArray(gitChanges.unstaged) ? gitChanges.unstaged : [],
+    untracked: Array.isArray(gitChanges.untracked) ? gitChanges.untracked : [],
+    conflicted: Array.isArray(gitChanges.conflicted) ? gitChanges.conflicted : []
+  };
+}
+
+function readGitCommandLines(repoRoot, args, options = {}) {
+  if (typeof repoRoot !== 'string' || repoRoot.trim() === '' || !Array.isArray(args) || args.length === 0) {
+    return [];
+  }
+
+  const acceptedStatuses = Array.isArray(options.acceptedStatuses) && options.acceptedStatuses.length > 0
+    ? options.acceptedStatuses
+    : [0];
+
+  const result = spawnSync('git', args, {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    maxBuffer: 8 * 1024 * 1024
+  });
+
+  if (result.error) {
+    return [];
+  }
+
+  if (typeof result.status === 'number' && !acceptedStatuses.includes(result.status)) {
+    return [];
+  }
+
+  const lines = String(result.stdout || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const limit = Number.isFinite(options.limit) ? Math.max(1, Math.floor(options.limit)) : null;
+  if (limit == null || lines.length <= limit) {
+    return lines;
+  }
+  return lines.slice(0, limit);
+}
+
+function buildGitStatusPanelLines(snapshot) {
+  const git = getGitChangesSnapshot(snapshot);
+  if (!git.available) {
+    return [{
+      text: 'Repository unavailable in selected worktree',
+      color: 'red',
+      bold: true
+    }];
+  }
+
+  const tracking = git.upstream
+    ? `${git.upstream} (${git.ahead > 0 ? `ahead ${git.ahead}` : 'ahead 0'}, ${git.behind > 0 ? `behind ${git.behind}` : 'behind 0'})`
+    : 'no upstream';
+
+  return [
+    {
+      text: `branch: ${git.branch}${git.detached ? ' [detached]' : ''}`,
+      color: 'green',
+      bold: true
+    },
+    {
+      text: `tracking: ${tracking}`,
+      color: 'gray',
+      bold: false
+    },
+    {
+      text: `changes: ${git.counts.total || 0} total`,
+      color: 'gray',
+      bold: false
+    },
+    {
+      text: `staged ${git.counts.staged || 0} | unstaged ${git.counts.unstaged || 0}`,
+      color: 'yellow',
+      bold: false
+    },
+    {
+      text: `untracked ${git.counts.untracked || 0} | conflicts ${git.counts.conflicted || 0}`,
+      color: 'yellow',
+      bold: false
+    }
+  ];
+}
+
+function buildGitCommitRows(snapshot) {
+  const git = getGitChangesSnapshot(snapshot);
+  if (!git.available) {
+    return [{
+      kind: 'info',
+      key: 'git:commits:unavailable',
+      label: 'No commit history (git unavailable)',
+      selectable: false
+    }];
+  }
+
+  const commitLines = readGitCommandLines(git.rootPath, [
+    '-c',
+    'color.ui=false',
+    'log',
+    '--date=relative',
+    '--pretty=format:%h %s',
+    '--max-count=30'
+  ], { limit: 30 });
+
+  if (commitLines.length === 0) {
+    return [{
+      kind: 'info',
+      key: 'git:commits:empty',
+      label: 'No commits found',
+      selectable: false
+    }];
+  }
+
+  return commitLines.map((line, index) => {
+    const firstSpace = line.indexOf(' ');
+    const commitHash = firstSpace > 0 ? line.slice(0, firstSpace) : '';
+    const message = firstSpace > 0 ? line.slice(firstSpace + 1) : line;
+    const label = commitHash ? `${commitHash} ${message}` : message;
+
+    return {
+      kind: 'git-commit',
+      key: `git:commit:${commitHash || index}:${index}`,
+      label,
+      commitHash,
+      repoRoot: git.rootPath,
+      previewType: 'git-commit-diff',
+      selectable: true
+    };
+  });
+}
+
+function buildGitChangeGroups(snapshot) {
+  const git = getGitChangesSnapshot(snapshot);
+
+  if (!git.available) {
+    return [];
+  }
+
+  const makeFiles = (items, scope) => items.map((item) => ({
+    label: item.relativePath,
+    path: item.path || path.join(git.rootPath || snapshot?.workspacePath || '', item.relativePath || ''),
+    scope,
+    allowMissing: true,
+    previewType: 'git-diff',
+    repoRoot: git.rootPath || snapshot?.workspacePath || '',
+    relativePath: item.relativePath || '',
+    bucket: item.bucket || scope
+  }));
+
+  const groups = [];
+  groups.push({
+    key: 'git:staged',
+    label: `staged (${git.counts.staged || 0})`,
+    files: makeFiles(git.staged, 'staged')
+  });
+  groups.push({
+    key: 'git:unstaged',
+    label: `unstaged (${git.counts.unstaged || 0})`,
+    files: makeFiles(git.unstaged, 'unstaged')
+  });
+  groups.push({
+    key: 'git:untracked',
+    label: `untracked (${git.counts.untracked || 0})`,
+    files: makeFiles(git.untracked, 'untracked')
+  });
+  groups.push({
+    key: 'git:conflicted',
+    label: `conflicts (${git.counts.conflicted || 0})`,
+    files: makeFiles(git.conflicted, 'conflicted')
+  });
+
+  return groups;
+}
+
+module.exports = {
+  getGitChangesSnapshot,
+  readGitCommandLines,
+  buildGitStatusPanelLines,
+  buildGitCommitRows,
+  buildGitChangeGroups
+};

package/lib/dashboard/tui/helpers.js

@@ -0,0 +1,236 @@
+const fs = require('fs');
+const stringWidthModule = require('string-width');
+const sliceAnsiModule = require('slice-ansi');
+
+const stringWidth = typeof stringWidthModule === 'function'
+  ? stringWidthModule
+  : stringWidthModule.default;
+const sliceAnsi = typeof sliceAnsiModule === 'function'
+  ? sliceAnsiModule
+  : sliceAnsiModule.default;
+
+function toDashboardError(error, defaultCode = 'DASHBOARD_ERROR') {
+  if (!error) {
+    return {
+      code: defaultCode,
+      message: 'Unknown dashboard error.'
+    };
+  }
+
+  if (typeof error === 'string') {
+    return {
+      code: defaultCode,
+      message: error
+    };
+  }
+
+  if (typeof error === 'object') {
+    return {
+      code: error.code || defaultCode,
+      message: error.message || 'Unknown dashboard error.',
+      details: error.details,
+      path: error.path,
+      hint: error.hint
+    };
+  }
+
+  return {
+    code: defaultCode,
+    message: String(error)
+  };
+}
+
+function safeJsonHash(value) {
+  try {
+    return JSON.stringify(value, (key, nestedValue) => {
+      if (key === 'generatedAt') {
+        return undefined;
+      }
+      return nestedValue;
+    });
+  } catch {
+    return String(value);
+  }
+}
+
+function resolveIconSet() {
+  const mode = (process.env.SPECSMD_ICON_SET || 'auto').toLowerCase();
+
+  const ascii = {
+    runs: '[R]',
+    overview: '[O]',
+    health: '[H]',
+    git: '[G]',
+    runFile: '*',
+    activeFile: '>',
+    groupCollapsed: '>',
+    groupExpanded: 'v'
+  };
+
+  const nerd = {
+    runs: '󰑮',
+    overview: '󰍉',
+    health: '󰓦',
+    git: '󰊢',
+    runFile: '󰈔',
+    activeFile: '󰜴',
+    groupCollapsed: '󰐕',
+    groupExpanded: '󰐗'
+  };
+
+  if (mode === 'ascii') {
+    return ascii;
+  }
+  if (mode === 'nerd') {
+    return nerd;
+  }
+
+  const locale = `${process.env.LC_ALL || ''}${process.env.LC_CTYPE || ''}${process.env.LANG || ''}`;
+  const isUtf8 = /utf-?8/i.test(locale);
+  const looksLikeVsCodeTerminal = (process.env.TERM_PROGRAM || '').toLowerCase().includes('vscode');
+
+  return isUtf8 && looksLikeVsCodeTerminal ? nerd : ascii;
+}
+
+function truncate(value, width) {
+  const text = String(value ?? '');
+  if (!Number.isFinite(width)) {
+    return text;
+  }
+
+  const safeWidth = Math.max(0, Math.floor(width));
+  if (safeWidth === 0) {
+    return '';
+  }
+
+  if (stringWidth(text) <= safeWidth) {
+    return text;
+  }
+
+  if (safeWidth <= 3) {
+    return sliceAnsi(text, 0, safeWidth);
+  }
+
+  const ellipsis = '...';
+  const bodyWidth = Math.max(0, safeWidth - stringWidth(ellipsis));
+  return `${sliceAnsi(text, 0, bodyWidth)}${ellipsis}`;
+}
+
+function resolveFrameWidth(columns) {
+  const safeColumns = Number.isFinite(columns) ? Math.max(1, Math.floor(columns)) : 120;
+  return safeColumns > 24 ? safeColumns - 1 : safeColumns;
+}
+
+function normalizePanelLine(line) {
+  if (line && typeof line === 'object' && !Array.isArray(line)) {
+    return {
+      text: typeof line.text === 'string' ? line.text : String(line.text ?? ''),
+      color: line.color,
+      bold: Boolean(line.bold),
+      selected: Boolean(line.selected),
+      loading: Boolean(line.loading)
+    };
+  }
+
+  return {
+    text: String(line ?? ''),
+    color: undefined,
+    bold: false,
+    selected: false,
+    loading: false
+  };
+}
+
+function fitLines(lines, maxLines, width) {
+  const safeLines = (Array.isArray(lines) ? lines : []).map((line) => {
+    const normalized = normalizePanelLine(line);
+    return {
+      ...normalized,
+      text: truncate(normalized.text, width)
+    };
+  });
+
+  if (safeLines.length <= maxLines) {
+    return safeLines;
+  }
+
+  const selectedIndex = safeLines.findIndex((line) => line.selected);
+  if (selectedIndex >= 0) {
+    const windowSize = Math.max(1, maxLines);
+    let start = selectedIndex - Math.floor(windowSize / 2);
+    start = Math.max(0, start);
+    start = Math.min(start, Math.max(0, safeLines.length - windowSize));
+    return safeLines.slice(start, start + windowSize);
+  }
+
+  const visible = safeLines.slice(0, Math.max(1, maxLines - 1));
+  visible.push({
+    text: truncate(`... +${safeLines.length - visible.length} more`, width),
+    color: 'gray',
+    bold: false
+  });
+  return visible;
+}
+
+function formatTime(value) {
+  if (!value) {
+    return 'n/a';
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+
+  return date.toLocaleTimeString();
+}
+
+function fileExists(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function readFileTextSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function normalizeToken(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.toLowerCase().trim().replace(/[\s-]+/g, '_');
+}
+
+function clampIndex(value, length) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  if (!Number.isFinite(length) || length <= 0) {
+    return 0;
+  }
+  return Math.max(0, Math.min(length - 1, Math.floor(value)));
+}
+
+module.exports = {
+  stringWidth,
+  sliceAnsi,
+  toDashboardError,
+  safeJsonHash,
+  resolveIconSet,
+  truncate,
+  resolveFrameWidth,
+  normalizePanelLine,
+  fitLines,
+  formatTime,
+  fileExists,
+  readFileTextSafe,
+  normalizeToken,
+  clampIndex
+};

package/lib/dashboard/tui/overlays.js

@@ -0,0 +1,242 @@
+const { truncate } = require('./helpers');
+
+function buildQuickHelpText(view, options = {}) {
+  const {
+    flow = 'fire',
+    previewOpen = false,
+    availableFlowCount = 1,
+    hasWorktrees = false
+  } = options;
+  const isAidlc = String(flow || '').toLowerCase() === 'aidlc';
+  const isSimple = String(flow || '').toLowerCase() === 'simple';
+  const activeLabel = isAidlc ? 'active bolt' : (isSimple ? 'active spec' : 'active run');
+
+  const parts = ['1/2/3/4/5 tabs', 'g/G sections'];
+
+  if (view === 'runs' || view === 'intents' || view === 'completed' || view === 'health' || view === 'git') {
+    if (previewOpen) {
+      parts.push('tab pane', '↑/↓ nav/scroll', 'v/space close');
+    } else {
+      parts.push('↑/↓ navigate', 'enter expand', 'v/space preview');
+    }
+  }
+  if (view === 'runs') {
+    if (hasWorktrees) {
+      parts.push('b worktrees', 'u others');
+    }
+    parts.push('a current', 'f files');
+  } else if (view === 'git') {
+    parts.push('6 status', '7 files', '8 commits', '- diff');
+  }
+  parts.push(`tab1 ${activeLabel}`);
+
+  if (availableFlowCount > 1) {
+    parts.push('[/] flow');
+  }
+
+  parts.push('r refresh', '? shortcuts', 'q quit');
+  return parts.join(' | ');
+}
+
+function buildGitCommandStrip(view, options = {}) {
+  const {
+    hasWorktrees = false,
+    previewOpen = false
+  } = options;
+
+  const parts = [];
+
+  if (view === 'runs') {
+    if (hasWorktrees) {
+      parts.push('b worktrees');
+    }
+    parts.push('a current', 'f files', 'enter expand');
+  } else if (view === 'intents') {
+    parts.push('n next', 'x completed', 'enter expand');
+  } else if (view === 'completed') {
+    parts.push('c completed', 'enter expand');
+  } else if (view === 'health') {
+    parts.push('s standards', 't stats', 'w warnings');
+  } else if (view === 'git') {
+    parts.push('6 status', '7 files', '8 commits', '- diff', 'space preview');
+  }
+
+  if (previewOpen) {
+    parts.push('tab pane', 'j/k scroll');
+  } else {
+    parts.push('v preview');
+  }
+
+  parts.push('1-5 views', 'g/G panels', 'r refresh', '? help', 'q quit');
+  return parts.join(' | ');
+}
+
+function buildGitCommandLogLine(options = {}) {
+  const {
+    statusLine = '',
+    activeFlow = 'fire',
+    watchEnabled = true,
+    watchStatus = 'watching',
+    selectedWorktreeLabel = null
+  } = options;
+
+  if (typeof statusLine === 'string' && statusLine.trim() !== '') {
+    return `Command Log | ${statusLine}`;
+  }
+
+  const watchLabel = watchEnabled ? watchStatus : 'off';
+  const worktreeSegment = selectedWorktreeLabel ? ` | wt:${selectedWorktreeLabel}` : '';
+  return `Command Log | flow:${String(activeFlow || 'fire').toUpperCase()} | watch:${watchLabel}${worktreeSegment} | ready`;
+}
+
+function buildHelpOverlayLines(options = {}) {
+  const {
+    view = 'runs',
+    flow = 'fire',
+    previewOpen = false,
+    paneFocus = 'main',
+    availableFlowCount = 1,
+    showErrorSection = false,
+    hasWorktrees = false
+  } = options;
+  const isAidlc = String(flow || '').toLowerCase() === 'aidlc';
+  const isSimple = String(flow || '').toLowerCase() === 'simple';
+  const itemLabel = isAidlc ? 'bolt' : (isSimple ? 'spec' : 'run');
+  const itemPlural = isAidlc ? 'bolts' : (isSimple ? 'specs' : 'runs');
+
+  const lines = [
+    { text: 'Global', color: 'cyan', bold: true },
+    'q or Ctrl+C quit',
+    'r refresh snapshot',
+    `1 active ${itemLabel} | 2 intents | 3 completed ${itemPlural} | 4 standards/health | 5 git changes`,
+    'g next section | G previous section',
+    'h/? toggle this shortcuts overlay',
+    'esc close overlays (help/preview/fullscreen)',
+    { text: '', color: undefined, bold: false },
+    { text: 'Tab 1 Active', color: 'yellow', bold: true },
+    ...(hasWorktrees ? ['b focus worktrees section', 'u focus other-worktrees section'] : []),
+    `a focus active ${itemLabel}`,
+    `f focus ${itemLabel} files`,
+    'up/down or j/k move selection',
+    'enter expand/collapse selected folder row',
+    'v or space preview selected file',
+    'v twice quickly opens fullscreen preview overlay',
+    'tab switch focus between main and preview panes',
+    'o open selected file in system default app'
+  ];
+
+  if (previewOpen) {
+    lines.push(`preview is open (focus: ${paneFocus})`);
+  }
+
+  if (availableFlowCount > 1) {
+    lines.push('[/] (and m) switch flow');
+  }
+
+  lines.push(
+    { text: '', color: undefined, bold: false },
+    { text: 'Tab 2 Intents', color: 'green', bold: true },
+    'i focus intents',
+    'n next intents | x completed intents',
+    'left/right toggles next/completed when intents is focused',
+    { text: '', color: undefined, bold: false },
+    { text: 'Tab 3 Completed', color: 'blue', bold: true },
+    'c focus completed items',
+    { text: '', color: undefined, bold: false },
+    { text: 'Tab 4 Standards/Health', color: 'magenta', bold: true },
+    `s standards | t stats | w warnings${showErrorSection ? ' | e errors' : ''}`,
+    { text: '', color: undefined, bold: false },
+    { text: 'Tab 5 Git Changes', color: 'yellow', bold: true },
+    '7 files: select changed files and preview per-file diffs',
+    '8 commits: select a commit to preview the full commit diff',
+    '6 status | 7 files | 8 commits | - diff',
+    { text: '', color: undefined, bold: false },
+    { text: `Current view: ${String(view || 'runs').toUpperCase()}`, color: 'gray', bold: false }
+  );
+
+  return lines;
+}
+
+function colorizeMarkdownLine(line, inCodeBlock) {
+  const text = String(line ?? '');
+
+  if (/^\s*```/.test(text)) {
+    return {
+      color: 'magenta',
+      bold: true,
+      togglesCodeBlock: true
+    };
+  }
+
+  if (/^\s{0,3}#{1,6}\s+/.test(text)) {
+    return {
+      color: 'cyan',
+      bold: true,
+      togglesCodeBlock: false
+    };
+  }
+
+  if (/^\s*[-*+]\s+\[[ xX]\]/.test(text) || /^\s*[-*+]\s+/.test(text) || /^\s*\d+\.\s+/.test(text)) {
+    return {
+      color: 'yellow',
+      bold: false,
+      togglesCodeBlock: false
+    };
+  }
+
+  if (/^\s*>\s+/.test(text)) {
+    return {
+      color: 'gray',
+      bold: false,
+      togglesCodeBlock: false
+    };
+  }
+
+  if (/^\s*---\s*$/.test(text)) {
+    return {
+      color: 'yellow',
+      bold: false,
+      togglesCodeBlock: false
+    };
+  }
+
+  if (inCodeBlock) {
+    return {
+      color: 'green',
+      bold: false,
+      togglesCodeBlock: false
+    };
+  }
+
+  return {
+    color: undefined,
+    bold: false,
+    togglesCodeBlock: false
+  };
+}
+
+function sanitizeRenderLine(value) {
+  const raw = String(value ?? '');
+  const withoutAnsi = raw
+    // OSC sequences (e.g. hyperlinks / title set): ESC ] ... BEL or ESC \
+    .replace(/\u001B\][^\u0007]*(?:\u0007|\u001B\\)/g, '')
+    // CSI sequences
+    .replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '')
+    // 7-bit C1 control sequences
+    .replace(/\u001B[@-Z\\-_]/g, '')
+    // Any remaining ESC bytes
+    .replace(/\u001B/g, '')
+    // Carriage return can reposition cursor to column 0 and corrupt frame painting
+    .replace(/\r/g, '');
+
+  return withoutAnsi.replace(/[\u0000-\u0008\u000B-\u001A\u001C-\u001F\u007F]/g, '');
+}
+
+module.exports = {
+  buildQuickHelpText,
+  buildGitCommandStrip,
+  buildGitCommandLogLine,
+  buildHelpOverlayLines,
+  colorizeMarkdownLine,
+  sanitizeRenderLine
+};