@sun-asterisk/sunlint 1.3.34 → 1.3.35

package/engines/arch-detect/utils/pattern-matcher.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * Pattern Matcher Utility
+ * Hỗ trợ matching các patterns trong code và config
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonPatterns = exports.PatternMatcher = void 0;
+const enums_1 = require("../types/enums");
+const file_scanner_1 = require("./file-scanner");
+/**
+ * Pattern Matcher class
+ */
+class PatternMatcher {
+    constructor(_projectRoot) {
+        this.fileContentCache = new Map();
+    }
+    /**
+     * Match folder patterns
+     */
+    async matchFolderPatterns(patterns, directoryTree) {
+        const matches = [];
+        for (const pattern of patterns) {
+            const regex = this.globToRegex(pattern);
+            const matchedFolders = file_scanner_1.FileScanner.findFoldersByPattern(directoryTree, regex);
+            for (const folder of matchedFolders) {
+                matches.push({
+                    type: enums_1.MatchType.FOLDER,
+                    path: folder.relativePath,
+                    matchedPattern: pattern,
+                });
+            }
+        }
+        return {
+            matched: matches.length > 0,
+            matches,
+            score: Math.min(matches.length / patterns.length, 1),
+            occurrences: matches.length,
+        };
+    }
+    /**
+     * Match file patterns
+     */
+    async matchFilePatterns(patterns, files) {
+        const matches = [];
+        for (const pattern of patterns) {
+            const regex = this.globToRegex(pattern);
+            const matchedFiles = file_scanner_1.FileScanner.findFilesByPattern(files, regex);
+            for (const file of matchedFiles) {
+                matches.push({
+                    type: enums_1.MatchType.FILE,
+                    path: file.relativePath,
+                    matchedPattern: pattern,
+                });
+            }
+        }
+        return {
+            matched: matches.length > 0,
+            matches,
+            score: Math.min(matches.length / patterns.length, 1),
+            occurrences: matches.length,
+        };
+    }
+    /**
+     * Match code patterns trong files
+     */
+    async matchCodePatterns(codePatterns, files) {
+        const matches = [];
+        for (const codePattern of codePatterns) {
+            const filteredFiles = this.filterFilesByLanguage(files, codePattern.language);
+            const regex = this.ensureRegex(codePattern.pattern);
+            for (const file of filteredFiles) {
+                try {
+                    const content = await this.getFileContent(file.absolutePath);
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        const match = line.match(regex);
+                        if (match) {
+                            matches.push({
+                                type: enums_1.MatchType.CODE,
+                                path: file.relativePath,
+                                line: i + 1,
+                                column: match.index || 0,
+                                snippet: line.trim(),
+                                matchedPattern: codePattern.pattern.toString(),
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Skip files that cannot be read
+                }
+            }
+        }
+        // Check minimum occurrences
+        const minOccurrences = codePatterns[0]?.minOccurrences || 1;
+        const passed = matches.length >= minOccurrences;
+        return {
+            matched: passed,
+            matches,
+            score: passed ? Math.min(matches.length / (minOccurrences * 2), 1) : 0,
+            occurrences: matches.length,
+        };
+    }
+    /**
+     * Match config patterns
+     */
+    async matchConfigPatterns(configPatterns, files) {
+        const matches = [];
+        for (const configPattern of configPatterns) {
+            const regex = this.globToRegex(configPattern.filePattern);
+            const configFiles = files.filter((f) => regex.test(f.relativePath) || regex.test(f.fileName));
+            for (const file of configFiles) {
+                try {
+                    const content = await this.getFileContent(file.absolutePath);
+                    let matched = false;
+                    // Check contains
+                    if (configPattern.contains) {
+                        if (content.includes(configPattern.contains)) {
+                            matched = true;
+                        }
+                    }
+                    // Check regex
+                    if (configPattern.regex) {
+                        const patternRegex = this.ensureRegex(configPattern.regex);
+                        if (patternRegex.test(content)) {
+                            matched = true;
+                        }
+                    }
+                    // Check JSON path
+                    if (configPattern.jsonPath && file.extension === '.json') {
+                        try {
+                            const json = JSON.parse(content);
+                            if (this.checkJsonPath(json, configPattern.jsonPath)) {
+                                matched = true;
+                            }
+                        }
+                        catch {
+                            // Invalid JSON, skip
+                        }
+                    }
+                    // If no specific check, just match file existence
+                    if (!configPattern.contains && !configPattern.regex && !configPattern.jsonPath) {
+                        matched = true;
+                    }
+                    if (matched) {
+                        matches.push({
+                            type: enums_1.MatchType.CONFIG,
+                            path: file.relativePath,
+                            matchedPattern: configPattern.filePattern,
+                        });
+                    }
+                }
+                catch {
+                    // Skip files that cannot be read
+                }
+            }
+        }
+        return {
+            matched: matches.length > 0,
+            matches,
+            score: Math.min(matches.length / configPatterns.length, 1),
+            occurrences: matches.length,
+        };
+    }
+    /**
+     * Check JSON path exists
+     */
+    checkJsonPath(obj, jsonPath) {
+        // Simple JSON path like $.dependencies.express
+        const parts = jsonPath.replace(/^\$\.?/, '').split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return false;
+            }
+            if (typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                return false;
+            }
+        }
+        return current !== undefined;
+    }
+    /**
+     * Filter files by language
+     */
+    filterFilesByLanguage(files, language) {
+        if (language === 'all') {
+            return files;
+        }
+        return files.filter((f) => f.language === language);
+    }
+    /**
+     * Get file content with caching
+     */
+    async getFileContent(filePath) {
+        if (this.fileContentCache.has(filePath)) {
+            return this.fileContentCache.get(filePath);
+        }
+        const content = await file_scanner_1.FileScanner.readFileContent(filePath);
+        this.fileContentCache.set(filePath, content);
+        return content;
+    }
+    /**
+     * Convert glob to regex
+     */
+    globToRegex(pattern) {
+        const regexStr = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '{{GLOBSTAR}}')
+            .replace(/\*/g, '[^/]*')
+            .replace(/\?/g, '.')
+            .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+        return new RegExp(regexStr, 'i');
+    }
+    /**
+     * Ensure pattern is a RegExp
+     */
+    ensureRegex(pattern) {
+        return typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+    }
+    /**
+     * Clear content cache
+     */
+    clearCache() {
+        this.fileContentCache.clear();
+    }
+}
+exports.PatternMatcher = PatternMatcher;
+/**
+ * Common code patterns for various languages
+ */
+exports.CommonPatterns = {
+    // Java patterns
+    java: {
+        controller: [
+            /@Controller\b/,
+            /@RestController\b/,
+            /@RequestMapping\b/,
+            /@GetMapping\b/,
+            /@PostMapping\b/,
+            /@PutMapping\b/,
+            /@DeleteMapping\b/,
+        ],
+        service: [/@Service\b/, /@Component\b/, /@Transactional\b/],
+        repository: [/@Repository\b/, /extends\s+(Jpa|Crud|Mongo)Repository\b/, /@Query\b/],
+        entity: [/@Entity\b/, /@Table\b/, /@Data\b/, /@Getter\b/, /@Setter\b/],
+    },
+    // TypeScript/JavaScript patterns
+    typescript: {
+        controller: [
+            /@Controller\s*\(/,
+            /@Get\s*\(/,
+            /@Post\s*\(/,
+            /@Put\s*\(/,
+            /@Delete\s*\(/,
+            /router\.(get|post|put|delete)\s*\(/,
+            /app\.(get|post|put|delete)\s*\(/,
+        ],
+        service: [/@Injectable\s*\(/, /\.service\.ts$/, /class\s+\w+Service\b/],
+        repository: [/@EntityRepository\s*\(/, /\.repository\.ts$/, /class\s+\w+Repository\b/],
+        entity: [/@Entity\s*\(/, /@Column\s*\(/, /interface\s+\w+\s*\{/],
+        module: [/@Module\s*\(/, /@NgModule\s*\(/],
+        viewModel: [
+            /useState\s*[<(]/,
+            /useReducer\s*\(/,
+            /ref\s*[<(]/,
+            /reactive\s*[<(]/,
+            /computed\s*\(/,
+        ],
+    },
+    // Swift patterns
+    swift: {
+        viewController: [
+            /class\s+\w+ViewController\s*:\s*UIViewController/,
+            /struct\s+\w+View\s*:\s*View/,
+        ],
+        viewModel: [
+            /class\s+\w+ViewModel\s*:\s*ObservableObject/,
+            /@Published\b/,
+            /@StateObject\b/,
+            /@ObservedObject\b/,
+        ],
+        interactor: [/protocol\s+\w+Interactor/, /class\s+\w+Interactor/],
+        router: [/protocol\s+\w+Router/, /class\s+\w+Router/, /class\s+\w+Coordinator/],
+    },
+    // Dart/Flutter patterns
+    dart: {
+        widget: [/class\s+\w+\s+extends\s+StatefulWidget/, /class\s+\w+\s+extends\s+StatelessWidget/],
+        viewModel: [/class\s+\w+\s+extends\s+ChangeNotifier/, /notifyListeners\s*\(/],
+        bloc: [/class\s+\w+Bloc\s+extends\s+Bloc/, /@freezed\b/],
+    },
+    // C# patterns
+    csharp: {
+        controller: [
+            /\[ApiController\]/,
+            /\[HttpGet\]/,
+            /\[HttpPost\]/,
+            /:\s*ControllerBase\b/,
+            /:\s*Controller\b/,
+        ],
+        service: [/class\s+\w+Service\b/, /interface\s+I\w+Service\b/],
+        repository: [/DbContext\b/, /DbSet\s*</, /interface\s+I\w+Repository\b/],
+        viewModel: [/:\s*INotifyPropertyChanged\b/, /PropertyChanged\?\s*\.Invoke/],
+    },
+    // PHP patterns
+    php: {
+        controller: [/extends\s+Controller\b/, /Route::get\s*\(/, /Route::post\s*\(/],
+        service: [/class\s+\w+Service\b/],
+        repository: [/extends\s+Model\b/, /\$fillable\s*=/, /DB::table\s*\(/],
+    },
+    // Python patterns
+    python: {
+        view: [/@app\.route\s*\(/, /@api_view\s*\(/, /class\s+\w+View\s*\(\s*APIView\s*\)/],
+        service: [/class\s+\w+Service\b/],
+        model: [/@dataclass\b/, /class\s+\w+\s*\(\s*models\.Model\s*\)/],
+    },
+    // Go patterns
+    go: {
+        handler: [/func\s+\(\w+\s+\*?\w*Handler\)/, /r\.HandleFunc\s*\(/, /gin\.Context/],
+        service: [/type\s+\w+Service\s+struct/],
+        repository: [/type\s+\w+Repository\s+struct/],
+    },
+};
+exports.default = PatternMatcher;
+//# sourceMappingURL=pattern-matcher.js.map

package/engines/impact/cli.js

@@ -0,0 +1,106 @@
+/**
+ * CLI - Command Line Interface Parser
+ * Handles argument parsing and validation
+ */
+
+export class CLI {
+  constructor(argv) {
+    this.args = new Map();
+    this.parseArgs(argv);
+  }
+
+  parseArgs(argv) {
+    for (let i = 2; i < argv.length; i++) {
+      const arg = argv[i];
+
+      if (arg.startsWith('--')) {
+        const [key, value] = arg.substring(2).split('=');
+        this.args.set(key, value || 'true');
+      } else if (arg.startsWith('-')) {
+        // Short flags
+        const key = arg.substring(1);
+        this.args.set(key, 'true');
+      }
+    }
+  }
+
+  getArg(key, defaultValue = '') {
+    return this.args.get(key) || defaultValue;
+  }
+
+  hasArg(key) {
+    return this.args.has(key);
+  }
+
+  getAllArgs() {
+    return Object.fromEntries(this.args);
+  }
+
+  showHelp() {
+    console.log(`
+╔═══════════════════════════════════════════════════════════════════╗
+║              🔍 Impact Analyzer CLI - Help Guide                  ║
+╚═══════════════════════════════════════════════════════════════════╝
+
+USAGE:
+  impact-analyzer [OPTIONS]
+
+DESCRIPTION:
+  Analyzes code changes and their impact on endpoints, database, and
+  components in TypeScript/JavaScript projects.
+
+OPTIONS:
+  --input=<path>          Source directory to analyze
+                          Default: src
+
+  --base=<ref>            Base git reference for comparison
+                          Default: HEAD~1 (previous commit)
+                          Examples: origin/main, HEAD~5, abc123
+
+  --head=<ref>            Head git reference (optional)
+                          Default: (working directory)
+
+  --exclude=<paths>       Comma-separated paths to exclude
+                          Default: node_modules,dist,build,specs,coverage
+
+  --output=<file>         Output markdown report file
+                          Default: impact-report.md
+
+  --json=<file>           Output JSON report file (optional)
+                          Example: --json=impact-report.json
+
+  --max-depth=<n>         Maximum call graph depth
+                          Default: 3
+
+  --include-tests         Include test files in analysis
+
+  --verbose               Show verbose output and stack traces
+
+  --no-fail               Don't exit with error on critical impact
+
+  --help, -h              Show this help message
+
+EXAMPLES:
+  # Analyze changes in last commit (default)
+  impact-analyzer
+
+  # Analyze changes between main branch and current
+  impact-analyzer --base=origin/main
+
+  # Analyze specific directory with JSON output
+  impact-analyzer --input=backend/src --json=report.json
+
+  # Analyze last 3 commits with verbose output
+  impact-analyzer --base=HEAD~3 --verbose
+
+  # Compare two specific commits
+  impact-analyzer --base=abc123 --head=def456
+
+REFERENCE:
+  Architecture: .specify/plans/architecture.md
+  Coding Rules: .github/copilot-instructions.md
+
+For more information, visit: https://github.com/sun-asterisk/impact-analyzer
+`);
+  }
+}

package/engines/impact/config/default-config.js

@@ -0,0 +1,54 @@
+/**
+ * Configuration Loader
+ * Loads and validates configuration from CLI args and defaults
+ */
+
+export function loadConfig(cli) {
+  const config = {
+    // Source directory to analyze
+    sourceDir: cli.getArg('input', 'src'),
+
+    // Paths to exclude from analysis
+    excludePaths: cli.getArg('exclude', 'node_modules,dist,build,specs,coverage')
+      .split(',')
+      .map(p => p.trim()),
+
+    // Git references - defaults to HEAD~1 (previous commit)
+    baseRef: cli.getArg('base', 'HEAD~1'),
+    headRef: cli.getArg('head', ''),  // Empty means current working directory
+
+    // Analysis options
+    maxDepth: parseInt(cli.getArg('max-depth', '3')),
+    includeTests: cli.hasArg('include-tests'),
+    verbose: cli.hasArg('verbose'),
+
+    // Report options
+    outputFormat: cli.getArg('format', 'markdown'),
+    outputFile: cli.getArg('output', 'impact-report.md'),
+  };
+
+  // Validate configuration
+  validateConfig(config);
+
+  return config;
+}
+
+function validateConfig(config) {
+  if (!config.sourceDir) {
+    throw new Error('Source directory (--input) is required');
+  }
+  
+  // baseRef and headRef are optional, have sensible defaults
+}
+
+export const DEFAULT_CONFIG = {
+  sourceDir: 'src',
+  excludePaths: ['node_modules', 'dist', 'build', 'specs', 'coverage'],
+  baseRef: 'HEAD~1',  // Previous commit
+  headRef: 'HEAD',     // Current commit
+  maxDepth: 3,
+  includeTests: false,
+  verbose: false,
+  outputFormat: 'markdown',
+  outputFile: 'impact-report.md',
+};