@agenthippo-ai/agenthippo 0.1.0

package/out/test/agentYaml.test.js

@@ -0,0 +1,373 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// YAML parsing (same as used in sync.ts)
+function parseYaml(content) {
+    const yaml = require('js-yaml');
+    return yaml.load(content);
+}
+function dumpYaml(doc) {
+    const yaml = require('js-yaml');
+    return yaml.dump(doc, { lineWidth: 120, noRefs: true });
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+async function createTempDir() {
+    return fs.mkdtemp(path.join(os.tmpdir(), 'agentide-test-'));
+}
+async function writeAgentYaml(dir, manifest) {
+    const filePath = path.join(dir, 'agent.yaml');
+    await fs.writeFile(filePath, dumpYaml(manifest), 'utf8');
+    return filePath;
+}
+async function readAgentYaml(dir) {
+    const filePath = path.join(dir, 'agent.yaml');
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        return parseYaml(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+// =============================================================================
+// Agent YAML Structure Tests
+// =============================================================================
+suite('Agent YAML Structure', () => {
+    let tempDir;
+    setup(async () => {
+        tempDir = await createTempDir();
+    });
+    teardown(async () => {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+    test('minimal valid agent.yaml has required fields', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'test-agent',
+                version: '1.0.0',
+            },
+            spec: {
+                engine: 'claude',
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.strictEqual(read.apiVersion, 'agenthippo.ai/v1');
+        assert.strictEqual(read.kind, 'Agent');
+        assert.strictEqual(read.metadata.name, 'test-agent');
+        assert.strictEqual(read.metadata.version, '1.0.0');
+        assert.strictEqual(read.spec.engine, 'claude');
+    });
+    test('agent.yaml with all metadata fields', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'full-agent',
+                version: '2.0.0',
+                author: 'Test Author',
+                description: 'A fully featured test agent',
+            },
+            spec: {
+                engine: 'codex',
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.strictEqual(read.metadata.name, 'full-agent');
+        assert.strictEqual(read.metadata.version, '2.0.0');
+        assert.strictEqual(read.metadata.author, 'Test Author');
+        assert.strictEqual(read.metadata.description, 'A fully featured test agent');
+    });
+    test('agent.yaml with skills array', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'skilled-agent',
+                version: '1.0.0',
+            },
+            spec: {
+                engine: 'claude',
+                skills: [
+                    { path: './skills/code-review' },
+                    { path: './skills/testing', name: 'Testing Skill' },
+                ],
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.ok(read.spec.skills, 'Skills should exist');
+        assert.strictEqual(read.spec.skills.length, 2);
+        assert.strictEqual(read.spec.skills[0].path, './skills/code-review');
+        assert.strictEqual(read.spec.skills[1].name, 'Testing Skill');
+    });
+    test('agent.yaml with permissions', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'capable-agent',
+                version: '1.0.0',
+            },
+            spec: {
+                engine: 'claude',
+                permissions: {
+                    fileAccess: 'full',
+                },
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.ok(read.spec.permissions, 'Permissions should exist');
+        assert.strictEqual(read.spec.permissions.fileAccess, 'full');
+    });
+    test('agent.yaml with MCP servers', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'mcp-agent',
+                version: '1.0.0',
+            },
+            spec: {
+                engine: 'claude',
+                mcp: [
+                    { name: 'database', config: './mcp/database.json' },
+                    { name: 'api-gateway', config: './mcp/api.json' },
+                ],
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.ok(read.spec.mcp, 'MCP should exist');
+        assert.strictEqual(read.spec.mcp.length, 2);
+        assert.strictEqual(read.spec.mcp[0].name, 'database');
+    });
+    test('agent.yaml visibility options', async () => {
+        for (const visibility of ['internal', 'team', 'public']) {
+            const manifest = {
+                apiVersion: 'agenthippo.ai/v1',
+                kind: 'Agent',
+                metadata: {
+                    name: `${visibility}-agent`,
+                    version: '1.0.0',
+                },
+                spec: {
+                    engine: 'claude',
+                    visibility,
+                },
+            };
+            await writeAgentYaml(tempDir, manifest);
+            const read = await readAgentYaml(tempDir);
+            assert.ok(read, `Should be able to read agent.yaml with visibility ${visibility}`);
+            assert.strictEqual(read.spec.visibility, visibility);
+        }
+    });
+    test('agent.yaml engine options', async () => {
+        for (const engine of ['claude', 'codex']) {
+            const manifest = {
+                apiVersion: 'agenthippo.ai/v1',
+                kind: 'Agent',
+                metadata: {
+                    name: `${engine}-agent`,
+                    version: '1.0.0',
+                },
+                spec: {
+                    engine,
+                },
+            };
+            await writeAgentYaml(tempDir, manifest);
+            const read = await readAgentYaml(tempDir);
+            assert.ok(read, `Should be able to read agent.yaml with engine ${engine}`);
+            assert.strictEqual(read.spec.engine, engine);
+        }
+    });
+    test('agent.yaml with model specification', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'model-agent',
+                version: '1.0.0',
+            },
+            spec: {
+                engine: 'claude',
+                model: 'claude-sonnet-4-20250514',
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.strictEqual(read.spec.model, 'claude-sonnet-4-20250514');
+    });
+    test('agent.yaml with optional cheap model specification', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'cheap-model-agent',
+                version: '1.0.0',
+            },
+            spec: {
+                engine: 'claude',
+                model: 'claude-sonnet-4-5-20250929',
+                cheapModel: 'claude-haiku-4-5-20251001',
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.strictEqual(read.spec.cheapModel, 'claude-haiku-4-5-20251001');
+    });
+    test('default agent has kind: Agent', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'default',
+                version: '1.0.0',
+                description: 'Workspace default agent',
+            },
+            spec: {
+                engine: 'claude',
+                permissions: {
+                    fileAccess: 'workspace-write',
+                },
+                visibility: 'internal',
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.strictEqual(read.kind, 'Agent');
+        assert.strictEqual(read.metadata.name, 'default');
+    });
+});
+// =============================================================================
+// Agent YAML Computed Fields Tests
+// =============================================================================
+suite('Agent YAML Computed Fields', () => {
+    let tempDir;
+    setup(async () => {
+        tempDir = await createTempDir();
+    });
+    teardown(async () => {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+    test('computed fields are preserved during read/write', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'computed-agent',
+                version: '1.0.0',
+            },
+            spec: {
+                engine: 'claude',
+            },
+            computed: {
+                agentSignature: 'sig-abc123',
+                skillsSignature: 'skills-def456',
+                rulesSignature: 'rules-ghi789',
+                promptsSignature: 'prompts-jkl012',
+                featureSetHash: 'feature-mno345',
+                syncedAt: '2025-01-15T10:00:00.000Z',
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.ok(read.computed, 'Computed should exist');
+        assert.strictEqual(read.computed.agentSignature, 'sig-abc123');
+        assert.strictEqual(read.computed.skillsSignature, 'skills-def456');
+        assert.strictEqual(read.computed.featureSetHash, 'feature-mno345');
+        assert.strictEqual(read.computed.syncedAt, '2025-01-15T10:00:00.000Z');
+    });
+    test('computed derivedSkillIngestState is preserved', async () => {
+        const manifest = {
+            apiVersion: 'agenthippo.ai/v1',
+            kind: 'Agent',
+            metadata: {
+                name: 'ingest-agent',
+                version: '1.0.0',
+            },
+            spec: {
+                engine: 'claude',
+            },
+            computed: {
+                agentSignature: 'sig-123',
+                skillsSignature: 'skills-123',
+                rulesSignature: 'rules-123',
+                promptsSignature: 'prompts-123',
+                featureSetHash: 'feature-123',
+                syncedAt: '2025-01-15T10:00:00.000Z',
+                derivedSkillIngestState: {
+                    'skill-a': {
+                        lastIngestedSkillMdSha256: 'sha256-aaa',
+                        lastIngestedAt: '2025-01-15T09:00:00.000Z',
+                    },
+                    'skill-b': {
+                        lastIngestedSkillMdSha256: 'sha256-bbb',
+                        lastIngestedAt: '2025-01-15T09:30:00.000Z',
+                    },
+                },
+            },
+        };
+        await writeAgentYaml(tempDir, manifest);
+        const read = await readAgentYaml(tempDir);
+        assert.ok(read, 'Should be able to read agent.yaml');
+        assert.ok(read.computed?.derivedSkillIngestState, 'derivedSkillIngestState should exist');
+        assert.strictEqual(Object.keys(read.computed.derivedSkillIngestState).length, 2);
+        assert.strictEqual(read.computed.derivedSkillIngestState['skill-a'].lastIngestedSkillMdSha256, 'sha256-aaa');
+    });
+});