@nexrall/code-core 1.4.77 → 1.4.78

package/dist/plugins/userConfig.js

@@ -0,0 +1,332 @@
+"use strict";
+// ─── Plugin `userConfig` (S24, Claude Code parity — G24) ─────────────────────
+//
+// A plugin that needs a value from the user (an API endpoint, a token, a log
+// directory) declares it in plugin.json instead of asking the user to edit
+// settings by hand:
+//
+//   "userConfig": {
+//     "api_token": { "type": "string", "title": "API token",
+//                    "description": "…", "sensitive": true }
+//   }
+//
+// Values are resolved by configStore.ts (settings `pluginConfigs` → secrets
+// file → manifest default) and reach the plugin three ways, matching Claude
+// Code's model:
+//
+//   • `${user_config.KEY}` substitution — MCP server configs (sensitive values
+//     included) and skill bodies (non-sensitive only; a sensitive reference is
+//     left as the literal token rather than shipped into model context);
+//   • `NEXRALL_PLUGIN_OPTION_<KEY>` environment variables on every hook
+//     process the plugin ships (KEY uppercased) — the ONLY way a shell-form
+//     hook can read a value, because a shell-form `command` rejects
+//     `${user_config.*}` (the substituted value would be re-parsed by the
+//     shell; validate.ts reports the reference as an error);
+//   • the `nex plugin configure` command and the install-time
+//     `--config key=value` flag, which write values back.
+//
+// This module is PURE (no fs): schema parsing, value validation, substitution
+// and env naming. The store lives in configStore.ts.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USER_CONFIG_TYPES = void 0;
+exports.parseUserConfig = parseUserConfig;
+exports.validateUserConfigValue = validateUserConfigValue;
+exports.coerceUserConfigValue = coerceUserConfigValue;
+exports.findUserConfigRefs = findUserConfigRefs;
+exports.substituteUserConfig = substituteUserConfig;
+exports.substituteUserConfigDeep = substituteUserConfigDeep;
+exports.collectUserConfigRefsDeep = collectUserConfigRefsDeep;
+exports.pluginOptionEnvKey = pluginOptionEnvKey;
+exports.pluginOptionEnvMap = pluginOptionEnvMap;
+/** Supported value types, matching Claude Code's set. */
+exports.USER_CONFIG_TYPES = ['string', 'number', 'boolean', 'directory', 'file'];
+const KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Fields an option object may carry. Anything else is an error (strict object). */
+const KNOWN_FIELDS = new Set([
+    'type',
+    'title',
+    'description',
+    'required',
+    'default',
+    'options',
+    'multiple',
+    'sensitive',
+    'min',
+    'max',
+]);
+/**
+ * Parse the manifest's `userConfig` block strictly — Claude Code's rule: an
+ * unknown key inside an option is an error. One bad option invalidates the
+ * WHOLE block (all-or-nothing): a plugin half-configured by a typo would be
+ * worse than one that loudly needs its manifest fixed.
+ */
+function parseUserConfig(manifest) {
+    const raw = manifest?.userConfig;
+    if (raw === undefined)
+        return { options: [], errors: [] };
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { options: [], errors: ['userConfig must be an object of option definitions'] };
+    }
+    const options = [];
+    const errors = [];
+    for (const [key, def] of Object.entries(raw)) {
+        const problems = parseOne(key, def);
+        if (typeof problems === 'string') {
+            errors.push(problems);
+            continue;
+        }
+        options.push(problems);
+    }
+    if (errors.length)
+        return { options: [], errors };
+    return { options, errors };
+}
+/** Parse one option; returns the option or its first error. */
+function parseOne(key, def) {
+    if (!KEY_RE.test(key))
+        return `userConfig "${key}": key must be letters, digits and underscores, not starting with a digit`;
+    if (!def || typeof def !== 'object' || Array.isArray(def))
+        return `userConfig "${key}": must be an object`;
+    const d = def;
+    for (const field of Object.keys(d)) {
+        if (!KNOWN_FIELDS.has(field))
+            return `userConfig "${key}": unknown field "${field}" (allowed: ${[...KNOWN_FIELDS].join(', ')})`;
+    }
+    const type = typeof d.type === 'string' ? d.type : undefined;
+    if (!type || !exports.USER_CONFIG_TYPES.includes(type))
+        return `userConfig "${key}": type must be ${exports.USER_CONFIG_TYPES.join(' | ')}`;
+    if (typeof d.title !== 'string' || !d.title.trim())
+        return `userConfig "${key}": title is required`;
+    if (typeof d.description !== 'string' || !d.description.trim())
+        return `userConfig "${key}": description is required`;
+    for (const boolField of ['required', 'multiple', 'sensitive']) {
+        if (d[boolField] !== undefined && typeof d[boolField] !== 'boolean')
+            return `userConfig "${key}": ${boolField} must be a boolean`;
+    }
+    if (d.options !== undefined) {
+        if (type !== 'string')
+            return `userConfig "${key}": options applies to string fields only (this is ${type})`;
+        if (d.multiple === true)
+            return `userConfig "${key}": options cannot be combined with multiple`;
+        if (d.sensitive === true)
+            return `userConfig "${key}": options cannot be combined with sensitive`;
+        if (!Array.isArray(d.options) || !d.options.length)
+            return `userConfig "${key}": options must be a non-empty array`;
+        for (const o of d.options) {
+            if (typeof o !== 'string' || !o.trim() || o.length > 64 || o.length < 1)
+                return `userConfig "${key}": each option must be a plain label of 1-64 characters`;
+        }
+    }
+    if (d.multiple === true && type !== 'string')
+        return `userConfig "${key}": multiple applies to string fields only`;
+    if (d.min !== undefined || d.max !== undefined) {
+        if (type !== 'number')
+            return `userConfig "${key}": min/max apply to number fields only`;
+        if (d.min !== undefined && typeof d.min !== 'number')
+            return `userConfig "${key}": min must be a number`;
+        if (d.max !== undefined && typeof d.max !== 'number')
+            return `userConfig "${key}": max must be a number`;
+        if (typeof d.min === 'number' && typeof d.max === 'number' && d.min > d.max)
+            return `userConfig "${key}": min is greater than max`;
+    }
+    const option = {
+        key,
+        type,
+        title: d.title,
+        description: d.description,
+        ...(d.required === true ? { required: true } : {}),
+        ...(d.multiple === true ? { multiple: true } : {}),
+        ...(d.sensitive === true ? { sensitive: true } : {}),
+        ...(Array.isArray(d.options) ? { options: [...d.options] } : {}),
+        ...(typeof d.min === 'number' ? { min: d.min } : {}),
+        ...(typeof d.max === 'number' ? { max: d.max } : {}),
+    };
+    if (d.default !== undefined) {
+        const bad = validateUserConfigValue(option, d.default);
+        if (bad)
+            return `userConfig "${key}": default is invalid — ${bad}`;
+        option.default = d.default;
+    }
+    return option;
+}
+/** Validate one value against its option. Returns an error string, or null when valid. */
+function validateUserConfigValue(option, value) {
+    if (option.multiple) {
+        if (!Array.isArray(value))
+            return 'expected an array of strings (multiple)';
+        for (const v of value) {
+            if (typeof v !== 'string')
+                return 'every entry must be a string';
+            const bad = validateSingle(option, v);
+            if (bad)
+                return bad;
+        }
+        return null;
+    }
+    return validateSingle(option, value);
+}
+function validateSingle(option, value) {
+    switch (option.type) {
+        case 'string':
+        case 'directory':
+        case 'file':
+            if (typeof value !== 'string')
+                return `expected a ${option.type}`;
+            if (option.options && !option.options.includes(value))
+                return `must be one of: ${option.options.join(', ')}`;
+            return null;
+        case 'number': {
+            if (typeof value !== 'number' || !Number.isFinite(value))
+                return 'expected a number';
+            if (option.min !== undefined && value < option.min)
+                return `must be at least ${option.min}`;
+            if (option.max !== undefined && value > option.max)
+                return `must be at most ${option.max}`;
+            return null;
+        }
+        case 'boolean':
+            return typeof value === 'boolean' ? null : 'expected true or false';
+    }
+}
+/**
+ * Coerce a CLI-supplied STRING into the option's type (values arrive from
+ * `--config key=value` / `--values-stdin` where everything is text).
+ * `parseNumber` is strict: "12abc" must not become 12.
+ */
+function coerceUserConfigValue(option, raw) {
+    if (option.multiple) {
+        // JSON array, or comma-separated.
+        const text = raw.trim();
+        let arr;
+        if (text.startsWith('[')) {
+            try {
+                arr = JSON.parse(text);
+            }
+            catch (e) {
+                return { ok: false, error: `could not parse as a JSON array: ${e.message}` };
+            }
+        }
+        else {
+            arr = text ? text.split(',').map((s) => s.trim()) : [];
+        }
+        const bad = validateUserConfigValue(option, arr);
+        return bad ? { ok: false, error: bad } : { ok: true, value: arr };
+    }
+    switch (option.type) {
+        case 'string':
+        case 'directory':
+        case 'file': {
+            const bad = validateUserConfigValue(option, raw);
+            return bad ? { ok: false, error: bad } : { ok: true, value: raw };
+        }
+        case 'number': {
+            const t = raw.trim();
+            const n = t === '' ? NaN : Number(t);
+            if (!Number.isFinite(n))
+                return { ok: false, error: `"${raw}" is not a number` };
+            const bad = validateUserConfigValue(option, n);
+            return bad ? { ok: false, error: bad } : { ok: true, value: n };
+        }
+        case 'boolean': {
+            const t = raw.trim().toLowerCase();
+            if (t === 'true' || t === '1' || t === 'yes')
+                return { ok: true, value: true };
+            if (t === 'false' || t === '0' || t === 'no')
+                return { ok: true, value: false };
+            return { ok: false, error: `"${raw}" is not a boolean (true/false)` };
+        }
+    }
+}
+// ─── Substitution ────────────────────────────────────────────────────────────
+const REF_RE = /\$\{user_config\.([A-Za-z_][A-Za-z0-9_]*)\}/g;
+/** Every `${user_config.KEY}` reference in a string, unique and in first-seen order. */
+function findUserConfigRefs(text) {
+    const out = new Set();
+    for (const m of text.matchAll(REF_RE))
+        out.add(m[1]);
+    return [...out];
+}
+/**
+ * Replace `${user_config.KEY}` with resolved values. A reference with no value
+ * keeps its literal token — a visible failure the plugin's author can debug,
+ * never an empty string masquerading as a value. `includeSensitive: false`
+ * (skill bodies) leaves sensitive tokens in place; configStore decides which
+ * values may be exposed where.
+ */
+function substituteUserConfig(text, opts) {
+    const result = { text, substituted: [], skippedSensitive: [], unresolved: [] };
+    const byKey = new Map(opts.options.map((o) => [o.key, o]));
+    result.text = text.replace(REF_RE, (whole, key) => {
+        const option = byKey.get(key);
+        if (!option) {
+            result.unresolved.push(key);
+            return whole; // undeclared reference: validate.ts reports it; runtime keeps it visible
+        }
+        if (option.sensitive && !opts.includeSensitive) {
+            result.skippedSensitive.push(key);
+            return whole;
+        }
+        const v = opts.values[key];
+        if (v === undefined) {
+            result.unresolved.push(key);
+            return whole;
+        }
+        if (!result.substituted.includes(key))
+            result.substituted.push(key);
+        return Array.isArray(v) ? v.join(', ') : String(v);
+    });
+    return result;
+}
+/** Deep substitution over an object/array graph (MCP server configs). Strings only. */
+function substituteUserConfigDeep(value, opts) {
+    if (typeof value === 'string')
+        return substituteUserConfig(value, opts).text;
+    if (Array.isArray(value))
+        return value.map((v) => substituteUserConfigDeep(v, opts));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = substituteUserConfigDeep(v, opts);
+        }
+        return out;
+    }
+    return value;
+}
+/** All `${user_config.KEY}` refs found anywhere in a JSON value graph, unique. */
+function collectUserConfigRefsDeep(value) {
+    const out = new Set();
+    const walk = (v) => {
+        if (typeof v === 'string')
+            for (const k of findUserConfigRefs(v))
+                out.add(k);
+        else if (Array.isArray(v))
+            v.forEach(walk);
+        else if (v && typeof v === 'object')
+            Object.values(v).forEach(walk);
+    };
+    walk(value);
+    return [...out];
+}
+// ─── Environment ─────────────────────────────────────────────────────────────
+/** Claude Code's naming rule: `CLAUDE_PLUGIN_OPTION_<KEY>` → ours mirrors it. */
+function pluginOptionEnvKey(key) {
+    return `NEXRALL_PLUGIN_OPTION_${key.toUpperCase()}`;
+}
+/**
+ * The env map a plugin's hook processes receive. Only scalar values can ride
+ * an environment variable; an array/object value is skipped (a shell would see
+ * "[object Object]" — worse than absent).
+ */
+function pluginOptionEnvMap(options, values) {
+    const env = {};
+    for (const o of options) {
+        const v = values[o.key];
+        if (v === undefined)
+            continue;
+        if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+            env[pluginOptionEnvKey(o.key)] = String(v);
+        }
+    }
+    return env;
+}
+//# sourceMappingURL=userConfig.js.map

package/dist/plugins/validate.d.ts

@@ -0,0 +1,14 @@
+import { type UserConfigOption } from './userConfig';
+export interface PluginValidateReport {
+    ok: boolean;
+    dir: string;
+    /** Which manifest file was found (null when none). */
+    manifest: string | null;
+    userConfig: UserConfigOption[];
+    errors: string[];
+    warnings: string[];
+}
+export declare function validatePluginDir(dir: string): PluginValidateReport;
+/** One-line human summary lines for the CLI printer (warnings then errors). */
+export declare function formatValidateReport(r: PluginValidateReport): string[];
+//# sourceMappingURL=validate.d.ts.map

package/dist/plugins/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/plugins/validate.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAkE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErH,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,sDAAsD;IACtD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAsBD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CA6HnE;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,oBAAoB,GAAG,MAAM,EAAE,CAUtE"}

package/dist/plugins/validate.js

@@ -0,0 +1,222 @@
+"use strict";
+// ─── `nex plugin validate` (S24) ─────────────────────────────────────────────
+//
+// One structural check of a plugin directory, runnable in CI before anyone
+// installs it. It answers the questions the install-time inspector cannot:
+//
+//   • does the manifest parse, and is its `userConfig` block legal (strict —
+//     an unknown field inside an option is an error, matching Claude Code)?
+//   • do hooks.json / mcp.json parse, and resolve through the SAME file table
+//     the runtime loader reads (a component under a path the loader ignores
+//     would otherwise pass validation and do nothing);
+//   • does every `${user_config.KEY}` reference name a DECLARED option
+//     (Claude Code 2.1.281's check) — and is it used in a place that accepts
+//     it? A shell-form hook `command` never does: the substituted value would
+//     be re-parsed by the shell, so the runtime rejects that reference and the
+//     validate report says to read NEXRALL_PLUGIN_OPTION_<KEY> from the
+//     environment instead;
+//   • does every MCP server entry carry what a connection needs (a string
+//     `command`, or a string `url`)?
+//   • insecure remote URLs (plain http:// to a non-localhost host) as warnings.
+//
+// Pure reads; no plugin code ever executes here.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePluginDir = validatePluginDir;
+exports.formatValidateReport = formatValidateReport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const files_1 = require("./files");
+const userConfig_1 = require("./userConfig");
+const LOCALHOST = /^(localhost|127\.0\.0\.1|\[::1\]|::1)$/i;
+function insecureUrl(url) {
+    if (!/^http:\/\//i.test(url))
+        return false;
+    try {
+        const host = new URL(url).hostname;
+        return !LOCALHOST.test(host);
+    }
+    catch {
+        return true; // unparseable http URL: still the insecure scheme
+    }
+}
+/** Walk one hooks phase entry (flat and nested CC forms) into handler objects. */
+function hookHandlers(entry) {
+    if (!entry || typeof entry !== 'object')
+        return [];
+    const e = entry;
+    if (Array.isArray(e.hooks))
+        return e.hooks.filter((h) => !!h && typeof h === 'object');
+    return [e];
+}
+function validatePluginDir(dir) {
+    const errors = [];
+    const warnings = [];
+    const report = { ok: true, dir, manifest: null, userConfig: [], errors, warnings };
+    try {
+        if (!fs.statSync(dir).isDirectory()) {
+            errors.push(`not a directory: ${dir}`);
+            return { ...report, ok: false };
+        }
+    }
+    catch {
+        errors.push(`does not exist: ${dir}`);
+        return { ...report, ok: false };
+    }
+    // ── manifest ───────────────────────────────────────────────────────────────
+    const manifestFile = (0, files_1.resolvePluginFile)(dir, 'manifest');
+    report.manifest = manifestFile;
+    let manifest = null;
+    if (!manifestFile) {
+        warnings.push('no plugin.json found (the plugin still loads by directory name, but cannot declare userConfig)');
+    }
+    else {
+        try {
+            const j = JSON.parse(fs.readFileSync(manifestFile, 'utf-8'));
+            if (!j || typeof j !== 'object' || Array.isArray(j)) {
+                errors.push(`${manifestFile}: must be a JSON object`);
+            }
+            else {
+                manifest = j;
+            }
+        }
+        catch (e) {
+            errors.push(`${manifestFile}: ${e.message}`);
+        }
+    }
+    if (manifest) {
+        for (const field of ['name', 'version', 'description']) {
+            if (manifest[field] !== undefined && typeof manifest[field] !== 'string') {
+                errors.push(`plugin.json: "${field}" must be a string`);
+            }
+        }
+        if (manifest.userConfig !== undefined) {
+            const parsed = (0, userConfig_1.parseUserConfig)(manifest);
+            report.userConfig = parsed.options;
+            errors.push(...parsed.errors);
+        }
+    }
+    const declared = new Set(report.userConfig.map((o) => o.key));
+    // ── hooks.json ─────────────────────────────────────────────────────────────
+    const hooksFile = (0, files_1.resolvePluginFile)(dir, 'hooks');
+    if (hooksFile) {
+        try {
+            const j = JSON.parse(fs.readFileSync(hooksFile, 'utf-8'));
+            const hooks = (j?.hooks ?? j);
+            if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) {
+                errors.push(`${hooksFile}: must be an object of hook phases`);
+            }
+            else {
+                for (const [phase, entries] of Object.entries(hooks)) {
+                    if (!Array.isArray(entries)) {
+                        errors.push(`${hooksFile}: "${phase}" must be an array`);
+                        continue;
+                    }
+                    for (const handler of entries.flatMap(hookHandlers)) {
+                        const type = handler.type ?? (handler.url ? 'http' : handler.prompt ? 'prompt' : 'command');
+                        if (type === 'command') {
+                            const cmd = handler.command;
+                            if (typeof cmd !== 'string' || !cmd.trim()) {
+                                errors.push(`${hooksFile}: a command hook in "${phase}" has no command string`);
+                                continue;
+                            }
+                            if ((0, userConfig_1.findUserConfigRefs)(cmd).length) {
+                                errors.push(`${hooksFile}: a command hook in "${phase}" uses \${user_config.*} in its shell-form command — ` +
+                                    'the value would be re-parsed by the shell. Read NEXRALL_PLUGIN_OPTION_<KEY> from the hook environment instead');
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            errors.push(`${hooksFile}: ${e.message}`);
+        }
+    }
+    // ── mcp.json ───────────────────────────────────────────────────────────────
+    const mcpFile = (0, files_1.resolvePluginFile)(dir, 'mcp');
+    if (mcpFile) {
+        try {
+            const j = JSON.parse(fs.readFileSync(mcpFile, 'utf-8'));
+            const servers = (j?.mcpServers ?? j);
+            if (!servers || typeof servers !== 'object' || Array.isArray(servers)) {
+                errors.push(`${mcpFile}: must be an object of server configs (or { mcpServers: … })`);
+            }
+            else {
+                for (const [name, cfg] of Object.entries(servers)) {
+                    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) {
+                        errors.push(`${mcpFile}: server "${name}" is not an object — it will not connect`);
+                        continue;
+                    }
+                    const c = cfg;
+                    const hasCommand = typeof c.command === 'string' && c.command.trim() !== '';
+                    const hasUrl = typeof c.url === 'string' && c.url.trim() !== '';
+                    if (!hasCommand && !hasUrl) {
+                        errors.push(`${mcpFile}: server "${name}" has neither a string "command" nor a "url" — it will not connect`);
+                    }
+                    if (hasUrl && insecureUrl(String(c.url))) {
+                        warnings.push(`${mcpFile}: server "${name}" uses a plain http:// URL (${String(c.url)})`);
+                    }
+                    for (const ref of (0, userConfig_1.collectUserConfigRefsDeep)(cfg)) {
+                        if (!declared.has(ref)) {
+                            errors.push(`${mcpFile}: server "${name}" references \${user_config.${ref}} but the manifest does not declare "${ref}"`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            errors.push(`${mcpFile}: ${e.message}`);
+        }
+    }
+    report.ok = errors.length === 0;
+    return report;
+}
+/** One-line human summary lines for the CLI printer (warnings then errors). */
+function formatValidateReport(r) {
+    const lines = [];
+    const label = path.basename(r.dir) || r.dir;
+    lines.push(`  Plugin: ${label}`);
+    lines.push(`  Manifest: ${r.manifest ?? '(none)'}`);
+    if (r.userConfig.length)
+        lines.push(`  userConfig options: ${r.userConfig.map((o) => o.key).join(', ')}`);
+    for (const w of r.warnings)
+        lines.push(`  ⚠ ${w}`);
+    for (const e of r.errors)
+        lines.push(`  ✗ ${e}`);
+    lines.push(r.ok ? '  ✓ Validation passed' : `  ✗ Validation failed (${r.errors.length} error(s))`);
+    return lines;
+}
+//# sourceMappingURL=validate.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.4.77",
+  "version": "1.4.78",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",