@gaodefa/daocore 2026.5.74 → 2026.5.76

package/dist/completion-cli-uJRHgHYJ.js

@@ -0,0 +1,315 @@
+import { t as formatDocsLink } from "./links-738LMw6G.js";
+import { r as theme } from "./theme-D58JpUfy.js";
+import { a as routeLogsToStderr } from "./console-DkZh-KMc.js";
+import { a as installCompletion, c as resolveCompletionCachePath, s as isCompletionShell, t as COMPLETION_SHELLS, u as resolveShellFromEnv } from "./completion-runtime-BfGS2hGl.js";
+import { n as registerSubCliByName, t as getSubCliEntries } from "./register.subclis-core-CXo28UGO.js";
+import { n as registerCoreCliByName, t as getCoreCliCommandNames } from "./command-registry-core-Q8mKRnm2.js";
+import { t as getProgramContext } from "./program-context-qqDjqw9S.js";
+import path from "node:path";
+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
+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 firstShell = params.shells[0] ?? "zsh";
+	const cacheDir = path.dirname(resolveCompletionCachePath(firstShell, params.binName));
+	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 writeCompletionRegistrationWarning(message) {
+	process.stderr.write(`[completion] ${message}\n`);
+}
+async function registerSubcommandsForCompletion(program) {
+	const entries = getSubCliEntries();
+	for (const entry of entries) {
+		if (entry.name === "completion") continue;
+		try {
+			await registerSubCliByName(program, entry.name, process.argv, { purpose: "completion" });
+		} catch (error) {
+			writeCompletionRegistrationWarning(`skipping subcommand \`${entry.name}\` while building completion cache: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+}
+function registerCompletionCli(program) {
+	program.command("completion").description("Generate shell completion script").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/completion", "daocore-ai.vercel.app/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 $DAOCORE_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);
+		await registerSubcommandsForCompletion(program);
+		if (process.env["DAOCORE_COMPLETION_SKIP_PLUGIN_COMMANDS"] !== "1") {
+			const { registerPluginCliCommandsFromValidatedConfig } = await import("./cli-BETu1LsL.js");
+			await registerPluginCliCommandsFromValidatedConfig(program, void 0, void 0, { mode: "eager" });
+		}
+		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");
+	});
+}
+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)}
+
+_${rootCmd}_register_completion() {
+  if (( ! $+functions[compdef] )); then
+    return 0
+  fi
+
+  compdef _${rootCmd}_root_completion ${rootCmd}
+  precmd_functions=(\${precmd_functions:#_${rootCmd}_register_completion})
+  unfunction _${rootCmd}_register_completion 2>/dev/null
+}
+
+_${rootCmd}_register_completion
+if (( ! $+functions[compdef] )); then
+  typeset -ga precmd_functions
+  if [[ -z "\${precmd_functions[(r)_${rootCmd}_register_completion]}" ]]; then
+    precmd_functions+=(_${rootCmd}_register_completion)
+  fi
+fi
+`;
+}
+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 { getCompletionScript, registerCompletionCli };

package/dist/components-u4gL95dv.d.ts

@@ -0,0 +1,228 @@
+import { m as InteractiveReply } from "./get-reply-options.types-BXrapyJ-.js";
+import { n as TopLevelComponents } from "./payload-U2icqU80.js";
+import { n as Modal, o as ComponentParserResult, r as TextDisplay, t as Label } from "./components.modal-glHG-y8o.js";
+//#region extensions/discord/src/component-custom-id.d.ts
+declare const DISCORD_COMPONENT_CUSTOM_ID_KEY = "occomp";
+declare const DISCORD_MODAL_CUSTOM_ID_KEY = "ocmodal";
+declare function buildDiscordComponentCustomId(params: {
+  componentId: string;
+  modalId?: string;
+}): string;
+declare function buildDiscordModalCustomId(modalId: string): string;
+declare function parseDiscordComponentCustomId(id: string): {
+  componentId: string;
+  modalId?: string;
+} | null;
+declare function parseDiscordModalCustomId(id: string): string | null;
+declare function parseDiscordComponentCustomIdForInteraction(id: string): ComponentParserResult;
+declare function parseDiscordModalCustomIdForInteraction(id: string): ComponentParserResult;
+//#endregion
+//#region extensions/discord/src/components.types.d.ts
+type DiscordComponentButtonStyle = "primary" | "secondary" | "success" | "danger" | "link";
+type DiscordComponentSelectType = "string" | "user" | "role" | "mentionable" | "channel";
+type DiscordComponentModalFieldType = "text" | "checkbox" | "radio" | "select" | "role-select" | "user-select";
+type DiscordComponentButtonSpec = {
+  label: string;
+  style?: DiscordComponentButtonStyle;
+  url?: string;
+  callbackData?: string; /** Internal use only: bypass dynamic component ids with a fixed custom id. */
+  internalCustomId?: string;
+  emoji?: {
+    name: string;
+    id?: string;
+    animated?: boolean;
+  };
+  disabled?: boolean; /** Keep this action available after a successful interaction. */
+  reusable?: boolean; /** Optional allowlist of users who can interact with this button (ids or names). */
+  allowedUsers?: string[];
+};
+type DiscordComponentSelectOption = {
+  label: string;
+  value: string;
+  description?: string;
+  emoji?: {
+    name: string;
+    id?: string;
+    animated?: boolean;
+  };
+  default?: boolean;
+};
+type DiscordComponentSelectSpec = {
+  type?: DiscordComponentSelectType;
+  callbackData?: string;
+  placeholder?: string;
+  minValues?: number;
+  maxValues?: number;
+  options?: DiscordComponentSelectOption[];
+  allowedUsers?: string[];
+};
+type DiscordComponentSectionAccessory = {
+  type: "thumbnail";
+  url: string;
+} | {
+  type: "button";
+  button: DiscordComponentButtonSpec;
+};
+type DiscordComponentSeparatorSpacing = "small" | "large" | 1 | 2;
+type DiscordComponentBlock = {
+  type: "text";
+  text: string;
+} | {
+  type: "section";
+  text?: string;
+  texts?: string[];
+  accessory?: DiscordComponentSectionAccessory;
+} | {
+  type: "separator";
+  spacing?: DiscordComponentSeparatorSpacing;
+  divider?: boolean;
+} | {
+  type: "actions";
+  buttons?: DiscordComponentButtonSpec[];
+  select?: DiscordComponentSelectSpec;
+} | {
+  type: "media-gallery";
+  items: Array<{
+    url: string;
+    description?: string;
+    spoiler?: boolean;
+  }>;
+} | {
+  type: "file";
+  file: `attachment://${string}`;
+  spoiler?: boolean;
+};
+type DiscordModalFieldSpec = {
+  type: DiscordComponentModalFieldType;
+  name?: string;
+  label: string;
+  description?: string;
+  placeholder?: string;
+  required?: boolean;
+  options?: DiscordComponentSelectOption[];
+  minValues?: number;
+  maxValues?: number;
+  minLength?: number;
+  maxLength?: number;
+  style?: "short" | "paragraph";
+};
+type DiscordModalSpec = {
+  title: string;
+  callbackData?: string;
+  triggerLabel?: string;
+  triggerStyle?: DiscordComponentButtonStyle;
+  allowedUsers?: string[];
+  fields: DiscordModalFieldSpec[];
+};
+type DiscordComponentMessageSpec = {
+  text?: string;
+  reusable?: boolean;
+  container?: {
+    accentColor?: string | number;
+    spoiler?: boolean;
+  };
+  blocks?: DiscordComponentBlock[];
+  modal?: DiscordModalSpec;
+};
+type DiscordComponentEntry = {
+  id: string;
+  kind: "button" | "select" | "modal-trigger";
+  label: string;
+  callbackData?: string;
+  selectType?: DiscordComponentSelectType;
+  options?: Array<{
+    value: string;
+    label: string;
+  }>;
+  modalId?: string;
+  sessionKey?: string;
+  agentId?: string;
+  accountId?: string;
+  reusable?: boolean;
+  consumptionGroupId?: string;
+  consumptionGroupEntryIds?: string[];
+  allowedUsers?: string[];
+  messageId?: string;
+  createdAt?: number;
+  expiresAt?: number;
+};
+type DiscordModalFieldDefinition = {
+  id: string;
+  name: string;
+  label: string;
+  type: DiscordComponentModalFieldType;
+  description?: string;
+  placeholder?: string;
+  required?: boolean;
+  options?: DiscordComponentSelectOption[];
+  minValues?: number;
+  maxValues?: number;
+  minLength?: number;
+  maxLength?: number;
+  style?: "short" | "paragraph";
+};
+type DiscordModalEntry = {
+  id: string;
+  title: string;
+  callbackData?: string;
+  fields: DiscordModalFieldDefinition[];
+  sessionKey?: string;
+  agentId?: string;
+  accountId?: string;
+  reusable?: boolean;
+  messageId?: string;
+  createdAt?: number;
+  expiresAt?: number;
+  allowedUsers?: string[];
+};
+type DiscordComponentBuildResult = {
+  components: TopLevelComponents[];
+  entries: DiscordComponentEntry[];
+  modals: DiscordModalEntry[];
+};
+//#endregion
+//#region extensions/discord/src/components.builders.d.ts
+declare function buildDiscordComponentMessage(params: {
+  spec: DiscordComponentMessageSpec;
+  fallbackText?: string;
+  sessionKey?: string;
+  agentId?: string;
+  accountId?: string;
+}): DiscordComponentBuildResult;
+declare function buildDiscordComponentMessageFlags(components: TopLevelComponents[]): number | undefined;
+//#endregion
+//#region extensions/discord/src/components.parse.d.ts
+declare const DISCORD_COMPONENT_ATTACHMENT_PREFIX = "attachment://";
+declare function resolveDiscordComponentAttachmentName(value: string): string;
+declare function readDiscordComponentSpec(raw: unknown): DiscordComponentMessageSpec | null;
+//#endregion
+//#region extensions/discord/src/components.modal.d.ts
+declare const ModalBase: typeof Modal;
+declare class DiscordFormModal extends ModalBase {
+  title: string;
+  customId: string;
+  components: Array<Label | TextDisplay>;
+  customIdParser: typeof parseDiscordModalCustomIdForInteraction;
+  constructor(params: {
+    modalId: string;
+    title: string;
+    fields: DiscordModalFieldDefinition[];
+  });
+  run(): Promise<void>;
+}
+declare function createDiscordFormModal(entry: DiscordModalEntry): Modal;
+//#endregion
+//#region extensions/discord/src/shared-interactive.d.ts
+/**
+ * @deprecated Use buildDiscordPresentationComponents with MessagePresentation.
+ */
+declare function buildDiscordInteractiveComponents(interactive?: InteractiveReply): DiscordComponentMessageSpec | undefined;
+//#endregion
+//#region extensions/discord/src/components.d.ts
+declare function formatDiscordComponentEventText(params: {
+  kind: "button" | "select";
+  label: string;
+  values?: string[];
+}): string;
+//#endregion
+export { parseDiscordComponentCustomIdForInteraction as A, DiscordModalFieldSpec as C, buildDiscordComponentCustomId as D, DISCORD_MODAL_CUSTOM_ID_KEY as E, parseDiscordModalCustomIdForInteraction as M, buildDiscordModalCustomId as O, DiscordModalFieldDefinition as S, DISCORD_COMPONENT_CUSTOM_ID_KEY as T, DiscordComponentSectionAccessory as _, DISCORD_COMPONENT_ATTACHMENT_PREFIX as a, DiscordComponentSelectType as b, buildDiscordComponentMessage as c, DiscordComponentBuildResult as d, DiscordComponentButtonSpec as f, DiscordComponentModalFieldType as g, DiscordComponentMessageSpec as h, createDiscordFormModal as i, parseDiscordModalCustomId as j, parseDiscordComponentCustomId as k, buildDiscordComponentMessageFlags as l, DiscordComponentEntry as m, buildDiscordInteractiveComponents as n, readDiscordComponentSpec as o, DiscordComponentButtonStyle as p, DiscordFormModal as r, resolveDiscordComponentAttachmentName as s, formatDiscordComponentEventText as t, DiscordComponentBlock as u, DiscordComponentSelectOption as v, DiscordModalSpec as w, DiscordModalEntry as x, DiscordComponentSelectSpec as y };