@michaelhartmayer/agentctl 1.1.0 → 1.1.4

package/dist/logic/ctl.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logic = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const skills_1 = require("../skills");
+/**
+ * THE BRAIN: Pure functions that calculate "Plans" (Effect arrays).
+ * NO IMPURE IMPORTS (no fs, no os, no process).
+ */
+exports.Logic = {
+    planScaffold(args, ctx, options) {
+        if (args.length === 0)
+            throw new Error('No command path provided');
+        if (options.exists) {
+            throw new Error(`Command ${args.join(' ')} already exists`);
+        }
+        if (options.cappedAncestor) {
+            throw new Error(`Cannot nest command under capped command: ${options.cappedAncestor.relPath}`);
+        }
+        const localRoot = ctx.localRoot || ctx.cwd;
+        const agentctlDir = path_1.default.join(localRoot, '.agentctl');
+        const cmdPath = args.join(path_1.default.sep);
+        const targetDir = path_1.default.join(agentctlDir, cmdPath);
+        const name = args[args.length - 1];
+        const type = options.type || 'scaffold';
+        const isWin = ctx.platform === 'win32';
+        const effects = [{ type: 'mkdir', path: targetDir }];
+        const manifest = {
+            name,
+            description: '<insert summary>',
+            help: '<insert usage/help instructions>',
+            type,
+        };
+        if (type === 'scaffold') {
+            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"';
+            manifest.run = `./${scriptName}`;
+            effects.push({ type: 'writeFile', path: scriptPath, content: scriptContent });
+            if (!isWin)
+                effects.push({ type: 'chmod', path: scriptPath, mode: 0o755 });
+        }
+        else if (type === 'alias') {
+            manifest.run = options.target;
+        }
+        effects.push({ type: 'writeJson', path: path_1.default.join(targetDir, 'manifest.json'), content: manifest });
+        const logMsg = type === 'scaffold' ? `Scaffolded command: ${args.join(' ')}` :
+            type === 'alias' ? `Aliased command: ${args.join(' ')} -> ${options.target}` :
+                `Created group: ${args.join(' ')}`;
+        effects.push({ type: 'log', message: logMsg });
+        return { effects };
+    },
+    planPushGlobal(args, ctx, options) {
+        if (!ctx.localRoot)
+            throw new Error('Not in a local context');
+        if (!options.existsInLocal)
+            throw new Error(`Local command ${args.join(' ')} not found`);
+        if (options.existsInGlobal)
+            throw new Error(`Global command ${args.join(' ')} already exists`);
+        const cmdPathStr = args.join(path_1.default.sep);
+        const srcDir = path_1.default.join(ctx.localRoot, '.agentctl', cmdPathStr);
+        const destDir = path_1.default.join(ctx.globalRoot, cmdPathStr);
+        const effects = [
+            { type: 'mkdir', path: path_1.default.dirname(destDir) }
+        ];
+        if (options.move) {
+            effects.push({ type: 'move', src: srcDir, dest: destDir });
+            effects.push({ type: 'log', message: `Moved ${args.join(' ')} to global scope` });
+        }
+        else {
+            effects.push({ type: 'copy', src: srcDir, dest: destDir });
+            effects.push({ type: 'log', message: `Copied ${args.join(' ')} to global scope` });
+        }
+        return effects;
+    },
+    planPullLocal(args, ctx, options) {
+        if (!ctx.localRoot)
+            throw new Error('Not in a local context');
+        if (!options.existsInGlobal)
+            throw new Error(`Global command ${args.join(' ')} not found`);
+        if (options.existsInLocal)
+            throw new Error(`Local command ${args.join(' ')} already exists`);
+        const cmdPathStr = args.join(path_1.default.sep);
+        const srcDir = path_1.default.join(ctx.globalRoot, cmdPathStr);
+        const destDir = path_1.default.join(ctx.localRoot, '.agentctl', cmdPathStr);
+        const effects = [
+            { type: 'mkdir', path: path_1.default.dirname(destDir) }
+        ];
+        if (options.move) {
+            effects.push({ type: 'move', src: srcDir, dest: destDir });
+            effects.push({ type: 'log', message: `Moved ${args.join(' ')} to local scope` });
+        }
+        else {
+            effects.push({ type: 'copy', src: srcDir, dest: destDir });
+            effects.push({ type: 'log', message: `Copied ${args.join(' ')} to local scope` });
+        }
+        return effects;
+    },
+    planRemove(args, ctx, options) {
+        if (!options.resolvedPath) {
+            throw new Error(`Command ${args.join(' ')} not found${options.global ? ' in global scope' : ''}`);
+        }
+        const targetDir = path_1.default.dirname(options.resolvedPath);
+        return [
+            { type: 'remove', path: targetDir },
+            { type: 'log', message: `Removed ${options.scope} command: ${args.join(' ')}` }
+        ];
+    },
+    planMove(srcArgs, destArgs, ctx, options) {
+        if (!options.resolvedSrc)
+            throw new Error(`Command ${srcArgs.join(' ')} not found`);
+        if (!options.rootDir || !options.agentctlDir)
+            throw new Error('Cannot determine root for move');
+        if (options.destExists)
+            throw new Error(`Destination ${destArgs.join(' ')} already exists`);
+        if (options.cappedAncestor)
+            throw new Error(`Cannot nest command under capped command: ${options.cappedAncestor.relPath}`);
+        const srcDir = path_1.default.dirname(options.resolvedSrc.manifestPath);
+        const destPathStr = destArgs.join(path_1.default.sep);
+        const destDir = path_1.default.join(options.agentctlDir, destPathStr);
+        const effects = [
+            { type: 'move', src: srcDir, dest: destDir }
+        ];
+        const updatedManifest = { ...options.resolvedSrc.manifest, name: destArgs[destArgs.length - 1] };
+        effects.push({ type: 'writeJson', path: path_1.default.join(destDir, 'manifest.json'), content: updatedManifest });
+        effects.push({ type: 'log', message: `Moved ${srcArgs.join(' ')} to ${destArgs.join(' ')}` });
+        return effects;
+    },
+    planInstallSkill(agent, ctx, options) {
+        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(ctx.cwd, '.cursor', 'skills');
+        }
+        else if (agent === 'antigravity') {
+            if (options.global) {
+                const globalRoot = options.antigravityGlobalDir || utils_1.UtilsLogic.getAntigravityGlobalRoot({
+                    platform: ctx.platform,
+                    env: {}, // UtilsLogic should probably take full ctx or we just use ctx.homedir
+                    homedir: ctx.homedir
+                });
+                targetDir = path_1.default.join(globalRoot, 'skills', 'agentctl');
+            }
+            else {
+                targetDir = path_1.default.join(ctx.cwd, '.agent', 'skills', 'agentctl');
+            }
+        }
+        else if (agent === 'agentsmd') {
+            targetDir = path_1.default.join(ctx.cwd, '.agents', 'skills', 'agentctl');
+        }
+        else if (agent === 'gemini') {
+            if (options.global) {
+                const globalRoot = options.geminiGlobalDir || path_1.default.join(ctx.homedir, '.gemini');
+                targetDir = path_1.default.join(globalRoot, 'skills', 'agentctl');
+            }
+            else {
+                targetDir = path_1.default.join(ctx.cwd, '.gemini', 'skills', 'agentctl');
+            }
+        }
+        else {
+            throw new Error(`Agent logic for '${agent}' not implemented.`);
+        }
+        return [{ type: 'installSkill', targetDir, agent }];
+    }
+};

package/dist/logic/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppLogic = void 0;
+const path_1 = __importDefault(require("path"));
+exports.AppLogic = {
+    planApp(args, result) {
+        if (!result) {
+            return [{ type: 'log', message: `Command '${args.join(' ')}' not found. Run 'agentctl list' to see available commands.` }];
+        }
+        const { manifest, args: remainingArgs, scope, manifestPath, cmdPath } = result;
+        const effects = [];
+        const allowedKeys = new Set(['name', 'description', 'help', 'type', 'run', 'flags']);
+        const unsupportedKeys = Object.keys(manifest).filter(k => !allowedKeys.has(k));
+        if (unsupportedKeys.length > 0) {
+            effects.push({
+                type: 'log',
+                message: `[WARNING] The manifest at ${manifestPath} contains unsupported keys: ${unsupportedKeys.join(', ')}. Agentctl will ignore them.`
+            });
+        }
+        if (manifest.run) {
+            const cmdDir = path_1.default.dirname(manifestPath);
+            let runCmd = manifest.run;
+            if (runCmd.startsWith('./') || runCmd.startsWith('.\\')) {
+                runCmd = path_1.default.resolve(cmdDir, runCmd);
+            }
+            runCmd = runCmd.replace(/{{DIR}}/g, cmdDir);
+            const fullCommand = `${runCmd} ${remainingArgs.join(' ')}`;
+            effects.push({ type: 'log', message: `[${scope}] Running: ${fullCommand}` }, {
+                type: 'spawn',
+                command: fullCommand,
+                options: {
+                    cwd: process.cwd(),
+                    shell: true,
+                    stdio: 'inherit',
+                    env: { ...process.env, AGENTCTL_SCOPE: scope }
+                },
+                onExit: (code) => {
+                    process.exit(code || 0);
+                }
+            });
+            return effects;
+        }
+        else {
+            return [...effects, ...exports.AppLogic.planGroupList(manifest, cmdPath, [], manifestPath)];
+        }
+    },
+    planGroupList(manifest, cmdPath, allCommands, manifestPath) {
+        const effects = [];
+        if (manifestPath) {
+            const allowedKeys = new Set(['name', 'description', 'help', 'type', 'run', 'flags']);
+            const unsupportedKeys = Object.keys(manifest).filter(k => !allowedKeys.has(k));
+            if (unsupportedKeys.length > 0) {
+                effects.push({
+                    type: 'log',
+                    message: `[WARNING] The manifest at ${manifestPath} contains unsupported keys: ${unsupportedKeys.join(', ')}. Agentctl will ignore them.`
+                });
+            }
+        }
+        effects.push({ type: 'log', message: manifest.name }, { type: 'log', message: manifest.help || manifest.description || 'Command group containing subcommands' }, { type: 'log', message: '\nSubcommands:' });
+        const prefix = cmdPath + ' ';
+        const depth = cmdPath.split(' ').length;
+        const children = allCommands.filter(c => c.path.startsWith(prefix) && c.path !== cmdPath);
+        const direct = children.filter(c => c.path.split(' ').length === depth + 1);
+        if (direct.length === 0) {
+            effects.push({ type: 'log', message: '  (No subcommands found)' });
+        }
+        else {
+            for (const child of direct) {
+                const name = child.path.split(' ').pop();
+                const desc = child.description || 'Command group containing subcommands';
+                effects.push({ type: 'log', message: `  ${name}\t${desc}` });
+            }
+        }
+        return effects;
+    }
+};

package/dist/logic/install.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planInstallClone = planInstallClone;
+exports.planInstallCopy = planInstallCopy;
+const path_1 = __importDefault(require("path"));
+function planInstallClone(ctx, deps) {
+    if (!ctx.global && !ctx.localRoot) {
+        throw new Error('Not in a local context. Run inside a project or use --global');
+    }
+    const tempDir = path_1.default.join(ctx.osTmpdir, deps.tempFolderName);
+    const effects = [];
+    // 1. Create a log message
+    effects.push({
+        type: 'log',
+        message: `Fetching ${ctx.repoUrl}...`
+    });
+    // 2. Clone the repository shallowly into a temp directory
+    effects.push({
+        type: 'gitClone',
+        url: ctx.repoUrl,
+        dest: tempDir
+    });
+    return { effects, tempDir };
+}
+function planInstallCopy(ctx, deps) {
+    if (!ctx.global && !ctx.localRoot) {
+        throw new Error('Not in a local context. Run inside a project or use --global');
+    }
+    const rootDir = ctx.global ? ctx.globalRoot : ctx.localRoot;
+    const agentctlDir = ctx.global ? rootDir : path_1.default.join(rootDir, '.agentctl');
+    const targetDir = path_1.default.join(agentctlDir, ...ctx.pathParts);
+    const effects = [];
+    if (!ctx.allowCollisions) {
+        // Simple collision detection based on paths relative to targetDir
+        const collisions = deps.existingItems.filter(item => deps.downloadedItems.includes(item));
+        if (collisions.length > 0) {
+            effects.push({ type: 'remove', path: path_1.default.dirname(deps.tempAgentctlDir) }); // cleanup
+            throw new Error(`Installation aborted due to collisions without --allow-collisions flag: \n${collisions.join('\n')}`);
+        }
+    }
+    // Ensure target path exists
+    effects.push({ type: 'mkdir', path: targetDir });
+    if (!ctx.global && ctx.isNewLocalRoot) {
+        effects.push({ type: 'log', message: `Initialized new .agentctl folder at ${agentctlDir}` });
+    }
+    // Copy contents
+    effects.push({
+        type: 'copy',
+        src: deps.tempAgentctlDir,
+        dest: targetDir,
+        options: { overwrite: ctx.allowCollisions }
+    });
+    // Clean up temp dir
+    effects.push({ type: 'remove', path: path_1.default.dirname(deps.tempAgentctlDir) });
+    effects.push({ type: 'log', message: `Successfully installed commands to ${targetDir}` });
+    return { effects };
+}

package/dist/logic/manifest.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestLogic = void 0;
+exports.ManifestLogic = {
+    isCappedManifest(m) {
+        return !!m.run || m.type === 'scaffold' || m.type === 'alias';
+    }
+};

package/dist/logic/resolve.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveLogic = void 0;
+exports.ResolveLogic = {
+    decide(local, global, isCapped) {
+        if (!local?.manifest && !global.manifest) {
+            return { currentMatch: null, finalResult: null, shouldStop: true };
+        }
+        const localManifest = local?.manifest;
+        const globalManifest = global.manifest;
+        // 1. Local Capped -> Return Match immediately.
+        if (localManifest && isCapped(localManifest)) {
+            return {
+                currentMatch: null,
+                finalResult: {
+                    scope: 'local',
+                    manifest: localManifest,
+                    manifestPath: local.path
+                },
+                shouldStop: true
+            };
+        }
+        // 2. Global Capped
+        if (globalManifest && isCapped(globalManifest)) {
+            if (localManifest) {
+                // Local Group shadows Global Capped
+                return {
+                    currentMatch: {
+                        scope: 'local',
+                        manifest: localManifest,
+                        manifestPath: local.path
+                    },
+                    finalResult: null,
+                    shouldStop: false
+                };
+            }
+            else {
+                return {
+                    currentMatch: null,
+                    finalResult: {
+                        scope: 'global',
+                        manifest: globalManifest,
+                        manifestPath: global.path
+                    },
+                    shouldStop: true
+                };
+            }
+        }
+        // 3. Neither capped
+        if (localManifest) {
+            return {
+                currentMatch: {
+                    scope: 'local',
+                    manifest: localManifest,
+                    manifestPath: local.path
+                },
+                finalResult: null,
+                shouldStop: false
+            };
+        }
+        else {
+            return {
+                currentMatch: {
+                    scope: 'global',
+                    manifest: globalManifest,
+                    manifestPath: global.path
+                },
+                finalResult: null,
+                shouldStop: false
+            };
+        }
+    }
+};

package/dist/logic/skills.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillsLogic = void 0;
+const path_1 = __importDefault(require("path"));
+exports.SkillsLogic = {
+    getSourcePaths(ctx) {
+        return [
+            path_1.default.resolve(ctx.dirname, '../../skills/agentctl/SKILL.md'),
+            path_1.default.resolve(ctx.dirname, '../skills/agentctl/SKILL.md'),
+            path_1.default.resolve(ctx.dirname, '../../../skills/agentctl/SKILL.md')
+        ];
+    },
+    getTargetPath(targetDir, agent) {
+        const filename = agent === 'cursor' ? 'agentctl.md' : 'SKILL.md';
+        return path_1.default.join(targetDir, filename);
+    }
+};

package/dist/logic/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UtilsLogic = void 0;
+const path_1 = __importDefault(require("path"));
+exports.UtilsLogic = {
+    getGlobalRoot(ctx) {
+        if (ctx.platform === 'win32') {
+            return path_1.default.join(ctx.env.APPDATA || path_1.default.join(ctx.homedir, 'AppData', 'Roaming'), 'agentctl');
+        }
+        return path_1.default.join(ctx.homedir, '.config', 'agentctl');
+    },
+    getAntigravityGlobalRoot(ctx) {
+        return path_1.default.join(ctx.homedir, '.gemini', 'antigravity');
+    },
+    findLocalRoot(cwd, existsSync) {
+        let current = path_1.default.resolve(cwd);
+        const root = path_1.default.parse(current).root;
+        for (;;) {
+            if (existsSync(path_1.default.join(current, '.agentctl'))) {
+                return current;
+            }
+            if (current === root) {
+                return null;
+            }
+            current = path_1.default.dirname(current);
+        }
+    }
+};

package/dist/manifest.js

@@ -1,4 +1,18 @@
 "use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,6 +20,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readManifest = readManifest;
 exports.isCappedManifest = isCappedManifest;
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const manifest_1 = require("./logic/manifest");
+__exportStar(require("./logic/manifest"), exports);
 async function readManifest(p) {
     try {
         return await fs_extra_1.default.readJson(p);
@@ -15,5 +31,5 @@ async function readManifest(p) {
     }
 }
 function isCappedManifest(m) {
-    return !!m.run || m.type === 'scaffold' || m.type === 'alias';
+    return manifest_1.ManifestLogic.isCappedManifest(m);
 }

package/dist/resolve.js

@@ -8,104 +8,58 @@ const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const fs_utils_1 = require("./fs-utils");
 const manifest_1 = require("./manifest");
+const resolve_1 = require("./logic/resolve");
 async function resolveCommand(args, options = {}) {
     const cwd = options.cwd || process.cwd();
     const localRoot = !options.global ? (0, fs_utils_1.findLocalRoot)(cwd) : null;
     const globalRoot = options.globalDir || (0, fs_utils_1.getGlobalRoot)();
     const localAgentctl = localRoot ? path_1.default.join(localRoot, '.agentctl') : null;
     let currentMatch = null;
-    // Iterate through args to find longest match
     for (let i = 0; i < args.length; i++) {
-        // Path corresponding to args[0..i]
         const currentArgs = args.slice(0, i + 1);
         const relPath = currentArgs.join(path_1.default.sep);
         const cmdPath = currentArgs.join(' ');
         const localPath = localAgentctl ? path_1.default.join(localAgentctl, relPath) : null;
         const globalPath = path_1.default.join(globalRoot, relPath);
-        let localManifest = null;
-        let globalManifest = null;
-        // check local
-        if (localPath && await fs_extra_1.default.pathExists(localPath)) {
-            const mPath = path_1.default.join(localPath, 'manifest.json');
+        const getFacts = async (p) => {
+            if (!p || !(await fs_extra_1.default.pathExists(p)))
+                return null;
+            const mPath = path_1.default.join(p, 'manifest.json');
+            let manifest = null;
             if (await fs_extra_1.default.pathExists(mPath)) {
-                localManifest = await (0, manifest_1.readManifest)(mPath);
+                manifest = await (0, manifest_1.readManifest)(mPath);
             }
-            if (!localManifest && (await fs_extra_1.default.stat(localPath)).isDirectory()) {
-                // Implicit group
-                localManifest = { name: args[i], type: 'group' };
+            const stats = await fs_extra_1.default.stat(p);
+            const isDir = stats.isDirectory();
+            if (!manifest && isDir) {
+                manifest = { name: args[i], type: 'group' };
             }
-        }
-        // check global
-        if (await fs_extra_1.default.pathExists(globalPath)) {
-            const mPath = path_1.default.join(globalPath, 'manifest.json');
-            if (await fs_extra_1.default.pathExists(mPath)) {
-                globalManifest = await (0, manifest_1.readManifest)(mPath);
-            }
-            if (!globalManifest && (await fs_extra_1.default.stat(globalPath)).isDirectory()) {
-                globalManifest = { name: args[i], type: 'group' };
-            }
-        }
-        if (!localManifest && !globalManifest) {
-            break;
-        }
+            return { exists: true, manifest, isDir, path: mPath };
+        };
+        const localFacts = await getFacts(localPath);
+        const globalFacts = (await getFacts(globalPath)) || { exists: false, manifest: null, isDir: false, path: path_1.default.join(globalPath, 'manifest.json') };
+        const decision = resolve_1.ResolveLogic.decide(localFacts, globalFacts, manifest_1.isCappedManifest);
         const remainingArgs = args.slice(i + 1);
-        // Priority logic
-        // 1. Local Capped -> Return Match immediately.
-        if (localManifest && (0, manifest_1.isCappedManifest)(localManifest)) {
+        if (decision.finalResult) {
             return {
-                manifest: localManifest,
-                manifestPath: path_1.default.join(localPath, 'manifest.json'),
+                manifest: decision.finalResult.manifest,
+                manifestPath: decision.finalResult.manifestPath,
                 args: remainingArgs,
-                scope: 'local',
+                scope: decision.finalResult.scope,
                 cmdPath
             };
         }
-        // 2. Global Capped
-        if (globalManifest && (0, manifest_1.isCappedManifest)(globalManifest)) {
-            // Check if shadowed by Local Group
-            if (localManifest) {
-                // Local exists (must be group since checked capped above).
-                // Shadowed. Treat as Local Group.
-                currentMatch = {
-                    manifest: localManifest,
-                    manifestPath: path_1.default.join(localPath, 'manifest.json'),
-                    args: remainingArgs,
-                    scope: 'local',
-                    cmdPath
-                };
-            }
-            else {
-                // Not shadowed. Global Capped wins. Return immediately.
-                return {
-                    manifest: globalManifest,
-                    manifestPath: path_1.default.join(globalPath, 'manifest.json'),
-                    args: remainingArgs,
-                    scope: 'global',
-                    cmdPath
-                };
-            }
+        if (decision.currentMatch) {
+            currentMatch = {
+                manifest: decision.currentMatch.manifest,
+                manifestPath: decision.currentMatch.manifestPath,
+                args: remainingArgs,
+                scope: decision.currentMatch.scope,
+                cmdPath
+            };
         }
-        else {
-            // Neither is capped. Both are groups (or one is).
-            // Local wins if exists.
-            if (localManifest) {
-                currentMatch = {
-                    manifest: localManifest,
-                    manifestPath: path_1.default.join(localPath, 'manifest.json'),
-                    args: remainingArgs,
-                    scope: 'local',
-                    cmdPath
-                };
-            }
-            else {
-                currentMatch = {
-                    manifest: globalManifest,
-                    manifestPath: path_1.default.join(globalPath, 'manifest.json'),
-                    args: remainingArgs,
-                    scope: 'global',
-                    cmdPath
-                };
-            }
+        if (decision.shouldStop) {
+            break;
         }
     }
     return currentMatch;