@agenthippo-ai/agenthippo 0.1.0

package/out/agentpack/stores.js

@@ -0,0 +1,554 @@
+"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 });
+exports.listUserLibraryAgents = listUserLibraryAgents;
+exports.isWorkspaceAgentAvailable = isWorkspaceAgentAvailable;
+exports.isAgentInUserLibrary = isAgentInUserLibrary;
+exports.hydrateFromUserLibrary = hydrateFromUserLibrary;
+exports.promoteToUserLibrary = promoteToUserLibrary;
+exports.readAgentSource = readAgentSource;
+exports.checkForUpdate = checkForUpdate;
+exports.updateFromUserLibrary = updateFromUserLibrary;
+exports.duplicateAgent = duplicateAgent;
+exports.resetDefaultAgent = resetDefaultAgent;
+/**
+ * Agent Stores: User Agent Library (UAL) and Hydration Logic
+ *
+ * Implements the local-first storage model from AgentStores.md:
+ * - Workspace Agent Store (WAS): .agentide/agents/<agentId>/ (authoritative)
+ * - User Agent Library (UAL): ${AGENTHIPPO_HOME}/agents/<agentId>/<version>/ (shared)
+ * - Hydration: Pull-only copy from UAL when workspace agent is missing/empty
+ */
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+const paths_1 = require("./paths");
+const manifest_1 = require("./manifest");
+const branding_1 = require("../branding");
+// -----------------------------------------------------------------------------
+// Version Utilities
+// -----------------------------------------------------------------------------
+/**
+ * Compare two semver-like version strings.
+ * Returns: negative if a < b, 0 if equal, positive if a > b
+ */
+function compareSemver(a, b) {
+    const parseVersion = (v) => {
+        // Extract numeric parts, treating non-numeric as 0
+        return v.split('.').map(part => {
+            const num = parseInt(part, 10);
+            return isNaN(num) ? 0 : num;
+        });
+    };
+    const aParts = parseVersion(a);
+    const bParts = parseVersion(b);
+    const maxLen = Math.max(aParts.length, bParts.length);
+    for (let i = 0; i < maxLen; i++) {
+        const aVal = aParts[i] ?? 0;
+        const bVal = bParts[i] ?? 0;
+        if (aVal !== bVal) {
+            return aVal - bVal;
+        }
+    }
+    return 0;
+}
+/**
+ * Sort versions in ascending semver order.
+ */
+function sortVersions(versions) {
+    return [...versions].sort(compareSemver);
+}
+/**
+ * Copy a directory recursively, excluding dot-directories (like .claude, .codex).
+ * Used for UAL promotion to ensure only source-of-truth content is copied.
+ */
+async function copyDirExcludingDotDirs(sourceDir, targetDir) {
+    await fs_1.promises.mkdir(targetDir, { recursive: true });
+    const entries = await fs_1.promises.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(sourceDir, entry.name);
+        const dstPath = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            // Skip dot-directories (derived dirs like .claude, .codex)
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+            await copyDirExcludingDotDirs(srcPath, dstPath);
+        }
+        else {
+            await fs_1.promises.copyFile(srcPath, dstPath);
+        }
+    }
+}
+// -----------------------------------------------------------------------------
+// User Agent Library Operations
+// -----------------------------------------------------------------------------
+/**
+ * List all agents in the User Agent Library.
+ */
+async function listUserLibraryAgents() {
+    const agentsDir = (0, paths_1.getUserAgentsDir)();
+    if (!(await (0, utils_1.pathExists)(agentsDir))) {
+        return [];
+    }
+    const entries = await fs_1.promises.readdir(agentsDir, { withFileTypes: true });
+    const agents = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.')) {
+            continue;
+        }
+        const agentId = entry.name;
+        const agentRoot = (0, paths_1.getUserAgentRoot)(agentId);
+        const versions = await listAgentVersions(agentRoot);
+        if (versions.length === 0) {
+            continue;
+        }
+        const currentVersion = await readCurrentVersion(agentId);
+        // Load metadata from current or latest version
+        const metadataVersion = currentVersion || versions[versions.length - 1];
+        const versionDir = (0, paths_1.getUserAgentVersionDir)(agentId, metadataVersion);
+        const manifestPath = path.join(versionDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+        let description;
+        let preferredEngine;
+        try {
+            const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
+            description = manifest.metadata.description;
+            preferredEngine = manifest.spec.engine;
+        }
+        catch {
+            // Ignore - use defaults
+        }
+        agents.push({
+            id: agentId,
+            versions,
+            currentVersion,
+            description,
+            preferredEngine,
+        });
+    }
+    return agents;
+}
+/**
+ * List available versions for an agent in the UAL.
+ * Returns versions sorted in ascending semver order.
+ */
+async function listAgentVersions(agentRoot) {
+    try {
+        const entries = await fs_1.promises.readdir(agentRoot, { withFileTypes: true });
+        const versions = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.')) {
+                continue;
+            }
+            // Check if this looks like a version (has valid agent.yaml)
+            const manifestPath = path.join(agentRoot, entry.name, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+            if (await (0, utils_1.pathExists)(manifestPath)) {
+                // Validate manifest is parseable
+                try {
+                    await (0, manifest_1.loadAgentManifest)(manifestPath);
+                    versions.push(entry.name);
+                }
+                catch {
+                    // Invalid manifest - skip this version
+                }
+            }
+        }
+        // Sort versions using proper semver comparison
+        return sortVersions(versions);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Read the current version pointer for an agent in the UAL.
+ * Validates that the version directory contains a valid agent.yaml.
+ */
+async function readCurrentVersion(agentId) {
+    const currentPath = (0, paths_1.getUserAgentCurrentPath)(agentId);
+    try {
+        const version = (await fs_1.promises.readFile(currentPath, 'utf8')).trim();
+        if (!version) {
+            return undefined;
+        }
+        // Validate version has a valid agent.yaml
+        const versionDir = (0, paths_1.getUserAgentVersionDir)(agentId, version);
+        const manifestPath = path.join(versionDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+        if (!(await (0, utils_1.pathExists)(manifestPath))) {
+            return undefined;
+        }
+        // Validate manifest is parseable
+        try {
+            await (0, manifest_1.loadAgentManifest)(manifestPath);
+            return version;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    catch {
+        // No current.txt or invalid
+    }
+    return undefined;
+}
+// -----------------------------------------------------------------------------
+// Hydration: Copy from UAL to Workspace
+// -----------------------------------------------------------------------------
+/**
+ * Check if a workspace agent is available (has valid agent.yaml).
+ */
+async function isWorkspaceAgentAvailable(workspaceRoot, agentId) {
+    const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, agentId);
+    if (!(await (0, utils_1.pathExists)(manifestPath))) {
+        return false;
+    }
+    try {
+        const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
+        return manifest.metadata.name === agentId;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if an agent is available in the User Agent Library.
+ */
+async function isAgentInUserLibrary(agentId) {
+    const currentVersion = await readCurrentVersion(agentId);
+    if (currentVersion) {
+        return true;
+    }
+    // Check if any versions exist
+    const agentRoot = (0, paths_1.getUserAgentRoot)(agentId);
+    const versions = await listAgentVersions(agentRoot);
+    return versions.length > 0;
+}
+/**
+ * Hydrate an agent from the User Agent Library into the workspace.
+ * Only called when workspace agent is missing/empty.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param agentId - Agent ID to hydrate
+ * @param version - Specific version (or undefined for current/latest)
+ * @param outputChannel - Output channel for logging
+ * @returns The hydrated version, or undefined if hydration failed
+ */
+async function hydrateFromUserLibrary(workspaceRoot, agentId, version, outputChannel) {
+    // Resolve version
+    let resolvedVersion = version;
+    let resolvedFrom = version ?? 'current';
+    if (!resolvedVersion) {
+        resolvedVersion = await readCurrentVersion(agentId);
+        if (!resolvedVersion) {
+            // Fall back to latest version
+            const agentRoot = (0, paths_1.getUserAgentRoot)(agentId);
+            const versions = await listAgentVersions(agentRoot);
+            if (versions.length === 0) {
+                (0, utils_1.logInfo)(outputChannel, `[AgentStores] Agent not in User Library: ${agentId}`);
+                return undefined;
+            }
+            resolvedVersion = versions[versions.length - 1];
+            resolvedFrom = resolvedVersion;
+        }
+    }
+    const sourceDir = (0, paths_1.getUserAgentVersionDir)(agentId, resolvedVersion);
+    if (!(await (0, utils_1.pathExists)(sourceDir))) {
+        (0, utils_1.logInfo)(outputChannel, `[AgentStores] Version not found in User Library: ${agentId}@${resolvedVersion}`);
+        return undefined;
+    }
+    const targetDir = (0, paths_1.getAgentRoot)(workspaceRoot, agentId);
+    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Hydrating ${agentId}@${resolvedVersion} from User Library`);
+    // Clear target directory if it exists to avoid mixed/dirty state
+    if (await (0, utils_1.pathExists)(targetDir)) {
+        (0, utils_1.logInfo)(outputChannel, `[AgentStores] Clearing existing directory: ${targetDir}`);
+        await fs_1.promises.rm(targetDir, { recursive: true, force: true });
+    }
+    // Copy agent to workspace
+    await (0, utils_1.copyDirRecursive)(sourceDir, targetDir);
+    // Write provenance file
+    const manifestPath = path.join(targetDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+    const { sha256 } = await (0, utils_1.readFileSha256)(manifestPath);
+    const source = {
+        source: 'user-library',
+        agentId,
+        version: resolvedVersion,
+        resolvedFrom,
+        sha256,
+        hydratedAt: new Date().toISOString(),
+    };
+    const sourcePath = path.join(targetDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE);
+    await fs_1.promises.writeFile(sourcePath, JSON.stringify(source, null, 2), 'utf8');
+    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Hydrated ${agentId}@${resolvedVersion} to ${targetDir}`);
+    return resolvedVersion;
+}
+// -----------------------------------------------------------------------------
+// Promote: Copy from Workspace to UAL
+// -----------------------------------------------------------------------------
+/**
+ * Promote (share) a workspace agent to the User Agent Library.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param agentId - Agent ID to promote
+ * @param outputChannel - Output channel for logging
+ * @returns The promoted version, or throws on conflict
+ */
+async function promoteToUserLibrary(workspaceRoot, agentId, outputChannel) {
+    // Cannot promote the default agent
+    if (agentId === paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID) {
+        throw new Error('Cannot promote the default agent to User Library');
+    }
+    const sourceDir = (0, paths_1.getAgentRoot)(workspaceRoot, agentId);
+    const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, agentId);
+    if (!(await (0, utils_1.pathExists)(manifestPath))) {
+        throw new Error(`Agent not found: ${agentId}`);
+    }
+    // Load manifest to get version
+    const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
+    const version = manifest.metadata.version;
+    const targetDir = (0, paths_1.getUserAgentVersionDir)(agentId, version);
+    const targetManifestPath = path.join(targetDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+    // Check for version conflict
+    if (await (0, utils_1.pathExists)(targetManifestPath)) {
+        const sourceHash = await (0, utils_1.readFileSha256)(manifestPath);
+        const targetHash = await (0, utils_1.readFileSha256)(targetManifestPath);
+        if (sourceHash.sha256 === targetHash.sha256) {
+            (0, utils_1.logInfo)(outputChannel, `[AgentStores] ${agentId}@${version} already in User Library (identical)`);
+            return version;
+        }
+        throw new Error(`Version conflict: ${agentId}@${version} already exists in User Library with different content. ` +
+            `Bump the version in agent.yaml and try again.`);
+    }
+    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Promoting ${agentId}@${version} to User Library`);
+    // Ensure UAL directories exist
+    await fs_1.promises.mkdir(targetDir, { recursive: true });
+    // Copy agent to UAL (excluding dot-dirs like .claude, .codex)
+    await copyDirExcludingDotDirs(sourceDir, targetDir);
+    // Update current.txt pointer
+    const currentPath = (0, paths_1.getUserAgentCurrentPath)(agentId);
+    await fs_1.promises.writeFile(currentPath, version, 'utf8');
+    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Promoted ${agentId}@${version} to ${targetDir}`);
+    return version;
+}
+// -----------------------------------------------------------------------------
+// Update: Pull new version from UAL to Workspace
+// -----------------------------------------------------------------------------
+/**
+ * Read the provenance of a workspace agent.
+ */
+async function readAgentSource(workspaceRoot, agentId) {
+    const sourcePath = path.join((0, paths_1.getAgentRoot)(workspaceRoot, agentId), paths_1.AGENT_CONSTANTS.SOURCE_FILE);
+    try {
+        const content = await fs_1.promises.readFile(sourcePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Check if an update is available from the User Agent Library.
+ * Returns the UAL's current version if it differs from the workspace version.
+ *
+ * @returns The new version if available, undefined otherwise
+ */
+async function checkForUpdate(workspaceRoot, agentId) {
+    const source = await readAgentSource(workspaceRoot, agentId);
+    if (!source || source.source !== 'user-library') {
+        return undefined;
+    }
+    const ualCurrentVersion = await readCurrentVersion(agentId);
+    if (!ualCurrentVersion) {
+        return undefined;
+    }
+    // Check if UAL has a different version than what we hydrated
+    // Note: This is a simple check - doesn't determine if it's newer or older
+    if (ualCurrentVersion !== source.version) {
+        return ualCurrentVersion;
+    }
+    return undefined;
+}
+/**
+ * Update a workspace agent from the User Agent Library.
+ * Creates a backup before updating.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param agentId - Agent ID to update
+ * @param version - Specific version (or undefined for current)
+ * @param outputChannel - Output channel for logging
+ * @returns The updated version
+ */
+async function updateFromUserLibrary(workspaceRoot, agentId, version, outputChannel) {
+    const agentDir = (0, paths_1.getAgentRoot)(workspaceRoot, agentId);
+    // Create backup
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = path.join(path.dirname(agentDir), `.${agentId}.backup-${timestamp}`);
+    if (await (0, utils_1.pathExists)(agentDir)) {
+        (0, utils_1.logInfo)(outputChannel, `[AgentStores] Backing up ${agentId} to ${backupDir}`);
+        await (0, utils_1.copyDirRecursive)(agentDir, backupDir);
+        await fs_1.promises.rm(agentDir, { recursive: true, force: true });
+    }
+    // Hydrate new version
+    const hydratedVersion = await hydrateFromUserLibrary(workspaceRoot, agentId, version, outputChannel);
+    if (!hydratedVersion) {
+        // Restore backup
+        if (await (0, utils_1.pathExists)(backupDir)) {
+            (0, utils_1.logInfo)(outputChannel, `[AgentStores] Restoring backup after failed update`);
+            await (0, utils_1.copyDirRecursive)(backupDir, agentDir);
+        }
+        throw new Error(`Failed to update ${agentId} from User Library`);
+    }
+    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Updated ${agentId} to ${hydratedVersion}`);
+    return hydratedVersion;
+}
+// -----------------------------------------------------------------------------
+// Duplicate: Create a copy of an agent with new ID
+// -----------------------------------------------------------------------------
+/**
+ * Generate a unique agent ID by appending a suffix.
+ */
+async function generateUniqueAgentId(workspaceRoot, baseId) {
+    // First try <baseId>-copy
+    const copyId = `${baseId}-copy`;
+    if (!(await (0, utils_1.pathExists)((0, paths_1.getAgentRoot)(workspaceRoot, copyId)))) {
+        return copyId;
+    }
+    // Then try <baseId>-2, <baseId>-3, etc.
+    for (let i = 2; i < 100; i++) {
+        const suffixedId = `${baseId}-${i}`;
+        if (!(await (0, utils_1.pathExists)((0, paths_1.getAgentRoot)(workspaceRoot, suffixedId)))) {
+            return suffixedId;
+        }
+    }
+    // Fallback: use timestamp
+    return `${baseId}-${Date.now()}`;
+}
+/**
+ * Duplicate a workspace agent with a new ID.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param sourceAgentId - Agent ID to duplicate
+ * @param outputChannel - Output channel for logging
+ * @returns The new agent ID
+ */
+async function duplicateAgent(workspaceRoot, sourceAgentId, outputChannel) {
+    const sourceAgentDir = (0, paths_1.getAgentRoot)(workspaceRoot, sourceAgentId);
+    const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, sourceAgentId);
+    if (!(await (0, utils_1.pathExists)(manifestPath))) {
+        throw new Error(`Agent not found: ${sourceAgentId}`);
+    }
+    const newAgentId = await generateUniqueAgentId(workspaceRoot, sourceAgentId);
+    const targetDir = (0, paths_1.getAgentRoot)(workspaceRoot, newAgentId);
+    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Duplicating ${sourceAgentId} to ${newAgentId}`);
+    // Copy agent (excluding dot-dirs like .claude, .codex)
+    await copyDirExcludingDotDirs(sourceAgentDir, targetDir);
+    // Update metadata.name in agent.yaml using proper YAML handling
+    const newManifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, newAgentId);
+    await (0, manifest_1.updateManifestName)(newManifestPath, newAgentId);
+    // Mark as locally created (remove provenance file if exists)
+    const sourcePath = path.join(targetDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE);
+    try {
+        await fs_1.promises.rm(sourcePath, { force: true });
+    }
+    catch {
+        // Ignore
+    }
+    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Duplicated ${sourceAgentId} to ${newAgentId}`);
+    return newAgentId;
+}
+// -----------------------------------------------------------------------------
+// Reset: Restore default agent from bundled templates
+// -----------------------------------------------------------------------------
+/**
+ * Reset the default agent from bundled templates.
+ * Creates a backup before resetting.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param bundledDir - Bundled base prompts directory
+ * @param outputChannel - Output channel for logging
+ */
+async function resetDefaultAgent(workspaceRoot, bundledDir, outputChannel) {
+    const defaultAgentDir = (0, paths_1.getAgentRoot)(workspaceRoot, paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID);
+    // Create backup
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = path.join(path.dirname(defaultAgentDir), `.default.backup-${timestamp}`);
+    if (await (0, utils_1.pathExists)(defaultAgentDir)) {
+        (0, utils_1.logInfo)(outputChannel, `[AgentStores] Backing up default agent to ${backupDir}`);
+        await (0, utils_1.copyDirRecursive)(defaultAgentDir, backupDir);
+        await fs_1.promises.rm(defaultAgentDir, { recursive: true, force: true });
+    }
+    // Create fresh default agent structure
+    await fs_1.promises.mkdir(defaultAgentDir, { recursive: true });
+    await fs_1.promises.mkdir(path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.RULES_DIR), { recursive: true });
+    await fs_1.promises.mkdir(path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.SKILLS_DIR), { recursive: true });
+    // Copy bundled AGENTS.md if available (with branding tokens applied)
+    if (bundledDir) {
+        const bundledAgentsFile = path.join(bundledDir, 'rules', 'AGENTS.md');
+        const targetAgentsFile = path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.AGENTS_MD);
+        if (await (0, utils_1.pathExists)(bundledAgentsFile)) {
+            const content = await fs_1.promises.readFile(bundledAgentsFile, 'utf8');
+            await fs_1.promises.writeFile(targetAgentsFile, (0, branding_1.applyBrandingTokens)(content), 'utf8');
+            (0, utils_1.logInfo)(outputChannel, `[AgentStores] Restored AGENTS.md from bundled templates`);
+        }
+        // Copy bundled GHOST_TEXT.md (inline completions prompt) if available
+        const bundledGhostTextFile = path.join(bundledDir, paths_1.AGENT_CONSTANTS.GHOST_TEXT_FILE);
+        const targetGhostTextFile = path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.GHOST_TEXT_FILE);
+        if (await (0, utils_1.pathExists)(bundledGhostTextFile) && !(await (0, utils_1.pathExists)(targetGhostTextFile))) {
+            const content = await fs_1.promises.readFile(bundledGhostTextFile, 'utf8');
+            await fs_1.promises.writeFile(targetGhostTextFile, content, 'utf8');
+            (0, utils_1.logInfo)(outputChannel, `[AgentStores] Restored GHOST_TEXT.md from bundled templates`);
+        }
+        // Copy bundled skills (with branding tokens applied to markdown files)
+        const bundledSkillsDir = path.join(bundledDir, 'skills');
+        if (await (0, utils_1.pathExists)(bundledSkillsDir)) {
+            const entries = await fs_1.promises.readdir(bundledSkillsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const srcSkill = path.join(bundledSkillsDir, entry.name);
+                const dstSkill = path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.SKILLS_DIR, entry.name);
+                await (0, utils_1.copyDirRecursiveWithTransform)(srcSkill, dstSkill, branding_1.applyBrandingTokens);
+                (0, utils_1.logInfo)(outputChannel, `[AgentStores] Restored skill: ${entry.name}`);
+            }
+        }
+    }
+    const defaultAgentYaml = (0, paths_1.generateDefaultAgentYaml)({ model: 'claude' });
+    const agentYamlPath = path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+    await fs_1.promises.writeFile(agentYamlPath, defaultAgentYaml, 'utf8');
+    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Reset default agent complete`);
+}

package/out/agentpack/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });