update

ts/plugins.ts

@@ -3,6 +3,11 @@ import * as path from 'path';
 
 export { path };
 
+// third party
+import { minimatch } from 'minimatch';
+
+export { minimatch };
+
 // @push.rocks scope
 import * as smartai from '@push.rocks/smartai';
 import * as smartdeno from '@push.rocks/smartdeno';

ts/smartagent.classes.dualagent.ts

@@ -158,9 +158,10 @@ export class DualAgentOrchestrator {
   /**
    * Register a scoped filesystem tool that can only access files within the specified directory
    * @param basePath The directory to scope filesystem operations to
+   * @param excludePatterns Optional glob patterns to exclude from listings (e.g., ['.nogit/**', 'node_modules/**'])
    */
-  public registerScopedFilesystemTool(basePath: string): void {
-    const scopedTool = new FilesystemTool({ basePath });
+  public registerScopedFilesystemTool(basePath: string, excludePatterns?: string[]): void {
+    const scopedTool = new FilesystemTool({ basePath, excludePatterns });
     this.registerTool(scopedTool);
   }
 

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 })
+    );
   }
 
   /**
@@ -361,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: {
@@ -499,6 +523,11 @@ export class FilesystemTool extends BaseToolWrapper {
               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,
@@ -603,11 +632,14 @@ export class FilesystemTool extends BaseToolWrapper {
           const matches = await dir.list();
 
           // Return file paths relative to base path for readability
-          const files = matches.map((entry) => ({
-            path: entry.path,
-            relativePath: plugins.path.relative(basePath, entry.path),
-            isDirectory: entry.isDirectory,
-          }));
+          // 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,