agentikit 0.0.13 → 0.0.15

package/dist/stash-clone.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+import { TYPE_DIRS } from "./asset-spec";
+import { isRemoteOrigin, resolveSourcesForOrigin } from "./origin-resolve";
+import { installRegistryRef } from "./registry-install";
+import { makeAssetRef, parseAssetRef } from "./stash-ref";
+import { resolveAssetPath } from "./stash-resolve";
+import { findSourceForPath, getPrimarySource, resolveStashSources } from "./stash-source";
+export async function agentikitClone(options) {
+    const parsed = parseAssetRef(options.sourceRef);
+    // When --dest is provided, the working stash is optional
+    let allSources;
+    try {
+        allSources = resolveStashSources();
+    }
+    catch (err) {
+        if (options.dest) {
+            allSources = [];
+        }
+        else {
+            throw err;
+        }
+    }
+    const primarySource = getPrimarySource(allSources);
+    const destRoot = options.dest ? path.resolve(options.dest) : primarySource?.path;
+    if (!destRoot) {
+        throw new Error("No working stash configured and no --dest provided. Run `akm init` or pass --dest.");
+    }
+    let searchSources = resolveSourcesForOrigin(parsed.origin, allSources);
+    // Remote fetch fallback: if no local source matched and origin looks remote, fetch it
+    let remoteFetched;
+    if (searchSources.length === 0 && parsed.origin && isRemoteOrigin(parsed.origin, allSources)) {
+        const installResult = await installRegistryRef(parsed.origin);
+        const syntheticSource = {
+            path: installResult.stashRoot,
+            registryId: installResult.id,
+        };
+        searchSources = [syntheticSource];
+        allSources = [...allSources, syntheticSource];
+        remoteFetched = {
+            origin: parsed.origin,
+            stashRoot: installResult.stashRoot,
+            cacheDir: installResult.cacheDir,
+        };
+    }
+    let sourcePath;
+    let lastError;
+    for (const source of searchSources) {
+        try {
+            sourcePath = resolveAssetPath(source.path, parsed.type, parsed.name);
+            break;
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+        }
+    }
+    if (!sourcePath) {
+        const context = remoteFetched ? ` (remote package fetched but asset not found inside it)` : "";
+        throw lastError ?? new Error(`Source asset not found for ref: ${options.sourceRef}${context}`);
+    }
+    const sourceSource = findSourceForPath(sourcePath, allSources);
+    const destName = options.newName ?? parsed.name;
+    const typeDir = TYPE_DIRS[parsed.type];
+    const destLabel = options.dest ? "at destination" : "in working stash";
+    // Guard against self-clone
+    if (parsed.type === "skill") {
+        const sourceSkillDir = path.resolve(path.dirname(sourcePath));
+        const destSkillDir = path.resolve(path.join(destRoot, typeDir, destName));
+        if (sourceSkillDir === destSkillDir) {
+            throw new Error(`Source and destination are the same path. Use --name to provide a new name for the clone.`);
+        }
+    }
+    else {
+        const resolvedSource = path.resolve(sourcePath);
+        const resolvedDest = path.resolve(path.join(destRoot, typeDir, destName));
+        if (resolvedSource === resolvedDest) {
+            throw new Error(`Source and destination are the same path. Use --name to provide a new name for the clone.`);
+        }
+    }
+    let destPath;
+    if (parsed.type === "skill") {
+        const sourceSkillDir = path.dirname(sourcePath);
+        const destSkillDir = path.join(destRoot, typeDir, destName);
+        const overwritten = fs.existsSync(destSkillDir);
+        if (overwritten && !options.force) {
+            throw new Error(`Asset already exists ${destLabel}: ${destSkillDir}. Use --force to overwrite.`);
+        }
+        if (overwritten) {
+            fs.rmSync(destSkillDir, { recursive: true, force: true });
+        }
+        fs.cpSync(sourceSkillDir, destSkillDir, { recursive: true });
+        destPath = path.join(destSkillDir, "SKILL.md");
+        const ref = makeAssetRef(parsed.type, destName, "local");
+        return {
+            source: { path: sourcePath, registryId: sourceSource?.registryId },
+            destination: { path: destPath, ref },
+            overwritten,
+            ...(remoteFetched ? { remoteFetched } : {}),
+        };
+    }
+    destPath = path.join(destRoot, typeDir, destName);
+    const overwritten = fs.existsSync(destPath);
+    if (overwritten && !options.force) {
+        throw new Error(`Asset already exists ${destLabel}: ${destPath}. Use --force to overwrite.`);
+    }
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.copyFileSync(sourcePath, destPath);
+    const ref = makeAssetRef(parsed.type, destName, "local");
+    return {
+        source: { path: sourcePath, registryId: sourceSource?.registryId },
+        destination: { path: destPath, ref },
+        overwritten,
+        ...(remoteFetched ? { remoteFetched } : {}),
+    };
+}

package/dist/{src/stash-ref.js → stash-ref.js}

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { isAssetType } from "./common";
+import { UsageError } from "./errors";
 // ── Construction ────────────────────────────────────────────────────────────
 /**
  * Build a ref string from components.
@@ -29,7 +30,7 @@ export function makeAssetRef(type, name, origin) {
 export function parseAssetRef(ref) {
     const trimmed = ref.trim();
     if (!trimmed)
-        throw new Error("Empty ref.");
+        throw new UsageError("Empty ref.");
     let origin;
     let body = trimmed;
     const boundary = trimmed.indexOf("//");
@@ -37,16 +38,16 @@ export function parseAssetRef(ref) {
         origin = trimmed.slice(0, boundary);
         body = trimmed.slice(boundary + 2);
         if (!origin)
-            throw new Error("Empty origin in ref.");
+            throw new UsageError("Empty origin in ref.");
     }
     const colon = body.indexOf(":");
     if (colon <= 0) {
-        throw new Error(`Invalid ref "${trimmed}". Expected [origin//]type:name`);
+        throw new UsageError(`Invalid ref "${trimmed}". Expected [origin//]type:name`);
     }
     const rawType = body.slice(0, colon);
     const rawName = body.slice(colon + 1);
     if (!isAssetType(rawType)) {
-        throw new Error(`Invalid asset type: "${rawType}".`);
+        throw new UsageError(`Invalid asset type: "${rawType}".`);
     }
     validateName(rawName);
     const name = normalizeName(rawName);
@@ -55,16 +56,16 @@ export function parseAssetRef(ref) {
 // ── Validation ──────────────────────────────────────────────────────────────
 function validateName(name) {
     if (!name)
-        throw new Error("Empty asset name.");
+        throw new UsageError("Empty asset name.");
     if (name.includes("\0"))
-        throw new Error("Null byte in asset name.");
+        throw new UsageError("Null byte in asset name.");
     if (/^[A-Za-z]:/.test(name))
-        throw new Error("Windows drive path in asset name.");
+        throw new UsageError("Windows drive path in asset name.");
     const normalized = path.posix.normalize(name.replace(/\\/g, "/"));
     if (path.posix.isAbsolute(normalized))
-        throw new Error("Absolute path in asset name.");
+        throw new UsageError("Absolute path in asset name.");
     if (normalized === ".." || normalized.startsWith("../")) {
-        throw new Error("Path traversal in asset name.");
+        throw new UsageError("Path traversal in asset name.");
     }
 }
 function normalizeName(name) {

package/dist/{src/stash-registry.js → stash-registry.js}

@@ -1,8 +1,10 @@
 import fs from "node:fs";
 import { resolveStashDir } from "./common";
 import { loadConfig } from "./config";
+import { NotFoundError, UsageError } from "./errors";
 import { agentikitIndex } from "./indexer";
-import { installRegistryRef, removeInstalledRegistryEntry, upsertInstalledRegistryEntry, } from "./registry-install";
+import { removeLockEntry, upsertLockEntry } from "./lockfile";
+import { installRegistryRef, removeInstalledRegistryEntry, upsertInstalledRegistryEntry } from "./registry-install";
 import { parseRegistryRef } from "./registry-resolve";
 export async function agentikitList(input) {
     const stashDir = input?.stashDir ?? resolveStashDir();
@@ -23,12 +25,13 @@ export async function agentikitList(input) {
 export async function agentikitRemove(input) {
     const target = input.target.trim();
     if (!target)
-        throw new Error("Target is required.");
+        throw new UsageError("Target is required.");
     const stashDir = input.stashDir ?? resolveStashDir();
     const config = loadConfig();
     const installed = config.registry?.installed ?? [];
     const entry = resolveInstalledTarget(installed, target);
     const updatedConfig = removeInstalledRegistryEntry(entry.id);
+    removeLockEntry(entry.id);
     cleanupDirectoryBestEffort(entry.cacheDir);
     const index = await agentikitIndex({ stashDir });
     return {
@@ -42,7 +45,7 @@ export async function agentikitRemove(input) {
             stashRoot: entry.stashRoot,
         },
         config: {
-            mountedStashDirs: updatedConfig.mountedStashDirs,
+            searchPaths: updatedConfig.searchPaths,
             installedRegistryCount: updatedConfig.registry?.installed.length ?? 0,
         },
         index: {
@@ -53,56 +56,28 @@ export async function agentikitRemove(input) {
         },
     };
 }
-export async function agentikitReinstall(input) {
+export async function agentikitUpdate(input) {
     const stashDir = input?.stashDir ?? resolveStashDir();
     const target = input?.target?.trim();
     const all = input?.all === true;
+    const force = input?.force === true;
     const installedEntries = loadConfig().registry?.installed ?? [];
     const selectedEntries = selectTargets(installedEntries, target, all);
     const processed = [];
     for (const entry of selectedEntries) {
-        const installed = await installRegistryRef(entry.ref);
-        upsertInstalledRegistryEntry(toInstalledEntry(installed));
-        if (entry.cacheDir !== installed.cacheDir) {
+        if (force) {
             cleanupDirectoryBestEffort(entry.cacheDir);
         }
-        processed.push({
-            id: entry.id,
-            source: entry.source,
-            ref: entry.ref,
-            previousCacheDir: entry.cacheDir,
-            installed: toInstallStatus(installed),
-        });
-    }
-    const index = await agentikitIndex({ stashDir });
-    const config = loadConfig();
-    return {
-        stashDir,
-        target,
-        all,
-        processed,
-        config: {
-            mountedStashDirs: config.mountedStashDirs,
-            installedRegistryCount: config.registry?.installed.length ?? 0,
-        },
-        index: {
-            mode: index.mode,
-            totalEntries: index.totalEntries,
-            directoriesScanned: index.directoriesScanned,
-            directoriesSkipped: index.directoriesSkipped,
-        },
-    };
-}
-export async function agentikitUpdate(input) {
-    const stashDir = input?.stashDir ?? resolveStashDir();
-    const target = input?.target?.trim();
-    const all = input?.all === true;
-    const installedEntries = loadConfig().registry?.installed ?? [];
-    const selectedEntries = selectTargets(installedEntries, target, all);
-    const processed = [];
-    for (const entry of selectedEntries) {
         const installed = await installRegistryRef(entry.ref);
         upsertInstalledRegistryEntry(toInstalledEntry(installed));
+        upsertLockEntry({
+            id: installed.id,
+            source: installed.source,
+            ref: installed.ref,
+            resolvedVersion: installed.resolvedVersion,
+            resolvedRevision: installed.resolvedRevision,
+            integrity: installed.integrity ?? (installed.source === "local" ? "local" : undefined),
+        });
         if (entry.cacheDir !== installed.cacheDir) {
             cleanupDirectoryBestEffort(entry.cacheDir);
         }
@@ -133,7 +108,7 @@ export async function agentikitUpdate(input) {
         all,
         processed,
         config: {
-            mountedStashDirs: config.mountedStashDirs,
+            searchPaths: config.searchPaths,
             installedRegistryCount: config.registry?.installed.length ?? 0,
         },
         index: {
@@ -146,12 +121,12 @@ export async function agentikitUpdate(input) {
 }
 function selectTargets(installed, target, all) {
     if (all && target) {
-        throw new Error("Specify either <target> or --all, not both.");
+        throw new UsageError("Specify either <target> or --all, not both.");
     }
     if (all)
         return installed;
     if (!target) {
-        throw new Error("Either <target> or --all is required.");
+        throw new UsageError("Either <target> or --all is required.");
     }
     return [resolveInstalledTarget(installed, target)];
 }
@@ -174,7 +149,7 @@ function resolveInstalledTarget(installed, target) {
         if (byParsedId)
             return byParsedId;
     }
-    throw new Error(`No installed registry entry matched target: ${target}`);
+    throw new NotFoundError(`No installed registry entry matched target: ${target}`);
 }
 function toInstalledEntry(status) {
     return {

package/dist/{src/stash-resolve.js → stash-resolve.js}

@@ -1,37 +1,38 @@
 import fs from "node:fs";
 import path from "node:path";
+import { isRelevantAssetFile, resolveAssetPathFromName, TYPE_DIRS } from "./asset-spec";
 import { hasErrnoCode, isWithin } from "./common";
-import { TYPE_DIRS, isRelevantAssetFile, resolveAssetPathFromName } from "./asset-spec";
+import { NotFoundError, UsageError } from "./errors";
 export function resolveAssetPath(stashDir, type, name) {
     const root = path.join(stashDir, TYPE_DIRS[type]);
     const target = resolveAssetPathFromName(type, root, name);
     const resolvedRoot = resolveAndValidateTypeRoot(root, type, name);
     const resolvedTarget = path.resolve(target);
     if (!isWithin(resolvedTarget, resolvedRoot)) {
-        throw new Error("Ref resolves outside the stash root.");
+        throw new UsageError("Ref resolves outside the stash root.");
     }
     if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isFile()) {
-        throw new Error(`Stash asset not found for ref: ${type}:${name}`);
+        throw new NotFoundError(`Stash asset not found for ref: ${type}:${name}`);
     }
     const realTarget = fs.realpathSync(resolvedTarget);
     if (!isWithin(realTarget, resolvedRoot)) {
-        throw new Error("Ref resolves outside the stash root.");
+        throw new UsageError("Ref resolves outside the stash root.");
     }
     if (!isRelevantAssetFile(type, path.basename(resolvedTarget))) {
         if (type === "tool") {
-            throw new Error("Tool ref must resolve to a .sh, .ts, .js, .ps1, .cmd, or .bat file.");
+            throw new NotFoundError("Tool ref must resolve to a .sh, .ts, .js, .ps1, .cmd, or .bat file.");
         }
         if (type === "script") {
-            throw new Error("Script ref must resolve to a file with a supported script extension. Refer to the Agentikit documentation for the complete list of supported script extensions.");
+            throw new NotFoundError("Script ref must resolve to a file with a supported script extension. Refer to the Agentikit documentation for the complete list of supported script extensions.");
         }
-        throw new Error(`Stash asset not found for ref: ${type}:${name}`);
+        throw new NotFoundError(`Stash asset not found for ref: ${type}:${name}`);
     }
     return realTarget;
 }
 function resolveAndValidateTypeRoot(root, type, name) {
     const rootStat = readTypeRootStat(root, type, name);
     if (!rootStat.isDirectory()) {
-        throw new Error(`Stash type root is not a directory for ref: ${type}:${name}`);
+        throw new NotFoundError(`Stash type root is not a directory for ref: ${type}:${name}`);
     }
     return fs.realpathSync(root);
 }
@@ -41,7 +42,7 @@ function readTypeRootStat(root, type, name) {
     }
     catch (error) {
         if (hasErrnoCode(error, "ENOENT")) {
-            throw new Error(`Stash type root not found for ref: ${type}:${name}`);
+            throw new NotFoundError(`Stash type root not found for ref: ${type}:${name}`);
         }
         throw error;
     }