genesis-ai-cli 7.4.5

package/dist/src/subagents/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Genesis v7.4 - Subagent System
+ *
+ * Parallel subprocess execution for complex tasks.
+ * Equivalent to Claude Code's Task tool.
+ *
+ * Usage:
+ * ```typescript
+ * import { getSubagentExecutor, TaskRequest } from './subagents/index.js';
+ *
+ * const executor = getSubagentExecutor();
+ *
+ * // Synchronous execution
+ * const result = await executor.execute({
+ *   description: 'Find auth handlers',
+ *   prompt: 'Search for authentication handling code',
+ *   subagentType: 'explore',
+ * });
+ *
+ * // Background execution
+ * const taskId = await executor.executeBackground({
+ *   description: 'Research OAuth patterns',
+ *   prompt: 'Find best practices for OAuth2 implementation',
+ *   subagentType: 'research',
+ *   runInBackground: true,
+ * });
+ *
+ * // Check status
+ * const task = executor.getTask(taskId);
+ *
+ * // Wait for completion
+ * const result = await executor.waitForTask(taskId);
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./registry.js"), exports);
+__exportStar(require("./executor.js"), exports);

package/dist/src/subagents/registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Genesis v7.4 - Subagent Registry
+ *
+ * Built-in subagent definitions for specialized tasks.
+ */
+import { SubagentDefinition, SubagentType } from './types.js';
+export declare const BUILTIN_SUBAGENTS: Record<SubagentType, SubagentDefinition>;
+/**
+ * Get a subagent definition by name
+ */
+export declare function getSubagent(name: string): SubagentDefinition | undefined;
+/**
+ * Register a custom subagent
+ */
+export declare function registerSubagent(definition: SubagentDefinition): void;
+/**
+ * List all available subagents
+ */
+export declare function listSubagents(): SubagentDefinition[];
+/**
+ * Get subagent names
+ */
+export declare function getSubagentNames(): string[];

package/dist/src/subagents/registry.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Genesis v7.4 - Subagent Registry
+ *
+ * Built-in subagent definitions for specialized tasks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_SUBAGENTS = void 0;
+exports.getSubagent = getSubagent;
+exports.registerSubagent = registerSubagent;
+exports.listSubagents = listSubagents;
+exports.getSubagentNames = getSubagentNames;
+// ============================================================================
+// Built-in Subagent Definitions
+// ============================================================================
+exports.BUILTIN_SUBAGENTS = {
+    explore: {
+        name: 'explore',
+        description: 'Fast codebase exploration - read-only, quick searches',
+        systemPrompt: `You are an exploration agent. Your job is to quickly find information in codebases.
+
+RULES:
+- READ-ONLY: Never modify files
+- Be FAST: Use glob/grep efficiently, don't read entire files unless necessary
+- Be THOROUGH: Search multiple patterns, check related files
+- SUMMARIZE: Return concise, actionable findings
+
+WORKFLOW:
+1. Understand what's being searched for
+2. Use glob to find candidate files
+3. Use grep to search content
+4. Read relevant sections only
+5. Summarize findings with file:line references`,
+        tools: ['glob', 'grep', 'read', 'bash'],
+        disallowedTools: ['write', 'edit', 'git_commit', 'git_push'],
+        model: 'fast',
+        maxTokens: 4096,
+        timeout: 60000, // 1 minute
+    },
+    plan: {
+        name: 'plan',
+        description: 'Architecture planning - design implementation strategies',
+        systemPrompt: `You are a planning agent. Your job is to design implementation strategies.
+
+RULES:
+- THINK DEEPLY: Consider architecture, patterns, trade-offs
+- READ FIRST: Understand existing code before planning
+- BE SPECIFIC: Include file paths, function signatures, data structures
+- NO IMPLEMENTATION: Only plan, never write code
+
+OUTPUT FORMAT:
+1. Current State Analysis
+2. Proposed Changes (with file:line references)
+3. Implementation Steps (ordered)
+4. Risks and Mitigations
+5. Testing Strategy`,
+        tools: ['glob', 'grep', 'read', 'bash'],
+        disallowedTools: ['write', 'edit', 'git_commit', 'git_push'],
+        model: 'powerful',
+        maxTokens: 8192,
+        timeout: 180000, // 3 minutes
+    },
+    code: {
+        name: 'code',
+        description: 'Code generation - write and modify code',
+        systemPrompt: `You are a coding agent. Your job is to write and modify code.
+
+RULES:
+- QUALITY: Write clean, tested, documented code
+- MINIMAL: Only change what's necessary
+- SAFE: Never delete without backup, use atomic operations
+- VERIFY: Check your changes compile/lint
+
+WORKFLOW:
+1. Read existing code to understand context
+2. Plan changes (small, incremental)
+3. Make edits using edit tool (old_string → new_string)
+4. Verify changes work`,
+        tools: ['glob', 'grep', 'read', 'write', 'edit', 'bash'],
+        disallowedTools: ['git_push'], // Require explicit push
+        model: 'balanced',
+        maxTokens: 8192,
+        timeout: 300000, // 5 minutes
+    },
+    research: {
+        name: 'research',
+        description: 'Web/paper research - find external information',
+        systemPrompt: `You are a research agent. Your job is to find information from external sources.
+
+RULES:
+- COMPREHENSIVE: Check multiple sources
+- CITE: Always include source URLs
+- SUMMARIZE: Distill key findings
+- VERIFY: Cross-reference claims
+
+SOURCES:
+- brave_web_search: General web search
+- web_search_exa: Technical content
+- search_arxiv: Academic papers
+- search_semantic_scholar: Paper metadata
+- query-docs: Library documentation`,
+        tools: [
+            'brave_web_search', 'web_search_exa', 'firecrawl_scrape',
+            'search_arxiv', 'parse_paper_content', 'search_semantic_scholar',
+            'resolve-library-id', 'query-docs'
+        ],
+        disallowedTools: ['write', 'edit', 'bash'],
+        model: 'balanced',
+        maxTokens: 8192,
+        timeout: 180000, // 3 minutes
+    },
+    general: {
+        name: 'general',
+        description: 'General-purpose - complex multi-step tasks',
+        systemPrompt: `You are a general-purpose agent. Handle complex, multi-step tasks autonomously.
+
+RULES:
+- AUTONOMOUS: Work independently without asking questions
+- THOROUGH: Complete the entire task
+- REPORT: Summarize what you did and results
+
+You have access to all tools. Use them wisely.`,
+        tools: ['*'], // All tools
+        model: 'powerful',
+        maxTokens: 16384,
+        timeout: 600000, // 10 minutes
+    },
+};
+// ============================================================================
+// Registry Management
+// ============================================================================
+const customSubagents = new Map();
+/**
+ * Get a subagent definition by name
+ */
+function getSubagent(name) {
+    // Check built-in first
+    if (name in exports.BUILTIN_SUBAGENTS) {
+        return exports.BUILTIN_SUBAGENTS[name];
+    }
+    // Then custom
+    return customSubagents.get(name);
+}
+/**
+ * Register a custom subagent
+ */
+function registerSubagent(definition) {
+    customSubagents.set(definition.name, definition);
+}
+/**
+ * List all available subagents
+ */
+function listSubagents() {
+    return [
+        ...Object.values(exports.BUILTIN_SUBAGENTS),
+        ...customSubagents.values(),
+    ];
+}
+/**
+ * Get subagent names
+ */
+function getSubagentNames() {
+    return [
+        ...Object.keys(exports.BUILTIN_SUBAGENTS),
+        ...customSubagents.keys(),
+    ];
+}

package/dist/src/subagents/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Genesis v7.4 - Subagent System Types
+ *
+ * Enables parallel subprocess execution for complex tasks.
+ * Inspired by Claude Code's Task tool with specialized agents.
+ */
+/**
+ * Built-in subagent types
+ */
+export type SubagentType = 'explore' | 'plan' | 'code' | 'research' | 'general';
+/**
+ * Subagent definition
+ */
+export interface SubagentDefinition {
+    name: SubagentType | string;
+    description: string;
+    systemPrompt: string;
+    tools: string[];
+    disallowedTools?: string[];
+    model?: 'fast' | 'balanced' | 'powerful';
+    maxTokens?: number;
+    timeout?: number;
+}
+/**
+ * Task request to spawn a subagent
+ */
+export interface TaskRequest {
+    description: string;
+    prompt: string;
+    subagentType: SubagentType | string;
+    runInBackground?: boolean;
+    model?: 'fast' | 'balanced' | 'powerful';
+}
+/**
+ * Task result from subagent
+ */
+export interface TaskResult {
+    taskId: string;
+    subagentType: string;
+    success: boolean;
+    result?: string;
+    error?: string;
+    duration: number;
+    tokensUsed?: {
+        input: number;
+        output: number;
+    };
+}
+/**
+ * Background task status
+ */
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Background task tracking
+ */
+export interface BackgroundTask {
+    taskId: string;
+    description: string;
+    subagentType: string;
+    status: TaskStatus;
+    startTime: number;
+    endTime?: number;
+    result?: TaskResult;
+    output: string[];
+}
+export type SubagentEventType = 'task_start' | 'task_progress' | 'task_complete' | 'task_error' | 'task_cancelled';
+export interface SubagentEvent {
+    type: SubagentEventType;
+    taskId: string;
+    timestamp: Date;
+    data?: unknown;
+}
+export type SubagentEventHandler = (event: SubagentEvent) => void;
+export interface SubagentConfig {
+    maxConcurrent: number;
+    defaultTimeout: number;
+    outputBufferSize: number;
+}
+export declare const DEFAULT_SUBAGENT_CONFIG: SubagentConfig;

package/dist/src/subagents/types.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Genesis v7.4 - Subagent System Types
+ *
+ * Enables parallel subprocess execution for complex tasks.
+ * Inspired by Claude Code's Task tool with specialized agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SUBAGENT_CONFIG = void 0;
+exports.DEFAULT_SUBAGENT_CONFIG = {
+    maxConcurrent: 5,
+    defaultTimeout: 300000, // 5 minutes
+    outputBufferSize: 1000,
+};

package/dist/src/tools/bash.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Genesis Secure Bash Executor
+ *
+ * Provides sandboxed command execution with:
+ * - Command validation (whitelist/blacklist)
+ * - Dangerous pattern detection
+ * - Timeout enforcement
+ * - Working directory confinement
+ * - Output streaming
+ */
+import { ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
+export interface SandboxConfig {
+    /** Commands always allowed */
+    allowedCommands: string[];
+    /** Regex patterns to block */
+    blockedPatterns: RegExp[];
+    /** Max execution time in ms */
+    maxTimeout: number;
+    /** Confined working directory */
+    workingDirectory: string;
+    /** Allow network operations */
+    allowNetwork: boolean;
+    /** Allow file writes outside workingDirectory */
+    allowExternalWrites: boolean;
+    /** Max output buffer size in bytes */
+    maxOutputSize: number;
+}
+export interface BashOptions {
+    /** Command timeout in ms (default: 120000) */
+    timeout?: number;
+    /** Working directory override */
+    cwd?: string;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Run in background */
+    background?: boolean;
+    /** Description for logging */
+    description?: string;
+}
+export interface BashResult {
+    success: boolean;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    duration: number;
+    truncated: boolean;
+    killed: boolean;
+    error?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    reason?: string;
+    severity: 'safe' | 'warning' | 'blocked';
+    matchedPattern?: string;
+}
+export interface BackgroundTask {
+    id: string;
+    command: string;
+    process: ChildProcess;
+    startTime: number;
+    stdout: string;
+    stderr: string;
+    status: 'running' | 'completed' | 'failed' | 'killed';
+    exitCode?: number;
+}
+export declare const DEFAULT_SANDBOX_CONFIG: SandboxConfig;
+export declare class BashTool extends EventEmitter {
+    private config;
+    private backgroundTasks;
+    private taskCounter;
+    constructor(config?: Partial<SandboxConfig>);
+    /**
+     * Validate a command against security rules
+     */
+    validate(command: string): ValidationResult;
+    /**
+     * Extract the base command from a command string
+     */
+    private extractBaseCommand;
+    /**
+     * Execute a command with sandboxing
+     */
+    execute(command: string, options?: BashOptions): Promise<BashResult>;
+    /**
+     * Execute command synchronously
+     */
+    private executeSync;
+    /**
+     * Execute command in background
+     */
+    private executeBackground;
+    /**
+     * Get output from a background task
+     */
+    getTaskOutput(taskId: string, block?: boolean, timeout?: number): Promise<BackgroundTask | null>;
+    /**
+     * Kill a background task
+     */
+    killTask(taskId: string): boolean;
+    /**
+     * List all background tasks
+     */
+    listTasks(): BackgroundTask[];
+    /**
+     * Clean up completed tasks
+     */
+    cleanupTasks(): number;
+    /**
+     * Update sandbox configuration
+     */
+    updateConfig(config: Partial<SandboxConfig>): void;
+    /**
+     * Add command to allowed list
+     */
+    allowCommand(command: string): void;
+    /**
+     * Add pattern to blocked list
+     */
+    blockPattern(pattern: RegExp): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): SandboxConfig;
+}
+export declare function getBashTool(config?: Partial<SandboxConfig>): BashTool;
+export declare function resetBashTool(): void;
+/**
+ * Execute a command with default settings
+ */
+export declare function bash(command: string, options?: BashOptions): Promise<BashResult>;
+/**
+ * Validate a command without executing
+ */
+export declare function validateCommand(command: string): ValidationResult;
+/**
+ * Execute command and return stdout only (throws on error)
+ */
+export declare function exec(command: string, options?: BashOptions): Promise<string>;