@sun-asterisk/sunlint 1.3.36 → 1.3.38

package/core/init-command.js

@@ -0,0 +1,261 @@
+/**
+ * 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 });
+    }
+
+    const language = options.language || 'typescript';
+
+    // Copy skill folder usage files (root)
+    const relativePath = toolConfig.skillPath || '.agent/skills';
+    console.log(chalk.blue(`  📁 Copying skill folder to ${relativePath}/sunlint-code-quality/`));
+
+    // 1. Copy root files (SKILL.md, AGENTS.md, etc) - Non-recursive
+    fs.mkdirSync(targetPath, { recursive: true });
+
+    // Copy root files
+    if (fs.existsSync(SKILL_SOURCE_DIR)) {
+        const items = fs.readdirSync(SKILL_SOURCE_DIR);
+        for (const item of items) {
+            const sourcePath = path.join(SKILL_SOURCE_DIR, item);
+            const targetItemPath = path.join(targetPath, item);
+            const stat = fs.statSync(sourcePath);
+
+            if (!stat.isDirectory()) {
+                fs.copyFileSync(sourcePath, targetItemPath);
+            }
+        }
+    }
+
+    // 2. Copy Language Rules to rules/ folder
+    const rulesSourceDir = path.join(SKILL_SOURCE_DIR, 'rules', language);
+    const rulesTargetDir = path.join(targetPath, 'rules');
+
+    if (fs.existsSync(rulesSourceDir)) {
+        console.log(chalk.blue(`  📝 Installing ${language} rules...`));
+        copyDirectoryRecursive(rulesSourceDir, rulesTargetDir);
+    } else {
+        console.warn(chalk.yellow(`  ⚠️  Language '${language}' rules not found. Falling back to typescript rules.`));
+        const fallbackDir = path.join(SKILL_SOURCE_DIR, 'rules', 'typescript');
+        if (fs.existsSync(fallbackDir)) {
+            copyDirectoryRecursive(fallbackDir, rulesTargetDir);
+        }
+    }
+}
+
+/**
+ * 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}`);
+        return;
+    }
+
+    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
       }
     );
 
@@ -380,16 +381,22 @@ class OutputService {
       if (index > 0) {
         output += '\n';
       }
-      output += `\n${chalk.underline(path.resolve(file))}\n`;
       
-      sortedViolations.forEach(violation => {
+      sortedViolations.forEach((violation, index) => {
+        const isDuplicateCodeRule = violation.ruleId === 'C002';
+        if (index === 0 && !isDuplicateCodeRule) {
+          output += `\n${chalk.underline(path.resolve(file))}\n`;
+        }
         // Support both location.start.line (new format) and line (legacy format)
         const line = (violation.location?.start?.line || violation.line || 1).toString();
         const column = (violation.location?.start?.column || violation.column || 1).toString();
-        const severityText = violation.severity === 'error' ? 'error' : 'warning';
+        const severityText = violation.severity === 'error' ? 'Error' : 'Warning';
         const severityColor = violation.severity === 'error' ? chalk.red : chalk.yellow;
-
-        output += ` ${chalk.dim(`${line}:${column}`)} ${severityColor(severityText)}  ${violation.message}  ${chalk.gray(violation.ruleId)}\n`;
+        if (isDuplicateCodeRule) {
+          output += `${severityColor(severityText)} ${chalk.white(` ${chalk.underline(path.resolve(file))}:${line}:${column} ${violation.message} ${chalk.yellow(`(Confidence: ${violation.confidence}%)`)}`)}  ${chalk.gray(violation.ruleId)}\n`;
+        } else {
+          output += ` ${chalk.blue(`${line}:${column}`)} ${severityColor(severityText)}  ${violation.message}  ${chalk.gray(violation.ruleId)}\n`;
+        }
       });
     });
 
@@ -431,10 +438,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 +478,7 @@ class OutputService {
           file = path.relative(cwd, file);
         }
       }
-      
+
       if (!fileGroups[file]) {
         fileGroups[file] = [];
       }
@@ -460,7 +496,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 +532,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/performance-optimizer.js

@@ -112,7 +112,7 @@ class PerformanceOptimizer {
           break;
         }
         
-        // Check file count limit (skip if unlimited -1)
+        // Check file count limit (skip if unlimited: 0)
         if (this.fileSizeLimits.maxTotalFiles > 0 && filtered.length >= this.fileSizeLimits.maxTotalFiles) {
           if (this.config.verbose) {
             console.log(`⚠️ Reached file count limit: ${this.fileSizeLimits.maxTotalFiles} files`);

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

@@ -207,8 +207,8 @@ class UnifiedRuleRegistry {
       }
     }
 
-    // Also check other category directories (security, typescript, etc.)
-    const otherDirs = ['security', 'typescript', 'react'];
+    // Also check other category directories (security, typescript, dart, etc.)
+    const otherDirs = ['security', 'typescript', 'dart', 'react'];
     for (const categoryDir of otherDirs) {
       const categoryPath = path.join(rulesBaseDir, categoryDir);
       
@@ -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/docs/DART_RULE_EXECUTION_FLOW.md

@@ -66,7 +66,7 @@ node cli.js --rule=C002 \
 // Line 27-51
 function detectDartSupport(ruleId) {
   const rulesBasePath = path.join(__dirname, '../rules');
-  const categories = ['common', 'security', 'typescript'];
+  const categories = ['common', 'security', 'typescript', 'dart'];
 
   for (const category of categories) {
     const categoryPath = path.join(rulesBasePath, category);