nova-terminal-assistant 0.1.0

package/src/core/types/tools.ts

@@ -0,0 +1,157 @@
+// ============================================================================
+// Tool Types - Tool definitions, schemas, and execution
+// ============================================================================
+
+import type { ToolCallId, ApprovalMode, ApprovalRequest, ApprovalResponse } from './session.js';
+
+// --- Tool Categories ---
+export type ToolCategory =
+  | 'file'           // File read/write/edit operations
+  | 'search'         // Search & grep operations
+  | 'execution'      // Shell command execution
+  | 'web'            // Web search & fetch
+  | 'memory'         // Memory & context management
+  | 'orchestration'  // Agent orchestration (task, plan, etc.)
+  | 'mcp';           // MCP server tools
+
+// --- Tool Definition ---
+export interface ToolParameter {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+  description: string;
+  required?: boolean;
+  default?: unknown;
+  enum?: string[];
+  items?: ToolParameter;
+  properties?: Record<string, ToolParameter>;
+}
+
+export interface ToolDefinition {
+  /** Unique tool name */
+  name: string;
+  /** Human-readable description for the LLM */
+  description: string;
+  /** Category for organizational purposes */
+  category: ToolCategory;
+  /** JSON Schema for input parameters */
+  inputSchema: Record<string, unknown>;
+  /** Whether this tool requires approval */
+  requiresApproval: boolean | ((input: Record<string, unknown>, mode: ApprovalMode) => boolean);
+  /** Risk level when tool is used */
+  riskLevel: 'low' | 'medium' | 'high' | 'critical';
+  /** Timeout in milliseconds */
+  timeout?: number;
+  /** Whether the tool can be cancelled mid-execution */
+  cancellable?: boolean;
+  /** Tags for searchability */
+  tags?: string[];
+}
+
+// --- Tool Execution ---
+export type ToolExecutionStatus = 'pending' | 'running' | 'completed' | 'error' | 'cancelled';
+
+export interface ToolCall {
+  id: ToolCallId;
+  toolName: string;
+  input: Record<string, unknown>;
+  status: ToolExecutionStatus;
+  startTime?: number;
+  endTime?: number;
+  result?: ToolResult;
+  error?: ToolErrorData;
+}
+
+export interface ToolResult {
+  output: string;
+  metadata?: Record<string, unknown>;
+  filesAffected?: string[];
+  duration: number;
+}
+
+export interface ToolErrorData {
+  code: string;
+  message: string;
+  details?: unknown;
+  retryable: boolean;
+}
+
+// --- Tool Registry ---
+export interface ToolRegistryEntry {
+  definition: ToolDefinition;
+  handler: ToolHandler;
+  enabled: boolean;
+}
+
+export type ToolHandler = (input: ToolHandlerInput) => Promise<ToolHandlerOutput>;
+
+export interface ToolHandlerInput {
+  params: Record<string, unknown>;
+  context: ToolExecutionContext;
+  abortSignal?: AbortSignal;
+}
+
+export interface ToolExecutionContext {
+  sessionId: string;
+  workingDirectory: string;
+  environment: Record<string, string>;
+  model: string;
+  approvalMode: ApprovalMode;
+  metadata?: Record<string, unknown>;
+  /** Maximum tokens for the model */
+  maxTokens?: number;
+  /** Approval required callback */
+  onApprovalRequired?: (request: ApprovalRequest) => Promise<ApprovalResponse>;
+  /** Session manager instance */
+  sessionManager?: unknown;
+  /** Tool registry instance */
+  toolRegistry?: unknown;
+  /** Model client instance */
+  modelClient?: unknown;
+  /** Context compressor instance */
+  contextCompressor?: unknown;
+}
+
+export interface ToolHandlerOutput {
+  content: string;
+  isError?: boolean;
+  metadata?: Record<string, unknown>;
+  filesAffected?: string[];
+}
+
+// --- Streaming Events ---
+export type ToolStreamEvent =
+  | { type: 'stdout'; data: string }
+  | { type: 'stderr'; data: string }
+  | { type: 'progress'; current: number; total: number; message?: string }
+  | { type: 'status'; message: string }
+  | { type: 'complete' };
+
+// --- Builtin Tool Names ---
+export const BUILTIN_TOOLS = {
+  // File operations
+  READ_FILE: 'read_file',
+  WRITE_FILE: 'write_file',
+  EDIT_FILE: 'edit_file',
+  LIST_DIRECTORY: 'list_directory',
+  
+  // Search operations
+  SEARCH_FILE: 'search_file',
+  SEARCH_CONTENT: 'search_content',
+  GLOB: 'glob',
+  
+  // Execution
+  EXECUTE_COMMAND: 'execute_command',
+  
+  // Web
+  WEB_SEARCH: 'web_search',
+  WEB_FETCH: 'web_fetch',
+  
+  // Memory
+  MEMORY_READ: 'memory_read',
+  MEMORY_WRITE: 'memory_write',
+  
+  // Orchestration
+  TASK: 'task',
+} as const;
+
+export type BuiltinToolName = (typeof BUILTIN_TOOLS)[keyof typeof BUILTIN_TOOLS];

package/src/core/utils/CheckpointManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheckpointManager.d.ts","sourceRoot":"","sources":["CheckpointManager.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,WAAW,UAAU;IACzB,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,oCAAoC;IACpC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAS;gBAEb,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU;IAQrD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IA2D7F;;OAEG;IACG,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBlD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IA2BnC;;OAEG;IACG,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAU5D;;OAEG;IACG,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAUpD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAgBvC;;OAEG;IACG,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAAA;KAAE,CAAC,CAAC;IA2B5G;;OAEG;YACW,qBAAqB;IAsBnC;;OAEG;YACW,SAAS;IAiBvB;;OAEG;IACH,OAAO,CAAC,UAAU;CAKnB"}

package/src/core/utils/CheckpointManager.ts

@@ -0,0 +1,327 @@
+// ============================================================================
+// CheckpointManager - File snapshot and rollback system
+// ============================================================================
+
+import { promises as fs } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { createHash } from 'node:crypto';
+import type { NovaConfig } from '../types/config.js';
+
+export interface Checkpoint {
+  /** Unique checkpoint ID */
+  id: string;
+  /** Human-readable name */
+  name: string;
+  /** Creation timestamp */
+  timestamp: number;
+  /** Files included in this checkpoint */
+  files: CheckpointFile[];
+  /** Description of changes */
+  description?: string;
+  /** Parent checkpoint ID (for branching) */
+  parentId?: string;
+}
+
+export interface CheckpointFile {
+  /** Relative path from workspace root */
+  path: string;
+  /** File hash for integrity checking */
+  hash: string;
+  /** File size in bytes */
+  size: number;
+  /** Modification timestamp */
+  mtime: number;
+  /** Whether this file was created new */
+  isNew?: boolean;
+  /** Whether this file was deleted */
+  isDeleted?: boolean;
+}
+
+export interface CheckpointStats {
+  totalCheckpoints: number;
+  totalSize: number;
+  oldest?: number;
+  newest?: number;
+}
+
+/**
+ * CheckpointManager - Manages file snapshots for rollback capability
+ * 
+ * Features:
+ * - Create snapshots before destructive operations
+ * - Rollback to previous states
+ * - List and manage checkpoints
+ * - Automatic cleanup of old checkpoints
+ */
+export class CheckpointManager {
+  private workspaceRoot: string;
+  private checkpointsDir: string;
+  private config: NovaConfig;
+  private maxCheckpoints: number;
+  private maxAgeMs: number;
+
+  constructor(workspaceRoot: string, config: NovaConfig) {
+    this.workspaceRoot = workspaceRoot;
+    this.config = config;
+    this.checkpointsDir = join(workspaceRoot, '.nova', 'checkpoints');
+    this.maxCheckpoints = config.core.maxCheckpoints || 10;
+    this.maxAgeMs = (config.core.checkpointMaxAgeDays || 7) * 24 * 60 * 60 * 1000;
+  }
+
+  /**
+   * Initialize checkpoint directory
+   */
+  async initialize(): Promise<void> {
+    try {
+      await fs.mkdir(this.checkpointsDir, { recursive: true });
+    } catch (err) {
+      // Directory might already exist
+    }
+  }
+
+  /**
+   * Create a checkpoint of specified files
+   */
+  async create(name: string, filePatterns: string[], description?: string): Promise<Checkpoint> {
+    await this.initialize();
+
+    const checkpointId = this.generateId();
+    const checkpointDir = join(this.checkpointsDir, checkpointId);
+    await fs.mkdir(checkpointDir, { recursive: true });
+
+    const files: CheckpointFile[] = [];
+    const matchedFiles = await this.findFiles(filePatterns);
+
+    for (const filePath of matchedFiles) {
+      const fullPath = join(this.workspaceRoot, filePath);
+      try {
+        const stats = await fs.stat(fullPath);
+        if (!stats.isFile()) continue;
+
+        // Read file content
+        const content = await fs.readFile(fullPath);
+        
+        // Calculate hash
+        const hash = createHash('sha256').update(content).digest('hex');
+
+        // Copy file to checkpoint
+        const checkpointFilePath = join(checkpointDir, filePath);
+        await fs.mkdir(dirname(checkpointFilePath), { recursive: true });
+        await fs.writeFile(checkpointFilePath, content);
+
+        files.push({
+          path: filePath,
+          hash,
+          size: content.length,
+          mtime: stats.mtimeMs,
+        });
+      } catch (err) {
+        // File might not exist or be readable
+        console.warn(`Warning: Could not checkpoint ${filePath}: ${err}`);
+      }
+    }
+
+    const checkpoint: Checkpoint = {
+      id: checkpointId,
+      name,
+      timestamp: Date.now(),
+      files,
+      description,
+    };
+
+    // Save checkpoint metadata
+    await fs.writeFile(
+      join(checkpointDir, 'metadata.json'),
+      JSON.stringify(checkpoint, null, 2)
+    );
+
+    // Cleanup old checkpoints
+    await this.cleanupOldCheckpoints();
+
+    return checkpoint;
+  }
+
+  /**
+   * Restore a checkpoint
+   */
+  async restore(checkpointId: string): Promise<void> {
+    const checkpoint = await this.load(checkpointId);
+    if (!checkpoint) {
+      throw new Error(`Checkpoint not found: ${checkpointId}`);
+    }
+
+    const checkpointDir = join(this.checkpointsDir, checkpointId);
+
+    for (const file of checkpoint.files) {
+      const sourcePath = join(checkpointDir, file.path);
+      const destPath = join(this.workspaceRoot, file.path);
+
+      try {
+        await fs.mkdir(dirname(destPath), { recursive: true });
+        const content = await fs.readFile(sourcePath);
+        await fs.writeFile(destPath, content);
+      } catch (err) {
+        throw new Error(`Failed to restore ${file.path}: ${err}`);
+      }
+    }
+  }
+
+  /**
+   * List all checkpoints
+   */
+  async list(): Promise<Checkpoint[]> {
+    await this.initialize();
+
+    try {
+      const entries = await fs.readdir(this.checkpointsDir, { withFileTypes: true });
+      const checkpoints: Checkpoint[] = [];
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          try {
+            const metadataPath = join(this.checkpointsDir, entry.name, 'metadata.json');
+            const metadata = await fs.readFile(metadataPath, 'utf-8');
+            const checkpoint = JSON.parse(metadata) as Checkpoint;
+            checkpoints.push(checkpoint);
+          } catch (err) {
+            // Skip invalid checkpoints
+          }
+        }
+      }
+
+      // Sort by timestamp (newest first)
+      return checkpoints.sort((a, b) => b.timestamp - a.timestamp);
+    } catch (err) {
+      return [];
+    }
+  }
+
+  /**
+   * Get checkpoint by ID
+   */
+  async load(checkpointId: string): Promise<Checkpoint | null> {
+    try {
+      const metadataPath = join(this.checkpointsDir, checkpointId, 'metadata.json');
+      const metadata = await fs.readFile(metadataPath, 'utf-8');
+      return JSON.parse(metadata) as Checkpoint;
+    } catch (err) {
+      return null;
+    }
+  }
+
+  /**
+   * Delete a checkpoint
+   */
+  async delete(checkpointId: string): Promise<boolean> {
+    try {
+      const checkpointDir = join(this.checkpointsDir, checkpointId);
+      await fs.rm(checkpointDir, { recursive: true, force: true });
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  /**
+   * Get checkpoint statistics
+   */
+  async stats(): Promise<CheckpointStats> {
+    const checkpoints = await this.list();
+    let totalSize = 0;
+
+    for (const checkpoint of checkpoints) {
+      totalSize += checkpoint.files.reduce((sum, file) => sum + file.size, 0);
+    }
+
+    return {
+      totalCheckpoints: checkpoints.length,
+      totalSize,
+      oldest: checkpoints.length > 0 ? checkpoints[checkpoints.length - 1].timestamp : undefined,
+      newest: checkpoints.length > 0 ? checkpoints[0].timestamp : undefined,
+    };
+  }
+
+  /**
+   * Compare current files with checkpoint
+   */
+  async diff(checkpointId: string): Promise<Array<{ path: string; status: 'modified' | 'deleted' | 'added' }>> {
+    const checkpoint = await this.load(checkpointId);
+    if (!checkpoint) {
+      throw new Error(`Checkpoint not found: ${checkpointId}`);
+    }
+
+    const differences: Array<{ path: string; status: 'modified' | 'deleted' | 'added' }> = [];
+
+    // Check files in checkpoint
+    for (const file of checkpoint.files) {
+      const currentPath = join(this.workspaceRoot, file.path);
+      try {
+        const currentContent = await fs.readFile(currentPath);
+        const currentHash = createHash('sha256').update(currentContent).digest('hex');
+        
+        if (currentHash !== file.hash) {
+          differences.push({ path: file.path, status: 'modified' });
+        }
+      } catch (err) {
+        // File doesn't exist (deleted)
+        differences.push({ path: file.path, status: 'deleted' });
+      }
+    }
+
+    return differences;
+  }
+
+  /**
+   * Cleanup old checkpoints based on age and count limits
+   */
+  private async cleanupOldCheckpoints(): Promise<void> {
+    const checkpoints = await this.list();
+    const now = Date.now();
+    const toDelete: string[] = [];
+
+    // Find checkpoints to delete
+    for (let i = 0; i < checkpoints.length; i++) {
+      const checkpoint = checkpoints[i];
+      const age = now - checkpoint.timestamp;
+
+      // Delete if too old or if we have too many
+      if (age > this.maxAgeMs || i >= this.maxCheckpoints) {
+        toDelete.push(checkpoint.id);
+      }
+    }
+
+    // Delete old checkpoints
+    for (const id of toDelete) {
+      await this.delete(id);
+    }
+  }
+
+  /**
+   * Find files matching patterns
+   */
+  private async findFiles(patterns: string[]): Promise<string[]> {
+    const files = new Set<string>();
+    
+    for (const pattern of patterns) {
+      if (pattern.includes('*')) {
+        // Simple glob pattern - in real implementation use a glob library
+        // For now, just add the pattern as-is
+        files.add(pattern);
+      } else {
+        // Single file or directory
+        files.add(pattern);
+      }
+    }
+
+    return Array.from(files);
+  }
+
+  /**
+   * Generate unique checkpoint ID
+   */
+  private generateId(): string {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substr(2, 6);
+    return `cp-${timestamp}-${random}`;
+  }
+}

package/src/core/utils/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["Logger.ts"],"names":[],"mappings":"AAIA,KAAK,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE/D,UAAU,QAAQ;IAChB,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,UAAU,CAAS;gBAEf,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,QAAiB,EAAE,UAAU,GAAE,MAAa;IAM/E,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI5C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI3C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI3C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI5C,OAAO,CAAC,GAAG;IAiBX,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,MAAM;IAgBd,UAAU,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,EAAE;IAKxC,YAAY,IAAI,IAAI;CAGrB;AAED,4BAA4B;AAC5B,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,CAErE"}

package/src/core/utils/Logger.ts

@@ -0,0 +1,98 @@
+// ============================================================================
+// Logger - Simple structured logging
+// ============================================================================
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  data?: unknown;
+  timestamp: string;
+  source: string;
+}
+
+export class Logger {
+  private level: LogLevel;
+  private source: string;
+  private history: LogEntry[] = [];
+  private maxHistory: number;
+
+  constructor(source: string, level: LogLevel = 'info', maxHistory: number = 1000) {
+    this.source = source;
+    this.level = level;
+    this.maxHistory = maxHistory;
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  debug(message: string, data?: unknown): void {
+    this.log('debug', message, data);
+  }
+
+  info(message: string, data?: unknown): void {
+    this.log('info', message, data);
+  }
+
+  warn(message: string, data?: unknown): void {
+    this.log('warn', message, data);
+  }
+
+  error(message: string, data?: unknown): void {
+    this.log('error', message, data);
+  }
+
+  private log(level: LogLevel, message: string, data?: unknown): void {
+    if (!this.shouldLog(level)) return;
+
+    const entry: LogEntry = {
+      level,
+      message,
+      data,
+      timestamp: new Date().toISOString(),
+      source: this.source,
+    };
+
+    this.history.push(entry);
+    if (this.history.length > this.maxHistory) this.history.shift();
+
+    this.output(entry);
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const levels: LogLevel[] = ['debug', 'info', 'warn', 'error', 'silent'];
+    return levels.indexOf(level) >= levels.indexOf(this.level);
+  }
+
+  private output(entry: LogEntry): void {
+    const colors: Record<LogLevel, string> = {
+      debug: '\x1b[36m', info: '\x1b[37m', warn: '\x1b[33m', error: '\x1b[31m', silent: '',
+    };
+    const reset = '\x1b[0m';
+    const color = colors[entry.level];
+    const prefix = `${entry.timestamp} [${entry.level.toUpperCase()}] [${entry.source}]`;
+
+    if (entry.level === 'error') {
+      console.error(`${color}${prefix}${reset} ${entry.message}`);
+      if (entry.data) console.error(`${color}  Data: ${JSON.stringify(entry.data)}${reset}`);
+    } else {
+      console.log(`${color}${prefix}${reset} ${entry.message}`);
+    }
+  }
+
+  getHistory(level?: LogLevel): LogEntry[] {
+    if (level) return this.history.filter((e) => e.level === level);
+    return [...this.history];
+  }
+
+  clearHistory(): void {
+    this.history = [];
+  }
+}
+
+/** Create a named logger */
+export function createLogger(source: string, level?: LogLevel): Logger {
+  return new Logger(source, level);
+}