Merge pull request #15 from Eilodon/claude/ci-feature-feasibility-kcr1ox

Claude/ci feature feasibility kcr1ox

Author: Eilodon

Cargo.lock

@@ -37,6 +37,9 @@ tree-sitter-bash = "0.25"
 stack-graphs = "0.14"
 tree-sitter-stack-graphs = "0.10"
 tree-sitter-stack-graphs-python = "0.3"
+# =0.23.2 pin (tree-sitter-typescript) comes from this crate's own Cargo.toml —
+# already the exact version tree-sitter-typescript resolves to workspace-wide.
+tree-sitter-stack-graphs-typescript = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 toml = "0.8"

Cargo.toml

@@ -87,7 +87,8 @@ agent: "tôi cần sửa hàm getUserByEmail"
   xuất symbol bằng line-scan regex; không có call-graph hay import resolution — built-in, không cần
   feature flag.
 - **Call graph có độ tin cậy** — mỗi edge được gắn nhãn `resolved` / `inferred` / `formal` /
-  `textual` tuỳ vào mức độ chắc chắn khi resolve. `formal` (Tier-3, StackGraph) hiện hỗ trợ Python.
+  `textual` tuỳ vào mức độ chắc chắn khi resolve. `formal` (Tier-3, StackGraph) hiện hỗ trợ Python
+  và TypeScript/TSX.
 - **Import graph** — file-level dependency graph cho tool `dependencies`.
 - **Graph metrics** — `coreness` (k-core) và `is_hub` để nhận diện symbol trung tâm trước khi sửa.
   `repo_overview.core_symbols` dùng lại chính `coreness` này để vẽ "khung xương kiến trúc" ngay từ

README.md

@@ -25,6 +25,7 @@ tree-sitter-go = { workspace = true }
 stack-graphs = { workspace = true }
 tree-sitter-stack-graphs = { workspace = true }
 tree-sitter-stack-graphs-python = { workspace = true }
+tree-sitter-stack-graphs-typescript = { workspace = true }
 model2vec-rs = { version = "0.2.1", optional = true }
 tree-sitter-c       = { workspace = true, optional = true }
 tree-sitter-cpp     = { workspace = true, optional = true }

crates/ci-core/Cargo.toml

@@ -27,7 +27,13 @@ fn import_node_types(language: &str) -> &'static [&'static str] {
         "python" => &["import_statement", "import_from_statement"],
         "rust" => &["use_declaration"],
         "go" => &["import_spec"],
-        "javascript" | "typescript" => &["import_statement"],
+        // `variable_declarator` also catches CommonJS `require()` — see
+        // `parse_js_require`. It's the same node kind `assignment_nodes()`
+        // (resolver/lang_constants.rs) already walks for alias tracking; the
+        // two extractions look for different shapes in the same nodes and
+        // don't conflict (alias tracking wants a bare-identifier RHS,
+        // `parse_js_require` wants a `require(...)` call RHS).
+        "javascript" | "typescript" => &["import_statement", "variable_declarator"],
         "java" => &["import_declaration"],
         _ => &[],
     }
@@ -199,6 +205,10 @@ fn parse_go_import(text: &str) -> Option<ParsedImport> {
 }
 
 fn parse_js_import(text: &str) -> Option<ParsedImport> {
+    parse_js_esm_import(text).or_else(|| parse_js_require(text))
+}
+
+fn parse_js_esm_import(text: &str) -> Option<ParsedImport> {
     // import { a, b as c } from 'mod';  import x from 'mod';  import * as ns from 'mod';
     let (clause, module) = text.split_once(" from ")?;
     let module = module
@@ -227,6 +237,47 @@ fn parse_js_import(text: &str) -> Option<ParsedImport> {
     })
 }
 
+/// CommonJS `require()`, still common in real Node.js code (older packages,
+/// TypeScript compiled to CommonJS) but structurally a call expression, not
+/// an `import_statement` — this is fed `variable_declarator` text instead
+/// (`NAME = require(...)` or `{ a, b as c } = require(...)`, no trailing
+/// `;`, no `const`/`let`/`var` keyword — that's the parent node).
+///
+/// Only a literal string argument resolves to a module — `require(path)`
+/// with a computed argument can't be statically attributed, so it's left
+/// unresolved (`None`) rather than guessed at.
+fn parse_js_require(text: &str) -> Option<ParsedImport> {
+    let (lhs, rhs) = text.split_once('=')?;
+    let after_require = rhs.trim().strip_prefix("require(")?.trim_start();
+    let quote = after_require.chars().next()?;
+    if quote != '"' && quote != '\'' {
+        return None;
+    }
+    let rest = &after_require[quote.len_utf8()..];
+    let end = rest.find(quote)?;
+    let module = rest[..end].to_string();
+    if module.is_empty() {
+        return None;
+    }
+
+    let lhs = lhs.trim();
+    let mut names = Vec::new();
+    if let Some(start) = lhs.find('{')
+        && let Some(end) = lhs.find('}')
+    {
+        for seg in lhs[start + 1..end].split(',') {
+            names.extend(bound_name(seg));
+        }
+    } else {
+        names.extend(ident(lhs));
+    }
+
+    Some(ParsedImport {
+        module_name: module,
+        imported_names: names,
+    })
+}
+
 fn parse_java_import(text: &str) -> Option<ParsedImport> {
     // import a.b.C;  import static a.b.C.m;  import a.b.*;
     let rest = text
@@ -299,6 +350,43 @@ mod tests {
         assert_eq!(i.imported_names, vec!["a", "c"]);
     }
 
+    #[test]
+    fn js_require_default() {
+        let i = one("const foo = require('./foo');\n", "javascript");
+        assert_eq!(i.module_name, "./foo");
+        assert_eq!(i.imported_names, vec!["foo"]);
+    }
+
+    #[test]
+    fn ts_require_double_quoted() {
+        let i = one("const foo = require(\"./foo\");\n", "typescript");
+        assert_eq!(i.module_name, "./foo");
+        assert_eq!(i.imported_names, vec!["foo"]);
+    }
+
+    #[test]
+    fn js_require_destructure() {
+        let i = one("const { a, b: c } = require('./mod');\n", "javascript");
+        assert_eq!(i.module_name, "./mod");
+        assert_eq!(i.imported_names, vec!["a", "c"]);
+    }
+
+    /// A computed argument can't be statically attributed to a module —
+    /// must not guess (see `parse_js_require`'s literal-only contract).
+    #[test]
+    fn js_require_with_computed_path_yields_no_import() {
+        let v = extract_imports("const x = require(somePath);\n", "javascript");
+        assert!(v.is_empty(), "expected no import, got {v:?}");
+    }
+
+    /// A plain (non-`require`) assignment must not be mistaken for an
+    /// import now that `variable_declarator` is walked for JS/TS.
+    #[test]
+    fn js_plain_assignment_yields_no_import() {
+        let v = extract_imports("const x = 5;\n", "javascript");
+        assert!(v.is_empty(), "expected no import, got {v:?}");
+    }
+
     #[test]
     fn java_import() {
         let i = one("import a.b.C;\n", "java");

crates/ci-core/src/indexer/imports.rs

@@ -658,6 +658,7 @@ pub fn run_indexing_pipeline(
     // ConservativeResolver only.
     let mut formal = crate::resolver::formal::FormalResolver::new();
     let _ = formal.load_python(); // non-fatal: falls back silently on error
+    let _ = formal.load_typescript(); // non-fatal: falls back silently on error
 
     let mut files = Vec::new();
     collect_source_files(project_root, &ignore_patterns, &mut files);
@@ -729,6 +730,7 @@ pub fn reindex_changed(
 
     let mut formal = crate::resolver::formal::FormalResolver::new();
     let _ = formal.load_python();
+    let _ = formal.load_typescript();
 
     let existing: HashMap<String, String> = {
         let mut stmt = conn.prepare("SELECT path, hash FROM file_index")?;
@@ -1117,6 +1119,58 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    /// CommonJS `require()` (real Node.js code, not just ES `import`) must
+    /// feed `import_map`/`import_edges` exactly like `import ... from ...`
+    /// does — see `indexer::imports::parse_js_require`.
+    #[test]
+    fn test_commonjs_require_cross_file_resolved_confidence() {
+        let dir = std::env::temp_dir().join(format!("ci_idx_require_{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(
+            dir.join("helper.js"),
+            "function helper() {}\nmodule.exports = { helper };\n",
+        )
+        .unwrap();
+        std::fs::write(
+            dir.join("main.js"),
+            "const { helper } = require('./helper');\n\nfunction run() {\n    helper();\n}\n",
+        )
+        .unwrap();
+
+        let mut conn = Connection::open_in_memory().unwrap();
+        init_db(&conn).unwrap();
+        run_indexing_pipeline(&mut conn, &dir, dummy_phase()).unwrap();
+
+        let (to_path, module): (String, String) = conn
+            .query_row(
+                "SELECT COALESCE(to_path,''), module_name FROM import_edges WHERE from_path = 'main.js'",
+                [],
+                |r| Ok((r.get(0)?, r.get(1)?)),
+            )
+            .unwrap();
+        assert_eq!(module, "./helper");
+        assert_eq!(
+            to_path, "helper.js",
+            "require() target resolved to in-project file"
+        );
+
+        let confidence: String = conn
+            .query_row(
+                "SELECT edge_confidence FROM call_edges \
+                 WHERE from_symbol = 'main.js::run' AND to_symbol = 'helper.js::helper'",
+                [],
+                |r| r.get(0),
+            )
+            .unwrap();
+        assert_eq!(
+            confidence, "resolved",
+            "call through require() should be resolved, not textual"
+        );
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     /// Regression: `Type::method()` (a scoped-path call, no `.` receiver) must
     /// resolve *only* against `Type`, not fan out to every same-named symbol
     /// project-wide. Two structs (`StructA`, `StructB`) each define `fn new()`;