agentikit 0.0.8 → 0.0.12

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

@@ -0,0 +1,27 @@
+import type { RegistrySearchResponse } from "./registry-types";
+export interface RegistryIndex {
+    version: number;
+    updatedAt: string;
+    kits: RegistryKitEntry[];
+}
+export interface RegistryKitEntry {
+    id: string;
+    name: string;
+    description?: string;
+    ref: string;
+    source: "npm" | "github" | "git";
+    homepage?: string;
+    tags?: string[];
+    assetTypes?: string[];
+    author?: string;
+    license?: string;
+    latestVersion?: string;
+    /** Whether this entry was manually reviewed and approved */
+    curated?: boolean;
+}
+export interface RegistrySearchOptions {
+    limit?: number;
+    /** Override registry URL(s). Accepts a single URL or an array. */
+    registryUrls?: string | string[];
+}
+export declare function searchRegistry(query: string, options?: RegistrySearchOptions): Promise<RegistrySearchResponse>;

package/dist/src/registry-search.js

@@ -0,0 +1,263 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fetchWithTimeout } from "./common";
+// ── Constants ───────────────────────────────────────────────────────────────
+/** Default registry index URL. Override via config or AKM_REGISTRY_URL env var. */
+const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/itlackey/agentikit-registry/main/index.json";
+/** Cache TTL in milliseconds (1 hour). */
+const CACHE_TTL_MS = 60 * 60 * 1000;
+/** Maximum age before cache is considered stale but still usable as fallback (7 days). */
+const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
+// ── Public API ──────────────────────────────────────────────────────────────
+export async function searchRegistry(query, options) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+        return { query: "", hits: [], warnings: [] };
+    }
+    const limit = clampLimit(options?.limit);
+    const urls = resolveRegistryUrls(options?.registryUrls);
+    const warnings = [];
+    // Load index from all configured registries, merge kits
+    const allKits = [];
+    for (const url of urls) {
+        try {
+            const index = await loadIndex(url);
+            if (index) {
+                allKits.push(...index.kits);
+            }
+        }
+        catch (err) {
+            warnings.push(`Registry ${url}: ${toErrorMessage(err)}`);
+        }
+    }
+    // Score and rank
+    const hits = scoreKits(allKits, trimmed, limit);
+    return { query: trimmed, hits, warnings };
+}
+// ── Index loading with cache ────────────────────────────────────────────────
+async function loadIndex(url) {
+    const cachePath = indexCachePath(url);
+    const cached = readCachedIndex(cachePath);
+    // Fresh cache: return immediately
+    if (cached && !isCacheExpired(cached.mtime)) {
+        return cached.index;
+    }
+    // Try to fetch fresh index
+    try {
+        const response = await fetchWithTimeout(url, undefined, 10_000);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = (await response.json());
+        const index = parseRegistryIndex(data);
+        if (index) {
+            writeCachedIndex(cachePath, index);
+            return index;
+        }
+        throw new Error("Invalid registry index format");
+    }
+    catch (err) {
+        // Fetch failed — use stale cache if available
+        if (cached && !isCacheStale(cached.mtime)) {
+            return cached.index;
+        }
+        throw err;
+    }
+}
+function readCachedIndex(cachePath) {
+    try {
+        const stat = fs.statSync(cachePath);
+        const raw = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+        const index = parseRegistryIndex(raw);
+        if (!index)
+            return null;
+        return { index, mtime: stat.mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+function writeCachedIndex(cachePath, index) {
+    try {
+        const dir = path.dirname(cachePath);
+        fs.mkdirSync(dir, { recursive: true });
+        const tmpPath = cachePath + `.tmp.${process.pid}`;
+        fs.writeFileSync(tmpPath, JSON.stringify(index), "utf8");
+        fs.renameSync(tmpPath, cachePath);
+    }
+    catch {
+        // Best-effort caching — don't fail the search if we can't write
+    }
+}
+function indexCachePath(url) {
+    const cacheRoot = resolveCacheDir();
+    // Deterministic filename from URL
+    const slug = url
+        .replace(/[^a-zA-Z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 120);
+    return path.join(cacheRoot, "registry-index", `${slug}.json`);
+}
+function resolveCacheDir() {
+    const xdgCache = process.env.XDG_CACHE_HOME?.trim();
+    if (xdgCache)
+        return path.join(path.resolve(xdgCache), "agentikit");
+    const home = process.env.HOME?.trim();
+    if (!home)
+        return path.join("/tmp", "agentikit-cache");
+    return path.join(path.resolve(home), ".cache", "agentikit");
+}
+function isCacheExpired(mtimeMs) {
+    return Date.now() - mtimeMs > CACHE_TTL_MS;
+}
+function isCacheStale(mtimeMs) {
+    return Date.now() - mtimeMs > CACHE_STALE_MS;
+}
+// ── Index parsing ───────────────────────────────────────────────────────────
+function parseRegistryIndex(data) {
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+        return null;
+    const obj = data;
+    if (typeof obj.version !== "number" || obj.version !== 1)
+        return null;
+    if (typeof obj.updatedAt !== "string")
+        return null;
+    if (!Array.isArray(obj.kits))
+        return null;
+    const kits = obj.kits.flatMap((raw) => {
+        const kit = parseKitEntry(raw);
+        return kit ? [kit] : [];
+    });
+    return { version: 1, updatedAt: obj.updatedAt, kits };
+}
+function parseKitEntry(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const id = asString(obj.id);
+    const name = asString(obj.name);
+    const ref = asString(obj.ref);
+    const source = asSource(obj.source);
+    if (!id || !name || !ref || !source)
+        return null;
+    return {
+        id,
+        name,
+        ref,
+        source,
+        description: asString(obj.description),
+        homepage: asString(obj.homepage),
+        tags: asStringArray(obj.tags),
+        assetTypes: asStringArray(obj.assetTypes),
+        author: asString(obj.author),
+        license: asString(obj.license),
+        latestVersion: asString(obj.latestVersion),
+        curated: obj.curated === true ? true : undefined,
+    };
+}
+// ── Scoring ─────────────────────────────────────────────────────────────────
+function scoreKits(kits, query, limit) {
+    const tokens = query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+    const scored = [];
+    for (const kit of kits) {
+        const score = scoreKit(kit, tokens);
+        if (score > 0) {
+            scored.push({ kit, score });
+        }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map(({ kit, score }) => toSearchHit(kit, score));
+}
+function scoreKit(kit, tokens) {
+    let score = 0;
+    const nameLower = kit.name.toLowerCase();
+    const descLower = (kit.description ?? "").toLowerCase();
+    const tagsLower = (kit.tags ?? []).map((t) => t.toLowerCase());
+    for (const token of tokens) {
+        // Exact name match is strongest signal
+        if (nameLower === token) {
+            score += 1.0;
+        }
+        else if (nameLower.includes(token)) {
+            score += 0.6;
+        }
+        // Tag matches are high-signal (curated keywords)
+        if (tagsLower.some((tag) => tag === token)) {
+            score += 0.5;
+        }
+        else if (tagsLower.some((tag) => tag.includes(token))) {
+            score += 0.25;
+        }
+        // Description substring
+        if (descLower.includes(token)) {
+            score += 0.2;
+        }
+        // Author match
+        if (kit.author?.toLowerCase().includes(token)) {
+            score += 0.15;
+        }
+    }
+    // Normalize by token count so multi-word queries don't inflate scores
+    return tokens.length > 0 ? score / tokens.length : 0;
+}
+function toSearchHit(kit, score) {
+    const metadata = {};
+    if (kit.latestVersion)
+        metadata.version = kit.latestVersion;
+    if (kit.author)
+        metadata.author = kit.author;
+    if (kit.license)
+        metadata.license = kit.license;
+    if (kit.assetTypes?.length)
+        metadata.assetTypes = kit.assetTypes.join(", ");
+    return {
+        source: kit.source,
+        id: kit.id,
+        title: kit.name,
+        description: kit.description,
+        ref: kit.ref,
+        homepage: kit.homepage,
+        score: Math.round(score * 1000) / 1000,
+        metadata,
+        curated: kit.curated,
+    };
+}
+// ── Registry URL resolution ─────────────────────────────────────────────────
+function resolveRegistryUrls(override) {
+    if (override) {
+        const urls = Array.isArray(override) ? override : [override];
+        return urls.filter(Boolean);
+    }
+    // Allow env var override (comma-separated)
+    const envUrls = process.env.AKM_REGISTRY_URL?.trim();
+    if (envUrls) {
+        return envUrls.split(",").map((u) => u.trim()).filter(Boolean);
+    }
+    return [DEFAULT_REGISTRY_URL];
+}
+// ── Utilities ───────────────────────────────────────────────────────────────
+function clampLimit(limit) {
+    if (!limit || !Number.isFinite(limit))
+        return 20;
+    return Math.min(100, Math.max(1, Math.trunc(limit)));
+}
+function asString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function asSource(value) {
+    return value === "npm" || value === "github" || value === "git"
+        ? value
+        : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const filtered = value.filter((v) => typeof v === "string");
+    return filtered.length > 0 ? filtered : undefined;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -0,0 +1,62 @@
+export type RegistrySource = "npm" | "github" | "git";
+export interface RegistryRefBase {
+    source: RegistrySource;
+    ref: string;
+    id: string;
+}
+export interface ParsedNpmRef extends RegistryRefBase {
+    source: "npm";
+    packageName: string;
+    requestedVersionOrTag?: string;
+}
+export interface ParsedGithubRef extends RegistryRefBase {
+    source: "github";
+    owner: string;
+    repo: string;
+    requestedRef?: string;
+}
+export interface ParsedGitRef extends RegistryRefBase {
+    source: "git";
+    repoRoot: string;
+    sourcePath: string;
+}
+export type ParsedRegistryRef = ParsedNpmRef | ParsedGithubRef | ParsedGitRef;
+export interface ResolvedRegistryArtifact {
+    id: string;
+    source: RegistrySource;
+    ref: string;
+    artifactUrl: string;
+    resolvedVersion?: string;
+    resolvedRevision?: string;
+}
+export interface RegistryInstalledEntry {
+    id: string;
+    source: RegistrySource;
+    ref: string;
+    resolvedVersion?: string;
+    resolvedRevision?: string;
+    artifactUrl: string;
+    stashRoot: string;
+    cacheDir: string;
+    installedAt: string;
+}
+export interface RegistryInstallResult extends RegistryInstalledEntry {
+    extractedDir: string;
+}
+export interface RegistrySearchHit {
+    source: RegistrySource;
+    id: string;
+    title: string;
+    description?: string;
+    ref: string;
+    homepage?: string;
+    score?: number;
+    metadata?: Record<string, string>;
+    /** Whether this entry was manually reviewed and approved */
+    curated?: boolean;
+}
+export interface RegistrySearchResponse {
+    query: string;
+    hits: RegistrySearchHit[];
+    warnings: string[];
+}

package/dist/src/registry-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import type { AddResponse } from "./stash-types";
+export declare function agentikitAdd(input: {
+    ref: string;
+}): Promise<AddResponse>;

package/dist/src/stash-add.js

@@ -0,0 +1,59 @@
+import { agentikitIndex } from "./indexer";
+import fs from "node:fs";
+import { resolveStashDir } from "./common";
+import { loadConfig } from "./config";
+import { upsertInstalledRegistryEntry, installRegistryRef } from "./registry-install";
+export async function agentikitAdd(input) {
+    const ref = input.ref.trim();
+    if (!ref)
+        throw new Error("Install ref or local git directory is required.");
+    const stashDir = resolveStashDir();
+    const installed = await installRegistryRef(ref);
+    const replaced = loadConfig().registry?.installed.find((entry) => entry.id === installed.id);
+    const config = upsertInstalledRegistryEntry({
+        id: installed.id,
+        source: installed.source,
+        ref: installed.ref,
+        artifactUrl: installed.artifactUrl,
+        resolvedVersion: installed.resolvedVersion,
+        resolvedRevision: installed.resolvedRevision,
+        stashRoot: installed.stashRoot,
+        cacheDir: installed.cacheDir,
+        installedAt: installed.installedAt,
+    });
+    if (replaced && replaced.cacheDir !== installed.cacheDir) {
+        try {
+            fs.rmSync(replaced.cacheDir, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+    }
+    const index = await agentikitIndex({ stashDir });
+    return {
+        stashDir,
+        ref,
+        installed: {
+            id: installed.id,
+            source: installed.source,
+            ref: installed.ref,
+            artifactUrl: installed.artifactUrl,
+            resolvedVersion: installed.resolvedVersion,
+            resolvedRevision: installed.resolvedRevision,
+            stashRoot: installed.stashRoot,
+            cacheDir: installed.cacheDir,
+            extractedDir: installed.extractedDir,
+            installedAt: installed.installedAt,
+        },
+        config: {
+            mountedStashDirs: config.mountedStashDirs,
+            installedRegistryCount: config.registry?.installed.length ?? 0,
+        },
+        index: {
+            mode: index.mode,
+            totalEntries: index.totalEntries,
+            directoriesScanned: index.directoriesScanned,
+            directoriesSkipped: index.directoriesSkipped,
+        },
+    };
+}

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

@@ -0,0 +1,22 @@
+import { type StashSourceKind } from "./stash-source";
+export interface CloneOptions {
+    /** Source ref (e.g., npm:@scope/pkg//tool:deploy.sh) */
+    sourceRef: string;
+    /** Optional new name for the cloned asset */
+    newName?: string;
+    /** If true, overwrite existing asset in working stash */
+    force?: boolean;
+}
+export interface CloneResponse {
+    source: {
+        path: string;
+        sourceKind: StashSourceKind;
+        registryId?: string;
+    };
+    destination: {
+        path: string;
+        ref: string;
+    };
+    overwritten: boolean;
+}
+export declare function agentikitClone(options: CloneOptions): Promise<CloneResponse>;

package/dist/src/stash-clone.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import { TYPE_DIRS } from "./asset-spec";
+import { parseAssetRef, makeAssetRef } from "./stash-ref";
+import { resolveSourcesForOrigin } from "./origin-resolve";
+import { resolveAssetPath } from "./stash-resolve";
+import { resolveStashSources, findSourceForPath } from "./stash-source";
+export async function agentikitClone(options) {
+    const parsed = parseAssetRef(options.sourceRef);
+    const allSources = resolveStashSources();
+    const workingSource = allSources.find((s) => s.kind === "working");
+    if (!workingSource) {
+        throw new Error("No working stash configured. Run `akm init` first.");
+    }
+    const searchSources = resolveSourcesForOrigin(parsed.origin, allSources);
+    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) {
+        throw lastError ?? new Error(`Source asset not found for ref: ${options.sourceRef}`);
+    }
+    const sourceSource = findSourceForPath(sourcePath, allSources);
+    const sourceKind = sourceSource?.kind ?? "working";
+    const destName = options.newName ?? parsed.name;
+    const typeDir = TYPE_DIRS[parsed.type];
+    const workingDir = workingSource.path;
+    // Guard against self-clone
+    if (parsed.type === "skill") {
+        const sourceSkillDir = path.resolve(path.dirname(sourcePath));
+        const destSkillDir = path.resolve(path.join(workingDir, 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(workingDir, 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(workingDir, typeDir, destName);
+        const overwritten = fs.existsSync(destSkillDir);
+        if (overwritten && !options.force) {
+            throw new Error(`Asset already exists in working stash: ${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, sourceKind, registryId: sourceSource?.registryId },
+            destination: { path: destPath, ref },
+            overwritten,
+        };
+    }
+    destPath = path.join(workingDir, typeDir, destName);
+    const overwritten = fs.existsSync(destPath);
+    if (overwritten && !options.force) {
+        throw new Error(`Asset already exists in working stash: ${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, sourceKind, registryId: sourceSource?.registryId },
+        destination: { path: destPath, ref },
+        overwritten,
+    };
+}

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

@@ -1,7 +1,31 @@
 import { type AgentikitAssetType } from "./common";
-export interface OpenRef {
+export interface AssetRef {
     type: AgentikitAssetType;
     name: string;
+    /**
+     * Where to find this asset.
+     *   - undefined: search all sources (working → mounted → installed)
+     *   - "local": working stash only
+     *   - registry ref: e.g. "npm:@scope/pkg", "owner/repo", "github:owner/repo#v1"
+     *   - filesystem path: e.g. "/mnt/shared-stash"
+     */
+    origin?: string;
 }
-export declare function parseOpenRef(ref: string): OpenRef;
-export declare function makeOpenRef(type: AgentikitAssetType, name: string): string;
+/**
+ * Build a ref string from components.
+ *
+ * Examples:
+ *   makeAssetRef("tool", "deploy.sh")
+ *     → "tool:deploy.sh"
+ *   makeAssetRef("tool", "deploy.sh", "npm:@scope/pkg")
+ *     → "npm:@scope/pkg//tool:deploy.sh"
+ *   makeAssetRef("skill", "code-review", "local")
+ *     → "local//skill:code-review"
+ *   makeAssetRef("tool", "db/migrate/run.sh", "owner/repo")
+ *     → "owner/repo//tool:db/migrate/run.sh"
+ */
+export declare function makeAssetRef(type: AgentikitAssetType, name: string, origin?: string): string;
+/**
+ * Parse a ref string in the format `[origin//]type:name`.
+ */
+export declare function parseAssetRef(ref: string): AssetRef;

package/dist/src/stash-ref.js

@@ -1,33 +1,72 @@
 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}".`);
+// ── Construction ────────────────────────────────────────────────────────────
+/**
+ * Build a ref string from components.
+ *
+ * Examples:
+ *   makeAssetRef("tool", "deploy.sh")
+ *     → "tool:deploy.sh"
+ *   makeAssetRef("tool", "deploy.sh", "npm:@scope/pkg")
+ *     → "npm:@scope/pkg//tool:deploy.sh"
+ *   makeAssetRef("skill", "code-review", "local")
+ *     → "local//skill:code-review"
+ *   makeAssetRef("tool", "db/migrate/run.sh", "owner/repo")
+ *     → "owner/repo//tool:db/migrate/run.sh"
+ */
+export function makeAssetRef(type, name, origin) {
+    validateName(name);
+    const normalized = normalizeName(name);
+    const asset = `${type}:${normalized}`;
+    if (!origin)
+        return asset;
+    return `${origin}//${asset}`;
+}
+// ── Parsing ─────────────────────────────────────────────────────────────────
+/**
+ * Parse a ref string in the format `[origin//]type:name`.
+ */
+export function parseAssetRef(ref) {
+    const trimmed = ref.trim();
+    if (!trimmed)
+        throw new Error("Empty ref.");
+    let origin;
+    let body = trimmed;
+    const boundary = trimmed.indexOf("//");
+    if (boundary >= 0) {
+        origin = trimmed.slice(0, boundary);
+        body = trimmed.slice(boundary + 2);
+        if (!origin)
+            throw new Error("Empty origin in ref.");
     }
-    let name;
-    try {
-        name = decodeURIComponent(rawName);
+    const colon = body.indexOf(":");
+    if (colon <= 0) {
+        throw new Error(`Invalid ref "${trimmed}". Expected [origin//]type:name`);
     }
-    catch {
-        throw new Error("Invalid open ref encoding.");
+    const rawType = body.slice(0, colon);
+    const rawName = body.slice(colon + 1);
+    if (!isAssetType(rawType)) {
+        throw new Error(`Invalid asset type: "${rawType}".`);
     }
+    validateName(rawName);
+    const name = normalizeName(rawName);
+    return { type: rawType, name, origin: origin || undefined };
+}
+// ── Validation ──────────────────────────────────────────────────────────────
+function validateName(name) {
+    if (!name)
+        throw new Error("Empty asset name.");
+    if (name.includes("\0"))
+        throw new Error("Null byte in asset name.");
+    if (/^[A-Za-z]:/.test(name))
+        throw new Error("Windows drive path in asset name.");
     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.");
+    if (path.posix.isAbsolute(normalized))
+        throw new Error("Absolute path in asset name.");
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error("Path traversal in asset name.");
     }
-    return { type: rawType, name: normalized };
 }
-export function makeOpenRef(type, name) {
-    return `${type}:${encodeURIComponent(name)}`;
+function normalizeName(name) {
+    return path.posix.normalize(name.replace(/\\/g, "/"));
 }

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>;