@olane/os 0.7.12-alpha.9 → 0.7.13-alpha.0

package/dist/test/capabilities/capability-registry.spec.js

@@ -0,0 +1,261 @@
+import { expect } from 'chai';
+import { ALL_CAPABILITIES, oCapabilityTask, oCapabilitySearch, oCapabilityEvaluate, oCapabilityMultipleStep, oCapabilityConfigure, oCapabilityType } from '@olane/o-lane';
+describe('Capability Registry @capability @registry', () => {
+    describe('ALL_CAPABILITIES array', () => {
+        it('should export ALL_CAPABILITIES array', () => {
+            expect(ALL_CAPABILITIES).to.exist;
+            expect(ALL_CAPABILITIES).to.be.an('array');
+        });
+        it('should contain all capability classes', () => {
+            expect(ALL_CAPABILITIES.length).to.be.greaterThan(0);
+        });
+        it('should include oCapabilityTask', () => {
+            expect(ALL_CAPABILITIES).to.include(oCapabilityTask);
+        });
+        it('should include oCapabilitySearch', () => {
+            expect(ALL_CAPABILITIES).to.include(oCapabilitySearch);
+        });
+        it('should include oCapabilityEvaluate', () => {
+            expect(ALL_CAPABILITIES).to.include(oCapabilityEvaluate);
+        });
+        it('should include oCapabilityMultipleStep', () => {
+            expect(ALL_CAPABILITIES).to.include(oCapabilityMultipleStep);
+        });
+        it('should include oCapabilityConfigure', () => {
+            expect(ALL_CAPABILITIES).to.include(oCapabilityConfigure);
+        });
+        it('should have exactly 5 capabilities', () => {
+            expect(ALL_CAPABILITIES.length).to.equal(5);
+        });
+    });
+    describe('Capability class registration', () => {
+        it('should allow instantiation of oCapabilityTask', () => {
+            const capability = new oCapabilityTask();
+            expect(capability).to.exist;
+            expect(capability.type).to.equal(oCapabilityType.TASK);
+        });
+        it('should allow instantiation of oCapabilitySearch', () => {
+            const capability = new oCapabilitySearch();
+            expect(capability).to.exist;
+            expect(capability.type).to.equal(oCapabilityType.SEARCH);
+        });
+        it('should allow instantiation of oCapabilityEvaluate', () => {
+            const capability = new oCapabilityEvaluate();
+            expect(capability).to.exist;
+            expect(capability.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should allow instantiation of oCapabilityMultipleStep', () => {
+            const capability = new oCapabilityMultipleStep();
+            expect(capability).to.exist;
+            expect(capability.type).to.equal(oCapabilityType.MULTIPLE_STEP);
+        });
+        it('should allow instantiation of oCapabilityConfigure', () => {
+            const capability = new oCapabilityConfigure();
+            expect(capability).to.exist;
+            expect(capability.type).to.equal(oCapabilityType.CONFIGURE);
+        });
+    });
+    describe('Capability type mapping', () => {
+        it('should map each capability to its type', () => {
+            const typeMap = new Map([
+                [oCapabilityTask, oCapabilityType.TASK],
+                [oCapabilitySearch, oCapabilityType.SEARCH],
+                [oCapabilityEvaluate, oCapabilityType.EVALUATE],
+                [oCapabilityMultipleStep, oCapabilityType.MULTIPLE_STEP],
+                [oCapabilityConfigure, oCapabilityType.CONFIGURE]
+            ]);
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                const expectedType = typeMap.get(CapabilityClass);
+                expect(CapabilityClass.type).to.equal(expectedType);
+            });
+        });
+        it('should have unique types for each capability', () => {
+            const types = ALL_CAPABILITIES.map(Cap => Cap.type);
+            const uniqueTypes = new Set(types);
+            expect(uniqueTypes.size).to.equal(ALL_CAPABILITIES.length);
+        });
+        it('should use static type getter', () => {
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                expect(CapabilityClass.type).to.exist;
+                expect(CapabilityClass.type).to.be.a('string');
+            });
+        });
+        it('should match instance type with static type', () => {
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                const instance = new CapabilityClass();
+                expect(instance.type).to.equal(CapabilityClass.type);
+            });
+        });
+    });
+    describe('Capability type enumeration', () => {
+        it('should define TASK type', () => {
+            expect(oCapabilityType.TASK).to.exist;
+            expect(oCapabilityType.TASK).to.be.a('string');
+        });
+        it('should define SEARCH type', () => {
+            expect(oCapabilityType.SEARCH).to.exist;
+            expect(oCapabilityType.SEARCH).to.be.a('string');
+        });
+        it('should define MULTIPLE_STEP type', () => {
+            expect(oCapabilityType.MULTIPLE_STEP).to.exist;
+            expect(oCapabilityType.MULTIPLE_STEP).to.be.a('string');
+        });
+        it('should define CONFIGURE type', () => {
+            expect(oCapabilityType.CONFIGURE).to.exist;
+            expect(oCapabilityType.CONFIGURE).to.be.a('string');
+        });
+        it('should define HANDSHAKE type', () => {
+            expect(oCapabilityType.HANDSHAKE).to.exist;
+            expect(oCapabilityType.HANDSHAKE).to.be.a('string');
+        });
+        it('should define EVALUATE type', () => {
+            expect(oCapabilityType.EVALUATE).to.exist;
+            expect(oCapabilityType.EVALUATE).to.be.a('string');
+        });
+        it('should define STOP type', () => {
+            expect(oCapabilityType.STOP).to.exist;
+            expect(oCapabilityType.STOP).to.be.a('string');
+        });
+        it('should define ERROR type', () => {
+            expect(oCapabilityType.ERROR).to.exist;
+            expect(oCapabilityType.ERROR).to.be.a('string');
+        });
+        it('should define UNKNOWN type', () => {
+            expect(oCapabilityType.UNKNOWN).to.exist;
+            expect(oCapabilityType.UNKNOWN).to.be.a('string');
+        });
+    });
+    describe('Capability discovery', () => {
+        it('should find capability by type', () => {
+            const findByType = (type) => {
+                return ALL_CAPABILITIES.find(Cap => Cap.type === type);
+            };
+            const taskCap = findByType(oCapabilityType.TASK);
+            expect(taskCap).to.equal(oCapabilityTask);
+            const searchCap = findByType(oCapabilityType.SEARCH);
+            expect(searchCap).to.equal(oCapabilitySearch);
+            const evaluateCap = findByType(oCapabilityType.EVALUATE);
+            expect(evaluateCap).to.equal(oCapabilityEvaluate);
+            const multiStepCap = findByType(oCapabilityType.MULTIPLE_STEP);
+            expect(multiStepCap).to.equal(oCapabilityMultipleStep);
+            const configureCap = findByType(oCapabilityType.CONFIGURE);
+            expect(configureCap).to.equal(oCapabilityConfigure);
+        });
+        it('should return undefined for unregistered type', () => {
+            const findByType = (type) => {
+                return ALL_CAPABILITIES.find(Cap => Cap.type === type);
+            };
+            const unknownCap = findByType(oCapabilityType.HANDSHAKE);
+            expect(unknownCap).to.be.undefined;
+        });
+        it('should list all registered capability types', () => {
+            const registeredTypes = ALL_CAPABILITIES.map(Cap => Cap.type);
+            expect(registeredTypes).to.include(oCapabilityType.TASK);
+            expect(registeredTypes).to.include(oCapabilityType.SEARCH);
+            expect(registeredTypes).to.include(oCapabilityType.EVALUATE);
+            expect(registeredTypes).to.include(oCapabilityType.MULTIPLE_STEP);
+            expect(registeredTypes).to.include(oCapabilityType.CONFIGURE);
+        });
+    });
+    describe('Capability order', () => {
+        it('should maintain consistent order', () => {
+            const expectedOrder = [
+                oCapabilityTask,
+                oCapabilitySearch,
+                oCapabilityEvaluate,
+                oCapabilityMultipleStep,
+                oCapabilityConfigure
+            ];
+            expect(ALL_CAPABILITIES).to.deep.equal(expectedOrder);
+        });
+        it('should have TASK as first capability', () => {
+            expect(ALL_CAPABILITIES[0]).to.equal(oCapabilityTask);
+        });
+        it('should have CONFIGURE as last capability', () => {
+            expect(ALL_CAPABILITIES[ALL_CAPABILITIES.length - 1]).to.equal(oCapabilityConfigure);
+        });
+    });
+    describe('Capability interface compliance', () => {
+        it('should have execute method on all capabilities', () => {
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                const instance = new CapabilityClass();
+                expect(instance.execute).to.be.a('function');
+            });
+        });
+        it('should have run method on all capabilities', () => {
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                const instance = new CapabilityClass();
+                expect(instance.run).to.be.a('function');
+            });
+        });
+        it('should have type getter on all capabilities', () => {
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                const instance = new CapabilityClass();
+                expect(instance.type).to.exist;
+            });
+        });
+        it('should have cancel method on all capabilities', () => {
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                const instance = new CapabilityClass();
+                expect(instance.cancel).to.be.a('function');
+            });
+        });
+    });
+    describe('Capability extensibility', () => {
+        it('should allow extending capabilities array', () => {
+            const extendedCapabilities = [...ALL_CAPABILITIES];
+            expect(extendedCapabilities.length).to.equal(ALL_CAPABILITIES.length);
+            expect(extendedCapabilities).to.deep.equal(ALL_CAPABILITIES);
+        });
+        it('should allow filtering capabilities', () => {
+            const intelligenceCapabilities = ALL_CAPABILITIES.filter(CapabilityClass => {
+                const instance = new CapabilityClass();
+                return 'intelligence' in instance;
+            });
+            // Configure, Evaluate, and MultipleStep extend oCapabilityIntelligence
+            expect(intelligenceCapabilities.length).to.be.greaterThan(0);
+        });
+        it('should allow mapping capabilities', () => {
+            const capabilityInfo = ALL_CAPABILITIES.map(CapabilityClass => ({
+                type: CapabilityClass.type,
+                name: CapabilityClass.name
+            }));
+            expect(capabilityInfo.length).to.equal(ALL_CAPABILITIES.length);
+            expect(capabilityInfo[0].type).to.equal(oCapabilityType.TASK);
+        });
+    });
+    describe('Capability metadata', () => {
+        it('should have class names', () => {
+            expect(oCapabilityTask.name).to.equal('oCapabilityTask');
+            expect(oCapabilitySearch.name).to.equal('oCapabilitySearch');
+            expect(oCapabilityEvaluate.name).to.equal('oCapabilityEvaluate');
+            expect(oCapabilityMultipleStep.name).to.equal('oCapabilityMultipleStep');
+            expect(oCapabilityConfigure.name).to.equal('oCapabilityConfigure');
+        });
+        it('should be constructable', () => {
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                expect(() => new CapabilityClass()).to.not.throw();
+            });
+        });
+        it('should have prototype methods', () => {
+            ALL_CAPABILITIES.forEach(CapabilityClass => {
+                expect(CapabilityClass.prototype.execute).to.exist;
+                expect(CapabilityClass.prototype.run).to.exist;
+                expect(CapabilityClass.prototype.cancel).to.exist;
+            });
+        });
+    });
+    describe('Registry immutability', () => {
+        it('should not modify original array when extended', () => {
+            const originalLength = ALL_CAPABILITIES.length;
+            const extended = [...ALL_CAPABILITIES, oCapabilityTask];
+            expect(ALL_CAPABILITIES.length).to.equal(originalLength);
+            expect(extended.length).to.equal(originalLength + 1);
+        });
+        it('should maintain array reference', () => {
+            const reference1 = ALL_CAPABILITIES;
+            const reference2 = ALL_CAPABILITIES;
+            expect(reference1).to.equal(reference2);
+        });
+    });
+});

package/dist/test/capabilities/configure-capability.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=configure-capability.spec.d.ts.map

package/dist/test/capabilities/configure-capability.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure-capability.spec.d.ts","sourceRoot":"","sources":["../../../test/capabilities/configure-capability.spec.ts"],"names":[],"mappings":""}

package/dist/test/capabilities/configure-capability.spec.js

@@ -0,0 +1,366 @@
+import { expect } from 'chai';
+import { oCapabilityConfigure, oCapabilityType } from '@olane/o-lane';
+import { createTestOS, createTestLaneTool, createMockCapabilityConfig } from './utils/capability-test-utils.js';
+describe('oCapabilityConfigure @capability @configure', () => {
+    let os;
+    let laneTool;
+    let configureCapability;
+    before(async () => {
+        os = await createTestOS();
+        laneTool = await createTestLaneTool(os);
+    });
+    after(async () => {
+        if (laneTool) {
+            await laneTool.stop();
+        }
+        if (os) {
+            await os.stop();
+        }
+    });
+    beforeEach(() => {
+        configureCapability = new oCapabilityConfigure();
+    });
+    describe('type identification', () => {
+        it('should return CONFIGURE type from instance getter', () => {
+            expect(configureCapability.type).to.equal(oCapabilityType.CONFIGURE);
+        });
+        it('should return CONFIGURE type from static getter', () => {
+            expect(oCapabilityConfigure.type).to.equal(oCapabilityType.CONFIGURE);
+        });
+    });
+    describe('inheritance', () => {
+        it('should extend oCapabilityIntelligence', async () => {
+            expect(configureCapability).to.respondTo('intelligence');
+        });
+        it('should have access to intelligence method', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test intent'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            expect(configureCapability.intelligence).to.be.a('function');
+        });
+    });
+    describe('generatePrompt() method', () => {
+        it('should generate prompt with tools and methods', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test configuration intent'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            config.history = 'Previous execution history';
+            await configureCapability.execute(config);
+            const tools = ['method1', 'method2', 'method3'];
+            const methods = {
+                method1: {
+                    name: 'method1',
+                    description: 'First method',
+                    params: {}
+                },
+                method2: {
+                    name: 'method2',
+                    description: 'Second method',
+                    params: {}
+                }
+            };
+            const prompt = configureCapability.generatePrompt(tools, methods);
+            expect(prompt).to.be.a('string');
+            expect(prompt.length).to.be.greaterThan(0);
+        });
+        it('should include tool address in prompt', async () => {
+            const toolAddress = 'o://specific-test-tool';
+            const params = {
+                toolAddress,
+                intent: 'Test intent'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            const tools = ['testMethod'];
+            const methods = {
+                testMethod: {
+                    name: 'testMethod',
+                    description: 'Test method',
+                    params: {}
+                }
+            };
+            const prompt = configureCapability.generatePrompt(tools, methods);
+            expect(prompt).to.include(toolAddress);
+        });
+        it('should include user intent in prompt', async () => {
+            const userIntent = 'Configure the calculator to add two numbers';
+            const params = {
+                toolAddress: 'o://calculator',
+                intent: userIntent
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            const tools = ['add'];
+            const methods = {
+                add: {
+                    name: 'add',
+                    description: 'Add two numbers',
+                    params: { a: 'number', b: 'number' }
+                }
+            };
+            const prompt = configureCapability.generatePrompt(tools, methods);
+            expect(prompt).to.include(userIntent);
+        });
+        it('should include history in prompt', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test intent'
+            };
+            const history = 'Previous steps:\n1. Evaluated intent\n2. Found tool';
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            config.history = history;
+            await configureCapability.execute(config);
+            const tools = ['method1'];
+            const methods = {
+                method1: {
+                    name: 'method1',
+                    description: 'Method 1',
+                    params: {}
+                }
+            };
+            const prompt = configureCapability.generatePrompt(tools, methods);
+            expect(prompt).to.be.a('string');
+            // History should be incorporated into the prompt
+        });
+        it('should handle empty tools array', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test intent'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            const tools = [];
+            const methods = {};
+            const prompt = configureCapability.generatePrompt(tools, methods);
+            expect(prompt).to.be.a('string');
+            expect(prompt.length).to.be.greaterThan(0);
+        });
+        it('should handle methods with complex parameters', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test intent'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            const tools = ['complexMethod'];
+            const methods = {
+                complexMethod: {
+                    name: 'complexMethod',
+                    description: 'Complex method with many params',
+                    params: {
+                        stringParam: 'string',
+                        numberParam: 'number',
+                        boolParam: 'boolean',
+                        objectParam: 'object',
+                        arrayParam: 'array'
+                    }
+                }
+            };
+            const prompt = configureCapability.generatePrompt(tools, methods);
+            expect(prompt).to.be.a('string');
+            expect(prompt).to.include('complexMethod');
+        });
+    });
+    describe('handshake() method', () => {
+        it('should attempt handshake with tool address', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test handshake'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            // Handshake may fail if tool doesn't exist
+            try {
+                const result = await configureCapability.handshake();
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if tool is not available
+                expect(error).to.exist;
+            }
+        });
+        it('should include intent in handshake', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Handshake with specific intent'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            try {
+                await configureCapability.handshake();
+            }
+            catch (error) {
+                // Expected if tool is not available
+                // Test validates structure
+            }
+        });
+        it('should return handshake result with tools and methods', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Get tool capabilities'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            try {
+                const result = await configureCapability.handshake();
+                if (result.result) {
+                    expect(result.result).to.have.property('tools');
+                    expect(result.result).to.have.property('methods');
+                }
+            }
+            catch (error) {
+                // Expected if tool is not available
+            }
+        });
+    });
+    describe('run() method', () => {
+        it('should execute handshake and intelligence', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Configure tool usage'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            // May fail if tool or intelligence service not available
+            try {
+                const result = await configureCapability.execute(config);
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if services are not configured
+                expect(error).to.exist;
+            }
+        });
+        it('should handle handshake failure', async () => {
+            const params = {
+                toolAddress: 'o://nonexistent-tool',
+                intent: 'Try to configure nonexistent tool'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            try {
+                const result = await configureCapability.execute(config);
+                // If it doesn't throw, check for error in result
+                if (result.error) {
+                    expect(result.error).to.exist;
+                }
+            }
+            catch (error) {
+                // Expected
+                expect(error).to.exist;
+            }
+        });
+        it('should handle replay mode', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Replay configuration'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params, { isReplay: true });
+            try {
+                const result = await configureCapability.execute(config);
+                expect(result).to.exist;
+                expect(config.isReplay).to.be.true;
+            }
+            catch (error) {
+                // Expected if services not available
+            }
+        });
+    });
+    describe('result structure', () => {
+        it('should return capability result', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test result structure'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            try {
+                const result = await configureCapability.execute(config);
+                expect(result).to.exist;
+                expect(result).to.have.property('type');
+            }
+            catch (error) {
+                // Expected if services not available
+            }
+        });
+        it('should include config in result', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test config inclusion'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            try {
+                const result = await configureCapability.execute(config);
+                if (result.config) {
+                    expect(result.config).to.exist;
+                }
+            }
+            catch (error) {
+                // Expected if services not available
+            }
+        });
+    });
+    describe('configuration parameters', () => {
+        it('should require toolAddress parameter', async () => {
+            const params = {
+                intent: 'Missing tool address'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            try {
+                await configureCapability.execute(config);
+                // If no error, validate that params are accessible
+            }
+            catch (error) {
+                // Should fail without tool address
+                expect(error).to.exist;
+            }
+        });
+        it('should use intent parameter', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Specific configuration intent'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            expect(configureCapability.config.params.intent).to.equal('Specific configuration intent');
+        });
+        it('should handle additional parameters', async () => {
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Test intent',
+                customParam1: 'value1',
+                customParam2: 123
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params);
+            await configureCapability.execute(config);
+            expect(configureCapability.config.params).to.deep.include({
+                toolAddress: 'o://test-tool',
+                intent: 'Test intent',
+                customParam1: 'value1',
+                customParam2: 123
+            });
+        });
+    });
+    describe('streaming support', () => {
+        it('should support streaming configuration', async () => {
+            const chunks = [];
+            const params = {
+                toolAddress: 'o://test-tool',
+                intent: 'Streaming configuration'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Configure intent', params, {
+                useStream: true,
+                onChunk: (chunk) => chunks.push(chunk)
+            });
+            try {
+                await configureCapability.execute(config);
+                expect(config.useStream).to.be.true;
+            }
+            catch (error) {
+                // Expected if services not available
+            }
+        });
+    });
+});

package/dist/test/capabilities/evaluate-capability.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evaluate-capability.spec.d.ts.map

package/dist/test/capabilities/evaluate-capability.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-capability.spec.d.ts","sourceRoot":"","sources":["../../../test/capabilities/evaluate-capability.spec.ts"],"names":[],"mappings":""}