{"version":3,"file":"args.mjs","names":[],"sources":["../../src/core/args.ts"],"sourcesContent":["import type { StandardJSONSchemaV1, StandardSchemaV1 } from '@standard-schema/spec';\nimport type { PadroneFieldMeta } from '../types/args-meta.ts';\nimport { camelToKebab } from '../util/shell-utils.ts';\nimport { asyncStreamRegistry } from '../util/stream.ts';\n\nexport type { PadroneArgsSchemaMeta, PadroneFieldMeta, SingleChar, StdinConfig } from '../types/args-meta.ts';\n\n/** Extract the JSON schema from a Standard Schema, returning it as a plain record. */\nexport function getJsonSchema(schema: StandardJSONSchemaV1): Record<string, any> {\n  return schema['~standard'].jsonSchema.input({\n    target: 'draft-2020-12',\n    libraryOptions: { unrepresentable: 'any' },\n  }) as Record<string, any>;\n}\n\nfunction getFieldJsonSchema(schema: StandardJSONSchemaV1 | undefined, field: string): Record<string, any> | undefined {\n  if (!schema) return undefined;\n  try {\n    const jsonSchema = getJsonSchema(schema);\n    if (jsonSchema.type === 'object' && jsonSchema.properties) return jsonSchema.properties[field];\n  } catch {}\n  return undefined;\n}\n\n/**\n * Checks if a field in the schema is an array type (e.g. `z.string().array()`).\n */\nexport function isArrayField(schema: StandardJSONSchemaV1 | undefined, field: string): boolean {\n  return getFieldJsonSchema(schema, field)?.type === 'array';\n}\n\n/**\n * Checks if a field is an async stream (marked with `asyncStream()` metadata).\n * Returns the item schema if provided, or `true` if it's a plain string stream.\n */\nexport function isAsyncStreamField(schema: StandardJSONSchemaV1 | undefined, field: string): { itemSchema?: StandardSchemaV1 } | false {\n  const prop = getFieldJsonSchema(schema, field);\n  const asyncStreamId = prop?.asyncStream;\n  if (asyncStreamId && asyncStreamRegistry.has(asyncStreamId)) {\n    const meta = asyncStreamRegistry.get(asyncStreamId);\n    return { itemSchema: meta?.itemSchema };\n  }\n\n  return false;\n}\n\n/**\n * Parse positional configuration to extract names and variadic info.\n */\nexport function parsePositionalConfig(positional: readonly string[]): { name: string; variadic: boolean }[] {\n  return positional.map((p) => {\n    const variadic = p.startsWith('...');\n    const name = variadic ? p.slice(3) : p;\n    return { name, variadic };\n  });\n}\n\n/**\n * Result type for extractSchemaMetadata function.\n */\ninterface SchemaMetadataResult {\n  /** Single-char flags: maps flag char → full arg name (e.g. `{ v: 'verbose' }`) */\n  flags: Record<string, string>;\n  /** Multi-char aliases: maps alias → full arg name (e.g. `{ 'dry-run': 'dryRun' }`) */\n  aliases: Record<string, string>;\n  /** Negative keywords: maps keyword → target arg name (e.g. `{ remote: 'local' }`) */\n  negatives: Record<string, string>;\n  /** Args that have custom negation set (even if empty), disabling the `--no-` prefix */\n  customNegation: Set<string>;\n}\n\nfunction addEntries(target: Record<string, string>, key: string, items: string | readonly string[], filter?: (item: string) => boolean) {\n  const list = typeof items === 'string' ? [items] : items;\n  for (const item of list) {\n    if (typeof item === 'string' && item && item !== key && !(item in target) && (!filter || filter(item))) {\n      target[item] = key;\n    }\n  }\n}\n\n/**\n * Extract all arg metadata from schema and meta in a single pass.\n * Returns flags (single-char, stackable) and aliases (multi-char, long names) separately.\n * When `autoAlias` is true (default), camelCase property names automatically get kebab-case aliases.\n */\nexport function extractSchemaMetadata(\n  schema: StandardJSONSchemaV1,\n  meta?: Record<string, PadroneFieldMeta | undefined>,\n  autoAlias?: boolean,\n): SchemaMetadataResult {\n  const flags: Record<string, string> = {};\n  const aliases: Record<string, string> = {};\n  const negatives: Record<string, string> = {};\n  const customNegation = new Set<string>();\n\n  // Extract from meta object\n  if (meta) {\n    for (const [key, value] of Object.entries(meta)) {\n      if (!value) continue;\n\n      if (value.flags) {\n        addEntries(flags, key, value.flags, (item) => item.length === 1);\n      }\n      if (value.alias) {\n        addEntries(aliases, key, value.alias, (item) => item.length > 1);\n      }\n      if (value.negative !== undefined) {\n        customNegation.add(key);\n        addEntries(negatives, key, value.negative);\n      }\n    }\n  }\n\n  // Extract from JSON schema properties\n  try {\n    const jsonSchema = getJsonSchema(schema) as Record<string, any>;\n    if (jsonSchema.type === 'object' && jsonSchema.properties) {\n      for (const [propertyName, propertySchema] of Object.entries(jsonSchema.properties as Record<string, any>)) {\n        if (!propertySchema) continue;\n\n        // Extract flags from schema `.meta({ flags: ... })`\n        const propFlags = propertySchema.flags;\n        if (propFlags) {\n          addEntries(flags, propertyName, propFlags, (item) => item.length === 1);\n        }\n\n        // Extract aliases from schema `.meta({ alias: ... })`\n        const propAlias = propertySchema.alias;\n        if (propAlias) {\n          const list = typeof propAlias === 'string' ? [propAlias] : propAlias;\n          if (Array.isArray(list)) {\n            addEntries(aliases, propertyName, list, (item) => item.length > 1);\n          }\n        }\n\n        // Extract negative keywords from schema `.meta({ negative: ... })`\n        const propNegative = propertySchema.negative;\n        if (propNegative !== undefined && !customNegation.has(propertyName)) {\n          customNegation.add(propertyName);\n          const list = typeof propNegative === 'string' ? [propNegative] : propNegative;\n          if (Array.isArray(list)) {\n            addEntries(negatives, propertyName, list);\n          }\n        }\n\n        // Auto-generate kebab-case alias for camelCase property names\n        if (autoAlias !== false) {\n          const kebab = camelToKebab(propertyName);\n          if (kebab && !(kebab in aliases)) {\n            aliases[kebab] = propertyName;\n          }\n        }\n      }\n    }\n  } catch {\n    // Ignore errors from JSON schema generation\n  }\n\n  return { flags, aliases, negatives, customNegation };\n}\n\nfunction preprocessMappings(data: Record<string, unknown>, mappings: Record<string, string>): Record<string, unknown> {\n  const result = { ...data };\n\n  for (const [mappedKey, fullArgName] of Object.entries(mappings)) {\n    if (mappedKey in data && mappedKey !== fullArgName) {\n      const mappedValue = data[mappedKey];\n      // Prefer full arg name if it exists\n      if (!(fullArgName in result)) result[fullArgName] = mappedValue;\n      delete result[mappedKey];\n    }\n  }\n\n  return result;\n}\n\n/**\n * Apply values to arguments using \"set if not present\" semantics.\n * Existing values take precedence — only fills in undefined or missing keys.\n */\nexport function applyValues(data: Record<string, unknown>, values: Record<string, unknown>): Record<string, unknown> {\n  const result = { ...data };\n\n  for (const [key, value] of Object.entries(values)) {\n    if (key in result && result[key] !== undefined) continue;\n    if (value !== undefined) {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\n/** Applies flag and alias mappings to raw arguments. */\nexport function preprocessArgs(\n  data: Record<string, unknown>,\n  ctx: { flags?: Record<string, string>; aliases?: Record<string, string> },\n): Record<string, unknown> {\n  let result = { ...data };\n\n  if (ctx.flags && Object.keys(ctx.flags).length > 0) {\n    result = preprocessMappings(result, ctx.flags);\n  }\n  if (ctx.aliases && Object.keys(ctx.aliases).length > 0) {\n    result = preprocessMappings(result, ctx.aliases);\n  }\n\n  return result;\n}\n\n/**\n * Walk a JSON schema fragment and collect the set of allowed primitive types,\n * descending into `anyOf` / `oneOf` (used for unions). For variants whose type\n * is `array`, item types are collected separately into `itemTypes`.\n */\nfunction collectAllowedTypes(prop: Record<string, any> | undefined, types: Set<string>, itemTypes: Set<string>): void {\n  if (!prop) return;\n\n  if (prop.type !== undefined) {\n    const list = Array.isArray(prop.type) ? prop.type : [prop.type];\n    for (const t of list) {\n      if (typeof t === 'string') types.add(t);\n    }\n    if (list.includes('array') && prop.items) {\n      collectAllowedTypes(prop.items, itemTypes, new Set());\n    }\n  }\n\n  const variants = prop.anyOf ?? prop.oneOf;\n  if (Array.isArray(variants)) {\n    for (const variant of variants) collectAllowedTypes(variant, types, itemTypes);\n  }\n}\n\n/** Coerce a single CLI string to a primitive based on the set of allowed types. */\nfunction coerceScalar(value: unknown, allowedTypes: Set<string>): unknown {\n  if (typeof value !== 'string') return value;\n\n  if (allowedTypes.has('boolean')) {\n    const lower = value.toLowerCase();\n    if (lower === 'true' || lower === '1' || lower === 'yes' || lower === 'on') return true;\n    if (lower === 'false' || lower === '0' || lower === 'no' || lower === 'off') return false;\n  }\n\n  if (allowedTypes.has('number') || allowedTypes.has('integer')) {\n    const trimmed = value.trim();\n    if (trimmed !== '') {\n      const num = Number(trimmed);\n      if (!Number.isNaN(num)) return num;\n    }\n  }\n\n  return value;\n}\n\n/**\n * Auto-coerce CLI string values to match the expected schema types.\n * Handles: string → number, string → boolean for primitive schema fields.\n * Arrays of primitives are also coerced element-wise.\n * Union types (`anyOf` / `oneOf`) are coerced to the most specific matching\n * primitive — e.g. `--test true` for `z.union([z.boolean(), z.string()])`\n * becomes the boolean `true` rather than the string \"true\".\n */\nexport function coerceArgs(data: Record<string, unknown>, schema: StandardJSONSchemaV1): Record<string, unknown> {\n  let properties: Record<string, any>;\n  try {\n    const jsonSchema = getJsonSchema(schema) as Record<string, any>;\n    if (jsonSchema.type !== 'object' || !jsonSchema.properties) return data;\n    properties = jsonSchema.properties;\n  } catch {\n    return data;\n  }\n\n  const result = { ...data };\n\n  for (const [key, value] of Object.entries(result)) {\n    const prop = properties[key];\n    if (!prop) continue;\n\n    const types = new Set<string>();\n    const itemTypes = new Set<string>();\n    collectAllowedTypes(prop, types, itemTypes);\n\n    const isArrayValue = Array.isArray(value);\n    const allowsArray = types.has('array');\n    const allowsScalar = types.has('string') || types.has('boolean') || types.has('number') || types.has('integer');\n\n    if (isArrayValue && allowsArray) {\n      result[key] = value.map((v) => coerceScalar(v, itemTypes));\n    } else if (!isArrayValue && allowsArray && !allowsScalar) {\n      // Wrap single value into an array when only array shapes are allowed\n      result[key] = [coerceScalar(value, itemTypes)];\n    } else if (!isArrayValue) {\n      result[key] = coerceScalar(value, types);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Detect unknown keys in the args that don't match any schema property.\n * Returns an array of { key } for each unknown key.\n * Framework-reserved keys (--config, -c) are always allowed.\n */\nexport function detectUnknownArgs(\n  data: Record<string, unknown>,\n  schema: StandardJSONSchemaV1,\n  flags: Record<string, string>,\n  aliases: Record<string, string>,\n  negatives?: Record<string, string>,\n): { key: string }[] {\n  let properties: Record<string, any>;\n  let isLoose = false;\n  try {\n    const jsonSchema = getJsonSchema(schema) as Record<string, any>;\n    if (jsonSchema.type !== 'object' || !jsonSchema.properties) return [];\n    properties = jsonSchema.properties;\n    // If additionalProperties is set (true, {}, or a schema), the schema allows extra keys\n    if (jsonSchema.additionalProperties !== undefined && jsonSchema.additionalProperties !== false) isLoose = true;\n  } catch {\n    return [];\n  }\n\n  if (isLoose) return [];\n\n  const knownKeys = new Set<string>([\n    ...Object.keys(properties),\n    ...Object.keys(flags),\n    ...Object.values(flags),\n    ...Object.keys(aliases),\n    ...Object.values(aliases),\n    ...(negatives ? Object.keys(negatives) : []),\n    ...(negatives ? Object.values(negatives) : []),\n  ]);\n  const unknowns: { key: string }[] = [];\n\n  for (const key of Object.keys(data)) {\n    if (!knownKeys.has(key)) {\n      unknowns.push({ key });\n    }\n  }\n\n  return unknowns;\n}\n"],"mappings":"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"}