midnight-mcp 0.1.41 → 0.2.1

package/dist/db/vectorStore.d.ts

@@ -1,69 +0,0 @@
-export interface CodeDocument {
-    id: string;
-    content: string;
-    embedding?: number[];
-    metadata: {
-        repository: string;
-        filePath: string;
-        language: string;
-        startLine: number;
-        endLine: number;
-        codeType: string;
-        codeName: string;
-        isPublic: boolean;
-        repoVersion?: string;
-        pragmaVersion?: string;
-        indexedAt?: string;
-    };
-}
-export interface SearchResult {
-    id: string;
-    content: string;
-    score: number;
-    metadata: CodeDocument["metadata"];
-}
-export interface SearchFilter {
-    repository?: string;
-    language?: string;
-    codeType?: string;
-    isPublic?: boolean;
-}
-declare class VectorStore {
-    private client;
-    private collection;
-    private collectionName;
-    private initialized;
-    /**
-     * Initialize the vector store connection
-     */
-    initialize(): Promise<void>;
-    /**
-     * Add documents to the vector store
-     */
-    addDocuments(documents: CodeDocument[]): Promise<void>;
-    /**
-     * Search for similar documents
-     */
-    search(query: string, limit?: number, filter?: SearchFilter): Promise<SearchResult[]>;
-    /**
-     * Delete documents by file path
-     */
-    deleteByPath(repository: string, filePath: string): Promise<void>;
-    /**
-     * Delete all documents for a repository
-     */
-    deleteRepository(repository: string): Promise<void>;
-    /**
-     * Get collection statistics
-     */
-    getStats(): Promise<{
-        count: number;
-    }>;
-    /**
-     * Clear all data from the collection
-     */
-    clear(): Promise<void>;
-}
-export declare const vectorStore: VectorStore;
-export {};
-//# sourceMappingURL=vectorStore.d.ts.map

package/dist/db/vectorStore.js

@@ -1,196 +0,0 @@
-import { ChromaClient } from "chromadb";
-import { config, logger } from "../utils/index.js";
-import { embeddingGenerator } from "../pipeline/embeddings.js";
-class VectorStore {
-    client = null;
-    collection = null;
-    collectionName = "midnight-code";
-    initialized = false;
-    /**
-     * Initialize the vector store connection
-     */
-    async initialize() {
-        if (this.initialized)
-            return;
-        try {
-            this.client = new ChromaClient({
-                path: config.chromaUrl,
-            });
-            // Get or create the collection
-            this.collection = await this.client.getOrCreateCollection({
-                name: this.collectionName,
-                metadata: {
-                    description: "Midnight blockchain code and documentation",
-                },
-            });
-            this.initialized = true;
-            logger.info("Vector store initialized successfully");
-        }
-        catch (error) {
-            logger.error("Failed to initialize vector store", {
-                error: String(error),
-            });
-            // Continue without vector store - use fallback search
-            logger.warn("Vector store unavailable, using in-memory fallback");
-        }
-    }
-    /**
-     * Add documents to the vector store
-     */
-    async addDocuments(documents) {
-        if (!this.collection) {
-            logger.warn("Vector store not initialized, skipping document storage");
-            return;
-        }
-        try {
-            const ids = documents.map((d) => d.id);
-            const embeddings = documents.map((d) => d.embedding);
-            const metadatas = documents.map((d) => ({
-                repository: d.metadata.repository,
-                filePath: d.metadata.filePath,
-                language: d.metadata.language,
-                startLine: d.metadata.startLine,
-                endLine: d.metadata.endLine,
-                codeType: d.metadata.codeType,
-                codeName: d.metadata.codeName,
-                isPublic: d.metadata.isPublic,
-            }));
-            const documentContents = documents.map((d) => d.content);
-            await this.collection.add({
-                ids,
-                embeddings,
-                metadatas,
-                documents: documentContents,
-            });
-            logger.debug(`Added ${documents.length} documents to vector store`);
-        }
-        catch (error) {
-            logger.error("Failed to add documents to vector store", {
-                error: String(error),
-            });
-            throw error;
-        }
-    }
-    /**
-     * Search for similar documents
-     */
-    async search(query, limit = 10, filter) {
-        if (!this.collection) {
-            logger.warn("Vector store not initialized, returning empty results");
-            return [];
-        }
-        try {
-            // Generate embedding for the query
-            const queryEmbedding = await embeddingGenerator.generateEmbedding(query);
-            // Build where filter
-            const whereFilter = {};
-            if (filter?.repository) {
-                whereFilter.repository = filter.repository;
-            }
-            if (filter?.language) {
-                whereFilter.language = filter.language;
-            }
-            if (filter?.codeType) {
-                whereFilter.codeType = filter.codeType;
-            }
-            if (filter?.isPublic !== undefined) {
-                whereFilter.isPublic = filter.isPublic;
-            }
-            const results = await this.collection.query({
-                queryEmbeddings: [queryEmbedding.embedding],
-                nResults: limit,
-                where: Object.keys(whereFilter).length > 0 ? whereFilter : undefined,
-            });
-            // Format results
-            const searchResults = [];
-            if (results.ids[0] && results.documents[0] && results.metadatas[0]) {
-                for (let i = 0; i < results.ids[0].length; i++) {
-                    const metadata = results.metadatas[0][i];
-                    searchResults.push({
-                        id: results.ids[0][i],
-                        content: results.documents[0][i] || "",
-                        score: results.distances ? 1 - (results.distances[0][i] || 0) : 0,
-                        metadata,
-                    });
-                }
-            }
-            return searchResults;
-        }
-        catch (error) {
-            logger.error("Search failed", { error: String(error) });
-            return [];
-        }
-    }
-    /**
-     * Delete documents by file path
-     */
-    async deleteByPath(repository, filePath) {
-        if (!this.collection)
-            return;
-        try {
-            await this.collection.delete({
-                where: {
-                    repository,
-                    filePath,
-                },
-            });
-            logger.debug(`Deleted documents for ${repository}:${filePath}`);
-        }
-        catch (error) {
-            logger.error("Failed to delete documents", { error: String(error) });
-        }
-    }
-    /**
-     * Delete all documents for a repository
-     */
-    async deleteRepository(repository) {
-        if (!this.collection)
-            return;
-        try {
-            await this.collection.delete({
-                where: { repository },
-            });
-            logger.info(`Deleted all documents for repository ${repository}`);
-        }
-        catch (error) {
-            logger.error("Failed to delete repository documents", {
-                error: String(error),
-            });
-        }
-    }
-    /**
-     * Get collection statistics
-     */
-    async getStats() {
-        if (!this.collection) {
-            return { count: 0 };
-        }
-        try {
-            const count = await this.collection.count();
-            return { count };
-        }
-        catch (error) {
-            logger.error("Failed to get stats", { error: String(error) });
-            return { count: 0 };
-        }
-    }
-    /**
-     * Clear all data from the collection
-     */
-    async clear() {
-        if (!this.client)
-            return;
-        try {
-            await this.client.deleteCollection({ name: this.collectionName });
-            this.collection = await this.client.getOrCreateCollection({
-                name: this.collectionName,
-            });
-            logger.info("Vector store cleared");
-        }
-        catch (error) {
-            logger.error("Failed to clear vector store", { error: String(error) });
-        }
-    }
-}
-export const vectorStore = new VectorStore();
-//# sourceMappingURL=vectorStore.js.map

package/dist/pipeline/embeddings.d.ts

@@ -1,25 +0,0 @@
-export interface EmbeddingResult {
-    text: string;
-    embedding: number[];
-    model: string;
-    tokenCount?: number;
-}
-export declare class EmbeddingGenerator {
-    private openai;
-    private model;
-    constructor();
-    /**
-     * Generate embeddings for a single text
-     */
-    generateEmbedding(text: string): Promise<EmbeddingResult>;
-    /**
-     * Generate embeddings for multiple texts in batch
-     */
-    generateEmbeddings(texts: string[]): Promise<EmbeddingResult[]>;
-    /**
-     * Calculate cosine similarity between two embeddings
-     */
-    cosineSimilarity(a: number[], b: number[]): number;
-}
-export declare const embeddingGenerator: EmbeddingGenerator;
-//# sourceMappingURL=embeddings.d.ts.map

package/dist/pipeline/embeddings.js

@@ -1,103 +0,0 @@
-import OpenAI from "openai";
-import { config, logger } from "../utils/index.js";
-export class EmbeddingGenerator {
-    openai = null;
-    model;
-    constructor() {
-        this.model = config.embeddingModel;
-        if (config.openaiApiKey) {
-            this.openai = new OpenAI({
-                apiKey: config.openaiApiKey,
-            });
-        }
-    }
-    /**
-     * Generate embeddings for a single text
-     */
-    async generateEmbedding(text) {
-        if (!this.openai) {
-            // Return a dummy embedding for testing without API key
-            logger.warn("No OpenAI API key configured, using dummy embeddings");
-            return {
-                text,
-                embedding: new Array(1536).fill(0).map(() => Math.random() - 0.5),
-                model: "dummy",
-            };
-        }
-        try {
-            const response = await this.openai.embeddings.create({
-                model: this.model,
-                input: text,
-            });
-            return {
-                text,
-                embedding: response.data[0].embedding,
-                model: this.model,
-                tokenCount: response.usage?.total_tokens,
-            };
-        }
-        catch (error) {
-            logger.error("Failed to generate embedding", { error: String(error) });
-            throw error;
-        }
-    }
-    /**
-     * Generate embeddings for multiple texts in batch
-     */
-    async generateEmbeddings(texts) {
-        if (!this.openai) {
-            logger.warn("No OpenAI API key configured, using dummy embeddings");
-            return texts.map((text) => ({
-                text,
-                embedding: new Array(1536).fill(0).map(() => Math.random() - 0.5),
-                model: "dummy",
-            }));
-        }
-        try {
-            // OpenAI allows up to 2048 inputs per request
-            const batchSize = 100;
-            const results = [];
-            for (let i = 0; i < texts.length; i += batchSize) {
-                const batch = texts.slice(i, i + batchSize);
-                logger.debug(`Generating embeddings for batch ${i / batchSize + 1}`);
-                const response = await this.openai.embeddings.create({
-                    model: this.model,
-                    input: batch,
-                });
-                for (let j = 0; j < batch.length; j++) {
-                    results.push({
-                        text: batch[j],
-                        embedding: response.data[j].embedding,
-                        model: this.model,
-                    });
-                }
-            }
-            return results;
-        }
-        catch (error) {
-            logger.error("Failed to generate batch embeddings", {
-                error: String(error),
-            });
-            throw error;
-        }
-    }
-    /**
-     * Calculate cosine similarity between two embeddings
-     */
-    cosineSimilarity(a, b) {
-        if (a.length !== b.length) {
-            throw new Error("Embeddings must have the same length");
-        }
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-    }
-}
-export const embeddingGenerator = new EmbeddingGenerator();
-//# sourceMappingURL=embeddings.js.map

package/dist/pipeline/github.d.ts

@@ -1,84 +0,0 @@
-import { RepositoryConfig, getRateLimitStatus } from "../utils/index.js";
-export interface GitHubFile {
-    path: string;
-    content: string;
-    sha: string;
-    size: number;
-    encoding: string;
-}
-export interface GitHubCommit {
-    sha: string;
-    message: string;
-    author: string;
-    date: string;
-    url: string;
-}
-export interface RepositoryInfo {
-    owner: string;
-    repo: string;
-    branch: string;
-    lastCommit: GitHubCommit | null;
-    fileCount: number;
-}
-export declare class GitHubClient {
-    private octokit;
-    private fileCache;
-    private treeCache;
-    private repoInfoCache;
-    constructor(token?: string);
-    /**
-     * Get repository information
-     */
-    getRepositoryInfo(owner: string, repo: string): Promise<RepositoryInfo>;
-    /**
-     * Get file content from a repository
-     */
-    getFileContent(owner: string, repo: string, path: string, ref?: string): Promise<GitHubFile | null>;
-    /**
-     * Get repository tree (list of all files)
-     */
-    getRepositoryTree(owner: string, repo: string, ref?: string): Promise<string[]>;
-    /**
-     * Filter files by patterns
-     */
-    filterFilesByPatterns(files: string[], patterns: string[], exclude: string[]): string[];
-    /**
-     * Fetch all files from a repository matching patterns
-     */
-    fetchRepositoryFiles(repoConfig: RepositoryConfig): Promise<GitHubFile[]>;
-    /**
-     * Get recent commits
-     */
-    getRecentCommits(owner: string, repo: string, since?: string, perPage?: number): Promise<GitHubCommit[]>;
-    /**
-     * Get files changed in recent commits
-     */
-    getChangedFiles(owner: string, repo: string, since: string): Promise<string[]>;
-    /**
-     * Search code in repositories
-     */
-    searchCode(query: string, owner?: string, repo?: string, language?: string): Promise<Array<{
-        path: string;
-        repository: string;
-        url: string;
-    }>>;
-    /**
-     * Get current rate limit status from GitHub API
-     */
-    getRateLimit(): Promise<{
-        limit: number;
-        remaining: number;
-        reset: Date;
-        used: number;
-    }>;
-    /**
-     * Check if it's safe to make API requests
-     */
-    checkRateLimit(): {
-        proceed: boolean;
-        reason?: string;
-        status: ReturnType<typeof getRateLimitStatus>;
-    };
-}
-export declare const githubClient: GitHubClient;
-//# sourceMappingURL=github.d.ts.map