@phnx-labs/agents-cli 1.20.4 → 1.20.6

package/dist/lib/staleness/detectors/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const hooksDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/hooks.js

@@ -0,0 +1,44 @@
+/**
+ * Hooks detector — names of hook scripts materialized in the version home
+ * whose contents match the central source. Mirrors versions.ts:391-421.
+ */
+import * as fs from 'fs';
+import { agentConfigDirName } from '../../agents.js';
+import * as path from 'path';
+import { capableAgents } from '../../capabilities.js';
+import { resolveHookSource } from '../writers/sources.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildHooksDetector(agent) {
+    return {
+        kind: 'hooks',
+        agent,
+        list({ versionHome }) {
+            const hooksDir = path.join(versionHome, agentConfigDirName(agent), 'hooks');
+            if (!fs.existsSync(hooksDir))
+                return [];
+            const installed = fs.readdirSync(hooksDir).filter(f => !f.startsWith('.'));
+            const synced = [];
+            for (const hook of installed) {
+                const src = resolveHookSource(hook);
+                if (!src) {
+                    // True orphan — count as accounted for.
+                    synced.push(hook);
+                    continue;
+                }
+                try {
+                    if (fs.readFileSync(src, 'utf-8') === fs.readFileSync(path.join(hooksDir, hook), 'utf-8')) {
+                        synced.push(hook);
+                    }
+                }
+                catch { /* read failure → not synced */ }
+            }
+            return synced;
+        },
+    };
+}
+export const hooksDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('hooks'))
+        m[agent] = buildHooksDetector(agent);
+    return m;
+});

package/dist/lib/staleness/detectors/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const mcpDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/mcp.js

@@ -0,0 +1,31 @@
+/**
+ * MCP detector — parses the agent's canonical MCP config in the version home
+ * and returns server names. Mirrors versions.ts:432-443.
+ */
+import * as fs from 'fs';
+import { capableAgents } from '../../capabilities.js';
+import { getMcpConfigPathForHome, parseMcpConfig } from '../../agents.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildMcpDetector(agent) {
+    return {
+        kind: 'mcp',
+        agent,
+        list({ versionHome }) {
+            const p = getMcpConfigPathForHome(agent, versionHome);
+            if (!fs.existsSync(p))
+                return [];
+            try {
+                return Object.keys(parseMcpConfig(agent, p));
+            }
+            catch {
+                return [];
+            }
+        },
+    };
+}
+export const mcpDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('mcp'))
+        m[agent] = buildMcpDetector(agent);
+    return m;
+});

package/dist/lib/staleness/detectors/permissions.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const permissionsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/permissions.js

@@ -0,0 +1,201 @@
+/**
+ * Permissions detector — inspects the agent's native permission storage and
+ * reports the permission GROUP names that have been applied.
+ *
+ * For claude/opencode the detector intersects with discovered groups (a group
+ * is "applied" if any of its allow/deny rules are present). For Codex / Gemini /
+ * Antigravity / Grok the on-disk format is lossy — once any group has been
+ * applied the storage doesn't carry per-group provenance back, so we report
+ * "all known groups applied" when any permission artifact is present. This
+ * matches the existing behavior in versions.ts:445-518 (extended to the
+ * agents that were previously silent-skipped).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as TOML from 'smol-toml';
+import { capableAgents } from '../../capabilities.js';
+import { discoverPermissionGroups, buildPermissionsFromGroups, CODEX_RULES_FILENAME, } from '../../permissions.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildClaudeDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'claude',
+        list({ versionHome }) {
+            const settingsPath = path.join(versionHome, '.claude', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return [];
+            try {
+                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                const allowRules = settings.permissions?.allow || [];
+                const denyRules = settings.permissions?.deny || [];
+                if (allowRules.length === 0 && denyRules.length === 0)
+                    return [];
+                const groups = discoverPermissionGroups();
+                const applied = [];
+                for (const group of groups) {
+                    const built = buildPermissionsFromGroups([group.name]);
+                    // Empty groups (header files) count as synced when anything is applied.
+                    if (built.allow.length === 0 && (!built.deny || built.deny.length === 0)) {
+                        applied.push(group.name);
+                        continue;
+                    }
+                    const hasAllow = built.allow.some(r => allowRules.includes(r));
+                    const hasDeny = built.deny?.some(r => denyRules.includes(r)) || false;
+                    if (hasAllow || hasDeny)
+                        applied.push(group.name);
+                }
+                return applied;
+            }
+            catch {
+                return [];
+            }
+        },
+    };
+}
+function buildCodexDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'codex',
+        list({ versionHome }) {
+            const codexConfigPath = path.join(versionHome, '.codex', 'config.toml');
+            const codexRulesPath = path.join(versionHome, '.codex', 'rules', CODEX_RULES_FILENAME);
+            const hasConfig = fs.existsSync(codexConfigPath);
+            const hasRules = fs.existsSync(codexRulesPath);
+            if (!hasConfig && !hasRules)
+                return [];
+            try {
+                let hasPermKeys = false;
+                if (hasConfig) {
+                    const config = TOML.parse(fs.readFileSync(codexConfigPath, 'utf-8'));
+                    hasPermKeys = !!(config.approval_policy || config.sandbox_mode || config.sandbox_workspace_write);
+                }
+                if (hasPermKeys || hasRules) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildOpenCodeDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'opencode',
+        list({ versionHome }) {
+            const opencodeConfigPath = path.join(versionHome, '.opencode', 'opencode.jsonc');
+            if (!fs.existsSync(opencodeConfigPath))
+                return [];
+            try {
+                const content = fs.readFileSync(opencodeConfigPath, 'utf-8');
+                const stripped = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+                const config = JSON.parse(stripped);
+                if (config.permission && Object.keys(config.permission.bash || {}).length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildGeminiDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'gemini',
+        list({ versionHome }) {
+            const settingsPath = path.join(versionHome, '.gemini', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return [];
+            try {
+                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                const allowed = settings?.tools?.allowed;
+                if (Array.isArray(allowed) && allowed.length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildAntigravityDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'antigravity',
+        list({ versionHome }) {
+            const settingsPath = path.join(versionHome, '.gemini', 'antigravity-cli', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return [];
+            try {
+                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                const perms = settings?.permissions;
+                const hasAllow = Array.isArray(perms?.allow) && perms.allow.length > 0;
+                const hasDeny = Array.isArray(perms?.deny) && perms.deny.length > 0;
+                if (hasAllow || hasDeny) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildGrokDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'grok',
+        list({ versionHome }) {
+            const configPath = path.join(versionHome, '.grok', 'config.toml');
+            if (!fs.existsSync(configPath))
+                return [];
+            try {
+                const config = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
+                const perm = config.permission;
+                if (perm && Array.isArray(perm.rules) && perm.rules.length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildKimiDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'kimi',
+        list({ versionHome }) {
+            const configPath = path.join(versionHome, '.kimi-code', 'config.toml');
+            if (!fs.existsSync(configPath))
+                return [];
+            try {
+                const config = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
+                const perm = config.permission;
+                if (perm && Array.isArray(perm.rules) && perm.rules.length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+const handlers = {
+    claude: buildClaudeDetector,
+    codex: buildCodexDetector,
+    opencode: buildOpenCodeDetector,
+    gemini: buildGeminiDetector,
+    antigravity: buildAntigravityDetector,
+    grok: buildGrokDetector,
+    kimi: buildKimiDetector,
+};
+export const permissionsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('allowlist')) {
+        const f = handlers[agent];
+        if (f)
+            m[agent] = f();
+    }
+    return m;
+});

package/dist/lib/staleness/detectors/plugins.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Plugins detector — for each discovered plugin, ask `isPluginSynced` whether
+ * its expected artifacts are present in the version home. Mirrors
+ * versions.ts:541-549.
+ */
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const pluginsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/plugins.js

@@ -0,0 +1,23 @@
+import { capableAgents } from '../../capabilities.js';
+import { discoverPlugins, isPluginSynced } from '../../plugins.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildPluginsDetector(agent) {
+    return {
+        kind: 'plugins',
+        agent,
+        list({ versionHome }) {
+            const synced = [];
+            for (const plugin of discoverPlugins()) {
+                if (isPluginSynced(plugin, agent, versionHome))
+                    synced.push(plugin.name);
+            }
+            return synced;
+        },
+    };
+}
+export const pluginsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('plugins'))
+        m[agent] = buildPluginsDetector(agent);
+    return m;
+});

package/dist/lib/staleness/detectors/rules.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const rulesDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/rules.js

@@ -0,0 +1,34 @@
+/**
+ * Rules detector — reports whether the composed instructions file exists in
+ * the version home. Uses the active rules preset name as the detected
+ * "resource name" so the diff stays meaningful (one preset = one synced
+ * name, mirroring what getAvailableResources surfaces under `memory`).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { AGENTS, agentConfigDirName } from '../../agents.js';
+import { capableAgents } from '../../capabilities.js';
+import { getActiveRulesPreset } from '../../state.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildRulesDetector(agent) {
+    return {
+        kind: 'rules',
+        agent,
+        list({ version, versionHome }) {
+            const cap = AGENTS[agent].capabilities.rules;
+            if (cap === false)
+                return [];
+            const agentDir = path.join(versionHome, agentConfigDirName(agent));
+            const instrFile = path.join(agentDir, cap.file);
+            if (!fs.existsSync(instrFile))
+                return [];
+            return [getActiveRulesPreset(agent, version)];
+        },
+    };
+}
+export const rulesDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('rules'))
+        m[agent] = buildRulesDetector(agent);
+    return m;
+});

package/dist/lib/staleness/detectors/skills.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const skillsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/skills.js

@@ -0,0 +1,71 @@
+/**
+ * Skills detector — names of skill directories materialized in the version
+ * home that match the central source content. Mirrors versions.ts:359-389.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { AGENTS, agentConfigDirName } from '../../agents.js';
+import { capableAgents } from '../../capabilities.js';
+import { resolveSkillSource } from '../writers/sources.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+const SKILL_COPY_IGNORE = new Set(['.DS_Store', '.git', '.gitignore', '.venv', '__pycache__', 'node_modules']);
+function skillDirsMatch(src, dest) {
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isSymbolicLink())
+            continue;
+        if (SKILL_COPY_IGNORE.has(entry.name))
+            continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            if (!fs.existsSync(destPath))
+                return false;
+            if (!skillDirsMatch(srcPath, destPath))
+                return false;
+        }
+        else {
+            if (!fs.existsSync(destPath))
+                return false;
+            if (fs.readFileSync(srcPath, 'utf-8') !== fs.readFileSync(destPath, 'utf-8'))
+                return false;
+        }
+    }
+    return true;
+}
+function buildSkillsDetector(agent) {
+    return {
+        kind: 'skills',
+        agent,
+        list({ versionHome }) {
+            const skillsDir = path.join(versionHome, agentConfigDirName(agent), 'skills');
+            if (!fs.existsSync(skillsDir))
+                return [];
+            const installed = fs.readdirSync(skillsDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+                .map(d => d.name);
+            const synced = [];
+            for (const name of installed) {
+                const src = resolveSkillSource(name);
+                if (!src) {
+                    // True orphan — no source. Still count so cleanup knows it's accounted for.
+                    synced.push(name);
+                    continue;
+                }
+                if (skillDirsMatch(src, path.join(skillsDir, name))) {
+                    synced.push(name);
+                }
+            }
+            return synced;
+        },
+    };
+}
+export const skillsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('skills')) {
+        if (AGENTS[agent].nativeAgentsSkillsDir)
+            continue;
+        m[agent] = buildSkillsDetector(agent);
+    }
+    return m;
+});

package/dist/lib/staleness/detectors/subagents.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const subagentsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/subagents.js

@@ -0,0 +1,50 @@
+/**
+ * Subagents detector. Claude: flat .md files under `<agentDir>/agents/`.
+ * OpenClaw: subdirectories containing AGENTS.md under `<versionHome>/.openclaw/`.
+ * Mirrors versions.ts:521-539.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { capableAgents } from '../../capabilities.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildClaudeDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'claude',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.claude', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            return fs.readdirSync(agentsDir)
+                .filter(f => f.endsWith('.md'))
+                .map(f => f.replace('.md', ''));
+        },
+    };
+}
+function buildOpenclawDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'openclaw',
+        list({ versionHome }) {
+            const openclawDir = path.join(versionHome, '.openclaw');
+            if (!fs.existsSync(openclawDir))
+                return [];
+            return fs.readdirSync(openclawDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && fs.existsSync(path.join(openclawDir, d.name, 'AGENTS.md')))
+                .map(d => d.name);
+        },
+    };
+}
+const handlers = {
+    claude: buildClaudeDetector,
+    openclaw: buildOpenclawDetector,
+};
+export const subagentsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('subagents')) {
+        const f = handlers[agent];
+        if (f)
+            m[agent] = f();
+    }
+    return m;
+});

package/dist/lib/staleness/detectors/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Per-(kind, agent) detector contract.
+ *
+ * A detector inspects a version home and reports which resource names of a
+ * given kind are materialized there. The aggregator at
+ * `getActuallySyncedResources` calls one detector per kind/agent pair to build
+ * the "what is actually on disk" view, which is then diffed against
+ * "what is available" to drive the resource prompt in `agents view`.
+ */
+import type { AgentId } from '../../types.js';
+import type { ResourceKind } from '../writers/kinds.js';
+export interface DetectArgs {
+    version: string;
+    versionHome: string;
+    /** Working directory — needed by detectors that resolve project state. */
+    cwd: string;
+}
+export interface ResourceDetector {
+    readonly kind: ResourceKind;
+    readonly agent: AgentId;
+    list(args: DetectArgs): string[];
+}

package/dist/lib/staleness/detectors/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/staleness/detectors/workflows.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const workflowsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/workflows.js

@@ -0,0 +1,28 @@
+/**
+ * Workflows detector — scans `{versionHome}/workflows/` for subdirectories
+ * containing WORKFLOW.md. Mirrors versions.ts:551-558.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { capableAgents } from '../../capabilities.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildWorkflowsDetector(agent) {
+    return {
+        kind: 'workflows',
+        agent,
+        list({ versionHome }) {
+            const workflowsDir = path.join(versionHome, 'workflows');
+            if (!fs.existsSync(workflowsDir))
+                return [];
+            return fs.readdirSync(workflowsDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && fs.existsSync(path.join(workflowsDir, d.name, 'WORKFLOW.md')))
+                .map(d => d.name);
+        },
+    };
+}
+export const workflowsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('workflows'))
+        m[agent] = buildWorkflowsDetector(agent);
+    return m;
+});

package/dist/lib/staleness/registry.d.ts

@@ -0,0 +1,26 @@
+import type { AgentId } from '../types.js';
+import { type ResourceKind } from './writers/kinds.js';
+import type { ResourceWriter } from './writers/types.js';
+import type { ResourceDetector } from './detectors/types.js';
+import type { RulesSelection } from './writers/rules.js';
+export type { ResourceKind } from './writers/kinds.js';
+export { kindToCapability, ALL_RESOURCE_KINDS } from './writers/kinds.js';
+export type { ResourceWriter, WriteArgs, WriteResult } from './writers/types.js';
+export type { ResourceDetector, DetectArgs } from './detectors/types.js';
+export type { RulesSelection } from './writers/rules.js';
+/** Per-kind selection payload. Most kinds are string[]; rules is special. */
+export type SelectionFor<K extends ResourceKind> = K extends 'rules' ? RulesSelection : string[];
+export declare const WRITERS: Record<ResourceKind, Partial<Record<AgentId, ResourceWriter<any>>>>;
+export declare const DETECTORS: Record<ResourceKind, Partial<Record<AgentId, ResourceDetector>>>;
+/**
+ * Verify every supported (agent, kind) pair has both a writer and a
+ * detector. Deferred from module-import time to the first `getWriter` /
+ * `getDetector` call to dodge the agents.ts ↔ versions.ts ↔ registry.ts
+ * import cycle (the same one the lazy writer/detector maps work around).
+ * Idempotent — runs at most once per process.
+ */
+export declare function assertRegistryComplete(): void;
+/** Return the writer for (kind, agent), or undefined if unsupported. */
+export declare function getWriter<K extends ResourceKind>(kind: K, agent: AgentId): ResourceWriter<SelectionFor<K>> | undefined;
+/** Return the detector for (kind, agent), or undefined if unsupported. */
+export declare function getDetector(kind: ResourceKind, agent: AgentId): ResourceDetector | undefined;