@imdeadpool/guardex 7.0.41 → 7.0.43

package/src/cockpit/render.js

@@ -0,0 +1,215 @@
+function line(label, value) {
+  return `${label}: ${value || '-'}`;
+}
+
+const BUCKETS = [
+  { key: 'working', title: 'WORKING NOW' },
+  { key: 'thinking', title: 'THINKING' },
+  { key: 'blocked', title: 'BLOCKED' },
+  { key: 'done', title: 'DONE' },
+  { key: 'stale', title: 'STALE' },
+];
+
+function lockSummary(locks) {
+  if (!Array.isArray(locks) || locks.length === 0) {
+    return 'none';
+  }
+
+  const preview = locks.slice(0, 3).join(', ');
+  const suffix = locks.length > 3 ? `, +${locks.length - 3} more` : '';
+  return `${locks.length} (${preview}${suffix})`;
+}
+
+function lockCountSummary(session) {
+  if (Array.isArray(session.locks)) {
+    return lockSummary(session.locks);
+  }
+
+  return Number.isFinite(session.lockCount) ? String(session.lockCount) : 'none';
+}
+
+function filePreview(files) {
+  if (!Array.isArray(files) || files.length === 0) {
+    return 'none';
+  }
+
+  const preview = files.slice(0, 3).join(', ');
+  const suffix = files.length > 3 ? `, +${files.length - 3} more` : '';
+  return `${files.length} (${preview}${suffix})`;
+}
+
+function metadataSummary(metadata) {
+  if (!metadata || typeof metadata !== 'object') return '';
+  return Object.entries(metadata)
+    .filter(([key, value]) => key.startsWith('colony.') && value !== null && value !== undefined && String(value) !== '')
+    .map(([key, value]) => `${key}=${value}`)
+    .join(' ');
+}
+
+function worktreeSummary(session) {
+  const worktreePath = session.worktreePath || '-';
+  if (session.worktreeExists === false) {
+    return `${worktreePath} (missing)`;
+  }
+  if (session.worktreeExists === true) {
+    return `${worktreePath} (present)`;
+  }
+  return worktreePath;
+}
+
+function normalizeState(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function sessionBucket(session) {
+  if (session.worktreeExists === false) {
+    return 'stale';
+  }
+
+  const status = normalizeState(session.status);
+  const activity = normalizeState(session.activity);
+  const prState = normalizeState(session.prState);
+  const state = `${status} ${activity}`.trim();
+
+  if (prState === 'merged' || /\b(done|complete|completed|merged)\b/.test(state)) {
+    return 'done';
+  }
+  if (/\b(blocked|failed|failing|error|errored|stalled|dead)\b/.test(state)) {
+    return 'blocked';
+  }
+  if (/\b(thinking|pending|queued|idle|waiting)\b/.test(state)) {
+    return 'thinking';
+  }
+  if (/\b(working|running|active|orbiting|symbioting|advising)\b/.test(state)) {
+    return 'working';
+  }
+  return 'thinking';
+}
+
+function groupSessions(sessions) {
+  const grouped = new Map(BUCKETS.map((bucket) => [bucket.key, []]));
+  sessions.forEach((session) => {
+    grouped.get(sessionBucket(session)).push(session);
+  });
+  return grouped;
+}
+
+function summaryLine(grouped) {
+  return BUCKETS
+    .map((bucket) => `${bucket.key}=${grouped.get(bucket.key).length}`)
+    .join(' ');
+}
+
+function stage(value) {
+  return value ? 'ok' : 'todo';
+}
+
+function progressSummary(session) {
+  const metadata = session.metadata && typeof session.metadata === 'object' ? session.metadata : {};
+  const hasSpec = Boolean(metadata['colony.plan'] || metadata['colony.subtask'] || metadata['colony.task_id']);
+  const hasCode = (
+    (Array.isArray(session.changedFiles) && session.changedFiles.length > 0) ||
+    (Array.isArray(session.locks) && session.locks.length > 0) ||
+    Number(session.lockCount || 0) > 0
+  );
+  const hasPr = Boolean(session.prUrl || session.prState);
+  const merged = normalizeState(session.prState) === 'merged';
+
+  return [
+    `Spec ${stage(hasSpec)}`,
+    `Code ${hasCode ? 'active' : 'todo'}`,
+    `Tests ${metadata['colony.verification'] ? 'ok' : 'todo'}`,
+    `PR ${stage(hasPr)}`,
+    `Merge ${stage(merged)}`,
+    `Cleanup ${merged ? 'ready' : 'todo'}`,
+  ].join(' | ');
+}
+
+function readinessSummary(session) {
+  const bucket = sessionBucket(session);
+  if (bucket === 'stale') return 'STALE';
+  if (bucket === 'blocked') return 'BLOCKED';
+  if (normalizeState(session.prState) === 'merged') return 'MERGED';
+  if (session.prUrl) return 'PR OPEN';
+  if (Array.isArray(session.changedFiles) && session.changedFiles.length > 0) return 'CHANGED';
+  return 'OPEN';
+}
+
+function renderSession(session, index) {
+  const lines = [
+    `${index + 1}. ${session.agentName || 'agent'} | ${readinessSummary(session)} | ${session.status || 'unknown'}`,
+    `   branch: ${session.branch || '-'}`,
+    `   progress: ${progressSummary(session)}`,
+    `   worktree: ${worktreeSummary(session)}`,
+    `   locks: ${lockCountSummary(session)}`,
+  ];
+
+  if (Array.isArray(session.changedFiles)) {
+    lines.push(`   changed: ${filePreview(session.changedFiles)}`);
+  }
+  if (session.task) {
+    lines.push(`   task: ${session.task}`);
+  }
+  const meta = metadataSummary(session.metadata);
+  if (meta) {
+    lines.push(`   colony: ${meta}`);
+  }
+  if (session.prUrl || session.prState) {
+    lines.push(`   pr: ${session.prState || '-'} ${session.prUrl || '-'}`);
+  }
+  if (session.lastHeartbeatAt) {
+    lines.push(`   heartbeat: ${session.lastHeartbeatAt}`);
+  }
+
+  return lines.join('\n');
+}
+
+function renderCockpit(state) {
+  const sessions = Array.isArray(state && state.sessions) ? state.sessions : [];
+  const grouped = groupSessions(sessions);
+  const lines = [
+    'GitGuardex Cockpit Fleet',
+    line('repo', state && state.repoPath),
+    line('base', state && state.baseBranch),
+    line('active sessions', String(sessions.length)),
+    line('summary', summaryLine(grouped)),
+    'actions: Enter inspect | f finish | h handoff | r refresh',
+    '',
+  ];
+
+  if (sessions.length === 0) {
+    lines.push('No active agent sessions.');
+  } else {
+    let displayIndex = 0;
+    BUCKETS.forEach((bucket) => {
+      const bucketSessions = grouped.get(bucket.key);
+      if (bucketSessions.length === 0) return;
+      if (displayIndex > 0) {
+        lines.push('');
+      }
+      lines.push(`${bucket.title} (${bucketSessions.length})`);
+      bucketSessions.forEach((session) => {
+        lines.push(renderSession(session, displayIndex));
+        displayIndex += 1;
+      });
+    });
+    lines.push('');
+    lines.push('detail: selected lane shows branch, progress, claims, changed files, PR, heartbeat, and Colony metadata.');
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+module.exports = {
+  renderCockpit,
+  renderSession,
+  filePreview,
+  groupSessions,
+  progressSummary,
+  readinessSummary,
+  sessionBucket,
+  lockSummary,
+  lockCountSummary,
+  metadataSummary,
+  worktreeSummary,
+};

package/src/cockpit/settings-render.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const { SETTINGS_KEYBINDINGS } = require('./shortcuts');
+const { colorize, getCockpitTheme } = require('./theme');
+
+const AVAILABLE_THEMES = 'blue, amber, dim, high-contrast, none';
+
+const DEFAULT_SETTINGS = {
+  theme: 'blue',
+  sidebarWidth: 32,
+  refreshMs: 2000,
+  defaultAgent: 'codex',
+  defaultBase: 'main',
+  showLocks: true,
+  showWorktreePaths: true,
+  autopilotDefault: false,
+  editorCommand: '',
+};
+
+const SECTION_DEFINITIONS = [
+  {
+    title: 'Appearance',
+    fields: [
+      ['theme', 'Theme', AVAILABLE_THEMES],
+    ],
+  },
+  {
+    title: 'Layout',
+    fields: [
+      ['sidebarWidth', 'Sidebar width', '20-80 columns'],
+      ['refreshMs', 'Refresh interval', '500-60000 ms'],
+      ['showWorktreePaths', 'Show worktree paths', 'true, false'],
+    ],
+  },
+  {
+    title: 'Agents',
+    fields: [
+      ['defaultAgent', 'Default agent', 'codex, claude, opencode, cursor, gemini'],
+      ['defaultBase', 'Default base', 'any branch name'],
+      ['autopilotDefault', 'Autopilot default', 'true, false'],
+    ],
+  },
+  {
+    title: 'Safety',
+    fields: [
+      ['showLocks', 'Show locks', 'true, false'],
+    ],
+  },
+  {
+    title: 'Editor',
+    fields: [
+      ['editorCommand', 'Editor command', 'any shell command, blank'],
+    ],
+  },
+];
+
+function normalizeSettings(settings) {
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+    return { ...DEFAULT_SETTINGS };
+  }
+
+  return {
+    ...DEFAULT_SETTINGS,
+    ...settings,
+  };
+}
+
+function formatValue(value) {
+  if (value === '') {
+    return '(blank)';
+  }
+  if (value === undefined || value === null) {
+    return '-';
+  }
+  return String(value);
+}
+
+function fieldLine(field, label, available, settings, selectedField, theme) {
+  const marker = field === selectedField ? '>' : ' ';
+  const line = `${marker} ${label}: ${formatValue(settings[field])} (available: ${available})`;
+  return field === selectedField ? colorize(line, 'selected', theme) : line;
+}
+
+function resolveSelectedField(options) {
+  if (!options || typeof options !== 'object') {
+    return null;
+  }
+  if (typeof options.selectedField === 'string') {
+    return options.selectedField;
+  }
+
+  return null;
+}
+
+function renderSection(section, settings, selectedField, theme) {
+  const lines = [colorize(`[${section.title}]`, 'heading', theme)];
+  for (const [field, label, available] of section.fields) {
+    lines.push(fieldLine(field, label, available, settings, selectedField, theme));
+  }
+  return lines.join('\n');
+}
+
+function renderSettingsScreen(settings, options = {}) {
+  const current = normalizeSettings(settings);
+  const theme = getCockpitTheme(options.theme || current.theme, options);
+  const selectedField = resolveSelectedField(options);
+  const lines = [
+    colorize('gx cockpit settings', 'title', theme),
+    colorize('Plain terminal settings view', 'secondary', theme),
+    '',
+  ];
+
+  for (const section of SECTION_DEFINITIONS) {
+    lines.push(renderSection(section, current, selectedField, theme));
+    lines.push('');
+  }
+
+  lines.push(colorize('[Keybindings]', 'heading', theme));
+  for (const keybinding of SETTINGS_KEYBINDINGS) {
+    lines.push(colorize(`  ${keybinding}`, 'secondary', theme));
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+module.exports = {
+  renderSettingsScreen,
+};

package/src/cockpit/settings.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SETTINGS_RELATIVE_PATH = ['.guardex', 'cockpit', 'settings.json'];
+const THEMES = new Set(['default', 'dim', 'high-contrast']);
+const AGENTS = new Set(['codex', 'claude', 'opencode', 'cursor', 'gemini']);
+const MIN_SIDEBAR_WIDTH = 20;
+const MAX_SIDEBAR_WIDTH = 80;
+const MIN_REFRESH_MS = 500;
+const MAX_REFRESH_MS = 60000;
+
+function defaultCockpitSettings() {
+  return {
+    theme: 'default',
+    sidebarWidth: 32,
+    refreshMs: 2000,
+    defaultAgent: 'codex',
+    defaultBase: 'main',
+    showLocks: true,
+    showWorktreePaths: true,
+    autopilotDefault: false,
+    editorCommand: '',
+  };
+}
+
+function settingsPath(repoRoot = process.cwd()) {
+  return path.join(path.resolve(repoRoot), ...SETTINGS_RELATIVE_PATH);
+}
+
+function clampNumber(value, fallback, min, max) {
+  const number = typeof value === 'number' ? value : Number(value);
+  if (!Number.isFinite(number)) {
+    return fallback;
+  }
+  return Math.min(max, Math.max(min, Math.round(number)));
+}
+
+function stringSetting(value, fallback) {
+  if (typeof value !== 'string') {
+    return fallback;
+  }
+  const trimmed = value.trim();
+  return trimmed || fallback;
+}
+
+function booleanSetting(value, fallback) {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+function normalizeCockpitSettings(raw) {
+  const defaults = defaultCockpitSettings();
+  const source = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  const theme = stringSetting(source.theme, defaults.theme);
+  const defaultAgent = stringSetting(source.defaultAgent, defaults.defaultAgent);
+
+  return {
+    theme: THEMES.has(theme) ? theme : defaults.theme,
+    sidebarWidth: clampNumber(
+      source.sidebarWidth,
+      defaults.sidebarWidth,
+      MIN_SIDEBAR_WIDTH,
+      MAX_SIDEBAR_WIDTH,
+    ),
+    refreshMs: clampNumber(source.refreshMs, defaults.refreshMs, MIN_REFRESH_MS, MAX_REFRESH_MS),
+    defaultAgent: AGENTS.has(defaultAgent) ? defaultAgent : defaults.defaultAgent,
+    defaultBase: stringSetting(source.defaultBase, defaults.defaultBase),
+    showLocks: booleanSetting(source.showLocks, defaults.showLocks),
+    showWorktreePaths: booleanSetting(source.showWorktreePaths, defaults.showWorktreePaths),
+    autopilotDefault: booleanSetting(source.autopilotDefault, defaults.autopilotDefault),
+    editorCommand: typeof source.editorCommand === 'string' ? source.editorCommand.trim() : defaults.editorCommand,
+  };
+}
+
+function readCockpitSettings(repoRoot = process.cwd()) {
+  const target = settingsPath(repoRoot);
+  try {
+    return normalizeCockpitSettings(JSON.parse(fs.readFileSync(target, 'utf8')));
+  } catch (error) {
+    if (error && (error.code === 'ENOENT' || error instanceof SyntaxError)) {
+      return defaultCockpitSettings();
+    }
+    throw error;
+  }
+}
+
+function writeCockpitSettings(repoRoot = process.cwd(), settings = {}) {
+  const normalized = normalizeCockpitSettings(settings);
+  const target = settingsPath(repoRoot);
+  const dir = path.dirname(target);
+  const temp = path.join(dir, `.settings.${process.pid}.${Date.now()}.tmp`);
+
+  fs.mkdirSync(dir, { recursive: true });
+  try {
+    fs.writeFileSync(temp, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+    fs.renameSync(temp, target);
+  } catch (error) {
+    try {
+      fs.unlinkSync(temp);
+    } catch (_cleanupError) {
+      // Best effort: the original settings file is untouched until rename succeeds.
+    }
+    throw error;
+  }
+
+  return normalized;
+}
+
+function updateCockpitSettings(repoRoot = process.cwd(), patch = {}) {
+  const source = patch && typeof patch === 'object' && !Array.isArray(patch) ? patch : {};
+  return writeCockpitSettings(repoRoot, {
+    ...readCockpitSettings(repoRoot),
+    ...source,
+  });
+}
+
+module.exports = {
+  defaultCockpitSettings,
+  readCockpitSettings,
+  writeCockpitSettings,
+  updateCockpitSettings,
+  normalizeCockpitSettings,
+};

package/src/cockpit/shortcuts.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const WELCOME_SHORTCUTS = Object.freeze([
+  ['n', 'new agent'],
+  ['t', 'terminal'],
+  ['s', 'settings'],
+  ['?', 'shortcuts'],
+  ['q', 'quit'],
+]);
+
+const SETTINGS_KEYBINDINGS = Object.freeze([
+  '↑/↓ navigate',
+  'Enter edit',
+  'Esc back',
+  'q quit',
+]);
+
+const CONTROL_KEY_HELP = 'keys: up/down select  j/k move  enter view/open  n new agent  t terminal  m menu  s settings  ? shortcuts  q quit';
+
+module.exports = {
+  CONTROL_KEY_HELP,
+  SETTINGS_KEYBINDINGS,
+  WELCOME_SHORTCUTS,
+};