@sun-asterisk/sunlint 1.3.36 → 1.3.37

package/core/init-command.js

@@ -0,0 +1,227 @@
+/**
+ * SunLint Init Command
+ * Initializes a project with SunLint code quality skill and AGENTS.md
+ * Following Rule C005: Single responsibility - only handle init logic
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+// Path to the bundled skill directory (relative to this file in the package)
+const SKILL_SOURCE_DIR = path.join(__dirname, '..', 'skill-assets', 'sunlint-code-quality');
+const AGENTS_MD_SOURCE = path.join(SKILL_SOURCE_DIR, 'AGENTS.md');
+
+/**
+ * AI Tool configuration mapping
+ * Each tool has its own skill folder path convention
+ */
+const AI_TOOL_CONFIG = {
+    'antigravity': {
+        name: 'Google Antigravity',
+        skillPath: '.agent/skills',
+        description: 'Google Gemini Agent (.agent/skills/)'
+    },
+    'cursor': {
+        name: 'Cursor AI',
+        skillPath: '.cursor/skills',
+        description: 'Cursor AI Agent (.cursor/skills/)'
+    },
+    'claude': {
+        name: 'Claude',
+        skillPath: '.claude/skills',
+        description: 'Anthropic Claude Agent (.claude/skills/)'
+    },
+    'github-copilot': {
+        name: 'GitHub Copilot',
+        skillPath: '.github/skills',
+        description: 'GitHub Copilot Agent (.github/skills/)'
+    }
+};
+
+// Default tool if not specified
+const DEFAULT_TOOL = 'antigravity';
+
+/**
+ * Get available tools list for help text
+ */
+function getAvailableToolsHelp() {
+    return Object.entries(AI_TOOL_CONFIG)
+        .map(([key, config]) => `  ${key.padEnd(16)} - ${config.description}`)
+        .join('\n');
+}
+
+/**
+ * Initialize a project with SunLint skill and AGENTS.md
+ * @param {string} targetDir - The target project directory
+ * @param {object} options - Command options
+ */
+async function initProject(targetDir, options = {}) {
+    const resolvedTargetDir = path.resolve(targetDir);
+    const tool = options.tool || DEFAULT_TOOL;
+
+    // Validate tool option
+    if (!AI_TOOL_CONFIG[tool]) {
+        console.error(chalk.red(`\n❌ Unknown tool: ${tool}`));
+        console.log(chalk.yellow('\nAvailable tools:'));
+        console.log(chalk.gray(getAvailableToolsHelp()));
+        throw new Error(`Unknown tool: ${tool}. Use one of: ${Object.keys(AI_TOOL_CONFIG).join(', ')}`);
+    }
+
+    const toolConfig = AI_TOOL_CONFIG[tool];
+
+    console.log(chalk.cyan('\n☀️  SunLint Init - Setting up code quality standards...\n'));
+    console.log(chalk.blue(`  🤖 Target AI Tool: ${toolConfig.name}`));
+
+    // Validate target directory exists
+    if (!fs.existsSync(resolvedTargetDir)) {
+        throw new Error(`Target directory does not exist: ${resolvedTargetDir}`);
+    }
+
+    const skillTargetDir = path.join(resolvedTargetDir, toolConfig.skillPath, 'sunlint-code-quality');
+    const agentsTargetPath = path.join(resolvedTargetDir, 'AGENTS.md');
+
+    // Step 1: Copy skill folder
+    await copySkillFolder(skillTargetDir, options, toolConfig);
+
+    // Step 2: Append/Create AGENTS.md
+    await setupAgentsMd(agentsTargetPath, options);
+
+    console.log(chalk.green('\n✅ SunLint initialization complete!\n'));
+    console.log(chalk.white('  Files created/updated:'));
+    console.log(chalk.gray(`    • ${path.relative(resolvedTargetDir, skillTargetDir)}/`));
+    console.log(chalk.gray(`    • AGENTS.md`));
+    console.log(chalk.cyan(`\n📖 ${toolConfig.name} will now follow SunLint code quality standards.\n`));
+}
+
+/**
+ * Copy the skill folder to target location
+ * @param {string} targetPath - Target path for the skill folder
+ * @param {object} options - Command options
+ * @param {object} toolConfig - AI tool configuration
+ */
+async function copySkillFolder(targetPath, options = {}, toolConfig = {}) {
+    const force = options.force || false;
+
+    // Check if skill folder already exists
+    if (fs.existsSync(targetPath)) {
+        if (!force) {
+            console.log(chalk.yellow(`  ⚠️  Skill folder already exists: ${targetPath}`));
+            console.log(chalk.yellow('     Use --force to overwrite.'));
+            return;
+        }
+        console.log(chalk.yellow(`  🔄 Overwriting existing skill folder...`));
+        fs.rmSync(targetPath, { recursive: true });
+    }
+
+    // Create parent directories if they don't exist
+    const parentDir = path.dirname(targetPath);
+    if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+    }
+
+    // Copy skill folder recursively
+    const relativePath = toolConfig.skillPath || '.agent/skills';
+    console.log(chalk.blue(`  📁 Copying skill folder to ${relativePath}/sunlint-code-quality/`));
+    copyDirectoryRecursive(SKILL_SOURCE_DIR, targetPath);
+}
+
+/**
+ * Recursively copy a directory
+ * @param {string} source - Source directory
+ * @param {string} target - Target directory
+ */
+function copyDirectoryRecursive(source, target) {
+    if (!fs.existsSync(source)) {
+        throw new Error(`Source directory not found: ${source}`);
+    }
+
+    fs.mkdirSync(target, { recursive: true });
+
+    const items = fs.readdirSync(source);
+
+    for (const item of items) {
+        const sourcePath = path.join(source, item);
+        const targetPath = path.join(target, item);
+
+        const stat = fs.statSync(sourcePath);
+
+        if (stat.isDirectory()) {
+            copyDirectoryRecursive(sourcePath, targetPath);
+        } else {
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}
+
+/**
+ * Setup AGENTS.md - append or create
+ * @param {string} targetPath - Target path for AGENTS.md
+ * @param {object} options - Command options
+ */
+async function setupAgentsMd(targetPath, options = {}) {
+    const force = options.force || false;
+
+    // Read the source AGENTS.md content
+    if (!fs.existsSync(AGENTS_MD_SOURCE)) {
+        throw new Error(`Source AGENTS.md not found: ${AGENTS_MD_SOURCE}`);
+    }
+
+    const sunlintAgentsContent = fs.readFileSync(AGENTS_MD_SOURCE, 'utf-8');
+    const separator = '\n\n---\n\n<!-- SunLint Code Quality Standards - Auto-generated by sunlint init -->\n\n';
+
+    if (fs.existsSync(targetPath)) {
+        // Check if already contains SunLint content
+        const existingContent = fs.readFileSync(targetPath, 'utf-8');
+
+        if (existingContent.includes('SunLint Code Quality & Security Standards')) {
+            if (!force) {
+                console.log(chalk.yellow(`  ⚠️  AGENTS.md already contains SunLint standards.`));
+                console.log(chalk.yellow('     Use --force to replace.'));
+                return;
+            }
+            // Remove existing SunLint section and append new one
+            console.log(chalk.yellow(`  🔄 Updating SunLint section in AGENTS.md...`));
+            const cleanedContent = removeSunlintSection(existingContent);
+            fs.writeFileSync(targetPath, cleanedContent + separator + sunlintAgentsContent, 'utf-8');
+        } else {
+            // Append to existing file
+            console.log(chalk.blue(`  📝 Appending SunLint standards to existing AGENTS.md`));
+            fs.appendFileSync(targetPath, separator + sunlintAgentsContent, 'utf-8');
+        }
+    } else {
+        // Create new AGENTS.md
+        console.log(chalk.blue(`  📝 Creating new AGENTS.md with SunLint standards`));
+        fs.writeFileSync(targetPath, sunlintAgentsContent, 'utf-8');
+    }
+}
+
+/**
+ * Remove existing SunLint section from content
+ * @param {string} content - Existing file content
+ * @returns {string} - Content without SunLint section
+ */
+function removeSunlintSection(content) {
+    // Find and remove the SunLint section (from marker to end or next major section)
+    const sunlintMarkerStart = content.indexOf('<!-- SunLint Code Quality Standards');
+    if (sunlintMarkerStart === -1) {
+        // Try alternative marker
+        const altMarkerStart = content.indexOf('# 🦾 SunLint Code Quality');
+        if (altMarkerStart === -1) {
+            return content;
+        }
+        // Remove from this point to end
+        return content.substring(0, altMarkerStart).trim();
+    }
+
+    return content.substring(0, sunlintMarkerStart).trim();
+}
+
+module.exports = {
+    initProject,
+    copySkillFolder,
+    setupAgentsMd,
+    AI_TOOL_CONFIG,
+    DEFAULT_TOOL,
+    getAvailableToolsHelp,
+};

package/core/output-service.js

@@ -242,7 +242,8 @@ class OutputService {
         cwd: process.cwd(),
         filesAnalyzed: totalFiles,
         duration: metadata.duration,
-        version: metadata.version || this.version
+        version: metadata.version || this.version,
+        architecture: results.architecture || null
       }
     );
 
@@ -431,10 +432,39 @@ class OutputService {
     const jsonResults = [];
     const fileGroups = {};
 
+    // Combine code quality violations with architecture violations
+    const combinedViolations = [...allViolations];
+
+    // Include architecture violations if available
+    if (results.architecture && results.architecture.violations) {
+      const cwd = process.cwd();
+      for (const archViolation of results.architecture.violations) {
+        let file = archViolation.file || 'unknown';
+
+        // Convert absolute path to relative path
+        if (file !== 'unknown' && path.isAbsolute(file)) {
+          if (file.startsWith(cwd)) {
+            file = path.relative(cwd, file);
+          }
+        }
+
+        combinedViolations.push({
+          file: file,
+          ruleId: archViolation.ruleId,
+          severity: archViolation.severity,
+          message: archViolation.message,
+          line: archViolation.line || 1,
+          column: archViolation.column || 1,
+          category: 'architecture',
+          source: 'architecture-detection'
+        });
+      }
+    }
+
     // Group violations by file
-    allViolations.forEach(violation => {
+    combinedViolations.forEach(violation => {
       let file = violation.file || violation.filePath || 'unknown';
-      
+
       // Convert absolute path to relative path for better display
       if (file !== 'unknown' && path.isAbsolute(file)) {
         const cwd = process.cwd();
@@ -442,7 +472,7 @@ class OutputService {
           file = path.relative(cwd, file);
         }
       }
-      
+
       if (!fileGroups[file]) {
         fileGroups[file] = [];
       }
@@ -460,7 +490,8 @@ class OutputService {
         nodeType: violation.nodeType || null,
         messageId: violation.messageId || null,
         endLine: violation.endLine || null,
-        endColumn: violation.endColumn || null
+        endColumn: violation.endColumn || null,
+        category: violation.category || null // Include category for architecture violations
       }));
 
       jsonResults.push({
@@ -495,6 +526,23 @@ class OutputService {
       });
     }
 
+    // Add architecture metadata as a special entry (maintains ESLint compatibility)
+    if (results.architecture && results.architecture.summary) {
+      jsonResults.push({
+        filePath: '__sunlint_architecture__',
+        _type: 'architecture-metadata',
+        _architectureSummary: results.architecture.summary,
+        messages: [],
+        suppressedMessages: [],
+        errorCount: 0,
+        warningCount: 0,
+        fatalErrorCount: 0,
+        fixableErrorCount: 0,
+        fixableWarningCount: 0,
+        source: null
+      });
+    }
+
     return jsonResults;
   }
 

package/core/summary-report-service.js

@@ -268,6 +268,52 @@ class SummaryReportService {
       }
     };
 
+    // Add architecture analysis if available
+    if (options.architecture && options.architecture.summary) {
+      const archSummary = options.architecture.summary;
+      summaryReport.architecture = {
+        primary_pattern: archSummary.primaryPattern || 'UNKNOWN',
+        primary_confidence: Math.round((archSummary.primaryConfidence || 0) * 100),
+        health_score: Math.round(archSummary.healthScore || 0),
+        violation_count: archSummary.violationCount || 0,
+        rules_checked: archSummary.rulesChecked || 0,
+        rules_passed: archSummary.rulesPassed || 0,
+        rules_failed: archSummary.rulesFailed || 0,
+        is_hybrid: archSummary.isHybrid || false,
+        combination: archSummary.combination || null,
+        secondary_patterns: (archSummary.secondaryPatterns || []).map(p => ({
+          pattern: p.pattern,
+          confidence: Math.round((p.confidence || 0) * 100)
+        })),
+        analysis_time_ms: archSummary.analysisTime || 0
+      };
+
+      // Add all rules with score > 0 (passed + failed) to report
+      if (options.architecture.allRules && options.architecture.allRules.length > 0) {
+        summaryReport.architecture.rules = options.architecture.allRules
+          .filter(r => r.score > 0) // Only include rules with evidence (score > 0)
+          .map(r => ({
+            rule_code: r.ruleId,
+            rule_name: r.ruleName,
+            score: r.score,
+            status: r.status,
+            passed: r.passed
+          }));
+      }
+
+      // Add architecture violations to violations summary (only score > 0)
+      if (options.architecture.violations && options.architecture.violations.length > 0) {
+        summaryReport.architecture.violations = options.architecture.violations.map(v => ({
+          rule_code: v.ruleId,
+          score: v.score || 0,
+          severity: v.severity,
+          message: v.message,
+          file: v.file,
+          line: v.line || 1
+        }));
+      }
+    }
+
     return summaryReport;
   }
 

package/core/unified-rule-registry.js

@@ -310,7 +310,8 @@ class UnifiedRuleRegistry {
    */
   registerEngineCapabilities() {
     // Define what each engine can handle
-    this.engineCapabilities.set('heuristic', ['semantic', 'ast', 'regex']);
+    // 'heuristic' strategy type added to support rules that use heuristic-based detection
+    this.engineCapabilities.set('heuristic', ['semantic', 'ast', 'regex', 'heuristic']);
     this.engineCapabilities.set('eslint', ['ast', 'regex']);
     this.engineCapabilities.set('openai', ['semantic']);
     

package/engines/eslint-engine.js

@@ -1228,6 +1228,12 @@ export default [
             results.metadata.warnings = ['ESLint analysis failed due to plugin compatibility issues'];
             return results;
           }
+        } else if (lintError.message && lintError.message.includes('Could not find config file')) {
+          // No ESLint config found - gracefully skip ESLint analysis
+          console.warn('⚠️ [ESLintEngine] No ESLint config file found in project');
+          console.warn('💡 [ESLintEngine] Create eslint.config.js or use --engine=heuristic to skip ESLint');
+          results.metadata.warnings = ['ESLint config not found - analysis skipped'];
+          return results;
         } else {
           // Re-throw other errors
           throw lintError;

package/engines/impact/core/detectors/database-detector.js

@@ -23,7 +23,7 @@ export class DatabaseDetector {
    */
   async detect(changedFiles) {
     const startTime = Date.now();
-    this.logger.info('\n   🔍 Analyzing database impacts...');
+    this.logger.verbose('DatabaseDetector', '\n   🔍 Analyzing database impacts...');
     this.logger.verbose('DatabaseDetector', `Processing ${changedFiles.length} files`);
 
     const databaseChanges = {

package/engines/impact/core/detectors/endpoint-detector.js

@@ -33,7 +33,7 @@ export class EndpointDetector {
       return [];
     }
 
-    this.logger.info(`\n   🔍 Finding affected endpoints for ${allChangedMethods.length} changed methods...`);
+    this.logger.verbose('EndpointDetector', `\n   🔍 Finding affected endpoints for ${allChangedMethods.length} changed methods...`);
     this.logger.verbose('EndpointDetector', `Call graph size: ${this.methodCallGraph.methodCallMap.size} entries`);
 
     const affectedEndpoints = this.methodCallGraph.findAffectedEndpoints(allChangedMethods);