agentloom 0.1.0 → 0.1.1

package/dist/core/lockfile.js

@@ -6,9 +6,64 @@ const EMPTY_LOCK = {
 export function readLockfile(paths) {
     const lock = readJsonIfExists(paths.lockPath);
     if (!lock || lock.version !== 1 || !Array.isArray(lock.entries)) {
-        return { ...EMPTY_LOCK };
+        return createEmptyLockfile();
     }
-    return lock;
+    return {
+        version: 1,
+        entries: lock.entries.map((entry) => ({
+            ...entry,
+            importedAgents: Array.isArray(entry.importedAgents)
+                ? entry.importedAgents
+                : [],
+            importedCommands: Array.isArray(entry.importedCommands)
+                ? entry.importedCommands
+                : [],
+            selectedSourceCommands: Array.isArray(entry.selectedSourceCommands)
+                ? entry.selectedSourceCommands
+                : undefined,
+            commandRenameMap: normalizeRenameMap(entry.commandRenameMap),
+            importedMcpServers: Array.isArray(entry.importedMcpServers)
+                ? entry.importedMcpServers
+                : [],
+            selectedSourceMcpServers: Array.isArray(entry.selectedSourceMcpServers)
+                ? entry.selectedSourceMcpServers
+                : undefined,
+            importedSkills: Array.isArray(entry.importedSkills)
+                ? entry.importedSkills
+                : [],
+            selectedSourceSkills: Array.isArray(entry.selectedSourceSkills)
+                ? entry.selectedSourceSkills
+                : undefined,
+            skillsProviders: Array.isArray(entry.skillsProviders)
+                ? entry.skillsProviders
+                : undefined,
+            skillRenameMap: normalizeRenameMap(entry.skillRenameMap),
+            trackedEntities: Array.isArray(entry.trackedEntities)
+                ? entry.trackedEntities
+                : undefined,
+        })),
+    };
+}
+function createEmptyLockfile() {
+    return {
+        version: EMPTY_LOCK.version,
+        entries: [],
+    };
+}
+function normalizeRenameMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [sourceName, importedName] of Object.entries(value)) {
+        if (typeof sourceName === "string" &&
+            sourceName.trim() &&
+            typeof importedName === "string" &&
+            importedName.trim()) {
+            normalized[sourceName] = importedName;
+        }
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
 }
 export function writeLockfile(paths, lockfile) {
     writeJsonAtomic(paths.lockPath, lockfile);
@@ -16,10 +71,38 @@ export function writeLockfile(paths, lockfile) {
 export function upsertLockEntry(lockfile, entry) {
     const index = lockfile.entries.findIndex((item) => item.source === entry.source &&
         item.sourceType === entry.sourceType &&
-        item.subdir === entry.subdir);
+        item.subdir === entry.subdir &&
+        sameRequestedAgents(item.requestedAgents, entry.requestedAgents) &&
+        sameSelection(item.selectedSourceCommands, entry.selectedSourceCommands) &&
+        sameSelection(item.selectedSourceMcpServers, entry.selectedSourceMcpServers) &&
+        sameSelection(item.selectedSourceSkills, entry.selectedSourceSkills) &&
+        sameSelection(item.skillsProviders, entry.skillsProviders));
     if (index >= 0) {
         lockfile.entries[index] = entry;
         return;
     }
     lockfile.entries.push(entry);
 }
+function sameRequestedAgents(left, right) {
+    const normalizedLeft = normalizeSelectionForKey(left);
+    const normalizedRight = normalizeSelectionForKey(right);
+    if (normalizedLeft.length !== normalizedRight.length) {
+        return false;
+    }
+    return normalizedLeft.every((value, index) => value === normalizedRight[index]);
+}
+function sameSelection(left, right) {
+    const normalizedLeft = normalizeSelectionForKey(left);
+    const normalizedRight = normalizeSelectionForKey(right);
+    if (normalizedLeft.length !== normalizedRight.length) {
+        return false;
+    }
+    return normalizedLeft.every((value, index) => value === normalizedRight[index]);
+}
+function normalizeSelectionForKey(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return [];
+    return [
+        ...new Set(value.map((item) => item.trim().toLowerCase()).filter(Boolean)),
+    ].sort();
+}

package/dist/core/manage-agents-bootstrap.d.ts

@@ -0,0 +1,10 @@
+export declare function getGlobalManageAgentsSkillPath(homeDir?: string): string;
+export declare function getLocalManageAgentsSkillPath(cwd?: string): string;
+export declare function maybePromptManageAgentsBootstrap(options: {
+    command: string;
+    help: boolean;
+    yes: boolean;
+    homeDir?: string;
+    cwd?: string;
+    interactive?: boolean;
+}): Promise<boolean>;

package/dist/core/manage-agents-bootstrap.js

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+const SKIP_COMMANDS = new Set([
+    "help",
+    "--help",
+    "-h",
+    "version",
+    "--version",
+    "-v",
+]);
+export function getGlobalManageAgentsSkillPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".agents", "skills", "manage-agents", "SKILL.md");
+}
+export function getLocalManageAgentsSkillPath(cwd = process.cwd()) {
+    return path.join(cwd, ".agents", "skills", "manage-agents", "SKILL.md");
+}
+export async function maybePromptManageAgentsBootstrap(options) {
+    if (process.env.AGENTLOOM_DISABLE_MANAGE_AGENTS_PROMPT === "1")
+        return false;
+    const interactive = options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (!interactive || options.help || options.yes)
+        return false;
+    const loweredCommand = options.command.trim().toLowerCase();
+    if (SKIP_COMMANDS.has(loweredCommand))
+        return false;
+    const globalSkillPath = getGlobalManageAgentsSkillPath(options.homeDir);
+    const localSkillPath = getLocalManageAgentsSkillPath(options.cwd);
+    if (fs.existsSync(globalSkillPath) || fs.existsSync(localSkillPath)) {
+        return false;
+    }
+    const accepted = await confirm({
+        message: 'Global skill "manage-agents" is missing. It helps agents reliably manage Agentloom resources (find/create/import/update/sync/delete). Install it after this command completes?',
+        initialValue: true,
+    });
+    if (isCancel(accepted) || accepted !== true)
+        return false;
+    return true;
+}

package/dist/core/manifest.js

@@ -10,7 +10,13 @@ export function readManifest(paths) {
         !Array.isArray(manifest.generatedFiles)) {
         return { ...EMPTY_MANIFEST };
     }
-    return manifest;
+    const generatedByEntity = manifest.generatedByEntity && typeof manifest.generatedByEntity === "object"
+        ? manifest.generatedByEntity
+        : undefined;
+    return {
+        ...manifest,
+        generatedByEntity,
+    };
 }
 export function writeManifest(paths, manifest) {
     writeJsonAtomic(paths.manifestPath, manifest);

package/dist/core/router.d.ts

@@ -0,0 +1,16 @@
+import type { EntityType } from "../types.js";
+export type AggregateVerb = "add" | "find" | "update" | "sync" | "delete";
+export type EntityVerb = "add" | "list" | "delete" | "find" | "update" | "sync";
+export type McpServerVerb = "add" | "list" | "delete";
+export type CommandRoute = {
+    mode: "aggregate";
+    verb: AggregateVerb;
+} | {
+    mode: "entity";
+    entity: EntityType;
+    verb: EntityVerb;
+} | {
+    mode: "mcp-server";
+    verb: McpServerVerb;
+};
+export declare function parseCommandRoute(argv: string[]): CommandRoute | null;

package/dist/core/router.js

@@ -0,0 +1,66 @@
+const AGGREGATE_VERBS = new Set([
+    "add",
+    "find",
+    "update",
+    "sync",
+    "delete",
+]);
+const ENTITY_NOUNS = new Set(["agent", "command", "mcp", "skill"]);
+const ENTITY_VERBS = new Set([
+    "add",
+    "list",
+    "delete",
+    "find",
+    "update",
+    "sync",
+]);
+const MCP_SERVER_VERBS = new Set(["add", "list", "delete"]);
+export function parseCommandRoute(argv) {
+    const root = argv[0]?.trim().toLowerCase();
+    if (!root)
+        return null;
+    if (AGGREGATE_VERBS.has(root)) {
+        return {
+            mode: "aggregate",
+            verb: root,
+        };
+    }
+    if (!ENTITY_NOUNS.has(root)) {
+        return null;
+    }
+    const action = argv[1]?.trim().toLowerCase();
+    if (!action || action === "--help" || action === "-h" || action === "help") {
+        return {
+            mode: "entity",
+            entity: root,
+            verb: "list",
+        };
+    }
+    if (root === "mcp" && action === "server") {
+        const serverVerb = argv[2]?.trim().toLowerCase();
+        if (!serverVerb ||
+            serverVerb === "--help" ||
+            serverVerb === "-h" ||
+            serverVerb === "help") {
+            return {
+                mode: "mcp-server",
+                verb: "list",
+            };
+        }
+        if (!MCP_SERVER_VERBS.has(serverVerb)) {
+            return null;
+        }
+        return {
+            mode: "mcp-server",
+            verb: serverVerb,
+        };
+    }
+    if (!ENTITY_VERBS.has(action)) {
+        return null;
+    }
+    return {
+        mode: "entity",
+        entity: root,
+        verb: action,
+    };
+}

package/dist/core/scope.d.ts

@@ -5,5 +5,5 @@ export interface ScopeResolutionOptions {
     local?: boolean;
     interactive?: boolean;
 }
-export declare function buildScopePaths(cwd: string, scope: Scope): ScopePaths;
+export declare function buildScopePaths(cwd: string, scope: Scope, homeDir?: string): ScopePaths;
 export declare function resolveScope(options: ScopeResolutionOptions): Promise<ScopePaths>;

package/dist/core/scope.js

@@ -3,9 +3,8 @@ import os from "node:os";
 import path from "node:path";
 import { cancel, isCancel, select } from "@clack/prompts";
 import { getGlobalSettingsPath, readSettings } from "./settings.js";
-export function buildScopePaths(cwd, scope) {
+export function buildScopePaths(cwd, scope, homeDir = os.homedir()) {
     const workspaceRoot = cwd;
-    const homeDir = os.homedir();
     const agentsRoot = scope === "local"
         ? path.join(workspaceRoot, ".agents")
         : path.join(homeDir, ".agents");
@@ -15,6 +14,8 @@ export function buildScopePaths(cwd, scope) {
         homeDir,
         agentsRoot,
         agentsDir: path.join(agentsRoot, "agents"),
+        commandsDir: path.join(agentsRoot, "commands"),
+        skillsDir: path.join(agentsRoot, "skills"),
         mcpPath: path.join(agentsRoot, "mcp.json"),
         lockPath: path.join(agentsRoot, "agents.lock.json"),
         settingsPath: path.join(agentsRoot, "settings.local.json"),
@@ -31,22 +32,25 @@ export async function resolveScope(options) {
     if (options.local)
         return buildScopePaths(cwd, "local");
     const hasLocalAgents = fs.existsSync(path.join(cwd, ".agents"));
-    if (!hasLocalAgents) {
-        return buildScopePaths(cwd, "global");
-    }
     const interactive = options.interactive ?? (process.stdin.isTTY && process.stdout.isTTY);
     if (!interactive) {
-        return buildScopePaths(cwd, "local");
+        return buildScopePaths(cwd, hasLocalAgents ? "local" : "global");
     }
     const globalSettings = readSettings(getGlobalSettingsPath());
-    const defaultScope = globalSettings.lastScope === "global" ? "global" : "local";
+    const defaultScope = globalSettings.lastScope === "local" ? "local" : "global";
     const selected = await select({
         message: "Choose scope for this command",
         options: [
             {
                 value: "local",
                 label: ".agents in this repository",
-                hint: defaultScope === "local" ? "default" : undefined,
+                hint: hasLocalAgents
+                    ? defaultScope === "local"
+                        ? "default"
+                        : undefined
+                    : defaultScope === "local"
+                        ? "default (creates .agents)"
+                        : "creates .agents",
             },
             {
                 value: "global",

package/dist/core/settings.d.ts

@@ -1,6 +1,7 @@
-import type { DotagentsSettings, Provider, Scope, ScopePaths } from "../types.js";
+import type { AgentloomSettings, Provider, Scope, ScopePaths } from "../types.js";
 export declare function getGlobalSettingsPath(homeDir?: string): string;
-export declare function readSettings(settingsPath: string): DotagentsSettings;
-export declare function writeSettings(settingsPath: string, settings: DotagentsSettings): void;
+export declare function readSettings(settingsPath: string): AgentloomSettings;
+export declare function writeSettings(settingsPath: string, settings: AgentloomSettings): void;
 export declare function updateLastScope(settingsPath: string, scope: Scope, providers?: Provider[]): void;
+export declare function updateLastScopeBestEffort(settingsPath: string, scope: Scope, providers?: Provider[]): void;
 export declare function settingsPathForScope(paths: ScopePaths): string;

package/dist/core/settings.js

@@ -1,16 +1,10 @@
 import os from "node:os";
 import path from "node:path";
 import { readJsonIfExists, writeJsonAtomic } from "./fs.js";
+import { ALL_PROVIDERS } from "../types.js";
 const DEFAULT_SETTINGS = {
     version: 1,
-    defaultProviders: [
-        "cursor",
-        "claude",
-        "codex",
-        "opencode",
-        "gemini",
-        "copilot",
-    ],
+    defaultProviders: [...ALL_PROVIDERS],
     telemetry: {
         enabled: true,
     },
@@ -49,6 +43,14 @@ export function updateLastScope(settingsPath, scope, providers) {
     }
     writeSettings(settingsPath, next);
 }
+export function updateLastScopeBestEffort(settingsPath, scope, providers) {
+    try {
+        updateLastScope(settingsPath, scope, providers);
+    }
+    catch {
+        // Global preference persistence should not block command execution.
+    }
+}
 export function settingsPathForScope(paths) {
     return paths.settingsPath;
 }

package/dist/core/skills.d.ts

@@ -0,0 +1,23 @@
+import type { Provider, ScopePaths } from "../types.js";
+export interface CanonicalSkill {
+    name: string;
+    sourcePath: string;
+    skillPath: string;
+    layout: "nested" | "root";
+}
+export declare const ROOT_SKILL_ARTIFACT_DIRS: readonly ["references", "assets", "scripts", "templates", "examples"];
+export declare function parseSkillsDir(skillsDir: string): CanonicalSkill[];
+export declare function normalizeSkillSelector(value: string): string;
+export declare function resolveSkillSelections(skills: CanonicalSkill[], selectors: string[]): {
+    selected: CanonicalSkill[];
+    unmatched: string[];
+};
+export declare function copyRootSkillArtifacts(sourceRoot: string, targetDir: string): void;
+export declare function copySkillArtifacts(skill: CanonicalSkill, targetDir: string): void;
+export declare function skillContentMatchesTarget(skill: CanonicalSkill, targetDir: string): boolean;
+export declare function applySkillProviderSideEffects(options: {
+    paths: ScopePaths;
+    providers: Provider[];
+    dryRun?: boolean;
+    warn?: (message: string) => void;
+}): void;