@sun-asterisk/sunlint 1.3.48 → 1.3.50

package/core/file-targeting-service.js

@@ -41,7 +41,7 @@ class FileTargetingService {
         allFiles = await this.getGitChangedFiles(cliOptions);
       } else {
         // Smart project-level optimization
-        const optimizedPaths = this.optimizeProjectPaths(inputPaths, cliOptions);
+        const optimizedPaths = this.optimizeProjectPaths(inputPaths, cliOptions, config);
 
         // Use enhanced targeting based on metadata
         if (metadata?.shouldBypassProjectDiscovery) {
@@ -247,7 +247,7 @@ class FileTargetingService {
    * Optimize project paths to focus on source and test directories
    * Prevents unnecessary scanning of entire project when smart targeting is possible
    */
-  optimizeProjectPaths(inputPaths, cliOptions = {}) {
+  optimizeProjectPaths(inputPaths, cliOptions = {}, config = {}) {
     const optimizedPaths = [];
     
     for (const inputPath of inputPaths) {
@@ -268,7 +268,7 @@ class FileTargetingService {
         }
         
         // Only optimize if this appears to be a project root directory
-        const projectOptimization = this.findProjectSourceDirs(inputPath, cliOptions);
+        const projectOptimization = this.findProjectSourceDirs(inputPath, cliOptions, config);
         if (projectOptimization.length > 0) {
           if (cliOptions.verbose) {
             console.log(chalk.blue(`🎯 Smart targeting: Found ${projectOptimization.length} source directories in ${path.basename(inputPath)}`));
@@ -286,26 +286,159 @@ class FileTargetingService {
   }
 
   /**
-   * Find source directories in project to avoid scanning entire project
+   * Find source directories in project to avoid scanning entire project.
+   * When language info is available, dynamically discovers every top-level
+   * directory that actually contains matching language files instead of
+   * relying on a fixed list of directory names.
    */
-  findProjectSourceDirs(projectPath, cliOptions = {}) {
-    const sourceDirs = [];
+  findProjectSourceDirs(projectPath, cliOptions = {}, config = {}) {
+    const testDirNames = ['test', 'tests', '__tests__', 'spec', 'specs'];
+    const targetLanguages = this.getTargetLanguages(config, cliOptions);
+    const targetExtensions = this.getExtensionsForLanguages(targetLanguages);
+
+    if (targetExtensions.length > 0) {
+      // Dynamic discovery: find all top-level dirs that contain matching files
+      let discoveredDirs = this.discoverDirsWithLanguageFiles(projectPath, targetExtensions, cliOptions);
+
+      // Exclude test dirs unless --include-tests is set
+      if (!cliOptions.includeTests) {
+        discoveredDirs = discoveredDirs.filter(dir => !testDirNames.includes(path.basename(dir)));
+      }
+
+      return discoveredDirs;
+    }
+
+    // Fallback: use hardcoded candidate dirs when no language info is available
     const candidateDirs = ['src', 'lib', 'app', 'packages', 'components', 'hooks', 'utils', 'helpers', 'services', 'worker'];
-    const testDirs = ['test', 'tests', '__tests__', 'spec', 'specs'];
-    
-    // Always include test directories if --include-tests flag is used
-    const dirsToCheck = cliOptions.includeTests ? [...candidateDirs, ...testDirs] : candidateDirs;
-    
+    const dirsToCheck = cliOptions.includeTests ? [...candidateDirs, ...testDirNames] : candidateDirs;
+    const sourceDirs = [];
+
     for (const dir of dirsToCheck) {
       const dirPath = path.join(projectPath, dir);
       if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
         sourceDirs.push(dirPath);
       }
     }
-    
+
     return sourceDirs;
   }
 
+  /**
+   * Extract target languages from config or CLI options
+   * Rule C006: getTargetLanguages - verb-noun naming
+   */
+  getTargetLanguages(config, cliOptions) {
+    if (cliOptions.languages) {
+      return cliOptions.languages.split(',').map(l => l.trim());
+    }
+    if (Array.isArray(config.languages)) {
+      return config.languages;
+    }
+    if (config.languages && typeof config.languages === 'object') {
+      return Object.keys(config.languages);
+    }
+    return [];
+  }
+
+  /**
+   * Map language names to their corresponding file extensions
+   * Rule C006: getExtensionsForLanguages - verb-noun naming
+   */
+  getExtensionsForLanguages(languages) {
+    const extensionMap = {
+      typescript: ['.ts', '.tsx', '.mts', '.cts'],
+      javascript: ['.js', '.jsx', '.mjs', '.cjs'],
+      dart:       ['.dart'],
+      kotlin:     ['.kt', '.kts'],
+      java:       ['.java'],
+      swift:      ['.swift'],
+    };
+
+    const extensions = new Set();
+    for (const lang of languages) {
+      (extensionMap[lang] || []).forEach(ext => extensions.add(ext));
+    }
+    return [...extensions];
+  }
+
+  /**
+   * Return every immediate child directory of projectPath that contains
+   * at least one file with a target extension (checked recursively up to
+   * a limited depth so large platform dirs are not fully traversed).
+   * Rule C006: discoverDirsWithLanguageFiles - verb-noun naming
+   */
+  discoverDirsWithLanguageFiles(projectPath, targetExtensions, cliOptions = {}) {
+    const dirs = [];
+
+    try {
+      const entries = fs.readdirSync(projectPath);
+
+      for (const entry of entries) {
+        if (this.shouldSkipDirectory(entry)) continue;
+
+        const fullPath = path.join(projectPath, entry);
+        let stat;
+        try {
+          stat = fs.lstatSync(fullPath);
+        } catch {
+          continue;
+        }
+
+        if (!stat.isDirectory() || stat.isSymbolicLink()) continue;
+
+        if (this.directoryContainsLanguageFiles(fullPath, targetExtensions)) {
+          if (cliOptions.verbose) {
+            console.log(chalk.blue(`🎯 Discovered language directory: ${entry}`));
+          }
+          dirs.push(fullPath);
+        }
+      }
+    } catch {
+      // silent fail — projectPath may be unreadable
+    }
+
+    return dirs;
+  }
+
+  /**
+   * Check recursively (up to depth) whether a directory contains at least
+   * one file whose extension is in targetExtensions.
+   * Rule C012: Query method - returns boolean, no side effects
+   */
+  directoryContainsLanguageFiles(dirPath, targetExtensions, depth = 5) {
+    if (depth <= 0) return false;
+
+    try {
+      const entries = fs.readdirSync(dirPath);
+
+      for (const entry of entries) {
+        if (this.shouldSkipDirectory(entry)) continue;
+
+        const fullPath = path.join(dirPath, entry);
+        let stat;
+        try {
+          stat = fs.lstatSync(fullPath);
+        } catch {
+          continue;
+        }
+
+        if (stat.isSymbolicLink()) continue;
+
+        if (stat.isFile()) {
+          if (targetExtensions.includes(path.extname(entry).toLowerCase())) return true;
+        } else if (stat.isDirectory()) {
+          if (this.directoryContainsLanguageFiles(fullPath, targetExtensions, depth - 1)) {
+            return true;
+          }
+        }
+      }
+    } catch {
+      // ignore unreadable subdirectory
+    }
+
+    return false;
+  }
+
   /**
    * Check if directory should be skipped
    * Enhanced with more comprehensive ignore patterns
@@ -771,7 +904,7 @@ class FileTargetingService {
    * Rule C012: Query method - returns boolean
    */
   isSourceFile(filePath, config) {
-    const sourceExtensions = ['.ts', '.tsx', '.js', '.jsx', '.dart', '.kt', '.java', '.swift'];
+    const sourceExtensions = ['.ts', '.tsx', '.js', '.jsx', '.dart', '.kt', '.kts', '.java', '.swift'];
     const ext = path.extname(filePath);
     return sourceExtensions.includes(ext);
   }
@@ -793,10 +926,10 @@ class FileTargetingService {
         return ext === '.dart' && !normalizedPath.match(/\.(g|freezed|mocks)\.dart$/);
       case 'kotlin':
         return ['.kt', '.kts'].includes(ext);
+      case 'java':
+        return ext === '.java';
       case 'swift':
         return ext === '.swift';
-      case 'python':
-        return ext === '.py';
       default:
         return false;
     }

package/core/init-command.js

@@ -1,13 +1,16 @@
 /**
  * SunLint Init Command
  * Initializes a project with SunLint code quality skill and AGENTS.md
- * Following Rule C005: Single responsibility - only handle init logic
+ * Following Rule C005: Single responsibility - only handle init orchestration
+ * Following Rule C014: Dependency injection via module imports (detector, tui)
  */
 
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
-const readline = require('readline');
+
+const { detectProjectLanguage } = require('./project-detector');
+const { printBanner, printDetectionHint, tuiSelect, tuiConfirm } = require('./tui-select');
 
 // 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');
@@ -62,78 +65,95 @@ function getAvailableLanguages() {
     return fs.readdirSync(rulesDir)
         .filter(item => {
             const fullPath = path.join(rulesDir, item);
-            return fs.statSync(fullPath).isDirectory();
+            // Exclude framework-specific sub-dirs (e.g. php-laravel, ruby-rails, go-gin)
+            // They are installed automatically based on detection, not selectable as base languages.
+            return fs.statSync(fullPath).isDirectory() && !item.includes('-');
         });
 }
 
-/**
- * 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();
-    });
-}
+// (Legacy promptSelection removed — replaced by tuiSelect in initProject)
 
 /**
  * Initialize a project with SunLint skill and AGENTS.md
+ * Uses TUI arrow-key selection and auto-detects project language preset.
+ *
  * @param {string} targetDir - The target project directory
- * @param {object} options - Command options
+ * @param {object} options   - CLI options {tool, language, force, nonInteractive}
  */
 async function initProject(targetDir, options = {}) {
     const resolvedTargetDir = path.resolve(targetDir);
 
+    // Validate target directory exists early
+    if (!fs.existsSync(resolvedTargetDir)) {
+        throw new Error(`Target directory does not exist: ${resolvedTargetDir}`);
+    }
+
     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) {
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY && !options.nonInteractive;
+
+    if (isInteractive) {
+        printBanner();
+
+        // ── Step 1: Auto-detect language preset ──────────────────────────────
+        const detection = options.language ? null : detectProjectLanguage(resolvedTargetDir);
+        printDetectionHint(detection);
+
+        // ── Step 2: Select AI tool ────────────────────────────────────────────
         if (!tool) {
-            const toolOptions = Object.entries(AI_TOOL_CONFIG).map(([key, config]) => ({
-                key,
-                name: config.name
-            }));
-            tool = await promptSelection('Select Target AI Tool', toolOptions);
+            const toolKeys   = Object.keys(AI_TOOL_CONFIG);
+            const toolLabels = Object.fromEntries(
+                Object.entries(AI_TOOL_CONFIG).map(([k, v]) => [k, v.name])
+            );
+            const toolDescs = Object.fromEntries(
+                Object.entries(AI_TOOL_CONFIG).map(([k, v]) => [k, v.skillPath + '/'])
+            );
+            const defaultToolIndex = toolKeys.indexOf(DEFAULT_TOOL);
+
+            tool = await tuiSelect({
+                question:     'Select Target AI Tool',
+                options:      toolKeys,
+                labels:       toolLabels,
+                badges:       toolDescs,
+                defaultIndex: Math.max(0, defaultToolIndex),
+            });
         }
 
+        // ── Step 3: Select language ───────────────────────────────────────────
         if (!language) {
-            const languageOptions = getAvailableLanguages();
-            language = await promptSelection('Select Target Language', languageOptions);
+            const availableLanguages = getAvailableLanguages();
+            const detectedLang       = detection ? detection.language : null;
+            const defaultLangIndex   = detectedLang
+                ? Math.max(0, availableLanguages.indexOf(detectedLang))
+                : availableLanguages.indexOf('typescript') >= 0
+                    ? availableLanguages.indexOf('typescript')
+                    : 0;
+
+            const langBadges = {};
+            if (detectedLang && availableLanguages.includes(detectedLang)) {
+                const frameworkNote = detection ? `Recommended · ${detection.framework}` : 'Recommended';
+                langBadges[detectedLang] = `[${frameworkNote}]`;
+            }
+
+            language = await tuiSelect({
+                question:     'Select Programming Language',
+                options:      availableLanguages,
+                badges:       langBadges,
+                defaultIndex: defaultLangIndex,
+            });
         }
     }
 
-    // Apply defaults if still missing (non-interactive or failed prompt)
-    tool = tool || DEFAULT_TOOL;
+    // ── Apply defaults for non-interactive / partial flags ───────────────────
+    if (!language) {
+        const detection = detectProjectLanguage(resolvedTargetDir);
+        if (detection) language = detection.language;
+    }
+    tool     = tool     || DEFAULT_TOOL;
     language = language || 'typescript';
 
-    // Update options for subsequent steps
-    options.tool = tool;
-    options.language = language;
-
-    // Validate tool option
+    // ── Validate tool selection ───────────────────────────────────────────────
     if (!AI_TOOL_CONFIG[tool]) {
         console.error(chalk.red(`\n❌ Unknown tool: ${tool}`));
         console.log(chalk.yellow('\nAvailable tools:'));
@@ -141,31 +161,40 @@ async function initProject(targetDir, options = {}) {
         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}`));
-    console.log(chalk.blue(`  📝 Target Language: ${language}`));
+    options.tool     = tool;
+    options.language = language;
 
-    // Validate target directory exists
-    if (!fs.existsSync(resolvedTargetDir)) {
-        throw new Error(`Target directory does not exist: ${resolvedTargetDir}`);
+    // Detect frameworkKey so framework-specific rules can be installed
+    if (options.frameworkKey === undefined) {
+        const fwDetection = detectProjectLanguage(resolvedTargetDir);
+        options.frameworkKey = (fwDetection && fwDetection.language === language)
+            ? (fwDetection.frameworkKey || null)
+            : null;
     }
 
-    const skillTargetDir = path.join(resolvedTargetDir, toolConfig.skillPath, 'sunlint-code-quality');
+    const toolConfig      = AI_TOOL_CONFIG[tool];
+    const skillTargetDir  = path.join(resolvedTargetDir, toolConfig.skillPath, 'sunlint-code-quality');
     const agentsTargetPath = path.join(resolvedTargetDir, 'AGENTS.md');
 
-    // Step 1: Copy skill folder
+    if (!isInteractive) {
+        // Non-interactive: still print a brief summary
+        console.log(chalk.cyan('\n☀️  SunLint Init - Setting up code quality standards...\n'));
+        console.log(chalk.blue(`  🤖 AI Tool: ${toolConfig.name}`));
+        console.log(chalk.blue(`  📝 Language: ${language}`));
+    }
+
+    // ── Step 4: Copy skill folder ─────────────────────────────────────────────
     await copySkillFolder(skillTargetDir, options, toolConfig);
 
-    // Step 2: Append/Create AGENTS.md
+    // ── Step 5: Setup AGENTS.md ───────────────────────────────────────────────
     await setupAgentsMd(agentsTargetPath, options);
 
+    // ── Done ──────────────────────────────────────────────────────────────────
     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 for ${language}.\n`));
+    console.log(chalk.cyan(`\n📖 ${toolConfig.name} will now follow SunLint ${language} quality standards.\n`));
 }
 
 /**
@@ -175,17 +204,15 @@ async function initProject(targetDir, options = {}) {
  * @param {object} toolConfig - AI tool configuration
  */
 async function copySkillFolder(targetPath, options = {}, toolConfig = {}) {
-    const force = options.force || false;
+    // Default to force overwrite — always keep skill folder up to date
+    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;
+        if (force) {
+            console.log(chalk.yellow(`  🔄 Updating existing skill folder...`));
+            fs.rmSync(targetPath, { recursive: true });
         }
-        console.log(chalk.yellow(`  🔄 Overwriting existing skill folder...`));
-        fs.rmSync(targetPath, { recursive: true });
     }
 
     // Create parent directories if they don't exist
@@ -231,6 +258,27 @@ async function copySkillFolder(targetPath, options = {}, toolConfig = {}) {
             copyDirectoryRecursive(fallbackDir, rulesTargetDir);
         }
     }
+
+    // 3. Copy framework-specific rules if a frameworkKey was detected
+    installFrameworkRules(targetPath, options);
+}
+
+/**
+ * Install framework-specific rules into an existing skill folder.
+ * Safe to call even if the rules subfolder already exists (overwrites).
+ * @param {string} targetPath - Path to the installed skill folder
+ * @param {object} options    - Must contain options.frameworkKey if applicable
+ */
+function installFrameworkRules(targetPath, options = {}) {
+    const frameworkKey = options.frameworkKey;
+    if (!frameworkKey) return;
+
+    const frameworkRulesDir = path.join(SKILL_SOURCE_DIR, 'rules', frameworkKey);
+    if (fs.existsSync(frameworkRulesDir)) {
+        const frameworkRulesTargetDir = path.join(targetPath, 'rules', frameworkKey);
+        console.log(chalk.blue(`  🏗️  Installing ${frameworkKey} framework rules...`));
+        copyDirectoryRecursive(frameworkRulesDir, frameworkRulesTargetDir);
+    }
 }
 
 /**