agentikit 0.0.7 → 0.0.9

package/dist/src/stash-ref.js

@@ -0,0 +1,33 @@
+import path from "node:path";
+import { isAssetType } from "./common";
+export function parseOpenRef(ref) {
+    const separator = ref.indexOf(":");
+    if (separator <= 0) {
+        throw new Error("Invalid open ref. Expected format '<type>:<name>'.");
+    }
+    const rawType = ref.slice(0, separator);
+    const rawName = ref.slice(separator + 1);
+    if (!isAssetType(rawType)) {
+        throw new Error(`Invalid open ref type: "${rawType}".`);
+    }
+    let name;
+    try {
+        name = decodeURIComponent(rawName);
+    }
+    catch {
+        throw new Error("Invalid open ref encoding.");
+    }
+    const normalized = path.posix.normalize(name.replace(/\\/g, "/"));
+    if (!name
+        || name.includes("\0")
+        || /^[A-Za-z]:/.test(name)
+        || path.posix.isAbsolute(normalized)
+        || normalized === ".."
+        || normalized.startsWith("../")) {
+        throw new Error("Invalid open ref name.");
+    }
+    return { type: rawType, name: normalized };
+}
+export function makeOpenRef(type, name) {
+    return `${type}:${encodeURIComponent(name)}`;
+}

package/dist/src/stash-registry.d.ts

@@ -0,0 +1,18 @@
+import type { ListResponse, RemoveResponse, ReinstallResponse, UpdateResponse } from "./stash-types";
+export declare function agentikitList(input?: {
+    stashDir?: string;
+}): Promise<ListResponse>;
+export declare function agentikitRemove(input: {
+    target: string;
+    stashDir?: string;
+}): Promise<RemoveResponse>;
+export declare function agentikitReinstall(input?: {
+    target?: string;
+    all?: boolean;
+    stashDir?: string;
+}): Promise<ReinstallResponse>;
+export declare function agentikitUpdate(input?: {
+    target?: string;
+    all?: boolean;
+    stashDir?: string;
+}): Promise<UpdateResponse>;

package/dist/src/stash-registry.js

@@ -0,0 +1,221 @@
+import fs from "node:fs";
+import { resolveStashDir } from "./common";
+import { loadConfig } from "./config";
+import { agentikitIndex } from "./indexer";
+import { installRegistryRef, removeInstalledRegistryEntry, upsertInstalledRegistryEntry, } from "./registry-install";
+import { parseRegistryRef } from "./registry-resolve";
+export async function agentikitList(input) {
+    const stashDir = input?.stashDir ?? resolveStashDir();
+    const config = loadConfig(stashDir);
+    const installed = config.registry?.installed ?? [];
+    return {
+        stashDir,
+        installed: installed.map((entry) => ({
+            ...entry,
+            status: {
+                cacheDirExists: directoryExists(entry.cacheDir),
+                stashRootExists: directoryExists(entry.stashRoot),
+            },
+        })),
+        totalInstalled: installed.length,
+    };
+}
+export async function agentikitRemove(input) {
+    const target = input.target.trim();
+    if (!target)
+        throw new Error("Target is required.");
+    const stashDir = input.stashDir ?? resolveStashDir();
+    const config = loadConfig(stashDir);
+    const installed = config.registry?.installed ?? [];
+    const entry = resolveInstalledTarget(installed, target);
+    const updatedConfig = removeInstalledRegistryEntry(entry.id, stashDir);
+    cleanupDirectoryBestEffort(entry.cacheDir);
+    const index = await agentikitIndex({ stashDir });
+    return {
+        stashDir,
+        target,
+        removed: {
+            id: entry.id,
+            source: entry.source,
+            ref: entry.ref,
+            cacheDir: entry.cacheDir,
+            stashRoot: entry.stashRoot,
+        },
+        config: {
+            additionalStashDirs: updatedConfig.additionalStashDirs,
+            installedRegistryCount: updatedConfig.registry?.installed.length ?? 0,
+        },
+        index: {
+            mode: index.mode,
+            totalEntries: index.totalEntries,
+            directoriesScanned: index.directoriesScanned,
+            directoriesSkipped: index.directoriesSkipped,
+        },
+    };
+}
+export async function agentikitReinstall(input) {
+    const stashDir = input?.stashDir ?? resolveStashDir();
+    const target = input?.target?.trim();
+    const all = input?.all === true;
+    const installedEntries = loadConfig(stashDir).registry?.installed ?? [];
+    const selectedEntries = selectTargets(installedEntries, target, all);
+    const processed = [];
+    for (const entry of selectedEntries) {
+        const installed = await installRegistryRef(entry.ref);
+        upsertInstalledRegistryEntry(toInstalledEntry(installed), stashDir);
+        if (entry.cacheDir !== installed.cacheDir) {
+            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(stashDir);
+    return {
+        stashDir,
+        target,
+        all,
+        processed,
+        config: {
+            additionalStashDirs: config.additionalStashDirs,
+            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(stashDir).registry?.installed ?? [];
+    const selectedEntries = selectTargets(installedEntries, target, all);
+    const processed = [];
+    for (const entry of selectedEntries) {
+        const installed = await installRegistryRef(entry.ref);
+        upsertInstalledRegistryEntry(toInstalledEntry(installed), stashDir);
+        if (entry.cacheDir !== installed.cacheDir) {
+            cleanupDirectoryBestEffort(entry.cacheDir);
+        }
+        const versionChanged = (entry.resolvedVersion ?? "") !== (installed.resolvedVersion ?? "");
+        const revisionChanged = (entry.resolvedRevision ?? "") !== (installed.resolvedRevision ?? "");
+        processed.push({
+            id: entry.id,
+            source: entry.source,
+            ref: entry.ref,
+            previous: {
+                resolvedVersion: entry.resolvedVersion,
+                resolvedRevision: entry.resolvedRevision,
+                cacheDir: entry.cacheDir,
+            },
+            installed: toInstallStatus(installed),
+            changed: {
+                version: versionChanged,
+                revision: revisionChanged,
+                any: versionChanged || revisionChanged,
+            },
+        });
+    }
+    const index = await agentikitIndex({ stashDir });
+    const config = loadConfig(stashDir);
+    return {
+        stashDir,
+        target,
+        all,
+        processed,
+        config: {
+            additionalStashDirs: config.additionalStashDirs,
+            installedRegistryCount: config.registry?.installed.length ?? 0,
+        },
+        index: {
+            mode: index.mode,
+            totalEntries: index.totalEntries,
+            directoriesScanned: index.directoriesScanned,
+            directoriesSkipped: index.directoriesSkipped,
+        },
+    };
+}
+function selectTargets(installed, target, all) {
+    if (all && target) {
+        throw new Error("Specify either <target> or --all, not both.");
+    }
+    if (all)
+        return installed;
+    if (!target) {
+        throw new Error("Either <target> or --all is required.");
+    }
+    return [resolveInstalledTarget(installed, target)];
+}
+function resolveInstalledTarget(installed, target) {
+    const byId = installed.find((entry) => entry.id === target);
+    if (byId)
+        return byId;
+    const byRef = installed.find((entry) => entry.ref === target);
+    if (byRef)
+        return byRef;
+    let parsedId;
+    try {
+        parsedId = parseRegistryRef(target).id;
+    }
+    catch {
+        parsedId = undefined;
+    }
+    if (parsedId) {
+        const byParsedId = installed.find((entry) => entry.id === parsedId);
+        if (byParsedId)
+            return byParsedId;
+    }
+    throw new Error(`No installed registry entry matched target: ${target}`);
+}
+function toInstalledEntry(status) {
+    return {
+        id: status.id,
+        source: status.source,
+        ref: status.ref,
+        artifactUrl: status.artifactUrl,
+        resolvedVersion: status.resolvedVersion,
+        resolvedRevision: status.resolvedRevision,
+        stashRoot: status.stashRoot,
+        cacheDir: status.cacheDir,
+        installedAt: status.installedAt,
+    };
+}
+function toInstallStatus(status) {
+    return {
+        id: status.id,
+        source: status.source,
+        ref: status.ref,
+        artifactUrl: status.artifactUrl,
+        resolvedVersion: status.resolvedVersion,
+        resolvedRevision: status.resolvedRevision,
+        stashRoot: status.stashRoot,
+        cacheDir: status.cacheDir,
+        extractedDir: status.extractedDir,
+        installedAt: status.installedAt,
+    };
+}
+function cleanupDirectoryBestEffort(target) {
+    try {
+        fs.rmSync(target, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort cleanup only.
+    }
+}
+function directoryExists(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/stash-resolve.d.ts

@@ -0,0 +1,2 @@
+import { type AgentikitAssetType } from "./common";
+export declare function resolveAssetPath(stashDir: string, type: AgentikitAssetType, name: string): string;

package/dist/src/stash-resolve.js

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+import { hasErrnoCode, isWithin } from "./common";
+import { TYPE_DIRS, isRelevantAssetFile, resolveAssetPathFromName } from "./asset-spec";
+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.");
+    }
+    if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isFile()) {
+        throw new Error(`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.");
+    }
+    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 Error(`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}`);
+    }
+    return fs.realpathSync(root);
+}
+function readTypeRootStat(root, type, name) {
+    try {
+        return fs.statSync(root);
+    }
+    catch (error) {
+        if (hasErrnoCode(error, "ENOENT")) {
+            throw new Error(`Stash type root not found for ref: ${type}:${name}`);
+        }
+        throw error;
+    }
+}

package/dist/src/stash-search.d.ts

@@ -0,0 +1,8 @@
+import type { AgentikitSearchType, SearchResponse, SearchSource, SearchUsageMode } from "./stash-types";
+export declare function agentikitSearch(input: {
+    query: string;
+    type?: AgentikitSearchType;
+    limit?: number;
+    usage?: SearchUsageMode;
+    source?: SearchSource;
+}): Promise<SearchResponse>;