{"version":3,"file":"commands.mjs","names":[],"sources":["../../src/core/commands.ts"],"sourcesContent":["import type { AnyPadroneCommand } from '../types/index.ts';\nimport { extractSchemaMetadata, getJsonSchema } from './args.ts';\nimport { resolveRuntime } from './default-runtime.ts';\nimport type { ResolvedPadroneRuntime } from './runtime.ts';\n\n// ---------------------------------------------------------------------------\n// Lazy command resolution\n// ---------------------------------------------------------------------------\n\nexport const lazyResolver = Symbol('lazyResolver');\n\n/** Resolves a lazy command in place by calling its stored resolver. No-op if already resolved. */\nexport function resolveCommand(cmd: AnyPadroneCommand): AnyPadroneCommand {\n  const resolver = (cmd as any)[lazyResolver];\n  if (resolver) {\n    delete (cmd as any)[lazyResolver];\n    resolver(cmd);\n  }\n  return cmd;\n}\n\n/** Recursively resolves a command and all its descendants. */\nexport function resolveAllCommands(cmd: AnyPadroneCommand): void {\n  resolveCommand(cmd);\n  if (cmd.commands) {\n    for (const sub of cmd.commands) resolveAllCommands(sub);\n  }\n}\n\n/** Checks whether a value is a Padrone program/builder. */\nexport function isPadroneProgram(value: unknown): value is object {\n  return !!value && typeof value === 'object' && commandSymbol in value;\n}\n\n/** Extracts the underlying command from a program/builder and resolves the full command tree. */\nexport function getCommand(program: object): AnyPadroneCommand {\n  const cmd = commandSymbol in program ? ((program as any)[commandSymbol] as AnyPadroneCommand) : (program as AnyPadroneCommand);\n  resolveAllCommands(cmd);\n  return cmd;\n}\n\nexport const commandSymbol = Symbol('padrone_command');\n\n/** Config keys that are merged when overriding a command. */\nexport const configKeys = ['title', 'description', 'version', 'deprecated', 'hidden', 'mutation', 'needsApproval'] as const;\n\n/**\n * Merges an existing command with an override.\n * - Config fields are shallow-merged (new overrides old).\n * - Action, arguments, meta, config schema, env schema are taken from the override if set.\n * - Subcommands are recursively merged by name.\n */\nexport function mergeCommands(existing: AnyPadroneCommand, override: AnyPadroneCommand): AnyPadroneCommand {\n  resolveCommand(existing);\n  resolveCommand(override);\n  const merged: AnyPadroneCommand = { ...existing };\n\n  // Merge config fields\n  for (const key of configKeys) {\n    if (override[key] !== undefined) (merged as any)[key] = override[key];\n  }\n\n  // Override fields: take from override if explicitly set (not inherited from existing via spread)\n  if (override.action !== existing.action) merged.action = override.action;\n  if (override.argsSchema !== existing.argsSchema) merged.argsSchema = override.argsSchema;\n  if (override.meta !== existing.meta) merged.meta = override.meta;\n  if (override.isAsync !== existing.isAsync) merged.isAsync = override.isAsync || existing.isAsync;\n  if (override.runtime !== existing.runtime) merged.runtime = override.runtime;\n  if (override.interceptors !== existing.interceptors) merged.interceptors = override.interceptors;\n  if (override.aliases !== existing.aliases) merged.aliases = override.aliases;\n  // Recursively merge subcommands by name\n  if (override.commands) {\n    const baseCommands = [...(existing.commands || [])];\n    for (const overrideChild of override.commands) {\n      const existingIndex = baseCommands.findIndex((c) => c.name === overrideChild.name);\n      if (existingIndex >= 0) {\n        baseCommands[existingIndex] = mergeCommands(baseCommands[existingIndex]!, overrideChild);\n      } else {\n        baseCommands.push(overrideChild);\n      }\n    }\n    merged.commands = baseCommands;\n  }\n\n  return merged;\n}\n\n/**\n * Resolves the runtime for a command by walking up the parent chain.\n * Returns a fully resolved runtime with all defaults filled in.\n */\nexport function getCommandRuntime(cmd: AnyPadroneCommand): ResolvedPadroneRuntime {\n  let current: AnyPadroneCommand | undefined = cmd;\n  while (current) {\n    if (current.runtime) return resolveRuntime(current.runtime);\n    current = current.parent;\n  }\n  return resolveRuntime();\n}\n\n/**\n * Recursively re-paths a command tree under a new parent path, updating parent references.\n */\nexport function repathCommandTree(\n  cmd: AnyPadroneCommand,\n  newName: string,\n  parentPath: string,\n  parent: AnyPadroneCommand,\n): AnyPadroneCommand {\n  resolveCommand(cmd);\n  const newPath = parentPath ? `${parentPath} ${newName}` : newName;\n  const remounted: AnyPadroneCommand = {\n    ...cmd,\n    name: newName,\n    path: newPath,\n    parent,\n    version: undefined,\n  };\n\n  if (cmd.commands?.length) {\n    remounted.commands = cmd.commands.map((child) => repathCommandTree(child, child.name, newPath, remounted));\n  }\n\n  return remounted;\n}\n\n/**\n * Builds a completer function for the REPL from the command tree.\n * Completes command names, subcommand names, option names (--foo), and aliases (-f).\n * Also includes dot-prefixed built-in REPL commands (.exit, .clear, .scope, .help, .history).\n */\nexport function buildReplCompleter(\n  rootCommand: AnyPadroneCommand,\n  builtins: {\n    inScope?: boolean;\n  },\n): (line: string) => [string[], string] {\n  resolveAllCommands(rootCommand);\n  return (line: string): [string[], string] => {\n    const trimmed = line.trimStart();\n    const parts = trimmed.split(/\\s+/);\n    const lastPart = parts[parts.length - 1] ?? '';\n\n    // If we're completing a dot-command\n    if (lastPart.startsWith('.')) {\n      const dotCmds = ['.exit', '.clear', '.help', '.history'];\n      if (rootCommand.commands?.some((c) => c.commands?.length) || builtins.inScope) dotCmds.push('.scope');\n      const hits = dotCmds.filter((c) => c.startsWith(lastPart));\n      return [hits.length ? hits : dotCmds, lastPart];\n    }\n\n    // If we're completing an option (starts with -)\n    if (lastPart.startsWith('-')) {\n      // Find which command we're in\n      const commandParts = parts.slice(0, -1).filter((p) => !p.startsWith('-'));\n      let targetCommand = rootCommand;\n      for (const part of commandParts) {\n        resolveCommand(targetCommand);\n        const sub = targetCommand.commands?.find((c) => c.name === part || c.aliases?.includes(part));\n        if (sub) {\n          resolveCommand(sub);\n          targetCommand = sub;\n        } else break;\n      }\n\n      // Get options for this command\n      const options: string[] = [];\n      if (targetCommand.argsSchema) {\n        try {\n          const argsMeta = targetCommand.meta?.fields;\n          const { flags, aliases } = extractSchemaMetadata(targetCommand.argsSchema, argsMeta, targetCommand.meta?.autoAlias);\n          const jsonSchema = getJsonSchema(targetCommand.argsSchema) as Record<string, any>;\n          if (jsonSchema.type === 'object' && jsonSchema.properties) {\n            for (const key of Object.keys(jsonSchema.properties)) {\n              options.push(`--${key}`);\n            }\n            for (const flag of Object.keys(flags)) {\n              options.push(`-${flag}`);\n            }\n            for (const alias of Object.keys(aliases)) {\n              options.push(`--${alias}`);\n            }\n          }\n        } catch {\n          // Ignore schema parsing errors\n        }\n      }\n      // Add global flags\n      options.push('--help', '-h');\n\n      const hits = options.filter((o) => o.startsWith(lastPart));\n      return [hits.length ? hits : options, lastPart];\n    }\n\n    // Completing command names\n    const commandParts = parts.filter((p) => !p.startsWith('-'));\n    // Walk into subcommands for all but the last token\n    let targetCommand = rootCommand;\n    for (let i = 0; i < commandParts.length - 1; i++) {\n      resolveCommand(targetCommand);\n      const sub = targetCommand.commands?.find((c) => c.name === commandParts[i] || c.aliases?.includes(commandParts[i]!));\n      if (sub) {\n        resolveCommand(sub);\n        targetCommand = sub;\n      } else break;\n    }\n\n    const candidates: string[] = [];\n\n    // Add subcommand names and aliases\n    if (targetCommand.commands) {\n      for (const cmd of targetCommand.commands) {\n        if (!cmd.hidden) {\n          candidates.push(cmd.name);\n          if (cmd.aliases) candidates.push(...cmd.aliases);\n        }\n      }\n    }\n\n    // Add dot-commands and `..` shorthand at the root level (relative to current scope)\n    if (targetCommand === rootCommand) {\n      candidates.push('.help', '.exit', '.clear', '.history');\n      if (rootCommand.commands?.some((c) => c.commands?.length) || builtins.inScope) candidates.push('.scope');\n      if (builtins.inScope) candidates.push('..');\n    }\n\n    const hits = candidates.filter((c) => c.startsWith(lastPart));\n    return [hits.length ? hits : candidates, lastPart];\n  };\n}\n\n/**\n * Computes the Levenshtein edit distance between two strings.\n */\nfunction levenshtein(a: string, b: string): number {\n  const m = a.length;\n  const n = b.length;\n  const dp: number[] = Array.from({ length: n + 1 }, (_, i) => i);\n\n  for (let i = 1; i <= m; i++) {\n    let prev = dp[0]!;\n    dp[0] = i;\n    for (let j = 1; j <= n; j++) {\n      const temp = dp[j]!;\n      dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j]!, dp[j - 1]!);\n      prev = temp;\n    }\n  }\n\n  return dp[n]!;\n}\n\n/**\n * Finds close matches from a list of candidates using Levenshtein distance\n * and prefix/substring matching (for inputs longer than 3 characters).\n * Returns up to 3 matching candidate names (raw, unformatted).\n */\nexport function suggestSimilar(input: string, candidates: string[]): string[] {\n  if (candidates.length === 0) return [];\n\n  const lower = input.toLowerCase();\n  const matches: { candidate: string; score: number }[] = [];\n\n  for (const candidate of candidates) {\n    const candidateLower = candidate.toLowerCase();\n    if (candidateLower === lower) continue;\n\n    const dist = levenshtein(lower, candidateLower);\n    const maxLen = Math.max(input.length, candidate.length);\n    const threshold = Math.min(3, Math.max(1, Math.ceil(maxLen * 0.4)));\n\n    if (dist > 0 && dist <= threshold) {\n      matches.push({ candidate, score: dist });\n    } else if (lower.length >= 3) {\n      // Prefix or substring match for longer inputs\n      if (candidateLower.startsWith(lower) || candidateLower.includes(lower)) {\n        matches.push({ candidate, score: threshold + 1 });\n      }\n    }\n  }\n\n  matches.sort((a, b) => a.score - b.score);\n  return matches.slice(0, 3).map((m) => m.candidate);\n}\n\nexport function findCommandByName(name: string, commands?: AnyPadroneCommand[]): AnyPadroneCommand | undefined {\n  if (!commands) return undefined;\n\n  const foundByName = commands.find((cmd) => cmd.name === name);\n  if (foundByName) return resolveCommand(foundByName);\n\n  // Check for aliases\n  const foundByAlias = commands.find((cmd) => cmd.aliases?.includes(name));\n  if (foundByAlias) return resolveCommand(foundByAlias);\n\n  for (const cmd of commands) {\n    if (name.startsWith(`${cmd.name} `)) {\n      resolveCommand(cmd);\n      if (cmd.commands) {\n        const subCommandName = name.slice(cmd.name.length + 1);\n        const subCommand = findCommandByName(subCommandName, cmd.commands);\n        if (subCommand) return subCommand;\n      }\n    }\n    // Check aliases for nested commands\n    if (cmd.aliases) {\n      for (const alias of cmd.aliases) {\n        if (name.startsWith(`${alias} `)) {\n          resolveCommand(cmd);\n          if (cmd.commands) {\n            const subCommandName = name.slice(alias.length + 1);\n            const subCommand = findCommandByName(subCommandName, cmd.commands);\n            if (subCommand) return subCommand;\n          }\n        }\n      }\n    }\n  }\n  return undefined;\n}\n\n// ---------------------------------------------------------------------------\n// Shared utilities for MCP and serve\n// ---------------------------------------------------------------------------\n\nexport type CollectedEndpoint = { name: string; command: AnyPadroneCommand };\n\n/** Collect all actionable commands recursively. Hidden commands are excluded. */\nexport function collectEndpoints(commands: AnyPadroneCommand[] | undefined, prefix: string): CollectedEndpoint[] {\n  if (!commands) return [];\n  const endpoints: CollectedEndpoint[] = [];\n  for (const cmd of commands) {\n    resolveCommand(cmd);\n    if (cmd.hidden) continue;\n    const path = cmd.name ? (prefix ? `${prefix}.${cmd.name}` : cmd.name) : prefix;\n    if (cmd.action || cmd.argsSchema) {\n      endpoints.push({ name: path, command: cmd });\n    }\n    if (cmd.commands?.length) {\n      endpoints.push(...collectEndpoints(cmd.commands, path));\n    }\n  }\n  return endpoints;\n}\n\n/** Build the JSON Schema for a command's arguments. */\nexport function buildInputSchema(cmd: AnyPadroneCommand): Record<string, unknown> {\n  if (!cmd.argsSchema) {\n    return { type: 'object', additionalProperties: false };\n  }\n  try {\n    return getJsonSchema(cmd.argsSchema) as Record<string, unknown>;\n  } catch {\n    return { type: 'object', additionalProperties: false };\n  }\n}\n\n/** Serialize a record of args into CLI flag strings. */\nexport function serializeArgsToFlags(args: Record<string, unknown>): string[] {\n  const parts: string[] = [];\n  for (const [key, value] of Object.entries(args)) {\n    if (value === undefined) continue;\n    if (typeof value === 'boolean') {\n      parts.push(value ? `--${key}` : `--no-${key}`);\n    } else if (Array.isArray(value)) {\n      for (const v of value) parts.push(`--${key}=${String(v)}`);\n    } else {\n      const strVal = String(value);\n      parts.push(strVal.includes(' ') ? `--${key}=\"${strVal}\"` : `--${key}=${strVal}`);\n    }\n  }\n  return parts;\n}\n"],"mappings":"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"}