wikifier 4.5.4__tar.gz → 4.5.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wikifier
-Version: 4.5.4
+Version: 4.5.5
 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.4 → wikifier-4.5.5}/tests/test_gap_closure.py

@@ -123,6 +123,72 @@ class TestGhostAndDeletionG7(TempProjectTestCase):
         self.assertIn("🔴", entries["gone.py"]["status"])
         self.assertIn("DELETED", entries["gone.py"]["reason"])
 
+    def test_record_deletion_rejects_flag_paths(self):
+        res = cli.record_deletion("--help", "oops", project_root=self.root)
+        self.assertFalse(res.get("success"))
+        self.assertIn("flag", (res.get("error") or "").lower())
+
+
+class TestPendingAndPollutionHygiene(TempProjectTestCase):
+    def test_pending_empty_marker_not_counted_and_no_dual_state(self):
+        health_mod = importlib.import_module("wikifier.health")
+        # Dual-state pollution (historical bug): empty marker + real items
+        p = self.root / "pending_updates.md"
+        p.write_text(
+            "# Pending Updates\n\n(no active items)\n- src/a.py: review\n",
+            encoding="utf-8",
+        )
+        self.assertEqual(health_mod.count_pending(self.root), 1)
+        # Normalize via remove of the only item → empty marker only
+        health_mod.remove_from_pending(self.root, "src/a.py")
+        text = p.read_text(encoding="utf-8")
+        self.assertIn("no pending", text.lower())
+        self.assertNotIn("- src/a.py", text)
+        self.assertEqual(health_mod.count_pending(self.root), 0)
+        # Add clears empty marker
+        health_mod.add_to_pending(self.root, "src/b.py", "need wiki")
+        text2 = p.read_text(encoding="utf-8")
+        self.assertIn("- src/b.py:", text2)
+        self.assertNotIn("no pending", text2.lower())
+        self.assertNotIn("no active", text2.lower())
+        self.assertEqual(health_mod.count_pending(self.root), 1)
+        summary = health_mod.get_summary(self.root)
+        self.assertEqual(summary["pending_updates"], 1)
+
+    def test_superseded_and_flag_deleted_keys_pruned(self):
+        health_mod = importlib.import_module("wikifier.health")
+        # Inject pollution keys directly then save
+        data = {
+            "version": 2,
+            "last_updated": "2026-01-01",
+            "entries": {
+                "M5.3 Cycle1 evidence append: 3 subs spawned": {
+                    "status": "🔴 Red",
+                    "reason": "DELETED — Historical early M5.3 launch note",
+                    "last_updated": "2026-01-01",
+                },
+                "--help": {
+                    "status": "🔴 Red",
+                    "reason": "DELETED — removed",
+                    "last_updated": "2026-01-01",
+                },
+                "real.py": {
+                    "status": "🟢 Green",
+                    "reason": "ok",
+                    "last_updated": "2026-01-01",
+                },
+            },
+        }
+        health_mod.save_health(self.root, data)
+        entries = health_mod.load_health(self.root)["entries"]
+        self.assertNotIn("M5.3 Cycle1 evidence append: 3 subs spawned", entries)
+        self.assertNotIn("--help", entries)
+        self.assertIn("real.py", entries)
+        # Real path DELETED audit is kept
+        health_mod.upsert_entry(self.root, "gone_real.py", "🔴 Red", "DELETED — intentional")
+        entries2 = health_mod.load_health(self.root)["entries"]
+        self.assertIn("gone_real.py", entries2)
+
 
 if __name__ == "__main__":
     unittest.main()

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

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

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

@@ -805,16 +805,40 @@ def main():
                 if res.get("message"):
                     print(res["message"])
                 return 0 if res.get("success", True) else 1
-            if _cmd0 == "record-change" and len(_args) >= 2:
+            if _cmd0 == "record-change":
+                if not _args or _args[0] in ("--help", "-h", "help"):
+                    print('Usage: wikifier record-change <file> "<reason>"')
+                    return 0
+                if _args[0].startswith("-") or len(_args) < 2:
+                    print('Usage: wikifier record-change <file> "<reason>"', file=sys.stderr)
+                    return 1
                 res = record_change(_args[0], " ".join(_args[1:]), project_root=project_root)
                 print(res.get("message") or res)
                 return 0 if res.get("success") else 1
-            if _cmd0 == "mark-green" and len(_args) >= 1:
+            if _cmd0 == "mark-green":
+                if not _args or _args[0] in ("--help", "-h", "help"):
+                    print("Usage: wikifier mark-green <file> [reason]")
+                    return 0
+                if _args[0].startswith("-"):
+                    print("Usage: wikifier mark-green <file> [reason]", file=sys.stderr)
+                    return 1
                 reason = " ".join(_args[1:]) if len(_args) > 1 else ""
                 res = mark_green(_args[0], reason, project_root=project_root)
                 print(res.get("message") or res)
                 return 0 if res.get("success") else 1
-            if _cmd0 == "record-deletion" and len(_args) >= 1:
+            if _cmd0 == "record-deletion":
+                # Guard: `record-deletion --help` must not treat `--help` as a file path
+                # (that polluted health with a 🔴 DELETED "--help" key).
+                if not _args or _args[0] in ("--help", "-h", "help"):
+                    print('Usage: wikifier record-deletion <file> "<reason>"')
+                    return 0
+                if _args[0].startswith("-"):
+                    print(
+                        'Usage: wikifier record-deletion <file> "<reason>"\n'
+                        "  <file> must be a project path, not a flag.",
+                        file=sys.stderr,
+                    )
+                    return 1
                 reason = " ".join(_args[1:]) if len(_args) > 1 else "removed"
                 res = record_deletion(_args[0], reason, project_root=project_root)
                 print(res.get("message") or res)
@@ -1039,8 +1063,14 @@ def _ensure_journal_entry(root: Path, action: str, file: str, reason: str) -> No
 
 
 def _add_to_pending(root: Path, file: str, msg: str) -> None:
-    """Pure-Py pending_updates.md appender (skeleton, matches sh add_pending)."""
+    """Append to pending_updates.md via health helpers (normalized empty/items)."""
     try:
+        if _health_mod is not None and hasattr(_health_mod, "add_to_pending"):
+            # Caller may already hold project lock (re-entrant).
+            _health_mod._do_add_to_pending(root, file, msg) if hasattr(
+                _health_mod, "_do_add_to_pending"
+            ) else _health_mod.add_to_pending(root, file, msg)
+            return
         p = root / "pending_updates.md"
         line = f"- {file}: {msg}\n"
         with open(p, "a", encoding="utf-8") as f:
@@ -1050,8 +1080,14 @@ def _add_to_pending(root: Path, file: str, msg: str) -> None:
 
 
 def _remove_from_pending(root: Path, file: str) -> None:
-    """Best-effort removal (used by mark_green skeleton)."""
+    """Best-effort removal (used by mark_green). Prefers health normalizer."""
     try:
+        if _health_mod is not None and hasattr(_health_mod, "_do_remove_from_pending"):
+            _health_mod._do_remove_from_pending(root, file)
+            return
+        if _health_mod is not None and hasattr(_health_mod, "remove_from_pending"):
+            _health_mod.remove_from_pending(root, file)
+            return
         p = root / "pending_updates.md"
         if p.exists():
             lines = [ln for ln in p.read_text(encoding="utf-8").splitlines() if file not in ln]
@@ -1265,9 +1301,13 @@ def record_deletion(file: str, reason: str, project_root: Optional[Union[str, Pa
 
     G7: marks 🔴 DELETED, pending + journal, and best-effort prunes barrel cache
     references so deleted paths do not keep invalidating importers forever.
+    Rejects flag-like paths (`--help`) so CLI misuse cannot pollute health.
     """
     root = _get_effective_root(project_root)
     result: Dict[str, Any] = {"success": False, "file": file, "project_root": str(root), "action": "deletion"}
+    if not file or str(file).startswith("-") or str(file) in ("--help", "-h", "help"):
+        result["error"] = "file must be a project path, not a flag/empty string"
+        return result
     try:
         lock_ctx = (locking.file_lock(root) if locking is not None else _nullcontext())
         with lock_ctx:
@@ -1279,7 +1319,11 @@ def record_deletion(file: str, reason: str, project_root: Optional[Union[str, Pa
             except Exception:
                 rel = file
             if _health_mod is not None:
-                _health_mod.upsert_entry(root, rel, "🔴 Red", f"DELETED — {reason}")
+                # Prefer unlocked upsert when we already hold the project lock.
+                if hasattr(_health_mod, "_do_upsert_entry"):
+                    _health_mod._do_upsert_entry(root, rel, "🔴 Red", f"DELETED — {reason}")
+                else:
+                    _health_mod.upsert_entry(root, rel, "🔴 Red", f"DELETED — {reason}")
             _add_to_pending(root, rel, f"File was deleted. Consider wiki archival. {reason}")
             _ensure_journal_entry(root, "record-deletion", rel, reason or "No reason provided.")
             prune_stats: Dict[str, Any] = {}

{wikifier-4.5.4 → wikifier-4.5.5}/wikifier/health.py

@@ -64,13 +64,60 @@ def _coerce_root(root) -> Path:
 
 
 # Post-v4.0 + M5.3 gate complete + cleanup hygiene:
-# Aggressively prune superseded historical wiki-note entries (e.g. early "M5.3 Cycle1 evidence append (from early coord, before alt gate pass)")
-# that survive under-root checks because they live under "Findings/" but are not maintained agent reference docs (Progress etc).
-# These pollute the health matrix / pending_updates that agents use for token-efficient lookup.
-# Keep real M5 docs (Progress, Milestones, Assessment, p6, M5.1-cross) + current gate/4.0 records.
-# Explicit Red "DELETED" audit records from record-deletion are intentionally kept (1 non-Green historical marker is useful/observable).
+# Aggressively prune superseded historical wiki-note entries (e.g. early "M5.3 Cycle1 evidence append …")
+# that are free-form note keys, not real project paths. These pollute the health matrix that agents use.
+# Keep real M5 docs (Progress, Milestones, Assessment, p6, M5.1-cross).
+# Real path deletions via record-deletion (e.g. "src/foo.py" + 🔴 DELETED) stay as audit rows.
+# Free-form DELETED non-path keys (e.g. accidental `record-deletion --help`) are always pruned.
 SUPERSEDED_PATTERNS = ["m5.3 cycle1", "cycle1 evidence append", "early m5.3 launch note", "m5.3 cycle1 evidence"]
 
+# Path-like health keys (real files we may keep as DELETED audits). Everything else that is
+# already DELETED and not path-shaped is pollution.
+_SOURCE_SUFFIXES = (
+    ".py", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs", ".md", ".json",
+    ".sh", ".toml", ".yaml", ".yml", ".html", ".css", ".rs", ".go", ".java",
+    ".cs", ".c", ".h", ".cpp", ".hpp", ".cc",
+)
+
+
+def _looks_like_path_key(key: str) -> bool:
+    """True if health key looks like a project-relative or absolute file path."""
+    if not key or not isinstance(key, str):
+        return False
+    if key.startswith(("-", "--")):
+        return False
+    if "/" in key or "\\" in key:
+        return True
+    return key.endswith(_SOURCE_SUFFIXES)
+
+
+def _is_pollution_health_key(key: str, entry: Optional[Dict[str, Any]] = None) -> bool:
+    """Keys that must never remain in the agent-facing health matrix."""
+    if not isinstance(key, str) or not key:
+        return True
+    kl = key.lower()
+    if any(p in kl for p in SUPERSEDED_PATTERNS):
+        return True
+    ent = entry or {}
+    reason = str(ent.get("reason") or "")
+    status = str(ent.get("status") or "")
+    # Accidental flag keys / free-form notes already marked DELETED (not real paths).
+    if not _looks_like_path_key(key) and ("DELETED" in reason or "DELETED" in status):
+        return True
+    return False
+
+
+def _prune_entries(root: Path, entries: Dict[str, Any]) -> Dict[str, Any]:
+    """Drop out-of-tree pollution + superseded free-form note keys."""
+    pruned: Dict[str, Any] = {}
+    for k, v in (entries or {}).items():
+        if not _entry_is_under_root(root, k):
+            continue
+        if _is_pollution_health_key(k, v if isinstance(v, dict) else None):
+            continue
+        pruned[k] = v
+    return pruned
+
 
 def _get_health_path(root: "str | Path") -> Path:
     root = _coerce_root(root)
@@ -273,23 +320,9 @@ def load_health(root: "str | Path") -> Dict[str, Any]:
         data["entries"] = normalized_entries
         if version < 2:
             data["version"] = 2  # mark for future save; additive, no breakage
-        # M5 dogfood fix: immediately drop any out-of-tree pollution entries persisted from
-        # prior bad cross-project or cwd-mismatched runs (e.g. worktree paths in external targets).
-        # Views (get_*) will be clean; next save will persist pruned json.
-        entries = data.get("entries", {}) or {}
-        pruned = {k: v for k, v in entries.items() if _entry_is_under_root(root, k)}
-        # Post-v4.0 superseded historical prune (see SUPERSEDED_PATTERNS at top).
-        # Leave explicit Red DELETED audit records (they are the agent-visible archival marker).
-        for k in list(pruned.keys()):
-            kl = str(k).lower()
-            if any(p in kl for p in SUPERSEDED_PATTERNS):
-                ent = pruned.get(k, {})
-                status = str(ent.get("status", ""))
-                reason = str(ent.get("reason", "")).lower()
-                if status.startswith("🔴") and ("deleted" in reason or "superseded" in reason):
-                    continue  # keep the audit Red
-                del pruned[k]
-        data["entries"] = pruned
+        # M5 dogfood fix: drop out-of-tree + free-form superseded/DELETED pollution.
+        # Views (get_*) are clean; next save persists pruned json.
+        data["entries"] = _prune_entries(root, data.get("entries", {}) or {})
         return data
 
     # Migration path: if JSON doesn't exist but MD does
@@ -306,20 +339,7 @@ def load_health(root: "str | Path") -> Dict[str, Any]:
                 norm[k] = _normalize_health_entry_local(v)
         migrated["entries"] = norm
         migrated["version"] = 2
-        # M5: prune pollution on migrate too (same as json path)
-        entries = migrated.get("entries", {}) or {}
-        pruned = {k: v for k, v in entries.items() if _entry_is_under_root(root, k)}
-        # Post-v4.0 superseded historical prune (see SUPERSEDED_PATTERNS at top).
-        for k in list(pruned.keys()):
-            kl = str(k).lower()
-            if any(p in kl for p in SUPERSEDED_PATTERNS):
-                ent = pruned.get(k, {})
-                status = str(ent.get("status", ""))
-                reason = str(ent.get("reason", "")).lower()
-                if status.startswith("🔴") and ("deleted" in reason or "superseded" in reason):
-                    continue
-                del pruned[k]
-        migrated["entries"] = pruned
+        migrated["entries"] = _prune_entries(root, migrated.get("entries", {}) or {})
         return migrated
 
     # Fresh project (start at v2 with Health B fields ready)
@@ -350,21 +370,9 @@ def _do_save_health(root: "str | Path", health_data: Dict[str, Any]) -> None:
     health_data["last_updated"] = _timestamp()
     health_data["version"] = 2  # B durable: ensure v2 on every save (additive fields)
 
-    # M5: always prune out-of-tree on save so target's file_health.json stays clean forever
+    # M5: always prune out-of-tree + free-form pollution so file_health.json stays clean
     if "entries" in health_data:
-        entries = health_data.get("entries") or {}
-        pruned = {k: v for k, v in entries.items() if _entry_is_under_root(root, k)}
-        # Post-v4.0 superseded historical prune (see SUPERSEDED_PATTERNS at top).
-        for k in list(pruned.keys()):
-            kl = str(k).lower()
-            if any(p in kl for p in SUPERSEDED_PATTERNS):
-                ent = pruned.get(k, {})
-                status = str(ent.get("status", ""))
-                reason = str(ent.get("reason", "")).lower()
-                if status.startswith("🔴") and ("deleted" in reason or "superseded" in reason):
-                    continue
-                del pruned[k]
-        health_data["entries"] = pruned
+        health_data["entries"] = _prune_entries(root, health_data.get("entries") or {})
 
     with open(json_path, "w", encoding="utf-8") as f:
         json.dump(health_data, f, indent=2, ensure_ascii=False)
@@ -450,11 +458,9 @@ def _do_upsert_entry(root: "str | Path", file: str, status: str, reason: str = "
     file = _normalize_to_relative(root, file)
     if not _entry_is_under_root(root, file):
         return
-    # Post-v4.0: skip superseded historical names (unless this is explicitly recording a Red DELETED audit).
-    kl = file.lower()
-    if any(p in kl for p in SUPERSEDED_PATTERNS):
-        if not (status.startswith("🔴") and ("deleted" in reason.lower() or "superseded" in reason.lower())):
-            return
+    # Never re-introduce free-form superseded notes or flag-key pollution.
+    if _is_pollution_health_key(file, {"status": status, "reason": reason}):
+        return
     health = load_health(root)
     existing = health.get("entries", {}).get(file, {})
     # Start from normalized existing to keep B fields
@@ -479,40 +485,74 @@ def _do_upsert_entry(root: "str | Path", file: str, status: str, reason: str = "
 # These ensure pending_updates.md mutations are atomic with health under the project lock
 # (per locking.py contract). Eliminates races/duplicates with add_pending from shell/monitor.
 
+_EMPTY_PENDING_MARKER = "(no pending items — run check-changes after making edits)"
+_EMPTY_PENDING_LINES = [
+    "# Pending Updates",
+    "",
+    _EMPTY_PENDING_MARKER,
+]
+
+
 def _get_pending_path(root: Path) -> Path:
     return root / PENDING_MD
 
 
+def _is_pending_item_line(ln: str) -> bool:
+    """True for real work-queue bullets (`- path: msg`), not headers/empty markers."""
+    s = (ln or "").strip()
+    return s.startswith("- ") and not s.startswith("- (")
+
+
+def _is_empty_pending_marker(ln: str) -> bool:
+    s = (ln or "").strip().lower()
+    if not s or s.startswith("#"):
+        return False
+    return "no pending" in s or "no active items" in s or s == _EMPTY_PENDING_MARKER.lower()
+
+
+def _pending_item_lines(lines: List[str]) -> List[str]:
+    return [ln for ln in lines if _is_pending_item_line(ln)]
+
+
+def _normalize_pending_lines(lines: List[str]) -> List[str]:
+    """Canonical pending_updates.md: header + empty marker XOR bullet list (never both)."""
+    items = _pending_item_lines(lines or [])
+    if not items:
+        return list(_EMPTY_PENDING_LINES)
+    seen = set()
+    uniq: List[str] = []
+    for it in items:
+        if it not in seen:
+            seen.add(it)
+            uniq.append(it)
+    return ["# Pending Updates", ""] + uniq
+
+
 def _read_pending_lines(root: Path) -> List[str]:
     """Read pending file as list of lines; return sensible default header if missing."""
     p = _get_pending_path(root)
     if not p.exists():
-        return [
-            "# Pending Updates",
-            "",
-            "(no pending items — run check-changes after making edits)"
-        ]
+        return list(_EMPTY_PENDING_LINES)
     try:
         with open(p, "r", encoding="utf-8") as f:
             return f.read().splitlines(keepends=False)
     except Exception:
-        # On read error, conservative: return current content best effort or default
-        return ["# Pending Updates", "", "(no pending items — run check-changes after making edits)"]
+        return list(_EMPTY_PENDING_LINES)
 
 
 def _write_pending_lines(root: Path, lines: List[str]) -> None:
-    """Atomic-ish write of pending (tmp + mv for safety on most FS)."""
+    """Atomic-ish write of pending (tmp + mv). Always normalized (no dual empty+items)."""
     p = _get_pending_path(root)
     p.parent.mkdir(parents=True, exist_ok=True)
+    normalized = _normalize_pending_lines(lines)
     tmp = p.with_suffix(".tmp")
     try:
         with open(tmp, "w", encoding="utf-8") as f:
-            f.write("\n".join(lines) + "\n")
-        os.replace(tmp, p)  # atomic rename on POSIX
+            f.write("\n".join(normalized) + "\n")
+        os.replace(tmp, p)
     except Exception:
-        # Fallback direct write
         with open(p, "w", encoding="utf-8") as f:
-            f.write("\n".join(lines) + "\n")
+            f.write("\n".join(normalized) + "\n")
         try:
             if tmp.exists():
                 tmp.unlink()
@@ -520,13 +560,19 @@ def _write_pending_lines(root: Path, lines: List[str]) -> None:
             pass
 
 
+def count_pending(root: Path) -> int:
+    """Count real pending work items (bullet lines only; empty markers ignored)."""
+    return len(_pending_item_lines(_read_pending_lines(root)))
+
+
 def _do_remove_from_pending(root: Path, file: str) -> int:
-    """Internal: idempotent remove of any lines containing file (fixed-string, like grep -vF)."""
+    """Internal: idempotent remove of any item lines containing file (fixed-string)."""
     lines = _read_pending_lines(root)
-    new_lines = [ln for ln in lines if file not in ln]
-    removed = len(lines) - len(new_lines)
-    if removed > 0:
-        _write_pending_lines(root, new_lines)
+    items_before = _pending_item_lines(lines)
+    new_items = [ln for ln in items_before if file not in ln]
+    removed = len(items_before) - len(new_items)
+    # Always rewrite so dual "(no active)" + items and stale markers get fixed.
+    _write_pending_lines(root, new_items)
     return removed
 
 
@@ -540,12 +586,13 @@ def remove_from_pending(root: Path, file: str) -> int:
 
 
 def _do_add_to_pending(root: Path, file: str, msg: str) -> None:
-    """Internal add (idempotent: no exact dup entry)."""
+    """Internal add (idempotent). Strips empty markers when real items exist."""
     lines = _read_pending_lines(root)
     entry = f"- {file}: {msg}"
-    if entry not in lines:
-        lines.append(entry)
-        _write_pending_lines(root, lines)
+    items = _pending_item_lines(lines)
+    if entry not in items:
+        items.append(entry)
+    _write_pending_lines(root, items)
 
 
 def add_to_pending(root: Path, file: str, msg: str) -> None:
@@ -875,12 +922,16 @@ def get_summary(root: Path, directory: Optional[str] = None, include_stale: bool
         elif "🔴" in status:
             red += 1
 
+    try:
+        pending_n = count_pending(root)
+    except Exception:
+        pending_n = 0
     out = {
         "total": total,
         "green": green,
         "yellow": yellow,
         "red": red,
-        "pending_updates": 0,
+        "pending_updates": pending_n,
         "directory": directory or ".",
         "version": health.get("version", 2),
         "last_updated": health.get("last_updated")

{wikifier-4.5.4 → wikifier-4.5.5}/wikifier/mcp/server.py

@@ -1644,7 +1644,13 @@ def get_project_status(
         summary = health_module.get_summary(root, directory)
         pending = _read_file_safe("pending_updates.md", root=root)
 
-        pending_count = len([l for l in pending.splitlines() if l.strip() and not l.startswith("#")])
+        if hasattr(health_module, "count_pending"):
+            pending_count = int(health_module.count_pending(root))
+        else:
+            pending_count = len([
+                l for l in pending.splitlines()
+                if l.strip().startswith("- ") and not l.strip().startswith("- (")
+            ])
 
         # ACS + CIABRE + Wave 2 Barrel/BRC surfacing uniformity: lightweight stats + invalidation reports foundation in project status (MCP primary for agents)
         dep_intel = {}
@@ -1770,7 +1776,13 @@ Use get_files_needing_attention() for the actual list. Use get_cycles(analysis=T
         # yielded zeros and lied to agents.
         root = _get_effective_root(project_root)
         pending = _read_file_safe("pending_updates.md", root=root)
-        pending_count = len([l for l in pending.splitlines() if l.strip() and not l.startswith("#")])
+        if hasattr(health_module, "count_pending"):
+            pending_count = int(health_module.count_pending(root))
+        else:
+            pending_count = len([
+                l for l in pending.splitlines()
+                if l.strip().startswith("- ") and not l.strip().startswith("- (")
+            ])
         green = yellow = red = total = 0
         try:
             import importlib

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

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