@reinteractive/rails-insight 1.0.1

package/src/extractors/views.js

@@ -0,0 +1,131 @@
+/**
+ * Views Extractor (#7)
+ * Lightweight aggregated scan of app/views for structural indicators.
+ */
+
+import { VIEW_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Detect primary template engine from file extensions.
+ * @param {Array<{path: string}>} entries
+ * @returns {string}
+ */
+function detectEngine(entries) {
+  let erb = 0,
+    haml = 0,
+    slim = 0
+  for (const e of entries) {
+    if (e.path.endsWith('.erb')) erb++
+    else if (e.path.endsWith('.haml')) haml++
+    else if (e.path.endsWith('.slim')) slim++
+  }
+  if (haml > erb && haml > slim) return 'haml'
+  if (slim > erb && slim > haml) return 'slim'
+  return 'erb'
+}
+
+/**
+ * Extract aggregated view layer information.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string, category: string}>} entries - all scanned entries
+ * @returns {object}
+ */
+export function extractViews(provider, entries) {
+  const result = {
+    layouts: [],
+    template_engine: 'erb',
+    turbo_frames_count: 0,
+    turbo_stream_templates: 0,
+    component_renders: 0,
+    partial_renders: 0,
+    form_with_usage: 0,
+    form_for_usage: 0,
+    jbuilder_views: 0,
+    content_for_keys: [],
+  }
+
+  const viewEntries = entries.filter(
+    (e) =>
+      e.path.startsWith('app/views/') ||
+      e.category === 'view' ||
+      e.category === 'layout' ||
+      e.category === 'partial' ||
+      e.category === 'jbuilder',
+  )
+
+  if (viewEntries.length === 0) return result
+
+  result.template_engine = detectEngine(viewEntries)
+
+  const contentForKeys = new Set()
+  let jbuilderCount = 0
+
+  for (const entry of viewEntries) {
+    const { path } = entry
+
+    // Layouts
+    if (path.startsWith('app/views/layouts/')) {
+      const name = path
+        .replace('app/views/layouts/', '')
+        .replace(/\.\w+(\.\w+)*$/, '')
+      if (!result.layouts.includes(name)) {
+        result.layouts.push(name)
+      }
+    }
+
+    // Turbo stream templates
+    if (path.includes('.turbo_stream.')) {
+      result.turbo_stream_templates++
+    }
+
+    // Jbuilder
+    if (path.endsWith('.jbuilder')) {
+      jbuilderCount++
+    }
+
+    // Read content for pattern matching
+    const content = provider.readFile(path)
+    if (!content) continue
+
+    // Turbo frames
+    const frameRe = new RegExp(VIEW_PATTERNS.turboFrame.source, 'g')
+    let m
+    while ((m = frameRe.exec(content))) {
+      result.turbo_frames_count++
+    }
+
+    // Component renders
+    const compRe = new RegExp(VIEW_PATTERNS.componentRender.source, 'g')
+    while ((m = compRe.exec(content))) {
+      result.component_renders++
+    }
+
+    // Partial renders
+    const partialRe = new RegExp(VIEW_PATTERNS.partialRender.source, 'g')
+    while ((m = partialRe.exec(content))) {
+      result.partial_renders++
+    }
+
+    // Form helpers
+    const formWithRe = new RegExp(VIEW_PATTERNS.formWith.source, 'g')
+    while ((m = formWithRe.exec(content))) {
+      result.form_with_usage++
+    }
+
+    const formForRe = new RegExp(VIEW_PATTERNS.formFor.source, 'g')
+    while ((m = formForRe.exec(content))) {
+      result.form_for_usage++
+    }
+
+    // Content for keys
+    const cfRe = new RegExp(VIEW_PATTERNS.contentFor.source, 'g')
+    while ((m = cfRe.exec(content))) {
+      contentForKeys.add(m[1])
+    }
+  }
+
+  result.jbuilder_views = jbuilderCount
+  result.content_for_keys = [...contentForKeys].sort()
+
+  return result
+}

package/src/extractors/worker.js

@@ -0,0 +1,62 @@
+/**
+ * Worker Extractor (#10 — Jobs sub-type)
+ * Extracts Sidekiq native worker metadata: class name, queue, retry config,
+ * sidekiq_options, and perform method signature.
+ */
+
+import { WORKER_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract a single Sidekiq native worker's metadata.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+export function extractWorker(provider, filePath) {
+  const content = provider.readFile(filePath)
+  if (!content) return null
+
+  // Must include Sidekiq::Job or Sidekiq::Worker
+  const includeMatch = content.match(WORKER_PATTERNS.includeSidekiq)
+  if (!includeMatch) return null
+
+  const classMatch = content.match(WORKER_PATTERNS.classDeclaration)
+  if (!classMatch) return null
+
+  const result = {
+    class: classMatch[1],
+    file: filePath,
+    type: 'sidekiq_native',
+    queue: 'default',
+    retry: true,
+    sidekiq_options: null,
+    perform_args: [],
+  }
+
+  // Sidekiq options
+  const optionsMatch = content.match(WORKER_PATTERNS.sidekiqOptions)
+  if (optionsMatch) {
+    result.sidekiq_options = optionsMatch[1].trim()
+
+    // Extract queue
+    const queueMatch = optionsMatch[1].match(WORKER_PATTERNS.queueOption)
+    if (queueMatch) {
+      result.queue = queueMatch[1]
+    }
+
+    // Extract retry
+    const retryMatch = optionsMatch[1].match(WORKER_PATTERNS.retryOption)
+    if (retryMatch) {
+      result.retry =
+        retryMatch[1] === 'false' ? false : parseInt(retryMatch[1], 10)
+    }
+  }
+
+  // Perform arguments
+  const performMatch = content.match(WORKER_PATTERNS.performSignature)
+  if (performMatch && performMatch[1].trim()) {
+    result.perform_args = performMatch[1].split(',').map((a) => a.trim())
+  }
+
+  return result
+}

package/src/git/diff-parser.js

@@ -0,0 +1,132 @@
+/**
+ * Git diff detection and file parsing.
+ * Detects changed files via git commands or parses raw diff output.
+ */
+
+const STATUS_MAP = {
+  M: 'modified',
+  A: 'added',
+  D: 'deleted',
+  R: 'renamed',
+  C: 'copied',
+  T: 'type-changed',
+}
+
+/**
+ * Parse a raw git diff --name-status output string into structured data.
+ * @param {string} rawOutput
+ * @returns {Array<{path: string, status: string}>}
+ */
+export function parseDiffOutput(rawOutput) {
+  if (!rawOutput || !rawOutput.trim()) return []
+
+  return rawOutput
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line) => parseDiffLine(line))
+    .filter(Boolean)
+}
+
+/**
+ * Parse a single diff line.
+ * @param {string} line
+ * @returns {{path: string, status: string, oldPath?: string}|null}
+ */
+function parseDiffLine(line) {
+  const parts = line.split('\t')
+  if (parts.length < 2) return null
+
+  const statusCode = parts[0].charAt(0)
+  const status = STATUS_MAP[statusCode] || 'unknown'
+
+  if (statusCode === 'R' || statusCode === 'C') {
+    return { path: parts[2] || parts[1], status, oldPath: parts[1] }
+  }
+  return { path: parts[1], status }
+}
+
+/**
+ * Parse untracked file listing into structured data.
+ * @param {string} rawOutput
+ * @returns {Array<{path: string, status: string}>}
+ */
+function parseUntrackedOutput(rawOutput) {
+  if (!rawOutput || !rawOutput.trim()) return []
+  return rawOutput
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((path) => ({ path: path.trim(), status: 'added' }))
+}
+
+/**
+ * Validate that a git ref is safe for shell interpolation.
+ * Allows alphanumeric chars, dots, hyphens, slashes, tildes, carets, at-signs,
+ * braces, and colons — all legal in git refs but no shell metacharacters.
+ * @param {string} ref
+ * @returns {boolean}
+ */
+function isValidGitRef(ref) {
+  return /^[\w.\-/~^@{}:]+$/.test(ref)
+}
+
+/**
+ * Detect changed files relative to a base ref.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {string} [baseRef='HEAD'] - Git ref to diff against
+ * @param {Object} [options]
+ * @param {boolean} [options.staged] - Only staged changes (default: false)
+ * @param {boolean} [options.includeUntracked] - Include untracked files (default: true)
+ * @returns {Promise<{files: Array<{path: string, status: string}>, baseRef: string, error: string|null}>}
+ */
+export async function detectChangedFiles(
+  provider,
+  baseRef = 'HEAD',
+  options = {},
+) {
+  const { staged = false, includeUntracked = true } = options
+
+  if (typeof provider.execCommand !== 'function') {
+    return {
+      files: [],
+      baseRef,
+      error: 'Provider does not support execCommand',
+    }
+  }
+
+  if (!staged && !isValidGitRef(baseRef)) {
+    return {
+      files: [],
+      baseRef,
+      error: 'Invalid git ref: contains unsafe characters',
+    }
+  }
+
+  const diffCommand = staged
+    ? 'git diff --name-status --cached'
+    : `git diff --name-status ${baseRef}`
+
+  const diffResult = await provider.execCommand(diffCommand)
+
+  if (diffResult.exitCode !== 0 && diffResult.stderr) {
+    const isNotGit =
+      diffResult.stderr.includes('not a git repository') ||
+      diffResult.stderr.includes('Not a git repository')
+    if (isNotGit) {
+      return { files: [], baseRef, error: 'Not a git repository' }
+    }
+    return { files: [], baseRef, error: diffResult.stderr.trim() }
+  }
+
+  const files = parseDiffOutput(diffResult.stdout)
+
+  if (includeUntracked) {
+    const untrackedResult = await provider.execCommand(
+      'git ls-files --others --exclude-standard',
+    )
+    if (untrackedResult.exitCode === 0) {
+      files.push(...parseUntrackedOutput(untrackedResult.stdout))
+    }
+  }
+
+  return { files, baseRef, error: null }
+}

package/src/providers/interface.js

@@ -0,0 +1,12 @@
+/**
+ * @typedef {Object} FileProvider
+ * @property {function(string): string|null} readFile - Read file contents. Returns null on error.
+ * @property {function(string): string[]} readLines - Read file as array of lines. Returns [] on error.
+ * @property {function(string): boolean} fileExists - Check if file exists.
+ * @property {function(string): string[]} glob - Recursive glob matching. Pattern supports ** wildcards.
+ * @property {function(string): string[]} listDir - List directory contents. Returns [] if not found.
+ * @property {function(): string} getProjectRoot - Return the project root identifier.
+ * @property {function(string): Promise<{stdout: string, stderr: string, exitCode: number}>} [execCommand]
+ *   Execute a shell command in the project root. Returns stdout, stderr, and exit code.
+ */
+export default {}

package/src/providers/local-fs.js

@@ -0,0 +1,318 @@
+import {
+  readFileSync,
+  readdirSync,
+  existsSync,
+  statSync,
+  realpathSync,
+} from 'node:fs'
+import { join, relative, resolve, sep } from 'node:path'
+import { exec } from 'node:child_process'
+import { promisify } from 'node:util'
+import { EXEC_MAX_BUFFER, EXEC_TIMEOUT_MS } from '../core/constants.js'
+
+const execPromise = promisify(exec)
+
+const SKIP_DIRS = new Set([
+  'node_modules',
+  'vendor',
+  '.git',
+  'tmp',
+  'log',
+  '.bundle',
+  'coverage',
+  '.yarn',
+])
+
+const SKIP_PATHS = new Set(['public/assets', 'public/packs'])
+
+/**
+ * LocalFSProvider implements the FileProvider interface using Node.js fs.
+ * All paths are relative to projectRoot.
+ */
+export class LocalFSProvider {
+  /** @param {string} projectRoot - Absolute path to the Rails project root */
+  constructor(projectRoot) {
+    this._root = projectRoot
+  }
+
+  /** @returns {string} */
+  getProjectRoot() {
+    return this._root
+  }
+
+  /**
+   * Resolve a relative path safely within the project root.
+   * Returns null if the path would escape the project root (path traversal).
+   * @param {string} relativePath
+   * @returns {string|null} Absolute path or null if unsafe
+   */
+  _safePath(relativePath) {
+    const full = resolve(join(this._root, relativePath))
+    const root = resolve(this._root)
+    if (full !== root && !full.startsWith(root + sep)) {
+      return null
+    }
+    return full
+  }
+
+  /**
+   * Read a file's contents as UTF-8.
+   * @param {string} relativePath
+   * @returns {string|null} File contents or null on error
+   */
+  readFile(relativePath) {
+    try {
+      const full = this._safePath(relativePath)
+      if (!full) return null
+      return readFileSync(full, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Read a file as an array of lines.
+   * @param {string} relativePath
+   * @returns {string[]}
+   */
+  readLines(relativePath) {
+    const content = this.readFile(relativePath)
+    if (content === null) return []
+    return content.split('\n')
+  }
+
+  /**
+   * Check if a file exists.
+   * @param {string} relativePath
+   * @returns {boolean}
+   */
+  fileExists(relativePath) {
+    try {
+      const full = this._safePath(relativePath)
+      if (!full) return false
+      return existsSync(full)
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Recursive glob matching. Supports ** wildcards and * single-level wildcards.
+   * @param {string} pattern - e.g. 'app/models/**\/*.rb'
+   * @returns {string[]} Matching relative paths, sorted
+   */
+  glob(pattern) {
+    const results = []
+    const parts = pattern.split('/')
+    const visited = new Set()
+    this._globWalk('', parts, results, visited)
+    return results.sort()
+  }
+
+  /**
+   * List directory contents.
+   * @param {string} relativePath
+   * @returns {string[]} Sorted list of entry names
+   */
+  listDir(relativePath) {
+    try {
+      const full = this._safePath(relativePath)
+      if (!full) return []
+      return readdirSync(full).sort()
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Internal recursive glob walker.
+   * @param {string} currentRel - Current relative directory
+   * @param {string[]} patternParts - Remaining pattern segments
+   * @param {string[]} results - Accumulator
+   * @param {Set<string>} visited - Visited real paths for circular symlink protection
+   */
+  _globWalk(currentRel, patternParts, results, visited) {
+    if (patternParts.length === 0) return
+
+    const currentAbs = join(this._root, currentRel)
+    const segment = patternParts[0]
+    const remaining = patternParts.slice(1)
+
+    if (segment === '**') {
+      // Match zero or more directories
+      // Try matching remaining pattern at current level (zero dirs)
+      this._globWalk(currentRel, remaining, results, visited)
+
+      // Also recurse into all subdirectories with ** still active
+      let entries
+      try {
+        entries = readdirSync(currentAbs, { withFileTypes: true })
+      } catch {
+        return
+      }
+
+      for (const entry of entries) {
+        if (this._shouldSkip(currentRel, entry.name)) continue
+        const isDir =
+          entry.isDirectory() ||
+          (entry.isSymbolicLink() &&
+            this._isDirectoryLink(currentRel, entry.name))
+        if (isDir) {
+          const childRel = currentRel
+            ? `${currentRel}/${entry.name}`
+            : entry.name
+          const childAbs = join(this._root, childRel)
+          const childReal = this._realPath(childAbs)
+          if (childReal && visited.has(childReal)) continue
+          if (childReal) visited.add(childReal)
+          this._globWalk(childRel, patternParts, results, visited)
+        }
+      }
+    } else if (remaining.length === 0) {
+      // This is the final segment — match files/dirs
+      let entries
+      try {
+        entries = readdirSync(currentAbs, { withFileTypes: true })
+      } catch {
+        return
+      }
+
+      for (const entry of entries) {
+        if (this._matchSegment(entry.name, segment)) {
+          const matchRel = currentRel
+            ? `${currentRel}/${entry.name}`
+            : entry.name
+          results.push(matchRel)
+        }
+      }
+    } else {
+      // Intermediate segment — match directories only
+      let entries
+      try {
+        entries = readdirSync(currentAbs, { withFileTypes: true })
+      } catch {
+        return
+      }
+
+      for (const entry of entries) {
+        const isDir =
+          entry.isDirectory() ||
+          (entry.isSymbolicLink() &&
+            this._isDirectoryLink(currentRel, entry.name))
+        if (!isDir) continue
+        if (this._shouldSkip(currentRel, entry.name)) continue
+        if (this._matchSegment(entry.name, segment)) {
+          const childRel = currentRel
+            ? `${currentRel}/${entry.name}`
+            : entry.name
+          this._globWalk(childRel, remaining, results, visited)
+        }
+      }
+    }
+  }
+
+  /**
+   * Check if a symbolic link points to a directory.
+   * @param {string} currentRel - Current relative directory
+   * @param {string} entryName - Entry name
+   * @returns {boolean}
+   */
+  _isDirectoryLink(currentRel, entryName) {
+    try {
+      const full = join(this._root, currentRel, entryName)
+      const stat = statSync(full)
+      return stat.isDirectory()
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Resolve the real path for circular symlink detection.
+   * @param {string} absPath
+   * @returns {string|null}
+   */
+  _realPath(absPath) {
+    try {
+      return realpathSync(absPath)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Match a filename against a simple glob segment (supports * and ?).
+   * @param {string} name
+   * @param {string} pattern
+   * @returns {boolean}
+   */
+  _matchSegment(name, pattern) {
+    // Convert glob pattern to regex
+    let regex = '^'
+    for (let i = 0; i < pattern.length; i++) {
+      const ch = pattern[i]
+      if (ch === '*') {
+        regex += '[^/]*'
+      } else if (ch === '?') {
+        regex += '[^/]'
+      } else if (ch === '.') {
+        regex += '\\.'
+      } else if (ch === '{') {
+        // Handle brace expansion: {a,b,c}
+        const closeIdx = pattern.indexOf('}', i)
+        if (closeIdx !== -1) {
+          const alternatives = pattern.substring(i + 1, closeIdx).split(',')
+          regex +=
+            '(?:' +
+            alternatives.map((a) => a.replace(/\./g, '\\.')).join('|') +
+            ')'
+          i = closeIdx
+        } else {
+          regex += '\\{'
+        }
+      } else {
+        regex += ch.replace(/[[\]()\\+^$|]/g, '\\$&')
+      }
+    }
+    regex += '$'
+    return new RegExp(regex).test(name)
+  }
+
+  /**
+   * Check if a directory entry should be skipped during glob traversal.
+   * @param {string} currentRel
+   * @param {string} entryName
+   * @returns {boolean}
+   */
+  _shouldSkip(currentRel, entryName) {
+    if (SKIP_DIRS.has(entryName)) return true
+    const entryRel = currentRel ? `${currentRel}/${entryName}` : entryName
+    if (SKIP_PATHS.has(entryRel)) return true
+    return false
+  }
+
+  /**
+   * Execute a shell command in the project root.
+   * @param {string} command
+   * @returns {Promise<{stdout: string, stderr: string, exitCode: number}>}
+   */
+  async execCommand(command) {
+    try {
+      const { stdout, stderr } = await execPromise(command, {
+        cwd: this._root,
+        maxBuffer: EXEC_MAX_BUFFER,
+        timeout: EXEC_TIMEOUT_MS,
+      })
+      return { stdout: stdout || '', stderr: stderr || '', exitCode: 0 }
+    } catch (err) {
+      const isTimeout = err.killed && err.signal === 'SIGTERM'
+      return {
+        stdout: err.stdout || '',
+        stderr: isTimeout
+          ? `Command timed out after ${EXEC_TIMEOUT_MS}ms: ${command}`
+          : err.stderr || '',
+        exitCode: err.code || 1,
+      }
+    }
+  }
+}