@phnx-labs/agents-cli 1.22.38 → 1.22.40

package/dist/lib/resources/skills.js

@@ -1,247 +0,0 @@
-/**
- * Skills resource handler.
- *
- * Skills are directory bundles with a SKILL.md containing YAML frontmatter.
- * Format is the same for all agents. Resolution order: project > user > system.
- */
-import * as fs from 'fs';
-import { AGENTS, agentConfigDirName, isAgentHardDeprecated } from '../agents.js';
-import * as path from 'path';
-import * as yaml from 'yaml';
-import { getSystemSkillsDir, getUserSkillsDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../state.js';
-/** Default provider uses the real state module. */
-const defaultProvider = {
-    getSystemSkillsDir,
-    getUserSkillsDir,
-    getProjectAgentsDir,
-    getEnabledExtraRepos,
-};
-/**
- * Parse SKILL.md frontmatter to extract skill metadata.
- * Returns null if the file doesn't exist or has no valid frontmatter.
- */
-function parseSkillMetadata(skillDir) {
-    const skillMdPath = path.join(skillDir, 'SKILL.md');
-    if (!fs.existsSync(skillMdPath)) {
-        return null;
-    }
-    try {
-        const content = fs.readFileSync(skillMdPath, 'utf-8');
-        const lines = content.split('\n');
-        // Check for YAML frontmatter (required)
-        if (lines[0] === '---') {
-            const endIndex = lines.slice(1).findIndex((l) => l === '---');
-            if (endIndex > 0) {
-                const frontmatter = lines.slice(1, endIndex + 1).join('\n');
-                const parsed = yaml.parse(frontmatter);
-                return {
-                    name: parsed.name || '',
-                    description: parsed.description || '',
-                    author: parsed.author,
-                    version: parsed.version,
-                    license: parsed.license,
-                    keywords: parsed.keywords,
-                };
-            }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Count .md files in the skill's rules/ subdirectory.
- */
-function countSkillRules(skillDir) {
-    const rulesDir = path.join(skillDir, 'rules');
-    if (!fs.existsSync(rulesDir)) {
-        return 0;
-    }
-    try {
-        const files = fs.readdirSync(rulesDir);
-        return files.filter((f) => f.endsWith('.md')).length;
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * Count bundled resource files in a skill directory (everything except SKILL.md).
- */
-function countSkillFiles(skillDir) {
-    if (!fs.existsSync(skillDir))
-        return 0;
-    let count = 0;
-    const walk = (dir) => {
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (entry.name.startsWith('.'))
-                continue;
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(full);
-            }
-            else if (entry.isFile()) {
-                if (dir === skillDir && entry.name === 'SKILL.md')
-                    continue;
-                count++;
-            }
-        }
-    };
-    walk(skillDir);
-    return count;
-}
-/**
- * List skill directories in a given base path.
- * Returns array of { name, fullPath } for directories containing SKILL.md.
- */
-function listSkillsInDir(baseDir) {
-    if (!fs.existsSync(baseDir))
-        return [];
-    const results = [];
-    try {
-        const entries = fs.readdirSync(baseDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith('.'))
-                continue;
-            const fullPath = path.join(baseDir, entry.name);
-            const skillMdPath = path.join(fullPath, 'SKILL.md');
-            if (fs.existsSync(skillMdPath)) {
-                results.push({ name: entry.name, fullPath });
-            }
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    return results;
-}
-/**
- * Get layer directories for skill resolution.
- */
-function getLayerDirs(cwd, provider = defaultProvider) {
-    const layers = [];
-    // Project layer
-    const projectDir = cwd ? provider.getProjectAgentsDir(cwd) : null;
-    if (projectDir) {
-        layers.push({ layer: 'project', dir: path.join(projectDir, 'skills') });
-    }
-    // User layer
-    layers.push({ layer: 'user', dir: provider.getUserSkillsDir() });
-    // Extra repos (treated as user layer since they're user-configured)
-    for (const extra of provider.getEnabledExtraRepos()) {
-        layers.push({ layer: 'user', dir: path.join(extra.dir, 'skills') });
-    }
-    // System layer
-    layers.push({ layer: 'system', dir: provider.getSystemSkillsDir() });
-    return layers;
-}
-/**
- * Create a SkillsHandler with the given layer directory provider.
- * Useful for testing with custom directory structures.
- */
-export function createSkillsHandler(provider = defaultProvider) {
-    return {
-        kind: 'skill',
-        listAll(_agent, cwd) {
-            const seen = new Map();
-            const layers = getLayerDirs(cwd, provider);
-            // Process in order: project > user > system
-            // First occurrence wins (higher layer takes precedence)
-            for (const { layer, dir } of layers) {
-                const skills = listSkillsInDir(dir);
-                for (const { name, fullPath } of skills) {
-                    if (seen.has(name))
-                        continue; // Higher layer already has this skill
-                    const metadata = parseSkillMetadata(fullPath);
-                    if (!metadata)
-                        continue; // Skip invalid skills
-                    seen.set(name, {
-                        name,
-                        item: {
-                            metadata,
-                            ruleCount: countSkillRules(fullPath),
-                            fileCount: countSkillFiles(fullPath),
-                        },
-                        layer,
-                        path: fullPath,
-                    });
-                }
-            }
-            return Array.from(seen.values()).sort((a, b) => a.name.localeCompare(b.name));
-        },
-        resolve(_agent, name, cwd) {
-            const layers = getLayerDirs(cwd, provider);
-            for (const { layer, dir } of layers) {
-                const skillPath = path.join(dir, name);
-                const skillMdPath = path.join(skillPath, 'SKILL.md');
-                if (fs.existsSync(skillMdPath)) {
-                    const metadata = parseSkillMetadata(skillPath);
-                    if (!metadata)
-                        continue;
-                    return {
-                        name,
-                        item: {
-                            metadata,
-                            ruleCount: countSkillRules(skillPath),
-                            fileCount: countSkillFiles(skillPath),
-                        },
-                        layer,
-                        path: skillPath,
-                    };
-                }
-            }
-            return null;
-        },
-        sync(agent, versionHome, cwd) {
-            if (isAgentHardDeprecated(agent)) {
-                return;
-            }
-            // Agents that read directly from central ~/.agents/skills/ (e.g. Gemini,
-            // Goose via the Summon extension) should not get a per-version copy.
-            if (AGENTS[agent]?.nativeAgentsSkillsDir) {
-                return;
-            }
-            const targetDir = path.join(versionHome, agentConfigDirName(agent), 'skills');
-            // Ensure target directory exists
-            if (!fs.existsSync(targetDir)) {
-                fs.mkdirSync(targetDir, { recursive: true });
-            }
-            const resolved = this.listAll(agent, cwd);
-            for (const skill of resolved) {
-                const targetPath = path.join(targetDir, skill.name);
-                // Remove existing if present
-                if (fs.existsSync(targetPath) || fs.lstatSync(targetPath, { throwIfNoEntry: false })) {
-                    try {
-                        fs.rmSync(targetPath, { recursive: true, force: true });
-                    }
-                    catch {
-                        // Ignore removal errors
-                    }
-                }
-                // Copy skill directory
-                try {
-                    fs.cpSync(skill.path, targetPath, { recursive: true });
-                }
-                catch {
-                    // Ignore copy errors
-                }
-            }
-        },
-        format(_agent) {
-            return 'md';
-        },
-        targetDir(agent) {
-            return `${agentConfigDirName(agent)}/skills`;
-        },
-    };
-}
-/** Default handler using real state module paths. */
-export const SkillsHandler = createSkillsHandler();

package/dist/lib/resources/subagents.d.ts

@@ -1,46 +0,0 @@
-/**
- * Subagents resource handler.
- *
- * Subagents are YAML files stored in subagents/ directories across layers.
- * Format is the same for all agents. Resolution order: project > user > system.
- */
-import type { AgentId, ResolvedItem, ResourceHandler } from './types.js';
-/** Parsed content of a subagent YAML file. */
-export interface SubagentItem {
-    name: string;
-    description: string;
-    model?: string;
-    /** Hex color for UI display. */
-    color?: string;
-    /** Additional agent-specific config. */
-    config?: Record<string, unknown>;
-}
-export declare class SubagentsHandler implements ResourceHandler<SubagentItem> {
-    readonly kind: "subagent";
-    /**
-     * List all subagents across layers, with higher layer winning on name conflict.
-     * Returns a union of all subagents, deduplicated by name.
-     */
-    listAll(_agent: AgentId, cwd?: string): ResolvedItem<SubagentItem>[];
-    /**
-     * Resolve a single subagent by name.
-     * Returns the winning layer's version, or null if not found.
-     */
-    resolve(_agent: AgentId, name: string, cwd?: string): ResolvedItem<SubagentItem> | null;
-    /**
-     * Sync resolved subagents to the agent's version home directory.
-     * Copies YAML files to the target directory.
-     */
-    sync(agent: AgentId, versionHome: string, cwd?: string): void;
-    /**
-     * Get the file format this resource uses for a given agent.
-     * Subagents always use YAML format.
-     */
-    format(_agent: AgentId): 'md' | 'toml' | 'json' | 'yaml';
-    /**
-     * Get the target directory name in the agent's version home.
-     */
-    targetDir(_agent: AgentId): string;
-}
-/** Singleton instance of the SubagentsHandler. */
-export declare const subagentsHandler: SubagentsHandler;

package/dist/lib/resources/subagents.js

@@ -1,202 +0,0 @@
-/**
- * Subagents resource handler.
- *
- * Subagents are YAML files stored in subagents/ directories across layers.
- * Format is the same for all agents. Resolution order: project > user > system.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'yaml';
-import { getProjectAgentsDir, getUserSubagentsDir, getSystemSubagentsDir, getEnabledExtraRepos, } from '../state.js';
-import { isAgentHardDeprecated } from '../agents.js';
-/** Get layer directories for subagent resolution. */
-function getLayerDirs(cwd) {
-    const projectDir = getProjectAgentsDir(cwd);
-    const extraRepos = getEnabledExtraRepos();
-    return {
-        system: path.join(getSystemSubagentsDir()),
-        user: getUserSubagentsDir(),
-        project: projectDir ? path.join(projectDir, 'subagents') : null,
-        extra: extraRepos.map((e) => path.join(e.dir, 'subagents')),
-    };
-}
-/** Map source directory to layer name. */
-function dirToLayer(dir, dirs) {
-    if (dirs.project && dir.startsWith(dirs.project))
-        return 'project';
-    if (dir.startsWith(dirs.user))
-        return 'user';
-    return 'system';
-}
-/** Parse a subagent YAML file and return parsed item. */
-function parseSubagentYaml(filePath) {
-    if (!fs.existsSync(filePath)) {
-        return null;
-    }
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const parsed = yaml.parse(content);
-        if (!parsed || typeof parsed !== 'object') {
-            return null;
-        }
-        return {
-            name: parsed.name || '',
-            description: parsed.description || '',
-            model: parsed.model,
-            color: parsed.color,
-            config: parsed.config,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/** Extract name from filename (removes .yaml/.yml extension). */
-function nameFromFile(filename) {
-    return filename.replace(/\.ya?ml$/, '');
-}
-export class SubagentsHandler {
-    kind = 'subagent';
-    /**
-     * List all subagents across layers, with higher layer winning on name conflict.
-     * Returns a union of all subagents, deduplicated by name.
-     */
-    listAll(_agent, cwd) {
-        const dirs = getLayerDirs(cwd);
-        const seen = new Set();
-        const results = [];
-        // Order: project > user > system > extra (extra comes last after system)
-        const layerDirs = [];
-        if (dirs.project && fs.existsSync(dirs.project)) {
-            layerDirs.push({ dir: dirs.project, layer: 'project' });
-        }
-        if (fs.existsSync(dirs.user)) {
-            layerDirs.push({ dir: dirs.user, layer: 'user' });
-        }
-        if (fs.existsSync(dirs.system)) {
-            layerDirs.push({ dir: dirs.system, layer: 'system' });
-        }
-        for (const extraDir of dirs.extra) {
-            if (fs.existsSync(extraDir)) {
-                layerDirs.push({ dir: extraDir, layer: 'system' });
-            }
-        }
-        for (const { dir, layer } of layerDirs) {
-            let entries;
-            try {
-                entries = fs.readdirSync(dir, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            for (const entry of entries) {
-                if (!entry.isFile())
-                    continue;
-                if (!entry.name.endsWith('.yaml') && !entry.name.endsWith('.yml'))
-                    continue;
-                if (entry.name.startsWith('.'))
-                    continue;
-                const name = nameFromFile(entry.name);
-                if (seen.has(name))
-                    continue;
-                const filePath = path.join(dir, entry.name);
-                const item = parseSubagentYaml(filePath);
-                if (!item)
-                    continue;
-                seen.add(name);
-                results.push({
-                    name,
-                    item,
-                    layer,
-                    path: filePath,
-                });
-            }
-        }
-        return results;
-    }
-    /**
-     * Resolve a single subagent by name.
-     * Returns the winning layer's version, or null if not found.
-     */
-    resolve(_agent, name, cwd) {
-        const dirs = getLayerDirs(cwd);
-        // Order: project > user > system > extra
-        const searchDirs = [];
-        if (dirs.project) {
-            searchDirs.push({ dir: dirs.project, layer: 'project' });
-        }
-        searchDirs.push({ dir: dirs.user, layer: 'user' });
-        searchDirs.push({ dir: dirs.system, layer: 'system' });
-        for (const extraDir of dirs.extra) {
-            searchDirs.push({ dir: extraDir, layer: 'system' });
-        }
-        for (const { dir, layer } of searchDirs) {
-            if (!fs.existsSync(dir))
-                continue;
-            // Try .yaml first, then .yml
-            for (const ext of ['.yaml', '.yml']) {
-                const filePath = path.join(dir, name + ext);
-                if (fs.existsSync(filePath)) {
-                    const item = parseSubagentYaml(filePath);
-                    if (item) {
-                        return {
-                            name,
-                            item,
-                            layer,
-                            path: filePath,
-                        };
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Sync resolved subagents to the agent's version home directory.
-     * Copies YAML files to the target directory.
-     */
-    sync(agent, versionHome, cwd) {
-        if (isAgentHardDeprecated(agent)) {
-            return;
-        }
-        const targetDir = path.join(versionHome, this.targetDir(agent));
-        // Ensure target directory exists
-        if (!fs.existsSync(targetDir)) {
-            fs.mkdirSync(targetDir, { recursive: true });
-        }
-        // Clear existing subagents in target
-        try {
-            const existing = fs.readdirSync(targetDir);
-            for (const file of existing) {
-                if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                    fs.unlinkSync(path.join(targetDir, file));
-                }
-            }
-        }
-        catch {
-            // Ignore errors during cleanup
-        }
-        // Copy all resolved subagents
-        const resolved = this.listAll(agent, cwd);
-        for (const { name, path: sourcePath } of resolved) {
-            const ext = sourcePath.endsWith('.yml') ? '.yml' : '.yaml';
-            const targetPath = path.join(targetDir, name + ext);
-            fs.copyFileSync(sourcePath, targetPath);
-        }
-    }
-    /**
-     * Get the file format this resource uses for a given agent.
-     * Subagents always use YAML format.
-     */
-    format(_agent) {
-        return 'yaml';
-    }
-    /**
-     * Get the target directory name in the agent's version home.
-     */
-    targetDir(_agent) {
-        return 'subagents';
-    }
-}
-/** Singleton instance of the SubagentsHandler. */
-export const subagentsHandler = new SubagentsHandler();