nduka 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,709 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { checkApiKeys } from '../llm/config.js';
+import { PromptRegistry, DEFAULT_PROMPTS } from '../prompts/registry.js';
+import { ToolCatalog } from '../tools/tool-catalog.js';
+import { DEFAULT_TOOL_CATALOG } from '../tools/tool-catalog-config.js';
+import { ModelManager } from '../tools/model-manager.js';
+import { CrunchtrovaClient } from '../tools/crunchtrova.js';
+import { normalizeFetchUrl, normalizeToolQuery } from '../tools/input-guard.js';
+import { DEFAULT_CHATBOT_CONFIG, loadChatbotConfig } from '../config/chatbot-config.js';
+import { createConfigBackup, diffConfig, parseCliJsonValue, restoreConfigBackup, setConfigValue, unsetConfigValue, } from '../config/config-editor.js';
+import { formatLocalEnvList, formatLocalEnvStatus, setLocalEnvValue, unsetLocalEnvValue } from '../config/local-env-editor.js';
+import { ensureConnectorManifest } from '../connectors/config.js';
+import { backupAuthState, formatAuthStatus, getAuthStatus, loginCommand, resetAuthState } from '../auth/session-admin.js';
+import { formatRuntimeHealth, getRuntimeHealth } from '../monitoring/runtime-health.js';
+import { backupAllLocal, cancelCliSchedule, formatAdminReport, formatCliAliasList, formatCliScheduleList, formatDbStats, formatDoctorJson, formatSecretsAudit, validateTools, } from './admin-inspection.js';
+import { handleConnectorCliCommand } from './connector-admin.js';
+function help() {
+    return [
+        'nduka',
+        '',
+        'Commands:',
+        '  doctor [--json]                Check provider keys, prompt config, tool catalog, and admin state',
+        '  health [--quiet]               Check local runtime/config/data health without starting WhatsApp',
+        '  admin report                   Print health, auth, database, model, tool, alias, and schedule status',
+        '  start [--print]                Start the gateway server',
+        '  worker [--print]               Start gateway plus media queue worker',
+        '  auth status                    Show local WhatsApp auth state status',
+        '  auth backup                    Back up local WhatsApp auth state',
+        '  auth reset --yes               Back up and remove local auth state so next login shows QR',
+        '  auth logout --yes              Alias for auth reset --yes',
+        '  auth login [--reset --yes]     Start worker login flow; use --print to print command only',
+        '  aliases list                   List saved chat aliases from the local database',
+        '  schedule list                  List pending scheduled messages from the local database',
+        '  schedule cancel <id>           Cancel a pending scheduled message',
+        '  db stats                       Show local SQLite table counts and file size',
+        '  backup all                     Back up config, auth, and data locally',
+        '  connectors status              Show custom connector manifest status',
+        '  connectors init [--force]      Create disabled custom connector manifest',
+        '  connectors list                List configured custom connectors',
+        '  connectors validate            Validate custom connector manifest',
+        '  connectors plan <name> <json>  Preview rendered connector URL without network access',
+        '  connectors audit [limit]       Show connector audit events',
+        '  secrets status                 Show allowed local .env entries with secrets masked',
+        '  secrets audit                  Show masked allowlisted secret/model status',
+        '  secrets list                   List allowed local .env entries',
+        '  secrets set <name> --from-env <ENV_VAR>  Set an allowlisted key from an environment variable',
+        '  secrets unset <name> --yes     Remove one allowlisted local .env key',
+        '  init [--force]                 Create default config, data, .env, and PM2 files if missing',
+        '  smoke                          Print manual smoke-test checklist',
+        '  tools list                     List enabled catalog tools',
+        '  tools validate                 Validate enabled tool definitions without network execution',
+        '  tools key <tool> --from-env <ENV_VAR>    Set an allowlisted tool key from an environment variable',
+        '  tools test <tool> <input>      Test a known tool: web_search, news_search, url_fetch',
+        '  models status                  Show active model status',
+        '  models list                    List available models',
+        '  models status|list                       Show settings-backed model routes',
+        '  prompts list                   List available configurable prompts',
+        '  prompts get <name>             Print one configurable prompt',
+        '  config paths                   Show config file environment variables and defaults',
+        '  config validate                Validate chatbot config can be loaded',
+        '  config show                    Print merged chatbot config as JSON',
+        '  config get <path>              Print one merged config value, e.g. tools.enabled',
+        '  config set <path> <json-value> Set one safe chatbot config value',
+        '  config unset <path>            Remove one value from the chatbot config file',
+        '  config backup                  Create a timestamped chatbot config backup',
+        '  config restore <backup-file>   Restore chatbot config from a backup file',
+        '  config diff                    Show chatbot config differences from defaults',
+        '  help                           Show this help',
+    ].join('\n');
+}
+function providerStatus() {
+    const keys = checkApiKeys();
+    return [
+        `OpenRouter: ${keys.openrouter ? 'ok' : 'missing'}`,
+        `Kilocode: ${keys.kilocode ? 'ok' : 'missing'}`,
+        `Gemini: ${keys.gemini ? 'ok' : 'missing'}`,
+        `Groq: ${keys.groq ? 'ok' : 'missing'}`,
+    ];
+}
+function configPaths() {
+    return [
+        'Config paths:',
+        `CHATBOT_CONFIG_PATH: ${process.env.CHATBOT_CONFIG_PATH || './config/chatbot.config.json'}`,
+        `CHATBOT_TOOLS_PATH: ${process.env.CHATBOT_TOOLS_PATH || './config/tools.chatbot.json'}`,
+        `CHATBOT_PROMPTS_PATH: ${process.env.CHATBOT_PROMPTS_PATH || './config/prompts.chatbot.json'}`,
+        `CHATBOT_CONNECTORS_PATH: ${process.env.CHATBOT_CONNECTORS_PATH || './config/connectors.chatbot.json'}`,
+        `LLM_SETTINGS_PATH: ${process.env.LLM_SETTINGS_PATH || './config/llm.settings.json'}`,
+        `AUTH_FILE_PATH: ${process.env.AUTH_FILE_PATH || './data/auth_state.json'}`,
+        `DATABASE_PATH: ${process.env.DATABASE_PATH || './data/bot.db'}`,
+        `DATA_DIR: ${process.env.DATA_DIR || './data'}`,
+        `MEDIA_DIR: ${process.env.MEDIA_DIR || './data/media'}`,
+        `BACKUP_DIR: ${process.env.BACKUP_DIR || './backups'}`,
+        `LOCAL_ENV_PATH: ${process.env.LOCAL_ENV_PATH || '.env'}`,
+    ].join('\n');
+}
+function valueAtPath(value, path) {
+    if (!path.trim())
+        return value;
+    return path.split('.').reduce((current, key) => {
+        if (current && typeof current === 'object' && key in current)
+            return current[key];
+        return undefined;
+    }, value);
+}
+function printable(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || value === null)
+        return String(value);
+    return JSON.stringify(value, null, 2);
+}
+function json(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function ensureFile(path, content, force) {
+    const existed = existsSync(path);
+    if (existed && !force)
+        return 'skipped';
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, 'utf8');
+    return existed ? 'updated' : 'created';
+}
+function ensureDir(path) {
+    const existed = existsSync(path);
+    mkdirSync(path, { recursive: true });
+    return existed ? 'exists' : 'created';
+}
+function packageFile(path) {
+    return readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', path), 'utf8');
+}
+function envTemplate() {
+    return [
+        'BOT_TIMEZONE=Asia/Dubai',
+        'OWNER_JID=',
+        'OPENROUTER_API_KEY=',
+        'KILOCODE_API_KEY=',
+        'GROQ_API_KEY=',
+        'GEMINI_API_KEY=',
+        'CRUNCHTROVA_API=',
+        '',
+        'DATA_DIR=./data',
+        'AUTH_FILE_PATH=./data/auth_state.json',
+        'DATABASE_PATH=./data/bot.db',
+        'MEDIA_DIR=./data/media',
+        'BACKUP_DIR=./backups',
+        '',
+        'CHATBOT_CONFIG_PATH=./config/chatbot.config.json',
+        'CHATBOT_TOOLS_PATH=./config/tools.chatbot.json',
+        'CHATBOT_PROMPTS_PATH=./config/prompts.chatbot.json',
+        'CHATBOT_CONNECTORS_PATH=./config/connectors.chatbot.json',
+        'LLM_SETTINGS_PATH=./config/llm.settings.json',
+        'LOCAL_ENV_PATH=./.env',
+        '',
+    ].join('\n');
+}
+function pm2Ecosystem() {
+    return [
+        "module.exports = {",
+        "  apps: [",
+        "    {",
+        "      name: 'nduka-bot',",
+        "      script: process.env.NDUKA_CLI_BIN || 'nduka',",
+        "      args: 'worker',",
+        "      interpreter: 'none',",
+        "      cwd: __dirname,",
+        "      autorestart: true,",
+        "      restart_delay: 5000,",
+        "      max_restarts: 25,",
+        "      max_memory_restart: '750M',",
+        "      time: true,",
+        "      env: {",
+        "        NODE_ENV: 'production',",
+        "        MEDIA_QUEUE_WORKER_ENABLED: 'true'",
+        "      }",
+        "    }",
+        "  ]",
+        "};",
+        '',
+    ].join('\n');
+}
+function initConfig(force) {
+    const chatbotPath = process.env.CHATBOT_CONFIG_PATH || './config/chatbot.config.json';
+    const toolsPath = process.env.CHATBOT_TOOLS_PATH || './config/tools.chatbot.json';
+    const promptsPath = process.env.CHATBOT_PROMPTS_PATH || './config/prompts.chatbot.json';
+    const llmPath = process.env.LLM_SETTINGS_PATH || './config/llm.settings.json';
+    const envPath = process.env.LOCAL_ENV_PATH || './.env';
+    const ecosystemPath = process.env.PM2_ECOSYSTEM_PATH || './ecosystem.config.cjs';
+    const dataPath = process.env.DATA_DIR || './data';
+    const mediaPath = process.env.MEDIA_DIR || './data/media';
+    const backupPath = process.env.BACKUP_DIR || './backups';
+    const connectorsResult = ensureConnectorManifest(undefined, force);
+    const results = [
+        `${dataPath}: ${ensureDir(dataPath)}`,
+        `${mediaPath}: ${ensureDir(mediaPath)}`,
+        `${backupPath}: ${ensureDir(backupPath)}`,
+        `${envPath}: ${ensureFile(envPath, envTemplate(), force)}`,
+        `${chatbotPath}: ${ensureFile(chatbotPath, json(DEFAULT_CHATBOT_CONFIG), force)}`,
+        `${toolsPath}: ${ensureFile(toolsPath, json(DEFAULT_TOOL_CATALOG), force)}`,
+        `${promptsPath}: ${ensureFile(promptsPath, json({ version: 1, prompts: DEFAULT_PROMPTS }), force)}`,
+        `${llmPath}: ${ensureFile(llmPath, packageFile('config/llm.settings.json'), force)}`,
+        `${process.env.CHATBOT_CONNECTORS_PATH || './config/connectors.chatbot.json'}: ${connectorsResult}`,
+        `${ecosystemPath}: ${ensureFile(ecosystemPath, pm2Ecosystem(), force)}`,
+    ];
+    return ['Initialized local runtime files:', ...results, '', 'Secrets are not written. Add API keys to .env or use secrets/tools key commands.'].join('\n');
+}
+function ensureRuntimeDefaults() {
+    initConfig(false);
+}
+function smokeChecklist() {
+    return [
+        'Manual smoke-test checklist',
+        '',
+        'Before starting:',
+        '1. nduka init',
+        '2. nduka doctor',
+        '3. nduka config validate',
+        '',
+        'Start:',
+        '4. nduka worker',
+        '',
+        'Customer DM checks:',
+        '5. /news US Iran today -> should show normal customer command guidance, not search results',
+        '6. /search president of Nigeria -> should show normal customer command guidance, not search results',
+        '7. What is the news about US and Iran today? -> should answer naturally using direct tool routing',
+        '8. Who is the current president of Nigeria and when did he enter office? -> should answer naturally using direct tool routing',
+        '',
+        'Owner self-chat checks:',
+        '9. /help -> should show full owner/admin help, including inbox commands',
+        '10. /news US Iran today -> synthesized answer',
+        '11. /search president of Nigeria -> synthesized answer',
+        '12. /fetch https://gulfnews.com -> synthesized page answer',
+        '13. /newsraw US Iran today -> raw debug output',
+        '14. /schedule <alias> in 3 hours Hello -> creates pending scheduled message for alias',
+        '',
+        'Group checks:',
+        '15. Unmentioned group message -> no reply',
+        '16. Mentioned group question -> concise group reply or safe fallback',
+    ].join('\n');
+}
+function runtimeScript(kind) {
+    const script = kind === 'worker' ? '../gateway/bootstrap.js' : '../gateway/server.js';
+    const packagedPath = resolve(dirname(fileURLToPath(import.meta.url)), script);
+    if (existsSync(packagedPath))
+        return packagedPath;
+    return kind === 'worker' ? 'dist/gateway/bootstrap.js' : 'dist/gateway/server.js';
+}
+function runtimeCommand(kind) {
+    const script = runtimeScript(kind);
+    if (kind === 'worker') {
+        return { command: process.execPath, args: [script], env: { MEDIA_QUEUE_WORKER_ENABLED: 'true' }, printable: `MEDIA_QUEUE_WORKER_ENABLED=true node ${script}` };
+    }
+    return { command: process.execPath, args: [script], printable: `node ${script}` };
+}
+function authLoginRuntimeCommand() {
+    const path = getAuthStatus().path;
+    const script = runtimeScript('worker');
+    return { command: process.execPath, args: [script], env: { MEDIA_QUEUE_WORKER_ENABLED: 'true', AUTH_FILE_PATH: path }, printable: loginCommand(path) };
+}
+function runRuntimeCommand(spec) {
+    return new Promise((resolveExitCode) => {
+        const child = spawn(spec.command, spec.args, { stdio: 'inherit', env: { ...process.env, ...(spec.env || {}) } });
+        child.on('exit', (code) => resolveExitCode(code ?? 0));
+        child.on('error', () => resolveExitCode(1));
+    });
+}
+function valueFromEnvArgs(args) {
+    const index = args.indexOf('--from-env');
+    if (index < 0 || !args[index + 1])
+        return { ok: false, error: 'Use --from-env <ENV_VAR> so secret values are not placed in shell history.' };
+    const envName = args[index + 1];
+    const value = process.env[envName];
+    if (!value)
+        return { ok: false, error: `Environment variable is not set: ${envName}` };
+    return { ok: true, value, envName };
+}
+async function handleAuthCommand(subcommand, args, io) {
+    try {
+        if (!subcommand || subcommand === 'status' || subcommand === 'paths') {
+            io.log(formatAuthStatus());
+            return 0;
+        }
+        if (subcommand === 'backup') {
+            const result = backupAuthState();
+            io.log(result.backupPath ? `Auth backup created: ${result.backupPath}` : `No auth state found at: ${result.authPath}`);
+            return 0;
+        }
+        if (subcommand === 'reset' || subcommand === 'logout') {
+            const result = resetAuthState({ yes: args.includes('--yes') });
+            io.log(result.backupPath ? `Auth backed up: ${result.backupPath}` : `No existing auth state found at: ${result.authPath}`);
+            io.log('Local auth state removed. Next login will require QR/pairing.');
+            return 0;
+        }
+        if (subcommand === 'login') {
+            if (args.includes('--reset'))
+                resetAuthState({ yes: args.includes('--yes') });
+            const spec = authLoginRuntimeCommand();
+            if (args.includes('--print')) {
+                io.log(spec.printable);
+                return 0;
+            }
+            ensureRuntimeDefaults();
+            return runRuntimeCommand(spec);
+        }
+        io.error('Usage: nduka auth status|backup|reset --yes|logout --yes|login [--reset --yes] [--print]');
+        return 1;
+    }
+    catch (err) {
+        io.error(err.message);
+        return 1;
+    }
+}
+function handleSecretsCommand(subcommand, arg, rest, io) {
+    try {
+        if (!subcommand || subcommand === 'status') {
+            io.log(formatLocalEnvStatus());
+            return 0;
+        }
+        if (subcommand === 'audit') {
+            io.log(formatSecretsAudit());
+            return 0;
+        }
+        if (subcommand === 'list') {
+            io.log(formatLocalEnvList());
+            return 0;
+        }
+        if (subcommand === 'set') {
+            if (!arg) {
+                io.error('Usage: nduka secrets set <name> --from-env <ENV_VAR>');
+                return 1;
+            }
+            const found = valueFromEnvArgs(rest);
+            if (!found.ok) {
+                io.error(found.error);
+                return 1;
+            }
+            const result = setLocalEnvValue(arg, found.value);
+            io.log(`Saved ${result.key} from ${found.envName} to ${result.path}. Value not printed.`);
+            return 0;
+        }
+        if (subcommand === 'unset') {
+            if (!arg || !rest.includes('--yes')) {
+                io.error('Usage: nduka secrets unset <name> --yes');
+                return 1;
+            }
+            const result = unsetLocalEnvValue(arg);
+            io.log(result.existed ? `Removed ${result.key} from ${result.path}.` : `${result.key} was not set in ${result.path}.`);
+            return 0;
+        }
+        io.error('Usage: nduka secrets status|audit|list|set|unset');
+        return 1;
+    }
+    catch (err) {
+        io.error(err.message);
+        return 1;
+    }
+}
+async function testKnownTool(toolName, input, io) {
+    if (!toolName || !input) {
+        io.error('Usage: nduka tools test <web_search|news_search|url_fetch> <query-or-url>');
+        return 1;
+    }
+    const client = new CrunchtrovaClient();
+    if (toolName === 'web_search') {
+        const guarded = normalizeToolQuery(input);
+        if (!guarded.ok) {
+            io.error(guarded.error || 'Invalid input');
+            return 1;
+        }
+        const { results, error } = await client.searchWeb(guarded.value, 3, 1000);
+        if (error) {
+            io.error(error);
+            return 1;
+        }
+        io.log(client.formatWebResults(results));
+        return 0;
+    }
+    if (toolName === 'news_search') {
+        const guarded = normalizeToolQuery(input);
+        if (!guarded.ok) {
+            io.error(guarded.error || 'Invalid input');
+            return 1;
+        }
+        const { results, error } = await client.searchNews(guarded.value, 3, 1000);
+        if (error) {
+            io.error(error);
+            return 1;
+        }
+        io.log(client.formatNewsResults(results));
+        return 0;
+    }
+    if (toolName === 'url_fetch') {
+        const guarded = normalizeFetchUrl(input);
+        if (!guarded.ok) {
+            io.error(guarded.error || 'Invalid input');
+            return 1;
+        }
+        const { result, error } = await client.fetchUrl(guarded.value);
+        if (error) {
+            io.error(error);
+            return 1;
+        }
+        if (!result) {
+            io.error('No content returned.');
+            return 1;
+        }
+        io.log(client.formatFetchResult(result));
+        return 0;
+    }
+    io.error(`Unknown testable tool: ${toolName}`);
+    return 1;
+}
+function isMainEntrypoint() {
+    const entrypoint = process.argv[1];
+    if (!entrypoint)
+        return false;
+    try {
+        return realpathSync(resolve(entrypoint)) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return /(?:^|[\/])(?:nduka|wa-chatbot|index\.(?:js|ts))$/.test(entrypoint);
+    }
+}
+export async function runCli(argv, io = console) {
+    const [command = 'help', subcommand = '', arg = '', ...rest] = argv;
+    if (command === 'help' || command === '--help' || command === '-h') {
+        io.log(help());
+        return 0;
+    }
+    if (command === 'health') {
+        const report = getRuntimeHealth();
+        if (subcommand !== '--quiet')
+            io.log(formatRuntimeHealth(report));
+        return report.status === 'fail' ? 1 : 0;
+    }
+    if (command === 'start' || command === 'worker') {
+        const spec = runtimeCommand(command);
+        if (subcommand === '--print') {
+            io.log(spec.printable);
+            return 0;
+        }
+        ensureRuntimeDefaults();
+        return runRuntimeCommand(spec);
+    }
+    if (command === 'auth')
+        return handleAuthCommand(subcommand, [arg, ...rest].filter(Boolean), io);
+    if (command === 'secrets')
+        return handleSecretsCommand(subcommand, arg, rest, io);
+    if (command === 'connectors') {
+        try {
+            io.log(handleConnectorCliCommand(subcommand, arg, rest));
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'admin' && subcommand === 'report') {
+        io.log(formatAdminReport());
+        return 0;
+    }
+    if (command === 'aliases' && (!subcommand || subcommand === 'list')) {
+        io.log(formatCliAliasList(Number(arg || 100)));
+        return 0;
+    }
+    if (command === 'schedule' && (!subcommand || subcommand === 'list')) {
+        io.log(formatCliScheduleList(Number(arg || 20)));
+        return 0;
+    }
+    if (command === 'schedule' && subcommand === 'cancel') {
+        try {
+            io.log(cancelCliSchedule(arg));
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'db' && subcommand === 'stats') {
+        io.log(formatDbStats());
+        return 0;
+    }
+    if (command === 'backup' && subcommand === 'all') {
+        try {
+            io.log(backupAllLocal());
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'init') {
+        io.log(initConfig(subcommand === '--force'));
+        return 0;
+    }
+    if (command === 'smoke') {
+        io.log(smokeChecklist());
+        return 0;
+    }
+    if (command === 'doctor') {
+        if (subcommand === '--json') {
+            io.log(formatDoctorJson());
+            return 0;
+        }
+        const prompts = new PromptRegistry();
+        const catalog = new ToolCatalog();
+        const models = new ModelManager();
+        io.log(['🩺 nduka doctor', '', 'Provider keys:', ...providerStatus(), '', 'Models:', models.statusFormatted(), '', 'Prompts:', ...prompts.list().map((name) => `- ${name}`), '', catalog.formatStatus(), '', configPaths(), '', 'Admin:', `Auth: ${getAuthStatus().exists ? 'present' : 'missing'}`].join('\n'));
+        return 0;
+    }
+    if (command === 'tools' && (subcommand === 'key-status' || subcommand === 'keys')) {
+        io.log(formatLocalEnvStatus());
+        return 0;
+    }
+    if (command === 'tools' && subcommand === 'validate') {
+        try {
+            io.log(validateTools());
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'tools' && subcommand === 'key') {
+        if (!arg) {
+            io.error('Usage: nduka tools key <crunchtrova> --from-env <ENV_VAR>');
+            return 1;
+        }
+        const found = valueFromEnvArgs(rest);
+        if (!found.ok) {
+            io.error(found.error);
+            return 1;
+        }
+        try {
+            const result = setLocalEnvValue(arg, found.value);
+            io.log(`Saved ${result.key} from ${found.envName} to ${result.path}. Value not printed.`);
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'tools' && subcommand === 'list') {
+        io.log(new ToolCatalog().formatStatus());
+        return 0;
+    }
+    if (command === 'tools' && subcommand === 'test')
+        return testKnownTool(arg, rest.join(' '), io);
+    if (command === 'models' && subcommand === 'choose') {
+        io.error('Provider-level model switching is disabled. Model routing is settings-backed. Edit config/llm.settings.json or set the task-specific env vars declared there.');
+        return 1;
+    }
+    if (command === 'models' && subcommand === 'status') {
+        io.log(new ModelManager().statusFormatted());
+        return 0;
+    }
+    if (command === 'models' && subcommand === 'list') {
+        io.log(new ModelManager().listModelsFormatted());
+        return 0;
+    }
+    if (command === 'prompts' && subcommand === 'list') {
+        const prompts = new PromptRegistry();
+        io.log(['Prompts:', ...prompts.list().map((name) => `- ${name}`)].join('\n'));
+        return 0;
+    }
+    if (command === 'prompts' && subcommand === 'get') {
+        if (!arg) {
+            io.error('Usage: nduka prompts get <name>');
+            return 1;
+        }
+        try {
+            io.log(new PromptRegistry().get(arg));
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'config' && subcommand === 'paths') {
+        io.log(configPaths());
+        return 0;
+    }
+    if (command === 'config' && subcommand === 'validate') {
+        try {
+            loadChatbotConfig();
+            io.log('Config valid.');
+            return 0;
+        }
+        catch (err) {
+            io.error(`Config invalid: ${err.message}`);
+            return 1;
+        }
+    }
+    if (command === 'config' && subcommand === 'show') {
+        try {
+            io.log(JSON.stringify(loadChatbotConfig(), null, 2));
+            return 0;
+        }
+        catch (err) {
+            io.error(`Config invalid: ${err.message}`);
+            return 1;
+        }
+    }
+    if (command === 'config' && subcommand === 'get') {
+        if (!arg) {
+            io.error('Usage: nduka config get <path>');
+            return 1;
+        }
+        try {
+            const value = valueAtPath(loadChatbotConfig(), arg);
+            if (value === undefined) {
+                io.error(`Config path not found: ${arg}`);
+                return 1;
+            }
+            io.log(printable(value));
+            return 0;
+        }
+        catch (err) {
+            io.error(`Config invalid: ${err.message}`);
+            return 1;
+        }
+    }
+    if (command === 'config' && subcommand === 'set') {
+        if (!arg || rest.length === 0) {
+            io.error('Usage: nduka config set <path> <json-value>');
+            return 1;
+        }
+        try {
+            const value = parseCliJsonValue(rest.join(' '));
+            const result = setConfigValue(arg, value);
+            io.log(`Config updated: ${arg}`);
+            io.log(`Backup created: ${result.backupPath}`);
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'config' && subcommand === 'unset') {
+        if (!arg) {
+            io.error('Usage: nduka config unset <path>');
+            return 1;
+        }
+        try {
+            const result = unsetConfigValue(arg);
+            io.log(`Config unset: ${arg}`);
+            io.log(`Backup created: ${result.backupPath}`);
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'config' && subcommand === 'backup') {
+        try {
+            const result = createConfigBackup();
+            io.log(`Backup created: ${result.backupPath}`);
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'config' && subcommand === 'restore') {
+        if (!arg) {
+            io.error('Usage: nduka config restore <backup-file>');
+            return 1;
+        }
+        try {
+            const result = restoreConfigBackup(arg);
+            io.log(`Config restored from: ${arg}`);
+            io.log(`Pre-restore backup created: ${result.backupPath}`);
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    if (command === 'config' && subcommand === 'diff') {
+        try {
+            io.log(diffConfig());
+            return 0;
+        }
+        catch (err) {
+            io.error(err.message);
+            return 1;
+        }
+    }
+    io.error(`Unknown command: ${argv.join(' ')}`.trim());
+    io.log(help());
+    return 1;
+}
+if (isMainEntrypoint()) {
+    runCli(process.argv.slice(2)).then((code) => { process.exitCode = code; });
+}
+//# sourceMappingURL=index.js.map