@ceraph/react-native-mcp 0.3.2 → 0.4.5

package/dist/error-parser.js

@@ -1,275 +0,0 @@
-const XCODE_ERROR_RE = /^(.+?):(\d+):(\d+):\s*(error|warning|note):\s*(.+)$/;
-const BUILD_FAILED_MARKERS = [
-    "Build Failed",
-    "** BUILD FAILED **",
-    "xcodebuild: error:",
-    "❌",
-];
-const LINKER_ERROR_RE = /^(ld|clang):\s*(error|warning):\s*(.+)$/;
-const UNDEFINED_SYMBOL_RE = /^Undefined symbols? for architecture .+:\s*"(.+)"/;
-const POD_ERROR_RE = /^\[!\]\s*(.+)$/;
-const METRO_ERROR_RE = /^(Error|TypeError|ReferenceError|SyntaxError|RangeError):\s*(.+)$/;
-const METRO_MODULE_RE = /Unable to resolve module ['"](.+?)['"]/;
-const METRO_ENCOUNTERED_RE = /Metro has encountered an error/;
-const CONSOLE_ERROR_RE = /^(ERROR|console\.error)\s*(.+)$/i;
-const INVARIANT_RE = /Invariant Violation:\s*(.+)/;
-const UNHANDLED_JS_RE = /Unhandled JS Exception:\s*(.+)/;
-const RED_SCREEN_RE = /ExceptionsManager\.js/;
-function parseXcodeLine(line) {
-    const match = line.match(XCODE_ERROR_RE);
-    if (match) {
-        return {
-            file: match[1],
-            line: parseInt(match[2], 10),
-            column: parseInt(match[3], 10),
-            message: match[5],
-            severity: match[4],
-            type: "build",
-        };
-    }
-    return null;
-}
-function parseLinkerLine(line) {
-    const linkerMatch = line.match(LINKER_ERROR_RE);
-    if (linkerMatch) {
-        return {
-            file: "",
-            line: 0,
-            column: 0,
-            message: linkerMatch[3],
-            severity: linkerMatch[2],
-            type: "link",
-        };
-    }
-    const undefinedMatch = line.match(UNDEFINED_SYMBOL_RE);
-    if (undefinedMatch) {
-        return {
-            file: "",
-            line: 0,
-            column: 0,
-            message: `Undefined symbol: ${undefinedMatch[1]}`,
-            severity: "error",
-            type: "link",
-        };
-    }
-    return null;
-}
-const POD_SAFE_WARNING_RE = /\b(cdn|trunk|repo update|overrides the|setting defined in|deprecated|recommends|should)\b/i;
-function parsePodLine(line) {
-    const match = line.match(POD_ERROR_RE);
-    if (!match)
-        return null;
-    const message = match[1];
-    const isSafeWarning = POD_SAFE_WARNING_RE.test(message);
-    return {
-        file: "Podfile",
-        line: 0,
-        column: 0,
-        message,
-        severity: isSafeWarning ? "warning" : "error",
-        type: "pod",
-    };
-}
-export function parseBuildOutput(lines) {
-    const errors = [];
-    const warnings = [];
-    let buildFailed = false;
-    let lastError = null;
-    let contextLines = 0;
-    const MAX_CONTEXT = 3;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            lastError = null;
-            contextLines = 0;
-            continue;
-        }
-        if (BUILD_FAILED_MARKERS.some((m) => trimmed.includes(m))) {
-            buildFailed = true;
-        }
-        const xcodeError = parseXcodeLine(trimmed);
-        if (xcodeError) {
-            if (xcodeError.severity === "error") {
-                errors.push(xcodeError);
-                lastError = xcodeError;
-                contextLines = 0;
-            }
-            else {
-                warnings.push({
-                    message: xcodeError.message,
-                    source: `${xcodeError.file}:${xcodeError.line}:${xcodeError.column}`,
-                });
-            }
-            continue;
-        }
-        const linkerError = parseLinkerLine(trimmed);
-        if (linkerError) {
-            if (linkerError.severity === "warning") {
-                warnings.push({ message: linkerError.message, source: "linker" });
-            }
-            else {
-                errors.push(linkerError);
-            }
-            lastError = linkerError;
-            contextLines = 0;
-            continue;
-        }
-        const podNotice = parsePodLine(trimmed);
-        if (podNotice) {
-            if (podNotice.severity === "warning") {
-                warnings.push({ message: podNotice.message, source: "CocoaPods" });
-            }
-            else {
-                errors.push(podNotice);
-                lastError = podNotice;
-                contextLines = 0;
-            }
-            continue;
-        }
-        if (lastError && contextLines < MAX_CONTEXT) {
-            lastError.message += `\n${trimmed}`;
-            contextLines++;
-        }
-    }
-    return { errors, warnings, buildFailed };
-}
-export class MetroErrorParser {
-    currentStack = [];
-    currentErrorMessage = "";
-    inStackTrace = false;
-    parse(lines) {
-        const runtimeErrors = [];
-        const warnings = [];
-        const flushInto = (sink) => {
-            if (this.currentErrorMessage) {
-                sink.push({
-                    message: this.currentErrorMessage,
-                    stack: this.currentStack.join("\n"),
-                    timestamp: new Date().toISOString(),
-                    kind: "metro-error",
-                });
-                this.currentErrorMessage = "";
-                this.currentStack = [];
-                this.inStackTrace = false;
-            }
-        };
-        for (const line of lines) {
-            const trimmed = line.trim();
-            const moduleMatch = trimmed.match(METRO_MODULE_RE);
-            if (moduleMatch) {
-                flushInto(runtimeErrors);
-                runtimeErrors.push({
-                    message: `Unable to resolve module '${moduleMatch[1]}'`,
-                    stack: trimmed,
-                    timestamp: new Date().toISOString(),
-                    kind: "metro-error",
-                });
-                continue;
-            }
-            if (METRO_ENCOUNTERED_RE.test(trimmed)) {
-                flushInto(runtimeErrors);
-                this.currentErrorMessage = "Metro has encountered an error";
-                this.inStackTrace = true;
-                continue;
-            }
-            const invariantMatch = trimmed.match(INVARIANT_RE);
-            if (invariantMatch) {
-                flushInto(runtimeErrors);
-                this.currentErrorMessage = `Invariant Violation: ${invariantMatch[1]}`;
-                this.inStackTrace = true;
-                continue;
-            }
-            const unhandledMatch = trimmed.match(UNHANDLED_JS_RE);
-            if (unhandledMatch) {
-                flushInto(runtimeErrors);
-                this.currentErrorMessage = `Unhandled JS Exception: ${unhandledMatch[1]}`;
-                this.inStackTrace = true;
-                continue;
-            }
-            const metroMatch = trimmed.match(METRO_ERROR_RE);
-            if (metroMatch) {
-                flushInto(runtimeErrors);
-                this.currentErrorMessage = `${metroMatch[1]}: ${metroMatch[2]}`;
-                this.inStackTrace = true;
-                continue;
-            }
-            const consoleMatch = trimmed.match(CONSOLE_ERROR_RE);
-            if (consoleMatch) {
-                flushInto(runtimeErrors);
-                this.currentErrorMessage = consoleMatch[2];
-                this.inStackTrace = true;
-                continue;
-            }
-            if (RED_SCREEN_RE.test(trimmed)) {
-                if (!this.currentErrorMessage) {
-                    this.currentErrorMessage = "Red screen error detected";
-                }
-                this.inStackTrace = true;
-            }
-            if (this.inStackTrace) {
-                if (trimmed.startsWith("at ") ||
-                    trimmed.startsWith("in ") ||
-                    /^\s+at\s/.test(line) ||
-                    /^\d+\s*\|/.test(trimmed)) {
-                    this.currentStack.push(trimmed);
-                    continue;
-                }
-                else if (trimmed === "") {
-                    flushInto(runtimeErrors);
-                    continue;
-                }
-                else {
-                    this.currentStack.push(trimmed);
-                    continue;
-                }
-            }
-            if (/^warn\s/i.test(trimmed) || /\(WARN\)/.test(trimmed)) {
-                warnings.push({
-                    message: trimmed.replace(/^warn\s*/i, "").replace(/\(WARN\)\s*/, ""),
-                    source: "metro",
-                });
-            }
-        }
-        return { runtimeErrors, warnings };
-    }
-    flush() {
-        const runtimeErrors = [];
-        if (this.currentErrorMessage) {
-            runtimeErrors.push({
-                message: this.currentErrorMessage,
-                stack: this.currentStack.join("\n"),
-                timestamp: new Date().toISOString(),
-                kind: "metro-error",
-            });
-            this.currentErrorMessage = "";
-            this.currentStack = [];
-            this.inStackTrace = false;
-        }
-        return { runtimeErrors, warnings: [] };
-    }
-}
-export function parseMetroOutput(lines) {
-    const parser = new MetroErrorParser();
-    const streamed = parser.parse(lines);
-    const flushed = parser.flush();
-    return {
-        runtimeErrors: [...streamed.runtimeErrors, ...flushed.runtimeErrors],
-        warnings: [...streamed.warnings, ...flushed.warnings],
-    };
-}
-export function classifyLogLevel(line) {
-    const trimmed = line.trim().toLowerCase();
-    if (trimmed.startsWith("error") ||
-        trimmed.includes("console.error") ||
-        trimmed.startsWith("❌") ||
-        /^\s*error\s*:/i.test(line)) {
-        return "error";
-    }
-    if (trimmed.startsWith("warn") ||
-        trimmed.includes("console.warn") ||
-        trimmed.includes("(warn)") ||
-        /^\s*warning\s*:/i.test(line)) {
-        return "warn";
-    }
-    return "log";
-}

package/dist/expo-manager.d.ts

@@ -1,62 +0,0 @@
-import { type RuntimeError, type Warning, type AllErrors } from "./error-parser.js";
-export interface BuildResult {
-    success: boolean;
-    errors: Array<{
-        file: string;
-        line: number;
-        message: string;
-        type: "build" | "link" | "pod";
-    }>;
-    warnings: Warning[];
-    output: string;
-}
-interface RunBuildOptions {
-    clean?: boolean;
-    device?: string;
-}
-interface StartMetroOptions {
-    port?: number;
-    clear?: boolean;
-}
-interface ConsoleOptions {
-    lines?: number;
-    level?: "all" | "error" | "warn" | "log";
-}
-export declare class RNManager {
-    private buildProcess;
-    private metroProcess;
-    private buildKilled;
-    private metroKilled;
-    private buildOutput;
-    private metroOutput;
-    private buildErrors;
-    private runtimeErrors;
-    private buildWarnings;
-    private metroWarnings;
-    private metroParser;
-    private readonly MAX_BUILD_LINES;
-    private readonly MAX_METRO_LINES;
-    private readonly MAX_ERRORS;
-    private cwd;
-    private errorFilePath;
-    constructor(cwd: string);
-    detectProjectType(): Promise<boolean>;
-    private writeErrorFile;
-    appendShimSignal(entry: RuntimeError): Promise<void>;
-    private clearErrorFile;
-    private pushLine;
-    private capErrors;
-    private killProcess;
-    private runPrebuildClean;
-    runBuild(options?: RunBuildOptions): Promise<BuildResult>;
-    startMetro(options?: StartMetroOptions): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    getErrors(): AllErrors;
-    getConsole(options?: ConsoleOptions): string[];
-    stopAll(): Promise<string[]>;
-    getBuildOutput(): string[];
-    getMetroOutput(): string[];
-}
-export {};