foliko 2.0.2 → 2.0.4

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,
-};