gencode-ai 0.4.0 → 0.5.0

package/src/core/session/tasks/types.ts

@@ -0,0 +1,140 @@
+/**
+ * Background Task System - Type Definitions
+ *
+ * Enables subagents to run in the background without blocking the main conversation.
+ */
+
+import type { SubagentType } from '../../../ext/subagents/types.js';
+
+/**
+ * Status of a background task
+ */
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'error' | 'cancelled';
+
+/**
+ * Background task metadata and state
+ */
+export interface BackgroundTask {
+  /** Unique task ID (format: bg-{type}-{timestamp}-{random}) */
+  id: string;
+
+  /** Linked subagent ID */
+  subagentId: string;
+
+  /** Type of subagent running this task */
+  subagentType: SubagentType;
+
+  /** Short task description (3-5 words) */
+  description: string;
+
+  /** Current task status */
+  status: TaskStatus;
+
+  /** Path to NDJSON output log file */
+  outputFile: string;
+
+  /** Path to task metadata JSON file */
+  metadataFile: string;
+
+  /** Task start timestamp */
+  startedAt: Date;
+
+  /** Task completion timestamp (if completed/error/cancelled) */
+  completedAt?: Date;
+
+  /** Final result summary (if completed) */
+  result?: string;
+
+  /** Error message (if status is 'error') */
+  error?: string;
+
+  /** Token usage statistics */
+  tokenUsage?: {
+    input: number;
+    output: number;
+  };
+
+  /** Total execution duration in milliseconds */
+  durationMs?: number;
+
+  /** Number of turns executed */
+  turns?: number;
+
+  /** Model used for execution */
+  model?: string;
+
+  /** Current progress (for running tasks) */
+  progress?: {
+    currentTurn: number;
+    maxTurns: number;
+  };
+}
+
+/**
+ * Action types for TaskOutput tool
+ */
+export type TaskOutputAction = 'status' | 'list' | 'result' | 'wait' | 'cancel';
+
+/**
+ * Filter for listing tasks
+ */
+export type TaskListFilter = 'all' | 'running' | 'completed' | 'error';
+
+/**
+ * Input parameters for TaskOutput tool
+ */
+export interface TaskOutputInput {
+  /** Action to perform */
+  action: TaskOutputAction;
+
+  /** Task ID (required for status/result/wait/cancel) */
+  taskId?: string;
+
+  /** Filter for list action */
+  filter?: TaskListFilter;
+
+  /** Timeout in milliseconds for wait action (max: 600000 = 10 min) */
+  timeout?: number;
+
+  /** Whether to block until task completes (for result action) */
+  block?: boolean;
+}
+
+/**
+ * Serializable version of BackgroundTask for JSON storage
+ */
+export interface BackgroundTaskJson {
+  id: string;
+  subagentId: string;
+  subagentType: SubagentType;
+  description: string;
+  status: TaskStatus;
+  outputFile: string;
+  metadataFile: string;
+  startedAt: string; // ISO 8601
+  completedAt?: string; // ISO 8601
+  result?: string;
+  error?: string;
+  tokenUsage?: {
+    input: number;
+    output: number;
+  };
+  durationMs?: number;
+  turns?: number;
+  model?: string;
+  progress?: {
+    currentTurn: number;
+    maxTurns: number;
+  };
+}
+
+/**
+ * Task registry structure (persisted to disk)
+ */
+export interface TaskRegistry {
+  /** Map of task ID to task metadata */
+  tasks: Record<string, BackgroundTaskJson>;
+
+  /** Last updated timestamp */
+  lastUpdated: string; // ISO 8601
+}

package/src/core/session/types.ts

@@ -0,0 +1,80 @@
+/**
+ * Session Management Types
+ */
+
+import type { Message } from '../providers/types.js';
+import type { CostEstimate } from '../pricing/types.js';
+import type { ConversationSummary, CompressionConfig } from './compression/types.js';
+import type { FileCheckpoint } from './checkpointing/types.js';
+import type { SubagentType } from '../../ext/subagents/types.js';
+
+export interface SessionMetadata {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  provider: string;
+  model: string;
+  cwd: string;
+  messageCount: number;
+  tokenUsage?: {
+    input: number;
+    output: number;
+  };
+  parentId?: string; // For forked sessions
+
+  // Track completions for UI restoration
+  completions?: Array<{
+    afterMessageIndex: number; // Which message this completion follows
+    durationMs: number;
+    usage?: { inputTokens: number; outputTokens: number };
+    cost?: CostEstimate;
+  }>;
+
+  // Subagent session fields (Phase 3)
+  isSubagentSession?: boolean; // True if this is a subagent session
+  subagentType?: SubagentType; // Type of subagent (Explore, Plan, Bash, general-purpose)
+  parentSessionId?: string; // Link to parent agent session (for subagents)
+  resumeCount?: number; // Number of times this session has been resumed
+  expiresAt?: string; // ISO 8601 timestamp when session expires
+  originalDescription?: string; // Original task description
+  lastResumedAt?: string; // ISO 8601 timestamp of last resume
+}
+
+export interface Session {
+  metadata: SessionMetadata;
+  messages: Message[];
+  systemPrompt?: string;
+
+  // Compression support
+  summaries?: ConversationSummary[];
+  fullMessageCount?: number; // Total messages before compression
+
+  // Checkpointing support
+  checkpoints?: FileCheckpoint[];
+}
+
+export interface SessionListItem {
+  id: string;
+  title: string;
+  updatedAt: string;
+  messageCount: number;
+  preview: string; // First user message preview
+}
+
+export interface SessionConfig {
+  storageDir: string;
+  maxSessions: number;
+  maxAge: number; // Days
+  autoSave: boolean;
+
+  // Compression configuration
+  compression?: Partial<CompressionConfig>;
+}
+
+export const DEFAULT_SESSION_CONFIG: SessionConfig = {
+  storageDir: '~/.gen/sessions',
+  maxSessions: 50,
+  maxAge: 30,
+  autoSave: true,
+};

package/src/core/tools/builtin/ask-user.ts

@@ -0,0 +1,185 @@
+/**
+ * AskUserQuestion Tool - Structured user questioning
+ *
+ * Allows the agent to pause execution and present structured questions
+ * to the user with predefined options. Supports single-select, multi-select,
+ * and custom "Other" input.
+ */
+
+import { z } from 'zod';
+import type { Tool, ToolResult, ToolContext } from '../types.js';
+import { loadToolDescription } from '../../../cli/prompts/index.js';
+
+// ============================================================================
+// Zod Schemas
+// ============================================================================
+
+export const QuestionOptionSchema = z.object({
+  label: z
+    .string()
+    .min(1)
+    .max(50)
+    .describe('Display text for this option (1-5 words, concise)'),
+  description: z
+    .string()
+    .min(1)
+    .max(200)
+    .describe('Explanation of what this option means or implications'),
+});
+
+export const QuestionSchema = z.object({
+  question: z
+    .string()
+    .min(1)
+    .describe('The complete question to ask the user, ending with a question mark'),
+  header: z
+    .string()
+    .min(1)
+    .max(12)
+    .describe('Very short label displayed as a chip/tag (max 12 chars)'),
+  options: z
+    .array(QuestionOptionSchema)
+    .min(2)
+    .max(4)
+    .describe('2-4 options for the user to choose from'),
+  multiSelect: z
+    .boolean()
+    .describe('Set to true to allow multiple selections, false for single choice'),
+});
+
+export const AskUserQuestionInputSchema = z.object({
+  questions: z
+    .array(QuestionSchema)
+    .min(1)
+    .max(4)
+    .describe('1-4 questions to ask the user'),
+});
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type QuestionOption = z.infer<typeof QuestionOptionSchema>;
+export type Question = z.infer<typeof QuestionSchema>;
+export type AskUserQuestionInput = z.infer<typeof AskUserQuestionInputSchema>;
+
+export interface QuestionAnswer {
+  question: string;
+  header: string;
+  selectedOptions: string[];
+  customInput?: string;
+}
+
+export interface AskUserQuestionResult {
+  answers: QuestionAnswer[];
+}
+
+// ============================================================================
+// Answer Formatting
+// ============================================================================
+
+/**
+ * Format answers for display to the agent
+ */
+export function formatAnswersForAgent(answers: QuestionAnswer[]): string {
+  const lines: string[] = ['User answered the following questions:', ''];
+
+  answers.forEach((answer, index) => {
+    lines.push(`${index + 1}. ${answer.header} (${answer.question})`);
+
+    if (answer.selectedOptions.length > 0) {
+      lines.push(`   Selected: ${answer.selectedOptions.join(', ')}`);
+    }
+
+    if (answer.customInput) {
+      lines.push(`   Custom input: ${answer.customInput}`);
+    }
+
+    lines.push('');
+  });
+
+  lines.push('Proceeding with user selections.');
+
+  return lines.join('\n');
+}
+
+/**
+ * Format answers for CLI confirmation display
+ */
+export function formatAnswersForDisplay(answers: QuestionAnswer[]): string {
+  return answers
+    .map((answer) => {
+      const selections = answer.customInput
+        ? [...answer.selectedOptions, answer.customInput].join(', ')
+        : answer.selectedOptions.join(', ');
+      return `✔ ${answer.header}: ${selections}`;
+    })
+    .join('\n');
+}
+
+// ============================================================================
+// Tool Implementation
+// ============================================================================
+
+/**
+ * AskUserQuestion tool
+ *
+ * This tool is special - it doesn't execute immediately but signals
+ * the agent loop to pause and wait for user input via the CLI.
+ *
+ * The actual questioning is handled by the CLI layer (QuestionPrompt component).
+ * This tool just validates the input and returns a marker for the agent loop.
+ */
+export const askUserQuestionTool: Tool<AskUserQuestionInput> = {
+  name: 'AskUserQuestion',
+  description: loadToolDescription('ask-user'),
+  parameters: AskUserQuestionInputSchema,
+
+  async execute(input: AskUserQuestionInput, context: ToolContext): Promise<ToolResult> {
+    // Validation is handled by Zod schema
+    // Additional validation for recommended options format
+    for (const question of input.questions) {
+      // Check if first option has (Recommended) - this is just a hint, not enforced
+      const firstOption = question.options[0];
+      if (firstOption && !firstOption.label.includes('(Recommended)')) {
+        // This is fine - recommended suffix is optional
+      }
+    }
+
+    // Check if context has askUser callback
+    if (context.askUser) {
+      try {
+        const answers = await context.askUser(input.questions);
+        return {
+          success: true,
+          output: formatAnswersForAgent(answers),
+          metadata: {
+            title: 'AskUserQuestion',
+            subtitle: `${answers.length} answer(s) received`,
+          },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: '',
+          error: `Failed to get user response: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      }
+    }
+
+    // If no askUser callback, return a special marker
+    // The agent loop should detect this and handle it specially
+    return {
+      success: true,
+      output: JSON.stringify({
+        type: 'ask_user_question',
+        questions: input.questions,
+        requiresUserInput: true,
+      }),
+      metadata: {
+        title: 'AskUserQuestion',
+        subtitle: `${input.questions.length} question(s) pending`,
+      },
+    };
+  },
+};

package/src/core/tools/builtin/bash.ts

@@ -0,0 +1,125 @@
+/**
+ * Bash Tool - Execute shell commands
+ */
+
+import { spawn } from 'child_process';
+import type { Tool, ToolContext, ToolResult } from '../types.js';
+import { BashInputSchema, type BashInput } from '../types.js';
+import { loadToolDescription } from '../../../cli/prompts/index.js';
+import { TaskManager } from '../../session/tasks/task-manager.js';
+
+export const bashTool: Tool<BashInput> = {
+  name: 'Bash',
+  description: loadToolDescription('bash'),
+  parameters: BashInputSchema,
+
+  async execute(input: BashInput, context: ToolContext): Promise<ToolResult> {
+    // Handle background execution
+    if (input.run_in_background) {
+      const taskManager = new TaskManager();
+      const description = input.description || `Bash: ${input.command.slice(0, 50)}`;
+
+      try {
+        const { taskId, outputFile } = await taskManager.createBashTask(
+          input.command,
+          description,
+          context.cwd
+        );
+
+        return {
+          success: true,
+          output: `Background task started: ${taskId}\n\nOutput file: ${outputFile}\n\nUse TaskOutput tool to check status:\n  TaskOutput { action: "status", taskId: "${taskId}" }`,
+          metadata: {
+            title: 'Bash (background)',
+            subtitle: description,
+          },
+        };
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+          success: false,
+          output: '',
+          error: `Failed to start background task: ${errorMsg}`,
+        };
+      }
+    }
+
+    // Foreground execution (existing code)
+    const timeout = input.timeout ?? 30000;
+
+    return new Promise((resolve) => {
+      const proc = spawn('bash', ['-c', input.command], {
+        cwd: context.cwd,
+        env: process.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      // Handle timeout
+      const timer = setTimeout(() => {
+        proc.kill('SIGTERM');
+        resolve({
+          success: false,
+          output: stdout,
+          error: `Command timed out after ${timeout}ms`,
+        });
+      }, timeout);
+
+      // Handle abort signal
+      if (context.abortSignal) {
+        context.abortSignal.addEventListener('abort', () => {
+          proc.kill('SIGTERM');
+          clearTimeout(timer);
+          resolve({
+            success: false,
+            output: stdout,
+            error: 'Command aborted',
+          });
+        });
+      }
+
+      proc.on('close', (code) => {
+        clearTimeout(timer);
+
+        // Truncate output if too long
+        const maxLength = 30000;
+        let output = stdout;
+        if (output.length > maxLength) {
+          output = output.slice(0, maxLength) + '\n... (output truncated)';
+        }
+
+        if (code === 0) {
+          resolve({
+            success: true,
+            output: output || '(no output)',
+          });
+        } else {
+          resolve({
+            success: false,
+            output,
+            error: stderr || `Command exited with code ${code}`,
+          });
+        }
+      });
+
+      proc.on('error', (error) => {
+        clearTimeout(timer);
+        resolve({
+          success: false,
+          output: '',
+          error: `Failed to execute command: ${error.message}`,
+        });
+      });
+    });
+  },
+};

package/src/core/tools/builtin/edit.ts

@@ -0,0 +1,97 @@
+/**
+ * Edit Tool - Edit file contents with string replacement
+ */
+
+import * as fs from 'fs/promises';
+import { createTwoFilesPatch } from 'diff';
+import type { Tool, ToolResult } from '../types.js';
+import { EditInputSchema, type EditInput, resolvePath, getErrorMessage } from '../types.js';
+import { loadToolDescription } from '../../../cli/prompts/index.js';
+
+export const editTool: Tool<EditInput> = {
+  name: 'Edit',
+  description: loadToolDescription('edit'),
+  parameters: EditInputSchema,
+
+  async execute(input, context): Promise<ToolResult> {
+    try {
+      const filePath = resolvePath(input.file_path, context.cwd);
+      const oldContent = await fs.readFile(filePath, 'utf-8');
+      const occurrences = oldContent.split(input.old_string).length - 1;
+
+      if (occurrences === 0) {
+        return { success: false, output: '', error: 'The string to replace was not found in the file.' };
+      }
+
+      // Handle replace_all vs unique replacement
+      const replaceAll = input.replace_all ?? false;
+
+      if (!replaceAll && occurrences > 1) {
+        return {
+          success: false,
+          output: '',
+          error: `The string to replace occurs ${occurrences} times. Please provide a more unique string, or use replace_all: true to replace all occurrences.`,
+        };
+      }
+
+      // Perform replacement (generate new content)
+      let newContent: string;
+      if (replaceAll) {
+        // Replace all occurrences
+        newContent = oldContent.split(input.old_string).join(input.new_string);
+      } else {
+        // Replace single occurrence
+        newContent = oldContent.replace(input.old_string, input.new_string);
+      }
+
+      // Generate unified diff for preview
+      const diff = createTwoFilesPatch(
+        filePath,
+        filePath,
+        oldContent,
+        newContent,
+        undefined,
+        undefined
+      );
+
+      // Trim diff to remove file headers (--- +++)
+      const trimmedDiff = diff
+        .split('\n')
+        .slice(2) // Remove first two lines (--- and +++)
+        .join('\n');
+
+      // Request permission with diff metadata
+      if (context.askPermission) {
+        const decision = await context.askPermission({
+          tool: 'Edit',
+          input,
+          metadata: {
+            diff: trimmedDiff,
+            filePath,
+          },
+        });
+
+        if (!decision || decision === 'deny') {
+          return {
+            success: false,
+            output: '',
+            error: 'Edit operation denied by user',
+          };
+        }
+      }
+
+      // User approved - write the file
+      await fs.writeFile(filePath, newContent, 'utf-8');
+
+      const oldLines = input.old_string.split('\n').length;
+      const newLines = input.new_string.split('\n').length;
+      const countInfo = replaceAll && occurrences > 1 ? ` (${occurrences} occurrences)` : '';
+      return {
+        success: true,
+        output: `Successfully edited ${filePath}: replaced ${oldLines} line(s) with ${newLines} line(s)${countInfo}`,
+      };
+    } catch (error) {
+      return { success: false, output: '', error: `Failed to edit file: ${getErrorMessage(error)}` };
+    }
+  },
+};

package/src/core/tools/builtin/glob.ts

@@ -0,0 +1,43 @@
+/**
+ * Glob Tool - Find files matching a pattern
+ */
+
+import fastGlob from 'fast-glob';
+import type { Tool, ToolResult } from '../types.js';
+import { GlobInputSchema, type GlobInput, resolvePath, getErrorMessage } from '../types.js';
+import { loadToolDescription } from '../../../cli/prompts/index.js';
+
+const MAX_RESULTS = 100;
+
+export const globTool: Tool<GlobInput> = {
+  name: 'Glob',
+  description: loadToolDescription('glob'),
+  parameters: GlobInputSchema,
+
+  async execute(input, context): Promise<ToolResult> {
+    try {
+      const searchPath = input.path ? resolvePath(input.path, context.cwd) : context.cwd;
+
+      const files = await fastGlob(input.pattern, {
+        cwd: searchPath,
+        absolute: true,
+        onlyFiles: true,
+        ignore: ['**/node_modules/**', '**/.git/**'],
+        followSymbolicLinks: false,
+      });
+
+      if (files.length === 0) {
+        return { success: true, output: 'No files found matching the pattern.' };
+      }
+
+      const truncated = files.length > MAX_RESULTS;
+      const displayFiles = files.slice(0, MAX_RESULTS);
+      return {
+        success: true,
+        output: `Found ${files.length} file(s):\n${displayFiles.join('\n')}${truncated ? '\n... (truncated)' : ''}`,
+      };
+    } catch (error) {
+      return { success: false, output: '', error: `Glob search failed: ${getErrorMessage(error)}` };
+    }
+  },
+};