agentloom 0.1.0 → 0.1.1

package/dist/commands/mcp.js

@@ -1,8 +1,12 @@
 import { getStringArrayFlag, parseProvidersFlag } from "../core/argv.js";
-import { formatUsageError, getMcpAddHelpText, getMcpDeleteHelpText, getMcpHelpText, getMcpListHelpText, } from "../core/copy.js";
+import { formatUsageError, getMcpAddHelpText, getMcpDeleteHelpText, getMcpHelpText, getMcpListHelpText, getMcpServerHelpText, } from "../core/copy.js";
 import { readCanonicalMcp, writeCanonicalMcp } from "../core/mcp.js";
-import { resolveScope } from "../core/scope.js";
-import { formatSyncSummary, syncFromCanonical } from "../sync/index.js";
+import { runScopedAddCommand } from "./add.js";
+import { runScopedDeleteCommand } from "./delete.js";
+import { resolvePathsForCommand } from "./entity-utils.js";
+import { runScopedFindCommand } from "./find.js";
+import { runScopedSyncCommand } from "./sync.js";
+import { runScopedUpdateCommand } from "./update.js";
 export async function runMcpCommand(argv, cwd) {
     const action = argv._[1];
     if (argv.help) {
@@ -18,79 +22,153 @@ export async function runMcpCommand(argv, cwd) {
             console.log(getMcpDeleteHelpText());
             return;
         }
+        if (action === "server") {
+            console.log(getMcpServerHelpText());
+            return;
+        }
         console.log(getMcpHelpText());
         return;
     }
-    if (action !== "add" && action !== "list" && action !== "delete") {
+    if (!action) {
+        console.log(getMcpHelpText());
+        return;
+    }
+    if (action === "server") {
+        await runMcpServerCommand(argv, cwd);
+        return;
+    }
+    if (action !== "add" &&
+        action !== "list" &&
+        action !== "delete" &&
+        action !== "find" &&
+        action !== "update" &&
+        action !== "sync") {
         throw new Error(formatUsageError({
             issue: "Invalid mcp command.",
-            usage: "agentloom mcp <add|list|delete> [options]",
-            example: "agentloom mcp add browser --command npx --arg browser-tools-mcp",
+            usage: "agentloom mcp <add|list|delete|find|update|sync> [options]",
+            example: "agentloom mcp add farnoodma/agents --mcps browser",
         }));
     }
-    const nonInteractive = !(process.stdin.isTTY && process.stdout.isTTY);
-    const paths = await resolveScope({
+    if (action === "list") {
+        const paths = await resolvePathsForCommand(argv, cwd);
+        runMcpList(paths, Boolean(argv.json));
+        return;
+    }
+    if (action === "add") {
+        await runScopedAddCommand({
+            argv,
+            cwd,
+            entity: "mcp",
+            sourceIndex: 2,
+        });
+        return;
+    }
+    if (action === "delete") {
+        await runScopedDeleteCommand({
+            argv,
+            cwd,
+            entity: "mcp",
+            sourceIndex: 2,
+        });
+        return;
+    }
+    if (action === "find") {
+        await runScopedFindCommand(argv, "mcp");
+        return;
+    }
+    if (action === "update") {
+        await runScopedUpdateCommand({
+            argv,
+            cwd,
+            entity: "mcp",
+            sourceIndex: 2,
+        });
+        return;
+    }
+    await runScopedSyncCommand({
+        argv,
         cwd,
-        global: Boolean(argv.global),
-        local: Boolean(argv.local),
-        interactive: !nonInteractive,
+        target: "mcp",
     });
+}
+async function runMcpServerCommand(argv, cwd) {
+    const action = argv._[2];
+    if (argv.help || !action) {
+        console.log(getMcpServerHelpText());
+        return;
+    }
+    if (action !== "add" && action !== "list" && action !== "delete") {
+        throw new Error(formatUsageError({
+            issue: "Invalid mcp server command.",
+            usage: "agentloom mcp server <add|list|delete> [options]",
+            example: "agentloom mcp server add browser --command npx --arg browser-tools-mcp",
+        }));
+    }
+    const nonInteractive = !(process.stdin.isTTY && process.stdout.isTTY);
+    const paths = await resolvePathsForCommand(argv, cwd);
     if (action === "list") {
+        if (argv.help) {
+            console.log(getMcpListHelpText());
+            return;
+        }
         runMcpList(paths, Boolean(argv.json));
         return;
     }
     if (action === "add") {
-        const name = argv._[2];
+        if (argv.help) {
+            console.log(getMcpAddHelpText());
+            return;
+        }
+        const name = argv._[3];
         if (typeof name !== "string" || !name.trim()) {
             throw new Error(formatUsageError({
                 issue: "Missing required MCP server name.",
-                usage: "agentloom mcp add <name> (--url <url> | --command <cmd>) [options]",
-                example: "agentloom mcp add browser --command npx --arg browser-tools-mcp",
+                usage: "agentloom mcp server add <name> (--url <url> | --command <cmd>) [options]",
+                example: "agentloom mcp server add browser --command npx --arg browser-tools-mcp",
             }));
         }
         runMcpAdd(paths, argv, name.trim());
         if (!argv["no-sync"]) {
-            const summary = await syncFromCanonical({
-                paths,
-                providers: parseProvidersFlag(argv.providers),
-                yes: Boolean(argv.yes),
-                nonInteractive,
+            await runScopedSyncCommand({
+                argv,
+                cwd,
+                target: "mcp",
             });
-            console.log("");
-            console.log(formatSyncSummary(summary, paths.agentsRoot));
         }
         return;
     }
-    if (action === "delete") {
-        const name = argv._[2];
-        if (typeof name !== "string" || !name.trim()) {
-            throw new Error(formatUsageError({
-                issue: "Missing required MCP server name.",
-                usage: "agentloom mcp delete <name> [options]",
-                example: "agentloom mcp delete browser",
-            }));
-        }
-        const mcp = readCanonicalMcp(paths);
-        if (!(name in mcp.mcpServers)) {
-            throw new Error(formatUsageError({
-                issue: `MCP server "${name}" was not found in canonical config.`,
-                usage: "agentloom mcp list [--json] [--local|--global]",
-                example: "agentloom mcp list --json",
-            }));
-        }
-        delete mcp.mcpServers[name];
-        writeCanonicalMcp(paths, mcp);
-        console.log(`Deleted MCP server: ${name}`);
-        if (!argv["no-sync"]) {
-            const summary = await syncFromCanonical({
-                paths,
-                providers: parseProvidersFlag(argv.providers),
-                yes: Boolean(argv.yes),
-                nonInteractive,
-            });
-            console.log("");
-            console.log(formatSyncSummary(summary, paths.agentsRoot));
-        }
+    if (argv.help) {
+        console.log(getMcpDeleteHelpText());
+        return;
+    }
+    const name = argv._[3];
+    if (typeof name !== "string" || !name.trim()) {
+        throw new Error(formatUsageError({
+            issue: "Missing required MCP server name.",
+            usage: "agentloom mcp server delete <name> [options]",
+            example: "agentloom mcp server delete browser",
+        }));
+    }
+    const mcp = readCanonicalMcp(paths);
+    if (!(name in mcp.mcpServers)) {
+        throw new Error(formatUsageError({
+            issue: `MCP server "${name}" was not found in canonical config.`,
+            usage: "agentloom mcp server list [--json] [--local|--global]",
+            example: "agentloom mcp server list --json",
+        }));
+    }
+    delete mcp.mcpServers[name];
+    writeCanonicalMcp(paths, mcp);
+    console.log(`Deleted MCP server: ${name}`);
+    if (!argv["no-sync"]) {
+        await runScopedSyncCommand({
+            argv,
+            cwd,
+            target: "mcp",
+        });
+    }
+    if (!nonInteractive) {
+        return;
     }
 }
 function runMcpList(paths, asJson) {
@@ -132,8 +210,8 @@ function runMcpAdd(paths, argv, name) {
     if (!baseConfig.url && !baseConfig.command) {
         throw new Error(formatUsageError({
             issue: "Missing MCP transport. Use --url or --command.",
-            usage: "agentloom mcp add <name> (--url <url> | --command <cmd>) [options]",
-            example: "agentloom mcp add browser --command npx --arg browser-tools-mcp",
+            usage: "agentloom mcp server add <name> (--url <url> | --command <cmd>) [options]",
+            example: "agentloom mcp server add browser --command npx --arg browser-tools-mcp",
         }));
     }
     const args = getStringArrayFlag(argv.arg);
@@ -148,8 +226,8 @@ function runMcpAdd(paths, argv, name) {
             if (separator <= 0) {
                 throw new Error(formatUsageError({
                     issue: `Invalid --env value "${pair}".`,
-                    usage: "agentloom mcp add <name> ... --env KEY=VALUE [--env KEY2=VALUE2]",
-                    example: "agentloom mcp add browser --command npx --env API_KEY=secret",
+                    usage: "agentloom mcp server add <name> ... --env KEY=VALUE [--env KEY2=VALUE2]",
+                    example: "agentloom mcp server add browser --command npx --env API_KEY=secret",
                 }));
             }
             const key = pair.slice(0, separator).trim();

package/dist/commands/skills.d.ts

@@ -1 +1,2 @@
-export declare function runSkillsPassthrough(args: string[]): never;
+import type { ParsedArgs } from "minimist";
+export declare function runSkillCommand(argv: ParsedArgs, cwd: string): Promise<void>;

package/dist/commands/skills.js

@@ -1,11 +1,107 @@
-import { spawnSync } from "node:child_process";
-export function runSkillsPassthrough(args) {
-    const child = spawnSync("npx", ["skills", ...args], {
-        stdio: "inherit",
-        shell: false,
-    });
-    if (child.error) {
-        throw child.error;
+import path from "node:path";
+import { parseProvidersFlag } from "../core/argv.js";
+import { formatUsageError } from "../core/copy.js";
+import { applySkillProviderSideEffects, parseSkillsDir, } from "../core/skills.js";
+import { formatSyncSummary, resolveProvidersForSync, syncFromCanonical, } from "../sync/index.js";
+import { runScopedAddCommand } from "./add.js";
+import { runScopedDeleteCommand } from "./delete.js";
+import { getNonInteractiveMode, resolvePathsForCommand, } from "./entity-utils.js";
+import { runScopedFindCommand } from "./find.js";
+import { runScopedUpdateCommand } from "./update.js";
+export async function runSkillCommand(argv, cwd) {
+    const action = argv._[1];
+    if (argv.help || !action) {
+        console.log("Usage:\n  agentloom skill <add|list|delete|find|update|sync> [options]");
+        return;
+    }
+    if (action !== "add" &&
+        action !== "list" &&
+        action !== "delete" &&
+        action !== "find" &&
+        action !== "update" &&
+        action !== "sync") {
+        throw new Error(formatUsageError({
+            issue: "Invalid skill command.",
+            usage: "agentloom skill <add|list|delete|find|update|sync> [options]",
+            example: "agentloom skill add farnoodma/agents",
+        }));
+    }
+    if (action === "add") {
+        await runScopedAddCommand({
+            argv,
+            cwd,
+            entity: "skill",
+            sourceIndex: 2,
+        });
+        return;
+    }
+    if (action === "list") {
+        const paths = await resolvePathsForCommand(argv, cwd);
+        const skills = parseSkillsDir(paths.skillsDir);
+        if (Boolean(argv.json)) {
+            console.log(JSON.stringify({
+                version: 1,
+                skills: skills.map((skill) => ({
+                    name: skill.name,
+                    directory: path.basename(skill.sourcePath),
+                })),
+            }, null, 2));
+            return;
+        }
+        if (skills.length === 0) {
+            console.log("No canonical skills configured.");
+            return;
+        }
+        for (const skill of skills) {
+            console.log(`${skill.name} (${path.basename(skill.sourcePath)})`);
+        }
+        return;
+    }
+    if (action === "delete") {
+        await runScopedDeleteCommand({
+            argv,
+            cwd,
+            entity: "skill",
+            sourceIndex: 2,
+        });
+        return;
     }
-    process.exit(child.status ?? 1);
+    if (action === "find") {
+        await runScopedFindCommand(argv, "skill");
+        return;
+    }
+    if (action === "update") {
+        await runScopedUpdateCommand({
+            argv,
+            cwd,
+            entity: "skill",
+            sourceIndex: 2,
+        });
+        return;
+    }
+    const paths = await resolvePathsForCommand(argv, cwd);
+    const nonInteractive = getNonInteractiveMode(argv);
+    const explicitProviders = parseProvidersFlag(argv.providers);
+    const providers = await resolveProvidersForSync({
+        paths,
+        explicitProviders,
+        nonInteractive,
+    });
+    applySkillProviderSideEffects({
+        paths,
+        providers,
+        dryRun: Boolean(argv["dry-run"]),
+        warn(message) {
+            console.warn(`Warning: ${message}`);
+        },
+    });
+    const summary = await syncFromCanonical({
+        paths,
+        providers,
+        yes: Boolean(argv.yes),
+        nonInteractive,
+        dryRun: Boolean(argv["dry-run"]),
+        target: "skill",
+    });
+    console.log(formatSyncSummary(summary, paths.agentsRoot));
 }

package/dist/commands/sync.d.ts

@@ -1,2 +1,8 @@
 import type { ParsedArgs } from "minimist";
+import type { EntityType } from "../types.js";
 export declare function runSyncCommand(argv: ParsedArgs, cwd: string): Promise<void>;
+export declare function runScopedSyncCommand(options: {
+    argv: ParsedArgs;
+    cwd: string;
+    target: EntityType | "all";
+}): Promise<void>;

package/dist/commands/sync.js

@@ -1,25 +1,27 @@
 import { parseProvidersFlag } from "../core/argv.js";
 import { getSyncHelpText } from "../core/copy.js";
-import { resolveScope } from "../core/scope.js";
+import { getNonInteractiveMode, resolvePathsForCommand, } from "./entity-utils.js";
 import { formatSyncSummary, syncFromCanonical } from "../sync/index.js";
 export async function runSyncCommand(argv, cwd) {
     if (argv.help) {
         console.log(getSyncHelpText());
         return;
     }
-    const nonInteractive = !(process.stdin.isTTY && process.stdout.isTTY);
-    const paths = await resolveScope({
+    await runScopedSyncCommand({
+        argv,
         cwd,
-        global: Boolean(argv.global),
-        local: Boolean(argv.local),
-        interactive: !nonInteractive,
+        target: "all",
     });
+}
+export async function runScopedSyncCommand(options) {
+    const paths = await resolvePathsForCommand(options.argv, options.cwd);
     const summary = await syncFromCanonical({
         paths,
-        providers: parseProvidersFlag(argv.providers),
-        yes: Boolean(argv.yes),
-        nonInteractive,
-        dryRun: Boolean(argv["dry-run"]),
+        providers: parseProvidersFlag(options.argv.providers),
+        yes: Boolean(options.argv.yes),
+        nonInteractive: getNonInteractiveMode(options.argv),
+        dryRun: Boolean(options.argv["dry-run"]),
+        target: options.target,
     });
     console.log(formatSyncSummary(summary, paths.agentsRoot));
 }

package/dist/commands/update.d.ts

@@ -1,2 +1,9 @@
 import type { ParsedArgs } from "minimist";
+import type { EntityType } from "../types.js";
 export declare function runUpdateCommand(argv: ParsedArgs, cwd: string): Promise<void>;
+export declare function runScopedUpdateCommand(options: {
+    argv: ParsedArgs;
+    cwd: string;
+    entity: EntityType;
+    sourceIndex: number;
+}): Promise<void>;