@cogitator-ai/cli 0.3.16 → 0.5.0

package/dist/commands/wizard.js

@@ -4,96 +4,84 @@ import { resolve } from 'node:path';
 import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { stringify, parse as parseYaml } from 'yaml';
-import { ModelRegistry } from '@cogitator-ai/models';
+import { AssistantConfigSchema } from '@cogitator-ai/channels';
 import { printBanner } from '../utils/logger.js';
-const FALLBACK_MODELS = {
-    anthropic: [
-        { label: 'Claude Sonnet 4', value: 'anthropic/claude-sonnet-4-20250514' },
-        { label: 'Claude Opus 4', value: 'anthropic/claude-opus-4-20250514' },
-        { label: 'Claude Haiku 3.5', value: 'anthropic/claude-3-5-haiku-20241022' },
-    ],
-    openai: [
-        { label: 'GPT-4o', value: 'openai/gpt-4o' },
-        { label: 'GPT-4o mini', value: 'openai/gpt-4o-mini' },
-        { label: 'o3-mini', value: 'openai/o3-mini' },
-    ],
-    google: [
-        { label: 'Gemini 2.5 Flash', value: 'google/gemini-2.5-flash' },
-        { label: 'Gemini 2.5 Pro', value: 'google/gemini-2.5-pro' },
-    ],
-    ollama: [
-        { label: 'Llama 3.1 8B', value: 'ollama/llama3.1:8b' },
-        { label: 'Gemma 3 4B', value: 'ollama/gemma3:4b' },
-        { label: 'Mistral 7B', value: 'ollama/mistral:7b' },
-    ],
+import { mergeEnvContent, parseDotenv } from '../utils/env.js';
+import { DEFAULT_OLLAMA_URL, resolveOllamaUrl } from '../utils/ollama.js';
+import { API_KEY_ENV, fetchOllamaModelOptions, fetchProviderModels, isSetupProvider, withProviderPrefix, } from '../utils/provider-models.js';
+export const CHANNEL_TOKEN_ENV = {
+    telegram: 'TG_TOKEN',
+    discord: 'DISCORD_TOKEN',
+    slack: 'SLACK_BOT_TOKEN',
 };
-async function fetchModels(provider) {
-    try {
-        const registry = new ModelRegistry({ fallbackToBuiltin: true });
-        await registry.initialize();
-        let models = registry.listModels({
-            provider,
-            supportsTools: true,
-            excludeDeprecated: true,
-        });
-        if (provider === 'google') {
-            models = models.filter((m) => m.id.includes('gemini'));
+const CHANNELS = ['telegram', 'discord', 'slack'];
+const DEFAULT_MEMORY_PATH = '~/.cogitator/memory.db';
+const NOTE_STYLE = { format: (line) => chalk.dim(line) };
+export function splitCommandLine(command) {
+    const parts = [];
+    let current = '';
+    let quote = null;
+    let hasToken = false;
+    for (let i = 0; i < command.length; i++) {
+        const ch = command[i];
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else if (ch === '\\' && quote === '"' && i + 1 < command.length) {
+                current += command[++i];
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            hasToken = true;
+        }
+        else if (ch === '\\' && i + 1 < command.length) {
+            current += command[++i];
+            hasToken = true;
+        }
+        else if (/\s/.test(ch)) {
+            if (hasToken)
+                parts.push(current);
+            current = '';
+            hasToken = false;
+        }
+        else {
+            current += ch;
+            hasToken = true;
         }
-        if (models.length === 0)
-            return FALLBACK_MODELS[provider] ?? [];
-        return models.map((m) => ({
-            label: m.displayName,
-            value: m.id,
-        }));
-    }
-    catch {
-        return FALLBACK_MODELS[provider] ?? [];
-    }
-}
-async function fetchOllamaModels(baseUrl) {
-    try {
-        const res = await fetch(`${baseUrl}/api/tags`);
-        if (!res.ok)
-            return FALLBACK_MODELS.ollama;
-        const data = (await res.json());
-        if (!data.models?.length)
-            return FALLBACK_MODELS.ollama;
-        return data.models.map((m) => ({
-            label: m.name,
-            value: `ollama/${m.name}`,
-            hint: formatBytes(m.size),
-        }));
-    }
-    catch {
-        return FALLBACK_MODELS.ollama;
     }
+    if (quote)
+        throw new Error('Unterminated quote in command');
+    if (hasToken)
+        parts.push(current);
+    return parts;
 }
-function formatBytes(bytes) {
-    if (bytes < 1024 * 1024 * 1024)
-        return `${(bytes / (1024 * 1024)).toFixed(0)} MB`;
-    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-function extractMcpName(args) {
+export function extractMcpName(args) {
+    const strip = (name) => name
+        .replace(/@[^@/]*$/, '')
+        .replace(/^(?:mcp-|server-)+/, '')
+        .replace(/(?:-mcp|-server)+$/, '');
     const pkg = args.find((a) => a.startsWith('@') || (!a.startsWith('-') && a.includes('/')));
     if (pkg) {
-        const name = pkg.split('/').pop() ?? pkg;
-        return name.replace(/^server-/, '').replace(/-server$/, '');
+        const name = pkg.startsWith('@') ? (pkg.split('/')[1] ?? pkg) : (pkg.split('/').pop() ?? pkg);
+        return strip(name) || 'mcp-server';
     }
     const nonFlag = args.find((a) => !a.startsWith('-'));
     if (nonFlag)
-        return nonFlag.replace(/^server-/, '').replace(/-server$/, '');
+        return strip(nonFlag) || 'mcp-server';
     return 'mcp-server';
 }
-const API_KEY_NAMES = {
-    anthropic: 'ANTHROPIC_API_KEY',
-    openai: 'OPENAI_API_KEY',
-    google: 'GOOGLE_API_KEY',
-};
-const CHANNEL_TOKEN_ENV = {
-    telegram: 'TG_TOKEN',
-    discord: 'DISCORD_TOKEN',
-    slack: 'SLACK_BOT_TOKEN',
-};
+export function parsePathList(raw) {
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
 function cancel() {
     p.cancel('Setup cancelled');
     process.exit(0);
@@ -103,6 +91,28 @@ function prompt(result) {
         cancel();
     return result;
 }
+function loadExistingConfig(configPath) {
+    try {
+        const raw = parseYaml(readFileSync(configPath, 'utf-8'));
+        const parsed = AssistantConfigSchema.safeParse(raw);
+        if (parsed.success)
+            return parsed.data;
+        p.log.warn('Existing config is not valid; known values will be pre-filled where possible');
+        const partial = AssistantConfigSchema.partial().safeParse(raw);
+        return partial.success ? partial.data : {};
+    }
+    catch {
+        p.log.warn('Failed to parse existing config, starting fresh');
+        return {};
+    }
+}
+async function askSecret(opts) {
+    const value = prompt(await p.password({
+        message: opts.current ? `${opts.message} (leave blank to keep current)` : opts.message,
+        validate: (v) => (!opts.current && !v?.trim() ? opts.required : undefined),
+    })).trim();
+    return value || undefined;
+}
 export const wizardCommand = new Command('wizard')
     .description('Interactive assistant setup — generates cogitator.yml + .env')
     .option('--edit', 'Edit existing cogitator.yml')
@@ -110,88 +120,125 @@ export const wizardCommand = new Command('wizard')
     printBanner();
     const configPath = resolve(process.cwd(), 'cogitator.yml');
     const envPath = resolve(process.cwd(), '.env');
+    const existingEnvContent = existsSync(envPath) ? readFileSync(envPath, 'utf-8') : '';
+    const existingEnv = parseDotenv(existingEnvContent);
+    const editing = options.edit === true && existsSync(configPath);
+    if (!options.edit && existsSync(configPath)) {
+        const overwrite = prompt(await p.confirm({
+            message: 'cogitator.yml already exists. Overwrite it? (use --edit to modify instead)',
+            initialValue: false,
+        }));
+        if (!overwrite)
+            cancel();
+    }
     let existing = {};
-    if (options.edit && existsSync(configPath)) {
+    if (editing) {
         p.intro(chalk.bgCyan(chalk.black(' Cogitator Assistant Setup (editing existing config) ')));
-        try {
-            existing = parseYaml(readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            p.log.warn('Failed to parse existing config, starting fresh');
-        }
-        p.note(`Loaded ${chalk.dim(configPath)}`, 'Existing config found');
+        existing = loadExistingConfig(configPath);
+        p.note(`Loaded ${chalk.dim(configPath)}`, 'Existing config found', NOTE_STYLE);
     }
     else {
         p.intro(chalk.bgCyan(chalk.black(' Cogitator Personal Assistant Setup ')));
     }
-    const existingUserName = existing.personality?.match(/assistant for (\w+)/)?.[1];
+    const envUpdates = new Map();
+    const existingUserName = existing.personality?.match(/assistant for ([^.\n]+)\./)?.[1];
     const userName = prompt(await p.text({
         message: "What's your name?",
         placeholder: 'Alex',
         ...(existingUserName ? { initialValue: existingUserName } : {}),
-        validate: (v) => (!v.trim() ? 'Name is required' : undefined),
-    }));
+        validate: (v) => (!v?.trim() ? 'Name is required' : undefined),
+    })).trim();
     const assistantName = prompt(await p.text({
         message: 'Assistant name',
         placeholder: 'jarvis',
         initialValue: existing.name ?? 'jarvis',
-        validate: (v) => (!v.trim() ? 'Name is required' : undefined),
-    }));
-    const provider = prompt(await p.select({
+        validate: (v) => (!v?.trim() ? 'Name is required' : undefined),
+    })).trim();
+    const providerChoice = prompt(await p.select({
         message: 'LLM Provider',
         initialValue: existing.llm?.provider ?? 'google',
         options: [
             { value: 'google', label: 'Google (Gemini)', hint: 'recommended' },
             { value: 'anthropic', label: 'Anthropic (Claude)' },
-            { value: 'openai', label: 'OpenAI (GPT-4o)' },
+            { value: 'openai', label: 'OpenAI (GPT)' },
             { value: 'ollama', label: 'Ollama', hint: 'local or cloud' },
         ],
     }));
-    let ollamaUrl = 'http://localhost:11434';
-    let apiKey = '';
+    if (!isSetupProvider(providerChoice))
+        cancel();
+    const provider = providerChoice;
+    let ollamaUrl = DEFAULT_OLLAMA_URL;
+    let ollamaApiKey;
     if (provider === 'ollama') {
+        const currentUrl = resolveOllamaUrl(existingEnv);
         const ollamaMode = prompt(await p.select({
             message: 'Ollama deployment',
-            initialValue: 'local',
+            initialValue: currentUrl === DEFAULT_OLLAMA_URL ? 'local' : 'cloud',
             options: [
                 { value: 'local', label: 'Local', hint: 'running on this machine' },
                 { value: 'cloud', label: 'Cloud / Remote', hint: 'custom URL + optional API key' },
             ],
         }));
         if (ollamaMode === 'cloud') {
-            ollamaUrl = prompt(await p.text({
+            const rawUrl = prompt(await p.text({
                 message: 'Ollama URL',
-                placeholder: 'https://ollama.example.com',
-                validate: (v) => (!v.trim() ? 'URL is required' : undefined),
-            }));
-            const ollamaApiKey = prompt(await p.text({
-                message: 'API key (leave blank if not needed)',
-                placeholder: 'optional',
+                placeholder: 'https://ollama.com',
+                ...(currentUrl !== DEFAULT_OLLAMA_URL ? { initialValue: currentUrl } : {}),
+                validate: (v) => {
+                    const url = v?.trim();
+                    if (!url)
+                        return 'URL is required';
+                    try {
+                        new URL(url);
+                        return undefined;
+                    }
+                    catch {
+                        return 'Enter a valid URL, e.g. https://ollama.com';
+                    }
+                },
             }));
-            if (ollamaApiKey.trim()) {
-                apiKey = ollamaApiKey.trim();
-            }
+            ollamaUrl = resolveOllamaUrl({}, rawUrl);
+            envUpdates.set('OLLAMA_URL', ollamaUrl);
+            const key = prompt(await p.password({
+                message: existingEnv.OLLAMA_API_KEY
+                    ? 'API key (leave blank to keep current)'
+                    : 'API key (leave blank if not needed)',
+            })).trim();
+            if (key)
+                envUpdates.set('OLLAMA_API_KEY', key);
+            ollamaApiKey = key || existingEnv.OLLAMA_API_KEY;
+        }
+        else if (existingEnv.OLLAMA_URL) {
+            envUpdates.set('OLLAMA_URL', DEFAULT_OLLAMA_URL);
         }
     }
     else {
-        apiKey = prompt(await p.password({
-            message: `${API_KEY_NAMES[provider]}:`,
-            validate: (v) => (!v.trim() ? 'API key is required' : undefined),
-        }));
+        const keyName = API_KEY_ENV[provider];
+        const key = await askSecret({
+            message: `${keyName}:`,
+            current: existingEnv[keyName] ?? process.env[keyName],
+            required: 'API key is required',
+        });
+        if (key)
+            envUpdates.set(keyName, key);
     }
     const modelSpinner = p.spinner();
     modelSpinner.start('Fetching available models...');
-    const modelOptions = provider === 'ollama' ? await fetchOllamaModels(ollamaUrl) : await fetchModels(provider);
-    modelSpinner.stop(modelOptions.length > 0
-        ? `Found ${chalk.cyan(modelOptions.length)} models`
-        : 'Using fallback model list');
-    const existingModelInList = modelOptions.some((m) => m.value === existing.llm?.model);
+    const modelOptions = provider === 'ollama'
+        ? await fetchOllamaModelOptions(ollamaUrl, ollamaApiKey)
+        : await fetchProviderModels(provider);
+    modelSpinner.stop(`Found ${chalk.cyan(modelOptions.length)} models`);
+    const existingModel = existing.llm?.model && existing.llm.provider === provider
+        ? withProviderPrefix(provider, existing.llm.model)
+        : undefined;
     const model = prompt(await p.select({
         message: 'Model',
-        ...(existingModelInList ? { initialValue: existing.llm.model } : {}),
+        ...(existingModel && modelOptions.some((m) => m.value === existingModel)
+            ? { initialValue: existingModel }
+            : {}),
         options: modelOptions,
     }));
-    const existingChannels = Object.keys(existing.channels ?? {}).filter((k) => existing.channels?.[k] !== undefined);
+    const existingChannels = CHANNELS.filter((ch) => existing.channels?.[ch] !== undefined);
     const selectedChannels = prompt(await p.multiselect({
         message: 'Channels (terminal is always available)',
         options: [
@@ -201,44 +248,38 @@ export const wizardCommand = new Command('wizard')
         ],
         ...(existingChannels.length > 0 ? { initialValues: existingChannels } : {}),
         required: false,
-    }));
-    const envLines = [];
-    if (provider === 'ollama') {
-        if (ollamaUrl !== 'http://localhost:11434') {
-            envLines.push(`OLLAMA_URL=${ollamaUrl}`);
-        }
-        if (apiKey) {
-            envLines.push(`OLLAMA_API_KEY=${apiKey}`);
-        }
-    }
-    else if (apiKey && API_KEY_NAMES[provider]) {
-        envLines.push(`${API_KEY_NAMES[provider]}=${apiKey}`);
-    }
+    })).filter((c) => c === 'telegram' || c === 'discord' || c === 'slack');
     const channelsConfig = {};
     for (const ch of selectedChannels) {
-        const token = prompt(await p.password({
+        const tokenEnv = CHANNEL_TOKEN_ENV[ch];
+        const token = await askSecret({
             message: `${ch} bot token:`,
-            validate: (v) => (!v.trim() ? 'Token is required' : undefined),
-        }));
-        const ownerId = prompt(await p.text({
-            message: `${ch} owner user ID (for admin commands)`,
+            current: existingEnv[tokenEnv],
+            required: 'Token is required',
+        });
+        if (token)
+            envUpdates.set(tokenEnv, token);
+        const existingOwners = existing.channels?.[ch]?.ownerIds?.join(', ');
+        const ownerIdsRaw = prompt(await p.text({
+            message: `${ch} owner user ID(s), comma-separated (for admin commands)`,
             placeholder: 'your user ID',
-            validate: (v) => (!v.trim() ? 'Owner ID is required' : undefined),
+            ...(existingOwners ? { initialValue: existingOwners } : {}),
+            validate: (v) => parsePathList(v ?? '').length === 0 ? 'Owner ID is required' : undefined,
         }));
-        envLines.push(`${CHANNEL_TOKEN_ENV[ch]}=${token}`);
         if (ch === 'slack') {
-            const signingSecret = prompt(await p.password({
+            const signingSecret = await askSecret({
                 message: 'Slack signing secret:',
-                validate: (v) => (!v.trim() ? 'Required' : undefined),
-            }));
-            envLines.push(`SLACK_SIGNING_SECRET=${signingSecret}`);
+                current: existingEnv.SLACK_SIGNING_SECRET,
+                required: 'Required',
+            });
+            if (signingSecret)
+                envUpdates.set('SLACK_SIGNING_SECRET', signingSecret);
         }
-        channelsConfig[ch] = { ownerIds: [ownerId] };
+        channelsConfig[ch] = { ownerIds: parsePathList(ownerIdsRaw) };
     }
-    const existingCaps = Object.keys(existing.capabilities ?? {}).filter((k) => {
-        const val = existing.capabilities?.[k];
-        return val === true || (typeof val === 'object' && val !== null);
-    });
+    const existingCaps = Object.entries(existing.capabilities ?? {})
+        .filter(([, value]) => value === true || (typeof value === 'object' && value !== null))
+        .map(([key]) => key);
     const selectedCapabilities = prompt(await p.multiselect({
         message: 'Capabilities',
         options: [
@@ -261,107 +302,118 @@ export const wizardCommand = new Command('wizard')
     }));
     const capabilities = {};
     for (const cap of selectedCapabilities) {
-        if (cap === 'fileSystem') {
-            const existingFsPaths = existing.capabilities?.fileSystem?.paths?.join(', ');
-            const pathsRaw = prompt(await p.text({
-                message: 'Paths to allow for file system access',
-                placeholder: '~/Documents, ~/Projects',
-                ...(existingFsPaths ? { initialValue: existingFsPaths } : {}),
-                validate: (v) => (!v.trim() ? 'At least one path is required' : undefined),
-            }));
-            capabilities.fileSystem = {
-                paths: pathsRaw.split(',').map((s) => s.trim()),
-            };
-        }
-        else if (cap === 'browser') {
-            const browserOpts = prompt(await p.multiselect({
-                message: 'Browser options',
-                options: [
-                    { value: 'visible', label: 'Visible window', hint: 'see what the agent does' },
-                    {
-                        value: 'stealth',
-                        label: 'Stealth mode',
-                        hint: 'anti-detection, human-like behavior',
-                    },
-                ],
-                required: false,
-            }));
-            if (browserOpts.includes('visible') || browserOpts.includes('stealth')) {
-                capabilities.browser = {
-                    headless: !browserOpts.includes('visible'),
-                    stealth: browserOpts.includes('stealth'),
-                };
+        switch (cap) {
+            case 'fileSystem': {
+                const existingFsPaths = existing.capabilities?.fileSystem?.paths?.join(', ');
+                const pathsRaw = prompt(await p.text({
+                    message: 'Paths to allow for file system access',
+                    placeholder: '~/Documents, ~/Projects',
+                    ...(existingFsPaths ? { initialValue: existingFsPaths } : {}),
+                    validate: (v) => parsePathList(v ?? '').length === 0 ? 'At least one path is required' : undefined,
+                }));
+                capabilities.fileSystem = { paths: parsePathList(pathsRaw) };
+                break;
             }
-            else {
-                capabilities.browser = true;
+            case 'browser': {
+                const current = existing.capabilities?.browser;
+                const currentOpts = typeof current === 'object'
+                    ? [...(current.headless ? [] : ['visible']), ...(current.stealth ? ['stealth'] : [])]
+                    : [];
+                const browserOpts = prompt(await p.multiselect({
+                    message: 'Browser options',
+                    options: [
+                        { value: 'visible', label: 'Visible window', hint: 'see what the agent does' },
+                        {
+                            value: 'stealth',
+                            label: 'Stealth mode',
+                            hint: 'anti-detection, human-like behavior',
+                        },
+                    ],
+                    ...(currentOpts.length > 0 ? { initialValues: currentOpts } : {}),
+                    required: false,
+                }));
+                capabilities.browser =
+                    browserOpts.length > 0
+                        ? {
+                            headless: !browserOpts.includes('visible'),
+                            stealth: browserOpts.includes('stealth'),
+                        }
+                        : true;
+                break;
             }
-        }
-        else if (cap === 'rag') {
-            const existingRagPaths = existing.capabilities?.rag?.paths?.join(', ');
-            const pathsRaw = prompt(await p.text({
-                message: 'Paths to index for RAG',
-                placeholder: '~/Documents/notes, ~/wiki',
-                ...(existingRagPaths ? { initialValue: existingRagPaths } : {}),
-                validate: (v) => (!v.trim() ? 'At least one path is required' : undefined),
-            }));
-            capabilities.rag = {
-                paths: pathsRaw.split(',').map((s) => s.trim()),
-            };
-        }
-        else if (cap === 'github') {
-            const ghToken = prompt(await p.password({
-                message: 'GitHub Personal Access Token (for GitHub API):',
-                validate: (v) => (!v.trim() ? 'Token is required for GitHub capability' : undefined),
-            }));
-            envLines.push(`GITHUB_TOKEN=${ghToken}`);
-            capabilities.github = true;
-        }
-        else {
-            capabilities[cap] = true;
+            case 'rag': {
+                const existingRagPaths = existing.capabilities?.rag?.paths?.join(', ');
+                const pathsRaw = prompt(await p.text({
+                    message: 'Paths to index for RAG',
+                    placeholder: '~/Documents/notes, ~/wiki',
+                    ...(existingRagPaths ? { initialValue: existingRagPaths } : {}),
+                    validate: (v) => parsePathList(v ?? '').length === 0 ? 'At least one path is required' : undefined,
+                }));
+                capabilities.rag = { paths: parsePathList(pathsRaw) };
+                break;
+            }
+            case 'github': {
+                const ghToken = await askSecret({
+                    message: 'GitHub Personal Access Token (for GitHub API):',
+                    current: existingEnv.GITHUB_TOKEN,
+                    required: 'Token is required for GitHub capability',
+                });
+                if (ghToken)
+                    envUpdates.set('GITHUB_TOKEN', ghToken);
+                capabilities.github = true;
+                break;
+            }
+            case 'selfTools':
+                capabilities.selfTools = existing.capabilities?.selfTools ?? true;
+                break;
+            case 'webSearch':
+            case 'deviceTools':
+            case 'scheduler':
+            case 'selfConfig':
+                capabilities[cap] = true;
+                break;
         }
     }
-    const mcpServers = {};
-    const existingMcpNames = Object.keys(existing.mcpServers ?? {});
-    const addMcp = prompt(await p.confirm({
-        message: 'Add MCP servers?',
-        initialValue: existingMcpNames.length > 0,
-    }));
-    if (addMcp) {
-        let addMore = true;
-        while (addMore) {
-            const fullCommand = prompt(await p.text({
-                message: 'Full command to start MCP server',
-                placeholder: 'npx -y @modelcontextprotocol/server-filesystem /home',
-                validate: (v) => (!v.trim() ? 'Command is required' : undefined),
-            }));
-            const parts = fullCommand
-                .trim()
-                .split(/\s+/)
-                .filter((s) => s.length > 0);
-            const command = parts[0];
-            const args = parts.slice(1);
-            const detectedName = extractMcpName(args);
-            const name = prompt(await p.text({
-                message: 'Server name',
-                initialValue: detectedName,
-                validate: (v) => (!v.trim() ? 'Name is required' : undefined),
-            }));
-            mcpServers[name] = { command, args };
-            p.log.success(`Added MCP server: ${chalk.cyan(name)}`);
-            addMore = prompt(await p.confirm({
-                message: 'Add another MCP server?',
-                initialValue: false,
-            }));
-        }
+    const mcpServers = { ...(existing.mcpServers ?? {}) };
+    const existingMcpNames = Object.keys(mcpServers);
+    if (existingMcpNames.length > 0) {
+        p.log.info(`Keeping MCP servers: ${existingMcpNames.join(', ')}`);
     }
-    const memoryAdapter = prompt(await p.select({
-        message: 'Memory',
-        initialValue: existing.memory?.adapter ?? 'sqlite',
-        options: [
-            { value: 'sqlite', label: 'SQLite (recommended)', hint: 'zero config, file-based' },
-            { value: 'postgres', label: 'PostgreSQL', hint: 'production-grade' },
-        ],
+    let addMore = prompt(await p.confirm({
+        message: existingMcpNames.length > 0 ? 'Add more MCP servers?' : 'Add MCP servers?',
+        initialValue: false,
     }));
+    while (addMore) {
+        const fullCommand = prompt(await p.text({
+            message: 'Full command to start MCP server',
+            placeholder: 'npx -y @modelcontextprotocol/server-filesystem /home',
+            validate: (v) => {
+                if (!v?.trim())
+                    return 'Command is required';
+                try {
+                    splitCommandLine(v);
+                    return undefined;
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : 'Invalid command';
+                }
+            },
+        }));
+        const [command, ...args] = splitCommandLine(fullCommand);
+        const name = prompt(await p.text({
+            message: 'Server name',
+            initialValue: extractMcpName(args),
+            validate: (v) => (!v?.trim() ? 'Name is required' : undefined),
+        })).trim();
+        mcpServers[name] = { command, args };
+        p.log.success(`Added MCP server: ${chalk.cyan(name)}`);
+        addMore = prompt(await p.confirm({ message: 'Add another MCP server?', initialValue: false }));
+    }
+    const memoryPath = prompt(await p.text({
+        message: 'SQLite memory database path',
+        initialValue: existing.memory?.path ?? DEFAULT_MEMORY_PATH,
+        validate: (v) => (!v?.trim() ? 'Path is required' : undefined),
+    })).trim();
     const defaultPersonality = [
         `You are ${assistantName}, a personal AI assistant for ${userName}.`,
         `Be concise, friendly, and proactive. Use tools when they can help.`,
@@ -371,55 +423,39 @@ export const wizardCommand = new Command('wizard')
         message: 'Assistant personality',
         placeholder: 'Describe how the assistant should behave...',
         initialValue: existing.personality ?? defaultPersonality,
+        validate: (v) => (!v?.trim() ? 'Personality is required' : undefined),
     }));
     const config = {
+        ...existing,
         name: assistantName,
         personality,
-        llm: {
-            provider: provider,
-            model,
-        },
+        llm: { provider, model },
         channels: channelsConfig,
         capabilities,
-        ...(Object.keys(mcpServers).length > 0 ? { mcpServers } : {}),
+        ...(Object.keys(mcpServers).length > 0 ? { mcpServers } : { mcpServers: undefined }),
         memory: {
-            adapter: memoryAdapter,
-            path: memoryAdapter === 'sqlite' ? '~/.cogitator/memory.db' : undefined,
             autoExtract: true,
             knowledgeGraph: true,
             compaction: { threshold: 50 },
+            ...existing.memory,
+            adapter: 'sqlite',
+            path: memoryPath,
         },
-        stream: { flushInterval: 600, minChunkSize: 30 },
+        stream: existing.stream ?? { flushInterval: 600, minChunkSize: 30 },
     };
-    writeFileSync(configPath, stringify(config, { lineWidth: 120 }));
-    if (envLines.length > 0) {
-        const existing = existsSync(envPath) ? readFileSync(envPath, 'utf-8') : '';
-        const merged = mergeEnvLines(existing, envLines);
-        writeFileSync(envPath, merged);
+    const validated = AssistantConfigSchema.parse(config);
+    writeFileSync(configPath, stringify(validated, { lineWidth: 120 }));
+    if (envUpdates.size > 0) {
+        writeFileSync(envPath, mergeEnvContent(existingEnvContent, envUpdates), { mode: 0o600 });
     }
     p.note([
         `${chalk.dim('Config:')} cogitator.yml`,
-        envLines.length > 0 ? `${chalk.dim('Env:')}    .env` : '',
+        envUpdates.size > 0 ? `${chalk.dim('Env:')}    .env` : '',
         '',
         `${chalk.dim('Next:')}   cogitator up`,
     ]
         .filter(Boolean)
-        .join('\n'), 'Files written');
+        .join('\n'), 'Files written', NOTE_STYLE);
     p.outro(chalk.green('Setup complete! Run: cogitator up'));
 });
-function mergeEnvLines(existing, newLines) {
-    const lines = existing.split('\n').filter(Boolean);
-    const map = new Map();
-    for (const line of lines) {
-        const eq = line.indexOf('=');
-        if (eq > 0)
-            map.set(line.slice(0, eq), line);
-    }
-    for (const line of newLines) {
-        const eq = line.indexOf('=');
-        if (eq > 0)
-            map.set(line.slice(0, eq), line);
-    }
-    return [...map.values()].join('\n') + '\n';
-}
 //# sourceMappingURL=wizard.js.map