foliko 2.0.4 → 2.0.5

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);
-    });
   });
-});
+});