@phnx-labs/agents-cli 1.22.38 → 1.22.40

package/dist/lib/resources/memory.js

@@ -1,46 +0,0 @@
-/**
- * Memory resource handler — knowledge/facts store (not rules/instructions).
- *
- * Canonical source: layered `memory/` dirs under project/user/system agents
- * roots. Sync copies into each capable agent's version home (see memory.ts).
- */
-import * as fs from 'fs';
-import { listMemoryFacts, readMemoryFact, syncMemoryToVersionHome, memoryTargetDir, } from '../memory.js';
-function toItem(fact) {
-    let content = '';
-    try {
-        content = fs.readFileSync(fact.path, 'utf-8');
-    }
-    catch {
-        content = '';
-    }
-    return {
-        name: fact.name,
-        item: { name: fact.name, content, summary: fact.summary },
-        layer: fact.layer,
-        path: fact.path,
-    };
-}
-export const MemoryHandler = {
-    kind: 'memory',
-    listAll(_agent, cwd) {
-        return listMemoryFacts(cwd).map(toItem);
-    },
-    resolve(_agent, name, cwd) {
-        const fact = readMemoryFact(name, cwd);
-        return fact ? toItem(fact) : null;
-    },
-    sync(agent, versionHome, cwd) {
-        syncMemoryToVersionHome(agent, versionHome, cwd);
-    },
-    format(_agent) {
-        return 'md';
-    },
-    targetDir(agent) {
-        return memoryTargetDir(agent);
-    },
-};
-/** Convenience: list fact names for a cwd. */
-export function listMemoryNames(cwd) {
-    return listMemoryFacts(cwd).map((f) => f.name);
-}

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

@@ -1,13 +0,0 @@
-/**
- * PermissionsHandler - ResourceHandler implementation for permissions.
- *
- * Permissions are stored as YAML files in permissions/ directories at each layer.
- * Resolution: project > user > system (higher layer wins on name conflict).
- * Unlike other resources, permissions merge into agent-specific config files
- * (Claude: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
- */
-import type { ResourceHandler } from './types.js';
-import type { PermissionSet } from '../types.js';
-export type PermissionItem = PermissionSet;
-export declare const PermissionsHandler: ResourceHandler<PermissionItem>;
-export default PermissionsHandler;

package/dist/lib/resources/permissions.js

@@ -1,202 +0,0 @@
-/**
- * PermissionsHandler - ResourceHandler implementation for permissions.
- *
- * Permissions are stored as YAML files in permissions/ directories at each layer.
- * Resolution: project > user > system (higher layer wins on name conflict).
- * Unlike other resources, permissions merge into agent-specific config files
- * (Claude: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { getSystemAgentsDir, getUserAgentsDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../state.js';
-import { parsePermissionSet, applyPermissionsToVersion, mergePermissionSets, } from '../permissions.js';
-import { isCapable } from '../capabilities.js';
-/**
- * Get the permissions directory for a given layer root.
- */
-function getPermissionsDirForRoot(root) {
-    return path.join(root, 'permissions');
-}
-/**
- * Get layer directories for permission resolution.
- */
-function getLayerDirs(cwd) {
-    return {
-        system: getSystemAgentsDir(),
-        user: getUserAgentsDir(),
-        project: cwd ? getProjectAgentsDir(cwd) : null,
-        extra: getEnabledExtraRepos().map((e) => e.dir),
-    };
-}
-/**
- * List permission files in a directory.
- * Returns only YAML files, stripping the extension for the name.
- */
-function listPermissionsInDir(dir) {
-    if (!fs.existsSync(dir))
-        return [];
-    try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        const permissions = [];
-        for (const entry of entries) {
-            if (!entry.isFile())
-                continue;
-            if (entry.name.startsWith('.'))
-                continue;
-            if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
-                permissions.push({
-                    name: entry.name.replace(/\.(yaml|yml)$/, ''),
-                    path: path.join(dir, entry.name),
-                });
-            }
-        }
-        return permissions;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Get the config file path for an agent's permissions.
- */
-function getAgentConfigPath(agent, versionHome) {
-    switch (agent) {
-        case 'claude':
-            return path.join(versionHome, '.claude', 'settings.json');
-        case 'codex':
-            return path.join(versionHome, '.codex', 'config.toml');
-        case 'opencode':
-            return path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
-        case 'kimi':
-            return path.join(versionHome, '.kimi-code', 'config.toml');
-        case 'droid':
-            return path.join(versionHome, '.factory', 'settings.json');
-        case 'kiro':
-            return path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
-        case 'openclaw':
-            return path.join(versionHome, '.openclaw', 'openclaw.json');
-        case 'copilot':
-            return path.join(versionHome, '.copilot', 'permissions-config.json');
-        case 'hermes':
-            return path.join(versionHome, '.hermes', 'config.yaml');
-        case 'goose':
-            return path.join(versionHome, '.config', 'goose', 'permission.yaml');
-        case 'muse':
-            // Muse approval defaults live in settings.json; no separate permissions file.
-            return path.join(versionHome, '.config', 'muse', 'settings.json');
-        default:
-            return null;
-    }
-}
-export const PermissionsHandler = {
-    kind: 'permission',
-    /**
-     * List all permissions across layers, with higher layer winning on name conflict.
-     * Returns a union of all permissions, deduplicated by name.
-     */
-    listAll(agent, cwd) {
-        const layers = getLayerDirs(cwd);
-        const seen = new Set();
-        const results = [];
-        // Build layer roots in precedence order: project > user > system > extras
-        const roots = [];
-        if (layers.project) {
-            roots.push({ dir: getPermissionsDirForRoot(layers.project), layer: 'project' });
-        }
-        roots.push({ dir: getPermissionsDirForRoot(layers.user), layer: 'user' });
-        roots.push({ dir: getPermissionsDirForRoot(layers.system), layer: 'system' });
-        for (const extraDir of layers.extra) {
-            roots.push({ dir: getPermissionsDirForRoot(extraDir), layer: 'system' });
-        }
-        for (const { dir, layer } of roots) {
-            const permissions = listPermissionsInDir(dir);
-            for (const perm of permissions) {
-                if (seen.has(perm.name))
-                    continue;
-                seen.add(perm.name);
-                const item = parsePermissionSet(perm.path);
-                if (item) {
-                    results.push({
-                        name: perm.name,
-                        item,
-                        layer,
-                        path: perm.path,
-                    });
-                }
-            }
-        }
-        return results.sort((a, b) => a.name.localeCompare(b.name));
-    },
-    /**
-     * Resolve a single permission by name.
-     * Returns the winning layer's version, or null if not found.
-     */
-    resolve(agent, name, cwd) {
-        const layers = getLayerDirs(cwd);
-        // Build candidate paths in precedence order: project > user > system > extras
-        const candidates = [];
-        if (layers.project) {
-            candidates.push({ dir: getPermissionsDirForRoot(layers.project), layer: 'project' });
-        }
-        candidates.push({ dir: getPermissionsDirForRoot(layers.user), layer: 'user' });
-        candidates.push({ dir: getPermissionsDirForRoot(layers.system), layer: 'system' });
-        for (const extraDir of layers.extra) {
-            candidates.push({ dir: getPermissionsDirForRoot(extraDir), layer: 'system' });
-        }
-        for (const { dir, layer } of candidates) {
-            // Try .yaml first, then .yml
-            for (const ext of ['.yaml', '.yml']) {
-                const filePath = path.join(dir, `${name}${ext}`);
-                const item = parsePermissionSet(filePath);
-                if (item) {
-                    return { name, item, layer, path: filePath };
-                }
-            }
-        }
-        return null;
-    },
-    /**
-     * Sync resolved permissions to the agent's version home config file.
-     * Merges all resolved permissions into a single set and applies to the agent's config.
-     */
-    sync(agent, versionHome, cwd) {
-        // Only sync to agents that support permissions
-        if (!isCapable(agent, 'allowlist')) {
-            return;
-        }
-        const resolved = this.listAll(agent, cwd);
-        if (resolved.length === 0)
-            return;
-        // Merge all permission sets into one
-        let merged = {
-            name: 'merged',
-            description: 'Merged from all layers',
-            allow: [],
-            deny: [],
-        };
-        for (const r of resolved) {
-            merged = mergePermissionSets(merged, r.item);
-        }
-        // Apply to the agent's config file
-        applyPermissionsToVersion(agent, merged, versionHome, true, cwd);
-    },
-    /**
-     * Permissions use YAML format.
-     */
-    format(_agent) {
-        return 'yaml';
-    },
-    /**
-     * Permissions directory name.
-     */
-    targetDir(_agent) {
-        return 'permissions';
-    },
-    /**
-     * Return the config file path where permissions are merged.
-     */
-    configPath(agent, versionHome) {
-        return getAgentConfigPath(agent, versionHome);
-    },
-};
-export default PermissionsHandler;

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

@@ -1,46 +0,0 @@
-/**
- * Rules resource handler.
- *
- * Rules are .md files in `<repo>/rules/subrules/` directories that get composed
- * into the agent's instructions file (AGENTS.md -> CLAUDE.md/GEMINI.md/etc).
- *
- * Layer resolution: project > user > extras > system
- * - Same-named subrule at higher layer wins (override)
- * - All unique subrules across layers are unioned
- */
-import type { Layer, ResolvedItem, ResourceHandler } from './types.js';
-/** A rule item is a subrule markdown fragment. */
-export interface RuleItem {
-    /** The subrule name (without .md extension). */
-    name: string;
-    /** The full content of the rule file. */
-    content: string;
-}
-/** Layer directory entry for rules resolution. */
-export interface RulesLayerDir {
-    layer: Layer;
-    dir: string;
-}
-/**
- * List subrule names in a directory.
- *
- * A name comes from either the flat form `<name>.md` OR the dir form
- * `<name>/rule.md`; a directory without `rule.md` is not a subrule. Returns
- * names without the .md extension.
- */
-export declare function listSubrulesInDir(subrulesDir: string): string[];
-/**
- * Get layer directories for rules resolution using production paths.
- */
-export declare function getLayerDirs(cwd?: string): RulesLayerDir[];
-/**
- * List all rules from the given layer directories.
- * Higher layers win on name collision.
- */
-export declare function listAllRules(layers: RulesLayerDir[]): ResolvedItem<RuleItem>[];
-/**
- * Resolve a single rule by name from the given layer directories.
- * Higher layers win.
- */
-export declare function resolveRule(name: string, layers: RulesLayerDir[]): ResolvedItem<RuleItem> | null;
-export declare const RulesHandler: ResourceHandler<RuleItem>;

package/dist/lib/resources/rules.js

@@ -1,179 +0,0 @@
-/**
- * Rules resource handler.
- *
- * Rules are .md files in `<repo>/rules/subrules/` directories that get composed
- * into the agent's instructions file (AGENTS.md -> CLAUDE.md/GEMINI.md/etc).
- *
- * Layer resolution: project > user > extras > system
- * - Same-named subrule at higher layer wins (override)
- * - All unique subrules across layers are unioned
- */
-import * as fs from 'fs';
-import { agentConfigDirName, isAgentHardDeprecated } from '../agents.js';
-import * as path from 'path';
-import { getSystemRulesDir, getUserRulesDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../state.js';
-const SUBRULES_DIR = 'subrules';
-const SUBRULES_README = 'README.md';
-/** Inside a dir-form subrule, the prose file. */
-const SUBRULE_RULE_FILE = 'rule.md';
-/**
- * Resolve the prose file path for a subrule named `name` under `subrulesDir`.
- *
- * Dir form `<name>/rule.md` wins when present; otherwise the flat `<name>.md`.
- * Returns null when neither exists.
- */
-function resolveSubruleFile(subrulesDir, name) {
-    const dirForm = path.join(subrulesDir, name, SUBRULE_RULE_FILE);
-    if (fs.existsSync(dirForm))
-        return dirForm;
-    const flatForm = path.join(subrulesDir, `${name}.md`);
-    if (fs.existsSync(flatForm))
-        return flatForm;
-    return null;
-}
-/**
- * List subrule names in a directory.
- *
- * A name comes from either the flat form `<name>.md` OR the dir form
- * `<name>/rule.md`; a directory without `rule.md` is not a subrule. Returns
- * names without the .md extension.
- */
-export function listSubrulesInDir(subrulesDir) {
-    if (!fs.existsSync(subrulesDir))
-        return [];
-    try {
-        const names = new Set();
-        for (const entry of fs.readdirSync(subrulesDir, { withFileTypes: true })) {
-            if (entry.isDirectory()) {
-                if (fs.existsSync(path.join(subrulesDir, entry.name, SUBRULE_RULE_FILE))) {
-                    names.add(entry.name);
-                }
-            }
-            else if (entry.name.endsWith('.md') && entry.name !== SUBRULES_README) {
-                names.add(entry.name.slice(0, -3));
-            }
-        }
-        return [...names].sort();
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Get layer directories for rules resolution using production paths.
- */
-export function getLayerDirs(cwd) {
-    const dirs = [];
-    // Project layer (highest priority)
-    const projectDir = getProjectAgentsDir(cwd);
-    if (projectDir) {
-        const rulesDir = path.join(projectDir, 'rules');
-        if (fs.existsSync(rulesDir)) {
-            dirs.push({ layer: 'project', dir: rulesDir });
-        }
-    }
-    // User layer
-    const userDir = getUserRulesDir();
-    if (fs.existsSync(userDir)) {
-        dirs.push({ layer: 'user', dir: userDir });
-    }
-    // Extra repos (treated as user-level in layering)
-    for (const extra of getEnabledExtraRepos()) {
-        const rulesDir = path.join(extra.dir, 'rules');
-        if (fs.existsSync(rulesDir)) {
-            dirs.push({ layer: 'user', dir: rulesDir });
-        }
-    }
-    // System layer (lowest priority)
-    const systemDir = getSystemRulesDir();
-    if (fs.existsSync(systemDir)) {
-        dirs.push({ layer: 'system', dir: systemDir });
-    }
-    return dirs;
-}
-/**
- * List all rules from the given layer directories.
- * Higher layers win on name collision.
- */
-export function listAllRules(layers) {
-    const seen = new Set();
-    const results = [];
-    for (const { layer, dir } of layers) {
-        const subrulesDir = path.join(dir, SUBRULES_DIR);
-        for (const name of listSubrulesInDir(subrulesDir)) {
-            if (seen.has(name))
-                continue;
-            seen.add(name);
-            const filePath = resolveSubruleFile(subrulesDir, name);
-            if (!filePath)
-                continue;
-            let content = '';
-            try {
-                content = fs.readFileSync(filePath, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            results.push({
-                name,
-                item: { name, content },
-                layer,
-                path: filePath,
-            });
-        }
-    }
-    return results;
-}
-/**
- * Resolve a single rule by name from the given layer directories.
- * Higher layers win.
- */
-export function resolveRule(name, layers) {
-    for (const { layer, dir } of layers) {
-        const filePath = resolveSubruleFile(path.join(dir, SUBRULES_DIR), name);
-        if (filePath) {
-            let content = '';
-            try {
-                content = fs.readFileSync(filePath, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            return {
-                name,
-                item: { name, content },
-                layer,
-                path: filePath,
-            };
-        }
-    }
-    return null;
-}
-export const RulesHandler = {
-    kind: 'rule',
-    listAll(_agent, cwd) {
-        return listAllRules(getLayerDirs(cwd));
-    },
-    resolve(_agent, name, cwd) {
-        return resolveRule(name, getLayerDirs(cwd));
-    },
-    sync(agent, versionHome, _cwd) {
-        if (isAgentHardDeprecated(agent)) {
-            return;
-        }
-        // Rules sync is handled by the compose module and syncResourcesToVersion.
-        // This method ensures the agent config directory exists.
-        // The actual composition and write happens in versions.ts via composeRulesFromState().
-        const targetDir = path.join(versionHome, agentConfigDirName(agent));
-        if (!fs.existsSync(targetDir)) {
-            fs.mkdirSync(targetDir, { recursive: true });
-        }
-    },
-    format(_agent) {
-        return 'md';
-    },
-    targetDir(agent) {
-        // Rules don't have a target subdirectory - they're written to the instructions file
-        return agentConfigDirName(agent);
-    },
-};

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

@@ -1,37 +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 type { ResourceHandler } from './types.js';
-import type { SkillMetadata } from '../types.js';
-/**
- * Layer directory provider for dependency injection in tests.
- */
-export interface LayerDirProvider {
-    getSystemSkillsDir(): string;
-    getUserSkillsDir(): string;
-    getProjectAgentsDir(cwd?: string): string | null;
-    getEnabledExtraRepos(): Array<{
-        alias: string;
-        dir: string;
-        url: string;
-    }>;
-}
-/** A resolved skill item with parsed metadata. */
-export interface SkillItem {
-    /** Parsed SKILL.md frontmatter metadata. */
-    metadata: SkillMetadata;
-    /** Number of rule files in the skill's rules/ subdirectory. */
-    ruleCount: number;
-    /** Number of additional bundled files (beyond SKILL.md). */
-    fileCount: number;
-}
-/**
- * Create a SkillsHandler with the given layer directory provider.
- * Useful for testing with custom directory structures.
- */
-export declare function createSkillsHandler(provider?: LayerDirProvider): ResourceHandler<SkillItem>;
-/** Default handler using real state module paths. */
-export declare const SkillsHandler: ResourceHandler<SkillItem>;