@push.rocks/smartagent 1.2.3 → 1.2.5

package/ts/smartagent.interfaces.ts

@@ -26,6 +26,14 @@ export interface IDualAgentOptions extends plugins.smartai.ISmartAiOptions {
   maxConsecutiveRejections?: number;
   /** Enable verbose logging */
   verbose?: boolean;
+  /** Maximum characters for tool result output before truncation (default: 15000). Set to 0 to disable. */
+  maxResultChars?: number;
+  /** Maximum history messages to pass to API (default: 20). Set to 0 for unlimited. */
+  maxHistoryMessages?: number;
+  /** Optional callback for live progress updates during execution */
+  onProgress?: (event: IProgressEvent) => void;
+  /** Prefix for log messages (e.g., "[README]", "[Commit]"). Default: empty */
+  logPrefix?: string;
 }
 
 // ================================
@@ -84,6 +92,8 @@ export interface IToolExecutionResult {
   success: boolean;
   result?: unknown;
   error?: string;
+  /** Optional human-readable summary for history (if provided, used instead of full result) */
+  summary?: string;
 }
 
 /**
@@ -195,6 +205,58 @@ export interface IDualAgentRunResult {
   error?: string;
 }
 
+// ================================
+// Progress Event Interfaces
+// ================================
+
+/**
+ * Progress event types for live feedback during agent execution
+ */
+export type TProgressEventType =
+  | 'task_started'
+  | 'iteration_started'
+  | 'tool_proposed'
+  | 'guardian_evaluating'
+  | 'tool_approved'
+  | 'tool_rejected'
+  | 'tool_executing'
+  | 'tool_completed'
+  | 'task_completed'
+  | 'clarification_needed'
+  | 'max_iterations'
+  | 'max_rejections';
+
+/**
+ * Log level for progress events
+ */
+export type TLogLevel = 'info' | 'warn' | 'error' | 'success';
+
+/**
+ * Progress event for live feedback during agent execution
+ */
+export interface IProgressEvent {
+  /** Type of progress event */
+  type: TProgressEventType;
+  /** Current iteration number */
+  iteration?: number;
+  /** Maximum iterations configured */
+  maxIterations?: number;
+  /** Name of the tool being used */
+  toolName?: string;
+  /** Action being performed */
+  action?: string;
+  /** Reason for rejection or other explanation */
+  reason?: string;
+  /** Human-readable message about the event */
+  message?: string;
+  /** Timestamp of the event */
+  timestamp: Date;
+  /** Log level for this event (info, warn, error, success) */
+  logLevel: TLogLevel;
+  /** Pre-formatted log message ready for output */
+  logMessage: string;
+}
+
 // ================================
 // Utility Types
 // ================================

package/ts/smartagent.tools.filesystem.ts

@@ -8,6 +8,8 @@ import { BaseToolWrapper } from './smartagent.tools.base.js';
 export interface IFilesystemToolOptions {
   /** Base path to scope all operations to. If set, all paths must be within this directory. */
   basePath?: string;
+  /** Glob patterns to exclude from listings (e.g., ['.nogit/**', 'node_modules/**']) */
+  excludePatterns?: string[];
 }
 
 /**
@@ -20,12 +22,25 @@ export class FilesystemTool extends BaseToolWrapper {
 
   /** Base path to scope all operations to */
   private basePath?: string;
+  /** Glob patterns to exclude from listings */
+  private excludePatterns: string[];
 
   constructor(options?: IFilesystemToolOptions) {
     super();
     if (options?.basePath) {
       this.basePath = plugins.path.resolve(options.basePath);
     }
+    this.excludePatterns = options?.excludePatterns || [];
+  }
+
+  /**
+   * Check if a relative path should be excluded based on exclude patterns
+   */
+  private isExcluded(relativePath: string): boolean {
+    if (this.excludePatterns.length === 0) return false;
+    return this.excludePatterns.some(pattern =>
+      plugins.minimatch(relativePath, pattern, { dot: true })
+    );
   }
 
   /**
@@ -46,17 +61,25 @@ export class FilesystemTool extends BaseToolWrapper {
   public actions: interfaces.IToolAction[] = [
     {
       name: 'read',
-      description: 'Read the contents of a file',
+      description: 'Read file contents (full or specific line range)',
       parameters: {
         type: 'object',
         properties: {
-          path: { type: 'string', description: 'Absolute path to the file' },
+          path: { type: 'string', description: 'Path to the file' },
           encoding: {
             type: 'string',
             enum: ['utf8', 'binary', 'base64'],
             default: 'utf8',
             description: 'File encoding',
           },
+          startLine: {
+            type: 'number',
+            description: 'First line to read (1-indexed, inclusive). If omitted, reads from beginning.',
+          },
+          endLine: {
+            type: 'number',
+            description: 'Last line to read (1-indexed, inclusive). If omitted, reads to end.',
+          },
         },
         required: ['path'],
       },
@@ -182,6 +205,55 @@ export class FilesystemTool extends BaseToolWrapper {
         required: ['path'],
       },
     },
+    {
+      name: 'tree',
+      description: 'Show directory structure as a tree (no file contents)',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Root directory path' },
+          maxDepth: {
+            type: 'number',
+            default: 3,
+            description: 'Maximum depth to traverse (default: 3)',
+          },
+          filter: {
+            type: 'string',
+            description: 'Glob pattern to filter files (e.g., "*.ts")',
+          },
+          showSizes: {
+            type: 'boolean',
+            default: false,
+            description: 'Include file sizes in output',
+          },
+          format: {
+            type: 'string',
+            enum: ['string', 'json'],
+            default: 'string',
+            description: 'Output format: "string" for human-readable tree, "json" for structured array',
+          },
+        },
+        required: ['path'],
+      },
+    },
+    {
+      name: 'glob',
+      description: 'Find files matching a glob pattern',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: {
+            type: 'string',
+            description: 'Glob pattern (e.g., "**/*.ts", "src/**/*.js")',
+          },
+          path: {
+            type: 'string',
+            description: 'Base path to search from (defaults to current directory)',
+          },
+        },
+        required: ['pattern'],
+      },
+    },
   ];
 
   private smartfs!: plugins.smartfs.SmartFs;
@@ -207,16 +279,61 @@ export class FilesystemTool extends BaseToolWrapper {
         case 'read': {
           const validatedPath = this.validatePath(params.path as string);
           const encoding = (params.encoding as string) || 'utf8';
-          const content = await this.smartfs
+          const startLine = params.startLine as number | undefined;
+          const endLine = params.endLine as number | undefined;
+
+          const fullContent = await this.smartfs
             .file(validatedPath)
             .encoding(encoding as 'utf8' | 'binary' | 'base64')
             .read();
+
+          const contentStr = fullContent.toString();
+          const lines = contentStr.split('\n');
+          const totalLines = lines.length;
+
+          // Apply line range if specified
+          let resultContent: string;
+          let resultStartLine = 1;
+          let resultEndLine = totalLines;
+
+          if (startLine !== undefined || endLine !== undefined) {
+            const start = Math.max(1, startLine ?? 1);
+            const end = Math.min(totalLines, endLine ?? totalLines);
+            resultStartLine = start;
+            resultEndLine = end;
+
+            // Convert to 0-indexed for array slicing
+            const selectedLines = lines.slice(start - 1, end);
+
+            // Add line numbers to output for context
+            resultContent = selectedLines
+              .map((line, idx) => `${String(start + idx).padStart(5)}│ ${line}`)
+              .join('\n');
+          } else {
+            // No range specified - return full content but warn if large
+            const MAX_LINES_WITHOUT_RANGE = 500;
+            if (totalLines > MAX_LINES_WITHOUT_RANGE) {
+              // Return first portion with warning
+              const selectedLines = lines.slice(0, MAX_LINES_WITHOUT_RANGE);
+              resultContent = selectedLines
+                .map((line, idx) => `${String(idx + 1).padStart(5)}│ ${line}`)
+                .join('\n');
+              resultContent += `\n\n[... ${totalLines - MAX_LINES_WITHOUT_RANGE} more lines. Use startLine/endLine to read specific ranges.]`;
+              resultEndLine = MAX_LINES_WITHOUT_RANGE;
+            } else {
+              resultContent = contentStr;
+            }
+          }
+
           return {
             success: true,
             result: {
               path: params.path,
-              content: content.toString(),
+              content: resultContent,
               encoding,
+              totalLines,
+              startLine: resultStartLine,
+              endLine: resultEndLine,
             },
           };
         }
@@ -259,7 +376,16 @@ export class FilesystemTool extends BaseToolWrapper {
           if (params.filter) {
             dir = dir.filter(params.filter as string);
           }
-          const entries = await dir.list();
+          let entries = await dir.list();
+
+          // Filter out excluded paths
+          if (this.excludePatterns.length > 0) {
+            entries = entries.filter(entry => {
+              const relativePath = plugins.path.relative(validatedPath, entry.path);
+              return !this.isExcluded(relativePath) && !this.isExcluded(entry.name);
+            });
+          }
+
           return {
             success: true,
             result: {
@@ -364,6 +490,168 @@ export class FilesystemTool extends BaseToolWrapper {
           };
         }
 
+        case 'tree': {
+          const validatedPath = this.validatePath(params.path as string);
+          const maxDepth = (params.maxDepth as number) ?? 3;
+          const filter = params.filter as string | undefined;
+          const showSizes = (params.showSizes as boolean) ?? false;
+          const format = (params.format as 'string' | 'json') ?? 'string';
+
+          // Collect all entries recursively up to maxDepth
+          interface ITreeEntry {
+            path: string;
+            relativePath: string;
+            isDir: boolean;
+            depth: number;
+            size?: number;
+          }
+
+          const entries: ITreeEntry[] = [];
+
+          const collectEntries = async (dirPath: string, depth: number, relativePath: string) => {
+            if (depth > maxDepth) return;
+
+            let dir = this.smartfs.directory(dirPath);
+            if (filter) {
+              dir = dir.filter(filter);
+            }
+            const items = await dir.list();
+
+            for (const item of items) {
+              // item is IDirectoryEntry with name, path, isFile, isDirectory properties
+              const itemPath = item.path;
+              const itemRelPath = relativePath ? `${relativePath}/${item.name}` : item.name;
+              const isDir = item.isDirectory;
+
+              // Skip excluded paths
+              if (this.isExcluded(itemRelPath) || this.isExcluded(item.name)) {
+                continue;
+              }
+
+              const entry: ITreeEntry = {
+                path: itemPath,
+                relativePath: itemRelPath,
+                isDir,
+                depth,
+              };
+
+              if (showSizes && !isDir && item.stats) {
+                entry.size = item.stats.size;
+              }
+
+              entries.push(entry);
+
+              // Recurse into directories
+              if (isDir && depth < maxDepth) {
+                await collectEntries(itemPath, depth + 1, itemRelPath);
+              }
+            }
+          };
+
+          await collectEntries(validatedPath, 0, '');
+
+          // Sort entries by path for consistent output
+          entries.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+
+          if (format === 'json') {
+            return {
+              success: true,
+              result: {
+                path: params.path,
+                entries: entries.map((e) => ({
+                  path: e.relativePath,
+                  isDir: e.isDir,
+                  depth: e.depth,
+                  ...(e.size !== undefined ? { size: e.size } : {}),
+                })),
+                count: entries.length,
+              },
+            };
+          }
+
+          // Format as string tree
+          const formatSize = (bytes: number): string => {
+            if (bytes < 1024) return `${bytes}B`;
+            if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+            return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+          };
+
+          // Build tree string with proper indentation
+          let treeStr = `${params.path}/\n`;
+          const pathParts = new Map<string, number>(); // Track which paths are last in their parent
+
+          // Group by parent to determine last child
+          const parentChildCount = new Map<string, number>();
+          const parentCurrentChild = new Map<string, number>();
+
+          for (const entry of entries) {
+            const parentPath = entry.relativePath.includes('/')
+              ? entry.relativePath.substring(0, entry.relativePath.lastIndexOf('/'))
+              : '';
+            parentChildCount.set(parentPath, (parentChildCount.get(parentPath) || 0) + 1);
+          }
+
+          for (const entry of entries) {
+            const parentPath = entry.relativePath.includes('/')
+              ? entry.relativePath.substring(0, entry.relativePath.lastIndexOf('/'))
+              : '';
+            parentCurrentChild.set(parentPath, (parentCurrentChild.get(parentPath) || 0) + 1);
+            const isLast = parentCurrentChild.get(parentPath) === parentChildCount.get(parentPath);
+
+            // Build prefix based on depth
+            let prefix = '';
+            const parts = entry.relativePath.split('/');
+            for (let i = 0; i < parts.length - 1; i++) {
+              prefix += '│   ';
+            }
+            prefix += isLast ? '└── ' : '├── ';
+
+            const name = parts[parts.length - 1];
+            const suffix = entry.isDir ? '/' : '';
+            const sizeStr = showSizes && entry.size !== undefined ? ` (${formatSize(entry.size)})` : '';
+
+            treeStr += `${prefix}${name}${suffix}${sizeStr}\n`;
+          }
+
+          return {
+            success: true,
+            result: {
+              path: params.path,
+              tree: treeStr,
+              count: entries.length,
+            },
+          };
+        }
+
+        case 'glob': {
+          const pattern = params.pattern as string;
+          const basePath = params.path ? this.validatePath(params.path as string) : (this.basePath || process.cwd());
+
+          // Use smartfs to list with filter
+          const dir = this.smartfs.directory(basePath).recursive().filter(pattern);
+          const matches = await dir.list();
+
+          // Return file paths relative to base path for readability
+          // Filter out excluded paths
+          const files = matches
+            .map((entry) => ({
+              path: entry.path,
+              relativePath: plugins.path.relative(basePath, entry.path),
+              isDirectory: entry.isDirectory,
+            }))
+            .filter((file) => !this.isExcluded(file.relativePath));
+
+          return {
+            success: true,
+            result: {
+              pattern,
+              basePath,
+              files,
+              count: files.length,
+            },
+          };
+        }
+
         default:
           return {
             success: false,
@@ -380,8 +668,12 @@ export class FilesystemTool extends BaseToolWrapper {
 
   public getCallSummary(action: string, params: Record<string, unknown>): string {
     switch (action) {
-      case 'read':
-        return `Read file "${params.path}" with encoding ${params.encoding || 'utf8'}`;
+      case 'read': {
+        const lineRange = params.startLine || params.endLine
+          ? ` lines ${params.startLine || 1}-${params.endLine || 'end'}`
+          : '';
+        return `Read file "${params.path}"${lineRange}`;
+      }
 
       case 'write': {
         const content = params.content as string;
@@ -416,6 +708,12 @@ export class FilesystemTool extends BaseToolWrapper {
       case 'mkdir':
         return `Create directory "${params.path}"${params.recursive !== false ? ' (with parents)' : ''}`;
 
+      case 'tree':
+        return `Show tree of "${params.path}" (depth: ${params.maxDepth ?? 3}, format: ${params.format ?? 'string'})`;
+
+      case 'glob':
+        return `Find files matching "${params.pattern}"${params.path ? ` in "${params.path}"` : ''}`;
+
       default:
         return `Unknown action: ${action}`;
     }