@automagik/genie 0.260201.2240

package/src/lib/worktree.ts

@@ -0,0 +1,362 @@
+import { $ } from "bun";
+import { mkdir, rm, access, readFile, writeFile, stat } from "fs/promises";
+import { join, basename } from "path";
+
+export interface WorktreeInfo {
+  path: string;
+  branch: string;
+  commitHash?: string;
+  createdAt?: Date;
+  size?: number;
+}
+
+export interface WorktreeMetadata {
+  worktrees: {
+    [sanitizedName: string]: {
+      branch: string;
+      createdAt: string;
+    };
+  };
+}
+
+export interface WorktreeManagerConfig {
+  /** Base directory for worktrees (default: .worktrees) */
+  baseDir: string;
+  /** Path to the main git repository */
+  repoPath: string;
+}
+
+/**
+ * Sanitizes a branch name for use as a directory name.
+ * Converts feature/auth to feature-auth, etc.
+ */
+export function sanitizeBranchName(branchName: string): string {
+  return branchName
+    .replace(/\//g, "-")
+    .replace(/\\/g, "-")
+    .replace(/[^a-zA-Z0-9-_.]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+/**
+ * Parses a timeframe string like "7d", "2w", "1m", "24h" into milliseconds.
+ */
+export function parseTimeframe(timeframe: string): number {
+  const match = timeframe.match(/^(\d+)([hdwm])$/i);
+  if (!match) {
+    throw new Error(`Invalid timeframe format: ${timeframe}. Use format like 7d, 2w, 1m, 24h`);
+  }
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+
+  const multipliers: Record<string, number> = {
+    h: 60 * 60 * 1000,           // hours
+    d: 24 * 60 * 60 * 1000,      // days
+    w: 7 * 24 * 60 * 60 * 1000,  // weeks
+    m: 30 * 24 * 60 * 60 * 1000, // months (approximate)
+  };
+
+  return value * multipliers[unit];
+}
+
+/**
+ * Formats a duration in milliseconds to human-readable format.
+ */
+export function formatAge(ms: number): string {
+  const hours = Math.floor(ms / (60 * 60 * 1000));
+  const days = Math.floor(hours / 24);
+  const remainingHours = hours % 24;
+
+  if (days > 0) {
+    return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
+  }
+  return `${hours}h`;
+}
+
+/**
+ * Formats bytes to human-readable size.
+ */
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(0)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+/**
+ * Manages Git worktrees for branch isolation.
+ */
+export class WorktreeManager {
+  private baseDir: string;
+  private repoPath: string;
+  private metadataPath: string;
+
+  constructor(config: WorktreeManagerConfig) {
+    this.baseDir = config.baseDir;
+    this.repoPath = config.repoPath;
+    this.metadataPath = join(this.baseDir, ".metadata.json");
+  }
+
+  /**
+   * Loads worktree metadata from disk.
+   */
+  private async loadMetadata(): Promise<WorktreeMetadata> {
+    try {
+      const content = await readFile(this.metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return { worktrees: {} };
+    }
+  }
+
+  /**
+   * Saves worktree metadata to disk.
+   */
+  private async saveMetadata(metadata: WorktreeMetadata): Promise<void> {
+    await mkdir(this.baseDir, { recursive: true });
+    await writeFile(this.metadataPath, JSON.stringify(metadata, null, 2));
+  }
+
+  /**
+   * Creates a new worktree for a branch.
+   * @param branchName - Git branch name
+   * @param createBranch - If true, create a new branch
+   * @param baseBranch - Base branch for new branch (only with createBranch)
+   */
+  async createWorktree(
+    branchName: string,
+    createBranch: boolean = false,
+    baseBranch?: string
+  ): Promise<WorktreeInfo> {
+    const sanitizedName = sanitizeBranchName(branchName);
+    const worktreePath = join(this.baseDir, sanitizedName);
+
+    // Ensure base directory exists
+    await mkdir(this.baseDir, { recursive: true });
+
+    // Check if worktree already exists
+    try {
+      await access(worktreePath);
+      throw new Error(`Worktree already exists at ${worktreePath}`);
+    } catch (e: any) {
+      if (e.code !== "ENOENT") throw e;
+    }
+
+    if (createBranch) {
+      if (baseBranch) {
+        // Create new branch from base and add worktree
+        await $`git -C ${this.repoPath} worktree add -b ${branchName} ${worktreePath} ${baseBranch}`.quiet();
+      } else {
+        // Create new branch from HEAD and add worktree
+        await $`git -C ${this.repoPath} worktree add -b ${branchName} ${worktreePath}`.quiet();
+      }
+    } else {
+      // Check if branch exists
+      const branchExists = await this.branchExists(branchName);
+      if (!branchExists) {
+        throw new Error(`Branch '${branchName}' does not exist. Use -b to create a new branch.`);
+      }
+      // Add worktree for existing branch
+      await $`git -C ${this.repoPath} worktree add ${worktreePath} ${branchName}`.quiet();
+    }
+
+    // Save metadata
+    const metadata = await this.loadMetadata();
+    metadata.worktrees[sanitizedName] = {
+      branch: branchName,
+      createdAt: new Date().toISOString(),
+    };
+    await this.saveMetadata(metadata);
+
+    // Get commit hash
+    const commitHash = await this.getCommitHash(worktreePath);
+
+    return {
+      path: worktreePath,
+      branch: branchName,
+      commitHash,
+      createdAt: new Date(),
+    };
+  }
+
+  /**
+   * Removes a worktree by branch name.
+   */
+  async removeWorktree(branchName: string): Promise<void> {
+    const sanitizedName = sanitizeBranchName(branchName);
+    const worktreePath = join(this.baseDir, sanitizedName);
+
+    // Remove from git worktree list
+    try {
+      await $`git -C ${this.repoPath} worktree remove ${worktreePath} --force`.quiet();
+    } catch {
+      // If git worktree remove fails, try removing the directory manually
+      try {
+        await rm(worktreePath, { recursive: true, force: true });
+      } catch {
+        // Directory doesn't exist
+      }
+    }
+
+    // Ensure directory is gone
+    try {
+      await access(worktreePath);
+      await rm(worktreePath, { recursive: true, force: true });
+    } catch {
+      // Directory doesn't exist, which is expected
+    }
+
+    // Remove from metadata
+    const metadata = await this.loadMetadata();
+    delete metadata.worktrees[sanitizedName];
+    await this.saveMetadata(metadata);
+  }
+
+  /**
+   * Lists all worktrees in the base directory.
+   */
+  async listWorktrees(): Promise<WorktreeInfo[]> {
+    const result = await $`git -C ${this.repoPath} worktree list --porcelain`.quiet();
+    const output = result.stdout.toString();
+
+    const worktrees: WorktreeInfo[] = [];
+    let current: Partial<WorktreeInfo> = {};
+
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        if (current.path) {
+          worktrees.push(current as WorktreeInfo);
+        }
+        current = { path: line.slice(9) };
+      } else if (line.startsWith("HEAD ")) {
+        current.commitHash = line.slice(5);
+      } else if (line.startsWith("branch ")) {
+        current.branch = line.slice(7).replace("refs/heads/", "");
+      }
+    }
+
+    if (current.path) {
+      worktrees.push(current as WorktreeInfo);
+    }
+
+    // Filter to only include worktrees in our base directory
+    const filtered = worktrees.filter((wt) => wt.path.startsWith(this.baseDir));
+
+    // Load metadata for creation times
+    const metadata = await this.loadMetadata();
+
+    // Enrich with metadata and size
+    for (const wt of filtered) {
+      const sanitizedName = basename(wt.path);
+      const meta = metadata.worktrees[sanitizedName];
+      if (meta) {
+        wt.createdAt = new Date(meta.createdAt);
+      }
+      wt.size = await this.getDiskUsage(wt.path);
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Cleans up worktrees older than the specified timeframe.
+   * @param timeframe - Timeframe string like "7d", "2w", "1m"
+   * @param dryRun - If true, only report what would be removed
+   * @returns List of removed (or would-be-removed) worktrees
+   */
+  async cleanup(timeframe: string, dryRun: boolean = false): Promise<WorktreeInfo[]> {
+    const maxAge = parseTimeframe(timeframe);
+    const now = Date.now();
+    const worktrees = await this.listWorktrees();
+
+    const toRemove: WorktreeInfo[] = [];
+
+    for (const wt of worktrees) {
+      if (wt.createdAt) {
+        const age = now - wt.createdAt.getTime();
+        if (age > maxAge) {
+          toRemove.push(wt);
+        }
+      }
+    }
+
+    if (!dryRun) {
+      for (const wt of toRemove) {
+        await this.removeWorktree(wt.branch);
+      }
+    }
+
+    return toRemove;
+  }
+
+  /**
+   * Prunes stale worktree references.
+   */
+  async prune(): Promise<void> {
+    await $`git -C ${this.repoPath} worktree prune`.quiet();
+  }
+
+  /**
+   * Gets disk usage for a directory.
+   */
+  async getDiskUsage(dirPath: string): Promise<number> {
+    try {
+      const result = await $`du -sb ${dirPath}`.quiet();
+      const output = result.stdout.toString().trim();
+      const size = parseInt(output.split("\t")[0], 10);
+      return isNaN(size) ? 0 : size;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Gets the path for a worktree by branch name.
+   */
+  getWorktreePath(branchName: string): string {
+    const sanitizedName = sanitizeBranchName(branchName);
+    return join(this.baseDir, sanitizedName);
+  }
+
+  /**
+   * Checks if a worktree exists for a branch.
+   */
+  async worktreeExists(branchName: string): Promise<boolean> {
+    const sanitizedName = sanitizeBranchName(branchName);
+    const worktreePath = join(this.baseDir, sanitizedName);
+    try {
+      await access(worktreePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async branchExists(branchName: string): Promise<boolean> {
+    try {
+      await $`git -C ${this.repoPath} rev-parse --verify ${branchName}`.quiet();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async getCommitHash(worktreePath: string): Promise<string> {
+    const result = await $`git -C ${worktreePath} rev-parse HEAD`.quiet();
+    return result.stdout.toString().trim();
+  }
+}
+
+/**
+ * Creates a WorktreeManager with default configuration.
+ */
+export function createWorktreeManager(
+  options?: Partial<WorktreeManagerConfig>
+): WorktreeManager {
+  const baseDir = options?.baseDir || join(process.cwd(), ".worktrees");
+  const repoPath = options?.repoPath || process.cwd();
+
+  return new WorktreeManager({ baseDir, repoPath });
+}

package/src/term-commands/attach.ts

@@ -0,0 +1,23 @@
+import { exec as execCallback } from 'child_process';
+import { promisify } from 'util';
+import * as tmux from '../lib/tmux.js';
+
+const exec = promisify(execCallback);
+
+export async function attachToSession(name: string): Promise<void> {
+  try {
+    // Check if session exists
+    const session = await tmux.findSessionByName(name);
+    if (!session) {
+      console.error(`❌ Session "${name}" not found`);
+      process.exit(1);
+    }
+
+    // Attach to session
+    console.log(`📎 Attaching to session "${name}"...`);
+    await exec(`tmux attach -t "${name}"`);
+  } catch (error: any) {
+    console.error(`❌ Error attaching to session: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/exec.ts

@@ -0,0 +1,34 @@
+import * as tmux from '../lib/tmux.js';
+
+export async function executeInSession(sessionName: string, command: 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;
+
+    // Execute command
+    await tmux.executeCommand(paneId, command);
+    console.log(`✅ Command sent to session "${sessionName}"`);
+  } catch (error: any) {
+    console.error(`❌ Error executing command: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/hook.ts

@@ -0,0 +1,42 @@
+import * as hookManager from '../lib/hook-manager.js';
+
+export async function setHook(event: string, command: string): Promise<void> {
+  try {
+    await hookManager.setHook(event, command);
+    console.log(`✅ Hook set: ${event} → ${command}`);
+  } catch (error: any) {
+    console.error(`❌ Error setting hook: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function listHooks(): Promise<void> {
+  try {
+    const hooks = await hookManager.listHooks();
+
+    if (hooks.length === 0) {
+      console.log('No hooks configured');
+      return;
+    }
+
+    console.log('EVENT\t\t\t\tCOMMAND');
+    console.log('─'.repeat(80));
+
+    for (const hook of hooks) {
+      console.log(`${hook.event}\t\t${hook.command}`);
+    }
+  } catch (error: any) {
+    console.error(`❌ Error listing hooks: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function removeHook(event: string): Promise<void> {
+  try {
+    await hookManager.removeHook(event);
+    console.log(`✅ Hook removed: ${event}`);
+  } catch (error: any) {
+    console.error(`❌ Error removing hook: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/ls.ts

@@ -0,0 +1,33 @@
+import * as tmux from '../lib/tmux.js';
+
+export interface ListOptions {
+  json?: boolean;
+}
+
+export async function listAllSessions(options: ListOptions = {}): Promise<void> {
+  try {
+    const sessions = await tmux.listSessions();
+
+    if (options.json) {
+      console.log(JSON.stringify(sessions, null, 2));
+      return;
+    }
+
+    if (sessions.length === 0) {
+      console.log('No tmux sessions found');
+      return;
+    }
+
+    // Docker ps style output
+    console.log('SESSION ID\t\tNAME\t\t\tWINDOWS\t\tATTACHED');
+    console.log('─'.repeat(80));
+
+    for (const session of sessions) {
+      const attached = session.attached ? 'yes' : 'no';
+      console.log(`${session.id}\t${session.name}\t\t${session.windows}\t\t${attached}`);
+    }
+  } catch (error: any) {
+    console.error(`Error listing sessions: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/new.ts

@@ -0,0 +1,73 @@
+import { join } from 'path';
+import * as tmux from '../lib/tmux.js';
+import { createWorktreeManager } from '../lib/worktree.js';
+import { saveSessionMetadata } from '../lib/session-metadata.js';
+
+export interface CreateSessionOptions {
+  workspace?: string;
+  worktree?: boolean;
+}
+
+export async function createNewSession(name: string, options: CreateSessionOptions = {}): Promise<void> {
+  try {
+    // Check if session already exists
+    const existing = await tmux.findSessionByName(name);
+    if (existing) {
+      console.error(`❌ Session "${name}" already exists`);
+      process.exit(1);
+    }
+
+    let workingDir = options.workspace || process.cwd();
+    let worktreePath: 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 already exists
+      const exists = await manager.worktreeExists(name);
+      if (exists) {
+        console.error(`❌ Worktree for "${name}" already exists`);
+        process.exit(1);
+      }
+
+      // Create worktree with auto-create branch
+      const wt = await manager.createWorktree(name, true);
+      worktreePath = wt.path;
+      workingDir = wt.path;
+
+      console.log(`✅ Worktree created at ${worktreePath}`);
+    }
+
+    // Create session
+    const session = await tmux.createSession(name);
+    if (!session) {
+      console.error(`❌ Failed to create session "${name}"`);
+      process.exit(1);
+    }
+
+    // Change to working directory
+    await tmux.executeTmux(`send-keys -t '${name}' 'cd ${workingDir}' Enter`);
+
+    // Save metadata for cleanup (if worktree was created)
+    if (worktreePath) {
+      await saveSessionMetadata(name, { worktreePath, workspace: options.workspace });
+    }
+
+    console.log(`✅ Session "${name}" created`);
+    if (workingDir !== process.cwd()) {
+      console.log(`   Working directory: ${workingDir}`);
+    }
+    console.log(`\nTo attach: term attach ${name}`);
+  } catch (error: any) {
+    console.error(`❌ Error creating session: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/pane.ts

@@ -0,0 +1,81 @@
+import * as tmux from '../lib/tmux.js';
+
+export interface PaneListOptions {
+  json?: boolean;
+}
+
+export async function listPanes(session: string, options: PaneListOptions = {}): Promise<void> {
+  try {
+    // Find session by name first
+    const sessionObj = await tmux.findSessionByName(session);
+    if (!sessionObj) {
+      console.error(`Session "${session}" not found`);
+      process.exit(1);
+    }
+
+    // Get all windows in session
+    const windows = await tmux.listWindows(sessionObj.id);
+    if (windows.length === 0) {
+      if (options.json) {
+        console.log('[]');
+      } else {
+        console.log('No panes found');
+      }
+      return;
+    }
+
+    // Collect all panes from all windows
+    const allPanes: Array<{
+      id: string;
+      windowId: string;
+      windowName: string;
+      title: string;
+      active: boolean;
+    }> = [];
+
+    for (const window of windows) {
+      const panes = await tmux.listPanes(window.id);
+      for (const pane of panes) {
+        allPanes.push({
+          id: pane.id,
+          windowId: window.id,
+          windowName: window.name,
+          title: pane.title,
+          active: pane.active,
+        });
+      }
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(allPanes, null, 2));
+      return;
+    }
+
+    if (allPanes.length === 0) {
+      console.log('No panes found');
+      return;
+    }
+
+    console.log('PANE ID\t\tWINDOW\t\t\tTITLE\t\t\tACTIVE');
+    console.log('─'.repeat(80));
+
+    for (const pane of allPanes) {
+      const active = pane.active ? 'yes' : 'no';
+      const title = pane.title || '-';
+      console.log(`${pane.id}\t\t${pane.windowName}\t\t\t${title}\t\t\t${active}`);
+    }
+  } catch (error: any) {
+    console.error(`Error listing panes: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function removePane(paneId: string): Promise<void> {
+  try {
+    await tmux.killPane(paneId);
+    console.log(`Pane removed: ${paneId}`);
+  } catch (error: any) {
+    console.error(`Error removing pane: ${error.message}`);
+    process.exit(1);
+  }
+}