codehere 0.2.2 → 0.3.0-rc.2

package/dist/infrastructure/protocols/mcp-server.js

@@ -1,333 +0,0 @@
-/**
- * Infrastructure: Model Context Protocol (MCP) Server
- * Exposes Codehere as an MCP-compatible server
- * Enables integration with other MCP clients and agents
- *
- * Based on research: MCP Architecture and OAuth 2.1 security
- * - Transport-agnostic (HTTP, gRPC, WebSocket)
- * - Stateless design for cloud-native ecosystems
- * - OAuth 2.1 with Dynamic Client Registration
- * - One-to-one Client-Server relationship (architectural decoupling)
- *
- * MCP Specification: https://modelcontextprotocol.io
- * Research: See docs/NOTEBOOKLM_RESEARCH_PROMPTS.md - Prompt #5
- */
-/**
- * Codehere MCP Server Implementation
- */
-export class CodehereMCPServer {
-    container;
-    constructor(container // Dependency container
-    ) {
-        this.container = container;
-    }
-    getCapabilities() {
-        return {
-            tools: {
-                listChanged: true,
-            },
-            resources: {
-                listChanged: true,
-            },
-            prompts: {
-                listChanged: true,
-            },
-        };
-    }
-    listTools() {
-        return [
-            {
-                name: 'codehere_ask',
-                description: 'Ask questions about codebase using semantic search',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        query: {
-                            type: 'string',
-                            description: 'The question to ask about the codebase',
-                        },
-                        maxResults: {
-                            type: 'number',
-                            description: 'Maximum number of code chunks to retrieve',
-                            default: 15,
-                        },
-                    },
-                    required: ['query'],
-                },
-            },
-            {
-                name: 'codehere_explain',
-                description: 'Get detailed explanation of a code file',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        filepath: {
-                            type: 'string',
-                            description: 'Path to the file to explain',
-                        },
-                    },
-                    required: ['filepath'],
-                },
-            },
-            {
-                name: 'codehere_edit',
-                description: 'Edit a file with AI-generated changes',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        filepath: {
-                            type: 'string',
-                            description: 'Path to the file to edit',
-                        },
-                        instruction: {
-                            type: 'string',
-                            description: 'Natural language instruction for the edit',
-                        },
-                    },
-                    required: ['filepath', 'instruction'],
-                },
-            },
-            {
-                name: 'codehere_search',
-                description: 'Search codebase using semantic search',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        query: {
-                            type: 'string',
-                            description: 'Search query',
-                        },
-                        maxResults: {
-                            type: 'number',
-                            description: 'Maximum number of results',
-                            default: 10,
-                        },
-                    },
-                    required: ['query'],
-                },
-            },
-            {
-                name: 'codehere_memory_query',
-                description: 'Query persistent episodic memory',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        query: {
-                            type: 'string',
-                            description: 'Memory query',
-                        },
-                        limit: {
-                            type: 'number',
-                            description: 'Maximum number of memories to retrieve',
-                            default: 10,
-                        },
-                    },
-                    required: ['query'],
-                },
-            },
-        ];
-    }
-    async callTool(name, args) {
-        try {
-            switch (name) {
-                case 'codehere_ask':
-                    return await this.handleAsk(args);
-                case 'codehere_explain':
-                    return await this.handleExplain(args);
-                case 'codehere_edit':
-                    return await this.handleEdit(args);
-                case 'codehere_search':
-                    return await this.handleSearch(args);
-                case 'codehere_memory_query':
-                    return await this.handleMemoryQuery(args);
-                default:
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Unknown tool: ${name}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-            }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    }
-    listResources() {
-        return [
-            {
-                uri: 'codehere://codebase',
-                name: 'Codebase',
-                description: 'The entire codebase',
-                mimeType: 'application/json',
-            },
-            {
-                uri: 'codehere://memory',
-                name: 'Memory',
-                description: 'Persistent episodic memory',
-                mimeType: 'application/json',
-            },
-        ];
-    }
-    async readResource(uri) {
-        if (uri === 'codehere://codebase') {
-            // Return codebase metadata
-            return {
-                uri,
-                mimeType: 'application/json',
-                text: JSON.stringify({
-                    description: 'Codehere codebase',
-                    capabilities: ['ask', 'explain', 'edit', 'search', 'memory'],
-                }, null, 2),
-            };
-        }
-        if (uri === 'codehere://memory') {
-            // Return memory statistics
-            const memoryStream = this.container.memoryStreamService;
-            const stats = await memoryStream.getStatistics?.() || {};
-            return {
-                uri,
-                mimeType: 'application/json',
-                text: JSON.stringify(stats, null, 2),
-            };
-        }
-        throw new Error(`Unknown resource: ${uri}`);
-    }
-    listPrompts() {
-        return [
-            {
-                name: 'codehere_analyze',
-                description: 'Analyze codebase structure and patterns',
-                arguments: [
-                    {
-                        name: 'focus',
-                        description: 'What to analyze (architecture, patterns, dependencies, etc.)',
-                        required: false,
-                    },
-                ],
-            },
-        ];
-    }
-    async getPrompt(name, promptArgs) {
-        if (name === 'codehere_analyze') {
-            const focus = promptArgs?.focus || 'general';
-            return {
-                messages: [
-                    {
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: `Analyze the codebase focusing on: ${focus}. Provide insights about architecture, patterns, and dependencies.`,
-                        },
-                    },
-                ],
-            };
-        }
-        throw new Error(`Unknown prompt: ${name}`);
-    }
-    async handleAsk(args) {
-        const useCase = this.container.askQuestionUseCase;
-        const result = await useCase.execute({
-            query: args.query,
-            maxResults: args.maxResults || 15,
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: result.answer,
-                },
-            ],
-        };
-    }
-    async handleExplain(args) {
-        const useCase = this.container.explainFileUseCase;
-        const result = await useCase.execute({
-            filepath: args.filepath,
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: result.explanation,
-                },
-            ],
-        };
-    }
-    async handleEdit(args) {
-        const useCase = this.container.editFileUseCase;
-        const result = await useCase.execute({
-            filepath: args.filepath,
-            instruction: args.instruction,
-        });
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Edit failed: ${result.error}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: 'Edit applied successfully',
-                },
-            ],
-        };
-    }
-    async handleSearch(args) {
-        const useCase = this.container.askQuestionUseCase;
-        const result = await useCase.execute({
-            query: args.query,
-            maxResults: args.maxResults || 10,
-        });
-        const chunks = result.chunks.map((chunk) => ({
-            filepath: chunk.filepath,
-            content: chunk.content.substring(0, 200),
-            score: chunk.score,
-        }));
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(chunks, null, 2),
-                },
-            ],
-        };
-    }
-    async handleMemoryQuery(args) {
-        const memoryStream = this.container.memoryStreamService;
-        const memories = await memoryStream.retrieve(args.query, args.limit || 10);
-        const memoryData = memories.map((m) => ({
-            type: m.type,
-            description: m.description,
-            timestamp: m.timestamp,
-            importance: m.importance,
-        }));
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(memoryData, null, 2),
-                },
-            ],
-        };
-    }
-}
-//# sourceMappingURL=mcp-server.js.map

package/dist/infrastructure/protocols/streaming-handler.js

@@ -1,103 +0,0 @@
-/**
- * Infrastructure: Streaming Handler
- * Provides streaming interface for real-time responses
- * Target: < 200ms perceived latency
- */
-/**
- * Enhanced streaming handler with buffering and batching
- * Optimizes for < 200ms perceived latency
- */
-export class OptimizedStreamingHandler {
-    output;
-    buffer = [];
-    flushInterval = null;
-    FLUSH_INTERVAL_MS = 50; // Flush every 50ms for better UX
-    MAX_BUFFER_SIZE = 100; // Max tokens before forced flush
-    constructor(output = (text) => process.stdout.write(text)) {
-        this.output = output;
-    }
-    onToken(token) {
-        this.buffer.push(token);
-        // Force flush if buffer is too large
-        if (this.buffer.length >= this.MAX_BUFFER_SIZE) {
-            this.flush();
-        }
-        else {
-            // Schedule flush if not already scheduled
-            if (!this.flushInterval) {
-                this.flushInterval = setTimeout(() => {
-                    this.flush();
-                    this.flushInterval = null;
-                }, this.FLUSH_INTERVAL_MS);
-            }
-        }
-    }
-    onProgress(phase, message) {
-        // Clear any pending flushes
-        if (this.flushInterval) {
-            clearTimeout(this.flushInterval);
-            this.flushInterval = null;
-        }
-        // Flush buffer before progress update
-        this.flush();
-        // Output progress (can be formatted differently)
-        this.output(`\n[${phase}] ${message}\n`);
-    }
-    onComplete(data) {
-        // Final flush
-        if (this.flushInterval) {
-            clearTimeout(this.flushInterval);
-            this.flushInterval = null;
-        }
-        this.flush();
-    }
-    onError(error) {
-        // Clear buffer and output error
-        if (this.flushInterval) {
-            clearTimeout(this.flushInterval);
-            this.flushInterval = null;
-        }
-        this.flush();
-        this.output(`\nError: ${error.message}\n`);
-    }
-    /**
-     * Flush buffered tokens
-     */
-    flush() {
-        if (this.buffer.length > 0) {
-            const text = this.buffer.join('');
-            this.output(text);
-            this.buffer = [];
-        }
-    }
-}
-/**
- * Create streaming handler for CLI
- */
-export function createCLIStreamingHandler() {
-    return new OptimizedStreamingHandler((text) => {
-        process.stdout.write(text);
-    });
-}
-/**
- * Create streaming handler for API
- */
-export function createAPIStreamingHandler(res) {
-    return {
-        onToken: (token) => {
-            res.write(`data: ${JSON.stringify({ type: 'token', data: token })}\n\n`);
-        },
-        onProgress: (phase, message) => {
-            res.write(`data: ${JSON.stringify({ type: 'progress', phase, message })}\n\n`);
-        },
-        onComplete: (data) => {
-            res.write(`data: ${JSON.stringify({ type: 'complete', data })}\n\n`);
-            res.end();
-        },
-        onError: (error) => {
-            res.write(`data: ${JSON.stringify({ type: 'error', error: error.message })}\n\n`);
-            res.end();
-        },
-    };
-}
-//# sourceMappingURL=streaming-handler.js.map