@zhive/cli 0.5.0

package/dist/components/Header.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { colors, symbols, border } from '../commands/shared/theme.js';
+export function Header() {
+    const leftPart = ` ${symbols.hive} Hive `;
+    const termWidth = process.stdout.columns || 60;
+    const fillerWidth = Math.max(0, termWidth - leftPart.length - 4);
+    const filler = border.horizontal.repeat(fillerWidth);
+    return (_jsx(Box, { flexDirection: "column", marginBottom: 0, children: _jsxs(Text, { children: [_jsx(Text, { color: colors.honey, bold: true, children: leftPart }), _jsxs(Text, { color: colors.grayDim, children: [border.horizontal, border.horizontal, border.horizontal, filler] })] }) }));
+}

package/dist/components/HoneycombLoader.js

@@ -0,0 +1,190 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from 'react';
+import { Box, Text } from 'ink';
+import { colors, animation } from '../commands/shared/theme.js';
+const ROWS = 3;
+const HEX_W = 8;
+const HEX_H = 4;
+const NUM_BEES = 3;
+const NUM_STREAMS = 4;
+const PULSE_SPAWN_INTERVAL = 4;
+const PULSE_TTL = 8;
+const PULSE_COLORS = [colors.green, colors.red, colors.honey];
+function isHexEdge(r, c) {
+    const rowInHex = ((r % HEX_H) + HEX_H) % HEX_H;
+    const isOddHex = Math.floor(r / HEX_H) % 2 === 1;
+    const colOffset = isOddHex ? HEX_W / 2 : 0;
+    const colInHex = (((c - colOffset) % HEX_W) + HEX_W) % HEX_W;
+    if (rowInHex === 0 || rowInHex === HEX_H - 1) {
+        return colInHex >= 2 && colInHex <= 5;
+    }
+    if (rowInHex === 1 || rowInHex === 2) {
+        return colInHex === 1 || colInHex === 6;
+    }
+    return false;
+}
+function initBees(cols, gridRows) {
+    const bees = [];
+    for (let i = 0; i < NUM_BEES; i++) {
+        bees.push({
+            r: Math.floor(Math.random() * gridRows),
+            c: Math.floor(Math.random() * cols),
+            vr: Math.random() > 0.5 ? 1 : -1,
+            vc: Math.random() > 0.5 ? 1 : -1,
+        });
+    }
+    return bees;
+}
+function initStreamCols(cols) {
+    const streamCols = [];
+    const spacing = Math.floor(cols / (NUM_STREAMS + 1));
+    for (let i = 1; i <= NUM_STREAMS; i++) {
+        streamCols.push(spacing * i);
+    }
+    return streamCols;
+}
+export function HoneycombLoader({ label }) {
+    const [frame, setFrame] = useState(0);
+    const cols = process.stdout.columns || 60;
+    const gridRows = ROWS * HEX_H;
+    const beesRef = useRef(initBees(cols, gridRows));
+    const pulsesRef = useRef([]);
+    const streamColsRef = useRef(initStreamCols(cols));
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((prev) => prev + 1);
+        }, animation.TICK_MS);
+        return () => {
+            clearInterval(timer);
+        };
+    }, []);
+    // Advance bees every other frame
+    if (frame > 0 && frame % 2 === 0) {
+        const bees = beesRef.current;
+        for (const bee of bees) {
+            bee.r += bee.vr;
+            bee.c += bee.vc;
+            if (bee.r <= 0 || bee.r >= gridRows - 1) {
+                bee.vr *= -1;
+                bee.r = Math.max(0, Math.min(gridRows - 1, bee.r));
+            }
+            if (bee.c <= 0 || bee.c >= cols - 1) {
+                bee.vc *= -1;
+                bee.c = Math.max(0, Math.min(cols - 1, bee.c));
+            }
+            if (Math.random() > 0.3) {
+                bee.vc = Math.random() > 0.5 ? 1 : -1;
+            }
+        }
+    }
+    // Spawn pulses
+    if (frame % PULSE_SPAWN_INTERVAL === 0) {
+        const newPulses = [];
+        for (let i = 0; i < 2; i++) {
+            const pr = Math.floor(Math.random() * gridRows);
+            const pc = Math.floor(Math.random() * cols);
+            if (isHexEdge(pr, pc)) {
+                const color = PULSE_COLORS[Math.floor(Math.random() * PULSE_COLORS.length)];
+                newPulses.push({ r: pr, c: pc, ttl: PULSE_TTL, color });
+            }
+        }
+        pulsesRef.current = [
+            ...pulsesRef.current.filter((p) => p.ttl > 1).map((p) => ({ ...p, ttl: p.ttl - 1 })),
+            ...newPulses,
+        ];
+    }
+    // Build the grid
+    const grid = [];
+    const streamCols = streamColsRef.current;
+    for (let r = 0; r < gridRows; r++) {
+        const row = [];
+        for (let c = 0; c < cols; c++) {
+            const hexEdge = isHexEdge(r, c);
+            // Scanning wave
+            const scanRow = frame % (gridRows + 6);
+            const dist = Math.abs(r - scanRow);
+            if (hexEdge && dist === 0) {
+                row.push({ char: '⬢', color: colors.honey });
+                continue;
+            }
+            if (hexEdge && dist <= 1) {
+                row.push({ char: '⬡', color: colors.honey });
+                continue;
+            }
+            // Data streams
+            let isStream = false;
+            for (const sc of streamCols) {
+                if (c === sc) {
+                    const streamOffset = (frame * 2 + sc) % (gridRows * 3);
+                    const streamDist = (((r - streamOffset) % gridRows) + gridRows) % gridRows;
+                    if (streamDist < 6) {
+                        const charIdx = (frame + r) % animation.DATA_CHARS.length;
+                        const streamChar = animation.DATA_CHARS[charIdx];
+                        if (streamDist === 0) {
+                            row.push({ char: streamChar, color: colors.white });
+                        }
+                        else if (streamDist < 3) {
+                            row.push({ char: streamChar, color: colors.green });
+                        }
+                        else {
+                            row.push({ char: streamChar, color: colors.grayDim });
+                        }
+                        isStream = true;
+                        break;
+                    }
+                }
+            }
+            if (isStream)
+                continue;
+            // Default hex skeleton
+            if (hexEdge) {
+                row.push({ char: '·', color: colors.grayDim });
+            }
+            else {
+                row.push({ char: ' ', color: colors.grayDim });
+            }
+        }
+        grid.push(row);
+    }
+    // Overlay pulses
+    for (const pulse of pulsesRef.current) {
+        if (pulse.r >= 0 && pulse.r < gridRows && pulse.c >= 0 && pulse.c < cols) {
+            const brightness = pulse.ttl / PULSE_TTL;
+            const cell = grid[pulse.r][pulse.c];
+            if (cell.char === '·' || cell.char === ' ') {
+                grid[pulse.r][pulse.c] = {
+                    char: brightness > 0.5 ? '⬡' : '·',
+                    color: pulse.color,
+                };
+            }
+        }
+    }
+    // Overlay bees
+    for (const bee of beesRef.current) {
+        const br = Math.max(0, Math.min(gridRows - 1, Math.round(bee.r)));
+        const bc = Math.max(0, Math.min(cols - 1, Math.round(bee.c)));
+        grid[br][bc] = { char: '◆', color: colors.honey };
+    }
+    // Render grid rows
+    const rowElements = grid.map((rowCells, r) => {
+        const segments = [];
+        let runColor = rowCells[0]?.color ?? colors.grayDim;
+        let runChars = '';
+        for (let c = 0; c < rowCells.length; c++) {
+            const cell = rowCells[c];
+            if (cell.color === runColor) {
+                runChars += cell.char;
+            }
+            else {
+                segments.push(_jsx(Text, { color: runColor, children: runChars }, segments.length));
+                runColor = cell.color;
+                runChars = cell.char;
+            }
+        }
+        if (runChars.length > 0) {
+            segments.push(_jsx(Text, { color: runColor, children: runChars }, segments.length));
+        }
+        return _jsx(Text, { children: segments }, r);
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [rowElements, _jsxs(Box, { justifyContent: "center", marginTop: 0, children: [_jsx(Text, { color: colors.honey, children: '⬡ ' }), _jsx(Text, { color: colors.gray, children: label })] })] }));
+}

package/dist/components/InputGuard.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+const defaultRef = { current: false };
+export const InputGuardContext = createContext(defaultRef);
+export function useInputGuard() {
+    return useContext(InputGuardContext);
+}

package/dist/components/MultiSelectPrompt.js

@@ -0,0 +1,45 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { colors, symbols } from '../commands/shared/theme.js';
+export function MultiSelectPrompt({ label, items, defaultSelected, onSubmit, }) {
+    const allValues = new Set(items.map((i) => i.value));
+    const [selected, setSelected] = useState(defaultSelected ?? allValues);
+    const [cursor, setCursor] = useState(0);
+    useInput((_input, key) => {
+        if (key.upArrow) {
+            setCursor((prev) => (prev > 0 ? prev - 1 : items.length - 1));
+        }
+        if (key.downArrow) {
+            setCursor((prev) => (prev < items.length - 1 ? prev + 1 : 0));
+        }
+        if (_input === ' ') {
+            const item = items[cursor];
+            if (!item)
+                return;
+            setSelected((prev) => {
+                const next = new Set(prev);
+                if (next.has(item.value)) {
+                    next.delete(item.value);
+                }
+                else {
+                    next.add(item.value);
+                }
+                return next;
+            });
+        }
+        if (key.return) {
+            const selectedItems = items.filter((i) => selected.has(i.value));
+            onSubmit(selectedItems);
+        }
+    });
+    const highlightedItem = items[cursor];
+    const highlightedDescription = highlightedItem?.description;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: [symbols.arrow, " "] }), _jsx(Text, { color: colors.white, bold: true, children: label })] }), _jsx(Box, { marginLeft: 2, marginBottom: 1, children: _jsx(Text, { color: colors.grayDim, italic: true, children: "All selected by default \u2014 deselect what you don't want" }) }), _jsx(Box, { flexDirection: "column", marginLeft: 2, children: items.map((item, i) => {
+                    const isCursor = i === cursor;
+                    const isSelected = selected.has(item.value);
+                    const checkbox = isSelected ? '◆' : '◇';
+                    const itemColor = isCursor ? colors.honey : colors.white;
+                    return (_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: [isCursor ? symbols.diamond : ' ', " "] }), _jsxs(Text, { color: isSelected ? colors.honey : colors.grayDim, children: [checkbox, " "] }), _jsx(Text, { color: itemColor, children: item.label })] }, item.value));
+                }) }), highlightedDescription && (_jsx(Box, { marginLeft: 4, marginTop: 1, children: _jsxs(Text, { color: colors.gray, italic: true, children: [symbols.arrow, " ", highlightedDescription] }) })), _jsx(Box, { marginLeft: 2, marginTop: 1, children: _jsxs(Text, { color: colors.grayDim, children: [_jsx(Text, { color: colors.honey, children: "space" }), " toggle ", _jsx(Text, { color: colors.honey, children: "enter" }), ' ', "confirm"] }) })] }));
+}

package/dist/components/SelectPrompt.js

@@ -0,0 +1,20 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { colors, symbols } from '../commands/shared/theme.js';
+export function SelectPrompt({ label, items, onSelect }) {
+    const [highlightedValue, setHighlightedValue] = useState(items[0]?.value ?? '');
+    const handleSelect = (item) => {
+        const found = items.find((i) => i.value === item.value);
+        if (found) {
+            onSelect(found);
+        }
+    };
+    const handleHighlight = (item) => {
+        setHighlightedValue(item.value);
+    };
+    const highlightedItem = items.find((i) => i.value === highlightedValue);
+    const highlightedDescription = highlightedItem?.description;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.honey, children: [symbols.arrow, " "] }), _jsx(Text, { color: colors.white, bold: true, children: label })] }), _jsx(Box, { marginLeft: 2, children: _jsx(SelectInput, { items: items, onSelect: handleSelect, onHighlight: handleHighlight, indicatorComponent: ({ isSelected }) => (_jsxs(Text, { color: colors.honey, children: [isSelected ? symbols.diamond : ' ', " "] })), itemComponent: ({ isSelected, label: itemLabel }) => (_jsx(Text, { color: isSelected ? colors.honey : colors.white, children: itemLabel })) }) }), highlightedDescription && (_jsx(Box, { marginLeft: 4, marginTop: 1, children: _jsxs(Text, { color: colors.gray, italic: true, children: [symbols.arrow, " ", highlightedDescription] }) }))] }));
+}

package/dist/components/Spinner.js

@@ -0,0 +1,16 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { colors, symbols } from '../commands/shared/theme.js';
+export function Spinner({ label }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((prev) => (prev + 1) % symbols.spinner.length);
+        }, 120);
+        return () => {
+            clearInterval(timer);
+        };
+    }, []);
+    return (_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: [symbols.spinner[frame], " "] }), _jsx(Text, { color: colors.gray, children: label })] }));
+}

package/dist/components/StepIndicator.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { colors, symbols } from '../commands/shared/theme.js';
+export function StepIndicator({ steps, currentIndex }) {
+    return (_jsx(Box, { marginLeft: 1, marginBottom: 1, children: steps.map((step, i) => {
+            const isCurrent = i === currentIndex;
+            const isCompleted = i < currentIndex;
+            let symbol;
+            let symbolColor;
+            let labelColor;
+            let bold = false;
+            if (isCurrent) {
+                symbol = symbols.dot;
+                symbolColor = colors.honey;
+                labelColor = colors.honey;
+                bold = true;
+            }
+            else if (isCompleted) {
+                symbol = symbols.check;
+                symbolColor = colors.green;
+                labelColor = colors.gray;
+            }
+            else {
+                symbol = symbols.diamondOpen;
+                symbolColor = colors.grayDim;
+                labelColor = colors.grayDim;
+            }
+            return (_jsxs(React.Fragment, { children: [i > 0 && _jsx(Text, { children: " " }), _jsx(Text, { color: symbolColor, children: symbol }), _jsxs(Text, { color: labelColor, bold: bold, children: [' ', step.label] })] }, step.key));
+        }) }));
+}

package/dist/components/StreamingText.js

@@ -0,0 +1,50 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from 'react';
+import { Box, Text } from 'ink';
+import { colors, border } from '../commands/shared/theme.js';
+import { extractErrorMessage } from '../shared/agent/utils.js';
+export function StreamingText({ stream, title, onComplete, onError, }) {
+    const [text, setText] = useState('');
+    const bufferRef = useRef('');
+    const completedRef = useRef(false);
+    useEffect(() => {
+        if (!stream) {
+            return;
+        }
+        bufferRef.current = '';
+        completedRef.current = false;
+        let cancelled = false;
+        const flushInterval = setInterval(() => {
+            if (!cancelled) {
+                setText(bufferRef.current);
+            }
+        }, 80);
+        const consume = async () => {
+            for await (const chunk of stream) {
+                if (cancelled) {
+                    break;
+                }
+                bufferRef.current += chunk;
+            }
+            if (!cancelled && !completedRef.current) {
+                completedRef.current = true;
+                const finalText = bufferRef.current;
+                setText(finalText);
+                onComplete?.(finalText);
+            }
+        };
+        consume().catch((err) => {
+            if (cancelled)
+                return;
+            const message = extractErrorMessage(err);
+            onError?.(message);
+        });
+        return () => {
+            cancelled = true;
+            clearInterval(flushInterval);
+        };
+    }, [stream]);
+    const termWidth = process.stdout.columns || 60;
+    const boxWidth = Math.min(termWidth - 4, 76);
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [title && (_jsx(Box, { children: _jsxs(Text, { color: colors.grayDim, children: [border.topLeft, border.horizontal, " ", title, ' ', border.horizontal.repeat(Math.max(0, boxWidth - title.length - 5)), border.topRight] }) })), _jsx(Box, { paddingLeft: 1, paddingRight: 1, width: boxWidth, children: _jsx(Text, { color: colors.white, wrap: "wrap", children: text || ' ' }) }), title && (_jsx(Box, { children: _jsxs(Text, { color: colors.grayDim, children: [border.bottomLeft, border.horizontal.repeat(Math.max(0, boxWidth - 2)), border.bottomRight] }) }))] }));
+}

package/dist/components/TextPrompt.js

@@ -0,0 +1,28 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { colors, symbols } from '../commands/shared/theme.js';
+export function TextPrompt({ label, placeholder, onSubmit, validate, maxLength, }) {
+    const [value, setValue] = useState('');
+    const [error, setError] = useState('');
+    useInput((_input, key) => {
+        if (key.tab && value === '' && placeholder) {
+            setValue(placeholder);
+        }
+    });
+    const handleSubmit = (input) => {
+        const trimmed = input.trim();
+        if (validate) {
+            const result = validate(trimmed);
+            if (result !== true) {
+                setError(result);
+                return;
+            }
+        }
+        setError('');
+        onSubmit(trimmed);
+    };
+    const charCounter = maxLength ? ` ${value.length}/${maxLength}` : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: [symbols.arrow, " "] }), _jsx(Text, { color: colors.white, bold: true, children: label }), maxLength && (_jsx(Text, { color: value.length > maxLength ? colors.red : colors.grayDim, children: charCounter }))] }), _jsx(Box, { marginLeft: 2, children: _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSubmit, placeholder: placeholder }) }), error !== '' && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: colors.red, children: [symbols.cross, " ", error] }) }))] }));
+}

package/dist/components/stdout-spinner.js

@@ -0,0 +1,48 @@
+import * as fs from 'fs';
+const FRAMES = ['\u25D0', '\u25D3', '\u25D1', '\u25D2']; // ◐ ◓ ◑ ◒
+const INTERVAL_MS = 200;
+const HONEY_ANSI = '\x1b[38;2;245;166;35m';
+const RESET_ANSI = '\x1b[0m';
+let _frame = 0;
+let _timer = null;
+const _entries = new Map();
+let _nextId = 0;
+function rawWrite(data) {
+    try {
+        fs.writeSync(process.stdout.fd, data);
+    }
+    catch {
+        // Ignore write errors (non-TTY, closed fd, etc.)
+    }
+}
+function tick() {
+    _frame = (_frame + 1) % FRAMES.length;
+    const char = `${HONEY_ANSI}${FRAMES[_frame]}${RESET_ANSI}`;
+    for (const getPosition of _entries.values()) {
+        const pos = getPosition();
+        if (!pos || pos.linesFromBottom <= 0)
+            continue;
+        rawWrite('\x1b7'); // Save cursor (DEC)
+        rawWrite(`\x1b[${pos.linesFromBottom}A`); // Move up N lines
+        rawWrite(`\x1b[${pos.col + 1}G`); // Move to column (1-indexed)
+        rawWrite(char);
+        rawWrite('\x1b8'); // Restore cursor (DEC)
+    }
+}
+export function register(getPosition) {
+    const id = _nextId++;
+    _entries.set(id, getPosition);
+    if (!_timer) {
+        _timer = setInterval(tick, INTERVAL_MS);
+    }
+    return id;
+}
+export function unregister(id) {
+    _entries.delete(id);
+    if (_entries.size === 0 && _timer) {
+        clearInterval(_timer);
+        _timer = null;
+        _frame = 0;
+    }
+}
+export { FRAMES };

package/dist/config.js

@@ -0,0 +1,28 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+export const HIVE_API_URL = 'https://api.zhive.ai';
+export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
+export function getHiveDir() {
+    const hiveDir = path.join(os.homedir(), '.hive');
+    return hiveDir;
+}
+export async function readConfig() {
+    try {
+        const configPath = path.join(getHiveDir(), 'config.json');
+        const config = (await fs.readJson(configPath));
+        if (!config.providerId || !config.apiKey) {
+            return null;
+        }
+        return config;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeConfig(config) {
+    const hiveDir = getHiveDir();
+    await fs.ensureDir(hiveDir);
+    const configPath = path.join(hiveDir, 'config.json');
+    await fs.writeJson(configPath, config, { spaces: 2, mode: 0o600 });
+}

package/dist/create/CreateApp.js

@@ -0,0 +1,153 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { Header } from '../components/Header.js';
+import { AsciiTicker } from '../components/AsciiTicker.js';
+import { StepIndicator } from '../components/StepIndicator.js';
+import { ApiKeyStep } from './steps/ApiKeyStep.js';
+import { NameStep } from './steps/NameStep.js';
+import { IdentityStep } from './steps/IdentityStep.js';
+import { AvatarStep } from './steps/AvatarStep.js';
+import { SoulStep } from './steps/SoulStep.js';
+import { StrategyStep } from './steps/StrategyStep.js';
+import { ScaffoldStep } from './steps/ScaffoldStep.js';
+import { DoneStep } from './steps/DoneStep.js';
+import { colors, symbols } from '../theme.js';
+import { getProvider } from '../ai-providers.js';
+function ensureAvatarUrl(content, avatarUrl) {
+    const lines = content.split('\n');
+    const avatarIdx = lines.findIndex((l) => /^## Avatar/.test(l));
+    if (avatarIdx === -1) {
+        return content;
+    }
+    // Find the next section header after ## Avatar
+    let nextSectionIdx = lines.length;
+    for (let i = avatarIdx + 1; i < lines.length; i++) {
+        if (/^##?\s/.test(lines[i])) {
+            nextSectionIdx = i;
+            break;
+        }
+    }
+    // Replace the content between ## Avatar and next section with the raw URL
+    const before = lines.slice(0, avatarIdx + 1);
+    const after = lines.slice(nextSectionIdx);
+    const result = [...before, '', avatarUrl, '', ...after];
+    return result.join('\n');
+}
+function ensureSectionLine(content, sectionHeader, linePrefix, value) {
+    const lines = content.split('\n');
+    const sectionIdx = lines.findIndex((l) => new RegExp(`^##\\s+${sectionHeader}`).test(l));
+    if (sectionIdx === -1) {
+        // Section missing — append it at the end
+        return content + `\n\n## ${sectionHeader}\n\n${linePrefix} ${value}\n`;
+    }
+    // Find the next section header after this one
+    let nextSectionIdx = lines.length;
+    for (let i = sectionIdx + 1; i < lines.length; i++) {
+        if (/^##?\s/.test(lines[i])) {
+            nextSectionIdx = i;
+            break;
+        }
+    }
+    // Look for existing line with the prefix in this section
+    const prefixRegex = new RegExp(`^${linePrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s`);
+    const lineIdx = lines.findIndex((l, i) => i > sectionIdx && i < nextSectionIdx && prefixRegex.test(l));
+    if (lineIdx !== -1) {
+        // Replace the existing line
+        lines[lineIdx] = `${linePrefix} ${value}`;
+    }
+    else {
+        // Insert after the section header (skip blank lines)
+        let insertIdx = sectionIdx + 1;
+        while (insertIdx < nextSectionIdx && lines[insertIdx].trim() === '') {
+            insertIdx++;
+        }
+        lines.splice(insertIdx, 0, `${linePrefix} ${value}`);
+    }
+    return lines.join('\n');
+}
+function ensureStrategyFields(content, sectors, sentiment, timeframes) {
+    const sectorsLine = sectors.length > 0 ? sectors.join(', ') : 'all categories';
+    const timeframesLine = timeframes.length > 0 ? timeframes.join(', ') : '1h, 4h, 24h';
+    let patched = ensureSectionLine(content, 'Sentiment', '- Bias:', sentiment);
+    patched = ensureSectionLine(patched, 'Sector Focus', '- Sectors:', sectorsLine);
+    patched = ensureSectionLine(patched, 'Timeframe', '- Active timeframes:', timeframesLine);
+    return patched;
+}
+const STEP_ORDER = ['name', 'identity', 'avatar', 'api-key', 'soul', 'strategy', 'scaffold', 'done'];
+const STEP_LABELS = {
+    'api-key': 'API Key',
+    'name': 'Name',
+    'identity': 'Identity',
+    'avatar': 'Avatar',
+    'soul': 'Soul',
+    'strategy': 'Strategy',
+    'scaffold': 'Scaffold',
+    'done': 'Done',
+};
+const STEP_DEFS = STEP_ORDER.map((s) => ({ key: s, label: STEP_LABELS[s] }));
+export function CreateApp({ initialName }) {
+    const { exit } = useApp();
+    const [step, setStep] = useState(initialName ? 'identity' : 'name');
+    const [providerId, setProviderId] = useState(null);
+    const [apiKey, setApiKey] = useState('');
+    const [agentName, setAgentName] = useState(initialName ?? '');
+    const [bio, setBio] = useState('');
+    const [personality, setPersonality] = useState('');
+    const [tone, setTone] = useState('');
+    const [voiceStyle, setVoiceStyle] = useState('');
+    const [tradingStyle, setTradingStyle] = useState('');
+    const [sectors, setSectors] = useState([]);
+    const [sentiment, setSentiment] = useState('');
+    const [timeframes, setTimeframes] = useState([]);
+    const [avatarUrl, setAvatarUrl] = useState('');
+    const [soulContent, setSoulContent] = useState('');
+    const [strategyContent, setStrategyContent] = useState('');
+    const [resolvedProjectDir, setResolvedProjectDir] = useState('');
+    const [error, setError] = useState('');
+    const stepIndex = STEP_ORDER.indexOf(step);
+    const provider = providerId ? getProvider(providerId) : null;
+    const handleApiKey = useCallback((result) => {
+        setProviderId(result.providerId);
+        setApiKey(result.apiKey);
+        setStep('soul');
+    }, []);
+    const handleName = useCallback((name) => {
+        setAgentName(name);
+        setStep('identity');
+    }, []);
+    const handleIdentity = useCallback((result) => {
+        setPersonality(result.personality);
+        setTone(result.tone);
+        setVoiceStyle(result.voiceStyle);
+        setTradingStyle(result.tradingStyle);
+        setSectors(result.sectors);
+        setSentiment(result.sentiment);
+        setTimeframes(result.timeframes);
+        setBio(result.bio);
+        setStep('avatar');
+    }, []);
+    const handleAvatar = useCallback((value) => {
+        setAvatarUrl(value);
+        setStep('api-key');
+    }, []);
+    const handleSoul = useCallback((content) => {
+        const patched = ensureAvatarUrl(content, avatarUrl);
+        setSoulContent(patched);
+        setStep('strategy');
+    }, [avatarUrl]);
+    const handleStrategy = useCallback((content) => {
+        const patched = ensureStrategyFields(content, sectors, sentiment, timeframes);
+        setStrategyContent(patched);
+        setStep('scaffold');
+    }, [sectors, sentiment, timeframes]);
+    const handleScaffoldComplete = useCallback((projectDir) => {
+        setResolvedProjectDir(projectDir);
+        setStep('done');
+    }, []);
+    const handleScaffoldError = useCallback((message) => {
+        setError(message);
+        exit();
+    }, [exit]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, {}), _jsx(StepIndicator, { steps: STEP_DEFS, currentIndex: stepIndex }), step !== 'done' && (_jsx(Box, { marginBottom: 1, children: _jsx(AsciiTicker, { step: stepIndex + 1 }) })), step === 'api-key' && (_jsx(ApiKeyStep, { onComplete: handleApiKey })), step === 'name' && (_jsx(NameStep, { onComplete: handleName })), step === 'identity' && (_jsx(IdentityStep, { agentName: agentName, onComplete: handleIdentity })), step === 'avatar' && (_jsx(AvatarStep, { agentName: agentName, onComplete: handleAvatar })), step === 'soul' && providerId && (_jsx(SoulStep, { providerId: providerId, apiKey: apiKey, agentName: agentName, bio: bio, avatarUrl: avatarUrl, personality: personality, tone: tone, voiceStyle: voiceStyle, tradingStyle: tradingStyle, sectors: sectors, sentiment: sentiment, timeframes: timeframes, onComplete: handleSoul })), step === 'strategy' && providerId && (_jsx(StrategyStep, { providerId: providerId, apiKey: apiKey, agentName: agentName, bio: bio, personality: personality, tone: tone, voiceStyle: voiceStyle, tradingStyle: tradingStyle, sectors: sectors, sentiment: sentiment, timeframes: timeframes, onComplete: handleStrategy })), step === 'scaffold' && provider && (_jsx(ScaffoldStep, { projectName: agentName, provider: provider, apiKey: apiKey, soulContent: soulContent, strategyContent: strategyContent, onComplete: handleScaffoldComplete, onError: handleScaffoldError })), step === 'done' && (_jsx(DoneStep, { projectDir: resolvedProjectDir })), error !== '' && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsxs(Text, { color: colors.red, children: [symbols.cross, " ", error] }) }))] }));
+}