foliko 2.0.4 → 2.0.6

package/src/plugin/manager.js

@@ -42,6 +42,15 @@ class PluginManager {
    * 注册插件（不加载，只记录状态）
    */
   register(plugin, options = {}) {
+    // 处理 function(Plugin) { return class... } 格式
+    if (typeof plugin === 'function' && !(plugin instanceof Plugin)) {
+      try {
+        plugin = plugin(Plugin);
+      } catch (err) {
+        throw new PluginError(`Plugin factory function failed: ${err.message}`);
+      }
+    }
+
     if (!(plugin instanceof Plugin)) {
       throw new PluginError('Plugin must be an instance of Plugin');
     }
@@ -146,9 +155,18 @@ class PluginManager {
   async load(plugin, options = {}) {
     let pluginInstance = plugin;
 
-    // 如果是类（Plugin 子类），实例化
-    if (typeof plugin === 'function' && plugin.prototype instanceof Plugin) {
-      pluginInstance = new plugin();
+    // 处理 function(Plugin) { return class... } 格式
+    if (typeof plugin === 'function') {
+      if (plugin.prototype instanceof Plugin) {
+        // Plugin 子类
+        pluginInstance = new plugin();
+      } else {
+        // Factory function
+        pluginInstance = plugin(Plugin);
+        if (pluginInstance.prototype instanceof Plugin) {
+          pluginInstance = new pluginInstance();
+        }
+      }
     }
 
     const name = pluginInstance.name;
@@ -187,7 +205,7 @@ class PluginManager {
     this._log.info(`Loading plugin: ${name}`);
 
     if (typeof pluginInstance.install === 'function') {
-      pluginInstance.install(this.framework);
+      await pluginInstance.install(this.framework);
     }
 
     entry.status = 'loaded';
@@ -250,10 +268,10 @@ class PluginManager {
       await plugin.reload(this.framework);
     } else {
       if (typeof plugin.uninstall === 'function') {
-        plugin.uninstall(this.framework);
+        await plugin.uninstall(this.framework);
       }
       if (typeof plugin.install === 'function') {
-        plugin.install(this.framework);
+        await plugin.install(this.framework);
       }
       if (typeof plugin.start === 'function') {
         await plugin.start(this.framework);
@@ -342,10 +360,10 @@ class PluginManager {
           } else {
             // 没有 reload，走完整 uninstall + install + start
             if (typeof entry.instance.uninstall === 'function') {
-              entry.instance.uninstall(this.framework);
+              await entry.instance.uninstall(this.framework);
             }
             if (typeof entry.instance.install === 'function') {
-              entry.instance.install(this.framework);
+              await entry.instance.install(this.framework);
             }
             if (typeof entry.instance.start === 'function') {
               await entry.instance.start(this.framework);
@@ -405,6 +423,9 @@ class PluginManager {
       }
     }
 
+    // 清理该插件注册的提示词
+    entry.instance._cleanupPrompts?.();
+
     this.framework?.emit('plugin:disabled', entry.instance);
     this._saveState();
     this._log.info(`Plugin '${name}' disabled`);

package/src/tool/schema.js

@@ -13,15 +13,36 @@ const { z } = require('zod');
  * @param {boolean} [required] - Whether this schema is required (optional when false)
  * @returns {z.ZodType}
  */
+/**
+ * Convert JSON Schema to Zod schema
+ * @param {Object} jsonSchema
+ * @param {boolean} [required] - Whether the root schema is required (default true)
+ * @returns {z.ZodType}
+ */
 function jsonSchemaToZod(jsonSchema, required) {
   if (!jsonSchema || typeof jsonSchema !== 'object') {
     return z.any();
   }
 
-  return _convertSchema(jsonSchema, required);
+  // 根级默认 required=true，optional() 在对象字段级别应用
+  const isRequired = required !== false;
+  return _applyOptional(_convertSchema(jsonSchema, true), isRequired, jsonSchema);
+}
+
+/**
+ * 在对象字段构建时调用：根据 required 包装
+ */
+function _applyOptional(zodType, isRequired, schema) {
+  if (isRequired) return zodType;
+  if (schema && schema.default !== undefined) return zodType;
+  return zodType.optional();
 }
 
-function _convertSchema(schema, required = false) {
+/**
+ * 内部转换：只负责类型转换，不做 optional 包装
+ * optional 包装由调用方根据 required 参数决定
+ */
+function _convertSchema(schema, _required = true) {
   if (!schema) return z.any();
 
   let type = schema.type;
@@ -55,8 +76,10 @@ function _convertSchema(schema, required = false) {
       zodType = z.boolean();
       break;
     case 'array': {
+      // 数组项的 required 由 _required 决定（通常为 true，因为数组存在即代表"有数组"）
+      const itemRequired = _required && schema.items?.required !== false;
       if (schema.items) {
-        zodType = z.array(_convertSchema(schema.items, true));
+        zodType = z.array(_convertSchema(schema.items, itemRequired));
       } else {
         zodType = z.array(z.any());
       }
@@ -68,12 +91,14 @@ function _convertSchema(schema, required = false) {
         break;
       }
       const shape = {};
-      const req = schema.required || [];
+      const req = new Set(schema.required || []);
       for (const [key, prop] of Object.entries(schema.properties)) {
-        shape[key] = _convertSchema(prop, req.includes(key));
+        const isRequired = req.has(key);
+        // 子字段的 optional() 在这里统一包装
+        const fieldSchema = _convertSchema(prop, isRequired);
+        shape[key] = _applyOptional(fieldSchema, isRequired, prop);
       }
-      const obj = z.object(shape);
-      zodType = req.length === Object.keys(shape).length ? obj : obj.partial();
+      zodType = z.object(shape);
       break;
     }
     case 'null':
@@ -84,8 +109,6 @@ function _convertSchema(schema, required = false) {
   }
 
   if (schema.nullable) zodType = zodType.nullable();
-  if (!required && schema.default === undefined) zodType = zodType.optional();
-
   return zodType;
 }
 

package/tests/core/plugin-prompts.test.js

@@ -17,7 +17,7 @@ describe('Plugin declarative prompts', () => {
       prompts = [
         {
           name: 'demo',
-          slot: 'BEHAVIOR',
+          priority: 50,
           description: 'demo part',
           provider: function () {
             return 'demo-content';
@@ -43,7 +43,7 @@ describe('Plugin declarative prompts', () => {
       prompts = [
         {
           name: 'foo',
-          slot: 'CAPABILITY',
+          scope: 'global',
           provider: function () {
             return 'foo';
           },
@@ -70,7 +70,7 @@ describe('Plugin declarative prompts', () => {
         { provider: () => 'no-name' },
         {
           name: 'valid',
-          slot: 'CUSTOM',
+          priority: 50,
           provider: function () {
             return 'valid-content';
           },
@@ -99,7 +99,7 @@ describe('Plugin declarative prompts', () => {
       prompts = [
         {
           name: 'capture',
-          slot: 'BEHAVIOR',
+          scope: 'global',
           provider: function () {
             capturedThis = this;
             return 'x';
@@ -122,8 +122,8 @@ describe('Plugin declarative prompts', () => {
         return this;
       }
       prompts = [
-        { name: 'a', slot: 'BEHAVIOR', provider: () => 'a' },
-        { name: 'b', slot: 'BEHAVIOR', provider: () => 'b' },
+        { name: 'a', priority: 50, provider: () => 'a' },
+        { name: 'b', priority: 60, provider: () => 'b' },
       ];
     }
     const plugin = new CleanupPlugin();
@@ -146,7 +146,7 @@ describe('Plugin declarative prompts', () => {
       prompts = [
         {
           name: 'reloadable',
-          slot: 'CUSTOM',
+          priority: 50,
           provider: function () {
             return 'v1';
           },
@@ -177,7 +177,7 @@ describe('Plugin declarative prompts', () => {
       prompts = [
         {
           name: 'demo',
-          slot: 'CUSTOM',
+          priority: 50,
           provider: function () {
             return 'demo-content';
           },
@@ -192,7 +192,7 @@ describe('Plugin declarative prompts', () => {
     expect(fw.prompts.getPart('test-owner', 'demo').get()).toBe('demo-content');
   });
 
-  it('renders in slot order', () => {
+  it('renders in priority order', () => {
     class MultiPlugin extends Plugin {
       name = 'multi';
       install(f) {
@@ -200,9 +200,9 @@ describe('Plugin declarative prompts', () => {
         return this;
       }
       prompts = [
-        { name: 'behavior', slot: 'BEHAVIOR', provider: () => 'BEHAVIOR_CONTENT' },
-        { name: 'identity', slot: 'IDENTITY', provider: () => 'IDENTITY_CONTENT' },
-        { name: 'capability', slot: 'CAPABILITY', provider: () => 'CAPABILITY_CONTENT' },
+        { name: 'behavior', priority: 50, provider: () => 'BEHAVIOR_CONTENT' },
+        { name: 'identity', priority: 10, provider: () => 'IDENTITY_CONTENT' },
+        { name: 'capability', priority: 30, provider: () => 'CAPABILITY_CONTENT' },
       ];
     }
     const plugin = new MultiPlugin();
@@ -216,4 +216,4 @@ describe('Plugin declarative prompts', () => {
     expect(identityIdx).toBeLessThan(capabilityIdx);
     expect(capabilityIdx).toBeLessThan(behaviorIdx);
   });
-});
+});

package/tests/core/prompt-registry.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { PromptRegistry, PROMPT_SLOT, PROMPT_PRIORITY_TO_SLOT } from '../../src/index';
+import { PromptRegistry } from '../../src/index';
 
 describe('PromptRegistry', () => {
   let reg;
@@ -10,13 +10,20 @@ describe('PromptRegistry', () => {
 
   describe('basic API', () => {
     it('registers and retrieves a part', () => {
-      reg.register('plugin-a', 'foo', () => 'hello', { slot: 'IDENTITY' });
+      reg.register('plugin-a', 'foo', () => 'hello');
       const part = reg.getPart('plugin-a', 'foo');
       expect(part).toBeTruthy();
       expect(part.get()).toBe('hello');
       expect(reg.count()).toBe(1);
     });
 
+    it('registers with scope and priority', () => {
+      reg.register('plugin-a', 'foo', () => 'hello', { scope: 'global', priority: 50 });
+      const part = reg.getPart('plugin-a', 'foo');
+      expect(part.scope).toBe('global');
+      expect(part.priority).toBe(50);
+    });
+
     it('requires owner/name/provider', () => {
       expect(() => reg.register('', 'foo', () => 'x')).toThrow(/owner/);
       expect(() => reg.register('p', '', () => 'x')).toThrow(/name/);
@@ -47,46 +54,53 @@ describe('PromptRegistry', () => {
     });
   });
 
-  describe('slot ordering', () => {
-    it('orders by slot order', () => {
-      reg.register('p', 'a', () => 'BEHAVIOR', { slot: 'BEHAVIOR' });
-      reg.register('p', 'b', () => 'IDENTITY', { slot: 'IDENTITY' });
-      reg.register('p', 'c', () => 'CAPABILITY', { slot: 'CAPABILITY' });
-      const order = reg.list().map((p) => p.slot);
-      expect(order).toEqual(['IDENTITY', 'CAPABILITY', 'BEHAVIOR']);
-    });
-
-    it('uses explicit order within same slot', () => {
-      reg.register('p', 'late', () => 'late', { slot: 'IDENTITY', order: 5 });
-      reg.register('p', 'early', () => 'early', { slot: 'IDENTITY', order: 1 });
-      const names = reg.list().map((p) => p.name);
-      expect(names).toEqual(['early', 'late']);
+  describe('priority ordering', () => {
+    it('orders by priority (smaller first)', () => {
+      reg.register('p', 'a', () => 'a', { priority: 100 });
+      reg.register('p', 'b', () => 'b', { priority: 10 });
+      reg.register('p', 'c', () => 'c', { priority: 50 });
+      const order = reg.list().map((p) => p.name);
+      expect(order).toEqual(['b', 'c', 'a']);
     });
 
-    it('falls back to alphabetical when order is equal', () => {
-      reg.register('zeta', 'z', () => 'z', { slot: 'IDENTITY' });
-      reg.register('alpha', 'a', () => 'a', { slot: 'IDENTITY' });
+    it('falls back to owner alphabetical when priority is equal', () => {
+      reg.register('zeta', 'z', () => 'z', { priority: 50 });
+      reg.register('alpha', 'a', () => 'a', { priority: 50 });
       const owners = reg.list().map((p) => p.owner);
       expect(owners).toEqual(['alpha', 'zeta']);
     });
 
-    it('PROMPT_SLOT exposes 7 named slots', () => {
-      const names = Object.keys(PROMPT_SLOT);
-      expect(names).toContain('IDENTITY');
-      expect(names).toContain('ENVIRONMENT');
-      expect(names).toContain('USER');
-      expect(names).toContain('CAPABILITY');
-      expect(names).toContain('BEHAVIOR');
-      expect(names).toContain('CONTEXT');
-      expect(names).toContain('CUSTOM');
+    it('defaults to priority 100', () => {
+      reg.register('p', 'a', () => 'a');
+      reg.register('p', 'b', () => 'b', { priority: 50 });
+      const order = reg.list().map((p) => p.name);
+      expect(order).toEqual(['b', 'a']);
+    });
+  });
+
+  describe('scope filtering', () => {
+    it('listByScope filters correctly', () => {
+      reg.register('p', 'a', () => 'a', { scope: 'global' });
+      reg.register('p', 'b', () => 'b', { scope: 'main' });
+      reg.register('p', 'c', () => 'c', { scope: 'sub-1' });
+      expect(reg.listByScope('global').map((p) => p.name)).toEqual(['a']);
+      expect(reg.listByScope('main').map((p) => p.name)).toEqual(['b']);
+      expect(reg.listByScope('sub-1').map((p) => p.name)).toEqual(['c']);
     });
 
-    it('PROMPT_PRIORITY_TO_SLOT maps all legacy priorities', () => {
-      expect(PROMPT_PRIORITY_TO_SLOT.DATETIME).toBe('ENVIRONMENT');
-      expect(PROMPT_PRIORITY_TO_SLOT.ORIGINAL_PROMPT).toBe('IDENTITY');
-      expect(PROMPT_PRIORITY_TO_SLOT.SHARED_PROMPT).toBe('USER');
-      expect(PROMPT_PRIORITY_TO_SLOT.CAPABILITIES).toBe('CAPABILITY');
-      expect(PROMPT_PRIORITY_TO_SLOT.TOOL_CORE_RULES).toBe('BEHAVIOR');
+    it('listForAgent includes global and matching scope', () => {
+      reg.register('p', 'global', () => 'g', { scope: 'global' });
+      reg.register('p', 'main', () => 'm', { scope: 'main' });
+      reg.register('p', 'sub1', () => 's1', { scope: 'sub-1' });
+      reg.register('p', 'sub2', () => 's2', { scope: 'sub-2' });
+
+      // Main agent sees global + main
+      const mainParts = reg.listForAgent(null).map((p) => p.name);
+      expect(mainParts).toEqual(['global', 'main']);
+
+      // sub-1 agent sees global + sub1
+      const sub1Parts = reg.listForAgent('sub-1').map((p) => p.name);
+      expect(sub1Parts).toEqual(['global', 'sub1']);
     });
   });
 
@@ -97,6 +111,13 @@ describe('PromptRegistry', () => {
       expect(reg.build()).toBe('AAA\n\nBBB');
     });
 
+    it('builds only parts for specific agent', () => {
+      reg.register('p', 'global', () => 'G', { scope: 'global' });
+      reg.register('p', 'main', () => 'M', { scope: 'main' });
+      reg.register('p', 'sub1', () => 'S1', { scope: 'sub-1' });
+      expect(reg.buildForAgent('sub-1')).toBe('G\n\nS1');
+    });
+
     it('skips null/empty content', () => {
       reg.register('p', 'a', () => 'AAA');
       reg.register('p', 'b', () => null);
@@ -116,7 +137,6 @@ describe('PromptRegistry', () => {
       console.warn = (msg) => warnings.push(msg);
       try {
         const result = reg.build();
-        // 排序：after → bad(fail) → good → "BBB\n\nAAA"
         expect(result).toBe('BBB\n\nAAA');
         expect(warnings.length).toBe(1);
       } finally {
@@ -170,14 +190,14 @@ describe('PromptRegistry', () => {
 
   describe('inspect', () => {
     it('returns structured per-part metadata', () => {
-      reg.register('plugin-a', 'foo', () => 'hello world', { slot: 'IDENTITY' });
+      reg.register('plugin-a', 'foo', () => 'hello world', { scope: 'global', priority: 50 });
       const out = reg.inspect();
       expect(out).toHaveLength(1);
       expect(out[0]).toMatchObject({
         owner: 'plugin-a',
         name: 'foo',
-        slot: 'IDENTITY',
-        order: 10,
+        scope: 'global',
+        priority: 50,
         hasContent: true,
         length: 11,
       });
@@ -190,20 +210,8 @@ describe('PromptRegistry', () => {
       const { Framework } = require('../../src/index');
       const fw = new Framework({ silent: true });
       expect(fw.prompts).toBeDefined();
-      expect(fw.prompts).toBe(fw.promptRegistry);
       expect(typeof fw.prompts.register).toBe('function');
       expect(typeof fw.prompts.preview).toBe('function');
     });
-
-    it('each agent has its own promptRegistry via BaseAgent', () => {
-      const { BaseAgent } = require('../../src/agent/base');
-      const { Framework } = require('../../src/index');
-      const fw = new Framework({ silent: true });
-      const agent = new BaseAgent(fw, { name: 'Test' });
-      expect(agent.promptRegistry).toBeDefined();
-      expect(agent.promptRegistry).toBe(agent._promptRegistry);
-      agent.promptRegistry.register('test', 'foo', () => 'x', { slot: 'CUSTOM' });
-      expect(agent.promptRegistry.count()).toBe(1);
-    });
   });
-});
+});