@push.rocks/smartagent 1.0.2

package/dist_ts/smartagent.tools.http.js

@@ -0,0 +1,187 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './smartagent.interfaces.js';
+import { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * HTTP tool for making web requests
+ * Wraps @push.rocks/smartrequest
+ */
+export class HttpTool extends BaseToolWrapper {
+    name = 'http';
+    description = 'Make HTTP requests to web APIs and services';
+    actions = [
+        {
+            name: 'get',
+            description: 'Make a GET request',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL to request' },
+                    headers: { type: 'object', description: 'Request headers (key-value pairs)' },
+                    query: { type: 'object', description: 'Query parameters (key-value pairs)' },
+                    timeout: { type: 'number', description: 'Timeout in milliseconds' },
+                },
+                required: ['url'],
+            },
+        },
+        {
+            name: 'post',
+            description: 'Make a POST request with JSON body',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL to request' },
+                    body: { type: 'object', description: 'JSON body to send' },
+                    headers: { type: 'object', description: 'Request headers (key-value pairs)' },
+                    query: { type: 'object', description: 'Query parameters (key-value pairs)' },
+                    timeout: { type: 'number', description: 'Timeout in milliseconds' },
+                },
+                required: ['url'],
+            },
+        },
+        {
+            name: 'put',
+            description: 'Make a PUT request with JSON body',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL to request' },
+                    body: { type: 'object', description: 'JSON body to send' },
+                    headers: { type: 'object', description: 'Request headers (key-value pairs)' },
+                    timeout: { type: 'number', description: 'Timeout in milliseconds' },
+                },
+                required: ['url', 'body'],
+            },
+        },
+        {
+            name: 'patch',
+            description: 'Make a PATCH request with JSON body',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL to request' },
+                    body: { type: 'object', description: 'JSON body to send' },
+                    headers: { type: 'object', description: 'Request headers (key-value pairs)' },
+                    timeout: { type: 'number', description: 'Timeout in milliseconds' },
+                },
+                required: ['url', 'body'],
+            },
+        },
+        {
+            name: 'delete',
+            description: 'Make a DELETE request',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL to request' },
+                    headers: { type: 'object', description: 'Request headers (key-value pairs)' },
+                    timeout: { type: 'number', description: 'Timeout in milliseconds' },
+                },
+                required: ['url'],
+            },
+        },
+    ];
+    async initialize() {
+        // SmartRequest is stateless, no initialization needed
+        this.isInitialized = true;
+    }
+    async cleanup() {
+        this.isInitialized = false;
+    }
+    async execute(action, params) {
+        this.validateAction(action);
+        this.ensureInitialized();
+        try {
+            let request = plugins.smartrequest.SmartRequest.create().url(params.url);
+            // Add headers
+            if (params.headers && typeof params.headers === 'object') {
+                for (const [key, value] of Object.entries(params.headers)) {
+                    request = request.header(key, value);
+                }
+            }
+            // Add query parameters
+            if (params.query && typeof params.query === 'object') {
+                request = request.query(params.query);
+            }
+            // Add timeout
+            if (params.timeout) {
+                request = request.timeout(params.timeout);
+            }
+            // Add JSON body for POST, PUT, PATCH
+            if (params.body && ['post', 'put', 'patch'].includes(action)) {
+                request = request.json(params.body);
+            }
+            // Execute the request
+            let response;
+            switch (action) {
+                case 'get':
+                    response = await request.get();
+                    break;
+                case 'post':
+                    response = await request.post();
+                    break;
+                case 'put':
+                    response = await request.put();
+                    break;
+                case 'patch':
+                    response = await request.patch();
+                    break;
+                case 'delete':
+                    response = await request.delete();
+                    break;
+                default:
+                    return { success: false, error: `Unknown action: ${action}` };
+            }
+            // Parse response body
+            let body;
+            const contentType = response.headers?.['content-type'] || '';
+            try {
+                if (contentType.includes('application/json')) {
+                    body = await response.json();
+                }
+                else {
+                    body = await response.text();
+                }
+            }
+            catch {
+                body = null;
+            }
+            return {
+                success: response.ok,
+                result: {
+                    url: params.url,
+                    method: action.toUpperCase(),
+                    status: response.status,
+                    statusText: response.statusText,
+                    ok: response.ok,
+                    headers: response.headers,
+                    body,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    getCallSummary(action, params) {
+        const method = action.toUpperCase();
+        let summary = `${method} request to "${params.url}"`;
+        if (params.query && Object.keys(params.query).length > 0) {
+            const queryStr = JSON.stringify(params.query);
+            summary += ` with query: ${queryStr.length > 50 ? queryStr.substring(0, 50) + '...' : queryStr}`;
+        }
+        if (params.body) {
+            const bodyStr = JSON.stringify(params.body);
+            const preview = bodyStr.length > 100 ? bodyStr.substring(0, 100) + '...' : bodyStr;
+            summary += ` with body: ${preview}`;
+        }
+        if (params.headers && Object.keys(params.headers).length > 0) {
+            const headerKeys = Object.keys(params.headers).join(', ');
+            summary += ` with headers: [${headerKeys}]`;
+        }
+        return summary;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartagent.tools.shell.d.ts

@@ -0,0 +1,16 @@
+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 declare class ShellTool extends BaseToolWrapper {
+    name: string;
+    description: string;
+    actions: interfaces.IToolAction[];
+    private smartshell;
+    initialize(): Promise<void>;
+    cleanup(): Promise<void>;
+    execute(action: string, params: Record<string, unknown>): Promise<interfaces.IToolExecutionResult>;
+    getCallSummary(action: string, params: Record<string, unknown>): string;
+}

package/dist_ts/smartagent.tools.shell.js

@@ -0,0 +1,155 @@
+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 {
+    name = 'shell';
+    description = 'Execute shell commands securely. Uses execSpawn (shell:false) to prevent command injection.';
+    actions = [
+        {
+            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'],
+            },
+        },
+    ];
+    smartshell;
+    async initialize() {
+        this.smartshell = new plugins.smartshell.Smartshell({
+            executor: 'bash',
+        });
+        this.isInitialized = true;
+    }
+    async cleanup() {
+        this.isInitialized = false;
+    }
+    async execute(action, params) {
+        this.validateAction(action);
+        this.ensureInitialized();
+        try {
+            switch (action) {
+                case 'execute': {
+                    const command = params.command;
+                    const args = params.args || [];
+                    // Build options
+                    const options = {};
+                    if (params.timeout) {
+                        options.timeout = params.timeout;
+                    }
+                    if (params.env) {
+                        options.env = {
+                            ...process.env,
+                            ...params.env,
+                        };
+                    }
+                    // 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);
+                        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),
+            };
+        }
+    }
+    getCallSummary(action, params) {
+        switch (action) {
+            case 'execute': {
+                const command = params.command;
+                const args = params.args || [];
+                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).length > 0) {
+                    const envKeys = Object.keys(params.env).join(', ');
+                    summary += ` [env: ${envKeys}]`;
+                }
+                return summary;
+            }
+            case 'which':
+                return `Check if command "${params.command}" exists and get its path`;
+            default:
+                return `Unknown action: ${action}`;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/npmextra.json

@@ -0,0 +1,18 @@
+{
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
+      "gitrepo": "smartagent",
+      "description": "an agentic framework built on top of @push.rocks/smartai",
+      "npmPackagename": "@push.rocks/smartagent",
+      "license": "MIT",
+      "projectDomain": "push.rocks"
+    }
+  },
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@push.rocks/smartagent",
+  "version": "1.0.2",
+  "private": false,
+  "description": "an agentic framework built on top of @push.rocks/smartai",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "author": "Task Venture Capital GmbH",
+  "license": "MIT",
+  "devDependencies": {
+    "@git.zone/tsbuild": "^3.1.2",
+    "@git.zone/tsbundle": "^2.6.2",
+    "@git.zone/tsrun": "^2.0.0",
+    "@git.zone/tstest": "^3.1.3",
+    "@types/node": "^24.10.1"
+  },
+  "dependencies": {
+    "@push.rocks/smartai": "^0.8.0",
+    "@push.rocks/smartbrowser": "^2.0.8",
+    "@push.rocks/smartfs": "^1.2.0",
+    "@push.rocks/smartrequest": "^5.0.1",
+    "@push.rocks/smartshell": "^3.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://code.foss.global/push.rocks/smartagent.git"
+  },
+  "bugs": {
+    "url": "https://code.foss.global/push.rocks/smartagent/issues"
+  },
+  "homepage": "https://code.foss.global/push.rocks/smartagent#readme",
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "scripts": {
+    "test": "(tstest test/ --web)",
+    "build": "(tsbuild --web --allowimplicitany)",
+    "buildDocs": "(tsdoc)"
+  }
+}

package/readme.hints.md

@@ -0,0 +1,16 @@
+# Project Readme Hints
+
+## Overview
+`@push.rocks/smartagent` is an agentic framework built on top of `@push.rocks/smartai`. It provides autonomous AI agent capabilities including tool use, multi-step reasoning, and conversation memory.
+
+## Architecture
+- **SmartAgent**: Main class that wraps SmartAi and adds agentic behaviors
+- **plugins.ts**: Imports and re-exports smartai
+- **index.ts**: Main entry point, exports SmartAgent class and relevant types
+
+## Key Dependencies
+- `@push.rocks/smartai`: Provides the underlying multi-modal AI provider interface
+
+## Test Structure
+- Tests use `@git.zone/tstest/tapbundle`
+- Tests must end with `export default tap.start();`