@heretek-ai/openclaw 2026.3.27 → 2026.3.29

package/dist/.buildstamp

@@ -1 +1 @@
-{"builtAt":1774362789993,"head":"8c105a767e34dbbc950e52858cad6e5623429498"}
+{"builtAt":1774369832018,"head":"11cc5e788a005e7630206b618fa8b88ecce3f492"}

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.3.27",
-  "commit": "8c105a767e34dbbc950e52858cad6e5623429498",
-  "builtAt": "2026-03-24T14:33:21.569Z"
+  "version": "2026.3.29",
+  "commit": "11cc5e788a005e7630206b618fa8b88ecce3f492",
+  "builtAt": "2026-03-24T16:31:01.165Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-b47b4db97ef184c2e90e6ad571812c36b72ba9f7830ef171e852a14d67e3ab53
+aefce4b5c9c1dc074a16e39a314f70b2bf435c912926142a174cbb3f7ec5e665

package/dist/chunks/command-registry-B9Orjysx.mjs

@@ -0,0 +1,214 @@
+import { E as getPrimaryCommand, k as hasHelpOrVersion } from "./logger-vRSRu9wD.mjs";
+import { a as removeCommandByName, i as registerSubCliCommands, o as reparseProgramFromActionArgs } from "./register.subclis-CVkk-8A3.mjs";
+import { t as getCoreCliCommandDescriptors } from "./core-command-descriptors-TFRcY_t7.mjs";
+
+//#region src/cli/program/command-registry.ts
+const shouldRegisterCorePrimaryOnly = (argv) => {
+	if (hasHelpOrVersion(argv)) return false;
+	return true;
+};
+const coreEntries = [
+	{
+		commands: [{
+			name: "setup",
+			description: "Initialize local config and agent workspace",
+			hasSubcommands: false
+		}],
+		register: async ({ program }) => {
+			(await import("./register.setup-BqV-_yA8.mjs")).registerSetupCommand(program);
+		}
+	},
+	{
+		commands: [{
+			name: "onboard",
+			description: "Interactive onboarding for gateway, workspace, and skills",
+			hasSubcommands: false
+		}],
+		register: async ({ program }) => {
+			(await import("./register.onboard-D128_sx4.mjs")).registerOnboardCommand(program);
+		}
+	},
+	{
+		commands: [{
+			name: "configure",
+			description: "Interactive configuration for credentials, channels, gateway, and agent defaults",
+			hasSubcommands: false
+		}],
+		register: async ({ program }) => {
+			(await import("./register.configure-zvnV2PSt.mjs")).registerConfigureCommand(program);
+		}
+	},
+	{
+		commands: [{
+			name: "config",
+			description: "Non-interactive config helpers (get/set/unset/file/validate). Default: starts guided setup.",
+			hasSubcommands: true
+		}],
+		register: async ({ program }) => {
+			(await import("./config-cli-BOBQYttC.mjs")).registerConfigCli(program);
+		}
+	},
+	{
+		commands: [{
+			name: "backup",
+			description: "Create and verify local backup archives for OpenClaw state",
+			hasSubcommands: true
+		}],
+		register: async ({ program }) => {
+			(await import("./register.backup-xkhaqqi_.mjs")).registerBackupCommand(program);
+		}
+	},
+	{
+		commands: [
+			{
+				name: "doctor",
+				description: "Health checks + quick fixes for the gateway and channels",
+				hasSubcommands: false
+			},
+			{
+				name: "dashboard",
+				description: "Open the Control UI with your current token",
+				hasSubcommands: false
+			},
+			{
+				name: "reset",
+				description: "Reset local config/state (keeps the CLI installed)",
+				hasSubcommands: false
+			},
+			{
+				name: "uninstall",
+				description: "Uninstall the gateway service + local data (CLI remains)",
+				hasSubcommands: false
+			}
+		],
+		register: async ({ program }) => {
+			(await import("./register.maintenance-BdaRRBo0.mjs")).registerMaintenanceCommands(program);
+		}
+	},
+	{
+		commands: [{
+			name: "message",
+			description: "Send, read, and manage messages",
+			hasSubcommands: true
+		}],
+		register: async ({ program, ctx }) => {
+			(await import("./register.message-xPNqGndv.mjs")).registerMessageCommands(program, ctx);
+		}
+	},
+	{
+		commands: [{
+			name: "memory",
+			description: "Search and reindex memory files",
+			hasSubcommands: true
+		}],
+		register: async ({ program }) => {
+			(await import("../cli/memory-cli.mjs")).registerMemoryCli(program);
+		}
+	},
+	{
+		commands: [{
+			name: "mcp",
+			description: "Manage embedded Pi MCP servers",
+			hasSubcommands: true
+		}],
+		register: async ({ program }) => {
+			(await import("./mcp-cli-C-78eMUr.mjs")).registerMcpCli(program);
+		}
+	},
+	{
+		commands: [{
+			name: "agent",
+			description: "Run one agent turn via the Gateway",
+			hasSubcommands: false
+		}, {
+			name: "agents",
+			description: "Manage isolated agents (workspaces, auth, routing)",
+			hasSubcommands: true
+		}],
+		register: async ({ program, ctx }) => {
+			(await import("./register.agent-CfJLdlXL.mjs")).registerAgentCommands(program, { agentChannelOptions: ctx.agentChannelOptions });
+		}
+	},
+	{
+		commands: [
+			{
+				name: "status",
+				description: "Show channel health and recent session recipients",
+				hasSubcommands: false
+			},
+			{
+				name: "health",
+				description: "Fetch health from the running gateway",
+				hasSubcommands: false
+			},
+			{
+				name: "sessions",
+				description: "List stored conversation sessions",
+				hasSubcommands: true
+			}
+		],
+		register: async ({ program }) => {
+			(await import("./register.status-health-sessions-BzfZ47A5.mjs")).registerStatusHealthSessionsCommands(program);
+		}
+	},
+	{
+		commands: [{
+			name: "browser",
+			description: "Manage OpenClaw's dedicated browser (Chrome/Chromium)",
+			hasSubcommands: true
+		}],
+		register: async ({ program }) => {
+			(await import("./browser-cli-Dh3oTAem.mjs")).registerBrowserCli(program);
+		}
+	}
+];
+function getCoreCliCommandNames() {
+	return getCoreCliCommandDescriptors().map((command) => command.name);
+}
+function removeEntryCommands(program, entry) {
+	for (const cmd of entry.commands) removeCommandByName(program, cmd.name);
+}
+function registerLazyCoreCommand(program, ctx, entry, command) {
+	const placeholder = program.command(command.name).description(command.description);
+	placeholder.allowUnknownOption(true);
+	placeholder.allowExcessArguments(true);
+	placeholder.action(async (...actionArgs) => {
+		removeEntryCommands(program, entry);
+		await entry.register({
+			program,
+			ctx,
+			argv: process.argv
+		});
+		await reparseProgramFromActionArgs(program, actionArgs);
+	});
+}
+async function registerCoreCliByName(program, ctx, name, argv = process.argv) {
+	const entry = coreEntries.find((candidate) => candidate.commands.some((cmd) => cmd.name === name));
+	if (!entry) return false;
+	removeEntryCommands(program, entry);
+	await entry.register({
+		program,
+		ctx,
+		argv
+	});
+	return true;
+}
+function registerCoreCliCommands(program, ctx, argv) {
+	const primary = getPrimaryCommand(argv);
+	if (primary && shouldRegisterCorePrimaryOnly(argv)) {
+		const entry = coreEntries.find((candidate) => candidate.commands.some((cmd) => cmd.name === primary));
+		if (entry) {
+			const cmd = entry.commands.find((c) => c.name === primary);
+			if (cmd) registerLazyCoreCommand(program, ctx, entry, cmd);
+			return;
+		}
+	}
+	for (const entry of coreEntries) for (const cmd of entry.commands) registerLazyCoreCommand(program, ctx, entry, cmd);
+}
+function registerProgramCommands(program, ctx, argv = process.argv) {
+	registerCoreCliCommands(program, ctx, argv);
+	registerSubCliCommands(program, argv);
+}
+
+//#endregion
+export { registerProgramCommands as i, registerCoreCliByName as n, registerCoreCliCommands as r, getCoreCliCommandNames as t };

package/dist/chunks/command-registry-BtWKyYyZ.mjs

@@ -0,0 +1,14 @@
+import "./logger-vRSRu9wD.mjs";
+import "./paths-CNST7z3O.mjs";
+import "./tmp-openclaw-dir-BeWwpCKM.mjs";
+import "./theme-w86ra_7m.mjs";
+import "./globals-DZFR3wyP.mjs";
+import "./subsystem-yLe4Gjha.mjs";
+import "./ansi-BJ9IOlIp.mjs";
+import "./boolean-Bwxxidw8.mjs";
+import "./env-9fhyzTaG.mjs";
+import "./register.subclis-CVkk-8A3.mjs";
+import { n as getCoreCliCommandsWithSubcommands, t as getCoreCliCommandDescriptors } from "./core-command-descriptors-TFRcY_t7.mjs";
+import { i as registerProgramCommands, n as registerCoreCliByName, r as registerCoreCliCommands, t as getCoreCliCommandNames } from "./command-registry-B9Orjysx.mjs";
+
+export { registerCoreCliByName };

package/dist/chunks/completion-cli-B8M--XTS.mjs

@@ -0,0 +1,448 @@
+import { _ as resolveStateDir } from "./paths-CNST7z3O.mjs";
+import { r as theme } from "./theme-w86ra_7m.mjs";
+import { c as routeLogsToStderr } from "./subsystem-yLe4Gjha.mjs";
+import { h as pathExists } from "./utils-Dc9DiBqf.mjs";
+import { t as formatDocsLink } from "./links-BNNF54ea.mjs";
+import { r as registerSubCliByName, t as getSubCliEntries } from "./register.subclis-CVkk-8A3.mjs";
+import { n as registerCoreCliByName, t as getCoreCliCommandNames } from "./command-registry-B9Orjysx.mjs";
+import { t as getProgramContext } from "./program-context-9v4H9od4.mjs";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs/promises";
+import { Option } from "commander";
+
+//#region src/cli/completion-fish.ts
+function escapeFishDescription(value) {
+	return value.replace(/'/g, "'\\''");
+}
+function parseOptionFlags(flags) {
+	const parts = flags.split(/[ ,|]+/);
+	return {
+		long: parts.find((flag) => flag.startsWith("--"))?.replace(/^--/, ""),
+		short: parts.find((flag) => flag.startsWith("-") && !flag.startsWith("--"))?.replace(/^-/, "")
+	};
+}
+function buildFishSubcommandCompletionLine(params) {
+	const desc = escapeFishDescription(params.description);
+	return `complete -c ${params.rootCmd} -n "${params.condition}" -a "${params.name}" -d '${desc}'\n`;
+}
+function buildFishOptionCompletionLine(params) {
+	const { short, long } = parseOptionFlags(params.flags);
+	const desc = escapeFishDescription(params.description);
+	let line = `complete -c ${params.rootCmd} -n "${params.condition}"`;
+	if (short) line += ` -s ${short}`;
+	if (long) line += ` -l ${long}`;
+	line += ` -d '${desc}'\n`;
+	return line;
+}
+
+//#endregion
+//#region src/cli/completion-cli.ts
+const COMPLETION_SHELLS = [
+	"zsh",
+	"bash",
+	"powershell",
+	"fish"
+];
+function isCompletionShell(value) {
+	return COMPLETION_SHELLS.includes(value);
+}
+function resolveShellFromEnv(env = process.env) {
+	const shellPath = env.SHELL?.trim() ?? "";
+	const shellName = shellPath ? path.basename(shellPath).toLowerCase() : "";
+	if (shellName === "zsh") return "zsh";
+	if (shellName === "bash") return "bash";
+	if (shellName === "fish") return "fish";
+	if (shellName === "pwsh" || shellName === "powershell") return "powershell";
+	return "zsh";
+}
+function sanitizeCompletionBasename(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return "openclaw";
+	return trimmed.replace(/[^a-zA-Z0-9._-]/g, "-");
+}
+function resolveCompletionCacheDir(env = process.env) {
+	const stateDir = resolveStateDir(env, os.homedir);
+	return path.join(stateDir, "completions");
+}
+function resolveCompletionCachePath(shell, binName) {
+	const basename$1 = sanitizeCompletionBasename(binName);
+	const extension = shell === "powershell" ? "ps1" : shell === "fish" ? "fish" : shell === "bash" ? "bash" : "zsh";
+	return path.join(resolveCompletionCacheDir(), `${basename$1}.${extension}`);
+}
+/** Check if the completion cache file exists for the given shell. */
+async function completionCacheExists(shell, binName = "openclaw") {
+	return pathExists(resolveCompletionCachePath(shell, binName));
+}
+function getCompletionScript(shell, program) {
+	if (shell === "zsh") return generateZshCompletion(program);
+	if (shell === "bash") return generateBashCompletion(program);
+	if (shell === "powershell") return generatePowerShellCompletion(program);
+	return generateFishCompletion(program);
+}
+async function writeCompletionCache(params) {
+	const cacheDir = resolveCompletionCacheDir();
+	await fs.mkdir(cacheDir, { recursive: true });
+	for (const shell of params.shells) {
+		const script = getCompletionScript(shell, params.program);
+		const targetPath = resolveCompletionCachePath(shell, params.binName);
+		await fs.writeFile(targetPath, script, "utf-8");
+	}
+}
+function formatCompletionSourceLine(shell, binName, cachePath) {
+	if (shell === "fish") return `source "${cachePath}"`;
+	return `source "${cachePath}"`;
+}
+function isCompletionProfileHeader(line) {
+	return line.trim() === "# OpenClaw Completion";
+}
+function isCompletionProfileLine(line, binName, cachePath) {
+	if (line.includes(`${binName} completion`)) return true;
+	if (cachePath && line.includes(cachePath)) return true;
+	return false;
+}
+/** Check if a line uses the slow dynamic completion pattern (source <(...)) */
+function isSlowDynamicCompletionLine(line, binName) {
+	return line.includes(`<(${binName} completion`) || line.includes(`${binName} completion`) && line.includes("| source");
+}
+function updateCompletionProfile(content, binName, cachePath, sourceLine) {
+	const lines = content.split("\n");
+	const filtered = [];
+	let hadExisting = false;
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i] ?? "";
+		if (isCompletionProfileHeader(line)) {
+			hadExisting = true;
+			i += 1;
+			continue;
+		}
+		if (isCompletionProfileLine(line, binName, cachePath)) {
+			hadExisting = true;
+			continue;
+		}
+		filtered.push(line);
+	}
+	const trimmed = filtered.join("\n").trimEnd();
+	const block = `# OpenClaw Completion\n${sourceLine}`;
+	const next = trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
+	return {
+		next,
+		changed: next !== content,
+		hadExisting
+	};
+}
+function getShellProfilePath(shell) {
+	const home = process.env.HOME || os.homedir();
+	if (shell === "zsh") return path.join(home, ".zshrc");
+	if (shell === "bash") return path.join(home, ".bashrc");
+	if (shell === "fish") return path.join(home, ".config", "fish", "config.fish");
+	if (process.platform === "win32") return path.join(process.env.USERPROFILE || home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+	return path.join(home, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
+}
+async function isCompletionInstalled(shell, binName = "openclaw") {
+	const profilePath = getShellProfilePath(shell);
+	if (!await pathExists(profilePath)) return false;
+	const cachePathCandidate = resolveCompletionCachePath(shell, binName);
+	const cachedPath = await pathExists(cachePathCandidate) ? cachePathCandidate : null;
+	return (await fs.readFile(profilePath, "utf-8")).split("\n").some((line) => isCompletionProfileHeader(line) || isCompletionProfileLine(line, binName, cachedPath));
+}
+/**
+* Check if the profile uses the slow dynamic completion pattern.
+* Returns true if profile has `source <(openclaw completion ...)` instead of cached file.
+*/
+async function usesSlowDynamicCompletion(shell, binName = "openclaw") {
+	const profilePath = getShellProfilePath(shell);
+	if (!await pathExists(profilePath)) return false;
+	const cachePath = resolveCompletionCachePath(shell, binName);
+	const lines = (await fs.readFile(profilePath, "utf-8")).split("\n");
+	for (const line of lines) if (isSlowDynamicCompletionLine(line, binName) && !line.includes(cachePath)) return true;
+	return false;
+}
+function registerCompletionCli(program) {
+	program.command("completion").description("Generate shell completion script").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/completion", "docs.openclaw.ai/cli/completion")}\n`).addOption(new Option("-s, --shell <shell>", "Shell to generate completion for (default: zsh)").choices(COMPLETION_SHELLS)).option("-i, --install", "Install completion script to shell profile").option("--write-state", "Write completion scripts to $OPENCLAW_STATE_DIR/completions (no stdout)").option("-y, --yes", "Skip confirmation (non-interactive)", false).action(async (options) => {
+		routeLogsToStderr();
+		const shell = options.shell ?? "zsh";
+		const ctx = getProgramContext(program);
+		if (ctx) for (const name of getCoreCliCommandNames()) await registerCoreCliByName(program, ctx, name);
+		const entries = getSubCliEntries();
+		for (const entry of entries) {
+			if (entry.name === "completion") continue;
+			await registerSubCliByName(program, entry.name);
+		}
+		if (options.writeState) await writeCompletionCache({
+			program,
+			shells: options.shell ? [shell] : [...COMPLETION_SHELLS],
+			binName: program.name()
+		});
+		if (options.install) {
+			await installCompletion(options.shell ?? resolveShellFromEnv(), Boolean(options.yes), program.name());
+			return;
+		}
+		if (options.writeState) return;
+		if (!isCompletionShell(shell)) throw new Error(`Unsupported shell: ${shell}`);
+		const script = getCompletionScript(shell, program);
+		process.stdout.write(script + "\n");
+	});
+}
+async function installCompletion(shell, yes, binName = "openclaw") {
+	const home = process.env.HOME || os.homedir();
+	let profilePath = "";
+	let sourceLine = "";
+	if (!isCompletionShell(shell)) {
+		console.error(`Automated installation not supported for ${shell} yet.`);
+		return;
+	}
+	const cachePath = resolveCompletionCachePath(shell, binName);
+	if (!await pathExists(cachePath)) {
+		console.error(`Completion cache not found at ${cachePath}. Run \`${binName} completion --write-state\` first.`);
+		return;
+	}
+	if (shell === "zsh") {
+		profilePath = path.join(home, ".zshrc");
+		sourceLine = formatCompletionSourceLine("zsh", binName, cachePath);
+	} else if (shell === "bash") {
+		profilePath = path.join(home, ".bashrc");
+		try {
+			await fs.access(profilePath);
+		} catch {
+			profilePath = path.join(home, ".bash_profile");
+		}
+		sourceLine = formatCompletionSourceLine("bash", binName, cachePath);
+	} else if (shell === "fish") {
+		profilePath = path.join(home, ".config", "fish", "config.fish");
+		sourceLine = formatCompletionSourceLine("fish", binName, cachePath);
+	} else {
+		console.error(`Automated installation not supported for ${shell} yet.`);
+		return;
+	}
+	try {
+		try {
+			await fs.access(profilePath);
+		} catch {
+			if (!yes) console.warn(`Profile not found at ${profilePath}. Created a new one.`);
+			await fs.mkdir(path.dirname(profilePath), { recursive: true });
+			await fs.writeFile(profilePath, "", "utf-8");
+		}
+		const update = updateCompletionProfile(await fs.readFile(profilePath, "utf-8"), binName, cachePath, sourceLine);
+		if (!update.changed) {
+			if (!yes) console.log(`Completion already installed in ${profilePath}`);
+			return;
+		}
+		if (!yes) {
+			const action = update.hadExisting ? "Updating" : "Installing";
+			console.log(`${action} completion in ${profilePath}...`);
+		}
+		await fs.writeFile(profilePath, update.next, "utf-8");
+		if (!yes) console.log(`Completion installed. Restart your shell or run: source ${profilePath}`);
+	} catch (err) {
+		console.error(`Failed to install completion: ${err}`);
+	}
+}
+function generateZshCompletion(program) {
+	const rootCmd = program.name();
+	return `
+#compdef ${rootCmd}
+
+_${rootCmd}_root_completion() {
+  local -a commands
+  local -a options
+  
+  _arguments -C \\
+    ${generateZshArgs(program)} \\
+    ${generateZshSubcmdList(program)} \\
+    "*::arg:->args"
+
+  case $state in
+    (args)
+      case $line[1] in
+        ${program.commands.map((cmd) => `(${cmd.name()}) _${rootCmd}_${cmd.name().replace(/-/g, "_")} ;;`).join("\n        ")}
+      esac
+      ;;
+  esac
+}
+
+${generateZshSubcommands(program, rootCmd)}
+
+compdef _${rootCmd}_root_completion ${rootCmd}
+`;
+}
+function generateZshArgs(cmd) {
+	return (cmd.options || []).map((opt) => {
+		const flags = opt.flags.split(/[ ,|]+/);
+		const name = flags.find((f) => f.startsWith("--")) || flags[0];
+		const short = flags.find((f) => f.startsWith("-") && !f.startsWith("--"));
+		const desc = opt.description.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/'/g, "'\\''").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+		if (short) return `"(${name} ${short})"{${name},${short}}"[${desc}]"`;
+		return `"${name}[${desc}]"`;
+	}).join(" \\\n    ");
+}
+function generateZshSubcmdList(cmd) {
+	return `"1: :_values 'command' ${cmd.commands.map((c) => {
+		const desc = c.description().replace(/\\/g, "\\\\").replace(/'/g, "'\\''").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+		return `'${c.name()}[${desc}]'`;
+	}).join(" ")}"`;
+}
+function generateZshSubcommands(program, prefix) {
+	const segments = [];
+	const visit = (current, currentPrefix) => {
+		for (const cmd of current.commands) {
+			const nextPrefix = `${currentPrefix}_${cmd.name().replace(/-/g, "_")}`;
+			const funcName = `_${nextPrefix}`;
+			visit(cmd, nextPrefix);
+			const subCommands = cmd.commands;
+			if (subCommands.length > 0) {
+				segments.push(`
+${funcName}() {
+  local -a commands
+  local -a options
+  
+  _arguments -C \\
+    ${generateZshArgs(cmd)} \\
+    ${generateZshSubcmdList(cmd)} \\
+    "*::arg:->args"
+
+  case $state in
+    (args)
+      case $line[1] in
+        ${subCommands.map((sub) => `(${sub.name()}) ${funcName}_${sub.name().replace(/-/g, "_")} ;;`).join("\n        ")}
+      esac
+      ;;
+  esac
+}
+`);
+				continue;
+			}
+			segments.push(`
+${funcName}() {
+  _arguments -C \\
+    ${generateZshArgs(cmd)}
+}
+`);
+		}
+	};
+	visit(program, prefix);
+	return segments.join("");
+}
+function generateBashCompletion(program) {
+	const rootCmd = program.name();
+	return `
+_${rootCmd}_completion() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    
+    # Simple top-level completion for now
+    opts="${program.commands.map((c) => c.name()).join(" ")} ${program.options.map((o) => o.flags.split(" ")[0]).join(" ")}"
+    
+    case "\${prev}" in
+      ${program.commands.map((cmd) => generateBashSubcommand(cmd)).join("\n      ")}
+    esac
+
+    if [[ \${cur} == -* ]] ; then
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+    fi
+    
+    COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+}
+
+complete -F _${rootCmd}_completion ${rootCmd}
+`;
+}
+function generateBashSubcommand(cmd) {
+	return `${cmd.name()})
+        opts="${cmd.commands.map((c) => c.name()).join(" ")} ${cmd.options.map((o) => o.flags.split(" ")[0]).join(" ")}"
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+        ;;`;
+}
+function generatePowerShellCompletion(program) {
+	const rootCmd = program.name();
+	const segments = [];
+	const visit = (cmd, pathSegments) => {
+		const fullPath = pathSegments.join(" ");
+		const subCommands = cmd.commands.map((c) => c.name());
+		const options = cmd.options.map((o) => o.flags.split(/[ ,|]+/)[0]);
+		const allCompletions = [...subCommands, ...options].map((s) => `'${s}'`).join(",");
+		if (fullPath.length > 0 && allCompletions.length > 0) segments.push(`
+            if ($commandPath -eq '${fullPath}') {
+                $completions = @(${allCompletions})
+                $completions | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+                }
+            }
+`);
+		for (const sub of cmd.commands) visit(sub, [...pathSegments, sub.name()]);
+	};
+	visit(program, []);
+	const rootBody = segments.join("");
+	return `
+Register-ArgumentCompleter -Native -CommandName ${rootCmd} -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+    
+    $commandElements = $commandAst.CommandElements
+    $commandPath = ""
+    
+    # Reconstruct command path (simple approximation)
+    # Skip the executable name
+    for ($i = 1; $i -lt $commandElements.Count; $i++) {
+        $element = $commandElements[$i].Extent.Text
+        if ($element -like "-*") { break }
+        if ($i -eq $commandElements.Count - 1 -and $wordToComplete -ne "") { break } # Don't include current word being typed
+        $commandPath += "$element "
+    }
+    $commandPath = $commandPath.Trim()
+    
+    # Root command
+    if ($commandPath -eq "") {
+         $completions = @(${program.commands.map((c) => `'${c.name()}'`).join(",")}, ${program.options.map((o) => `'${o.flags.split(" ")[0]}'`).join(",")}) 
+         $completions | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+         }
+    }
+    
+    ${rootBody}
+}
+`;
+}
+function generateFishCompletion(program) {
+	const rootCmd = program.name();
+	const segments = [];
+	const visit = (cmd, parents) => {
+		const cmdName = cmd.name();
+		if (parents.length === 0) {
+			for (const sub of cmd.commands) segments.push(buildFishSubcommandCompletionLine({
+				rootCmd,
+				condition: "__fish_use_subcommand",
+				name: sub.name(),
+				description: sub.description()
+			}));
+			for (const opt of cmd.options) segments.push(buildFishOptionCompletionLine({
+				rootCmd,
+				condition: "__fish_use_subcommand",
+				flags: opt.flags,
+				description: opt.description
+			}));
+		} else {
+			for (const sub of cmd.commands) segments.push(buildFishSubcommandCompletionLine({
+				rootCmd,
+				condition: `__fish_seen_subcommand_from ${cmdName}`,
+				name: sub.name(),
+				description: sub.description()
+			}));
+			for (const opt of cmd.options) segments.push(buildFishOptionCompletionLine({
+				rootCmd,
+				condition: `__fish_seen_subcommand_from ${cmdName}`,
+				flags: opt.flags,
+				description: opt.description
+			}));
+		}
+		for (const sub of cmd.commands) visit(sub, [...parents, cmdName]);
+	};
+	visit(program, []);
+	return segments.join("");
+}
+
+//#endregion
+export { registerCompletionCli as a, usesSlowDynamicCompletion as c, isCompletionInstalled as i, getCompletionScript as n, resolveCompletionCachePath as o, installCompletion as r, resolveShellFromEnv as s, completionCacheExists as t };