byterover-cli 1.5.0 → 1.7.0

package/dist/server/infra/team/http-team-service.d.ts

@@ -0,0 +1,21 @@
+import type { ITeamService } from '../../core/interfaces/services/i-team-service.js';
+import { Team } from '../../core/domain/entities/team.js';
+export type TeamServiceConfig = {
+    apiBaseUrl: string;
+    timeout?: number;
+};
+export declare class HttpTeamService implements ITeamService {
+    private readonly config;
+    constructor(config: TeamServiceConfig);
+    getTeams(sessionKey: string, option?: {
+        fetchAll?: boolean;
+        isActive?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        teams: Team[];
+        total: number;
+    }>;
+    private fetchAllTeams;
+    private mapToTeam;
+}

package/dist/server/infra/team/http-team-service.js

@@ -0,0 +1,72 @@
+import { Team } from '../../core/domain/entities/team.js';
+import { getErrorMessage } from '../../utils/error-helpers.js';
+import { AuthenticatedHttpClient } from '../http/authenticated-http-client.js';
+export class HttpTeamService {
+    config;
+    constructor(config) {
+        this.config = {
+            ...config,
+            timeout: 10_000, // Default 10 seconds timeout
+        };
+    }
+    async getTeams(sessionKey, option) {
+        try {
+            const httpClient = new AuthenticatedHttpClient(sessionKey);
+            // Scenario 1: Fetch all automatically via auto-pagination
+            if (option?.fetchAll === true) {
+                return await this.fetchAllTeams(httpClient, option?.isActive);
+            }
+            // Scenario 2 & 3: Single request (with or without pagination params)
+            const params = new URLSearchParams();
+            if (option?.limit !== undefined) {
+                params.append('limit', option.limit.toString());
+            }
+            if (option?.offset !== undefined) {
+                params.append('offset', option.offset.toString());
+            }
+            if (option?.isActive !== undefined) {
+                params.append('is_active', option.isActive.toString());
+            }
+            const url = `${this.config.apiBaseUrl}/teams${params.toString() ? `?${params.toString()}` : ''}`;
+            const response = await httpClient.get(url, {
+                timeout: this.config.timeout,
+            });
+            return {
+                teams: response.data.teams.map((teamData) => this.mapToTeam(teamData)),
+                total: response.data.total,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch teams: ${getErrorMessage(error)}`);
+        }
+    }
+    async fetchAllTeams(httpClient, isActive) {
+        const pageSize = 100; // Larger pages for fewer requests
+        let offset = 0;
+        let allTeams = [];
+        let total = 0;
+        while (true) {
+            const params = new URLSearchParams({
+                limit: pageSize.toString(),
+                offset: offset.toString(),
+            });
+            if (isActive !== undefined) {
+                params.append('is_active', isActive.toString());
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const response = await httpClient.get(`${this.config.apiBaseUrl}/teams?${params.toString()}`, { timeout: this.config.timeout });
+            const pageTeams = response.data.teams.map((teamData) => this.mapToTeam(teamData));
+            allTeams = [...allTeams, ...pageTeams];
+            total = response.data.total;
+            // Stop if we've fetched everything or got empty page
+            if (allTeams.length >= total || pageTeams.length === 0) {
+                break;
+            }
+            offset += pageSize;
+        }
+        return { teams: allTeams, total };
+    }
+    mapToTeam(teamData) {
+        return Team.fromJson(teamData);
+    }
+}

package/dist/server/infra/template/fs-template-loader.d.ts

@@ -0,0 +1,33 @@
+import { type IFileService } from '../../core/interfaces/services/i-file-service.js';
+import { type ITemplateLoader } from '../../core/interfaces/services/i-template-loader.js';
+/**
+ * File system-based template loader.
+ * Loads templates from src/templates/ directory and performs variable substitution.
+ */
+export declare class FsTemplateLoader implements ITemplateLoader {
+    private readonly fileService;
+    private readonly templatesDir;
+    constructor(fileService: IFileService);
+    /**
+     * Loads a section template from the sections/ directory.
+     * @param sectionName - Name of the section (e.g., 'workflow', 'command-reference')
+     * @returns Promise resolving to section content
+     * @throws Error if section file cannot be read
+     */
+    loadSection(sectionName: string): Promise<string>;
+    /**
+     * Loads a template file from the templates directory.
+     * @param templatePath - Relative path to template (e.g., 'base.md', 'sections/workflow.md')
+     * @returns Promise resolving to template content
+     * @throws Error if template file cannot be read
+     */
+    loadTemplate(templatePath: string): Promise<string>;
+    /**
+     * Substitutes variables in a template string.
+     * Replaces {{variable_name}} with corresponding values from context.
+     * @param template - Template string with {{variable}} placeholders
+     * @param context - Object mapping variable names to values
+     * @returns Template with variables replaced
+     */
+    substituteVariables(template: string, context: Record<string, string>): string;
+}

package/dist/server/infra/terminal/headless-terminal.d.ts

@@ -0,0 +1,91 @@
+import type { ConfirmOptions, FileSelectorItem, FileSelectorOptions, InputOptions, ITerminal, SearchOptions, SelectOptions } from '../../core/interfaces/services/i-terminal.js';
+/**
+ * Output format for headless terminal.
+ * - 'text': Human-readable text output
+ * - 'json': NDJSON (newline-delimited JSON) for machine parsing
+ */
+export type HeadlessOutputFormat = 'json' | 'text';
+/**
+ * JSON message types for structured output.
+ */
+export type HeadlessMessageType = 'action_start' | 'action_stop' | 'error' | 'log' | 'result' | 'warning';
+/**
+ * Structured JSON output message.
+ */
+export interface HeadlessJsonMessage {
+    actionId?: string;
+    id: string;
+    message: string;
+    timestamp: string;
+    type: HeadlessMessageType;
+}
+/**
+ * Options for creating a HeadlessTerminal.
+ */
+export interface HeadlessTerminalOptions {
+    /**
+     * Stream for errors (defaults to process.stderr).
+     */
+    errorStream?: NodeJS.WritableStream;
+    /**
+     * If true, throw HeadlessPromptError when a prompt cannot be answered.
+     * If false, use sensible defaults (first choice, false for confirm, etc.)
+     * @default true
+     */
+    failOnPrompt?: boolean;
+    /**
+     * Output format: 'text' for human readable, 'json' for machine parsing.
+     * @default 'text'
+     */
+    outputFormat?: HeadlessOutputFormat;
+    /**
+     * Stream for output (defaults to process.stdout).
+     */
+    outputStream?: NodeJS.WritableStream;
+    /**
+     * Default values for prompts, keyed by prompt message or prompt type.
+     * Used to answer prompts automatically in headless mode.
+     */
+    promptDefaults?: Record<string, unknown>;
+}
+/**
+ * Terminal implementation for headless/non-interactive mode.
+ * Outputs to stdout/stderr and handles prompts via defaults or fails gracefully.
+ */
+export declare class HeadlessTerminal implements ITerminal {
+    private currentActionId;
+    private readonly errorOutput;
+    private readonly failOnPrompt;
+    private readonly output;
+    private readonly outputFormat;
+    private readonly promptDefaults;
+    constructor(options?: HeadlessTerminalOptions);
+    actionStart(message: string): void;
+    actionStop(message?: string): void;
+    confirm(options: ConfirmOptions): Promise<boolean>;
+    error(message: string): void;
+    fileSelector(options: FileSelectorOptions): Promise<FileSelectorItem | null>;
+    input(options: InputOptions): Promise<string>;
+    log(message?: string): void;
+    search<T>(options: SearchOptions<T>): Promise<T>;
+    select<T>(options: SelectOptions<T>): Promise<T>;
+    warn(message: string): void;
+    /**
+     * Write final response with success/error status.
+     */
+    writeFinalResponse(response: {
+        command: string;
+        data?: unknown;
+        error?: {
+            code: string;
+            message: string;
+        };
+        success: boolean;
+    }): void;
+    /**
+     * Write final result in JSON format (convenience method for commands).
+     */
+    writeResult(data: Record<string, unknown>): void;
+    private getDefault;
+    private writeJson;
+}

package/dist/server/infra/terminal/headless-terminal.js

@@ -0,0 +1,211 @@
+import { randomUUID } from 'node:crypto';
+import { HeadlessPromptError } from '../../core/domain/errors/headless-prompt-error.js';
+/**
+ * Terminal implementation for headless/non-interactive mode.
+ * Outputs to stdout/stderr and handles prompts via defaults or fails gracefully.
+ */
+export class HeadlessTerminal {
+    currentActionId = null;
+    errorOutput;
+    failOnPrompt;
+    output;
+    outputFormat;
+    promptDefaults;
+    constructor(options = {}) {
+        this.outputFormat = options.outputFormat ?? 'text';
+        this.promptDefaults = options.promptDefaults ?? {};
+        this.failOnPrompt = options.failOnPrompt ?? true;
+        this.output = options.outputStream ?? process.stdout;
+        this.errorOutput = options.errorStream ?? process.stderr;
+    }
+    // ==================== Output Methods ====================
+    actionStart(message) {
+        this.currentActionId = randomUUID();
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                actionId: this.currentActionId,
+                id: randomUUID(),
+                message,
+                timestamp: new Date().toISOString(),
+                type: 'action_start',
+            });
+        }
+        // In text mode, suppress action start for cleaner output
+    }
+    actionStop(message) {
+        if (this.outputFormat === 'json' && this.currentActionId) {
+            this.writeJson({
+                actionId: this.currentActionId,
+                id: randomUUID(),
+                message: message ?? '',
+                timestamp: new Date().toISOString(),
+                type: 'action_stop',
+            });
+        }
+        this.currentActionId = null;
+    }
+    async confirm(options) {
+        // Check for explicit default in promptDefaults
+        const defaultValue = this.getDefault('confirm', options.message);
+        if (defaultValue !== undefined) {
+            return Boolean(defaultValue);
+        }
+        // Use options.default if provided
+        if (options.default !== undefined) {
+            return options.default;
+        }
+        // Fail or return false
+        if (this.failOnPrompt) {
+            throw new HeadlessPromptError('confirm', options.message);
+        }
+        return false;
+    }
+    error(message) {
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                id: randomUUID(),
+                message,
+                timestamp: new Date().toISOString(),
+                type: 'error',
+            });
+        }
+        else {
+            this.errorOutput.write(`Error: ${message}\n`);
+        }
+    }
+    async fileSelector(options) {
+        // Check for explicit default in promptDefaults
+        const defaultValue = this.getDefault('file_selector', options.message);
+        if (defaultValue !== undefined && typeof defaultValue === 'string') {
+            return {
+                isDirectory: options.type === 'directory',
+                name: defaultValue.split('/').pop() ?? defaultValue,
+                path: defaultValue,
+            };
+        }
+        // Allow cancel if specified
+        if (options.allowCancel) {
+            return null;
+        }
+        // Fail
+        if (this.failOnPrompt) {
+            throw new HeadlessPromptError('file_selector', options.message);
+        }
+        return null;
+    }
+    // ==================== Input Methods ====================
+    async input(options) {
+        // Check for explicit default in promptDefaults
+        const defaultValue = this.getDefault('input', options.message);
+        if (defaultValue !== undefined) {
+            const value = String(defaultValue);
+            // Validate if validator is provided
+            if (options.validate) {
+                const validationResult = options.validate(value);
+                if (validationResult !== true) {
+                    const errorMsg = typeof validationResult === 'string' ? validationResult : 'Validation failed';
+                    throw new HeadlessPromptError('input', `${options.message} (validation error: ${errorMsg})`);
+                }
+            }
+            return value;
+        }
+        // Fail
+        if (this.failOnPrompt) {
+            throw new HeadlessPromptError('input', options.message);
+        }
+        return '';
+    }
+    log(message) {
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                id: randomUUID(),
+                message: message ?? '',
+                timestamp: new Date().toISOString(),
+                type: 'log',
+            });
+        }
+        else {
+            this.output.write((message ?? '') + '\n');
+        }
+    }
+    async search(options) {
+        // Search prompts require user interaction - always fail in headless mode
+        // unless a default is explicitly provided
+        const defaultValue = this.getDefault('search', options.message);
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        throw new HeadlessPromptError('search', options.message);
+    }
+    async select(options) {
+        // Check for explicit default in promptDefaults (by value or name)
+        const defaultValue = this.getDefault('select', options.message);
+        if (defaultValue !== undefined) {
+            const choice = options.choices.find((c) => c.value === defaultValue || c.name === defaultValue);
+            if (choice) {
+                return choice.value;
+            }
+        }
+        // Fail or return first choice
+        if (this.failOnPrompt) {
+            throw new HeadlessPromptError('select', options.message, options.choices.map((c) => c.name));
+        }
+        // Return first choice as fallback
+        if (options.choices.length > 0) {
+            return options.choices[0].value;
+        }
+        throw new HeadlessPromptError('select', options.message, []);
+    }
+    warn(message) {
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                id: randomUUID(),
+                message,
+                timestamp: new Date().toISOString(),
+                type: 'warning',
+            });
+        }
+        else {
+            this.errorOutput.write(`Warning: ${message}\n`);
+        }
+    }
+    // ==================== Helper Methods ====================
+    /**
+     * Write final response with success/error status.
+     */
+    writeFinalResponse(response) {
+        if (this.outputFormat === 'json') {
+            this.output.write(JSON.stringify({
+                ...response,
+                timestamp: new Date().toISOString(),
+            }) + '\n');
+        }
+    }
+    /**
+     * Write final result in JSON format (convenience method for commands).
+     */
+    writeResult(data) {
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                id: randomUUID(),
+                message: JSON.stringify(data),
+                timestamp: new Date().toISOString(),
+                type: 'result',
+            });
+        }
+    }
+    getDefault(promptType, promptMessage) {
+        // First check by exact message
+        if (this.promptDefaults[promptMessage] !== undefined) {
+            return this.promptDefaults[promptMessage];
+        }
+        // Then check by prompt type
+        if (this.promptDefaults[promptType] !== undefined) {
+            return this.promptDefaults[promptType];
+        }
+        return undefined;
+    }
+    writeJson(data) {
+        this.output.write(JSON.stringify(data) + '\n');
+    }
+}

package/dist/server/infra/terminal/oclif-terminal.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+import type { ConfirmOptions, FileSelectorItem, FileSelectorOptions, InputOptions, ITerminal, SearchOptions, SelectOptions } from '../../core/interfaces/services/i-terminal.js';
+/**
+ * Terminal implementation that wraps oclif Command methods and @inquirer/prompts.
+ */
+export declare class OclifTerminal implements ITerminal {
+    private readonly command;
+    constructor(command: Command);
+    actionStart(message: string): void;
+    actionStop(message?: string): void;
+    confirm({ default: defaultValue, message }: ConfirmOptions): Promise<boolean>;
+    error(message: string): void;
+    fileSelector(options: FileSelectorOptions): Promise<FileSelectorItem | null>;
+    input({ message, validate }: InputOptions): Promise<string>;
+    log(message?: string): void;
+    search<T>({ message, source }: SearchOptions<T>): Promise<T>;
+    select<T>({ choices, message }: SelectOptions<T>): Promise<T>;
+    warn(message: string): void;
+}

package/dist/server/infra/terminal/repl-terminal.d.ts

@@ -0,0 +1,31 @@
+import type { PromptRequest, StreamingMessage } from '../../../tui/types.js';
+import type { ConfirmOptions, FileSelectorItem, FileSelectorOptions, InputOptions, ITerminal, SearchOptions, SelectOptions } from '../../core/interfaces/services/i-terminal.js';
+/**
+ * Callbacks for ReplTerminal operations.
+ * These bridge the terminal to the TUI streaming system.
+ */
+export interface ReplTerminalCallbacks {
+    /** Callback for streaming output messages */
+    onMessage: (msg: StreamingMessage) => void;
+    /** Callback for interactive prompts */
+    onPrompt: (prompt: PromptRequest) => void;
+}
+/**
+ * REPL-compatible ITerminal implementation.
+ * Uses callbacks to integrate with TUI streaming and prompt system.
+ */
+export declare class ReplTerminal implements ITerminal {
+    private readonly callbacks;
+    private currentActionId;
+    constructor(callbacks: ReplTerminalCallbacks);
+    actionStart(message: string): void;
+    actionStop(message?: string): void;
+    confirm(options: ConfirmOptions): Promise<boolean>;
+    error(message: string): void;
+    fileSelector(options: FileSelectorOptions): Promise<FileSelectorItem | null>;
+    input(options: InputOptions): Promise<string>;
+    log(message?: string): void;
+    search<T>(options: SearchOptions<T>): Promise<T>;
+    select<T>(options: SelectOptions<T>): Promise<T>;
+    warn(message: string): void;
+}

package/dist/server/infra/tracking/mixpanel-tracking-service.d.ts

@@ -0,0 +1,24 @@
+import { Mixpanel } from 'mixpanel';
+import { EventName, PropertyDict } from '../../core/domain/entities/event.js';
+import { ITokenStore } from '../../core/interfaces/auth/i-token-store.js';
+import { ITrackingService } from '../../core/interfaces/services/i-tracking-service.js';
+import { IGlobalConfigStore } from '../../core/interfaces/storage/i-global-config-store.js';
+/**
+ * Parameters for creating a MixpanelTrackingService instance.
+ */
+export interface MixpanelTrackingServiceParams {
+    readonly globalConfigStore: IGlobalConfigStore;
+    readonly mixpanel?: Mixpanel;
+    readonly tokenStore: ITokenStore;
+}
+/**
+ * Tracking service implementation using the Mixpanel library.
+ */
+export declare class MixpanelTrackingService implements ITrackingService {
+    private readonly globalConfigStore;
+    private readonly mp;
+    private readonly tokenStore;
+    constructor(params: MixpanelTrackingServiceParams);
+    track(eventName: EventName, properties?: PropertyDict): Promise<void>;
+    private getIdentificationProperties;
+}

package/dist/server/infra/transport/index.d.ts

@@ -0,0 +1,3 @@
+export * from './port-utils.js';
+export * from './socket-io-transport-server.js';
+export { createTransportServer } from './transport-factory.js';

package/dist/server/infra/transport/index.js

@@ -0,0 +1,6 @@
+// Local server implementation only
+// For client types (ITransportClient, etc.), use @campfirein/brv-transport-client
+// For server types (ITransportServer, etc.), use core/interfaces/transport/
+export * from './port-utils.js';
+export * from './socket-io-transport-server.js';
+export { createTransportServer } from './transport-factory.js';

package/dist/server/infra/transport/transport-factory.d.ts

@@ -0,0 +1,17 @@
+import type { TransportServerConfig } from '../../core/domain/transport/types.js';
+import type { ITransportServer } from '../../core/interfaces/transport/i-transport-server.js';
+/**
+ * Creates a transport server instance.
+ *
+ * @param config - Optional server configuration, defaults to constants
+ * @returns Transport server implementation
+ *
+ * @example
+ * // Use defaults
+ * const server = createTransportServer();
+ *
+ * @example
+ * // Custom config
+ * const server = createTransportServer({ pingIntervalMs: 2000 });
+ */
+export declare function createTransportServer(config?: TransportServerConfig): ITransportServer;

package/dist/server/infra/transport/transport-factory.js

@@ -0,0 +1,31 @@
+import { TRANSPORT_PING_INTERVAL_MS, TRANSPORT_PING_TIMEOUT_MS } from '../../constants.js';
+import { SocketIOTransportServer } from './socket-io-transport-server.js';
+/**
+ * Default server configuration using constants.
+ */
+const DEFAULT_SERVER_CONFIG = {
+    corsOrigin: '*',
+    pingIntervalMs: TRANSPORT_PING_INTERVAL_MS,
+    pingTimeoutMs: TRANSPORT_PING_TIMEOUT_MS,
+};
+/**
+ * Creates a transport server instance.
+ *
+ * @param config - Optional server configuration, defaults to constants
+ * @returns Transport server implementation
+ *
+ * @example
+ * // Use defaults
+ * const server = createTransportServer();
+ *
+ * @example
+ * // Custom config
+ * const server = createTransportServer({ pingIntervalMs: 2000 });
+ */
+export function createTransportServer(config) {
+    const mergedConfig = { ...DEFAULT_SERVER_CONFIG, ...config };
+    return new SocketIOTransportServer(mergedConfig);
+}
+// NOTE: For transport client, use connectToTransport() from @campfirein/brv-transport-client
+// Do NOT use new TransportClient() directly - it requires manual discovery and connection
+// Example: const {client, projectRoot} = await connectToTransport()

package/dist/server/infra/usecase/connectors-use-case.d.ts

@@ -0,0 +1,63 @@
+import type { IConnectorManager } from '../../core/interfaces/connectors/i-connector-manager.js';
+import type { ITerminal } from '../../core/interfaces/services/i-terminal.js';
+import type { ITrackingService } from '../../core/interfaces/services/i-tracking-service.js';
+import { IConnectorsUseCase } from '../../core/interfaces/usecase/i-connectors-use-case.js';
+/**
+ * Options for constructing ConnectorsUseCase.
+ */
+export interface ConnectorsUseCaseOptions {
+    connectorManager: IConnectorManager;
+    terminal: ITerminal;
+    trackingService: ITrackingService;
+}
+/**
+ * Use case for managing connectors.
+ * Shows list of connected agents and allows managing or adding new connections.
+ */
+export declare class ConnectorsUseCase implements IConnectorsUseCase {
+    private readonly connectorManager;
+    private readonly terminal;
+    private readonly trackingService;
+    constructor(options: ConnectorsUseCaseOptions);
+    run(): Promise<void>;
+    /**
+     * Display manual setup instructions for MCP configuration.
+     */
+    private displayManualInstructions;
+    /**
+     * Gets a description for a connector type.
+     */
+    private getConnectorDescription;
+    /**
+     * Gets a human-readable label for a connector type.
+     */
+    private getConnectorLabel;
+    /**
+     * Handles the case when connectors are already installed.
+     */
+    private handleExistingConnectors;
+    /**
+     * Handles the case when no connectors are installed.
+     */
+    private handleNoConnectorsInstalled;
+    /**
+     * Installs the selected connector and displays result.
+     */
+    private installConnector;
+    /**
+     * Prompts user to select from connected agents or add new.
+     */
+    private promptForAgentToManage;
+    /**
+     * Prompts the user to select a connector type.
+     */
+    private promptForConnectorType;
+    /**
+     * Prompts user to select a new agent (excludes already connected agents).
+     */
+    private promptForNewAgentSelection;
+    /**
+     * Prompts the user to confirm switching connectors.
+     */
+    private promptForSwitchConfirmation;
+}