@sun-asterisk/sunlint 1.3.37 → 1.3.39

package/cli.js

@@ -24,16 +24,18 @@ program
   .command('init [directory]')
   .description('Initialize a project with SunLint code quality skill and AGENTS.md')
   .option('-f, --force', 'Overwrite existing files')
-  .option('-t, --tool <tool>', `Target AI tool (default: ${DEFAULT_TOOL})`, DEFAULT_TOOL)
+  .option('-t, --tool <tool>', `Target AI tool (default: ${DEFAULT_TOOL})`)
+  .option('-l, --language <language>', `Target language (default: typescript)`)
+  .option('--non-interactive', 'Disable interactive prompts')
   .addHelpText('after', `
 AI Tool Options:
 ${getAvailableToolsHelp()}
 
 Examples:
-  $ sunlint init                     # Use default (antigravity)
+  $ sunlint init                     # Use default (antigravity, typescript)
   $ sunlint init -t cursor           # For Cursor AI
-  $ sunlint init -t claude           # For Claude
-  $ sunlint init -t github-copilot   # For GitHub Copilot
+  $ sunlint init -l csharp           # For C# project
+  $ sunlint init -t github-copilot -l csharp   # For GitHub Copilot with C# rules
   $ sunlint init ./my-project -t cursor --force
 `)
   .action(async (directory, options) => {

package/config/rules/enhanced-rules-registry.json

@@ -3640,6 +3640,39 @@
         "headers",
         "privacy"
       ]
+    },
+    "D001": {
+      "id": "D001",
+      "name": "Recommended Lint Rules Should Be Enabled",
+      "description": "Ensure recommended lint rules from flutter_lints or very_good_analysis are enabled in analysis_options.yaml with appropriate severity",
+      "category": "dart",
+      "severity": "warning",
+      "languages": [
+        "dart"
+      ],
+      "analyzer": "dart",
+      "config": "./rules/dart/D001_recommended_lint_rules/config.json",
+      "version": "1.0.0",
+      "status": "stable",
+      "tags": [
+        "dart",
+        "flutter",
+        "lint",
+        "best-practices",
+        "code-quality"
+      ],
+      "strategy": {
+        "preferred": "dart",
+        "fallbacks": [],
+        "accuracy": {
+          "dart": 95
+        }
+      },
+      "engineMappings": {
+        "dart": [
+          "D001_recommended_lint_rules"
+        ]
+      }
     }
   }
 }

package/config/rules/rules-registry-generated.json

@@ -1833,8 +1833,8 @@
       ]
     },
     "D001": {
-      "name": "Keep parameter names consistent when overriding methods",
-      "description": "Maintain consistency between inherited classes",
+      "name": "Recommended Lint Rules Should Be Enabled",
+      "description": "Ensure code quality through standard lint configurations",
       "category": "Common",
       "severity": "major",
       "languages": [
@@ -1848,7 +1848,9 @@
         "code-quality"
       ],
       "tools": [
-        "`dart lint` (`avoid_renaming_method_parameters`)"
+        "`dart lint` (flutter_lints",
+        "very_good_analysis",
+        "lints)"
       ],
       "framework": "All",
       "principles": [

package/config/rules-summary.json

@@ -404,7 +404,7 @@
       },
       {
         "id": "D001",
-        "name": "Keep parameter names consistent when overriding methods",
+        "name": "Recommended Lint Rules Should Be Enabled",
         "severity": "major",
         "status": "activated"
       },

package/core/cli-action-handler.js

@@ -170,7 +170,8 @@ class CliActionHandler {
           performanceMode: this.options.performanceMode,
           ruleBatchSize: parseInt(this.options.ruleBatchSize) || 10,
           fileBatchSize: parseInt(this.options.fileBatchSize) || 50,
-          maxFiles: parseInt(this.options.maxFiles) || 1000,
+          // maxFiles: 0 or undefined = unlimited, positive number = limit
+          maxFiles: parseInt(this.options.maxFiles) || 0,
           enableFileFiltering: !this.options.noFileFiltering,
           enableBatching: !this.options.noBatching
         }

package/core/cli-program.js

@@ -85,8 +85,8 @@ function createCliProgram() {
   program
     .option('--performance <mode>', 'Performance mode: auto, fast, careful', 'auto')
     .option('--timeout <ms>', 'Analysis timeout in milliseconds', '0')
-    .option('--max-files <n>', 'Maximum files to analyze', '0')
-    .option('--max-semantic-files <n>', 'TypeScript symbol table limit (default: 1000)');
+    .option('--max-files <n>', 'Maximum files to analyze (0=unlimited)', '0')
+    .option('--max-semantic-files <n>', 'TypeScript symbol table limit (0=unlimited, default=1000)');
 
   // ──────────────────────────────────────────────────────────────
   // Output Control

package/core/init-command.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
+const readline = require('readline');
 
 // 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');
@@ -51,6 +52,52 @@ function getAvailableToolsHelp() {
         .join('\n');
 }
 
+/**
+ * Get available languages from rules directory
+ */
+function getAvailableLanguages() {
+    const rulesDir = path.join(SKILL_SOURCE_DIR, 'rules');
+    if (!fs.existsSync(rulesDir)) return ['typescript', 'csharp', 'python'];
+
+    return fs.readdirSync(rulesDir)
+        .filter(item => {
+            const fullPath = path.join(rulesDir, item);
+            return fs.statSync(fullPath).isDirectory();
+        });
+}
+
+/**
+ * Interactive selection helper
+ */
+async function promptSelection(question, options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        console.log(chalk.cyan(`\n? ${question}`));
+        options.forEach((opt, i) => {
+            console.log(`  ${chalk.white(i + 1)}) ${opt.name || opt}`);
+        });
+
+        const ask = () => {
+            rl.question(chalk.yellow(`\nSelect [1-${options.length}]: `), (answer) => {
+                const choice = parseInt(answer.trim());
+                if (choice >= 1 && choice <= options.length) {
+                    rl.close();
+                    const selected = options[choice - 1];
+                    resolve(selected.key || selected);
+                } else {
+                    console.log(chalk.red(`Invalid selection. Please enter a number between 1 and ${options.length}.`));
+                    ask();
+                }
+            });
+        };
+        ask();
+    });
+}
+
 /**
  * Initialize a project with SunLint skill and AGENTS.md
  * @param {string} targetDir - The target project directory
@@ -58,7 +105,33 @@ function getAvailableToolsHelp() {
  */
 async function initProject(targetDir, options = {}) {
     const resolvedTargetDir = path.resolve(targetDir);
-    const tool = options.tool || DEFAULT_TOOL;
+
+    let tool = options.tool;
+    let language = options.language;
+
+    // Interactive step-by-step setup if options are missing and in TTY
+    if (process.stdin.isTTY && process.stdout.isTTY && !options.nonInteractive) {
+        if (!tool) {
+            const toolOptions = Object.entries(AI_TOOL_CONFIG).map(([key, config]) => ({
+                key,
+                name: config.name
+            }));
+            tool = await promptSelection('Select Target AI Tool', toolOptions);
+        }
+
+        if (!language) {
+            const languageOptions = getAvailableLanguages();
+            language = await promptSelection('Select Target Language', languageOptions);
+        }
+    }
+
+    // Apply defaults if still missing (non-interactive or failed prompt)
+    tool = tool || DEFAULT_TOOL;
+    language = language || 'typescript';
+
+    // Update options for subsequent steps
+    options.tool = tool;
+    options.language = language;
 
     // Validate tool option
     if (!AI_TOOL_CONFIG[tool]) {
@@ -72,6 +145,7 @@ async function initProject(targetDir, options = {}) {
 
     console.log(chalk.cyan('\n☀️  SunLint Init - Setting up code quality standards...\n'));
     console.log(chalk.blue(`  🤖 Target AI Tool: ${toolConfig.name}`));
+    console.log(chalk.blue(`  📝 Target Language: ${language}`));
 
     // Validate target directory exists
     if (!fs.existsSync(resolvedTargetDir)) {
@@ -91,7 +165,7 @@ async function initProject(targetDir, options = {}) {
     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`));
+    console.log(chalk.cyan(`\n📖 ${toolConfig.name} will now follow SunLint code quality standards for ${language}.\n`));
 }
 
 /**
@@ -120,10 +194,43 @@ async function copySkillFolder(targetPath, options = {}, toolConfig = {}) {
         fs.mkdirSync(parentDir, { recursive: true });
     }
 
-    // Copy skill folder recursively
+    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/`));
-    copyDirectoryRecursive(SKILL_SOURCE_DIR, targetPath);
+
+    // 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);
+        }
+    }
 }
 
 /**
@@ -133,7 +240,8 @@ async function copySkillFolder(targetPath, options = {}, toolConfig = {}) {
  */
 function copyDirectoryRecursive(source, target) {
     if (!fs.existsSync(source)) {
-        throw new Error(`Source directory not found: ${source}`);
+        // throw new Error(`Source directory not found: ${source}`);
+        return;
     }
 
     fs.mkdirSync(target, { recursive: true });

package/core/output-service.js

@@ -381,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`;
+        }
       });
     });
 

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/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);
       

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);

package/docs/REGISTRY_GENERATION_DIAGRAM.md

@@ -0,0 +1,289 @@
+# Registry Generation - Visual Diagram
+
+> Quick visual reference cho registry generation flow
+
+---
+
+## 🔄 High-Level Overview
+
+```
+    EDIT HERE                AUTO-COPY              AUTO-GENERATE           USED HERE
+        ↓                        ↓                        ↓                     ↓
+┌──────────────┐        ┌──────────────┐        ┌──────────────┐        ┌──────────────┐
+│   Markdown   │   →    │ origin-rules │   →    │   Registry   │   →    │   SunLint    │
+│    Files     │        │   (copies)   │        │     JSON     │        │   CLI/VSCode │
+└──────────────┘        └──────────────┘        └──────────────┘        └──────────────┘
+  dart-en.md           dart-en.md (copy)    rules-registry-    Display rule names
+  common-en.md         common-en.md          generated.json    Show descriptions
+                                                                Run analysis
+```
+
+---
+
+## 📂 Directory Structure
+
+```
+engineer-excellence/
+│
+├── coding-quality/
+│   │
+│   ├── rules/                                    ← 📝 EDIT HERE (Step 1)
+│   │   ├── dart-en.md                           ← Source of Truth
+│   │   ├── dart.md                              ← Vietnamese version
+│   │   ├── common-en.md
+│   │   ├── security-en.md
+│   │   ├── examples/
+│   │   │   ├── en/D001.md                       ← Create examples
+│   │   │   └── vi/D001.md
+│   │   └── ...
+│   │
+│   └── extensions/sunlint/
+│       │
+│       ├── origin-rules/                        ← 📋 AUTO-COPIED (Step 2)
+│       │   ├── dart-en.md                       ← Copy from ../../../rules/
+│       │   ├── common-en.md
+│       │   └── ...
+│       │
+│       ├── config/
+│       │   └── rules/
+│       │       └── rules-registry-generated.json ← 🤖 AUTO-GENERATED (Step 3)
+│       │
+│       └── scripts/
+│           ├── copy-rules.js                    ← Run this first
+│           └── generate-rules-registry.js       ← Then run this
+```
+
+---
+
+## 🔄 Step-by-Step Flow
+
+### Step 1: Edit Markdown (SOURCE OF TRUTH)
+
+```
+📝 Edit: coding-quality/rules/dart-en.md
+
+┌─────────────────────────────────────────────────────────────┐
+│ ### 📘 Rule D001 – Recommended Lint Rules Should Be Enabled │
+│                                                               │
+│ - **Objective**: Ensure code quality...                     │
+│ - **Details**: The `analysis_options.yaml`...               │
+│ - **Applies to**: Flutter/Dart                              │
+│ - **Tools**: `dart lint` (flutter_lints...)                 │
+│ - **Principles**: CODE_QUALITY                              │
+│ - **Version**: 1.0                                          │
+│ - **Status**: activated                                     │
+│ - **Severity**: major                                       │
+└─────────────────────────────────────────────────────────────┘
+                           ↓
+                    This is what users
+                    will see in CLI
+```
+
+### Step 2: Copy Rules Script
+
+```bash
+$ cd coding-quality/extensions/sunlint
+$ node scripts/copy-rules.js
+```
+
+```
+📋 Copy Process:
+
+   Source                           Destination
+      ↓                                  ↓
+../../../rules/                  origin-rules/
+   ├── dart-en.md        →          ├── dart-en.md
+   ├── common-en.md      →          ├── common-en.md
+   ├── security-en.md    →          ├── security-en.md
+   └── ...               →          └── ...
+
+✅ Successfully copied 8 rule files
+```
+
+### Step 3: Generate Registry Script
+
+```bash
+$ node scripts/generate-rules-registry.js
+```
+
+```
+🤖 Generation Process:
+
+   origin-rules/                Parser Logic              config/rules/
+      ↓                              ↓                         ↓
+   dart-en.md          →      Extract:              rules-registry-generated.json
+   common-en.md        →      - Rule ID (D001)             {
+   security-en.md      →      - Name                        "rules": {
+   ...                 →      - Description                   "D001": {
+                              - Tools                            "name": "Recommended...",
+                              - Severity                         "description": "...",
+                              - etc.                             "severity": "major",
+                                                                 ...
+                                                               }
+                                                             }
+                                                           }
+
+✅ Generated registry with 257 rules
+```
+
+### Step 4: Used by SunLint
+
+```
+   config/rules/                UnifiedRuleRegistry           CLI Output
+         ↓                              ↓                         ↓
+rules-registry-                 Loads registry            $ sunlint --rule=D001
+generated.json          →       Finds D001 entry    →
+   {                            Reads:                    D001: Recommended Lint
+     "D001": {                  - name                    Rules Should Be Enabled
+       "name": "...",           - description             ─────────────────────
+       "description": "..."     - severity                analysis_options.yaml
+     }                                                    1:1 warning ...
+   }
+```
+
+---
+
+## 🔁 Complete Cycle with Example
+
+### Scenario: Rename Rule D001
+
+```
+┌─ STEP 1: Edit Markdown ────────────────────────────────────┐
+│                                                              │
+│ $ vim ../../../rules/dart-en.md                             │
+│                                                              │
+│ BEFORE:                                                      │
+│ ### 📘 Rule D001 – Keep parameter names consistent          │
+│                                                              │
+│ AFTER:                                                       │
+│ ### 📘 Rule D001 – Recommended Lint Rules Should Be Enabled │
+│                                                              │
+└──────────────────────────────────────────────────────────────┘
+                           ↓
+┌─ STEP 2: Copy Rules ───────────────────────────────────────┐
+│                                                              │
+│ $ node scripts/copy-rules.js                                │
+│                                                              │
+│ Output:                                                      │
+│ ✅ Copied: dart-en.md                                        │
+│ ✅ Successfully copied 8 rule files                          │
+│                                                              │
+└──────────────────────────────────────────────────────────────┘
+                           ↓
+┌─ STEP 3: Generate Registry ────────────────────────────────┐
+│                                                              │
+│ $ node scripts/generate-rules-registry.js                   │
+│                                                              │
+│ Output:                                                      │
+│ Parsed rule D001: 0 good examples, 0 bad examples          │
+│ ✅ Generated registry with 257 rules                         │
+│                                                              │
+└──────────────────────────────────────────────────────────────┘
+                           ↓
+┌─ STEP 4: Verify ───────────────────────────────────────────┐
+│                                                              │
+│ $ grep -A 3 '"D001"' config/rules/rules-registry-          │
+│   generated.json                                            │
+│                                                              │
+│ Output:                                                      │
+│ "D001": {                                                   │
+│   "name": "Recommended Lint Rules Should Be Enabled",      │
+│   "description": "Ensure code quality...",                 │
+│   ...                                                       │
+│ }                                                           │
+│                                                              │
+└──────────────────────────────────────────────────────────────┘
+                           ↓
+┌─ STEP 5: Test ─────────────────────────────────────────────┐
+│                                                              │
+│ $ node cli.js --rule=D001 --input=./test --languages=dart  │
+│                                                              │
+│ Output shows NEW NAME:                                      │
+│ D001: Recommended Lint Rules Should Be Enabled             │
+│ ─────────────────────────────────────────────────           │
+│ analysis_options.yaml                                       │
+│ 1:1 warning ...                                             │
+│                                                              │
+└──────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## ❌ Wrong Way vs ✅ Right Way
+
+### ❌ WRONG: Edit JSON Directly
+
+```
+┌─ WRONG APPROACH ──────────────────────────────────────────┐
+│                                                             │
+│ $ vim config/rules/rules-registry-generated.json          │
+│                                                             │
+│ Change:                                                     │
+│ "name": "Old Name"                                         │
+│ To:                                                         │
+│ "name": "New Name"                                         │
+│                                                             │
+│ ❌ Problem: Will be overwritten on next generation!        │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### ✅ RIGHT: Edit Markdown → Regenerate
+
+```
+┌─ CORRECT APPROACH ────────────────────────────────────────┐
+│                                                             │
+│ STEP 1: Edit source                                        │
+│ $ vim ../../../rules/dart-en.md                            │
+│ Change: ### 📘 Rule D001 – Old Name                        │
+│ To:     ### 📘 Rule D001 – New Name                        │
+│                                                             │
+│ STEP 2 & 3: Regenerate                                    │
+│ $ node scripts/copy-rules.js                               │
+│ $ node scripts/generate-rules-registry.js                  │
+│                                                             │
+│ ✅ Result: Changes persist, properly tracked in git        │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🎯 Quick Reference Card
+
+```
+╔═══════════════════════════════════════════════════════════╗
+║               REGISTRY GENERATION CHEATSHEET              ║
+╠═══════════════════════════════════════════════════════════╣
+║                                                           ║
+║  📝 To change rule name:                                  ║
+║     1. Edit: ../../../rules/dart-en.md                   ║
+║     2. Run:  node scripts/copy-rules.js                  ║
+║     3. Run:  node scripts/generate-rules-registry.js     ║
+║                                                           ║
+║  🔍 To verify changes:                                    ║
+║     grep '"D001"' config/rules/rules-registry-           ║
+║     generated.json                                        ║
+║                                                           ║
+║  ✅ Files you SHOULD edit:                                ║
+║     - coding-quality/rules/dart-en.md                    ║
+║     - coding-quality/rules/dart.md                       ║
+║     - coding-quality/rules/examples/en/D001.md           ║
+║                                                           ║
+║  ❌ Files you should NEVER edit:                          ║
+║     - origin-rules/*.md (auto-copied)                    ║
+║     - config/rules/rules-registry-generated.json         ║
+║                                                           ║
+║  📖 Read more:                                            ║
+║     docs/REGISTRY_GENERATION_FLOW.md                     ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+```
+
+---
+
+## 🔗 Related Documents
+
+- [REGISTRY_GENERATION_FLOW.md](./REGISTRY_GENERATION_FLOW.md) - Detailed explanation
+- [CREATE_NEW_DART_RULE.md](./skills/CREATE_NEW_DART_RULE.md) - How to create rules
+- [PROJECT_STRUCTURE.md](./PROJECT_STRUCTURE.md) - Overall structure