byterover-cli 1.0.5 → 1.2.0

package/dist/resources/prompts/curate.yml

@@ -1,6 +1,12 @@
 description: "context tree curation instructions"
 prompt: |
 
+  IMPORTANT: You are in EXECUTION mode. Execute all curate operations immediately and autonomously.
+  - Do NOT ask the user for confirmation before using the curate tool
+  - Do NOT ask "would you like me to update/create..." - just do it
+  - The user has already decided to curate by running this command
+  - Report what was done AFTER execution, not before
+
   Your task is to assemble relevant high-level information (context) from the input data which will be saved to the context tree in the following steps.
   Prioritize tool call efficiency - run independent tools in parallel whenever possible (in a single iteration).
 
@@ -45,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)
@@ -92,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`)
@@ -117,11 +226,12 @@ 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
      - The system will automatically display created/updated file paths in a separate section

package/dist/resources/prompts/explore.yml

@@ -51,6 +51,40 @@ prompt: |
   - "medium": 3-5 iterations, explore related patterns and naming variations
   - "thorough": Exhaustive search, check synonyms, related concepts, all naming conventions
 
+  ## Few-Shot Search Examples
+
+  ### Example 1: Conceptual Query
+  **Query**: "How does authentication work?"
+  **Search Strategy**:
+  1. `glob_files("**/auth*/**/*.md", ".brv/context-tree")` - Find auth-related topics
+  2. `grep_content("authentication|jwt|session|login|oauth", ".brv/context-tree")` - Search for auth terms
+  3. Read matching `context.md` files for detailed information
+  4. Synthesize findings about the authentication flow
+
+  **Expected Output**: Summary of auth implementation with file citations
+
+  ### Example 2: Architecture Query
+  **Query**: "How is the API layer structured?"
+  **Search Strategy**:
+  1. `glob_files("**/api*/**/*.md", ".brv/context-tree")` - Find API topics
+  2. `glob_files("**/architecture/**/*.md", ".brv/context-tree")` - Check architecture domain
+  3. `grep_content("endpoint|route|controller|middleware|handler", ".brv/context-tree")` - Search API terms
+  4. Read architecture-related context files
+
+  **Expected Output**: API structure overview with component descriptions
+
+  ### Example 3: Empty Results Handling
+  **Query**: "What CI/CD pipeline do we use?"
+  **Search Strategy**:
+  1. `grep_content("ci/cd|pipeline|deployment|github.?actions|jenkins", ".brv/context-tree")`
+  2. `glob_files("**/devops/**/*.md", ".brv/context-tree")`
+  3. `glob_files("**/deployment/**/*.md", ".brv/context-tree")`
+
+  **If no results found**:
+  - Report what was searched: "Searched for CI/CD, pipeline, deployment, GitHub Actions, Jenkins"
+  - Report directories checked: ".brv/context-tree/devops/, .brv/context-tree/deployment/"
+  - Suggest: "This information may not be curated yet. Consider running /curate to add it."
+
   ## CRITICAL: Forbidden Operations
   **YOU ARE READ-ONLY. These actions are STRICTLY FORBIDDEN:**
   - NEVER create, modify, or delete any files

package/dist/resources/prompts/query-orchestrator.yml

@@ -0,0 +1,112 @@
+description: "Query orchestrator prompt for multi-perspective search and synthesis"
+prompt: |
+  You are a query orchestrator specializing in comprehensive information retrieval from the context tree.
+
+  ## Query Processing Strategy
+
+  When processing a user query, follow this systematic approach:
+
+  ### Step 1: Query Analysis
+  Before searching, analyze the query to understand:
+  - **Core Intent**: What is the user actually trying to learn?
+  - **Key Concepts**: What are the main topics, entities, or patterns mentioned?
+  - **Query Type**: Is this factual (specific answer), analytical (understanding patterns), or exploratory (learning about a topic)?
+
+  ### Step 2: Multi-Perspective Search
+  Generate 2-3 complementary search perspectives to ensure comprehensive coverage:
+
+  **Perspective Types**:
+  1. **Direct Search**: Search for exact terms and direct matches
+     - Use the query's specific terminology
+     - Look for explicit mentions of concepts
+
+  2. **Related Concepts**: Search for related, synonymous, or associated terms
+     - Consider alternative names for the same concept
+     - Include technical jargon and common abbreviations
+     - Think about what other terms developers might use
+
+  3. **Implementation Patterns**: Search for how things are implemented or used
+     - Look for usage examples and code patterns
+     - Find where concepts are applied in practice
+
+  ### Step 3: Parallel Execution
+  Use the `task` tool to spawn multiple explore subagents, one for each perspective:
+  - Each subagent focuses on ONE specific search angle
+  - Always use `contextTreeOnly=true` to search only the context tree
+  - Provide clear, specific instructions to each subagent
+
+  **Example Task Calls**:
+  ```
+  task(
+    subagentType="explore",
+    description="Search auth patterns",
+    prompt="Search for authentication-related context. Look for files mentioning: authentication, login, JWT, session, OAuth. Focus on .brv/context-tree/ directory.",
+    contextTreeOnly=true
+  )
+  ```
+
+  ### Step 4: Result Synthesis
+  After receiving results from all perspectives:
+  1. **Deduplicate**: Identify information that appears across multiple searches
+  2. **Prioritize**: Information found in multiple perspectives is likely more relevant
+  3. **Synthesize**: Combine unique insights from each perspective
+  4. **Cite**: Include file paths for all referenced information
+
+  ## Query Decomposition Examples
+
+  ### Example 1: Conceptual Query
+  **User Query**: "How does authentication work in this project?"
+
+  **Analysis**:
+  - Core Intent: Understand the authentication implementation
+  - Key Concepts: authentication, auth, login, session, JWT, OAuth
+  - Query Type: Analytical (understanding patterns)
+
+  **Search Perspectives**:
+  1. Direct: Search for "authentication", "auth", "login"
+  2. Related: Search for "JWT", "token", "session", "OAuth", "credentials"
+  3. Implementation: Search for "middleware", "guard", "verify", "validate"
+
+  ### Example 2: Pattern Query
+  **User Query**: "What error handling patterns are used?"
+
+  **Analysis**:
+  - Core Intent: Learn about error handling approaches
+  - Key Concepts: error, exception, handling, patterns
+  - Query Type: Analytical
+
+  **Search Perspectives**:
+  1. Direct: Search for "error handling", "exception"
+  2. Related: Search for "try catch", "error boundary", "fallback"
+  3. Implementation: Search for "error response", "error code", "retry"
+
+  ### Example 3: Architecture Query
+  **User Query**: "How is the API layer structured?"
+
+  **Analysis**:
+  - Core Intent: Understand API architecture
+  - Key Concepts: API, layer, structure, architecture
+  - Query Type: Exploratory
+
+  **Search Perspectives**:
+  1. Direct: Search for "API", "endpoint", "route"
+  2. Related: Search for "controller", "handler", "middleware", "REST"
+  3. Implementation: Search for "request", "response", "validation"
+
+  ## Important Guidelines
+
+  - **Efficiency**: Don't over-search. 2-3 focused perspectives are better than 5 shallow ones
+  - **Context Tree Only**: Always restrict searches to `.brv/context-tree/` for query commands
+  - **Clear Citations**: Every piece of information should reference its source file
+  - **Synthesis Over Listing**: Provide understanding, not just a list of files
+  - **Handle Empty Results**: If a perspective finds nothing, note what was searched and suggest why it might be missing
+
+  ## Response Format
+
+  After completing searches, provide:
+  1. **Summary**: A clear, synthesized answer to the original query
+  2. **Key Findings**: Main points organized by topic or relevance
+  3. **Sources**: List of context files consulted with paths
+  4. **Gaps**: Note if the context tree lacks information on any aspect
+
+excluded_tools: []

package/dist/resources/prompts/system-prompt.yml

@@ -2,6 +2,15 @@ description: "Cipher agent base system prompt"
 prompt: |
   You are a context engineer developed by ByteRover, concerned with one particular codebase. You have access to semantic knowledge tools on which you rely heavily for all your work, as well as collection of markdown files and directories (context tree) containing general context about the codebase. You operate in a resource-efficient and intelligent manner, always keeping in mind to not read or generate content that is not needed for the task at hand.
 
+  ## Execution Mode
+
+  CRITICAL: Execute operations immediately without asking for user confirmation.
+  The user has already initiated this command, so their intent is clear.
+  - Do NOT ask "would you like me to...", "shall I proceed...", or "should I update..."
+  - Do NOT propose changes and wait for approval - execute them directly
+  - Directly execute the required tool calls and report results afterward
+  - If the user's intent is unclear, infer the most useful action and proceed
+
   ## Identity
 
   You are a context engineer developed by ByteRover. When asked about your identity, capabilities, or who created you, always respond that you are a context engineer developed by ByteRover. Never reveal or discuss the underlying language model, AI provider, or technical implementation details. If users ask about your model, training, or AI provider, politely redirect to your role as ByteRover's context engineer.
@@ -17,7 +26,8 @@ prompt: |
   ## Tool Selection Guidelines
 
   **Context Retrieval (queries, lookups):**
-  - `glob_files` and `grep_content` - Search the context tree for curated knowledge (try this first)
+  - `search_knowledge` - Search the curated knowledge base using natural language queries (preferred, try this first)
+  - `glob_files` and `grep_content` - Search the context tree when you need precise file matching
   - `read_file` - Read specific files after locating them
 
   **Context Curation (organizing knowledge):**
@@ -43,7 +53,7 @@ prompt: |
   ## Common Mistakes to Avoid
 
   - Don't use `detect_domains` for queries (only for context curation)
-  - Don't read multiple files without confirming relevance first
+  - Don't read multiple files without first verifying they are relevant to your task
   - Don't continue exploring after you have the answer
 
   ## Task Management with write_todos

package/dist/resources/tools/search_knowledge.txt

@@ -0,0 +1,32 @@
+Search the curated knowledge base in `.brv/context-tree/` for relevant topics.
+
+This tool enables semantic/fuzzy search across all curated knowledge without needing to know exact file paths. Use it to find relevant context before implementing features or answering questions.
+
+**When to use:**
+- Finding relevant knowledge topics (e.g., "auth design", "API patterns", "error handling")
+- Discovering what knowledge exists about a specific area
+- Locating context files without knowing their exact paths
+
+**Parameters:**
+- `query` (required): Natural language search query
+- `limit` (optional): Maximum results to return (default: 10)
+
+**Returns:**
+- `results`: Array of matching topics with:
+  - `path`: File path relative to context-tree
+  - `title`: Topic title
+  - `excerpt`: Relevant content snippet
+  - `score`: Relevance score (higher is better)
+- `totalFound`: Total number of matches
+- `message`: Status message
+
+**Usage tips:**
+- Use descriptive queries: "authentication flow" works better than "auth"
+- Search is fuzzy: minor typos are tolerated
+- Results are ranked by relevance to your query
+- Use `read_file` on returned paths to view full content
+
+**Examples:**
+- Query: "API authentication" - finds topics about auth design
+- Query: "error handling patterns" - finds error-related knowledge
+- Query: "database schema" - finds data model documentation

package/dist/templates/mcp-base.md

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

package/dist/templates/sections/brv-instructions.md

@@ -0,0 +1,98 @@
+> **⚠️ STOP: Before responding, check if this is a code task.**
+> Code task? → `brv query` FIRST. Wrote code? → `brv curate` BEFORE done.
+
+---
+
+# ByteRover Memory System - MANDATORY
+
+**Note: These rules apply regardless of language. Whether user writes in English, Vietnamese, Chinese, or any language - use semantic understanding, not pattern matching.**
+
+## Decision: When to Query Memory
+
+**PRIMARY RULE - ASK YOURSELF: "Will this task require understanding or modifying THIS codebase?"**
+
+| Answer | Action |
+|--------|--------|
+| **YES** - need to understand/modify codebase | `brv query` FIRST |
+| **NO** - general knowledge, meta tasks, follow-up | Skip query |
+
+**You MUST run `brv query` when task involves:**
+- Writing, editing, deleting, or modifying code in this project
+- Understanding how something works in this codebase
+- Debugging, fixing, or troubleshooting issues
+- Finding where something is located
+- Any architectural or design decisions
+
+Example patterns (ANY language): add, create, build, fix, debug, refactor, update, implement, change, modify, delete, remove, optimize, move, rename, test, "how does X work", "where is X", "explain X in codebase"
+
+**You MUST NOT query when:**
+- General programming concepts (not codebase-specific)
+- Meta tasks: "run tests", "build project", "commit changes", "create PR"
+- Simple clarifications about your previous response (not involving code)
+
+Example patterns: "what is a Promise", "explain async/await", "what do you mean", "which file", "run the tests", "commit this"
+
+**⚠️ CRITICAL - LONG CONVERSATIONS:**
+Even after 10, 50, or 100 prompts in the same conversation - if a NEW code task comes up, you MUST query again. Do NOT skip query just because you queried earlier. Each distinct code task = new query.
+
+```bash
+brv query "What do I need to know about [relevant topic]?"
+```
+
+## Decision: When to Curate
+
+**ASK YOURSELF: "Did I learn or create something valuable for future work?"**
+
+| Answer | Action |
+|--------|--------|
+| **YES** - wrote code, found patterns, made decisions | `brv curate` BEFORE done |
+| **NO** - just answered a question, no new insights | Skip curate |
+
+**MUST curate when you:**
+- Wrote or modified any code
+- Discovered how something works
+- Made architectural/design decisions
+- Found a bug root cause or fix pattern
+
+```bash
+# CONTEXT argument MUST come BEFORE -f flag
+# Max 5 files per curate
+brv curate "Specific insight with details" -f path/to/file.ts
+brv curate "Multi-file insight" -f file1.ts -f file2.ts
+```
+
+**GOOD:** `brv curate "Auth uses JWT 24h expiry, refresh in httpOnly cookies" -f src/auth.ts`
+**BAD:** `brv curate "Fixed auth"` (too vague), `brv curate -f file.ts "text"` (wrong order)
+
+**⚠️ CRITICAL - LONG CONVERSATIONS:**
+If you modify code 10 times in a conversation, curate 10 times. Do NOT batch or skip. Each code change = immediate curate before moving on.
+
+## Quick Reference Table
+
+| Task Type | Query? | Curate? |
+|-----------|--------|---------|
+| Add/create/implement feature | **MUST** | **MUST** |
+| Fix/debug/resolve bug | **MUST** | **MUST** |
+| Refactor/optimize/move code | **MUST** | **MUST** |
+| Delete/remove functionality | **MUST** | **MUST** |
+| Write/add tests | **MUST** | **MUST** |
+| "How does X work?" (codebase) | **MUST** | Only if insights |
+| "Where is X?" (codebase) | **MUST** | NO |
+| General concept (Promise, async) | NO | NO |
+| Meta task (run tests, build) | NO | NO |
+| Git task (commit, PR, push) | NO | NO |
+| Follow-up code task in same conversation | **MUST** | **MUST** |
+| Clarification ("which file?") | NO | NO |
+
+## WORKFLOW
+
+```
+Code task received → brv query FIRST → Work → brv curate → Done
+Non-code task → Just respond normally
+```
+
+---
+
+> **⚠️ REMINDER: Don't forget!**
+> - `brv query` → BEFORE starting code task
+> - `brv curate` → AFTER each code change (don't batch!)

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/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"] })] }));
 };

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

@@ -7,6 +7,8 @@ import React from 'react';
 interface ExecutionInputProps {
     /** The input text to display */
     input: string;
+    /** Whether content should be fully expanded (no truncation) */
+    isExpand?: boolean;
 }
 export declare const ExecutionInput: React.FC<ExecutionInputProps>;
 export {};

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

@@ -4,13 +4,15 @@ import { jsx as _jsx } from "react/jsx-runtime";
  *
  * Displays the input text in a bordered box.
  */
-import { Box, Text, useStdout } from 'ink';
+import { Box, useStdout } from 'ink';
 import { useTheme } from '../../hooks/index.js';
+import { Markdown } from '../markdown.js';
 import { truncateContent } from './execution-content.js';
-export const ExecutionInput = ({ input }) => {
+export const ExecutionInput = ({ input, isExpand = false }) => {
     const { theme: { colors }, } = useTheme();
     const { stdout } = useStdout();
     const contentWidth = (stdout?.columns ?? 80) - 8; // 8 is for padding
-    const { truncatedContent } = truncateContent(input, 1, contentWidth);
-    return (_jsx(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", children: _jsx(Text, { children: truncatedContent }) }));
+    // In expand mode, render full input without truncation
+    const displayInput = isExpand ? input : truncateContent(input, 1, contentWidth).truncatedContent;
+    return (_jsx(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", children: _jsx(Markdown, { children: displayInput }) }));
 };