@michaelhartmayer/agentctl 1.1.0 → 1.1.3

package/dist/ctl.js

@@ -8,206 +8,207 @@ 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");
-async function scaffold(args, options = {}) {
-    const { targetDir, name, isWin } = await 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"';
-    await fs_extra_1.default.writeFile(scriptPath, scriptContent);
-    if (!isWin)
-        await fs_extra_1.default.chmod(scriptPath, 0o755);
-    const manifest = {
-        name,
-        description: '',
-        type: 'scaffold',
-        run: `./${scriptName}`,
+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;
+}
+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()
     };
-    await fs_extra_1.default.writeJson(path_1.default.join(targetDir, 'manifest.json'), manifest, { spaces: 2 });
-    console.log(`Scaffolded command: ${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 { targetDir, name } = await prepareCommand(args, options);
-    const manifest = {
-        name,
-        description: '',
+    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',
-        run: target,
-    };
-    await fs_extra_1.default.writeJson(path_1.default.join(targetDir, 'manifest.json'), manifest, { spaces: 2 });
-    console.log(`Aliased command: ${args.join(' ')} -> ${target}`);
+        target
+    });
+    await (0, effects_1.execute)(effects);
 }
 async function group(args, options = {}) {
-    const { targetDir, name } = await prepareCommand(args, options);
-    const manifest = {
-        name,
-        description: '',
-        type: 'group',
-    };
-    await fs_extra_1.default.writeJson(path_1.default.join(targetDir, 'manifest.json'), manifest, { spaces: 2 });
-    console.log(`Created group: ${args.join(' ')}`);
+    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);
 }
 async function pushGlobal(args, options = {}) {
-    const cwd = options.cwd || process.cwd();
-    const localRoot = (0, fs_utils_1.findLocalRoot)(cwd);
-    if (!localRoot)
+    const ctx = await getContext(options);
+    if (!ctx.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 (!await fs_extra_1.default.pathExists(srcDir)) {
-        throw new Error(`Local command ${args.join(' ')} not found`);
-    }
-    const destDir = path_1.default.join(globalRoot, cmdPathStr);
-    if (await fs_extra_1.default.pathExists(destDir)) {
-        throw new Error(`Global command ${args.join(' ')} already exists`);
-    }
-    await fs_extra_1.default.ensureDir(path_1.default.dirname(destDir));
-    if (options.move) {
-        await fs_extra_1.default.move(srcDir, destDir);
-        console.log(`Moved ${args.join(' ')} to global scope`);
-    }
-    else {
-        await fs_extra_1.default.copy(srcDir, destDir);
-        console.log(`Copied ${args.join(' ')} to global scope`);
-    }
+    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);
 }
 async function pullLocal(args, options = {}) {
-    const cwd = options.cwd || process.cwd();
-    const localRoot = (0, fs_utils_1.findLocalRoot)(cwd);
-    if (!localRoot)
+    const ctx = await getContext(options);
+    if (!ctx.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 (!await 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 (await fs_extra_1.default.pathExists(destDir)) {
-        throw new Error(`Local command ${args.join(' ')} already exists`);
-    }
-    await fs_extra_1.default.ensureDir(path_1.default.dirname(destDir));
-    if (options.move) {
-        await fs_extra_1.default.move(srcDir, destDir);
-        console.log(`Moved ${args.join(' ')} to local scope`);
-    }
-    else {
-        await fs_extra_1.default.copy(srcDir, destDir);
-        console.log(`Copied ${args.join(' ')} to local scope`);
-    }
-}
-const skills_1 = require("./skills");
-async function installSkill(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 = await (0, skills_1.copySkill)(targetDir, agent);
-    console.log(`Installed skill for ${agent} at ${p}`);
+    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);
 }
 async function rm(args, options = {}) {
     const resolved = await (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);
-    await fs_extra_1.default.remove(targetDir);
-    console.log(`Removed ${resolved.scope} command: ${args.join(' ')}`);
+    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);
 }
 async function mv(srcArgs, destArgs, options = {}) {
     const resolved = await (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'
-        ? (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 (await 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 (await isCapped(current)) {
-            const relPath = path_1.default.relative(agentctlDir, current); // relative to base
-            throw new Error(`Cannot nest command under capped command: ${relPath}`);
+    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) {
+            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 };
         }
-        current = path_1.default.dirname(current);
-    }
-    await fs_extra_1.default.move(srcDir, destDir);
-    // Update manifest name
-    const manifestPath = path_1.default.join(destDir, 'manifest.json');
-    if (await fs_extra_1.default.pathExists(manifestPath)) {
-        const manifest = await fs_extra_1.default.readJson(manifestPath);
-        manifest.name = destArgs[destArgs.length - 1];
-        await 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);
 }
 async function inspect(args, options = {}) {
     const resolved = await (0, resolve_1.resolveCommand)(args, options);
-    if (!resolved) {
+    if (!resolved)
         return null;
-    }
     return {
         manifest: resolved.manifest,
         resolvedPath: resolved.manifestPath,
         scope: resolved.scope
     };
 }
+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);
+}
+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);
+}
 async function list(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 ctx = await getContext(options);
     const commands = new Map();
     async function walk(dir, prefix, scope) {
         if (!await fs_extra_1.default.pathExists(dir))
@@ -228,89 +229,32 @@ async function list(options = {}) {
             const cmdPath = cmdPathParts.join(' ');
             let manifest = null;
             const mPath = path_1.default.join(filePath, 'manifest.json');
-            if (await fs_extra_1.default.pathExists(mPath)) {
+            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)) {
+                if ((0, manifest_1.isCappedManifest)(manifest))
                     type = manifest.type || 'scaffold';
-                }
-                else if (manifest.type) {
+                else if (manifest.type)
                     type = manifest.type;
-                }
             }
-            const item = {
-                path: cmdPath,
-                type,
-                scope,
-                description: manifest?.description || ''
-            };
+            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)) {
+                if (!(0, manifest_1.isCappedManifest)(effectiveManifest))
                     await walk(filePath, cmdPathParts, scope);
-                }
             }
             else {
                 const existing = commands.get(cmdPath);
-                if (existing && existing.scope === 'local') {
-                    if (existing.type === 'group' && type === 'group') {
-                        await walk(filePath, cmdPathParts, scope);
-                    }
+                if (existing && existing.scope === 'local' && existing.type === 'group' && type === 'group') {
+                    await walk(filePath, cmdPathParts, scope);
                 }
             }
         }
     }
-    if (localRoot) {
-        await walk(path_1.default.join(localRoot, '.agentctl'), [], 'local');
-    }
-    await walk(globalRoot, [], 'global');
+    if (ctx.localRoot)
+        await walk(path_1.default.join(ctx.localRoot, '.agentctl'), [], 'local');
+    await walk(ctx.globalRoot, [], 'global');
     return Array.from(commands.values());
 }
-// Helpers
-async function prepareCommand(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 (await 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 (await 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);
-    }
-    await fs_extra_1.default.ensureDir(targetDir);
-    return {
-        targetDir,
-        name: args[args.length - 1],
-        isWin: process.platform === 'win32'
-    };
-}
-async function isCapped(dir) {
-    const manifestPath = path_1.default.join(dir, 'manifest.json');
-    if (await fs_extra_1.default.pathExists(manifestPath)) {
-        try {
-            const m = await fs_extra_1.default.readJson(manifestPath);
-            return (0, manifest_1.isCappedManifest)(m);
-        }
-        catch {
-            return false;
-        }
-    }
-    return false;
-}
-function isSamePath(p1, p2) {
-    return path_1.default.relative(p1, p2) === '';
-}

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;
+            }
+        }
+    }
+}

package/dist/fs-utils.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,30 +20,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalRoot = getGlobalRoot;
 exports.getAntigravityGlobalRoot = getAntigravityGlobalRoot;
 exports.findLocalRoot = findLocalRoot;
-const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./logic/utils");
+__exportStar(require("./logic/utils"), exports);
+function getRealContext() {
+    return {
+        platform: process.platform,
+        env: process.env,
+        homedir: process.env.HOME || process.env.USERPROFILE || os_1.default.homedir()
+    };
+}
 function getGlobalRoot() {
-    if (process.platform === 'win32') {
-        return path_1.default.join(process.env.APPDATA || path_1.default.join(os_1.default.homedir(), 'AppData', 'Roaming'), 'agentctl');
-    }
-    return path_1.default.join(os_1.default.homedir(), '.config', 'agentctl');
+    return utils_1.UtilsLogic.getGlobalRoot(getRealContext());
 }
 function getAntigravityGlobalRoot() {
-    return path_1.default.join(os_1.default.homedir(), '.gemini', 'antigravity');
+    return utils_1.UtilsLogic.getAntigravityGlobalRoot(getRealContext());
 }
 function findLocalRoot(cwd = process.cwd()) {
-    let current = path_1.default.resolve(cwd);
-    const root = path_1.default.parse(current).root;
-    // Safety break and root check
-    // Using for(;;) to avoid no-constant-condition
-    for (;;) {
-        if (fs_extra_1.default.existsSync(path_1.default.join(current, '.agentctl'))) {
-            return current;
-        }
-        if (current === root) {
-            return null;
-        }
-        current = path_1.default.dirname(current);
-    }
+    return utils_1.UtilsLogic.findLocalRoot(cwd, fs_extra_1.default.existsSync);
 }