@caplets/opencode 0.5.3 → 0.5.5

package/dist/completion-DZg_TWiX-C5ffzfh6.js

@@ -1,497 +0,0 @@
-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 };