@sun-asterisk/sunlint 1.3.48 → 1.3.49

package/core/tui-select.js

@@ -0,0 +1,245 @@
+/**
+ * SunLint TUI Select Widget
+ * Arrow-key driven interactive selection for terminal.
+ * Zero external dependencies - uses Node.js built-in readline + raw mode.
+ *
+ * Rule C005: Single responsibility - terminal selection UI only
+ */
+
+'use strict';
+
+const readline = require('readline');
+
+// ─── ANSI helpers ────────────────────────────────────────────────────────────
+const ansi = {
+    saveCursor:    '\x1b7',
+    restoreCursor: '\x1b8',
+    clearToEnd:    '\x1b[J',
+    clearLine:     '\x1b[2K\r',
+    hideCursor:    '\x1b[?25l',
+    showCursor:    '\x1b[?25h',
+    reset:    '\x1b[0m',
+    bold:     '\x1b[1m',
+    dim:      '\x1b[2m',
+    cyan:     '\x1b[36m',
+    blue:     '\x1b[34m',
+    green:    '\x1b[32m',
+    yellow:   '\x1b[33m',
+    magenta:  '\x1b[35m',
+    white:    '\x1b[37m',
+    gray:     '\x1b[90m',
+    bgCyan:   '\x1b[46m',
+    bgBlue:   '\x1b[44m',
+};
+
+function c(colorKey, text) {
+    return `${ansi[colorKey] || ''}${text}${ansi.reset}`;
+}
+
+function bold(text) { return `${ansi.bold}${text}${ansi.reset}`; }
+function dim(text)  { return `${ansi.dim}${text}${ansi.reset}`; }
+
+// ─── Banner ──────────────────────────────────────────────────────────────────
+
+/**
+ * Print the SunLint init banner
+ */
+function printBanner() {
+    const line = '─'.repeat(58);
+    process.stdout.write('\n');
+    process.stdout.write(c('cyan', ` ┌${line}┐\n`));
+    process.stdout.write(c('cyan', ` │`) + bold('  ☀️  SunLint Init') + c('gray', '  ·  Interactive Project Setup') + c('cyan', '         │\n'));
+    process.stdout.write(c('cyan', ` └${line}┘\n`));
+    process.stdout.write('\n');
+}
+
+// ─── Detection info ──────────────────────────────────────────────────────────
+
+/**
+ * Print the auto-detection result hint.
+ * @param {import('./project-detector').DetectionResult | null} detection
+ */
+function printDetectionHint(detection) {
+    if (!detection) {
+        process.stdout.write(c('gray', ' 🔍 No framework detected — default preset: TypeScript\n\n'));
+        return;
+    }
+
+    const badge = detection.confidence === 'high'
+        ? c('green', '● high confidence')
+        : c('yellow', '◐ medium confidence');
+
+    process.stdout.write(
+        ` ✨ ${bold('Auto-detected:')} ${c('cyan', detection.framework)}  ${badge}\n`
+    );
+    process.stdout.write(
+        c('gray', `    Signals: ${detection.signals.slice(0, 4).join(', ')}\n`)
+    );
+    process.stdout.write('\n');
+}
+
+// ─── Core TUI select ─────────────────────────────────────────────────────────
+
+/**
+ * Show an interactive arrow-key selection list.
+ *
+ * @param {Object} params
+ * @param {string}   params.question       - Prompt label
+ * @param {string[]} params.options         - List of option values
+ * @param {Object}   [params.labels]        - Optional display label map { value: 'Label' }
+ * @param {Object}   [params.badges]        - Optional badge map { value: '[badge text]' }
+ * @param {number}   [params.defaultIndex]  - Pre-selected index (0-based)
+ * @returns {Promise<string>} - The selected option value
+ */
+function tuiSelect({ question, options, labels = {}, badges = {}, defaultIndex = 0 }) {
+    return new Promise((resolve, reject) => {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            resolve(options[defaultIndex] || options[0]);
+            return;
+        }
+
+        let selected = Math.max(0, Math.min(defaultIndex, options.length - 1));
+
+        function renderLabel(value) {
+            return labels[value] || value;
+        }
+
+        function renderBadge(value) {
+            return badges[value] ? c('green', ` ${badges[value]}`) : '';
+        }
+
+        function render(firstRender = false) {
+            if (firstRender) {
+                // Save cursor position BEFORE first render
+                process.stdout.write(ansi.saveCursor);
+            } else {
+                // Restore to saved position, then clear everything below
+                process.stdout.write(ansi.restoreCursor + ansi.clearToEnd);
+            }
+
+            // Question line
+            process.stdout.write(
+                ` ${c('cyan', '?')} ${bold(question)}\n`
+            );
+
+            // Hint line
+            process.stdout.write(
+                `   ${dim('Use ↑↓ arrows · Enter to confirm · Esc to cancel')}\n\n`
+            );
+
+            // Option lines
+            for (let i = 0; i < options.length; i++) {
+                const value = options[i];
+                const label = renderLabel(value);
+                const badge = renderBadge(value);
+                const isActive = i === selected;
+
+                const pointer = isActive ? c('cyan', ' ❯ ') : '   ';
+                const dot     = isActive ? c('cyan', '●') : c('gray', '○');
+                const text    = isActive
+                    ? bold(c('white', label))
+                    : c('gray', label);
+
+                process.stdout.write(`${pointer}${dot} ${text}${badge}\n`);
+            }
+        }
+
+        // Hide cursor and switch to raw mode
+        process.stdout.write(ansi.hideCursor);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+
+        render(true);
+
+        function cleanup() {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdout.write(ansi.showCursor);
+        }
+
+        function onKeypress(key) {
+            if (key === '\u001b[A' || key === '\u001b[D') {
+                // Up / Left
+                selected = (selected - 1 + options.length) % options.length;
+                render();
+            } else if (key === '\u001b[B' || key === '\u001b[C') {
+                // Down / Right
+                selected = (selected + 1) % options.length;
+                render();
+            } else if (key === '\r' || key === '\n') {
+                // Enter
+                cleanup();
+                process.stdin.removeListener('data', onKeypress);
+
+                // Replace the whole rendered block with a single summary line
+                const value = options[selected];
+                const label = renderLabel(value);
+                const badge = renderBadge(value);
+                process.stdout.write(
+                    ansi.restoreCursor + ansi.clearToEnd +
+                    ` ${c('green', '✔')} ${bold(question)} ${c('cyan', label)}${badge}\n\n`
+                );
+
+                resolve(value);
+            } else if (key === '\u001b' || key === '\u0003') {
+                // Esc / Ctrl+C
+                cleanup();
+                process.stdin.removeListener('data', onKeypress);
+                process.stdout.write(ansi.restoreCursor + ansi.clearToEnd + '\n');
+                reject(new Error('Cancelled by user'));
+            }
+        }
+
+        process.stdin.on('data', onKeypress);
+    });
+}
+
+// ─── Confirm prompt ──────────────────────────────────────────────────────────
+
+/**
+ * Simple yes/no confirmation.
+ * @param {string} question
+ * @param {boolean} [defaultYes=true]
+ * @returns {Promise<boolean>}
+ */
+function tuiConfirm(question, defaultYes = true) {
+    return new Promise((resolve, reject) => {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            resolve(defaultYes);
+            return;
+        }
+
+        const hint = defaultYes ? '(Y/n)' : '(y/N)';
+        process.stdout.write(` ${c('cyan', '?')} ${bold(question)} ${c('gray', hint)} `);
+
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+
+        function onKey(key) {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdin.removeListener('data', onKey);
+
+            if (key === '\u0003') {
+                process.stdout.write('\n');
+                reject(new Error('Cancelled by user'));
+                return;
+            }
+
+            const input = key.toLowerCase().trim();
+            let answer;
+            if (input === 'y') answer = true;
+            else if (input === 'n') answer = false;
+            else answer = defaultYes;
+
+            process.stdout.write(`${answer ? c('green', 'Yes') : c('yellow', 'No')}\n`);
+            resolve(answer);
+        }
+
+        process.stdin.on('data', onKey);
+    });
+}
+
+module.exports = { printBanner, printDetectionHint, tuiSelect, tuiConfirm };

package/engines/arch-detect/rules/layered/l001-presentation-layer.js

@@ -125,8 +125,8 @@ let L001PresentationLayer = (() => {
         }
         async customDetection(context) {
             const matches = [];
-            let hasFolders = false;
-            let hasFiles = false;
+            let _hasFolders = false;
+            let _hasFiles = false;
             let hasCode = false;
             // Check for controller folders
             const controllerFolders = [
@@ -147,7 +147,7 @@ let L001PresentationLayer = (() => {
                         path: folder,
                         matchedPattern: 'Controller folder',
                     });
-                    hasFolders = true;
+                    _hasFolders = true;
                 }
             }
             // Check for controller files
@@ -162,7 +162,7 @@ let L001PresentationLayer = (() => {
                         matchedPattern: 'Controller file',
                     });
                 }
-                hasFiles = true;
+                _hasFiles = true;
             }
             // Check for code patterns (sampling first 50 source files)
             const sourceFiles = context.files
@@ -201,17 +201,9 @@ let L001PresentationLayer = (() => {
                     // Skip unreadable files
                 }
             }
-            // Calculate score based on presence
-            let score = 0;
-            if (hasFolders && hasFiles)
-                score = 1;
-            else if (hasFiles)
-                score = 0.7;
-            else if (hasCode)
-                score = 0.6;
-            else if (hasFolders)
-                score = 0.4;
-            return { matches, violations: [], score };
+            // Let BaseRule's language-aware scoring handle the score calculation
+            // customDetection only contributes additional matches
+            return { matches, violations: [] };
         }
         getMetadata(context, matches) {
             const controllerCount = matches.filter((m) => m.matchedPattern === 'Controller file').length;

package/engines/arch-detect/rules/layered/l002-business-layer.js

@@ -105,8 +105,8 @@ let L002BusinessLayer = (() => {
         }
         async customDetection(context) {
             const matches = [];
-            let hasFolders = false;
-            let hasFiles = false;
+            let _hasFolders = false;
+            let _hasFiles = false;
             let hasCode = false;
             // Check for service folders
             const serviceFolders = [
@@ -128,7 +128,7 @@ let L002BusinessLayer = (() => {
                         path: folder,
                         matchedPattern: 'Service folder',
                     });
-                    hasFolders = true;
+                    _hasFolders = true;
                 }
             }
             // Check for service files
@@ -144,7 +144,7 @@ let L002BusinessLayer = (() => {
                         matchedPattern: 'Service file',
                     });
                 }
-                hasFiles = true;
+                _hasFiles = true;
             }
             // Check for code patterns
             const sourceFiles = context.files
@@ -179,17 +179,9 @@ let L002BusinessLayer = (() => {
                     // Skip unreadable files
                 }
             }
-            // Calculate score
-            let score = 0;
-            if (hasFolders && hasFiles)
-                score = 1;
-            else if (hasFiles)
-                score = 0.7;
-            else if (hasCode)
-                score = 0.6;
-            else if (hasFolders)
-                score = 0.4;
-            return { matches, violations: [], score };
+            // Let BaseRule's language-aware scoring handle the score calculation
+            // customDetection only contributes additional matches
+            return { matches, violations: [] };
         }
         getMetadata(context, matches) {
             const serviceCount = matches.filter((m) => m.matchedPattern === 'Service file').length;

package/engines/arch-detect/rules/layered/l003-data-layer.js

@@ -119,8 +119,8 @@ let L003DataLayer = (() => {
         }
         async customDetection(context) {
             const matches = [];
-            let hasFolders = false;
-            let hasFiles = false;
+            let _hasFolders = false;
+            let _hasFiles = false;
             let hasCode = false;
             // Check for repository folders
             const repoFolders = [
@@ -142,7 +142,7 @@ let L003DataLayer = (() => {
                         path: folder,
                         matchedPattern: 'Repository folder',
                     });
-                    hasFolders = true;
+                    _hasFolders = true;
                 }
             }
             // Check for repository files
@@ -158,7 +158,7 @@ let L003DataLayer = (() => {
                         matchedPattern: 'Repository file',
                     });
                 }
-                hasFiles = true;
+                _hasFiles = true;
             }
             // Check for code patterns
             const sourceFiles = context.files
@@ -193,17 +193,9 @@ let L003DataLayer = (() => {
                     // Skip unreadable files
                 }
             }
-            // Calculate score
-            let score = 0;
-            if (hasFolders && hasFiles)
-                score = 1;
-            else if (hasFiles)
-                score = 0.7;
-            else if (hasCode)
-                score = 0.6;
-            else if (hasFolders)
-                score = 0.4;
-            return { matches, violations: [], score };
+            // Let BaseRule's language-aware scoring handle the score calculation
+            // customDetection only contributes additional matches
+            return { matches, violations: [] };
         }
         getMetadata(context, matches) {
             const repoCount = matches.filter((m) => m.matchedPattern === 'Repository file').length;

package/engines/arch-detect/rules/layered/l004-model-layer.js

@@ -91,8 +91,8 @@ let L004ModelLayer = (() => {
         }
         async customDetection(context) {
             const matches = [];
-            let hasFolders = false;
-            let hasFiles = false;
+            let _hasFolders = false;
+            let _hasFiles = false;
             let hasCode = false;
             // Check for model folders
             const modelFolders = [
@@ -114,7 +114,7 @@ let L004ModelLayer = (() => {
                         path: folder,
                         matchedPattern: 'Model folder',
                     });
-                    hasFolders = true;
+                    _hasFolders = true;
                 }
             }
             // Check for model/entity files
@@ -132,7 +132,7 @@ let L004ModelLayer = (() => {
                         matchedPattern: 'Model file',
                     });
                 }
-                hasFiles = true;
+                _hasFiles = true;
             }
             // Check for code patterns
             const sourceFiles = context.files
@@ -168,17 +168,9 @@ let L004ModelLayer = (() => {
                     // Skip unreadable files
                 }
             }
-            // Calculate score
-            let score = 0;
-            if (hasFolders && hasFiles)
-                score = 1;
-            else if (hasFiles)
-                score = 0.7;
-            else if (hasCode)
-                score = 0.6;
-            else if (hasFolders)
-                score = 0.4;
-            return { matches, violations: [], score };
+            // Let BaseRule's language-aware scoring handle the score calculation
+            // customDetection only contributes additional matches
+            return { matches, violations: [] };
         }
         getMetadata(context, matches) {
             const modelCount = matches.filter((m) => m.matchedPattern === 'Model file').length;

package/engines/arch-detect/rules/layered/l005-layer-separation.js

@@ -175,8 +175,28 @@ let L005LayerSeparation = (() => {
                 .filter((f) => !f.isTest && !f.isConfig && f.language)
                 .slice(0, 30);
             const layerIndicators = {
-                presentation: [/@Controller\b/, /@Get\(/, /@Post\(/, /router\.(get|post)/],
-                data: [/@Repository\b/, /DbContext/, /\.query\(/, /\.find\(/],
+                presentation: [
+                    /@Controller\b/, // Java Spring
+                    /@RestController\b/, // Java Spring
+                    /@Get\(/, // NestJS
+                    /@Post\(/, // NestJS
+                    /router\.(get|post)/, // Express
+                    /\[ApiController\]/, // C#
+                    /@app\.route\s*\(/, // Python Flask
+                    /Route::(get|post)\s*\(/, // PHP Laravel
+                    /r\.HandleFunc\s*\(/, // Go
+                    /gin\.Context/, // Go Gin
+                ],
+                data: [
+                    /@Repository\b/, // Java Spring
+                    /DbContext/, // C# EF
+                    /\.query\s*\(/, // Generic
+                    /DB::table\s*\(/, // PHP Laravel
+                    /models\.Model/, // Python Django
+                    /type\s+\w+Repository\s+struct/, // Go
+                    /extends\s+Model\b/, // PHP Eloquent
+                    /extends\s+(Jpa|Crud|Mongo)Repository\b/, // Java Spring Data
+                ],
             };
             for (const file of sourceFiles) {
                 try {

package/engines/arch-detect/rules/layered/l006-dependency-direction.js

@@ -118,11 +118,14 @@ let L006DependencyDirection = (() => {
                 .filter((f) => !f.isTest && !f.isConfig && f.language)
                 .slice(0, 50);
             const importPatterns = [
-                /import\s+.*\s+from\s+['"]([^'"]+)['"]/g,
-                /import\s+['"]([^'"]+)['"]/g,
-                /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-                /from\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+import/g,
-                /using\s+([a-zA-Z_.]+);/g,
+                /import\s+.*\s+from\s+['"]([^'"]+)['"]/g, // ES6 import
+                /import\s+['"]([^'"]+)['"]/g, // ES6 side-effect import
+                /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g, // CommonJS / Ruby require
+                /from\s+([a-zA-Z_][\w.]*)\s+import/g, // Python from...import
+                /using\s+([a-zA-Z_.]+);/g, // C# using
+                /import\s+([\w.]+);/g, // Java/Kotlin import
+                /use\s+([\w\\]+)/g, // PHP use
+                /import\s+"([^"]+)"/g, // Go import
             ];
             for (const file of sourceFiles) {
                 const fromLayer = this.classifyFileLayer(file);

package/engines/arch-detect/rules/modular/m005-no-deep-imports.js

@@ -71,43 +71,81 @@ let M005NoDeepImports = (() => {
                 // Not enough modules to check cross-module imports
                 return { matches, violations, score: 0.5 };
             }
-            // Check imports in source files
+            // Check imports in source files (all recognized languages)
             const sourceFiles = context.files
-                .filter((f) => !f.isTest &&
-                !f.isConfig &&
-                (f.extension === '.ts' || f.extension === '.js' || f.extension === '.tsx'))
+                .filter((f) => !f.isTest && !f.isConfig && f.language != null)
                 .slice(0, 50);
-            const importPattern = /import\s+.*\s+from\s+['"]([^'"]+)['"]/g;
+            // Language-aware import patterns
+            const importPatterns = [
+                // TypeScript/JavaScript ES6 imports
+                {
+                    pattern: /import\s+.*\s+from\s+['"]([^'"]+)['"]/g,
+                    languages: new Set(['typescript', 'javascript']),
+                },
+                // TypeScript/JavaScript require
+                {
+                    pattern: /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+                    languages: new Set(['typescript', 'javascript', 'ruby']),
+                },
+                // Java/Kotlin imports
+                { pattern: /import\s+([\w.]+)/g, languages: new Set(['java', 'kotlin']) },
+                // Python imports
+                { pattern: /from\s+([\w.]+)\s+import/g, languages: new Set(['python']) },
+                // PHP use statements
+                { pattern: /use\s+([\w\\]+)/g, languages: new Set(['php']) },
+                // Go imports
+                { pattern: /import\s+"([^"]+)"/g, languages: new Set(['go']) },
+                // C# using
+                { pattern: /using\s+([\w.]+);/g, languages: new Set(['csharp']) },
+            ];
             for (const file of sourceFiles) {
                 try {
                     const content = await context.helpers.readFile(file.absolutePath);
                     const fileModulePath = this.getModulePath(file.relativePath, modulePaths);
-                    let match;
-                    while ((match = importPattern.exec(content)) !== null) {
-                        const importPath = match[1];
-                        // Skip external packages
-                        if (!importPath.startsWith('.') &&
-                            !importPath.startsWith('@app') &&
-                            !importPath.startsWith('@/')) {
-                            continue;
-                        }
-                        // Check if this is a cross-module import
-                        const targetModulePath = this.resolveImportToModule(importPath, file.relativePath, modulePaths);
-                        if (targetModulePath && targetModulePath !== fileModulePath) {
-                            // Cross-module import detected
-                            const isDeepImport = this.isDeepImport(importPath, targetModulePath);
-                            if (isDeepImport) {
-                                deepImportCount++;
-                                violations.push({
-                                    type: 'deep_import',
-                                    severity: enums_1.Severity.WARNING,
-                                    path: file.relativePath,
-                                    message: `Deep import into ${targetModulePath}: ${importPath}`,
-                                    suggestion: `Import from ${targetModulePath}/index instead`,
-                                });
+                    const fileLang = file.language || '';
+                    // Select import patterns relevant to this file's language
+                    const relevantPatterns = importPatterns.filter((ip) => ip.languages.has(fileLang));
+                    for (const { pattern } of relevantPatterns) {
+                        pattern.lastIndex = 0;
+                        let match;
+                        while ((match = pattern.exec(content)) !== null) {
+                            const importPath = match[1];
+                            // Skip external packages based on language
+                            if (fileLang === 'typescript' || fileLang === 'javascript') {
+                                if (!importPath.startsWith('.') &&
+                                    !importPath.startsWith('@app') &&
+                                    !importPath.startsWith('@/')) {
+                                    continue;
+                                }
                             }
                             else {
-                                validImportCount++;
+                                // For other languages, use folder-based module path resolution
+                                // Skip if import path doesn't match any known module path segment
+                                const matchesModule = modulePaths.some((mp) => {
+                                    const moduleName = mp.split('/').pop()?.toLowerCase() || '';
+                                    return importPath.toLowerCase().includes(moduleName);
+                                });
+                                if (!matchesModule)
+                                    continue;
+                            }
+                            // Check if this is a cross-module import
+                            const targetModulePath = this.resolveImportToModule(importPath, file.relativePath, modulePaths);
+                            if (targetModulePath && targetModulePath !== fileModulePath) {
+                                // Cross-module import detected
+                                const isDeepImport = this.isDeepImport(importPath, targetModulePath);
+                                if (isDeepImport) {
+                                    deepImportCount++;
+                                    violations.push({
+                                        type: 'deep_import',
+                                        severity: enums_1.Severity.WARNING,
+                                        path: file.relativePath,
+                                        message: `Deep import into ${targetModulePath}: ${importPath}`,
+                                        suggestion: `Import from ${targetModulePath}/index instead`,
+                                    });
+                                }
+                                else {
+                                    validImportCount++;
+                                }
                             }
                         }
                     }

package/engines/arch-detect/rules/presentation/pr001-view-layer.js

@@ -144,13 +144,17 @@ let PR001ViewLayer = (() => {
                 }
             }
             // Check for view files
-            const viewFiles = context.files.filter((f) => /View\.(ts|tsx|js|jsx|swift|kt|dart)$/i.test(f.fileName) ||
-                /Screen\.(ts|tsx|js|jsx|swift|kt|dart)$/i.test(f.fileName) ||
-                /Page\.(ts|tsx|js|jsx|swift|kt|dart)$/i.test(f.fileName) ||
+            const viewFiles = context.files.filter((f) => /View\.(ts|tsx|js|jsx|swift|kt|dart|java|php|py|go|rb|cs)$/i.test(f.fileName) ||
+                /Screen\.(ts|tsx|js|jsx|swift|kt|dart|java|php|py|go|rb|cs)$/i.test(f.fileName) ||
+                /Page\.(ts|tsx|js|jsx|swift|kt|dart|java|php|py|go|rb|cs)$/i.test(f.fileName) ||
                 /Activity\.(kt|java)$/i.test(f.fileName) ||
                 /Fragment\.(kt|java)$/i.test(f.fileName) ||
                 /ViewController\.swift$/i.test(f.fileName) ||
-                /\.vue$/i.test(f.fileName));
+                /\.vue$/i.test(f.fileName) ||
+                /\.blade\.php$/i.test(f.fileName) ||
+                /\.twig$/i.test(f.fileName) ||
+                /\.cshtml$/i.test(f.fileName) ||
+                /\.html\.erb$/i.test(f.fileName));
             if (viewFiles.length > 0) {
                 for (const file of viewFiles.slice(0, 5)) {
                     matches.push({
@@ -166,11 +170,14 @@ let PR001ViewLayer = (() => {
                 .filter((f) => !f.isTest && !f.isConfig && f.language)
                 .slice(0, 50);
             const codePatterns = [
-                /@Composable\s+fun/,
-                /struct\s+\w+View\s*:\s*View/,
-                /class\s+\w+ViewController/,
-                /extends\s+(StatefulWidget|StatelessWidget)/,
-                /<template>/,
+                /@Composable\s+fun/, // Android Kotlin
+                /struct\s+\w+View\s*:\s*View/, // SwiftUI
+                /class\s+\w+ViewController/, // iOS UIKit
+                /extends\s+(StatefulWidget|StatelessWidget)/, // Flutter
+                /<template>/, // Vue
+                /class\s+\w+View\s*\(\s*APIView\s*\)/, // Python Django REST
+                /@app\.route\s*\(/, // Python Flask views
+                /class\s+\w+Controller\s*<\s*ApplicationController/, // Ruby Rails
             ];
             for (const file of sourceFiles) {
                 try {