code-simplifier 1.2.0 → 1.2.1

package/lib/ai-knowledge-base.js

@@ -128,6 +128,9 @@ class AIKnowledgeBase {
     // Ensure we meet weekly quota
     await this.ensureWeeklyQuota()
 
+    // Update statistics
+    this.updateStatistics()
+
     await this.saveKnowledgeBase()
 
     return {

package/lib/ai-quality-analyzer.js

@@ -503,73 +503,60 @@ class AIQualityAnalyzer {
   checkHighComplexity(code, language, filePath) {
     const issues = []
     const lines = code.split('\n')
-    const functionRegex = this.getFunctionRegex(language)
-    const functionRegexNoGlobal = new RegExp(functionRegex.source, functionRegex.flags.replace('g', ''))
 
-    let inFunction = false
-    let functionStartLine = 0
+    // Track nested structures by counting braces and if statements
     let braceDepth = 0
-    let decisionPoints = 0
+    let ifDepth = 0
+    let functionStartLine = 0
+    let inFunction = false
+    let maxNestingDepth = 0
 
     lines.forEach((line, index) => {
       const trimmed = line.trim()
 
-      // Check for function start
+      // Check for function definition
+      const functionRegex = this.getFunctionRegex(language)
+      const functionRegexNoGlobal = new RegExp(functionRegex.source, functionRegex.flags.replace('g', ''))
       if (functionRegexNoGlobal.test(line)) {
-        if (inFunction && decisionPoints > 10) {
-          issues.push({
-            type: 'highComplexity',
-            name: CODE_SMELLS.highComplexity.name,
-            severity: CODE_SMELLS.highComplexity.severity,
-            category: CODE_SMELLS.highComplexity.category,
-            line: functionStartLine,
-            message: `Cyclomatic complexity: ${decisionPoints} (recommended: < 10)`,
-            fix: 'Simplify logic by extracting methods or using early returns'
-          })
-        }
-
         inFunction = true
         functionStartLine = index + 1
         braceDepth = 0
-        decisionPoints = 1 // Start with 1 for the function itself
+        ifDepth = 0
+        maxNestingDepth = 0
       }
 
       if (inFunction) {
-        // Count braces to track function scope
-        for (const char of line) {
-          if (char === '{') braceDepth++
-          else if (char === '}') braceDepth--
+        // Count opening braces
+        const openBraces = (line.match(/{/g) || []).length
+        const closeBraces = (line.match(/}/g) || []).length
+        braceDepth += openBraces - closeBraces
+
+        // Track if statement nesting
+        if (trimmed.match(/if\s*\(/)) {
+          ifDepth++
+          if (ifDepth > maxNestingDepth) {
+            maxNestingDepth = ifDepth
+          }
         }
 
-        // Count decision points
-        if (trimmed.includes('if ') || trimmed.includes('else if')) {
-          decisionPoints++
-        } else if (trimmed.includes('for ') || trimmed.includes('while ')) {
-          decisionPoints++
-        } else if (trimmed.includes('case ') || trimmed.includes('default:')) {
-          decisionPoints++
-        } else if (trimmed.includes('catch ')) {
-          decisionPoints++
-        } else if (trimmed.includes('&&')) {
-          decisionPoints++
-        } else if (trimmed.includes('||')) {
-          decisionPoints++
-        }
+        // Check for function end (braceDepth returns to 0 or less)
+        if (braceDepth <= 0 && inFunction && index > functionStartLine) {
+          // Calculate complexity based on nesting depth
+          const complexity = ifDepth + 1 // Base complexity + nesting
 
-        // Check for function end (when we exit the function's brace scope)
-        if (trimmed === '}' && braceDepth === 0) {
-          inFunction = false
-          if (decisionPoints > 10) {
+          if (complexity > 10 || maxNestingDepth > 5) {
             issues.push({
               type: 'highComplexity',
               name: CODE_SMELLS.highComplexity.name,
               severity: CODE_SMELLS.highComplexity.severity,
               category: CODE_SMELLS.highComplexity.category,
               line: functionStartLine,
-              message: `Cyclomatic complexity: ${decisionPoints} (recommended: < 10)`,
+              message: `High cyclomatic complexity or deep nesting (max depth: ${maxNestingDepth})`,
               fix: 'Simplify logic by extracting methods or using early returns'
             })
           }
+
+          inFunction = false
         }
       }
     })
@@ -614,27 +601,19 @@ class AIQualityAnalyzer {
 
     // Check for unreachable code after return/throw
     let foundReturn = false
-    let braceDepth = 0
-    let inBlock = false
 
     lines.forEach((line, index) => {
       const trimmed = line.trim()
 
-      // Track brace depth
-      for (const char of line) {
-        if (char === '{') {
-          braceDepth++
-          inBlock = true
-        } else if (char === '}') {
-          braceDepth--
-          if (braceDepth === 0) {
-            inBlock = false
-            foundReturn = false
-          }
-        }
-      }
-
-      if (foundReturn && trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('*') && !trimmed.match(/^[{}]$/)) {
+      // Check for return/throw/break statements
+      if (trimmed.startsWith('return') || trimmed.startsWith('throw') ||
+          trimmed.startsWith('break') || trimmed.startsWith('exit') ||
+          trimmed.startsWith('sys.exit')) {
+        foundReturn = true
+      } else if (foundReturn && trimmed && !trimmed.startsWith('//') &&
+                 !trimmed.startsWith('*') && !trimmed.startsWith('*') &&
+                 !trimmed.match(/^[{}\]\);,]$/)) {
+        // Found code after return statement
         issues.push({
           type: 'deadCode',
           name: CODE_SMELLS.deadCode.name,
@@ -646,9 +625,9 @@ class AIQualityAnalyzer {
         })
       }
 
-      if (!inBlock && (trimmed.startsWith('return') || trimmed.startsWith('throw') ||
-          trimmed.startsWith('exit') || trimmed.startsWith('sys.exit'))) {
-        foundReturn = true
+      // Reset flag when we hit a closing brace at the same level
+      if (trimmed === '}' && foundReturn) {
+        foundReturn = false
       }
     })
 
@@ -722,9 +701,14 @@ class AIQualityAnalyzer {
         })
       }
 
-      // Hardcoded secrets
-      if (trimmed.includes('api_key') || trimmed.includes('password') ||
-          trimmed.includes('secret') || trimmed.includes('token')) {
+      // Hardcoded secrets - check both snake_case and camelCase
+      const secretKeywords = ['api_key', 'apikey', 'password', 'secret', 'token', 'private_key', 'privatekey']
+      const hasSecretKeyword = secretKeywords.some(keyword => {
+        // Check both snake_case and camelCase versions
+        return trimmed.includes(keyword) || trimmed.includes(keyword.replace('_', ''))
+      })
+
+      if (hasSecretKeyword) {
         // Check for assignment without process.env
         if (trimmed.includes('=') && !trimmed.includes('process.env') &&
             !trimmed.includes('env.') && !trimmed.includes('env[')) {
@@ -795,12 +779,13 @@ class AIQualityAnalyzer {
     const lines = code.split('\n')
 
     lines.forEach((line, index) => {
-      // Single letter variables (except loop counters)
-      const singleLetterVar = line.match(/\b([a-z])\b(?!\s*[=+\-*/]|\s*[;,\)\]])/g)
-      if (singleLetterVar && singleLetterVar.length > 0) {
-        // Check if it's not a common loop counter
-        const hasLoopCounter = /\bfor\s*\(\s*[a-z]\s+/.test(line)
-        if (!hasLoopCounter) {
+      // Check for bad variable names (const/let/var with single letter or unclear names)
+      const varDeclaration = line.match(/(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/)
+      if (varDeclaration) {
+        const varName = varDeclaration[1]
+        // Check if it's a single letter variable (except common exceptions)
+        const singleLetterExceptions = ['i', 'j', 'k', 'x', 'y', 'z', '_', '$']
+        if (varName.length === 1 && !singleLetterExceptions.includes(varName)) {
           issues.push({
             type: 'badVariableNames',
             name: CODE_SMELLS.badVariableNames.name,

package/lib/ai-trend-analyzer.js

@@ -243,15 +243,23 @@ class AITrendAnalyzer {
    * Predict future values for a metric
    */
   predictMetric(trend, days) {
+    // Handle edge case where trend.values is undefined
+    const lastValue = trend.values && trend.values.length > 0
+      ? trend.values[trend.values.length - 1]
+      : 0
+
     if (!trend.regression || trend.confidence < 0.5) {
       return {
-        predicted: trend.values[trend.values.length - 1] || 0,
-        confidence: trend.confidence,
+        predicted: lastValue,
+        confidence: trend.confidence || 0,
         warning: 'Low confidence prediction due to insufficient data'
       }
     }
 
-    const lastDate = trend.dates[trend.dates.length - 1]
+    const lastDate = trend.dates && trend.dates.length > 0
+      ? trend.dates[trend.dates.length - 1]
+      : Date.now()
+
     const futureDate = lastDate + (days * 24 * 60 * 60 * 1000)
 
     const predicted = simpleStatistics.linearRegressionLine(trend.regression)(futureDate)
@@ -259,7 +267,7 @@ class AITrendAnalyzer {
     return {
       predicted,
       confidence: trend.confidence,
-      direction: predicted > trend.values[trend.values.length - 1] ? 'up' : 'down'
+      direction: predicted > lastValue ? 'up' : 'down'
     }
   }
 

package/lib/ralph-integration.js

@@ -87,7 +87,7 @@ class RalphIntegration {
       this.prd = await fs.readJson(this.config.prdPath)
       console.log(chalk.green(`✓ PRD loaded (${this.prd.userStories.length} user stories)`))
     } else {
-      throw new Error(`PRD not found at ${this.config.prdPath}`)
+      throw new Error('PRD not found')
     }
 
     // Load progress
@@ -106,8 +106,7 @@ class RalphIntegration {
    */
   async runLoop() {
     if (this.isRunning) {
-      console.log(chalk.yellow('⚠ Ralph loop already running'))
-      return
+      throw new Error('Ralph loop is already running')
     }
 
     this.isRunning = true
@@ -116,11 +115,15 @@ class RalphIntegration {
     const startTime = Date.now()
 
     try {
+      // Check if all tasks are complete before starting
+      const remainingTasks = this.prd.userStories.filter(task => !task.passes)
+      if (remainingTasks.length === 0) {
+        console.log(chalk.green('\n🎉 All tasks already completed!'))
+        return
+      }
+
       // Run loop until all tasks complete or max iterations reached
       while (this.iterationCount < this.config.maxIterations) {
-        this.iterationCount++
-        console.log(chalk.cyan(`\n--- Iteration ${this.iterationCount}/${this.config.maxIterations} ---`))
-
         // Check if all tasks are complete
         const remainingTasks = this.prd.userStories.filter(task => !task.passes)
         if (remainingTasks.length === 0) {
@@ -128,6 +131,9 @@ class RalphIntegration {
           break
         }
 
+        this.iterationCount++
+        console.log(chalk.cyan(`\n--- Iteration ${this.iterationCount}/${this.config.maxIterations} ---`))
+
         // Select next task by priority
         const task = this.selectNextTask(remainingTasks)
         if (!task) {
@@ -176,6 +182,10 @@ class RalphIntegration {
    * Select next task by priority
    */
   selectNextTask(tasks) {
+    if (!tasks || tasks.length === 0) {
+      return null
+    }
+
     // Sort by priority (lower number = higher priority)
     const sorted = tasks.sort((a, b) => {
       // Handle priority as number or string
@@ -262,7 +272,7 @@ class RalphIntegration {
    */
   async createFeatureBranch(task) {
     const date = new Date().toISOString().slice(0, 10).replace(/-/g, '')
-    const branchName = `${this.config.branchPrefix}${date}-${task.id.toLowerCase()}`
+    const branchName = `${this.config.branchPrefix}${date}-${task.id}`
 
     try {
       // Check if branch exists
@@ -394,13 +404,12 @@ class RalphIntegration {
     const modulePath = path.join(process.cwd(), 'lib', 'ralph-integration.js')
 
     if (await fs.pathExists(modulePath)) {
-      // Verify the module loads correctly
-      const RalphIntegrationModule = require('./ralph-integration')
-      const testInstance = new RalphIntegrationModule()
+      // Verify the module exists
       console.log(chalk.green(`  ✓ Ralph Integration module verified`))
       return true
     }
 
+    console.log(chalk.red(`  ✗ Ralph Integration module not found`))
     return false
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-simplifier",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Code-Simplifier持续改进系统 - 自动化的代码质量监控、持续改进和知识管理工具（支持 ESLint、Git 钩子、自动修复、多语言分析、完整测试套件、AI驱动分析）",
   "keywords": [
     "code-quality",