byterover-cli 1.4.0 → 1.6.0

package/dist/core/domain/errors/headless-prompt-error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Error thrown when headless mode encounters a prompt that cannot be handled.
+ * Provides detailed information about what prompt was required and available choices.
+ */
+export declare class HeadlessPromptError extends Error {
+    readonly availableChoices?: string[];
+    readonly code = "HEADLESS_PROMPT_REQUIRED";
+    readonly promptMessage: string;
+    readonly promptType: string;
+    constructor(promptType: string, promptMessage: string, availableChoices?: string[]);
+}

package/dist/core/domain/errors/headless-prompt-error.js

@@ -0,0 +1,18 @@
+/**
+ * Error thrown when headless mode encounters a prompt that cannot be handled.
+ * Provides detailed information about what prompt was required and available choices.
+ */
+export class HeadlessPromptError extends Error {
+    availableChoices;
+    code = 'HEADLESS_PROMPT_REQUIRED';
+    promptMessage;
+    promptType;
+    constructor(promptType, promptMessage, availableChoices) {
+        const choicesInfo = availableChoices?.length ? ` Available choices: ${availableChoices.join(', ')}` : '';
+        super(`Headless mode cannot handle ${promptType} prompt: "${promptMessage}".${choicesInfo}`);
+        this.name = 'HeadlessPromptError';
+        this.promptType = promptType;
+        this.promptMessage = promptMessage;
+        this.availableChoices = availableChoices;
+    }
+}

package/dist/core/interfaces/cipher/i-content-generator.d.ts

@@ -12,6 +12,17 @@
 import type { ToolSet } from '../../domain/cipher/tools/types.js';
 import type { ExecutionContext } from './i-cipher-agent.js';
 import type { InternalMessage, ToolCall } from './message-types.js';
+/**
+ * Stream chunk type for distinguishing content types during streaming.
+ */
+export declare enum StreamChunkType {
+    /** Regular text content */
+    CONTENT = "content",
+    /** Thinking/reasoning content from models like Gemini */
+    THINKING = "thinking",
+    /** Tool call request */
+    TOOL_CALL = "tool_call"
+}
 /**
  * Configuration for content generation.
  */
@@ -76,8 +87,27 @@ export interface GenerateContentChunk {
     finishReason?: 'error' | 'max_tokens' | 'stop' | 'tool_calls';
     /** Whether this is the final chunk */
     isComplete: boolean;
+    /** Provider-specific metadata */
+    providerMetadata?: Record<string, unknown>;
+    /**
+     * Raw API chunk data for native reasoning extraction.
+     * Used by models that return reasoning in native fields (OpenAI, Grok, Gemini).
+     */
+    rawChunk?: unknown;
+    /**
+     * Incremental reasoning/thinking content.
+     * For models that provide native reasoning fields (OpenAI o1/o3, Grok, Gemini).
+     */
+    reasoning?: string;
+    /** Unique ID for the reasoning block (for tracking across deltas) */
+    reasoningId?: string;
     /** Tool calls (only on final chunk or when complete) */
     toolCalls?: ToolCall[];
+    /**
+     * Type of this chunk for distinguishing content from thinking.
+     * Defaults to CONTENT if not specified.
+     */
+    type?: StreamChunkType;
 }
 /**
  * Content Generator interface.

package/dist/core/interfaces/cipher/i-content-generator.js

@@ -9,4 +9,15 @@
  *
  * Based on gemini-cli's ContentGenerator pattern.
  */
-export {};
+/**
+ * Stream chunk type for distinguishing content types during streaming.
+ */
+export var StreamChunkType;
+(function (StreamChunkType) {
+    /** Regular text content */
+    StreamChunkType["CONTENT"] = "content";
+    /** Thinking/reasoning content from models like Gemini */
+    StreamChunkType["THINKING"] = "thinking";
+    /** Tool call request */
+    StreamChunkType["TOOL_CALL"] = "tool_call";
+})(StreamChunkType || (StreamChunkType = {}));

package/dist/core/interfaces/cipher/message-factory.d.ts

@@ -40,7 +40,10 @@ export declare function createFilePart(data: FilePart['data'], mimeType: string,
 export declare function createReasoningPart(text: string, summary?: {
     description: string;
     subject: string;
-}, options?: PartOptions): ReasoningPart;
+}, options?: PartOptions & {
+    id?: string;
+    providerMetadata?: Record<string, unknown>;
+}): ReasoningPart;
 /**
  * Create a ToolPart in pending state.
  */

package/dist/core/interfaces/cipher/message-factory.js

@@ -52,9 +52,14 @@ export function createFilePart(data, mimeType, filename, options) {
  */
 export function createReasoningPart(text, summary, options) {
     return {
+        id: options?.id ?? `reasoning-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
         text,
+        time: {
+            start: Date.now(),
+        },
         type: 'reasoning',
         ...(summary && { summary }),
+        ...(options?.providerMetadata && { providerMetadata: options.providerMetadata }),
         ...(options?.synthetic !== undefined && { synthetic: options.synthetic }),
         ...(options?.metadata && { metadata: options.metadata }),
     };

package/dist/core/interfaces/cipher/message-types.d.ts

@@ -57,9 +57,17 @@ export interface FilePart extends BasePart {
 }
 /**
  * Reasoning/thinking content part.
- * Represents structured thinking traces from models like Gemini or Claude.
+ * Represents structured thinking traces from models like Gemini, Claude, Grok, or OpenAI.
+ * Follows OpenCode's pattern with id, timing, and provider metadata.
  */
 export interface ReasoningPart extends BasePart {
+    /** Unique identifier for this reasoning block */
+    id: string;
+    /**
+     * Provider-specific metadata (encrypted content, reasoning effort, etc.)
+     * Used to preserve original provider data for debugging and special handling.
+     */
+    providerMetadata?: Record<string, unknown>;
     /**
      * Parsed summary for display in UI.
      * Extracted from the raw text for easier rendering.
@@ -72,6 +80,16 @@ export interface ReasoningPart extends BasePart {
     };
     /** Raw reasoning/thinking text from the model */
     text: string;
+    /**
+     * Timing information for the reasoning block.
+     * Used for UX feedback and analytics.
+     */
+    time: {
+        /** Unix timestamp when reasoning ended (undefined if still streaming) */
+        end?: number;
+        /** Unix timestamp when reasoning started */
+        start: number;
+    };
     type: 'reasoning';
 }
 /**

package/dist/core/interfaces/i-cogit-pull-service.d.ts

@@ -3,7 +3,6 @@ import type { CogitSnapshot } from '../domain/entities/cogit-snapshot.js';
  * Parameters for pulling a snapshot from CoGit.
  */
 export type PullParams = {
-    accessToken: string;
     branch: string;
     sessionKey: string;
     spaceId: string;

package/dist/core/interfaces/i-memory-retrieval-service.d.ts

@@ -1,6 +1,5 @@
 import type { RetrieveResult } from '../domain/entities/retrieve-result.js';
 export type RetrieveParams = {
-    accessToken: string;
     nodeKeys?: string[];
     query: string;
     sessionKey: string;

package/dist/core/interfaces/i-memory-storage-service.d.ts

@@ -3,7 +3,6 @@ import type { PresignedUrlsResponse } from '../domain/entities/presigned-urls-re
  * Parameters for requesting presigned URLs.
  */
 export type GetPresignedUrlsParams = {
-    accessToken: string;
     branch: string;
     fileNames: string[];
     sessionKey: string;
@@ -14,7 +13,6 @@ export type GetPresignedUrlsParams = {
  * Parameters for confirming upload completion.
  */
 export type ConfirmUploadParams = {
-    accessToken: string;
     requestId: string;
     sessionKey: string;
     spaceId: string;

package/dist/core/interfaces/i-provider-config-store.d.ts

@@ -0,0 +1,88 @@
+import type { ProviderConfig } from '../domain/entities/provider-config.js';
+/**
+ * Interface for storing and retrieving provider configuration.
+ * Handles non-sensitive data (API keys stored separately in keychain).
+ */
+export interface IProviderConfigStore {
+    /**
+     * Marks a provider as connected.
+     *
+     * @param providerId The provider ID to mark as connected
+     * @param options Optional settings like default model
+     */
+    connectProvider: (providerId: string, options?: {
+        activeModel?: string;
+    }) => Promise<void>;
+    /**
+     * Removes a provider connection.
+     *
+     * @param providerId The provider ID to disconnect
+     */
+    disconnectProvider: (providerId: string) => Promise<void>;
+    /**
+     * Gets the active model for a provider.
+     *
+     * @param providerId The provider ID
+     * @returns The active model ID or undefined
+     */
+    getActiveModel: (providerId: string) => Promise<string | undefined>;
+    /**
+     * Gets the active provider ID.
+     *
+     * @returns The active provider ID
+     */
+    getActiveProvider: () => Promise<string>;
+    /**
+     * Gets favorite models for a provider.
+     *
+     * @param providerId The provider ID
+     * @returns Array of favorite model IDs
+     */
+    getFavoriteModels: (providerId: string) => Promise<readonly string[]>;
+    /**
+     * Gets recent models for a provider.
+     *
+     * @param providerId The provider ID
+     * @returns Array of recent model IDs
+     */
+    getRecentModels: (providerId: string) => Promise<readonly string[]>;
+    /**
+     * Checks if a provider is connected.
+     *
+     * @param providerId The provider ID to check
+     * @returns True if the provider is connected
+     */
+    isProviderConnected: (providerId: string) => Promise<boolean>;
+    /**
+     * Reads the provider configuration.
+     *
+     * @returns The configuration if found, default config otherwise
+     */
+    read: () => Promise<ProviderConfig>;
+    /**
+     * Sets the active model for a provider.
+     *
+     * @param providerId The provider ID
+     * @param modelId The model ID to set as active
+     */
+    setActiveModel: (providerId: string, modelId: string) => Promise<void>;
+    /**
+     * Sets the active provider.
+     *
+     * @param providerId The provider ID to set as active
+     */
+    setActiveProvider: (providerId: string) => Promise<void>;
+    /**
+     * Toggles a model as favorite.
+     *
+     * @param providerId The provider ID
+     * @param modelId The model ID to toggle
+     */
+    toggleFavorite: (providerId: string, modelId: string) => Promise<void>;
+    /**
+     * Writes the provider configuration.
+     *
+     * @param config The configuration to write
+     */
+    write: (config: ProviderConfig) => Promise<void>;
+}

package/dist/core/interfaces/i-provider-config-store.js

@@ -0,0 +1 @@
+export {};

package/dist/core/interfaces/i-provider-keychain-store.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Interface for storing provider API keys securely.
+ * Uses system keychain (macOS Keychain, Linux Secret Service, Windows Credential Manager).
+ */
+export interface IProviderKeychainStore {
+    /**
+     * Deletes the API key for a provider.
+     *
+     * @param providerId The provider ID
+     */
+    deleteApiKey: (providerId: string) => Promise<void>;
+    /**
+     * Gets the API key for a provider.
+     *
+     * @param providerId The provider ID
+     * @returns The API key if found, undefined otherwise
+     */
+    getApiKey: (providerId: string) => Promise<string | undefined>;
+    /**
+     * Checks if an API key exists for a provider.
+     *
+     * @param providerId The provider ID
+     * @returns True if an API key exists
+     */
+    hasApiKey: (providerId: string) => Promise<boolean>;
+    /**
+     * Sets the API key for a provider.
+     *
+     * @param providerId The provider ID
+     * @param apiKey The API key to store
+     */
+    setApiKey: (providerId: string, apiKey: string) => Promise<void>;
+}

package/dist/core/interfaces/i-provider-keychain-store.js

@@ -0,0 +1 @@
+export {};

package/dist/core/interfaces/i-space-service.d.ts

@@ -6,7 +6,6 @@ import type { Space } from '../domain/entities/space.js';
 export interface ISpaceService {
     /**
      * Fetches spaces accessible to the authenticated user within a specific team.
-     * @param accessToken The OAuth access token for authentication
      * @param sessionKey The session key for tracking the user session
      * @param teamId The team ID to filter spaces by
      * @param option Optional pagination options
@@ -17,7 +16,7 @@ export interface ISpaceService {
      *  - spaces: Array of Space entities
      *  - total: Total number of spaces available (across all pages)
      */
-    getSpaces: (accessToken: string, sessionKey: string, teamId: string, option?: {
+    getSpaces: (sessionKey: string, teamId: string, option?: {
         fetchAll?: boolean;
         limit?: number;
         offset?: number;

package/dist/core/interfaces/i-team-service.d.ts

@@ -6,7 +6,6 @@ import type { Team } from '../domain/entities/team.js';
 export interface ITeamService {
     /**
      * Fetches teams where the authenticated user is a member.
-     * @param accessToken The OAuth access token for authentication
      * @param sessionKey The session key for tracking the user session
      * @param option Optional filtering and pagination options
      * @param option.limit Maximum number of teams to fetch in a single request
@@ -17,7 +16,7 @@ export interface ITeamService {
      *  - teams: Array of Team entities
      *  - total: Total number of teams available (across all pages)
      */
-    getTeams: (accessToken: string, sessionKey: string, option?: {
+    getTeams: (sessionKey: string, option?: {
         fetchAll?: boolean;
         isActive?: boolean;
         limit?: number;

package/dist/core/interfaces/i-user-service.d.ts

@@ -6,9 +6,8 @@ import type { User } from '../domain/entities/user.js';
 export interface IUserService {
     /**
      * Fetches the current authenticated user's information.
-     * @param accessToken The OAuth access token for authentication
      * @param sessionKey The session key for tracking the user session
      * @returns A promise that resolves to the User entity
      */
-    getCurrentUser: (accessToken: string, sessionKey: string) => Promise<User>;
+    getCurrentUser: (sessionKey: string) => Promise<User>;
 }

package/dist/core/interfaces/usecase/i-curate-use-case.d.ts

@@ -2,6 +2,8 @@ export interface CurateUseCaseRunOptions {
     apiKey?: string;
     context?: string;
     files?: string[];
+    format?: 'json' | 'text';
+    headless?: boolean;
     model?: string;
     verbose?: boolean;
 }

package/dist/core/interfaces/usecase/i-init-use-case.d.ts

@@ -1,5 +1,11 @@
+export interface InitUseCaseRunOptions {
+    force: boolean;
+    format?: 'json' | 'text';
+    /** Space ID for headless mode (skips interactive selection) */
+    spaceId?: string;
+    /** Team ID for headless mode (skips interactive selection) */
+    teamId?: string;
+}
 export interface IInitUseCase {
-    run(options: {
-        force: boolean;
-    }): Promise<void>;
+    run(options: InitUseCaseRunOptions): Promise<void>;
 }

package/dist/core/interfaces/usecase/i-login-use-case.d.ts

@@ -1,3 +1,6 @@
+export interface LoginUseCaseRunOptions {
+    apiKey?: string;
+}
 export interface ILoginUseCase {
-    run(): Promise<void>;
+    run(options: LoginUseCaseRunOptions): Promise<void>;
 }

package/dist/core/interfaces/usecase/i-pull-use-case.d.ts

@@ -1,5 +1,7 @@
+export interface PullUseCaseRunOptions {
+    branch: string;
+    format?: 'json' | 'text';
+}
 export interface IPullUseCase {
-    run: (options: {
-        branch: string;
-    }) => Promise<void>;
+    run: (options: PullUseCaseRunOptions) => Promise<void>;
 }

package/dist/core/interfaces/usecase/i-push-use-case.d.ts

@@ -1,6 +1,8 @@
+export interface PushUseCaseRunOptions {
+    branch: string;
+    format?: 'json' | 'text';
+    skipConfirmation: boolean;
+}
 export interface IPushUseCase {
-    run(options: {
-        branch: string;
-        skipConfirmation: boolean;
-    }): Promise<void>;
+    run(options: PushUseCaseRunOptions): Promise<void>;
 }

package/dist/core/interfaces/usecase/i-query-use-case.d.ts

@@ -1,5 +1,7 @@
 export interface QueryUseCaseRunOptions {
     apiKey?: string;
+    format?: 'json' | 'text';
+    headless?: boolean;
     model?: string;
     query: string;
     verbose?: boolean;

package/dist/core/interfaces/usecase/i-status-use-case.d.ts

@@ -1,5 +1,6 @@
 export interface IStatusUseCase {
     run(options: {
         cliVersion: string;
+        format?: 'json' | 'text';
     }): Promise<void>;
 }

package/dist/infra/cipher/agent/service-initializer.d.ts

@@ -39,7 +39,7 @@ export interface SessionLLMConfig {
     temperature?: number;
     verbose?: boolean;
 }
-export type { CipherAgentServices, SessionManagerConfig, SessionServices } from '../../../core/interfaces/cipher/cipher-services.js';
+export type { CipherAgentServices, SessionManagerConfig, SessionServices, } from '../../../core/interfaces/cipher/cipher-services.js';
 /**
  * Creates shared services for CipherAgent.
  * These services are singletons shared across all sessions.

package/dist/infra/cipher/agent/service-initializer.js

@@ -232,7 +232,6 @@ export function createSessionServices(sessionId, sharedServices, httpConfig, llm
         // Use HTTP backend service (default) with generator pattern
         // Step 1: Create HTTP service
         const httpService = new ByteRoverLlmHttpService({
-            accessToken: httpConfig.accessToken,
             apiBaseUrl: httpConfig.apiBaseUrl,
             projectId: httpConfig.projectId,
             region: httpConfig.region,

package/dist/infra/cipher/file-system/file-system-service.js

@@ -314,12 +314,12 @@ export class FileSystemService {
      */
     async listDirectory(dirPath, options = {}) {
         this.ensureInitialized();
-        // Resolve path
-        const resolvedPath = path.resolve(this.config.workingDirectory, dirPath || '.');
-        // Validate path
-        const validation = this.pathValidator.validate(resolvedPath, 'read');
+        // Validate path - let PathValidator handle resolution to prevent path duplication
+        // (e.g., when workingDirectory is .brv/context-tree and dirPath is also .brv/context-tree)
+        const pathToValidate = dirPath || '.';
+        const validation = this.pathValidator.validate(pathToValidate, 'read');
         if (!validation.valid) {
-            this.throwValidationError(resolvedPath, validation.error);
+            this.throwValidationError(pathToValidate, validation.error);
         }
         const { normalizedPath } = validation;
         // Verify directory exists

package/dist/infra/cipher/http/internal-llm-http-service.d.ts

@@ -1,11 +1,11 @@
 import type { RequestOptions } from '@anthropic-ai/sdk/internal/request-options';
 import type { MessageCreateParamsNonStreaming } from '@anthropic-ai/sdk/resources/messages.js';
 import type { Content, GenerateContentConfig, GenerateContentResponse } from '@google/genai';
+import type { GenerateContentChunk } from '../../../core/interfaces/cipher/i-content-generator.js';
 /**
  * ByteRover HTTP LLM provider configuration.
  */
 export interface ByteRoverHttpConfig {
-    accessToken: string;
     apiBaseUrl: string;
     projectId?: string;
     region?: string;
@@ -61,6 +61,22 @@ export declare class ByteRoverLlmHttpService {
      * @returns Response in GenerateContentResponse format
      */
     generateContent(contents: Content[] | MessageCreateParamsNonStreaming, config: GenerateContentConfig | RequestOptions, model: string, executionMetadata?: Record<string, unknown>): Promise<GenerateContentResponse>;
+    /**
+     * Call ByteRover REST LLM service to generate content with streaming.
+     *
+     * Currently falls back to non-streaming endpoint since /api/llm/generate/stream
+     * doesn't exist on the backend yet. Extracts thinking/reasoning from the complete
+     * response and yields them as separate chunks.
+     *
+     * When backend streaming is available, this will use SSE for true streaming.
+     *
+     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
+     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
+     * @param model - Model to use (detects provider from model name)
+     * @param executionMetadata - Optional execution metadata (mode, executionContext)
+     * @yields GenerateContentChunk objects as they are generated
+     */
+    generateContentStream(contents: Content[] | MessageCreateParamsNonStreaming, config: GenerateContentConfig | RequestOptions, model: string, executionMetadata?: Record<string, unknown>): AsyncGenerator<GenerateContentChunk>;
     /**
      * Call the ByteRover REST Generate endpoint.
      *
@@ -91,4 +107,27 @@ export declare class ByteRoverLlmHttpService {
      * @returns GCP region identifier ('us-east5' or 'global')
      */
     private detectRegionFromModel;
+    /**
+     * Extract content chunks from a complete response.
+     *
+     * Looks for text parts (excluding thinking) and function calls,
+     * yields them as final chunks.
+     *
+     * @param response - Complete GenerateContentResponse
+     * @yields GenerateContentChunk for content and tool calls
+     */
+    private extractContentFromResponse;
+    /**
+     * Extract thinking/reasoning chunks from a complete response.
+     *
+     * Looks for parts with `thought: true` and yields them as THINKING chunks.
+     *
+     * @param response - Complete GenerateContentResponse
+     * @yields GenerateContentChunk for each thinking part
+     */
+    private extractThinkingFromResponse;
+    /**
+     * Map provider finish reason to standard format.
+     */
+    private mapFinishReason;
 }