@imdeadpool/guardex 7.0.41 → 7.1.0

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,
+};