@redpanda-data/docs-extensions-and-macros 5.14.0 → 5.17.0

package/tools/lint-strings/fixtures/properties/lint_fixture.h

@@ -0,0 +1,33 @@
+// Fixture header for lint-strings tests. The declarations mirror the shapes
+// in redpanda's src/v/config/configuration.h so the real property extractor
+// can parse the matching .cc file.
+#pragma once
+
+#include "config/property.h"
+
+namespace config {
+
+struct lint_fixture_config {
+    // Known-bad: empty description (mirrors configuration.cc
+    // compaction_ctrl_update_interval_ms)
+    property<std::chrono::milliseconds> compaction_ctrl_update_interval_ms;
+
+    // Known-bad: unbalanced backticks (mirrors configuration.cc
+    // cloud_storage_credentials_source)
+    enum_property<ss::sstring> cloud_storage_credentials_source;
+
+    // Known-bad: lowercase-start fragment, no terminal period
+    property<double> cloud_storage_upload_ctrl_p_coeff;
+
+    // Known-bad: tautology (description just restates the name)
+    property<std::optional<ss::sstring>> cluster_id;
+
+    // Known-bad: "recomended" typo string. Typo detection is NOT a lint rule;
+    // this doubles as the lowercase-start + under-20-chars example.
+    property<int32_t> write_caching_default_bytes;
+
+    // Conforming counterpart: must produce zero findings.
+    property<int32_t> kafka_batch_max_bytes;
+};
+
+} // namespace config

package/tools/lint-strings/fixtures/rpk/lint_cmd.go

@@ -0,0 +1,69 @@
+// Package lintfixture is a lint-strings test fixture: known-bad rpk
+// declarations with conforming counterparts. It only needs to parse as Go
+// text for the scanner; it is never compiled.
+package lintfixture
+
+import (
+	"github.com/spf13/afero"
+	"github.com/spf13/cobra"
+)
+
+// cobra.Command mentioned in a comment must never match: cobra.Command{Use: "fake"}.
+
+func newLowercaseShortCommand(fs afero.Fs) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "badshort",
+		Short: "queries cluster for health overview.",
+		Long: `Query the cluster.
+
+USAGE DETAILS
+
+This section heading above is intended.
+
+Some detail text here that is not a heading.
+====
+
+The ==== line above breaks the generated page.
+`,
+		Run: func(cmd *cobra.Command, _ []string) {
+			// A paren ) and brace } in a string: "don't break (the) scanner".
+		},
+	}
+	cmd.Flags().BoolVarP(&watch, "watch", "w", false, "Blocks and writes out all changes")
+	cmd.Flags().StringVar(&dest, "trailing-period", "", "Writes the output to the given path.")
+	cmd.Flags().String("verbose-output", "", "verbose output")
+	return cmd
+}
+
+const conformingLong = `Manage widgets.
+
+This is a conforming Long description with no heading-shaped lines,
+resolved through a package-level constant.
+`
+
+func newConformingCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "widget [NAME]",
+		Aliases: []string{"widgets"},
+		Short:   "Manage widgets in the cluster",
+		Long:    conformingLong,
+	}
+	f := cmd.Flags()
+	f.IntVar(&count, "retries", 3, "Number of retries before giving up")
+	f.DurationVar(&timeout, "timeout", 0, "How long to wait for the cluster to respond, for example 30s")
+	cmd.Flags().StringP("format", "f", "text", "Output format, one of text or json")
+	// Dynamic usage strings stay unverifiable, never errors:
+	cmd.Flags().BoolP("help", "h", false, "Help for "+cmd.Name())
+	return cmd
+}
+
+// A multiline Short: the rpk convention is a one-line Short, so this is the
+// known-bad counterpart for the rpk-short-multiline rule. Everything else
+// about it conforms, so it isolates that one rule.
+func newMultilineShortCommand() *cobra.Command {
+	return &cobra.Command{
+		Use: "multiline",
+		Short: `Manage the widget cache
+and everything attached to it`,
+	}
+}

package/tools/lint-strings/go-source.js

@@ -0,0 +1,327 @@
+'use strict'
+
+/**
+ * Shared Go source scanning helpers for the rpk, crd, and connect surfaces.
+ *
+ * Same philosophy as the metrics scanner (surfaces/metrics.js): a
+ * comment-masked regex/paren scanner over real source text, never a compiler.
+ * Go adds two string shapes the C++ scanner does not have: raw strings
+ * (`...` backticks, no escapes, literal newlines) and rune literals ('x').
+ * All helpers preserve offsets and newlines so line numbers stay exact.
+ */
+
+/**
+ * Replace // and /* *\/ comments with spaces, preserving every offset and
+ * newline. String and rune literal contents are left untouched, so a "//"
+ * inside a string never masks anything.
+ */
+function maskComments (content) {
+  const out = content.split('')
+  let i = 0
+  while (i < content.length) {
+    const ch = content[i]
+    if (ch === '"' || ch === '`' || ch === "'") {
+      i = skipString(content, i)
+      continue
+    }
+    if (ch === '/' && content[i + 1] === '/') {
+      while (i < content.length && content[i] !== '\n') out[i++] = ' '
+      continue
+    }
+    if (ch === '/' && content[i + 1] === '*') {
+      const end = content.indexOf('*/', i + 2)
+      const stop = end === -1 ? content.length : end + 2
+      while (i < stop) {
+        if (content[i] !== '\n') out[i] = ' '
+        i++
+      }
+      continue
+    }
+    i++
+  }
+  return out.join('')
+}
+
+/**
+ * Skip a Go string/rune literal starting at index; returns the index after
+ * it. Interpreted strings ("...") and runes ('x') honor backslash escapes;
+ * raw strings (`...`) have no escapes and may span lines.
+ */
+function skipString (content, start) {
+  const quote = content[start]
+  let i = start + 1
+  if (quote === '`') {
+    while (i < content.length && content[i] !== '`') i++
+    return Math.min(i + 1, content.length)
+  }
+  while (i < content.length) {
+    if (content[i] === '\\') {
+      i += 2
+      continue
+    }
+    if (content[i] === quote) return i + 1
+    i++
+  }
+  return content.length
+}
+
+/**
+ * Walk forward from an opening delimiter and return the index of its
+ * balanced closing delimiter, skipping string/rune literals. Assumes
+ * comment-masked content. Returns -1 when unbalanced.
+ */
+function findBalancedClose (content, openIndex, open = '(', close = ')') {
+  let depth = 0
+  let i = openIndex
+  while (i < content.length) {
+    const ch = content[i]
+    if (ch === '"' || ch === '`' || ch === "'") {
+      i = skipString(content, i)
+      continue
+    }
+    if (ch === open) depth++
+    if (ch === close) {
+      depth--
+      if (depth === 0) return i
+    }
+    i++
+  }
+  return -1
+}
+
+/** Decode a Go interpreted-string body (the text between the quotes). */
+function unescapeGo (text) {
+  return text.replace(/\\(.)/g, (whole, ch) => {
+    if (ch === 'n') return '\n'
+    if (ch === 't') return '\t'
+    if (ch === 'r') return '\r'
+    return ch
+  })
+}
+
+/**
+ * Split argument text on top-level commas (string, paren, brace, and
+ * bracket aware). Assumes comment-masked content.
+ */
+function splitTopLevelArgs (argText) {
+  const args = []
+  let start = 0
+  let depth = 0
+  let i = 0
+  while (i < argText.length) {
+    const ch = argText[i]
+    if (ch === '"' || ch === '`' || ch === "'") {
+      i = skipString(argText, i)
+      continue
+    }
+    if (ch === '(' || ch === '{' || ch === '[') depth++
+    if (ch === ')' || ch === '}' || ch === ']') depth--
+    if (ch === ',' && depth === 0) {
+      args.push(argText.slice(start, i))
+      start = i + 1
+    }
+    i++
+  }
+  const last = argText.slice(start)
+  if (last.trim() !== '' || args.length > 0) args.push(last)
+  return args
+}
+
+/**
+ * Collect same-file string constants: `const x = "..."` and const blocks.
+ * Only constants whose value is purely (concatenated) string literals are
+ * recorded - anything else stays unresolvable so it can never fake a
+ * verifiable description.
+ *
+ * @param {string} masked - Comment-masked file content
+ * @returns {Map<string, string>} identifier -> string value
+ */
+function collectStringConsts (masked) {
+  const consts = new Map()
+  const pattern = /\bconst\b/g
+  let match
+  while ((match = pattern.exec(masked)) !== null) {
+    let i = match.index + match[0].length
+    while (i < masked.length && /[ \t]/.test(masked[i])) i++
+    if (masked[i] === '(') {
+      const close = findBalancedClose(masked, i)
+      if (close === -1) continue
+      collectConstEntries(masked.slice(i + 1, close), consts)
+      pattern.lastIndex = close + 1
+    } else {
+      // Single-const form: the statement ends at the first newline OUTSIDE
+      // a string (a raw-string value may span lines), unless that newline
+      // follows a `+` continuation - Go allows a string concatenation to
+      // wrap across lines with no surrounding parens.
+      let j = i
+      while (j < masked.length) {
+        if (masked[j] === '"' || masked[j] === '`' || masked[j] === "'") {
+          j = skipString(masked, j)
+          continue
+        }
+        if (masked[j] === '\n') {
+          let k = j - 1
+          while (k >= i && /[ \t\r]/.test(masked[k])) k--
+          if (k >= i && masked[k] === '+') {
+            j++
+            continue
+          }
+          break
+        }
+        j++
+      }
+      collectConstEntries(masked.slice(i, j), consts)
+      pattern.lastIndex = j
+    }
+  }
+  return consts
+}
+
+/** Parse `name [type] = <string expr>` lines inside a const region. */
+function collectConstEntries (regionText, consts) {
+  // Split on newlines OUTSIDE strings (raw strings may span lines), unless
+  // the newline follows a `+` continuation - a string concatenation may
+  // wrap across lines with no surrounding parens, and must stay one entry.
+  const lines = []
+  let start = 0
+  let i = 0
+  while (i < regionText.length) {
+    const ch = regionText[i]
+    if (ch === '"' || ch === '`' || ch === "'") {
+      i = skipString(regionText, i)
+      continue
+    }
+    if (ch === '\n') {
+      let k = i - 1
+      while (k >= start && /[ \t\r]/.test(regionText[k])) k--
+      if (k >= start && regionText[k] === '+') {
+        i++
+        continue
+      }
+      lines.push(regionText.slice(start, i))
+      start = i + 1
+    }
+    i++
+  }
+  lines.push(regionText.slice(start))
+
+  for (const line of lines) {
+    const m = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*(?:[A-Za-z_][A-Za-z0-9_.]*\s*)?=\s*(.+)$/s)
+    if (!m) continue
+    const { verifiable, value } = evalStringExpr(m[2], consts)
+    if (verifiable) consts.set(m[1], value)
+  }
+}
+
+/**
+ * Evaluate a Go expression expected to produce a string: a sequence of
+ * string literals and known identifiers joined by `+`. Anything else
+ * (function calls, fmt.Sprintf, selectors, unknown identifiers) makes the
+ * result unverifiable - the caller reports it, never guesses.
+ *
+ * @param {string} exprText - Comment-masked expression text
+ * @param {Map<string, string>} [consts] - Same-file string constants
+ * @returns {{ verifiable: boolean, value: string|null, sawString: boolean }}
+ */
+function evalStringExpr (exprText, consts = new Map()) {
+  const parts = []
+  let verifiable = true
+  let sawString = false
+  let i = 0
+  while (i < exprText.length) {
+    const ch = exprText[i]
+    if (/\s/.test(ch) || ch === '+') {
+      i++
+      continue
+    }
+    if (ch === '"') {
+      const end = skipString(exprText, i)
+      parts.push(unescapeGo(exprText.slice(i + 1, end - 1)))
+      sawString = true
+      i = end
+      continue
+    }
+    if (ch === '`') {
+      const end = skipString(exprText, i)
+      parts.push(exprText.slice(i + 1, end - 1))
+      sawString = true
+      i = end
+      continue
+    }
+    if (/[A-Za-z_]/.test(ch)) {
+      let j = i
+      while (j < exprText.length && /[A-Za-z0-9_.]/.test(exprText[j])) j++
+      const ident = exprText.slice(i, j)
+      // A following "(" means a call - unverifiable.
+      let k = j
+      while (k < exprText.length && /\s/.test(exprText[k])) k++
+      if (exprText[k] === '(') {
+        verifiable = false
+        const close = findBalancedClose(exprText, k)
+        i = close === -1 ? exprText.length : close + 1
+        continue
+      }
+      if (consts.has(ident)) {
+        parts.push(consts.get(ident))
+        sawString = true
+      } else {
+        verifiable = false
+      }
+      i = j
+      continue
+    }
+    // Any other token (&, numbers, composite literals, ...) is not a string.
+    verifiable = false
+    if (ch === '(' || ch === '{' || ch === '[') {
+      const close = findBalancedClose(exprText, i, ch, ch === '(' ? ')' : ch === '{' ? '}' : ']')
+      i = close === -1 ? exprText.length : close + 1
+      continue
+    }
+    i++
+  }
+  if (!sawString) return { verifiable: false, value: null, sawString }
+  return { verifiable, value: verifiable ? parts.join('') : null, sawString }
+}
+
+/** 1-indexed line number of a character offset. */
+function lineOf (content, index) {
+  let line = 1
+  for (let i = 0; i < index; i++) {
+    if (content[i] === '\n') line++
+  }
+  return line
+}
+
+const fs = require('fs')
+const path = require('path')
+
+/**
+ * Recursively collect .go files under root (repo-relative paths), skipping
+ * _test.go files, testdata/fuzzing dirs, and hidden dirs.
+ */
+function collectGoFiles (root, base = root, out = []) {
+  if (!fs.existsSync(root)) return out
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (entry.name.startsWith('.')) continue
+    const fullPath = path.join(root, entry.name)
+    if (entry.isDirectory()) {
+      if (entry.name === 'testdata' || entry.name === 'fuzzing' || entry.name === 'node_modules') continue
+      collectGoFiles(fullPath, base, out)
+    } else if (entry.name.endsWith('.go') && !entry.name.endsWith('_test.go')) {
+      out.push(path.relative(base, fullPath))
+    }
+  }
+  return out
+}
+
+module.exports = {
+  maskComments,
+  skipString,
+  findBalancedClose,
+  unescapeGo,
+  splitTopLevelArgs,
+  collectStringConsts,
+  evalStringExpr,
+  lineOf,
+  collectGoFiles
+}

package/tools/lint-strings/index.js

@@ -0,0 +1,229 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+const { runRules, mergeResults } = require('./engine')
+const { getChangedLines, classifyDiff, spanIntersects, SURFACE_ROUTES } = require('./diff')
+const { COMMON_RULES } = require('./rules/common')
+const { VERBATIM_ASCIIDOC_RULES } = require('./rules/verbatim-asciidoc')
+
+/**
+ * doc-tools lint-strings: deterministic linting of user-facing doc strings
+ * embedded in engineering source code (the strings doc-tools publishes
+ * verbatim to docs.redpanda.com).
+ *
+ * Registered surfaces. SEAM: new surface modules plug in here - implement
+ * ./surfaces/<name>.js with the same contract as the existing modules
+ * ({ name, convention, extract({repo, files}), rules, [skipRules] }) and
+ * add it to this registry plus ./diff.js SURFACE_ROUTES for diff-mode path
+ * routing.
+ */
+const SURFACES = {
+  properties: require('./surfaces/properties'),
+  metrics: require('./surfaces/metrics'),
+  rpk: require('./surfaces/rpk'),
+  helm: require('./surfaces/helm'),
+  crd: require('./surfaces/crd'),
+  connect: require('./surfaces/connect')
+}
+
+/**
+ * Build the rule set for a surface: common rules + verbatim-AsciiDoc rules
+ * (for surfaces whose strings ship unescaped) + surface-specific rules.
+ * A surface may opt out of specific auto-applied rules via an optional
+ * skipRules array (for example, rpk skips too-short: one-line Shorts and
+ * flag usages are the convention, not a defect).
+ */
+function rulesFor (surface) {
+  const rules = [...COMMON_RULES]
+  if (surface.convention.verbatim_asciidoc) rules.push(...VERBATIM_ASCIIDOC_RULES)
+  rules.push(...surface.rules)
+  const skip = new Set(surface.skipRules || [])
+  return skip.size > 0 ? rules.filter((rule) => !skip.has(rule.name)) : rules
+}
+
+/**
+ * Run the linter.
+ *
+ * @param {Object} options
+ * @param {string} options.repo - Path to the engineering checkout (required)
+ * @param {string[]} [options.surfaces] - Surface names (default: all registered)
+ * @param {string} [options.diffBase] - Declaration-anchored diff mode: lint
+ *   only declarations whose span intersects lines changed since this ref
+ * @param {string[]} [options.skipRules]
+ * @param {string[]} [options.onlyRules]
+ * @param {Function} [options.log] - Progress logger (stderr by default)
+ * @returns {Object} { findings, summary, unsupported_surfaces }
+ */
+function lintStrings (options) {
+  const {
+    repo,
+    surfaces = null,
+    diffBase = null,
+    skipRules = [],
+    onlyRules = null,
+    log = (msg) => process.stderr.write(`${msg}\n`)
+  } = options
+
+  if (!repo) throw new Error('lint-strings requires --repo <path>')
+  const repoPath = path.resolve(repo)
+  if (!fs.existsSync(repoPath)) throw new Error(`Repo path does not exist: ${repoPath}`)
+
+  const requested = surfaces && surfaces.length > 0 ? surfaces : Object.keys(SURFACES)
+  for (const name of requested) {
+    if (!SURFACES[name]) {
+      const known = SURFACE_ROUTES.some((route) => route.surface === name)
+      throw new Error(known
+        ? `Surface "${name}" is routed but has no extractor registered yet. Registered: ${Object.keys(SURFACES).join(', ')}`
+        : `Unknown surface "${name}". Registered: ${Object.keys(SURFACES).join(', ')}`)
+    }
+  }
+
+  const results = []
+  const unsupportedSurfaces = []
+
+  if (diffBase) {
+    const changed = getChangedLines(repoPath, diffBase)
+    const classified = classifyDiff(changed)
+
+    for (const [surfaceName, files] of Object.entries(classified)) {
+      if (!SURFACES[surfaceName]) {
+        // Routed by path but no extractor registered yet (rpk/helm/crd/connect
+        // until their surface modules land). Report instead of dropping.
+        unsupportedSurfaces.push({ surface: surfaceName, files: [...files.keys()] })
+        continue
+      }
+      if (!requested.includes(surfaceName)) continue
+
+      const surface = SURFACES[surfaceName]
+      log(`[${surfaceName}] ${files.size} changed file(s) in diff; extracting declarations at HEAD...`)
+      const fileSet = new Set(files.keys())
+      const declarations = surface
+        .extract({ repo: repoPath, files: fileSet, log })
+        .filter((decl) => spanIntersects(decl.line_start, decl.line_end, files.get(decl.file)))
+      for (const decl of declarations) decl.in_pr_diff = true
+      results.push(runRules(declarations, rulesFor(surface), { skipRules, onlyRules }))
+    }
+  } else {
+    for (const surfaceName of requested) {
+      const surface = SURFACES[surfaceName]
+      log(`[${surfaceName}] extracting declarations from ${repoPath}...`)
+      const declarations = surface.extract({ repo: repoPath, log })
+      for (const decl of declarations) decl.in_pr_diff = false
+      results.push(runRules(declarations, rulesFor(surface), { skipRules, onlyRules }))
+    }
+  }
+
+  const merged = mergeResults(results)
+  merged.findings.sort((a, b) =>
+    a.surface.localeCompare(b.surface) || a.file.localeCompare(b.file) || (a.line_start || 0) - (b.line_start || 0))
+  merged.unsupported_surfaces = unsupportedSurfaces
+  return merged
+}
+
+/**
+ * Human-readable report (the default --format).
+ */
+function formatHuman (result) {
+  const lines = []
+  const { findings, summary } = result
+
+  for (const finding of findings) {
+    const span = finding.line_start != null ? `:${finding.line_start}-${finding.line_end}` : ''
+    const diffMark = finding.in_pr_diff ? ' [in PR diff]' : ''
+    lines.push(`${finding.file}${span}  ${finding.name || '(unresolved name)'}  (${finding.surface})${diffMark}`)
+    if (finding.string != null) {
+      const preview = finding.string.length > 100 ? `${finding.string.slice(0, 100)}...` : finding.string
+      lines.push(`  string: ${JSON.stringify(preview)}`)
+    }
+    for (const issue of finding.rules) {
+      lines.push(`  ${issue.severity.toUpperCase().padEnd(7)} [${issue.id}] ${issue.message}`)
+    }
+    lines.push('')
+  }
+
+  lines.push('='.repeat(60))
+  lines.push('LINT-STRINGS SUMMARY')
+  lines.push('='.repeat(60))
+  lines.push(`Declarations checked: ${summary.totalDeclarations}`)
+  lines.push(`Declarations flagged: ${summary.flaggedDeclarations}`)
+  lines.push(`Errors: ${summary.errors}  Warnings: ${summary.warnings}  Info: ${summary.info}`)
+  if (Object.keys(summary.byRule).length > 0) {
+    lines.push('\nBy rule:')
+    for (const [rule, counts] of Object.entries(summary.byRule).sort()) {
+      const parts = []
+      if (counts.errors) parts.push(`${counts.errors} errors`)
+      if (counts.warnings) parts.push(`${counts.warnings} warnings`)
+      if (counts.info) parts.push(`${counts.info} info`)
+      lines.push(`  ${rule}: ${parts.join(', ')}`)
+    }
+  }
+  if (Object.keys(summary.bySurface).length > 0) {
+    lines.push('\nBy surface:')
+    for (const [surface, counts] of Object.entries(summary.bySurface).sort()) {
+      lines.push(`  ${surface}: ${counts.flagged}/${counts.declarations} declarations flagged (${counts.errors} errors, ${counts.warnings} warnings, ${counts.info} info)`)
+    }
+  }
+  for (const entry of result.unsupported_surfaces || []) {
+    lines.push(`\nNote: diff touches ${entry.surface} files but that surface has no extractor registered yet: ${entry.files.join(', ')}`)
+  }
+  return lines.join('\n')
+}
+
+/**
+ * CLI entry point shared by bin/doc-tools.js and direct invocation
+ * (node tools/lint-strings --repo <path> ...).
+ *
+ * Exit code contract: always 0 (suggest, never block), unless --strict is
+ * passed AND there is at least one error-severity finding.
+ */
+function runCli (options) {
+  let result
+  try {
+    result = lintStrings({
+      repo: options.repo,
+      surfaces: options.surface ? String(options.surface).split(',').map((s) => s.trim()).filter(Boolean) : null,
+      diffBase: options.diff || null,
+      skipRules: options.skipRules ? String(options.skipRules).split(',').map((s) => s.trim()).filter(Boolean) : [],
+      onlyRules: options.onlyRules ? String(options.onlyRules).split(',').map((s) => s.trim()).filter(Boolean) : null
+    })
+  } catch (err) {
+    console.error(`Error: ${err.message}`)
+    process.exit(2)
+  }
+
+  if (options.format === 'json') {
+    console.log(JSON.stringify(result, null, 2))
+  } else {
+    console.log(formatHuman(result))
+  }
+
+  if (options.strict && result.summary.errors > 0) process.exit(1)
+  process.exit(0)
+}
+
+module.exports = { lintStrings, formatHuman, runCli, SURFACES, rulesFor }
+
+// Direct usage: node tools/lint-strings --repo <path> [--surface a,b]
+//   [--diff <base>] [--format json|human] [--strict]
+if (require.main === module) {
+  const args = process.argv.slice(2)
+  const options = {}
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === '--repo') options.repo = args[++i]
+    else if (arg === '--surface') options.surface = args[++i]
+    else if (arg === '--diff') options.diff = args[++i]
+    else if (arg === '--format') options.format = args[++i]
+    else if (arg === '--skip-rules') options.skipRules = args[++i]
+    else if (arg === '--only-rules') options.onlyRules = args[++i]
+    else if (arg === '--strict') options.strict = true
+    else {
+      console.error(`Unknown argument: ${arg}`)
+      console.error('Usage: node tools/lint-strings --repo <path> [--surface a,b] [--diff <base>] [--format json|human] [--skip-rules a,b] [--only-rules a,b] [--strict]')
+      process.exit(2)
+    }
+  }
+  runCli(options)
+}