byterover-cli 1.3.0 → 1.5.0

package/dist/infra/cipher/session/chat-session.js

@@ -47,6 +47,8 @@ export class ChatSession {
     llmService;
     messageQueue;
     sharedServices;
+    /** When true, strip taskId from forwarded events (subagent mode via emitTaskId: false) */
+    suppressTaskIdForwarding = false;
     /**
      * Creates a new chat session
      *
@@ -184,6 +186,9 @@ export class ChatSession {
         }
         // Store taskId for event forwarding only if emitTaskId is true
         this.currentTaskId = emitTaskId ? taskId : undefined;
+        // Suppress taskId in forwarded events for subagent sessions (prevents subagent
+        // events from appearing under the parent task in the TUI)
+        this.suppressTaskIdForwarding = !emitTaskId;
         this.isExecuting = true;
         sessionStatusManager.setBusy(this.id, this.eventBus);
         try {
@@ -217,6 +222,8 @@ export class ChatSession {
             if (this.currentTaskId === taskId) {
                 this.currentTaskId = undefined;
             }
+            // Reset suppression flag
+            this.suppressTaskIdForwarding = false;
             // Only mark idle if no active tasks
             if (this.activeControllers.size === 0) {
                 this.isExecuting = false;
@@ -290,6 +297,7 @@ export class ChatSession {
             await this.llmService.completeTask(finalInput, {
                 executionContext: options?.executionContext,
                 signal: controller.signal,
+                stream: true,
                 taskId,
             });
         }
@@ -341,9 +349,12 @@ export class ChatSession {
             const forwarder = (payload) => {
                 // Add sessionId and taskId to payload
                 const basePayload = payload && typeof payload === 'object' ? payload : {};
-                // Preserve taskId from payload if present, fallback to currentTaskId for backward compat
+                // When suppressTaskIdForwarding is true (subagent mode), strip taskId from
+                // forwarded events so they don't appear under the parent task in the TUI
                 const payloadTaskId = basePayload.taskId;
-                const effectiveTaskId = payloadTaskId ?? this.currentTaskId;
+                const effectiveTaskId = this.suppressTaskIdForwarding
+                    ? undefined
+                    : (payloadTaskId ?? this.currentTaskId);
                 const payloadWithSession = {
                     ...basePayload,
                     sessionId: this.id,

package/dist/infra/cipher/storage/message-storage-service.js

@@ -523,8 +523,12 @@ export class MessageStorageService {
             case 'reasoning': {
                 return {
                     messagePart: {
+                        id: part.id ?? `reasoning-${Date.now()}`,
                         summary: part.reasoningSummary,
                         text: part.content,
+                        time: {
+                            start: part.createdAt ?? Date.now(),
+                        },
                         type: 'reasoning',
                     },
                 };

package/dist/infra/cipher/tools/implementations/bash-exec-tool.js

@@ -26,7 +26,7 @@ const BashExecInputSchema = z
         .default(false)
         .describe('Execute command in background'),
     /**
-     * Timeout in milliseconds (max: 600000).
+     * Timeout in milliseconds (max: 600000, default: 300000 = 5 minutes).
      */
     timeout: z
         .number()
@@ -34,8 +34,8 @@ const BashExecInputSchema = z
         .positive()
         .max(600_000)
         .optional()
-        .default(120_000)
-        .describe('Timeout in milliseconds'),
+        .default(300_000)
+        .describe('Timeout in milliseconds (default: 5 minutes)'),
 })
     .strict();
 /**

package/dist/infra/cipher/tools/implementations/read-file-tool.js

@@ -7,8 +7,23 @@ import { isImageFile } from '../../file-system/binary-utils.js';
 const ReadFileInputSchema = z
     .object({
     filePath: z.string().describe('Path to the file to read (absolute or relative to working directory)'),
-    limit: z.number().int().positive().optional().describe('Maximum number of lines to read (optional, default: 2000)'),
-    offset: z.number().int().min(1).optional().describe('Starting line number (1-based, optional)'),
+    limit: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Maximum number of lines to read for text files (default: 2000), or pages for PDFs in text mode (default: 100, max: 200)'),
+    offset: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe('Starting line number (1-based) for text files, or starting page number for PDFs. ' +
+        'If the file is truncated, you MUST set offset to the next line/page number to continue reading.'),
+    pdfMode: z
+        .enum(['text', 'base64'])
+        .optional()
+        .describe("PDF read mode: 'text' (default) extracts text page by page with pagination support, 'base64' returns raw PDF as attachment for multimodal analysis"),
 })
     .strict();
 /**
@@ -29,14 +44,18 @@ const ReadFileInputSchema = z
  */
 export function createReadFileTool(fileSystemService) {
     return {
-        description: 'Read the contents of a file. Supports relative/absolute paths, pagination, and returns images/PDFs as base64 attachments.',
+        description: 'Read the contents of a file. Supports relative/absolute paths and pagination. ' +
+            'For PDFs, defaults to text extraction with page-by-page pagination (use pdfMode="base64" for raw attachment). ' +
+            'Images are returned as base64 attachments. ' +
+            'Must continue running read_file tool with the correct offset to finish reading the file.',
         async execute(input, _context) {
-            const { filePath, limit, offset } = input;
+            const { filePath, limit, offset, pdfMode } = input;
             try {
                 // Call file system service
                 const result = await fileSystemService.readFile(filePath, {
                     limit,
                     offset,
+                    pdfMode,
                 });
                 // Transform attachment format (singular → plural array)
                 let attachments;
@@ -55,6 +74,7 @@ export function createReadFileTool(fileSystemService) {
                     content: result.formattedContent,
                     lines: result.lines,
                     message: result.message,
+                    pdfMetadata: result.pdfMetadata,
                     preview: result.preview,
                     size: result.size,
                     success: true,

package/dist/infra/cipher/tools/implementations/task-tool.js

@@ -152,7 +152,7 @@ export function createTaskTool(dependencies) {
                     session = await sessionManager.createChildSessionWithOverrides(context?.sessionId ?? 'parent', agent.name, subagentSessionId, { fileSystemService: restrictedFs });
                 }
                 else {
-                    session = await sessionManager.createSession(subagentSessionId);
+                    session = await sessionManager.createChildSession(context?.sessionId ?? 'parent', agent.name, subagentSessionId);
                 }
                 // Build the system prompt for the subagent
                 // Load the agent's prompt from YAML file or use inline prompt

package/dist/infra/connectors/rules/rules-connector-config.d.ts

@@ -20,6 +20,10 @@ export declare const RULES_CONNECTOR_CONFIGS: {
         readonly filePath: "AGENTS.md";
         readonly writeMode: "append";
     };
+    readonly Antigravity: {
+        readonly filePath: ".agent/rules/agent-context.md";
+        readonly writeMode: "overwrite";
+    };
     readonly 'Augment Code': {
         readonly filePath: ".augment/rules/agent-context.md";
         readonly writeMode: "overwrite";

package/dist/infra/connectors/rules/rules-connector-config.js

@@ -6,6 +6,10 @@ export const RULES_CONNECTOR_CONFIGS = {
         filePath: 'AGENTS.md',
         writeMode: 'append',
     },
+    Antigravity: {
+        filePath: '.agent/rules/agent-context.md',
+        writeMode: 'overwrite',
+    },
     'Augment Code': {
         filePath: '.augment/rules/agent-context.md',
         writeMode: 'overwrite',

package/dist/infra/http/openrouter-api-client.d.ts

@@ -0,0 +1,148 @@
+/**
+ * OpenRouter API Client
+ *
+ * Handles API calls to OpenRouter for:
+ * - Fetching available models
+ * - Validating API keys
+ *
+ * Uses the OpenRouter REST API: https://openrouter.ai/api/v1
+ */
+import type { ProviderDefinition } from '../../core/domain/entities/provider-registry.js';
+/**
+ * OpenRouter model from the /models endpoint.
+ * Based on: https://openrouter.ai/docs#models
+ */
+export interface OpenRouterModel {
+    /** Supported modalities */
+    architecture?: {
+        instruct_type?: string;
+        modality: string;
+        tokenizer: string;
+    };
+    /** Context length (max tokens) */
+    context_length: number;
+    /** Description */
+    description?: string;
+    /** Model ID (e.g., 'anthropic/claude-3.5-sonnet') */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Per-request limits */
+    per_request_limits?: {
+        completion_tokens?: string;
+        prompt_tokens?: string;
+    };
+    /** Pricing per token (as string) */
+    pricing: {
+        completion: string;
+        prompt: string;
+    };
+    /** Top provider info */
+    top_provider?: {
+        context_length?: number;
+        is_moderated?: boolean;
+        max_completion_tokens?: number;
+    };
+}
+/**
+ * Normalized model for use in the application.
+ */
+export interface NormalizedModel {
+    /** Context window size */
+    contextLength: number;
+    /** Optional description */
+    description?: string;
+    /** Model ID (e.g., 'anthropic/claude-3.5-sonnet') */
+    id: string;
+    /** Whether this model is free */
+    isFree: boolean;
+    /** Display name */
+    name: string;
+    /** Pricing per million tokens */
+    pricing: {
+        inputPerM: number;
+        outputPerM: number;
+    };
+    /** Provider name extracted from ID (e.g., 'anthropic') */
+    provider: string;
+}
+/**
+ * OpenRouter API client configuration.
+ */
+export interface OpenRouterApiClientConfig {
+    /** Base URL for OpenRouter API */
+    baseUrl?: string;
+    /** Cache TTL in milliseconds (default: 1 hour) */
+    cacheTtlMs?: number;
+    /** HTTP Referer header */
+    httpReferer?: string;
+    /** X-Title header */
+    xTitle?: string;
+}
+/**
+ * OpenRouter API Client.
+ *
+ * Provides methods to interact with the OpenRouter API for fetching models
+ * and validating API keys.
+ *
+ * @example
+ * ```typescript
+ * const client = new OpenRouterApiClient()
+ *
+ * // Validate API key
+ * const isValid = await client.validateApiKey('sk-or-v1-...')
+ *
+ * // Fetch models
+ * const models = await client.fetchModels('sk-or-v1-...')
+ * ```
+ */
+export declare class OpenRouterApiClient {
+    private readonly baseUrl;
+    private readonly cacheTtlMs;
+    private readonly httpReferer?;
+    private modelCache;
+    private readonly xTitle?;
+    constructor(config?: OpenRouterApiClientConfig);
+    /**
+     * Clears the model cache.
+     */
+    clearCache(): void;
+    /**
+     * Fetches available models from OpenRouter.
+     * Results are cached for the configured TTL.
+     *
+     * @param apiKey - The API key to use
+     * @param forceRefresh - If true, bypasses cache
+     * @returns Array of normalized models
+     */
+    fetchModels(apiKey: string, forceRefresh?: boolean): Promise<NormalizedModel[]>;
+    /**
+     * Validates an API key by attempting to fetch models.
+     *
+     * @param apiKey - The API key to validate
+     * @returns Object with isValid flag and optional error message
+     */
+    validateApiKey(apiKey: string): Promise<{
+        error?: string;
+        isValid: boolean;
+    }>;
+    /**
+     * Internal method to fetch models from OpenRouter API.
+     */
+    private fetchModelsInternal;
+    /**
+     * Normalizes an OpenRouter model to our standard format.
+     */
+    private normalizeModel;
+}
+/**
+ * Creates an OpenRouterApiClient configured from a provider definition.
+ *
+ * @param provider - Provider definition from the registry
+ * @returns Configured OpenRouterApiClient
+ */
+export declare function createOpenRouterApiClient(provider: ProviderDefinition): OpenRouterApiClient;
+/**
+ * Gets or creates the singleton OpenRouter API client.
+ */
+export declare function getOpenRouterApiClient(): OpenRouterApiClient;

package/dist/infra/http/openrouter-api-client.js

@@ -0,0 +1,161 @@
+/**
+ * OpenRouter API Client
+ *
+ * Handles API calls to OpenRouter for:
+ * - Fetching available models
+ * - Validating API keys
+ *
+ * Uses the OpenRouter REST API: https://openrouter.ai/api/v1
+ */
+import axios, { isAxiosError } from 'axios';
+const DEFAULT_BASE_URL = 'https://openrouter.ai/api/v1';
+const DEFAULT_CACHE_TTL = 60 * 60 * 1000; // 1 hour
+/**
+ * OpenRouter API Client.
+ *
+ * Provides methods to interact with the OpenRouter API for fetching models
+ * and validating API keys.
+ *
+ * @example
+ * ```typescript
+ * const client = new OpenRouterApiClient()
+ *
+ * // Validate API key
+ * const isValid = await client.validateApiKey('sk-or-v1-...')
+ *
+ * // Fetch models
+ * const models = await client.fetchModels('sk-or-v1-...')
+ * ```
+ */
+export class OpenRouterApiClient {
+    baseUrl;
+    cacheTtlMs;
+    httpReferer;
+    modelCache;
+    xTitle;
+    constructor(config = {}) {
+        this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+        this.cacheTtlMs = config.cacheTtlMs ?? DEFAULT_CACHE_TTL;
+        this.httpReferer = config.httpReferer ?? 'https://byterover.dev';
+        this.xTitle = config.xTitle ?? 'byterover-cli';
+    }
+    /**
+     * Clears the model cache.
+     */
+    clearCache() {
+        this.modelCache = undefined;
+    }
+    /**
+     * Fetches available models from OpenRouter.
+     * Results are cached for the configured TTL.
+     *
+     * @param apiKey - The API key to use
+     * @param forceRefresh - If true, bypasses cache
+     * @returns Array of normalized models
+     */
+    async fetchModels(apiKey, forceRefresh = false) {
+        // Check cache
+        if (!forceRefresh && this.modelCache && Date.now() - this.modelCache.timestamp < this.cacheTtlMs) {
+            return this.modelCache.models;
+        }
+        const models = await this.fetchModelsInternal(apiKey);
+        // Update cache
+        this.modelCache = {
+            models,
+            timestamp: Date.now(),
+        };
+        return models;
+    }
+    /**
+     * Validates an API key by attempting to fetch models.
+     *
+     * @param apiKey - The API key to validate
+     * @returns Object with isValid flag and optional error message
+     */
+    async validateApiKey(apiKey) {
+        try {
+            await this.fetchModelsInternal(apiKey);
+            return { isValid: true };
+        }
+        catch (error) {
+            if (isAxiosError(error)) {
+                if (error.response?.status === 401) {
+                    return { error: 'Invalid API key', isValid: false };
+                }
+                if (error.response?.status === 403) {
+                    return { error: 'API key does not have required permissions', isValid: false };
+                }
+                return { error: `API error: ${error.response?.statusText ?? error.message}`, isValid: false };
+            }
+            return { error: error instanceof Error ? error.message : 'Unknown error', isValid: false };
+        }
+    }
+    /**
+     * Internal method to fetch models from OpenRouter API.
+     */
+    async fetchModelsInternal(apiKey) {
+        const response = await axios.get(`${this.baseUrl}/models`, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'HTTP-Referer': this.httpReferer,
+                'X-Title': this.xTitle,
+            },
+            timeout: 30_000,
+        });
+        return response.data.data.map((model) => this.normalizeModel(model));
+    }
+    /**
+     * Normalizes an OpenRouter model to our standard format.
+     */
+    normalizeModel(model) {
+        // Extract provider from model ID (e.g., 'anthropic' from 'anthropic/claude-3.5-sonnet')
+        const [provider, ...nameParts] = model.id.split('/');
+        const shortName = nameParts.join('/') || model.id;
+        // Parse pricing (convert from string to number)
+        // OpenRouter returns price per token, multiply by 1M to get price per million tokens
+        const inputPricePerToken = Number.parseFloat(model.pricing.prompt) || 0;
+        const outputPricePerToken = Number.parseFloat(model.pricing.completion) || 0;
+        const inputPerM = inputPricePerToken * 1_000_000;
+        const outputPerM = outputPricePerToken * 1_000_000;
+        // Check if free (both prices are 0)
+        const isFree = inputPricePerToken === 0 && outputPricePerToken === 0;
+        return {
+            contextLength: model.context_length,
+            description: model.description,
+            id: model.id,
+            isFree,
+            name: model.name || shortName,
+            pricing: {
+                inputPerM,
+                outputPerM,
+            },
+            provider: provider.charAt(0).toUpperCase() + provider.slice(1), // Capitalize
+        };
+    }
+}
+/**
+ * Creates an OpenRouterApiClient configured from a provider definition.
+ *
+ * @param provider - Provider definition from the registry
+ * @returns Configured OpenRouterApiClient
+ */
+export function createOpenRouterApiClient(provider) {
+    return new OpenRouterApiClient({
+        baseUrl: provider.baseUrl || DEFAULT_BASE_URL,
+        httpReferer: provider.headers['HTTP-Referer'],
+        xTitle: provider.headers['X-Title'],
+    });
+}
+/**
+ * Singleton instance of the OpenRouter API client.
+ */
+let _openRouterApiClient;
+/**
+ * Gets or creates the singleton OpenRouter API client.
+ */
+export function getOpenRouterApiClient() {
+    if (!_openRouterApiClient) {
+        _openRouterApiClient = new OpenRouterApiClient();
+    }
+    return _openRouterApiClient;
+}

package/dist/infra/mcp/tools/brv-curate-tool.d.ts

@@ -1,14 +1,20 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { ITransportClient } from '../../../core/interfaces/transport/index.js';
-export declare const BrvCurateInputSchema: z.ZodObject<{
-    context: z.ZodString;
+export declare const BrvCurateInputSchema: z.ZodEffects<z.ZodObject<{
+    context: z.ZodOptional<z.ZodString>;
     files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-    context: string;
+    context?: string | undefined;
     files?: string[] | undefined;
 }, {
-    context: string;
+    context?: string | undefined;
+    files?: string[] | undefined;
+}>, {
+    context?: string | undefined;
+    files?: string[] | undefined;
+}, {
+    context?: string | undefined;
     files?: string[] | undefined;
 }>;
 /**

package/dist/infra/mcp/tools/brv-curate-tool.js

@@ -1,13 +1,16 @@
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 export const BrvCurateInputSchema = z.object({
-    context: z.string().describe('Knowledge to store: patterns, decisions, errors, or insights about the codebase'),
+    context: z
+        .string()
+        .optional()
+        .describe('Knowledge to store: patterns, decisions, errors, or insights about the codebase. Required unless files are provided.'),
     files: z
         .array(z.string())
         .max(5)
         .optional()
-        .describe('Optional file paths with critical context to include (max 5 files)'),
-});
+        .describe('Optional file paths with critical context to include (max 5 files). Required if context not provided.'),
+}).refine((data) => Boolean(data.context?.trim()) || Boolean(data.files?.length), { message: 'Either context or files must be provided' });
 /**
  * Registers the brv-curate tool with the MCP server.
  *
@@ -41,9 +44,11 @@ export function registerBrvCurateTool(server, getClient, getWorkingDirectory) {
         try {
             const taskId = randomUUID();
             // Create task via transport (same pattern as brv curate command)
+            // Use provided context, or empty string for file-only mode
+            const resolvedContent = context?.trim() ? context : '';
             await client.request('task:create', {
                 clientCwd: getWorkingDirectory(),
-                content: context,
+                content: resolvedContent,
                 taskId,
                 type: 'curate',
                 ...(files?.length ? { files } : {}),

package/dist/infra/mcp/tools/task-result-waiter.js

@@ -9,7 +9,7 @@
  * - task:completed: Task finished successfully
  * - task:error: Task failed with an error
  */
-export async function waitForTaskResult(client, taskId, timeoutMs = 120_000) {
+export async function waitForTaskResult(client, taskId, timeoutMs = 300_000) {
     return new Promise((resolve, reject) => {
         let result = '';
         let completed = false;
@@ -59,6 +59,14 @@ export async function waitForTaskResult(client, taskId, timeoutMs = 120_000) {
                 cleanup();
                 reject(new Error(payload.error.message));
             }
+        }), 
+        // Listen for task cancellation
+        client.on('task:cancelled', (payload) => {
+            if (payload.taskId === taskId && !completed) {
+                completed = true;
+                cleanup();
+                reject(new Error('Task was cancelled'));
+            }
         }));
     });
 }