@automagik/genie 0.260202.530 → 0.260202.1833

package/src/lib/hooks/index.ts

@@ -1,163 +0,0 @@
-/**
- * Hook Preset Library
- *
- * Provides reusable hook configurations that can be composed
- * to enforce agent behaviors architecturally (without prompting).
- *
- * Usage:
- *   import { loadHooksFromConfig, presets, composeHooks } from './hooks';
- *
- *   // Load hooks based on genie config
- *   const hooks = await loadHooksFromConfig();
- *
- *   // Or compose manually
- *   const hooks = composeHooks(
- *     presets.collaborative(),
- *     presets.audited({ logPath: '~/.genie/audit.log' })
- *   );
- */
-
-import { loadGenieConfig } from '../genie-config.js';
-import type {
-  GenieConfig,
-  PresetName,
-  CollaborativeConfig,
-  SupervisedConfig,
-  SandboxedConfig,
-  AuditedConfig,
-} from '../../types/genie-config.js';
-
-// Re-export types
-export type { HookConfig, HookCallback, HookInput, HookOutput } from './presets/collaborative.js';
-
-// Re-export utilities
-export { mergeHooks, composeHooks, isEmptyHookConfig, countHooks } from './compose.js';
-export { escapeForSingleQuotes, escapeForDoubleQuotes, singleQuote, doubleQuote } from './utils/escape.js';
-
-// Import presets
-import { collaborativeHooks, type CollaborativeHookConfig } from './presets/collaborative.js';
-import { supervisedHooks, type SupervisedHookConfig } from './presets/supervised.js';
-import { sandboxedHooks, type SandboxedHookConfig } from './presets/sandboxed.js';
-import { auditedHooks, type AuditedHookConfig } from './presets/audited.js';
-
-// Re-export preset types
-export type { CollaborativeHookConfig } from './presets/collaborative.js';
-export type { SupervisedHookConfig } from './presets/supervised.js';
-export type { SandboxedHookConfig } from './presets/sandboxed.js';
-export type { AuditedHookConfig } from './presets/audited.js';
-
-// Import compose utilities
-import { composeHooks } from './compose.js';
-import type { HookConfig } from './presets/collaborative.js';
-
-/**
- * All available presets as functions
- */
-export const presets = {
-  collaborative: collaborativeHooks,
-  supervised: supervisedHooks,
-  sandboxed: sandboxedHooks,
-  audited: auditedHooks,
-} as const;
-
-/**
- * Preset factory type
- */
-export type PresetFactory = typeof presets[PresetName];
-
-/**
- * Load hooks from genie config file
- *
- * Reads ~/.genie/config.json and builds a combined hook configuration
- * from all enabled presets.
- *
- * @returns Combined hook configuration from all enabled presets
- */
-export async function loadHooksFromConfig(): Promise<HookConfig> {
-  const config = await loadGenieConfig();
-  return buildHooksFromConfig(config);
-}
-
-/**
- * Build hooks from a genie config object
- *
- * This is useful for testing or when you already have the config loaded.
- */
-export function buildHooksFromConfig(config: GenieConfig): HookConfig {
-  const enabledPresets = config.hooks.enabled;
-
-  if (enabledPresets.length === 0) {
-    return {};
-  }
-
-  const hookConfigs: HookConfig[] = [];
-
-  for (const presetName of enabledPresets) {
-    const presetConfig = config.hooks[presetName] || {};
-    const presetFactory = presets[presetName];
-
-    if (presetFactory) {
-      hookConfigs.push(presetFactory(presetConfig as any));
-    }
-  }
-
-  return composeHooks(...hookConfigs);
-}
-
-/**
- * Get a human-readable description of the enabled hooks
- */
-export function describeEnabledHooks(config: GenieConfig): string[] {
-  const descriptions: string[] = [];
-
-  for (const presetName of config.hooks.enabled) {
-    switch (presetName) {
-      case 'collaborative': {
-        const collabConfig: Partial<CollaborativeConfig> = config.hooks.collaborative || {};
-        const session = collabConfig.sessionName || 'genie';
-        const window = collabConfig.windowName || 'shell';
-        descriptions.push(`Collaborative: Bash → term exec ${session}:${window}`);
-        break;
-      }
-      case 'supervised': {
-        const supervisedConfig: Partial<SupervisedConfig> = config.hooks.supervised || {};
-        const tools = supervisedConfig.alwaysAsk || ['Write', 'Edit'];
-        descriptions.push(`Supervised: ${tools.join(', ')} require approval`);
-        break;
-      }
-      case 'sandboxed': {
-        const sandboxConfig: Partial<SandboxedConfig> = config.hooks.sandboxed || {};
-        const paths = sandboxConfig.allowedPaths || ['~/projects', '/tmp'];
-        descriptions.push(`Sandboxed: Restricted to ${paths.join(', ')}`);
-        break;
-      }
-      case 'audited': {
-        const auditConfig: Partial<AuditedConfig> = config.hooks.audited || {};
-        const logPath = auditConfig.logPath || '~/.genie/audit.log';
-        descriptions.push(`Audited: Logging to ${logPath}`);
-        break;
-      }
-    }
-  }
-
-  return descriptions;
-}
-
-/**
- * Check if any hooks are enabled
- */
-export function hasEnabledHooks(config: GenieConfig): boolean {
-  return config.hooks.enabled.length > 0;
-}
-
-/**
- * Parse hook names from a comma-separated string
- */
-export function parseHookNames(input: string): PresetName[] {
-  const validPresets: PresetName[] = ['collaborative', 'supervised', 'sandboxed', 'audited'];
-  const names = input.split(',').map((s) => s.trim().toLowerCase());
-
-  return names.filter((name): name is PresetName =>
-    validPresets.includes(name as PresetName)
-  );
-}

package/src/lib/hooks/presets/audited.ts

@@ -1,191 +0,0 @@
-/**
- * Audited Hook Preset
- *
- * Logs all tool executions to a file for later review.
- * Uses PostToolUse hooks to capture tool inputs and outputs.
- *
- * Usage:
- *   const hooks = auditedHooks({ logPath: '~/.genie/audit.log' });
- */
-
-import { appendFileSync, mkdirSync, existsSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { homedir } from 'os';
-import type { AuditedConfig } from '../../../types/genie-config.js';
-import type { HookConfig, HookInput, HookOutput } from './collaborative.js';
-
-export interface AuditedHookConfig {
-  logPath: string;
-}
-
-/**
- * Default configuration for audited hooks
- */
-export const DEFAULT_AUDITED_CONFIG: AuditedHookConfig = {
-  logPath: '~/.genie/audit.log',
-};
-
-/**
- * Expand ~ to home directory
- */
-function expandTilde(path: string): string {
-  if (path.startsWith('~/')) {
-    return homedir() + path.slice(1);
-  }
-  if (path === '~') {
-    return homedir();
-  }
-  return path;
-}
-
-/**
- * Format a tool input/output for logging
- * Truncates very long values to avoid log bloat
- */
-function formatForLog(value: unknown, maxLength: number = 1000): string {
-  try {
-    const str = JSON.stringify(value);
-    if (str.length > maxLength) {
-      return str.slice(0, maxLength) + '...[truncated]';
-    }
-    return str;
-  } catch {
-    return String(value);
-  }
-}
-
-/**
- * Audit log entry
- */
-interface AuditEntry {
-  timestamp: string;
-  tool: string;
-  input: unknown;
-  response?: unknown;
-  duration_ms?: number;
-}
-
-/**
- * Append an entry to the audit log
- */
-function appendToLog(logPath: string, entry: AuditEntry): void {
-  const expandedPath = resolve(expandTilde(logPath));
-  const dir = dirname(expandedPath);
-
-  // Ensure directory exists
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-
-  const logLine = JSON.stringify({
-    ...entry,
-    input: formatForLog(entry.input),
-    response: entry.response ? formatForLog(entry.response) : undefined,
-  }) + '\n';
-
-  appendFileSync(expandedPath, logLine, 'utf-8');
-}
-
-// Track tool start times for duration calculation
-const toolStartTimes = new Map<string, number>();
-
-/**
- * Create audited hooks configuration
- *
- * This hook captures all tool executions using PostToolUse hooks and
- * logs them to a file in JSONL format for later review.
- */
-export function auditedHooks(config: Partial<AuditedConfig> = {}): HookConfig {
-  const logPath = config.logPath || DEFAULT_AUDITED_CONFIG.logPath;
-
-  return {
-    PreToolUse: [
-      {
-        // Match all tools
-        matcher: /.*/,
-        timeout: 10,
-        hooks: [
-          async (input: HookInput, toolUseID, _options): Promise<HookOutput> => {
-            // Record start time for duration calculation
-            if (toolUseID) {
-              toolStartTimes.set(toolUseID, Date.now());
-            }
-            return { continue: true };
-          },
-        ],
-      },
-    ],
-    PostToolUse: [
-      {
-        // Match all tools
-        matcher: /.*/,
-        timeout: 10,
-        hooks: [
-          async (input: HookInput, toolUseID, _options): Promise<HookOutput> => {
-            // Type guard - only process PostToolUse events
-            if (input.hook_event_name !== 'PostToolUse') {
-              return { continue: true };
-            }
-
-            // Calculate duration if we have a start time
-            let duration_ms: number | undefined;
-            if (toolUseID && toolStartTimes.has(toolUseID)) {
-              duration_ms = Date.now() - toolStartTimes.get(toolUseID)!;
-              toolStartTimes.delete(toolUseID);
-            }
-
-            const entry: AuditEntry = {
-              timestamp: new Date().toISOString(),
-              tool: input.tool_name || 'unknown',
-              input: input.tool_input,
-              response: input.tool_response,
-              duration_ms,
-            };
-
-            try {
-              appendToLog(logPath, entry);
-            } catch (error) {
-              // Don't fail the tool call if logging fails
-              console.warn(`Audit log warning: ${error}`);
-            }
-
-            return { continue: true };
-          },
-        ],
-      },
-    ],
-  };
-}
-
-/**
- * Read the audit log as an array of entries
- * Useful for analysis and review
- */
-export function readAuditLog(logPath: string = DEFAULT_AUDITED_CONFIG.logPath): AuditEntry[] {
-  const expandedPath = resolve(expandTilde(logPath));
-
-  if (!existsSync(expandedPath)) {
-    return [];
-  }
-
-  const { readFileSync } = require('fs');
-  const content = readFileSync(expandedPath, 'utf-8');
-  const lines = content.trim().split('\n').filter(Boolean);
-
-  return lines.map((line: string) => {
-    try {
-      return JSON.parse(line);
-    } catch {
-      return { error: 'parse_failed', raw: line };
-    }
-  });
-}
-
-/**
- * Clear the audit log
- */
-export function clearAuditLog(logPath: string = DEFAULT_AUDITED_CONFIG.logPath): void {
-  const expandedPath = resolve(expandTilde(logPath));
-  const { writeFileSync } = require('fs');
-  writeFileSync(expandedPath, '', 'utf-8');
-}

package/src/lib/hooks/presets/collaborative.ts

@@ -1,143 +0,0 @@
-/**
- * Collaborative Hook Preset
- *
- * Makes all terminal operations human-observable via tmux.
- * Intercepts Bash tool calls and rewrites them to go through `term exec`.
- *
- * Usage:
- *   const hooks = collaborativeHooks({ sessionName: 'genie', windowName: 'shell' });
- */
-
-import type { CollaborativeConfig } from '../../../types/genie-config.js';
-import { escapeForSingleQuotes } from '../utils/escape.js';
-
-export interface CollaborativeHookConfig {
-  sessionName: string;
-  windowName: string;
-}
-
-/**
- * Default configuration for collaborative hooks
- */
-export const DEFAULT_COLLABORATIVE_CONFIG: CollaborativeHookConfig = {
-  sessionName: 'genie',
-  windowName: 'shell',
-};
-
-/**
- * Create collaborative hooks configuration
- *
- * This hook intercepts all Bash tool calls and rewrites them to execute
- * through `term exec <session>:<window> '<command>'`, making all terminal
- * operations visible in a tmux session that humans can attach to.
- */
-export function collaborativeHooks(config: Partial<CollaborativeConfig> = {}): HookConfig {
-  const sessionName = config.sessionName || DEFAULT_COLLABORATIVE_CONFIG.sessionName;
-  const windowName = config.windowName || DEFAULT_COLLABORATIVE_CONFIG.windowName;
-  const target = `${sessionName}:${windowName}`;
-
-  return {
-    PreToolUse: [
-      {
-        matcher: 'Bash',
-        timeout: 30,
-        hooks: [
-          async (input, _toolUseID, _options) => {
-            // Type guard - only process PreToolUse events
-            if (input.hook_event_name !== 'PreToolUse') {
-              return { continue: true };
-            }
-
-            // Only intercept Bash tool
-            if (input.tool_name !== 'Bash') {
-              return { continue: true };
-            }
-
-            const bashInput = input.tool_input as {
-              command: string;
-              timeout?: number;
-              description?: string;
-              run_in_background?: boolean;
-            };
-
-            // Rewrite the command to go through term exec
-            const termCommand = `term exec ${target} '${escapeForSingleQuotes(bashInput.command)}'`;
-
-            // Create a brief description for the proxied command
-            const originalDesc = bashInput.description || bashInput.command.slice(0, 50);
-            const proxyDescription = `[term] ${originalDesc}${bashInput.command.length > 50 ? '...' : ''}`;
-
-            return {
-              continue: true,
-              hookSpecificOutput: {
-                hookEventName: 'PreToolUse',
-                updatedInput: {
-                  command: termCommand,
-                  timeout: bashInput.timeout,
-                  description: proxyDescription,
-                  run_in_background: bashInput.run_in_background,
-                },
-                permissionDecision: 'allow',
-                additionalContext: `Human can observe: tmux attach -t ${sessionName}`,
-              },
-            };
-          },
-        ],
-      },
-    ],
-  };
-}
-
-/**
- * HookConfig type matching the Claude Agent SDK hook configuration
- */
-export interface HookConfig {
-  PreToolUse?: Array<{
-    matcher: string | RegExp;
-    timeout?: number;
-    hooks: Array<HookCallback>;
-  }>;
-  PostToolUse?: Array<{
-    matcher?: string | RegExp;
-    timeout?: number;
-    hooks: Array<HookCallback>;
-  }>;
-  PermissionRequest?: Array<{
-    timeout?: number;
-    hooks: Array<HookCallback>;
-  }>;
-}
-
-/**
- * Hook input types
- */
-export interface HookInput {
-  hook_event_name: string;
-  tool_name?: string;
-  tool_input?: unknown;
-  tool_response?: unknown;
-}
-
-/**
- * Hook callback type
- */
-export type HookCallback = (
-  input: HookInput,
-  toolUseID: string | undefined,
-  options: { signal: AbortSignal }
-) => Promise<HookOutput>;
-
-/**
- * Hook output type
- */
-export interface HookOutput {
-  continue: boolean;
-  hookSpecificOutput?: {
-    hookEventName: string;
-    updatedInput?: unknown;
-    permissionDecision?: 'allow' | 'deny' | 'ask';
-    permissionDecisionReason?: string;
-    additionalContext?: string;
-    decision?: { behavior: 'allow' | 'deny' | 'ask' };
-  };
-}

package/src/lib/hooks/presets/sandboxed.ts

@@ -1,153 +0,0 @@
-/**
- * Sandboxed Hook Preset
- *
- * Restricts file operations to specific directories.
- * Intercepts PreToolUse events for file-related tools and denies operations
- * outside the allowed paths.
- *
- * Usage:
- *   const hooks = sandboxedHooks({ allowedPaths: ['~/projects', '/tmp'] });
- */
-
-import { resolve, normalize } from 'path';
-import { homedir } from 'os';
-import type { SandboxedConfig } from '../../../types/genie-config.js';
-import type { HookConfig, HookInput, HookOutput } from './collaborative.js';
-
-export interface SandboxedHookConfig {
-  allowedPaths: string[];
-}
-
-/**
- * Default configuration for sandboxed hooks
- */
-export const DEFAULT_SANDBOXED_CONFIG: SandboxedHookConfig = {
-  allowedPaths: ['~/projects', '/tmp'],
-};
-
-/**
- * Tools that access files
- */
-const FILE_TOOLS = ['Read', 'Write', 'Edit', 'Glob', 'Grep'];
-
-/**
- * Expand ~ to home directory
- */
-function expandTilde(path: string): string {
-  if (path.startsWith('~/')) {
-    return homedir() + path.slice(1);
-  }
-  if (path === '~') {
-    return homedir();
-  }
-  return path;
-}
-
-/**
- * Normalize and resolve a path, expanding ~
- */
-function normalizePath(path: string): string {
-  return normalize(resolve(expandTilde(path)));
-}
-
-/**
- * Check if a path is within any of the allowed paths
- */
-function isWithinAllowed(targetPath: string, allowedPaths: string[]): boolean {
-  const normalizedTarget = normalizePath(targetPath);
-
-  for (const allowed of allowedPaths) {
-    const normalizedAllowed = normalizePath(allowed);
-
-    // Check if target is within or equal to allowed path
-    if (
-      normalizedTarget === normalizedAllowed ||
-      normalizedTarget.startsWith(normalizedAllowed + '/')
-    ) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Extract the path from tool input
- */
-function extractPath(toolName: string, toolInput: unknown): string | null {
-  const input = toolInput as Record<string, unknown>;
-
-  switch (toolName) {
-    case 'Read':
-    case 'Write':
-    case 'Edit':
-      return (input.file_path as string) || null;
-    case 'Glob':
-      return (input.path as string) || process.cwd();
-    case 'Grep':
-      return (input.path as string) || process.cwd();
-    default:
-      return null;
-  }
-}
-
-/**
- * Create sandboxed hooks configuration
- *
- * This hook intercepts PreToolUse events for file-related tools and
- * denies operations on paths outside the allowed directories.
- */
-export function sandboxedHooks(config: Partial<SandboxedConfig> = {}): HookConfig {
-  const allowedPaths = config.allowedPaths || DEFAULT_SANDBOXED_CONFIG.allowedPaths;
-
-  // Create a regex pattern that matches all file tools
-  const fileToolPattern = new RegExp(`^(${FILE_TOOLS.join('|')})$`);
-
-  return {
-    PreToolUse: [
-      {
-        matcher: fileToolPattern,
-        timeout: 30,
-        hooks: [
-          async (input: HookInput, _toolUseID, _options): Promise<HookOutput> => {
-            // Type guard - only process PreToolUse events
-            if (input.hook_event_name !== 'PreToolUse') {
-              return { continue: true };
-            }
-
-            const toolName = input.tool_name;
-            if (!toolName || !FILE_TOOLS.includes(toolName)) {
-              return { continue: true };
-            }
-
-            const targetPath = extractPath(toolName, input.tool_input);
-
-            // If we can't extract a path, allow the operation
-            // (better to be permissive than block valid operations)
-            if (!targetPath) {
-              return { continue: true };
-            }
-
-            // Check if path is within allowed directories
-            if (!isWithinAllowed(targetPath, allowedPaths)) {
-              const allowedDisplay = allowedPaths.map((p) =>
-                p.startsWith('~') ? p : expandTilde(p)
-              ).join(', ');
-
-              return {
-                continue: false,
-                hookSpecificOutput: {
-                  hookEventName: 'PreToolUse',
-                  permissionDecision: 'deny',
-                  permissionDecisionReason: `Path "${targetPath}" is outside the sandbox. Allowed paths: ${allowedDisplay}`,
-                },
-              };
-            }
-
-            return { continue: true };
-          },
-        ],
-      },
-    ],
-  };
-}