@automagik/genie 0.260201.2240

package/src/lib/log-reader.ts

@@ -0,0 +1,213 @@
+import * as tmux from './tmux.js';
+
+export interface ReadOptions {
+  lines?: number;           // Number of lines (default 100)
+  from?: number;            // Start line
+  to?: number;              // End line
+  search?: string;          // Search pattern
+  grep?: string;            // Regex pattern
+  follow?: boolean;         // Live tail mode
+  all?: boolean;            // Entire scrollback
+  reverse?: boolean;        // Newest first
+  range?: string;           // Range syntax like "100:200"
+}
+
+/**
+ * Strip internal TMUX_MCP markers from log output
+ */
+function stripTmuxMarkers(content: string): string {
+  const lines = content.split('\n');
+
+  // First pass: mark lines to remove
+  const filtered = lines.filter(line => {
+    const trimmed = line.trim();
+
+    // Remove complete marker lines
+    if (trimmed.match(/^TMUX_MCP_START$/)) return false;
+    if (trimmed.match(/^TMUX_MCP_DONE_\d+$/)) return false;
+
+    // Remove partial marker fragments (from split echo commands)
+    if (trimmed.includes('TMUX_MCP_START')) return false;
+    if (trimmed.includes('TMUX_MCP_DONE_')) return false;
+
+    // Remove lines containing echo commands for markers
+    if (line.includes('echo "TMUX_MCP_START"')) return false;
+    if (line.includes('echo "TMUX_MCP_DONE_')) return false;
+
+    // Remove bash locale warnings and fragments
+    if (line.includes('-bash:')) return false;
+    if (line.includes('warning: setlocale:')) return false;
+    if (line.includes('cannot change locale')) return false;
+    if (trimmed === 'or directory') return false;  // Orphan fragment from wrapped warning
+
+    return true;
+  });
+
+  // Remove leading/trailing empty lines
+  while (filtered.length > 0 && filtered[0].trim() === '') {
+    filtered.shift();
+  }
+  while (filtered.length > 0 && filtered[filtered.length - 1].trim() === '') {
+    filtered.pop();
+  }
+
+  return filtered.join('\n');
+}
+
+/**
+ * Read logs from a tmux session with comprehensive filtering options
+ */
+export async function readSessionLogs(
+  sessionName: string,
+  options: ReadOptions = {}
+): Promise<string> {
+  // Find session
+  const session = await tmux.findSessionByName(sessionName);
+  if (!session) {
+    throw new Error(`Session "${sessionName}" not found`);
+  }
+
+  // Get first window and pane
+  const windows = await tmux.listWindows(session.id);
+  if (!windows || windows.length === 0) {
+    throw new Error(`No windows found in session "${sessionName}"`);
+  }
+
+  const panes = await tmux.listPanes(windows[0].id);
+  if (!panes || panes.length === 0) {
+    throw new Error(`No panes found in session "${sessionName}"`);
+  }
+
+  const paneId = panes[0].id;
+
+  // Parse range if provided
+  if (options.range) {
+    const parts = options.range.split(':');
+    if (parts.length === 2) {
+      options.from = parseInt(parts[0], 10);
+      options.to = parseInt(parts[1], 10);
+    }
+  }
+
+  // Handle different read modes
+  if (options.all) {
+    // Get entire scrollback buffer (tmux history limit, usually 2000-10000 lines)
+    const content = await tmux.capturePaneContent(paneId, 10000);
+    return stripTmuxMarkers(content);
+  }
+
+  if (options.from !== undefined && options.to !== undefined) {
+    // Read specific range
+    const fullContent = await tmux.capturePaneContent(paneId, 10000);
+    const cleanContent = stripTmuxMarkers(fullContent);
+    const lines = cleanContent.split('\n');
+    const rangeContent = lines.slice(options.from, options.to + 1).join('\n');
+
+    if (options.reverse) {
+      return rangeContent.split('\n').reverse().join('\n');
+    }
+
+    return rangeContent;
+  }
+
+  if (options.search || options.grep) {
+    // Search logs
+    const pattern = options.search || options.grep;
+    const fullContent = await tmux.capturePaneContent(paneId, 10000);
+    const cleanContent = stripTmuxMarkers(fullContent);
+    const lines = cleanContent.split('\n');
+
+    try {
+      const regex = new RegExp(pattern, 'i');
+      const matchedLines = lines.filter(line => regex.test(line));
+
+      if (options.reverse) {
+        return matchedLines.reverse().join('\n');
+      }
+
+      return matchedLines.join('\n');
+    } catch (error: any) {
+      throw new Error(`Invalid regex pattern: ${error.message}`);
+    }
+  }
+
+  // Default: last N lines
+  const lineCount = options.lines || 100;
+  let content = await tmux.capturePaneContent(paneId, lineCount);
+  content = stripTmuxMarkers(content);
+
+  if (options.reverse) {
+    // Newest first
+    content = content.split('\n').reverse().join('\n');
+  }
+
+  return content;
+}
+
+/**
+ * Follow a session's logs in real-time (like tail -f)
+ * Returns a function to stop following
+ */
+export async function followSessionLogs(
+  sessionName: string,
+  callback: (line: string) => void
+): Promise<() => void> {
+  const session = await tmux.findSessionByName(sessionName);
+  if (!session) {
+    throw new Error(`Session "${sessionName}" not found`);
+  }
+
+  const windows = await tmux.listWindows(session.id);
+  if (!windows || windows.length === 0) {
+    throw new Error(`No windows found in session "${sessionName}"`);
+  }
+
+  const panes = await tmux.listPanes(windows[0].id);
+  if (!panes || panes.length === 0) {
+    throw new Error(`No panes found in session "${sessionName}"`);
+  }
+
+  const paneId = panes[0].id;
+  let lastContent = '';
+  let following = true;
+
+  // Poll for new content every 500ms
+  const pollInterval = setInterval(async () => {
+    if (!following) {
+      clearInterval(pollInterval);
+      return;
+    }
+
+    try {
+      const rawContent = await tmux.capturePaneContent(paneId, 100);
+      const content = stripTmuxMarkers(rawContent);
+
+      if (content !== lastContent) {
+        const newLines = content.split('\n');
+        const oldLines = lastContent.split('\n');
+
+        // Find new lines by comparing arrays
+        const startIndex = oldLines.length > 0 ? oldLines.length - 1 : 0;
+        const addedLines = newLines.slice(startIndex);
+
+        addedLines.forEach(line => {
+          if (line && line !== oldLines[oldLines.length - 1]) {
+            callback(line);
+          }
+        });
+
+        lastContent = content;
+      }
+    } catch (error) {
+      // Session might have been closed
+      clearInterval(pollInterval);
+      following = false;
+    }
+  }, 500);
+
+  // Return stop function
+  return () => {
+    following = false;
+    clearInterval(pollInterval);
+  };
+}

package/src/lib/picker.ts

@@ -0,0 +1,62 @@
+import { search, input, confirm } from '@inquirer/prompts';
+import { Model } from './api-client.js';
+
+export interface PickerOptions {
+  message: string;
+  models: Model[];
+}
+
+export async function pickModel(options: PickerOptions): Promise<string> {
+  const { message, models } = options;
+
+  const modelIds = models.map((m) => m.id);
+
+  const selected = await search({
+    message,
+    source: async (term) => {
+      const searchTerm = (term || '').toLowerCase();
+      const filtered = modelIds.filter((id) =>
+        id.toLowerCase().includes(searchTerm)
+      );
+      return filtered.map((id) => ({
+        name: id,
+        value: id,
+      }));
+    },
+  });
+
+  return selected;
+}
+
+export async function pickProfileModels(models: Model[]): Promise<{ opus: string; sonnet: string; haiku: string }> {
+  const opus = await pickModel({
+    message: 'Select OPUS model:',
+    models,
+  });
+
+  const sonnet = await pickModel({
+    message: 'Select SONNET model:',
+    models,
+  });
+
+  const haiku = await pickModel({
+    message: 'Select HAIKU model:',
+    models,
+  });
+
+  return { opus, sonnet, haiku };
+}
+
+export async function promptText(message: string, defaultValue?: string): Promise<string> {
+  return input({
+    message,
+    default: defaultValue,
+  });
+}
+
+export async function promptConfirm(message: string, defaultValue = false): Promise<boolean> {
+  return confirm({
+    message,
+    default: defaultValue,
+  });
+}

package/src/lib/session-metadata.ts

@@ -0,0 +1,58 @@
+import { mkdir, readFile, writeFile, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+export interface SessionMetadata {
+  worktreePath?: string;
+  workspace?: string;
+  createdAt: string;
+}
+
+interface SessionsData {
+  sessions: Record<string, SessionMetadata>;
+}
+
+const CONFIG_DIR = join(homedir(), '.config', 'term');
+const SESSIONS_FILE = join(CONFIG_DIR, 'sessions.json');
+
+async function ensureConfigDir(): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true });
+}
+
+async function loadSessions(): Promise<SessionsData> {
+  try {
+    await access(SESSIONS_FILE);
+    const content = await readFile(SESSIONS_FILE, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return { sessions: {} };
+  }
+}
+
+async function saveSessions(data: SessionsData): Promise<void> {
+  await ensureConfigDir();
+  await writeFile(SESSIONS_FILE, JSON.stringify(data, null, 2));
+}
+
+export async function saveSessionMetadata(
+  name: string,
+  data: Omit<SessionMetadata, 'createdAt'>
+): Promise<void> {
+  const sessions = await loadSessions();
+  sessions.sessions[name] = {
+    ...data,
+    createdAt: new Date().toISOString(),
+  };
+  await saveSessions(sessions);
+}
+
+export async function loadSessionMetadata(name: string): Promise<SessionMetadata | null> {
+  const sessions = await loadSessions();
+  return sessions.sessions[name] || null;
+}
+
+export async function deleteSessionMetadata(name: string): Promise<void> {
+  const sessions = await loadSessions();
+  delete sessions.sessions[name];
+  await saveSessions(sessions);
+}

package/src/lib/system-detect.ts

@@ -0,0 +1,185 @@
+import { platform, arch } from 'os';
+import { readFile } from 'fs/promises';
+import { $ } from 'bun';
+
+export type OSType = 'macos' | 'linux' | 'unknown';
+export type LinuxDistro = 'debian' | 'ubuntu' | 'fedora' | 'rhel' | 'arch' | 'unknown';
+export type PackageManager = 'brew' | 'apt' | 'dnf' | 'yum' | 'pacman' | 'none';
+
+export interface SystemInfo {
+  os: OSType;
+  arch: string;
+  linuxDistro?: LinuxDistro;
+  preferredPM: PackageManager;
+}
+
+export interface CommandCheck {
+  exists: boolean;
+  version?: string;
+  path?: string;
+}
+
+export interface PrerequisiteStatus {
+  name: string;
+  installed: boolean;
+  version?: string;
+  path?: string;
+  required: boolean;
+  description: string;
+}
+
+function getOSType(): OSType {
+  const p = platform();
+  if (p === 'darwin') return 'macos';
+  if (p === 'linux') return 'linux';
+  return 'unknown';
+}
+
+async function parseOsRelease(): Promise<LinuxDistro> {
+  try {
+    const content = await readFile('/etc/os-release', 'utf-8');
+    const lines = content.split('\n');
+    const info: Record<string, string> = {};
+
+    for (const line of lines) {
+      const [key, ...valueParts] = line.split('=');
+      if (key && valueParts.length > 0) {
+        info[key] = valueParts.join('=').replace(/^"|"$/g, '');
+      }
+    }
+
+    const id = (info.ID || '').toLowerCase();
+    const idLike = (info.ID_LIKE || '').toLowerCase();
+
+    if (id === 'ubuntu' || idLike.includes('ubuntu')) return 'ubuntu';
+    if (id === 'debian' || idLike.includes('debian')) return 'debian';
+    if (id === 'fedora' || idLike.includes('fedora')) return 'fedora';
+    if (id === 'rhel' || id === 'centos' || id === 'rocky' || id === 'almalinux' || idLike.includes('rhel')) return 'rhel';
+    if (id === 'arch' || idLike.includes('arch')) return 'arch';
+
+    return 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+async function commandExists(cmd: string): Promise<boolean> {
+  try {
+    const result = await $`which ${cmd}`.quiet();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+async function detectPackageManager(): Promise<PackageManager> {
+  // Prefer brew if available (works on both macOS and Linux)
+  if (await commandExists('brew')) return 'brew';
+  if (await commandExists('apt')) return 'apt';
+  if (await commandExists('dnf')) return 'dnf';
+  if (await commandExists('yum')) return 'yum';
+  if (await commandExists('pacman')) return 'pacman';
+  return 'none';
+}
+
+export async function detectSystem(): Promise<SystemInfo> {
+  const os = getOSType();
+  const systemArch = arch();
+
+  const result: SystemInfo = {
+    os,
+    arch: systemArch,
+    preferredPM: await detectPackageManager(),
+  };
+
+  if (os === 'linux') {
+    result.linuxDistro = await parseOsRelease();
+  }
+
+  return result;
+}
+
+export async function checkCommand(cmd: string): Promise<CommandCheck> {
+  try {
+    const whichResult = await $`which ${cmd}`.quiet().text();
+    const cmdPath = whichResult.trim();
+
+    if (!cmdPath) {
+      return { exists: false };
+    }
+
+    // Try to get version
+    let version: string | undefined;
+    try {
+      // Try common version flags
+      const versionResult = await $`${cmd} --version`.quiet().text();
+      // Extract first line and clean it up
+      const firstLine = versionResult.split('\n')[0].trim();
+      // Try to extract version number
+      const versionMatch = firstLine.match(/(\d+\.[\d.]+[a-z0-9-]*)/i);
+      version = versionMatch ? versionMatch[1] : firstLine.slice(0, 50);
+    } catch {
+      // Some commands don't support --version, try -v
+      try {
+        const vResult = await $`${cmd} -v`.quiet().text();
+        const firstLine = vResult.split('\n')[0].trim();
+        const versionMatch = firstLine.match(/(\d+\.[\d.]+[a-z0-9-]*)/i);
+        version = versionMatch ? versionMatch[1] : firstLine.slice(0, 50);
+      } catch {
+        // Version unknown but command exists
+      }
+    }
+
+    return { exists: true, version, path: cmdPath };
+  } catch {
+    return { exists: false };
+  }
+}
+
+const PREREQUISITES = [
+  {
+    name: 'tmux',
+    required: true,
+    description: 'Terminal multiplexer for shared sessions',
+  },
+  {
+    name: 'bun',
+    required: true,
+    description: 'Fast JavaScript runtime and package manager',
+  },
+  {
+    name: 'claude',
+    required: false,
+    description: 'Claude Code CLI (optional, recommended)',
+  },
+];
+
+export async function checkAllPrerequisites(): Promise<PrerequisiteStatus[]> {
+  const results: PrerequisiteStatus[] = [];
+
+  for (const prereq of PREREQUISITES) {
+    const check = await checkCommand(prereq.name);
+    results.push({
+      name: prereq.name,
+      installed: check.exists,
+      version: check.version,
+      path: check.path,
+      required: prereq.required,
+      description: prereq.description,
+    });
+  }
+
+  return results;
+}
+
+export function getDistroDisplayName(distro: LinuxDistro): string {
+  const names: Record<LinuxDistro, string> = {
+    ubuntu: 'Ubuntu',
+    debian: 'Debian',
+    fedora: 'Fedora',
+    rhel: 'RHEL/CentOS',
+    arch: 'Arch Linux',
+    unknown: 'Linux',
+  };
+  return names[distro] || 'Linux';
+}