byterover-cli 1.6.0 → 1.7.1

package/dist/server/utils/file-content-reader.js

@@ -0,0 +1,180 @@
+import fs from 'node:fs/promises';
+import { createDocumentParserService } from '../../agent/infra/document-parser/index.js';
+import { isBinaryFile, isImageFile, isOfficeFile, isPdfFile } from '../../agent/infra/file-system/binary-utils.js';
+import { formatPdfContent, PdfExtractor } from '../../agent/infra/file-system/pdf-extractor.js';
+const DEFAULT_MAX_CONTENT_LENGTH = 40_000;
+const DEFAULT_MAX_LINES_PER_FILE = 2000;
+const DEFAULT_MAX_PDF_PAGES = 50;
+const SAMPLE_BUFFER_SIZE = 4096;
+/**
+ * Service for reading file contents with support for various file types.
+ *
+ * Supports:
+ * - Text/code files: Read directly with truncation
+ * - Office documents (.docx, .pptx, .xlsx, etc.): Parse using DocumentParserService
+ * - PDFs: Extract text using PdfExtractor
+ * - Images/Binaries: Skip with appropriate error message
+ */
+export class FileContentReader {
+    documentParser;
+    constructor(documentParser) {
+        this.documentParser = documentParser ?? createDocumentParserService();
+    }
+    /**
+     * Read content from a single file based on its type.
+     *
+     * @param filePath - Absolute path to the file
+     * @param config - Optional configuration for reading
+     * @returns FileReadResult with content or error
+     */
+    async readFile(filePath, config = {}) {
+        const maxLength = config.maxContentLength ?? DEFAULT_MAX_CONTENT_LENGTH;
+        const maxLines = config.maxLinesPerFile ?? DEFAULT_MAX_LINES_PER_FILE;
+        const maxPdfPages = config.maxPdfPages ?? DEFAULT_MAX_PDF_PAGES;
+        try {
+            // Read initial buffer for type detection
+            const buffer = await fs.readFile(filePath);
+            const sampleBuffer = buffer.subarray(0, SAMPLE_BUFFER_SIZE);
+            // Handle by file type (order matters - check specific types first)
+            // 1. Images - skip with warning
+            if (isImageFile(filePath)) {
+                return {
+                    content: '',
+                    error: 'Image files are not supported for text extraction',
+                    filePath,
+                    fileType: 'image',
+                    success: false,
+                };
+            }
+            // 2. PDFs - extract text
+            if (isPdfFile(filePath, sampleBuffer)) {
+                return this.readPdfFile(filePath, buffer, maxPdfPages, maxLength);
+            }
+            // 3. Office documents - parse with DocumentParserService
+            if (isOfficeFile(filePath)) {
+                return this.readOfficeFile(filePath, buffer, maxLength);
+            }
+            // 4. Other binary files - skip with warning
+            if (isBinaryFile(filePath, sampleBuffer)) {
+                return {
+                    content: '',
+                    error: 'Binary files are not supported for text extraction',
+                    filePath,
+                    fileType: 'binary',
+                    success: false,
+                };
+            }
+            // 5. Text files - read directly
+            return this.readTextFile(filePath, buffer, maxLines, maxLength);
+        }
+        catch (error) {
+            return {
+                content: '',
+                error: error instanceof Error ? error.message : String(error),
+                filePath,
+                fileType: 'text',
+                success: false,
+            };
+        }
+    }
+    /**
+     * Read content from multiple files in parallel.
+     *
+     * @param filePaths - Array of absolute file paths
+     * @param config - Optional configuration for reading
+     * @returns Array of FileReadResult for each file
+     */
+    async readFiles(filePaths, config = {}) {
+        return Promise.all(filePaths.map((filePath) => this.readFile(filePath, config)));
+    }
+    /**
+     * Read an Office document using DocumentParserService.
+     */
+    async readOfficeFile(filePath, buffer, maxLength) {
+        try {
+            const result = await this.documentParser.parse(filePath, buffer, { maxLength });
+            return {
+                content: result.content,
+                filePath,
+                fileType: 'office',
+                metadata: {
+                    pageCount: result.metadata?.pageCount,
+                    truncated: result.content.endsWith('[Content truncated...]'),
+                },
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                content: '',
+                error: error instanceof Error ? error.message : String(error),
+                filePath,
+                fileType: 'office',
+                success: false,
+            };
+        }
+    }
+    /**
+     * Read a PDF file using PdfExtractor.
+     */
+    async readPdfFile(filePath, buffer, maxPages, maxLength) {
+        try {
+            const result = await PdfExtractor.extractText(buffer, filePath, { limit: maxPages });
+            const content = formatPdfContent(result.pages, result.metadata, result.hasMore, maxPages + 1);
+            // Truncate if too long
+            const truncatedByLength = content.length > maxLength;
+            const finalContent = truncatedByLength ? content.slice(0, maxLength) + '\n[Content truncated...]' : content;
+            return {
+                content: finalContent,
+                filePath,
+                fileType: 'pdf',
+                metadata: {
+                    pageCount: result.metadata.pageCount,
+                    truncated: result.hasMore || truncatedByLength,
+                },
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                content: '',
+                error: error instanceof Error ? error.message : String(error),
+                filePath,
+                fileType: 'pdf',
+                success: false,
+            };
+        }
+    }
+    /**
+     * Read a text file with line and length truncation.
+     */
+    readTextFile(filePath, buffer, maxLines, maxLength) {
+        const rawContent = buffer.toString('utf8');
+        const lines = rawContent.split('\n');
+        const totalLines = lines.length;
+        // Truncate by lines if needed
+        const truncatedByLines = totalLines > maxLines;
+        let content = truncatedByLines ? lines.slice(0, maxLines).join('\n') + '\n[...truncated]' : rawContent;
+        // Truncate by length if needed
+        const truncatedByLength = content.length > maxLength;
+        if (truncatedByLength) {
+            content = content.slice(0, maxLength) + '\n[Content truncated...]';
+        }
+        return {
+            content,
+            filePath,
+            fileType: 'text',
+            metadata: {
+                lineCount: totalLines,
+                truncated: truncatedByLines || truncatedByLength,
+            },
+            success: true,
+        };
+    }
+}
+/**
+ * Factory function to create a FileContentReader instance.
+ */
+export function createFileContentReader(documentParser) {
+    return new FileContentReader(documentParser);
+}

package/dist/server/utils/file-validator.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { isBinaryFile, isImageFile, isPdfFile } from '../../agent/infra/file-system/binary-utils.js';
+/**
+ * Normalize file path - handles relative, absolute, tilde, symlinks
+ * Returns absolute canonical path
+ * @param filePath - The file path to normalize
+ * @returns Normalized absolute path
+ */
+function normalizeFilePath(filePath, baseDir) {
+    // Expand tilde to home directory
+    const expanded = filePath.startsWith('~') ? filePath.replace(/^~/, os.homedir()) : filePath;
+    // Resolve to absolute path using baseDir for relative paths
+    const absolute = path.isAbsolute(expanded) ? expanded : path.resolve(baseDir ?? process.cwd(), expanded);
+    // Resolve symlinks (only if file exists)
+    try {
+        return fs.realpathSync(absolute);
+    }
+    catch {
+        // File doesn't exist or cannot resolve, return resolved path
+        return absolute;
+    }
+}
+/**
+ * Validate file for --files flag in brv curate command
+ * Checks:
+ * 1. File exists
+ * 2. File is within project directory (where .brv exists)
+ * 3. File is supported by read_file tool (text, images, or PDFs)
+ *
+ * @param filePath - The file path to validate (can be relative, absolute, or tilde)
+ * @param projectRoot - The project root directory (current working directory)
+ * @returns Validation result with normalized path or error message
+ */
+export function validateFileForCurate(filePath, projectRoot) {
+    // Normalize projectRoot first to ensure consistent behavior
+    // This handles cases where projectRoot might be relative
+    const normalizedProjectRoot = normalizeFilePath(projectRoot);
+    // Normalize file path using normalizedProjectRoot as base for relative paths
+    const normalized = normalizeFilePath(filePath, normalizedProjectRoot);
+    // Check existence
+    if (!fs.existsSync(normalized)) {
+        return { error: `File does not exist: ${filePath}`, valid: false };
+    }
+    // Check if it's a file (not a directory)
+    const stats = fs.statSync(normalized);
+    if (!stats.isFile()) {
+        return { error: `Path is not a file: ${filePath}`, valid: false };
+    }
+    // Check within project (both paths are already normalized)
+    if (!normalized.startsWith(normalizedProjectRoot + path.sep) && normalized !== normalizedProjectRoot) {
+        return { error: `File is outside project directory: ${filePath}`, valid: false };
+    }
+    // Read sample buffer for file type detection
+    let buffer;
+    let bytesRead;
+    try {
+        buffer = Buffer.alloc(4096);
+        const fd = fs.openSync(normalized, 'r');
+        bytesRead = fs.readSync(fd, buffer, 0, 4096, 0);
+        fs.closeSync(fd);
+    }
+    catch {
+        return { error: `Cannot read file: ${filePath}`, valid: false };
+    }
+    const sampleBuffer = buffer.subarray(0, bytesRead);
+    // Check file type using binary-utils (same logic as read_file tool)
+    // Allow image files - read_file returns them as base64 attachments
+    if (isImageFile(normalized)) {
+        return { normalizedPath: normalized, valid: true };
+    }
+    // Allow PDF files with valid magic bytes - read_file extracts text or returns base64
+    // Use buffer validation to reject fake PDFs (e.g., binary files renamed to .pdf)
+    if (isPdfFile(normalized, sampleBuffer)) {
+        return { normalizedPath: normalized, valid: true };
+    }
+    // Check if it's a binary file (using same logic as read_file tool)
+    if (isBinaryFile(normalized, sampleBuffer)) {
+        return { error: `File type not supported: ${filePath}`, valid: false };
+    }
+    // It's a text file - supported
+    return { normalizedPath: normalized, valid: true };
+}

package/dist/server/utils/type-guards.d.ts

@@ -0,0 +1,16 @@
+import { type TaskType } from '../core/domain/transport/schemas.js';
+/**
+ * Type guard to check if value is a non-null object (Record).
+ * Useful for safely narrowing unknown values before accessing properties.
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard for valid task types.
+ * Uses TaskTypeSchema as the single source of truth.
+ *
+ * @example
+ * if (isValidTaskType(data.type)) {
+ *   // data.type is narrowed to TaskType
+ * }
+ */
+export declare function isValidTaskType(value: string): value is TaskType;

package/dist/tui/app.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * TUI App - Main Layout
  *
@@ -7,19 +7,22 @@ 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';
-import { CommandView, LoginView, LogsView } from './views/index.js';
+import { useEffect } from 'react';
+import { Footer, Header } from './components/index.js';
+import { useAuth, useServices } from './contexts/index.js';
+import { useTerminalBreakpoint, useUIHeights } from './hooks/index.js';
+import { LoginView } from './views/index.js';
+import { MainView } from './views/main-view.js';
 export const App = () => {
     const { columns: terminalWidth, rows: terminalHeight } = useTerminalBreakpoint();
-    const { appBottomPadding, footer, header, tab } = useUIHeights();
+    const { appBottomPadding, footer, header } = useUIHeights();
+    const { connectorManager } = useServices();
     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: [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, {}) }))] }));
+    const contentHeight = Math.max(1, terminalHeight - header - footer);
+    useEffect(() => {
+        // Clean up orphaned connectors from agents that no longer support them.
+        // Runs in the background to avoid blocking REPL startup.
+        connectorManager.migrateOrphanedConnectors().catch(console.error);
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", height: terminalHeight, paddingBottom: appBottomPadding, width: terminalWidth, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Header, { compact: isAuthorized }) }), isAuthorized ? (_jsxs(_Fragment, { children: [_jsx(MainView, { availableHeight: contentHeight }), _jsx(Box, { flexShrink: 0, children: _jsx(Footer, {}) })] })) : (_jsx(Box, { flexGrow: 1, paddingX: 1, children: _jsx(LoginView, {}) }))] }));
 };

package/dist/tui/commands/arg-parser.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Shared argument parser for REPL commands
+ *
+ * Combines shell-like string splitting with oclif's Parser for consistent
+ * flag and argument handling across REPL commands.
+ */
+import { type Interfaces } from '@oclif/core';
+import { CommandFlag } from '../types.js';
+export { Args, Flags } from '@oclif/core';
+type ArgInput = Interfaces.ArgInput;
+type FlagInput = Interfaces.FlagInput;
+/**
+ * Convert oclif flag definitions to CommandFlag[] for SlashCommand.flags
+ *
+ * This allows defining flags once using oclif format and auto-generating
+ * the CommandFlag[] needed for help display.
+ *
+ * @example
+ * const flags = {
+ *   apiKey: Flags.string({char: 'k', description: 'API key'}),
+ *   verbose: Flags.boolean({char: 'v', description: 'Verbose output'}),
+ * }
+ *
+ * export const myCommand: SlashCommand = {
+ *   action(context, args) {
+ *     const parsed = await parseReplArgs(args, {flags})
+ *   },
+ *   flags: toCommandFlags(flags),
+ * }
+ */
+export declare function toCommandFlags(flags: FlagInput): CommandFlag[];
+/**
+ * Result from splitArgs with file and folder references
+ */
+export interface SplitArgsResult {
+    /** Regular arguments */
+    args: string[];
+    /** File references (tokens starting with @ that point to files) */
+    files: string[];
+    /** Folder references (tokens starting with @ that point to directories) */
+    folders: string[];
+}
+/**
+ * Split a string into args array, respecting quoted strings
+ * Handles both single and double quotes, and extracts @file and @folder references
+ *
+ * @example
+ * splitArgs('"hello world" --force') // { args: ['hello world', '--force'], files: [], folders: [] }
+ * splitArgs("'hello world' -f") // { args: ['hello world', '-f'], files: [], folders: [] }
+ * splitArgs('query @src/file.ts') // { args: ['query'], files: ['src/file.ts'], folders: [] }
+ * splitArgs('"context" @src/') // { args: ['context'], files: [], folders: ['src/'] }
+ * splitArgs('text @src/ @README.md') // { args: ['text'], files: ['README.md'], folders: ['src/'] }
+ */
+export declare function splitArgs(input: string): SplitArgsResult;
+/**
+ * Parse result from parseReplArgs
+ */
+export interface ParsedReplArgs<TFlags extends FlagInput, TArgs extends ArgInput> {
+    /** Parsed arguments */
+    args: {
+        [K in keyof TArgs]: TArgs[K] extends {
+            required: true;
+        } ? string : string | undefined;
+    };
+    /** Remaining unparsed arguments (when strict: false) */
+    argv: string[];
+    /** File references extracted from @filepath tokens (non-directory paths) */
+    files: string[];
+    /** Parsed flags */
+    flags: {
+        [K in keyof TFlags]: TFlags[K] extends {
+            type: 'boolean';
+        } ? boolean : string | undefined;
+    };
+    /** Folder references extracted from @folderpath tokens (directory paths) */
+    folders: string[];
+}
+/**
+ * Parse REPL command arguments using oclif's Parser
+ *
+ * @param input - Raw input string from REPL (e.g., '"hello world" --force @src/file.ts')
+ * @param options - Parser options
+ * @param options.args - Argument definitions using Args from @oclif/core
+ * @param options.flags - Flag definitions using Flags from @oclif/core
+ * @param options.strict - Whether to error on unknown flags (default: false)
+ * @returns Parsed flags, args, remaining argv, and file references
+ *
+ * @example
+ * const result = await parseReplArgs('query text --verbose @src/auth.ts', {
+ *   args: { query: Args.string({ required: true }) },
+ *   flags: { verbose: Flags.boolean({ char: 'v' }) },
+ * })
+ * // result.args.query === 'query'
+ * // result.flags.verbose === true
+ * // result.argv === ['query', 'text']
+ * // result.files === ['src/auth.ts']
+ */
+export declare function parseReplArgs<TFlags extends FlagInput, TArgs extends ArgInput>(input: string, options: {
+    args?: TArgs;
+    flags?: TFlags;
+    strict?: boolean;
+}): Promise<ParsedReplArgs<TFlags, TArgs>>;

package/dist/tui/commands/arg-parser.js

@@ -0,0 +1,186 @@
+/**
+ * Shared argument parser for REPL commands
+ *
+ * Combines shell-like string splitting with oclif's Parser for consistent
+ * flag and argument handling across REPL commands.
+ */
+import { Parser } from '@oclif/core';
+import fs from 'node:fs';
+import path from 'node:path';
+// Re-export Args and Flags for use by REPL commands
+export { Args, Flags } from '@oclif/core';
+/**
+ * Convert oclif flag definitions to CommandFlag[] for SlashCommand.flags
+ *
+ * This allows defining flags once using oclif format and auto-generating
+ * the CommandFlag[] needed for help display.
+ *
+ * @example
+ * const flags = {
+ *   apiKey: Flags.string({char: 'k', description: 'API key'}),
+ *   verbose: Flags.boolean({char: 'v', description: 'Verbose output'}),
+ * }
+ *
+ * export const myCommand: SlashCommand = {
+ *   action(context, args) {
+ *     const parsed = await parseReplArgs(args, {flags})
+ *   },
+ *   flags: toCommandFlags(flags),
+ * }
+ */
+export function toCommandFlags(flags) {
+    return Object.entries(flags).map(([name, flag]) => ({
+        char: flag.char,
+        default: flag.default,
+        description: flag.description ?? '',
+        name,
+        type: flag.type === 'boolean' ? 'boolean' : 'string',
+    }));
+}
+/**
+ * Check if a path refers to a directory.
+ * Handles both explicit trailing slash and actual filesystem check.
+ */
+function isDirectoryPath(refPath) {
+    // Empty path is not a directory (edge case for @ alone)
+    if (!refPath) {
+        return false;
+    }
+    // Handle current directory explicitly (. or ./)
+    if (refPath === '.' || refPath === './') {
+        return true;
+    }
+    // Explicit trailing slash indicates folder intent
+    if (refPath.endsWith('/') || refPath.endsWith(path.sep)) {
+        return true;
+    }
+    // Check filesystem
+    try {
+        const fullPath = path.isAbsolute(refPath) ? refPath : path.resolve(process.cwd(), refPath);
+        const stats = fs.statSync(fullPath);
+        return stats.isDirectory();
+    }
+    catch {
+        // If path doesn't exist, default to file
+        return false;
+    }
+}
+/**
+ * Categorize a @ reference as file or folder.
+ */
+function categorizeReference(refPath) {
+    return isDirectoryPath(refPath) ? 'folder' : 'file';
+}
+/**
+ * Split a string into args array, respecting quoted strings
+ * Handles both single and double quotes, and extracts @file and @folder references
+ *
+ * @example
+ * splitArgs('"hello world" --force') // { args: ['hello world', '--force'], files: [], folders: [] }
+ * splitArgs("'hello world' -f") // { args: ['hello world', '-f'], files: [], folders: [] }
+ * splitArgs('query @src/file.ts') // { args: ['query'], files: ['src/file.ts'], folders: [] }
+ * splitArgs('"context" @src/') // { args: ['context'], files: [], folders: ['src/'] }
+ * splitArgs('text @src/ @README.md') // { args: ['text'], files: ['README.md'], folders: ['src/'] }
+ */
+export function splitArgs(input) {
+    const args = [];
+    const files = [];
+    const folders = [];
+    let current = '';
+    let inQuote = null;
+    for (const char of input) {
+        if (inQuote) {
+            // Inside a quoted string
+            if (char === inQuote) {
+                // End of quoted string - don't include the quote
+                inQuote = null;
+            }
+            else {
+                current += char;
+            }
+        }
+        else if (char === '"' || char === "'") {
+            // Start of quoted string - don't include the quote
+            inQuote = char;
+        }
+        else if (char === ' ' || char === '\t') {
+            // Whitespace outside quotes - end current arg
+            if (current) {
+                if (current.startsWith('@')) {
+                    // Reference - strip the @ prefix and categorize
+                    const refPath = current.slice(1);
+                    // Skip empty @ references (just "@" alone)
+                    if (refPath) {
+                        if (categorizeReference(refPath) === 'folder') {
+                            folders.push(refPath);
+                        }
+                        else {
+                            files.push(refPath);
+                        }
+                    }
+                }
+                else {
+                    args.push(current);
+                }
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    // Don't forget the last arg
+    if (current) {
+        if (current.startsWith('@')) {
+            const refPath = current.slice(1);
+            // Skip empty @ references (just "@" alone)
+            if (refPath) {
+                if (categorizeReference(refPath) === 'folder') {
+                    folders.push(refPath);
+                }
+                else {
+                    files.push(refPath);
+                }
+            }
+        }
+        else {
+            args.push(current);
+        }
+    }
+    return { args, files, folders };
+}
+/**
+ * Parse REPL command arguments using oclif's Parser
+ *
+ * @param input - Raw input string from REPL (e.g., '"hello world" --force @src/file.ts')
+ * @param options - Parser options
+ * @param options.args - Argument definitions using Args from @oclif/core
+ * @param options.flags - Flag definitions using Flags from @oclif/core
+ * @param options.strict - Whether to error on unknown flags (default: false)
+ * @returns Parsed flags, args, remaining argv, and file references
+ *
+ * @example
+ * const result = await parseReplArgs('query text --verbose @src/auth.ts', {
+ *   args: { query: Args.string({ required: true }) },
+ *   flags: { verbose: Flags.boolean({ char: 'v' }) },
+ * })
+ * // result.args.query === 'query'
+ * // result.flags.verbose === true
+ * // result.argv === ['query', 'text']
+ * // result.files === ['src/auth.ts']
+ */
+export async function parseReplArgs(input, options) {
+    const { args: argv, files, folders } = splitArgs(input);
+    const result = await Parser.parse(argv, {
+        args: options.args ?? {},
+        flags: options.flags ?? {},
+        strict: options.strict ?? false,
+    });
+    return {
+        args: result.args,
+        argv: result.argv,
+        files,
+        flags: result.flags,
+        folders,
+    };
+}

package/dist/tui/commands/connectors-command.d.ts

@@ -0,0 +1,8 @@
+import { SlashCommand } from '../types.js';
+/**
+ * Connectors command
+ *
+ * Manages connectors (rules, hook) for integrating BRV with coding agents.
+ * Lists connected agents and allows managing or adding new connections.
+ */
+export declare const connectorsCommand: SlashCommand;

package/dist/tui/commands/connectors-command.js

@@ -0,0 +1,49 @@
+import { ConnectorManager } from '../../server/infra/connectors/connector-manager.js';
+import { RuleTemplateService } from '../../server/infra/connectors/shared/template-service.js';
+import { FsFileService } from '../../server/infra/file/fs-file-service.js';
+import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
+import { createTokenStore } from '../../server/infra/storage/token-store.js';
+import { FsTemplateLoader } from '../../server/infra/template/fs-template-loader.js';
+import { ReplTerminal } from '../../server/infra/terminal/repl-terminal.js';
+import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
+import { ConnectorsUseCase } from '../../server/infra/usecase/connectors-use-case.js';
+import { CommandKind } from '../types.js';
+/**
+ * Connectors command
+ *
+ * Manages connectors (rules, hook) for integrating BRV with coding agents.
+ * Lists connected agents and allows managing or adding new connections.
+ */
+export const connectorsCommand = {
+    action: () => ({
+        async execute(onMessage, onPrompt) {
+            // Create ReplTerminal with callbacks
+            const terminal = new ReplTerminal({ onMessage, onPrompt });
+            // Create services
+            const fileService = new FsFileService();
+            const templateLoader = new FsTemplateLoader(fileService);
+            const templateService = new RuleTemplateService(templateLoader);
+            const globalConfigStore = new FileGlobalConfigStore();
+            const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore: createTokenStore() });
+            // Create ConnectorManager
+            const connectorManager = new ConnectorManager({
+                fileService,
+                projectRoot: process.cwd(),
+                templateService,
+            });
+            // Create and run UseCase
+            const useCase = new ConnectorsUseCase({
+                connectorManager,
+                terminal,
+                trackingService,
+            });
+            await useCase.run();
+        },
+        type: 'streaming',
+    }),
+    aliases: ['connectors'],
+    autoExecute: true,
+    description: 'Manage agent connectors (rules, hook, mcp, or skill)',
+    kind: CommandKind.BUILT_IN,
+    name: 'connector',
+};