@caplets/core 0.17.0 → 0.18.1

package/dist/cli/commands.d.ts

@@ -0,0 +1,37 @@
+export declare const completionShells: readonly ["bash", "zsh", "fish", "powershell", "cmd"];
+export type CompletionShell = (typeof completionShells)[number];
+export declare const cliCommands: {
+    readonly completion: "completion";
+    readonly completeHidden: "__complete";
+    readonly serve: "serve";
+    readonly init: "init";
+    readonly list: "list";
+    readonly install: "install";
+    readonly add: "add";
+    readonly getCaplet: "get-caplet";
+    readonly checkBackend: "check-backend";
+    readonly listTools: "list-tools";
+    readonly searchTools: "search-tools";
+    readonly getTool: "get-tool";
+    readonly callTool: "call-tool";
+    readonly listResources: "list-resources";
+    readonly searchResources: "search-resources";
+    readonly listResourceTemplates: "list-resource-templates";
+    readonly readResource: "read-resource";
+    readonly listPrompts: "list-prompts";
+    readonly searchPrompts: "search-prompts";
+    readonly getPrompt: "get-prompt";
+    readonly complete: "complete";
+    readonly config: "config";
+    readonly auth: "auth";
+};
+export declare const topLevelCommandNames: readonly ["serve", "init", "list", "install", "add", "get-caplet", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "completion"];
+export declare const cliSubcommands: {
+    readonly add: readonly ["cli", "mcp", "openapi", "graphql", "http"];
+    readonly auth: readonly ["login", "logout", "list"];
+    readonly completion: readonly ["bash", "zsh", "fish", "powershell", "cmd"];
+    readonly config: readonly ["path", "paths"];
+};
+export declare const capletIdCommands: Set<string>;
+export declare const qualifiedToolCommands: Set<string>;
+export declare const qualifiedPromptCommands: Set<string>;

package/dist/cli/completion-cache.d.ts

@@ -0,0 +1,30 @@
+export type CompletionDiscoveryKind = "tools" | "prompts" | "resources" | "resourceTemplates";
+export type CompletionCandidate = {
+    value: string;
+    label?: string | undefined;
+    description?: string | undefined;
+};
+export type CompletionCacheKeyInput = {
+    server: string;
+    backend: string;
+    kind: CompletionDiscoveryKind;
+    fingerprint: string;
+};
+export type CompletionCacheEntry = {
+    status: "positive";
+    fetchedAt: number;
+    expiresAt: number;
+    candidates: CompletionCandidate[];
+} | {
+    status: "negative";
+    fetchedAt: number;
+    expiresAt: number;
+    reason: "auth_required" | "timeout" | "unavailable" | "unsupported" | "error";
+    candidates?: CompletionCandidate[];
+};
+export type ReadCompletionCacheEntry = CompletionCacheEntry & {
+    fresh: boolean;
+};
+export declare function completionCacheKey(input: CompletionCacheKeyInput): string;
+export declare function readCompletionCacheEntry(cacheDir: string, key: string, now?: number): ReadCompletionCacheEntry | undefined;
+export declare function writeCompletionCacheEntry(cacheDir: string, key: string, entry: CompletionCacheEntry): void;

package/dist/cli/completion-discovery.d.ts

@@ -0,0 +1,30 @@
+import { type CapletConfig, type CapletsConfig, type CompletionConfig } from "../config";
+import { type CompletionCandidate, type CompletionDiscoveryKind } from "./completion-cache";
+export type CompletionDiscoveryManagers = {
+    listTools?: (server: CapletConfig) => Promise<Array<{
+        name: string;
+        description?: string;
+    }>>;
+    listPrompts?: (server: CapletConfig) => Promise<Array<{
+        name: string;
+        description?: string;
+    }>>;
+    listResources?: (server: CapletConfig) => Promise<Array<{
+        uri: string;
+        name?: string;
+        description?: string;
+    }>>;
+    listResourceTemplates?: (server: CapletConfig) => Promise<Array<{
+        uriTemplate: string;
+        name?: string;
+        description?: string;
+    }>>;
+};
+export type CompletionDiscoveryOptions = {
+    config: CapletsConfig;
+    completion?: CompletionConfig | undefined;
+    cacheDir?: string | undefined;
+    managers?: CompletionDiscoveryManagers | undefined;
+    now?: number | undefined;
+};
+export declare function discoverCompletionCandidates(serverId: string, kind: CompletionDiscoveryKind, options: CompletionDiscoveryOptions): Promise<CompletionCandidate[]>;

package/dist/cli/completion.d.ts

@@ -0,0 +1,15 @@
+import { type CapletsConfig, type CompletionConfig } from "../config";
+import { type CompletionShell } from "./commands";
+import { type CompletionDiscoveryManagers } from "./completion-discovery";
+export { completionShells, type CompletionShell } from "./commands";
+export declare const trailingSpaceCompletionToken = "__CAPLETS_TRAILING_SPACE__";
+export type CompletionOptions = {
+    configPath?: string;
+    projectConfigPath?: string;
+    config?: CapletsConfig;
+    completion?: CompletionConfig;
+    cacheDir?: string;
+    managers?: CompletionDiscoveryManagers;
+};
+export declare function completionScript(shell: CompletionShell): string;
+export declare function completeCliWords(words: string[], options?: CompletionOptions): Promise<string[]>;

package/dist/completion-dbB1hc97.js

@@ -0,0 +1,560 @@
+import { Ct as resolveProjectConfigPath, Mt as __exportAll, Ot as CapletsError, St as resolveProjectCapletsRoot, bt as resolveCapletsRoot, gt as loadConfigWithSources, vt as DEFAULT_AUTH_DIR, xt as resolveConfigPath, yt as DEFAULT_COMPLETION_CACHE_DIR } from "./options-BqibJVxq.js";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/cli/commands.ts
+const completionShells = [
+	"bash",
+	"zsh",
+	"fish",
+	"powershell",
+	"cmd"
+];
+const cliCommands = {
+	completion: "completion",
+	completeHidden: "__complete",
+	serve: "serve",
+	init: "init",
+	list: "list",
+	install: "install",
+	add: "add",
+	getCaplet: "get-caplet",
+	checkBackend: "check-backend",
+	listTools: "list-tools",
+	searchTools: "search-tools",
+	getTool: "get-tool",
+	callTool: "call-tool",
+	listResources: "list-resources",
+	searchResources: "search-resources",
+	listResourceTemplates: "list-resource-templates",
+	readResource: "read-resource",
+	listPrompts: "list-prompts",
+	searchPrompts: "search-prompts",
+	getPrompt: "get-prompt",
+	complete: "complete",
+	config: "config",
+	auth: "auth"
+};
+const topLevelCommandNames = [
+	cliCommands.serve,
+	cliCommands.init,
+	cliCommands.list,
+	cliCommands.install,
+	cliCommands.add,
+	cliCommands.getCaplet,
+	cliCommands.checkBackend,
+	cliCommands.listTools,
+	cliCommands.searchTools,
+	cliCommands.getTool,
+	cliCommands.callTool,
+	cliCommands.listResources,
+	cliCommands.searchResources,
+	cliCommands.listResourceTemplates,
+	cliCommands.readResource,
+	cliCommands.listPrompts,
+	cliCommands.searchPrompts,
+	cliCommands.getPrompt,
+	cliCommands.complete,
+	cliCommands.config,
+	cliCommands.auth,
+	cliCommands.completion
+];
+const cliSubcommands = {
+	[cliCommands.add]: [
+		"cli",
+		"mcp",
+		"openapi",
+		"graphql",
+		"http"
+	],
+	[cliCommands.auth]: [
+		"login",
+		"logout",
+		"list"
+	],
+	[cliCommands.completion]: [...completionShells],
+	[cliCommands.config]: ["path", "paths"]
+};
+const capletIdCommands = new Set([
+	cliCommands.getCaplet,
+	cliCommands.checkBackend,
+	cliCommands.listTools,
+	cliCommands.searchTools,
+	cliCommands.listResources,
+	cliCommands.searchResources,
+	cliCommands.listResourceTemplates,
+	cliCommands.readResource,
+	cliCommands.listPrompts,
+	cliCommands.searchPrompts,
+	cliCommands.complete
+]);
+const qualifiedToolCommands = new Set([cliCommands.getTool, cliCommands.callTool]);
+const qualifiedPromptCommands = new Set([cliCommands.getPrompt]);
+//#endregion
+//#region src/cli/inspection.ts
+function listCaplets(configWithSources, options) {
+	const { config, sources, shadows } = configWithSources;
+	return allCaplets(config).filter((server) => options.includeDisabled || !server.disabled).map((server) => ({
+		server: server.server,
+		backend: server.backend,
+		name: server.name,
+		description: server.description,
+		disabled: server.disabled,
+		status: initialServerStatus(server),
+		source: sources[server.server]?.kind ?? "unknown",
+		path: sources[server.server]?.path ?? null,
+		shadows: shadows[server.server] ?? []
+	})).sort((left, right) => left.server.localeCompare(right.server));
+}
+function initialServerStatus(server) {
+	return server.disabled ? "disabled" : "not_started";
+}
+function allCaplets(config) {
+	return [
+		...Object.values(config.mcpServers),
+		...Object.values(config.openapiEndpoints),
+		...Object.values(config.graphqlEndpoints),
+		...Object.values(config.httpApis),
+		...Object.values(config.cliTools)
+	];
+}
+function formatCapletList(rows, format = "plain") {
+	return format === "markdown" ? formatCapletListMarkdown(rows) : formatCapletListPlain(rows);
+}
+function formatCapletListMarkdown(rows) {
+	if (rows.length === 0) return "## Configured Caplets\n\nNo configured Caplets found.\n";
+	const heading = [
+		"## Configured Caplets",
+		"",
+		`${rows.length} ${rows.length === 1 ? "Caplet" : "Caplets"} shown.`,
+		""
+	];
+	const entries = rows.flatMap((row) => [
+		`- \`${row.server}\` — ${row.name}`,
+		`  - Backend: ${row.backend}`,
+		`  - Status: ${row.status}`,
+		`  - Source: ${row.source}`,
+		...row.disabled ? ["  - Disabled: true"] : [],
+		...row.path ? [`  - Path: ${row.path}`] : []
+	]);
+	const warnings = rows.flatMap((row) => row.shadows.map((shadow) => `Warning: ${formatSourceKind(row.source)} Caplet ${row.server} shadows ${formatSourceKind(shadow.kind)} Caplet at ${shadow.path}`));
+	if (warnings.length === 0) return `${[...heading, ...entries].join("\n")}\n`;
+	return `${[
+		...heading,
+		...entries,
+		"",
+		"Warnings:",
+		...warnings.map((warning) => `- ${warning}`)
+	].join("\n")}\n`;
+}
+function formatCapletListPlain(rows) {
+	if (rows.length === 0) return "No configured Caplets found.\n";
+	const entries = rows.map((row) => [
+		row.server,
+		`  Name: ${row.name}`,
+		`  Backend: ${row.backend}`,
+		`  Status: ${row.status}`,
+		`  Source: ${row.source}`,
+		...row.disabled ? ["  Disabled: true"] : [],
+		...row.path ? [`  Path: ${row.path}`] : []
+	].join("\n")).join("\n\n");
+	const warnings = rows.flatMap((row) => row.shadows.map((shadow) => `Warning: ${formatSourceKind(row.source)} Caplet ${row.server} shadows ${formatSourceKind(shadow.kind)} Caplet at ${shadow.path}`));
+	if (warnings.length === 0) return `Configured Caplets (${rows.length})\n\n${entries}\n`;
+	return `Configured Caplets (${rows.length})\n\n${entries}\n\n${warnings.join("\n")}\n`;
+}
+function formatSourceKind(kind) {
+	if (kind.startsWith("project")) return "project";
+	if (kind.startsWith("global")) return "global";
+	return kind;
+}
+function resolveCliConfigPaths(envConfigPath, authDir) {
+	const configPath = resolveConfigPath(envConfigPath);
+	const effectiveAuthDir = authDir ?? DEFAULT_AUTH_DIR;
+	return {
+		userConfig: configPath,
+		projectConfig: resolveProjectConfigPath(),
+		userRoot: resolveCapletsRoot(configPath),
+		stateRoot: dirname(effectiveAuthDir),
+		projectRoot: resolveProjectCapletsRoot(),
+		authDir: effectiveAuthDir,
+		envConfig: envConfigPath ?? null
+	};
+}
+function formatConfigPaths(paths, format = "plain") {
+	if (format === "markdown") return formatConfigPathsMarkdown(paths);
+	return formatConfigPathsPlain(paths);
+}
+function formatConfigPathsMarkdown(paths) {
+	return [
+		"## Caplets paths",
+		"",
+		`- User config: ${paths.userConfig}`,
+		`- Project config: ${paths.projectConfig}`,
+		`- User Caplets root: ${paths.userRoot}`,
+		`- State root: ${paths.stateRoot}`,
+		`- Project Caplets root: ${paths.projectRoot}`,
+		`- Auth directory: ${paths.authDir}`,
+		`- CAPLETS_CONFIG: ${paths.envConfig ?? "unset"}`
+	].join("\n") + "\n";
+}
+function formatConfigPathsPlain(paths) {
+	return [
+		"Caplets paths",
+		"",
+		`User config: ${paths.userConfig}`,
+		`Project config: ${paths.projectConfig}`,
+		`User root: ${paths.userRoot}`,
+		`State root: ${paths.stateRoot}`,
+		`Project root: ${paths.projectRoot}`,
+		`Auth directory: ${paths.authDir}`,
+		`CAPLETS_CONFIG: ${paths.envConfig ?? "unset"}`
+	].join("\n") + "\n";
+}
+//#endregion
+//#region src/cli/completion-cache.ts
+function completionCacheKey(input) {
+	return createHash("sha256").update(JSON.stringify(input)).digest("hex");
+}
+function readCompletionCacheEntry(cacheDir, key, now = Date.now()) {
+	try {
+		const parsed = JSON.parse(readFileSync(cachePath(cacheDir, key), "utf8"));
+		if (parsed.status === "positive" && Array.isArray(parsed.candidates)) return {
+			...parsed,
+			fresh: now <= parsed.expiresAt
+		};
+		if (parsed.status === "negative" && typeof parsed.reason === "string") return {
+			...parsed,
+			fresh: now <= parsed.expiresAt
+		};
+	} catch {
+		return;
+	}
+}
+function writeCompletionCacheEntry(cacheDir, key, entry) {
+	mkdirSync(cacheDir, { recursive: true });
+	const path = cachePath(cacheDir, key);
+	const tempPath = `${path}.${process.pid}.tmp`;
+	writeFileSync(tempPath, JSON.stringify(entry), { mode: 384 });
+	renameSync(tempPath, path);
+}
+function cachePath(cacheDir, key) {
+	return join(cacheDir, `${key}.json`);
+}
+//#endregion
+//#region src/cli/completion-discovery.ts
+async function discoverCompletionCandidates(serverId, kind, options) {
+	const server = enabledServer(serverId, options.config);
+	if (!server) return [];
+	const completion = options.completion ?? options.config.options.completion;
+	const now = options.now ?? Date.now();
+	const configCandidates = configDefinedCandidates(serverId, kind, options.config);
+	const cacheDir = options.cacheDir ?? DEFAULT_COMPLETION_CACHE_DIR;
+	const key = completionCacheKey({
+		server: server.server,
+		backend: server.backend,
+		kind,
+		fingerprint: completionFingerprint(server, kind, completion)
+	});
+	const cached = readCompletionCacheEntry(cacheDir, key, now);
+	if (cached?.status === "positive" && cached.fresh) return cached.candidates;
+	if (cached?.status === "negative" && cached.fresh) return cached.candidates ?? configCandidates;
+	try {
+		const live = await withTimeout(liveCandidates(server, kind, options.managers), Math.min(completion.discoveryTimeoutMs, completion.overallTimeoutMs));
+		const candidates = dedupeCandidates([...configCandidates, ...live]);
+		writeCompletionCacheEntry(cacheDir, key, {
+			status: "positive",
+			fetchedAt: now,
+			expiresAt: now + completion.cacheTtlMs,
+			candidates
+		});
+		return candidates;
+	} catch (error) {
+		writeCompletionCacheEntry(cacheDir, key, {
+			status: "negative",
+			fetchedAt: now,
+			expiresAt: now + completion.negativeCacheTtlMs,
+			reason: negativeReason(error),
+			...cached?.status === "positive" ? { candidates: cached.candidates } : {}
+		});
+		if (cached?.status === "positive") return cached.candidates;
+		return configCandidates;
+	}
+}
+function configDefinedCandidates(serverId, kind, config) {
+	if (kind !== "tools") return [];
+	const cli = config.cliTools[serverId];
+	if (cli && !cli.disabled) return Object.keys(cli.actions).map((name) => ({ value: `${serverId}.${name}` }));
+	const http = config.httpApis[serverId];
+	if (http && !http.disabled) return Object.keys(http.actions).map((name) => ({ value: `${serverId}.${name}` }));
+	const graphql = config.graphqlEndpoints[serverId];
+	if (graphql && !graphql.disabled && graphql.operations) return Object.keys(graphql.operations).map((name) => ({ value: `${serverId}.${name}` }));
+	return [];
+}
+async function liveCandidates(server, kind, managers) {
+	if (kind === "tools" && managers?.listTools) return (await managers.listTools(server)).map((tool) => ({
+		value: `${server.server}.${tool.name}`,
+		description: tool.description
+	}));
+	if (kind === "tools") return [];
+	if (server.backend !== "mcp") return [];
+	if (kind === "prompts" && managers?.listPrompts) return (await managers.listPrompts(server)).map((prompt) => ({
+		value: `${server.server}.${prompt.name}`,
+		description: prompt.description
+	}));
+	if (kind === "resources" && managers?.listResources) return (await managers.listResources(server)).map((resource) => ({
+		value: resource.uri,
+		label: resource.name,
+		description: resource.description
+	}));
+	if (kind === "resourceTemplates" && managers?.listResourceTemplates) return (await managers.listResourceTemplates(server)).map((template) => ({
+		value: template.uriTemplate,
+		label: template.name,
+		description: template.description
+	}));
+	throw new CapletsError("UNSUPPORTED_CAPABILITY", `Completion discovery is unsupported for ${kind}`);
+}
+function completionFingerprint(server, kind, completion) {
+	return JSON.stringify({
+		kind,
+		completion: {
+			discoveryTimeoutMs: completion.discoveryTimeoutMs,
+			cacheTtlMs: completion.cacheTtlMs,
+			negativeCacheTtlMs: completion.negativeCacheTtlMs
+		},
+		server: secretFreeServerShape(server)
+	});
+}
+function secretFreeServerShape(server) {
+	const base = {
+		server: server.server,
+		backend: server.backend,
+		name: server.name,
+		description: server.description,
+		tags: server.tags,
+		disabled: server.disabled
+	};
+	switch (server.backend) {
+		case "mcp": return {
+			...base,
+			transport: server.transport,
+			command: server.command,
+			args: server.args,
+			cwd: server.cwd,
+			url: server.url,
+			authType: server.auth?.type,
+			startupTimeoutMs: server.startupTimeoutMs,
+			callTimeoutMs: server.callTimeoutMs
+		};
+		case "openapi": return {
+			...base,
+			specPath: server.specPath,
+			specUrl: server.specUrl,
+			baseUrl: server.baseUrl,
+			authType: server.auth.type,
+			requestTimeoutMs: server.requestTimeoutMs
+		};
+		case "graphql": return {
+			...base,
+			endpointUrl: server.endpointUrl,
+			schemaPath: server.schemaPath,
+			schemaUrl: server.schemaUrl,
+			authType: server.auth.type,
+			operationNames: server.operations ? Object.keys(server.operations) : void 0
+		};
+		case "http": return {
+			...base,
+			baseUrl: server.baseUrl,
+			authType: server.auth.type,
+			actions: Object.fromEntries(Object.entries(server.actions).map(([name, action]) => [name, {
+				method: action.method,
+				path: action.path
+			}])),
+			requestTimeoutMs: server.requestTimeoutMs
+		};
+		case "cli": return {
+			...base,
+			cwd: server.cwd,
+			actions: Object.fromEntries(Object.entries(server.actions).map(([name, action]) => [name, {
+				command: action.command,
+				args: action.args,
+				cwd: action.cwd
+			}])),
+			timeoutMs: server.timeoutMs,
+			maxOutputBytes: server.maxOutputBytes
+		};
+		case "caplets": return {
+			...base,
+			configPath: server.configPath,
+			capletsRoot: server.capletsRoot,
+			defaultSearchLimit: server.defaultSearchLimit,
+			maxSearchLimit: server.maxSearchLimit
+		};
+	}
+}
+function negativeReason(error) {
+	if (error instanceof CapletsError) {
+		if (error.code === "AUTH_REQUIRED" || error.code === "AUTH_FAILED" || error.code === "AUTH_REFRESH_FAILED") return "auth_required";
+		if (error.code === "SERVER_UNAVAILABLE" || error.code === "SERVER_START_TIMEOUT") return "unavailable";
+		if (error.code === "UNSUPPORTED_CAPABILITY" || error.code === "UNSUPPORTED_OPERATION") return "unsupported";
+		if (error.code === "TOOL_CALL_TIMEOUT" || error.code === "DOWNSTREAM_COMPLETION_ERROR") return "timeout";
+	}
+	return error instanceof Error && error.message.includes("timeout") ? "timeout" : "error";
+}
+async function withTimeout(promise, timeoutMs) {
+	let timeout;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("completion discovery timeout")), timeoutMs);
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function enabledServer(serverId, config) {
+	const server = config.mcpServers[serverId] ?? config.openapiEndpoints[serverId] ?? config.graphqlEndpoints[serverId] ?? config.httpApis[serverId] ?? config.cliTools[serverId] ?? config.capletSets[serverId];
+	return server && !server.disabled ? server : void 0;
+}
+function dedupeCandidates(candidates) {
+	const seen = /* @__PURE__ */ new Set();
+	return candidates.filter((candidate) => {
+		if (seen.has(candidate.value)) return false;
+		seen.add(candidate.value);
+		return true;
+	});
+}
+//#endregion
+//#region src/cli/completion.ts
+var completion_exports = /* @__PURE__ */ __exportAll({
+	completeCliWords: () => completeCliWords,
+	completionScript: () => completionScript,
+	trailingSpaceCompletionToken: () => trailingSpaceCompletionToken
+});
+const trailingSpaceCompletionToken = "__CAPLETS_TRAILING_SPACE__";
+const optionValueSuggestions = {
+	"*": { "--format": [
+		"markdown",
+		"md",
+		"plain",
+		"json"
+	] },
+	serve: { "--transport": ["stdio", "http"] },
+	"add:mcp": { "--transport": ["http", "sse"] },
+	"add:cli": { "--include": [
+		"git",
+		"gh",
+		"package"
+	] }
+};
+function completionScript(shell) {
+	switch (shell) {
+		case "bash": return bashCompletionScript();
+		case "zsh": return zshCompletionScript();
+		case "fish": return fishCompletionScript();
+		case "powershell": return powershellCompletionScript();
+		case "cmd": return cmdCompletionScript();
+		default: throw new CapletsError("REQUEST_INVALID", "completion shell must be bash, zsh, fish, powershell, or cmd");
+	}
+}
+async function completeCliWords(words, options = {}) {
+	try {
+		const normalized = words.length === 0 ? [""] : words;
+		const current = normalized.at(-1) ?? "";
+		const previous = normalized.at(-2);
+		const command = normalized[0] ?? "";
+		const subcommand = normalized[1] ?? "";
+		if (command === cliCommands.complete && previous === "--prompt" && subcommand) return prefixFilter((await discoverCompletionCandidates(subcommand, "prompts", discoveryOptions(options))).map((candidate) => candidate.value.replace(`${subcommand}.`, "")), current);
+		if (command === cliCommands.complete && previous === "--resource-template" && subcommand) return prefixFilter((await discoverCompletionCandidates(subcommand, "resourceTemplates", discoveryOptions(options))).map((candidate) => candidate.value), current);
+		const optionValues = suggestionsForOptionValue(command, subcommand, previous);
+		if (optionValues) return prefixFilter(optionValues, current);
+		if (normalized.length === 1) return prefixFilter([...topLevelCommandNames], current);
+		if (normalized.length === 2 && command in cliSubcommands) return prefixFilter(cliSubcommands[command], current);
+		if (normalized.length === 2 && capletIdCommands.has(command)) return prefixFilter(promptResourceCommands.has(command) ? configuredCapletIds(options, { backend: "mcp" }) : configuredCapletIds(options), current);
+		if (normalized.length === 2 && (qualifiedToolCommands.has(command) || qualifiedPromptCommands.has(command))) {
+			if (current.includes(".")) return prefixFilter((await discoverCompletionCandidates(current.slice(0, current.indexOf(".")), qualifiedToolCommands.has(command) ? "tools" : "prompts", discoveryOptions(options))).map((candidate) => candidate.value), current);
+			return prefixFilter(configuredCapletIds(options, qualifiedPromptCommands.has(command) ? { backend: "mcp" } : void 0).map((id) => `${id}.`), current);
+		}
+		if (command === cliCommands.readResource && normalized.length === 3) return prefixFilter((await discoverCompletionCandidates(subcommand, "resources", discoveryOptions(options))).map((candidate) => candidate.value), current);
+		if (command === cliCommands.auth && ["login", "logout"].includes(subcommand) && normalized.length === 3) return prefixFilter(configuredCapletIds(options), current);
+		return [];
+	} catch {
+		return [];
+	}
+}
+function suggestionsForOptionValue(command, subcommand, previous) {
+	if (!previous) return void 0;
+	return optionValueSuggestions[`${command}:${subcommand}`]?.[previous] ?? optionValueSuggestions[command]?.[previous] ?? optionValueSuggestions["*"]?.[previous];
+}
+const promptResourceCommands = new Set([
+	cliCommands.getPrompt,
+	cliCommands.readResource,
+	cliCommands.complete
+]);
+function configuredCapletIds(options, filter = {}) {
+	return listCaplets(options.config ? {
+		config: options.config,
+		sources: {},
+		shadows: {}
+	} : loadConfigWithSources(options.configPath, options.projectConfigPath), { includeDisabled: false }).filter((row) => !filter.backend || row.backend === filter.backend).map((row) => row.server);
+}
+function discoveryOptions(options) {
+	return {
+		config: options.config ?? loadConfigWithSources(options.configPath, options.projectConfigPath).config,
+		completion: options.completion,
+		cacheDir: options.cacheDir,
+		managers: options.managers
+	};
+}
+function prefixFilter(values, prefix) {
+	return values.filter((value) => value.startsWith(prefix));
+}
+function bashCompletionScript() {
+	return `# caplets bash completion
+_caplets_completions() {
+  local IFS=$'\n'
+  COMPREPLY=( $(caplets __complete --shell bash -- "\${COMP_WORDS[@]:1}" 2>/dev/null) )
+}
+complete -o default -F _caplets_completions caplets
+`;
+}
+function zshCompletionScript() {
+	return `#compdef caplets
+_caplets() {
+  local -a suggestions
+  suggestions=("\${(@f)$(caplets __complete --shell zsh -- "\${words[@]:1}" 2>/dev/null)}")
+  compadd -- $suggestions
+}
+_caplets "$@"
+`;
+}
+function fishCompletionScript() {
+	return `# caplets fish completion
+function __caplets_complete
+  set -l tokens (commandline -opc)
+  set -l current (commandline -ct)
+  caplets __complete --shell fish -- $tokens[2..-1] $current 2>/dev/null
+end
+complete -c caplets -f -a '(__caplets_complete)'
+`;
+}
+function powershellCompletionScript() {
+	return `# caplets PowerShell completion
+Register-ArgumentCompleter -Native -CommandName caplets -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $tokens = @($commandAst.CommandElements | Select-Object -Skip 1 | ForEach-Object { $_.ToString() })
+  if ($tokens.Count -eq 0 -or $commandAst.Extent.Text.EndsWith(' ')) { $tokens += '${trailingSpaceCompletionToken}' }
+  caplets __complete --shell powershell -- @tokens 2>$null | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+`;
+}
+function cmdCompletionScript() {
+	return `@echo off
+REM caplets cmd completion helper
+REM cmd.exe has no native programmable completion API. This doskey macro prints suggestions for the current words.
+doskey caplets-complete=caplets __complete --shell cmd -- $* 2^>nul
+REM Usage: caplets-complete get-caplet 
+`;
+}
+//#endregion
+export { formatCapletList as a, resolveCliConfigPaths as c, trailingSpaceCompletionToken as i, cliCommands as l, completionScript as n, formatConfigPaths as o, completion_exports as r, listCaplets as s, completeCliWords as t, completionShells as u };

package/dist/config/paths.d.ts

@@ -2,10 +2,13 @@ type Platform = NodeJS.Platform;
 type PathEnv = NodeJS.ProcessEnv;
 export declare function defaultConfigBaseDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultStateBaseDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultCacheBaseDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultConfigPath(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultAuthDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultCompletionCacheDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare const DEFAULT_CONFIG_PATH: string;
 export declare const DEFAULT_AUTH_DIR: string;
+export declare const DEFAULT_COMPLETION_CACHE_DIR: string;
 export declare const PROJECT_CONFIG_FILE: string;
 export declare function resolveConfigPath(path?: string): string;
 export declare function resolveProjectConfigPath(cwd?: string): string;