depwire-cli 1.1.8 → 1.2.0

package/dist/{chunk-ZO3LWFDE.js → chunk-O5HXGEGE.js}

@@ -39,8 +39,9 @@ function scanDirectory(rootDir, baseDir = rootDir) {
         const isPhp = entry.endsWith(".php");
         const isSwift = entry.endsWith(".swift");
         const isMojo = entry.endsWith(".mojo") || entry.endsWith(".\u{1F525}");
+        const isRuby = entry.endsWith(".rb") || entry.endsWith(".rake") || entry.endsWith(".gemspec") || entry.endsWith(".ru") || entry === "Gemfile";
         const isCppBuild = entry === "CMakeLists.txt" || entry === "conanfile.txt" || entry === "vcpkg.json";
-        if (isTypeScript || isJavaScript || isPython || isGo || isRust || isC || isCpp || isCSharp || isJava || isKotlin || isPhp || isSwift || isMojo || isCppBuild) {
+        if (isTypeScript || isJavaScript || isPython || isGo || isRust || isC || isCpp || isCSharp || isJava || isKotlin || isPhp || isSwift || isMojo || isRuby || isCppBuild) {
           files.push(relative(rootDir, fullPath));
         }
       }
@@ -90,6 +91,8 @@ function findProjectRoot(startDir = process.cwd()) {
     // Swift (SPM)
     "mojoproject.toml",
     // Mojo
+    "Gemfile",
+    // Ruby (Bundler)
     ".git"
     // Any git repo
   ];
@@ -123,11 +126,11 @@ function findProjectRoot(startDir = process.cwd()) {
 }
 
 // src/parser/index.ts
-import { readFileSync as readFileSync11, statSync as statSync8 } from "fs";
-import { join as join15, resolve as resolve9 } from "path";
+import { readFileSync as readFileSync12, statSync as statSync9 } from "fs";
+import { join as join16, resolve as resolve10 } from "path";
 
 // src/parser/detect.ts
-import { extname as extname10, basename as basename8 } from "path";
+import { extname as extname11, basename as basename9 } from "path";
 
 // src/parser/wasm-init.ts
 import { Parser, Language } from "web-tree-sitter";
@@ -160,7 +163,8 @@ async function initParser() {
     "cpp": "tree-sitter-cpp.wasm",
     "kotlin": "tree-sitter-kotlin.wasm",
     "php": "tree-sitter-php.wasm",
-    "swift": "tree-sitter-swift.wasm"
+    "swift": "tree-sitter-swift.wasm",
+    "ruby": "tree-sitter-ruby.wasm"
     // Note: Mojo uses a pattern-based parser (no tree-sitter-mojo WASM available)
   };
   for (const [name, file] of Object.entries(grammarFiles)) {
@@ -7146,12 +7150,566 @@ function parseMojoProject(filePath, sourceCode, projectRoot) {
       });
     }
   }
-  return { filePath, symbols, edges };
+  return { filePath, symbols, edges };
+}
+var mojoParser = {
+  name: "mojo",
+  extensions: [".mojo", ".\u{1F525}", "mojoproject.toml"],
+  parseFile: parseMojoFile
+};
+
+// src/parser/ruby.ts
+import { dirname as dirname14, join as join15, basename as basename8 } from "path";
+import { existsSync as existsSync14 } from "fs";
+function parseRubyFile(filePath, sourceCode, projectRoot) {
+  if (basename8(filePath) === "Gemfile") {
+    return parseGemfile(filePath, sourceCode, projectRoot);
+  }
+  const parser = getParser("ruby");
+  const tree = parser.parse(sourceCode, null, { bufferSize: 1024 * 1024 });
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    currentClass: null,
+    currentModule: null,
+    imports: /* @__PURE__ */ new Map(),
+    isGemfile: false
+  };
+  walkNode13(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode13(node, context) {
+  const handled = processNode13(node, context);
+  if (handled) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode13(child, context);
+    }
+  }
+}
+function processNode13(node, context) {
+  switch (node.type) {
+    case "class":
+      processClassDeclaration8(node, context);
+      return true;
+    case "module":
+      processModuleDeclaration(node, context);
+      return true;
+    case "method":
+      processMethodDeclaration5(node, context);
+      return true;
+    case "singleton_method":
+      processSingletonMethod(node, context);
+      return true;
+    case "assignment":
+      processAssignment(node, context);
+      return false;
+    case "call":
+    case "method_call":
+      processCallExpression13(node, context);
+      return false;
+    case "command":
+      processCommand(node, context);
+      return false;
+    case "command_call":
+      processCommandCall(node, context);
+      return false;
+    case "constant":
+      return false;
+    case "block":
+    case "do_block":
+      return false;
+    case "lambda":
+      processLambda(node, context);
+      return false;
+    default:
+      return false;
+  }
+}
+function processClassDeclaration8(node, context) {
+  const nameNode = findChildByType13(node, "constant") || findChildByType13(node, "scope_resolution");
+  if (!nameNode) return;
+  const name = nodeText12(nameNode, context);
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "class",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true
+  });
+  const superclassNode = findChildByType13(node, "superclass");
+  if (superclassNode) {
+    const superName = nodeText12(superclassNode, context).replace(/^\s*<\s*/, "").trim();
+    if (superName) {
+      const baseId = resolveSymbol12(superName, context);
+      if (baseId) {
+        context.edges.push({
+          source: symbolId,
+          target: baseId,
+          kind: "implements",
+          filePath: context.filePath,
+          line: node.startPosition.row + 1
+        });
+      }
+    }
+  }
+  const oldClass = context.currentClass;
+  context.currentClass = name;
+  context.currentScope.push(name);
+  const body = findChildByType13(node, "body_statement");
+  if (body) {
+    walkNode13(body, context);
+  }
+  context.currentScope.pop();
+  context.currentClass = oldClass;
+}
+function processModuleDeclaration(node, context) {
+  const nameNode = findChildByType13(node, "constant") || findChildByType13(node, "scope_resolution");
+  if (!nameNode) return;
+  const name = nodeText12(nameNode, context);
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "module",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true
+  });
+  const oldModule = context.currentModule;
+  const oldClass = context.currentClass;
+  context.currentModule = name;
+  context.currentClass = name;
+  context.currentScope.push(name);
+  const body = findChildByType13(node, "body_statement");
+  if (body) {
+    walkNode13(body, context);
+  }
+  context.currentScope.pop();
+  context.currentModule = oldModule;
+  context.currentClass = oldClass;
+}
+function processMethodDeclaration5(node, context) {
+  const nameNode = findChildByType13(node, "identifier");
+  if (!nameNode) return;
+  const name = nodeText12(nameNode, context);
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: context.currentClass ? "method" : "function",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true,
+    scope
+  });
+  const scopeName = scope ? `${scope}.${name}` : name;
+  context.currentScope.push(scopeName);
+  const body = findChildByType13(node, "body_statement");
+  if (body) {
+    walkNode13(body, context);
+  }
+  context.currentScope.pop();
+}
+function processSingletonMethod(node, context) {
+  const nameNode = node.childCount > 2 ? node.child(node.childCount - 2) : null;
+  let name = "";
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "identifier") {
+      name = nodeText12(child, context);
+    }
+  }
+  if (!name) return;
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.self.${name}` : `${context.filePath}::self.${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name: `self.${name}`,
+    kind: "method",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true,
+    scope
+  });
+  const scopeName = scope ? `${scope}.self.${name}` : `self.${name}`;
+  context.currentScope.push(scopeName);
+  const body = findChildByType13(node, "body_statement");
+  if (body) {
+    walkNode13(body, context);
+  }
+  context.currentScope.pop();
+}
+function processAssignment(node, context) {
+  const left = node.child(0);
+  if (!left) return;
+  const text = nodeText12(left, context);
+  const scope = context.currentClass || void 0;
+  if (left.type === "constant") {
+    const symbolId = scope ? `${context.filePath}::${scope}.${text}` : `${context.filePath}::${text}`;
+    context.symbols.push({
+      id: symbolId,
+      name: text,
+      kind: "constant",
+      filePath: context.filePath,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      exported: true,
+      scope
+    });
+  }
+  if (left.type === "instance_variable") {
+    const symbolId = scope ? `${context.filePath}::${scope}.${text}` : `${context.filePath}::${text}`;
+    context.symbols.push({
+      id: symbolId,
+      name: text,
+      kind: "property",
+      filePath: context.filePath,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      exported: false,
+      scope
+    });
+  }
+  if (left.type === "class_variable") {
+    const symbolId = scope ? `${context.filePath}::${scope}.${text}` : `${context.filePath}::${text}`;
+    context.symbols.push({
+      id: symbolId,
+      name: text,
+      kind: "property",
+      filePath: context.filePath,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      exported: false,
+      scope
+    });
+  }
+}
+function processCallExpression13(node, context) {
+  const text = nodeText12(node, context);
+  const line = node.startPosition.row + 1;
+  const requireMatch = text.match(/^require(?:_relative)?\s*\(?['"]([^'"]+)['"]\)?/);
+  if (requireMatch) {
+    processRequire(requireMatch[1], text.startsWith("require_relative"), context, line);
+    return;
+  }
+  const mixinMatch = text.match(/^(?:include|extend|prepend)\s+([A-Z]\w*(?:::\w+)*)/);
+  if (mixinMatch) {
+    processMixin(mixinMatch[1], context, line);
+    return;
+  }
+  const attrMatch = text.match(/^attr_(accessor|reader|writer)\s+(.+)/);
+  if (attrMatch) {
+    processAttrAccessor(attrMatch[2], context, line);
+    return;
+  }
+  if (context.currentScope.length > 0) {
+    const firstChild = node.child(0);
+    let calleeName = null;
+    if (firstChild && firstChild.type === "identifier") {
+      calleeName = nodeText12(firstChild, context);
+    }
+    if (calleeName && !isBuiltin(calleeName)) {
+      const callerId = getCurrentSymbolId13(context);
+      if (callerId) {
+        const calleeId = resolveSymbol12(calleeName, context);
+        if (calleeId) {
+          context.edges.push({
+            source: callerId,
+            target: calleeId,
+            kind: "calls",
+            filePath: context.filePath,
+            line
+          });
+        }
+      }
+    }
+  }
+}
+function processCommand(node, context) {
+  const text = nodeText12(node, context).trim();
+  const line = node.startPosition.row + 1;
+  const requireMatch = text.match(/^require(?:_relative)?\s+['"]([^'"]+)['"]/);
+  if (requireMatch) {
+    processRequire(requireMatch[1], text.startsWith("require_relative"), context, line);
+    return;
+  }
+  const mixinMatch = text.match(/^(?:include|extend|prepend)\s+([A-Z]\w*(?:::\w+)*)/);
+  if (mixinMatch) {
+    processMixin(mixinMatch[1], context, line);
+    return;
+  }
+  const attrMatch = text.match(/^attr_(accessor|reader|writer)\s+(.+)/);
+  if (attrMatch) {
+    processAttrAccessor(attrMatch[2], context, line);
+    return;
+  }
+}
+function processCommandCall(node, context) {
+  const text = nodeText12(node, context).trim();
+  if (/Struct\.new/.test(text) || /OpenStruct\.new/.test(text)) {
+    const parent = node.parent;
+    if (parent && parent.type === "assignment") {
+      const left = parent.child(0);
+      if (left && left.type === "constant") {
+        const name = nodeText12(left, context);
+        const symbolId = `${context.filePath}::${name}`;
+        context.symbols.push({
+          id: symbolId,
+          name,
+          kind: "class",
+          filePath: context.filePath,
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          exported: true
+        });
+      }
+    }
+  }
+}
+function processLambda(node, context) {
+  const parent = node.parent;
+  if (parent && parent.type === "assignment") {
+    const left = parent.child(0);
+    if (left) {
+      const name = nodeText12(left, context);
+      const scope = context.currentClass || void 0;
+      const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+      context.symbols.push({
+        id: symbolId,
+        name,
+        kind: "function",
+        filePath: context.filePath,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        exported: true,
+        scope
+      });
+    }
+  }
+}
+function processRequire(path6, isRelative, context, line) {
+  const resolvedPath = resolveRubyRequire(path6, isRelative, context.filePath, context.projectRoot);
+  if (resolvedPath) {
+    const sourceId = `${context.filePath}::__file__`;
+    const targetId = `${resolvedPath}::__file__`;
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "imports",
+      filePath: context.filePath,
+      line
+    });
+  }
+  const symbolId = `${context.filePath}::require:${path6}`;
+  context.symbols.push({
+    id: symbolId,
+    name: path6,
+    kind: "import",
+    filePath: context.filePath,
+    startLine: line,
+    endLine: line,
+    exported: false
+  });
+}
+function processMixin(moduleName, context, line) {
+  const scope = context.currentClass || void 0;
+  const sourceId = scope ? `${context.filePath}::${scope}` : `${context.filePath}::__file__`;
+  const targetId = resolveSymbol12(moduleName, context);
+  if (targetId) {
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "implements",
+      filePath: context.filePath,
+      line
+    });
+  }
+}
+function processAttrAccessor(args, context, line) {
+  const scope = context.currentClass || void 0;
+  const symbols = args.match(/:\w+/g);
+  if (!symbols) return;
+  for (const sym of symbols) {
+    const name = sym.slice(1);
+    const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+    context.symbols.push({
+      id: symbolId,
+      name,
+      kind: "property",
+      filePath: context.filePath,
+      startLine: line,
+      endLine: line,
+      exported: true,
+      scope
+    });
+  }
+}
+function parseGemfile(filePath, sourceCode, projectRoot) {
+  const symbols = [];
+  const edges = [];
+  const lines = sourceCode.split("\n");
+  symbols.push({
+    id: `${filePath}::Gemfile`,
+    name: "Gemfile",
+    kind: "module",
+    filePath,
+    startLine: 1,
+    endLine: lines.length,
+    exported: true
+  });
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const lineNum = i + 1;
+    const gemMatch = line.match(/^\s*gem\s+['"]([^'"]+)['"]/);
+    if (gemMatch) {
+      const gemName = gemMatch[1];
+      symbols.push({
+        id: `${filePath}::gem:${gemName}`,
+        name: gemName,
+        kind: "import",
+        filePath,
+        startLine: lineNum,
+        endLine: lineNum,
+        exported: false
+      });
+    }
+  }
+  return { filePath, symbols, edges };
+}
+function resolveRubyRequire(requirePath, isRelative, currentFile, projectRoot) {
+  const extensions = [".rb", ""];
+  if (isRelative) {
+    const dir = dirname14(join15(projectRoot, currentFile));
+    for (const ext of extensions) {
+      const candidate = join15(dir, requirePath + ext);
+      if (existsSync14(candidate)) {
+        const rel = candidate.replace(projectRoot + "/", "");
+        return rel;
+      }
+    }
+  } else {
+    const searchRoots = ["lib", "app", "app/models", "app/controllers", "app/services", ""];
+    for (const root of searchRoots) {
+      for (const ext of extensions) {
+        const candidate = root ? join15(projectRoot, root, requirePath + ext) : join15(projectRoot, requirePath + ext);
+        if (existsSync14(candidate)) {
+          const rel = candidate.replace(projectRoot + "/", "");
+          return rel;
+        }
+      }
+    }
+  }
+  return null;
+}
+function resolveSymbol12(name, context) {
+  if (context.imports.has(name)) {
+    return context.imports.get(name) || null;
+  }
+  const currentFileId = `${context.filePath}::${name}`;
+  if (context.symbols.find((s) => s.id === currentFileId)) {
+    return currentFileId;
+  }
+  if (context.currentClass) {
+    const classMethodId = `${context.filePath}::${context.currentClass}.${name}`;
+    if (context.symbols.find((s) => s.id === classMethodId)) {
+      return classMethodId;
+    }
+  }
+  return null;
+}
+function isBuiltin(name) {
+  const builtins = /* @__PURE__ */ new Set([
+    "puts",
+    "print",
+    "p",
+    "pp",
+    "warn",
+    "raise",
+    "fail",
+    "require",
+    "require_relative",
+    "include",
+    "extend",
+    "prepend",
+    "attr_accessor",
+    "attr_reader",
+    "attr_writer",
+    "private",
+    "protected",
+    "public",
+    "new",
+    "initialize",
+    "super",
+    "self",
+    "map",
+    "each",
+    "select",
+    "reject",
+    "reduce",
+    "collect",
+    "find",
+    "detect",
+    "any?",
+    "all?",
+    "none?",
+    "count",
+    "freeze",
+    "dup",
+    "clone",
+    "nil?",
+    "is_a?",
+    "kind_of?",
+    "respond_to?",
+    "send",
+    "class",
+    "object_id",
+    "to_s",
+    "to_i",
+    "to_f",
+    "to_a",
+    "to_h",
+    "lambda",
+    "proc",
+    "block_given?",
+    "yield"
+  ]);
+  return builtins.has(name);
+}
+function findChildByType13(node, type) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) return child;
+  }
+  return null;
 }
-var mojoParser = {
-  name: "mojo",
-  extensions: [".mojo", ".\u{1F525}", "mojoproject.toml"],
-  parseFile: parseMojoFile
+function nodeText12(node, context) {
+  return context.sourceCode.substring(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId13(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope[context.currentScope.length - 1]}`;
+}
+var rubyParser = {
+  name: "ruby",
+  extensions: [".rb", ".rake", ".gemspec", "Gemfile"],
+  parseFile: parseRubyFile
 };
 
 // src/parser/detect.ts
@@ -7168,12 +7726,13 @@ var parsers = [
   kotlinParser,
   phpParser,
   swiftParser,
-  mojoParser
+  mojoParser,
+  rubyParser
 ];
 var CPP_KEYWORDS = /\b(?:class|namespace|template|public:|private:|protected:|virtual|nullptr|constexpr|auto\s+\w+\s*=|using\s+\w+\s*=|static_cast|dynamic_cast|reinterpret_cast|const_cast|noexcept|override|final|decltype|concept|requires|co_await|co_yield|co_return|std::)\b/;
 function getParserForFile(filePath, content) {
-  const ext = extname10(filePath).toLowerCase();
-  const fileName = basename8(filePath);
+  const ext = extname11(filePath).toLowerCase();
+  const fileName = basename9(filePath);
   if (ext === ".h" && content) {
     if (CPP_KEYWORDS.test(content)) {
       return cppParser;
@@ -7191,7 +7750,7 @@ import { minimatch } from "minimatch";
 var MAX_FILE_SIZE = 1e6;
 function shouldParseFile(fullPath) {
   try {
-    const stats = statSync8(fullPath);
+    const stats = statSync9(fullPath);
     if (stats.size > MAX_FILE_SIZE) {
       console.error(`[Parser] Skipping ${fullPath} \u2014 file too large (${(stats.size / 1024).toFixed(0)}KB)`);
       return false;
@@ -7209,8 +7768,8 @@ async function parseProject(projectRoot, options) {
   let errorFiles = 0;
   for (const file of files) {
     try {
-      const fullPath = join15(projectRoot, file);
-      if (!resolve9(fullPath).startsWith(resolve9(projectRoot))) {
+      const fullPath = join16(projectRoot, file);
+      if (!resolve10(fullPath).startsWith(resolve10(projectRoot))) {
         skippedFiles++;
         continue;
       }
@@ -7233,7 +7792,7 @@ async function parseProject(projectRoot, options) {
       if (options?.verbose) {
         console.error(`[Parser] Parsing: ${file}`);
       }
-      const sourceCode = readFileSync11(fullPath, "utf-8");
+      const sourceCode = readFileSync12(fullPath, "utf-8");
       const parser = getParserForFile(file, sourceCode);
       if (!parser) {
         console.error(`No parser found for file: ${file}`);
@@ -7262,8 +7821,8 @@ async function parseProject(projectRoot, options) {
 }
 
 // src/cross-language/detectors/rest-api.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { join as join16, resolve as resolve10 } from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import { join as join17, resolve as resolve11 } from "path";
 function getLanguage(filePath) {
   if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "typescript";
   if (filePath.endsWith(".js") || filePath.endsWith(".jsx") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs")) return "javascript";
@@ -7274,6 +7833,7 @@ function getLanguage(filePath) {
   if (filePath.endsWith(".kt") || filePath.endsWith(".kts")) return "kotlin";
   if (filePath.endsWith(".php")) return "php";
   if (filePath.endsWith(".swift")) return "swift";
+  if (filePath.endsWith(".rb") || filePath.endsWith(".rake") || filePath.endsWith(".ru") || filePath.endsWith(".gemspec")) return "ruby";
   if (filePath.endsWith(".mojo") || filePath.endsWith(".\u{1F525}")) return "mojo";
   if (filePath.endsWith(".cpp") || filePath.endsWith(".cc") || filePath.endsWith(".cxx") || filePath.endsWith(".c++") || filePath.endsWith(".hpp") || filePath.endsWith(".hh") || filePath.endsWith(".hxx") || filePath.endsWith(".h++") || filePath.endsWith(".h") || filePath.endsWith(".inl") || filePath.endsWith(".ipp")) return "cpp";
   return "unknown";
@@ -7761,6 +8321,63 @@ function extractRouteDefinitions(source, filePath) {
         }
       }
     }
+    if (lang === "ruby") {
+      const railsRouteMatch = line.match(/^\s*(get|post|put|patch|delete)\s+['"]([^'"]+)['"]/);
+      if (railsRouteMatch) {
+        const path6 = railsRouteMatch[2].startsWith("/") ? railsRouteMatch[2] : "/" + railsRouteMatch[2];
+        routes.push({
+          method: railsRouteMatch[1].toUpperCase(),
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const sinatraMatch = line.match(/^\s*(get|post|put|patch|delete)\s+['"]([^'"]+)['"]\s+do/);
+      if (sinatraMatch && !railsRouteMatch) {
+        const path6 = sinatraMatch[2].startsWith("/") ? sinatraMatch[2] : "/" + sinatraMatch[2];
+        routes.push({
+          method: sinatraMatch[1].toUpperCase(),
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const resourcesMatch = line.match(/^\s*resources?\s+:(\w+)/);
+      if (resourcesMatch) {
+        const resourcePath = "/" + resourcesMatch[1];
+        routes.push({
+          method: "ANY",
+          path: resourcePath,
+          normalizedPath: normalizePath(resourcePath),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const rackMatch = line.match(/^\s*map\s+['"]([^'"]+)['"]/);
+      if (rackMatch) {
+        const path6 = rackMatch[1].startsWith("/") ? rackMatch[1] : "/" + rackMatch[1];
+        routes.push({
+          method: "ANY",
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const grapeMatch = line.match(/^\s*(get|post|put|patch|delete)\s+['"]([^'"]+)['"]/);
+      if (grapeMatch && !railsRouteMatch) {
+        const path6 = grapeMatch[2].startsWith("/") ? grapeMatch[2] : "/" + grapeMatch[2];
+        routes.push({
+          method: grapeMatch[1].toUpperCase(),
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+    }
     if (lang === "cpp") {
       const crowMatch = line.match(/CROW_ROUTE\s*\(\s*\w+\s*,\s*"([^"]+)"/);
       if (crowMatch) {
@@ -7875,11 +8492,11 @@ function detectRestApiEdges(files, projectRoot) {
   const allCalls = [];
   const allRoutes = [];
   for (const file of files) {
-    const fullPath = join16(projectRoot, file.filePath);
-    if (!resolve10(fullPath).startsWith(resolve10(projectRoot))) continue;
+    const fullPath = join17(projectRoot, file.filePath);
+    if (!resolve11(fullPath).startsWith(resolve11(projectRoot))) continue;
     let source;
     try {
-      source = readFileSync12(fullPath, "utf-8");
+      source = readFileSync13(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -7951,6 +8568,34 @@ function detectRestApiEdges(files, projectRoot) {
         }
       }
     }
+    if (lang === "ruby") {
+      const rubyLines = source.split("\n");
+      for (let i = 0; i < rubyLines.length; i++) {
+        const line = rubyLines[i];
+        const faradayMatch = line.match(/\w+\s*\.\s*(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]/i);
+        if (faradayMatch) {
+          const path6 = faradayMatch[2];
+          if (isLocalApiPath(path6)) {
+            allCalls.push({ method: faradayMatch[1].toUpperCase(), path: cleanPath(path6), file: file.filePath, line: i + 1 });
+          }
+        }
+        const netHttpMatch = line.match(/Net::HTTP\s*\.\s*(get|post_form|post)\s*\(/i);
+        if (netHttpMatch) {
+          const uriMatch = line.match(/['"]([^'"]+)['"]/);
+          if (uriMatch && isLocalApiPath(uriMatch[1])) {
+            const method = netHttpMatch[1].toUpperCase().replace("POST_FORM", "POST");
+            allCalls.push({ method, path: cleanPath(uriMatch[1]), file: file.filePath, line: i + 1 });
+          }
+        }
+        const httpartyMatch = line.match(/(?:HTTParty|self)\s*\.\s*(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]/i);
+        if (httpartyMatch) {
+          const path6 = httpartyMatch[2];
+          if (isLocalApiPath(path6)) {
+            allCalls.push({ method: httpartyMatch[1].toUpperCase(), path: cleanPath(path6), file: file.filePath, line: i + 1 });
+          }
+        }
+      }
+    }
     allRoutes.push(...extractRouteDefinitions(source, file.filePath));
   }
   for (const call of allCalls) {
@@ -7979,8 +8624,8 @@ function detectRestApiEdges(files, projectRoot) {
 }
 
 // src/cross-language/detectors/subprocess.ts
-import { readFileSync as readFileSync13 } from "fs";
-import { join as join17, resolve as resolve11, basename as basename9 } from "path";
+import { readFileSync as readFileSync14 } from "fs";
+import { join as join18, resolve as resolve12, basename as basename10 } from "path";
 var SCRIPT_EXTENSIONS = [".py", ".js", ".ts", ".go", ".rs"];
 function getLanguage2(filePath) {
   if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "typescript";
@@ -8079,16 +8724,16 @@ function detectSubprocessEdges(files, projectRoot) {
   const knownFiles = new Set(files.map((f) => f.filePath));
   const basenameMap = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const base = basename9(f.filePath);
+    const base = basename10(f.filePath);
     if (!basenameMap.has(base)) basenameMap.set(base, []);
     basenameMap.get(base).push(f.filePath);
   }
   for (const file of files) {
-    const fullPath = join17(projectRoot, file.filePath);
-    if (!resolve11(fullPath).startsWith(resolve11(projectRoot))) continue;
+    const fullPath = join18(projectRoot, file.filePath);
+    if (!resolve12(fullPath).startsWith(resolve12(projectRoot))) continue;
     let source;
     try {
-      source = readFileSync13(fullPath, "utf-8");
+      source = readFileSync14(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -8100,7 +8745,7 @@ function detectSubprocessEdges(files, projectRoot) {
         targetFile = call.calledFile;
         confidence = "high";
       } else {
-        const base = basename9(call.calledFile);
+        const base = basename10(call.calledFile);
         const candidates = basenameMap.get(base);
         if (candidates && candidates.length > 0) {
           const exactCandidate = candidates.find((c) => c.endsWith(call.calledFile));
@@ -8479,7 +9124,7 @@ function getArchitectureSummary(graph) {
 }
 
 // src/health/metrics.ts
-import { dirname as dirname14 } from "path";
+import { dirname as dirname15 } from "path";
 function scoreToGrade(score) {
   if (score >= 90) return "A";
   if (score >= 80) return "B";
@@ -8512,8 +9157,8 @@ function calculateCouplingScore(graph) {
       totalEdges++;
       fileConnections.set(sourceAttrs.filePath, (fileConnections.get(sourceAttrs.filePath) || 0) + 1);
       fileConnections.set(targetAttrs.filePath, (fileConnections.get(targetAttrs.filePath) || 0) + 1);
-      const sourceDir = dirname14(sourceAttrs.filePath).split("/")[0];
-      const targetDir = dirname14(targetAttrs.filePath).split("/")[0];
+      const sourceDir = dirname15(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname15(targetAttrs.filePath).split("/")[0];
       if (sourceDir !== targetDir) {
         crossDirEdges++;
       }
@@ -8560,8 +9205,8 @@ function calculateCohesionScore(graph) {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
     if (sourceAttrs.filePath !== targetAttrs.filePath) {
-      const sourceDir = dirname14(sourceAttrs.filePath);
-      const targetDir = dirname14(targetAttrs.filePath);
+      const sourceDir = dirname15(sourceAttrs.filePath);
+      const targetDir = dirname15(targetAttrs.filePath);
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { internal: 0, total: 0 });
       }
@@ -8843,8 +9488,8 @@ function calculateDepthScore(graph) {
 }
 
 // src/health/index.ts
-import { readFileSync as readFileSync14, writeFileSync, existsSync as existsSync14, mkdirSync } from "fs";
-import { dirname as dirname15, resolve as resolve12 } from "path";
+import { readFileSync as readFileSync15, writeFileSync, existsSync as existsSync15, mkdirSync } from "fs";
+import { dirname as dirname16, resolve as resolve13 } from "path";
 function calculateHealthScore(graph, projectRoot) {
   const coupling = calculateCouplingScore(graph);
   const cohesion = calculateCohesionScore(graph);
@@ -8943,8 +9588,8 @@ function getHealthTrend(projectRoot, currentScore) {
   }
 }
 function saveHealthHistory(projectRoot, report) {
-  const resolvedRoot = resolve12(projectRoot);
-  const historyFile = resolve12(resolvedRoot, ".depwire", "health-history.json");
+  const resolvedRoot = resolve13(projectRoot);
+  const historyFile = resolve13(resolvedRoot, ".depwire", "health-history.json");
   if (!historyFile.startsWith(resolvedRoot)) {
     return;
   }
@@ -8959,10 +9604,10 @@ function saveHealthHistory(projectRoot, report) {
     }))
   };
   let history = [];
-  if (existsSync14(historyFile)) {
+  if (existsSync15(historyFile)) {
     try {
       if (!historyFile.startsWith(resolvedRoot)) return;
-      const content = readFileSync14(historyFile, "utf-8");
+      const content = readFileSync15(historyFile, "utf-8");
       history = JSON.parse(content);
     } catch {
     }
@@ -8971,19 +9616,19 @@ function saveHealthHistory(projectRoot, report) {
   if (history.length > 50) {
     history = history.slice(-50);
   }
-  mkdirSync(dirname15(historyFile), { recursive: true });
+  mkdirSync(dirname16(historyFile), { recursive: true });
   if (!historyFile.startsWith(resolvedRoot)) return;
   writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf-8");
 }
 function loadHealthHistory(projectRoot) {
-  const resolvedRoot = resolve12(projectRoot);
-  const historyFile = resolve12(resolvedRoot, ".depwire", "health-history.json");
-  if (!historyFile.startsWith(resolvedRoot) || !existsSync14(historyFile)) {
+  const resolvedRoot = resolve13(projectRoot);
+  const historyFile = resolve13(resolvedRoot, ".depwire", "health-history.json");
+  if (!historyFile.startsWith(resolvedRoot) || !existsSync15(historyFile)) {
     return [];
   }
   try {
     if (!historyFile.startsWith(resolvedRoot)) return [];
-    const content = readFileSync14(historyFile, "utf-8");
+    const content = readFileSync15(historyFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -8992,7 +9637,7 @@ function loadHealthHistory(projectRoot) {
 
 // src/dead-code/detector.ts
 import path2 from "path";
-import { readFileSync as readFileSync15, existsSync as existsSync15 } from "fs";
+import { readFileSync as readFileSync16, existsSync as existsSync16 } from "fs";
 function findDeadSymbols(graph, projectRoot, includeTests = false, debug = false) {
   const deadSymbols = [];
   const context = { graph, projectRoot };
@@ -9125,11 +9770,11 @@ function getPackageEntryPoints(projectRoot) {
   const entryPoints = /* @__PURE__ */ new Set();
   const resolvedRoot = path2.resolve(projectRoot);
   const packageJsonPath = path2.resolve(resolvedRoot, "package.json");
-  if (!packageJsonPath.startsWith(resolvedRoot) || !existsSync15(packageJsonPath)) {
+  if (!packageJsonPath.startsWith(resolvedRoot) || !existsSync16(packageJsonPath)) {
     return entryPoints;
   }
   try {
-    const packageJson = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync16(packageJsonPath, "utf-8"));
     if (packageJson.main) {
       entryPoints.add(path2.resolve(projectRoot, packageJson.main));
     }
@@ -9195,6 +9840,9 @@ function shouldExclude(attrs, context, includeTests, packageEntryPoints) {
   if (isMojoExcluded(attrs)) {
     return "framework";
   }
+  if (isRubyExcluded(attrs)) {
+    return "framework";
+  }
   return null;
 }
 function isRealPackageEntryPoint(filePath, packageEntryPoints) {
@@ -9407,6 +10055,50 @@ function isMojoExcluded(attrs) {
   if (name === "main") return true;
   return false;
 }
+function isRubyExcluded(attrs) {
+  const filePath = attrs.file || attrs.filePath || "";
+  const name = attrs.name || "";
+  if (!filePath.endsWith(".rb") && !filePath.endsWith(".rake") && !filePath.endsWith(".gemspec")) return false;
+  const railsCallbacks = [
+    "before_action",
+    "after_action",
+    "around_action",
+    "before_filter",
+    "after_filter",
+    "around_filter"
+  ];
+  if (railsCallbacks.includes(name)) return true;
+  const arCallbacks = [
+    "before_save",
+    "after_save",
+    "before_create",
+    "after_create",
+    "before_update",
+    "after_update",
+    "before_destroy",
+    "after_destroy",
+    "before_validation",
+    "after_validation",
+    "after_commit",
+    "after_rollback",
+    "after_initialize",
+    "after_find"
+  ];
+  if (arCallbacks.includes(name)) return true;
+  if (filePath.endsWith(".rake") || name === "task") return true;
+  if (["it", "describe", "context", "specify", "subject", "let", "let!", "before", "after"].includes(name)) return true;
+  if (name.startsWith("test_")) return true;
+  if (name === "included" || name === "class_methods") return true;
+  if (name === "initialize") return true;
+  if (name === "method_missing" || name === "respond_to_missing?") return true;
+  if (name === "concern" || name === "concerning") return true;
+  const policyMethods = ["index?", "show?", "create?", "new?", "update?", "edit?", "destroy?"];
+  if (policyMethods.includes(name)) return true;
+  const deviseMethods = ["authenticate!", "valid?", "authenticate_user!", "current_user"];
+  if (deviseMethods.includes(name)) return true;
+  if (name === "main") return true;
+  return false;
+}
 
 // src/dead-code/classifier.ts
 import path3 from "path";
@@ -9473,8 +10165,8 @@ function generateReason(symbol, confidence) {
   return "Potentially unused";
 }
 function isBarrelFile(filePath) {
-  const basename13 = path3.basename(filePath);
-  return basename13 === "index.ts" || basename13 === "index.js";
+  const basename14 = path3.basename(filePath);
+  return basename14 === "index.ts" || basename14 === "index.js";
 }
 function isTestFile2(filePath) {
   return filePath.includes("__tests__/") || filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("/test/") || filePath.includes("/tests/");
@@ -9653,11 +10345,11 @@ function filterByConfidence(symbols, minConfidence) {
 }
 
 // src/docs/generator.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync18 } from "fs";
-import { join as join21 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync19 } from "fs";
+import { join as join22 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname16 } from "path";
+import { dirname as dirname17 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -9808,7 +10500,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname16(attrs.filePath);
+    const dir = dirname17(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -9833,7 +10525,7 @@ function getDirectoryStats(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname16(attrs.filePath);
+    const dir = dirname17(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -9848,8 +10540,8 @@ function getDirectoryStats(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname16(sourceAttrs.filePath);
-    const targetDir = dirname16(targetAttrs.filePath);
+    const sourceDir = dirname17(sourceAttrs.filePath);
+    const targetDir = dirname17(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -10056,7 +10748,7 @@ function detectCycles(graph) {
 }
 
 // src/docs/conventions.ts
-import { basename as basename10, extname as extname11 } from "path";
+import { basename as basename11, extname as extname12 } from "path";
 function generateConventions(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -10094,7 +10786,7 @@ function generateFileOrganization(graph) {
   graph.forEachNode((node, attrs) => {
     if (!files.has(attrs.filePath)) {
       files.add(attrs.filePath);
-      const fileName = basename10(attrs.filePath);
+      const fileName = basename11(attrs.filePath);
       if (fileName === "index.ts" || fileName === "index.js" || fileName === "index.tsx" || fileName === "index.jsx") {
         barrelFileCount++;
       }
@@ -10153,7 +10845,7 @@ function generateNamingPatterns(graph) {
   graph.forEachNode((node, attrs) => {
     if (!files.has(attrs.filePath)) {
       files.add(attrs.filePath);
-      const fileName = basename10(attrs.filePath, extname11(attrs.filePath));
+      const fileName = basename11(attrs.filePath, extname12(attrs.filePath));
       if (isCamelCase(fileName)) patterns.files.camelCase++;
       else if (isPascalCase(fileName)) patterns.files.PascalCase++;
       else if (isKebabCase(fileName)) patterns.files.kebabCase++;
@@ -10830,7 +11522,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname17 } from "path";
+import { dirname as dirname18 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -10889,7 +11581,7 @@ function generateQuickOrientation(graph) {
   const primaryLang = Object.entries(languages2).sort((a, b) => b[1] - a[1])[0];
   const dirs = /* @__PURE__ */ new Set();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname17(attrs.filePath);
+    const dir = dirname18(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -10993,7 +11685,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname17(attrs.filePath);
+    const dir = dirname18(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -11008,7 +11700,7 @@ function getDirectoryStats2(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname17(attrs.filePath);
+    const dir = dirname18(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -11023,8 +11715,8 @@ function getDirectoryStats2(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname17(sourceAttrs.filePath);
-    const targetDir = dirname17(targetAttrs.filePath);
+    const sourceDir = dirname18(sourceAttrs.filePath);
+    const targetDir = dirname18(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -11105,7 +11797,7 @@ function detectClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname17(attrs.filePath);
+    const dir = dirname18(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -11159,8 +11851,8 @@ function inferClusterName(files) {
   if (sortedWords.length > 0 && sortedWords[0][1] > 1) {
     return capitalizeFirst2(sortedWords[0][0]);
   }
-  const commonDir = dirname17(files[0]);
-  if (files.every((f) => dirname17(f) === commonDir)) {
+  const commonDir = dirname18(files[0]);
+  if (files.every((f) => dirname18(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -11218,7 +11910,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname18, basename as basename11 } from "path";
+import { dirname as dirname19, basename as basename12 } from "path";
 function generateFiles(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -11322,7 +12014,7 @@ function generateDirectoryBreakdown(graph) {
   const fileStats = getFileStats2(graph);
   const dirMap = /* @__PURE__ */ new Map();
   for (const file of fileStats) {
-    const dir = dirname18(file.filePath);
+    const dir = dirname19(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -11337,7 +12029,7 @@ function generateDirectoryBreakdown(graph) {
     dirStats.symbolCount += file.symbolCount;
     if (file.totalConnections > dirStats.maxConnections) {
       dirStats.maxConnections = file.totalConnections;
-      dirStats.mostConnectedFile = basename11(file.filePath);
+      dirStats.mostConnectedFile = basename12(file.filePath);
     }
   }
   if (dirMap.size === 0) {
@@ -11965,7 +12657,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename12, dirname as dirname19 } from "path";
+import { basename as basename13, dirname as dirname20 } from "path";
 function generateTests(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -11993,8 +12685,8 @@ function getFileCount8(graph) {
   return files.size;
 }
 function isTestFile3(filePath) {
-  const fileName = basename12(filePath).toLowerCase();
-  const dirPath = dirname19(filePath).toLowerCase();
+  const fileName = basename13(filePath).toLowerCase();
+  const dirPath = dirname20(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -12052,13 +12744,13 @@ function generateTestFileInventory(graph) {
   return output;
 }
 function matchTestToSource(testFile) {
-  const testFileName = basename12(testFile);
-  const testDir = dirname19(testFile);
+  const testFileName = basename13(testFile);
+  const testDir = dirname20(testFile);
   let sourceFileName = testFileName.replace(/\.test\./g, ".").replace(/\.spec\./g, ".").replace(/_test\./g, ".").replace(/_spec\./g, ".");
   const possiblePaths = [];
   possiblePaths.push(testDir + "/" + sourceFileName);
   if (testDir.endsWith("/test") || testDir.endsWith("/tests") || testDir.endsWith("/__tests__")) {
-    const parentDir = dirname19(testDir);
+    const parentDir = dirname20(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
@@ -12214,7 +12906,7 @@ function generateTestCoverageMap(graph) {
   const rows = mappings.slice(0, 30).map((m) => [
     `\`${m.sourceFile}\``,
     m.hasTest ? "\u2705" : "\u274C",
-    m.testFile ? `\`${basename12(m.testFile)}\`` : "-",
+    m.testFile ? `\`${basename13(m.testFile)}\`` : "-",
     formatNumber(m.symbolCount)
   ]);
   let output = table(headers, rows);
@@ -12255,7 +12947,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname19(sourceFile).split("/")[0];
+    const dir = dirname20(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -12278,7 +12970,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname20 } from "path";
+import { dirname as dirname21 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -12559,7 +13251,7 @@ function generateFeatureClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname20(attrs.filePath);
+    const dir = dirname21(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -12641,7 +13333,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname21 } from "path";
+import { dirname as dirname22 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -12779,7 +13471,7 @@ function generateCompleteFileIndex(graph) {
   fileInfos.sort((a, b) => a.filePath.localeCompare(b.filePath));
   const dirGroups = /* @__PURE__ */ new Map();
   for (const info of fileInfos) {
-    const dir = dirname21(info.filePath);
+    const dir = dirname22(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -12990,8 +13682,8 @@ function getTopLevelDir2(filePath) {
 }
 
 // src/docs/status.ts
-import { readFileSync as readFileSync16, existsSync as existsSync16 } from "fs";
-import { resolve as resolve13 } from "path";
+import { readFileSync as readFileSync17, existsSync as existsSync17 } from "fs";
+import { resolve as resolve14 } from "path";
 function generateStatus(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -13024,16 +13716,16 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const resolvedRoot = resolve13(projectRoot);
-  const fullPath = resolve13(resolvedRoot, filePath);
+  const resolvedRoot = resolve14(projectRoot);
+  const fullPath = resolve14(resolvedRoot, filePath);
   if (!fullPath.startsWith(resolvedRoot)) {
     return comments;
   }
-  if (!existsSync16(fullPath)) {
+  if (!existsSync17(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync16(fullPath, "utf-8");
+    const content = readFileSync17(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -13612,16 +14304,16 @@ function generateConfidenceSection(title, description, symbols, projectRoot) {
 }
 
 // src/docs/metadata.ts
-import { existsSync as existsSync17, readFileSync as readFileSync17, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync18, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve15 } from "path";
 function loadMetadata(outputDir) {
-  const resolvedDir = resolve14(outputDir);
-  const metadataPath = resolve14(resolvedDir, "metadata.json");
-  if (!metadataPath.startsWith(resolvedDir) || !existsSync17(metadataPath)) {
+  const resolvedDir = resolve15(outputDir);
+  const metadataPath = resolve15(resolvedDir, "metadata.json");
+  if (!metadataPath.startsWith(resolvedDir) || !existsSync18(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync17(metadataPath, "utf-8");
+    const content = readFileSync18(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -13629,8 +14321,8 @@ function loadMetadata(outputDir) {
   }
 }
 function saveMetadata(outputDir, metadata) {
-  const resolvedDir = resolve14(outputDir);
-  const metadataPath = resolve14(resolvedDir, "metadata.json");
+  const resolvedDir = resolve15(outputDir);
+  const metadataPath = resolve15(resolvedDir, "metadata.json");
   if (!metadataPath.startsWith(resolvedDir)) {
     throw new Error(`Path traversal attempt blocked: ${metadataPath}`);
   }
@@ -13676,7 +14368,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync18(options.outputDir)) {
+    if (!existsSync19(options.outputDir)) {
       mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
@@ -13715,7 +14407,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ARCHITECTURE.md...");
           const content = generateArchitecture(graph, projectRoot, version, parseTime);
-          const filePath = join21(options.outputDir, "ARCHITECTURE.md");
+          const filePath = join22(options.outputDir, "ARCHITECTURE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
@@ -13726,7 +14418,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CONVENTIONS.md...");
           const content = generateConventions(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "CONVENTIONS.md");
+          const filePath = join22(options.outputDir, "CONVENTIONS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
@@ -13737,7 +14429,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating DEPENDENCIES.md...");
           const content = generateDependencies(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "DEPENDENCIES.md");
+          const filePath = join22(options.outputDir, "DEPENDENCIES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
@@ -13748,7 +14440,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ONBOARDING.md...");
           const content = generateOnboarding(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "ONBOARDING.md");
+          const filePath = join22(options.outputDir, "ONBOARDING.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
@@ -13759,7 +14451,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating FILES.md...");
           const content = generateFiles(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "FILES.md");
+          const filePath = join22(options.outputDir, "FILES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
@@ -13770,7 +14462,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating API_SURFACE.md...");
           const content = generateApiSurface(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "API_SURFACE.md");
+          const filePath = join22(options.outputDir, "API_SURFACE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("API_SURFACE.md");
         } catch (err) {
@@ -13781,7 +14473,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ERRORS.md...");
           const content = generateErrors(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "ERRORS.md");
+          const filePath = join22(options.outputDir, "ERRORS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
@@ -13792,7 +14484,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating TESTS.md...");
           const content = generateTests(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "TESTS.md");
+          const filePath = join22(options.outputDir, "TESTS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
@@ -13803,7 +14495,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HISTORY.md...");
           const content = generateHistory(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "HISTORY.md");
+          const filePath = join22(options.outputDir, "HISTORY.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
@@ -13814,7 +14506,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CURRENT.md...");
           const content = generateCurrent(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "CURRENT.md");
+          const filePath = join22(options.outputDir, "CURRENT.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
@@ -13825,7 +14517,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating STATUS.md...");
           const content = generateStatus(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "STATUS.md");
+          const filePath = join22(options.outputDir, "STATUS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
@@ -13836,7 +14528,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HEALTH.md...");
           const content = generateHealth(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "HEALTH.md");
+          const filePath = join22(options.outputDir, "HEALTH.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HEALTH.md");
         } catch (err) {
@@ -13847,7 +14539,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating DEAD_CODE.md...");
           const content = generateDeadCode(graph, projectRoot, version);
-          const filePath = join21(options.outputDir, "DEAD_CODE.md");
+          const filePath = join22(options.outputDir, "DEAD_CODE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEAD_CODE.md");
         } catch (err) {
@@ -13891,7 +14583,7 @@ function getFileCount13(graph) {
 }
 
 // src/simulation/engine.ts
-import { dirname as dirname22, join as join22 } from "path";
+import { dirname as dirname23, join as join23 } from "path";
 function normalizePath2(p) {
   return p.replace(/^\.\//, "").replace(/\/+$/, "");
 }
@@ -14023,7 +14715,7 @@ var SimulationEngine = class {
     }
   }
   applyRename(clone, target, newName, brokenImports) {
-    const destination = join22(dirname22(target), newName);
+    const destination = join23(dirname23(target), newName);
     this.applyMove(clone, target, destination, brokenImports);
   }
   applySplit(clone, target, newFile, symbols, brokenImports) {
@@ -14223,13 +14915,13 @@ var SimulationEngine = class {
 };
 
 // src/security/scanner.ts
-import { existsSync as existsSync20 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { join as join33 } from "path";
 
 // src/security/checks/dependencies.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync19, readFileSync as readFileSync18, readdirSync as readdirSync11 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync19, readdirSync as readdirSync12 } from "fs";
+import { join as join24 } from "path";
 function cvssToSeverity(score) {
   if (score >= 9) return "critical";
   if (score >= 7) return "high";
@@ -14239,18 +14931,18 @@ function cvssToSeverity(score) {
 async function checkDependencies(_files, projectRoot) {
   const findings = [];
   try {
-    if (existsSync19(join23(projectRoot, "package.json"))) {
+    if (existsSync20(join24(projectRoot, "package.json"))) {
       findings.push(...checkNpmAudit(projectRoot));
       findings.push(...checkPackageJsonPatterns(projectRoot));
       findings.push(...checkPostinstallScripts(projectRoot));
     }
-    if (existsSync19(join23(projectRoot, "requirements.txt")) || existsSync19(join23(projectRoot, "pyproject.toml"))) {
+    if (existsSync20(join24(projectRoot, "requirements.txt")) || existsSync20(join24(projectRoot, "pyproject.toml"))) {
       findings.push(...checkPipAudit(projectRoot));
     }
-    if (existsSync19(join23(projectRoot, "Cargo.toml"))) {
+    if (existsSync20(join24(projectRoot, "Cargo.toml"))) {
       findings.push(...checkCargoAudit(projectRoot));
     }
-    if (existsSync19(join23(projectRoot, "go.mod"))) {
+    if (existsSync20(join24(projectRoot, "go.mod"))) {
       findings.push(...checkGoVerify(projectRoot));
     }
   } catch (err) {
@@ -14339,8 +15031,8 @@ function checkNpmAudit(projectRoot) {
 function checkPackageJsonPatterns(projectRoot) {
   const findings = [];
   try {
-    const pkgPath = join23(projectRoot, "package.json");
-    const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+    const pkgPath = join24(projectRoot, "package.json");
+    const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     for (const [name, version] of Object.entries(allDeps)) {
       if (version.startsWith("^") || version.startsWith("~")) {
@@ -14362,15 +15054,15 @@ function checkPackageJsonPatterns(projectRoot) {
 }
 function checkPostinstallScripts(projectRoot) {
   const findings = [];
-  const nodeModules = join23(projectRoot, "node_modules");
-  if (!existsSync19(nodeModules)) return findings;
+  const nodeModules = join24(projectRoot, "node_modules");
+  if (!existsSync20(nodeModules)) return findings;
   try {
-    const topLevelDeps = readdirSync11(nodeModules).filter((d) => !d.startsWith("."));
+    const topLevelDeps = readdirSync12(nodeModules).filter((d) => !d.startsWith("."));
     for (const dep of topLevelDeps) {
-      const depPkgPath = join23(nodeModules, dep, "package.json");
-      if (!existsSync19(depPkgPath)) continue;
+      const depPkgPath = join24(nodeModules, dep, "package.json");
+      if (!existsSync20(depPkgPath)) continue;
       try {
-        const depPkg = JSON.parse(readFileSync18(depPkgPath, "utf-8"));
+        const depPkg = JSON.parse(readFileSync19(depPkgPath, "utf-8"));
         const scripts = depPkg.scripts || {};
         if (scripts.postinstall || scripts.preinstall || scripts.install) {
           const scriptName = scripts.postinstall ? "postinstall" : scripts.preinstall ? "preinstall" : "install";
@@ -14408,7 +15100,7 @@ function checkPipAudit(projectRoot) {
         id: "",
         severity: cvssToSeverity(vuln.cvss?.score || 5),
         vulnerabilityClass: "dependency-cve",
-        file: existsSync19(join23(projectRoot, "requirements.txt")) ? "requirements.txt" : "pyproject.toml",
+        file: existsSync20(join24(projectRoot, "requirements.txt")) ? "requirements.txt" : "pyproject.toml",
         title: `Vulnerable Python dependency: ${vuln.name}`,
         description: `${vuln.name}@${vuln.version} \u2014 ${vuln.id}: ${vuln.description || "Known vulnerability"}`,
         attackScenario: `An attacker could exploit the vulnerability in ${vuln.name}.`,
@@ -14505,8 +15197,8 @@ function checkGoVerify(projectRoot) {
 }
 
 // src/security/checks/injection.ts
-import { readFileSync as readFileSync19 } from "fs";
-import { join as join24 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import { join as join25 } from "path";
 var SKIP_DIRS = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 var TEST_PATTERNS = ["test", "spec", "fixture", "mock", "__tests__", "__mocks__"];
 var USER_INPUT_NAMES = /(?:input|user|name|path|query|branch|hash|cmd|command|req\.|params|body|args|url|dir|file|subdirectory)/i;
@@ -14876,6 +15568,106 @@ var PATTERNS = [
     description: "SIMD store/load operations without explicit bounds checking \u2014 buffer overflow risk.",
     attackScenario: "An attacker could trigger out-of-bounds SIMD operations to corrupt memory.",
     suggestedFix: "Validate buffer size against SIMD width before store/load operations."
+  },
+  // Ruby injection patterns
+  {
+    regex: /(?:where|find_by_sql|execute)\s*\(\s*["'][^"']*#\{/,
+    title: "Ruby string interpolation in database query method",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "Database query built with string interpolation \u2014 values are not parameterized.",
+    attackScenario: "An attacker could manipulate interpolated values to alter query logic.",
+    suggestedFix: 'Use parameterized queries: Model.where("column = ?", value) or ActiveRecord query interface.'
+  },
+  {
+    regex: /`[^`]*#\{/,
+    title: "Ruby backtick command with string interpolation",
+    vulnClass: "shell-injection",
+    baseSeverity: "high",
+    description: "Backtick command execution with interpolated values \u2014 potential for unintended command execution.",
+    attackScenario: "An attacker could inject shell metacharacters through the interpolated variable.",
+    suggestedFix: "Use Open3.capture3 with separate arguments instead of backtick interpolation."
+  },
+  {
+    regex: /\b(?:system|exec)\s*\(\s*["'][^"']*#\{/,
+    title: "Ruby system/exec with string interpolation",
+    vulnClass: "shell-injection",
+    baseSeverity: "high",
+    description: "system() or exec() called with interpolated string \u2014 potential for unintended command execution.",
+    attackScenario: "An attacker could inject shell metacharacters through the interpolated variable.",
+    suggestedFix: 'Use system() with separate arguments: system("cmd", arg1, arg2) instead of string interpolation.'
+  },
+  {
+    regex: /%x\{[^}]*#\{/,
+    title: "Ruby %x{} command with string interpolation",
+    vulnClass: "shell-injection",
+    baseSeverity: "high",
+    description: "%x{} command execution with interpolated values \u2014 potential for unintended command execution.",
+    attackScenario: "An attacker could inject shell metacharacters through the interpolated variable.",
+    suggestedFix: "Use Open3.capture3 with separate arguments instead of %x{} interpolation."
+  },
+  {
+    regex: /\beval\s*\(\s*(?!['"])/,
+    title: "Ruby eval() with dynamic input",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "eval() executes arbitrary Ruby code from a variable \u2014 potential for unintended code execution.",
+    attackScenario: "An attacker could inject malicious code if user input reaches eval().",
+    suggestedFix: "Remove eval() and use safe alternatives (JSON.parse for data, specific parsers for expressions)."
+  },
+  {
+    regex: /\b(?:instance_eval|class_eval)\s*\(\s*(?!['"])/,
+    title: "Ruby instance_eval/class_eval with dynamic input",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "instance_eval/class_eval executes code in object context \u2014 dangerous with dynamic input.",
+    attackScenario: "An attacker could inject code that executes with elevated privileges in the object context.",
+    suggestedFix: "Use instance_exec with a block instead of string evaluation."
+  },
+  {
+    regex: /\b(?:send|public_send)\s*\(\s*(?:params|request|input|user)/i,
+    title: "Ruby send/public_send with user-controlled method name",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "send() called with user-controlled method name \u2014 could invoke unintended methods.",
+    attackScenario: "An attacker could call arbitrary methods on the receiver by controlling the method name.",
+    suggestedFix: "Validate the method name against a strict allowlist before passing to send()."
+  },
+  {
+    regex: /File\.(?:read|write|delete|open)\s*\(\s*(?:params|request|input|user)/i,
+    title: "Ruby file operation with user-controlled path",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "File operation with user-controlled path \u2014 potential for unintended file access.",
+    attackScenario: "An attacker could traverse directories to access or modify arbitrary files.",
+    suggestedFix: "Validate and sanitize file paths. Use File.expand_path and check against an allowed directory."
+  },
+  {
+    regex: /YAML\.load\s*\(\s*(?!.*safe)/i,
+    title: "Ruby YAML.load with potentially unsafe input",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "YAML.load can instantiate arbitrary Ruby objects \u2014 potential for unintended code execution.",
+    attackScenario: "An attacker could craft a YAML payload that instantiates dangerous objects during deserialization.",
+    suggestedFix: "Use YAML.safe_load instead of YAML.load to restrict allowed classes."
+  },
+  {
+    regex: /Marshal\.load\s*\(/,
+    title: "Ruby Marshal.load with potentially unsafe data",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "Marshal.load deserializes arbitrary Ruby objects \u2014 potential for unintended code execution.",
+    attackScenario: "An attacker could craft a marshaled payload that executes code during deserialization.",
+    suggestedFix: "Use JSON.parse or MessagePack for data exchange. Never Marshal.load untrusted data."
+  },
+  {
+    regex: /ERB\.new\s*\(\s*(?:params|request|input|user)/i,
+    title: "Ruby ERB template with user-controlled input",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "ERB template created from user input \u2014 potential for unintended code execution via template injection.",
+    attackScenario: "An attacker could inject ERB tags to execute arbitrary Ruby code on the server.",
+    suggestedFix: "Never pass user input directly to ERB.new. Use parameterized templates with safe escaping."
   }
 ];
 function shouldSkip(filePath) {
@@ -14892,7 +15684,7 @@ async function checkInjection(files, projectRoot) {
       if (shouldSkip(file.filePath) || isTestFile4(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync19(join24(projectRoot, file.filePath), "utf-8");
+        content = readFileSync20(join25(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -14930,8 +15722,8 @@ async function checkInjection(files, projectRoot) {
 }
 
 // src/security/checks/secrets.ts
-import { readFileSync as readFileSync20 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync21 } from "fs";
+import { join as join26 } from "path";
 var SKIP_DIRS2 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 var TEST_PATTERNS2 = ["test", "spec", "fixture", "mock", "__tests__", "__mocks__", ".example", ".sample"];
 var SECRET_PATTERNS = [
@@ -14964,7 +15756,7 @@ async function checkSecrets(files, projectRoot) {
       if (shouldSkip2(file.filePath) || isTestFile5(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync20(join25(projectRoot, file.filePath), "utf-8");
+        content = readFileSync21(join26(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -14997,8 +15789,8 @@ async function checkSecrets(files, projectRoot) {
 }
 
 // src/security/checks/path-traversal.ts
-import { readFileSync as readFileSync21 } from "fs";
-import { join as join26 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join27 } from "path";
 var SKIP_DIRS3 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 var USER_INPUT_VARS = /(?:req\.|params|query|body|input|path|dir|subdirectory|file|userInput|fileName|filePath)/i;
 var PATTERNS2 = [
@@ -15045,7 +15837,7 @@ async function checkPathTraversal(files, projectRoot) {
       if (shouldSkip3(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync21(join26(projectRoot, file.filePath), "utf-8");
+        content = readFileSync22(join27(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -15087,8 +15879,8 @@ async function checkPathTraversal(files, projectRoot) {
 }
 
 // src/security/checks/auth.ts
-import { readFileSync as readFileSync22 } from "fs";
-import { join as join27 } from "path";
+import { readFileSync as readFileSync23 } from "fs";
+import { join as join28 } from "path";
 var SKIP_DIRS4 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip4(filePath) {
   return SKIP_DIRS4.some((d) => filePath.includes(d));
@@ -15104,7 +15896,7 @@ async function checkAuth(files, projectRoot) {
       if (shouldSkip4(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync22(join27(projectRoot, file.filePath), "utf-8");
+        content = readFileSync23(join28(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -15195,8 +15987,8 @@ async function checkAuth(files, projectRoot) {
 }
 
 // src/security/checks/input-validation.ts
-import { readFileSync as readFileSync23 } from "fs";
-import { join as join28 } from "path";
+import { readFileSync as readFileSync24 } from "fs";
+import { join as join29 } from "path";
 var SKIP_DIRS5 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip5(filePath) {
   return SKIP_DIRS5.some((d) => filePath.includes(d));
@@ -15208,7 +16000,7 @@ async function checkInputValidation(files, projectRoot) {
       if (shouldSkip5(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync23(join28(projectRoot, file.filePath), "utf-8");
+        content = readFileSync24(join29(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -15285,8 +16077,8 @@ async function checkInputValidation(files, projectRoot) {
 }
 
 // src/security/checks/information-disclosure.ts
-import { readFileSync as readFileSync24 } from "fs";
-import { join as join29 } from "path";
+import { readFileSync as readFileSync25 } from "fs";
+import { join as join30 } from "path";
 var SKIP_DIRS6 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip6(filePath) {
   return SKIP_DIRS6.some((d) => filePath.includes(d));
@@ -15298,7 +16090,7 @@ async function checkInformationDisclosure(files, projectRoot) {
       if (shouldSkip6(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync24(join29(projectRoot, file.filePath), "utf-8");
+        content = readFileSync25(join30(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -15368,8 +16160,8 @@ async function checkInformationDisclosure(files, projectRoot) {
 }
 
 // src/security/checks/cryptography.ts
-import { readFileSync as readFileSync25 } from "fs";
-import { join as join30 } from "path";
+import { readFileSync as readFileSync26 } from "fs";
+import { join as join31 } from "path";
 var SKIP_DIRS7 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 var USER_INPUT_NAMES2 = /(?:input|user|name|path|query|param|request|body|args|url)/i;
 function shouldSkip7(filePath) {
@@ -15386,7 +16178,7 @@ async function checkCryptography(files, projectRoot) {
       if (shouldSkip7(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync25(join30(projectRoot, file.filePath), "utf-8");
+        content = readFileSync26(join31(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -15763,6 +16555,86 @@ async function checkCryptography(files, projectRoot) {
             });
           }
         }
+        if (/Digest::MD5/.test(line)) {
+          findings.push({
+            id: "",
+            severity: isCryptoFile ? "high" : "medium",
+            vulnerabilityClass: "cryptography",
+            file: file.filePath,
+            line: i + 1,
+            title: "Weak hash algorithm: MD5 in Ruby",
+            description: "MD5 is cryptographically broken \u2014 collisions can be generated in seconds.",
+            attackScenario: "An attacker could generate MD5 collisions to bypass integrity checks or forge hashes.",
+            suggestedFix: "Use Digest::SHA256 or bcrypt for password hashing."
+          });
+        }
+        if (/Digest::SHA1/.test(line)) {
+          findings.push({
+            id: "",
+            severity: isCryptoFile ? "high" : "medium",
+            vulnerabilityClass: "cryptography",
+            file: file.filePath,
+            line: i + 1,
+            title: "Weak hash algorithm: SHA-1 in Ruby",
+            description: "SHA-1 has known collision attacks \u2014 should not be used for security purposes.",
+            attackScenario: "An attacker could generate SHA-1 collisions to bypass integrity checks.",
+            suggestedFix: "Use Digest::SHA256 or stronger for integrity checks."
+          });
+        }
+        if (/\brand\s*\(/.test(line) && isCryptoFile) {
+          findings.push({
+            id: "",
+            severity: "medium",
+            vulnerabilityClass: "cryptography",
+            file: file.filePath,
+            line: i + 1,
+            title: "Weak random: rand() in Ruby security context",
+            description: "rand() is not cryptographically secure \u2014 its output can be predicted.",
+            attackScenario: "An attacker could predict rand() values to forge tokens or bypass security checks.",
+            suggestedFix: "Use SecureRandom.hex, SecureRandom.uuid, or SecureRandom.random_bytes for cryptographic purposes."
+          });
+        }
+        if (/(?:password|secret|api_key|token)\s*=\s*['"][^'"]{4,}['"]/i.test(line)) {
+          if (file.filePath.endsWith(".rb")) {
+            findings.push({
+              id: "",
+              severity: "high",
+              vulnerabilityClass: "cryptography",
+              file: file.filePath,
+              line: i + 1,
+              title: "Hardcoded credentials in Ruby source",
+              description: "A password, secret, or API key is hardcoded as a string literal.",
+              attackScenario: "An attacker with access to the source could extract the credential.",
+              suggestedFix: 'Load credentials from environment variables using ENV["KEY"] or Rails credentials.'
+            });
+          }
+        }
+        if (/verify_mode\s*=\s*OpenSSL::SSL::VERIFY_NONE/.test(line)) {
+          findings.push({
+            id: "",
+            severity: "high",
+            vulnerabilityClass: "cryptography",
+            file: file.filePath,
+            line: i + 1,
+            title: "Ruby SSL verification disabled",
+            description: "SSL certificate verification is disabled \u2014 connections are not authenticated.",
+            attackScenario: "An attacker on the network could intercept and modify traffic without detection.",
+            suggestedFix: "Use OpenSSL::SSL::VERIFY_PEER to verify server certificates."
+          });
+        }
+        if (/OpenSSL::Cipher\s*\.\s*new\s*\(\s*['"](?:DES|RC4)/i.test(line)) {
+          findings.push({
+            id: "",
+            severity: "high",
+            vulnerabilityClass: "cryptography",
+            file: file.filePath,
+            line: i + 1,
+            title: "Weak cipher algorithm in Ruby",
+            description: "DES/RC4 ciphers are cryptographically weak and can be broken with modern hardware.",
+            attackScenario: "An attacker could brute-force or exploit weaknesses in DES/RC4 to decrypt data.",
+            suggestedFix: 'Use OpenSSL::Cipher.new("aes-256-gcm") for authenticated encryption.'
+          });
+        }
       }
     }
   } catch {
@@ -15771,8 +16643,8 @@ async function checkCryptography(files, projectRoot) {
 }
 
 // src/security/checks/frontend.ts
-import { readFileSync as readFileSync26 } from "fs";
-import { join as join31 } from "path";
+import { readFileSync as readFileSync27 } from "fs";
+import { join as join32 } from "path";
 var SKIP_DIRS8 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip8(filePath) {
   return SKIP_DIRS8.some((d) => filePath.includes(d));
@@ -15788,7 +16660,7 @@ async function checkFrontend(files, projectRoot) {
       if (!isFrontendFile(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync26(join31(projectRoot, file.filePath), "utf-8");
+        content = readFileSync27(join32(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -16248,13 +17120,13 @@ async function scanSecurity(projectRoot, graph, options = {}) {
   };
 }
 function detectPackageManager(projectRoot) {
-  if (existsSync20(join32(projectRoot, "package.json"))) return "npm";
-  if (existsSync20(join32(projectRoot, "requirements.txt"))) return "pip";
-  if (existsSync20(join32(projectRoot, "pyproject.toml"))) return "pip";
-  if (existsSync20(join32(projectRoot, "Cargo.toml"))) return "cargo";
-  if (existsSync20(join32(projectRoot, "go.mod"))) return "go";
-  if (existsSync20(join32(projectRoot, "pom.xml"))) return "maven";
-  if (existsSync20(join32(projectRoot, "build.gradle")) || existsSync20(join32(projectRoot, "build.gradle.kts"))) return "gradle";
+  if (existsSync21(join33(projectRoot, "package.json"))) return "npm";
+  if (existsSync21(join33(projectRoot, "requirements.txt"))) return "pip";
+  if (existsSync21(join33(projectRoot, "pyproject.toml"))) return "pip";
+  if (existsSync21(join33(projectRoot, "Cargo.toml"))) return "cargo";
+  if (existsSync21(join33(projectRoot, "go.mod"))) return "go";
+  if (existsSync21(join33(projectRoot, "pom.xml"))) return "maven";
+  if (existsSync21(join33(projectRoot, "build.gradle")) || existsSync21(join33(projectRoot, "build.gradle.kts"))) return "gradle";
   return "unknown";
 }