@caplets/opencode 0.5.2 → 0.5.3

package/dist/completion-DZg_TWiX-C5ffzfh6.js

@@ -0,0 +1,497 @@
+import { i as loadConfigWithSources, n as __exportAll, s as CapletsError, t as DEFAULT_COMPLETION_CACHE_DIR } from "./service-D3W-LuOx-BOGHu_BV.js";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+//#region ../core/dist/completion-DZg_TWiX.js
+const completionShells = [
+	"bash",
+	"zsh",
+	"fish",
+	"powershell",
+	"cmd"
+];
+const cliCommands = {
+	completion: "completion",
+	completeHidden: "__complete",
+	codeMode: "code-mode",
+	serve: "serve",
+	attach: "attach",
+	cloud: "cloud",
+	init: "init",
+	setup: "setup",
+	doctor: "doctor",
+	list: "list",
+	install: "install",
+	add: "add",
+	inspect: "inspect",
+	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.codeMode,
+	cliCommands.attach,
+	cliCommands.cloud,
+	cliCommands.init,
+	cliCommands.setup,
+	cliCommands.doctor,
+	cliCommands.list,
+	cliCommands.install,
+	cliCommands.add,
+	cliCommands.inspect,
+	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.cloud]: ["auth"],
+	[cliCommands.codeMode]: ["types"],
+	[cliCommands.completion]: [...completionShells],
+	[cliCommands.config]: ["path", "paths"],
+	[cliCommands.serve]: [
+		"start",
+		"stop",
+		"status",
+		"restart",
+		"enable",
+		"disable"
+	],
+	[cliCommands.setup]: [
+		"codex",
+		"claude-code",
+		"opencode",
+		"pi",
+		"mcp-client"
+	]
+};
+const capletIdCommands = new Set([
+	cliCommands.inspect,
+	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]);
+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),
+		...Object.values(config.capletSets)
+	];
+}
+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`);
+}
+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;
+	});
+}
+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"] },
+	setup: { "--format": ["plain", "json"] },
+	"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 (qualifiedToolCommands.has(command) || qualifiedPromptCommands.has(command)) {
+			const kind = qualifiedToolCommands.has(command) ? "tools" : "prompts";
+			const idFilter = qualifiedPromptCommands.has(command) ? { backend: "mcp" } : void 0;
+			if (normalized.length === 2) {
+				if (current.includes(".")) return prefixFilter((await discoverCompletionCandidates(current.slice(0, current.indexOf(".")), kind, discoveryOptions(options))).map((candidate) => candidate.value), current);
+				return prefixFilter(configuredCapletIds(options, idFilter), current);
+			}
+			if (normalized.length === 3 && subcommand && !subcommand.includes(".")) {
+				if (current.startsWith("-")) return [];
+				return prefixFilter((await discoverCompletionCandidates(subcommand, kind, discoveryOptions(options))).map((candidate) => candidate.value.replace(`${subcommand}.`, "")), 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 inspect
+`;
+}
+//#endregion
+export { completion_exports as r };