foliko 2.0.5 → 2.0.7

package/sandbox/test-fixes.js

@@ -0,0 +1,40 @@
+const fs = require('fs');
+const path = require('path');
+
+const helloPath = path.resolve('.foliko/workflows/hello-js.js');
+delete require.cache[helloPath];
+const helloModule = require(helloPath);
+
+const t = typeof helloModule;
+console.log('hello-js.js type:', t);
+
+if (t === 'function') {
+  try {
+    const wf = helloModule({});
+    console.log('returned keys:', Object.keys(wf));
+    console.log(
+      'steps count:',
+      Array.isArray(wf.steps) ? wf.steps.length : 'N/A'
+    );
+    console.log('OK: js workflow shape is v2 compatible');
+  } catch (e) {
+    console.log('execution failed (expected):', e.message);
+  }
+}
+
+// Also verify the manager.js and workflow/index.js parse OK
+const filesToCheck = [
+  'src/plugin/manager.js',
+  'plugins/core/workflow/index.js',
+];
+
+for (const rel of filesToCheck) {
+  const p = path.resolve(rel);
+  delete require.cache[p];
+  try {
+    const m = require(p);
+    console.log(`OK ${rel}: parsed, exports=`, Object.keys(m).slice(0, 5));
+  } catch (e) {
+    console.log(`FAIL ${rel}:`, e.message);
+  }
+}

package/sandbox/test-hello-js.js

@@ -0,0 +1,46 @@
+(async () => {
+  try {
+    const { JsRunner } = require('../plugins/core/workflow/js-runner');
+    const stubFramework = {
+      executeTool: async (name, args, sid) => {
+        console.log('  [tool]', name, JSON.stringify(args));
+        return { success: true, data: 'tool_ok', echo: args };
+      },
+      runWithContext: async (ctx, fn) => fn(),
+      getExecutionContext: () => ({ sessionId: 'test-session' })
+    };
+    // Override the proxy used by JsRunner to bind tool/extension/etc.
+    // (see fix in _createFlowApi below)
+    const origRequire = require.cache[require.resolve('../plugins/core/workflow/js-runner.js')].exports;
+    console.log('JsRunner exports:', Object.keys(origRequire));
+    console.log('tool keys at runtime:');
+    const { FlowContext } = require('../plugins/core/workflow/context');
+    const c = new FlowContext({}, 'sid');
+    c.setFramework(stubFramework);
+    const t = c.tool;
+    console.log(' t:', t);
+    console.log(' Object.getOwnPropertyNames:', Object.getOwnPropertyNames(t));
+    console.log(' for-in:');
+    for (const k in t) { console.log('   -', k); }
+    console.log(' execute type:', typeof t.execute);
+    const r = new JsRunner(stubFramework);
+    const wfPath = require.resolve('../.foliko/workflows/hello-js.js');
+    delete require.cache[wfPath];
+    const wf = require(wfPath);
+    const res = await r.execute(wf, {}, 'test-session');
+    console.log('Result:', JSON.stringify(res, null, 2));
+
+    // Direct test of $.tool
+    console.log('Direct $.tool test...');
+    const $obj = { data: {}, get tool() { return c.tool; }, push: () => {}, next: () => {} };
+    try {
+      const out = await $.tool.execute('notification_send', { title: 'x', message: 'y' });
+      console.log('Direct $.tool result:', out);
+    } catch (e) {
+      console.log('Direct $.tool error:', e.message);
+    }
+  } catch (err) {
+    console.error('OUTER ERROR:', err && err.stack || err);
+    process.exit(1);
+  }
+})();

package/skills/foliko/AGENTS.md

@@ -63,19 +63,18 @@ module.exports = function (Plugin) {
       this.priority = 10;
     }
 
-    install(framework) {
-      const { z } = require('zod');
-      framework.registerTool({
+    onStart(framework) {
+      // Register AI SDK tool
+      this.tool.register({
         name: 'my_tool',
         description: '工具描述',
-        inputSchema: z.object({
-          param: z.string().describe('参数描述'),
+        inputSchema: framework.z.object({
+          param: framework.z.string().describe('参数描述'),
         }),
-        execute: async (args, framework) => {
+        execute: async (args) => {
           return { success: true, result: args.param };
         },
       });
-      return this;
     }
 
     uninstall(framework) {
@@ -119,18 +118,17 @@ class MyPlugin extends Plugin {
     this.priority = 10;
   }
 
-  install(framework) {
-    framework.registerTool({
+  onStart(framework) {
+    this.tool.register({
       name: 'my_tool',
       description: '工具描述',
-      inputSchema: z.object({
-        param: z.string().describe('参数描述'),
+      inputSchema: framework.z.object({
+        param: framework.z.string().describe('参数描述'),
       }),
-      execute: async (args, framework) => {
+      execute: async (args) => {
         return { success: true, result: args.param };
       },
     });
-    return this;
   }
 
   uninstall(framework) {}
@@ -150,47 +148,204 @@ module.exports = { MyPlugin };
 
 ## Lifecycle Methods
 
-| Method                 | Called When        | Required    |
-| ---------------------- | ------------------ | ----------- |
-| `install(framework)`   | Plugin installed   | ✅          |
-| `start(framework)`     | Plugin started     | Recommended |
-| `reload(framework)`    | Hot reload         | Optional    |
-| `uninstall(framework)` | Plugin uninstalled | Recommended |
+| Method | Called When | Required | Description |
+|--------|-------------|----------|-------------|
+| `install(framework)` | Plugin installed | ✅ | Initialize, get framework |
+| `onStart(framework)` | start/enable/reload | Recommended | Register tools, extensions, sub-agents |
+| `onStop()` | disable | Optional | Cleanup resources |
+| `reload(framework)` | Hot reload | Optional | prompts auto cleanup/register |
+| `uninstall(framework)` | Plugin uninstalled | Recommended | Cleanup resources |
+
+### onStart / onStop (Recommended)
+
+**Use `onStart` to register tools and extensions** - base class handles lifecycle automatically:
+
+```javascript
+class MyPlugin extends Plugin {
+  name = 'my-plugin';
+  version = '1.0.0';
+  description = '我的插件';
+
+  onStart(framework) {
+    // Register AI SDK tool (direct call)
+    this.tool.register({
+      name: 'hello',
+      description: '打招呼',
+      inputSchema: framework.z.object({
+        name: framework.z.string().describe('姓名')
+      }),
+      execute: async (args) => ({ message: `Hello, ${args.name}!` }),
+    });
+
+    // Register extension tool (via ext_call)
+    this.extension.register({
+      name: 'greet',
+      description: '打招呼扩展',
+      inputSchema: framework.z.object({
+        name: framework.z.string()
+      }),
+      execute: async (args) => ({ message: `Hi, ${args.name}!` }),
+    });
+  }
+}
+```
+
+### Lifecycle Auto-Management
+
+| Operation | Effect |
+|-----------|--------|
+| `disable` | Auto-remove tools/extensions (keep registration records) |
+| `enable` | Auto re-register tools/extensions |
+| `reload` | Remove and re-register |
+| `uninstall` | Remove and clear registration records |
 
 ## Tool Registration
 
-In `install()` method, register tools using `framework.registerTool()`:
+### Recommended: `this.tool.register()` in `onStart`
+
+```javascript
+onStart(framework) {
+  this.tool.register({
+    name: 'my_tool',
+    description: 'Tool description',
+    inputSchema: framework.z.object({
+      param: framework.z.string().describe('Parameter description')
+    }),
+    execute: async (args) => ({ success: true, result: args.param })
+  });
+}
+```
+
+### Alternative: `this.tools = {}` (ExtensionExecutor auto-scan)
+
+```javascript
+class MyPlugin extends Plugin {
+  name = 'my-plugin';
+
+  tools = {
+    my_tool: {
+      description: 'Tool description',
+      inputSchema: z.object({
+        param: z.string().describe('Parameter description')
+      }),
+      execute: async (args) => ({ success: true })
+    }
+  };
+}
+```
+
+### Legacy: `framework.registerTool()` in `install()`
 
 ```javascript
 install(framework) {
-  const { z } = require('zod')
   framework.registerTool({
     name: 'my_tool',
-    description: '工具描述',
-    inputSchema: z.object({
-      param: z.string().describe('参数描述')
+    description: 'Tool description',
+    inputSchema: framework.z.object({
+      param: framework.z.string().describe('Parameter description')
     }),
-    execute: async (args, framework) => {
-      return { success: true, result: args.param }
-    }
-  })
-  return this
+    execute: async (args) => ({ success: true })
+  });
+  return this;
+}
+```
+
+## Extension Registration
+
+```javascript
+onStart(framework) {
+  this.extension.register({
+    name: 'my_ext_tool',
+    description: 'Extension tool',
+    inputSchema: framework.z.object({
+      param: framework.z.string()
+    }),
+    execute: async (args) => ({ success: true })
+  });
 }
 ```
 
+## Tool/Extension Operations
+
+```javascript
+// Register
+this.tool.register({ name: 'xxx', ... });
+this.extension.register({ name: 'xxx', ... });
+
+// Remove
+this.tool.remove('xxx');
+this.extension.remove('xxx');
+
+// Execute
+const r1 = await this.tool.execute('any-tool', { arg: 'value' });  // Execute any registered tool
+const r2 = await this.extension.execute('xxx', { arg: 'value' });  // Execute current plugin's extension
+const r3 = await this.extension.execute('plugin-name', 'xxx', { arg: 'value' }); // Execute specified plugin's extension
+```
+
+## Workflow Operations
+
+```javascript
+// Register workflow
+this.workflow.register('my-workflow', {
+  name: 'my-workflow',
+  description: 'My workflow',
+  steps: [
+    { type: 'tool', tool: 'hello', args: {} }
+  ]
+});
+
+// Execute workflow
+const result = await this.workflow.execute('my-workflow', { input: 'value' });
+
+// Remove workflow
+this.workflow.remove('my-workflow');
+```
+
+## Agent Operations
+
+```javascript
+// Register sub-agent
+this.agent.register({
+  name: 'my-agent',
+  role: 'Assistant',
+  goal: 'Description',
+  tools: {},
+  parentTools: ['read_file', 'write_file']
+});
+
+// Get sub-agent
+const agent = this.agent.get('my-agent');
+
+// Remove sub-agent
+this.agent.remove('my-agent');
+```
+
+## Prompt Operations
+
+```javascript
+// Register prompt
+this.prompt.register('my-prompt', () => 'Prompt content', {
+  scope: 'global',
+  priority: 50
+});
+
+// Remove prompt
+this.prompt.remove('my-prompt');
+```
+
 ## Framework Object
 
 The framework object provides:
 
-| Method                              | Description                     |
-| ----------------------------------- | ------------------------------- |
-| `framework.registerTool(tool)`      | Register tool                   |
-| `framework.getTools()`              | Get all tools                   |
-| `framework.executeTool(name, args)` | Execute tool                    |
-| `framework.callTool(name, args)`    | Call tool (for installing deps) |
-| `framework.createAgent(config)`     | Create Agent                    |
-| `framework.reloadPlugin(name)`      | Reload single plugin            |
-| `framework.reloadAllPlugins()`      | Reload all plugins              |
+| Method | Description |
+|--------|-------------|
+| `framework.registerTool(tool)` | Register tool (legacy) |
+| `framework.getTools()` | Get all tools |
+| `framework.executeTool(name, args)` | Execute tool |
+| `framework.callTool(name, args)` | Call tool (for installing deps) |
+| `framework.createAgent(config)` | Create Agent |
+| `framework.reloadPlugin(name)` | Reload single plugin |
+| `framework.reloadAllPlugins()` | Reload all plugins |
 
 ## Dependency Management
 
@@ -229,8 +384,6 @@ await framework.callTool('install', {
 
 ## Common Mistakes
 
-1. ❌ Forgetting `install()` - tools won't be registered
-2. ❌ Forgetting `return this` - chain calls will fail
-3. ❌ Using `parameters` instead of `inputSchema`
-4. ❌ Registering tools outside `install()`
-5. ❌ Using same name for folder and file - folder takes priority, file will be ignored
+1. ❌ Using `parameters` instead of `inputSchema`
+2. ❌ Forgetting `framework.` prefix when using `framework.z.object()`
+3. ❌ Using same name for folder and file - folder takes priority, file will be ignored

package/skills/foliko/SKILL.md

@@ -341,28 +341,69 @@ module.exports = MyPlugin;
 
 ## 生命周期
 
-| 方法                   | 调用时机   | 必须实现 |
-| ---------------------- | ---------- | -------- |
-| `install(framework)`   | 插件安装时 | ✅       |
-| `start(framework)`     | 插件启动时 | 推荐     |
-| `reload(framework)`    | 热重载时   | 可选     |
-| `uninstall(framework)` | 卸载时     | 推荐     |
+| 方法 | 调用时机 | 必须实现 | 说明 |
+|------|----------|----------|------|
+| `install(framework)` | 插件安装时 | ✅ | 初始化，获取 framework |
+| `onStart(framework)` | start/enable/reload 时 | 推荐 | 注册工具、扩展、子代理 |
+| `onStop()` | disable 时 | 可选 | 清理资源 |
+| `reload(framework)` | 热重载时 | 可选 | prompts 自动清理/注册 |
+| `uninstall(framework)` | 卸载时 | 推荐 | 清理资源 |
+
+### onStart / onStop（推荐方式）
+
+**推荐使用 `onStart` 注册工具和扩展**，基类自动处理生命周期：
+
+```javascript
+class MyPlugin extends Plugin {
+  name = 'my-plugin';
+  version = '1.0.0';
+  description = '我的工具插件';
+
+  onStart(framework) {
+    // 注册 AI SDK 工具（直接调用）
+    this.tool.register({
+      name: 'hello',
+      description: '打招呼',
+      inputSchema: framework.z.object({
+        name: framework.z.string().describe('姓名')
+      }),
+      execute: async (args) => ({ message: `Hello, ${args.name}!` }),
+    });
+
+    // 注册扩展工具（通过 ext_call 调用）
+    this.extension.register({
+      name: 'greet',
+      description: '打招呼扩展',
+      inputSchema: framework.z.object({
+        name: framework.z.string()
+      }),
+      execute: async (args) => ({ message: `Hi, ${args.name}!` }),
+    });
+  }
+}
+```
+
+### 生命周期自动管理
+
+| 操作 | 效果 |
+|------|------|
+| `disable` | 自动移除工具/扩展（保留注册记录） |
+| `enable` | 自动重新注册工具/扩展 |
+| `reload` | 移除后重新注册 |
+| `uninstall` | 移除并清空注册记录 |
 
 ---
 
 ## 注册工具
 
-### 最新方式：定义在 `this.tools = {}`
+### 方式1：`this.tools = {}`（ExtensionExecutor 自动扫描）
 
-插件将工具定义在 `this.tools = {}` 中，ExtensionExecutor 会自动扫描并注册到系统提示词：
+插件将工具定义在 `this.tools = {}` 中，ExtensionExecutor 会自动扫描并注册：
 
 ```javascript
 class MyPlugin extends Plugin {
-  constructor(config = {}) {
-    super();
-    this.name = 'my-plugin';
-    this.description = '我的工具插件';
-  }
+  name = 'my-plugin';
+  description = '我的工具插件';
 
   tools = {
     my_tool: {
@@ -378,37 +419,125 @@ class MyPlugin extends Plugin {
 }
 ```
 
-### 方式2：使用 `this.registerTool()`
+### 方式2：`this.tool.register()`（推荐）
 
-支持两种调用格式：
+在 `onStart` 中使用，支持完整的生命周期管理：
 
 ```javascript
-install(framework) {
-  const { z } = require('zod');
-
-  // 方式1：分开传 name 和 def
-  this.registerTool('my_tool', {
+onStart(framework) {
+  this.tool.register({
+    name: 'my_tool',
     description: '我的工具',
-    inputSchema: z.object({
-      param: z.string().describe('参数描述')
+    inputSchema: framework.z.object({
+      param: framework.z.string().describe('参数描述')
     }),
     execute: async (args) => {
       return { success: true, result: args.param };
     }
   });
+}
+```
 
-  // 方式2：直接传对象（name 在对象中）
-  this.registerTool({
-    name: 'another_tool',
-    description: '另一个工具',
-    inputSchema: z.object({}),
+### 方式3：`this.registerTool()`（旧方式）
+
+```javascript
+install(framework) {
+  this.registerTool('my_tool', {
+    description: '我的工具',
+    inputSchema: framework.z.object({
+      param: framework.z.string().describe('参数描述')
+    }),
     execute: async (args) => ({ success: true })
   });
-
   return this;
 }
 ```
 
+### 注册扩展工具
+
+```javascript
+onStart(framework) {
+  this.extension.register({
+    name: 'my_ext_tool',
+    description: '扩展工具',
+    inputSchema: framework.z.object({
+      param: framework.z.string()
+    }),
+    execute: async (args) => ({ success: true })
+  });
+}
+```
+
+---
+
+## 工具/扩展操作
+
+```javascript
+// 注册
+this.tool.register({ name: 'xxx', ... });
+this.extension.register({ name: 'xxx', ... });
+
+// 移除
+this.tool.remove('xxx');
+this.extension.remove('xxx');
+
+// 执行
+const r1 = await this.tool.execute('any-tool', { arg: 'value' });  // 执行任何已注册工具
+const r2 = await this.extension.execute('xxx', { arg: 'value' });  // 执行当前插件的扩展
+const r3 = await this.extension.execute('plugin-name', 'xxx', { arg: 'value' }); // 执行指定插件的扩展
+```
+
+## 工作流操作
+
+```javascript
+// 注册工作流
+this.workflow.register('my-workflow', {
+  name: 'my-workflow',
+  description: '我的工作流',
+  steps: [
+    { type: 'tool', tool: 'hello', args: {} }
+  ]
+});
+
+// 执行工作流
+const result = await this.workflow.execute('my-workflow', { input: 'value' });
+
+// 移除工作流
+this.workflow.remove('my-workflow');
+```
+
+## 子代理操作
+
+```javascript
+// 注册子代理
+this.agent.register({
+  name: 'my-agent',
+  role: '助手',
+  goal: '描述',
+  tools: {},
+  parentTools: ['read_file', 'write_file']
+});
+
+// 获取子代理
+const agent = this.agent.get('my-agent');
+
+// 移除子代理
+this.agent.remove('my-agent');
+```
+
+## Prompt 操作
+
+```javascript
+// 注册 prompt
+this.prompt.register('my-prompt', () => 'Prompt content', {
+  scope: 'global',
+  priority: 50
+});
+
+// 移除 prompt
+this.prompt.remove('my-prompt');
+```
+
 ---
 
 ## 核心规则