all-hands-cli 0.1.0

package/.allhands/harness/src/tui/actions.ts

@@ -0,0 +1,227 @@
+/**
+ * Actions Pane - Left sidebar with agent spawners, toggles, and controls
+ *
+ * All actions are always visible — agents exit early if nothing to do.
+ *
+ * Layout (vertical):
+ * [1] Coordinator     [2] New Initiative  [3] Planner
+ * [4] Review Jury     [5] E2E Test Plan   [6] PR Action
+ * [7] Address PR Review  [8] Compound     [9] Complete
+ * [0] Switch Workspace  [-] Custom Flow
+ * ━━ Toggles ━━
+ * [O] Loop            [P] Parallel
+ * ━━ Controls ━━
+ * [V] View Logs       [C] Clear Logs      [R] Refresh
+ * [Q] Quit
+ */
+
+import blessed from 'blessed';
+import type { PRActionState } from './index.js';
+
+export interface ActionItem {
+  id: string;
+  label: string;
+  key?: string;
+  type: 'action' | 'toggle' | 'separator';
+  highlight?: boolean;
+  checked?: boolean;
+}
+
+export interface ToggleState {
+  loopEnabled: boolean;
+  parallelEnabled: boolean;
+  prActionState: PRActionState;
+}
+
+const PANE_WIDTH = 24;
+const HEADER_HEIGHT = 3;
+
+export function createActionsPane(
+  screen: blessed.Widgets.Screen,
+  toggleState: ToggleState,
+  selectedIndex?: number
+): blessed.Widgets.BoxElement {
+  // Create outer container (non-scrollable, holds border and help text)
+  const container = blessed.box({
+    parent: screen,
+    top: HEADER_HEIGHT,
+    left: 0,
+    width: PANE_WIDTH,
+    height: `100%-${HEADER_HEIGHT}`,
+    border: {
+      type: 'line',
+    },
+    label: ' Actions ',
+    tags: true,
+    style: {
+      border: {
+        fg: '#4A34C5',
+      },
+    },
+  });
+
+  // Calculate content area height (container minus borders minus help text lines)
+  const containerHeight = typeof container.height === 'number' ? container.height : (screen.height as number) - HEADER_HEIGHT;
+  const contentHeight = containerHeight - 4; // 2 for borders, 2 for help text lines
+
+  // Create scrollable content area inside the container
+  const scrollArea = blessed.box({
+    parent: container,
+    top: 0,
+    left: 0,
+    width: '100%-2',
+    height: contentHeight,
+    tags: true,
+    scrollable: true,
+    alwaysScroll: true,
+    scrollbar: {
+      ch: '┃',
+      track: {
+        bg: 'black',
+      },
+      style: {
+        fg: '#4A34C5',
+      },
+    },
+  });
+
+  const items = buildActionItems(toggleState);
+  const { content, selectedLineNumber } = formatActionsContent(items, selectedIndex);
+
+  scrollArea.setContent(content);
+
+  // Scroll to ensure selected item is visible
+  if (selectedLineNumber !== undefined && selectedLineNumber >= 0) {
+    const visibleHeight = contentHeight;
+
+    // Only scroll if selected line would be outside visible area
+    if (selectedLineNumber >= visibleHeight) {
+      // Scroll to put selected line in the middle of visible area when possible
+      const scrollOffset = Math.max(0, selectedLineNumber - Math.floor(visibleHeight / 2));
+      scrollArea.scrollTo(scrollOffset);
+    }
+  }
+
+  // Add help text at bottom of container (fixed position, outside scroll area)
+  blessed.text({
+    parent: container,
+    bottom: 1,
+    left: 1,
+    content: '{#5c6370-fg}Tab: Switch Pane{/#5c6370-fg}',
+    tags: true,
+  });
+  blessed.text({
+    parent: container,
+    bottom: 0,
+    left: 1,
+    content: '{#5c6370-fg}j/k: Navigate{/#5c6370-fg}',
+    tags: true,
+  });
+
+  return container;
+}
+
+interface ActionsContentResult {
+  content: string;
+  selectedLineNumber?: number;
+}
+
+function formatActionsContent(items: ActionItem[], selectedIndex?: number): ActionsContentResult {
+  const lines: string[] = [];
+  let selectableIndex = 0;
+  let selectedLineNumber: number | undefined;
+
+  for (const item of items) {
+    if (item.type === 'separator') {
+      lines.push(`{#6366f1-fg}${item.label}{/#6366f1-fg}`);
+    } else {
+      const isSelected = selectedIndex === selectableIndex;
+
+      if (isSelected) {
+        selectedLineNumber = lines.length;
+      }
+
+      const content = formatItemContent(item, isSelected);
+      lines.push(content);
+      selectableIndex++;
+    }
+  }
+
+  return { content: lines.join('\n'), selectedLineNumber };
+}
+
+export function buildActionItems(toggleState: ToggleState): ActionItem[] {
+  const prLabel = getPRActionLabel(toggleState.prActionState);
+
+  return [
+    // Agent spawners — all always visible
+    { id: 'coordinator', label: 'Coordinator', key: '1', type: 'action' },
+    { id: 'new-initiative', label: 'New Initiative', key: '2', type: 'action' },
+    { id: 'planner', label: 'Planner', key: '3', type: 'action' },
+    { id: 'review-jury', label: 'Review Jury', key: '4', type: 'action' },
+    { id: 'e2e-test-planner', label: 'E2E Test Plan', key: '5', type: 'action' },
+    { id: 'pr-action', label: prLabel, key: '6', type: 'action' },
+    { id: 'review-pr', label: 'Address PR Review', key: '7', type: 'action' },
+    { id: 'compound', label: 'Compound', key: '8', type: 'action' },
+    { id: 'mark-completed', label: 'Complete', key: '9', type: 'action' },
+    { id: 'switch-spec', label: 'Switch Workspace', key: '0', type: 'action' },
+    { id: 'custom-flow', label: 'Custom Flow', key: '-', type: 'action' },
+    { id: 'initiative-steering', label: 'Steer Initiative', key: '=', type: 'action' },
+    // Spacing before toggles
+    { id: 'spacer-1', label: '', type: 'separator' },
+    { id: 'separator-toggles', label: '━━ Toggles ━━', type: 'separator' },
+    { id: 'toggle-loop', label: 'Loop', key: 'O', type: 'toggle', checked: toggleState.loopEnabled },
+    { id: 'toggle-parallel', label: 'Parallel', key: 'P', type: 'toggle', checked: toggleState.parallelEnabled },
+    // Spacing before controls
+    { id: 'spacer-2', label: '', type: 'separator' },
+    { id: 'separator-bottom', label: '━━ Controls ━━', type: 'separator' },
+    { id: 'view-logs', label: 'View Logs', key: 'V', type: 'action' },
+    { id: 'clear-logs', label: 'Clear Logs', key: 'C', type: 'action' },
+    { id: 'refresh', label: 'Refresh', key: 'R', type: 'action' },
+    { id: 'quit', label: 'Quit', key: 'Q', type: 'action' },
+  ];
+}
+
+function getPRActionLabel(state: PRActionState): string {
+  switch (state) {
+    case 'create-pr':
+      return 'Create PR';
+    case 'awaiting-review':
+      return 'Awaiting Review...';
+    case 'rerun-pr-review':
+      return 'Rerun PR Review';
+  }
+}
+
+function formatItemContent(item: ActionItem, isSelected: boolean): string {
+  const prefix = item.key ? `{#818cf8-fg}[${item.key}]{/#818cf8-fg} ` : '    ';
+  let label = item.label;
+
+  // Toggle checkbox
+  if (item.type === 'toggle') {
+    const checkbox = item.checked ? '{#10b981-fg}[x]{/#10b981-fg}' : '{#5c6370-fg}[ ]{/#5c6370-fg}';
+    label = `${checkbox} ${label}`;
+  }
+
+  // Apply styling
+  let style = '';
+  let endStyle = '';
+
+  if (isSelected) {
+    style = '{#a78bfa-fg}{bold}▸ ';
+    endStyle = '{/bold}{/#a78bfa-fg}';
+    // For selected items, use plain prefix without colors
+    return `${style}${item.key ? `[${item.key}] ` : ''}${label}${endStyle}`;
+  } else if (item.highlight) {
+    style = '{#f59e0b-fg}';
+    endStyle = '{/#f59e0b-fg}';
+  }
+
+  return `${style}${prefix}${label}${endStyle}`;
+}
+
+export function getSelectableItems(toggleState: ToggleState): ActionItem[] {
+  return buildActionItems(toggleState).filter(
+    (item) => item.type !== 'separator'
+  );
+}

package/.allhands/harness/src/tui/file-viewer-modal.ts

@@ -0,0 +1,270 @@
+/**
+ * File Viewer Modal - Scrollable modal for viewing markdown files
+ *
+ * Used for viewing:
+ * - Spec files
+ * - Alignment documents
+ * - E2E test plans
+ * - Prompt files
+ *
+ * Navigation:
+ * - j/k: Scroll one line up/down
+ * - u/d: Page up/down
+ * - g: Jump to top
+ * - G: Jump to bottom
+ * - Esc: Close modal
+ */
+
+import blessed from 'blessed';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { parse as parseYaml } from 'yaml';
+
+export interface FileViewerOptions {
+  title: string;
+  filePath: string;
+  onClose: () => void;
+}
+
+export interface FileViewer {
+  box: blessed.Widgets.BoxElement;
+  destroy: () => void;
+  scrollUp: (lines?: number) => void;
+  scrollDown: (lines?: number) => void;
+  scrollToTop: () => void;
+  scrollToBottom: () => void;
+}
+
+export function createFileViewer(
+  screen: blessed.Widgets.Screen,
+  options: FileViewerOptions
+): FileViewer | null {
+  const { title, filePath, onClose } = options;
+
+  // Check if file exists
+  if (!existsSync(filePath)) {
+    return null;
+  }
+
+  // Read file content
+  let content: string;
+  try {
+    content = readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  // Calculate modal size (80% of screen)
+  const width = Math.floor((screen.width as number) * 0.8);
+  const height = Math.floor((screen.height as number) * 0.8);
+
+  // Create outer container (non-scrollable, holds border and help text)
+  const container = blessed.box({
+    parent: screen,
+    top: 'center',
+    left: 'center',
+    width,
+    height,
+    border: 'line',
+    label: ` ${title} `,
+    tags: true,
+    style: {
+      border: {
+        fg: '#c4b5fd',
+        bold: true,
+      },
+      fg: '#e0e7ff',
+    },
+  });
+
+  // Calculate content area height (container minus borders minus help text)
+  // Container inner area = height - 2 (borders), minus 1 for help text = height - 3
+  const contentHeight = height - 4; // Be more conservative to ensure we don't clip
+
+  // Create scrollable content area inside the container
+  const scrollArea = blessed.box({
+    parent: container,
+    top: 0,
+    left: 0,
+    width: '100%-2', // Fill width minus scrollbar space
+    height: contentHeight,
+    tags: true,
+    scrollable: true,
+    alwaysScroll: true,
+    keys: false,
+    vi: false,
+    scrollbar: {
+      ch: '┃',
+      track: {
+        bg: 'black',
+      },
+      style: {
+        fg: '#4A34C5',
+      },
+    },
+    style: {
+      fg: '#e0e7ff',
+    },
+  });
+
+  // Set content
+  scrollArea.setContent(content);
+
+  // Focus the container for key events
+  container.focus();
+
+  // Track scroll position
+  let scrollPosition = 0;
+  const contentLines = content.split('\n').length;
+  const visibleLines = contentHeight;
+  // Allow scrolling to show the last line at the top of the view
+  // This ensures we can always reach the true bottom of the file
+  const maxScroll = Math.max(0, contentLines);
+
+  function updateScroll(): void {
+    scrollArea.scrollTo(scrollPosition);
+    screen.render();
+  }
+
+  function scrollUp(lines: number = 1): void {
+    scrollPosition = Math.max(0, scrollPosition - lines);
+    updateScroll();
+  }
+
+  function scrollDown(lines: number = 1): void {
+    scrollPosition = Math.min(maxScroll, scrollPosition + lines);
+    updateScroll();
+  }
+
+  function scrollToTop(): void {
+    scrollPosition = 0;
+    updateScroll();
+  }
+
+  function scrollToBottom(): void {
+    scrollPosition = maxScroll;
+    updateScroll();
+  }
+
+  // Set up key bindings on container
+  container.key(['j'], () => scrollDown(1));
+  container.key(['k'], () => scrollUp(1));
+  container.key(['u'], () => scrollUp(Math.floor(visibleLines / 2)));
+  container.key(['d'], () => scrollDown(Math.floor(visibleLines / 2)));
+  container.key(['g'], () => scrollToTop());
+  container.key(['S-g'], () => scrollToBottom()); // Shift+G
+  container.key(['escape'], () => onClose());
+
+  // Add help text at bottom of container (fixed position, outside scroll area)
+  blessed.text({
+    parent: container,
+    bottom: 0,
+    left: 1,
+    content: '{#5c6370-fg}j/k:scroll  u/d:page  g/G:top/bottom  Esc:close{/#5c6370-fg}',
+    tags: true,
+  });
+
+  // Initial render
+  screen.render();
+
+  return {
+    box: container,
+    destroy: () => container.destroy(),
+    scrollUp,
+    scrollDown,
+    scrollToTop,
+    scrollToBottom,
+  };
+}
+
+/**
+ * Check if a planning file exists for the given spec and file type
+ * Tries multiple folder name formats to handle branch name variations
+ */
+export function getPlanningFilePath(
+  cwd: string,
+  spec: string,
+  fileType: 'alignment' | 'e2e_test_plan'
+): string | null {
+  // Try multiple filename variations (underscore vs hyphen)
+  const filenames = fileType === 'alignment'
+    ? ['alignment.md']
+    : ['e2e-test-plan.md', 'e2e_test_plan.md'];
+
+  // Try multiple folder name variations to handle branch naming differences
+  // e.g., "feature/core-taskflow" might be stored as "feature-core-taskflow"
+  const folderVariations = [
+    spec,                                    // Original: feature/core-taskflow
+    spec.replace(/\//g, '-'),               // Slashes to hyphens: feature-core-taskflow
+    spec.replace(/[/\\]/g, '-'),            // All path separators to hyphens
+  ];
+
+  for (const folderName of folderVariations) {
+    for (const filename of filenames) {
+      const filePath = join(cwd, '.planning', folderName, filename);
+      if (existsSync(filePath)) {
+        return filePath;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get the spec file path for a spec
+ * First tries to read from status.yaml, then falls back to common locations
+ */
+export function getSpecFilePath(cwd: string, specId: string): string | null {
+  // Try variations of the spec ID (slashes to hyphens, etc.)
+  const specIdVariations = [
+    specId,
+    specId.replace(/\//g, '-'),
+    specId.replace(/[/\\]/g, '-'),
+  ];
+
+  // First, try to read the spec path from status.yaml in the planning directory
+  for (const id of specIdVariations) {
+    const statusPath = join(cwd, '.planning', id, 'status.yaml');
+    if (existsSync(statusPath)) {
+      try {
+        const content = readFileSync(statusPath, 'utf-8');
+        const status = parseYaml(content) as { spec?: string };
+        if (status?.spec) {
+          // The spec path in status.yaml might be relative or absolute
+          const specPath = status.spec.startsWith('/')
+            ? status.spec
+            : join(cwd, status.spec);
+          if (existsSync(specPath)) {
+            return specPath;
+          }
+        }
+      } catch {
+        // Ignore parse errors, continue to fallback
+      }
+    }
+  }
+
+  // Fallback: try common spec file locations
+  const locations: string[] = [];
+
+  for (const id of specIdVariations) {
+    // Check specs/ folder
+    locations.push(join(cwd, 'specs', `${id}.spec.md`));
+    locations.push(join(cwd, 'specs', `${id}.md`));
+    // Check .specs/ folder
+    locations.push(join(cwd, '.specs', `${id}.spec.md`));
+    locations.push(join(cwd, '.specs', `${id}.md`));
+    // Check .planning/ folder (spec.md inside the planning dir)
+    locations.push(join(cwd, '.planning', id, 'spec.md'));
+    locations.push(join(cwd, '.planning', id, `${id}.spec.md`));
+  }
+
+  for (const filePath of locations) {
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+
+  return null;
+}