@oflow-ai/core 0.1.0

package/dist/tools/run-shell-command.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunShellCommandTool = void 0;
+const base_1 = require("./base");
+const child_process_1 = require("child_process");
+class RunShellCommandTool extends base_1.BaseTool {
+    name = 'run_shell_command';
+    description = 'Executes a shell command in the terminal. Supports both foreground and background execution.';
+    parameters = {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'The shell command to execute'
+            },
+            description: {
+                type: 'string',
+                description: 'Brief description of what the command does'
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in seconds (default: 120)'
+            },
+            run_in_bg: {
+                type: 'boolean',
+                description: 'If true, run command in background'
+            }
+        },
+        required: ['command']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['command']);
+        const timeout = (params.timeout || 120) * 1000;
+        const workingDir = options?.workingDirectory || process.cwd();
+        return new Promise((resolve) => {
+            const isWindows = process.platform === 'win32';
+            const shell = isWindows ? 'powershell.exe' : '/bin/bash';
+            const shellArgs = isWindows
+                ? ['-NoProfile', '-Command', params.command]
+                : ['-c', params.command];
+            const proc = (0, child_process_1.spawn)(shell, shellArgs, {
+                cwd: workingDir,
+                env: process.env,
+                timeout: timeout
+            });
+            let stdout = '';
+            let stderr = '';
+            let timeoutId = null;
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('error', (error) => {
+                resolve((0, base_1.formatToolError)(error));
+            });
+            proc.on('close', (code, signal) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                let output = `Command: ${params.command}\n`;
+                output += `Directory: ${workingDir}\n`;
+                output += `Exit Code: ${code}\n\n`;
+                if (stdout) {
+                    output += `Stdout:\n${stdout}\n`;
+                }
+                if (stderr) {
+                    output += `Stderr:\n${stderr}\n`;
+                }
+                resolve(output);
+            });
+            // Handle timeout
+            timeoutId = setTimeout(() => {
+                proc.kill();
+                resolve(`Command timed out after ${timeout / 1000} seconds`);
+            }, timeout);
+        });
+    }
+}
+exports.RunShellCommandTool = RunShellCommandTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/save-memory.d.ts

@@ -0,0 +1,22 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface SaveMemoryParams {
+    fact: string;
+}
+export declare class SaveMemoryTool extends BaseTool<SaveMemoryParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            fact: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    private memoryFile;
+    constructor();
+    execute(params: SaveMemoryParams, options?: ToolExecuteOptions): Promise<string>;
+}
+export {};

package/dist/tools/save-memory.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveMemoryTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class SaveMemoryTool extends base_1.BaseTool {
+    name = 'save_memory';
+    description = 'Saves a specific piece of information or fact to long-term memory for future sessions.';
+    parameters = {
+        type: 'object',
+        properties: {
+            fact: {
+                type: 'string',
+                description: 'The specific fact or piece of information to remember'
+            }
+        },
+        required: ['fact']
+    };
+    memoryFile;
+    constructor() {
+        super();
+        // 内存文件存储在用户主目录
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        const oflowDir = path.join(homeDir, '.oflow');
+        this.memoryFile = path.join(oflowDir, 'memory.json');
+    }
+    async execute(params, options) {
+        this.validateRequired(params, ['fact']);
+        try {
+            // 确保目录存在
+            const dir = path.dirname(this.memoryFile);
+            await fs.mkdir(dir, { recursive: true });
+            // 读取现有内存
+            let memories = [];
+            try {
+                const content = await fs.readFile(this.memoryFile, 'utf-8');
+                memories = JSON.parse(content);
+            }
+            catch {
+                // 文件不存在，使用空数组
+            }
+            // 添加新记忆
+            memories.push({
+                fact: params.fact,
+                createdAt: new Date().toISOString()
+            });
+            // 保存
+            await fs.writeFile(this.memoryFile, JSON.stringify(memories, null, 2), 'utf-8');
+            return `✓ Saved to memory: "${params.fact}"`;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+}
+exports.SaveMemoryTool = SaveMemoryTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/search-file-content.d.ts

@@ -0,0 +1,42 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface SearchFileContentParams {
+    pattern: string;
+    path?: string;
+    include?: string;
+    case_sensitive?: boolean;
+    context?: number;
+}
+export declare class SearchFileContentTool extends BaseTool<SearchFileContentParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            pattern: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            include: {
+                type: string;
+                description: string;
+            };
+            case_sensitive: {
+                type: string;
+                description: string;
+            };
+            context: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: SearchFileContentParams, options?: ToolExecuteOptions): Promise<string>;
+    private searchInDir;
+    private shouldInclude;
+}
+export {};

package/dist/tools/search-file-content.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchFileContentTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class SearchFileContentTool extends base_1.BaseTool {
+    name = 'search_file_content';
+    description = 'Searches for a pattern within files in a directory using regex.';
+    parameters = {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'The regular expression pattern to search for'
+            },
+            path: {
+                type: 'string',
+                description: 'Optional: The path to search within'
+            },
+            include: {
+                type: 'string',
+                description: 'Optional: A glob pattern to filter files'
+            },
+            case_sensitive: {
+                type: 'boolean',
+                description: 'If true, search is case-sensitive'
+            },
+            context: {
+                type: 'number',
+                description: 'Number of lines of context around matches'
+            }
+        },
+        required: ['pattern']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['pattern']);
+        const workingDir = options?.workingDirectory || process.cwd();
+        const searchPath = params.path || workingDir;
+        const caseSensitive = params.case_sensitive ?? false;
+        try {
+            const regex = new RegExp(params.pattern, caseSensitive ? 'g' : 'gi');
+            const results = [];
+            const maxResults = 500;
+            await this.searchInDir(searchPath, regex, params.include, results, maxResults);
+            if (results.length === 0) {
+                return `No matches found for pattern: ${params.pattern}`;
+            }
+            const output = results.map(r => {
+                return `${r.file}:${r.line}: ${r.content}`;
+            }).join('\n');
+            return `Found ${results.length} matches:\n\n${output}`;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+    async searchInDir(dir, regex, include, results, maxResults) {
+        if (results.length >= maxResults)
+            return;
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (results.length >= maxResults)
+                return;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) {
+                    continue;
+                }
+                await this.searchInDir(fullPath, regex, include, results, maxResults);
+            }
+            else if (entry.isFile()) {
+                if (!this.shouldInclude(fullPath, include)) {
+                    continue;
+                }
+                try {
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    const lines = content.split('\n');
+                    lines.forEach((line, index) => {
+                        if (results.length >= maxResults)
+                            return;
+                        const match = line.match(regex);
+                        if (match) {
+                            results.push({
+                                file: fullPath,
+                                line: index + 1,
+                                content: line.trim(),
+                                match: match[0]
+                            });
+                        }
+                    });
+                }
+                catch {
+                    // Skip files that can't be read as text
+                }
+            }
+        }
+    }
+    shouldInclude(filePath, include) {
+        if (!include) {
+            // Default: only text files
+            const ext = path.extname(filePath).toLowerCase();
+            const textExts = [
+                '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt',
+                '.py', '.java', '.c', '.cpp', '.h', '.go', '.rs',
+                '.yaml', '.yml', '.toml', '.ini', '.env', '.sh',
+                '.html', '.css', '.scss', '.less', '.vue', '.svelte'
+            ];
+            return textExts.includes(ext) || ext === '';
+        }
+        // Simple include pattern matching
+        if (include.startsWith('*.')) {
+            const ext = include.slice(1);
+            return filePath.endsWith(ext);
+        }
+        return filePath.includes(include);
+    }
+}
+exports.SearchFileContentTool = SearchFileContentTool;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-file-content.js","sourceRoot":"","sources":["../../src/tools/search-file-content.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTool, ToolExecuteOptions, formatToolError } from './base';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\ninterface SearchFileContentParams {\n  pattern: string;\n  path?: string;\n  include?: string;\n  case_sensitive?: boolean;\n  context?: number;\n}\n\ninterface SearchResult {\n  file: string;\n  line: number;\n  content: string;\n  match: string;\n}\n\nexport class SearchFileContentTool extends BaseTool<SearchFileContentParams> {\n  name = 'search_file_content';\n  description = 'Searches for a pattern within files in a directory using regex.';\n  parameters = {\n    type: 'object',\n    properties: {\n      pattern: {\n        type: 'string',\n        description: 'The regular expression pattern to search for'\n      },\n      path: {\n        type: 'string',\n        description: 'Optional: The path to search within'\n      },\n      include: {\n        type: 'string',\n        description: 'Optional: A glob pattern to filter files'\n      },\n      case_sensitive: {\n        type: 'boolean',\n        description: 'If true, search is case-sensitive'\n      },\n      context: {\n        type: 'number',\n        description: 'Number of lines of context around matches'\n      }\n    },\n    required: ['pattern']\n  };\n\n  async execute(params: SearchFileContentParams, options?: ToolExecuteOptions): Promise<string> {\n    this.validateRequired(params, ['pattern']);\n\n    const workingDir = options?.workingDirectory || process.cwd();\n    const searchPath = params.path || workingDir;\n    const caseSensitive = params.case_sensitive ?? false;\n\n    try {\n      const regex = new RegExp(params.pattern, caseSensitive ? 'g' : 'gi');\n      const results: SearchResult[] = [];\n      const maxResults = 500;\n\n      await this.searchInDir(searchPath, regex, params.include, results, maxResults);\n\n      if (results.length === 0) {\n        return `No matches found for pattern: ${params.pattern}`;\n      }\n\n      const output = results.map(r => {\n        return `${r.file}:${r.line}: ${r.content}`;\n      }).join('\\n');\n\n      return `Found ${results.length} matches:\\n\\n${output}`;\n    } catch (error) {\n      return formatToolError(error);\n    }\n  }\n\n  private async searchInDir(\n    dir: string,\n    regex: RegExp,\n    include: string | undefined,\n    results: SearchResult[],\n    maxResults: number\n  ): Promise<void> {\n    if (results.length >= maxResults) return;\n\n    const entries = await fs.readdir(dir, { withFileTypes: true });\n\n    for (const entry of entries) {\n      if (results.length >= maxResults) return;\n\n      const fullPath = path.join(dir, entry.name);\n\n      if (entry.isDirectory()) {\n        if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) {\n          continue;\n        }\n        await this.searchInDir(fullPath, regex, include, results, maxResults);\n      } else if (entry.isFile()) {\n        if (!this.shouldInclude(fullPath, include)) {\n          continue;\n        }\n\n        try {\n          const content = await fs.readFile(fullPath, 'utf-8');\n          const lines = content.split('\\n');\n\n          lines.forEach((line, index) => {\n            if (results.length >= maxResults) return;\n\n            const match = line.match(regex);\n            if (match) {\n              results.push({\n                file: fullPath,\n                line: index + 1,\n                content: line.trim(),\n                match: match[0]\n              });\n            }\n          });\n        } catch {\n          // Skip files that can't be read as text\n        }\n      }\n    }\n  }\n\n  private shouldInclude(filePath: string, include: string | undefined): boolean {\n    if (!include) {\n      // Default: only text files\n      const ext = path.extname(filePath).toLowerCase();\n      const textExts = [\n        '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt',\n        '.py', '.java', '.c', '.cpp', '.h', '.go', '.rs',\n        '.yaml', '.yml', '.toml', '.ini', '.env', '.sh',\n        '.html', '.css', '.scss', '.less', '.vue', '.svelte'\n      ];\n      return textExts.includes(ext) || ext === '';\n    }\n\n    // Simple include pattern matching\n    if (include.startsWith('*.')) {\n      const ext = include.slice(1);\n      return filePath.endsWith(ext);\n    }\n    return filePath.includes(include);\n  }\n}\n"]}

package/dist/tools/task.d.ts

@@ -0,0 +1,46 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface TaskParams {
+    description: string;
+    prompt: string;
+    subagent_type: 'general-purpose' | 'plan-agent' | 'explore-agent' | 'code-reviewer' | 'frontend-tester';
+    useContext?: boolean;
+    outputFormat?: string;
+    constraints?: string;
+}
+export declare class TaskTool extends BaseTool<TaskParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            description: {
+                type: string;
+                description: string;
+            };
+            prompt: {
+                type: string;
+                description: string;
+            };
+            subagent_type: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            useContext: {
+                type: string;
+                description: string;
+            };
+            outputFormat: {
+                type: string;
+                description: string;
+            };
+            constraints: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: TaskParams, options?: ToolExecuteOptions): Promise<string>;
+}
+export {};

package/dist/tools/task.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskTool = void 0;
+const base_1 = require("./base");
+class TaskTool extends base_1.BaseTool {
+    name = 'task';
+    description = 'Launch a specialized agent to handle complex, multi-step tasks autonomously. Available agents: general-purpose, plan-agent, explore-agent, code-reviewer, frontend-tester';
+    parameters = {
+        type: 'object',
+        properties: {
+            description: {
+                type: 'string',
+                description: 'A short (3-5 word) description of the task'
+            },
+            prompt: {
+                type: 'string',
+                description: 'The detailed task description for the agent'
+            },
+            subagent_type: {
+                type: 'string',
+                enum: ['general-purpose', 'plan-agent', 'explore-agent', 'code-reviewer', 'frontend-tester'],
+                description: 'The type of specialized agent to use'
+            },
+            useContext: {
+                type: 'boolean',
+                description: 'Whether to include the main agent context'
+            },
+            outputFormat: {
+                type: 'string',
+                description: 'Optional output format template'
+            },
+            constraints: {
+                type: 'string',
+                description: 'Optional constraints or limitations'
+            }
+        },
+        required: ['description', 'prompt', 'subagent_type']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['description', 'prompt', 'subagent_type']);
+        // 返回任务信息，由上层处理
+        return JSON.stringify({
+            type: 'agent_task',
+            description: params.description,
+            prompt: params.prompt,
+            subagent_type: params.subagent_type,
+            useContext: params.useContext,
+            outputFormat: params.outputFormat,
+            constraints: params.constraints
+        });
+    }
+}
+exports.TaskTool = TaskTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/web-fetch.d.ts

@@ -0,0 +1,26 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface WebFetchParams {
+    url: string;
+    prompt?: string;
+}
+export declare class WebFetchTool extends BaseTool<WebFetchParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            url: {
+                type: string;
+                description: string;
+            };
+            prompt: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: WebFetchParams, options?: ToolExecuteOptions): Promise<string>;
+    private extractTextFromHtml;
+}
+export {};