agentloom 0.1.0 → 0.1.1

package/dist/commands/update.js

@@ -1,30 +1,69 @@
+import path from "node:path";
+import { parseProvidersFlag } from "../core/argv.js";
 import { importSource, NonInteractiveConflictError } from "../core/importer.js";
+import { normalizeCommandSelector, stripCommandFileExtension, } from "../core/commands.js";
 import { readLockfile } from "../core/lockfile.js";
-import { resolveScope } from "../core/scope.js";
-import { prepareSource } from "../core/sources.js";
-import { parseProvidersFlag } from "../core/argv.js";
+import { prepareSource, parseSourceSpec } from "../core/sources.js";
 import { getUpdateHelpText } from "../core/copy.js";
-import { formatSyncSummary, syncFromCanonical } from "../sync/index.js";
+import { resolveProvidersForSync } from "../sync/index.js";
+import { getNonInteractiveMode, resolvePathsForCommand, runPostMutationSync, } from "./entity-utils.js";
 export async function runUpdateCommand(argv, cwd) {
     if (argv.help) {
         console.log(getUpdateHelpText());
         return;
     }
-    const nonInteractive = !(process.stdin.isTTY && process.stdout.isTTY);
-    const paths = await resolveScope({
+    await runEntityAwareUpdate({
+        argv,
         cwd,
-        global: Boolean(argv.global),
-        local: Boolean(argv.local),
-        interactive: !nonInteractive,
+        target: "all",
+        sourceIndex: 1,
+    });
+}
+export async function runScopedUpdateCommand(options) {
+    await runEntityAwareUpdate({
+        argv: options.argv,
+        cwd: options.cwd,
+        target: options.entity,
+        sourceIndex: options.sourceIndex,
     });
+}
+async function runEntityAwareUpdate(options) {
+    const nonInteractive = getNonInteractiveMode(options.argv);
+    const paths = await resolvePathsForCommand(options.argv, options.cwd);
+    const explicitProviders = parseProvidersFlag(options.argv.providers);
+    let resolvedSkillProviders;
+    const resolveProvidersForSkills = async () => {
+        if (explicitProviders && explicitProviders.length > 0) {
+            return explicitProviders;
+        }
+        if (resolvedSkillProviders && resolvedSkillProviders.length > 0) {
+            return resolvedSkillProviders;
+        }
+        resolvedSkillProviders = await resolveProvidersForSync({
+            paths,
+            explicitProviders,
+            nonInteractive,
+        });
+        return resolvedSkillProviders;
+    };
     const lockfile = readLockfile(paths);
     if (lockfile.entries.length === 0) {
         console.log(`No lock entries found in ${paths.lockPath}.`);
         return;
     }
+    const sourceFilter = resolveSourceFilter(options.argv, options.sourceIndex);
+    const entries = lockfile.entries.filter((entry) => matchesSourceFilter(entry, sourceFilter));
+    if (entries.length === 0) {
+        console.log("No lock entries matched the requested source filter.");
+        return;
+    }
     let updated = 0;
     let skipped = 0;
-    for (const entry of lockfile.entries) {
+    for (const entry of entries) {
+        if (!entryIncludesTarget(entry, options.target)) {
+            skipped += 1;
+            continue;
+        }
         const probe = prepareSource({
             source: entry.source,
             ref: entry.requestedRef,
@@ -36,15 +75,58 @@ export async function runUpdateCommand(argv, cwd) {
             skipped += 1;
             continue;
         }
+        const updatePlan = buildEntryUpdatePlan(entry, options.target);
+        if (!updatePlan.importAgents &&
+            !updatePlan.importCommands &&
+            !updatePlan.importMcp &&
+            !updatePlan.importSkills) {
+            skipped += 1;
+            continue;
+        }
         try {
-            await importSource({
+            const importOptions = {
                 source: entry.source,
                 ref: entry.requestedRef,
                 subdir: entry.subdir,
-                yes: Boolean(argv.yes),
+                agents: updatePlan.requestedAgents,
+                promptForAgentSelection: false,
+                promptForCommands: false,
+                promptForMcp: false,
+                promptForSkills: false,
+                yes: Boolean(options.argv.yes),
                 nonInteractive,
                 paths,
-            });
+                importAgents: updatePlan.importAgents,
+                requireAgents: updatePlan.importAgents,
+                importCommands: updatePlan.importCommands,
+                importMcp: updatePlan.importMcp,
+            };
+            if (updatePlan.importSkills) {
+                importOptions.importSkills = true;
+                if (explicitProviders && explicitProviders.length > 0) {
+                    importOptions.skillsProviders = explicitProviders;
+                }
+                else if (updatePlan.skillsProviders) {
+                    importOptions.skillsProviders = updatePlan.skillsProviders;
+                }
+                else {
+                    importOptions.resolveSkillsProviders = resolveProvidersForSkills;
+                }
+            }
+            if (updatePlan.commandSelectors) {
+                importOptions.commandSelectors = updatePlan.commandSelectors;
+                importOptions.commandRenameMap = updatePlan.commandRenameMap;
+            }
+            if (updatePlan.mcpSelectors) {
+                importOptions.mcpSelectors = updatePlan.mcpSelectors;
+            }
+            if (updatePlan.skillSelectors) {
+                importOptions.skillSelectors = updatePlan.skillSelectors;
+            }
+            if (updatePlan.skillRenameMap) {
+                importOptions.skillRenameMap = updatePlan.skillRenameMap;
+            }
+            await importSource(importOptions);
             updated += 1;
         }
         catch (err) {
@@ -57,15 +139,198 @@ export async function runUpdateCommand(argv, cwd) {
     }
     console.log(`Updated entries: ${updated}`);
     console.log(`Unchanged entries: ${skipped}`);
-    if (updated > 0 && !argv["no-sync"]) {
-        const syncSummary = await syncFromCanonical({
+    if (updated > 0) {
+        await runPostMutationSync({
+            argv: options.argv,
             paths,
-            providers: parseProvidersFlag(argv.providers),
-            yes: Boolean(argv.yes),
-            nonInteractive,
-            dryRun: Boolean(argv["dry-run"]),
+            target: options.target,
+            providers: explicitProviders ?? resolvedSkillProviders,
         });
-        console.log("");
-        console.log(formatSyncSummary(syncSummary, paths.agentsRoot));
     }
 }
+function buildEntryUpdatePlan(entry, target) {
+    const includeAgents = shouldUpdateEntity(entry, "agent", target);
+    const includeCommands = shouldUpdateEntity(entry, "command", target);
+    const includeMcp = shouldUpdateEntity(entry, "mcp", target);
+    const includeSkills = shouldUpdateEntity(entry, "skill", target);
+    const commandOptions = getUpdateCommandOptions(entry, includeCommands);
+    const mcpOptions = getUpdateMcpOptions(entry, includeMcp);
+    const skillOptions = getUpdateSkillOptions(entry, includeSkills);
+    return {
+        importAgents: includeAgents,
+        importCommands: commandOptions.importCommands,
+        importMcp: mcpOptions.importMcp,
+        importSkills: skillOptions.importSkills,
+        requestedAgents: includeAgents ? entry.requestedAgents : undefined,
+        commandSelectors: commandOptions.commandSelectors,
+        commandRenameMap: commandOptions.commandRenameMap,
+        mcpSelectors: mcpOptions.mcpSelectors,
+        skillSelectors: skillOptions.skillSelectors,
+        skillsProviders: skillOptions.skillsProviders,
+        skillRenameMap: skillOptions.skillRenameMap,
+    };
+}
+function resolveSourceFilter(argv, sourceIndex) {
+    const sourceFromFlag = typeof argv.source === "string" && argv.source.trim().length > 0
+        ? argv.source.trim()
+        : undefined;
+    if (sourceFromFlag)
+        return sourceFromFlag;
+    const sourceFromArg = argv._[sourceIndex];
+    if (typeof sourceFromArg !== "string" || sourceFromArg.trim().length === 0) {
+        return undefined;
+    }
+    return sourceFromArg.trim();
+}
+function matchesSourceFilter(entry, filter) {
+    if (!filter)
+        return true;
+    if (entry.source === filter)
+        return true;
+    try {
+        const parsed = parseSourceSpec(filter);
+        return entry.source === parsed.source;
+    }
+    catch {
+        return false;
+    }
+}
+function entryIncludesTarget(entry, target) {
+    if (target === "all")
+        return true;
+    return tracksEntity(entry, target);
+}
+function shouldUpdateEntity(entry, entity, target) {
+    if (target !== "all" && target !== entity)
+        return false;
+    if (target === "all" && !entry.trackedEntities) {
+        if (entity === "skill") {
+            return tracksEntity(entry, entity);
+        }
+        return true;
+    }
+    return tracksEntity(entry, entity);
+}
+function tracksEntity(entry, entity) {
+    const importedAgents = Array.isArray(entry.importedAgents)
+        ? entry.importedAgents
+        : [];
+    const importedCommands = Array.isArray(entry.importedCommands)
+        ? entry.importedCommands
+        : [];
+    const importedMcpServers = Array.isArray(entry.importedMcpServers)
+        ? entry.importedMcpServers
+        : [];
+    const importedSkills = Array.isArray(entry.importedSkills)
+        ? entry.importedSkills
+        : [];
+    if (entry.trackedEntities?.includes(entity))
+        return true;
+    if (entity === "agent") {
+        return importedAgents.length > 0 || Boolean(entry.requestedAgents);
+    }
+    if (entity === "command") {
+        return (importedCommands.length > 0 ||
+            Boolean(entry.selectedSourceCommands) ||
+            Boolean(entry.commandRenameMap));
+    }
+    if (entity === "mcp") {
+        return (importedMcpServers.length > 0 || Boolean(entry.selectedSourceMcpServers));
+    }
+    return (importedSkills.length > 0 ||
+        Boolean(entry.selectedSourceSkills) ||
+        Boolean(entry.skillsProviders) ||
+        Boolean(entry.skillRenameMap));
+}
+function getUpdateCommandOptions(entry, includeCommands) {
+    if (!includeCommands) {
+        return { importCommands: false };
+    }
+    const commandSelectors = getUpdateCommandSelectors(entry);
+    if (commandSelectors && commandSelectors.length === 0) {
+        return { importCommands: false };
+    }
+    if (!commandSelectors) {
+        return { importCommands: true };
+    }
+    return {
+        importCommands: true,
+        commandSelectors,
+        commandRenameMap: getUpdateCommandRenameMap(entry, commandSelectors),
+    };
+}
+function getUpdateMcpOptions(entry, includeMcp) {
+    if (!includeMcp) {
+        return { importMcp: false };
+    }
+    if (Array.isArray(entry.selectedSourceMcpServers) &&
+        entry.selectedSourceMcpServers.length === 0) {
+        return { importMcp: false };
+    }
+    return {
+        importMcp: true,
+        mcpSelectors: entry.selectedSourceMcpServers,
+    };
+}
+function getUpdateSkillOptions(entry, includeSkills) {
+    if (!includeSkills) {
+        return { importSkills: false };
+    }
+    if (Array.isArray(entry.selectedSourceSkills) &&
+        entry.selectedSourceSkills.length === 0) {
+        return { importSkills: false };
+    }
+    return {
+        importSkills: true,
+        skillSelectors: entry.selectedSourceSkills,
+        skillsProviders: entry.skillsProviders,
+        skillRenameMap: entry.skillRenameMap,
+    };
+}
+function getUpdateCommandSelectors(entry) {
+    if (entry.selectedSourceCommands !== undefined) {
+        return entry.selectedSourceCommands;
+    }
+    return undefined;
+}
+function getUpdateCommandRenameMap(entry, commandSelectors) {
+    const renameMapFromLock = filterRenameMapBySelectors(entry.commandRenameMap, commandSelectors);
+    if (renameMapFromLock) {
+        return renameMapFromLock;
+    }
+    const inferredRename = inferUpdateCommandRename(entry, commandSelectors);
+    if (!inferredRename)
+        return undefined;
+    return {
+        [commandSelectors[0]]: inferredRename,
+    };
+}
+function inferUpdateCommandRename(entry, commandSelectors) {
+    if (!commandSelectors || commandSelectors.length !== 1) {
+        return undefined;
+    }
+    if (entry.importedCommands.length !== 1) {
+        return undefined;
+    }
+    const sourceName = stripCommandFileExtension(commandSelectors[0]);
+    const importedName = stripCommandFileExtension(path.basename(entry.importedCommands[0]));
+    if (!sourceName || !importedName || sourceName === importedName) {
+        return undefined;
+    }
+    return importedName;
+}
+function filterRenameMapBySelectors(renameMap, selectors) {
+    if (!renameMap)
+        return undefined;
+    const selectorSet = new Set(selectors.map(normalizeCommandSelector));
+    const filteredEntries = Object.entries(renameMap)
+        .filter(([sourceSelector]) => selectorSet.has(normalizeCommandSelector(sourceSelector)))
+        .map(([sourceSelector, importedFileName]) => [
+        sourceSelector,
+        path.basename(importedFileName),
+    ]);
+    if (filteredEntries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(filteredEntries);
+}

package/dist/core/argv.d.ts

@@ -1,5 +1,6 @@
 import type { ParsedArgs } from "minimist";
-import type { Provider } from "../types.js";
+import type { Provider, SelectionMode } from "../types.js";
 export declare function parseArgs(argv: string[]): ParsedArgs;
 export declare function parseProvidersFlag(input: unknown): Provider[] | undefined;
+export declare function parseSelectionModeFlag(input: unknown): SelectionMode | undefined;
 export declare function getStringArrayFlag(value: unknown, fallback?: string[]): string[];

package/dist/core/argv.js

@@ -1,8 +1,28 @@
 import minimist from "minimist";
 export function parseArgs(argv) {
-    return minimist(argv, {
+    const parsed = minimist(argv, {
         boolean: ["global", "local", "yes", "no-sync", "dry-run", "json", "help"],
-        string: ["ref", "subdir", "providers", "rename", "command", "url"],
+        string: [
+            "ref",
+            "subdir",
+            "providers",
+            "rename",
+            "agent",
+            "agents",
+            "command",
+            "commands",
+            "mcp",
+            "mcps",
+            "skill",
+            "skills",
+            "url",
+            "arg",
+            "env",
+            "source",
+            "name",
+            "entity",
+            "selection-mode",
+        ],
         alias: {
             g: "global",
             l: "local",
@@ -11,6 +31,14 @@ export function parseArgs(argv) {
         },
         "--": true,
     });
+    const syncFlag = parsed.sync;
+    if (syncFlag === false ||
+        syncFlag === "false" ||
+        syncFlag === 0 ||
+        syncFlag === "0") {
+        parsed["no-sync"] = true;
+    }
+    return parsed;
 }
 export function parseProvidersFlag(input) {
     if (typeof input !== "string" || input.trim() === "")
@@ -35,6 +63,18 @@ export function parseProvidersFlag(input) {
     }
     return [...new Set(validProviders)];
 }
+export function parseSelectionModeFlag(input) {
+    if (typeof input !== "string" || input.trim() === "")
+        return undefined;
+    const normalized = input.trim().toLowerCase();
+    if (normalized === "all" || normalized === "sync-all") {
+        return "all";
+    }
+    if (normalized === "custom") {
+        return "custom";
+    }
+    throw new Error(`Unknown selection mode: ${normalized}. Expected one of: all, sync-all, custom.`);
+}
 export function getStringArrayFlag(value, fallback = []) {
     if (Array.isArray(value)) {
         return value

package/dist/core/commands.d.ts

@@ -0,0 +1,13 @@
+export interface CanonicalCommandFile {
+    fileName: string;
+    sourcePath: string;
+    content: string;
+}
+export declare function parseCommandsDir(commandsDir: string): CanonicalCommandFile[];
+export declare function stripCommandFileExtension(fileName: string): string;
+export declare function commandFileMatchesSelector(fileName: string, selector: string): boolean;
+export declare function normalizeCommandSelector(selector: string): string;
+export declare function resolveCommandSelections(commands: CanonicalCommandFile[], selectors: string[]): {
+    selected: CanonicalCommandFile[];
+    unmatched: string[];
+};

package/dist/core/commands.js

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listMarkdownFiles, slugify } from "./fs.js";
+export function parseCommandsDir(commandsDir) {
+    if (!fs.existsSync(commandsDir))
+        return [];
+    return listMarkdownFiles(commandsDir)
+        .sort((a, b) => a.localeCompare(b))
+        .map((sourcePath) => ({
+        fileName: path.basename(sourcePath),
+        sourcePath,
+        content: fs.readFileSync(sourcePath, "utf8"),
+    }));
+}
+export function stripCommandFileExtension(fileName) {
+    const lower = fileName.toLowerCase();
+    if (lower.endsWith(".prompt.md")) {
+        return fileName.slice(0, -".prompt.md".length);
+    }
+    const ext = path.extname(fileName);
+    if (!ext)
+        return fileName;
+    return fileName.slice(0, -ext.length);
+}
+export function commandFileMatchesSelector(fileName, selector) {
+    const raw = selector.trim().toLowerCase();
+    if (!raw)
+        return false;
+    const normalizedSelector = normalizeCommandSelector(raw);
+    const normalizedFileName = fileName.toLowerCase();
+    const withoutExt = stripCommandFileExtension(normalizedFileName);
+    if (normalizedFileName === raw || normalizedFileName === normalizedSelector) {
+        return true;
+    }
+    if (withoutExt === raw || withoutExt === normalizedSelector) {
+        return true;
+    }
+    if (slugify(withoutExt) === normalizedSelector ||
+        slugify(withoutExt) === slugify(normalizedSelector)) {
+        return true;
+    }
+    return false;
+}
+export function normalizeCommandSelector(selector) {
+    const trimmed = selector.trim().replace(/^\/+/, "");
+    return stripCommandFileExtension(trimmed).toLowerCase();
+}
+export function resolveCommandSelections(commands, selectors) {
+    const uniqueSelected = new Map();
+    const unmatched = [];
+    for (const selector of selectors) {
+        const matches = commands.filter((command) => commandFileMatchesSelector(command.fileName, selector));
+        if (matches.length === 0) {
+            unmatched.push(selector);
+            continue;
+        }
+        for (const match of matches) {
+            uniqueSelected.set(match.fileName, match);
+        }
+    }
+    return {
+        selected: [...uniqueSelected.values()],
+        unmatched,
+    };
+}

package/dist/core/copy.d.ts

@@ -4,10 +4,16 @@ type UsageErrorInput = {
     example?: string;
 };
 export declare function getRootHelpText(): string;
+export declare function getFindHelpText(): string;
 export declare function getAddHelpText(): string;
 export declare function getUpdateHelpText(): string;
 export declare function getSyncHelpText(): string;
+export declare function getCommandHelpText(): string;
+export declare function getCommandAddHelpText(): string;
+export declare function getCommandListHelpText(): string;
+export declare function getCommandDeleteHelpText(): string;
 export declare function getMcpHelpText(): string;
+export declare function getMcpServerHelpText(): string;
 export declare function getMcpAddHelpText(): string;
 export declare function getMcpListHelpText(): string;
 export declare function getMcpDeleteHelpText(): string;