midnight-mcp 0.1.41 → 0.2.2

package/dist/pipeline/releases.js

@@ -1,298 +0,0 @@
-import { Octokit } from "octokit";
-import { config, logger } from "../utils/index.js";
-/**
- * Fetches and tracks releases from GitHub repositories
- */
-export class ReleaseTracker {
-    octokit;
-    cache = new Map();
-    cacheMaxAge = 1000 * 60 * 15; // 15 minutes
-    constructor(token) {
-        this.octokit = new Octokit({
-            auth: token || config.githubToken,
-        });
-    }
-    /**
-     * Get all releases for a repository
-     */
-    async getReleases(owner, repo, limit = 20) {
-        try {
-            const { data } = await this.octokit.rest.repos.listReleases({
-                owner,
-                repo,
-                per_page: limit,
-            });
-            return data.map((release) => ({
-                tag: release.tag_name,
-                name: release.name || release.tag_name,
-                body: release.body || "",
-                publishedAt: release.published_at || release.created_at,
-                url: release.html_url,
-                isPrerelease: release.prerelease,
-                assets: release.assets.map((asset) => ({
-                    name: asset.name,
-                    downloadUrl: asset.browser_download_url,
-                })),
-            }));
-        }
-        catch (error) {
-            logger.warn(`Failed to fetch releases for ${owner}/${repo}`, {
-                error: String(error),
-            });
-            return [];
-        }
-    }
-    /**
-     * Parse a release body to extract structured changelog info
-     */
-    parseChangelog(releaseBody, version, date) {
-        const changes = {
-            breaking: [],
-            features: [],
-            fixes: [],
-            deprecations: [],
-        };
-        const lines = releaseBody.split("\n");
-        let currentSection = null;
-        for (const line of lines) {
-            const trimmed = line.trim().toLowerCase();
-            // Detect section headers
-            if (trimmed.includes("breaking") || trimmed.includes("⚠️")) {
-                currentSection = "breaking";
-                continue;
-            }
-            if (trimmed.includes("feature") ||
-                trimmed.includes("added") ||
-                trimmed.includes("✨") ||
-                trimmed.includes("🚀")) {
-                currentSection = "features";
-                continue;
-            }
-            if (trimmed.includes("fix") ||
-                trimmed.includes("bug") ||
-                trimmed.includes("🐛") ||
-                trimmed.includes("🔧")) {
-                currentSection = "fixes";
-                continue;
-            }
-            if (trimmed.includes("deprecat") || trimmed.includes("⚠")) {
-                currentSection = "deprecations";
-                continue;
-            }
-            // Extract list items
-            if (currentSection &&
-                (line.startsWith("-") || line.startsWith("*") || line.match(/^\d+\./))) {
-                const content = line.replace(/^[-*]\s*|\d+\.\s*/, "").trim();
-                if (content) {
-                    changes[currentSection].push(content);
-                }
-            }
-        }
-        return {
-            version,
-            date,
-            changes,
-            rawBody: releaseBody,
-        };
-    }
-    /**
-     * Get version info for a repository with caching
-     */
-    async getVersionInfo(owner, repo) {
-        const repoKey = `${owner}/${repo}`;
-        const cached = this.cache.get(repoKey);
-        if (cached) {
-            const age = Date.now() - new Date(cached.lastChecked).getTime();
-            if (age < this.cacheMaxAge) {
-                return cached;
-            }
-        }
-        const releases = await this.getReleases(owner, repo);
-        const latestRelease = releases[0] || null;
-        const latestStableRelease = releases.find((r) => !r.isPrerelease) || null;
-        const changelog = releases.map((r) => this.parseChangelog(r.body, r.tag, r.publishedAt));
-        const info = {
-            repository: repoKey,
-            latestRelease,
-            latestStableRelease,
-            recentReleases: releases.slice(0, 10),
-            changelog,
-            lastChecked: new Date().toISOString(),
-        };
-        this.cache.set(repoKey, info);
-        return info;
-    }
-    /**
-     * Get breaking changes since a specific version
-     */
-    async getBreakingChangesSince(owner, repo, sinceVersion) {
-        const info = await this.getVersionInfo(owner, repo);
-        const breakingChanges = [];
-        for (const entry of info.changelog) {
-            // Stop if we've reached the version they're using
-            if (entry.version === sinceVersion)
-                break;
-            breakingChanges.push(...entry.changes.breaking);
-        }
-        return breakingChanges;
-    }
-    /**
-     * Check if a version is outdated
-     */
-    async isOutdated(owner, repo, currentVersion) {
-        const info = await this.getVersionInfo(owner, repo);
-        const latestVersion = info.latestStableRelease?.tag || info.latestRelease?.tag || null;
-        if (!latestVersion) {
-            return {
-                isOutdated: false,
-                latestVersion: null,
-                versionsBehind: 0,
-                hasBreakingChanges: false,
-            };
-        }
-        const releaseIndex = info.recentReleases.findIndex((r) => r.tag === currentVersion);
-        const versionsBehind = releaseIndex === -1 ? info.recentReleases.length : releaseIndex;
-        const breakingChanges = await this.getBreakingChangesSince(owner, repo, currentVersion);
-        return {
-            isOutdated: currentVersion !== latestVersion,
-            latestVersion,
-            versionsBehind,
-            hasBreakingChanges: breakingChanges.length > 0,
-        };
-    }
-    /**
-     * Get migration guide between two versions
-     */
-    async getMigrationGuide(owner, repo, fromVersion, toVersion) {
-        const info = await this.getVersionInfo(owner, repo);
-        const to = toVersion ||
-            info.latestStableRelease?.tag ||
-            info.latestRelease?.tag ||
-            fromVersion;
-        const result = {
-            from: fromVersion,
-            to,
-            breakingChanges: [],
-            deprecations: [],
-            newFeatures: [],
-            migrationSteps: [],
-        };
-        let inRange = false;
-        for (const entry of [...info.changelog].reverse()) {
-            if (entry.version === fromVersion) {
-                inRange = true;
-                continue;
-            }
-            if (entry.version === to) {
-                result.breakingChanges.push(...entry.changes.breaking);
-                result.deprecations.push(...entry.changes.deprecations);
-                result.newFeatures.push(...entry.changes.features);
-                break;
-            }
-            if (inRange) {
-                result.breakingChanges.push(...entry.changes.breaking);
-                result.deprecations.push(...entry.changes.deprecations);
-                result.newFeatures.push(...entry.changes.features);
-            }
-        }
-        // Generate migration steps from breaking changes
-        result.migrationSteps = result.breakingChanges.map((change) => `Review and update: ${change}`);
-        return result;
-    }
-    /**
-     * Get version-specific documentation hints
-     */
-    getVersionContext(versionInfo) {
-        const parts = [];
-        if (versionInfo.latestRelease) {
-            parts.push(`Latest version: ${versionInfo.latestRelease.tag} (${versionInfo.latestRelease.publishedAt.split("T")[0]})`);
-        }
-        if (versionInfo.latestStableRelease &&
-            versionInfo.latestStableRelease !== versionInfo.latestRelease) {
-            parts.push(`Latest stable: ${versionInfo.latestStableRelease.tag}`);
-        }
-        const recentBreaking = versionInfo.changelog
-            .slice(0, 3)
-            .flatMap((c) => c.changes.breaking);
-        if (recentBreaking.length > 0) {
-            parts.push(`Recent breaking changes:\n${recentBreaking.map((b) => `  - ${b}`).join("\n")}`);
-        }
-        return parts.join("\n");
-    }
-    /**
-     * Fetch a file at a specific version/tag
-     * This is critical for ensuring code recommendations match the user's version
-     */
-    async getFileAtVersion(owner, repo, filePath, version) {
-        try {
-            const { data } = await this.octokit.rest.repos.getContent({
-                owner,
-                repo,
-                path: filePath,
-                ref: version, // Can be a tag like "v1.0.0" or branch
-            });
-            if (Array.isArray(data) || data.type !== "file") {
-                return null;
-            }
-            const content = data.encoding === "base64"
-                ? Buffer.from(data.content, "base64").toString("utf-8")
-                : data.content;
-            return { content, version };
-        }
-        catch (error) {
-            logger.warn(`Failed to fetch ${filePath} at ${version} from ${owner}/${repo}`, {
-                error: String(error),
-            });
-            return null;
-        }
-    }
-    /**
-     * Compare syntax between two versions of a file
-     * Useful for showing what changed in API/syntax
-     */
-    async compareSyntax(owner, repo, filePath, oldVersion, newVersion) {
-        const [oldFile, newFile] = await Promise.all([
-            this.getFileAtVersion(owner, repo, filePath, oldVersion),
-            this.getFileAtVersion(owner, repo, filePath, newVersion),
-        ]);
-        return {
-            oldVersion,
-            newVersion,
-            oldContent: oldFile?.content || null,
-            newContent: newFile?.content || null,
-            hasDifferences: oldFile?.content !== newFile?.content,
-        };
-    }
-    /**
-     * Get the grammar/syntax reference files at the latest version
-     * These are the source of truth for valid Compact syntax
-     */
-    async getLatestSyntaxReference(owner, repo) {
-        const versionInfo = await this.getVersionInfo(owner, repo);
-        const version = versionInfo.latestStableRelease?.tag ||
-            versionInfo.latestRelease?.tag ||
-            "main";
-        // Key files that define Compact syntax
-        const syntaxFilePaths = [
-            "docs/grammar.md",
-            "docs/syntax.md",
-            "docs/reference.md",
-            "src/grammar.ts",
-            "grammar/compact.grammar",
-            "README.md",
-        ];
-        const syntaxFiles = [];
-        for (const path of syntaxFilePaths) {
-            const file = await this.getFileAtVersion(owner, repo, path, version);
-            if (file) {
-                syntaxFiles.push({ path, content: file.content });
-            }
-        }
-        if (syntaxFiles.length === 0) {
-            return null;
-        }
-        return { version, syntaxFiles };
-    }
-}
-export const releaseTracker = new ReleaseTracker();
-//# sourceMappingURL=releases.js.map

package/dist/pipeline/repository.d.ts

@@ -1,372 +0,0 @@
-import { z } from "zod";
-export declare const GetFileInputSchema: z.ZodObject<{
-    repo: z.ZodString;
-    path: z.ZodString;
-    ref: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    repo: string;
-    ref?: string | undefined;
-}, {
-    path: string;
-    repo: string;
-    ref?: string | undefined;
-}>;
-export declare const ListExamplesInputSchema: z.ZodObject<{
-    category: z.ZodDefault<z.ZodOptional<z.ZodEnum<["counter", "bboard", "token", "voting", "all"]>>>;
-}, "strip", z.ZodTypeAny, {
-    category: "all" | "counter" | "bboard" | "token" | "voting";
-}, {
-    category?: "all" | "counter" | "bboard" | "token" | "voting" | undefined;
-}>;
-export declare const GetLatestUpdatesInputSchema: z.ZodObject<{
-    since: z.ZodOptional<z.ZodString>;
-    repos: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    repos?: string[] | undefined;
-    since?: string | undefined;
-}, {
-    repos?: string[] | undefined;
-    since?: string | undefined;
-}>;
-export declare const GetVersionInfoInputSchema: z.ZodObject<{
-    repo: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    repo: string;
-}, {
-    repo: string;
-}>;
-export declare const CheckBreakingChangesInputSchema: z.ZodObject<{
-    repo: z.ZodString;
-    currentVersion: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    repo: string;
-    currentVersion: string;
-}, {
-    repo: string;
-    currentVersion: string;
-}>;
-export declare const GetMigrationGuideInputSchema: z.ZodObject<{
-    repo: z.ZodString;
-    fromVersion: z.ZodString;
-    toVersion: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    repo: string;
-    fromVersion: string;
-    toVersion?: string | undefined;
-}, {
-    repo: string;
-    fromVersion: string;
-    toVersion?: string | undefined;
-}>;
-export type GetFileInput = z.infer<typeof GetFileInputSchema>;
-export type ListExamplesInput = z.infer<typeof ListExamplesInputSchema>;
-export type GetLatestUpdatesInput = z.infer<typeof GetLatestUpdatesInputSchema>;
-export type GetVersionInfoInput = z.infer<typeof GetVersionInfoInputSchema>;
-export type CheckBreakingChangesInput = z.infer<typeof CheckBreakingChangesInputSchema>;
-export type GetMigrationGuideInput = z.infer<typeof GetMigrationGuideInputSchema>;
-/**
- * Retrieve a specific file from Midnight repositories
- */
-export declare function getFile(input: GetFileInput): Promise<{
-    error: string;
-    suggestion: string;
-    repository?: undefined;
-    content?: undefined;
-    path?: undefined;
-    sha?: undefined;
-    size?: undefined;
-    url?: undefined;
-} | {
-    error: string;
-    repository: string;
-    suggestion: string;
-    content?: undefined;
-    path?: undefined;
-    sha?: undefined;
-    size?: undefined;
-    url?: undefined;
-} | {
-    content: string;
-    path: string;
-    repository: string;
-    sha: string;
-    size: number;
-    url: string;
-    error?: undefined;
-    suggestion?: undefined;
-}>;
-/**
- * List available example contracts and DApps
- */
-export declare function listExamples(input: ListExamplesInput): Promise<{
-    examples: {
-        name: string;
-        repository: string;
-        description: string;
-        complexity: "beginner" | "intermediate" | "advanced";
-        mainFile: string;
-        features: string[];
-        githubUrl: string;
-    }[];
-    totalCount: number;
-    categories: string[];
-}>;
-/**
- * Retrieve recent changes across Midnight repositories
- */
-export declare function getLatestUpdates(input: GetLatestUpdatesInput): Promise<{
-    summary: {
-        since: string;
-        totalCommits: number;
-        activeRepositories: number;
-        checkedRepositories: number;
-    };
-    updates: {
-        repository: string;
-        commitCount: number;
-        latestCommit: {
-            message: string;
-            date: string;
-            author: string;
-            url: string;
-        } | null;
-        recentCommits: {
-            message: string;
-            date: string;
-            sha: string;
-        }[];
-    }[];
-}>;
-/**
- * Get version and release info for a repository
- */
-export declare function getVersionInfo(input: GetVersionInfoInput): Promise<{
-    note: string;
-    examples: ({
-        name: string;
-        repository: string;
-        latestVersion: string;
-        publishedAt: string | null;
-    } | null)[];
-    availableExamples: {
-        name: string;
-        repository: string;
-        description: string;
-        complexity: "beginner" | "intermediate" | "advanced";
-    }[];
-    hint: string;
-    repository?: undefined;
-    latestVersion?: undefined;
-    latestStableVersion?: undefined;
-    publishedAt?: undefined;
-    releaseNotes?: undefined;
-    recentReleases?: undefined;
-    recentBreakingChanges?: undefined;
-    versionContext?: undefined;
-} | {
-    repository: string;
-    latestVersion: string;
-    latestStableVersion: string;
-    publishedAt: string | null;
-    releaseNotes: string | null;
-    recentReleases: {
-        version: string;
-        date: string;
-        isPrerelease: boolean;
-        url: string;
-    }[];
-    recentBreakingChanges: string[];
-    versionContext: string;
-    note?: undefined;
-    examples?: undefined;
-    availableExamples?: undefined;
-    hint?: undefined;
-}>;
-/**
- * Check for breaking changes since a specific version
- */
-export declare function checkBreakingChanges(input: CheckBreakingChangesInput): Promise<{
-    repository: string;
-    currentVersion: string;
-    latestVersion: string | null;
-    isOutdated: boolean;
-    versionsBehind: number;
-    hasBreakingChanges: boolean;
-    breakingChanges: string[];
-    recommendation: string;
-}>;
-/**
- * Get migration guide between versions
- */
-export declare function getMigrationGuide(input: GetMigrationGuideInput): Promise<{
-    repository: string;
-    from: string;
-    to: string;
-    summary: {
-        breakingChangesCount: number;
-        deprecationsCount: number;
-        newFeaturesCount: number;
-    };
-    breakingChanges: string[];
-    deprecations: string[];
-    newFeatures: string[];
-    migrationSteps: string[];
-    migrationDifficulty: string;
-}>;
-export declare const repositoryTools: ({
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            repo: {
-                type: string;
-                description: string;
-            };
-            path: {
-                type: string;
-                description: string;
-            };
-            ref: {
-                type: string;
-                description: string;
-            };
-            category?: undefined;
-            since?: undefined;
-            repos?: undefined;
-            currentVersion?: undefined;
-            fromVersion?: undefined;
-            toVersion?: undefined;
-        };
-        required: string[];
-    };
-    handler: typeof getFile;
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            category: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            repo?: undefined;
-            path?: undefined;
-            ref?: undefined;
-            since?: undefined;
-            repos?: undefined;
-            currentVersion?: undefined;
-            fromVersion?: undefined;
-            toVersion?: undefined;
-        };
-        required: never[];
-    };
-    handler: typeof listExamples;
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            since: {
-                type: string;
-                description: string;
-            };
-            repos: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-            repo?: undefined;
-            path?: undefined;
-            ref?: undefined;
-            category?: undefined;
-            currentVersion?: undefined;
-            fromVersion?: undefined;
-            toVersion?: undefined;
-        };
-        required: never[];
-    };
-    handler: typeof getLatestUpdates;
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            repo: {
-                type: string;
-                description: string;
-            };
-            path?: undefined;
-            ref?: undefined;
-            category?: undefined;
-            since?: undefined;
-            repos?: undefined;
-            currentVersion?: undefined;
-            fromVersion?: undefined;
-            toVersion?: undefined;
-        };
-        required: string[];
-    };
-    handler: typeof getVersionInfo;
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            repo: {
-                type: string;
-                description: string;
-            };
-            currentVersion: {
-                type: string;
-                description: string;
-            };
-            path?: undefined;
-            ref?: undefined;
-            category?: undefined;
-            since?: undefined;
-            repos?: undefined;
-            fromVersion?: undefined;
-            toVersion?: undefined;
-        };
-        required: string[];
-    };
-    handler: typeof checkBreakingChanges;
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            repo: {
-                type: string;
-                description: string;
-            };
-            fromVersion: {
-                type: string;
-                description: string;
-            };
-            toVersion: {
-                type: string;
-                description: string;
-            };
-            path?: undefined;
-            ref?: undefined;
-            category?: undefined;
-            since?: undefined;
-            repos?: undefined;
-            currentVersion?: undefined;
-        };
-        required: string[];
-    };
-    handler: typeof getMigrationGuide;
-})[];
-//# sourceMappingURL=repository.d.ts.map