byterover-cli 1.1.0 → 1.2.1

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

@@ -46,6 +46,20 @@ export class ConnectorsUseCase {
         // Step 6: Install the selected connector
         await this.installConnector(selectedAgent, selectedType);
     }
+    /**
+     * Display manual setup instructions for MCP configuration.
+     */
+    displayManualInstructions(agent, instructions) {
+        this.terminal.log(`\nManual setup required for ${agent}`);
+        this.terminal.log('');
+        this.terminal.log('Add this configuration to your MCP settings:');
+        this.terminal.log('');
+        this.terminal.log(instructions.configContent);
+        this.terminal.log('');
+        if (instructions.guide) {
+            this.terminal.log(`\nFor detailed instructions, see: ${instructions.guide}`);
+        }
+    }
     /**
      * Gets a description for a connector type.
      */
@@ -54,12 +68,12 @@ export class ConnectorsUseCase {
             case 'hook': {
                 return `Instructions injected on each prompt (${configPath})`;
             }
+            case 'mcp': {
+                return `Agent connects via MCP protocol ${configPath ? `(${configPath})` : ''}`;
+            }
             case 'rules': {
                 return `Agent reads instructions from rule file (${configPath})`;
             }
-            default: {
-                return configPath;
-            }
         }
     }
     /**
@@ -70,12 +84,12 @@ export class ConnectorsUseCase {
             case 'hook': {
                 return 'Hook';
             }
+            case 'mcp': {
+                return 'MCP';
+            }
             case 'rules': {
                 return 'Rules';
             }
-            default: {
-                return type;
-            }
         }
     }
     /**
@@ -101,8 +115,13 @@ export class ConnectorsUseCase {
     async installConnector(agent, connectorType) {
         const result = await this.connectorManager.switchConnector(agent, connectorType);
         if (result.success) {
+            // Handle manual setup instructions
+            if (result.installResult.requiresManualSetup && result.installResult.manualInstructions) {
+                this.displayManualInstructions(agent, result.installResult.manualInstructions);
+                return;
+            }
             if (result.fromType && result.fromType !== result.toType) {
-                this.terminal.log(`${agent} switched from ${result.fromType} to ${result.toType}`);
+                this.terminal.log(`${agent} switched from ${this.getConnectorLabel(result.fromType)} to ${this.getConnectorLabel(result.toType)}`);
                 if (result.uninstallResult?.wasInstalled) {
                     this.terminal.log(`   Uninstalled: ${result.uninstallResult.configPath}`);
                 }
@@ -117,8 +136,8 @@ export class ConnectorsUseCase {
                 this.terminal.log(`   Installed: ${result.installResult.configPath}`);
             }
             // Show restart message for hook connector
-            if (result.toType === 'hook' && !result.installResult.alreadyInstalled) {
-                this.terminal.warn(`\nPlease restart ${agent} to apply the new hooks.`);
+            if ((result.toType === 'hook' || result.toType === 'mcp') && !result.installResult.alreadyInstalled) {
+                this.terminal.warn(`\nPlease restart ${agent} to apply the new ${result.toType}.`);
             }
         }
         else {
@@ -194,7 +213,7 @@ export class ConnectorsUseCase {
     async promptForSwitchConfirmation(agent, fromType, toType) {
         const fromConnector = this.connectorManager.getConnector(fromType);
         const fromPath = fromConnector.getConfigPath(agent);
-        this.terminal.warn(`${agent} is currently connected via ${fromType} (${fromPath})`);
+        this.terminal.warn(`${agent} is currently connected via ${this.getConnectorLabel(fromType)} ${fromPath ? `(${fromPath})` : ''}`);
         return this.terminal.confirm({
             default: true,
             message: `Switch to ${toType}? This will uninstall the current connector.`,

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

@@ -178,8 +178,8 @@ export class InitUseCase {
                 this.terminal.log(`${selectedAgent} connected via ${defaultType}`);
                 this.terminal.log(`   Installed: ${result.configPath}`);
                 // Show restart message for hook connector
-                if (defaultType === 'hook') {
-                    this.terminal.warn(`\n⚠️  Please restart ${selectedAgent} to apply the new hooks.`);
+                if (defaultType === 'hook' || defaultType === 'mcp') {
+                    this.terminal.warn(`\n⚠️  Please restart ${selectedAgent} to apply the new ${defaultType}.`);
                 }
             }
         }
@@ -351,7 +351,6 @@ export class InitUseCase {
                 this.terminal.log('✓ Context tree initialized');
             }
             else {
-                // Remote has real data - sync it to local
                 await this.contextTreeWriterService.sync({ files: [...coGitSnapshot.files] });
                 await this.contextTreeSnapshotService.saveSnapshot();
                 this.terminal.log(`✓ Synced ${coGitSnapshot.files.length} context files from remote`);

package/dist/infra/usecase/status-use-case.d.ts

@@ -4,10 +4,12 @@ import type { IProjectConfigStore } from '../../core/interfaces/i-project-config
 import type { ITerminal } from '../../core/interfaces/i-terminal.js';
 import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
 import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+import type { IInstanceDiscovery } from '../../core/interfaces/instance/i-instance-discovery.js';
 import type { IStatusUseCase } from '../../core/interfaces/usecase/i-status-use-case.js';
 export interface StatusUseCaseOptions {
     contextTreeService: IContextTreeService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
+    instanceDiscovery?: IInstanceDiscovery;
     projectConfigStore: IProjectConfigStore;
     terminal: ITerminal;
     tokenStore: ITokenStore;
@@ -16,6 +18,7 @@ export interface StatusUseCaseOptions {
 export declare class StatusUseCase implements IStatusUseCase {
     private readonly contextTreeService;
     private readonly contextTreeSnapshotService;
+    private readonly instanceDiscovery;
     private readonly projectConfigStore;
     private readonly terminal;
     private readonly tokenStore;
@@ -24,4 +27,11 @@ export declare class StatusUseCase implements IStatusUseCase {
     run(options: {
         cliVersion: string;
     }): Promise<void>;
+    /**
+     * Checks the MCP connection status by:
+     * 1. Discovering running brv instance
+     * 2. Connecting to it via Socket.IO
+     * 3. Verifying bidirectional communication with ping
+     */
+    private checkMcpStatus;
 }

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

@@ -2,9 +2,12 @@ import chalk from 'chalk';
 import { join } from 'node:path';
 import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
 import { getErrorMessage } from '../../utils/error-helpers.js';
+import { FileInstanceDiscovery } from '../instance/file-instance-discovery.js';
+import { SocketIOTransportClient } from '../transport/socket-io-transport-client.js';
 export class StatusUseCase {
     contextTreeService;
     contextTreeSnapshotService;
+    instanceDiscovery;
     projectConfigStore;
     terminal;
     tokenStore;
@@ -12,6 +15,7 @@ export class StatusUseCase {
     constructor(options) {
         this.contextTreeService = options.contextTreeService;
         this.contextTreeSnapshotService = options.contextTreeSnapshotService;
+        this.instanceDiscovery = options.instanceDiscovery ?? new FileInstanceDiscovery();
         this.projectConfigStore = options.projectConfigStore;
         this.terminal = options.terminal;
         this.tokenStore = options.tokenStore;
@@ -56,6 +60,8 @@ export class StatusUseCase {
             this.terminal.log('Project Status: Unable to read project configuration');
             this.terminal.warn(`Warning: ${getErrorMessage(error)}`);
         }
+        // MCP connection status
+        await this.checkMcpStatus();
         // Context tree status
         try {
             const contextTreeExists = await this.contextTreeService.exists();
@@ -94,4 +100,51 @@ export class StatusUseCase {
             this.terminal.warn(`Warning: ${error instanceof Error ? error.message : 'Context Tree unable to check status'}`);
         }
     }
+    /**
+     * Checks the MCP connection status by:
+     * 1. Discovering running brv instance
+     * 2. Connecting to it via Socket.IO
+     * 3. Verifying bidirectional communication with ping
+     */
+    async checkMcpStatus() {
+        try {
+            // Step 1: Discover running instance
+            const discoveryResult = await this.instanceDiscovery.discover(process.cwd());
+            if (!discoveryResult.found) {
+                if (discoveryResult.reason === 'instance_crashed') {
+                    this.terminal.log(`MCP Status: ${chalk.red('Instance crashed')} (stale instance file found)`);
+                }
+                else {
+                    this.terminal.log(`MCP Status: ${chalk.yellow('No instance running')}`);
+                }
+                return;
+            }
+            const { instance, projectRoot } = discoveryResult;
+            this.terminal.log(`MCP Status: Instance found (PID: ${instance.pid}, Port: ${instance.port})`);
+            // Step 2: Connect to instance
+            const client = new SocketIOTransportClient();
+            const url = instance.getTransportUrl();
+            try {
+                await client.connect(url);
+            }
+            catch (connectError) {
+                this.terminal.log(`MCP Status: ${chalk.red('Connection failed')} - ${getErrorMessage(connectError)}`);
+                return;
+            }
+            // Step 3: Verify bidirectional communication with ping
+            const isResponsive = await client.isConnected(2000);
+            if (isResponsive) {
+                this.terminal.log(`MCP Status: ${chalk.green('Connected and responsive')} (${projectRoot})`);
+            }
+            else {
+                this.terminal.log(`MCP Status: ${chalk.yellow('Connected but not responsive')} (ping timeout)`);
+            }
+            // Clean up
+            await client.disconnect();
+        }
+        catch (error) {
+            this.terminal.log(`MCP Status: ${chalk.red('Error checking status')}`);
+            this.terminal.warn(`Warning: ${getErrorMessage(error)}`);
+        }
+    }
 }

package/dist/resources/prompts/curate.yml

@@ -51,7 +51,110 @@ prompt: |
      - **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. **Two-Part Context Model (REQUIRED)**: When creating context using the `curate` tool, you MUST use the structured format with `rawConcept` and `narrative`:
+  5. **Domain Context (REQUIRED for new domains)**: When creating content in a NEW domain (one that doesn't exist yet), you MUST provide the `domainContext` field:
+
+     **domainContext** - Describes the domain's purpose and scope:
+     - `purpose` (required): What this domain represents and why it exists
+     - `scope.included` (required): Array of what belongs in this domain
+     - `scope.excluded` (optional): Array of what does NOT belong in this domain
+     - `ownership` (optional): Which team/system owns this domain
+     - `usage` (optional): How this domain should be used
+
+     **Example with domainContext for a new domain:**
+     ```json
+     {
+       "type": "ADD",
+       "path": "authentication/jwt",
+       "title": "Token Handling",
+       "content": { ... },
+       "domainContext": {
+         "purpose": "Contains all knowledge related to user and service authentication mechanisms used across the platform. Documents how identities are verified, credentials issued/validated, and authentication flows implemented.",
+         "scope": {
+           "included": [
+             "Login and signup authentication flows",
+             "Token-based authentication (JWT, refresh tokens)",
+             "Session handling",
+             "OAuth and third-party identity providers",
+             "Service-to-service authentication"
+           ],
+           "excluded": [
+             "Authorization and permission models (belongs in authorization)",
+             "User profile management",
+             "Account lifecycle management"
+           ]
+         },
+         "ownership": "Platform Security Team",
+         "usage": "Use this domain for documenting authentication flows, token handling, identity verification. Backend engineers implementing login/token validation, security engineers auditing auth flows."
+       },
+       "reason": "Documenting JWT token handling in new authentication domain"
+     }
+     ```
+
+     **When to provide domainContext:**
+     - ALWAYS when the domain doesn't exist yet (check with `list_directory` or `glob_files` first)
+     - NOT needed when adding to an existing domain (context.md already exists)
+
+  6. **Topic Context (REQUIRED for new topics)**: When creating content in a NEW topic (one that doesn't exist yet), you MUST provide the `topicContext` field:
+
+     **topicContext** - Describes what the topic covers:
+     - `overview` (required): What this topic covers and its main focus
+     - `keyConcepts` (optional): Array of key concepts covered in this topic
+     - `relatedTopics` (optional): Array of related topics and how they connect
+
+     **Example with topicContext for a new topic:**
+     ```json
+     {
+       "type": "ADD",
+       "path": "authentication/jwt",
+       "title": "Token Handling",
+       "content": { ... },
+       "topicContext": {
+         "overview": "Covers all aspects of JWT-based authentication including token generation, validation, and refresh mechanisms used across the platform.",
+         "keyConcepts": [
+           "JWT tokens and their structure",
+           "Refresh token rotation",
+           "Token blacklisting for revocation",
+           "Token validation middleware"
+         ],
+         "relatedTopics": [
+           "authentication/session - for session-based alternatives",
+           "security/encryption - for token signing mechanisms"
+         ]
+       },
+       "reason": "Documenting JWT token handling in new jwt topic"
+     }
+     ```
+
+     **When to provide topicContext:**
+     - ALWAYS when the topic doesn't exist yet (check with `list_directory` or `glob_files` first)
+     - NOT needed when adding to an existing topic (topic/context.md already exists)
+
+  7. **Subtopic Context (REQUIRED for new subtopics)**: When creating content in a NEW subtopic (one that doesn't exist yet), you MUST provide the `subtopicContext` field:
+
+     **subtopicContext** - Describes the subtopic's specific focus:
+     - `focus` (required): The specific focus of this subtopic
+     - `parentRelation` (optional): How this subtopic relates to its parent topic
+
+     **Example with subtopicContext for a new subtopic:**
+     ```json
+     {
+       "type": "ADD",
+       "path": "authentication/jwt/refresh_tokens",
+       "title": "Rotation Strategy",
+       "content": { ... },
+       "subtopicContext": {
+         "focus": "Focuses on refresh token rotation strategy and invalidation mechanisms to prevent token reuse attacks.",
+         "parentRelation": "Handles the token refresh aspect of JWT authentication, specifically how old tokens are invalidated when new ones are issued."
+       },
+       "reason": "Documenting refresh token rotation in new subtopic"
+     }
+     ```
+
+     **When to provide subtopicContext:**
+     - ALWAYS when the subtopic doesn't exist yet (check with `list_directory` or `glob_files` first)
+     - NOT needed when adding to an existing subtopic (subtopic/context.md already exists)
+
+  8. **Two-Part Context Model (REQUIRED)**: When creating context using the `curate` tool, you MUST use the structured format with `rawConcept` and `narrative`:
 
      **rawConcept** - Captures essential metadata and technical footprint:
      - `task`: What is the task/feature being documented (required - always include this)
@@ -98,7 +201,7 @@ prompt: |
      }
      ```
 
-  6. **Context Quality Requirements**: Each context MUST:
+  9. **Context Quality Requirements**: Each context MUST:
      - Include a clear `task` in rawConcept describing what the concept is about
      - Provide at least one of: `changes`, `files`, or `flow` in rawConcept
      - Include at least one narrative field (`structure`, `dependencies`, or `features`)
@@ -123,11 +226,11 @@ prompt: |
         code, message, context object, and optional cause. Use `ErrorHandler.wrap(fn)` for consistent error boundaries across
         async operations."
 
-  7. **Tool Execution Efficiency**:
+  10. **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
 
-  8. **Response Format**:
+  11. **Response Format**:
      - Your final response must be a brief summary (1-2 sentences) describing what knowledge was curated
      - Always mention the topic name, and include the subtopic name if a subtopic was created
      - Do NOT include any file paths, directory paths, or specific location details in your response

package/dist/templates/mcp-base.md

@@ -0,0 +1 @@
+{{mcp_workflow}}

package/dist/templates/sections/command-reference.md

@@ -1,100 +1,9 @@
 # ByteRover CLI Command Reference
 
-## Memory Commands
+## Available Commands
 
-### `brv curate`
+- `brv curate` - Curate context to the context tree
+- `brv query` - Query and retrieve information from the context tree
+- `brv status` - Show CLI status and project information
 
-**Description:** Curate context to the context tree (interactive or autonomous mode)
-
-**Arguments:**
-
-- `CONTEXT`: Knowledge context: patterns, decisions, errors, or insights (triggers autonomous mode, optional)
-
-**Flags:**
-
-- `--files`, `-f`: Include file paths for critical context (max 5 files). Only text/code files from the current project directory are allowed. **CONTEXT argument must come BEFORE this flag.**
-
-**Good examples of context:**
-
-- "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"
-- "API rate limit is 100 req/min per user. Implemented using Redis with sliding window in rateLimiter.ts"
-
-**Bad examples:**
-
-- "Authentication" or "JWT tokens" (too vague, lacks context)
-- "Rate limiting" (no implementation details or file references)
-
-**Examples:**
-
-```bash
-# Interactive mode (manually choose domain/topic)
-brv curate
-
-# Autonomous mode - LLM auto-categorizes your context
-brv curate "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"
-
-# Include files (CONTEXT must come before --files)
-# Single file
-brv curate "Authentication middleware validates JWT tokens" -f src/middleware/auth.ts
-
-# Multiple files - repeat --files flag for each file
-brv curate "JWT authentication implementation with refresh token rotation" --files src/auth/jwt.ts --files docs/auth.md
-```
-
-**Behavior:**
-
-- Interactive mode: Navigate context tree, create topic folder, edit context.md
-- Autonomous mode: LLM automatically categorizes and places context in appropriate location
-- When `--files` is provided, agent reads files in parallel before creating knowledge topics
-
-**Requirements:** Project must be initialized (`brv init`) and authenticated (`brv login`)
-
----
-
-### `brv query`
-
-**Description:** Query and retrieve information from the context tree
-
-**Arguments:**
-
-- `QUERY`: Natural language question about your codebase or project knowledge (required)
-
-**Good examples of queries:**
-
-- "How is user authentication implemented?"
-- "What are the API rate limits and where are they enforced?"
-
-**Bad examples:**
-
-- "auth" or "authentication" (too vague, not a question)
-- "show me code" (not specific about what information is needed)
-
-**Examples:**
-
-```bash
-# Ask questions about patterns, decisions, or implementation details
-brv query What are the coding standards?
-brv query How is authentication implemented?
-```
-
-**Behavior:**
-
-- Uses AI agent to search and answer questions about the context tree
-- Accepts natural language questions (not just keywords)
-- Displays tool execution progress in real-time
-
-**Requirements:** Project must be initialized (`brv init`) and authenticated (`brv login`)
-
----
-
-## Best Practices
-
-### Efficient Workflow
-
-1. **Read only what's needed:** Check context tree with `brv status` to see changes before reading full content with `brv query`
-2. **Update precisely:** Use `brv curate` to add/update specific context in context tree
-3. **Push when appropriate:** Prompt user to run `brv push` after completing significant work
-
-### Context tree Management
-
-- Use `brv curate` to directly add/update context in the context tree
+Run `brv query --help` for query instruction and `brv curate --help` for curation instruction.

package/dist/templates/sections/mcp-workflow.md

@@ -0,0 +1,13 @@
+# Workflow Instruction
+
+You are a coding agent integrated with ByteRover via MCP (Model Context Protocol).
+
+## Core Rules
+
+1. **Query First**: Automatically call the mcp tool `brv-query` when you need to query the context for the task and you do not have the context.
+2. **Curate Later**: After finishing the task, call `brv-curate` to store back the knowledge if it is very important.
+
+## Tool Usage
+
+- `brv-query`: Query the context tree.
+- `brv-curate`: Store context to the context tree.

package/dist/templates/sections/workflow.md

@@ -1,27 +1,32 @@
 # Workflow Instruction
 
 You are a coding agent focused on one codebase. Use the brv CLI to manage working context.
-Core Rules:
 
-- Start from memory. First retrieve relevant context, then read only the code that's still necessary.
-- Keep a local context tree. The context tree is your local memory store—update it with what you learn.
+## Core Rules
 
-## Context Tree Guideline
-
-- Be specific ("Use React Query for data fetching in web modules").
-- Be actionable (clear instruction a future agent/dev can apply).
-- Be contextual (mention module/service, constraints, links to source).
-- Include source (file + lines or commit) when possible.
+- **Start from memory.** First retrieve relevant context with `brv query`, then read only the code that's still necessary.
+- **Keep a local context tree.** The context tree is your local memory store—update it with `brv curate` when you learn something valuable.
 
-## Using `brv curate` with Files
+## When to Query
 
-When adding complex implementations, use `--files` to include relevant source files (max 5).  Only text/code files from the current project directory are allowed. **CONTEXT argument must come BEFORE --files flag.** For multiple files, repeat the `--files` (or `-f`) flag for each file.
+Use `brv query` **before** starting any code task that requires understanding the codebase:
+- Writing, editing, or modifying code
+- Understanding how something works
+- Debugging or troubleshooting issues
+- Making architectural decisions
 
-Examples:
+## When to Curate
 
-- Single file: `brv curate "JWT authentication with refresh token rotation" -f src/auth.ts`
-- Multiple files: `brv curate "Authentication system" --files src/auth/jwt.ts --files src/auth/middleware.ts --files docs/auth.md`
+Use `brv curate` **after** you learn or create something valuable:
+- Wrote or modified code
+- Discovered how something works
+- Made architectural/design decisions
+- Found a bug root cause or fix pattern
 
-## CLI Usage Notes
+## Context Tree Guideline
 
-- Use --help on any command to discover flags. Provide exact arguments for the scenario.
+Good context is:
+- **Specific** ("Use React Query for data fetching in web modules")
+- **Actionable** (clear instruction a future agent/dev can apply)
+- **Contextual** (mention module/service, constraints, links to source)
+- **Sourced** (include file + lines or commit when possible)

package/dist/tui/app.js

@@ -7,6 +7,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * - Authorized: Show main app with tabs
  */
 import { Box } from 'ink';
+import { useState } from 'react';
 import { Footer, Header, TabBar } from './components/index.js';
 import { useAuth, useTasks } from './contexts/index.js';
 import { useTabNavigation, useTerminalBreakpoint, useUIHeights } from './hooks/index.js';
@@ -17,6 +18,8 @@ export const App = () => {
     const { isAuthorized } = useAuth();
     const { activeTab, tabs } = useTabNavigation();
     const { stats: taskStats } = useTasks();
+    const [selectedLogIndex, setSelectedLogIndex] = useState(0);
+    const [expandedViewLogId, setExpandedViewLogId] = useState(null);
     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, 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, {}) }))] }));
+    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: [activeTab === 'activity' && (_jsx(LogsView, { availableHeight: contentHeight, expandedViewLogId: expandedViewLogId, selectedLogIndex: selectedLogIndex, setExpandedViewLogId: setExpandedViewLogId, setSelectedLogIndex: setSelectedLogIndex })), _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/command-details.js

@@ -20,7 +20,7 @@ function formatUsage(label, args, flags, subCommands) {
         usage += ` ${argsStr}`;
     }
     if (flags?.length) {
-        const flagsStr = flags.map((f) => `[--${f.name}]`).join(' ');
+        const flagsStr = flags.map((f) => (f.type === 'file' ? `[${f.char}${f.name}]` : `[--${f.name}]`)).join(' ');
         usage += ` ${flagsStr}`;
     }
     return usage;

package/dist/tui/components/execution/execution-changes.d.ts

@@ -7,6 +7,8 @@ import React from 'react';
 interface ExecutionChangesProps {
     /** List of created file paths */
     created: string[];
+    /** Whether content should be fully expanded (no truncation) */
+    isExpand?: boolean;
     /** Maximum changes configuration */
     maxChanges?: {
         created: number;

package/dist/tui/components/execution/execution-changes.js

@@ -6,7 +6,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { Box, Text } from 'ink';
 import { useTheme } from '../../hooks/index.js';
-export const ExecutionChanges = ({ created, updated, maxChanges = { created: Infinity, updated: Infinity }, }) => {
+export const ExecutionChanges = ({ created, isExpand = false, updated, maxChanges = { created: Number.MAX_SAFE_INTEGER, updated: Number.MAX_SAFE_INTEGER }, }) => {
     const { theme: { colors }, } = useTheme();
     const totalChanges = created.length + updated.length;
     if (totalChanges === 0) {
@@ -14,6 +14,10 @@ export const ExecutionChanges = ({ created, updated, maxChanges = { created: Inf
     }
     const hasCreated = created.length > 0;
     const hasUpdated = updated.length > 0;
+    // In expand mode, show all changes without truncation
+    if (isExpand) {
+        return (_jsxs(Box, { flexDirection: "column", children: [hasCreated && (_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { color: colors.secondary, children: "created at:" }), _jsx(Box, { flexDirection: "column", children: created.map((path) => (_jsx(Text, { children: path }, path))) })] })), hasUpdated && (_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { color: colors.secondary, children: "updated at:" }), _jsx(Box, { flexDirection: "column", children: updated.map((path) => (_jsx(Text, { children: path }, path))) })] }))] }));
+    }
     // Calculate overflow for each section
     // maxChanges represents total lines (items + indicator if overflow)
     const createdOverflow = created.length > maxChanges.created;

package/dist/tui/components/execution/execution-content.d.ts

@@ -20,6 +20,8 @@ interface ExecutionContentProps {
     content: string;
     /** Whether this is error content */
     isError?: boolean;
+    /** Whether content should be fully expanded (no truncation) */
+    isExpand?: boolean;
     /** Maximum number of lines (rows) this component can use, including the "more lines" indicator */
     maxLines?: number;
 }

package/dist/tui/components/execution/execution-content.js

@@ -7,6 +7,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useStdout } from 'ink';
 import { useTheme } from '../../hooks/index.js';
 import { getVisualLineCount } from '../../utils/line.js';
+import { Markdown } from '../markdown.js';
 const DEFAULT_MAX_LINES = 5;
 /**
  * Truncate content string to maxLines, returning truncated content and remaining line count.
@@ -42,39 +43,28 @@ export function truncateContent(content, maxLines, maxCharsPerLine) {
             break;
         }
     }
-    // Replace last 3 characters of last line with "..." if truncated
-    let finalContent = truncatedLines.join('\n');
-    if (truncatedLines.length > 0 && totalVisualLines > visualLineCount) {
-        const lastLineIndex = truncatedLines.length - 1;
-        const lastLine = truncatedLines[lastLineIndex];
-        if (lastLine.length >= 3) {
-            truncatedLines[lastLineIndex] = lastLine.slice(0, -3) + '...';
-            finalContent = truncatedLines.join('\n');
-        }
-        else if (lastLine.length > 0) {
-            // If last line is shorter than 3 chars, just replace entirely with "..."
-            truncatedLines[lastLineIndex] = '...';
-            finalContent = truncatedLines.join('\n');
-        }
-    }
     return {
         remainingLines: totalVisualLines - visualLineCount,
         totalLines: totalVisualLines,
-        truncatedContent: finalContent,
+        truncatedContent: truncatedLines.join('\n'),
     };
 }
-export const ExecutionContent = ({ bottomMargin = 1, content, isError = false, maxLines = DEFAULT_MAX_LINES, }) => {
+export const ExecutionContent = ({ bottomMargin = 1, content, isError = false, isExpand = false, maxLines = DEFAULT_MAX_LINES, }) => {
     const { theme: { colors }, } = useTheme();
     const { stdout } = useStdout();
     const contentWidth = (stdout?.columns ?? 80) - 4; // 4 is for padding
     if (!content) {
         return null;
     }
+    // In expand mode, render full content without truncation
+    if (isExpand) {
+        return (_jsx(Box, { flexDirection: "column", marginY: 1, children: isError ? (_jsx(Text, { color: colors.errorText, children: content })) : (_jsx(Markdown, { children: content })) }));
+    }
     // First check if content would overflow
     const { totalLines } = truncateContent(content, maxLines, contentWidth);
     const hasOverflow = totalLines > maxLines;
     // If overflow, reserve 1 line for indicator, show (maxLines - 1) lines of content
     const effectiveMaxLines = hasOverflow ? maxLines - 1 : maxLines;
     const { remainingLines, truncatedContent } = truncateContent(content, effectiveMaxLines, contentWidth);
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: bottomMargin, children: [_jsx(Text, { color: isError ? colors.errorText : colors.text, children: truncatedContent }), remainingLines > 0 && _jsxs(Text, { color: colors.dimText, children: ["\u2195 ", remainingLines, " more lines"] })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: bottomMargin, children: [isError ? (_jsx(Text, { color: colors.errorText, children: truncatedContent })) : (_jsx(Markdown, { children: truncatedContent })), remainingLines > 0 && _jsxs(Text, { color: colors.dimText, children: [remainingLines, " more lines"] })] }));
 };