wikifier 4.5.3__tar.gz → 4.5.4__tar.gz

{wikifier-4.5.3/wikifier.egg-info → wikifier-4.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wikifier
-Version: 4.5.3
+Version: 4.5.4
 Summary: Zero-dependency agent-to-agent codebase wiki for LLMs and AI agents. Autonomously maintained via record-change and mark-green for token-efficient lookup of files, dependencies, health, and summaries — across tiny scripts to 50k+ monorepos. Optional MCP server with rich tools for agents.
 Author-email: Aron Amos <aron@example.com>
 Maintainer: Aron Amos
@@ -40,7 +40,19 @@ Dynamic: license-file
 
 Wikifier is an **agent-to-agent** tool: it builds a living map of a project (health matrix, dependency graph, short file summaries) and agents keep that map current as they work. Humans can peek via a small dashboard; the product is the agent loop, not a general docs site or IDE.
 
-Works from small scripts to large monorepos. **Deep import maps** cover **Python + JavaScript/TypeScript** (barrels, cycles, incremental updates). Other languages can still use health/journal/watch; they won’t get full import graphs until a parser exists.
+Works from small scripts to large monorepos. **Deep import/include maps** (zero-dep regex parsers):
+
+| Language | Extensions | Notes |
+|----------|------------|--------|
+| Python | `.py` | full ACS/CDIA path |
+| JavaScript / TypeScript | `.js` `.ts` `.jsx` `.tsx` | barrels (BREE), dynamic/CDIA |
+| Rust | `.rs` | `use` / `mod` / `extern crate` |
+| Go | `.go` | `import` / import blocks |
+| C / C++ | `.c` `.h` `.cpp` `.cc` `.cxx` `.hpp` `.hh` | `#include` (local + system) |
+| C# | `.cs` | `using` namespaces |
+| Java | `.java` | `import` / `import static` |
+
+Health/journal still work for any monitored path. Parsers are **pragmatic regex** (not full cargo/`go.mod`/classpath/`-I` resolution). Prefer **lean `monitored_paths.txt`** on huge monorepos; raise dirty cap with `WIKIFIER_CHECK_CHANGES_MAX` (default 2000) only when needed.
 
 ## Why
 
@@ -90,7 +102,7 @@ MCP **Core 6** (start every session): `get_project_status`, `check_changes`, `ge
 
 ## What you get
 
-- **Import analysis** — Python + JS/TS (ESM, CommonJS, dynamic imports, path aliases, package exports); per-edge confidence; name-routed barrel expansion (precise leaves, not edge explosion)
+- **Import analysis** — Python, JS/TS (ESM/CJS, barrels), Rust, Go, C/C++ includes, C# usings; per-edge confidence; name-routed barrel expansion for TS/JS
 - **Incremental pipeline** — pure-Python `update-maps`: dirty parse → import cache → reverse deps → cycles → `library.md`
 - **Selective agent work** — health + suggest bias to 🔴/🟡 only; ACS *actionable* low-conf excludes stdlib/external noise
 - **Scale** — reverse index + barrel invalidation so one edit doesn’t re-scan the monorepo

{wikifier-4.5.3 → wikifier-4.5.4}/README.md

@@ -8,7 +8,19 @@
 
 Wikifier is an **agent-to-agent** tool: it builds a living map of a project (health matrix, dependency graph, short file summaries) and agents keep that map current as they work. Humans can peek via a small dashboard; the product is the agent loop, not a general docs site or IDE.
 
-Works from small scripts to large monorepos. **Deep import maps** cover **Python + JavaScript/TypeScript** (barrels, cycles, incremental updates). Other languages can still use health/journal/watch; they won’t get full import graphs until a parser exists.
+Works from small scripts to large monorepos. **Deep import/include maps** (zero-dep regex parsers):
+
+| Language | Extensions | Notes |
+|----------|------------|--------|
+| Python | `.py` | full ACS/CDIA path |
+| JavaScript / TypeScript | `.js` `.ts` `.jsx` `.tsx` | barrels (BREE), dynamic/CDIA |
+| Rust | `.rs` | `use` / `mod` / `extern crate` |
+| Go | `.go` | `import` / import blocks |
+| C / C++ | `.c` `.h` `.cpp` `.cc` `.cxx` `.hpp` `.hh` | `#include` (local + system) |
+| C# | `.cs` | `using` namespaces |
+| Java | `.java` | `import` / `import static` |
+
+Health/journal still work for any monitored path. Parsers are **pragmatic regex** (not full cargo/`go.mod`/classpath/`-I` resolution). Prefer **lean `monitored_paths.txt`** on huge monorepos; raise dirty cap with `WIKIFIER_CHECK_CHANGES_MAX` (default 2000) only when needed.
 
 ## Why
 
@@ -58,7 +70,7 @@ MCP **Core 6** (start every session): `get_project_status`, `check_changes`, `ge
 
 ## What you get
 
-- **Import analysis** — Python + JS/TS (ESM, CommonJS, dynamic imports, path aliases, package exports); per-edge confidence; name-routed barrel expansion (precise leaves, not edge explosion)
+- **Import analysis** — Python, JS/TS (ESM/CJS, barrels), Rust, Go, C/C++ includes, C# usings; per-edge confidence; name-routed barrel expansion for TS/JS
 - **Incremental pipeline** — pure-Python `update-maps`: dirty parse → import cache → reverse deps → cycles → `library.md`
 - **Selective agent work** — health + suggest bias to 🔴/🟡 only; ACS *actionable* low-conf excludes stdlib/external noise
 - **Scale** — reverse index + barrel invalidation so one edit doesn’t re-scan the monorepo

{wikifier-4.5.3 → wikifier-4.5.4}/skills/run.md

@@ -12,7 +12,8 @@
 - **First-run:** `init` → `update-maps` → `health --summary` → `suggest_next_actions`. Map is automatic; wiki *prose* is agent-filled over time.
 - **Steady-state selective work:** only 🔴/🟡 (never re-wiki 🟢 unless required). ACS suggestions use `actionable_low_conf_edges` (stdlib/external bare demoted).
 - **Deletions:** `record-deletion` + check-changes ghost detection (missing paths → Red DELETED).
-- **Languages:** deep import maps = Python + JS/TS. journal/pending = audit queue, not Jira.
+- **Languages:** deep import maps = Python, JS/TS, Rust, Go, C/C++, C#, Java (regex; not full toolchain resolution). journal/pending = audit queue, not Jira.
+- **Huge monorepos:** lean `monitored_paths.txt` (package roots, not bare `.`). Optional `WIKIFIER_CHECK_CHANGES_MAX` (default 2000). `update-maps` seeds Yellow health stubs for newly parsed files (map-first).
 - **Monitor:** optional background `monitor`/`daemon` for mtime heartbeat; agents still own wiki/mark-green.
 - Health module: use `importlib.import_module("wikifier.health")` or `wikifier.health_module` — `from wikifier import health` is the *function*.
 

wikifier-4.5.4/tests/test_multi_lang_parsers.py

@@ -0,0 +1,104 @@
+"""Multi-language parser smoke tests (Rust, Go, C/C++, C#)."""
+
+import unittest
+from pathlib import Path
+
+from tests._base import TempProjectTestCase
+
+from wikifier.parsers import rust, go_lang, c_cpp, csharp, java
+from wikifier.cli import run_full_update, check_changes
+import importlib
+import os
+
+
+class TestRustParser(TempProjectTestCase):
+    def test_use_and_mod(self):
+        self.write("lib.rs", "mod foo;\nuse crate::foo::Bar;\nuse std::io;\n")
+        self.write("foo.rs", "pub struct Bar;\n")
+        edges = rust.parse_rust_imports(str(self.root / "lib.rs"))
+        kinds = {e.get("statement_type") for e in edges}
+        self.assertIn("mod", kinds)
+        self.assertIn("use", kinds)
+        mod_e = next(e for e in edges if e.get("statement_type") == "mod")
+        self.assertTrue(mod_e.get("resolved_path") and mod_e["resolved_path"].endswith("foo.rs"))
+
+
+class TestGoParser(TempProjectTestCase):
+    def test_import_block(self):
+        self.write("main.go", 'package main\nimport (\n\t"fmt"\n\t"os"\n)\n')
+        edges = go_lang.parse_go_imports(str(self.root / "main.go"))
+        mods = {e["raw_module"] for e in edges}
+        self.assertIn("fmt", mods)
+        self.assertIn("os", mods)
+
+
+class TestCParser(TempProjectTestCase):
+    def test_local_and_system_include(self):
+        self.write("a.c", '#include "b.h"\n#include <stdio.h>\n')
+        self.write("b.h", "int x;\n")
+        edges = c_cpp.parse_c_cpp_imports(str(self.root / "a.c"))
+        self.assertGreaterEqual(len(edges), 2)
+        local = next(e for e in edges if e["raw_module"] == "b.h")
+        self.assertTrue(local.get("resolved_path"))
+        sys_e = next(e for e in edges if e["raw_module"] == "stdio.h")
+        self.assertEqual((sys_e.get("diagnostic") or {}).get("category"), "external_or_bare")
+
+
+class TestCsharpParser(TempProjectTestCase):
+    def test_using(self):
+        self.write("A.cs", "using System;\nusing System.IO;\nusing MyApp.Core;\n")
+        edges = csharp.parse_csharp_imports(str(self.root / "A.cs"))
+        mods = {e["raw_module"] for e in edges}
+        self.assertIn("System", mods)
+        self.assertIn("MyApp.Core", mods)
+
+
+class TestJavaParser(TempProjectTestCase):
+    def test_import(self):
+        self.write("A.java", "import java.util.List;\nimport com.foo.Bar;\n")
+        edges = java.parse_java_imports(str(self.root / "A.java"))
+        mods = {e["raw_module"] for e in edges}
+        self.assertIn("java.util.List", mods)
+        self.assertIn("com.foo.Bar", mods)
+
+
+class TestPipelineMultiLang(TempProjectTestCase):
+    def test_run_full_update_parses_all_langs(self):
+        self.write("a.py", "import os\n")
+        self.write("b.rs", "mod x;\n")
+        self.write("x.rs", "pub fn f() {}\n")
+        self.write("c.go", 'package p\nimport "fmt"\n')
+        self.write("d.c", '#include "e.h"\n')
+        self.write("e.h", "int y;\n")
+        self.write("f.cs", "using System;\n")
+        self.write("G.java", "import java.io.File;\n")
+        res = run_full_update(root=self.root, force_full=True, verbose=False)
+        self.assertTrue(res.get("success"))
+        self.assertGreaterEqual(res.get("files_parsed", 0), 5)
+        self.assertIn("languages_parsed", res)
+        self.assertGreaterEqual(res.get("health_stubs_seeded", 0), 1)
+        health_mod = importlib.import_module("wikifier.health")
+        entries = health_mod.load_health(self.root).get("entries") or {}
+        self.assertTrue(any(k.endswith((".py", ".rs", ".java", ".cs", ".go", ".c")) for k in entries))
+
+    def test_check_changes_cap_env(self):
+        self.write("monitored_paths.txt", ".\n")
+        for i in range(5):
+            self.write(f"f{i}.py", f"x={i}\n")
+        run_full_update(root=self.root, force_full=True, verbose=False)
+        import time
+        time.sleep(0.05)
+        for i in range(5):
+            (self.root / f"f{i}.py").write_text(f"x={i + 1}\n")
+        os.environ["WIKIFIER_CHECK_CHANGES_MAX"] = "2"
+        try:
+            r = check_changes(project_root=self.root)
+            self.assertTrue(r.get("success"))
+            self.assertLessEqual(r.get("changes_detected", 0), 2)
+            self.assertTrue(r.get("dirty_truncated") or (r.get("dirty_total") or 0) <= 2)
+        finally:
+            os.environ.pop("WIKIFIER_CHECK_CHANGES_MAX", None)
+
+
+if __name__ == "__main__":
+    unittest.main()

{wikifier-4.5.3 → wikifier-4.5.4}/wikifier/__init__.py

@@ -71,4 +71,4 @@ from .contracts import (
     compute_acs_confidence,
 )
 
-__version__ = "4.5.3"
+__version__ = "4.5.4"

{wikifier-4.5.3 → wikifier-4.5.4}/wikifier/cli.py

@@ -174,7 +174,13 @@ def _collect_candidate_source_files(root: Path) -> List[Path]:
         ".pnpm", ".yarn", ".store", "store", "virtual-store", ".pnp",
         ".pnp.cjs", "node_modules/.pnpm", "node_modules/.yarn"
     }
-    exts = (".py", ".js", ".ts", ".jsx", ".tsx")
+    # Deep-map languages (agent multi-lang dogfood)
+    exts = (
+        ".py", ".js", ".ts", ".jsx", ".tsx",
+        ".rs", ".go",
+        ".c", ".h", ".cpp", ".cc", ".cxx", ".hpp", ".hh",
+        ".cs", ".java",
+    )
     try:
         root = Path(root).resolve()
     except Exception:
@@ -499,6 +505,26 @@ def run_full_update(
         # === 3. Parse every dirty file (in-process, BREE batched) ===
         from .parsers import javascript as js_parser
         from .parsers import python as py_parser
+        try:
+            from .parsers import rust as rust_parser
+        except Exception:
+            rust_parser = None
+        try:
+            from .parsers import go_lang as go_parser
+        except Exception:
+            go_parser = None
+        try:
+            from .parsers import c_cpp as c_cpp_parser
+        except Exception:
+            c_cpp_parser = None
+        try:
+            from .parsers import csharp as csharp_parser
+        except Exception:
+            csharp_parser = None
+        try:
+            from .parsers import java as java_parser
+        except Exception:
+            java_parser = None
         try:
             from .parsers import bree as bree_mod
         except Exception:
@@ -521,10 +547,28 @@ def run_full_update(
             except Exception:
                 return None
 
+        def _parse_file(fstr: str, low: str):
+            if low.endswith((".js", ".ts", ".jsx", ".tsx")):
+                return js_parser.parse_javascript_imports(fstr) or []
+            if low.endswith(".py"):
+                return py_parser.parse_python_imports(fstr) or []
+            if low.endswith(".rs") and rust_parser is not None:
+                return rust_parser.parse_rust_imports(fstr) or []
+            if low.endswith(".go") and go_parser is not None:
+                return go_parser.parse_go_imports(fstr) or []
+            if low.endswith((".c", ".h", ".cpp", ".cc", ".cxx", ".hpp", ".hh")) and c_cpp_parser is not None:
+                return c_cpp_parser.parse_c_cpp_imports(fstr) or []
+            if low.endswith(".cs") and csharp_parser is not None:
+                return csharp_parser.parse_csharp_imports(fstr) or []
+            if low.endswith(".java") and java_parser is not None:
+                return java_parser.parse_java_imports(fstr) or []
+            return None
+
         new_entries: Dict[str, Dict[str, Any]] = {}
         edges_total = 0
         parsed_count = 0
         parse_errors: List[Dict[str, str]] = []
+        lang_counts: Dict[str, int] = {}
 
         if bree_mod is not None:
             try:
@@ -536,11 +580,8 @@ def run_full_update(
                 fstr = str(f)
                 low = fstr.lower()
                 try:
-                    if low.endswith((".js", ".ts", ".jsx", ".tsx")):
-                        edges = js_parser.parse_javascript_imports(fstr) or []
-                    elif low.endswith(".py"):
-                        edges = py_parser.parse_python_imports(fstr) or []
-                    else:
+                    edges = _parse_file(fstr, low)
+                    if edges is None:
                         continue
                 except Exception as pe:
                     parse_errors.append({"file": fstr, "error": f"{type(pe).__name__}: {pe}"})
@@ -557,6 +598,8 @@ def run_full_update(
                 }
                 parsed_count += 1
                 edges_total += len(pairs)
+                ext = Path(low).suffix.lower() or "unknown"
+                lang_counts[ext] = lang_counts.get(ext, 0) + 1
                 if verbose and parsed_count % 200 == 0:
                     print(f"[run_full_update] parsed {parsed_count}/{len(dirty)}")
         finally:
@@ -568,10 +611,28 @@ def run_full_update(
 
         result["files_parsed"] = parsed_count
         result["edges_persisted"] = edges_total
+        result["languages_parsed"] = lang_counts
         if parse_errors:
             result["parse_errors"] = parse_errors[:10]
             result["parse_error_count"] = len(parse_errors)
 
+        # Seed health stubs for newly parsed files (map-first wiki: agents fill prose later)
+        health_seeded = 0
+        if _health_mod is not None and new_entries:
+            try:
+                existing = (_health_mod.load_health(root) or {}).get("entries") or {}
+                for rel in new_entries:
+                    if rel in existing:
+                        continue
+                    _health_mod.upsert_entry(
+                        root, rel, "🟡 Yellow",
+                        "Initial stub — parsed into map; agent should wiki + mark-green when editing"
+                    )
+                    health_seeded += 1
+            except Exception:
+                health_seeded = 0
+        result["health_stubs_seeded"] = health_seeded
+
         # === 4. Persist (single save; reload first to pick up the barrel flush) ===
         cache = ic.load_cache(root) or {}
         cache.update(new_entries)
@@ -1079,11 +1140,28 @@ def check_changes(project_root: Optional[Union[str, Path]] = None) -> Dict[str,
                 except Exception:
                     pass
 
+            # Cap is configurable: WIKIFIER_CHECK_CHANGES_MAX (default 2000; was hard 200).
+            # Huge monorepos with monitored_paths=. can still thrash — prefer lean monitored paths.
+            try:
+                max_dirty = int(os.environ.get("WIKIFIER_CHECK_CHANGES_MAX", "2000") or "2000")
+            except ValueError:
+                max_dirty = 2000
+            max_dirty = max(1, min(max_dirty, 50000))
+            try:
+                max_ghosts = int(os.environ.get("WIKIFIER_CHECK_CHANGES_GHOST_MAX", "200") or "200")
+            except ValueError:
+                max_ghosts = 200
+            max_ghosts = max(1, min(max_ghosts, 10000))
+
+            dirty_list = list(dirty or [])
+            dirty_truncated = len(dirty_list) > max_dirty
+            dirty_batch = dirty_list[:max_dirty]
+
             changed_count = 0
             ghosts_marked = 0
             if _health_mod is not None:
                 root_res = root.resolve()
-                for p in (dirty or [])[:200]:  # bounded for skeleton safety at scale
+                for p in dirty_batch:
                     try:
                         pr = Path(p).resolve()
                         if not str(pr).startswith(str(root_res)):
@@ -1102,7 +1180,8 @@ def check_changes(project_root: Optional[Union[str, Path]] = None) -> Dict[str,
                 # G7: surface ghost health entries (tracked path missing on disk, not already DELETED)
                 try:
                     if hasattr(_health_mod, "find_ghost_entries"):
-                        for g in (_health_mod.find_ghost_entries(root) or [])[:50]:
+                        ghosts_all = _health_mod.find_ghost_entries(root) or []
+                        for g in ghosts_all[:max_ghosts]:
                             _health_mod.upsert_entry(
                                 root, g, "🔴 Red",
                                 "DELETED — path missing on disk (check_changes ghost detection)"
@@ -1115,15 +1194,24 @@ def check_changes(project_root: Optional[Union[str, Path]] = None) -> Dict[str,
                 except Exception:
                     pass
 
+            msg = (
+                f"Python-primary check_changes complete: {changed_count} files marked/updated"
+                + (f", {ghosts_marked} ghost(s) marked Red" if ghosts_marked else "")
+                + ". Health + pending + journal touched."
+            )
+            if dirty_truncated:
+                msg += (
+                    f" Note: dirty set truncated to {max_dirty} of {len(dirty_list)} "
+                    f"(set WIKIFIER_CHECK_CHANGES_MAX or lean monitored_paths.txt)."
+                )
             result.update({
                 "success": True,
                 "changes_detected": changed_count,
+                "dirty_total": len(dirty_list),
+                "dirty_truncated": dirty_truncated,
+                "max_dirty": max_dirty,
                 "ghosts_marked": ghosts_marked,
-                "message": (
-                    f"Python-primary check_changes complete: {changed_count} files marked/updated"
-                    + (f", {ghosts_marked} ghost(s) marked Red" if ghosts_marked else "")
-                    + ". Health + pending + journal touched."
-                ),
+                "message": msg,
             })
     except Exception as e:
         result["error"] = str(e)

wikifier-4.5.4/wikifier/parsers/__init__.py

@@ -0,0 +1,23 @@
+"""Language parsers — shared edge contract for update-maps.
+
+Supported (deep import/include graphs):
+  python, javascript/typescript, rust, go, c/c++, csharp, java
+"""
+
+from . import python
+from . import javascript
+from . import rust
+from . import go_lang
+from . import c_cpp
+from . import csharp
+from . import java
+
+__all__ = [
+    "python",
+    "javascript",
+    "rust",
+    "go_lang",
+    "c_cpp",
+    "csharp",
+    "java",
+]

wikifier-4.5.4/wikifier/parsers/_edge.py

@@ -0,0 +1,71 @@
+"""Shared edge helpers for language parsers (zero-dep, agent-first)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+def make_edge(
+    *,
+    module: str,
+    raw_module: str,
+    is_relative: bool = False,
+    level: int = 0,
+    resolved_path: Optional[str] = None,
+    resolution_confidence: str = "medium",
+    confidence_score: Optional[float] = None,
+    confidence_reasons: Optional[List[str]] = None,
+    is_dynamic: bool = False,
+    statement_type: str = "import",
+    original_statement: str = "",
+    diagnostic: Optional[Dict[str, Any]] = None,
+    strategy: str = "lang-static",
+    imported_names: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """Build a parser edge dict matching the shared py/js contract (additive fields OK)."""
+    conf = resolution_confidence
+    if confidence_score is None:
+        confidence_score = {"high": 0.9, "medium": 0.6, "low": 0.4, "unresolved": 0.2}.get(conf, 0.5)
+    reasons = list(confidence_reasons or [f"base:{conf}"])
+    if not resolved_path and "no_resolved_path" not in reasons:
+        reasons.append("no_resolved_path")
+    expl = f"Base {conf} ({confidence_score:.2f})."
+    if not resolved_path:
+        expl += " unresolved/partial target."
+    if diagnostic and diagnostic.get("category") == "external_or_bare":
+        expl += " External/stdlib-style include."
+    expl += " Recommendation: Use project-relative edges for automation trust; externals are expected noise."
+
+    edge: Dict[str, Any] = {
+        "module": module,
+        "raw_module": raw_module,
+        "is_relative": is_relative,
+        "level": level,
+        "alias": None,
+        "imported_names": imported_names or [],
+        "original_statement": original_statement or raw_module,
+        "statement_type": statement_type,
+        "resolved_path": resolved_path,
+        "resolved": resolved_path or module,
+        "resolution_confidence": conf,
+        "confidence": conf,
+        "confidence_score": float(confidence_score),
+        "confidence_reasons": reasons,
+        "confidence_explanation": expl,
+        "is_dynamic": is_dynamic,
+        "dynamic_type": "static" if not is_dynamic else "expression",
+        "is_conditional": False,
+        "via_barrel": False,
+        "barrel_depth": 0,
+        "resolution_metadata": {
+            "strategy": strategy,
+            "package_hierarchy_walk": False,
+            "target_on_disk": bool(resolved_path),
+            "relative_level": level,
+        },
+        "parser": strategy.split("-")[0] if strategy else "unknown",
+        "strategy": strategy,
+    }
+    if diagnostic:
+        edge["diagnostic"] = diagnostic
+    return edge

wikifier-4.5.4/wikifier/parsers/c_cpp.py

@@ -0,0 +1,83 @@
+"""C/C++ #include parser (zero-dep, agent-first).
+
+AGENT MAP:
+  parse_c_cpp_imports(filepath) → edge list for .c/.h/.cpp/.hpp/.cc/.cxx
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from ._edge import make_edge
+
+_INCLUDE_RE = re.compile(
+    r'^\s*#\s*include\s*([<"])([^>"]+)([>"])',
+    re.MULTILINE,
+)
+_COMMENT_BLOCK = re.compile(r"/\*.*?\*/", re.DOTALL)
+_COMMENT_LINE = re.compile(r"//.*?$", re.MULTILINE)
+
+
+def _strip(src: str) -> str:
+    return _COMMENT_LINE.sub(" ", _COMMENT_BLOCK.sub(" ", src))
+
+
+def _resolve_local(current: Path, inc: str) -> Optional[str]:
+    parent = current.parent
+    cand = (parent / inc).resolve()
+    if cand.is_file():
+        return str(cand)
+    # walk up a few parents for monorepo headers (bounded)
+    for _ in range(4):
+        parent = parent.parent
+        cand = (parent / inc).resolve()
+        if cand.is_file():
+            return str(cand)
+    return None
+
+
+def parse_c_cpp_imports(filepath: str) -> List[Dict]:
+    path = Path(filepath)
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return []
+    text = _strip(text)
+    edges: List[Dict] = []
+
+    for m in _INCLUDE_RE.finditer(text):
+        quote, inc, _ = m.group(1), m.group(2), m.group(3)
+        is_system = quote == "<"
+        is_rel = not is_system
+        rp = _resolve_local(path, inc) if is_rel else None
+        diag = None
+        if is_system or not rp:
+            diag = {
+                "category": "external_or_bare" if is_system else "no_fs_match",
+                "reason": f"#include {'<' if is_system else '\"'}{inc}{' >' if is_system else '\"'}",
+                "severity": "info",
+                "alternatives": [],
+                "suggestion_for_agent": (
+                    "System includes are expected external."
+                    if is_system
+                    else "Could not resolve local include on disk (include paths not fully modeled)."
+                ),
+                "details": {},
+            }
+        edges.append(
+            make_edge(
+                module=inc,
+                raw_module=inc,
+                is_relative=is_rel,
+                level=1 if is_rel else 0,
+                resolved_path=rp,
+                resolution_confidence="high" if rp else ("medium" if is_system else "low"),
+                statement_type="include",
+                original_statement=m.group(0).strip(),
+                diagnostic=diag,
+                strategy="c-include" if is_system else "c-include-local",
+            )
+        )
+    return edges

wikifier-4.5.4/wikifier/parsers/csharp.py

@@ -0,0 +1,64 @@
+"""C# using-directive parser (zero-dep, agent-first).
+
+AGENT MAP:
+  parse_csharp_imports(filepath) → edge list for .cs using directives
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Dict, List
+
+from ._edge import make_edge
+
+_USING_RE = re.compile(
+    r"^\s*using\s+(?:static\s+)?(?:[\w.]+\s*=\s*)?([\w.]+)\s*;",
+    re.MULTILINE,
+)
+_COMMENT_BLOCK = re.compile(r"/\*.*?\*/", re.DOTALL)
+_COMMENT_LINE = re.compile(r"//.*?$", re.MULTILINE)
+
+
+def _strip(src: str) -> str:
+    return _COMMENT_LINE.sub(" ", _COMMENT_BLOCK.sub(" ", src))
+
+
+def parse_csharp_imports(filepath: str) -> List[Dict]:
+    path = Path(filepath)
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return []
+    text = _strip(text)
+    edges: List[Dict] = []
+    seen = set()
+
+    for m in _USING_RE.finditer(text):
+        ns = m.group(1).strip()
+        if not ns or ns in seen:
+            continue
+        seen.add(ns)
+        # Project namespaces often PascalCase multi-part; System.* is framework
+        is_framework = ns == "System" or ns.startswith("System.") or ns.startswith("Microsoft.")
+        diag = {
+            "category": "external_or_bare",
+            "reason": f"C# using '{ns}' (namespace; not a filesystem path).",
+            "severity": "info",
+            "alternatives": [],
+            "suggestion_for_agent": "Namespace graph is symbolic; pair with project structure for deeper maps.",
+            "details": {"framework": is_framework},
+        }
+        edges.append(
+            make_edge(
+                module=ns,
+                raw_module=ns,
+                is_relative=False,
+                resolution_confidence="medium",
+                statement_type="using",
+                original_statement=m.group(0).strip(),
+                diagnostic=diag,
+                strategy="csharp-using",
+            )
+        )
+    return edges

wikifier-4.5.4/wikifier/parsers/go_lang.py

@@ -0,0 +1,87 @@
+"""Go import parser (zero-dep, agent-first).
+
+AGENT MAP:
+  parse_go_imports(filepath) → edge list (import / import ())
+Module name: go_lang (avoid stdlib `go` clash if any).
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from ._edge import make_edge
+
+_IMPORT_SINGLE = re.compile(r'^\s*import\s+(?:(\w+)\s+)?["\']([^"\']+)["\']', re.MULTILINE)
+_IMPORT_BLOCK = re.compile(r"^\s*import\s*\((.*?)\)", re.MULTILINE | re.DOTALL)
+_BLOCK_LINE = re.compile(r'^\s*(?:(\w+)\s+)?["\']([^"\']+)["\']', re.MULTILINE)
+_COMMENT_BLOCK = re.compile(r"/\*.*?\*/", re.DOTALL)
+_COMMENT_LINE = re.compile(r"//.*?$", re.MULTILINE)
+
+
+def _strip(src: str) -> str:
+    return _COMMENT_LINE.sub(" ", _COMMENT_BLOCK.sub(" ", src))
+
+
+def _is_stdlib(path: str) -> bool:
+    # Rough: no dot in first path segment → often stdlib (fmt, os, net/http)
+    first = path.split("/")[0]
+    return "." not in first and not path.startswith(".")
+
+
+def _edge_for(path: str, alias: Optional[str], stmt: str) -> Dict:
+    is_rel = path.startswith("./") or path.startswith("../")
+    external = (not is_rel) and (_is_stdlib(path) or "." in path.split("/")[0] or True)
+    # Mark non-relative as external_or_bare for ACS noise filter (module paths are rarely on-disk relative)
+    diag = None
+    if not is_rel:
+        diag = {
+            "category": "external_or_bare",
+            "reason": f"Go import path '{path}' (module path; not relative filesystem).",
+            "severity": "info",
+            "alternatives": [],
+            "suggestion_for_agent": "Relative imports are rare in Go; module paths are expected.",
+            "details": {"stdlib_heuristic": _is_stdlib(path)},
+        }
+    return make_edge(
+        module=path,
+        raw_module=path,
+        is_relative=is_rel,
+        level=1 if is_rel else 0,
+        resolution_confidence="medium",
+        statement_type="import",
+        original_statement=stmt.strip(),
+        diagnostic=diag,
+        strategy="go-import",
+        imported_names=[alias] if alias else [],
+    )
+
+
+def parse_go_imports(filepath: str) -> List[Dict]:
+    path = Path(filepath)
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return []
+    text = _strip(text)
+    edges: List[Dict] = []
+    seen = set()
+
+    for m in _IMPORT_BLOCK.finditer(text):
+        block = m.group(1)
+        for lm in _BLOCK_LINE.finditer(block):
+            alias, imp = lm.group(1), lm.group(2)
+            if imp in seen:
+                continue
+            seen.add(imp)
+            edges.append(_edge_for(imp, alias, lm.group(0)))
+
+    for m in _IMPORT_SINGLE.finditer(text):
+        alias, imp = m.group(1), m.group(2)
+        if imp in seen:
+            continue
+        seen.add(imp)
+        edges.append(_edge_for(imp, alias, m.group(0)))
+
+    return edges

wikifier-4.5.4/wikifier/parsers/java.py

@@ -0,0 +1,64 @@
+"""Java import parser (zero-dep, agent-first).
+
+AGENT MAP:
+  parse_java_imports(filepath) → edge list for .java import statements
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Dict, List
+
+from ._edge import make_edge
+
+_IMPORT_RE = re.compile(
+    r"^\s*import\s+(static\s+)?([\w.]+)(?:\.\*)?\s*;",
+    re.MULTILINE,
+)
+_COMMENT_BLOCK = re.compile(r"/\*.*?\*/", re.DOTALL)
+_COMMENT_LINE = re.compile(r"//.*?$", re.MULTILINE)
+
+
+def _strip(src: str) -> str:
+    return _COMMENT_LINE.sub(" ", _COMMENT_BLOCK.sub(" ", src))
+
+
+def parse_java_imports(filepath: str) -> List[Dict]:
+    path = Path(filepath)
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return []
+    text = _strip(text)
+    edges: List[Dict] = []
+    seen = set()
+
+    for m in _IMPORT_RE.finditer(text):
+        is_static = bool(m.group(1))
+        name = m.group(2).strip()
+        if not name or name in seen:
+            continue
+        seen.add(name)
+        is_jdk = name.startswith("java.") or name.startswith("javax.") or name.startswith("jdk.")
+        diag = {
+            "category": "external_or_bare",
+            "reason": f"Java import '{name}'" + (" (static)" if is_static else ""),
+            "severity": "info",
+            "alternatives": [],
+            "suggestion_for_agent": "Package names are symbolic without classpath resolution.",
+            "details": {"jdk": is_jdk, "static": is_static},
+        }
+        edges.append(
+            make_edge(
+                module=name,
+                raw_module=name,
+                is_relative=False,
+                resolution_confidence="medium",
+                statement_type="import_static" if is_static else "import",
+                original_statement=m.group(0).strip(),
+                diagnostic=diag,
+                strategy="java-import",
+            )
+        )
+    return edges

wikifier-4.5.4/wikifier/parsers/rust.py

@@ -0,0 +1,133 @@
+"""Rust import/use parser (zero-dep, agent-first).
+
+AGENT MAP:
+  parse_rust_imports(filepath) → edge list (use / mod / extern crate)
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from ._edge import make_edge
+
+_USE_RE = re.compile(
+    r"^\s*(?:pub\s+)?use\s+((?:crate|super|self|::)?(?:::)?[\w:{}*,\s]+);",
+    re.MULTILINE,
+)
+_MOD_RE = re.compile(r"^\s*(?:pub\s+)?mod\s+(\w+)\s*;", re.MULTILINE)
+_EXTERN_RE = re.compile(r"^\s*extern\s+crate\s+(\w+)\s*;", re.MULTILINE)
+_COMMENT_BLOCK = re.compile(r"/\*.*?\*/", re.DOTALL)
+_COMMENT_LINE = re.compile(r"//.*?$", re.MULTILINE)
+
+
+def _strip_comments(src: str) -> str:
+    src = _COMMENT_BLOCK.sub(" ", src)
+    src = _COMMENT_LINE.sub(" ", src)
+    return src
+
+
+def _resolve_mod(current: Path, name: str) -> Optional[str]:
+    parent = current.parent
+    for cand in (
+        parent / f"{name}.rs",
+        parent / name / "mod.rs",
+        parent / name / "lib.rs",
+        parent / name / "main.rs",
+    ):
+        if cand.is_file():
+            return str(cand.resolve())
+    return None
+
+
+def parse_rust_imports(filepath: str) -> List[Dict]:
+    path = Path(filepath)
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return []
+    text = _strip_comments(text)
+    edges: List[Dict] = []
+
+    for m in _USE_RE.finditer(text):
+        raw = m.group(1).strip()
+        # Collapse use foo::{a, b} to foo
+        base = raw.split("::")[0].replace("{", "").replace("}", "").strip().split(",")[0].strip()
+        is_rel = base in ("crate", "super", "self") or raw.startswith("crate::") or raw.startswith("super::")
+        conf = "medium" if is_rel else "medium"
+        diag = None
+        if not is_rel and base not in ("std", "core", "alloc"):
+            # external crate name
+            diag = {
+                "category": "external_or_bare",
+                "reason": f"Rust crate/path use '{raw}' (not crate/super/self-local).",
+                "severity": "info",
+                "alternatives": [],
+                "suggestion_for_agent": "Local crate::/super::/mod edges are preferred for graph trust.",
+                "details": {},
+            }
+        if base in ("std", "core", "alloc") or (not is_rel and "::" not in raw and base.isidentifier()):
+            if base in ("std", "core", "alloc") or (diag and not is_rel):
+                diag = diag or {
+                    "category": "external_or_bare",
+                    "reason": f"Rust std/external use '{raw}'.",
+                    "severity": "info",
+                    "alternatives": [],
+                    "suggestion_for_agent": "Expected for std/external crates.",
+                    "details": {},
+                }
+        edges.append(
+            make_edge(
+                module=raw.replace(" ", ""),
+                raw_module=raw,
+                is_relative=is_rel,
+                level=1 if is_rel else 0,
+                resolution_confidence=conf,
+                statement_type="use",
+                original_statement=m.group(0).strip(),
+                diagnostic=diag,
+                strategy="rust-use",
+            )
+        )
+
+    for m in _MOD_RE.finditer(text):
+        name = m.group(1)
+        rp = _resolve_mod(path, name)
+        edges.append(
+            make_edge(
+                module=name,
+                raw_module=name,
+                is_relative=True,
+                level=1,
+                resolved_path=rp,
+                resolution_confidence="high" if rp else "medium",
+                statement_type="mod",
+                original_statement=m.group(0).strip(),
+                strategy="rust-mod",
+            )
+        )
+
+    for m in _EXTERN_RE.finditer(text):
+        name = m.group(1)
+        edges.append(
+            make_edge(
+                module=name,
+                raw_module=name,
+                is_relative=False,
+                resolution_confidence="medium",
+                statement_type="extern_crate",
+                original_statement=m.group(0).strip(),
+                diagnostic={
+                    "category": "external_or_bare",
+                    "reason": f"extern crate {name}",
+                    "severity": "info",
+                    "alternatives": [],
+                    "suggestion_for_agent": "External crate.",
+                    "details": {},
+                },
+                strategy="rust-extern",
+            )
+        )
+
+    return edges

{wikifier-4.5.3 → wikifier-4.5.4/wikifier.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wikifier
-Version: 4.5.3
+Version: 4.5.4
 Summary: Zero-dependency agent-to-agent codebase wiki for LLMs and AI agents. Autonomously maintained via record-change and mark-green for token-efficient lookup of files, dependencies, health, and summaries — across tiny scripts to 50k+ monorepos. Optional MCP server with rich tools for agents.
 Author-email: Aron Amos <aron@example.com>
 Maintainer: Aron Amos
@@ -40,7 +40,19 @@ Dynamic: license-file
 
 Wikifier is an **agent-to-agent** tool: it builds a living map of a project (health matrix, dependency graph, short file summaries) and agents keep that map current as they work. Humans can peek via a small dashboard; the product is the agent loop, not a general docs site or IDE.
 
-Works from small scripts to large monorepos. **Deep import maps** cover **Python + JavaScript/TypeScript** (barrels, cycles, incremental updates). Other languages can still use health/journal/watch; they won’t get full import graphs until a parser exists.
+Works from small scripts to large monorepos. **Deep import/include maps** (zero-dep regex parsers):
+
+| Language | Extensions | Notes |
+|----------|------------|--------|
+| Python | `.py` | full ACS/CDIA path |
+| JavaScript / TypeScript | `.js` `.ts` `.jsx` `.tsx` | barrels (BREE), dynamic/CDIA |
+| Rust | `.rs` | `use` / `mod` / `extern crate` |
+| Go | `.go` | `import` / import blocks |
+| C / C++ | `.c` `.h` `.cpp` `.cc` `.cxx` `.hpp` `.hh` | `#include` (local + system) |
+| C# | `.cs` | `using` namespaces |
+| Java | `.java` | `import` / `import static` |
+
+Health/journal still work for any monitored path. Parsers are **pragmatic regex** (not full cargo/`go.mod`/classpath/`-I` resolution). Prefer **lean `monitored_paths.txt`** on huge monorepos; raise dirty cap with `WIKIFIER_CHECK_CHANGES_MAX` (default 2000) only when needed.
 
 ## Why
 
@@ -90,7 +102,7 @@ MCP **Core 6** (start every session): `get_project_status`, `check_changes`, `ge
 
 ## What you get
 
-- **Import analysis** — Python + JS/TS (ESM, CommonJS, dynamic imports, path aliases, package exports); per-edge confidence; name-routed barrel expansion (precise leaves, not edge explosion)
+- **Import analysis** — Python, JS/TS (ESM/CJS, barrels), Rust, Go, C/C++ includes, C# usings; per-edge confidence; name-routed barrel expansion for TS/JS
 - **Incremental pipeline** — pure-Python `update-maps`: dirty parse → import cache → reverse deps → cycles → `library.md`
 - **Selective agent work** — health + suggest bias to 🔴/🟡 only; ACS *actionable* low-conf excludes stdlib/external noise
 - **Scale** — reverse index + barrel invalidation so one edit doesn’t re-scan the monorepo

{wikifier-4.5.3 → wikifier-4.5.4}/wikifier.egg-info/SOURCES.txt

@@ -21,10 +21,16 @@ pyproject.toml
 ./wikifier/mcp/__init__.py
 ./wikifier/mcp/server.py
 ./wikifier/parsers/__init__.py
+./wikifier/parsers/_edge.py
 ./wikifier/parsers/bree.py
+./wikifier/parsers/c_cpp.py
 ./wikifier/parsers/cdia.py
+./wikifier/parsers/csharp.py
+./wikifier/parsers/go_lang.py
+./wikifier/parsers/java.py
 ./wikifier/parsers/javascript.py
 ./wikifier/parsers/python.py
+./wikifier/parsers/rust.py
 ./wikifier/scripts/wikifier.bat
 ./wikifier/scripts/wikifier.ps1
 ./wikifier/scripts/wikifier.sh
@@ -34,6 +40,7 @@ tests/test_barrel_invalidation.py
 tests/test_gap_closure.py
 tests/test_health.py
 tests/test_import_cache.py
+tests/test_multi_lang_parsers.py
 tests/test_parsers.py
 tests/test_selftest_wrappers.py
 wikifier/__init__.py
@@ -58,10 +65,16 @@ wikifier.egg-info/top_level.txt
 wikifier/mcp/__init__.py
 wikifier/mcp/server.py
 wikifier/parsers/__init__.py
+wikifier/parsers/_edge.py
 wikifier/parsers/bree.py
+wikifier/parsers/c_cpp.py
 wikifier/parsers/cdia.py
+wikifier/parsers/csharp.py
+wikifier/parsers/go_lang.py
+wikifier/parsers/java.py
 wikifier/parsers/javascript.py
 wikifier/parsers/python.py
+wikifier/parsers/rust.py
 wikifier/scripts/wikifier.bat
 wikifier/scripts/wikifier.ps1
 wikifier/scripts/wikifier.sh