@push.rocks/smartagent 1.8.0 → 3.0.1

package/ts/smartagent.tools.search.ts

@@ -1,237 +0,0 @@
-import * as interfaces from './smartagent.interfaces.js';
-import { BaseToolWrapper } from './smartagent.tools.base.js';
-import { ToolRegistry } from './smartagent.classes.toolregistry.js';
-
-/**
- * ToolSearchTool - AI-facing interface for discovering and activating tools
- *
- * This tool enables the Driver to:
- * - Search for tools by capability
- * - List all available tools
- * - Activate on-demand tools
- * - Get detailed information about specific tools
- */
-export class ToolSearchTool extends BaseToolWrapper {
-  public name = 'tools';
-  public description =
-    'Search for and activate available tools and experts. Use this to discover specialized capabilities.';
-
-  public actions: interfaces.IToolAction[] = [
-    {
-      name: 'search',
-      description: 'Search for tools by name, description, tags, or capabilities',
-      parameters: {
-        type: 'object',
-        properties: {
-          query: { type: 'string', description: 'Search query' },
-        },
-        required: ['query'],
-      },
-    },
-    {
-      name: 'list',
-      description: 'List all available tools grouped by visibility',
-      parameters: { type: 'object', properties: {} },
-    },
-    {
-      name: 'activate',
-      description: 'Activate an on-demand tool to make it available for use',
-      parameters: {
-        type: 'object',
-        properties: {
-          name: { type: 'string', description: 'Name of the tool to activate' },
-        },
-        required: ['name'],
-      },
-    },
-    {
-      name: 'details',
-      description: 'Get detailed information about a specific tool',
-      parameters: {
-        type: 'object',
-        properties: {
-          name: { type: 'string', description: 'Name of the tool' },
-        },
-        required: ['name'],
-      },
-    },
-  ];
-
-  private registry: ToolRegistry;
-  private onToolActivated?: (tool: BaseToolWrapper) => void;
-
-  constructor(registry: ToolRegistry, onToolActivated?: (tool: BaseToolWrapper) => void) {
-    super();
-    this.registry = registry;
-    this.onToolActivated = onToolActivated;
-  }
-
-  async initialize(): Promise<void> {
-    this.isInitialized = true;
-  }
-
-  async cleanup(): Promise<void> {
-    this.isInitialized = false;
-  }
-
-  async execute(
-    action: string,
-    params: Record<string, unknown>
-  ): Promise<interfaces.IToolExecutionResult> {
-    this.validateAction(action);
-
-    switch (action) {
-      case 'search':
-        return this.handleSearch(params.query as string);
-      case 'list':
-        return this.handleList();
-      case 'activate':
-        return this.handleActivate(params.name as string);
-      case 'details':
-        return this.handleDetails(params.name as string);
-      default:
-        return { success: false, error: `Unknown action: ${action}` };
-    }
-  }
-
-  private handleSearch(query: string): interfaces.IToolExecutionResult {
-    const results = this.registry.search(query);
-    return {
-      success: true,
-      result: results.map((m) => ({
-        name: m.name,
-        description: m.description,
-        visibility: m.visibility,
-        isActivated: m.isActivated,
-        category: m.category,
-        tags: m.tags,
-        actionCount: m.actions.length,
-      })),
-      summary: `Found ${results.length} tools matching "${query}"`,
-    };
-  }
-
-  private handleList(): interfaces.IToolExecutionResult {
-    const all = this.registry.getAllMetadata();
-    const initial = all.filter((m) => m.visibility === 'initial');
-    const onDemand = all.filter((m) => m.visibility === 'on-demand');
-
-    return {
-      success: true,
-      result: {
-        initial: initial.map((m) => ({
-          name: m.name,
-          description: m.description,
-          category: m.category,
-        })),
-        onDemand: onDemand.map((m) => ({
-          name: m.name,
-          description: m.description,
-          category: m.category,
-          isActivated: m.isActivated,
-        })),
-        summary: `${initial.length} initial, ${onDemand.length} on-demand`,
-      },
-    };
-  }
-
-  private async handleActivate(name: string): Promise<interfaces.IToolExecutionResult> {
-    const result = await this.registry.activate(name);
-
-    if (result.success && this.onToolActivated) {
-      const tool = this.registry.getTool(name);
-      if (tool) {
-        this.onToolActivated(tool);
-      }
-    }
-
-    return {
-      success: result.success,
-      result: result.success ? { name, message: `Tool "${name}" is now available` } : undefined,
-      error: result.error,
-      summary: result.success ? `Activated: ${name}` : result.error,
-    };
-  }
-
-  private handleDetails(name: string): interfaces.IToolExecutionResult {
-    const tool = this.registry.getTool(name);
-    const meta = this.registry.getMetadata(name);
-
-    if (!tool || !meta) {
-      return { success: false, error: `Tool "${name}" not found` };
-    }
-
-    return {
-      success: true,
-      result: {
-        name: meta.name,
-        description: meta.description,
-        visibility: meta.visibility,
-        isActivated: meta.isActivated,
-        category: meta.category,
-        tags: meta.tags,
-        actions: meta.actions,
-        fullExplanation: tool.getToolExplanation(),
-      },
-    };
-  }
-
-  getCallSummary(action: string, params: Record<string, unknown>): string {
-    switch (action) {
-      case 'search':
-        return `Search tools: "${params.query}"`;
-      case 'list':
-        return 'List all tools';
-      case 'activate':
-        return `Activate tool: ${params.name}`;
-      case 'details':
-        return `Get details: ${params.name}`;
-      default:
-        return `tools.${action}`;
-    }
-  }
-
-  getToolExplanation(): string {
-    return `## Tool: tools
-Search for and manage available tools and experts.
-
-### Actions:
-
-**search** - Find tools by capability
-\`\`\`
-<tool_call>
-  <tool>tools</tool>
-  <action>search</action>
-  <params>{"query": "database"}</params>
-</tool_call>
-\`\`\`
-
-**list** - List all tools grouped by visibility
-\`\`\`
-<tool_call>
-  <tool>tools</tool>
-  <action>list</action>
-  <params>{}</params>
-</tool_call>
-\`\`\`
-
-**activate** - Activate an on-demand tool
-\`\`\`
-<tool_call>
-  <tool>tools</tool>
-  <action>activate</action>
-  <params>{"name": "database_expert"}</params>
-</tool_call>
-\`\`\`
-
-**details** - Get full information about a tool
-\`\`\`
-<tool_call>
-  <tool>tools</tool>
-  <action>details</action>
-  <params>{"name": "filesystem"}</params>
-</tool_call>
-\`\`\`
-`;
-  }
-}

package/ts/smartagent.tools.shell.ts

@@ -1,230 +0,0 @@
-import * as plugins from './plugins.js';
-import * as interfaces from './smartagent.interfaces.js';
-import { BaseToolWrapper } from './smartagent.tools.base.js';
-
-/**
- * Shell tool for executing commands securely
- * Wraps @push.rocks/smartshell with execSpawn for safety (no shell injection)
- */
-export class ShellTool extends BaseToolWrapper {
-  public name = 'shell';
-  public description =
-    'Execute shell commands securely. Uses execSpawn (shell:false) to prevent command injection.';
-
-  public actions: interfaces.IToolAction[] = [
-    {
-      name: 'execute',
-      description:
-        'Execute a command with arguments (secure, no shell injection possible). Command and args are passed separately.',
-      parameters: {
-        type: 'object',
-        properties: {
-          command: {
-            type: 'string',
-            description: 'The command to execute (e.g., "ls", "cat", "grep", "node")',
-          },
-          args: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Array of arguments (each argument is properly escaped)',
-          },
-          cwd: { type: 'string', description: 'Working directory for the command' },
-          timeout: { type: 'number', description: 'Timeout in milliseconds' },
-          env: {
-            type: 'object',
-            description: 'Additional environment variables (key-value pairs)',
-          },
-        },
-        required: ['command'],
-      },
-    },
-    {
-      name: 'which',
-      description: 'Check if a command exists and get its path',
-      parameters: {
-        type: 'object',
-        properties: {
-          command: { type: 'string', description: 'Command name to look up (e.g., "node", "git")' },
-        },
-        required: ['command'],
-      },
-    },
-  ];
-
-  private smartshell!: plugins.smartshell.Smartshell;
-
-  public async initialize(): Promise<void> {
-    this.smartshell = new plugins.smartshell.Smartshell({
-      executor: 'bash',
-    });
-    this.isInitialized = true;
-  }
-
-  public async cleanup(): Promise<void> {
-    this.isInitialized = false;
-  }
-
-  public async execute(
-    action: string,
-    params: Record<string, unknown>
-  ): Promise<interfaces.IToolExecutionResult> {
-    this.validateAction(action);
-    this.ensureInitialized();
-
-    try {
-      switch (action) {
-        case 'execute': {
-          const command = params.command as string;
-          const args = (params.args as string[]) || [];
-
-          // Build options
-          const options: {
-            timeout?: number;
-            env?: NodeJS.ProcessEnv;
-            cwd?: string;
-          } = {};
-
-          if (params.timeout) {
-            options.timeout = params.timeout as number;
-          }
-
-          if (params.env) {
-            options.env = {
-              ...process.env,
-              ...(params.env as NodeJS.ProcessEnv),
-            };
-          }
-
-          // Use execSpawn for security - no shell injection possible
-          const result = await this.smartshell.execSpawn(command, args, options);
-
-          return {
-            success: result.exitCode === 0,
-            result: {
-              command,
-              args,
-              exitCode: result.exitCode,
-              stdout: result.stdout,
-              stderr: result.stderr,
-              signal: result.signal,
-            },
-          };
-        }
-
-        case 'which': {
-          try {
-            const commandPath = await plugins.smartshell.which(params.command as string);
-            return {
-              success: true,
-              result: {
-                command: params.command,
-                path: commandPath,
-                exists: true,
-              },
-            };
-          } catch {
-            return {
-              success: true,
-              result: {
-                command: params.command,
-                path: null,
-                exists: false,
-              },
-            };
-          }
-        }
-
-        default:
-          return {
-            success: false,
-            error: `Unknown action: ${action}`,
-          };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-
-  public getToolExplanation(): string {
-    return `## Tool: shell
-Execute shell commands securely. Uses execSpawn (shell:false) to prevent command injection.
-
-### Actions:
-
-**execute** - Execute a command with arguments (secure, no shell injection possible)
-Parameters:
-  - command (required): The command to execute (e.g., "ls", "cat", "grep", "node")
-  - args (optional): Array of arguments (each argument is properly escaped)
-  - cwd (optional): Working directory for the command
-  - timeout (optional): Timeout in milliseconds
-  - env (optional): Additional environment variables (key-value object)
-
-Example - List files:
-<tool_call>
-  <tool>shell</tool>
-  <action>execute</action>
-  <params>{"command": "ls", "args": ["-la", "/path/to/dir"]}</params>
-</tool_call>
-
-Example - Run Node script:
-<tool_call>
-  <tool>shell</tool>
-  <action>execute</action>
-  <params>{"command": "node", "args": ["script.js"], "cwd": "/path/to/project"}</params>
-</tool_call>
-
-Example - Search in files:
-<tool_call>
-  <tool>shell</tool>
-  <action>execute</action>
-  <params>{"command": "grep", "args": ["-r", "pattern", "src/"]}</params>
-</tool_call>
-
-**which** - Check if a command exists and get its path
-Parameters:
-  - command (required): Command name to look up (e.g., "node", "git")
-
-Example:
-<tool_call>
-  <tool>shell</tool>
-  <action>which</action>
-  <params>{"command": "node"}</params>
-</tool_call>
-`;
-  }
-
-  public getCallSummary(action: string, params: Record<string, unknown>): string {
-    switch (action) {
-      case 'execute': {
-        const command = params.command as string;
-        const args = (params.args as string[]) || [];
-        const fullCommand = [command, ...args].join(' ');
-        let summary = `Execute: ${fullCommand}`;
-
-        if (params.cwd) {
-          summary += ` (in ${params.cwd})`;
-        }
-
-        if (params.timeout) {
-          summary += ` [timeout: ${params.timeout}ms]`;
-        }
-
-        if (params.env && Object.keys(params.env as object).length > 0) {
-          const envKeys = Object.keys(params.env as object).join(', ');
-          summary += ` [env: ${envKeys}]`;
-        }
-
-        return summary;
-      }
-
-      case 'which':
-        return `Check if command "${params.command}" exists and get its path`;
-
-      default:
-        return `Unknown action: ${action}`;
-    }
-  }
-}