@automagik/genie 0.260201.2240

package/src/term-commands/status.ts

@@ -0,0 +1,116 @@
+import * as tmux from '../lib/tmux.js';
+
+export interface StatusOptions {
+  command?: string;
+  json?: boolean;
+}
+
+interface SessionStatus {
+  session: string;
+  id: string;
+  attached: boolean;
+  windows: number;
+  panes: number;
+  state: 'idle' | 'busy';
+}
+
+interface CommandStatus {
+  id: string;
+  paneId: string;
+  command: string;
+  status: 'pending' | 'completed' | 'error';
+  exitCode?: number;
+  startTime: string;
+  result?: string;
+}
+
+export async function getStatus(session: string, options: StatusOptions = {}): Promise<void> {
+  try {
+    // If checking a specific command
+    if (options.command) {
+      await getCommandStatus(options.command, options.json);
+      return;
+    }
+
+    // Find session by name
+    const sessionObj = await tmux.findSessionByName(session);
+    if (!sessionObj) {
+      console.error(`Session "${session}" not found`);
+      process.exit(1);
+    }
+
+    // Get windows and panes
+    const windows = await tmux.listWindows(sessionObj.id);
+    let totalPanes = 0;
+
+    for (const window of windows) {
+      const panes = await tmux.listPanes(window.id);
+      totalPanes += panes.length;
+    }
+
+    // Determine state (simplified: idle if session exists, could be enhanced with activity detection)
+    const state: 'idle' | 'busy' = 'idle';
+
+    const status: SessionStatus = {
+      session: sessionObj.name,
+      id: sessionObj.id,
+      attached: sessionObj.attached,
+      windows: windows.length,
+      panes: totalPanes,
+      state,
+    };
+
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+
+    console.log(`Session: ${status.session}`);
+    console.log(`ID: ${status.id}`);
+    console.log(`Attached: ${status.attached ? 'yes' : 'no'}`);
+    console.log(`Windows: ${status.windows}`);
+    console.log(`Panes: ${status.panes}`);
+    console.log(`State: ${status.state}`);
+  } catch (error: any) {
+    console.error(`Error getting status: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function getCommandStatus(commandId: string, json?: boolean): Promise<void> {
+  try {
+    const result = await tmux.checkCommandStatus(commandId);
+
+    if (!result) {
+      console.error(`Command "${commandId}" not found`);
+      process.exit(1);
+    }
+
+    const status: CommandStatus = {
+      id: result.id,
+      paneId: result.paneId,
+      command: result.command,
+      status: result.status,
+      exitCode: result.exitCode,
+      startTime: result.startTime.toISOString(),
+      result: result.result,
+    };
+
+    if (json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+
+    console.log(`Command: ${status.id}`);
+    console.log(`Status: ${status.status}`);
+    console.log(`Exit Code: ${status.exitCode ?? 'N/A'}`);
+    console.log(`Start Time: ${status.startTime}`);
+
+    if (status.result) {
+      console.log(`\nOutput:\n${status.result}`);
+    }
+  } catch (error: any) {
+    console.error(`Error getting command status: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/window.ts

@@ -0,0 +1,72 @@
+import * as tmux from '../lib/tmux.js';
+
+export interface WindowListOptions {
+  json?: boolean;
+}
+
+export async function listWindows(session: string, options: WindowListOptions = {}): 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);
+    }
+
+    const windows = await tmux.listWindows(sessionObj.id);
+
+    if (options.json) {
+      console.log(JSON.stringify(windows, null, 2));
+      return;
+    }
+
+    if (windows.length === 0) {
+      console.log('No windows found');
+      return;
+    }
+
+    console.log('WINDOW ID\t\tNAME\t\t\tACTIVE');
+    console.log('─'.repeat(60));
+
+    for (const window of windows) {
+      const active = window.active ? 'yes' : 'no';
+      console.log(`${window.id}\t\t${window.name}\t\t\t${active}`);
+    }
+  } catch (error: any) {
+    console.error(`Error listing windows: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function createWindow(session: string, name: string): 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);
+    }
+
+    const window = await tmux.createWindow(sessionObj.id, name);
+
+    if (window) {
+      console.log(`Window created: ${window.id}`);
+    } else {
+      console.error('Failed to create window');
+      process.exit(1);
+    }
+  } catch (error: any) {
+    console.error(`Error creating window: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function removeWindow(windowId: string): Promise<void> {
+  try {
+    await tmux.killWindow(windowId);
+    console.log(`Window removed: ${windowId}`);
+  } catch (error: any) {
+    console.error(`Error removing window: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander';
+import * as newCmd from './term-commands/new.js';
+import * as lsCmd from './term-commands/ls.js';
+import * as attachCmd from './term-commands/attach.js';
+import * as rmCmd from './term-commands/rm.js';
+import * as readCmd from './term-commands/read.js';
+import * as execCmd from './term-commands/exec.js';
+import * as sendCmd from './term-commands/send.js';
+import * as splitCmd from './term-commands/split.js';
+import * as hookCmd from './term-commands/hook.js';
+import * as windowCmd from './term-commands/window.js';
+import * as paneCmd from './term-commands/pane.js';
+import * as statusCmd from './term-commands/status.js';
+import * as shortcutsCmd from './term-commands/shortcuts.js';
+
+const program = new Command();
+
+program
+  .name('term')
+  .description(`AI-friendly terminal orchestration (tmux wrapper)
+
+Workflow: new → exec → read → rm
+Full control: window new/ls/rm, pane ls/rm, split, status`)
+  .version('0.2.0');
+
+// Session management
+program
+  .command('new <name>')
+  .description('Create a new tmux session')
+  .option('-d, --workspace <path>', 'Working directory for the session')
+  .option('-w, --worktree', 'Create git worktree in .worktrees/<name>/')
+  .action(async (name: string, options: { workspace?: string; worktree?: boolean }) => {
+    await newCmd.createNewSession(name, options);
+  });
+
+program
+  .command('ls')
+  .description('List all tmux sessions')
+  .option('--json', 'Output as JSON')
+  .action(async (options: { json?: boolean }) => {
+    await lsCmd.listAllSessions(options);
+  });
+
+program
+  .command('attach <name>')
+  .description('Attach to a tmux session')
+  .action(async (name: string) => {
+    await attachCmd.attachToSession(name);
+  });
+
+program
+  .command('rm <name>')
+  .description('Remove a tmux session')
+  .option('--keep-worktree', 'Keep worktree folder when removing session')
+  .action(async (name: string, options: { keepWorktree?: boolean }) => {
+    await rmCmd.removeSession(name, options);
+  });
+
+// Log reading (CRITICAL for AI orchestration)
+program
+  .command('read <session>')
+  .description('Read logs from a tmux session')
+  .option('-n, --lines <number>', 'Number of lines to read (default: 100)', '100')
+  .option('--from <line>', 'Start line number')
+  .option('--to <line>', 'End line number')
+  .option('--range <range>', 'Line range (e.g., 100:200)')
+  .option('--search <pattern>', 'Search for pattern')
+  .option('--grep <pattern>', 'Regex search pattern')
+  .option('-f, --follow', 'Follow mode (live tail)')
+  .option('--all', 'Export entire scrollback buffer')
+  .option('--reverse', 'Reverse chronological (newest first)')
+  .option('--json', 'Output as JSON')
+  .action(async (session: string, options: readCmd.ReadOptions) => {
+    await readCmd.readSessionLogs(session, options);
+  });
+
+// Command execution
+program
+  .command('exec <session> <command...>')
+  .description('Execute command in a tmux session')
+  .action(async (session: string, command: string[]) => {
+    await execCmd.executeInSession(session, command.join(' '));
+  });
+
+program
+  .command('send <session> <keys>')
+  .description('Send raw keys to a tmux session')
+  .action(async (session: string, keys: string) => {
+    await sendCmd.sendKeysToSession(session, keys);
+  });
+
+// Pane splitting
+program
+  .command('split <session> [direction]')
+  .description('Split pane in a tmux session (h=horizontal, v=vertical)')
+  .option('-d, --workspace <path>', 'Working directory for the new pane')
+  .option('-w, --worktree <branch>', 'Create git worktree in .worktrees/<branch>/')
+  .action(async (session: string, direction: string | undefined, options: { workspace?: string; worktree?: string }) => {
+    await splitCmd.splitSessionPane(session, direction, options);
+  });
+
+// Status command
+program
+  .command('status <session>')
+  .description('Check session state (idle/busy, pane count)')
+  .option('--command <id>', 'Check specific command status')
+  .option('--json', 'Output as JSON')
+  .action(async (session: string, options: statusCmd.StatusOptions) => {
+    await statusCmd.getStatus(session, options);
+  });
+
+// Window management
+const windowProgram = program.command('window').description('Manage tmux windows');
+
+windowProgram
+  .command('new <session> <name>')
+  .description('Create a new window in session')
+  .action(async (session: string, name: string) => {
+    await windowCmd.createWindow(session, name);
+  });
+
+windowProgram
+  .command('ls <session>')
+  .description('List windows in session')
+  .option('--json', 'Output as JSON')
+  .action(async (session: string, options: { json?: boolean }) => {
+    await windowCmd.listWindows(session, options);
+  });
+
+windowProgram
+  .command('rm <window-id>')
+  .description('Remove window by ID')
+  .action(async (windowId: string) => {
+    await windowCmd.removeWindow(windowId);
+  });
+
+// Pane management
+const paneProgram = program.command('pane').description('Manage tmux panes');
+
+paneProgram
+  .command('ls <session>')
+  .description('List all panes in session')
+  .option('--json', 'Output as JSON')
+  .action(async (session: string, options: { json?: boolean }) => {
+    await paneCmd.listPanes(session, options);
+  });
+
+paneProgram
+  .command('rm <pane-id>')
+  .description('Remove pane by ID')
+  .action(async (paneId: string) => {
+    await paneCmd.removePane(paneId);
+  });
+
+// Hook management
+const hookProgram = program.command('hook').description('Manage tmux hooks');
+
+hookProgram
+  .command('set <event> <command>')
+  .description('Set a tmux hook')
+  .action(async (event: string, command: string) => {
+    await hookCmd.setHook(event, command);
+  });
+
+hookProgram
+  .command('list')
+  .description('List all tmux hooks')
+  .action(async () => {
+    await hookCmd.listHooks();
+  });
+
+hookProgram
+  .command('rm <event>')
+  .description('Remove a tmux hook')
+  .action(async (event: string) => {
+    await hookCmd.removeHook(event);
+  });
+
+// Shortcuts command
+program
+  .command('shortcuts')
+  .description('Warp-like keyboard shortcuts for tmux/Termux')
+  .option('--tmux', 'Output tmux.conf snippet')
+  .option('--termux', 'Output termux.properties snippet')
+  .option('--install', 'Install to config files (interactive)')
+  .action(async (options: shortcutsCmd.ShortcutsOptions) => {
+    await shortcutsCmd.handleShortcuts(options);
+  });
+
+program.parse();

package/src/types/config.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export const ProfileSchema = z.object({
+  opus: z.string(),
+  sonnet: z.string(),
+  haiku: z.string(),
+});
+
+export const ConfigSchema = z.object({
+  apiUrl: z.string().url(),
+  apiKey: z.string().min(1),
+  defaultProfile: z.string().optional(),
+  profiles: z.record(ProfileSchema),
+});
+
+export type Profile = z.infer<typeof ProfileSchema>;
+export type Config = z.infer<typeof ConfigSchema>;

package/src/types/genie-config.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+
+/**
+ * Genie Configuration Schema
+ *
+ * Stored at ~/.genie/config.json
+ * Manages hook presets and session configuration for the genie CLI.
+ */
+
+// Sandboxed preset configuration
+export const SandboxedConfigSchema = z.object({
+  allowedPaths: z.array(z.string()).default(['~/projects', '/tmp']),
+});
+
+// Audited preset configuration
+export const AuditedConfigSchema = z.object({
+  logPath: z.string().default('~/.genie/audit.log'),
+});
+
+// Supervised preset configuration
+export const SupervisedConfigSchema = z.object({
+  alwaysAsk: z.array(z.string()).default(['Write', 'Edit']),
+});
+
+// Collaborative preset configuration
+export const CollaborativeConfigSchema = z.object({
+  sessionName: z.string().default('genie'),
+  windowName: z.string().default('shell'),
+});
+
+// Hook presets configuration
+export const HooksConfigSchema = z.object({
+  enabled: z.array(z.enum(['collaborative', 'supervised', 'sandboxed', 'audited'])).default([]),
+  collaborative: CollaborativeConfigSchema.optional(),
+  supervised: SupervisedConfigSchema.optional(),
+  sandboxed: SandboxedConfigSchema.optional(),
+  audited: AuditedConfigSchema.optional(),
+});
+
+// Session configuration
+export const SessionConfigSchema = z.object({
+  name: z.string().default('genie'),
+  defaultWindow: z.string().default('shell'),
+});
+
+// Full genie configuration
+export const GenieConfigSchema = z.object({
+  hooks: HooksConfigSchema.default({}),
+  session: SessionConfigSchema.default({}),
+});
+
+// Inferred types
+export type SandboxedConfig = z.infer<typeof SandboxedConfigSchema>;
+export type AuditedConfig = z.infer<typeof AuditedConfigSchema>;
+export type SupervisedConfig = z.infer<typeof SupervisedConfigSchema>;
+export type CollaborativeConfig = z.infer<typeof CollaborativeConfigSchema>;
+export type HooksConfig = z.infer<typeof HooksConfigSchema>;
+export type SessionConfig = z.infer<typeof SessionConfigSchema>;
+export type GenieConfig = z.infer<typeof GenieConfigSchema>;
+
+// Preset names type
+export type PresetName = 'collaborative' | 'supervised' | 'sandboxed' | 'audited';
+
+// Preset description for UI
+export interface PresetDescription {
+  name: PresetName;
+  title: string;
+  what: string;
+  why: string;
+  how: string;
+  recommended?: boolean;
+}
+
+export const PRESET_DESCRIPTIONS: PresetDescription[] = [
+  {
+    name: 'collaborative',
+    title: 'Collaborative',
+    what: 'All terminal commands run through tmux',
+    why: 'You can watch AI work in real-time',
+    how: 'Bash commands → term exec genie:shell',
+    recommended: true,
+  },
+  {
+    name: 'supervised',
+    title: 'Supervised',
+    what: 'File changes require your approval',
+    why: 'Prevents accidental overwrites',
+    how: 'Write/Edit tools always ask permission',
+  },
+  {
+    name: 'sandboxed',
+    title: 'Sandboxed',
+    what: 'Restrict file access to specific directories',
+    why: 'Protects sensitive areas of your system',
+    how: 'Operations outside sandbox are blocked',
+  },
+  {
+    name: 'audited',
+    title: 'Audited',
+    what: 'Log all AI tool usage to a file',
+    why: 'Review what the AI did after a session',
+    how: 'Every tool call → ~/.genie/audit.log',
+  },
+];

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["bun"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}