wikifier 4.5.8__tar.gz → 4.5.9__tar.gz

{wikifier-4.5.8/wikifier.egg-info → wikifier-4.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wikifier
-Version: 4.5.8
+Version: 4.5.9
 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

{wikifier-4.5.8 → wikifier-4.5.9}/tests/test_gap_closure.py

@@ -103,6 +103,85 @@ class TestAcsActionableG4(TempProjectTestCase):
             for p in action
         ))
 
+    def test_dynamic_literal_noise_demoted_from_actionable(self):
+        """ACS v1.2: importlib.import_module(\"pkg\") static dynamics are not actionable."""
+        dyn_lit = {
+            "raw": "\"wikifier.health\"",
+            "resolved": "wikifier.health",
+            "resolved_path": None,
+            "is_dynamic": True,
+            "dynamic_type": "static",
+            "confidence_score": 0.05,
+            "confidence_reasons": [
+                "base:low", "conditional_context", "dynamic",
+                "detector:TernaryDetector",
+            ],
+            "confidence_explanation": (
+                'Base low (0.05). TernaryDetector=importlib.import_module("wikifier.health"). '
+                "Recommendation: Runtime optional load is expected noise."
+            ),
+            "resolution_metadata": {"strategy": "python-dynamic"},
+        }
+        project_fragile = {
+            "raw": "./missing_local",
+            "resolved": "missing_local",
+            "resolved_path": None,
+            "is_dynamic": False,
+            "confidence_score": 0.35,
+            "confidence_reasons": ["base:low", "no_resolved_path"],
+            "confidence_explanation": "Unresolved project-local. Recommendation: fix path.",
+            "diagnostic": {"category": "project"},
+            "resolution_metadata": {"strategy": "relative-fs"},
+        }
+        cache = {
+            "mod.py": {
+                "mtime": 1,
+                "resolved_pairs": [dyn_lit, project_fragile],
+            }
+        }
+        self.assertTrue(ic._edge_is_dynamic_literal_noise(dyn_lit))
+        self.assertFalse(ic._edge_is_dynamic_literal_noise(project_fragile))
+        summary = ic.compute_acs_summary(cache)
+        self.assertEqual(summary.get("acs_version"), "1.2")
+        self.assertGreaterEqual(summary["low_conf_edges"], 2)
+        self.assertEqual(summary["actionable_low_conf_edges"], 1)
+        self.assertGreaterEqual(summary.get("dynamic_literal_noise_edges", 0), 1)
+        action = ic.get_low_confidence_edges(cache, actionable_only=True)
+        self.assertEqual(len(action), 1)
+        self.assertIn("missing_local", str(action[0].get("raw") or action[0].get("resolved")))
+
+
+class TestLoadSafetyNoImportCycle(unittest.TestCase):
+    """Load-time safety: core modules import without circular-import failure."""
+
+    def test_import_wikifier_and_cycle_trio(self):
+        import importlib
+        import wikifier
+        self.assertTrue(hasattr(wikifier, "discover_project_root"))
+        # Fresh submodule loads (project_root breaks former cli↔cache↔bree SCC)
+        for name in (
+            "wikifier.project_root",
+            "wikifier.cli",
+            "wikifier.import_cache",
+            "wikifier.parsers.bree",
+        ):
+            mod = importlib.import_module(name)
+            self.assertIsNotNone(mod)
+        from wikifier.project_root import discover_project_root as dpr
+        from wikifier.cli import discover_project_root as dpr_cli
+        self.assertIs(dpr, dpr_cli)
+        root = dpr()
+        self.assertTrue(root.exists())
+
+    def test_bree_does_not_import_cli_at_module_level(self):
+        """Static check: bree source must not load-time import wikifier.cli."""
+        from pathlib import Path
+        bree_src = Path(__file__).resolve().parents[1] / "wikifier" / "parsers" / "bree.py"
+        text = bree_src.read_text(encoding="utf-8")
+        self.assertNotIn("from ..cli import", text)
+        self.assertNotIn("from wikifier.cli import", text)
+        self.assertIn("from ..project_root import", text)
+
 
 class TestGhostAndDeletionG7(TempProjectTestCase):
     def test_find_ghost_and_record_deletion(self):

{wikifier-4.5.8 → wikifier-4.5.9}/wikifier/__init__.py

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

{wikifier-4.5.8 → wikifier-4.5.9}/wikifier/cli.py

@@ -21,136 +21,9 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 from contextlib import nullcontext as _nullcontext
 
-
-def discover_project_root() -> Path:
-    """
-    Unified discovery helper for the *target project root* (user codebase / monorepo).
-
-    This is the canonical implementation for CLI, MCP, direct Python use, and
-    is mirrored (same priority + markers) by the shell script's discover_project_root().
-
-    Highest-leverage fix for External / Packaged Full-Update Robustness (Gap #1):
-    Makes `pip install wikifier` + `wikifier ...` (or direct packaged sh) reliable
-    from any external monorepo cwd without requiring manual WIKIFIER_PROJECT_ROOT
-    or --target on every invocation. Zero-dependency.
-
-    Wave 3 hardening (symlinks + pnpm/yarn stores):
-    - Consults $PWD (and $OLDPWD) logical cwd in addition to Path.cwd() / .resolve().
-    - Walks parent chains from *logical* start points first; this ensures that when
-      cwd is deep inside a pnpm symlinked store layout (e.g. monorepo/node_modules/.pnpm/pkg@1/.../pkg
-      whose physical target is /global-store/...), the logical ancestor chain still reaches
-      the real project root markers (.git, package.json etc.) outside the store.
-    - Falls back to resolved physical; returns the outermost marker root found.
-    - Prevents packaged/parser/daemon from accidentally using a store dir as PROJECT_ROOT.
-
-    Wave 4 further hardening for complex monorepo layouts:
-    - Collects *all* candidate marker roots across logical/physical/realpath chains (no early return).
-    - Selects the outermost (shallowest fs path) preferring .git roots, then lockfiles (pnpm/yarn), then other.
-      This correctly picks true monorepo root even when deep sub-packages have their own package.json / yarn workspaces.
-    - Expanded common markers: pnpm-lock.yaml, yarn.lock, lerna.json, nx.json, turbo.json, rush.json, workspace yamls.
-    - Explicit skipping of node_modules/.pnpm / .yarn / .pnp internals as candidate roots (even on logical paths).
-    - Additional os.path.realpath chains for nested/broken symlink monorepo layouts.
-    - Daemon, parsers (via _get_*_fallback), run_full_update all inherit automatically.
-    """
-    # 1. Explicit env var (highest priority, supports all the R6 --target flows)
-    env_root = os.environ.get("WIKIFIER_PROJECT_ROOT")
-    if env_root:
-        p = Path(env_root).expanduser().resolve()
-        if p.exists():
-            return p
-
-    # Wave 3/4: logical cwd (PWD/OLDPWD) + physical + realpath fallbacks for symlink/pnpm/yarn/nested
-    cwd = Path.cwd()
-    logical_cwd_str = os.environ.get("PWD") or os.environ.get("OLDPWD") or str(cwd)
-    try:
-        logical_cwd = Path(logical_cwd_str).expanduser()
-    except Exception:
-        logical_cwd = cwd
-
-    start_points: List[Path] = []
-    for start in (logical_cwd, cwd, cwd.resolve()):
-        if start and start not in start_points:
-            start_points.append(start)
-
-    # Wave 4: realpath variants for deeper symlink nest robustness (e.g. git submodules + pnpm links)
-    for sp in list(start_points):
-        try:
-            rp = Path(os.path.realpath(str(sp)))
-            if rp not in start_points:
-                start_points.append(rp)
-        except Exception:
-            continue
-
-    # 2/3. Markers: wikifier-specific + expanded common monorepo (Wave 4)
-    wikifier_specific = [".wikifier", "monitored_paths.txt", ".wikifier/config"]
-    common_markers = [
-        ".git", "package.json", "pyproject.toml", "setup.py", "setup.cfg",
-        "Cargo.toml", "go.mod", ".hg",
-        # Wave 4 monorepo root indicators (for workspace/subpkg layouts + yarn/pnpm detection)
-        "pnpm-lock.yaml", "yarn.lock", "lerna.json", "nx.json", "turbo.json",
-        "rush.json", "workspace.json", "pnpm-workspace.yaml", ".yarnrc.yml"
-    ]
-    store_indicators = (".pnpm", ".yarn", ".pnp", ".pnp.cjs", "virtual-store", ".store")
-
-    candidates: List[Path] = []
-    for start in start_points:
-        try:
-            parent_chain = [start] + list(start.parents)
-        except Exception:
-            parent_chain = [start]
-
-        # Wikifier markers (post-init)
-        for parent in parent_chain:
-            try:
-                pstr = str(parent)
-                if any(ind in pstr for ind in store_indicators) and "node_modules" in pstr:
-                    continue  # never treat deep pnpm/yarn store paths as project root
-                if ((parent / ".wikifier").is_dir() or
-                        (parent / "monitored_paths.txt").exists() or
-                        (parent / ".wikifier/config").exists()):
-                    if parent not in candidates:
-                        candidates.append(parent)
-            except Exception:
-                continue
-
-        # Common + monorepo markers (any-scale external)
-        for parent in parent_chain:
-            try:
-                pstr = str(parent)
-                if any(ind in pstr for ind in store_indicators) and "node_modules" in pstr:
-                    continue
-                for marker in common_markers:
-                    if (parent / marker).exists():
-                        if parent not in candidates:
-                            candidates.append(parent)
-            except Exception:
-                continue
-
-    if candidates:
-        # Wave 4: pick outermost/shallowest, with strong preference for .git (true monorepo root)
-        # even if a deeper packages/*/package.json also matches. Solves workspace subdir case.
-        def _root_key(p: Path):
-            try:
-                rp = p.resolve()
-                has_git = (rp / ".git").exists() or (rp / ".git").is_file()  # worktree support
-                depth = len(rp.parts)
-                return (0 if has_git else 1, depth, str(rp))
-            except Exception:
-                return (99, 99999, str(p))
-
-        best = min(candidates, key=_root_key)
-        try:
-            return best.resolve() if best.exists() else best
-        except Exception:
-            return best
-
-    # 4. Last-resort sensible default: the directory the user is running from.
-    #    This is the key robustness fix vs. old "fall back to package dir".
-    #    Prefer resolved for the final fallback.
-    try:
-        return cwd.resolve()
-    except Exception:
-        return cwd
+# Canonical discovery lives in project_root (no cli↔cache↔bree load cycle).
+# Re-export for public API: `from wikifier.cli import discover_project_root`.
+from .project_root import discover_project_root  # noqa: F401
 
 
 # =============================================================================

{wikifier-4.5.8 → wikifier-4.5.9}/wikifier/import_cache.py

@@ -993,6 +993,54 @@ def _edge_is_external_noise(pair: Dict[str, Any]) -> bool:
     return False
 
 
+def _edge_is_dynamic_literal_noise(pair: Dict[str, Any]) -> bool:
+    """True for dynamic imports of static string literals (not agent actionable risk).
+
+    ACS v1.2: demote importlib.import_module(\"pkg\"), __import__(\"pkg\"), and other
+    is_dynamic + dynamic_type=static string-literal edges. These are intentional runtime
+    loads (often optional/try fallbacks), not unresolved project graph holes.
+
+    Keep as telemetry (still in low_conf_edges) but exclude from actionable_low_conf_edges.
+    """
+    if not isinstance(pair, dict):
+        return False
+    reasons = pair.get("confidence_reasons") or []
+    reason_l = " ".join(str(r).lower() for r in reasons if isinstance(r, str))
+    is_dyn = bool(pair.get("is_dynamic")) or ("dynamic" in reason_l)
+    if not is_dyn:
+        return False
+
+    dtype = str(pair.get("dynamic_type") or "").lower()
+    raw = str(pair.get("raw") or pair.get("raw_module") or pair.get("module") or "").strip()
+    expl = str(pair.get("confidence_explanation") or "")
+    resolved = str(pair.get("resolved") or "").strip()
+
+    # Explicit importlib / __import__ traces → always non-actionable for ACS
+    # (includes static string loads and parser traces that mention the call form).
+    if "import_module(" in expl or "__import__(" in expl or "importlib.import_module" in expl:
+        return True
+
+    # dynamic_type=static means LDSI recovered a concrete string literal
+    if dtype in ("static", "string", "literal"):
+        # Quoted raw like "\"wikifier.health\"" or '"./x"'
+        if (raw.startswith("\"") and raw.endswith("\"")) or (raw.startswith("'") and raw.endswith("'")):
+            return True
+        # Unquoted but resolved/raw is a dotted package name (no path variables)
+        cand = raw or resolved
+        if cand and "${" not in cand and "+" not in cand:
+            inner = cand.strip().strip("\"'")
+            if inner and not any(ch in inner for ch in ("/", "\\", " ", "(", ")")):
+                # pure module id literal (e.g. wikifier.health) — not a computed path
+                if "." in inner or inner.isidentifier():
+                    return True
+    return False
+
+
+def _edge_is_non_actionable_noise(pair: Dict[str, Any]) -> bool:
+    """Union of external/stdlib noise + dynamic-literal noise (ACS actionable filter)."""
+    return _edge_is_external_noise(pair) or _edge_is_dynamic_literal_noise(pair)
+
+
 def compute_acs_summary(
     cache: Dict[str, Any],
     max_samples: int = 5,
@@ -1013,6 +1061,9 @@ def compute_acs_summary(
       - external_noise_edges: count of scored edges classified as external noise
       - sample_actionable_low_conf_explanations: samples for agent action only
     Agents should prefer actionable_* for next-steps; low_conf_edges remains full telemetry.
+
+    ACS v1.2: also demotes dynamic string-literal noise (importlib.import_module(\"…\"),
+    is_dynamic+dynamic_type=static) from actionable counts. Full low_conf telemetry unchanged.
     """
     # Phase 5e (66): compute_acs_summary + get_acs_summary promoted first-class default (O(k) bounded samples via ACS/CIABRE, deque-style in practice) for 20k+ creative; format=summary paths in MCP/CLI/health default to this + barrel summary (per 48/58/50/57, crit2/5 long-term WS A).
     t0 = time.time()
@@ -1021,6 +1072,7 @@ def compute_acs_summary(
     low_count = 0
     actionable_low = 0
     external_noise = 0
+    dynamic_literal_noise = 0
     reason_counts: Dict[str, int] = {}
     samples: List[str] = []  # full expls for lowest-risk (prioritized)
 
@@ -1037,9 +1089,13 @@ def compute_acs_summary(
             sc = p.get("confidence_score")
             expl = p.get("confidence_explanation") or ""
             reasons = p.get("confidence_reasons") or []
-            is_noise = _edge_is_external_noise(p)
-            if is_noise:
+            is_ext = _edge_is_external_noise(p)
+            is_dyn_lit = _edge_is_dynamic_literal_noise(p)
+            is_noise = is_ext or is_dyn_lit
+            if is_ext:
                 external_noise += 1
+            if is_dyn_lit:
+                dynamic_literal_noise += 1
             if isinstance(sc, (int, float)):
                 scf = float(sc)
                 sum_score += scf
@@ -1073,13 +1129,14 @@ def compute_acs_summary(
     top_reasons = sorted(reason_counts.items(), key=lambda x: -x[1])[:6]
 
     return {
-        "acs_version": "1.1",
+        "acs_version": "1.2",
         "generated_at": datetime.now(timezone.utc).isoformat(),
         "total_scored_edges": total,
         "avg_confidence": avg,
         "low_conf_edges": low_count,
         "actionable_low_conf_edges": actionable_low,
         "external_noise_edges": external_noise,
+        "dynamic_literal_noise_edges": dynamic_literal_noise,
         "low_conf_threshold": low_threshold,
         "top_risk_reasons": dict(top_reasons),
         "sample_low_conf_explanations": samples,  # full Recommendation text for agents
@@ -1116,12 +1173,12 @@ def ensure_acs_summary_persisted(
       always-available oracle in primary surfaces without requiring explicit update first.
     """
     acs = get_acs_summary(cache)
-    # G4: recompute when missing OR pre-1.1 summaries (no actionable_low_conf_edges)
+    # G4/v1.2: recompute when missing OR pre-1.2 summaries (dynamic-literal demotion)
     needs = (
         not acs
         or acs.get("total_scored_edges", 0) == 0
         or "actionable_low_conf_edges" not in acs
-        or str(acs.get("acs_version") or "") < "1.1"
+        or str(acs.get("acs_version") or "") < "1.2"
     )
     if needs:
         acs = compute_acs_summary(cache)
@@ -1705,8 +1762,8 @@ def get_low_confidence_edges(
     Complements get_unresolved_imports; used for ACS-style hotspots.
     Includes full provenance/diagnostic when present (from python/JS parity).
 
-    actionable_only=True (G4): skip external/bare/stdlib noise so agents do not treat
-    `import json` as a wiki/refactor action item.
+    actionable_only=True (G4/v1.2): skip external/bare/stdlib + dynamic-literal noise so
+    agents do not treat `import json` or importlib.import_module(\"pkg\") as action items.
     """
     results: List[Dict[str, Any]] = []
     for rel, data in cache.items():
@@ -1714,7 +1771,7 @@ def get_low_confidence_edges(
             for p in (data.get("resolved_pairs") or []):
                 if not isinstance(p, dict):
                     continue
-                if actionable_only and _edge_is_external_noise(p):
+                if actionable_only and _edge_is_non_actionable_noise(p):
                     continue
                 score = p.get("confidence_score")
                 conf_str = (p.get("confidence") or p.get("resolution_confidence") or "").lower()
@@ -1727,7 +1784,7 @@ def get_low_confidence_edges(
                 except Exception:
                     is_low = conf_str in ("low", "unresolved")
                 if is_low or not p.get("resolved_path"):
-                    if actionable_only and not p.get("resolved_path") and _edge_is_external_noise(p):
+                    if actionable_only and not p.get("resolved_path") and _edge_is_non_actionable_noise(p):
                         continue
                     entry = dict(p)
                     entry.setdefault("src", rel)
@@ -1855,7 +1912,8 @@ def generate_update_events(
     # Defensive root
     if root is None:
         try:
-            from .cli import discover_project_root
+            # Load-safe: project_root (not cli) — avoids import_cache→cli→import_cache cycle
+            from .project_root import discover_project_root
             root = discover_project_root()
         except Exception:
             root = Path(".").resolve()

{wikifier-4.5.8 → wikifier-4.5.9}/wikifier/parsers/bree.py

@@ -121,8 +121,8 @@ def _get_project_root_fallback(default: Optional[Union[str, Path]] = None) -> Pa
     from subdirs of user monorepos. Safe, zero-dep, never raises.
     """
     try:
-        # parsers/ subpackage -> ..cli
-        from ..cli import discover_project_root
+        # Load-safe: project_root (not cli) — avoids bree→cli→import_cache→bree cycle
+        from ..project_root import discover_project_root
         root = discover_project_root()
         if root:
             return Path(root).resolve()

{wikifier-4.5.8 → wikifier-4.5.9}/wikifier/parsers/javascript.py

@@ -216,7 +216,7 @@ def _get_project_root_fallback(default: Optional[Union[str, Path]] = None) -> Pa
 
     try:
         # inside parsers/ -> ..cli sibling
-        from ..cli import discover_project_root
+        from ..project_root import discover_project_root
         root = discover_project_root()
         if root:
             r = Path(root).resolve()

wikifier-4.5.9/wikifier/project_root.py

@@ -0,0 +1,144 @@
+"""
+Canonical project-root discovery (load-time safe).
+
+AGENT MAP:
+  discover_project_root() — env → markers → cwd (no imports of cli/import_cache/bree)
+  Used by cli (re-export), import_cache, bree, daemon, serve, mcp
+  Extracted so bree/import_cache never import cli (breaks cyclic SCC).
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import List
+
+
+def discover_project_root() -> Path:
+    """
+    Unified discovery helper for the *target project root* (user codebase / monorepo).
+
+    This is the canonical implementation for CLI, MCP, direct Python use, and
+    is mirrored (same priority + markers) by the shell script's discover_project_root().
+
+    Highest-leverage fix for External / Packaged Full-Update Robustness (Gap #1):
+    Makes `pip install wikifier` + `wikifier ...` (or direct packaged sh) reliable
+    from any external monorepo cwd without requiring manual WIKIFIER_PROJECT_ROOT
+    or --target on every invocation. Zero-dependency.
+
+    Wave 3 hardening (symlinks + pnpm/yarn stores):
+    - Consults $PWD (and $OLDPWD) logical cwd in addition to Path.cwd() / .resolve().
+    - Walks parent chains from *logical* start points first; this ensures that when
+      cwd is deep inside a pnpm symlinked store layout (e.g. monorepo/node_modules/.pnpm/pkg@1/.../pkg
+      whose physical target is /global-store/...), the logical ancestor chain still reaches
+      the real project root markers (.git, package.json etc.) outside the store.
+    - Falls back to resolved physical; returns the outermost marker root found.
+    - Prevents packaged/parser/daemon from accidentally using a store dir as PROJECT_ROOT.
+
+    Wave 4 further hardening for complex monorepo layouts:
+    - Collects *all* candidate marker roots across logical/physical/realpath chains (no early return).
+    - Selects the outermost (shallowest fs path) preferring .git roots, then lockfiles (pnpm/yarn), then other.
+      This correctly picks true monorepo root even when deep sub-packages have their own package.json / yarn workspaces.
+    - Expanded common markers: pnpm-lock.yaml, yarn.lock, lerna.json, nx.json, turbo.json, rush.json, workspace yamls.
+    - Explicit skipping of node_modules/.pnpm / .yarn / .pnp internals as candidate roots (even on logical paths).
+    - Additional os.path.realpath chains for nested/broken symlink monorepo layouts.
+    - Daemon, parsers (via _get_*_fallback), run_full_update all inherit automatically.
+    """
+    # 1. Explicit env var (highest priority, supports all the R6 --target flows)
+    env_root = os.environ.get("WIKIFIER_PROJECT_ROOT")
+    if env_root:
+        p = Path(env_root).expanduser().resolve()
+        if p.exists():
+            return p
+
+    # Wave 3/4: logical cwd (PWD/OLDPWD) + physical + realpath fallbacks for symlink/pnpm/yarn/nested
+    cwd = Path.cwd()
+    logical_cwd_str = os.environ.get("PWD") or os.environ.get("OLDPWD") or str(cwd)
+    try:
+        logical_cwd = Path(logical_cwd_str).expanduser()
+    except Exception:
+        logical_cwd = cwd
+
+    start_points: List[Path] = []
+    for start in (logical_cwd, cwd, cwd.resolve()):
+        if start and start not in start_points:
+            start_points.append(start)
+
+    # Wave 4: realpath variants for deeper symlink nest robustness (e.g. git submodules + pnpm links)
+    for sp in list(start_points):
+        try:
+            rp = Path(os.path.realpath(str(sp)))
+            if rp not in start_points:
+                start_points.append(rp)
+        except Exception:
+            continue
+
+    # 2/3. Markers: wikifier-specific + expanded common monorepo (Wave 4)
+    common_markers = [
+        ".git", "package.json", "pyproject.toml", "setup.py", "setup.cfg",
+        "Cargo.toml", "go.mod", ".hg",
+        # Wave 4 monorepo root indicators (for workspace/subpkg layouts + yarn/pnpm detection)
+        "pnpm-lock.yaml", "yarn.lock", "lerna.json", "nx.json", "turbo.json",
+        "rush.json", "workspace.json", "pnpm-workspace.yaml", ".yarnrc.yml"
+    ]
+    store_indicators = (".pnpm", ".yarn", ".pnp", ".pnp.cjs", "virtual-store", ".store")
+
+    candidates: List[Path] = []
+    for start in start_points:
+        try:
+            parent_chain = [start] + list(start.parents)
+        except Exception:
+            parent_chain = [start]
+
+        # Wikifier markers (post-init)
+        for parent in parent_chain:
+            try:
+                pstr = str(parent)
+                if any(ind in pstr for ind in store_indicators) and "node_modules" in pstr:
+                    continue  # never treat deep pnpm/yarn store paths as project root
+                if ((parent / ".wikifier").is_dir() or
+                        (parent / "monitored_paths.txt").exists() or
+                        (parent / ".wikifier/config").exists()):
+                    if parent not in candidates:
+                        candidates.append(parent)
+            except Exception:
+                continue
+
+        # Common + monorepo markers (any-scale external)
+        for parent in parent_chain:
+            try:
+                pstr = str(parent)
+                if any(ind in pstr for ind in store_indicators) and "node_modules" in pstr:
+                    continue
+                for marker in common_markers:
+                    if (parent / marker).exists():
+                        if parent not in candidates:
+                            candidates.append(parent)
+            except Exception:
+                continue
+
+    if candidates:
+        # Wave 4: pick outermost/shallowest, with strong preference for .git (true monorepo root)
+        # even if a deeper packages/*/package.json also matches. Solves workspace subdir case.
+        def _root_key(p: Path):
+            try:
+                rp = p.resolve()
+                has_git = (rp / ".git").exists() or (rp / ".git").is_file()  # worktree support
+                depth = len(rp.parts)
+                return (0 if has_git else 1, depth, str(rp))
+            except Exception:
+                return (99, 99999, str(p))
+
+        best = min(candidates, key=_root_key)
+        try:
+            return best.resolve() if best.exists() else best
+        except Exception:
+            return best
+
+    # 4. Last-resort sensible default: the directory the user is running from.
+    #    This is the key robustness fix vs. old "fall back to package dir".
+    #    Prefer resolved for the final fallback.
+    try:
+        return cwd.resolve()
+    except Exception:
+        return cwd

{wikifier-4.5.8 → wikifier-4.5.9/wikifier.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wikifier
-Version: 4.5.8
+Version: 4.5.9
 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

{wikifier-4.5.8 → wikifier-4.5.9}/wikifier.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ pyproject.toml
 ./wikifier/index.html
 ./wikifier/library.py
 ./wikifier/locking.py
+./wikifier/project_root.py
 ./wikifier/resolution.py
 ./wikifier/serve.py
 ./wikifier/mcp/__init__.py
@@ -54,6 +55,7 @@ wikifier/import_cache.py
 wikifier/index.html
 wikifier/library.py
 wikifier/locking.py
+wikifier/project_root.py
 wikifier/resolution.py
 wikifier/serve.py
 wikifier.egg-info/PKG-INFO