@xano/cli 1.0.4 → 1.0.5

package/dist/commands/tenant/snapshot/swap/index.d.ts

@@ -0,0 +1,19 @@
+import BaseCommand from '../../../../base-command.js';
+export default class TenantSnapshotSwap extends BaseCommand {
+    static args: {
+        tenant_name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        snapshot: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private confirm;
+}

package/dist/commands/tenant/snapshot/swap/index.js

@@ -0,0 +1,103 @@
+import { Args, Flags } from '@oclif/core';
+import * as readline from 'node:readline';
+import BaseCommand from '../../../../base-command.js';
+export default class TenantSnapshotSwap extends BaseCommand {
+    static args = {
+        tenant_name: Args.string({
+            description: 'Tenant name to swap',
+            required: true,
+        }),
+    };
+    static description = "Swap a tenant's live database to a snapshot. This repoints the tenant; the current live database is left untouched, so you can swap back. To roll back, swap to the original database name.";
+    static examples = [
+        `$ xano tenant snapshot swap t1234-abcd-xyz1 --snapshot t1234-abcd-xyz1_bk_20260603_203614
+Swapped tenant t1234-abcd-xyz1 from t1234-abcd-xyz1 to t1234-abcd-xyz1_bk_20260603_203614
+`,
+        `$ xano tenant snapshot swap t1234-abcd-xyz1 --snapshot t1234-abcd-xyz1 --force`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skips the confirmation prompt.',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+        snapshot: Flags.string({
+            description: 'Snapshot database name to swap to (use the original tenant name to roll back)',
+            required: true,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (uses profile workspace if not provided)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TenantSnapshotSwap);
+        const { profile } = this.resolveProfile(flags);
+        const workspaceId = flags.workspace || profile.workspace;
+        if (!workspaceId) {
+            this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
+        }
+        const tenantName = args.tenant_name;
+        const { snapshot } = flags;
+        if (!flags.force) {
+            const confirmed = await this.confirm(`Swap tenant ${tenantName} to "${snapshot}"? This repoints the tenant's live database.`);
+            if (!confirmed) {
+                this.log('Swap cancelled.');
+                return;
+            }
+        }
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/tenant/${tenantName}/snapshot/swap`;
+        try {
+            const response = await this.verboseFetch(apiUrl, {
+                body: JSON.stringify({ snapshot }),
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'POST',
+            }, flags.verbose, profile.access_token);
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            const result = (await response.json());
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                this.log(`Swapped tenant ${tenantName} from ${result.from ?? 'unknown'} to ${result.to ?? snapshot}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to swap snapshot: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to swap snapshot: ${String(error)}`);
+            }
+        }
+    }
+    async confirm(message) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(`${message} (y/N) `, (answer) => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+            });
+        });
+    }
+}

package/dist/commands/tenant/unit_test/run/index.d.ts

@@ -6,6 +6,7 @@ export default class TenantUnitTestRun extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         tenant: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/tenant/unit_test/run/index.js

@@ -17,6 +17,11 @@ Result: PASS
     ];
     static flags = {
         ...BaseCommand.baseFlags,
+        branch: Flags.string({
+            char: 'b',
+            description: 'Branch the unit test belongs to (uses profile branch if not provided, then the live branch)',
+            required: false,
+        }),
         output: Flags.string({
             char: 'o',
             default: 'summary',
@@ -43,12 +48,14 @@ Result: PASS
             this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
         }
         const tenantName = encodeURIComponent(flags.tenant);
+        const branch = flags.branch ?? profile.branch;
         const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/tenant/${tenantName}/unit_test/${encodeURIComponent(args.unit_test_id)}/run`;
         try {
             if (flags.output === 'summary') {
                 this.log(`Running unit test ${args.unit_test_id}...`);
             }
             const response = await this.verboseFetch(apiUrl, {
+                body: JSON.stringify(branch ? { branch } : {}),
                 headers: {
                     accept: 'application/json',
                     Authorization: `Bearer ${profile.access_token}`,

package/dist/commands/tenant/unit_test/run_all/index.js

@@ -18,7 +18,7 @@ Results: 4 passed, 1 failed
         ...BaseCommand.baseFlags,
         branch: Flags.string({
             char: 'b',
-            description: 'Filter by branch name',
+            description: 'Branch to run tests from (uses profile branch if not provided, then the live branch)',
             required: false,
         }),
         'obj-type': Flags.string({
@@ -53,11 +53,14 @@ Results: 4 passed, 1 failed
         }
         const tenantName = encodeURIComponent(flags.tenant);
         const baseUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/tenant/${tenantName}/unit_test`;
+        // Resolve the branch once so the listed tests and the tests we run come
+        // from the same branch.
+        const branch = flags.branch ?? profile.branch;
         try {
             const listParams = new URLSearchParams();
             listParams.set('per_page', '10000');
-            if (flags.branch)
-                listParams.set('branch', flags.branch);
+            if (branch)
+                listParams.set('branch', branch);
             if (flags['obj-type'])
                 listParams.set('obj_type', flags['obj-type']);
             const listResponse = await this.verboseFetch(`${baseUrl}?${listParams}`, {
@@ -94,6 +97,7 @@ Results: 4 passed, 1 failed
                 const runUrl = `${baseUrl}/${test.id}/run`;
                 try {
                     const runResponse = await this.verboseFetch(runUrl, {
+                        body: JSON.stringify(branch ? { branch } : {}),
                         headers: {
                             accept: 'application/json',
                             Authorization: `Bearer ${profile.access_token}`,

package/dist/commands/unit_test/run/index.d.ts

@@ -6,6 +6,7 @@ export default class UnitTestRun extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/unit_test/run/index.js

@@ -14,9 +14,15 @@ Running unit test abc-123...
 Result: PASS
 `,
         `$ xano unit-test run abc-123 -o json`,
+        `$ xano unit-test run abc-123 --branch dev`,
     ];
     static flags = {
         ...BaseCommand.baseFlags,
+        branch: Flags.string({
+            char: 'b',
+            description: 'Branch the unit test belongs to (uses profile branch if not provided, then the live branch)',
+            required: false,
+        }),
         output: Flags.string({
             char: 'o',
             default: 'summary',
@@ -37,12 +43,14 @@ Result: PASS
         if (!workspaceId) {
             this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
         }
+        const branch = flags.branch ?? profile.branch;
         const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/unit_test/${args.unit_test_id}/run`;
         try {
             if (flags.output === 'summary') {
                 this.log(`Running unit test ${args.unit_test_id}...`);
             }
             const response = await this.verboseFetch(apiUrl, {
+                body: JSON.stringify(branch ? { branch } : {}),
                 headers: {
                     'accept': 'application/json',
                     'Authorization': `Bearer ${profile.access_token}`,

package/dist/commands/unit_test/run_all/index.js

@@ -19,7 +19,7 @@ Results: 2 passed, 1 failed
         ...BaseCommand.baseFlags,
         branch: Flags.string({
             char: 'b',
-            description: 'Filter by branch name',
+            description: 'Branch to run tests from (uses profile branch if not provided, then the live branch)',
             required: false,
         }),
         'obj-type': Flags.string({
@@ -48,12 +48,15 @@ Results: 2 passed, 1 failed
             this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
         }
         const baseUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/unit_test`;
+        // Resolve the branch once so the listed tests and the tests we run come
+        // from the same branch.
+        const branch = flags.branch ?? profile.branch;
         try {
             // Step 1: List all unit tests
             const listParams = new URLSearchParams();
             listParams.set('per_page', '10000');
-            if (flags.branch) {
-                listParams.set('branch', flags.branch);
+            if (branch) {
+                listParams.set('branch', branch);
             }
             if (flags['obj-type']) {
                 listParams.set('obj_type', flags['obj-type']);
@@ -93,6 +96,7 @@ Results: 2 passed, 1 failed
                 const runUrl = `${baseUrl}/${test.id}/run`;
                 try {
                     const runResponse = await this.verboseFetch(runUrl, {
+                        body: JSON.stringify(branch ? { branch } : {}),
                         headers: {
                             accept: 'application/json',
                             Authorization: `Bearer ${profile.access_token}`,

package/dist/commands/workspace/pull/index.js

@@ -4,11 +4,12 @@ import * as path from 'node:path';
 import snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
 import { buildApiGroupFolderResolver, parseDocument } from '../../../utils/document-parser.js';
+import { fetchKnowledge, writeKnowledge } from '../../../utils/knowledge-sync.js';
 export default class Pull extends BaseCommand {
     static description = 'Pull a workspace multidoc from the Xano Metadata API and split into individual files';
     static examples = [
         `$ xano workspace pull
-Pulled 42 documents to current directory
+Pulled 42 documents + 5 knowledge files to current directory
 `,
         `$ xano workspace pull -d ./my-workspace
 Pulled 42 documents to ./my-workspace
@@ -239,7 +240,17 @@ Pulled 58 documents
             fs.writeFileSync(filePath, doc.content, 'utf8');
             writtenCount++;
         }
-        this.log(`Pulled ${writtenCount} documents to ${flags.directory}`);
+        // ── Pull knowledge ────────────────────────────────────────────────────
+        const knowledgeUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/knowledge/sync`;
+        const knowledgeObjects = await fetchKnowledge(knowledgeUrl, branch, profile.access_token, this.verboseFetch.bind(this), flags.verbose);
+        let knowledgeCount = 0;
+        if (knowledgeObjects.length > 0) {
+            knowledgeCount = writeKnowledge(knowledgeObjects, outputDir);
+        }
+        const parts = [`${writtenCount} documents`];
+        if (knowledgeCount > 0)
+            parts.push(`${knowledgeCount} knowledge file${knowledgeCount === 1 ? '' : 's'}`);
+        this.log(`Pulled ${parts.join(' + ')} to ${flags.directory}`);
     }
     /**
      * Sanitize a document name for use as a filename.

package/dist/commands/workspace/push/index.d.ts

@@ -4,8 +4,8 @@ export default class Push extends BaseCommand {
     static examples: string[];
     static flags: {
         branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        directory: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         delete: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        directory: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         env: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         exclude: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/workspace/push/index.js

@@ -53,6 +53,12 @@ Push all files except tables
 `,
         `$ xano workspace push -i "function/*" -e "**/test*"
 Push functions but exclude test files
+`,
+        `$ xano workspace push -i "knowledge/**"
+Push only knowledge files (agents.md / skills / docs)
+`,
+        `$ xano workspace push --sync --delete
+Full sync including knowledge files; removes server objects not present locally
 `,
     ];
     static flags = {
@@ -62,17 +68,17 @@ Push functions but exclude test files
             description: 'Branch name (optional if set in profile, defaults to live)',
             required: false,
         }),
+        delete: Flags.boolean({
+            default: false,
+            description: '[CRITICAL] STOP and confirm with the user before running. Delete workspace objects not included in the push (requires --sync).',
+            required: false,
+        }),
         directory: Flags.string({
             char: 'd',
             default: '.',
             description: 'Directory containing documents to push (defaults to current directory)',
             required: false,
         }),
-        delete: Flags.boolean({
-            default: false,
-            description: '[CRITICAL] STOP and confirm with the user before running. Delete workspace objects not included in the push (requires --sync).',
-            required: false,
-        }),
         'dry-run': Flags.boolean({
             default: false,
             description: 'Show preview of changes without pushing (exit after preview)',
@@ -186,6 +192,10 @@ Push functions but exclude test files
             branch,
             command: this,
             inputDir,
+            knowledge: {
+                listUrl: () => `${baseUrl}/knowledge/sync`,
+                rootDir: inputDir,
+            },
             verboseFetch: this.verboseFetch.bind(this),
         }, target, pushFlags);
     }

package/dist/utils/function-input.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Input assembly for `xano function run`.
+ *
+ * A run's `input` is a single JSON object sent to the Metadata API. Users can
+ * build that object from several sources, which this module normalizes and
+ * merges:
+ *
+ *   --json <inline | @file | ->   a base JSON object
+ *   --data key=value              a string field (httpie convention)
+ *   --data key:=<json>            a raw-JSON field (numbers, bools, arrays, ...)
+ *   --data key@<file>             a field whose value is a file's contents (string)
+ *
+ * Merge order is: JSON base first, then --data pairs override — so the common
+ * "reuse a payload file, tweak one field" flow works without editing the file.
+ *
+ * Everything here is pure and free of oclif/network deps so it is unit-testable
+ * in isolation; the command layer handles fetching, prompting and output.
+ */
+export type JsonObject = Record<string, unknown>;
+/** A single declared function input parameter, as returned by the meta API. */
+export interface FunctionInputParam {
+    children?: FunctionInputParam[];
+    default?: unknown;
+    description?: string;
+    name: string;
+    nullable?: boolean;
+    required?: boolean;
+    style?: {
+        type?: string;
+    };
+    type?: string;
+    values?: unknown[];
+}
+/**
+ * Split a `--data` token into its key, operator and value.
+ * Recognizes, in priority order: `:=` (raw json), `@` (file), `=` (string).
+ * The operator is the FIRST occurrence scanned left-to-right, but `:=` is
+ * detected before a bare `=` at the same position so `k:=1` is raw-json, not
+ * a string key `k:` set to `=1`.
+ */
+export declare function splitDataToken(token: string): {
+    key: string;
+    op: ':=' | '=' | '@';
+    value: string;
+};
+/**
+ * Parse `--data` tokens into an object, applying httpie-style typing.
+ * Later tokens override earlier ones with the same key.
+ */
+export declare function parseDataPairs(pairs: string[], readFile?: (p: string) => string): JsonObject;
+/**
+ * Load the `--json` source: inline JSON, `@file`, or `-` (stdin, supplied by
+ * the caller via `stdin`). Must parse to a plain object; arrays/scalars are
+ * rejected because a function's input is always a keyed object.
+ */
+export declare function loadJsonSource(source: string | undefined, opts?: {
+    readFile?: (p: string) => string;
+    stdin?: () => string;
+}): JsonObject | undefined;
+/**
+ * Merge a JSON base with --data overrides into the final input object.
+ * Precedence: base first, then dataPairs override (shallow).
+ */
+export declare function assembleInput(opts: {
+    dataPairs?: JsonObject;
+    jsonBase?: JsonObject;
+}): JsonObject;
+/**
+ * Validate a supplied input object against a function's declared input schema.
+ * Non-destructive: returns lists the caller can act on (prompt for missing
+ * required params on a TTY, warn on enum mismatches, etc.). The server remains
+ * the source of truth, so type mismatches are warnings, not hard failures.
+ */
+export declare function validateAgainstSchema(input: JsonObject, schema: FunctionInputParam[] | undefined): {
+    missingRequired: FunctionInputParam[];
+    warnings: string[];
+};

package/dist/utils/function-input.js

@@ -0,0 +1,148 @@
+import * as fs from 'node:fs';
+/**
+ * Split a `--data` token into its key, operator and value.
+ * Recognizes, in priority order: `:=` (raw json), `@` (file), `=` (string).
+ * The operator is the FIRST occurrence scanned left-to-right, but `:=` is
+ * detected before a bare `=` at the same position so `k:=1` is raw-json, not
+ * a string key `k:` set to `=1`.
+ */
+export function splitDataToken(token) {
+    // Find the earliest `=` and `@`; `:=` is an `=` preceded by `:`.
+    const eq = token.indexOf('=');
+    const at = token.indexOf('@');
+    // Neither operator present -> invalid.
+    if (eq === -1 && at === -1) {
+        throw new Error(`Invalid --data '${token}'. Expected key=value, key:=json, or key@file.`);
+    }
+    // Choose whichever operator appears first. On a tie an '=' can't tie with '@'
+    // at the same index, so a simple "smallest index wins" is unambiguous.
+    const useAt = at !== -1 && (eq === -1 || at < eq);
+    if (useAt) {
+        const key = token.slice(0, at);
+        if (!key)
+            throw new Error(`Invalid --data '${token}': missing key before '@'.`);
+        return { key, op: '@', value: token.slice(at + 1) };
+    }
+    // `=` path — check for the `:=` raw-json form (a ':' immediately before '=').
+    if (eq > 0 && token[eq - 1] === ':') {
+        const key = token.slice(0, eq - 1);
+        if (!key)
+            throw new Error(`Invalid --data '${token}': missing key before ':='.`);
+        return { key, op: ':=', value: token.slice(eq + 1) };
+    }
+    const key = token.slice(0, eq);
+    if (!key)
+        throw new Error(`Invalid --data '${token}': missing key before '='.`);
+    return { key, op: '=', value: token.slice(eq + 1) };
+}
+/**
+ * Parse `--data` tokens into an object, applying httpie-style typing.
+ * Later tokens override earlier ones with the same key.
+ */
+export function parseDataPairs(pairs, readFile = defaultReadFile) {
+    const out = {};
+    for (const token of pairs) {
+        const { key, op, value } = splitDataToken(token);
+        switch (op) {
+            case ':=': {
+                try {
+                    out[key] = JSON.parse(value);
+                }
+                catch (error) {
+                    throw new Error(`Invalid JSON for --data '${key}:=': ${error.message}`);
+                }
+                break;
+            }
+            case '@': {
+                out[key] = readFile(value);
+                break;
+            }
+            default: {
+                out[key] = value;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Load the `--json` source: inline JSON, `@file`, or `-` (stdin, supplied by
+ * the caller via `stdin`). Must parse to a plain object; arrays/scalars are
+ * rejected because a function's input is always a keyed object.
+ */
+export function loadJsonSource(source, opts = {}) {
+    if (source === undefined)
+        return undefined;
+    const readFile = opts.readFile ?? defaultReadFile;
+    let raw;
+    if (source === '-') {
+        if (!opts.stdin)
+            throw new Error('stdin reader not available for --json -');
+        raw = opts.stdin();
+    }
+    else if (source.startsWith('@')) {
+        raw = readFile(source.slice(1));
+    }
+    else {
+        raw = source;
+    }
+    if (raw.trim() === '')
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON input: ${error.message}`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Function input must be a JSON object (e.g. {"name":"..."}), not an array or scalar.');
+    }
+    return parsed;
+}
+/**
+ * Merge a JSON base with --data overrides into the final input object.
+ * Precedence: base first, then dataPairs override (shallow).
+ */
+export function assembleInput(opts) {
+    return { ...opts.jsonBase, ...opts.dataPairs };
+}
+/**
+ * Validate a supplied input object against a function's declared input schema.
+ * Non-destructive: returns lists the caller can act on (prompt for missing
+ * required params on a TTY, warn on enum mismatches, etc.). The server remains
+ * the source of truth, so type mismatches are warnings, not hard failures.
+ */
+export function validateAgainstSchema(input, schema) {
+    const missingRequired = [];
+    const warnings = [];
+    if (!schema)
+        return { missingRequired, warnings };
+    for (const param of schema) {
+        const present = Object.hasOwn(input, param.name);
+        if (!present) {
+            // A required param with no default must be supplied.
+            if (param.required && param.default === undefined) {
+                missingRequired.push(param);
+            }
+            continue;
+        }
+        const value = input[param.name];
+        if (value === null && param.nullable === false) {
+            warnings.push(`Input '${param.name}' is null but the parameter is not nullable.`);
+        }
+        // Enum membership check (only for non-null scalar values).
+        if (Array.isArray(param.values) && param.values.length > 0 && value !== null && !param.values.includes(value)) {
+            warnings.push(`Input '${param.name}' = ${JSON.stringify(value)} is not one of the allowed values: ` +
+                param.values.map((v) => JSON.stringify(v)).join(', '));
+        }
+    }
+    return { missingRequired, warnings };
+}
+function defaultReadFile(p) {
+    try {
+        return fs.readFileSync(p, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read file '${p}': ${error.message}`);
+    }
+}