agentikit 0.0.8 → 0.0.9

package/dist/src/registry-install.js

@@ -0,0 +1,208 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { TYPE_DIRS } from "./common";
+import { loadConfig, saveConfig } from "./config";
+import { parseRegistryRef, resolveRegistryArtifact } from "./registry-resolve";
+const REGISTRY_STASH_DIR_NAMES = new Set(Object.values(TYPE_DIRS));
+export async function installRegistryRef(ref, options) {
+    const parsed = parseRegistryRef(ref);
+    const resolved = await resolveRegistryArtifact(parsed);
+    const installedAt = (options?.now ?? new Date()).toISOString();
+    const cacheRootDir = options?.cacheRootDir ?? getRegistryCacheRootDir();
+    const cacheDir = buildInstallCacheDir(cacheRootDir, resolved.source, resolved.id);
+    const archivePath = path.join(cacheDir, "artifact.tar.gz");
+    const extractedDir = path.join(cacheDir, "extracted");
+    fs.mkdirSync(cacheDir, { recursive: true });
+    await downloadArchive(resolved.artifactUrl, archivePath);
+    extractTarGzSecure(archivePath, extractedDir);
+    const stashRoot = detectStashRoot(extractedDir);
+    return {
+        id: resolved.id,
+        source: resolved.source,
+        ref: resolved.ref,
+        artifactUrl: resolved.artifactUrl,
+        resolvedVersion: resolved.resolvedVersion,
+        resolvedRevision: resolved.resolvedRevision,
+        installedAt,
+        cacheDir,
+        extractedDir,
+        stashRoot,
+    };
+}
+export function upsertInstalledRegistryEntry(entry, stashDir) {
+    const current = loadConfig(stashDir);
+    const currentInstalled = current.registry?.installed ?? [];
+    const previousRegistryRoots = new Set(currentInstalled.map((item) => path.resolve(item.stashRoot)));
+    const withoutExisting = currentInstalled.filter((item) => item.id !== entry.id);
+    const nextInstalled = [...withoutExisting, normalizeInstalledEntry(entry)];
+    const nextRegistryRoots = new Set(nextInstalled.map((item) => path.resolve(item.stashRoot)));
+    const preservedAdditional = current.additionalStashDirs.filter((dir) => !previousRegistryRoots.has(path.resolve(dir)));
+    const syncedAdditional = uniquePaths([...preservedAdditional, ...nextRegistryRoots]);
+    const nextConfig = {
+        ...current,
+        additionalStashDirs: syncedAdditional,
+        registry: {
+            installed: nextInstalled,
+        },
+    };
+    saveConfig(nextConfig, stashDir);
+    return nextConfig;
+}
+export function removeInstalledRegistryEntry(id, stashDir) {
+    const current = loadConfig(stashDir);
+    const currentInstalled = current.registry?.installed ?? [];
+    const previousRegistryRoots = new Set(currentInstalled.map((item) => path.resolve(item.stashRoot)));
+    const nextInstalled = currentInstalled.filter((item) => item.id !== id);
+    const nextRegistryRoots = new Set(nextInstalled.map((item) => path.resolve(item.stashRoot)));
+    const preservedAdditional = current.additionalStashDirs.filter((dir) => !previousRegistryRoots.has(path.resolve(dir)));
+    const syncedAdditional = uniquePaths([...preservedAdditional, ...nextRegistryRoots]);
+    const nextConfig = {
+        ...current,
+        additionalStashDirs: syncedAdditional,
+        registry: nextInstalled.length > 0 ? { installed: nextInstalled } : undefined,
+    };
+    saveConfig(nextConfig, stashDir);
+    return nextConfig;
+}
+export function getRegistryCacheRootDir() {
+    const xdgCache = process.env.XDG_CACHE_HOME?.trim();
+    if (xdgCache) {
+        return path.join(path.resolve(xdgCache), "agentikit", "registry");
+    }
+    const home = process.env.HOME?.trim();
+    if (!home) {
+        throw new Error("Unable to determine cache directory. Set XDG_CACHE_HOME or HOME.");
+    }
+    return path.join(path.resolve(home), ".cache", "agentikit", "registry");
+}
+export function detectStashRoot(extractedDir) {
+    const root = path.resolve(extractedDir);
+    const rootDotStash = path.join(root, ".stash");
+    if (isDirectory(rootDotStash)) {
+        return root;
+    }
+    if (hasStashDirs(root)) {
+        return root;
+    }
+    const opencodeDir = path.join(root, "opencode");
+    if (hasStashDirs(opencodeDir)) {
+        return opencodeDir;
+    }
+    const shallowest = findShallowestDotStashRoot(root);
+    if (shallowest)
+        return shallowest;
+    return root;
+}
+function buildInstallCacheDir(cacheRootDir, source, id) {
+    const slug = `${source}-${id.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "")}`;
+    const stamp = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    return path.join(cacheRootDir, slug || source, stamp);
+}
+async function downloadArchive(url, destination) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download archive (${response.status}) from ${url}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    fs.writeFileSync(destination, Buffer.from(arrayBuffer));
+}
+function extractTarGzSecure(archivePath, destinationDir) {
+    const listResult = spawnSync("tar", ["tzf", archivePath], { encoding: "utf8" });
+    if (listResult.status !== 0) {
+        const err = listResult.stderr?.trim() || listResult.error?.message || "unknown error";
+        throw new Error(`Failed to inspect archive ${archivePath}: ${err}`);
+    }
+    validateTarEntries(listResult.stdout);
+    fs.rmSync(destinationDir, { recursive: true, force: true });
+    fs.mkdirSync(destinationDir, { recursive: true });
+    const extractResult = spawnSync("tar", ["xzf", archivePath, "--strip-components=1", "-C", destinationDir], {
+        encoding: "utf8",
+    });
+    if (extractResult.status !== 0) {
+        const err = extractResult.stderr?.trim() || extractResult.error?.message || "unknown error";
+        throw new Error(`Failed to extract archive ${archivePath}: ${err}`);
+    }
+}
+function validateTarEntries(listOutput) {
+    const lines = listOutput.split(/\r?\n/).filter(Boolean);
+    for (const rawLine of lines) {
+        const entry = rawLine.trim();
+        if (!entry || entry.includes("\0")) {
+            throw new Error(`Archive contains an invalid entry: ${JSON.stringify(rawLine)}`);
+        }
+        if (entry.startsWith("/")) {
+            throw new Error(`Archive contains an absolute path entry: ${entry}`);
+        }
+        const normalized = path.posix.normalize(entry);
+        if (normalized === ".." || normalized.startsWith("../")) {
+            throw new Error(`Archive contains a path traversal entry: ${entry}`);
+        }
+        const parts = normalized.split("/").filter(Boolean);
+        const stripped = parts.slice(1).join("/");
+        if (!stripped)
+            continue;
+        const normalizedStripped = path.posix.normalize(stripped);
+        if (normalizedStripped === ".." || normalizedStripped.startsWith("../") || path.posix.isAbsolute(normalizedStripped)) {
+            throw new Error(`Archive contains an unsafe entry after strip-components: ${entry}`);
+        }
+    }
+}
+function isDirectory(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function hasStashDirs(dirPath) {
+    if (!isDirectory(dirPath))
+        return false;
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    return entries.some((entry) => entry.isDirectory() && REGISTRY_STASH_DIR_NAMES.has(entry.name));
+}
+function findShallowestDotStashRoot(root) {
+    const queue = [root];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const dotStash = path.join(current, ".stash");
+        if (isDirectory(dotStash)) {
+            return current;
+        }
+        let children;
+        try {
+            children = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const child of children) {
+            if (!child.isDirectory())
+                continue;
+            if (child.name === ".git" || child.name === "node_modules")
+                continue;
+            queue.push(path.join(current, child.name));
+        }
+    }
+    return undefined;
+}
+function normalizeInstalledEntry(entry) {
+    return {
+        ...entry,
+        stashRoot: path.resolve(entry.stashRoot),
+        cacheDir: path.resolve(entry.cacheDir),
+    };
+}
+function uniquePaths(paths) {
+    const seen = new Set();
+    const result = [];
+    for (const candidate of paths) {
+        const normalized = path.resolve(candidate);
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import type { ParsedRegistryRef, ResolvedRegistryArtifact } from "./registry-types";
+export declare function parseRegistryRef(rawRef: string): ParsedRegistryRef;
+export declare function resolveRegistryArtifact(parsed: ParsedRegistryRef): Promise<ResolvedRegistryArtifact>;

package/dist/src/registry-resolve.js

@@ -0,0 +1,231 @@
+const GITHUB_API_BASE = "https://api.github.com";
+export function parseRegistryRef(rawRef) {
+    const ref = rawRef.trim();
+    if (!ref)
+        throw new Error("Registry ref is required.");
+    if (ref.startsWith("npm:")) {
+        return parseNpmRef(ref.slice(4), ref);
+    }
+    if (ref.startsWith("github:")) {
+        return parseGithubShorthand(ref.slice(7), ref);
+    }
+    if (ref.startsWith("http://") || ref.startsWith("https://")) {
+        return parseGithubUrl(ref);
+    }
+    if (ref.startsWith("@") || !looksLikeGithubOwnerRepo(ref)) {
+        return parseNpmRef(ref, ref);
+    }
+    return parseGithubShorthand(ref, ref);
+}
+export async function resolveRegistryArtifact(parsed) {
+    if (parsed.source === "npm") {
+        return resolveNpmArtifact(parsed);
+    }
+    return resolveGithubArtifact(parsed);
+}
+function parseNpmRef(input, originalRef) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        throw new Error("Invalid npm ref.");
+    const parsed = splitNpmNameAndVersion(trimmed);
+    validateNpmPackageName(parsed.packageName);
+    return {
+        source: "npm",
+        ref: originalRef,
+        id: `npm:${parsed.packageName}`,
+        packageName: parsed.packageName,
+        requestedVersionOrTag: parsed.requestedVersionOrTag,
+    };
+}
+function parseGithubShorthand(input, originalRef) {
+    const [repoPart, requestedRef] = splitRefSuffix(input.trim());
+    const segments = repoPart.split("/").filter(Boolean);
+    if (segments.length !== 2) {
+        throw new Error("Invalid GitHub ref. Expected owner/repo or owner/repo#ref.");
+    }
+    const owner = segments[0];
+    const repo = segments[1].replace(/\.git$/i, "");
+    if (!owner || !repo) {
+        throw new Error("Invalid GitHub ref. Expected owner/repo.");
+    }
+    return {
+        source: "github",
+        ref: originalRef,
+        id: `github:${owner}/${repo}`,
+        owner,
+        repo,
+        requestedRef,
+    };
+}
+function parseGithubUrl(rawUrl) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        throw new Error("Invalid registry URL.");
+    }
+    if (url.hostname !== "github.com") {
+        throw new Error("Only GitHub URLs are currently supported for URL refs.");
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length < 2) {
+        throw new Error("Invalid GitHub URL. Expected https://github.com/owner/repo.");
+    }
+    const owner = segments[0];
+    const repo = segments[1].replace(/\.git$/i, "");
+    const requestedRef = url.hash ? decodeURIComponent(url.hash.slice(1)) : undefined;
+    return {
+        source: "github",
+        ref: rawUrl,
+        id: `github:${owner}/${repo}`,
+        owner,
+        repo,
+        requestedRef,
+    };
+}
+async function resolveNpmArtifact(parsed) {
+    const encodedName = encodeURIComponent(parsed.packageName);
+    const metadata = await fetchJson(`https://registry.npmjs.org/${encodedName}`);
+    const versions = asRecord(metadata.versions);
+    const distTags = asRecord(metadata["dist-tags"]);
+    const requested = parsed.requestedVersionOrTag;
+    let resolvedVersion;
+    if (!requested) {
+        resolvedVersion = asString(distTags.latest);
+    }
+    else if (requested in versions) {
+        resolvedVersion = requested;
+    }
+    else {
+        resolvedVersion = asString(distTags[requested]);
+    }
+    if (!resolvedVersion || !(resolvedVersion in versions)) {
+        throw new Error(`Unable to resolve npm ref \"${parsed.ref}\".`);
+    }
+    const versionMeta = asRecord(versions[resolvedVersion]);
+    const dist = asRecord(versionMeta.dist);
+    const tarballUrl = asString(dist.tarball);
+    if (!tarballUrl) {
+        throw new Error(`npm package ${parsed.packageName}@${resolvedVersion} does not expose a tarball URL.`);
+    }
+    const resolvedRevision = asString(dist.shasum) ?? asString(dist.integrity);
+    return {
+        id: parsed.id,
+        source: parsed.source,
+        ref: parsed.ref,
+        artifactUrl: tarballUrl,
+        resolvedVersion,
+        resolvedRevision,
+    };
+}
+async function resolveGithubArtifact(parsed) {
+    const headers = githubHeaders();
+    if (parsed.requestedRef) {
+        const commit = await tryFetchJson(`${GITHUB_API_BASE}/repos/${encodeURIComponent(parsed.owner)}/${encodeURIComponent(parsed.repo)}/commits/${encodeURIComponent(parsed.requestedRef)}`, headers);
+        const resolvedRevision = asString(commit?.sha) ?? parsed.requestedRef;
+        return {
+            id: parsed.id,
+            source: parsed.source,
+            ref: parsed.ref,
+            artifactUrl: `${GITHUB_API_BASE}/repos/${encodeURIComponent(parsed.owner)}/${encodeURIComponent(parsed.repo)}/tarball/${encodeURIComponent(parsed.requestedRef)}`,
+            resolvedRevision,
+            resolvedVersion: parsed.requestedRef,
+        };
+    }
+    const latestRelease = await tryFetchJson(`${GITHUB_API_BASE}/repos/${encodeURIComponent(parsed.owner)}/${encodeURIComponent(parsed.repo)}/releases/latest`, headers);
+    if (latestRelease) {
+        const tarballUrl = asString(latestRelease.tarball_url);
+        if (tarballUrl) {
+            return {
+                id: parsed.id,
+                source: parsed.source,
+                ref: parsed.ref,
+                artifactUrl: tarballUrl,
+                resolvedVersion: asString(latestRelease.tag_name),
+                resolvedRevision: asString(latestRelease.target_commitish),
+            };
+        }
+    }
+    const repoMeta = await fetchJson(`${GITHUB_API_BASE}/repos/${encodeURIComponent(parsed.owner)}/${encodeURIComponent(parsed.repo)}`, headers);
+    const defaultBranch = asString(repoMeta.default_branch);
+    if (!defaultBranch) {
+        throw new Error(`Unable to resolve default branch for ${parsed.owner}/${parsed.repo}.`);
+    }
+    const commit = await tryFetchJson(`${GITHUB_API_BASE}/repos/${encodeURIComponent(parsed.owner)}/${encodeURIComponent(parsed.repo)}/commits/${encodeURIComponent(defaultBranch)}`, headers);
+    return {
+        id: parsed.id,
+        source: parsed.source,
+        ref: parsed.ref,
+        artifactUrl: `${GITHUB_API_BASE}/repos/${encodeURIComponent(parsed.owner)}/${encodeURIComponent(parsed.repo)}/tarball/${encodeURIComponent(defaultBranch)}`,
+        resolvedVersion: defaultBranch,
+        resolvedRevision: asString(commit?.sha) ?? defaultBranch,
+    };
+}
+function splitNpmNameAndVersion(input) {
+    if (input.startsWith("@")) {
+        const secondAt = input.indexOf("@", 1);
+        if (secondAt > 0) {
+            return {
+                packageName: input.slice(0, secondAt),
+                requestedVersionOrTag: input.slice(secondAt + 1) || undefined,
+            };
+        }
+        return { packageName: input };
+    }
+    const at = input.lastIndexOf("@");
+    if (at > 0) {
+        return {
+            packageName: input.slice(0, at),
+            requestedVersionOrTag: input.slice(at + 1) || undefined,
+        };
+    }
+    return { packageName: input };
+}
+function validateNpmPackageName(name) {
+    if (!name || name.includes(" ")) {
+        throw new Error(`Invalid npm package name: \"${name}\".`);
+    }
+}
+function looksLikeGithubOwnerRepo(ref) {
+    const [repoPart] = splitRefSuffix(ref);
+    const parts = repoPart.split("/").filter(Boolean);
+    return parts.length === 2;
+}
+function splitRefSuffix(value) {
+    const hash = value.indexOf("#");
+    if (hash < 0)
+        return [value, undefined];
+    return [value.slice(0, hash), value.slice(hash + 1) || undefined];
+}
+function githubHeaders() {
+    const token = process.env.GITHUB_TOKEN?.trim();
+    const headers = {
+        Accept: "application/vnd.github+json",
+        "User-Agent": "agentikit-registry",
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+}
+async function fetchJson(url, headers) {
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+        throw new Error(`Request failed (${response.status}) for ${url}`);
+    }
+    return await response.json();
+}
+async function tryFetchJson(url, headers) {
+    const response = await fetch(url, { headers });
+    if (!response.ok)
+        return null;
+    return await response.json();
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}

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

@@ -0,0 +1,5 @@
+import type { RegistrySearchResponse } from "./registry-types";
+export interface RegistrySearchOptions {
+    limit?: number;
+}
+export declare function searchRegistry(query: string, options?: RegistrySearchOptions): Promise<RegistrySearchResponse>;

package/dist/src/registry-search.js

@@ -0,0 +1,129 @@
+const GITHUB_API_BASE = "https://api.github.com";
+export async function searchRegistry(query, options) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+        return { query: "", hits: [], warnings: [] };
+    }
+    const limit = clampLimit(options?.limit);
+    const [npmResult, githubResult] = await Promise.allSettled([
+        searchNpm(trimmed, limit),
+        searchGithub(trimmed, limit),
+    ]);
+    const hits = [];
+    const warnings = [];
+    if (npmResult.status === "fulfilled") {
+        hits.push(...npmResult.value);
+    }
+    else {
+        warnings.push(`npm search failed: ${toErrorMessage(npmResult.reason)}`);
+    }
+    if (githubResult.status === "fulfilled") {
+        hits.push(...githubResult.value);
+    }
+    else {
+        warnings.push(`GitHub search failed: ${toErrorMessage(githubResult.reason)}`);
+    }
+    hits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    return {
+        query: trimmed,
+        hits: hits.slice(0, limit * 2),
+        warnings,
+    };
+}
+async function searchNpm(query, limit) {
+    const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(query)}&size=${limit}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const objects = Array.isArray(data.objects) ? data.objects : [];
+    return objects.flatMap((raw) => {
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+            return [];
+        const obj = raw;
+        const pkg = asRecord(obj.package);
+        const name = asString(pkg.name);
+        if (!name)
+            return [];
+        const version = asString(pkg.version);
+        const metadata = {};
+        if (version)
+            metadata.version = version;
+        const date = asString(pkg.date);
+        if (date)
+            metadata.updatedAt = date;
+        return [{
+                source: "npm",
+                id: `npm:${name}`,
+                title: name,
+                description: asString(pkg.description),
+                ref: name,
+                homepage: asString(asRecord(pkg.links).homepage),
+                score: asNumber(obj.score),
+                metadata,
+            }];
+    });
+}
+async function searchGithub(query, limit) {
+    const q = encodeURIComponent(`${query} in:name,description,readme`);
+    const url = `${GITHUB_API_BASE}/search/repositories?q=${q}&sort=stars&order=desc&per_page=${limit}`;
+    const response = await fetch(url, { headers: githubHeaders() });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const items = Array.isArray(data.items) ? data.items : [];
+    return items.flatMap((raw) => {
+        const repo = asRecord(raw);
+        const fullName = asString(repo.full_name);
+        if (!fullName)
+            return [];
+        const metadata = {};
+        const stars = asNumber(repo.stargazers_count);
+        if (stars > 0)
+            metadata.stars = String(stars);
+        const language = asString(repo.language);
+        if (language)
+            metadata.language = language;
+        return [{
+                source: "github",
+                id: `github:${fullName}`,
+                title: fullName,
+                description: asString(repo.description),
+                ref: fullName,
+                homepage: asString(repo.html_url),
+                score: stars,
+                metadata,
+            }];
+    });
+}
+function githubHeaders() {
+    const token = process.env.GITHUB_TOKEN?.trim();
+    const headers = {
+        Accept: "application/vnd.github+json",
+        "User-Agent": "agentikit-registry",
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+}
+function clampLimit(limit) {
+    if (!limit || !Number.isFinite(limit))
+        return 20;
+    return Math.min(100, Math.max(1, Math.trunc(limit)));
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -0,0 +1,55 @@
+export type RegistrySource = "npm" | "github";
+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 type ParsedRegistryRef = ParsedNpmRef | ParsedGithubRef;
+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>;
+}
+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>;