@synergenius/flow-weaver-pack-weaver 0.9.0 → 0.9.4

package/dist/cli-handlers.js

@@ -32,6 +32,7 @@ export function parseArgs(argv) {
         autoApprove: false,
         genesisInit: false,
         genesisWatch: false,
+        sessionContinuous: false,
     };
     const args = argv.slice(2);
     let i = 0;
@@ -176,6 +177,18 @@ export function parseArgs(argv) {
         else if (arg === 'session') {
             result.command = 'session';
         }
+        else if (arg === 'assistant') {
+            result.command = 'assistant';
+        }
+        else if (arg === 'examples') {
+            result.command = 'examples';
+        }
+        else if (arg === 'doctor') {
+            result.command = 'doctor';
+        }
+        else if (arg === 'status') {
+            result.command = 'status';
+        }
         else if (arg === 'steer') {
             result.command = 'steer';
             // Next arg is the subcommand
@@ -237,6 +250,35 @@ export function parseArgs(argv) {
         else if (arg === '--watch') {
             result.genesisWatch = true;
         }
+        else if (arg === '--new') {
+            result.assistantNew = true;
+        }
+        else if (arg === '--resume' && i + 1 < args.length) {
+            i++;
+            result.assistantResume = args[i];
+        }
+        else if (arg === '--list') {
+            result.assistantList = true;
+        }
+        else if (arg === '--delete' && i + 1 < args.length) {
+            i++;
+            result.assistantDelete = args[i];
+        }
+        else if (arg === '--continuous') {
+            result.sessionContinuous = true;
+        }
+        else if (arg === '--until' && i + 1 < args.length) {
+            i++;
+            result.sessionUntil = args[i];
+        }
+        else if (arg === '--max-tasks' && i + 1 < args.length) {
+            i++;
+            result.sessionMaxTasks = parseInt(args[i], 10) || undefined;
+        }
+        else if (arg === '--parallel' && i + 1 < args.length) {
+            i++;
+            result.sessionParallel = Math.min(Math.max(parseInt(args[i], 10) || 1, 1), 5);
+        }
         else if (arg === '--project-dir' && i + 1 < args.length) {
             i++;
             result.file = args[i];
@@ -326,6 +368,14 @@ function printRunDetail(r) {
     if (r.params) {
         console.log(`  Params:         ${JSON.stringify(r.params)}`);
     }
+    if (r.stepLog && r.stepLog.length > 0) {
+        console.log(`\n  Steps (${r.stepLog.length}):`);
+        for (const entry of r.stepLog) {
+            const icon = entry.status === 'ok' ? '\x1b[32m+\x1b[0m' : entry.status === 'blocked' ? '\x1b[33m⚠\x1b[0m' : '\x1b[31m✗\x1b[0m';
+            const detail = entry.detail ? ` — ${entry.detail}` : '';
+            console.log(`    ${icon} ${entry.step}${detail}`);
+        }
+    }
     console.log('');
 }
 function parseSince(spec) {
@@ -426,10 +476,20 @@ export async function handleCosts(opts) {
     const sinceTs = parseSince(opts.costsSince);
     const summary = store.summarize({ since: sinceTs, model: opts.costsModel });
     if (summary.totalRuns === 0) {
-        console.log('No cost data found.');
+        if (opts.historyJson) {
+            console.log(JSON.stringify(summary, null, 2));
+        }
+        else {
+            console.log('No cost data found.');
+        }
         return;
     }
-    console.log(formatCostTable(summary));
+    if (opts.historyJson) {
+        console.log(JSON.stringify(summary, null, 2));
+    }
+    else {
+        console.log(formatCostTable(summary));
+    }
 }
 export async function handleWatch(opts) {
     if (!opts.file) {
@@ -653,6 +713,7 @@ export async function handleProviders() {
 // --- Workflow map for eject and resolution ---
 const MANAGED_WORKFLOWS = {
     bot: 'weaver-bot',
+    agent: 'weaver-agent',
     batch: 'weaver-bot-batch',
     genesis: 'genesis-task',
 };
@@ -1130,31 +1191,304 @@ export async function handleBot(opts) {
     }
 }
 export async function handleSession(opts) {
-    const workflowPath = resolveWorkflowPath('bot', opts.file ?? process.cwd());
+    const projectDir = opts.file ?? process.cwd();
+    // Set project dir for per-project queue isolation
+    process.env.WEAVER_PROJECT_DIR = projectDir;
     const config = await loadConfig(opts.configPath);
-    if (!opts.quiet) {
-        console.log('[weaver] Starting bot session (Ctrl+C to stop)');
-        console.log('[weaver] Add tasks with: flow-weaver weaver queue add "task"');
-    }
+    const workflowPath = resolveWorkflowPath('agent', projectDir);
+    // Create terminal renderer for all session output
+    const { TerminalRenderer } = await import('./bot/terminal-renderer.js');
+    const renderer = new TerminalRenderer({ verbose: opts.verbose, quiet: opts.quiet });
+    // Parse --until HH:MM into a deadline timestamp
+    let deadline;
+    let deadlineStr;
+    if (opts.sessionUntil) {
+        const match = opts.sessionUntil.match(/^(\d{1,2}):(\d{2})$/);
+        if (match) {
+            const now = new Date();
+            const target = new Date(now);
+            target.setHours(parseInt(match[1], 10), parseInt(match[2], 10), 0, 0);
+            if (target.getTime() <= now.getTime())
+                target.setDate(target.getDate() + 1);
+            deadline = target.getTime();
+            deadlineStr = target.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+        }
+    }
+    const maxTasks = opts.sessionMaxTasks ?? Infinity;
+    const continuous = opts.sessionContinuous || !!opts.sessionUntil || maxTasks < Infinity;
+    const parallelism = opts.sessionParallel ?? 1;
+    // Crash recovery
+    if (continuous) {
+        const { TaskQueue } = await import('./bot/task-queue.js');
+        const recoveryQueue = new TaskQueue();
+        const recovered = await recoveryQueue.recoverOrphans();
+        if (recovered > 0)
+            renderer.info(`Recovered ${recovered} orphaned task(s)`);
+    }
+    // Clean stale cache files
     try {
-        const result = await runWorkflow(workflowPath, {
-            params: { projectDir: opts.file ?? process.cwd() },
-            verbose: opts.verbose,
-            dryRun: opts.dryRun,
-            config,
-        });
-        if (!opts.quiet) {
-            const color = result.success ? '\x1b[32m' : '\x1b[31m';
-            console.log(`${color}Session: ${result.outcome}\x1b[0m`);
+        const { execSync: execSyncClean } = await import('node:child_process');
+        const staleOutput = execSyncClean(`find "${projectDir}" -name "fw-exec-*" -type f`, { encoding: 'utf-8', timeout: 5000 }).trim();
+        if (staleOutput) {
+            const staleFiles = staleOutput.split('\n').filter(Boolean);
+            for (const f of staleFiles) {
+                try {
+                    fs.unlinkSync(f);
+                }
+                catch { }
+            }
         }
-        process.exit(result.success ? 0 : 1);
     }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`\x1b[31m[weaver] Fatal: ${msg}\x1b[0m`);
-        process.exit(1);
+    catch { /* non-fatal */ }
+    // Detect provider label for session start
+    const providerType = config?.provider ?? 'auto';
+    const providerLabel = typeof providerType === 'object' ? providerType.name : String(providerType);
+    const sessionStartTime = Date.now();
+    renderer.sessionStart({ provider: providerLabel, parallel: parallelism, deadline: deadlineStr });
+    // Single-run mode (backwards compatible)
+    if (!continuous) {
+        try {
+            const result = await runWorkflow(workflowPath, {
+                params: { projectDir },
+                verbose: opts.verbose,
+                dryRun: opts.dryRun,
+                config,
+            });
+            if (!opts.quiet) {
+                const color = result.success ? '\x1b[32m' : '\x1b[31m';
+                console.log(`${color}Session: ${result.outcome}\x1b[0m`);
+            }
+            process.exit(result.success ? 0 : 1);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`\x1b[31m[weaver] Fatal: ${msg}\x1b[0m`);
+            process.exit(1);
+        }
+        return;
+    }
+    // Continuous mode: loop until deadline/maxTasks/interrupt
+    const { TaskQueue } = await import('./bot/task-queue.js');
+    const { isTransientError, getErrorGuidance } = await import('./bot/error-classifier.js');
+    const queue = new TaskQueue();
+    let taskCount = 0;
+    let interrupted = false;
+    let consecutiveErrors = 0;
+    let consecutiveNoOps = 0;
+    const MAX_CONSECUTIVE_ERRORS = 3;
+    const MAX_CONSECUTIVE_NO_OPS = 5;
+    // Session stats
+    let sessionCompleted = 0, sessionFailed = 0, sessionNoOp = 0;
+    let sessionInputTokens = 0, sessionOutputTokens = 0, sessionCost = 0;
+    process.on('SIGINT', () => { interrupted = true; });
+    process.on('SIGTERM', () => { interrupted = true; });
+    // Parallel task tracking
+    const running = new Map();
+    const filesInUse = new Set();
+    const processTask = async (task) => {
+        try {
+            const result = await runWorkflow(workflowPath, {
+                params: { projectDir, taskJson: JSON.stringify(task) },
+                verbose: opts.verbose,
+                dryRun: opts.dryRun,
+                config,
+            });
+            // Classify outcome: the summary contains "no changes" or "0 files" for no-ops
+            const isNoOp = result.success && (result.summary.includes('no changes') ||
+                result.summary.includes('0 file') ||
+                result.summary.includes("doesn't exist") ||
+                result.summary.includes('does not exist') ||
+                result.summary.includes('nothing to') ||
+                result.outcome === 'no-op');
+            if (isNoOp) {
+                await queue.markNoOp(task.id);
+                sessionNoOp++;
+                consecutiveNoOps++;
+                consecutiveErrors = 0;
+            }
+            else if (result.success) {
+                await queue.markComplete(task.id);
+                sessionCompleted++;
+                consecutiveErrors = 0;
+                consecutiveNoOps = 0;
+            }
+            else {
+                await queue.markFailed(task.id, result.summary || result.outcome || 'unknown error');
+                sessionFailed++;
+                consecutiveErrors++;
+                consecutiveNoOps = 0;
+            }
+            // Track cost from workflow result
+            if (result.cost) {
+                sessionInputTokens += result.cost.totalInputTokens ?? 0;
+                sessionOutputTokens += result.cost.totalOutputTokens ?? 0;
+                sessionCost += result.cost.totalCost ?? 0;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const guidance = getErrorGuidance(msg);
+            renderer.error(`Task ${task.id.slice(0, 8)} error`, guidance ? `${msg}\n  Hint: ${guidance}` : msg);
+            await queue.markFailed(task.id, msg);
+            sessionFailed++;
+            if (!isTransientError(err)) {
+                consecutiveErrors++;
+            }
+        }
+        finally {
+            for (const f of task.targets ?? [])
+                filesInUse.delete(f);
+            running.delete(task.id);
+        }
+    };
+    while (taskCount < maxTasks && !interrupted) {
+        if (deadline && Date.now() >= deadline) {
+            renderer.info('Deadline reached, stopping session.');
+            break;
+        }
+        if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+            renderer.error('Session stopped', `${MAX_CONSECUTIVE_ERRORS} consecutive errors — check your API key or provider config.`);
+            break;
+        }
+        // Pause on consecutive no-ops (bot is spinning without doing anything)
+        if (consecutiveNoOps >= MAX_CONSECUTIVE_NO_OPS) {
+            renderer.warn(`${MAX_CONSECUTIVE_NO_OPS} consecutive no-op tasks — pausing 60s`);
+            await new Promise(r => setTimeout(r, 60_000));
+            consecutiveNoOps = 0;
+        }
+        // Wait if at capacity
+        if (running.size >= parallelism) {
+            await Promise.race(running.values());
+            continue;
+        }
+        const task = await queue.next();
+        if (!task) {
+            if (running.size > 0) {
+                // Tasks still running — wait for one to finish
+                await Promise.race(running.values());
+                continue;
+            }
+            // No pending or running tasks — wait and retry
+            await new Promise(r => setTimeout(r, 5_000));
+            continue;
+        }
+        // Auto-decompose broad tasks into per-file tasks
+        const { decomposeTask } = await import('./bot/task-decomposer.js');
+        const { decomposed, tasks: subtasks } = decomposeTask(task, projectDir);
+        if (decomposed && subtasks.length > 1) {
+            // Replace the broad task with per-file tasks
+            await queue.markComplete(task.id);
+            let decomposedCount = 0;
+            for (const st of subtasks) {
+                const { duplicate } = await queue.add({ instruction: st.instruction, mode: st.mode, targets: st.targets, priority: st.priority ?? 0 });
+                if (!duplicate)
+                    decomposedCount++;
+            }
+            renderer.info(`Decomposed into ${subtasks.length} per-file tasks`);
+            continue;
+        }
+        // File conflict check: if task targets overlap with files in use, wait
+        const taskTargets = task.targets ?? [];
+        const hasConflict = taskTargets.some(f => filesInUse.has(f));
+        if (hasConflict && running.size > 0) {
+            await Promise.race(running.values());
+            continue;
+        }
+        taskCount++;
+        if (opts.verbose)
+            process.env.WEAVER_VERBOSE = '1';
+        renderer.taskStart(taskCount, task.instruction ?? task.id);
+        await queue.markRunning(task.id);
+        // Reserve files
+        for (const f of taskTargets)
+            filesInUse.add(f);
+        // Launch task (parallel or sequential based on parallelism setting)
+        const promise = processTask(task);
+        running.set(task.id, promise);
+        // In sequential mode (parallelism=1), await immediately
+        if (parallelism <= 1) {
+            await promise;
+        }
+    }
+    // Wait for all remaining parallel tasks
+    if (running.size > 0) {
+        await Promise.allSettled(running.values());
+    }
+    const elapsed = Date.now() - sessionStartTime;
+    renderer.sessionEnd({
+        tasks: taskCount,
+        completed: sessionCompleted,
+        failed: sessionFailed,
+        totalInputTokens: sessionInputTokens,
+        totalOutputTokens: sessionOutputTokens,
+        totalCost: sessionCost,
+        elapsed,
+    });
+    // Desktop notification on session end (cross-platform)
+    if (taskCount > 0) {
+        try {
+            const { sendDesktopNotification } = await import('./bot/bot-manager.js');
+            sendDesktopNotification('Weaver Session Complete', `${sessionCompleted} done, ${sessionFailed} failed, ${sessionNoOp} no-op`);
+        }
+        catch { /* non-fatal */ }
     }
 }
+export async function handleAssistant(opts) {
+    const projectDir = opts.file ?? process.cwd();
+    // Handle --list and --delete before creating provider
+    if (opts.assistantList) {
+        const { ConversationStore } = await import('./bot/conversation-store.js');
+        const { formatTokens, formatElapsed } = await import('./bot/terminal-renderer.js');
+        const store = new ConversationStore();
+        const convos = store.list();
+        if (convos.length === 0) {
+            console.log('  No conversations yet.');
+            return;
+        }
+        console.log(`  Conversations (${convos.length}):\n`);
+        for (const c of convos) {
+            const ago = formatElapsed(Date.now() - c.lastMessageAt) + ' ago';
+            const title = c.title ? `"${c.title}"` : '(untitled)';
+            console.log(`    ${c.id}  ${title.padEnd(45)}  ${String(c.messageCount).padStart(3)} msgs  ${formatTokens(c.totalTokens).padStart(5)} tokens  ${ago}`);
+        }
+        return;
+    }
+    if (opts.assistantDelete) {
+        const { ConversationStore } = await import('./bot/conversation-store.js');
+        const store = new ConversationStore();
+        store.delete(opts.assistantDelete);
+        console.log(`  Deleted conversation ${opts.assistantDelete}`);
+        return;
+    }
+    const config = await loadConfig(opts.configPath);
+    // Create provider
+    const { createAnthropicProvider, createClaudeCliProvider } = await import('@synergenius/flow-weaver/agent');
+    const providerSetting = config?.provider ?? 'auto';
+    const providerType = typeof providerSetting === 'object' ? providerSetting.name : String(providerSetting);
+    let provider;
+    if (providerType === 'anthropic' || (providerType === 'auto' && process.env.ANTHROPIC_API_KEY)) {
+        const apiKey = process.env.ANTHROPIC_API_KEY ?? (typeof providerSetting === 'object' ? providerSetting.apiKey : undefined);
+        if (!apiKey) {
+            console.error('ANTHROPIC_API_KEY required for anthropic provider');
+            process.exit(1);
+        }
+        provider = createAnthropicProvider({ apiKey, model: typeof providerSetting === 'object' ? providerSetting.model : undefined });
+    }
+    else {
+        provider = createClaudeCliProvider({ model: typeof providerSetting === 'object' ? providerSetting.model : undefined });
+    }
+    const { ASSISTANT_TOOLS, createAssistantExecutor } = await import('./bot/assistant-tools.js');
+    const { runAssistant } = await import('./bot/assistant-core.js');
+    const executor = createAssistantExecutor(projectDir);
+    await runAssistant({
+        provider,
+        tools: ASSISTANT_TOOLS,
+        executor,
+        projectDir,
+        resumeId: opts.assistantResume,
+        newConversation: opts.assistantNew,
+    });
+}
 export async function handleSteer(opts) {
     const { SteeringController } = await import('./bot/steering.js');
     const controller = new SteeringController();
@@ -1175,8 +1509,8 @@ export async function handleQueue(opts) {
     const { TaskQueue } = await import('./bot/task-queue.js');
     const queue = new TaskQueue();
     const action = opts.botTask;
-    if (!action || !['add', 'list', 'clear', 'remove'].includes(action)) {
-        console.error('[weaver] Usage: flow-weaver weaver queue <add|list|clear|remove> [task|id]');
+    if (!action || !['add', 'list', 'clear', 'remove', 'retry'].includes(action)) {
+        console.error('[weaver] Usage: flow-weaver weaver queue <add|list|clear|remove|retry> [task|id]');
         process.exit(1);
     }
     switch (action) {
@@ -1186,19 +1520,27 @@ export async function handleQueue(opts) {
                 console.error('[weaver] Usage: flow-weaver weaver queue add "task instruction"');
                 process.exit(1);
             }
-            const id = await queue.add({ instruction, priority: 0 });
-            console.log(`[weaver] Task added: ${id}`);
+            const { id, duplicate } = await queue.add({ instruction, priority: 0 });
+            if (duplicate) {
+                console.log(`[weaver] Task already queued (${id}).`);
+            }
+            else {
+                console.log(`[weaver] Task added: ${id}`);
+            }
             break;
         }
         case 'list': {
             const tasks = await queue.list();
-            if (tasks.length === 0) {
+            if (opts.historyJson) {
+                console.log(JSON.stringify(tasks, null, 2));
+            }
+            else if (tasks.length === 0) {
                 console.log('No tasks in queue.');
             }
             else {
-                console.log('ID'.padEnd(10) + 'STATUS'.padEnd(12) + 'INSTRUCTION');
+                console.log('ID'.padEnd(10) + 'STATUS'.padEnd(12) + 'PRIORITY'.padEnd(10) + 'INSTRUCTION');
                 for (const t of tasks) {
-                    console.log(t.id.padEnd(10) + t.status.padEnd(12) + t.instruction.slice(0, 60));
+                    console.log(t.id.padEnd(10) + t.status.padEnd(12) + String(t.priority).padEnd(10) + t.instruction.slice(0, 60));
                 }
             }
             break;
@@ -1218,7 +1560,60 @@ export async function handleQueue(opts) {
             console.log(removed ? `Removed task ${id}.` : `No task found with id "${id}".`);
             break;
         }
+        case 'retry': {
+            const id = opts.botFile;
+            if (id) {
+                // Retry a specific task
+                const retried = await queue.retry(id);
+                console.log(retried ? `Task ${id} reset to pending.` : `No failed/running task found with id "${id}".`);
+            }
+            else {
+                // Retry all failed tasks
+                const count = await queue.retryAll();
+                console.log(`Reset ${count} failed task(s) to pending.`);
+            }
+            break;
+        }
+    }
+}
+export async function handleStatus(opts) {
+    const store = new RunStore();
+    const { TaskQueue } = await import('./bot/task-queue.js');
+    const queue = new TaskQueue();
+    const orphans = store.checkOrphans();
+    const recentRuns = store.list({ limit: 5 });
+    const tasks = await queue.list();
+    const pending = tasks.filter(t => t.status === 'pending').length;
+    const running = tasks.filter(t => t.status === 'running').length;
+    const completed = tasks.filter(t => t.status === 'completed').length;
+    const failed = tasks.filter(t => t.status === 'failed').length;
+    if (opts.historyJson) {
+        console.log(JSON.stringify({
+            queue: { pending, running, completed, failed, total: tasks.length },
+            orphanedRuns: orphans.length,
+            recentRuns: recentRuns.map(r => ({
+                id: r.id, outcome: r.outcome, summary: r.summary,
+                startedAt: r.startedAt, durationMs: r.durationMs,
+            })),
+        }, null, 2));
+        return;
+    }
+    console.log('\n\x1b[1mWeaver Status\x1b[0m\n');
+    console.log(`  Queue:  ${pending} pending, ${running} running, ${completed} completed, ${failed} failed`);
+    if (orphans.length > 0) {
+        console.log(`  \x1b[33mOrphaned runs: ${orphans.length} (recovered)\x1b[0m`);
+    }
+    if (recentRuns.length > 0) {
+        console.log(`\n  Recent runs:`);
+        for (const r of recentRuns) {
+            const icon = r.success ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+            console.log(`    ${icon} ${r.id.slice(0, 8)} ${r.outcome.padEnd(9)} ${formatDuration(r.durationMs).padEnd(8)} ${r.summary.slice(0, 60)}`);
+        }
+    }
+    else {
+        console.log('\n  No recent runs.');
     }
+    console.log('');
 }
 export async function handleGenesis(opts) {
     const projectDir = opts.file ?? process.cwd();
@@ -1353,6 +1748,7 @@ const COMMAND_HELP = {
     genesis: 'genesis [--init] [--watch]     Run self-evolution cycle',
     eject: 'eject [--workflow bot|genesis]  Export managed workflows',
     audit: 'audit [runId] [--limit N]      View audit log',
+    assistant: 'assistant                       AI-powered assistant for managing bots and workflows',
 };
 export function printHelp(command) {
     if (command && command !== 'help' && COMMAND_HELP[command]) {
@@ -1440,28 +1836,34 @@ export async function handleInit(opts) {
         console.log('  Edit it directly or delete it to regenerate.');
         return;
     }
-    // Detect best available provider
+    // Detect best available provider (priority: Anthropic API > OpenAI API > Claude CLI > Copilot CLI)
     let provider = 'auto';
+    const detected = [];
     try {
         if (process.env.ANTHROPIC_API_KEY) {
             provider = 'anthropic';
+            detected.push('Anthropic API (ANTHROPIC_API_KEY)');
         }
-        else {
-            const { execFileSync } = await import('node:child_process');
-            try {
-                execFileSync('claude', ['--version'], { stdio: 'pipe' });
+        if (process.env.OPENAI_API_KEY) {
+            if (provider === 'auto')
+                provider = 'openai';
+            detected.push('OpenAI API (OPENAI_API_KEY)');
+        }
+        const { execFileSync } = await import('node:child_process');
+        try {
+            execFileSync('claude', ['--version'], { stdio: 'pipe' });
+            if (provider === 'auto')
                 provider = 'claude-cli';
-            }
-            catch {
-                try {
-                    execFileSync('copilot', ['--version'], { stdio: 'pipe' });
-                    provider = 'copilot-cli';
-                }
-                catch {
-                    // Stay with auto
-                }
-            }
+            detected.push('Claude CLI');
+        }
+        catch { /* not found */ }
+        try {
+            execFileSync('copilot', ['--version'], { stdio: 'pipe' });
+            if (provider === 'auto')
+                provider = 'copilot-cli';
+            detected.push('Copilot CLI');
         }
+        catch { /* not found */ }
     }
     catch {
         // Stay with auto
@@ -1471,11 +1873,176 @@ export async function handleInit(opts) {
         approval: 'auto',
     };
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-    console.log(`\x1b[32m✓\x1b[0m Created ${configPath}`);
-    console.log(`  Provider: ${provider}`);
     console.log('');
-    console.log('Next steps:');
-    console.log('  flow-weaver weaver providers              # verify provider detection');
-    console.log('  flow-weaver weaver bot "Create a ..."     # create your first workflow');
+    console.log('  \x1b[1mWelcome to Weaver\x1b[0m — your AI workflow companion.');
+    console.log('');
+    console.log('  \x1b[2mDetecting providers...\x1b[0m');
+    if (detected.length > 0) {
+        for (const d of detected)
+            console.log(`    \x1b[32m✓\x1b[0m ${d}`);
+    }
+    else {
+        console.log('    \x1b[33m⚠\x1b[0m No provider detected');
+        console.log('      Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or install Claude CLI');
+    }
+    console.log('');
+    // Test connection if possible
+    if (provider === 'claude-cli') {
+        try {
+            const { execFileSync: testExec } = await import('node:child_process');
+            testExec('claude', ['--version'], { stdio: 'pipe', timeout: 5000 });
+            console.log('  \x1b[2mTesting connection...\x1b[0m');
+            console.log('    \x1b[32m✓\x1b[0m Claude CLI: connected');
+        }
+        catch {
+            console.log('  \x1b[33m⚠\x1b[0m Could not verify Claude CLI connection');
+        }
+    }
+    console.log('');
+    console.log(`  \x1b[32m✓\x1b[0m Config written to .weaver.json`);
+    console.log(`    provider: ${provider}`);
+    console.log('    approval: auto');
+    console.log('');
+    console.log('  Try it now:');
+    console.log('    \x1b[36mweaver bot "Create a hello world workflow"\x1b[0m');
+    console.log('    \x1b[36mweaver assistant\x1b[0m');
+    console.log('');
+    console.log('  Learn more:');
+    console.log('    weaver examples         \x1b[2m# see what weaver can do\x1b[0m');
+    console.log('    weaver doctor           \x1b[2m# validate your setup\x1b[0m');
+    console.log('');
+}
+export async function handleExamples(_opts) {
+    console.log('');
+    console.log('  \x1b[1mWeaver Examples\x1b[0m');
+    console.log('');
+    console.log('  \x1b[36mCreate workflows:\x1b[0m');
+    console.log('    weaver bot "Create a workflow that validates user input and sends email"');
+    console.log('    weaver bot "Create a data pipeline that reads CSV, transforms, and writes JSON"');
+    console.log('    weaver bot "Create an AI agent with retry and fallback providers"');
+    console.log('    weaver bot "Create a webhook handler that processes Stripe events"');
+    console.log('    weaver bot "Create a RAG pipeline with document chunking and embedding"');
+    console.log('');
+    console.log('  \x1b[36mModify existing workflows:\x1b[0m');
+    console.log('    weaver bot "Add error handling to my-workflow.ts" --file src/my-workflow.ts');
+    console.log('    weaver bot "Add a validation step before the API call" --file src/pipeline.ts');
+    console.log('    weaver bot "Make the retry node use exponential backoff" --file src/agent.ts');
+    console.log('');
+    console.log('  \x1b[36mInteractive assistant:\x1b[0m');
+    console.log('    weaver assistant                        \x1b[2m# AI assistant with tools\x1b[0m');
+    console.log('    weaver assistant --new                  \x1b[2m# fresh conversation\x1b[0m');
+    console.log('    weaver assistant --list                 \x1b[2m# saved conversations\x1b[0m');
+    console.log('');
+    console.log('  \x1b[36mAutonomous mode:\x1b[0m');
+    console.log('    weaver session --continuous             \x1b[2m# process task queue\x1b[0m');
+    console.log('    weaver queue add "Fix all validation errors"');
+    console.log('    weaver session --continuous --until 10:00 --parallel 3');
+    console.log('');
+    console.log('  \x1b[36mInspect and debug:\x1b[0m');
+    console.log('    flow-weaver validate src/*.ts           \x1b[2m# check all workflows\x1b[0m');
+    console.log('    flow-weaver diagram src/my-workflow.ts  \x1b[2m# visual diagram\x1b[0m');
+    console.log('    flow-weaver describe src/my-workflow.ts \x1b[2m# natural language description\x1b[0m');
+    console.log('');
+    console.log('  \x1b[36mCustomize the bot:\x1b[0m');
+    console.log('    weaver eject                            \x1b[2m# get editable bot workflow\x1b[0m');
+    console.log('    weaver eject --workflow bot              \x1b[2m# eject specific workflow\x1b[0m');
+    console.log('');
+}
+export async function handleDoctor(opts) {
+    const dir = opts.file ?? process.cwd();
+    const checks = [];
+    // Config check
+    const configPath = path.join(dir, '.weaver.json');
+    if (fs.existsSync(configPath)) {
+        checks.push({ label: 'Config', status: 'ok', detail: '.weaver.json found' });
+    }
+    else {
+        checks.push({ label: 'Config', status: 'warn', detail: 'No .weaver.json — run "weaver init"' });
+    }
+    // Provider check
+    const config = await loadConfig(opts.configPath);
+    const providerSetting = config?.provider ?? 'auto';
+    const providerName = typeof providerSetting === 'object' ? providerSetting.name : String(providerSetting);
+    let providerDetail = providerName;
+    if (providerName === 'anthropic' || process.env.ANTHROPIC_API_KEY) {
+        providerDetail = 'anthropic (API key set)';
+        checks.push({ label: 'Provider', status: 'ok', detail: providerDetail });
+    }
+    else {
+        try {
+            const { execFileSync: provCheck } = await import('node:child_process');
+            provCheck('claude', ['--version'], { stdio: 'pipe', timeout: 5000 });
+            providerDetail = 'claude-cli';
+            checks.push({ label: 'Provider', status: 'ok', detail: providerDetail });
+        }
+        catch {
+            checks.push({ label: 'Provider', status: 'fail', detail: 'No provider found — set ANTHROPIC_API_KEY or install Claude CLI' });
+        }
+    }
+    // Connection test
+    if (providerName === 'claude-cli' || (!process.env.ANTHROPIC_API_KEY && providerName === 'auto')) {
+        try {
+            const { execFileSync: connCheck } = await import('node:child_process');
+            const start = Date.now();
+            connCheck('claude', ['-p', '--max-turns', '1', 'say ok'], { stdio: 'pipe', timeout: 15000 });
+            checks.push({ label: 'Connection', status: 'ok', detail: `OK (${((Date.now() - start) / 1000).toFixed(1)}s)` });
+        }
+        catch {
+            checks.push({ label: 'Connection', status: 'warn', detail: 'Could not verify (Claude CLI may need auth)' });
+        }
+    }
+    else if (process.env.ANTHROPIC_API_KEY) {
+        checks.push({ label: 'Connection', status: 'ok', detail: 'API key configured' });
+    }
+    else {
+        checks.push({ label: 'Connection', status: 'warn', detail: 'Not tested' });
+    }
+    // Flow Weaver version
+    try {
+        const { execFileSync: fwCheck } = await import('node:child_process');
+        const version = fwCheck('npx', ['flow-weaver', '--version'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000, cwd: dir }).trim();
+        checks.push({ label: 'Flow Weaver', status: 'ok', detail: version });
+    }
+    catch {
+        checks.push({ label: 'Flow Weaver', status: 'fail', detail: 'Not installed — run "npm install @synergenius/flow-weaver"' });
+    }
+    // Queue status
+    try {
+        const { TaskQueue } = await import('./bot/task-queue.js');
+        process.env.WEAVER_PROJECT_DIR = dir;
+        const queue = new TaskQueue();
+        const tasks = await queue.list();
+        const pending = tasks.filter(t => t.status === 'pending').length;
+        const running = tasks.filter(t => t.status === 'running').length;
+        checks.push({ label: 'Queue', status: 'ok', detail: `${pending} pending, ${running} running` });
+    }
+    catch {
+        checks.push({ label: 'Queue', status: 'ok', detail: 'Empty (no queue file)' });
+    }
+    // Plan file
+    const planPath = path.join(dir, '.weaver-plan.md');
+    if (fs.existsSync(planPath)) {
+        checks.push({ label: 'Plan', status: 'ok', detail: '.weaver-plan.md found' });
+    }
+    else {
+        checks.push({ label: 'Plan', status: 'warn', detail: 'No .weaver-plan.md — optional, guides bot behavior' });
+    }
+    // Output
+    console.log('');
+    console.log('  \x1b[1mWeaver Doctor\x1b[0m');
+    console.log('');
+    const icons = { ok: '\x1b[32m✓\x1b[0m', warn: '\x1b[33m⚠\x1b[0m', fail: '\x1b[31m✗\x1b[0m' };
+    for (const check of checks) {
+        console.log(`  ${icons[check.status]} ${check.label.padEnd(14)} ${check.detail}`);
+    }
+    console.log('');
+    const failures = checks.filter(c => c.status === 'fail');
+    if (failures.length > 0) {
+        console.log(`  \x1b[31m${failures.length} issue(s) found.\x1b[0m`);
+    }
+    else {
+        console.log('  \x1b[32mAll checks passed.\x1b[0m');
+    }
+    console.log('');
 }
 //# sourceMappingURL=cli-handlers.js.map