midnight-mcp 0.1.40 → 0.2.1

package/dist/pipeline/parser.js

@@ -1,436 +0,0 @@
-import { logger } from "../utils/index.js";
-/**
- * Parse Compact smart contract files
- */
-export function parseCompactFile(path, content) {
-    const lines = content.split("\n");
-    const codeUnits = [];
-    const imports = [];
-    const exports = [];
-    let hasLedger = false;
-    let hasCircuits = false;
-    let hasWitnesses = false;
-    // Extract imports
-    const importRegex = /^include\s+["']([^"']+)["'];?/gm;
-    let importMatch;
-    while ((importMatch = importRegex.exec(content)) !== null) {
-        imports.push(importMatch[1]);
-    }
-    // Parse ledger block
-    const ledgerRegex = /ledger\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gs;
-    let ledgerMatch;
-    while ((ledgerMatch = ledgerRegex.exec(content)) !== null) {
-        hasLedger = true;
-        const ledgerContent = ledgerMatch[1];
-        const startLine = content.substring(0, ledgerMatch.index).split("\n").length;
-        const endLine = startLine + ledgerMatch[0].split("\n").length - 1;
-        codeUnits.push({
-            type: "ledger",
-            name: "ledger",
-            code: ledgerMatch[0],
-            startLine,
-            endLine,
-            isPublic: true,
-            isPrivate: false,
-        });
-        // Parse individual ledger fields
-        const fieldRegex = /(@private\s+)?(\w+)\s*:\s*([^;]+);/g;
-        let fieldMatch;
-        while ((fieldMatch = fieldRegex.exec(ledgerContent)) !== null) {
-            const isPrivate = !!fieldMatch[1];
-            codeUnits.push({
-                type: "ledger",
-                name: fieldMatch[2],
-                code: fieldMatch[0].trim(),
-                startLine: startLine,
-                endLine: startLine,
-                isPublic: !isPrivate,
-                isPrivate,
-                returnType: fieldMatch[3].trim(),
-            });
-        }
-    }
-    // Parse circuit definitions
-    const circuitRegex = /(export\s+)?circuit\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*(\w+))?\s*\{/g;
-    let circuitMatch;
-    while ((circuitMatch = circuitRegex.exec(content)) !== null) {
-        hasCircuits = true;
-        const isExport = !!circuitMatch[1];
-        const name = circuitMatch[2];
-        const params = circuitMatch[3];
-        const returnType = circuitMatch[4] || "Void";
-        // Find the matching closing brace
-        const startIndex = circuitMatch.index;
-        let braceCount = 1;
-        let endIndex = content.indexOf("{", startIndex) + 1;
-        while (braceCount > 0 && endIndex < content.length) {
-            if (content[endIndex] === "{")
-                braceCount++;
-            if (content[endIndex] === "}")
-                braceCount--;
-            endIndex++;
-        }
-        const circuitCode = content.substring(startIndex, endIndex);
-        const startLine = content.substring(0, startIndex).split("\n").length;
-        const endLine = startLine + circuitCode.split("\n").length - 1;
-        // Parse parameters
-        const parameters = params
-            .split(",")
-            .filter((p) => p.trim())
-            .map((p) => {
-            const parts = p.trim().split(":");
-            return {
-                name: parts[0]?.trim() || "",
-                type: parts[1]?.trim() || "unknown",
-            };
-        });
-        if (isExport) {
-            exports.push(name);
-        }
-        codeUnits.push({
-            type: "circuit",
-            name,
-            code: circuitCode,
-            startLine,
-            endLine,
-            isPublic: isExport,
-            isPrivate: false,
-            parameters,
-            returnType,
-        });
-    }
-    // Parse witness functions
-    const witnessRegex = /witness\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*([^{]+))?\s*\{/g;
-    let witnessMatch;
-    while ((witnessMatch = witnessRegex.exec(content)) !== null) {
-        hasWitnesses = true;
-        const name = witnessMatch[1];
-        const params = witnessMatch[2];
-        const returnType = witnessMatch[3]?.trim() || "unknown";
-        // Find the matching closing brace
-        const startIndex = witnessMatch.index;
-        let braceCount = 1;
-        let endIndex = content.indexOf("{", startIndex) + 1;
-        while (braceCount > 0 && endIndex < content.length) {
-            if (content[endIndex] === "{")
-                braceCount++;
-            if (content[endIndex] === "}")
-                braceCount--;
-            endIndex++;
-        }
-        const witnessCode = content.substring(startIndex, endIndex);
-        const startLine = content.substring(0, startIndex).split("\n").length;
-        const endLine = startLine + witnessCode.split("\n").length - 1;
-        // Parse parameters
-        const parameters = params
-            .split(",")
-            .filter((p) => p.trim())
-            .map((p) => {
-            const parts = p.trim().split(":");
-            return {
-                name: parts[0]?.trim() || "",
-                type: parts[1]?.trim() || "unknown",
-            };
-        });
-        codeUnits.push({
-            type: "witness",
-            name,
-            code: witnessCode,
-            startLine,
-            endLine,
-            isPublic: false,
-            isPrivate: true,
-            parameters,
-            returnType,
-        });
-    }
-    // Parse type definitions
-    const typeRegex = /(export\s+)?type\s+(\w+)\s*=\s*([^;]+);/g;
-    let typeMatch;
-    while ((typeMatch = typeRegex.exec(content)) !== null) {
-        const isExport = !!typeMatch[1];
-        const name = typeMatch[2];
-        const startLine = content.substring(0, typeMatch.index).split("\n").length;
-        if (isExport) {
-            exports.push(name);
-        }
-        codeUnits.push({
-            type: "type",
-            name,
-            code: typeMatch[0],
-            startLine,
-            endLine: startLine,
-            isPublic: isExport,
-            isPrivate: false,
-            returnType: typeMatch[3].trim(),
-        });
-    }
-    return {
-        path,
-        language: "compact",
-        content,
-        codeUnits,
-        imports,
-        exports,
-        metadata: {
-            hasLedger,
-            hasCircuits,
-            hasWitnesses,
-            lineCount: lines.length,
-        },
-    };
-}
-/**
- * Parse TypeScript files
- */
-export function parseTypeScriptFile(path, content) {
-    const lines = content.split("\n");
-    const codeUnits = [];
-    const imports = [];
-    const exports = [];
-    // Extract imports
-    const importRegex = /import\s+(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+["']([^"']+)["']/g;
-    let importMatch;
-    while ((importMatch = importRegex.exec(content)) !== null) {
-        imports.push(importMatch[1]);
-    }
-    // Parse function declarations
-    const functionRegex = /(export\s+)?(async\s+)?function\s+(\w+)\s*(?:<[^>]+>)?\s*\(([^)]*)\)\s*(?::\s*([^{]+))?\s*\{/g;
-    let funcMatch;
-    while ((funcMatch = functionRegex.exec(content)) !== null) {
-        const isExport = !!funcMatch[1];
-        const isAsync = !!funcMatch[2];
-        const name = funcMatch[3];
-        const params = funcMatch[4];
-        const returnType = funcMatch[5]?.trim() || (isAsync ? "Promise<void>" : "void");
-        // Find the matching closing brace
-        const startIndex = funcMatch.index;
-        let braceCount = 1;
-        let endIndex = content.indexOf("{", startIndex) + 1;
-        while (braceCount > 0 && endIndex < content.length) {
-            if (content[endIndex] === "{")
-                braceCount++;
-            if (content[endIndex] === "}")
-                braceCount--;
-            endIndex++;
-        }
-        const funcCode = content.substring(startIndex, endIndex);
-        const startLine = content.substring(0, startIndex).split("\n").length;
-        const endLine = startLine + funcCode.split("\n").length - 1;
-        // Parse parameters
-        const parameters = params
-            .split(",")
-            .filter((p) => p.trim())
-            .map((p) => {
-            const parts = p.trim().split(":");
-            return {
-                name: parts[0]?.trim().replace(/\?$/, "") || "",
-                type: parts[1]?.trim() || "any",
-            };
-        });
-        if (isExport) {
-            exports.push(name);
-        }
-        codeUnits.push({
-            type: "function",
-            name,
-            code: funcCode,
-            startLine,
-            endLine,
-            isPublic: isExport,
-            isPrivate: false,
-            parameters,
-            returnType,
-        });
-    }
-    // Parse class declarations
-    const classRegex = /(export\s+)?(abstract\s+)?class\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[^{]+)?\s*\{/g;
-    let classMatch;
-    while ((classMatch = classRegex.exec(content)) !== null) {
-        const isExport = !!classMatch[1];
-        const isAbstract = !!classMatch[2];
-        const name = classMatch[3];
-        // Find the matching closing brace
-        const startIndex = classMatch.index;
-        let braceCount = 1;
-        let endIndex = content.indexOf("{", startIndex) + 1;
-        while (braceCount > 0 && endIndex < content.length) {
-            if (content[endIndex] === "{")
-                braceCount++;
-            if (content[endIndex] === "}")
-                braceCount--;
-            endIndex++;
-        }
-        const classCode = content.substring(startIndex, endIndex);
-        const startLine = content.substring(0, startIndex).split("\n").length;
-        const endLine = startLine + classCode.split("\n").length - 1;
-        if (isExport) {
-            exports.push(name);
-        }
-        codeUnits.push({
-            type: "class",
-            name,
-            code: classCode,
-            startLine,
-            endLine,
-            isPublic: isExport,
-            isPrivate: false,
-            documentation: isAbstract ? "abstract class" : undefined,
-        });
-    }
-    // Parse interface declarations
-    const interfaceRegex = /(export\s+)?interface\s+(\w+)(?:\s+extends\s+[^{]+)?\s*\{/g;
-    let ifaceMatch;
-    while ((ifaceMatch = interfaceRegex.exec(content)) !== null) {
-        const isExport = !!ifaceMatch[1];
-        const name = ifaceMatch[2];
-        // Find the matching closing brace
-        const startIndex = ifaceMatch.index;
-        let braceCount = 1;
-        let endIndex = content.indexOf("{", startIndex) + 1;
-        while (braceCount > 0 && endIndex < content.length) {
-            if (content[endIndex] === "{")
-                braceCount++;
-            if (content[endIndex] === "}")
-                braceCount--;
-            endIndex++;
-        }
-        const ifaceCode = content.substring(startIndex, endIndex);
-        const startLine = content.substring(0, startIndex).split("\n").length;
-        const endLine = startLine + ifaceCode.split("\n").length - 1;
-        if (isExport) {
-            exports.push(name);
-        }
-        codeUnits.push({
-            type: "interface",
-            name,
-            code: ifaceCode,
-            startLine,
-            endLine,
-            isPublic: isExport,
-            isPrivate: false,
-        });
-    }
-    // Parse type definitions
-    const typeRegex = /(export\s+)?type\s+(\w+)(?:<[^>]+>)?\s*=\s*([^;]+);/g;
-    let typeMatch;
-    while ((typeMatch = typeRegex.exec(content)) !== null) {
-        const isExport = !!typeMatch[1];
-        const name = typeMatch[2];
-        const startLine = content.substring(0, typeMatch.index).split("\n").length;
-        if (isExport) {
-            exports.push(name);
-        }
-        codeUnits.push({
-            type: "type",
-            name,
-            code: typeMatch[0],
-            startLine,
-            endLine: startLine,
-            isPublic: isExport,
-            isPrivate: false,
-            returnType: typeMatch[3].trim(),
-        });
-    }
-    return {
-        path,
-        language: "typescript",
-        content,
-        codeUnits,
-        imports,
-        exports,
-        metadata: {
-            hasLedger: false,
-            hasCircuits: false,
-            hasWitnesses: false,
-            lineCount: lines.length,
-        },
-    };
-}
-/**
- * Parse Markdown documentation files
- */
-export function parseMarkdownFile(path, content) {
-    const lines = content.split("\n");
-    const codeUnits = [];
-    // Parse headings as sections
-    const headingRegex = /^(#{1,6})\s+(.+)$/gm;
-    let headingMatch;
-    const headings = [];
-    while ((headingMatch = headingRegex.exec(content)) !== null) {
-        headings.push({
-            level: headingMatch[1].length,
-            title: headingMatch[2],
-            index: headingMatch.index,
-        });
-    }
-    // Create sections between headings
-    for (let i = 0; i < headings.length; i++) {
-        const heading = headings[i];
-        const nextHeading = headings[i + 1];
-        const startIndex = heading.index;
-        const endIndex = nextHeading ? nextHeading.index : content.length;
-        const sectionContent = content.substring(startIndex, endIndex).trim();
-        const startLine = content.substring(0, startIndex).split("\n").length;
-        const endLine = startLine + sectionContent.split("\n").length - 1;
-        codeUnits.push({
-            type: "function", // Using function type for documentation sections
-            name: heading.title.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase(),
-            code: sectionContent,
-            startLine,
-            endLine,
-            isPublic: true,
-            isPrivate: false,
-            documentation: heading.title,
-        });
-    }
-    return {
-        path,
-        language: "markdown",
-        content,
-        codeUnits,
-        imports: [],
-        exports: [],
-        metadata: {
-            hasLedger: false,
-            hasCircuits: false,
-            hasWitnesses: false,
-            lineCount: lines.length,
-        },
-    };
-}
-/**
- * Parse a file based on its extension
- */
-export function parseFile(path, content) {
-    const extension = path.split(".").pop()?.toLowerCase();
-    switch (extension) {
-        case "compact":
-            return parseCompactFile(path, content);
-        case "ts":
-        case "tsx":
-        case "js":
-        case "jsx":
-            return parseTypeScriptFile(path, content);
-        case "md":
-        case "mdx":
-            return parseMarkdownFile(path, content);
-        default:
-            logger.warn(`Unknown file extension: ${extension} for ${path}`);
-            return {
-                path,
-                language: "typescript",
-                content,
-                codeUnits: [],
-                imports: [],
-                exports: [],
-                metadata: {
-                    hasLedger: false,
-                    hasCircuits: false,
-                    hasWitnesses: false,
-                    lineCount: content.split("\n").length,
-                },
-            };
-    }
-}
-//# sourceMappingURL=parser.js.map

package/dist/pipeline/releases.d.ts

@@ -1,112 +0,0 @@
-export interface Release {
-    tag: string;
-    name: string;
-    body: string;
-    publishedAt: string;
-    url: string;
-    isPrerelease: boolean;
-    assets: Array<{
-        name: string;
-        downloadUrl: string;
-    }>;
-}
-export interface ChangelogEntry {
-    version: string;
-    date: string;
-    changes: {
-        breaking: string[];
-        features: string[];
-        fixes: string[];
-        deprecations: string[];
-    };
-    rawBody: string;
-}
-export interface VersionInfo {
-    repository: string;
-    latestRelease: Release | null;
-    latestStableRelease: Release | null;
-    recentReleases: Release[];
-    changelog: ChangelogEntry[];
-    lastChecked: string;
-}
-/**
- * Fetches and tracks releases from GitHub repositories
- */
-export declare class ReleaseTracker {
-    private octokit;
-    private cache;
-    private cacheMaxAge;
-    constructor(token?: string);
-    /**
-     * Get all releases for a repository
-     */
-    getReleases(owner: string, repo: string, limit?: number): Promise<Release[]>;
-    /**
-     * Parse a release body to extract structured changelog info
-     */
-    parseChangelog(releaseBody: string, version: string, date: string): ChangelogEntry;
-    /**
-     * Get version info for a repository with caching
-     */
-    getVersionInfo(owner: string, repo: string): Promise<VersionInfo>;
-    /**
-     * Get breaking changes since a specific version
-     */
-    getBreakingChangesSince(owner: string, repo: string, sinceVersion: string): Promise<string[]>;
-    /**
-     * Check if a version is outdated
-     */
-    isOutdated(owner: string, repo: string, currentVersion: string): Promise<{
-        isOutdated: boolean;
-        latestVersion: string | null;
-        versionsBehind: number;
-        hasBreakingChanges: boolean;
-    }>;
-    /**
-     * Get migration guide between two versions
-     */
-    getMigrationGuide(owner: string, repo: string, fromVersion: string, toVersion?: string): Promise<{
-        from: string;
-        to: string;
-        breakingChanges: string[];
-        deprecations: string[];
-        newFeatures: string[];
-        migrationSteps: string[];
-    }>;
-    /**
-     * Get version-specific documentation hints
-     */
-    getVersionContext(versionInfo: VersionInfo): string;
-    /**
-     * Fetch a file at a specific version/tag
-     * This is critical for ensuring code recommendations match the user's version
-     */
-    getFileAtVersion(owner: string, repo: string, filePath: string, version: string): Promise<{
-        content: string;
-        version: string;
-    } | null>;
-    /**
-     * Compare syntax between two versions of a file
-     * Useful for showing what changed in API/syntax
-     */
-    compareSyntax(owner: string, repo: string, filePath: string, oldVersion: string, newVersion: string): Promise<{
-        oldVersion: string;
-        newVersion: string;
-        oldContent: string | null;
-        newContent: string | null;
-        hasDifferences: boolean;
-    }>;
-    /**
-     * Get the grammar/syntax reference files at the latest version
-     * These are the source of truth for valid Compact syntax
-     */
-    getLatestSyntaxReference(owner: string, repo: string): Promise<{
-        version: string;
-        syntaxFiles: Array<{
-            path: string;
-            content: string;
-        }>;
-    } | null>;
-}
-export declare const releaseTracker: ReleaseTracker;
-//# sourceMappingURL=releases.d.ts.map