@reinteractive/rails-insight 1.0.12 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reinteractive/rails-insight",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "Rails-aware codebase indexer — MCP server for AI agents",
   "type": "module",
   "bin": {

package/src/core/indexer.js

@@ -223,7 +223,11 @@ export async function buildIndex(provider, options = {}) {
         extractionErrors,
       )
       if (model) extractions.models[className] = model
-    } else if (entry.categoryName === 'controllers') {
+    } else if (
+      entry.categoryName === 'controllers' ||
+      (entry.categoryName === 'authentication' &&
+        entry.path.includes('_controller.rb'))
+    ) {
       const ctrl = safeExtract(
         `controller:${entry.path}`,
         () => extractController(provider, entry.path),
@@ -585,6 +589,7 @@ function computeStatistics(manifest, extractions, relationships) {
     models: Object.values(extractions.models || {}).filter(
       (m) => m.type !== 'concern' && !m.abstract,
     ).length,
+    models_in_manifest: (manifest.stats || {}).models || 0,
     controllers: Object.keys(extractions.controllers || {}).length,
     components: Object.keys(extractions.components || {}).length,
     relationships: relationships.length,

package/src/core/patterns/model.js

@@ -22,6 +22,7 @@ export const MODEL_PATTERNS = {
   validates: /^\s*validates?\s+:?(\w+(?:,\s*:\w+)*)(?:,\s*(.+))?$/m,
   validate: /^\s*validate\s+:(\w+)/m,
   validatesWithValidator: /^\s*validates_with\s+(\S+)(?:,\s*(.+))?$/m,
+  validatesOldStyle: /^\s*validates_(\w+?)(?:_of)?\s+:(\w+)(?:,\s*(.+))?$/m,
 
   // === SCOPES ===
   scope: /^\s*scope\s+:(\w+),\s*(?:->|lambda|proc)/m,

package/src/core/patterns/route.js

@@ -10,7 +10,7 @@ export const ROUTE_PATTERNS = {
   constraints: /^\s*constraints\s*(?:\((.+)\))?\s*do/m,
   httpVerb:
     /^\s*(?:get|post|put|patch|delete)\s+['"]([^'"]+)['"](?:.*?(?:to:|=>)\s*['"]([^'"#]+)#?([^'"]*)['"'])?/m,
-  root: /^\s*root\s+(?:to:\s*)?['"]([^'"#]+)#?([^'"]*)['"']/m,
+  root: /^\s*root\s+(?:(?::to\s*=>|to:)\s*)?['"]([^'"#]+)#?([^'"]*)['"']/m,
   mount:
     /^\s*mount\s+(\w+(?:(?:::|\.)\w+)*)\s*(?:=>|,\s*at:)\s*['"]([^'"]+)['"]/m,
   concern: /^\s*concern\s+:(\w+)\s+do/m,

package/src/core/version-detector.js

@@ -242,9 +242,13 @@ function detectFramework(gemfile, gems, appConfig, provider) {
   let cacheStore = null
   if (hasGem('solid_cache')) cacheStore = 'solid_cache'
   else if (hasGem('redis')) cacheStore = 'redis'
-  // Also check config
-  const prodConfig =
+  // Also check config — strip comment lines first to avoid false positives
+  const prodConfigRaw =
     provider.readFile('config/environments/production.rb') || ''
+  const prodConfig = prodConfigRaw
+    .split('\n')
+    .filter((l) => !l.trim().startsWith('#'))
+    .join('\n')
   const cacheStoreMatch = prodConfig.match(/config\.cache_store\s*=\s*:(\w+)/)
   if (cacheStoreMatch) cacheStore = cacheStoreMatch[1]
 

package/src/extractors/authorization.js

@@ -576,28 +576,35 @@ export function extractAuthorization(
   if (hasCanCan) {
     if (!result.strategy) result.strategy = 'cancancan'
     let abilityContent = provider.readFile('app/models/ability.rb')
-    // Fallback: scan model files for CanCan::Ability
+    let abilityFile = 'app/models/ability.rb'
+    // Fallback: scan model and authorization files for CanCan::Ability
     if (!abilityContent || !AUTHORIZATION_PATTERNS.abilityClass.test(abilityContent)) {
-      const modelEntries = entries.filter(
+      const abilityEntries = entries.filter(
         (e) =>
-          (e.category === 'model' || e.categoryName === 'models') &&
+          (e.category === 'model' ||
+            e.categoryName === 'models' ||
+            e.category === 1 ||
+            e.categoryName === 'authorization' ||
+            e.category === 9) &&
           e.path.endsWith('.rb'),
       )
-      for (const entry of modelEntries) {
+      for (const entry of abilityEntries) {
         const c = provider.readFile(entry.path)
         if (
           c &&
-          AUTHORIZATION_PATTERNS.abilityClass.test(c) &&
-          AUTHORIZATION_PATTERNS.includeCanCan.test(c)
+          (AUTHORIZATION_PATTERNS.abilityClass.test(c) ||
+            AUTHORIZATION_PATTERNS.includeCanCan.test(c))
         ) {
           abilityContent = c
+          abilityFile = entry.path
           break
         }
       }
     }
     if (
       abilityContent &&
-      AUTHORIZATION_PATTERNS.abilityClass.test(abilityContent)
+      (AUTHORIZATION_PATTERNS.abilityClass.test(abilityContent) ||
+        AUTHORIZATION_PATTERNS.includeCanCan.test(abilityContent))
     ) {
       const abilities = []
       const canRe = new RegExp(AUTHORIZATION_PATTERNS.canDef.source, 'gm')
@@ -610,6 +617,21 @@ export function extractAuthorization(
         abilities.push({ type: 'cannot', definition: m[1].trim() })
       }
       result.abilities = abilities
+
+      // Extract roles from has_role? calls in the ability file
+      const roleRe = /has_role\?\s*\(:?['"]?(\w+)['"]?\)/g
+      const roles = new Set()
+      while ((m = roleRe.exec(abilityContent))) {
+        roles.add(m[1])
+      }
+      if (roles.size > 0) {
+        result.roles = {
+          source: 'ability_class',
+          model: 'User',
+          roles: [...roles],
+          file: abilityFile,
+        }
+      }
     }
   }
 

package/src/extractors/config.js

@@ -62,6 +62,31 @@ export function extractConfig(provider) {
     }
   }
 
+  // Fallback: try config/database.yml.example
+  if (!result.database.adapter) {
+    const dbExample = provider.readFile('config/database.yml.example')
+    if (dbExample) {
+      const parsed = parseYaml(dbExample)
+      const section =
+        parsed.production || parsed.development || parsed.default || {}
+      result.database.adapter = section.adapter || null
+      if (result.database.adapter) result.database.source = 'database.yml.example'
+    }
+  }
+
+  // Fallback: detect adapter from Gemfile when database.yml is absent
+  if (!result.database.adapter) {
+    const gemfile = provider.readFile('Gemfile') || ''
+    if (/gem\s+['"]mysql2['"]/.test(gemfile)) result.database.adapter = 'mysql2'
+    else if (/gem\s+['"]pg['"]/.test(gemfile))
+      result.database.adapter = 'postgresql'
+    else if (/gem\s+['"]sqlite3['"]/.test(gemfile))
+      result.database.adapter = 'sqlite3'
+    else if (/gem\s+['"]trilogy['"]/.test(gemfile))
+      result.database.adapter = 'trilogy'
+    if (result.database.adapter) result.database.source = 'gemfile'
+  }
+
   // config/environments/*.rb
   for (const env of ['production', 'development', 'test']) {
     const content = provider.readFile(`config/environments/${env}.rb`)

package/src/extractors/controller.js

@@ -40,12 +40,12 @@ export function extractController(provider, filePath) {
   }
 
   // Filters — tag authorization guards
-  const filters = []
+  const rawFilters = []
   const filterRe = new RegExp(CONTROLLER_PATTERNS.filterType.source, 'gm')
   while ((m = filterRe.exec(content))) {
     const filterMethod = m[2]
     const isAuthzGuard = /^require_\w+!$/.test(filterMethod)
-    filters.push({
+    rawFilters.push({
       type: m[1],
       method: filterMethod,
       ...(isAuthzGuard ? { authorization_guard: true } : {}),
@@ -53,6 +53,60 @@ export function extractController(provider, filePath) {
     })
   }
 
+  // Expand multi-method filters: `before_action :a, :b, :c` → separate entries
+  const filters = []
+  for (const filter of rawFilters) {
+    const opts = filter.options
+    if (!opts) {
+      filters.push(filter)
+      continue
+    }
+
+    // Top-level comma split (ignores commas inside brackets)
+    const parts = []
+    let depth = 0
+    let current = ''
+    for (const ch of opts) {
+      if (ch === '[' || ch === '(' || ch === '{') depth++
+      else if (ch === ']' || ch === ')' || ch === '}') depth--
+      if (ch === ',' && depth === 0) {
+        parts.push(current.trim())
+        current = ''
+      } else {
+        current += ch
+      }
+    }
+    if (current.trim()) parts.push(current.trim())
+
+    const additionalMethods = []
+    const realOptions = []
+
+    for (const part of parts) {
+      if (/^:(\w+!?)$/.test(part)) {
+        // Bare symbol — another method, not a keyword option
+        additionalMethods.push(part.replace(/^:/, ''))
+      } else {
+        // Keyword option like `only: [:show]`, `if: :condition`
+        realOptions.push(part)
+      }
+    }
+
+    filters.push({
+      ...filter,
+      options: realOptions.length > 0 ? realOptions.join(', ') : null,
+    })
+
+    for (const method of additionalMethods) {
+      const isAuthz = /^require_\w+!$/.test(method)
+      filters.push({
+        type: filter.type,
+        method,
+        ...(isAuthz ? { authorization_guard: true } : {}),
+        options: realOptions.length > 0 ? realOptions.join(', ') : null,
+      })
+    }
+  }
+
   // Actions (public methods before private/protected) with line ranges
   const actions = []
   const action_line_ranges = {}

package/src/extractors/model.js

@@ -127,7 +127,7 @@ export function extractModel(provider, filePath, className) {
   }
   while ((m = extendRe.exec(content))) {
     const mod = m[1]
-    if (mod !== 'ActiveSupport::Concern' && mod !== 'FriendlyId') {
+    if (mod !== 'ActiveSupport::Concern') {
       extends_.push(mod)
     }
   }
@@ -179,6 +179,16 @@ export function extractModel(provider, filePath, className) {
   while ((m = vwRe.exec(content))) {
     custom_validators.push(`validates_with:${m[1]}`)
   }
+  // Old-style validators: validates_presence_of, validates_length_of, etc.
+  const oldStyleRe = /^\s*validates_(\w+?)(?:_of)?\s+:(\w+)(?:,\s*(.+))?$/gm
+  while ((m = oldStyleRe.exec(content))) {
+    const validationType = m[1]
+    const attr = m[2]
+    validations.push({
+      attributes: [attr],
+      rules: `${validationType}: true${m[3] ? ', ' + m[3] : ''}`,
+    })
+  }
 
   // Scopes — names array (backward-compat) + scope_queries dict with bodies
   const scopes = []

package/src/extractors/test-conventions.js

@@ -66,9 +66,11 @@ export function extractTestConventions(provider, entries, gemInfo = {}) {
     pattern_reference_files: [],
   }
 
-  // Scan spec files for convention patterns
+  // Scan spec/test files for convention patterns
   const specEntries = entries.filter(
-    (e) => e.categoryName === 'testing' && e.path.endsWith('_spec.rb'),
+    (e) =>
+      e.categoryName === 'testing' &&
+      (e.path.endsWith('_spec.rb') || e.path.endsWith('_test.rb')),
   )
 
   // Count spec files by specCategory
@@ -319,9 +321,13 @@ function findPatternReferences(provider, specEntries) {
     const content = provider.readFile(entry.path)
     if (!content) continue
 
-    const describeCount = (content.match(/^\s*(?:describe|context)\s/gm) || [])
-      .length
-    const exampleCount = (content.match(/^\s*it\s/gm) || []).length
+    // Handle both RSpec and Minitest structural patterns
+    const describeCount = (
+      content.match(/^\s*(?:describe|context|class\s+\w+Test)\s/gm) || []
+    ).length
+    const exampleCount = (
+      content.match(/^\s*(?:it\s|def\s+test_|test\s+['"])/gm) || []
+    ).length
 
     // Skip trivially small files
     if (exampleCount < 3) continue