@reinteractive/rails-insight 1.0.1

package/src/utils/inflector.js

@@ -0,0 +1,223 @@
+/**
+ * English Inflection Module
+ * Provides pluralization, singularization, and case conversion
+ * for Rails-style naming conventions.
+ *
+ * @module inflector
+ */
+
+/** @type {Array<[RegExp, string]>} Pluralization rules (applied last-to-first). */
+const PLURAL_RULES = [
+  [/quiz$/i, 'quizzes'],
+  [/^(ox)$/i, '$1en'],
+  [/(matr|vert|append)ix$/i, '$1ices'],
+  [/(x|ch|ss|sh)$/i, '$1es'],
+  [/([^aeiouy])y$/i, '$1ies'],
+  [/(hive)$/i, '$1s'],
+  [/([lr])f$/i, '$1ves'],
+  [/(shea|lea|wol|cal)f$/i, '$1ves'],
+  [/([^f])fe$/i, '$1ves'],
+  [/sis$/i, 'ses'],
+  [/([ti])um$/i, '$1a'],
+  [/(buffal|tomat|volcan|potat|ech|her|vet)o$/i, '$1oes'],
+  [/(bu|mis|gas)s$/i, '$1ses'],
+  [/(alias|status)$/i, '$1es'],
+  [/(octop|vir)us$/i, '$1i'],
+  [/(ax|test)is$/i, '$1es'],
+  [/s$/i, 's'],
+  [/$/, 's'],
+]
+
+/** @type {Array<[RegExp, string]>} Singularization rules (applied last-to-first). */
+const SINGULAR_RULES = [
+  [/(database)s$/i, '$1'],
+  [/(quiz)zes$/i, '$1'],
+  [/(matr)ices$/i, '$1ix'],
+  [/(vert|append)ices$/i, '$1ex'],
+  [/^(ox)en/i, '$1'],
+  [/(alias|status)es$/i, '$1'],
+  [/(octop|vir)i$/i, '$1us'],
+  [/(cris|ax|test)es$/i, '$1is'],
+  [/(shoe)s$/i, '$1'],
+  [/(o)es$/i, '$1'],
+  [/(bus)es$/i, '$1'],
+  [/([mlr])ives$/i, '$1ife'],
+  [/(x|ch|ss|sh)es$/i, '$1'],
+  [/(m)ovies$/i, '$1ovie'],
+  [/(s)eries$/i, '$1eries'],
+  [/([^aeiouy])ies$/i, '$1y'],
+  [/([lr])ves$/i, '$1f'],
+  [/(tive)s$/i, '$1'],
+  [/(hive)s$/i, '$1'],
+  [/([^f])ves$/i, '$1fe'],
+  [/(^analy)ses$/i, '$1sis'],
+  [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '$1$2sis'],
+  [/([ti])a$/i, '$1um'],
+  [/(n)ews$/i, '$1ews'],
+  [/s$/i, ''],
+]
+
+/** @type {Array<[string, string]>} Irregular singular/plural pairs. */
+const IRREGULARS = [
+  ['person', 'people'],
+  ['man', 'men'],
+  ['woman', 'women'],
+  ['child', 'children'],
+  ['sex', 'sexes'],
+  ['move', 'moves'],
+  ['zombie', 'zombies'],
+  ['goose', 'geese'],
+  ['mouse', 'mice'],
+  ['tooth', 'teeth'],
+  ['foot', 'feet'],
+]
+
+/** @type {Set<string>} Words that do not change between singular and plural. */
+const UNCOUNTABLES = new Set([
+  'equipment',
+  'information',
+  'rice',
+  'money',
+  'species',
+  'series',
+  'fish',
+  'sheep',
+  'jeans',
+  'police',
+  'news',
+  'data',
+  'feedback',
+  'staff',
+  'advice',
+  'furniture',
+  'homework',
+  'knowledge',
+  'luggage',
+  'progress',
+  'research',
+  'software',
+  'weather',
+])
+
+/**
+ * Check if a word is uncountable (case-insensitive).
+ * @param {string} word
+ * @returns {boolean}
+ */
+function isUncountable(word) {
+  return UNCOUNTABLES.has(word.toLowerCase())
+}
+
+/**
+ * Check irregular words in the given direction.
+ * @param {string} word
+ * @param {'toPlural'|'toSingular'} direction
+ * @returns {string|null} Replacement word or null
+ */
+function checkIrregular(word, direction) {
+  const lower = word.toLowerCase()
+  for (const [singular, plural] of IRREGULARS) {
+    const from = direction === 'toPlural' ? singular : plural
+    const to = direction === 'toPlural' ? plural : singular
+    if (lower === from) {
+      return preserveCase(word, to)
+    }
+  }
+  return null
+}
+
+/**
+ * Preserve the first-letter casing of the original word on the replacement.
+ * @param {string} original
+ * @param {string} replacement
+ * @returns {string}
+ */
+function preserveCase(original, replacement) {
+  if (!original || !replacement) return replacement
+  if (original[0] === original[0].toUpperCase()) {
+    return replacement.charAt(0).toUpperCase() + replacement.slice(1)
+  }
+  return replacement
+}
+
+/**
+ * Apply inflection rules to a word (first match wins, most specific first).
+ * @param {string} word
+ * @param {Array<[RegExp, string]>} rules
+ * @returns {string}
+ */
+function applyRules(word, rules) {
+  for (const [pattern, replacement] of rules) {
+    if (pattern.test(word)) {
+      return word.replace(pattern, replacement)
+    }
+  }
+  return word
+}
+
+/**
+ * Pluralize an English word.
+ * @param {string} word - Singular English word
+ * @returns {string} Plural form
+ */
+export function pluralize(word) {
+  if (!word) return ''
+  if (isUncountable(word)) return word
+  const irregular = checkIrregular(word, 'toPlural')
+  if (irregular) return irregular
+  return applyRules(word, PLURAL_RULES)
+}
+
+/**
+ * Singularize an English word.
+ * @param {string} word - Plural English word
+ * @returns {string} Singular form
+ */
+export function singularize(word) {
+  if (!word) return ''
+  if (isUncountable(word)) return word
+  const irregular = checkIrregular(word, 'toSingular')
+  if (irregular) return irregular
+  return applyRules(word, SINGULAR_RULES)
+}
+
+/**
+ * Convert a PascalCase string to snake_case.
+ * @param {string} str
+ * @returns {string}
+ */
+export function underscore(str) {
+  if (!str) return ''
+  return str
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+    .toLowerCase()
+}
+
+/**
+ * Convert a snake_case or plural string to a PascalCase singular class name.
+ * 'user_profiles' → 'UserProfile', 'comments' → 'Comment'
+ * @param {string} str - snake_case or plural string
+ * @returns {string} PascalCase singular class name
+ */
+export function classify(str) {
+  if (!str) return ''
+  return str
+    .split(/[_\s]+/)
+    .map((segment, idx, arr) => {
+      const word = idx === arr.length - 1 ? singularize(segment) : segment
+      return word.charAt(0).toUpperCase() + word.slice(1)
+    })
+    .join('')
+}
+
+/**
+ * Convert a PascalCase class name to a snake_case plural table name.
+ * 'UserProfile' → 'user_profiles', 'Person' → 'people'
+ * @param {string} className - PascalCase class name
+ * @returns {string} snake_case plural table name
+ */
+export function tableize(className) {
+  if (!className) return ''
+  return pluralize(underscore(className))
+}

package/src/utils/ruby-parser.js

@@ -0,0 +1,115 @@
+/**
+ * Regex-based Ruby declaration extractor.
+ * All functions accept string content (not file paths).
+ */
+
+/**
+ * Extract class declaration from Ruby source.
+ * @param {string} content - Ruby file content
+ * @returns {{ name: string, superclass: string|null }|null}
+ */
+export function extractClassDeclaration(content) {
+  const match = content.match(/class\s+(\w+(?:::\w+)*)\s*<\s*(\w+(?:::\w+)*)/)
+  if (match) {
+    return { name: match[1], superclass: match[2] }
+  }
+  // Class without superclass
+  const basic = content.match(/class\s+(\w+(?:::\w+)*)\s*$/m)
+  if (basic) {
+    return { name: basic[1], superclass: null }
+  }
+  return null
+}
+
+/**
+ * Extract module declaration from Ruby source.
+ * @param {string} content
+ * @returns {string|null} Module name
+ */
+export function extractModuleDeclaration(content) {
+  const match = content.match(/module\s+(\w+(?:::\w+)*)/)
+  return match ? match[1] : null
+}
+
+/**
+ * Extract all method names from Ruby source.
+ * @param {string} content
+ * @returns {string[]}
+ */
+export function extractMethodNames(content) {
+  const methods = []
+  const regex = /^\s*def\s+(?:self\.)?(\w+[?!=]?)/gm
+  let match
+  while ((match = regex.exec(content)) !== null) {
+    methods.push(match[1])
+  }
+  return methods
+}
+
+/**
+ * Extract DSL calls (like has_many, validates, scope, etc).
+ * @param {string} content
+ * @param {RegExp} pattern - The DSL pattern to match
+ * @returns {RegExpExecArray[]} All matches
+ */
+export function extractDSLCalls(content, pattern) {
+  const results = []
+  const regex = new RegExp(
+    pattern.source,
+    pattern.flags.includes('g') ? pattern.flags : pattern.flags + 'g',
+  )
+  let match
+  while ((match = regex.exec(content)) !== null) {
+    results.push(match)
+  }
+  return results
+}
+
+/**
+ * Extract include and extend statements.
+ * @param {string} content
+ * @returns {{ includes: string[], extends: string[] }}
+ */
+export function extractIncludesExtends(content) {
+  const includes = []
+  const extends_ = []
+
+  const includeRegex = /^\s*include\s+(\w+(?:::\w+)*)/gm
+  let match
+  while ((match = includeRegex.exec(content)) !== null) {
+    includes.push(match[1])
+  }
+
+  const extendRegex = /^\s*extend\s+(\w+(?:::\w+)*)/gm
+  while ((match = extendRegex.exec(content)) !== null) {
+    extends_.push(match[1])
+  }
+
+  return { includes, extends: extends_ }
+}
+
+/**
+ * Extract the visibility sections (public/private/protected) from Ruby source.
+ * Returns methods grouped by visibility.
+ * @param {string} content
+ * @returns {{ public: string[], private: string[], protected: string[] }}
+ */
+export function extractMethodsByVisibility(content) {
+  const result = { public: [], private: [], protected: [] }
+  let currentVisibility = 'public'
+  const lines = content.split('\n')
+
+  for (const line of lines) {
+    const visMatch = line.match(/^\s*(private|protected)\s*$/)
+    if (visMatch) {
+      currentVisibility = visMatch[1]
+      continue
+    }
+    const methodMatch = line.match(/^\s*def\s+(?:self\.)?(\w+[?!=]?)/)
+    if (methodMatch) {
+      result[currentVisibility].push(methodMatch[1])
+    }
+  }
+
+  return result
+}

package/src/utils/spec-style-detector.js

@@ -0,0 +1,26 @@
+/**
+ * Shared spec style detection utility.
+ * Detects whether a project uses request specs or controller specs.
+ *
+ * @module spec-style-detector
+ */
+
+/**
+ * Detect spec style (request vs controller specs).
+ * @param {Array<{path: string}>} entries
+ * @returns {{primary: string, request_count: number, controller_count: number, has_mixed: boolean}}
+ */
+export function detectSpecStyle(entries) {
+  const requestCount = entries.filter((e) =>
+    e.path.startsWith('spec/requests/'),
+  ).length
+  const controllerCount = entries.filter((e) =>
+    e.path.startsWith('spec/controllers/'),
+  ).length
+  return {
+    primary: requestCount >= controllerCount ? 'request' : 'controller',
+    request_count: requestCount,
+    controller_count: controllerCount,
+    has_mixed: requestCount > 0 && controllerCount > 0,
+  }
+}

package/src/utils/token-counter.js

@@ -0,0 +1,46 @@
+/**
+ * Token estimation utilities.
+ * Uses content-aware character-per-token ratios for more accurate estimation.
+ */
+
+/** Characters-per-token ratio for different content types. */
+const CHARS_PER_TOKEN_PROSE = 4.0
+const CHARS_PER_TOKEN_JSON = 3.0
+const CHARS_PER_TOKEN_CODE = 3.5
+
+/**
+ * Detect content type and return appropriate chars-per-token ratio.
+ * @param {string} text
+ * @returns {number}
+ */
+function detectContentRatio(text) {
+  if (text.length < 10) return CHARS_PER_TOKEN_PROSE
+  const sample = text.slice(0, 200)
+  const jsonIndicators = (sample.match(/[{}\[\]:,"]/g) || []).length
+  const ratio = jsonIndicators / sample.length
+  if (ratio > 0.15) return CHARS_PER_TOKEN_JSON
+  if (ratio > 0.05) return CHARS_PER_TOKEN_CODE
+  return CHARS_PER_TOKEN_PROSE
+}
+
+/**
+ * Estimate tokens for a text string.
+ * @param {string} text
+ * @returns {number}
+ */
+export function estimateTokens(text) {
+  if (!text) return 0
+  const ratio = detectContentRatio(text)
+  return Math.ceil(text.length / ratio)
+}
+
+/**
+ * Estimate tokens for a JSON-serializable object.
+ * @param {Object} obj
+ * @returns {number}
+ */
+export function estimateTokensForObject(obj) {
+  if (obj === null || obj === undefined) return 0
+  const json = JSON.stringify(obj)
+  return estimateTokens(json)
+}

package/src/utils/yaml-parser.js

@@ -0,0 +1,135 @@
+/**
+ * Simple YAML parser for Rails config files.
+ * Handles key-value pairs, arrays, nested structures, and anchors/aliases.
+ * Not a full YAML parser — designed for Rails convention YAML files.
+ */
+
+/**
+ * Parse a simple YAML string into a nested object.
+ * @param {string} content - YAML content
+ * @returns {Object}
+ */
+export function parseYaml(content) {
+  if (!content || typeof content !== 'string') return {}
+
+  const lines = content.split('\n')
+  const result = {}
+  const anchors = {}
+  const stack = [{ obj: result, indent: -1 }]
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+
+    // Skip empty lines and comments
+    if (/^\s*$/.test(line) || /^\s*#/.test(line)) continue
+
+    // Handle ERB tags by removing them
+    const cleanLine = line.replace(/<%.*?%>/g, '')
+    if (/^\s*$/.test(cleanLine)) continue
+
+    const indentMatch = cleanLine.match(/^(\s*)/)
+    const indent = indentMatch ? indentMatch[1].length : 0
+
+    // Pop stack to correct parent
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop()
+    }
+
+    // Merge key: <<: *alias
+    const mergeMatch = cleanLine.match(/^\s*<<:\s*\*(\w+)/)
+    if (mergeMatch) {
+      const aliasName = mergeMatch[1]
+      const source = anchors[aliasName]
+      if (source && typeof source === 'object') {
+        const parent = stack[stack.length - 1].obj
+        Object.assign(parent, structuredClone(source))
+      }
+      continue
+    }
+
+    // Array item
+    const arrayMatch = cleanLine.match(/^(\s*)-\s*(.+)$/)
+    if (arrayMatch) {
+      const parent = stack[stack.length - 1]
+      if (parent.arrayKey) {
+        if (!Array.isArray(parent.obj[parent.arrayKey])) {
+          parent.obj[parent.arrayKey] = []
+        }
+        parent.obj[parent.arrayKey].push(parseYamlValue(arrayMatch[2].trim()))
+      }
+      continue
+    }
+
+    // Key-value with anchor: key: &anchor value
+    const kvAnchorMatch = cleanLine.match(
+      /^(\s*)(\w[\w\s-]*):\s*&(\w+)\s*(.*)$/,
+    )
+    if (kvAnchorMatch) {
+      const key = kvAnchorMatch[2].trim()
+      const anchorName = kvAnchorMatch[3]
+      const value = kvAnchorMatch[4].trim()
+      const parent = stack[stack.length - 1].obj
+
+      if (value === '' || value === '|' || value === '>') {
+        parent[key] = {}
+        anchors[anchorName] = parent[key]
+        stack.push({ obj: parent[key], indent, arrayKey: null })
+      } else {
+        parent[key] = parseYamlValue(value)
+        anchors[anchorName] = parent[key]
+      }
+      continue
+    }
+
+    // Key-value with alias: key: *alias
+    const kvAliasMatch = cleanLine.match(/^(\s*)(\w[\w\s-]*):\s*\*(\w+)/)
+    if (kvAliasMatch) {
+      const key = kvAliasMatch[2].trim()
+      const aliasName = kvAliasMatch[3]
+      const parent = stack[stack.length - 1].obj
+      const source = anchors[aliasName]
+      parent[key] = source !== undefined ? structuredClone(source) : null
+      continue
+    }
+
+    // Key-value pair
+    const kvMatch = cleanLine.match(/^(\s*)(\w[\w\s-]*):\s*(.*)$/)
+    if (kvMatch) {
+      const key = kvMatch[2].trim()
+      const value = kvMatch[3].trim()
+      const parent = stack[stack.length - 1].obj
+
+      if (value === '' || value === '|' || value === '>') {
+        parent[key] = {}
+        stack.push({ obj: parent[key], indent, arrayKey: null })
+      } else {
+        parent[key] = parseYamlValue(value)
+      }
+    }
+  }
+
+  // Resolve anchors: for any anchor that points to an object, update the reference
+  // since nested keys were added after the anchor was stored
+  return result
+}
+
+/**
+ * Parse a YAML value string into appropriate JS type.
+ * @param {string} value
+ * @returns {string|number|boolean|null}
+ */
+function parseYamlValue(value) {
+  if (value === 'true') return true
+  if (value === 'false') return false
+  if (value === 'null' || value === '~') return null
+  if (/^\d+$/.test(value)) return parseInt(value, 10)
+  if (/^\d+\.\d+$/.test(value)) return parseFloat(value)
+  // Remove quotes
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1)
+  }
+  return value
+}