@jclaw/core 0.6.1 → 0.8.0

package/dist/runtime/task-executor.js.backup

@@ -0,0 +1,295 @@
+/**
+ * Task Executor
+ *
+ * Manages task execution workflow including context retrieval,
+ * LLM interaction, and command execution.
+ *
+ * @module @jclaw/core/runtime/task-executor
+ */
+/**
+ * System prompt for the agent
+ */
+const DEFAULT_SYSTEM_PROMPT = `You are JClaw, a self-evolving AI agent.
+You help users complete tasks by:
+1. Understanding their request
+2. Planning the necessary steps
+3. Executing commands when needed
+4. Reporting results clearly
+
+Always think step by step and explain your reasoning.`;
+/**
+ * Task Executor
+ *
+ * Orchestrates task execution by:
+ * - Retrieving relevant context
+ * - Generating plans with LLM
+ * - Executing commands when needed
+ * - Handling errors and retries
+ *
+ * @example
+ * ```typescript
+ * const executor = new TaskExecutor({
+ *   llmClient: createLLMClient(config),
+ *   contextManager: openVikingClient,
+ *   executor: localExecutor
+ * });
+ *
+ * const result = await executor.execute({
+ *   id: 'task-1',
+ *   prompt: 'List all files in the current directory'
+ * });
+ * ```
+ */
+export class TaskExecutor {
+    config;
+    /**
+     * Create a new task executor instance.
+     *
+     * @param config - Configuration options
+     */
+    constructor(config) {
+        this.config = {
+            systemPrompt: DEFAULT_SYSTEM_PROMPT,
+            maxRetries: 3,
+            verbose: false,
+            ...config,
+        };
+    }
+    /**
+     * Execute a task and return the result.
+     *
+     * @param task - The task to execute
+     * @returns Promise resolving to task result
+     */
+    async execute(task) {
+        const startTime = Date.now();
+        let attempts = 0;
+        let lastError;
+        while (attempts < this.config.maxRetries) {
+            attempts++;
+            try {
+                const output = await this.executeTask(task);
+                const duration = Date.now() - startTime;
+                return {
+                    taskId: task.id,
+                    success: true,
+                    output,
+                    duration,
+                };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error.message : 'Unknown error';
+                this.log(`Attempt ${attempts} failed: ${lastError}`);
+                // Wait before retry (exponential backoff)
+                if (attempts < this.config.maxRetries) {
+                    await this.sleep(1000 * Math.pow(2, attempts - 1));
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        return {
+            taskId: task.id,
+            success: false,
+            error: `Task failed after ${attempts} attempts. Last error: ${lastError}`,
+            duration,
+        };
+    }
+    /**
+     * Internal method to execute a single task attempt.
+     */
+    async executeTask(task) {
+        // Build messages array
+        const messages = [
+            { role: 'system', content: this.config.systemPrompt },
+        ];
+        // Add context if available
+        if (this.config.contextManager) {
+            try {
+                const context = await this.config.contextManager.query(task.prompt, { topK: 5 });
+                if (context) {
+                    messages.push({
+                        role: 'system',
+                        content: `Relevant context:\n${context}`,
+                    });
+                }
+            }
+            catch {
+                this.log('Warning: Failed to retrieve context');
+            }
+        }
+        // Add user prompt
+        messages.push({ role: 'user', content: task.prompt });
+        // Add task context if provided
+        if (task.context) {
+            messages.push({
+                role: 'user',
+                content: `Additional context: ${JSON.stringify(task.context, null, 2)}`,
+            });
+        }
+        // Get LLM response
+        const response = await this.config.llmClient.chat(messages);
+        // Check if we need to execute commands
+        const commands = this.extractCommands(response.content);
+        if (commands.length > 0 && this.config.executor) {
+            for (const cmd of commands) {
+                this.log(`Executing command: ${cmd}`);
+                const result = await this.config.executor.execute(cmd, {
+                    mode: task.executionMode,
+                });
+                if (result.exitCode !== 0) {
+                    // Feed error back to LLM
+                    messages.push({ role: 'assistant', content: response.content });
+                    messages.push({
+                        role: 'user',
+                        content: `Command failed with exit code ${result.exitCode}:\n${result.stderr}`,
+                    });
+                    const retryResponse = await this.config.llmClient.chat(messages);
+                    return retryResponse.content;
+                }
+                // Feed output back to LLM
+                messages.push({ role: 'assistant', content: response.content });
+                messages.push({
+                    role: 'user',
+                    content: `Command output:\n${result.stdout}`,
+                });
+            }
+            const finalResponse = await this.config.llmClient.chat(messages);
+            return finalResponse.content;
+        }
+        return response.content;
+    }
+    /**
+     * Extract shell commands from LLM response.
+     *
+     * Looks for commands in code blocks marked as shell/bash.
+     */
+    extractCommands(content) {
+        const commands = [];
+        // Match ```shell or ```bash code blocks
+        const shellBlockRegex = /```(?:shell|bash|sh)\n([\s\S]*?)```/g;
+        let match;
+        while ((match = shellBlockRegex.exec(content)) !== null) {
+            const cmd = match[1]?.trim();
+            if (cmd && !cmd.startsWith('#')) {
+                commands.push(cmd);
+            }
+        }
+        return commands;
+    }
+    /**
+     * Log message if verbose mode is enabled.
+     */
+    log(message) {
+        if (this.config.verbose) {
+            console.log(`[TaskExecutor] ${message}`);
+        }
+    }
+    /**
+     * Sleep for specified milliseconds.
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Build system prompt with available capabilities.
+     */
+    buildSystemPrompt() {
+        let prompt = this.config.systemPrompt;
+        // Add available capabilities if registry exists
+        if (this.config.extensionRegistry) {
+            const capabilities = this.config.extensionRegistry.getCapabilityNames();
+            if (capabilities.length > 0) {
+                prompt += '\n\n## Available Capabilities\n\nYou have access to the following capabilities:\n';
+                capabilities.forEach(cap => {
+                    prompt += `- \`${cap}\` - Use this capability when appropriate\n`;
+                });
+                prompt += '\n### How to Use a Capability\n\n';
+                prompt += 'To use a capability, respond with a code block in this format:\n';
+                prompt += '```capability\n{\n  "name": "capability_name",\n  "input": { ... }\n}\n```\n\n';
+                prompt += 'The capability will be executed and the result will be provided to you.\n';
+            }
+        }
+        return prompt;
+    }
+    /**
+     * Extract capability call from LLM response.
+     */
+    extractCapabilityCall(content) {
+        // Match ```capability { ... } ``` blocks
+        const capabilityRegex = /```capability\s*\n([\s\S]*?)\n\s*```/;
+        const match = capabilityRegex.exec(content);
+        if (match && match[1]) {
+            try {
+                const parsed = JSON.parse(match[1].trim());
+                if (parsed.name && typeof parsed.name === 'string') {
+                    return {
+                        name: parsed.name,
+                        input: parsed.input || {}
+                    };
+                }
+            }
+            catch (e) {
+                this.log(`Failed to parse capability call: ${e}`);
+            }
+        }
+        return null;
+    }
+}
+/**
+ * Extract shell commands from LLM response.
+
+/**
+* Create a new task executor instance.
+*
+* @param config - Configuration options
+* @returns New TaskExecutor instance
+*/
+export function createTaskExecutor(config) {
+    return new TaskExecutor(config);
+}
+buildSystemPrompt();
+string;
+{
+    let prompt = this.config.systemPrompt;
+    // Add available capabilities if registry exists
+    if (this.config.extensionRegistry) {
+        const capabilities = this.config.extensionRegistry.getCapabilityNames();
+        if (capabilities.length > 0) {
+            prompt += '\n\n## Available Capabilities\n\nYou have access to the following capabilities:\n';
+            capabilities.forEach(cap => {
+                prompt += `- \`${cap}\` - Use this capability when appropriate\n`;
+            });
+            prompt += '\n### How to Use a Capability\n\n';
+            prompt += 'To use a capability, respond with a code block in this format:\n';
+            prompt += '```capability\n{\n  "name": "capability_name",\n  "input": { ... }\n}\n```\n\n';
+            prompt += 'The capability will be executed and the result will be provided to you.\n';
+        }
+    }
+    return prompt;
+}
+extractCapabilityCall(content, string);
+{
+    name: string;
+    input: unknown;
+}
+ | null;
+{
+    // Match ```capability { ... } ``` blocks
+    const capabilityRegex = /```capability\s*\n([\s\S]*?)\n\s*```/;
+    const match = capabilityRegex.exec(content);
+    if (match && match[1]) {
+        try {
+            const parsed = JSON.parse(match[1].trim());
+            if (parsed.name && typeof parsed.name === 'string') {
+                return {
+                    name: parsed.name,
+                    input: parsed.input || {}
+                };
+            }
+        }
+        catch (e) {
+            this.log(`Failed to parse capability call: ${e}`);
+        }
+    }
+    return null;
+}

package/package.json

@@ -1,18 +1,36 @@
 {
   "name": "@jclaw/core",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Universal self-evolving Agent with improved AutoSkill retry logic",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "bin": { "jclaw": "./dist/cli/jclaw.js" },
-  "exports": { ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" } },
-  "files": ["dist", "README.md"],
-  "scripts": {"build": "tsc"},
-  "keywords": ["ai", "agent", "cli", "self-evolving"],
+  "bin": {
+    "jclaw": "./dist/cli/jclaw.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "self-evolving"
+  ],
   "author": "JClaw Team",
   "license": "MIT",
   "dependencies": {
-    "glob": "^10.3.10"
+    "glob": "^10.3.10",
+    "memsearch-core": "^1.0.5"
   }
-}
+}