foliko 2.0.1 → 2.0.3

package/src/utils/message-validator.js

@@ -53,24 +53,28 @@ function validateMessagesPairing(messages, options = {}) {
   let removedToolResultCount = 0;
 
   for (const msg of messages) {
-    if (msg.role !== 'tool' || !Array.isArray(msg.content)) continue;
+    if (msg.role !== 'tool') continue;
 
-    const originalLength = msg.content.length;
-    msg.content = msg.content.filter((item) => {
-      if (
-        item &&
-        (item.type === 'tool-result' || item.type === 'tool_result') &&
-        item.toolCallId &&
-        !validToolCallIds.has(item.toolCallId)
-      ) {
-        removedToolResultCount++;
-        return false;
+    if (Array.isArray(msg.content)) {
+      const originalLength = msg.content.length;
+      msg.content = msg.content.filter((item) => {
+        if (
+          item &&
+          (item.type === 'tool-result' || item.type === 'tool_result') &&
+          item.toolCallId &&
+          !validToolCallIds.has(item.toolCallId)
+        ) {
+          removedToolResultCount++;
+          return false;
+        }
+        return true;
+      });
+      // content 全被删除了，标记整个消息待删除
+      if (msg.content.length === 0 && originalLength > 0) {
+        msg._orphaned = true;
       }
-      return true;
-    });
-
-    // content 全被删除了，标记整个消息待删除
-    if (msg.content.length === 0 && originalLength > 0) {
+    } else if (msg.tool_call_id && !validToolCallIds.has(msg.tool_call_id)) {
+      // OpenAI 兼容格式：整条消息无对应 tool_calls，标记为 orphaned
       msg._orphaned = true;
     }
   }
@@ -280,4 +284,4 @@ module.exports = {
   validateToolCalls,
   validateAll,
   filterPairedMessages,
-};
+};

package/src/utils/plugin-helpers.js

@@ -70,15 +70,20 @@ function resolvePluginPath(pluginsDir, name, options = {}) {
 }
 
 /**
- * 扫描插件目录，返回所有插件名称
+ * 扫描插件目录，返回所有插件名称（支持嵌套目录）
  * @param {string} pluginsDir - 插件目录
+ * @param {string} baseDir - 基础目录（用于计算相对路径）
  * @returns {string[]} 插件名称列表
  */
-function scanPluginNames(pluginsDir) {
+function scanPluginNames(pluginsDir, baseDir = null) {
   if (!fs.existsSync(pluginsDir)) {
     return [];
   }
 
+  if (baseDir === null) {
+    baseDir = pluginsDir;
+  }
+
   // 忽略的目录/文件（无意义或系统文件）
   const IGNORE_PATTERNS = new Set([
     '__pycache__',
@@ -105,13 +110,22 @@ function scanPluginNames(pluginsDir) {
     const isDir = entry.isSymbolicLink() ? isDirectory(fullPath) : entry.isDirectory();
 
     if (isDir) {
-      // 文件夹插件（包括 Junction 和 Symbolic Link）
-      names.add(entry.name);
+      const indexPath = path.join(fullPath, 'index.js');
+      if (fs.existsSync(indexPath)) {
+        // 这是一个插件目录
+        const relativePath = path.relative(baseDir, fullPath);
+        names.add(relativePath.replace(/\\/g, '/'));
+      } else {
+        // 不是插件目录，递归扫描子目录
+        const subNames = scanPluginNames(fullPath, baseDir);
+        subNames.forEach(n => names.add(n));
+      }
     } else if (entry.isFile() && entry.name.endsWith('.js')) {
       // 单文件插件（排除与文件夹同名的）
       const baseName = entry.name.replace(/\.js$/, '');
       if (!names.has(baseName)) {
-        names.add(baseName);
+        const relativePath = path.relative(baseDir, fullPath);
+        names.add(relativePath.replace(/\\/g, '/').replace(/\.js$/, ''));
       }
     }
   }

package/subagent.md

@@ -111,7 +111,7 @@
 ## 【Extensions】扩展插件
 
 **使用流程（必须按顺序执行）：**
-1. 调用  `ext_skill({ plugin: "<plugin_name>" })` 或 `loadSkill({ skill: "<skill_name>" })` 获取目标扩展的详细工具参数
+1. 调用  `ext_skill({ plugin: "<plugin_name>" })` 或 `skill_load({ skill: "<skill_name>" })` 获取目标扩展的详细工具参数
 2. 根据返回的参数定义，使用 `ext_call({ plugin, tool, args })` 调用扩展
 
 > **警告**：禁止在未执行第1步获取参数的情况下直接调用 `ext_call`！
@@ -167,4 +167,4 @@ MCP (Model Context Protocol) 执行器
 **工具:** `designmd_search_design_kits`, `designmd_get_design_kit`, `designmd_download_design_kit`, `designmd_upload_design_kit`, `designmd_delete_design_kit`, `designmd_list_popular_kits`, `designmd_list_tags`
 
 ## 禁止事项
-- 不先调用 `ext_skill/loadSkill` 获取参数就直接使用 `ext_call`
+- 不先调用 `ext_skill/skill_load` 获取参数就直接使用 `ext_call`

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

@@ -0,0 +1,219 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Framework, Plugin } from '../../src/index';
+
+describe('Plugin declarative prompts', () => {
+  let fw;
+
+  beforeEach(() => {
+    fw = new Framework({ silent: true });
+  });
+
+  it('auto-registers prompts declared in Plugin.prompts array', () => {
+    class DemoPlugin extends Plugin {
+      install(f) {
+        this._framework = f;
+        return this;
+      }
+      prompts = [
+        {
+          name: 'demo',
+          slot: 'BEHAVIOR',
+          description: 'demo part',
+          provider: function () {
+            return 'demo-content';
+          },
+        },
+      ];
+    }
+    const plugin = new DemoPlugin();
+    plugin.install(fw);
+    plugin.start(fw);
+
+    expect(fw.prompts.has('unnamed-plugin', 'demo')).toBe(true);
+    expect(fw.prompts.getPart('unnamed-plugin', 'demo').get()).toBe('demo-content');
+  });
+
+  it('uses plugin.name as owner', () => {
+    class NamedPlugin extends Plugin {
+      name = 'my-plugin';
+      install(f) {
+        this._framework = f;
+        return this;
+      }
+      prompts = [
+        {
+          name: 'foo',
+          slot: 'CAPABILITY',
+          provider: function () {
+            return 'foo';
+          },
+        },
+      ];
+    }
+    const plugin = new NamedPlugin();
+    plugin.install(fw);
+    plugin.start(fw);
+
+    expect(fw.prompts.has('my-plugin', 'foo')).toBe(true);
+  });
+
+  it('skips invalid entries without breaking others', () => {
+    class MixedPlugin extends Plugin {
+      name = 'mixed';
+      install(f) {
+        this._framework = f;
+        return this;
+      }
+      prompts = [
+        null,
+        { name: 'no-provider' },
+        { provider: () => 'no-name' },
+        {
+          name: 'valid',
+          slot: 'CUSTOM',
+          provider: function () {
+            return 'valid-content';
+          },
+        },
+      ];
+    }
+    const plugin = new MixedPlugin();
+    plugin.install(fw);
+    plugin.start(fw);
+
+    // 合法条目注册成功
+    expect(fw.prompts.has('mixed', 'valid')).toBe(true);
+    // 非法条目被跳过（不抛错，不影响合法条目）
+    expect(fw.prompts.has('mixed', 'no-provider')).toBe(false);
+    expect(fw.prompts.has('mixed', 'no-name')).toBe(false);
+  });
+
+  it('binds this to the plugin instance inside provider', () => {
+    let capturedThis;
+    class CapturePlugin extends Plugin {
+      name = 'capture';
+      install(f) {
+        this._framework = f;
+        return this;
+      }
+      prompts = [
+        {
+          name: 'capture',
+          slot: 'BEHAVIOR',
+          provider: function () {
+            capturedThis = this;
+            return 'x';
+          },
+        },
+      ];
+    }
+    const plugin = new CapturePlugin();
+    plugin.install(fw);
+    plugin.start(fw);
+    fw.prompts.getPart('capture', 'capture').get();
+    expect(capturedThis).toBe(plugin);
+  });
+
+  it('cleanup on uninstall removes all parts owned by plugin', () => {
+    class CleanupPlugin extends Plugin {
+      name = 'cleanup';
+      install(f) {
+        this._framework = f;
+        return this;
+      }
+      prompts = [
+        { name: 'a', slot: 'BEHAVIOR', provider: () => 'a' },
+        { name: 'b', slot: 'BEHAVIOR', provider: () => 'b' },
+      ];
+    }
+    const plugin = new CleanupPlugin();
+    plugin.install(fw);
+    plugin.start(fw);
+    expect(fw.prompts.count()).toBe(2);
+
+    plugin.uninstall(fw);
+    expect(fw.prompts.has('cleanup', 'a')).toBe(false);
+    expect(fw.prompts.has('cleanup', 'b')).toBe(false);
+  });
+
+  it('reload re-registers declarative prompts', () => {
+    class ReloadPlugin extends Plugin {
+      name = 'reload-test';
+      install(f) {
+        this._framework = f;
+        return this;
+      }
+      prompts = [
+        {
+          name: 'reloadable',
+          slot: 'CUSTOM',
+          provider: function () {
+            return 'v1';
+          },
+        },
+      ];
+    }
+    const plugin = new ReloadPlugin();
+    plugin.install(fw);
+    plugin.start(fw);
+    expect(fw.prompts.getPart('reload-test', 'reloadable').get()).toBe('v1');
+
+    // 修改后 reload
+    plugin.prompts[0].provider = function () {
+      return 'v2';
+    };
+    plugin.reload(fw);
+    fw.prompts.invalidate('reload-test', 'reloadable');
+    expect(fw.prompts.getPart('reload-test', 'reloadable').get()).toBe('v2');
+  });
+
+  it('declarative prompts with owner matching plugin name', () => {
+    class NamedPlugin extends Plugin {
+      name = 'test-owner';
+      install(f) {
+        this._framework = f;
+        return this;
+      }
+      prompts = [
+        {
+          name: 'demo',
+          slot: 'CUSTOM',
+          provider: function () {
+            return 'demo-content';
+          },
+        },
+      ];
+    }
+    const plugin = new NamedPlugin();
+    plugin.install(fw);
+    plugin.start(fw);
+
+    expect(fw.prompts.has('test-owner', 'demo')).toBe(true);
+    expect(fw.prompts.getPart('test-owner', 'demo').get()).toBe('demo-content');
+  });
+
+  it('renders in slot order', () => {
+    class MultiPlugin extends Plugin {
+      name = 'multi';
+      install(f) {
+        this._framework = f;
+        return this;
+      }
+      prompts = [
+        { name: 'behavior', slot: 'BEHAVIOR', provider: () => 'BEHAVIOR_CONTENT' },
+        { name: 'identity', slot: 'IDENTITY', provider: () => 'IDENTITY_CONTENT' },
+        { name: 'capability', slot: 'CAPABILITY', provider: () => 'CAPABILITY_CONTENT' },
+      ];
+    }
+    const plugin = new MultiPlugin();
+    plugin.install(fw);
+    plugin.start(fw);
+
+    const built = fw.prompts.build();
+    const identityIdx = built.indexOf('IDENTITY_CONTENT');
+    const capabilityIdx = built.indexOf('CAPABILITY_CONTENT');
+    const behaviorIdx = built.indexOf('BEHAVIOR_CONTENT');
+    expect(identityIdx).toBeLessThan(capabilityIdx);
+    expect(capabilityIdx).toBeLessThan(behaviorIdx);
+  });
+});

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

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PromptRegistry, PROMPT_SLOT, PROMPT_PRIORITY_TO_SLOT } from '../../src/index';
+
+describe('PromptRegistry', () => {
+  let reg;
+
+  beforeEach(() => {
+    reg = new PromptRegistry();
+  });
+
+  describe('basic API', () => {
+    it('registers and retrieves a part', () => {
+      reg.register('plugin-a', 'foo', () => 'hello', { slot: 'IDENTITY' });
+      const part = reg.getPart('plugin-a', 'foo');
+      expect(part).toBeTruthy();
+      expect(part.get()).toBe('hello');
+      expect(reg.count()).toBe(1);
+    });
+
+    it('requires owner/name/provider', () => {
+      expect(() => reg.register('', 'foo', () => 'x')).toThrow(/owner/);
+      expect(() => reg.register('p', '', () => 'x')).toThrow(/name/);
+      expect(() => reg.register('p', 'n', 'not-fn')).toThrow(/provider/);
+    });
+
+    it('unregisters a part', () => {
+      reg.register('p', 'n', () => 'x');
+      expect(reg.unregister('p', 'n')).toBe(true);
+      expect(reg.unregister('p', 'n')).toBe(false);
+      expect(reg.count()).toBe(0);
+    });
+
+    it('clears all parts of an owner', () => {
+      reg.register('p', 'a', () => '1');
+      reg.register('p', 'b', () => '2');
+      reg.register('q', 'c', () => '3');
+      const cleared = reg.clearOwner('p');
+      expect(cleared).toBe(2);
+      expect(reg.count()).toBe(1);
+    });
+
+    it('isolates namespaces by owner', () => {
+      reg.register('x', 'foo', () => 'x-foo');
+      reg.register('y', 'foo', () => 'y-foo');
+      expect(reg.getPart('x', 'foo').get()).toBe('x-foo');
+      expect(reg.getPart('y', 'foo').get()).toBe('y-foo');
+    });
+  });
+
+  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']);
+    });
+
+    it('falls back to alphabetical when order is equal', () => {
+      reg.register('zeta', 'z', () => 'z', { slot: 'IDENTITY' });
+      reg.register('alpha', 'a', () => 'a', { slot: 'IDENTITY' });
+      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('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');
+    });
+  });
+
+  describe('build', () => {
+    it('joins non-empty parts with double newline', () => {
+      reg.register('p', 'a', () => 'AAA');
+      reg.register('p', 'b', () => 'BBB');
+      expect(reg.build()).toBe('AAA\n\nBBB');
+    });
+
+    it('skips null/empty content', () => {
+      reg.register('p', 'a', () => 'AAA');
+      reg.register('p', 'b', () => null);
+      reg.register('p', 'c', () => '   ');
+      reg.register('p', 'd', () => 'DDD');
+      expect(reg.build()).toBe('AAA\n\nDDD');
+    });
+
+    it('does not break when provider throws', () => {
+      reg.register('p', 'good', () => 'AAA');
+      reg.register('p', 'bad', () => {
+        throw new Error('boom');
+      });
+      reg.register('p', 'after', () => 'BBB');
+      const original = console.warn;
+      const warnings = [];
+      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 {
+        console.warn = original;
+      }
+    });
+
+    it('preview is an alias for build', () => {
+      reg.register('p', 'a', () => 'AAA');
+      expect(reg.preview()).toBe(reg.build());
+    });
+  });
+
+  describe('caching & invalidation', () => {
+    it('caches provider result until invalidated', () => {
+      let calls = 0;
+      reg.register('p', 'a', () => {
+        calls++;
+        return 'v' + calls;
+      });
+      expect(reg.getPart('p', 'a').get()).toBe('v1');
+      expect(reg.getPart('p', 'a').get()).toBe('v1');
+      reg.invalidate('p', 'a');
+      expect(reg.getPart('p', 'a').get()).toBe('v2');
+    });
+
+    it('invalidateAll resets all caches', () => {
+      let n = 0;
+      reg.register('p', 'a', () => ++n);
+      reg.register('p', 'b', () => ++n);
+      reg.build();
+      reg.invalidateAll();
+      reg.build();
+      expect(n).toBeGreaterThanOrEqual(4);
+    });
+  });
+
+  describe('events', () => {
+    it('emits register / unregister / clear-owner', () => {
+      const events = [];
+      reg.on('register', (e) => events.push('reg:' + e.owner));
+      reg.on('unregister', (e) => events.push('unreg:' + e.owner));
+      reg.on('clear-owner', (e) => events.push('clear-owner:' + e.owner));
+      reg.register('p', 'a', () => 'x');
+      reg.register('q', 'b', () => 'x');
+      reg.unregister('p', 'a');
+      reg.clearOwner('q');
+      expect(events).toEqual(['reg:p', 'reg:q', 'unreg:p', 'clear-owner:q']);
+    });
+  });
+
+  describe('inspect', () => {
+    it('returns structured per-part metadata', () => {
+      reg.register('plugin-a', 'foo', () => 'hello world', { slot: 'IDENTITY' });
+      const out = reg.inspect();
+      expect(out).toHaveLength(1);
+      expect(out[0]).toMatchObject({
+        owner: 'plugin-a',
+        name: 'foo',
+        slot: 'IDENTITY',
+        order: 10,
+        hasContent: true,
+        length: 11,
+      });
+      expect(out[0].contentPreview).toContain('hello');
+    });
+  });
+
+  describe('Framework integration', () => {
+    it('Framework exposes prompts registry', () => {
+      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);
+    });
+  });
+});

package/src/cli/utils/plugin-config.js

@@ -1,50 +0,0 @@
-/**
- * 插件管理器公共配置
- */
-
-// 默认插件仓库
-const DEFAULT_REPO = 'https://github.com/chnak/foliko-plugins.git';
-
-// 发布时忽略的文件和目录
-const IGNORE_PATTERNS = [
-  'node_modules',
-  '.git',
-  '.env',
-  '.DS_Store',
-  'Thumbs.db',
-  '*.log',
-  '*.lock',
-  '*.bak',
-  '.claude',
-  '.foliko',
-  'examples',
-  'dist',
-  'build',
-  'coverage',
-  'tests',
-  '__tests__',
-  '*.test.js',
-  '*.spec.js',
-  'package-lock.json',
-  'yarn.lock',
-  'pnpm-lock.yaml',
-];
-
-/**
- * 检查文件/目录是否应该被忽略
- */
-function shouldIgnore(name) {
-  return IGNORE_PATTERNS.some((pattern) => {
-    if (pattern.startsWith('*.')) {
-      const ext = pattern.slice(1);
-      return name.endsWith(ext);
-    }
-    return name === pattern;
-  });
-}
-
-module.exports = {
-  DEFAULT_REPO,
-  IGNORE_PATTERNS,
-  shouldIgnore,
-};

package/src/config/plugin-config.js

@@ -1,50 +0,0 @@
-/**
- * 插件管理器公共配置
- */
-
-// 默认插件仓库
-const DEFAULT_REPO = 'https://github.com/chnak/foliko-plugins.git';
-
-// 发布时忽略的文件和目录
-const IGNORE_PATTERNS = [
-  'node_modules',
-  '.git',
-  '.env',
-  '.DS_Store',
-  'Thumbs.db',
-  '*.log',
-  '*.lock',
-  '*.bak',
-  '.claude',
-  '.foliko',
-  'examples',
-  'dist',
-  'build',
-  'coverage',
-  'tests',
-  '__tests__',
-  '*.test.js',
-  '*.spec.js',
-  'package-lock.json',
-  'yarn.lock',
-  'pnpm-lock.yaml',
-];
-
-/**
- * 检查文件/目录是否应该被忽略
- */
-function shouldIgnore(name) {
-  return IGNORE_PATTERNS.some((pattern) => {
-    if (pattern.startsWith('*.')) {
-      const ext = pattern.slice(1);
-      return name.endsWith(ext);
-    }
-    return name === pattern;
-  });
-}
-
-module.exports = {
-  DEFAULT_REPO,
-  IGNORE_PATTERNS,
-  shouldIgnore,
-};