@michaelhartmayer/agentctl 1.0.3 → 1.1.3

package/dist/ctl.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,335 +8,253 @@ exports.alias = alias;
 exports.group = group;
 exports.pushGlobal = pushGlobal;
 exports.pullLocal = pullLocal;
-exports.installSkill = installSkill;
 exports.rm = rm;
 exports.mv = mv;
 exports.inspect = inspect;
+exports.installSkill = installSkill;
+exports.install = install;
 exports.list = list;
-const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
-const resolve_1 = require("./resolve");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
 const fs_utils_1 = require("./fs-utils");
 const manifest_1 = require("./manifest");
-function scaffold(args_1) {
-    return __awaiter(this, arguments, void 0, function* (args, options = {}) {
-        const { targetDir, name, isWin } = yield prepareCommand(args, options);
-        const scriptName = isWin ? 'command.cmd' : 'command.sh';
-        const scriptPath = path_1.default.join(targetDir, scriptName);
-        const scriptContent = isWin
-            ? '@echo off\r\nREM Add your command logic here\r\necho Not implemented'
-            : '#!/usr/bin/env bash\n# Add your command logic here\necho "Not implemented"';
-        yield fs_extra_1.default.writeFile(scriptPath, scriptContent);
-        if (!isWin)
-            yield fs_extra_1.default.chmod(scriptPath, 0o755);
-        const manifest = {
-            name,
-            description: '',
-            type: 'scaffold',
-            run: `./${scriptName}`,
-        };
-        yield fs_extra_1.default.writeJson(path_1.default.join(targetDir, 'manifest.json'), manifest, { spaces: 2 });
-        console.log(`Scaffolded command: ${args.join(' ')}`);
-    });
+const resolve_1 = require("./resolve");
+const effects_1 = require("./effects");
+const ctl_1 = require("./logic/ctl");
+const install_1 = require("./logic/install");
+async function getCappedAncestor(dir, baseDir) {
+    let current = path_1.default.dirname(dir);
+    while (current.length >= baseDir.length && current !== path_1.default.dirname(baseDir)) {
+        const mPath = path_1.default.join(current, 'manifest.json');
+        if (await fs_extra_1.default.pathExists(mPath)) {
+            try {
+                const m = await fs_extra_1.default.readJson(mPath);
+                if ((0, manifest_1.isCappedManifest)(m)) {
+                    return { path: current, relPath: path_1.default.relative(baseDir, current) };
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        current = path_1.default.dirname(current);
+    }
+    return null;
 }
-function alias(args_1, target_1) {
-    return __awaiter(this, arguments, void 0, function* (args, target, options = {}) {
-        const { targetDir, name } = yield prepareCommand(args, options);
-        const manifest = {
-            name,
-            description: '',
-            type: 'alias',
-            run: target,
-        };
-        yield fs_extra_1.default.writeJson(path_1.default.join(targetDir, 'manifest.json'), manifest, { spaces: 2 });
-        console.log(`Aliased command: ${args.join(' ')} -> ${target}`);
-    });
+async function getContext(options) {
+    const cwd = options.cwd || process.cwd();
+    return {
+        cwd: path_1.default.resolve(cwd),
+        platform: process.platform,
+        localRoot: (0, fs_utils_1.findLocalRoot)(cwd),
+        globalRoot: options.globalDir || (0, fs_utils_1.getGlobalRoot)(),
+        homedir: process.env.HOME || process.env.USERPROFILE || os_1.default.homedir()
+    };
 }
-function group(args_1) {
-    return __awaiter(this, arguments, void 0, function* (args, options = {}) {
-        const { targetDir, name } = yield prepareCommand(args, options);
-        const manifest = {
-            name,
-            description: '',
-            type: 'group',
-        };
-        yield fs_extra_1.default.writeJson(path_1.default.join(targetDir, 'manifest.json'), manifest, { spaces: 2 });
-        console.log(`Created group: ${args.join(' ')}`);
+async function scaffold(args, options = {}) {
+    const ctx = await getContext(options);
+    const localRoot = ctx.localRoot || ctx.cwd;
+    const agentctlDir = path_1.default.join(localRoot, '.agentctl');
+    const targetDir = path_1.default.join(agentctlDir, args.join(path_1.default.sep));
+    const exists = await fs_extra_1.default.pathExists(targetDir);
+    const cappedAncestor = await getCappedAncestor(targetDir, agentctlDir);
+    const { effects } = ctl_1.Logic.planScaffold(args, ctx, { exists, cappedAncestor: cappedAncestor || undefined, type: 'scaffold' });
+    await (0, effects_1.execute)(effects);
+}
+async function alias(args, target, options = {}) {
+    const ctx = await getContext(options);
+    const localRoot = ctx.localRoot || ctx.cwd;
+    const agentctlDir = path_1.default.join(localRoot, '.agentctl');
+    const targetDir = path_1.default.join(agentctlDir, args.join(path_1.default.sep));
+    const exists = await fs_extra_1.default.pathExists(targetDir);
+    const cappedAncestor = await getCappedAncestor(targetDir, agentctlDir);
+    const { effects } = ctl_1.Logic.planScaffold(args, ctx, {
+        exists,
+        cappedAncestor: cappedAncestor || undefined,
+        type: 'alias',
+        target
     });
+    await (0, effects_1.execute)(effects);
 }
-function pushGlobal(args_1) {
-    return __awaiter(this, arguments, void 0, function* (args, options = {}) {
-        const cwd = options.cwd || process.cwd();
-        const localRoot = (0, fs_utils_1.findLocalRoot)(cwd);
-        if (!localRoot)
-            throw new Error('Not in a local context');
-        const globalRoot = options.globalDir || (0, fs_utils_1.getGlobalRoot)();
-        const localAgentctl = path_1.default.join(localRoot, '.agentctl');
-        const cmdPathStr = args.join(path_1.default.sep);
-        const srcDir = path_1.default.join(localAgentctl, cmdPathStr);
-        if (!(yield fs_extra_1.default.pathExists(srcDir))) {
-            throw new Error(`Local command ${args.join(' ')} not found`);
-        }
-        const destDir = path_1.default.join(globalRoot, cmdPathStr);
-        if (yield fs_extra_1.default.pathExists(destDir)) {
-            throw new Error(`Global command ${args.join(' ')} already exists`);
-        }
-        yield fs_extra_1.default.ensureDir(path_1.default.dirname(destDir));
-        if (options.move) {
-            yield fs_extra_1.default.move(srcDir, destDir);
-            console.log(`Moved ${args.join(' ')} to global scope`);
-        }
-        else {
-            yield fs_extra_1.default.copy(srcDir, destDir);
-            console.log(`Copied ${args.join(' ')} to global scope`);
-        }
+async function group(args, options = {}) {
+    const ctx = await getContext(options);
+    const localRoot = ctx.localRoot || ctx.cwd;
+    const agentctlDir = path_1.default.join(localRoot, '.agentctl');
+    const targetDir = path_1.default.join(agentctlDir, args.join(path_1.default.sep));
+    const exists = await fs_extra_1.default.pathExists(targetDir);
+    const cappedAncestor = await getCappedAncestor(targetDir, agentctlDir);
+    const { effects } = ctl_1.Logic.planScaffold(args, ctx, {
+        exists,
+        cappedAncestor: cappedAncestor || undefined,
+        type: 'group'
     });
+    await (0, effects_1.execute)(effects);
 }
-function pullLocal(args_1) {
-    return __awaiter(this, arguments, void 0, function* (args, options = {}) {
-        const cwd = options.cwd || process.cwd();
-        const localRoot = (0, fs_utils_1.findLocalRoot)(cwd);
-        if (!localRoot)
-            throw new Error('Not in a local context');
-        const globalRoot = options.globalDir || (0, fs_utils_1.getGlobalRoot)();
-        const cmdPathStr = args.join(path_1.default.sep);
-        const srcDir = path_1.default.join(globalRoot, cmdPathStr);
-        if (!(yield fs_extra_1.default.pathExists(srcDir))) {
-            throw new Error(`Global command ${args.join(' ')} not found`);
-        }
-        const localAgentctl = path_1.default.join(localRoot, '.agentctl');
-        const destDir = path_1.default.join(localAgentctl, cmdPathStr);
-        if (yield fs_extra_1.default.pathExists(destDir)) {
-            throw new Error(`Local command ${args.join(' ')} already exists`);
-        }
-        yield fs_extra_1.default.ensureDir(path_1.default.dirname(destDir));
-        if (options.move) {
-            yield fs_extra_1.default.move(srcDir, destDir);
-            console.log(`Moved ${args.join(' ')} to local scope`);
-        }
-        else {
-            yield fs_extra_1.default.copy(srcDir, destDir);
-            console.log(`Copied ${args.join(' ')} to local scope`);
-        }
+async function pushGlobal(args, options = {}) {
+    const ctx = await getContext(options);
+    if (!ctx.localRoot)
+        throw new Error('Not in a local context');
+    const cmdPathStr = args.join(path_1.default.sep);
+    const existsInLocal = await fs_extra_1.default.pathExists(path_1.default.join(ctx.localRoot, '.agentctl', cmdPathStr));
+    const existsInGlobal = await fs_extra_1.default.pathExists(path_1.default.join(ctx.globalRoot, cmdPathStr));
+    const effects = ctl_1.Logic.planPushGlobal(args, ctx, {
+        move: options.move,
+        existsInLocal,
+        existsInGlobal
     });
+    await (0, effects_1.execute)(effects);
 }
-const skills_1 = require("./skills");
-function installSkill(agent_1) {
-    return __awaiter(this, arguments, void 0, function* (agent, options = {}) {
-        const cwd = options.cwd || process.cwd();
-        if (!skills_1.SUPPORTED_AGENTS.includes(agent)) {
-            throw new Error(`Agent '${agent}' not supported. Supported agents: ${skills_1.SUPPORTED_AGENTS.join(', ')}`);
-        }
-        let targetDir;
-        if (agent === 'cursor') {
-            targetDir = path_1.default.join(cwd, '.cursor', 'skills');
-        }
-        else if (agent === 'antigravity') {
-            if (options.global) {
-                const globalRoot = options.antigravityGlobalDir || (0, fs_utils_1.getAntigravityGlobalRoot)();
-                targetDir = path_1.default.join(globalRoot, 'skills', 'agentctl');
-            }
-            else {
-                targetDir = path_1.default.join(cwd, '.agent', 'skills', 'agentctl');
-            }
-        }
-        else if (agent === 'agentsmd') {
-            targetDir = path_1.default.join(cwd, '.agents', 'skills', 'agentctl');
-        }
-        else if (agent === 'gemini') {
-            if (options.global) {
-                const globalRoot = options.geminiGlobalDir || path_1.default.join(process.env.HOME || process.env.USERPROFILE, '.gemini');
-                targetDir = path_1.default.join(globalRoot, 'skills', 'agentctl');
-            }
-            else {
-                targetDir = path_1.default.join(cwd, '.gemini', 'skills', 'agentctl');
-            }
-        }
-        else {
-            throw new Error(`Agent logic for '${agent}' not implemented.`);
-        }
-        const p = yield (0, skills_1.copySkill)(targetDir, agent);
-        console.log(`Installed skill for ${agent} at ${p}`);
+async function pullLocal(args, options = {}) {
+    const ctx = await getContext(options);
+    if (!ctx.localRoot)
+        throw new Error('Not in a local context');
+    const cmdPathStr = args.join(path_1.default.sep);
+    const existsInGlobal = await fs_extra_1.default.pathExists(path_1.default.join(ctx.globalRoot, cmdPathStr));
+    const existsInLocal = await fs_extra_1.default.pathExists(path_1.default.join(ctx.localRoot, '.agentctl', cmdPathStr));
+    const effects = ctl_1.Logic.planPullLocal(args, ctx, {
+        move: options.move,
+        existsInLocal,
+        existsInGlobal
     });
+    await (0, effects_1.execute)(effects);
 }
-function rm(args_1) {
-    return __awaiter(this, arguments, void 0, function* (args, options = {}) {
-        const resolved = yield (0, resolve_1.resolveCommand)(args, options);
-        if (!resolved) {
-            throw new Error(`Command ${args.join(' ')} not found${options.global ? ' in global scope' : ''}`);
-        }
-        const targetDir = path_1.default.dirname(resolved.manifestPath);
-        yield fs_extra_1.default.remove(targetDir);
-        console.log(`Removed ${resolved.scope} command: ${args.join(' ')}`);
+async function rm(args, options = {}) {
+    const resolved = await (0, resolve_1.resolveCommand)(args, options);
+    const ctx = await getContext(options);
+    const effects = ctl_1.Logic.planRemove(args, ctx, {
+        resolvedPath: resolved?.manifestPath || null,
+        scope: resolved?.scope || 'unknown',
+        global: options.global
     });
+    await (0, effects_1.execute)(effects);
 }
-function mv(srcArgs_1, destArgs_1) {
-    return __awaiter(this, arguments, void 0, function* (srcArgs, destArgs, options = {}) {
-        const resolved = yield (0, resolve_1.resolveCommand)(srcArgs, options);
-        if (!resolved) {
-            throw new Error(`Command ${srcArgs.join(' ')} not found`);
-        }
-        const srcDir = path_1.default.dirname(resolved.manifestPath);
-        const rootDir = resolved.scope === 'local'
+async function mv(srcArgs, destArgs, options = {}) {
+    const resolved = await (0, resolve_1.resolveCommand)(srcArgs, options);
+    const ctx = await getContext(options);
+    let rootDir = null;
+    let agentctlDir = null;
+    let destExists = false;
+    let cappedAncestor = null;
+    if (resolved) {
+        rootDir = resolved.scope === 'local'
             ? (0, fs_utils_1.findLocalRoot)(options.cwd || process.cwd())
             : (options.globalDir || (0, fs_utils_1.getGlobalRoot)());
-        if (!rootDir)
-            throw new Error('Cannot determine root for move');
-        const agentctlDir = resolved.scope === 'local' ? path_1.default.join(rootDir, '.agentctl') : rootDir;
-        // For global, rootDir IS the agentctl dir (config dir). Local has .agentctl subdir.
-        const destPathStr = destArgs.join(path_1.default.sep);
-        const destDir = path_1.default.join(agentctlDir, destPathStr);
-        if (yield fs_extra_1.default.pathExists(destDir)) {
-            throw new Error(`Destination ${destArgs.join(' ')} already exists`);
-        }
-        // Check parent validity (nesting under capped)
-        let current = path_1.default.dirname(destDir);
-        while (current.length >= agentctlDir.length && !isSamePath(current, path_1.default.dirname(agentctlDir))) {
-            if (yield isCapped(current)) {
-                const relPath = path_1.default.relative(agentctlDir, current); // relative to base
-                throw new Error(`Cannot nest command under capped command: ${relPath}`);
-            }
-            current = path_1.default.dirname(current);
+        if (rootDir) {
+            agentctlDir = resolved.scope === 'local' ? path_1.default.join(rootDir, '.agentctl') : rootDir;
+            const destPathStr = destArgs.join(path_1.default.sep);
+            const destDir = path_1.default.join(agentctlDir, destPathStr);
+            destExists = await fs_extra_1.default.pathExists(destDir);
+            const ancestor = await getCappedAncestor(destDir, agentctlDir);
+            if (ancestor)
+                cappedAncestor = { relPath: ancestor.relPath };
         }
-        yield fs_extra_1.default.move(srcDir, destDir);
-        // Update manifest name
-        const manifestPath = path_1.default.join(destDir, 'manifest.json');
-        if (yield fs_extra_1.default.pathExists(manifestPath)) {
-            const manifest = yield fs_extra_1.default.readJson(manifestPath);
-            manifest.name = destArgs[destArgs.length - 1];
-            yield fs_extra_1.default.writeJson(manifestPath, manifest, { spaces: 2 });
-        }
-        console.log(`Moved ${srcArgs.join(' ')} to ${destArgs.join(' ')}`);
+    }
+    const effects = ctl_1.Logic.planMove(srcArgs, destArgs, ctx, {
+        resolvedSrc: resolved ? { manifestPath: resolved.manifestPath, scope: resolved.scope, manifest: resolved.manifest } : null,
+        destExists,
+        cappedAncestor: cappedAncestor || undefined,
+        rootDir,
+        agentctlDir
     });
+    await (0, effects_1.execute)(effects);
 }
-function inspect(args_1) {
-    return __awaiter(this, arguments, void 0, function* (args, options = {}) {
-        const resolved = yield (0, resolve_1.resolveCommand)(args, options);
-        if (!resolved) {
-            return null;
-        }
-        return {
-            manifest: resolved.manifest,
-            resolvedPath: resolved.manifestPath,
-            scope: resolved.scope
-        };
-    });
+async function inspect(args, options = {}) {
+    const resolved = await (0, resolve_1.resolveCommand)(args, options);
+    if (!resolved)
+        return null;
+    return {
+        manifest: resolved.manifest,
+        resolvedPath: resolved.manifestPath,
+        scope: resolved.scope
+    };
 }
-function list() {
-    return __awaiter(this, arguments, void 0, function* (options = {}) {
-        const cwd = options.cwd || process.cwd();
-        const localRoot = (0, fs_utils_1.findLocalRoot)(cwd);
-        const globalRoot = options.globalDir || (0, fs_utils_1.getGlobalRoot)();
-        const commands = new Map();
-        function walk(dir, prefix, scope) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (!(yield fs_extra_1.default.pathExists(dir)))
-                    return;
-                const files = yield fs_extra_1.default.readdir(dir);
-                for (const file of files) {
-                    const filePath = path_1.default.join(dir, file);
-                    let stats;
-                    try {
-                        stats = yield fs_extra_1.default.stat(filePath);
-                    }
-                    catch (_a) {
-                        continue;
-                    }
-                    if (!stats.isDirectory())
-                        continue;
-                    const cmdPathParts = [...prefix, file];
-                    const cmdPath = cmdPathParts.join(' ');
-                    let manifest = null;
-                    const mPath = path_1.default.join(filePath, 'manifest.json');
-                    if (yield fs_extra_1.default.pathExists(mPath)) {
-                        manifest = yield (0, manifest_1.readManifest)(mPath);
-                    }
-                    let type = 'group';
-                    if (manifest) {
-                        if ((0, manifest_1.isCappedManifest)(manifest)) {
-                            type = manifest.type || 'scaffold';
-                        }
-                        else if (manifest.type) {
-                            type = manifest.type;
-                        }
-                    }
-                    const item = {
-                        path: cmdPath,
-                        type,
-                        scope,
-                        description: (manifest === null || manifest === void 0 ? void 0 : manifest.description) || ''
-                    };
-                    if (!commands.has(cmdPath)) {
-                        commands.set(cmdPath, item);
-                        const effectiveManifest = manifest || { name: file, type: 'group' };
-                        if (!(0, manifest_1.isCappedManifest)(effectiveManifest)) {
-                            yield walk(filePath, cmdPathParts, scope);
-                        }
-                    }
-                    else {
-                        const existing = commands.get(cmdPath);
-                        if (existing && existing.scope === 'local') {
-                            if (existing.type === 'group' && type === 'group') {
-                                yield walk(filePath, cmdPathParts, scope);
-                            }
-                        }
-                    }
-                }
-            });
-        }
-        if (localRoot) {
-            yield walk(path_1.default.join(localRoot, '.agentctl'), [], 'local');
-        }
-        yield walk(globalRoot, [], 'global');
-        return Array.from(commands.values());
-    });
+async function installSkill(agent, options = {}) {
+    const ctx = await getContext(options);
+    const effects = ctl_1.Logic.planInstallSkill(agent, ctx, options);
+    await (0, effects_1.execute)(effects);
 }
-// Helpers
-function prepareCommand(args_1) {
-    return __awaiter(this, arguments, void 0, function* (args, options = {}) {
-        const cwd = options.cwd || process.cwd();
-        const rootDir = cwd;
-        const agentctlDir = path_1.default.join(rootDir, '.agentctl');
-        if (args.length === 0)
-            throw new Error('No command path provided');
-        const cmdPath = args.join(path_1.default.sep);
-        const targetDir = path_1.default.join(agentctlDir, cmdPath);
-        if (yield fs_extra_1.default.pathExists(targetDir)) {
-            throw new Error(`Command ${args.join(' ')} already exists`);
-        }
-        let current = path_1.default.dirname(targetDir);
-        while (current.length >= agentctlDir.length && !isSamePath(current, path_1.default.dirname(agentctlDir))) {
-            if (yield isCapped(current)) {
-                const relPath = path_1.default.relative(agentctlDir, current); // This uses cwd for resolution if agentctlDir is cwd resolved
-                // Need to verify relative works predictably
-                // agentctlDir comes from path.join(cwd, '.agentctl').
-                throw new Error(`Cannot nest command under capped command: ${relPath}`);
-            }
-            current = path_1.default.dirname(current);
-        }
-        yield fs_extra_1.default.ensureDir(targetDir);
-        return {
-            targetDir,
-            name: args[args.length - 1],
-            isWin: process.platform === 'win32'
-        };
+async function install(repoUrl, pathArgs, options = {}) {
+    const ctx = await getContext(options);
+    const installCtx = {
+        repoUrl,
+        pathParts: pathArgs,
+        global: !!options.global,
+        allowCollisions: !!options.allowCollisions,
+        localRoot: ctx.localRoot,
+        globalRoot: ctx.globalRoot,
+        osTmpdir: os_1.default.tmpdir()
+    };
+    // Phase 1: Clone
+    const tempFolderName = `agentctl-install-${Date.now()}-${Math.floor(Math.random() * 10000)}`;
+    const { effects: cloneEffects, tempDir } = (0, install_1.planInstallClone)(installCtx, { tempFolderName });
+    await (0, effects_1.execute)(cloneEffects);
+    // Phase 2: Copy
+    const tempAgentctlDir = path_1.default.join(tempDir, '.agentctl');
+    if (!(await fs_extra_1.default.pathExists(tempAgentctlDir))) {
+        await fs_extra_1.default.remove(tempDir);
+        throw new Error(`Repository does not contain an .agentctl directory at the root.`);
+    }
+    const downloadedItems = await fs_extra_1.default.readdir(tempAgentctlDir);
+    const rootDir = installCtx.global ? installCtx.globalRoot : installCtx.localRoot;
+    const agentctlDir = installCtx.global ? rootDir : path_1.default.join(rootDir, '.agentctl');
+    const targetDir = path_1.default.join(agentctlDir, ...installCtx.pathParts);
+    const existingItems = (await fs_extra_1.default.pathExists(targetDir)) ? await fs_extra_1.default.readdir(targetDir) : [];
+    const { effects: copyEffects } = (0, install_1.planInstallCopy)(installCtx, {
+        tempAgentctlDir,
+        existingItems,
+        downloadedItems
     });
+    await (0, effects_1.execute)(copyEffects);
 }
-function isCapped(dir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const manifestPath = path_1.default.join(dir, 'manifest.json');
-        if (yield fs_extra_1.default.pathExists(manifestPath)) {
+async function list(options = {}) {
+    const ctx = await getContext(options);
+    const commands = new Map();
+    async function walk(dir, prefix, scope) {
+        if (!await fs_extra_1.default.pathExists(dir))
+            return;
+        const files = await fs_extra_1.default.readdir(dir);
+        for (const file of files) {
+            const filePath = path_1.default.join(dir, file);
+            let stats;
             try {
-                const m = yield fs_extra_1.default.readJson(manifestPath);
-                return (0, manifest_1.isCappedManifest)(m);
+                stats = await fs_extra_1.default.stat(filePath);
             }
-            catch (_a) {
-                return false;
+            catch {
+                continue;
+            }
+            if (!stats.isDirectory())
+                continue;
+            const cmdPathParts = [...prefix, file];
+            const cmdPath = cmdPathParts.join(' ');
+            let manifest = null;
+            const mPath = path_1.default.join(filePath, 'manifest.json');
+            if (await fs_extra_1.default.pathExists(mPath))
+                manifest = await (0, manifest_1.readManifest)(mPath);
+            let type = 'group';
+            if (manifest) {
+                if ((0, manifest_1.isCappedManifest)(manifest))
+                    type = manifest.type || 'scaffold';
+                else if (manifest.type)
+                    type = manifest.type;
+            }
+            const item = { path: cmdPath, type, scope, description: manifest?.description || '' };
+            if (!commands.has(cmdPath)) {
+                commands.set(cmdPath, item);
+                const effectiveManifest = manifest || { name: file, type: 'group' };
+                if (!(0, manifest_1.isCappedManifest)(effectiveManifest))
+                    await walk(filePath, cmdPathParts, scope);
+            }
+            else {
+                const existing = commands.get(cmdPath);
+                if (existing && existing.scope === 'local' && existing.type === 'group' && type === 'group') {
+                    await walk(filePath, cmdPathParts, scope);
+                }
             }
         }
-        return false;
-    });
-}
-function isSamePath(p1, p2) {
-    return path_1.default.relative(p1, p2) === '';
+    }
+    if (ctx.localRoot)
+        await walk(path_1.default.join(ctx.localRoot, '.agentctl'), [], 'local');
+    await walk(ctx.globalRoot, [], 'global');
+    return Array.from(commands.values());
 }

package/dist/effects.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const skills_1 = require("./skills");
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const execFileAsync = util_1.default.promisify(child_process_1.execFile);
+/**
+ * THE EXECUTOR: The only part of the app that actually "does" things.
+ * It's a simple, dumb loop.
+ */
+async function execute(effects) {
+    for (const effect of effects) {
+        switch (effect.type) {
+            case 'writeFile':
+                await fs_extra_1.default.writeFile(effect.path, effect.content);
+                break;
+            case 'writeJson':
+                await fs_extra_1.default.writeJson(effect.path, effect.content, { spaces: 2 });
+                break;
+            case 'mkdir':
+                await fs_extra_1.default.ensureDir(effect.path);
+                break;
+            case 'chmod':
+                await fs_extra_1.default.chmod(effect.path, effect.mode);
+                break;
+            case 'move':
+                await fs_extra_1.default.move(effect.src, effect.dest);
+                break;
+            case 'copy':
+                await fs_extra_1.default.copy(effect.src, effect.dest, effect.options);
+                break;
+            case 'remove':
+                await fs_extra_1.default.remove(effect.path);
+                break;
+            case 'log':
+                console.log(effect.message);
+                break;
+            case 'installSkill': {
+                const p = await (0, skills_1.copySkill)(effect.targetDir, effect.agent);
+                console.log(`Installed skill for ${effect.agent} at ${p}`);
+                break;
+            }
+            case 'spawn': {
+                const child = (0, child_process_1.spawn)(effect.command, effect.options);
+                if (effect.onExit) {
+                    child.on('exit', effect.onExit);
+                }
+                break;
+            }
+            case 'gitClone': {
+                await execFileAsync('git', ['clone', '--depth', '1', effect.url, effect.dest]);
+                break;
+            }
+        }
+    }
+}