minovative-mind-cli 2.5.2 → 2.6.1

package/dist/utils/localSyntaxValidator.js

@@ -1,103 +1,302 @@
 import path from 'path';
+/**
+ * Checks if file content contains placeholder comments indicating AI code truncation.
+ */
+function isTruncated(content) {
+    const lines = content.split('\n');
+    const truncPattern = '^(/\\/|/\\*)\\s*(\\.\\.\\.\\s*$|\\.\\.\\.\\s*\\*\\/$|\\[?\\s*\\.\\.\\.\\s*(existing\\s*code|rest\\s*of\\s*(the\\s*)?(file|code|content|implementation)|remaining|omitted|unchanged))';
+    const truncRegex = new RegExp(truncPattern, 'i');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (truncRegex.test(trimmed)) {
+            return true;
+        }
+    }
+    return false;
+}
 export function localValidate(filePath, content) {
     const ext = path.extname(filePath).toLowerCase();
-    // Check for truncation markers
-    if (content.includes('// ...') || content.includes('/* ... */')) {
+    // 1. Check JSON files using native JSON parser
+    if (ext === '.json') {
+        try {
+            JSON.parse(content);
+            return { isValid: true };
+        }
+        catch (err) {
+            return {
+                isValid: false,
+                error: 'Invalid JSON syntax: ' + err.message,
+            };
+        }
+    }
+    // 2. Check for truncation markers
+    if (isTruncated(content)) {
         return {
             isValid: false,
             error: 'File appears to be truncated (contains placeholder comments)',
         };
     }
-    // C-style languages
     const C_STYLE_EXTS = [
-        '.ts', '.js', '.tsx', '.jsx', '.json', '.css', '.html',
-        '.rs', '.go', '.java', '.cpp', '.c', '.h', '.cs', '.php', '.swift'
+        '.ts',
+        '.js',
+        '.tsx',
+        '.jsx',
+        '.css',
+        '.html',
+        '.rs',
+        '.go',
+        '.java',
+        '.cpp',
+        '.c',
+        '.h',
+        '.cs',
+        '.php',
+        '.swift',
     ];
-    // Hash-style languages (only validate [] and ())
     const HASH_STYLE_EXTS = ['.py', '.rb', '.sh', '.yaml', '.yml'];
-    if (C_STYLE_EXTS.includes(ext) || HASH_STYLE_EXTS.includes(ext)) {
-        const stack = [];
-        const pairs = {
-            '{': '}',
-            '[': ']',
-            '(': ')',
-        };
-        let inString = false;
-        let stringChar = '';
-        let inSingleComment = false;
-        let inMultiComment = false;
-        const isHashStyle = HASH_STYLE_EXTS.includes(ext);
-        for (let i = 0; i < content.length; i++) {
-            const char = content[i];
-            const nextChar = content[i + 1];
-            // Handle comments
-            if (!isHashStyle) {
-                if (!inString && !inMultiComment && char === '/' && nextChar === '/') {
-                    inSingleComment = true;
-                    continue;
-                }
-                if (inSingleComment && char === '\n') {
-                    inSingleComment = false;
-                    continue;
-                }
-                if (!inString && !inSingleComment && char === '/' && nextChar === '*') {
-                    inMultiComment = true;
-                    continue;
-                }
-                if (inMultiComment && char === '*' && nextChar === '/') {
-                    inMultiComment = false;
-                    i++; // skip '/'
-                    continue;
-                }
+    const isJsTs = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'].includes(ext);
+    const isCStyle = C_STYLE_EXTS.includes(ext);
+    const isHashStyle = HASH_STYLE_EXTS.includes(ext);
+    if (!isCStyle && !isHashStyle && !isJsTs) {
+        return { isValid: true };
+    }
+    const stack = [];
+    const pairs = {
+        '{': '}',
+        '[': ']',
+        '(': ')',
+        '${': '}',
+    };
+    let inSingleComment = false;
+    let inMultiComment = false;
+    let inString = false;
+    let stringChar = '';
+    let inTemplate = false;
+    let inRegex = false;
+    let inRegexCharClass = false;
+    // Track tokens to determine if '/' can start a regex literal
+    let lastToken = '';
+    let currentWord = '';
+    const EXPR_KEYWORDS = new Set([
+        'return',
+        'case',
+        'typeof',
+        'void',
+        'delete',
+        'yield',
+        'await',
+        'throw',
+        'instanceof',
+        'in',
+        'of',
+        'new',
+        'else',
+        'do',
+        'tok',
+    ]);
+    const EXPR_PUNCT = new Set([
+        '(',
+        '[',
+        '{',
+        ';',
+        ',',
+        '=',
+        '+',
+        '-',
+        '*',
+        '%',
+        '&',
+        '|',
+        '^',
+        '!',
+        '~',
+        '?',
+        ':',
+        '<',
+        '>',
+        '/',
+        '=>',
+        '${',
+    ]);
+    const wordCharRegex = new RegExp('[a-zA-Z0-9_$]');
+    const alphaRegex = new RegExp('[a-zA-Z]');
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        const nextChar = content[i + 1];
+        // --- 1. SINGLE LINE COMMENT ---
+        if (inSingleComment) {
+            if (char === '\n') {
+                inSingleComment = false;
             }
-            else {
-                // Hash-style comment: #
-                if (!inString && char === '#') {
-                    inSingleComment = true;
-                    continue;
-                }
-                if (inSingleComment && char === '\n') {
-                    inSingleComment = false;
-                    continue;
-                }
+            continue;
+        }
+        // --- 2. MULTI LINE COMMENT ---
+        if (inMultiComment) {
+            if (char === '*' && nextChar === '/') {
+                inMultiComment = false;
+                i++; // skip '/'
             }
-            // Handle strings
-            if (!inSingleComment && !inMultiComment) {
-                if ((char === '"' || char === "'" || char === '`') && content[i - 1] !== '\\') {
-                    if (!inString) {
-                        inString = true;
-                        stringChar = char;
-                    }
-                    else if (char === stringChar) {
-                        inString = false;
-                    }
-                }
+            continue;
+        }
+        // --- 3. STRING LITERAL ('...' or "...") ---
+        if (inString) {
+            if (char === '\\') {
+                i++; // skip escaped char
+                continue;
+            }
+            if (char === stringChar) {
+                inString = false;
+                stringChar = '';
             }
-            if (inString || inSingleComment || inMultiComment)
+            continue;
+        }
+        // --- 4. TEMPLATE LITERAL (`...`) ---
+        if (inTemplate) {
+            if (char === '\\') {
+                i++; // skip escaped char
+                continue;
+            }
+            if (char === '$' && nextChar === '{') {
+                // Enter template expression ${...}
+                stack.push('${');
+                inTemplate = false;
+                i++; // skip '{'
+                lastToken = '${';
+                currentWord = '';
                 continue;
-            if (['{', '[', '('].includes(char)) {
-                if (isHashStyle && char === '{')
-                    continue;
-                stack.push(char);
-            }
-            else if (['}', ']', ')'].includes(char)) {
-                if (isHashStyle && char === '}')
-                    continue;
-                const last = stack.pop();
-                if (!last || pairs[last] !== char) {
-                    return {
-                        isValid: false,
-                        error: `Unbalanced character '${char}' at position ${i}`,
-                    };
+            }
+            if (char === '`') {
+                inTemplate = false;
+            }
+            continue;
+        }
+        // --- 5. REGEX LITERAL (/.../) ---
+        if (inRegex) {
+            if (char === '\\') {
+                i++; // skip escaped char
+                continue;
+            }
+            if (char === '[') {
+                inRegexCharClass = true;
+                continue;
+            }
+            if (char === ']') {
+                inRegexCharClass = false;
+                continue;
+            }
+            if (char === '/' && !inRegexCharClass) {
+                inRegex = false;
+                // Skip regex flags (e.g. /foo/gim)
+                while (i + 1 < content.length && alphaRegex.test(content[i + 1])) {
+                    i++;
                 }
             }
+            continue;
         }
-        if (stack.length > 0) {
-            return {
-                isValid: false,
-                error: `Unclosed character '${stack[stack.length - 1]}'`,
-            };
+        // --- 6. NOT IN STRING / COMMENT / TEMPLATE / REGEX ---
+        // Check for comment starts
+        if (!isHashStyle) {
+            if (char === '/' && nextChar === '/') {
+                inSingleComment = true;
+                i++; // skip second '/'
+                continue;
+            }
+            if (char === '/' && nextChar === '*') {
+                inMultiComment = true;
+                i++; // skip '*'
+                continue;
+            }
+        }
+        else {
+            if (char === '#') {
+                inSingleComment = true;
+                continue;
+            }
+        }
+        // Check for string starts (' or ")
+        if (char === '"' || char === "'") {
+            inString = true;
+            stringChar = char;
+            continue;
+        }
+        // Check for template literal start (`)
+        if (isJsTs && char === '`') {
+            inTemplate = true;
+            continue;
+        }
+        // Check for regex literal start
+        if (isJsTs && char === '/') {
+            // Determine if '/' starts a regex or is a division operator
+            const prevToken = currentWord || lastToken;
+            const isExpr = !prevToken || EXPR_KEYWORDS.has(prevToken) || EXPR_PUNCT.has(prevToken);
+            if (isExpr) {
+                inRegex = true;
+                inRegexCharClass = false;
+                currentWord = '';
+                lastToken = '/';
+                continue;
+            }
+        }
+        // Update lastToken / currentWord tracking
+        if (char === ' ' || char === '\t' || char === '\n' || char === '\r') {
+            if (currentWord) {
+                lastToken = currentWord;
+                currentWord = '';
+            }
         }
+        else if (wordCharRegex.test(char)) {
+            currentWord += char;
+        }
+        else {
+            if (currentWord) {
+                lastToken = currentWord;
+                currentWord = '';
+            }
+            lastToken = char;
+        }
+        // --- 7. BRACKET MATCHING ---
+        if (['{', '[', '('].includes(char)) {
+            if (isHashStyle && char === '{')
+                continue;
+            stack.push(char);
+        }
+        else if (['}', ']', ')'].includes(char)) {
+            if (isHashStyle && char === '}')
+                continue;
+            const last = stack.pop();
+            if (!last || pairs[last] !== char) {
+                return {
+                    isValid: false,
+                    error: "Unbalanced character '" + char + "' at position " + i,
+                };
+            }
+            // If we popped a '${' template expression delimiter, return to template literal mode
+            if (last === '${') {
+                inTemplate = true;
+            }
+        }
+    }
+    // Final check for unclosed delimiters or unclosed comments/strings/regex
+    if (stack.length > 0) {
+        const unclosed = stack[stack.length - 1];
+        return {
+            isValid: false,
+            error: "Unclosed character '" + unclosed + "'",
+        };
+    }
+    if (inMultiComment) {
+        return { isValid: false, error: 'Unclosed multi-line comment' };
+    }
+    if (inString) {
+        return { isValid: false, error: 'Unclosed string literal' };
+    }
+    if (inTemplate) {
+        return { isValid: false, error: 'Unclosed template literal' };
+    }
+    if (inRegex) {
+        return { isValid: false, error: 'Unclosed regex literal' };
     }
     return { isValid: true };
 }

package/dist/utils/performanceAuditor.d.ts

@@ -20,10 +20,7 @@ export declare function isAuditableFile(filePath: string): boolean;
 /**
  * Scans source code for performance anti-patterns using language-aware
  * regex-based heuristics. Returns structured findings grouped by severity.
- *
- * This function is designed to be called inline during the verification
- * phase — it's synchronous, zero-dependency, and executes in <50ms on
- * files up to 10,000 lines.
+ * Supports comment suppression directives (perf-ignore).
  *
  * @param content - The raw source code string to audit.
  * @param filePath - The file path (used for language detection via extension).
@@ -31,12 +28,10 @@ export declare function isAuditableFile(filePath: string): boolean;
  */
 export declare function auditFilePerformance(content: string, filePath: string): PerfAuditResult;
 /**
- * Formats audit findings for beautiful terminal display using picocolors.
- * Used for non-blocking warnings shown to the user after verification.
+ * Formats audit findings for terminal display using picocolors.
  */
 export declare function formatAuditForTerminal(results: PerfAuditResult[]): string;
 /**
  * Formats audit findings into a structured prompt for the AI auto-correction loop.
- * Only includes ERROR-severity findings (warnings and info are non-blocking).
  */
 export declare function formatAuditForModel(results: PerfAuditResult[]): string;