zoe-agent 0.3.1

package/dist/adapters/cli/commands/settings-utils.js

@@ -0,0 +1,182 @@
+/**
+ * Zoe CLI — Settings Display Utilities
+ *
+ * Pure formatting functions for settings display.
+ * Render functions produce bordered ASCII boxes for the wizard TUI.
+ */
+import { ENV_VAR_MAP, SETTINGS_MAP, SETTINGS_SCHEMA, } from '../../../core/settings-schema.js';
+// ── Value formatting ──────────────────────────────────────────────────────
+export function formatSettingValue(value, secret) {
+    if (value === undefined || value === null)
+        return '(not set)';
+    if (secret)
+        return maskValue(String(value));
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    return String(value);
+}
+export function maskValue(value) {
+    if (!value || value.length < 8)
+        return '******';
+    return `${value.slice(0, 3)}...${value.slice(-4)}`;
+}
+// ── Origin resolution ─────────────────────────────────────────────────────
+export function getOriginLabel(dotKey, projectConfig, globalConfig) {
+    const envVar = ENV_VAR_MAP.get(dotKey);
+    if (envVar && process.env[envVar])
+        return `env: ${envVar}`;
+    const entry = SETTINGS_MAP.get(dotKey);
+    if (!entry)
+        return 'default';
+    if (projectConfig && hasPath(projectConfig, entry.configPath)) {
+        return 'project config';
+    }
+    if (globalConfig && hasPath(globalConfig, entry.configPath)) {
+        return 'global config';
+    }
+    return 'default';
+}
+export function formatSettingTable(settings) {
+    if (settings.length === 0)
+        return '  No settings found.';
+    const col1 = 24;
+    const col2 = 20;
+    const lines = [];
+    lines.push(`  ${padTo('Setting', col1)} ${padTo('Value', col2)} Origin`);
+    lines.push(`  ${'─'.repeat(col1)} ${'─'.repeat(col2)} ${'─'.repeat(20)}`);
+    for (const s of settings) {
+        const originSuffix = s.restartRequired ? '  [restart]' : '';
+        lines.push(`  ${padTo(s.dotKey, col1)} ${padTo(s.value, col2)} ${s.origin}${originSuffix}`);
+    }
+    return lines.join('\n');
+}
+// ── Wizard renderers ──────────────────────────────────────────────────────
+/**
+ * Render the bordered header box for Level 1 (category menu).
+ * Shows current provider, model, permissions, and auto-confirm.
+ */
+export function renderWizardHeader(manager) {
+    const width = Math.max(40, Math.min(50, (process.stdout.columns ?? 80) - 2));
+    const halfWidth = Math.floor((width - 4) / 2);
+    const provider = manager.get('provider').value ?? 'not configured';
+    const permLevel = manager.get('agent.permissionLevel').value ?? 'moderate';
+    const autoConfirm = manager.get('agent.autoConfirm').value ?? false;
+    // Resolve current model from active provider
+    let model = 'not configured';
+    const providerModelMap = {
+        'openai': 'providers.openai.model',
+        'anthropic': 'providers.anthropic.model',
+        'glm': 'providers.glm.model',
+        'openai-compatible': 'providers.openai-compat.model',
+    };
+    const modelKey = providerModelMap[String(provider)];
+    if (modelKey) {
+        const modelResult = manager.get(modelKey);
+        if (modelResult.value != null)
+            model = String(modelResult.value);
+    }
+    const left1 = `Provider: ${provider}`;
+    const right1 = `Model: ${model}`;
+    const left2 = `Permissions: ${permLevel}`;
+    const right2 = `Auto-confirm: ${autoConfirm ? 'on' : 'off'}`;
+    const lines = [];
+    lines.push(`┌${'─'.repeat(width - 2)}┐`);
+    lines.push(`│${padTo('  Current Settings', width - 2)}│`);
+    lines.push(`│${' '.repeat(width - 2)}│`);
+    lines.push(`│  ${padTo(left1, halfWidth)}  ${padTo(right1, halfWidth)}│`);
+    lines.push(`│  ${padTo(left2, halfWidth)}  ${padTo(right2, halfWidth)}│`);
+    lines.push(`│${' '.repeat(width - 2)}│`);
+    lines.push(`│${padTo('  ? What would you like to change?', width - 2)}│`);
+    lines.push(`└${'─'.repeat(width - 2)}┘`);
+    return lines.join('\n');
+}
+/**
+ * Render the aligned settings list for Level 2 (category drilldown).
+ * 3-column layout: label, value, origin.
+ */
+export function renderSettingsList(keys, manager) {
+    if (keys.length === 0)
+        return '  (none configured)';
+    const col1 = 28;
+    const col2 = 18;
+    const lines = [];
+    for (const key of keys) {
+        const entry = SETTINGS_MAP.get(key);
+        const schema = SETTINGS_SCHEMA.get(key);
+        const result = manager.get(key);
+        const label = entry?.label ?? key;
+        const value = formatSettingValue(result.value, result.masked);
+        const origin = result.origin;
+        const restartTag = schema?.restartRequired ? '  [restart]' : '';
+        lines.push(`  ${padTo(label, col1)} ${padTo(value, col2)} ${chalk_dim(origin)}${restartTag}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Render the bordered mini-form for Level 3 (setting edit).
+ * Shows setting name, current value, source, and type.
+ */
+export function renderSettingForm(dotKey, manager) {
+    const width = Math.max(36, Math.min(42, (process.stdout.columns ?? 80) - 2));
+    const entry = SETTINGS_MAP.get(dotKey);
+    const schema = SETTINGS_SCHEMA.get(dotKey);
+    const result = manager.get(dotKey);
+    const label = entry?.label ?? dotKey;
+    const current = formatSettingValue(result.value, result.masked);
+    const origin = result.origin;
+    const type = schema?.type ?? 'string';
+    const restartTag = schema?.restartRequired ? '  [restart required]' : '';
+    const lines = [];
+    lines.push(`┌${'─'.repeat(width - 2)}┐`);
+    lines.push(`│${padTo(`  ${label}${restartTag}`, width - 2)}│`);
+    lines.push(`│${' '.repeat(width - 2)}│`);
+    lines.push(`│${padTo(`  Current:  ${current}`, width - 2)}│`);
+    lines.push(`│${padTo(`  Source:   ${origin}`, width - 2)}│`);
+    lines.push(`│${padTo(`  Type:     ${type}`, width - 2)}│`);
+    lines.push(`└${'─'.repeat(width - 2)}┘`);
+    return lines.join('\n');
+}
+/**
+ * Render the category status label for the Level 1 menu.
+ */
+export function renderCategoryStatus(categoryKey, manager) {
+    const keys = [];
+    for (const entry of SETTINGS_MAP.values()) {
+        if (entry.category === categoryKey)
+            keys.push(entry.dotKey);
+    }
+    if (keys.length === 0)
+        return '(reserved)';
+    const configured = keys.filter(k => {
+        const v = manager.get(k).value;
+        return v !== undefined && v !== null && v !== '';
+    }).length;
+    if (categoryKey === 'providers') {
+        return `[${configured}/${keys.length}]`;
+    }
+    if (configured === 0)
+        return '[not set]';
+    if (configured === keys.length)
+        return '[configured]';
+    return '[partially configured]';
+}
+// ── Helpers ───────────────────────────────────────────────────────────────
+function padTo(str, len) {
+    if (str.length >= len)
+        return str.slice(0, len - 1) + ' ';
+    return str + ' '.repeat(len - str.length);
+}
+function hasPath(obj, pathParts) {
+    let current = obj;
+    for (const part of pathParts) {
+        if (current == null || typeof current !== 'object')
+            return false;
+        if (!(part in current))
+            return false;
+        current = current[part];
+    }
+    return true;
+}
+function chalk_dim(str) {
+    return `\x1b[2m${str}\x1b[0m`;
+}

package/dist/adapters/cli/commands/settings.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Zoe CLI — /settings Command Handler
+ *
+ * Read subcommands (list/get/reset/export/help) return their output for the
+ * adapter to render. The interactive wizard and `set` use inquirer (own stdin)
+ * and self-print — the TUI defers those. Subcommand router accepts direct ops.
+ */
+import type { CommandHandler } from './registry.js';
+export declare function settingsHandler(): CommandHandler;

package/dist/adapters/cli/commands/settings.js

@@ -0,0 +1,395 @@
+/**
+ * Zoe CLI — /settings Command Handler
+ *
+ * Read subcommands (list/get/reset/export/help) return their output for the
+ * adapter to render. The interactive wizard and `set` use inquirer (own stdin)
+ * and self-print — the TUI defers those. Subcommand router accepts direct ops.
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { SettingsManager } from '../../../core/settings-manager.js';
+import { SettingsError } from '../../../core/settings-manager.js';
+import { SETTINGS_MAP, SETTINGS_SCHEMA, SETTINGS_CATEGORIES, isSecretField, isRestartRequired, getSettingsByCategory, } from '../../../core/settings-schema.js';
+import { formatSettingValue, formatSettingTable, renderWizardHeader, renderSettingsList, renderSettingForm, renderCategoryStatus, } from './settings-utils.js';
+import { loadMergedConfig, loadJsonConfig, getConfigPaths, applyEnvOverrides } from '../config-loader.js';
+import { isNonInteractive } from '../docker-utils.js';
+function parseSubcommand(args) {
+    const parts = args.trim().split(/\s+/);
+    const first = parts[0]?.toLowerCase();
+    const subcommands = ['list', 'get', 'set', 'reset', 'export', 'help'];
+    if (!first)
+        return { sub: null, rest: '' };
+    if (subcommands.includes(first)) {
+        return { sub: first, rest: parts.slice(1).join(' ') };
+    }
+    return { sub: null, rest: args };
+}
+// ── Manager factory ───────────────────────────────────────────────────────
+function createManager() {
+    const config = applyEnvOverrides(loadMergedConfig());
+    const paths = getConfigPaths();
+    const projectConfig = loadJsonConfig(paths.local);
+    const globalConfig = loadJsonConfig(paths.global);
+    return new SettingsManager({
+        config,
+        projectConfigPath: paths.local,
+        globalConfigPath: paths.global,
+        projectConfig: projectConfig,
+        globalConfig: globalConfig,
+    });
+}
+// ── Main handler ──────────────────────────────────────────────────────────
+export function settingsHandler() {
+    return async (ctx) => {
+        const { sub, rest } = parseSubcommand(ctx.args);
+        const manager = createManager();
+        if (sub === 'list' || (sub === null && isNonInteractive())) {
+            return { output: handleList(manager) };
+        }
+        if (sub === 'get')
+            return { output: handleGet(manager, rest) };
+        if (sub === 'set') {
+            await handleSet(manager, rest);
+            return {};
+        }
+        if (sub === 'reset')
+            return { output: await handleReset(manager, rest) };
+        if (sub === 'export')
+            return { output: handleExport(manager) };
+        if (sub === 'help')
+            return { output: handleHelp() };
+        // sub === null && interactive → wizard (owns stdin)
+        await handleWizard(manager);
+        return {};
+    };
+}
+// ── Level 1: Category Menu (interactive — self-prints) ────────────────────
+async function handleWizard(manager) {
+    while (true) {
+        console.log(renderWizardHeader(manager));
+        const choices = SETTINGS_CATEGORIES.map(c => {
+            const status = renderCategoryStatus(c.key, manager);
+            const keys = getSettingsByCategory(c.key);
+            const suffix = keys.length > 0 ? `(${keys.length})` : '';
+            return { name: `${c.label}  ${status}  ${suffix}`, value: c.key };
+        });
+        let selected;
+        try {
+            const result = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select a category:',
+                    choices: [
+                        ...choices,
+                        new inquirer.Separator(),
+                        { name: 'View full config (JSON)', value: '__export' },
+                        { name: 'Reset to defaults', value: '__reset' },
+                        { name: 'Done', value: '__done' },
+                    ],
+                }]);
+            selected = result.selected;
+        }
+        catch {
+            return; // Ctrl+C
+        }
+        if (selected === '__done')
+            return;
+        if (selected === '__export') {
+            console.log(handleExport(manager));
+            return;
+        }
+        if (selected === '__reset') {
+            try {
+                const { confirm } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: 'Reset all settings to defaults?',
+                        default: false,
+                    }]);
+                if (confirm) {
+                    await manager.resetAll();
+                    console.log(chalk.green('All settings reset to defaults.'));
+                }
+            }
+            catch {
+                return; // Ctrl+C
+            }
+            continue;
+        }
+        await handleCategoryDrilldown(manager, selected);
+    }
+}
+// ── Level 2: Settings List (interactive — self-prints) ────────────────────
+async function handleCategoryDrilldown(manager, category) {
+    const catEntry = SETTINGS_CATEGORIES.find(c => c.key === category);
+    if (!catEntry)
+        return;
+    const keys = getSettingsByCategory(catEntry.key);
+    const categoryInfo = catEntry;
+    while (true) {
+        console.log('');
+        console.log(chalk.bold(`  ${categoryInfo.label}`));
+        console.log('');
+        console.log(renderSettingsList(keys, manager));
+        console.log('');
+        const settingChoices = keys.map(k => {
+            const entry = SETTINGS_MAP.get(k);
+            const result = manager.get(k);
+            const label = entry?.label ?? k;
+            const value = formatSettingValue(result.value, result.masked);
+            return { name: `${label}: ${value}`, value: k };
+        });
+        let selected;
+        try {
+            const result = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select a setting to edit:',
+                    choices: [
+                        ...settingChoices,
+                        new inquirer.Separator(),
+                        { name: '← Back to categories', value: '__back' },
+                    ],
+                }]);
+            selected = result.selected;
+        }
+        catch {
+            return; // Ctrl+C
+        }
+        if (selected === '__back')
+            return;
+        await handleSettingEdit(manager, selected);
+    }
+}
+// ── Level 3: Bordered Mini-Form (interactive — self-prints) ───────────────
+async function handleSettingEdit(manager, dotKey) {
+    const entry = SETTINGS_MAP.get(dotKey);
+    const schema = SETTINGS_SCHEMA.get(dotKey);
+    const label = entry?.label ?? dotKey;
+    while (true) {
+        console.log('');
+        console.log(renderSettingForm(dotKey, manager));
+        console.log('');
+        // Warn if env var overrides this setting
+        const envVar = schema?.envVar;
+        if (envVar && process.env[envVar]) {
+            console.log(chalk.yellow(`  ⚠ This setting is overridden by env var ${envVar}`));
+            console.log(chalk.yellow(`    Your edit will only take effect when ${envVar} is unset.`));
+            console.log('');
+        }
+        // Determine prompt type from schema
+        let promptType;
+        let promptChoices;
+        let validate;
+        if (schema?.type === 'boolean') {
+            promptType = 'confirm';
+        }
+        else if (schema?.type === 'enum' && schema.enumValues) {
+            promptType = 'list';
+            promptChoices = schema.enumValues.map(v => ({ name: v, value: v }));
+        }
+        else if (schema?.secret) {
+            promptType = 'password';
+        }
+        else {
+            promptType = 'input';
+            // M4: Validate number fields
+            if (schema?.type === 'number') {
+                validate = (input) => {
+                    const num = Number(input);
+                    if (isNaN(num))
+                        return 'Please enter a valid number';
+                    if (schema.min !== undefined && num < schema.min)
+                        return `Minimum value is ${schema.min}`;
+                    if (schema.max !== undefined && num > schema.max)
+                        return `Maximum value is ${schema.max}`;
+                    return true;
+                };
+            }
+        }
+        const current = manager.get(dotKey);
+        const promptConfig = {
+            type: promptType,
+            name: 'newValue',
+            message: `New value for ${label}:`,
+        };
+        if (promptType === 'password')
+            promptConfig.mask = '*';
+        if (promptType === 'input' && current.value != null && !schema?.secret) {
+            promptConfig.default = String(current.value);
+        }
+        if (validate)
+            promptConfig.validate = validate;
+        if (promptType === 'confirm' && current.value != null) {
+            promptConfig.default = Boolean(current.value);
+        }
+        if (promptType === 'list' && promptChoices) {
+            promptConfig.choices = promptChoices;
+            if (current.value != null)
+                promptConfig.default = String(current.value);
+        }
+        let newValue;
+        try {
+            const result = await inquirer.prompt([promptConfig]);
+            newValue = result.newValue;
+        }
+        catch {
+            return; // Ctrl+C
+        }
+        // Boolean confirm — value is already boolean, set directly
+        if (promptType === 'confirm') {
+            try {
+                await manager.set(dotKey, String(newValue));
+                const updated = manager.get(dotKey);
+                console.log(chalk.green(`  Updated ${dotKey} = ${formatSettingValue(updated.value, updated.masked)}`));
+            }
+            catch (e) {
+                console.log(chalk.red(`  Error: ${e.message}`));
+            }
+            return;
+        }
+        // For other types, empty means cancel
+        if (!newValue && newValue !== 0) {
+            console.log(chalk.dim('  Cancelled.'));
+            return;
+        }
+        try {
+            await manager.set(dotKey, String(newValue));
+            const updated = manager.get(dotKey);
+            console.log(chalk.green(`  Updated ${dotKey} = ${formatSettingValue(updated.value, updated.masked)}`));
+            if (isRestartRequired(dotKey)) {
+                console.log(chalk.yellow('  Restart the REPL for this change to take full effect.'));
+            }
+            return;
+        }
+        catch (e) {
+            console.log(chalk.red(`  Error: ${e.message}`));
+            console.log(chalk.dim('  Retrying...'));
+            // Loop to retry
+        }
+    }
+}
+// ── Read subcommands (return output for the adapter to render) ────────────
+function handleList(manager) {
+    const settings = manager.list();
+    const rows = settings.map(s => ({
+        dotKey: s.dotKey,
+        value: formatSettingValue(s.value, s.masked),
+        origin: s.origin,
+        category: s.category,
+        restartRequired: s.restartRequired,
+    }));
+    return formatSettingTable(rows);
+}
+function handleGet(manager, args) {
+    const dotKey = args.trim();
+    if (!dotKey) {
+        return chalk.yellow('Usage: /settings get <dot.key>');
+    }
+    try {
+        const result = manager.get(dotKey);
+        const schema = SETTINGS_SCHEMA.get(dotKey);
+        const lines = [`${chalk.cyan(dotKey)} = ${formatSettingValue(result.value, result.masked)}`];
+        if (schema?.default !== undefined && result.value !== schema.default) {
+            lines.push(chalk.dim(`  Default: ${schema.default}`));
+        }
+        lines.push(chalk.dim(`  Source: ${result.origin}`));
+        if (isRestartRequired(dotKey)) {
+            lines.push(chalk.yellow('  [restart required]'));
+        }
+        return lines.join('\n');
+    }
+    catch (e) {
+        return chalk.red(e.message);
+    }
+}
+async function handleSet(manager, args) {
+    const parts = args.trim().split(/\s+/);
+    const dotKey = parts[0];
+    let value = parts.slice(1).join(' ');
+    if (!dotKey) {
+        console.log(chalk.yellow('Usage: /settings set <dot.key> <value>'));
+        return;
+    }
+    // Secret field with no value — prompt
+    if (!value && isSecretField(dotKey)) {
+        const answers = await inquirer.prompt([{
+                type: 'password',
+                name: 'secretValue',
+                message: `Enter new value for ${dotKey}:`,
+                mask: '*',
+            }]);
+        value = answers.secretValue;
+        if (!value)
+            return;
+    }
+    else if (!value || value === '-') {
+        const answers = await inquirer.prompt([{
+                type: 'password',
+                name: 'secretValue',
+                message: `Enter new value for ${dotKey}:`,
+                mask: '*',
+            }]);
+        value = answers.secretValue;
+        if (!value)
+            return;
+    }
+    try {
+        await manager.set(dotKey, value);
+        const result = manager.get(dotKey);
+        console.log(chalk.green(`Updated ${dotKey} = ${formatSettingValue(result.value, result.masked)}`));
+        if (isRestartRequired(dotKey)) {
+            console.log(chalk.yellow('Restart the REPL for this change to take full effect.'));
+        }
+        else {
+            console.log(chalk.dim('Change takes effect immediately.'));
+        }
+    }
+    catch (e) {
+        if (e instanceof SettingsError) {
+            console.log(chalk.red(`Error: ${e.message}`));
+        }
+        else {
+            console.log(chalk.red(`Error: ${e.message}`));
+        }
+    }
+}
+async function handleReset(manager, args) {
+    const dotKey = args.trim();
+    if (!dotKey) {
+        return chalk.yellow('Usage: /settings reset <dot.key>');
+    }
+    try {
+        await manager.reset(dotKey);
+        return chalk.green(`Reset ${dotKey} to default.`);
+    }
+    catch (e) {
+        return chalk.red(`Error: ${e.message}`);
+    }
+}
+function handleExport(manager) {
+    const settings = manager.list();
+    const obj = {};
+    for (const s of settings) {
+        obj[s.dotKey] = formatSettingValue(s.value, s.masked);
+    }
+    return JSON.stringify(obj, null, 2);
+}
+function handleHelp() {
+    const lines = [
+        `${chalk.bold.cyan('/settings')} — View and edit configuration`,
+        '',
+        'Usage:',
+        '  /settings                          Interactive settings wizard',
+        '  /settings list [category]          List settings in a category',
+        '  /settings get <dot.key>            Show current value + origin',
+        '  /settings set <dot.key> <value>    Set a value',
+        '  /settings reset <dot.key>          Remove a value (revert to default)',
+        '  /settings export                   Print full merged config as JSON',
+        '  /settings help                     Show this help',
+        '',
+        chalk.dim('Aliases: /config, /setting'),
+        chalk.dim('Setup wizard: /setup'),
+    ];
+    return lines.join('\n');
+}

package/dist/adapters/cli/commands/skills.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Zoe CLI — /skills Command Handler
+ *
+ * Lists loaded skills with descriptions.
+ */
+import type { CommandHandler } from './registry.js';
+export declare const skillsHandler: CommandHandler;

package/dist/adapters/cli/commands/skills.js

@@ -0,0 +1,21 @@
+/**
+ * Zoe CLI — /skills Command Handler
+ *
+ * Lists loaded skills with descriptions.
+ */
+import chalk from 'chalk';
+export const skillsHandler = async (ctx) => {
+    const { agent } = ctx;
+    const registry = agent.getSkillRegistry();
+    if (!registry || registry.getAll().length === 0) {
+        return {
+            output: `${chalk.yellow('No skills loaded.')}\n${chalk.dim('Add skills to .zoe/skills/ or set ZOE_SKILLS_PATH env var.')}`,
+        };
+    }
+    const lines = [chalk.bold.cyan('Loaded Skills:')];
+    for (const s of registry.getAll()) {
+        lines.push(`${chalk.green(`  ${s.name}`)}${chalk.dim(` — ${s.description.split('\n')[0]}`)}`);
+    }
+    lines.push(chalk.dim('\nUse /<skill-name> <query> to invoke a skill directly.'));
+    return { output: lines.join('\n') };
+};

package/dist/adapters/cli/config-loader.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Zoe CLI — Config Loader
+ *
+ * Re-exports core config utilities and adds CLI-specific chalk output.
+ */
+import type { AppConfig } from '../../core/config.js';
+import { applyEnvOverrides, getConfigPath, getConfigDir, getConfigPaths, migrateLegacyFormat, resolveActiveProviderType, maskSecret } from '../../core/config.js';
+export { AppConfig, applyEnvOverrides, getConfigPath, getConfigDir, getConfigPaths, migrateLegacyFormat, resolveActiveProviderType, maskSecret, };
+/**
+ * Load and parse a JSON config file, returning {} on failure.
+ * Logs parse warnings to console with chalk.
+ */
+export declare function loadJsonConfig(filePath: string): AppConfig;
+/**
+ * Load global and local configs and merge them.
+ * Priority: local > global.
+ */
+export declare function loadMergedConfig(): AppConfig;
+/**
+ * Save config to disk. If a local config exists, saves there; otherwise global.
+ */
+export declare function saveConfig(config: AppConfig): void;
+/**
+ * Save config to a specific path.
+ * Logs errors to console with chalk.
+ */
+export declare function writeConfigToPath(config: AppConfig, targetFile: string): void;