byterover-cli 1.0.3 → 1.0.4

package/dist/infra/storage/file-token-store.d.ts

@@ -0,0 +1,31 @@
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import { AuthToken } from '../../core/domain/entities/auth-token.js';
+/**
+ * Dependencies for FileTokenStore.
+ * Allows injection for testing.
+ */
+export interface FileTokenStoreDeps {
+    readonly getCredentialsPath: () => string;
+    readonly getDataDir: () => string;
+    readonly getKeyPath: () => string;
+}
+/**
+ * File-based token store for WSL2 environments.
+ *
+ * Note: This class should not be used directly. Use createTokenStore() instead,
+ * which handles platform detection and selects the appropriate backend.
+ *
+ * Security:
+ * - Random 32-byte key stored in ~/.local/share/brv/.token-key (rotated on each save)
+ * - AES-256-GCM authenticated encryption for token data
+ * - Both files have 0600 permissions (owner read/write only)
+ */
+export declare class FileTokenStore implements ITokenStore {
+    private readonly deps;
+    constructor(deps?: FileTokenStoreDeps);
+    clear(): Promise<void>;
+    load(): Promise<AuthToken | undefined>;
+    save(token: AuthToken): Promise<void>;
+    private decrypt;
+    private encrypt;
+}

package/dist/infra/storage/file-token-store.js

@@ -0,0 +1,98 @@
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { AuthToken } from '../../core/domain/entities/auth-token.js';
+import { getGlobalDataDir } from '../../utils/global-data-path.js';
+const KEY_FILE = '.token-key';
+const CREDENTIALS_FILE = 'credentials';
+const ALGORITHM = 'aes-256-gcm';
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+const defaultDeps = {
+    getCredentialsPath: () => `${getGlobalDataDir()}/${CREDENTIALS_FILE}`,
+    getDataDir: getGlobalDataDir,
+    getKeyPath: () => `${getGlobalDataDir()}/${KEY_FILE}`,
+};
+/**
+ * File-based token store for WSL2 environments.
+ *
+ * Note: This class should not be used directly. Use createTokenStore() instead,
+ * which handles platform detection and selects the appropriate backend.
+ *
+ * Security:
+ * - Random 32-byte key stored in ~/.local/share/brv/.token-key (rotated on each save)
+ * - AES-256-GCM authenticated encryption for token data
+ * - Both files have 0600 permissions (owner read/write only)
+ */
+export class FileTokenStore {
+    deps;
+    constructor(deps = defaultDeps) {
+        this.deps = deps;
+    }
+    async clear() {
+        try {
+            const credentialsPath = this.deps.getCredentialsPath();
+            const keyPath = this.deps.getKeyPath();
+            if (existsSync(credentialsPath)) {
+                await unlink(credentialsPath);
+            }
+            if (existsSync(keyPath)) {
+                await unlink(keyPath);
+            }
+        }
+        catch {
+            /** Ignore errors */
+        }
+    }
+    async load() {
+        try {
+            const keyPath = this.deps.getKeyPath();
+            const credentialsPath = this.deps.getCredentialsPath();
+            if (!existsSync(keyPath) || !existsSync(credentialsPath)) {
+                return undefined;
+            }
+            const key = await readFile(keyPath);
+            const encrypted = await readFile(credentialsPath, 'utf8');
+            const decrypted = this.decrypt(encrypted.trim(), key);
+            const json = JSON.parse(decrypted);
+            return AuthToken.fromJson(json);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async save(token) {
+        const dataDir = this.deps.getDataDir();
+        const keyPath = this.deps.getKeyPath();
+        const credentialsPath = this.deps.getCredentialsPath();
+        await mkdir(dataDir, { recursive: true });
+        // Always generate new key for rotation (security best practice)
+        const key = randomBytes(KEY_LENGTH);
+        await writeFile(keyPath, key);
+        await chmod(keyPath, 0o600);
+        const plaintext = JSON.stringify(token.toJson());
+        const encrypted = this.encrypt(plaintext, key);
+        await writeFile(credentialsPath, encrypted, 'utf8');
+        await chmod(credentialsPath, 0o600);
+    }
+    decrypt(ciphertext, key) {
+        const parts = ciphertext.split(':');
+        if (parts.length !== 3) {
+            throw new Error('Invalid format');
+        }
+        const iv = Buffer.from(parts[0], 'base64');
+        const authTag = Buffer.from(parts[1], 'base64');
+        const encrypted = Buffer.from(parts[2], 'base64');
+        const decipher = createDecipheriv(ALGORITHM, key, iv);
+        decipher.setAuthTag(authTag);
+        return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf8');
+    }
+    encrypt(plaintext, key) {
+        const iv = randomBytes(IV_LENGTH);
+        const cipher = createCipheriv(ALGORITHM, key, iv);
+        const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+        const authTag = cipher.getAuthTag();
+        /** Format: iv:authTag:data (all base64) */
+        return `${iv.toString('base64')}:${authTag.toString('base64')}:${encrypted.toString('base64')}`;
+    }
+}

package/dist/infra/storage/keychain-token-store.d.ts

@@ -1,7 +1,10 @@
 import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
 import { AuthToken } from '../../core/domain/entities/auth-token.js';
 /**
- * Token store implementation using the system keychain via the keytar library.
+ * Token store using system keychain via keytar.
+ *
+ * Note: This class should not be used directly. Use createTokenStore() instead,
+ * which handles platform detection and selects the appropriate backend.
  */
 export declare class KeychainTokenStore implements ITokenStore {
     clear(): Promise<void>;

package/dist/infra/storage/keychain-token-store.js

@@ -3,7 +3,10 @@ import { AuthToken } from '../../core/domain/entities/auth-token.js';
 const SERVICE_NAME = 'byterover-cli';
 const ACCOUNT_NAME = 'auth-token';
 /**
- * Token store implementation using the system keychain via the keytar library.
+ * Token store using system keychain via keytar.
+ *
+ * Note: This class should not be used directly. Use createTokenStore() instead,
+ * which handles platform detection and selects the appropriate backend.
  */
 export class KeychainTokenStore {
     async clear() {
@@ -11,7 +14,7 @@ export class KeychainTokenStore {
             await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
         }
         catch {
-            // Ignore errors - token might not exist or keychain might be unavailable
+            // Ignore errors (token may not exist, permissions, etc.)
         }
     }
     async load() {
@@ -24,13 +27,12 @@ export class KeychainTokenStore {
             return AuthToken.fromJson(deserialized);
         }
         catch {
-            // Return undefined on any error (missing token, invalid JSON, keychain errors)
             return undefined;
         }
     }
     async save(token) {
         try {
-            const data = JSON.stringify(token);
+            const data = JSON.stringify(token.toJson());
             await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, data);
         }
         catch (error) {

package/dist/infra/storage/token-store.d.ts

@@ -0,0 +1,10 @@
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+/**
+ * Creates the appropriate token store for the current platform.
+ *
+ * - WSL: FileTokenStore (encrypted file-based, keychain not available)
+ * - macOS/Linux/Windows: KeychainTokenStore (system keychain via keytar)
+ *
+ * @param isWslFn - Optional function to detect WSL (for testing)
+ */
+export declare function createTokenStore(isWslFn?: () => boolean): ITokenStore;

package/dist/infra/storage/token-store.js

@@ -0,0 +1,14 @@
+import { isWsl } from '../../utils/environment-detector.js';
+import { FileTokenStore } from './file-token-store.js';
+import { KeychainTokenStore } from './keychain-token-store.js';
+/**
+ * Creates the appropriate token store for the current platform.
+ *
+ * - WSL: FileTokenStore (encrypted file-based, keychain not available)
+ * - macOS/Linux/Windows: KeychainTokenStore (system keychain via keytar)
+ *
+ * @param isWslFn - Optional function to detect WSL (for testing)
+ */
+export function createTokenStore(isWslFn = isWsl) {
+    return isWslFn() ? new FileTokenStore() : new KeychainTokenStore();
+}

package/dist/infra/usecase/curate-use-case.js

@@ -32,8 +32,8 @@ export class CurateUseCase {
             }
             // Generate taskId in UseCase (Application layer owns task creation)
             const taskId = randomUUID();
-            // Send task:create - Transport routes to Agent, UseCase handles logic
             await client.request('task:create', {
+                clientCwd: process.cwd(),
                 content: context,
                 ...(files?.length ? { files } : {}),
                 taskId,

package/dist/infra/user/http-user-service.js

@@ -1,5 +1,4 @@
 import { User } from '../../core/domain/entities/user.js';
-import { getErrorMessage } from '../../utils/error-helpers.js';
 import { AuthenticatedHttpClient } from '../http/authenticated-http-client.js';
 export class HttpUserService {
     config;
@@ -10,16 +9,12 @@ export class HttpUserService {
         };
     }
     async getCurrentUser(accessToken, sessionKey) {
-        try {
-            const httpClient = new AuthenticatedHttpClient(accessToken, sessionKey);
-            const response = await httpClient.get(`${this.config.apiBaseUrl}/user/me`, {
-                timeout: this.config.timeout,
-            });
-            return this.mapToUser(response.data);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch user information: ${getErrorMessage(error)}`);
-        }
+        // IMPORTANT: Do not try-catch here - let callers handle errors (e.g., distinguish 401 from network errors)
+        const httpClient = new AuthenticatedHttpClient(accessToken, sessionKey);
+        const response = await httpClient.get(`${this.config.apiBaseUrl}/user/me`, {
+            timeout: this.config.timeout,
+        });
+        return this.mapToUser(response.data);
     }
     mapToUser(userData) {
         return new User(userData.email, userData.id, userData.name);

package/dist/resources/prompts/curate.yml

@@ -7,7 +7,7 @@ prompt: |
   The information should be sufficient to understand what the user has provided to the coding assistant as the important context so that the coding assistant can use it to complete the task at hand. When organizing the context, keep in mind the hierarchical structure with a maximum of 2 levels: domain → topic → subtopic. If subtopics contain complex information, break them into separate topics rather than creating deeper nesting.
 
   The context tree captures:
-  - the domains of the context
+  - the domains of the context (dynamically created based on content)
   - the topics of the context
   - the subtopics of the context (maximum one level under topics)
   - the code snippets of the context
@@ -29,16 +29,25 @@ prompt: |
      - The current domain and text segments from the user's input data
      - The existing context in the context tree
      Use the `curate` tool to create new knowledge topics or update existing ones. Ensure that:
-     - **Domain selection**: Always prefer predefined domains (code_style, design, structure, compliance, testing, bug_fixes). Only create custom domains if content clearly doesn't fit any predefined domain. Maximum 3 custom domains allowed.
+     - **Dynamic Domain Creation**: Create domains that are semantically meaningful for the content being curated
      - The context is well-structured and MUST meet **Context quality requirements**
      - There is no duplication with existing context
      - The information is clear and easy to understand
 
-  4. **Tool Execution Efficiency:**
+  4. **Domain Naming Guidelines** (CRITICAL for quality):
+     - Choose domain names that accurately describe the category of knowledge
+     - Use snake_case format with 1-3 words (e.g., `authentication`, `api_design`, `error_handling`)
+     - **Good examples**: `authentication`, `data_models`, `ui_components`, `testing_patterns`, `api_endpoints`, `security`, `configuration`, `logging`, `caching`, `performance`
+     - **Avoid**: Generic names like `misc`, `other`, `general`, `stuff`
+     - **Avoid**: Overly specific names that only fit one topic
+     - **Before creating a new domain**: Check if existing domains could accommodate the content
+     - **Consolidate related concepts**: Group similar topics under the same domain for better organization
+
+  5. **Tool Execution Efficiency:**
      - When multiple tools don't depend on each other's results, execute them in parallel with `batch`
      - Example: `glob_files`, `list_directory`, `grep_content` and `read_file` operations for different files can run together
 
-  5. **Context quality requirements**: Each context in the `contexts` array must:
+  6. **Context quality requirements**: Each context in the `contexts` array must:
      - Important: Minimum 2-4 sentences per context. Otherwise, DO NOT add that context.
      - A developer should understand the concept without reading source code
      - Include names of functions, classes, patterns, or key concepts
@@ -57,7 +66,7 @@ prompt: |
         code, message, context object, and optional cause. Use `ErrorHandler.wrap(fn)` for consistent error boundaries across
         async operations."
 
-  6. **Response Format**:
+  7. **Response Format**:
      - Your final response must be a brief summary (1-2 sentences) describing what knowledge was curated
      - Do NOT include any file paths, directory paths, or specific location details in your response
      - The system will automatically display created/updated file paths in a separate section 

package/dist/resources/prompts/plan.yml

@@ -34,6 +34,12 @@ prompt: |
   - For **query commands**: Search ONLY within the structure shown
   - For **curate commands**: Check existing content to avoid duplicates
 
+  **Dynamic Domain System**: Domains are created dynamically based on content semantics, not from a fixed predefined list. When curating:
+  - The curate agent will create semantically meaningful domain names based on the content
+  - Domain names should be descriptive and follow snake_case format (e.g., `authentication`, `api_design`, `error_handling`)
+  - Before creating new domains, check if existing domains could accommodate the content
+  - Good domain examples: `authentication`, `data_models`, `ui_components`, `testing_patterns`, `api_endpoints`
+
   ## Workflow for Context Search/Query Requests
 
   When a user wants to **search or retrieve information from the context tree** (query command), follow these steps:

package/dist/tui/app.js

@@ -18,5 +18,5 @@ export const App = () => {
     const { activeTab, tabs } = useTabNavigation();
     const { stats: taskStats } = useTasks();
     const contentHeight = Math.max(1, terminalHeight - header - tab - footer);
-    return (_jsxs(Box, { flexDirection: "column", height: terminalHeight, paddingBottom: appBottomPadding, width: terminalWidth, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Header, { compact: isAuthorized, showTransportStats: isAuthorized, taskStats: taskStats }) }), isAuthorized ? (_jsxs(_Fragment, { children: [_jsx(Box, { flexShrink: 0, children: _jsx(TabBar, { activeTab: activeTab, tabs: tabs }) }), _jsxs(Box, { flexGrow: 1, paddingX: 1, children: [_jsx(Box, { display: activeTab === 'activity' ? 'flex' : 'none', height: "100%", width: "100%", children: _jsx(LogsView, { availableHeight: contentHeight }) }), _jsx(Box, { display: activeTab === 'console' ? 'flex' : 'none', height: "100%", width: "100%", children: _jsx(CommandView, { availableHeight: contentHeight }) })] }), _jsx(Box, { flexShrink: 0, children: _jsx(Footer, {}) })] })) : (_jsx(Box, { flexGrow: 1, paddingX: 1, children: _jsx(LoginView, {}) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", height: terminalHeight, paddingBottom: appBottomPadding, width: terminalWidth, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Header, { compact: isAuthorized, showStatusLine: isAuthorized, taskStats: taskStats }) }), isAuthorized ? (_jsxs(_Fragment, { children: [_jsx(Box, { flexShrink: 0, children: _jsx(TabBar, { activeTab: activeTab, tabs: tabs }) }), _jsxs(Box, { flexGrow: 1, paddingX: 1, children: [_jsx(Box, { display: activeTab === 'activity' ? 'flex' : 'none', height: "100%", width: "100%", children: _jsx(LogsView, { availableHeight: contentHeight }) }), _jsx(Box, { display: activeTab === 'console' ? 'flex' : 'none', height: "100%", width: "100%", children: _jsx(CommandView, { availableHeight: contentHeight }) })] }), _jsx(Box, { flexShrink: 0, children: _jsx(Footer, {}) })] })) : (_jsx(Box, { flexGrow: 1, paddingX: 1, children: _jsx(LoginView, {}) }))] }));
 };

package/dist/tui/components/execution/log-item.js

@@ -6,6 +6,7 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
  */
 import { Box, Spacer, Text } from 'ink';
 import { useTheme } from '../../hooks/index.js';
+import { formatTime } from '../../utils/index.js';
 import { ExecutionChanges } from './execution-changes.js';
 import { ExecutionContent } from './execution-content.js';
 import { ExecutionInput } from './execution-input.js';
@@ -13,10 +14,6 @@ import { ExecutionProgress } from './execution-progress.js';
 import { ExecutionStatus } from './execution-status.js';
 export const LogItem = ({ heights, log }) => {
     const { theme: { colors }, } = useTheme();
-    // Format timestamp as local time HH:MM:SS
-    const hours = log.timestamp.getHours().toString().padStart(2, '0');
-    const minutes = log.timestamp.getMinutes().toString().padStart(2, '0');
-    const seconds = log.timestamp.getSeconds().toString().padStart(2, '0');
-    const displayTime = `${hours}:${minutes}:${seconds}`;
+    const displayTime = formatTime(log.timestamp);
     return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, width: "100%", children: [_jsxs(Box, { children: [_jsxs(Text, { color: log.type === 'curate' ? colors.curateCommand : colors.queryCommand, children: ["[", log.type, "] "] }), _jsxs(Text, { color: colors.dimText, children: ["@", log.source ?? 'system'] }), _jsx(Spacer, {}), _jsxs(Text, { color: colors.dimText, children: ["[", displayTime, "]"] })] }), _jsx(ExecutionInput, { input: log.input }), _jsxs(Box, { flexDirection: "column", children: [log.progress && _jsx(ExecutionProgress, { maxLines: heights.maxProgressItems, progress: log.progress }), _jsx(ExecutionStatus, { status: log.status })] }), (log.status === 'failed' || log.status === 'completed') && (_jsx(ExecutionContent, { bottomMargin: heights.contentBottomMargin, content: log.content ?? '', isError: log.status === 'failed', maxLines: heights.maxContentLines })), log.status === 'completed' && (_jsx(ExecutionChanges, { created: log.changes.created, maxChanges: heights.maxChanges, updated: log.changes.updated }))] }));
 };

package/dist/tui/components/header.d.ts

@@ -11,7 +11,7 @@ import { TaskStats } from '../types/ui.js';
 interface HeaderProps {
     compact?: boolean;
     connectedAgent?: string;
-    showTransportStats?: boolean;
+    showStatusLine?: boolean;
     taskStats?: TaskStats;
 }
 export declare const Header: React.FC<HeaderProps>;

package/dist/tui/components/header.js

@@ -7,14 +7,35 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * - Connected agent status
  * - Queue stats (pending/processing)
  */
-import { Box, Spacer, Text } from 'ink';
-import { useServices } from '../contexts/index.js';
+import { Box, Text } from 'ink';
+import { useEffect, useState } from 'react';
+import { useServices, useStatus } from '../contexts/index.js';
 import { useTheme } from '../contexts/theme-context.js';
 import { useTerminalBreakpoint } from '../hooks/use-terminal-breakpoint.js';
 import { Logo } from './logo.js';
-export const Header = ({ compact, connectedAgent, showTransportStats, taskStats: transportStats }) => {
+import { StatusBadge } from './status-badge.js';
+export const Header = ({ compact, showStatusLine, taskStats: transportStats }) => {
     const { version } = useServices();
     const { theme } = useTheme();
     const { breakpoint } = useTerminalBreakpoint();
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(Logo, { compact: compact, version: version }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 2, children: [connectedAgent && (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "\u25CF " }), _jsx(Text, { color: "gray", children: connectedAgent })] })), breakpoint === "compact" && (_jsx(Text, { color: theme.colors.warning, children: "Terminal too small - expand for better experience" }))] }), showTransportStats && (_jsxs(Box, { paddingRight: 1, children: [_jsx(Spacer, {}), _jsx(Text, { children: "~ in queue: " }), _jsx(Text, { color: theme.colors.warning, children: transportStats?.created ?? 0 }), _jsx(Text, { children: " | running: " }), _jsx(Text, { color: theme.colors.primary, children: transportStats?.started ?? 0 })] }))] })] }));
+    const { currentEvent } = useStatus();
+    const [breakpointWarning, setBreakpointWarning] = useState(null);
+    useEffect(() => {
+        if (breakpoint === 'compact') {
+            setBreakpointWarning({
+                message: 'Terminal too small - expand for better experience',
+                type: 'warning',
+            });
+        }
+        else {
+            setBreakpointWarning(null);
+        }
+    }, [breakpoint]);
+    // Status event takes priority over breakpoint warning
+    const displayStatus = currentEvent
+        ? { label: currentEvent.label, message: currentEvent.message, type: currentEvent.type }
+        : breakpointWarning
+            ? { label: breakpointWarning.type, message: breakpointWarning.message, type: breakpointWarning.type }
+            : null;
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(Logo, { compact: compact, version: version }), showStatusLine && (_jsxs(Box, { gap: 2, justifyContent: "space-between", children: [_jsx(StatusBadge, { label: displayStatus?.label ?? 'Idle', message: displayStatus?.message ?? 'Ready', type: displayStatus?.type ?? 'info' }), _jsxs(Box, { flexShrink: 0, paddingRight: 1, children: [_jsx(Text, { children: "~ in queue: " }), _jsx(Text, { color: theme.colors.warning, children: transportStats?.created ?? 0 }), _jsx(Text, { children: " | running: " }), _jsx(Text, { color: theme.colors.primary, children: transportStats?.started ?? 0 })] })] }))] }));
 };

package/dist/tui/components/index.d.ts

@@ -6,13 +6,17 @@ export { EnterPrompt } from './enter-prompt.js';
 export { ExecutionChanges, ExecutionContent, ExecutionInput, ExecutionProgress, ExecutionStatus, LogItem, truncateContent, } from './execution/index.js';
 export { Footer } from './footer.js';
 export { Header } from './header.js';
+export { Init } from './init.js';
+export type { InitProps } from './init.js';
 export { Logo } from './logo.js';
 export type { LogoVariant } from './logo.js';
 export { MessageItem } from './message-item.js';
-export { CopyablePrompt, OnboardingFlow, OnboardingStep } from './onboarding/index.js';
+export { CopyablePrompt, OnboardingFlow, OnboardingStep, WelcomeBox } from './onboarding/index.js';
 export type { OnboardingStepType } from './onboarding/index.js';
 export { OutputLog } from './output-log.js';
 export { ScrollableList } from './scrollable-list.js';
 export type { ScrollableListProps } from './scrollable-list.js';
+export { StatusBadge } from './status-badge.js';
+export type { StatusBadgeProps, StatusType } from './status-badge.js';
 export { Suggestions } from './suggestions.js';
 export { TabBar } from './tab-bar.js';

package/dist/tui/components/index.js

@@ -6,10 +6,12 @@ export { EnterPrompt } from './enter-prompt.js';
 export { ExecutionChanges, ExecutionContent, ExecutionInput, ExecutionProgress, ExecutionStatus, LogItem, truncateContent, } from './execution/index.js';
 export { Footer } from './footer.js';
 export { Header } from './header.js';
+export { Init } from './init.js';
 export { Logo } from './logo.js';
 export { MessageItem } from './message-item.js';
-export { CopyablePrompt, OnboardingFlow, OnboardingStep } from './onboarding/index.js';
+export { CopyablePrompt, OnboardingFlow, OnboardingStep, WelcomeBox } from './onboarding/index.js';
 export { OutputLog } from './output-log.js';
 export { ScrollableList } from './scrollable-list.js';
+export { StatusBadge } from './status-badge.js';
 export { Suggestions } from './suggestions.js';
 export { TabBar } from './tab-bar.js';

package/dist/tui/components/init.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Init Component
+ *
+ * Reusable component for running the /init command with streaming output
+ * and inline prompts. Used by InitView and OnboardingFlow.
+ */
+import React from 'react';
+import type { StreamingMessage } from '../types.js';
+/**
+ * Processed streaming message for rendering
+ * Includes action state for spinner display
+ */
+export interface ProcessedMessage extends StreamingMessage {
+    /** For action_start: whether the action is still running (no matching action_stop) */
+    isActionRunning?: boolean;
+    /** For action_start: the completion message from action_stop */
+    stopMessage?: string;
+}
+export interface InitProps {
+    /** Whether the component should be interactive (for EnterPrompt activation) */
+    active?: boolean;
+    /** Auto-start init without waiting for Enter key in idle state */
+    autoStart?: boolean;
+    /** Custom idle state message (optional) */
+    idleMessage?: string;
+    /** Maximum lines available for streaming output */
+    maxOutputLines: number;
+    /** Optional callback when init completes successfully */
+    onInitComplete?: () => void;
+    /** Show idle state message? (default: true for InitView, false for OnboardingFlow) */
+    showIdleMessage?: boolean;
+}
+export declare const Init: React.FC<InitProps>;