fix: resolve merge conflicts with main (docs check acknowledged)

Impact: 1 functions changed, 2 affected

Author: carlos-alm

.claude/hooks/track-edits.sh

@@ -23,6 +23,17 @@ if [ -z "$FILE_PATH" ]; then
   exit 0
 fi
 
+# Normalize Windows-style separators before any dirname/git splitting below —
+# dirname (GNU coreutils) only splits on '/', so a backslash-delimited path
+# would make it silently no-op and return ".". Only touch paths that
+# unambiguously look like a Windows absolute path (drive letter prefix), so a
+# POSIX path containing a literal backslash in a filename is left untouched.
+# Uses grep/tr rather than a bash case pattern/parameter expansion so the
+# match is byte-based, not affected by the shell's active locale.
+if printf '%s' "$FILE_PATH" | grep -qE '^[A-Za-z]:[\\/]'; then
+  FILE_PATH=$(printf '%s' "$FILE_PATH" | tr '\\' '/')
+fi
+
 # Resolve the git worktree that actually owns the edited file, rather than
 # the hook process's own ambient cwd. Edit/Write tool calls carry only an
 # absolute file_path with no associated "current directory" state, so the
@@ -32,9 +43,9 @@ fi
 #
 # Walk up to the nearest existing ancestor directory first: Write can target
 # a not-yet-created nested directory, and `git -C` requires an existing path.
-SEARCH_DIR=$(dirname -- "$FILE_PATH")
+SEARCH_DIR=$(dirname "$FILE_PATH")
 while [ ! -d "$SEARCH_DIR" ] && [ "$SEARCH_DIR" != "/" ] && [ -n "$SEARCH_DIR" ]; do
-  SEARCH_DIR=$(dirname -- "$SEARCH_DIR")
+  SEARCH_DIR=$(dirname "$SEARCH_DIR")
 done
 
 PROJECT_DIR=""
@@ -46,11 +57,39 @@ if [ -z "$PROJECT_DIR" ]; then
 fi
 LOG_FILE="$PROJECT_DIR/.claude/session-edits.log"
 
-# Normalize to relative path with forward slashes
+# Normalize to relative path with forward slashes. Canonicalize both sides
+# via realpath first (walking up to the nearest existing ancestor, since
+# Write can target a not-yet-created nested path) — on Windows the same
+# directory can be reported as either its long form or its auto-generated
+# 8.3 short-name alias (e.g. "runneradmin" vs "RUNNER~1") depending on which
+# API produced it, and a naive string-based path.relative() treats those as
+# unrelated trees, producing a long chain of spurious '../' segments.
 REL_PATH=$(node -e "
+  const fs = require('fs');
   const path = require('path');
-  const abs = path.resolve(process.argv[1]);
-  const base = path.resolve(process.argv[2]);
+
+  function realpathWalkUp(p) {
+    let dir = path.resolve(p);
+    let tail = '';
+    while (true) {
+      try {
+        // .native calls the OS's own canonicalization (GetFinalPathNameByHandleW
+        // on Windows), which resolves 8.3 short-name aliases; the plain JS
+        // fallback only walks symlinks component-by-component and would leave
+        // a short-name alias like "RUNNER~1" untouched.
+        const real = fs.realpathSync.native(dir);
+        return tail ? path.join(real, tail) : real;
+      } catch {
+        const parent = path.dirname(dir);
+        if (parent === dir) return path.resolve(p);
+        tail = tail ? path.join(path.basename(dir), tail) : path.basename(dir);
+        dir = parent;
+      }
+    }
+  }
+
+  const abs = realpathWalkUp(process.argv[1]);
+  const base = realpathWalkUp(process.argv[2]);
   const rel = path.relative(base, abs).split(path.sep).join('/');
   process.stdout.write(rel);
 " "$FILE_PATH" "$PROJECT_DIR" 2>/dev/null) || true

.claude/skills/titan-grind/SKILL.md

@@ -109,7 +109,7 @@ Forge shapes the metal. Grind smooths the rough edges. Your goal: find helpers t
 
 12. **Capture dead-symbol baseline** (only if `grind.deadSymbolBaseline` is null):
     ```bash
-    codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{const data=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:data.count,byRole:data.summary}));})"
+    codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{try{const data=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:data.count??0,byRole:data.summary??{}}));}catch(e){console.error('Failed to parse roles --json output: '+e.message);process.exit(1);}})"
     ```
     `codegraph roles --json` returns `{ count, summary, symbols }` (not a bare array) — `summary` is already the per-role breakdown (e.g. `dead-leaf`, `dead-entry`, `dead-ffi`, `dead-unresolved`), so no manual reduce is needed.
     Store the total in `grind.deadSymbolBaseline`. Write `titan-state.json` immediately.
@@ -580,7 +580,7 @@ After all targets in the phase are processed:
 
 ```bash
 codegraph build
-codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{const data=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:data.count,byRole:data.summary}));})"
+codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{try{const data=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:data.count??0,byRole:data.summary??{}}));}catch(e){console.error('Failed to parse roles --json output: '+e.message);process.exit(1);}})"
 ```
 
 Store in `grind.deadSymbolCurrent`. Write `titan-state.json`.

CONTRIBUTING.md

@@ -58,7 +58,7 @@ installs two git hooks:
 
 ## Project Structure
 
-Source is TypeScript under `src/`, compiled via `tsup`/`tsc`; the native engine
+Source is TypeScript under `src/`, compiled via `tsc`; the native engine
 lives in `crates/codegraph-core/` (Rust, via napi-rs) and mirrors the `src/`
 tree module-for-module. `src/` is organized by layer, not by language:
 
@@ -327,9 +327,10 @@ configuration system, credential resolution, MCP isolation model) see
 
 ## WASM Grammars
 
-`.wasm` grammar files are **not** committed to git — they're built from
+Most `.wasm` grammar files are **not** committed to git — they're built from
 `devDependencies` into `grammars/` automatically via the `prepare` npm script
-(`npm run build:wasm`), which runs on every `npm install`. Each git worktree
+(`npm run build:wasm`), which runs on every `npm install`; pinned exceptions
+such as `grammars/tree-sitter-erlang.wasm` remain tracked. Each git worktree
 therefore needs its own `npm install` before its `grammars/` directory is
 populated (see "Working in multiple git worktrees?" above; `npm run doctor`
 detects a missing or incomplete `grammars/`).

crates/codegraph-core/src/ast_analysis/complexity.rs

@@ -1748,6 +1748,22 @@ mod tests {
         assert_eq!(m.cyclomatic, 3);
     }
 
+    #[test]
+    fn lua_method_declaration() {
+        // Greptile follow-up to #1782: colon-syntax method declarations
+        // (`function Obj:method(x)`) have a `method_index_expression` name
+        // field but are still `function_declaration` nodes, so `function_nodes`
+        // already covers them — this pins that native/TS parity explicitly.
+        // Mirrors the TS test 'method declaration (colon syntax) is
+        // recognized as a function'.
+        let m = compute_lua(
+            "local Obj = {}\nfunction Obj:method(x)\n  if x > 0 then\n    return x\n  end\nend",
+        );
+        assert_eq!(m.cognitive, 1);
+        assert_eq!(m.cyclomatic, 2);
+        assert_eq!(m.max_nesting, 1);
+    }
+
     #[test]
     fn lua_nested_if() {
         let m = compute_lua(

crates/codegraph-core/src/db/connection.rs

@@ -895,10 +895,13 @@ impl NativeDatabase {
         let insert_ok = insert_nodes::do_insert_nodes(conn, &batches, &removed_files)
             .inspect_err(|e| eprintln!("[NativeDatabase] bulk_insert_nodes failed: {e}"))
             .is_ok();
+        if !insert_ok {
+            return Ok(false);
+        }
         let hashes_ok = insert_nodes::commit_file_hashes(conn, &file_hashes)
             .inspect_err(|e| eprintln!("[NativeDatabase] bulk_insert_nodes hash commit failed: {e}"))
             .is_ok();
-        Ok(insert_ok && hashes_ok)
+        Ok(hashes_ok)
     }
 
     /// Bulk-insert edge rows using chunked multi-value INSERT statements.

crates/codegraph-core/src/domain/graph/builder/stages/build_edges.rs

@@ -206,9 +206,11 @@ impl<'a> EdgeContext<'a> {
 /// (a cross-file consumer added in an untouched file won't be seen until the
 /// next full rebuild) — the same scoping trade-off already accepted
 /// elsewhere in this codebase's incremental classification
-/// (`has_active_file_siblings`, exported-via-reexport, and median fan-in/out
-/// all recompute from the affected file set only, not the whole graph, in
-/// `graph/classifiers/roles.rs`'s incremental path). Mirrors
+/// (`has_active_file_siblings` and exported-via-reexport both recompute from
+/// the affected file set only, not the whole graph, in
+/// `graph/classifiers/roles.rs`'s incremental path — median fan-in/out is a
+/// separate case, deliberately kept as a whole-graph statistic even on the
+/// incremental path, for classification-threshold consistency). Mirrors
 /// `collectInvokedPropertyNames` in `src/domain/graph/builder/call-resolver.ts`.
 fn collect_invoked_property_names(files: &[FileEdgeInput]) -> HashSet<&str> {
     let mut names = HashSet::new();
@@ -831,13 +833,14 @@ fn process_file<'a>(
         // of these positions is as likely to be a plain data reference
         // (`{ name: SOME_CONSTANT }`) as a real function/class, so drop any
         // other-kind match rather than fabricating a "calls" edge to a
-        // constant. `class` is included alongside function/method because
-        // `instanceof`'s right operand is always a class/constructor
-        // (#1784) — unlike the original #1771 object-literal case, which is
-        // function/method only. Applied once here (after all
-        // resolve_call_targets tiers), mirroring the
-        // `dynamicKind === 'value-ref'` filter in resolveFallbackTargets
-        // (stages/build-edges.ts).
+        // constant. `class` was added because `instanceof`'s right operand
+        // is always a class/constructor (#1784). The filter is keyed on
+        // `dynamic_kind`, not on which site produced the call, so the #1771
+        // object-literal and #1776 Lua sites also gain class-kind
+        // resolution as a side effect — not because either idiom commonly
+        // names a class. Applied once here (after all resolve_call_targets
+        // tiers), mirroring the `dynamicKind === 'value-ref'` filter in
+        // resolveFallbackTargets (stages/build-edges.ts).
         if call.dynamic_kind.as_deref() == Some("value-ref") {
             targets.retain(|t| t.kind == "function" || t.kind == "method" || t.kind == "class");
             // #1895: object-literal-property value-refs (key_expr set — see
@@ -888,7 +891,7 @@ fn process_file<'a>(
         }
     }
 
-    emit_hierarchy_edges(ctx, file_input, fc.rel_path, &fc.imported_names, edges);
+    emit_hierarchy_edges(ctx, file_input, fc.rel_path, &fc.imported_names, &fc.imported_original_names, edges);
 }
 
 /// Callable definition kinds — only function/method bodies act as enclosing
@@ -1622,7 +1625,11 @@ fn emit_receiver_edge(
 /// the graph regardless of file or language, producing false cross-file
 /// (even cross-language) hierarchy edges for common type names. Priority:
 /// 1. Same-file declaration, when `name` is not itself an import artifact.
-/// 2. The file's actually-resolved import for `name` (barrel-traced).
+/// 2. The file's actually-resolved import for `name` (barrel-traced). For a
+///    renamed import (`import { Base as MyBase }`), the imported file stores
+///    the symbol under its original exported name, not the local alias — so
+///    `imported_original_name` resolves `MyBase` back to `Base` before the
+///    lookup, mirroring `resolve_call_targets` (#1730).
 /// 3. Last resort: a same-language-family global-by-name match (#1783),
 ///    first candidate only — a heritage clause names exactly one type.
 fn resolve_hierarchy_targets<'a>(
@@ -1631,6 +1638,7 @@ fn resolve_hierarchy_targets<'a>(
     rel_path: &str,
     imported_names: &HashMap<&str, &str>,
     target_kinds: &[&str],
+    imported_original_names: &HashMap<&str, &str>,
 ) -> Vec<&'a NodeInfo> {
     let samefile_all: Vec<&NodeInfo> = ctx.nodes_by_name_and_file
         .get(&(name, rel_path))
@@ -1643,8 +1651,9 @@ fn resolve_hierarchy_targets<'a>(
     }
 
     if let Some(imported_from) = imported_names.get(name) {
+        let target_name = imported_original_names.get(name).copied().unwrap_or(name);
         let imported_candidates: Vec<&NodeInfo> = ctx.nodes_by_name_and_file
-            .get(&(name, *imported_from))
+            .get(&(target_name, *imported_from))
             .cloned().unwrap_or_default()
             .into_iter()
             .filter(|n| target_kinds.contains(&n.kind.as_str()))
@@ -1665,6 +1674,7 @@ fn resolve_hierarchy_targets<'a>(
 fn emit_hierarchy_edges(
     ctx: &EdgeContext, file_input: &FileEdgeInput, rel_path: &str,
     imported_names: &HashMap<&str, &str>,
+    imported_original_names: &HashMap<&str, &str>,
     edges: &mut Vec<ComputedEdge>,
 ) {
     for cls in &file_input.classes {
@@ -1675,7 +1685,7 @@ fn emit_hierarchy_edges(
         let Some(source) = source_row else { continue };
 
         if let Some(ref extends_name) = cls.extends {
-            let targets = resolve_hierarchy_targets(ctx, extends_name, rel_path, imported_names, EXTENDS_TARGET_KINDS);
+            let targets = resolve_hierarchy_targets(ctx, extends_name, rel_path, imported_names, EXTENDS_TARGET_KINDS, imported_original_names);
             for t in targets {
                 edges.push(ComputedEdge {
                     source_id: source.id, target_id: t.id,
@@ -1685,7 +1695,7 @@ fn emit_hierarchy_edges(
             }
         }
         if let Some(ref implements_name) = cls.implements {
-            let targets = resolve_hierarchy_targets(ctx, implements_name, rel_path, imported_names, IMPLEMENTS_TARGET_KINDS);
+            let targets = resolve_hierarchy_targets(ctx, implements_name, rel_path, imported_names, IMPLEMENTS_TARGET_KINDS, imported_original_names);
             for t in targets {
                 edges.push(ComputedEdge {
                     source_id: source.id, target_id: t.id,
@@ -1697,6 +1707,7 @@ fn emit_hierarchy_edges(
     }
 }
 
+
 // ── Import edges (native) ──────────────────────────────────────────────
 
 #[napi(object)]
@@ -1945,6 +1956,16 @@ fn is_named_reexport(imp: &ImportInfo) -> bool {
     imp.reexport && !imp.wildcard_reexport
 }
 
+/// True for a genuine wildcard re-export (`export * from 'Y'`). Emitted as a
+/// distinct file-level marker edge (`reexports-wildcard`) alongside the
+/// generic `reexports` edge so the query layer can tell a target reached
+/// only by named specifiers apart from one that's also reached by a
+/// wildcard — even when a *different* statement in the same file names
+/// specific symbols from that exact target (#1849 review).
+fn is_wildcard_reexport(imp: &ImportInfo) -> bool {
+    imp.reexport && imp.wildcard_reexport
+}
+
 /// For a `type` import or a named re-export targeting a barrel or resolved
 /// file, emit one symbol-level edge per named symbol so the target symbols
 /// receive fan-in credit and aren't misclassified as dead code
@@ -2113,6 +2134,15 @@ fn process_single_import(
     }
     if is_named_reexport(imp) {
         emit_named_symbol_edges(edges, file_input, imp, resolved_path, "reexports", ctx);
+    } else if is_wildcard_reexport(imp) {
+        edges.push(ComputedEdge {
+            source_id: file_input.file_node_id,
+            target_id: target_node_id,
+            kind: "reexports-wildcard".to_string(),
+            confidence: 1.0,
+            dynamic: 0,
+            dynamic_kind: None,
+        });
     }
     emit_barrel_through_edges(edges, file_input, imp, resolved_path, edge_kind, ctx);
 }
@@ -2269,9 +2299,12 @@ mod import_edge_tests {
 
     #[test]
     fn wildcard_reexport_emits_no_symbol_level_edge() {
-        // `export * from './utils'` carries no specific names, so only the
-        // file-level `reexports` edge is emitted — the query layer falls
-        // back to the target's full export list for genuine wildcards.
+        // `export * from './utils'` carries no specific names, so no
+        // symbol-level edge is emitted. It does get the dedicated
+        // `reexports-wildcard` file-level marker (alongside the generic
+        // `reexports` edge) so the query layer can always apply full-export
+        // semantics for genuine wildcards, even when a *different* statement
+        // to the same target also names specific symbols (#1849 review).
         let files = vec![make_file("src/index.ts", 1, vec![
             ImportInfo {
                 source: "./utils".to_string(),
@@ -2302,9 +2335,64 @@ mod import_edge_tests {
             "/root".to_string(),
             Some(symbol_nodes),
         );
-        assert_eq!(edges.len(), 1);
+        assert_eq!(edges.len(), 2);
         assert_eq!(edges[0].kind, "reexports");
         assert_eq!(edges[0].target_id, 2);
+        assert_eq!(edges[1].kind, "reexports-wildcard");
+        assert_eq!(edges[1].target_id, 2);
+    }
+
+    #[test]
+    fn named_and_wildcard_reexport_of_same_target_both_marked() {
+        // `export { foo } from './utils'` AND `export * from './utils'` in
+        // the same file, both targeting utils.ts. The wildcard's full-export
+        // semantics must stay independently signalled (via the dedicated
+        // `reexports-wildcard` marker) rather than being suppressed by the
+        // named specifier's symbol-level edge — otherwise the query layer
+        // would report only `foo` and silently drop every other export of
+        // utils.ts that the wildcard was meant to surface (#1849 review).
+        let files = vec![make_file("src/index.ts", 1, vec![
+            make_import("./utils", vec!["foo"], true, false, false),
+            ImportInfo {
+                source: "./utils".to_string(),
+                names: vec![],
+                reexport: true,
+                type_only: false,
+                dynamic_import: false,
+                wildcard_reexport: true,
+                type_only_names: vec![],
+                renamed_imports: vec![],
+            },
+        ], vec![])];
+        let resolved = vec![make_resolved("/root/src/index.ts", "./utils", "src/utils.ts")];
+        let node_ids = vec![make_node_entry("src/index.ts", 1), make_node_entry("src/utils.ts", 2)];
+        let symbol_nodes = vec![SymbolNodeEntry {
+            name: "foo".to_string(),
+            file: "src/utils.ts".to_string(),
+            node_id: 99,
+            kind: "function".to_string(),
+        }];
+
+        let edges = build_import_edges(
+            files,
+            resolved,
+            vec![],
+            node_ids,
+            vec![],
+            "/root".to_string(),
+            Some(symbol_nodes),
+        );
+        assert_eq!(edges.len(), 4);
+        // Named statement: file-level `reexports` + symbol-level `reexports` to foo.
+        assert_eq!(edges[0].kind, "reexports");
+        assert_eq!(edges[0].target_id, 2);
+        assert_eq!(edges[1].kind, "reexports");
+        assert_eq!(edges[1].target_id, 99);
+        // Wildcard statement: file-level `reexports` + the `reexports-wildcard` marker.
+        assert_eq!(edges[2].kind, "reexports");
+        assert_eq!(edges[2].target_id, 2);
+        assert_eq!(edges[3].kind, "reexports-wildcard");
+        assert_eq!(edges[3].target_id, 2);
     }
 
     #[test]