agentloom 0.1.2 → 0.1.4

package/dist/core/provider-paths.d.ts

@@ -0,0 +1,16 @@
+import type { Provider, ScopePaths } from "../types.js";
+export declare function getProviderAgentsDir(paths: ScopePaths, provider: Provider): string;
+export declare function getProviderCommandsDir(paths: ScopePaths, provider: Provider): string;
+export declare function getProviderSkillsPaths(paths: ScopePaths, providers: Provider[]): string[];
+export declare function getCursorMcpPath(paths: ScopePaths): string;
+export declare function getClaudeMcpPath(paths: ScopePaths): string;
+export declare function getClaudeSettingsPath(paths: ScopePaths): string;
+export declare function getOpenCodeConfigPath(paths: ScopePaths): string;
+export declare function getGeminiSettingsPath(paths: ScopePaths): string;
+export declare function getCopilotMcpPath(paths: ScopePaths): string;
+export declare function getCodexRootDir(paths: ScopePaths): string;
+export declare function getCodexConfigPath(paths: ScopePaths): string;
+export declare function getCodexAgentsDir(paths: ScopePaths): string;
+export declare function getCodexPromptsDir(paths: ScopePaths): string;
+export declare function getPiMcpPath(paths: ScopePaths): string;
+export declare function getVsCodeSettingsPath(homeDir: string): string;

package/dist/core/provider-paths.js

@@ -0,0 +1,154 @@
+import os from "node:os";
+import path from "node:path";
+export function getProviderAgentsDir(paths, provider) {
+    const workspaceRoot = paths.workspaceRoot;
+    const home = paths.homeDir;
+    switch (provider) {
+        case "cursor":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".cursor", "agents")
+                : path.join(home, ".cursor", "agents");
+        case "claude":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".claude", "agents")
+                : path.join(home, ".claude", "agents");
+        case "codex":
+            return path.join(getCodexRootDir(paths), "agents");
+        case "opencode":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".opencode", "agents")
+                : path.join(home, ".config", "opencode", "agents");
+        case "gemini":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".gemini", "agents")
+                : path.join(home, ".gemini", "agents");
+        case "copilot":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".github", "agents")
+                : path.join(home, ".vscode", "chatmodes");
+        case "pi":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".pi", "agents")
+                : path.join(home, ".pi", "agent", "agents");
+        default:
+            return path.join(workspaceRoot, ".agents", "unknown");
+    }
+}
+export function getProviderCommandsDir(paths, provider) {
+    const workspaceRoot = paths.workspaceRoot;
+    const home = paths.homeDir;
+    switch (provider) {
+        case "cursor":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".cursor", "commands")
+                : path.join(home, ".cursor", "commands");
+        case "claude":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".claude", "commands")
+                : path.join(home, ".claude", "commands");
+        case "codex":
+            return getCodexPromptsDir(paths);
+        case "opencode":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".opencode", "commands")
+                : path.join(home, ".config", "opencode", "commands");
+        case "gemini":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".gemini", "commands")
+                : path.join(home, ".gemini", "commands");
+        case "copilot":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".github", "prompts")
+                : path.join(home, ".github", "prompts");
+        case "pi":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".pi", "prompts")
+                : path.join(home, ".pi", "agent", "prompts");
+        default:
+            return path.join(workspaceRoot, ".agents", "unknown", "commands");
+    }
+}
+export function getProviderSkillsPaths(paths, providers) {
+    const targets = new Set();
+    const hasClaudeStyleProvider = providers.includes("claude") || providers.includes("copilot");
+    if (hasClaudeStyleProvider) {
+        targets.add(paths.scope === "local"
+            ? path.join(paths.workspaceRoot, ".claude", "skills")
+            : path.join(paths.homeDir, ".claude", "skills"));
+    }
+    if (providers.includes("cursor")) {
+        targets.add(paths.scope === "local"
+            ? path.join(paths.workspaceRoot, ".cursor", "skills")
+            : path.join(paths.homeDir, ".cursor", "skills"));
+    }
+    if (providers.includes("pi")) {
+        targets.add(paths.scope === "local"
+            ? path.join(paths.workspaceRoot, ".pi", "skills")
+            : path.join(paths.homeDir, ".pi", "agent", "skills"));
+    }
+    return [...targets];
+}
+export function getCursorMcpPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".cursor", "mcp.json")
+        : path.join(paths.homeDir, ".cursor", "mcp.json");
+}
+export function getClaudeMcpPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".mcp.json")
+        : path.join(paths.homeDir, ".mcp.json");
+}
+export function getClaudeSettingsPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".claude", "settings.json")
+        : path.join(paths.homeDir, ".claude.json");
+}
+export function getOpenCodeConfigPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".opencode", "opencode.json")
+        : path.join(paths.homeDir, ".config", "opencode", "opencode.json");
+}
+export function getGeminiSettingsPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".gemini", "settings.json")
+        : path.join(paths.homeDir, ".gemini", "settings.json");
+}
+export function getCopilotMcpPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".vscode", "mcp.json")
+        : path.join(paths.homeDir, ".vscode", "mcp.json");
+}
+export function getCodexRootDir(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".codex")
+        : path.join(paths.homeDir, ".codex");
+}
+export function getCodexConfigPath(paths) {
+    return path.join(getCodexRootDir(paths), "config.toml");
+}
+export function getCodexAgentsDir(paths) {
+    return path.join(getCodexRootDir(paths), "agents");
+}
+export function getCodexPromptsDir(paths) {
+    return path.join(paths.homeDir, ".codex", "prompts");
+}
+export function getPiMcpPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".pi", "mcp.json")
+        : path.join(paths.homeDir, ".pi", "agent", "mcp.json");
+}
+export function getVsCodeSettingsPath(homeDir) {
+    switch (os.platform()) {
+        case "darwin":
+            return path.join(homeDir, "Library", "Application Support", "Code", "User", "settings.json");
+        case "win32": {
+            const appData = process.env.APPDATA;
+            if (!appData) {
+                return path.join(homeDir, "AppData", "Roaming", "Code", "User", "settings.json");
+            }
+            return path.join(appData, "Code", "User", "settings.json");
+        }
+        default:
+            return path.join(homeDir, ".config", "Code", "User", "settings.json");
+    }
+}

package/dist/core/router.d.ts

@@ -1,5 +1,5 @@
 import type { EntityType } from "../types.js";
-export type AggregateVerb = "add" | "find" | "update" | "sync" | "delete";
+export type AggregateVerb = "add" | "find" | "update" | "upgrade" | "sync" | "delete" | "init";
 export type EntityVerb = "add" | "list" | "delete" | "find" | "update" | "sync";
 export type McpServerVerb = "add" | "list" | "delete";
 export type CommandRoute = {

package/dist/core/router.js

@@ -2,8 +2,10 @@ const AGGREGATE_VERBS = new Set([
     "add",
     "find",
     "update",
+    "upgrade",
     "sync",
     "delete",
+    "init",
 ]);
 const ENTITY_NOUNS = new Set(["agent", "command", "mcp", "skill"]);
 const ENTITY_VERBS = new Set([

package/dist/core/skills.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import matter from "gray-matter";
 import { ensureDir, slugify } from "./fs.js";
+import { getProviderSkillsPaths } from "./provider-paths.js";
 export const ROOT_SKILL_ARTIFACT_DIRS = [
     "references",
     "assets",
@@ -123,7 +124,7 @@ export function skillContentMatchesTarget(skill, targetDir) {
     return rootSkillArtifactsEqual(skill.sourcePath, targetDir);
 }
 export function applySkillProviderSideEffects(options) {
-    const pathsToSymlink = resolveProviderSkillsPaths(options.paths, options.providers);
+    const pathsToSymlink = getProviderSkillsPaths(options.paths, options.providers);
     if (pathsToSymlink.length === 0)
         return;
     const canonicalSkillsDir = options.paths.skillsDir;
@@ -139,21 +140,6 @@ export function applySkillProviderSideEffects(options) {
         });
     }
 }
-function resolveProviderSkillsPaths(paths, providers) {
-    const targets = new Set();
-    const hasClaudeStyleProvider = providers.includes("claude") || providers.includes("copilot");
-    if (hasClaudeStyleProvider) {
-        targets.add(paths.scope === "local"
-            ? path.join(paths.workspaceRoot, ".claude", "skills")
-            : path.join(paths.homeDir, ".claude", "skills"));
-    }
-    if (providers.includes("cursor")) {
-        targets.add(paths.scope === "local"
-            ? path.join(paths.workspaceRoot, ".cursor", "skills")
-            : path.join(paths.homeDir, ".cursor", "skills"));
-    }
-    return [...targets];
-}
 function enforceProviderSkillsSymlink(options) {
     const resolvedCanonical = realPathOrResolved(options.canonicalSkillsDir);
     const targetDir = options.targetSkillsDir;

package/dist/core/version-notifier.d.ts

@@ -1,9 +1,19 @@
 type MaybeNotifyOptions = {
     command: string;
+    argv: string[];
     packageName?: string;
     currentVersion: string;
 };
+export type UpgradeResult = "updated" | "already-latest" | "failed" | "unavailable";
 export declare function maybeNotifyVersionUpdate(options: MaybeNotifyOptions): Promise<void>;
+export declare function upgradeToLatest(options: {
+    currentVersion: string;
+    packageName?: string;
+}): Promise<UpgradeResult>;
 export declare function isNewerVersion(candidate: string, current: string): boolean;
-export declare function promptAndUpdate(current: string, latest: string): Promise<"updated" | "declined" | "failed">;
+export declare function promptAndUpdate(current: string, latest: string, options?: {
+    packageName?: string;
+    rerunArgs?: string[];
+}): Promise<"updated" | "already-latest" | "failed">;
+export declare function maybeConfirmAutoUpgrade(current: string, latest: string): Promise<boolean>;
 export {};

package/dist/core/version-notifier.js

@@ -6,50 +6,73 @@ import path from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
 import { ensureDir, writeJsonAtomic } from "./fs.js";
 const UPDATE_CACHE_PATH = path.join(os.homedir(), ".agents", ".agentloom-version-cache.json");
-const CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
+const CHECK_INTERVAL_MS = 2 * 60 * 60 * 1000;
 const REQUEST_TIMEOUT_MS = 1800;
+const DISABLE_UPDATE_ENV = "AGENTLOOM_DISABLE_UPDATE_NOTIFIER";
+const SKIP_COMMANDS = new Set([
+    "help",
+    "--help",
+    "-h",
+    "version",
+    "--version",
+    "-v",
+    "upgrade",
+]);
 export async function maybeNotifyVersionUpdate(options) {
-    if (process.env.AGENTLOOM_DISABLE_UPDATE_NOTIFIER === "1")
+    if (process.env[DISABLE_UPDATE_ENV] === "1")
         return;
-    if (!process.stdout.isTTY || !process.stderr.isTTY)
+    const loweredCommand = options.command.trim().toLowerCase();
+    if (SKIP_COMMANDS.has(loweredCommand))
         return;
-    const loweredCommand = options.command.toLowerCase();
-    if (loweredCommand === "help" ||
-        loweredCommand === "--help" ||
-        loweredCommand === "-h" ||
-        loweredCommand === "version" ||
-        loweredCommand === "--version" ||
-        loweredCommand === "-v") {
-        return;
-    }
     const packageName = options.packageName ?? "agentloom";
     const cache = readVersionCache();
-    if (cache.latestVersion &&
-        isNewerVersion(cache.latestVersion, options.currentVersion) &&
-        cache.lastNotifiedVersion !== cache.latestVersion) {
-        await promptAndUpdate(options.currentVersion, cache.latestVersion);
-        cache.lastNotifiedVersion = cache.latestVersion;
-        writeVersionCache(cache);
-    }
+    const latest = await resolveLatestVersion({
+        packageName,
+        cache,
+        forceFetch: false,
+    });
+    if (!latest)
+        return;
+    if (!isNewerVersion(latest, options.currentVersion))
+        return;
     const now = Date.now();
-    const lastChecked = parseTime(cache.lastCheckedAt);
-    if (lastChecked && now - lastChecked < CHECK_INTERVAL_MS) {
+    if (!shouldAttemptAutoUpgrade(cache, latest, now)) {
         return;
     }
-    const latest = await fetchLatestVersion(packageName);
-    if (!latest) {
-        cache.lastCheckedAt = new Date(now).toISOString();
+    const approved = await maybeConfirmAutoUpgrade(options.currentVersion, latest);
+    if (!approved) {
+        recordUpgradeAttempt(cache, latest, now);
         writeVersionCache(cache);
         return;
     }
-    cache.lastCheckedAt = new Date(now).toISOString();
-    cache.latestVersion = latest;
-    if (isNewerVersion(latest, options.currentVersion) &&
-        cache.lastNotifiedVersion !== latest) {
-        await promptAndUpdate(options.currentVersion, latest);
-        cache.lastNotifiedVersion = latest;
+    // Persist attempt before upgrade/rerun, because rerun success paths can exit the process.
+    recordUpgradeAttempt(cache, latest, now);
+    writeVersionCache(cache);
+    await promptAndUpdate(options.currentVersion, latest, {
+        packageName,
+        rerunArgs: options.argv,
+    });
+}
+export async function upgradeToLatest(options) {
+    const packageName = options.packageName ?? "agentloom";
+    const cache = readVersionCache();
+    const latest = await resolveLatestVersion({
+        packageName,
+        cache,
+        forceFetch: true,
+    });
+    if (!latest)
+        return "unavailable";
+    if (!isNewerVersion(latest, options.currentVersion)) {
+        return "already-latest";
     }
+    const result = await promptAndUpdate(options.currentVersion, latest, {
+        packageName,
+    });
+    const now = Date.now();
+    recordUpgradeAttempt(cache, latest, now);
     writeVersionCache(cache);
+    return result;
 }
 export function isNewerVersion(candidate, current) {
     const next = parseSemver(candidate);
@@ -111,24 +134,54 @@ function fetchLatestVersion(packageName) {
         req.on("error", () => resolve(null));
     });
 }
-export async function promptAndUpdate(current, latest) {
-    const accepted = await confirm({
-        message: `Update available: ${current} → ${latest}. Update now?`,
-        initialValue: true,
+export async function promptAndUpdate(current, latest, options = {}) {
+    if (!isNewerVersion(latest, current))
+        return "already-latest";
+    const packageName = options.packageName ?? "agentloom";
+    const rerunArgs = options.rerunArgs ?? [];
+    if (rerunArgs.length > 0 && isLikelyNpxExecution()) {
+        if (!canRunPackageViaNpx(packageName, latest)) {
+            console.error("\nAutomatic npx upgrade is currently unavailable; continuing with current version.\n");
+            return "failed";
+        }
+        console.log(`\nUpdate available: ${current} → ${latest}. Re-running with npx ${packageName}@${latest}...\n`);
+        const rerun = spawnSync("npx", ["--yes", `${packageName}@${latest}`, ...rerunArgs], {
+            stdio: "inherit",
+            env: buildChildEnv(),
+        });
+        if (rerun.error || rerun.status === null) {
+            console.error("\nAutomatic npx rerun failed after upgrade. Please run your command again.\n");
+            process.exit(1);
+            return "failed"; // unreachable, but satisfies type checker
+        }
+        process.exit(rerun.status);
+        return rerun.status === 0 ? "updated" : "failed"; // unreachable, but satisfies type checker
+    }
+    console.log(`\nUpdating ${packageName} ${current} → ${latest}...\n`);
+    const install = spawnSync("npm", ["i", "-g", `${packageName}@${latest}`], {
+        stdio: "inherit",
     });
-    if (isCancel(accepted) || !accepted)
-        return "declined";
-    console.log(`\nUpdating agentloom to ${latest}...\n`);
-    const result = spawnSync("npm", ["i", "-g", "agentloom"], {
+    if (install.status !== 0) {
+        console.error("\nAutomatic upgrade failed. Run `agentloom upgrade` to retry.\n");
+        return "failed";
+    }
+    if (rerunArgs.length === 0) {
+        console.log(`\nUpdated to ${latest}.\n`);
+        return "updated";
+    }
+    console.log(`\nUpdated to ${latest}. Re-running your command...\n`);
+    const invocation = buildRerunInvocation(rerunArgs);
+    const rerun = spawnSync(invocation.command, invocation.args, {
         stdio: "inherit",
+        env: buildChildEnv(),
     });
-    if (result.status === 0) {
-        console.log(`\nUpdated to ${latest}. Please re-run your command.\n`);
-        process.exit(0);
-        return "updated"; // unreachable, but satisfies type checker
+    if (rerun.error || rerun.status === null) {
+        console.error("\nAutomatic rerun failed after upgrade. Please run your command again.\n");
+        process.exit(1);
+        return "failed"; // unreachable, but satisfies type checker
     }
-    console.error(`\nUpdate failed. You can update manually: npm i -g agentloom\n`);
-    return "failed";
+    process.exit(rerun.status);
+    return "updated"; // unreachable, but satisfies type checker
 }
 function readVersionCache() {
     try {
@@ -158,3 +211,85 @@ function parseTime(value) {
         return null;
     return parsed;
 }
+async function resolveLatestVersion(options) {
+    const now = Date.now();
+    const lastChecked = parseTime(options.cache.lastCheckedAt);
+    const shouldFetch = options.forceFetch ||
+        !lastChecked ||
+        now - lastChecked >= CHECK_INTERVAL_MS;
+    if (!shouldFetch) {
+        return options.cache.latestVersion ?? null;
+    }
+    const fetched = await fetchLatestVersion(options.packageName);
+    options.cache.lastCheckedAt = new Date(now).toISOString();
+    if (fetched) {
+        options.cache.latestVersion = fetched;
+    }
+    writeVersionCache(options.cache);
+    if (options.forceFetch) {
+        return fetched ?? null;
+    }
+    return fetched ?? options.cache.latestVersion ?? null;
+}
+function shouldAttemptAutoUpgrade(cache, latest, now) {
+    const lastAttemptVersion = cache.lastUpgradeAttemptVersion ?? cache.lastAutoUpgradeVersion;
+    if (lastAttemptVersion !== latest)
+        return true;
+    const lastAttempt = parseTime(cache.lastUpgradeAttemptAt ?? cache.lastAutoUpgradeAt);
+    if (!lastAttempt)
+        return true;
+    return now - lastAttempt >= CHECK_INTERVAL_MS;
+}
+function isLikelyNpxExecution() {
+    const npmCommand = process.env.npm_command?.trim().toLowerCase();
+    if (npmCommand === "exec")
+        return true;
+    const argv1 = process.argv[1];
+    if (typeof argv1 !== "string" || argv1.length === 0)
+        return false;
+    return argv1.includes(`${path.sep}_npx${path.sep}`);
+}
+function buildChildEnv() {
+    return {
+        ...process.env,
+        [DISABLE_UPDATE_ENV]: "1",
+    };
+}
+export async function maybeConfirmAutoUpgrade(current, latest) {
+    if (!isInteractiveTty())
+        return true;
+    const approved = await confirm({
+        message: `Update available: ${current} → ${latest}. Upgrade now and re-run your command?`,
+        initialValue: true,
+    });
+    if (isCancel(approved) || approved !== true)
+        return false;
+    return true;
+}
+function isInteractiveTty() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY && process.stderr.isTTY);
+}
+function recordUpgradeAttempt(cache, latest, now) {
+    cache.lastUpgradeAttemptVersion = latest;
+    cache.lastUpgradeAttemptAt = new Date(now).toISOString();
+}
+function canRunPackageViaNpx(packageName, version) {
+    const probe = spawnSync("npx", ["--yes", `${packageName}@${version}`, "--version"], {
+        stdio: "ignore",
+        env: buildChildEnv(),
+    });
+    return !probe.error && probe.status === 0;
+}
+function buildRerunInvocation(rerunArgs) {
+    const scriptPath = process.argv[1];
+    if (typeof scriptPath === "string" && scriptPath.trim().length > 0) {
+        return {
+            command: process.execPath,
+            args: [...process.execArgv, scriptPath, ...rerunArgs],
+        };
+    }
+    return {
+        command: "agentloom",
+        args: rerunArgs,
+    };
+}