@imdeadpool/guardex 7.0.39 → 7.0.43

package/src/cockpit/layout.js

@@ -0,0 +1,224 @@
+const DEFAULT_SESSION_NAME = 'guardex';
+const DEFAULT_SIDEBAR_WIDTH = 34;
+const DEFAULT_TERMINAL_COLUMNS = 120;
+const DEFAULT_TERMINAL_ROWS = 40;
+const MIN_CONTENT_COLUMNS = 20;
+
+function text(value, fallback = '') {
+  if (typeof value === 'string') return value.trim() || fallback;
+  if (value === null || value === undefined) return fallback;
+  return String(value).trim() || fallback;
+}
+
+function positiveInteger(value, fallback) {
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function sidebarWidthFor(value, terminalColumns) {
+  const requested = positiveInteger(value, DEFAULT_SIDEBAR_WIDTH);
+  if (terminalColumns <= MIN_CONTENT_COLUMNS) {
+    return Math.max(1, terminalColumns - 1);
+  }
+  return Math.min(requested, terminalColumns - MIN_CONTENT_COLUMNS);
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function normalizeSessions(sessions) {
+  if (!Array.isArray(sessions)) return [];
+  return sessions.map((session, index) => ({
+    sessionId: text(session.sessionId || session.id, `session-${index + 1}`),
+    branch: text(session.branch),
+    worktreePath: text(session.worktreePath),
+    command: text(session.command),
+  }));
+}
+
+function paneTarget(sessionName, paneIndex) {
+  return `${sessionName}:0.${paneIndex}`;
+}
+
+function windowTarget(sessionName) {
+  return `${sessionName}:0`;
+}
+
+function agentGrid(count) {
+  if (count <= 1) return { columns: 1, rows: 1 };
+  const columns = Math.ceil(Math.sqrt(count));
+  return {
+    columns,
+    rows: Math.ceil(count / columns),
+  };
+}
+
+function dimension(total, parts, index) {
+  const base = Math.floor(total / parts);
+  const remainder = total % parts;
+  return base + (index < remainder ? 1 : 0);
+}
+
+function offset(total, parts, index) {
+  let value = 0;
+  for (let part = 0; part < index; part += 1) {
+    value += dimension(total, parts, part);
+  }
+  return value;
+}
+
+function agentGeometry(index, count, sidebarWidth, terminalColumns, terminalRows) {
+  const mainColumns = Math.max(1, terminalColumns - sidebarWidth);
+  const grid = agentGrid(count);
+  const column = index % grid.columns;
+  const row = Math.floor(index / grid.columns);
+  return {
+    x: sidebarWidth + offset(mainColumns, grid.columns, column),
+    y: offset(terminalRows, grid.rows, row),
+    width: dimension(mainColumns, grid.columns, column),
+    height: dimension(terminalRows, grid.rows, row),
+  };
+}
+
+function sidebarPane(sessionName, sidebarWidth, terminalRows, command) {
+  return {
+    role: 'sidebar',
+    target: paneTarget(sessionName, 0),
+    width: sidebarWidth,
+    height: terminalRows,
+    command,
+  };
+}
+
+function agentCommand(session) {
+  if (session.command) return session.command;
+  if (!session.worktreePath) return 'gx agents status';
+  return `cd ${shellQuote(session.worktreePath)} && exec ${'${SHELL:-bash}'}`;
+}
+
+function agentPane(sessionName, session, index, count, selectedSessionId, sidebarWidth, terminalColumns, terminalRows) {
+  return {
+    role: 'agent',
+    target: paneTarget(sessionName, index + 1),
+    sessionId: session.sessionId,
+    branch: session.branch,
+    worktreePath: session.worktreePath,
+    selected: session.sessionId === selectedSessionId,
+    command: agentCommand(session),
+    ...agentGeometry(index, count, sidebarWidth, terminalColumns, terminalRows),
+  };
+}
+
+function detailsPane(sessionName, paneIndex, sidebarWidth, terminalColumns, terminalRows, command) {
+  return {
+    role: 'details',
+    target: paneTarget(sessionName, paneIndex),
+    x: sidebarWidth,
+    y: 0,
+    width: Math.max(1, terminalColumns - sidebarWidth),
+    height: terminalRows,
+    command,
+  };
+}
+
+function sendKeysCommand(role, target, command) {
+  return {
+    role,
+    args: ['send-keys', '-t', target, command, 'C-m'],
+  };
+}
+
+function buildTmuxCommands(plan) {
+  const commands = [
+    {
+      role: 'session',
+      args: ['new-session', '-d', '-s', plan.sessionName],
+    },
+    sendKeysCommand('sidebar', plan.panes[0].target, plan.panes[0].command),
+  ];
+
+  const contentPanes = plan.panes.filter((pane) => pane.role !== 'sidebar');
+  if (contentPanes.length > 0) {
+    commands.push({
+      role: 'content',
+      args: ['split-window', '-h', '-t', plan.panes[0].target],
+    });
+    commands.push({
+      role: 'sidebar',
+      args: ['resize-pane', '-t', plan.panes[0].target, '-x', String(plan.sidebarWidth)],
+    });
+  }
+
+  for (let index = 1; index < contentPanes.length; index += 1) {
+    commands.push({
+      role: contentPanes[index].role,
+      args: ['split-window', index % 2 === 1 ? '-h' : '-v', '-t', contentPanes[index - 1].target],
+    });
+  }
+
+  if (contentPanes.filter((pane) => pane.role === 'agent').length > 1) {
+    commands.push({
+      role: 'layout',
+      args: ['select-layout', '-t', windowTarget(plan.sessionName), 'tiled'],
+    });
+    commands.push({
+      role: 'sidebar',
+      args: ['resize-pane', '-t', plan.panes[0].target, '-x', String(plan.sidebarWidth)],
+    });
+  }
+
+  for (const pane of contentPanes) {
+    commands.push(sendKeysCommand(pane.role, pane.target, pane.command));
+  }
+
+  return commands;
+}
+
+function planCockpitLayout(options = {}) {
+  const sessions = normalizeSessions(options.sessions);
+  const terminalColumns = positiveInteger(options.terminalColumns, DEFAULT_TERMINAL_COLUMNS);
+  const terminalRows = positiveInteger(options.terminalRows, DEFAULT_TERMINAL_ROWS);
+  const sessionName = text(options.sessionName, DEFAULT_SESSION_NAME);
+  const sidebarWidth = sidebarWidthFor(options.sidebarWidth, terminalColumns);
+  const sidebarCommand = text(options.sidebarCommand, 'gx agents status');
+  const selectedSessionId = text(options.selectedSessionId);
+  const panes = [
+    sidebarPane(sessionName, sidebarWidth, terminalRows, sidebarCommand),
+  ];
+
+  if (sessions.length === 0) {
+    panes.push(detailsPane(sessionName, 1, sidebarWidth, terminalColumns, terminalRows, 'gx agents status'));
+  } else {
+    sessions.forEach((session, index) => {
+      panes.push(agentPane(
+        sessionName,
+        session,
+        index,
+        sessions.length,
+        selectedSessionId,
+        sidebarWidth,
+        terminalColumns,
+        terminalRows,
+      ));
+    });
+  }
+
+  const plan = {
+    sessionName,
+    terminalColumns,
+    terminalRows,
+    sidebarWidth,
+    panes,
+  };
+  return {
+    ...plan,
+    tmuxCommands: buildTmuxCommands(plan),
+  };
+}
+
+module.exports = {
+  DEFAULT_SESSION_NAME,
+  DEFAULT_SIDEBAR_WIDTH,
+  planCockpitLayout,
+};

package/src/cockpit/logs-reader.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_TAIL_BYTES = 32 * 1024;
+const DEFAULT_LIMIT = 200;
+const DEFAULT_LOG_GLOBS = ['apps/logs', '.omc/logs', '.omx/logs'];
+
+const LEVELS = ['info', 'warning', 'error', 'debug'];
+const LEVEL_PATTERNS = [
+  { level: 'error', regex: /\b(error|err|exception|fail(?:ed|ure)?|fatal|panic|traceback)\b/i },
+  { level: 'warning', regex: /\b(warn|warning|deprecated|caution)\b/i },
+  { level: 'debug', regex: /\b(debug|trace|verbose)\b/i },
+];
+
+function text(value, fallback = '') {
+  if (typeof value === 'string') return value || fallback;
+  if (value === null || value === undefined) return fallback;
+  return String(value) || fallback;
+}
+
+function classifyLevel(line) {
+  for (const { level, regex } of LEVEL_PATTERNS) {
+    if (regex.test(line)) return level;
+  }
+  return 'info';
+}
+
+function pickFs(options = {}) {
+  return options.fs || fs;
+}
+
+function listLogPaths(root, options = {}) {
+  const fsImpl = pickFs(options);
+  const globs = Array.isArray(options.globs) && options.globs.length > 0 ? options.globs : DEFAULT_LOG_GLOBS;
+  const seen = new Set();
+  const paths = [];
+
+  for (const glob of globs) {
+    const dir = path.isAbsolute(glob) ? glob : path.join(root, glob);
+    pushLogsFromDir(dir, fsImpl, seen, paths);
+  }
+
+  return paths;
+}
+
+function pushLogsFromDir(dir, fsImpl, seen, paths) {
+  let entries;
+  try {
+    entries = fsImpl.readdirSync(dir, { withFileTypes: true });
+  } catch (_error) {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      pushLogsFromDir(full, fsImpl, seen, paths);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith('.log')) continue;
+    if (seen.has(full)) continue;
+    seen.add(full);
+    paths.push(full);
+  }
+}
+
+function tailFile(file, options = {}) {
+  const fsImpl = pickFs(options);
+  const tailBytes = Number.isFinite(options.tailBytes) && options.tailBytes > 0
+    ? options.tailBytes
+    : DEFAULT_TAIL_BYTES;
+  let stat;
+  try {
+    stat = fsImpl.statSync(file, { throwIfNoEntry: false });
+  } catch (_error) {
+    return [];
+  }
+  if (!stat) return [];
+
+  const size = Number.isFinite(stat.size) ? stat.size : 0;
+  const start = size > tailBytes ? size - tailBytes : 0;
+
+  let content = '';
+  try {
+    if (typeof fsImpl.openSync === 'function' && typeof fsImpl.readSync === 'function' && typeof fsImpl.closeSync === 'function' && start > 0) {
+      const fd = fsImpl.openSync(file, 'r');
+      try {
+        const buffer = Buffer.alloc(size - start);
+        fsImpl.readSync(fd, buffer, 0, buffer.length, start);
+        content = buffer.toString('utf8');
+      } finally {
+        fsImpl.closeSync(fd);
+      }
+    } else if (typeof fsImpl.readFileSync === 'function') {
+      content = fsImpl.readFileSync(file, 'utf8');
+      if (content.length > tailBytes) content = content.slice(content.length - tailBytes);
+    }
+  } catch (_error) {
+    return [];
+  }
+
+  const lines = content.split('\n');
+  return lines.map((line, index) => ({ line, partial: index === 0 && start > 0 }));
+}
+
+function readLogs(options = {}) {
+  const root = text(options.repoRoot || options.root || process.cwd(), process.cwd());
+  const limit = Number.isFinite(options.limit) && options.limit > 0 ? options.limit : DEFAULT_LIMIT;
+  const sources = options.sources || listLogPaths(root, options);
+  const entries = [];
+
+  for (const source of sources) {
+    const tail = tailFile(source, options);
+    const sourceName = path.relative(root, source) || source;
+    for (let i = 0; i < tail.length; i += 1) {
+      const { line, partial } = tail[i];
+      if (partial && i === 0) continue;
+      const trimmed = line.replace(/\r$/, '');
+      if (!trimmed) continue;
+      entries.push({
+        source: sourceName,
+        line: trimmed,
+        level: classifyLevel(trimmed),
+      });
+    }
+  }
+
+  if (entries.length > limit) {
+    entries.splice(0, entries.length - limit);
+  }
+
+  return {
+    entries,
+    sources: sources.map((source) => path.relative(root, source) || source),
+    counts: tallyLevels(entries),
+  };
+}
+
+function tallyLevels(entries) {
+  const counts = { all: entries.length };
+  for (const level of LEVELS) counts[level] = 0;
+  for (const entry of entries) {
+    counts[entry.level] = (counts[entry.level] || 0) + 1;
+  }
+  return counts;
+}
+
+function filterEntries(entries, filter) {
+  const value = String(filter || 'all').toLowerCase();
+  if (value === 'all' || value === '') return entries.slice();
+  if (value === 'by-pane' || value === 'by-source') {
+    const groups = new Map();
+    for (const entry of entries) {
+      const key = entry.source || 'unknown';
+      const arr = groups.get(key) || [];
+      arr.push(entry);
+      groups.set(key, arr);
+    }
+    const ordered = [];
+    for (const [, arr] of groups) ordered.push(...arr);
+    return ordered;
+  }
+  if (LEVELS.includes(value)) {
+    return entries.filter((entry) => entry.level === value);
+  }
+  return entries.slice();
+}
+
+module.exports = {
+  DEFAULT_LIMIT,
+  DEFAULT_LOG_GLOBS,
+  DEFAULT_TAIL_BYTES,
+  LEVELS,
+  classifyLevel,
+  filterEntries,
+  listLogPaths,
+  readLogs,
+  tailFile,
+  tallyLevels,
+};

package/src/cockpit/menu.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const paneMenu = require('./pane-menu');
+const { colorize, getCockpitTheme, stripAnsi } = require('./theme');
+
+const {
+  PANE_MENU_ACTIONS,
+  PANE_MENU_ACTION_IDS,
+  PANE_MENU_FOOTER,
+  normalizePaneMenuKey,
+} = paneMenu;
+
+const PANE_MENU_ITEMS = Object.freeze([
+  { id: PANE_MENU_ACTION_IDS.VIEW, label: 'View', hotkey: 'v', needsSession: true },
+  { id: PANE_MENU_ACTION_IDS.HIDE_PANE, label: 'Hide Pane', hotkey: 'h', needsSession: true },
+  { id: PANE_MENU_ACTION_IDS.CLOSE, label: 'Close', hotkey: 'x', danger: true, needsSession: true },
+  { id: PANE_MENU_ACTION_IDS.MERGE, label: 'Merge / Finish', hotkey: 'm', needsSession: true, needsWorktree: true, needsBranch: true },
+  { id: PANE_MENU_ACTION_IDS.CREATE_PR, label: 'Create GitHub PR', hotkey: 'p', needsSession: true, needsWorktree: true, needsBranch: true },
+  { id: PANE_MENU_ACTION_IDS.RENAME, label: 'Rename', hotkey: 'r', needsSession: true },
+  { id: PANE_MENU_ACTION_IDS.COPY_PATH, label: 'Copy Path', hotkey: 'c', needsSession: true, needsWorktree: true },
+  { id: PANE_MENU_ACTION_IDS.OPEN_EDITOR, label: 'Open in Editor', hotkey: 'o', needsSession: true, needsWorktree: true },
+  { id: PANE_MENU_ACTION_IDS.TOGGLE_AUTOPILOT, label: 'Toggle Autopilot', hotkey: 'a', needsSession: true, needsWorktree: true, needsBranch: true },
+  { id: PANE_MENU_ACTION_IDS.CREATE_CHILD_WORKTREE, label: 'Create Child Worktree', hotkey: 'b', needsSession: true, needsWorktree: true, needsBranch: true },
+  { id: PANE_MENU_ACTION_IDS.BROWSE_FILES, label: 'Browse Files', hotkey: 'f', needsSession: true, needsWorktree: true },
+  { id: PANE_MENU_ACTION_IDS.ADD_TERMINAL, label: 'Add Terminal to Worktree', hotkey: 'T', needsSession: true, needsWorktree: true },
+  { id: PANE_MENU_ACTION_IDS.ADD_AGENT, label: 'Add Agent to Worktree', hotkey: 'A', needsSession: true, needsWorktree: true, needsBranch: true },
+]);
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return '';
+}
+
+function fileName(value) {
+  const text = String(value || '').replace(/[/\\]+$/, '');
+  const parts = text.split(/[/\\]+/).filter(Boolean);
+  return parts[parts.length - 1] || '';
+}
+
+function selectedPaneName(session = {}, context = {}) {
+  return firstString(
+    context.name,
+    session.displayName,
+    session.paneName,
+    session.name,
+    session.agentName,
+    session.agent,
+    fileName(session.worktreePath),
+    fileName(session.path),
+    session.branch,
+    session.id,
+    'selected pane',
+  );
+}
+
+function paneMenuTitle(name) {
+  const text = String(name || '').trim() || 'selected pane';
+  return text.startsWith('Menu:') ? text : `Menu: ${text}`;
+}
+
+function selectedSession(context = {}) {
+  return context.session || context.selectedSession || context.pane || context.lane || null;
+}
+
+function resolveBranch(session = {}, context = {}) {
+  return firstString(
+    context.branch,
+    session.branch,
+    session.lane && session.lane.branch,
+  );
+}
+
+function resolveWorktreePath(session = {}, context = {}) {
+  return firstString(
+    context.worktreePath,
+    context.path,
+    session.worktreePath,
+    session.worktree && session.worktree.path,
+    session.path,
+  );
+}
+
+function resolveWorktreeExists(session = {}, context = {}, worktreePath = '') {
+  if (typeof context.worktreeExists === 'boolean') return context.worktreeExists;
+  if (typeof session.worktreeExists === 'boolean') return session.worktreeExists;
+  return worktreePath.length > 0;
+}
+
+function disabledReason(item, context) {
+  if (item.needsSession && !context.selected) return 'No pane selected';
+
+  const reasons = [];
+  if (item.needsWorktree && !context.worktreeExists) reasons.push('Worktree missing');
+  if (item.needsBranch && !context.branch) reasons.push('Branch missing');
+  return reasons.join('; ');
+}
+
+function createPaneMenuItems(context) {
+  return PANE_MENU_ITEMS.map((item) => {
+    const reason = disabledReason(item, context);
+    return {
+      id: item.id,
+      label: item.label,
+      hotkey: item.hotkey,
+      shortcut: item.hotkey,
+      enabled: reason.length === 0,
+      danger: Boolean(item.danger),
+      reason,
+    };
+  });
+}
+
+function createPaneMenuState(options = {}) {
+  const session = selectedSession(options);
+  const selected = Boolean(session) && options.selected !== false;
+  const source = session || {};
+  const branch = selected ? resolveBranch(source, options) : '';
+  const worktreePath = selected ? resolveWorktreePath(source, options) : '';
+  const context = {
+    selected,
+    branch,
+    worktreePath,
+    worktreeExists: selected && resolveWorktreeExists(source, options, worktreePath),
+  };
+  const items = Array.isArray(options.items) && options.items.length > 0
+    ? options.items.map((item) => ({ ...item }))
+    : createPaneMenuItems(context);
+
+  return paneMenu.createPaneMenuState({
+    ...options,
+    session,
+    title: paneMenuTitle(firstString(options.title, selectedPaneName(source, options))),
+    items,
+  });
+}
+
+function applyPaneMenuKey(state = {}, rawKey) {
+  return paneMenu.applyPaneMenuKey(createPaneMenuState(state), rawKey);
+}
+
+function themeMenuLine(line, state, theme) {
+  const plain = stripAnsi(line);
+  if (/^[┌├└+]/.test(plain)) {
+    return colorize(line, 'border', theme);
+  }
+  if (plain.includes('Menu:')) {
+    return colorize(line, 'title', theme);
+  }
+  if (plain.includes('status:')) {
+    return colorize(line, 'warning', theme);
+  }
+  if (plain.includes('Close')) {
+    return colorize(line, plain.includes('>') ? 'selected' : 'danger', theme);
+  }
+  if (plain.includes('>')) {
+    return colorize(line, 'selected', theme);
+  }
+  if (plain.includes(PANE_MENU_FOOTER)) {
+    return colorize(line, 'secondary', theme);
+  }
+  return line;
+}
+
+function applyMenuTheme(output, state, options) {
+  const theme = getCockpitTheme(options.theme || state.theme || (state.settings && state.settings.theme), options);
+  if (!theme.color) {
+    return output;
+  }
+  return `${String(output).replace(/\n$/, '').split('\n').map((line) => themeMenuLine(line, state, theme)).join('\n')}\n`;
+}
+
+function renderPaneMenu(state = {}, options = {}) {
+  const selectedIndex = Number.isInteger(options.selectedIndex)
+    ? options.selectedIndex
+    : state.selectedIndex;
+  const current = createPaneMenuState({ ...state, selectedIndex });
+  const output = paneMenu.renderPaneMenu(current, options).replace(/\u25b6/g, '>');
+  return applyMenuTheme(output, current, options);
+}
+
+function buildLaneMenu(session, context = {}) {
+  return createPaneMenuState({ ...context, session });
+}
+
+function renderLaneMenu(menu, options = {}) {
+  return renderPaneMenu(menu, options);
+}
+
+module.exports = {
+  PANE_MENU_ACTIONS,
+  PANE_MENU_ACTION_IDS,
+  PANE_MENU_FOOTER,
+  PANE_MENU_ITEMS,
+  applyPaneMenuKey,
+  buildLaneMenu,
+  createPaneMenuState,
+  normalizePaneMenuKey,
+  renderLaneMenu,
+  renderPaneMenu,
+};