🚀 Release: Interactive Onboarding with Ink Wizard (rc.27)

.genie/cli/dist/commands/init.js

@@ -21,10 +21,41 @@ async function runInit(parsed, _config, _paths) {
         const flags = parseFlags(parsed.commandArgs);
         const cwd = process.cwd();
         const packageRoot = (0, paths_1.getPackageRoot)();
-        // Determine template type
-        // Direct: genie init code/create (automation-friendly)
-        // Interactive: genie init (human discovery)
-        const template = flags.template || await promptTemplateChoice();
+        // Check if running in interactive mode (TTY) or automation mode (--yes flag or explicit template)
+        const isInteractive = process.stdout.isTTY && !flags.yes && !flags.template;
+        let template;
+        let executor;
+        let model;
+        let shouldInitGit = false;
+        if (isInteractive) {
+            // Use dynamic import to load ESM Ink components
+            // @ts-expect-error - .mjs file exists at runtime
+            const { runInitWizard } = await import('../views/init-wizard.mjs');
+            const templates = [
+                { value: 'code', label: '💻 Code', description: 'Full-stack development with Git, testing, CI/CD' },
+                { value: 'create', label: '✍️  Create', description: 'Research, writing, content creation' }
+            ];
+            const executors = Object.keys(executor_registry_1.EXECUTORS).map(key => ({
+                label: executor_registry_1.EXECUTORS[key].label,
+                value: key
+            }));
+            const hasGit = await (0, fs_utils_1.pathExists)(path_1.default.join(cwd, '.git'));
+            const wizardConfig = await runInitWizard({
+                templates,
+                executors,
+                hasGit
+            });
+            template = wizardConfig.template;
+            executor = wizardConfig.executor;
+            model = wizardConfig.model;
+            shouldInitGit = wizardConfig.initGit;
+        }
+        else {
+            // Automation mode: use flags or defaults
+            template = (flags.template || 'code');
+            executor = Object.keys(executor_registry_1.EXECUTORS)[0] || 'codex';
+            model = undefined;
+        }
         const templateGenie = (0, paths_1.getTemplateGeniePath)(template);
         const targetGenie = (0, paths_1.resolveTargetGeniePath)(cwd);
         const templateExists = await (0, fs_utils_1.pathExists)(templateGenie);
@@ -45,7 +76,7 @@ async function runInit(parsed, _config, _paths) {
             const { executor, model } = await selectExecutorAndModel(flags);
             await applyExecutorDefaults(targetGenie, executor, model);
             await (0, mcp_config_1.configureBothExecutors)(cwd);
-            await runInstallViaCli(cwd, template);
+            // TODO: Add install chat flow here (future enhancement)
             await (0, view_helpers_1.emitView)(buildInitSummaryView({ executor, model, templateSource: templateGenie, target: targetGenie }), parsed.options);
             return;
         }
@@ -68,15 +99,9 @@ async function runInit(parsed, _config, _paths) {
             ]), parsed.options);
             return;
         }
-        // Check for .git directory, offer initialization if missing
-        const gitDir = path_1.default.join(cwd, '.git');
-        const hasGit = await (0, fs_utils_1.pathExists)(gitDir);
-        if (!hasGit) {
-            console.log('');
-            console.log('⚠️  No .git directory found');
-            console.log('🧞 Forge requires git to track work');
-            console.log('');
-            if (flags.yes || await promptYesNo('Initialize git repository?', true)) {
+        // Initialize git if needed (wizard already prompted in interactive mode)
+        if (shouldInitGit || (!isInteractive && !await (0, fs_utils_1.pathExists)(path_1.default.join(cwd, '.git')))) {
+            if (!isInteractive && flags.yes) {
                 const { execSync } = await import('child_process');
                 execSync('git init', { cwd, stdio: 'inherit' });
                 try {
@@ -85,12 +110,16 @@ async function runInit(parsed, _config, _paths) {
                 catch {
                     // Ignore if branch rename fails (already on main)
                 }
-                console.log('✅ Git initialized');
-                console.log('');
             }
-            else {
-                console.log('⚠️  Skipping git init (Forge may not work correctly)');
-                console.log('');
+            else if (shouldInitGit) {
+                const { execSync } = await import('child_process');
+                execSync('git init', { cwd, stdio: 'inherit' });
+                try {
+                    execSync('git branch -m main', { cwd, stdio: 'pipe' });
+                }
+                catch {
+                    // Ignore if branch rename fails (already on main)
+                }
             }
         }
         const backupId = (0, fs_utils_1.toIsoId)();
@@ -147,13 +176,18 @@ async function runInit(parsed, _config, _paths) {
             }
         }
         await (0, fs_utils_1.ensureDir)(backupsRoot);
-        const { executor, model } = await selectExecutorAndModel(flags);
+        // Use wizard selections in interactive mode, or select defaults in automation mode
+        if (!isInteractive && !executor) {
+            const selected = await selectExecutorAndModel(flags);
+            executor = selected.executor;
+            model = selected.model;
+        }
         await writeVersionState(cwd, backupId, false);
         await initializeProviderStatus(cwd);
         await applyExecutorDefaults(targetGenie, executor, model);
         // Configure MCP servers for both Codex and Claude Code
         await (0, mcp_config_1.configureBothExecutors)(cwd);
-        await runInstallViaCli(cwd, template);
+        // TODO: Add install chat flow here (future enhancement)
         const summary = { executor, model, backupId, templateSource: templateGenie, target: targetGenie };
         await (0, view_helpers_1.emitView)(buildInitSummaryView(summary), parsed.options);
     }

.genie/cli/dist/genie-cli.js

@@ -440,6 +440,37 @@ async function startGenieServer() {
         console.log(genieGradient('━'.repeat(60)));
         console.log(genieGradient('🛑 Shutting down Genie...'));
         console.log(genieGradient('━'.repeat(60)));
+        // Check for running tasks before killing Forge
+        const runningTasks = await (0, forge_manager_1.getRunningTasks)(baseUrl);
+        if (runningTasks.length > 0) {
+            console.log('');
+            console.log('⚠️  WARNING: Running tasks detected!');
+            console.log('');
+            console.log(`${runningTasks.length} task(s) are currently running:`);
+            console.log('');
+            runningTasks.forEach((task, index) => {
+                console.log(`${index + 1}. ${task.projectName} → ${task.taskTitle}`);
+                console.log(`   ${task.url}`);
+                console.log('');
+            });
+            // Prompt for confirmation
+            const readline = require('readline').createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const answer = await new Promise((resolve) => {
+                readline.question('Kill these tasks and shutdown? [y/N]: ', resolve);
+            });
+            readline.close();
+            if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+                console.log('');
+                console.log('❌ Shutdown cancelled. Tasks are still running.');
+                console.log('   Press Ctrl+C again to force shutdown.');
+                console.log('');
+                isShuttingDown = false; // Reset flag to allow retry
+                return;
+            }
+        }
         // Calculate session stats
         const sessionDuration = Date.now() - startTime;
         const uptimeStr = formatUptime(sessionDuration);
@@ -448,6 +479,8 @@ async function startGenieServer() {
             mcpChild.kill('SIGTERM');
             console.log('📡 MCP server stopped');
         }
+        // Kill Forge child process immediately (prevents orphaned processes)
+        (0, forge_manager_1.killForgeProcess)();
         // Stop Forge and wait for completion
         try {
             const stopped = await (0, forge_manager_1.stopForge)(logDir);

.genie/cli/dist/lib/forge-manager.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isForgeRunning = isForgeRunning;
 exports.waitForForgeReady = waitForForgeReady;
 exports.startForgeInBackground = startForgeInBackground;
+exports.getRunningTasks = getRunningTasks;
+exports.killForgeProcess = killForgeProcess;
 exports.stopForge = stopForge;
 exports.restartForge = restartForge;
 exports.getForgeProcess = getForgeProcess;
@@ -17,6 +19,8 @@ const forge_js_1 = require("../../../../forge.js");
 const DEFAULT_BASE_URL = process.env.FORGE_BASE_URL || 'http://localhost:8887';
 const HEALTH_CHECK_TIMEOUT = 3000; // 3s per health check
 const MAX_HEALTH_RETRIES = 3;
+// Track Forge child process for graceful shutdown
+let forgeChildProcess = null;
 /**
  * Health check with retry logic and exponential backoff
  */
@@ -184,6 +188,8 @@ function startForgeInBackground(opts) {
             fs_1.default.appendFileSync(logPath, `\n[EARLY EXIT] Process exited with code ${code}, signal ${signal}\n`);
         }
     });
+    // Track child process for graceful shutdown
+    forgeChildProcess = child;
     // Detach so it survives parent exit
     child.unref();
     // Close our handle to log file (child has inherited it)
@@ -208,6 +214,70 @@ function startForgeInBackground(opts) {
         }
     };
 }
+/**
+ * Check for running task attempts and return them with URLs
+ */
+async function getRunningTasks(baseUrl = DEFAULT_BASE_URL) {
+    try {
+        const client = new forge_js_1.ForgeClient(baseUrl, process.env.FORGE_TOKEN);
+        // Get all projects
+        const projects = await client.listProjects();
+        const runningTasks = [];
+        // Check each project for running attempts
+        for (const project of projects) {
+            const tasks = await client.listTasks(project.id);
+            for (const task of tasks) {
+                // Check if task has running attempts
+                const attempts = await client.listAttempts(project.id, task.id);
+                const runningAttempts = attempts.filter((a) => a.status === 'running' || a.status === 'pending');
+                for (const attempt of runningAttempts) {
+                    runningTasks.push({
+                        projectId: project.id,
+                        projectName: project.name || 'Unnamed Project',
+                        taskId: task.id,
+                        taskTitle: task.title || 'Untitled Task',
+                        attemptId: attempt.id,
+                        url: `${baseUrl}/projects/${project.id}/tasks/${task.id}/attempts/${attempt.id}`
+                    });
+                }
+            }
+        }
+        return runningTasks;
+    }
+    catch (error) {
+        // If we can't check, return empty array (don't block shutdown)
+        return [];
+    }
+}
+/**
+ * Kill Forge child process immediately (for Ctrl+C shutdown)
+ * Sends SIGTERM to the entire process group
+ */
+function killForgeProcess() {
+    if (!forgeChildProcess || forgeChildProcess.killed) {
+        return;
+    }
+    try {
+        const pid = forgeChildProcess.pid;
+        if (pid) {
+            // Kill the entire process group (negative PID)
+            // This ensures all child processes are terminated
+            try {
+                process.kill(-pid, 'SIGTERM');
+            }
+            catch (err) {
+                // If process group kill fails, try killing the process directly
+                forgeChildProcess.kill('SIGTERM');
+            }
+        }
+    }
+    catch (error) {
+        // Ignore errors - process might already be dead
+    }
+    finally {
+        forgeChildProcess = null;
+    }
+}
 /**
  * Stop Forge process with verification
  */