midnight-mcp 0.1.41 → 0.2.2

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

package/dist/pipeline/github.js

@@ -1,399 +0,0 @@
-import { Octokit } from "octokit";
-import { config, logger, updateRateLimit, shouldProceedWithRequest, getRateLimitStatus, } from "../utils/index.js";
-// Retry configuration
-const RETRY_CONFIG = {
-    maxRetries: 3,
-    baseDelayMs: 1000,
-    maxDelayMs: 10000,
-};
-/**
- * Retry wrapper with exponential backoff
- */
-async function withRetry(operation, operationName) {
-    let lastError = null;
-    for (let attempt = 1; attempt <= RETRY_CONFIG.maxRetries; attempt++) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            lastError = error;
-            const isRetryable = isRetryableError(error);
-            if (!isRetryable || attempt === RETRY_CONFIG.maxRetries) {
-                logger.error(`${operationName} failed after ${attempt} attempt(s)`, {
-                    error: String(error),
-                    attempt,
-                });
-                throw enhanceError(error, operationName);
-            }
-            const delay = Math.min(RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt - 1), RETRY_CONFIG.maxDelayMs);
-            logger.warn(`${operationName} failed, retrying in ${delay}ms...`, {
-                attempt,
-                error: String(error),
-            });
-            await sleep(delay);
-        }
-    }
-    throw lastError;
-}
-/**
- * Check if an error is retryable
- */
-function isRetryableError(error) {
-    if (error instanceof Error) {
-        const message = error.message.toLowerCase();
-        // Retry on network errors, rate limits, and server errors
-        return (message.includes("network") ||
-            message.includes("timeout") ||
-            message.includes("econnreset") ||
-            message.includes("rate limit") ||
-            message.includes("403") ||
-            message.includes("500") ||
-            message.includes("502") ||
-            message.includes("503") ||
-            message.includes("504"));
-    }
-    return false;
-}
-/**
- * Enhance error with more context
- */
-function enhanceError(error, operation) {
-    const originalMessage = error instanceof Error ? error.message : String(error);
-    // Provide user-friendly error messages
-    if (originalMessage.includes("rate limit") ||
-        originalMessage.includes("403")) {
-        return new Error(`GitHub API rate limit exceeded during ${operation}. ` +
-            `Add a GITHUB_TOKEN to your config to increase limits from 60 to 5000 requests/hour.`);
-    }
-    if (originalMessage.includes("404")) {
-        return new Error(`Resource not found during ${operation}. ` +
-            `Check that the repository/file exists and is accessible.`);
-    }
-    if (originalMessage.includes("timeout") ||
-        originalMessage.includes("network")) {
-        return new Error(`Network error during ${operation}. ` +
-            `Check your internet connection and try again.`);
-    }
-    return new Error(`${operation} failed: ${originalMessage}`);
-}
-/**
- * Sleep for a given number of milliseconds
- */
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-class SimpleCache {
-    cache = new Map();
-    ttlMs;
-    constructor(ttlMinutes = 10) {
-        this.ttlMs = ttlMinutes * 60 * 1000;
-    }
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return null;
-        if (Date.now() - entry.timestamp > this.ttlMs) {
-            this.cache.delete(key);
-            return null;
-        }
-        return entry.data;
-    }
-    set(key, data) {
-        this.cache.set(key, { data, timestamp: Date.now() });
-    }
-    clear() {
-        this.cache.clear();
-    }
-}
-export class GitHubClient {
-    octokit;
-    fileCache = new SimpleCache(15); // 15 min cache for files
-    treeCache = new SimpleCache(10); // 10 min cache for trees
-    repoInfoCache = new SimpleCache(10); // 10 min cache for repo info
-    constructor(token) {
-        this.octokit = new Octokit({
-            auth: token || config.githubToken,
-            request: {
-                timeout: 10000, // 10 second timeout for API calls
-            },
-        });
-    }
-    /**
-     * Get repository information
-     */
-    async getRepositoryInfo(owner, repo) {
-        const cacheKey = `repo:${owner}/${repo}`;
-        const cached = this.repoInfoCache.get(cacheKey);
-        if (cached) {
-            logger.debug(`Cache hit for repo info: ${cacheKey}`);
-            return cached;
-        }
-        try {
-            const { data: repoData } = await withRetry(() => this.octokit.rest.repos.get({ owner, repo }), `getRepositoryInfo(${owner}/${repo})`);
-            const { data: commits } = await withRetry(() => this.octokit.rest.repos.listCommits({ owner, repo, per_page: 1 }), `getCommits(${owner}/${repo})`);
-            const lastCommit = commits[0]
-                ? {
-                    sha: commits[0].sha,
-                    message: commits[0].commit.message,
-                    author: commits[0].commit.author?.name || "Unknown",
-                    date: commits[0].commit.author?.date || "",
-                    url: commits[0].html_url,
-                }
-                : null;
-            const result = {
-                owner,
-                repo,
-                branch: repoData.default_branch,
-                lastCommit,
-                fileCount: 0, // Will be updated during tree fetch
-            };
-            this.repoInfoCache.set(cacheKey, result);
-            return result;
-        }
-        catch (error) {
-            logger.error(`Failed to get repository info for ${owner}/${repo}`, {
-                error: String(error),
-            });
-            throw error;
-        }
-    }
-    /**
-     * Get file content from a repository
-     */
-    async getFileContent(owner, repo, path, ref) {
-        const cacheKey = `file:${owner}/${repo}/${path}@${ref || "main"}`;
-        const cached = this.fileCache.get(cacheKey);
-        if (cached) {
-            logger.debug(`Cache hit for file: ${cacheKey}`);
-            return cached;
-        }
-        try {
-            const { data } = await withRetry(() => this.octokit.rest.repos.getContent({ owner, repo, path, ref }), `getFileContent(${owner}/${repo}/${path})`);
-            if (Array.isArray(data) || data.type !== "file") {
-                return null;
-            }
-            const content = data.encoding === "base64"
-                ? Buffer.from(data.content, "base64").toString("utf-8")
-                : data.content;
-            const result = {
-                path: data.path,
-                content,
-                sha: data.sha,
-                size: data.size,
-                encoding: data.encoding,
-            };
-            this.fileCache.set(cacheKey, result);
-            return result;
-        }
-        catch (error) {
-            logger.warn(`Failed to get file ${path} from ${owner}/${repo}`, {
-                error: String(error),
-            });
-            return null;
-        }
-    }
-    /**
-     * Get repository tree (list of all files)
-     */
-    async getRepositoryTree(owner, repo, ref) {
-        const cacheKey = `tree:${owner}/${repo}@${ref || "main"}`;
-        const cached = this.treeCache.get(cacheKey);
-        if (cached) {
-            logger.debug(`Cache hit for tree: ${cacheKey}`);
-            return cached;
-        }
-        try {
-            const { data: refData } = await withRetry(() => this.octokit.rest.git.getRef({
-                owner,
-                repo,
-                ref: `heads/${ref || "main"}`,
-            }), `getRef(${owner}/${repo})`);
-            const { data: treeData } = await withRetry(() => this.octokit.rest.git.getTree({
-                owner,
-                repo,
-                tree_sha: refData.object.sha,
-                recursive: "true",
-            }), `getTree(${owner}/${repo})`);
-            const result = treeData.tree
-                .filter((item) => item.type === "blob" && item.path)
-                .map((item) => item.path);
-            this.treeCache.set(cacheKey, result);
-            return result;
-        }
-        catch (error) {
-            logger.error(`Failed to get repository tree for ${owner}/${repo}`, {
-                error: String(error),
-            });
-            throw error;
-        }
-    }
-    /**
-     * Filter files by patterns
-     */
-    filterFilesByPatterns(files, patterns, exclude) {
-        const matchPattern = (file, pattern) => {
-            // Convert glob pattern to regex
-            const regexPattern = pattern
-                .replace(/\*\*/g, ".*")
-                .replace(/\*/g, "[^/]*")
-                .replace(/\./g, "\\.");
-            return new RegExp(`^${regexPattern}$`).test(file);
-        };
-        return files.filter((file) => {
-            const matchesInclude = patterns.some((p) => matchPattern(file, p));
-            const matchesExclude = exclude.some((p) => matchPattern(file, p));
-            return matchesInclude && !matchesExclude;
-        });
-    }
-    /**
-     * Fetch all files from a repository matching patterns
-     */
-    async fetchRepositoryFiles(repoConfig) {
-        const { owner, repo, branch, patterns, exclude } = repoConfig;
-        logger.info(`Fetching files from ${owner}/${repo}...`);
-        const allFiles = await this.getRepositoryTree(owner, repo, branch);
-        const filteredFiles = this.filterFilesByPatterns(allFiles, patterns, exclude);
-        logger.info(`Found ${filteredFiles.length} matching files in ${owner}/${repo}`);
-        const files = [];
-        for (const filePath of filteredFiles) {
-            const file = await this.getFileContent(owner, repo, filePath, branch);
-            if (file) {
-                files.push(file);
-            }
-        }
-        return files;
-    }
-    /**
-     * Get recent commits
-     */
-    async getRecentCommits(owner, repo, since, perPage = 30) {
-        try {
-            const params = {
-                owner,
-                repo,
-                per_page: perPage,
-            };
-            if (since) {
-                params.since = since;
-            }
-            const { data } = await this.octokit.rest.repos.listCommits(params);
-            return data.map((commit) => ({
-                sha: commit.sha,
-                message: commit.commit.message,
-                author: commit.commit.author?.name || "Unknown",
-                date: commit.commit.author?.date || "",
-                url: commit.html_url,
-            }));
-        }
-        catch (error) {
-            logger.error(`Failed to get commits for ${owner}/${repo}`, {
-                error: String(error),
-            });
-            return [];
-        }
-    }
-    /**
-     * Get files changed in recent commits
-     */
-    async getChangedFiles(owner, repo, since) {
-        try {
-            const commits = await this.getRecentCommits(owner, repo, since);
-            const changedFiles = new Set();
-            for (const commit of commits) {
-                const { data } = await this.octokit.rest.repos.getCommit({
-                    owner,
-                    repo,
-                    ref: commit.sha,
-                });
-                data.files?.forEach((file) => {
-                    if (file.filename) {
-                        changedFiles.add(file.filename);
-                    }
-                });
-            }
-            return Array.from(changedFiles);
-        }
-        catch (error) {
-            logger.error(`Failed to get changed files for ${owner}/${repo}`, {
-                error: String(error),
-            });
-            return [];
-        }
-    }
-    /**
-     * Search code in repositories
-     */
-    async searchCode(query, owner, repo, language) {
-        try {
-            let q = query;
-            if (owner && repo) {
-                q += ` repo:${owner}/${repo}`;
-            }
-            else if (owner) {
-                q += ` user:${owner}`;
-            }
-            if (language) {
-                q += ` language:${language}`;
-            }
-            const { data } = await this.octokit.rest.search.code({
-                q,
-                per_page: 30,
-            });
-            return data.items.map((item) => ({
-                path: item.path,
-                repository: item.repository.full_name,
-                url: item.html_url,
-            }));
-        }
-        catch (error) {
-            logger.warn(`Code search failed for query: ${query}`, {
-                error: String(error),
-            });
-            return [];
-        }
-    }
-    /**
-     * Get current rate limit status from GitHub API
-     */
-    async getRateLimit() {
-        try {
-            const { data } = await this.octokit.rest.rateLimit.get();
-            const rateLimit = {
-                limit: data.rate.limit,
-                remaining: data.rate.remaining,
-                reset: new Date(data.rate.reset * 1000),
-                used: data.rate.used,
-            };
-            // Update the global rate limit tracker
-            updateRateLimit(rateLimit);
-            return rateLimit;
-        }
-        catch (error) {
-            logger.warn("Failed to get rate limit", { error: String(error) });
-            // Return defaults if we can't get rate limit
-            return {
-                limit: 60,
-                remaining: 60,
-                reset: new Date(Date.now() + 3600000),
-                used: 0,
-            };
-        }
-    }
-    /**
-     * Check if it's safe to make API requests
-     */
-    checkRateLimit() {
-        const check = shouldProceedWithRequest();
-        const status = getRateLimitStatus();
-        if (!check.proceed) {
-            logger.warn("Rate limit check failed", { reason: check.reason });
-        }
-        return {
-            proceed: check.proceed,
-            reason: check.reason,
-            status,
-        };
-    }
-}
-export const githubClient = new GitHubClient();
-//# sourceMappingURL=github.js.map

package/dist/pipeline/index.d.ts

@@ -1,11 +0,0 @@
-export { GitHubClient, githubClient } from "./github.js";
-export type { GitHubFile, GitHubCommit, RepositoryInfo } from "./github.js";
-export { parseFile, parseCompactFile, parseTypeScriptFile, parseMarkdownFile, } from "./parser.js";
-export type { ParsedFile, CodeUnit } from "./parser.js";
-export { EmbeddingGenerator, embeddingGenerator } from "./embeddings.js";
-export type { EmbeddingResult } from "./embeddings.js";
-export { indexRepository, indexAllRepositories, incrementalUpdate, } from "./indexer.js";
-export type { IndexStats } from "./indexer.js";
-export { ReleaseTracker, releaseTracker } from "./releases.js";
-export type { Release, ChangelogEntry, VersionInfo } from "./releases.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/pipeline/index.js

@@ -1,6 +0,0 @@
-export { GitHubClient, githubClient } from "./github.js";
-export { parseFile, parseCompactFile, parseTypeScriptFile, parseMarkdownFile, } from "./parser.js";
-export { EmbeddingGenerator, embeddingGenerator } from "./embeddings.js";
-export { indexRepository, indexAllRepositories, incrementalUpdate, } from "./indexer.js";
-export { ReleaseTracker, releaseTracker } from "./releases.js";
-//# sourceMappingURL=index.js.map

package/dist/pipeline/indexer.d.ts

@@ -1,41 +0,0 @@
-import { RepositoryConfig } from "../utils/index.js";
-export interface IndexStats {
-    totalFiles: number;
-    totalChunks: number;
-    totalCodeUnits: number;
-    repositoriesIndexed: string[];
-    lastIndexed: string;
-}
-export interface ChunkMetadata {
-    repository: string;
-    filePath: string;
-    language: string;
-    chunkType: "code_unit" | "file_chunk";
-    codeUnitType?: string;
-    codeUnitName?: string;
-    startLine: number;
-    endLine: number;
-    isPublic: boolean;
-    repoVersion?: string;
-    pragmaVersion?: string;
-    indexedAt?: string;
-}
-/**
- * Index a single repository
- */
-export declare function indexRepository(repoConfig: RepositoryConfig): Promise<{
-    fileCount: number;
-    chunkCount: number;
-}>;
-/**
- * Index all configured repositories
- */
-export declare function indexAllRepositories(): Promise<IndexStats>;
-/**
- * Incremental update - only index changed files
- */
-export declare function incrementalUpdate(repoConfig: RepositoryConfig, since: string): Promise<{
-    fileCount: number;
-    chunkCount: number;
-}>;
-//# sourceMappingURL=indexer.d.ts.map