feat(wiki-engine): add WASM tree-sitter AST track for code knowledge graph

[m0Nst3r873]

What & Why

The code knowledge graph extractors (src/wiki-engine/code-knowledge/) were purely regex / line-based. That has two concrete problems:

1. False-positive edges. Dependency edges were built by path-substring matching (file.includes(importPath)), so an import "./user" wrongly links to both user.ts and user-repo.ts (any path containing user).
2. No call relationships. Only DEPENDS_ON (imports) existed; call sites were invisible.

This PR adds a real AST track using web-tree-sitter (pure-WASM, no native toolchain), ported from the team-wiki reference implementation, for TypeScript/JavaScript, Python, and Go. It runs alongside the existing regex heuristic track (which still covers Java/Rust/config), and AST results win on merge.

How it works

• New ast/ module: WASM parser registry (async one-time init), tree-sitter queries, symbol/import/call-site walk, import & call resolvers, and fact/edge adapters. Emits precise file-to-file DEPENDS_ON / REFERENCES edges tagged source: "code-ast" with confidence weights.
• Dual-track with graceful fallback: if the WASM runtime can't load, or TEAMAI_SKIP_AST=1 is set, extraction falls back to heuristic-only and records an AST_UNAVAILABLE gap.
• code-graph: AST relation facts build precise edges directly, instead of being re-fuzzed through the path-substring matcher.
• enrich: manifest edges now preserve real AST relation/source provenance (deterministic rank-based merge) instead of hardcoding DEPENDS_ON / code-heuristic. Combined with upstream's resolveImportToModule resolver.
• Pinned versions: web-tree-sitter@0.25.10 + tree-sitter-wasms@0.1.13 — the only ABI-14-compatible pair (0.26 rejects these grammars). Both are pure-JS deps resolved from node_modules at runtime; no .wasm files are bundled into dist/.

Accuracy (measured)

On a fixture with a naming-collision decoy (user.ts real target, user-repo.ts decoy that nobody imports):

Mode	Edges	False positives	Precision
Regex only (TEAMAI_SKIP_AST=1)	3	1 (→ user-repo.ts)	67%
AST enabled	2	0	100%

Test Plan

• npx tsc --noEmit — clean
• npx vitest run — 2074/2074 pass (includes new src/__tests__/ast-extract.test.ts, 11 cases covering TS/Python/Go extraction, merge precedence, gap recording, and enrich provenance)
• npm run build — success
• E2E: real teamai codebase --extract on a multi-language sample repo produces code-ast DEPENDS_ON + REFERENCES edges; TEAMAI_SKIP_AST=1 falls back to heuristic-only + writes AST_UNAVAILABLE gap
• Packaged form: npm pack + install into a clean consumer — all .wasm files resolve from node_modules, AST track engages via the installed CLI (verifies npx/npm distribution works)

Docs

README and usage-guide updated in both EN and zh-CN; new TEAMAI_SKIP_AST env var documented.

Compatibility notes for downstream consumers

• recall graph-boost already registers REFERENCES in RELATION_WEIGHT and uses maxBoost semantics, so the new edges participate correctly with no change and can't inflate scores via duplicate edges.
• GraphEdgeSource already contains code-ast; no schema change.

🤖 Generated with Claude Code

[m0Nst3r873]

Code review follow-up (pushed in 6555763)

Ran a senior-engineer review pass over the diff. No P0. Addressed the following in this branch:

Correctness / robustness (fixed):

• WASM memory leak — walkFile now frees the parsed tree-sitter Tree via try/finally { tree.delete() }. JS GC does not reclaim WASM off-heap memory, so a large repo would have grown the emscripten heap unbounded.
• Quadratic call resolution — resolveCallSites now memoizes import bindings per source file (was rebuilt for every call site).
• Python export detection — was gated on a non-existent __export__ tree-sitter node, so every Python symbol was exported=false and symbol-level call resolution never fired. Now detects module-level class/def. Added a regression test.

Cleanup (fixed):

• Removed speculative dead code (findConflictingEdges, EdgeConflict, clearTsconfigCache) and simplified a no-op ternary.

Known limitations (deliberately deferred — the regex heuristic track still fills these gaps)

These are AST-resolver precision gaps; when the AST track doesn't resolve an edge it degrades to the heuristic track, so no coverage is lost — only precision is bounded:

• Python multi-segment imports (from a.b.c import x) don't map dotted paths to nested files yet — only single-segment sibling imports resolve.
• Go cross-package imports using full module paths (github.com/org/repo/pkg) resolve to an external/unresolved gap (no go.mod module-prefix stripping).
• IMPLEMENTS edges are handled downstream but no query capture emits them yet.

Happy to fold any of these into this PR if preferred, or track them as follow-ups.

Full suite green after the fixes: tsc clean, 2075 tests pass, build + real-CLI E2E verified.

[m0Nst3r873]

Addressed two of the three known limitations (pushed in 3add345)

• Python multi-segment imports — from a.b.c import x now maps the dotted module to a nested path (a/b/c.py or a/b/c/__init__.py). Previously only single-segment sibling imports resolved.
• TS/TSX IMPLEMENTS edges — a class's implements clause now emits IMPLEMENTS edges (source: "code-ast") to the interface's defining file, resolved via same-file interface symbols or imported bindings. Uses a separate query pattern so a class implementing multiple interfaces doesn't collide in the capture map; names that resolve to neither (ambient/global types) are skipped rather than emitting a spurious edge.

Both covered by new tests (unit + real-CLI E2E). Full suite: tsc clean, 2078 tests pass.

Still deferred: Go cross-package imports (github.com/org/repo/pkg) — needs go.mod module-prefix stripping plus directory-level package resolution; lower value / higher cost, and the heuristic track still covers it. Happy to take it in a follow-up if desired.