@automagik/genie 0.260201.2240

package/src/term-commands/read.ts

@@ -0,0 +1,70 @@
+import * as logReader from '../lib/log-reader.js';
+
+export interface ReadOptions {
+  lines?: string;
+  from?: string;
+  to?: string;
+  range?: string;
+  search?: string;
+  grep?: string;
+  follow?: boolean;
+  all?: boolean;
+  reverse?: boolean;
+  json?: boolean;
+}
+
+export async function readSessionLogs(sessionName: string, options: ReadOptions): Promise<void> {
+  try {
+    // Parse options
+    const readOptions: logReader.ReadOptions = {
+      lines: options.lines ? parseInt(options.lines, 10) : 100,
+      from: options.from ? parseInt(options.from, 10) : undefined,
+      to: options.to ? parseInt(options.to, 10) : undefined,
+      range: options.range,
+      search: options.search,
+      grep: options.grep,
+      follow: options.follow,
+      all: options.all,
+      reverse: options.reverse,
+    };
+
+    // Handle follow mode
+    if (options.follow) {
+      console.log(`Following session "${sessionName}" (Ctrl+C to stop)...`);
+      console.log('');
+
+      const stopFollowing = await logReader.followSessionLogs(sessionName, (line) => {
+        console.log(line);
+      });
+
+      // Handle Ctrl+C
+      process.on('SIGINT', () => {
+        stopFollowing();
+        console.log('\nStopped following');
+        process.exit(0);
+      });
+
+      // Keep process running
+      await new Promise(() => {});
+      return;
+    }
+
+    // Regular read mode
+    const content = await logReader.readSessionLogs(sessionName, readOptions);
+
+    if (options.json) {
+      const lines = content.split('\n');
+      console.log(JSON.stringify({
+        session: sessionName,
+        lineCount: lines.length,
+        content: lines,
+      }, null, 2));
+      return;
+    }
+
+    console.log(content);
+  } catch (error: any) {
+    console.error(`Error reading session logs: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/rm.ts

@@ -0,0 +1,47 @@
+import { join } from 'path';
+import * as tmux from '../lib/tmux.js';
+import { createWorktreeManager } from '../lib/worktree.js';
+import { loadSessionMetadata, deleteSessionMetadata } from '../lib/session-metadata.js';
+
+export interface RemoveSessionOptions {
+  keepWorktree?: boolean;
+}
+
+export async function removeSession(name: string, options: RemoveSessionOptions = {}): Promise<void> {
+  try {
+    // Check if session exists
+    const session = await tmux.findSessionByName(name);
+    if (!session) {
+      console.error(`❌ Session "${name}" not found`);
+      process.exit(1);
+    }
+
+    // Check if session has associated worktree
+    const metadata = await loadSessionMetadata(name);
+
+    // Kill session
+    await tmux.killSession(session.id);
+
+    // Remove worktree unless --keep-worktree
+    if (metadata?.worktreePath && metadata?.workspace && !options.keepWorktree) {
+      const manager = createWorktreeManager({
+        baseDir: join(metadata.workspace, '.worktrees'),
+        repoPath: metadata.workspace
+      });
+      await manager.removeWorktree(name);
+      console.log(`✅ Session "${name}" and worktree removed`);
+    } else if (metadata?.worktreePath && options.keepWorktree) {
+      console.log(`✅ Session "${name}" removed (worktree kept at ${metadata.worktreePath})`);
+    } else {
+      console.log(`✅ Session "${name}" removed`);
+    }
+
+    // Clean up metadata
+    if (metadata) {
+      await deleteSessionMetadata(name);
+    }
+  } catch (error: any) {
+    console.error(`❌ Error removing session: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/send.ts

@@ -0,0 +1,34 @@
+import * as tmux from '../lib/tmux.js';
+
+export async function sendKeysToSession(sessionName: string, keys: string): Promise<void> {
+  try {
+    // Find session
+    const session = await tmux.findSessionByName(sessionName);
+    if (!session) {
+      console.error(`❌ Session "${sessionName}" not found`);
+      process.exit(1);
+    }
+
+    // Get first window and pane
+    const windows = await tmux.listWindows(session.id);
+    if (!windows || windows.length === 0) {
+      console.error(`❌ No windows found in session "${sessionName}"`);
+      process.exit(1);
+    }
+
+    const panes = await tmux.listPanes(windows[0].id);
+    if (!panes || panes.length === 0) {
+      console.error(`❌ No panes found in session "${sessionName}"`);
+      process.exit(1);
+    }
+
+    const paneId = panes[0].id;
+
+    // Send keys without Enter
+    await tmux.executeCommand(paneId, keys, false, true);
+    console.log(`✅ Keys sent to session "${sessionName}"`);
+  } catch (error: any) {
+    console.error(`❌ Error sending keys: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/shortcuts.ts

@@ -0,0 +1,355 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync } from 'fs';
+import * as readline from 'readline';
+
+export interface ShortcutsOptions {
+  tmux?: boolean;
+  termux?: boolean;
+  install?: boolean;
+}
+
+// Generate tmux.conf snippet for Warp-like shortcuts
+export function generateTmuxConfig(): string {
+  return `# Warp-like keyboard shortcuts (generated by genie-cli)
+# To use: add to ~/.tmux.conf or source this file
+
+# Ctrl+T: New window (tab) in current session
+bind-key -n C-t new-window
+
+# Ctrl+S: Vertical split (requires stty -ixon in shell rc)
+bind-key -n C-s split-window -v
+
+# Alt+S: Horizontal split
+bind-key -n M-s split-window -h
+`;
+}
+
+// Generate termux.properties snippet for extra keys
+export function generateTermuxConfig(): string {
+  return `# Warp-like extra keys (generated by genie-cli)
+# To use: add to ~/.termux/termux.properties
+
+# Extra keys row with F-keys for shortcuts
+# F1=New Tab, F2=VSplit, F3=HSplit
+extra-keys = [['ESC','TAB','CTRL','ALT','F1','F2','F3']]
+`;
+}
+
+// Generate shell functions for bashrc/zshrc
+export function generateShellFunctions(): string {
+  return `# Warp-like shortcuts (generated by genie-cli)
+# To use: add to ~/.bashrc or ~/.zshrc
+
+# Disable Ctrl+S flow control (required for Ctrl+S to work in tmux)
+stty -ixon 2>/dev/null
+
+# Genie shortcuts (for Termux extra keys F1-F3)
+genie-new-tab() {
+  local session
+  session=$(tmux display-message -p '#S' 2>/dev/null)
+  if [ -n "$session" ]; then
+    tmux new-window
+  else
+    echo "Not in a tmux session"
+  fi
+}
+
+genie-vsplit() {
+  if tmux display-message -p '#S' >/dev/null 2>&1; then
+    tmux split-window -v
+  else
+    echo "Not in a tmux session"
+  fi
+}
+
+genie-hsplit() {
+  if tmux display-message -p '#S' >/dev/null 2>&1; then
+    tmux split-window -h
+  else
+    echo "Not in a tmux session"
+  fi
+}
+
+# Bind F1-F3 to genie shortcuts (works in Termux)
+bind -x '"\eOP":"genie-new-tab"' 2>/dev/null   # F1
+bind -x '"\eOQ":"genie-vsplit"' 2>/dev/null    # F2
+bind -x '"\eOR":"genie-hsplit"' 2>/dev/null    # F3
+`;
+}
+
+// Display all shortcuts in a readable format
+export function displayShortcuts(): void {
+  console.log(`
+Warp-like Terminal Shortcuts for tmux + Termux
+
+┌────────────┬────────────────────────────────────────┐
+│ Shortcut   │ Action                                 │
+├────────────┼────────────────────────────────────────┤
+│ Ctrl+T     │ New tab (window) in current session    │
+│ Ctrl+S     │ Vertical split in current session      │
+│ Alt+S      │ Horizontal split in current session    │
+└────────────┴────────────────────────────────────────┘
+
+Termux Extra Keys (F1-F3):
+  F1 → New tab       F2 → Vertical split
+  F3 → Horizontal split
+
+Commands:
+  term shortcuts --tmux     Output tmux.conf snippet
+  term shortcuts --termux   Output termux.properties snippet
+  term shortcuts --install  Install to config files
+`);
+}
+
+// Helper to prompt user
+async function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+// Check if content already exists in file
+function contentExists(filePath: string, marker: string): boolean {
+  if (!existsSync(filePath)) return false;
+  const content = readFileSync(filePath, 'utf-8');
+  return content.includes(marker);
+}
+
+// Install shortcuts to config files
+export async function installShortcuts(): Promise<void> {
+  const home = homedir();
+  const marker = 'generated by genie-cli';
+
+  console.log('Installing Warp-like shortcuts...\n');
+
+  // 1. Install to tmux.conf
+  const tmuxConf = join(home, '.tmux.conf');
+  if (contentExists(tmuxConf, marker)) {
+    console.log('✓ tmux.conf already has genie shortcuts');
+  } else {
+    const answer = await prompt(`Add shortcuts to ${tmuxConf}? [Y/n] `);
+    if (answer !== 'n') {
+      const content = '\n' + generateTmuxConfig();
+      appendFileSync(tmuxConf, content);
+      console.log(`✅ Added to ${tmuxConf}`);
+    } else {
+      console.log('⏭️ Skipped tmux.conf');
+    }
+  }
+
+  // 2. Install to bashrc/zshrc
+  const shellRc = existsSync(join(home, '.zshrc'))
+    ? join(home, '.zshrc')
+    : join(home, '.bashrc');
+
+  if (contentExists(shellRc, marker)) {
+    console.log(`✓ ${shellRc} already has genie shortcuts`);
+  } else {
+    const answer = await prompt(`Add shell functions to ${shellRc}? [Y/n] `);
+    if (answer !== 'n') {
+      const content = '\n' + generateShellFunctions();
+      appendFileSync(shellRc, content);
+      console.log(`✅ Added to ${shellRc}`);
+    } else {
+      console.log(`⏭️ Skipped ${shellRc}`);
+    }
+  }
+
+  // 3. Install to termux.properties (if Termux detected)
+  const termuxDir = join(home, '.termux');
+  const termuxProps = join(termuxDir, 'termux.properties');
+  const isTermux = existsSync(termuxDir) || process.env.TERMUX_VERSION;
+
+  if (isTermux) {
+    if (contentExists(termuxProps, marker)) {
+      console.log('✓ termux.properties already has genie shortcuts');
+    } else {
+      const answer = await prompt(`Add extra keys to ${termuxProps}? [Y/n] `);
+      if (answer !== 'n') {
+        if (!existsSync(termuxDir)) {
+          mkdirSync(termuxDir, { recursive: true });
+        }
+        const content = '\n' + generateTermuxConfig();
+        appendFileSync(termuxProps, content);
+        console.log(`✅ Added to ${termuxProps}`);
+        console.log('   Run: termux-reload-settings');
+      } else {
+        console.log('⏭️ Skipped termux.properties');
+      }
+    }
+  }
+
+  console.log('\n✅ Installation complete!');
+  console.log('\nNext steps:');
+  console.log('  1. Reload tmux: tmux source ~/.tmux.conf');
+  console.log('  2. Restart your shell or run: source ~/.bashrc');
+  if (isTermux) {
+    console.log('  3. Reload Termux: termux-reload-settings');
+  }
+}
+
+// Check if shortcuts are installed in a file
+export function isShortcutsInstalled(filePath: string): boolean {
+  const marker = 'generated by genie-cli';
+  return contentExists(filePath, marker);
+}
+
+// Remove content between markers from a file
+function removeMarkedContent(filePath: string, marker: string): boolean {
+  if (!existsSync(filePath)) return false;
+
+  const content = readFileSync(filePath, 'utf-8');
+  if (!content.includes(marker)) return false;
+
+  // Split into lines and find the block to remove
+  const lines = content.split('\n');
+  const filteredLines: string[] = [];
+  let inBlock = false;
+  let blockStartIndex = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes(marker) && !inBlock) {
+      // Start of a marked block - find the comment start (could be previous line)
+      inBlock = true;
+      // Check if previous line is a blank line we should also remove
+      if (blockStartIndex === -1 && filteredLines.length > 0 && filteredLines[filteredLines.length - 1].trim() === '') {
+        filteredLines.pop();
+      }
+      continue;
+    }
+    if (inBlock) {
+      // Check if this is the end of the block (empty line followed by non-genie content)
+      if (line.trim() === '' && i + 1 < lines.length && !lines[i + 1].includes('genie')) {
+        inBlock = false;
+        continue;
+      }
+      // Check if this line is part of our genie config (has specific markers)
+      const isGenieContent =
+        line.includes('genie') ||
+        line.includes('Ctrl+') ||
+        line.includes('split-window') ||
+        line.includes('new-window') ||
+        line.includes('stty -ixon') ||
+        line.includes('Warp-like') ||
+        line.includes('bind-key -n') ||
+        line.includes('extra-keys') ||
+        line.includes('F1=') ||
+        line.includes('bind -x') ||
+        line.startsWith('#') && lines[i - 1]?.includes('genie');
+
+      if (!isGenieContent && line.trim() !== '') {
+        inBlock = false;
+        filteredLines.push(line);
+      }
+      // Skip genie content lines
+      continue;
+    }
+    filteredLines.push(line);
+  }
+
+  // Clean up trailing newlines
+  while (filteredLines.length > 0 && filteredLines[filteredLines.length - 1].trim() === '') {
+    filteredLines.pop();
+  }
+
+  // Add back one trailing newline if file had content
+  const newContent = filteredLines.length > 0 ? filteredLines.join('\n') + '\n' : '';
+  writeFileSync(filePath, newContent);
+  return true;
+}
+
+// Uninstall shortcuts from config files
+export async function uninstallShortcuts(): Promise<void> {
+  const home = homedir();
+  const marker = 'generated by genie-cli';
+
+  console.log('Uninstalling Warp-like shortcuts...\n');
+
+  // 1. Remove from tmux.conf
+  const tmuxConf = join(home, '.tmux.conf');
+  if (!contentExists(tmuxConf, marker)) {
+    console.log('✓ tmux.conf has no genie shortcuts');
+  } else {
+    const answer = await prompt(`Remove shortcuts from ${tmuxConf}? [Y/n] `);
+    if (answer !== 'n') {
+      if (removeMarkedContent(tmuxConf, marker)) {
+        console.log(`✅ Removed from ${tmuxConf}`);
+      }
+    } else {
+      console.log('⏭️ Skipped tmux.conf');
+    }
+  }
+
+  // 2. Remove from bashrc/zshrc
+  const zshrc = join(home, '.zshrc');
+  const bashrc = join(home, '.bashrc');
+
+  // Check both files
+  for (const shellRc of [zshrc, bashrc]) {
+    if (!existsSync(shellRc)) continue;
+    if (!contentExists(shellRc, marker)) {
+      console.log(`✓ ${shellRc} has no genie shortcuts`);
+    } else {
+      const answer = await prompt(`Remove shell functions from ${shellRc}? [Y/n] `);
+      if (answer !== 'n') {
+        if (removeMarkedContent(shellRc, marker)) {
+          console.log(`✅ Removed from ${shellRc}`);
+        }
+      } else {
+        console.log(`⏭️ Skipped ${shellRc}`);
+      }
+    }
+  }
+
+  // 3. Remove from termux.properties (if Termux detected)
+  const termuxDir = join(home, '.termux');
+  const termuxProps = join(termuxDir, 'termux.properties');
+  const isTermux = existsSync(termuxDir) || process.env.TERMUX_VERSION;
+
+  if (isTermux) {
+    if (!contentExists(termuxProps, marker)) {
+      console.log('✓ termux.properties has no genie shortcuts');
+    } else {
+      const answer = await prompt(`Remove extra keys from ${termuxProps}? [Y/n] `);
+      if (answer !== 'n') {
+        if (removeMarkedContent(termuxProps, marker)) {
+          console.log(`✅ Removed from ${termuxProps}`);
+          console.log('   Run: termux-reload-settings');
+        }
+      } else {
+        console.log('⏭️ Skipped termux.properties');
+      }
+    }
+  }
+
+  console.log('\n✅ Uninstallation complete!');
+  console.log('\nNext steps:');
+  console.log('  1. Reload tmux: tmux source ~/.tmux.conf');
+  console.log('  2. Restart your shell or run: source ~/.bashrc');
+  if (isTermux) {
+    console.log('  3. Reload Termux: termux-reload-settings');
+  }
+}
+
+// Main handler
+export async function handleShortcuts(options: ShortcutsOptions): Promise<void> {
+  if (options.tmux) {
+    console.log(generateTmuxConfig());
+  } else if (options.termux) {
+    console.log(generateTermuxConfig());
+  } else if (options.install) {
+    await installShortcuts();
+  } else {
+    displayShortcuts();
+  }
+}

package/src/term-commands/split.ts

@@ -0,0 +1,87 @@
+import { join } from 'path';
+import * as tmux from '../lib/tmux.js';
+import { createWorktreeManager } from '../lib/worktree.js';
+
+export interface SplitOptions {
+  workspace?: string;
+  worktree?: string;
+}
+
+export async function splitSessionPane(
+  sessionName: string,
+  direction?: string,
+  options: SplitOptions = {}
+): Promise<void> {
+  try {
+    // Find session
+    const session = await tmux.findSessionByName(sessionName);
+    if (!session) {
+      console.error(`❌ Session "${sessionName}" not found`);
+      process.exit(1);
+    }
+
+    // Get first window and pane
+    const windows = await tmux.listWindows(session.id);
+    if (!windows || windows.length === 0) {
+      console.error(`❌ No windows found in session "${sessionName}"`);
+      process.exit(1);
+    }
+
+    const panes = await tmux.listPanes(windows[0].id);
+    if (!panes || panes.length === 0) {
+      console.error(`❌ No panes found in session "${sessionName}"`);
+      process.exit(1);
+    }
+
+    const paneId = panes[0].id;
+
+    // Determine direction
+    const splitDirection = direction === 'h' ? 'horizontal' : 'vertical';
+
+    // Handle workspace and worktree options
+    let workingDir: string | undefined;
+
+    if (options.worktree) {
+      if (!options.workspace) {
+        console.error('❌ --worktree requires --workspace');
+        process.exit(1);
+      }
+
+      const manager = createWorktreeManager({
+        baseDir: join(options.workspace, '.worktrees'),
+        repoPath: options.workspace
+      });
+
+      // Check if worktree exists, create if not
+      const exists = await manager.worktreeExists(options.worktree);
+      if (!exists) {
+        const wt = await manager.createWorktree(options.worktree, true);
+        console.log(`✅ Worktree created at ${wt.path}`);
+      }
+
+      workingDir = manager.getWorktreePath(options.worktree);
+    } else if (options.workspace) {
+      workingDir = options.workspace;
+    }
+
+    // Split pane
+    const newPane = await tmux.splitPane(paneId, splitDirection);
+    if (!newPane) {
+      console.error('❌ Failed to split pane');
+      process.exit(1);
+    }
+
+    // Change to working directory if specified
+    if (workingDir && newPane) {
+      await tmux.executeTmux(`send-keys -t '${newPane.id}' 'cd ${workingDir}' Enter`);
+    }
+
+    console.log(`✅ Pane split ${splitDirection}ly in session "${sessionName}"`);
+    if (workingDir) {
+      console.log(`   Working directory: ${workingDir}`);
+    }
+  } catch (error: any) {
+    console.error(`❌ Error splitting pane: ${error.message}`);
+    process.exit(1);
+  }
+}