@agenthippo-ai/agenthippo 0.1.0

package/out/test/agentpack.test.js

@@ -0,0 +1,639 @@
+"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 path = __importStar(require("path"));
+// Import the functions we want to test - only pure utilities that don't depend on vscode
+const paths_1 = require("../agentpack/paths");
+const manifest_1 = require("../agentpack/manifest");
+// Note: Session and engine tests require vscode module and are tested via
+// VS Code's extension test framework (src/vs/workbench/contrib/agentide/test/)
+// =============================================================================
+// Agent Path Resolution Tests (Pure Functions - No vscode dependency)
+// =============================================================================
+suite('Agent Path Resolution', () => {
+    const workspaceRoot = '/Users/test/myproject';
+    const storageUri = '/Users/test/.vscode/storage';
+    test('resolveAgentRuntimePaths returns correct paths for a pack', () => {
+        const paths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'code-reviewer', '1.0.0');
+        assert.strictEqual(paths.agentId, 'code-reviewer');
+        assert.strictEqual(paths.agentVersion, '1.0.0');
+        assert.strictEqual(paths.agentRoot, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'code-reviewer'));
+        assert.strictEqual(paths.rulesDir, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'code-reviewer', 'rules'));
+        assert.strictEqual(paths.skillsDir, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'code-reviewer', 'skills'));
+        assert.strictEqual(paths.codexDerivedDir, path.join(workspaceRoot, '.codex'));
+        assert.strictEqual(paths.claudeDerivedDir, path.join(workspaceRoot, '.claude'));
+        assert.strictEqual(paths.codexHome, path.join(storageUri, 'agents', 'code-reviewer', 'codex'));
+        assert.strictEqual(paths.claudeConfigDir, path.join(storageUri, 'agents', 'code-reviewer', 'claude'));
+    });
+    test('resolveAgentRuntimePaths returns correct paths for default agent', () => {
+        const paths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'default');
+        assert.strictEqual(paths.agentId, 'default');
+        assert.strictEqual(paths.agentRoot, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'default'));
+        assert.strictEqual(paths.rulesDir, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'default', 'rules'));
+        assert.strictEqual(paths.skillsDir, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'default', 'skills'));
+        assert.strictEqual(paths.codexDerivedDir, path.join(workspaceRoot, '.codex'));
+        assert.strictEqual(paths.claudeDerivedDir, path.join(workspaceRoot, '.claude'));
+        assert.strictEqual(paths.codexHome, path.join(storageUri, 'agents', 'default', 'codex'));
+        assert.strictEqual(paths.claudeConfigDir, path.join(storageUri, 'agents', 'default', 'claude'));
+    });
+    test('resolveRuntimePaths returns pack paths when agentId is provided', () => {
+        const paths = (0, paths_1.resolveRuntimePaths)(workspaceRoot, storageUri, 'my-pack');
+        assert.strictEqual(paths.agentId, 'my-pack');
+        assert.ok(paths.agentRoot.includes('agents'));
+    });
+    test('resolveRuntimePaths returns default paths when agentId is undefined', () => {
+        const paths = (0, paths_1.resolveRuntimePaths)(workspaceRoot, storageUri);
+        assert.strictEqual(paths.agentId, 'default');
+    });
+    test('resolveRuntimePaths returns default paths when agentId is "default"', () => {
+        const paths = (0, paths_1.resolveRuntimePaths)(workspaceRoot, storageUri, 'default');
+        assert.strictEqual(paths.agentId, 'default');
+    });
+    test('isDefaultAgent correctly identifies default agent', () => {
+        assert.strictEqual((0, paths_1.isDefaultAgent)('default'), true);
+        assert.strictEqual((0, paths_1.isDefaultAgent)('code-reviewer'), false);
+        assert.strictEqual((0, paths_1.isDefaultAgent)(''), false);
+    });
+});
+suite('Agent Path Utilities', () => {
+    const workspaceRoot = '/Users/test/project';
+    test('getAgentManifestPath returns correct path', () => {
+        const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, 'code-reviewer');
+        assert.strictEqual(manifestPath, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'code-reviewer', 'agent.yaml'));
+    });
+    test('getAgentAgentsMdPath returns correct path', () => {
+        const agentsMdPath = (0, paths_1.getAgentAgentsMdPath)(workspaceRoot, 'code-reviewer');
+        assert.strictEqual(agentsMdPath, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'code-reviewer', 'AGENTS.md'));
+    });
+    test('getAgentsDir returns correct path', () => {
+        const agentsDir = (0, paths_1.getAgentsDir)(workspaceRoot);
+        assert.strictEqual(agentsDir, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'));
+    });
+    test('getAgentRoot returns correct path', () => {
+        const agentRoot = (0, paths_1.getAgentRoot)(workspaceRoot, 'my-agent');
+        assert.strictEqual(agentRoot, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'my-agent'));
+    });
+    test('parseAgentIdFromPath extracts agent ID correctly', () => {
+        const agentRoot = path.join('/Users/test/project', paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'code-reviewer');
+        const agentId = (0, paths_1.parseAgentIdFromPath)(agentRoot);
+        assert.strictEqual(agentId, 'code-reviewer');
+    });
+    test('parseAgentIdFromPath returns undefined for non-agent path', () => {
+        const nonAgentPath = path.join('/Users/test/project', paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'skills');
+        const agentId = (0, paths_1.parseAgentIdFromPath)(nonAgentPath);
+        assert.strictEqual(agentId, undefined);
+    });
+});
+suite('Agent Constants', () => {
+    test('AGENT_CONSTANTS has required values', () => {
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID, 'default');
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.AGENTS_DIR, 'agents');
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.RULES_DIR, 'rules');
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.SKILLS_DIR, 'skills');
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.MANIFEST_FILE, 'agent.yaml');
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.AGENTS_MD, 'AGENTS.md');
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.CLAUDE_MD, 'CLAUDE.md');
+    });
+});
+// =============================================================================
+// Agent Runtime Path Isolation Tests
+// =============================================================================
+suite('Agent Runtime Path Isolation', () => {
+    const workspaceRoot = '/Users/test/myproject';
+    const storageUri = '/Users/test/.vscode/storage';
+    test('different agents have different codexHome paths', () => {
+        const agentA = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-a');
+        const agentB = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-b');
+        assert.notStrictEqual(agentA.codexHome, agentB.codexHome);
+        assert.ok(agentA.codexHome.includes('agent-a'));
+        assert.ok(agentB.codexHome.includes('agent-b'));
+    });
+    test('different agents have different claudeConfigDir paths', () => {
+        const agentA = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-a');
+        const agentB = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-b');
+        assert.notStrictEqual(agentA.claudeConfigDir, agentB.claudeConfigDir);
+        assert.ok(agentA.claudeConfigDir.includes('agent-a'));
+        assert.ok(agentB.claudeConfigDir.includes('agent-b'));
+    });
+    test('all agents have the same derived dirs (workspace root)', () => {
+        const agentA = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-a');
+        const agentB = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-b');
+        const defaultAgent = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'default');
+        // All agents share the same derived dirs at workspace root
+        assert.strictEqual(agentA.codexDerivedDir, agentB.codexDerivedDir);
+        assert.strictEqual(agentA.claudeDerivedDir, agentB.claudeDerivedDir);
+        assert.strictEqual(agentA.codexDerivedDir, defaultAgent.codexDerivedDir);
+        assert.strictEqual(agentA.claudeDerivedDir, defaultAgent.claudeDerivedDir);
+    });
+    test('agent content paths are isolated per agent', () => {
+        const agentA = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-a');
+        const defaultAgent = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'default');
+        // Content dirs should be different
+        assert.notStrictEqual(agentA.agentRoot, defaultAgent.agentRoot);
+        assert.notStrictEqual(agentA.rulesDir, defaultAgent.rulesDir);
+        assert.notStrictEqual(agentA.skillsDir, defaultAgent.skillsDir);
+        // SDK config dirs should be different
+        assert.notStrictEqual(agentA.codexHome, defaultAgent.codexHome);
+        assert.notStrictEqual(agentA.claudeConfigDir, defaultAgent.claudeConfigDir);
+    });
+    test('derived dirs are at workspace root for all agents', () => {
+        const paths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'test-agent');
+        assert.strictEqual(paths.codexDerivedDir, path.join(workspaceRoot, '.codex'), '.codex/ should be at workspace root');
+        assert.strictEqual(paths.claudeDerivedDir, path.join(workspaceRoot, '.claude'), '.claude/ should be at workspace root');
+    });
+});
+// =============================================================================
+// User Agent Library (UAL) Path Tests
+// =============================================================================
+suite('User Agent Library Paths', () => {
+    // Save and restore env vars
+    let originalAgentideHome;
+    let originalUserAgentsDir;
+    setup(() => {
+        originalAgentideHome = process.env.AGENTHIPPO_HOME;
+        originalUserAgentsDir = process.env.AGENTIDE_USER_AGENTS_DIR;
+        delete process.env.AGENTHIPPO_HOME;
+        delete process.env.AGENTIDE_USER_AGENTS_DIR;
+    });
+    teardown(() => {
+        if (originalAgentideHome !== undefined) {
+            process.env.AGENTHIPPO_HOME = originalAgentideHome;
+        }
+        else {
+            delete process.env.AGENTHIPPO_HOME;
+        }
+        if (originalUserAgentsDir !== undefined) {
+            process.env.AGENTIDE_USER_AGENTS_DIR = originalUserAgentsDir;
+        }
+        else {
+            delete process.env.AGENTIDE_USER_AGENTS_DIR;
+        }
+    });
+    test('getAgentideHome returns default path', () => {
+        const home = (0, paths_1.getAgentideHome)();
+        assert.ok(home.endsWith(paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME), `Expected path ending with ${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}, got ${home}`);
+    });
+    test('getAgentideHome respects AGENTHIPPO_HOME env var', () => {
+        process.env.AGENTHIPPO_HOME = '/custom/agentide';
+        const home = (0, paths_1.getAgentideHome)();
+        assert.strictEqual(home, '/custom/agentide');
+    });
+    test('getUserAgentsDir returns correct path', () => {
+        process.env.AGENTHIPPO_HOME = `/home/user/${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}`;
+        const dir = (0, paths_1.getUserAgentsDir)();
+        assert.strictEqual(dir, path.join('/home/user', paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'));
+    });
+    test('getUserAgentsDir respects AGENTIDE_USER_AGENTS_DIR env var', () => {
+        process.env.AGENTIDE_USER_AGENTS_DIR = '/custom/agents';
+        const dir = (0, paths_1.getUserAgentsDir)();
+        assert.strictEqual(dir, '/custom/agents');
+    });
+    test('getUserAgentRoot returns correct path', () => {
+        process.env.AGENTHIPPO_HOME = `/home/user/${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}`;
+        const root = (0, paths_1.getUserAgentRoot)('my-agent');
+        assert.strictEqual(root, path.join('/home/user', paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'my-agent'));
+    });
+    test('getUserAgentVersionDir returns correct path', () => {
+        process.env.AGENTHIPPO_HOME = `/home/user/${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}`;
+        const versionDir = (0, paths_1.getUserAgentVersionDir)('my-agent', '1.0.0');
+        assert.strictEqual(versionDir, path.join('/home/user', paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'my-agent', '1.0.0'));
+    });
+    test('getUserAgentCurrentPath returns correct path', () => {
+        process.env.AGENTHIPPO_HOME = `/home/user/${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}`;
+        const currentPath = (0, paths_1.getUserAgentCurrentPath)('my-agent');
+        assert.strictEqual(currentPath, path.join('/home/user', paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'my-agent', 'current.txt'));
+    });
+});
+// =============================================================================
+// Agent Manifest Parsing Tests
+// =============================================================================
+suite('Agent Manifest Parsing', () => {
+    test('parseAgentManifest parses valid manifest', () => {
+        const yaml = [
+            'apiVersion: agenthippo.ai/v1',
+            'kind: Agent',
+            'metadata:',
+            '  name: test-agent',
+            '  version: "1.0.0"',
+            '  description: A test agent',
+            'spec:',
+            '  engine: claude',
+            '  permissions:',
+            '    fileAccess: workspace-write',
+        ].join('\n');
+        const manifest = (0, manifest_1.parseAgentManifest)(yaml);
+        assert.strictEqual(manifest.metadata.name, 'test-agent');
+        assert.strictEqual(manifest.metadata.version, '1.0.0');
+        assert.strictEqual(manifest.metadata.description, 'A test agent');
+        assert.strictEqual(manifest.spec.engine, 'claude');
+    });
+    test('parseAgentManifest throws on missing metadata.name', () => {
+        const yaml = [
+            'metadata:',
+            '  version: "1.0.0"',
+            'spec:',
+            '  engine: claude',
+        ].join('\n');
+        assert.throws(() => (0, manifest_1.parseAgentManifest)(yaml), /missing metadata\.name/i);
+    });
+    test('parseAgentManifest throws on missing metadata.version', () => {
+        const yaml = [
+            'metadata:',
+            '  name: test-agent',
+            'spec:',
+            '  engine: claude',
+        ].join('\n');
+        assert.throws(() => (0, manifest_1.parseAgentManifest)(yaml), /missing metadata\.version/i);
+    });
+    test('parseAgentManifest throws on missing spec.engine', () => {
+        const yaml = [
+            'metadata:',
+            '  name: test-agent',
+            '  version: "1.0.0"',
+            'spec:',
+            '  permissions:',
+            '    fileAccess: workspace-write',
+        ].join('\n');
+        assert.throws(() => (0, manifest_1.parseAgentManifest)(yaml), /missing spec\.engine/i);
+    });
+    test('parseAgentManifest accepts optional spec.data config', () => {
+        const yaml = [
+            'metadata:',
+            '  name: data-agent',
+            '  version: "1.0.0"',
+            'spec:',
+            '  engine: claude',
+            '  data:',
+            '    sourcePath: ./data',
+            `    workspacePath: .${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME.slice(1)}/data/data-agent`,
+        ].join('\n');
+        const manifest = (0, manifest_1.parseAgentManifest)(yaml);
+        assert.strictEqual(manifest.spec.data?.sourcePath, './data');
+        assert.strictEqual(manifest.spec.data?.workspacePath, `.${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME.slice(1)}/data/data-agent`);
+    });
+    test('parseAgentManifest allows spec.data with defaults derived from metadata.name', () => {
+        const yaml = [
+            'metadata:',
+            '  name: my-agent',
+            '  version: "1.0.0"',
+            'spec:',
+            '  engine: claude',
+            '  data: {}',
+        ].join('\n');
+        const manifest = (0, manifest_1.parseAgentManifest)(yaml);
+        assert.strictEqual(manifest.metadata.name, 'my-agent');
+    });
+    test('parseAgentManifest rejects absolute spec.data.sourcePath', () => {
+        const yaml = [
+            'metadata:',
+            '  name: data-agent',
+            '  version: "1.0.0"',
+            'spec:',
+            '  engine: claude',
+            '  data:',
+            '    sourcePath: /tmp/data',
+        ].join('\n');
+        assert.throws(() => (0, manifest_1.parseAgentManifest)(yaml), /spec\.data\.sourcePath.*relative/i);
+    });
+    test('parseAgentManifest rejects URL spec.data.sourcePath', () => {
+        const yaml = [
+            'metadata:',
+            '  name: data-agent',
+            '  version: "1.0.0"',
+            'spec:',
+            '  engine: claude',
+            '  data:',
+            '    sourcePath: https://example.com/repo.git',
+        ].join('\n');
+        assert.throws(() => (0, manifest_1.parseAgentManifest)(yaml), /spec\.data\.sourcePath.*local relative path/i);
+    });
+    test('parseAgentManifest rejects parent-escape spec.data.workspacePath', () => {
+        const yaml = [
+            'metadata:',
+            '  name: data-agent',
+            '  version: "1.0.0"',
+            'spec:',
+            '  engine: claude',
+            '  data:',
+            '    workspacePath: ../outside',
+        ].join('\n');
+        assert.throws(() => (0, manifest_1.parseAgentManifest)(yaml), /spec\.data\.workspacePath.*escape parent directories/i);
+    });
+    test('parseAgentManifest includes source path in error message', () => {
+        const yaml = [
+            'metadata:',
+            '  version: "1.0.0"',
+            'spec:',
+            '  engine: claude',
+        ].join('\n');
+        try {
+            (0, manifest_1.parseAgentManifest)(yaml, '/path/to/agent.yaml');
+            assert.fail('Expected error to be thrown');
+        }
+        catch (e) {
+            assert.ok(e instanceof Error);
+            assert.ok(e.message.includes('/path/to/agent.yaml'));
+        }
+    });
+    test('parseAgentManifest handles codex engine', () => {
+        const yaml = [
+            'metadata:',
+            '  name: codex-agent',
+            '  version: "2.0.0"',
+            'spec:',
+            '  engine: codex',
+            '  model: o3',
+        ].join('\n');
+        const manifest = (0, manifest_1.parseAgentManifest)(yaml);
+        assert.strictEqual(manifest.spec.engine, 'codex');
+        assert.strictEqual(manifest.spec.model, 'o3');
+    });
+    test('parseAgentManifest accepts optional spec.cheapModel', () => {
+        const yaml = [
+            'metadata:',
+            '  name: cheap-model-agent',
+            '  version: "1.0.0"',
+            'spec:',
+            '  engine: claude',
+            '  model: claude-sonnet-4-5-20250929',
+            '  cheapModel: claude-haiku-4-5-20251001',
+        ].join('\n');
+        const manifest = (0, manifest_1.parseAgentManifest)(yaml);
+        assert.strictEqual(manifest.spec.engine, 'claude');
+        assert.strictEqual(manifest.spec.cheapModel, 'claude-haiku-4-5-20251001');
+    });
+});
+// =============================================================================
+// Agent Constants - UAL additions
+// =============================================================================
+suite('Agent Constants - UAL', () => {
+    test('AGENT_CONSTANTS has UAL-related values', () => {
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.SOURCE_FILE, '.agentide-source.json');
+        assert.strictEqual(paths_1.AGENT_CONSTANTS.CURRENT_VERSION_FILE, 'current.txt');
+    });
+});
+// =============================================================================
+// Pack Name Validation Tests
+// =============================================================================
+suite('Pack Name Validation', () => {
+    test('isValidPackName accepts valid simple names', () => {
+        assert.strictEqual((0, paths_1.isValidPackName)('agent'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('code-reviewer'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('security-auditor'), true);
+    });
+    test('isValidPackName accepts names with numbers', () => {
+        assert.strictEqual((0, paths_1.isValidPackName)('agent2'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('code-reviewer-v2'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('123test'), true); // Numbers at start are OK
+    });
+    test('isValidPackName accepts uppercase and mixed case', () => {
+        assert.strictEqual((0, paths_1.isValidPackName)('CodeReviewer'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('code-Reviewer'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('AGENT'), true);
+    });
+    test('isValidPackName accepts underscores and other valid chars', () => {
+        assert.strictEqual((0, paths_1.isValidPackName)('code_reviewer'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('code.reviewer'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('code@reviewer'), true);
+        assert.strictEqual((0, paths_1.isValidPackName)('code reviewer'), true); // spaces OK
+    });
+    test('isValidPackName rejects empty string', () => {
+        assert.strictEqual((0, paths_1.isValidPackName)(''), false);
+    });
+    test('isValidPackName rejects names starting with dot', () => {
+        assert.strictEqual((0, paths_1.isValidPackName)('.hidden'), false);
+        assert.strictEqual((0, paths_1.isValidPackName)('.agent'), false);
+    });
+    test('isValidPackName rejects path separators', () => {
+        assert.strictEqual((0, paths_1.isValidPackName)('path/name'), false);
+        assert.strictEqual((0, paths_1.isValidPackName)('path\\name'), false);
+    });
+    test('isValidPackName rejects problematic filesystem chars', () => {
+        assert.strictEqual((0, paths_1.isValidPackName)('name:with:colons'), false);
+        assert.strictEqual((0, paths_1.isValidPackName)('name*star'), false);
+        assert.strictEqual((0, paths_1.isValidPackName)('name?question'), false);
+        assert.strictEqual((0, paths_1.isValidPackName)('name<angle>'), false);
+        assert.strictEqual((0, paths_1.isValidPackName)('name|pipe'), false);
+    });
+});
+suite('Pack Name Error Messages', () => {
+    test('getPackNameError returns undefined for valid names', () => {
+        assert.strictEqual((0, paths_1.getPackNameError)('code-reviewer'), undefined);
+        assert.strictEqual((0, paths_1.getPackNameError)('agent'), undefined);
+        assert.strictEqual((0, paths_1.getPackNameError)('My Agent'), undefined);
+    });
+    test('getPackNameError returns error for empty string', () => {
+        const error = (0, paths_1.getPackNameError)('');
+        assert.ok(error);
+        assert.ok(error.includes('required'));
+    });
+    test('getPackNameError returns error for whitespace-only', () => {
+        const error = (0, paths_1.getPackNameError)('   ');
+        assert.ok(error);
+    });
+    test('getPackNameError returns error for dot-prefixed names', () => {
+        const error = (0, paths_1.getPackNameError)('.hidden');
+        assert.ok(error);
+        assert.ok(error.includes('dot'));
+    });
+    test('getPackNameError returns error for path separators', () => {
+        const error = (0, paths_1.getPackNameError)('path/name');
+        assert.ok(error);
+        assert.ok(error.includes('separator') || error.includes('special'));
+    });
+});
+suite('Pack Name Normalization', () => {
+    test('normalizePackName trims whitespace', () => {
+        assert.strictEqual((0, paths_1.normalizePackName)('  code-review  '), 'code-review');
+    });
+    test('normalizePackName converts to lowercase', () => {
+        assert.strictEqual((0, paths_1.normalizePackName)('CodeReviewer'), 'codereviewer');
+        assert.strictEqual((0, paths_1.normalizePackName)('CODE-REVIEW'), 'code-review');
+    });
+    test('normalizePackName replaces spaces with hyphens', () => {
+        assert.strictEqual((0, paths_1.normalizePackName)('My Code Reviewer'), 'my-code-reviewer');
+        assert.strictEqual((0, paths_1.normalizePackName)('code review agent'), 'code-review-agent');
+    });
+    test('normalizePackName replaces underscores with hyphens', () => {
+        assert.strictEqual((0, paths_1.normalizePackName)('code_reviewer'), 'code-reviewer');
+        assert.strictEqual((0, paths_1.normalizePackName)('my_code_review'), 'my-code-review');
+    });
+    test('normalizePackName collapses multiple hyphens', () => {
+        assert.strictEqual((0, paths_1.normalizePackName)('code--review'), 'code-review');
+        assert.strictEqual((0, paths_1.normalizePackName)('code---review'), 'code-review');
+    });
+    test('normalizePackName removes leading and trailing hyphens', () => {
+        assert.strictEqual((0, paths_1.normalizePackName)('-code-review-'), 'code-review');
+        assert.strictEqual((0, paths_1.normalizePackName)('---test---'), 'test');
+    });
+    test('normalizePackName handles complex input', () => {
+        assert.strictEqual((0, paths_1.normalizePackName)('  My Code__Reviewer  '), 'my-code-reviewer');
+        assert.strictEqual((0, paths_1.normalizePackName)('Security   Audit'), 'security-audit');
+    });
+});
+suite('Strip Model Provider Prefix', () => {
+    test('strips agentide-litellm:: prefix', () => {
+        assert.strictEqual((0, paths_1.stripModelProviderPrefix)('agentide-litellm::litellm/gpt-4.1-nano'), 'litellm/gpt-4.1-nano');
+    });
+    test('strips agentide:: prefix', () => {
+        assert.strictEqual((0, paths_1.stripModelProviderPrefix)('agentide::claude-sonnet-4'), 'claude-sonnet-4');
+    });
+    test('leaves model IDs without prefix unchanged', () => {
+        assert.strictEqual((0, paths_1.stripModelProviderPrefix)('claude-sonnet-4'), 'claude-sonnet-4');
+        assert.strictEqual((0, paths_1.stripModelProviderPrefix)('gpt-4o'), 'gpt-4o');
+    });
+    test('handles litellm/ path format', () => {
+        assert.strictEqual((0, paths_1.stripModelProviderPrefix)('litellm/gpt-4.1-nano'), 'litellm/gpt-4.1-nano');
+    });
+    test('handles empty string', () => {
+        assert.strictEqual((0, paths_1.stripModelProviderPrefix)(''), '');
+    });
+});
+suite('Pack Name to Title', () => {
+    test('packNameToTitle converts single word', () => {
+        assert.strictEqual((0, paths_1.packNameToTitle)('agent'), 'Agent');
+    });
+    test('packNameToTitle converts hyphenated names', () => {
+        assert.strictEqual((0, paths_1.packNameToTitle)('code-reviewer'), 'Code Reviewer');
+    });
+    test('packNameToTitle converts multiple hyphens', () => {
+        assert.strictEqual((0, paths_1.packNameToTitle)('security-code-auditor'), 'Security Code Auditor');
+    });
+    test('packNameToTitle converts underscored names', () => {
+        assert.strictEqual((0, paths_1.packNameToTitle)('code_reviewer'), 'Code Reviewer');
+    });
+    test('packNameToTitle converts mixed separators', () => {
+        assert.strictEqual((0, paths_1.packNameToTitle)('code_reviewer-v2'), 'Code Reviewer V2');
+    });
+    test('packNameToTitle handles spaces', () => {
+        assert.strictEqual((0, paths_1.packNameToTitle)('my custom agent'), 'My Custom Agent');
+    });
+});
+// =============================================================================
+// Pack Template Generation Tests
+// =============================================================================
+suite('Agent YAML Generation', () => {
+    test('generateAgentYaml creates valid YAML structure', () => {
+        const yaml = (0, paths_1.generateAgentYaml)('test-agent');
+        assert.ok(yaml.includes('apiVersion: agenthippo.ai/v1'));
+        assert.ok(yaml.includes('kind: Agent'));
+        assert.ok(yaml.includes('name: test-agent'));
+    });
+    test('generateAgentYaml includes custom description', () => {
+        const yaml = (0, paths_1.generateAgentYaml)('my-agent', {
+            description: 'A custom test agent',
+        });
+        assert.ok(yaml.includes('A custom test agent'));
+    });
+    test('generateAgentYaml sets engine correctly', () => {
+        const claudeYaml = (0, paths_1.generateAgentYaml)('claude-agent', { engine: 'claude' });
+        const codexYaml = (0, paths_1.generateAgentYaml)('codex-agent', { engine: 'codex' });
+        assert.ok(claudeYaml.includes('engine: claude'));
+        assert.ok(claudeYaml.includes('model: claude-sonnet-4'));
+        assert.ok(codexYaml.includes('engine: codex'));
+        assert.ok(codexYaml.includes('model: codex'));
+    });
+    test('generateAgentYaml includes all required sections', () => {
+        const yaml = (0, paths_1.generateAgentYaml)('test-agent');
+        assert.ok(yaml.includes('metadata:'));
+        assert.ok(yaml.includes('spec:'));
+        assert.ok(yaml.includes('permissions:'));
+        assert.ok(yaml.includes('fileAccess: full'));
+    });
+    test('generateAgentYaml documents optional data block', () => {
+        const yaml = (0, paths_1.generateAgentYaml)('data-agent');
+        assert.ok(yaml.includes('# Optional: seed pack data into workspace on first use'));
+        assert.ok(yaml.includes('# data:'));
+        assert.ok(yaml.includes('#   sourcePath: ./data'));
+        assert.ok(yaml.includes(`#   workspacePath: ${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/data/data-agent`));
+    });
+    test('generateAgentYaml includes author', () => {
+        const yaml = (0, paths_1.generateAgentYaml)('test-agent', { author: 'test-user' });
+        assert.ok(yaml.includes('author: test-user'));
+    });
+    test('generateAgentYaml includes cheapModel when provided', () => {
+        const yaml = (0, paths_1.generateAgentYaml)('test-agent', {
+            engine: 'claude',
+            model: 'claude-sonnet-4-5-20250929',
+            cheapModel: 'claude-haiku-4-5-20251001',
+        });
+        assert.ok(yaml.includes('cheapModel: claude-haiku-4-5-20251001'));
+    });
+});
+suite('Default Agent YAML Generation', () => {
+    test('generateDefaultAgentYaml creates valid default agent manifest', () => {
+        const yaml = (0, paths_1.generateDefaultAgentYaml)();
+        const manifest = (0, manifest_1.parseAgentManifest)(yaml);
+        assert.strictEqual(manifest.metadata.name, 'default');
+        assert.strictEqual(manifest.spec.engine, 'claude');
+        assert.strictEqual(manifest.spec.permissions?.fileAccess, 'full');
+    });
+    test('generateDefaultAgentYaml can include model hint comments', () => {
+        const yaml = (0, paths_1.generateDefaultAgentYaml)({ includeModelHintComment: true });
+        assert.ok(yaml.includes('# model: claude-sonnet-4-20250514'));
+    });
+    test('generateDefaultAgentYaml can set an explicit model', () => {
+        const yaml = (0, paths_1.generateDefaultAgentYaml)({ model: 'claude' });
+        assert.ok(yaml.includes('model: claude'));
+    });
+});
+suite('AGENTS.md Generation', () => {
+    test('generateAgentsMd creates markdown with title', () => {
+        const md = (0, paths_1.generateAgentsMd)('code-reviewer');
+        assert.ok(md.includes('# Code Reviewer Agent'));
+    });
+    test('generateAgentsMd includes custom description', () => {
+        const md = (0, paths_1.generateAgentsMd)('my-agent', {
+            description: 'A specialized agent for testing',
+        });
+        assert.ok(md.includes('A specialized agent for testing'));
+    });
+    test('generateAgentsMd includes all sections', () => {
+        const md = (0, paths_1.generateAgentsMd)('test-agent');
+        assert.ok(md.includes('## Core Behaviors'));
+        assert.ok(md.includes('## Constraints'));
+        assert.ok(md.includes('## Output Format'));
+    });
+    test('generateAgentsMd uses default description if not provided', () => {
+        const md = (0, paths_1.generateAgentsMd)('security-auditor');
+        // Should contain something about the agent's purpose
+        assert.ok(md.includes('Security Auditor'));
+    });
+});