@apappas1129/ngx-fluent-extract 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# @apappas1129/ngx-fluent-extract
+
+A report-only extraction CLI for [ngx-fluent](https://github.com/apappas1129/ngx-fluent). It diffs the translation keys used in your Angular app's code against each locale's `.ftl` file, and tells you what's **missing** (used in code, not defined) and **orphaned** (defined, never used).
+
+It never writes to `.ftl` files. Fluent messages can carry variants, attributes, and term references that a generated stub can't meaningfully guess — so this tool only reports, it doesn't scaffold.
+
+## When you'd need this
+
+Nothing in ngx-fluent stops your app from compiling or running if a translation key is missing — the `fluent` pipe just falls back to showing the raw key string (`'welcome-user'` instead of "Welcome!"). That's silent in dev and in code review; the first anyone notices is usually a user seeing a raw key in production, or a translator asking why a locale looks half-finished. Reach for this CLI when:
+
+- **You're about to add a new locale.** Point the config at the new `.ftl` file and see exactly which keys it's missing before you ship it, instead of finding out from a user.
+- **You just refactored or deleted a component.** The `.ftl` entries it used don't get cleaned up automatically — `orphaned` tells you what's now dead weight in your translation files.
+- **You want a CI check on PRs that touch templates or translations.** A key typo'd in a template, or added in code but never given a translation, exits non-zero — catch it before merge instead of after a user reports it.
+- **A `.ftl` file came back from a translator or survived a merge conflict.** Malformed Fluent syntax fails silently at runtime (the bundle just drops the broken entry); this CLI's `parseError` surfaces it as a build-breaking problem, not a runtime mystery.
+
+If none of that applies — small app, one locale, translations always land alongside the code that uses them — you probably don't need this yet.
+
+## Install
+
+```bash
+npm install --save-dev @apappas1129/ngx-fluent-extract
+```
+
+Requires TypeScript as a peer dependency (already present in any Angular project).
+
+## Usage
+
+```bash
+npx ngx-fluent-extract [scanRoot] [options]
+```
+
+- `scanRoot` — directory to scan from. Defaults to the current directory (like `code .` / `code <path>`).
+- `--config <path>` — path to the extraction config. Defaults to `<scanRoot>/ngx-fluent-extract.config.json`.
+- `--project <path>` — path to a `tsconfig.json`. Defaults to auto-discovery from `scanRoot` (following `references` one level).
+- `--json` — print the report as JSON instead of human-readable text.
+- `--help` — show usage.
+
+Exit code is non-zero only when a locale has **missing** keys or a **parse error**. Orphaned keys alone don't fail the run — they're hygiene, not a defect users will see.
+
+## Config
+
+`ngx-fluent-extract.config.json`, at the scan root:
+
+```json
+{
+  "locales": {
+    "en": "public/i18n/en.ftl",
+    "sv": "public/i18n/sv.ftl"
+  }
+}
+```
+
+Paths are resolved relative to the config file's own directory. There's no source-glob field — source files are discovered from the resolved `tsconfig.json`'s file list plus each `@Component`'s `templateUrl`/inline `template`, not by pattern matching.
+
+## What it detects
+
+- `'key' | fluent` pipe usage in templates (inline or external, via `templateUrl`)
+- `NgxFluentService.translate('key', ...)` calls in TypeScript, matched type-aware (via the TypeScript Compiler API) rather than by name alone, so an unrelated `.translate()` method on another class isn't mistaken for this library's
+
+A key that isn't a string literal (a variable, a function call) can't be resolved statically. Those surface as **dynamic key warnings** — file and line — rather than being silently dropped, so they don't corrupt the missing/orphaned counts.
+
+## Out of scope for v1
+
+- **Message attributes** (`login-button.title`) — `NgxFluentService.translate()` doesn't expose attribute lookup at all yet, so there's nothing in code for an attribute-aware report to check against.
+- **Fluent terms** (`-brand-name`) — terms are only referenced from within other messages, never from code. Checking whether a term is used anywhere in a `.ftl` file is a different job (dead-code-within-`.ftl`) from this tool's code-vs-translation-file diff.
+
+## Why a standalone CLI, not an `ng` builder
+
+An Angular builder (`ng run ... :extract-i18n`-style) would need `@angular-devkit/architect` and an `angular.json` target for what's fundamentally a diagnostic side-channel, not a build step. A plain CLI runs anywhere — this repo's own example apps, any CI pipeline — without that coupling. It ships as its own package rather than bundled into `@apappas1129/ngx-fluent` because that library is built with `ng-packagr` for Angular consumption, which can't produce a runnable `bin` script.
+
+A thin Angular builder that wraps this same CLI is a good scope for a community PR if there's demand — issues and PRs welcome.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { formatJson, formatText, run } from './index.js';
+function printHelp() {
+    console.log(`Usage: ngx-fluent-extract [scanRoot] [options]
+
+Diffs translation keys used in an Angular app's code against each locale's .ftl file.
+Report-only — never writes to .ftl files.
+
+Options:
+  --config <path>   Path to the extraction config (default: <scanRoot>/ngx-fluent-extract.config.json)
+  --project <path>  Path to a tsconfig.json (default: auto-discovered from scanRoot)
+  --json            Print the report as JSON instead of human-readable text
+  --help            Show this help message
+`);
+}
+const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    options: {
+        config: { type: 'string' },
+        project: { type: 'string' },
+        json: { type: 'boolean', default: false },
+        help: { type: 'boolean', default: false },
+    },
+});
+if (values.help) {
+    printHelp();
+    process.exit(0);
+}
+const scanRoot = positionals[0] ?? process.cwd();
+try {
+    const { report, exitCode } = run({ scanRoot, configPath: values.config, projectPath: values.project });
+    console.log(values.json ? formatJson(report) : formatText(report));
+    process.exitCode = exitCode;
+}
+catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+}

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractConfig } from './types.js';
+export declare const DEFAULT_CONFIG_FILENAME = "ngx-fluent-extract.config.json";
+/** Reads and validates the config, resolving each locale path relative to the config file's directory. */
+export declare function loadConfig(configPath: string): ExtractConfig;

package/dist/config.js

@@ -0,0 +1,40 @@
+import { readFileSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+export const DEFAULT_CONFIG_FILENAME = 'ngx-fluent-extract.config.json';
+/** Reads and validates the config, resolving each locale path relative to the config file's directory. */
+export function loadConfig(configPath) {
+    let raw;
+    try {
+        raw = readFileSync(configPath, 'utf8');
+    }
+    catch {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Config file is not valid JSON: ${configPath}\n${error.message}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Config file must be a JSON object with a "locales" field: ${configPath}`);
+    }
+    const locales = parsed['locales'];
+    if (typeof locales !== 'object' || locales === null || Array.isArray(locales)) {
+        throw new Error(`Config file's "locales" field must be an object mapping locale -> .ftl path: ${configPath}`);
+    }
+    const entries = Object.entries(locales);
+    if (entries.length === 0) {
+        throw new Error(`Config file's "locales" field must not be empty: ${configPath}`);
+    }
+    const configDir = dirname(configPath);
+    const resolved = {};
+    for (const [locale, path] of entries) {
+        if (typeof path !== 'string') {
+            throw new Error(`Config file's "locales.${locale}" must be a string path: ${configPath}`);
+        }
+        resolved[locale] = isAbsolute(path) ? path : resolve(configDir, path);
+    }
+    return { locales: resolved };
+}

package/dist/ftl-scan.d.ts

@@ -0,0 +1,7 @@
+export interface FtlScanResult {
+    messageIds: string[];
+    /** Human-readable summary of the first parse error found, or null if the file parsed cleanly. */
+    parseError: string | null;
+}
+/** Parses a locale's .ftl file, collecting top-level message identifiers and any Junk (parse error) entries. */
+export declare function scanFtlFile(path: string): FtlScanResult;

package/dist/ftl-scan.js

@@ -0,0 +1,30 @@
+import { readFileSync } from 'node:fs';
+import { FluentParser } from '@fluent/syntax';
+const parser = new FluentParser();
+/** Parses a locale's .ftl file, collecting top-level message identifiers and any Junk (parse error) entries. */
+export function scanFtlFile(path) {
+    let content;
+    try {
+        content = readFileSync(path, 'utf8');
+    }
+    catch {
+        return { messageIds: [], parseError: `File not found: ${path}` };
+    }
+    const resource = parser.parse(content);
+    const messageIds = [];
+    const junkMessages = [];
+    for (const entry of resource.body) {
+        if (entry.type === 'Message') {
+            messageIds.push(entry.id.name);
+        }
+        else if (entry.type === 'Junk') {
+            for (const annotation of entry.annotations) {
+                junkMessages.push(annotation.message);
+            }
+        }
+    }
+    return {
+        messageIds,
+        parseError: junkMessages.length > 0 ? junkMessages.join('; ') : null,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import type { Report } from './types.js';
+export interface RunOptions {
+    scanRoot: string;
+    configPath?: string;
+    projectPath?: string;
+}
+export interface RunResult {
+    report: Report;
+    exitCode: number;
+}
+export declare function run(options: RunOptions): RunResult;
+export { formatJson, formatText } from './report.js';
+export type { Report } from './types.js';

package/dist/index.js

@@ -0,0 +1,25 @@
+import { resolve } from 'node:path';
+import { DEFAULT_CONFIG_FILENAME, loadConfig } from './config.js';
+import { scanFtlFile } from './ftl-scan.js';
+import { buildReport, hasFailures } from './report.js';
+import { scanTemplates } from './template-scan.js';
+import { loadProgram, scanProgram } from './ts-scan.js';
+export function run(options) {
+    const scanRoot = resolve(options.scanRoot);
+    const configPath = options.configPath
+        ? resolve(scanRoot, options.configPath)
+        : resolve(scanRoot, DEFAULT_CONFIG_FILENAME);
+    const config = loadConfig(configPath);
+    const program = loadProgram(scanRoot, options.projectPath);
+    const tsResult = scanProgram(program);
+    const templateResult = scanTemplates(tsResult.componentTemplates);
+    const keyUsages = [...tsResult.keyUsages, ...templateResult.keyUsages];
+    const dynamicKeyWarnings = [...tsResult.dynamicKeyWarnings, ...templateResult.dynamicKeyWarnings];
+    const localeMessages = {};
+    for (const [locale, path] of Object.entries(config.locales)) {
+        localeMessages[locale] = scanFtlFile(path);
+    }
+    const report = buildReport(keyUsages, dynamicKeyWarnings, localeMessages);
+    return { report, exitCode: hasFailures(report) ? 1 : 0 };
+}
+export { formatJson, formatText } from './report.js';

package/dist/report.d.ts

@@ -0,0 +1,8 @@
+import type { DynamicKeyWarning, KeyUsage, Report } from './types.js';
+export declare function buildReport(keyUsages: KeyUsage[], dynamicKeyWarnings: DynamicKeyWarning[], localeMessages: Record<string, {
+    messageIds: string[];
+    parseError: string | null;
+}>): Report;
+export declare function hasFailures(report: Report): boolean;
+export declare function formatText(report: Report): string;
+export declare function formatJson(report: Report): string;

package/dist/report.js

@@ -0,0 +1,56 @@
+export function buildReport(keyUsages, dynamicKeyWarnings, localeMessages) {
+    const usedKeys = new Set(keyUsages.map((usage) => usage.key));
+    const locales = {};
+    for (const [locale, { messageIds, parseError }] of Object.entries(localeMessages)) {
+        if (parseError) {
+            // A partially-parsed file can't produce trustworthy missing/orphaned counts.
+            locales[locale] = { missing: [], orphaned: [], parseError };
+            continue;
+        }
+        const definedKeys = new Set(messageIds);
+        locales[locale] = {
+            missing: [...usedKeys].filter((key) => !definedKeys.has(key)).sort(),
+            orphaned: messageIds.filter((key) => !usedKeys.has(key)).sort(),
+            parseError: null,
+        };
+    }
+    return { locales, dynamicKeyWarnings };
+}
+export function hasFailures(report) {
+    return Object.values(report.locales).some((locale) => locale.missing.length > 0 || locale.parseError !== null);
+}
+export function formatText(report) {
+    const lines = [];
+    for (const [locale, localeReport] of Object.entries(report.locales)) {
+        lines.push(`${locale}:`);
+        if (localeReport.parseError) {
+            lines.push(`  parse error: ${localeReport.parseError}`);
+            lines.push('  (missing/orphaned skipped for this locale until the parse error is fixed)');
+            continue;
+        }
+        if (localeReport.missing.length === 0 && localeReport.orphaned.length === 0) {
+            lines.push('  ok');
+            continue;
+        }
+        if (localeReport.missing.length > 0) {
+            lines.push(`  missing (${localeReport.missing.length}):`);
+            for (const key of localeReport.missing)
+                lines.push(`    - ${key}`);
+        }
+        if (localeReport.orphaned.length > 0) {
+            lines.push(`  orphaned (${localeReport.orphaned.length}):`);
+            for (const key of localeReport.orphaned)
+                lines.push(`    - ${key}`);
+        }
+    }
+    if (report.dynamicKeyWarnings.length > 0) {
+        lines.push('');
+        lines.push(`dynamic keys, could not verify (${report.dynamicKeyWarnings.length}):`);
+        for (const warning of report.dynamicKeyWarnings)
+            lines.push(`  - ${warning.file}:${warning.line}`);
+    }
+    return lines.join('\n');
+}
+export function formatJson(report) {
+    return JSON.stringify(report, null, 2);
+}

package/dist/template-scan.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentTemplate } from './ts-scan.js';
+import type { DynamicKeyWarning, KeyUsage } from './types.js';
+export declare function scanTemplateText(text: string, file: string): {
+    keyUsages: KeyUsage[];
+    dynamicKeyWarnings: DynamicKeyWarning[];
+};
+export declare function scanTemplates(templates: ComponentTemplate[]): {
+    keyUsages: KeyUsage[];
+    dynamicKeyWarnings: DynamicKeyWarning[];
+};

package/dist/template-scan.js

@@ -0,0 +1,42 @@
+// ponytail: regex-based, not a full Angular template parser. Handles the common
+// `'key' | fluent` / `{{ someExpr | fluent }}` shapes; upgrade to @angular/compiler's
+// parseTemplate if a real-world template expression shape slips past this.
+const LITERAL_KEY_RE = /(['"])((?:\\.|(?!\1).)*)\1\s*\|\s*fluent\b/g;
+const PIPE_USAGE_RE = /\|\s*fluent\b/g;
+function lineAt(text, index) {
+    let line = 1;
+    for (let i = 0; i < index; i++) {
+        if (text.charCodeAt(i) === 10 /* \n */)
+            line++;
+    }
+    return line;
+}
+export function scanTemplateText(text, file) {
+    const keyUsages = [];
+    const dynamicKeyWarnings = [];
+    const literalEnds = new Set();
+    for (const match of text.matchAll(LITERAL_KEY_RE)) {
+        const index = match.index ?? 0;
+        const end = index + match[0].length;
+        literalEnds.add(end);
+        keyUsages.push({ key: match[2].replace(/\\(.)/g, '$1'), file, line: lineAt(text, index) });
+    }
+    for (const match of text.matchAll(PIPE_USAGE_RE)) {
+        const index = match.index ?? 0;
+        const end = index + match[0].length;
+        if (!literalEnds.has(end)) {
+            dynamicKeyWarnings.push({ file, line: lineAt(text, index) });
+        }
+    }
+    return { keyUsages, dynamicKeyWarnings };
+}
+export function scanTemplates(templates) {
+    const keyUsages = [];
+    const dynamicKeyWarnings = [];
+    for (const template of templates) {
+        const result = scanTemplateText(template.text, template.file);
+        keyUsages.push(...result.keyUsages);
+        dynamicKeyWarnings.push(...result.dynamicKeyWarnings);
+    }
+    return { keyUsages, dynamicKeyWarnings };
+}

package/dist/ts-scan.d.ts

@@ -0,0 +1,16 @@
+import ts from 'typescript';
+import type { DynamicKeyWarning, KeyUsage } from './types.js';
+export interface ComponentTemplate {
+    text: string;
+    /** Path used for reporting line numbers — the external template file, or the component's own file for inline templates. */
+    file: string;
+}
+export interface TsScanResult {
+    keyUsages: KeyUsage[];
+    dynamicKeyWarnings: DynamicKeyWarning[];
+    componentTemplates: ComponentTemplate[];
+}
+/** Loads a ts.Program from a tsconfig, following one level of project references to gather all root files. */
+export declare function loadProgram(scanRoot: string, projectPath?: string): ts.Program;
+/** Scans a ts.Program for NgxFluentService.translate() calls and @Component template sources. */
+export declare function scanProgram(program: ts.Program): TsScanResult;

package/dist/ts-scan.js

@@ -0,0 +1,109 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import ts from 'typescript';
+const NGX_FLUENT_SERVICE_SYMBOL_NAME = 'NgxFluentService';
+/**
+ * ponytail: matches by resolved type-symbol name only, not by declaration file path.
+ * Upgrade to checking the symbol's declaring module specifier if a same-named type from
+ * another package ever produces a false positive in practice.
+ */
+function isNgxFluentServiceCall(checker, expression) {
+    const type = checker.getTypeAtLocation(expression);
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    return symbol?.getName() === NGX_FLUENT_SERVICE_SYMBOL_NAME;
+}
+function isProjectSourceFile(sourceFile) {
+    return !sourceFile.isDeclarationFile && !sourceFile.fileName.includes('/node_modules/');
+}
+/** Loads a ts.Program from a tsconfig, following one level of project references to gather all root files. */
+export function loadProgram(scanRoot, projectPath) {
+    const configPath = projectPath
+        ? resolve(scanRoot, projectPath)
+        : ts.findConfigFile(scanRoot, ts.sys.fileExists, 'tsconfig.json');
+    if (!configPath) {
+        throw new Error(`No tsconfig.json found starting from ${scanRoot}. Pass --project to point at one explicitly.`);
+    }
+    const fileNames = new Set();
+    const seen = new Set();
+    let rootOptions = {};
+    function loadConfig(path, isRoot) {
+        const resolvedPath = resolve(path);
+        if (seen.has(resolvedPath))
+            return;
+        seen.add(resolvedPath);
+        const readResult = ts.readConfigFile(resolvedPath, ts.sys.readFile);
+        if (readResult.error) {
+            throw new Error(ts.flattenDiagnosticMessageText(readResult.error.messageText, '\n'));
+        }
+        const parsed = ts.parseJsonConfigFileContent(readResult.config, ts.sys, dirname(resolvedPath));
+        for (const fileName of parsed.fileNames)
+            fileNames.add(fileName);
+        if (isRoot)
+            rootOptions = parsed.options;
+        for (const ref of parsed.projectReferences ?? []) {
+            loadConfig(ts.resolveProjectReferencePath(ref), false);
+        }
+    }
+    loadConfig(configPath, true);
+    if (fileNames.size === 0) {
+        throw new Error(`${configPath} resolved to zero source files (check its "include"/"references").`);
+    }
+    return ts.createProgram({ rootNames: [...fileNames], options: rootOptions });
+}
+/** Scans a ts.Program for NgxFluentService.translate() calls and @Component template sources. */
+export function scanProgram(program) {
+    const checker = program.getTypeChecker();
+    const keyUsages = [];
+    const dynamicKeyWarnings = [];
+    const componentTemplates = [];
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!isProjectSourceFile(sourceFile))
+            continue;
+        const lineOf = (node) => sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+        const visit = (node) => {
+            if (ts.isCallExpression(node) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                node.expression.name.text === 'translate' &&
+                isNgxFluentServiceCall(checker, node.expression.expression)) {
+                const [keyArg] = node.arguments;
+                if (keyArg && ts.isStringLiteralLike(keyArg)) {
+                    keyUsages.push({ key: keyArg.text, file: sourceFile.fileName, line: lineOf(node) });
+                }
+                else {
+                    dynamicKeyWarnings.push({ file: sourceFile.fileName, line: lineOf(node) });
+                }
+            }
+            if (ts.isClassDeclaration(node)) {
+                for (const decorator of ts.getDecorators(node) ?? []) {
+                    if (!ts.isCallExpression(decorator.expression) ||
+                        !ts.isIdentifier(decorator.expression.expression) ||
+                        decorator.expression.expression.text !== 'Component') {
+                        continue;
+                    }
+                    const [arg] = decorator.expression.arguments;
+                    if (!arg || !ts.isObjectLiteralExpression(arg))
+                        continue;
+                    for (const prop of arg.properties) {
+                        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                            continue;
+                        if (prop.name.text === 'template' && ts.isStringLiteralLike(prop.initializer)) {
+                            componentTemplates.push({ text: prop.initializer.text, file: sourceFile.fileName });
+                        }
+                        else if (prop.name.text === 'templateUrl' && ts.isStringLiteralLike(prop.initializer)) {
+                            const templatePath = resolve(dirname(sourceFile.fileName), prop.initializer.text);
+                            try {
+                                componentTemplates.push({ text: readFileSync(templatePath, 'utf8'), file: templatePath });
+                            }
+                            catch {
+                                // Referenced template file doesn't exist on disk — nothing to scan.
+                            }
+                        }
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    return { keyUsages, dynamicKeyWarnings, componentTemplates };
+}

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+export interface ExtractConfig {
+    /** Locale code -> path to that locale's .ftl file, resolved relative to the config file's directory. */
+    locales: Record<string, string>;
+}
+export interface KeyUsage {
+    key: string;
+    file: string;
+    line: number;
+}
+export interface DynamicKeyWarning {
+    file: string;
+    line: number;
+}
+export interface LocaleReport {
+    missing: string[];
+    orphaned: string[];
+    parseError: string | null;
+}
+export interface Report {
+    locales: Record<string, LocaleReport>;
+    dynamicKeyWarnings: DynamicKeyWarning[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@apappas1129/ngx-fluent-extract",
+  "version": "0.1.0",
+  "description": "Extraction report CLI for ngx-fluent: diffs translation keys used in an Angular app's code against each locale's .ftl file.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "ngx-fluent-extract": "dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"require('node:fs').chmodSync('dist/cli.js', 0o755)\"",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@fluent/syntax": "^0.19.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apappas1129/ngx-fluent.git",
+    "directory": "ngx-fluent-extract"
+  },
+  "keywords": [
+    "i18n",
+    "l10n",
+    "localization",
+    "ftl",
+    "fluent",
+    "angular",
+    "cli"
+  ]
+}