ki-manager 2.3.1__tar.gz → 2.3.2.dev1__tar.gz

{ki_manager-2.3.1 → ki_manager-2.3.2.dev1}/CHANGELOG.md

@@ -9,6 +9,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.3.2.dev1] — 2026-10-20
+
+### Fixed
+- **`find_unmapped_files` Traversal & Scoping**:
+  - Automatically loads and enforces `.gitignore` patterns and `doc_config.json` `exclude` rules (in addition to `exclude_patterns`) during repository discovery.
+  - When scanning repository root by default, scopes file discovery to root segments of configured `tracked_modules`, avoiding timeouts and runaway directory walks across large external data trees.
+  - Made the CLI `path` argument optional, defaulting to root / tracked modules.
+- **`check_ki_drift` Markdown Table Header Validation**:
+  - Validates Markdown table headers explicitly for file path columns (`File`, `Path`, `Source`, `Location`) before inspecting cells for broken paths.
+  - Tables without file columns (e.g. `| Tool | Access | Purpose |`) are cleanly bypassed, eliminating false-positive `Missing file: Access` errors.
+
 ## [2.3.1] — 2026-10-18
 
 ### Security & Hardening

{ki_manager-2.3.1 → ki_manager-2.3.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ki-manager
-Version: 2.3.1
+Version: 2.3.2.dev1
 Summary: Knowledge Item (KI) management MCP server for AI-assisted development
 Project-URL: Homepage, https://github.com/Laeryid/KI-base
 Project-URL: Repository, https://github.com/Laeryid/KI-base

{ki_manager-2.3.1 → ki_manager-2.3.2.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ki-manager"
-version = "2.3.1"
+version = "2.3.2.dev1"
 description = "Knowledge Item (KI) management MCP server for AI-assisted development"
 readme = "README.md"
 license = { file = "LICENSE" }

{ki_manager-2.3.1 → ki_manager-2.3.2.dev1}/src/ki_manager/__init__.py

@@ -1,3 +1,3 @@
 
 """ki-manager — Knowledge Item MCP server for AI-assisted development."""
-__version__ = "2.3.1"
+__version__ = "2.3.2.dev1"

{ki_manager-2.3.1 → ki_manager-2.3.2.dev1}/src/ki_manager/scripts/check_ki_drift.py

@@ -76,31 +76,87 @@ def parse_ki_file(ki_path: Path) -> Dict[str, Any]:
 
     # Extract Key Components table symbols
     # Expected table format: | `SymbolName` | `rel/path/file.ext` | Purpose |
+    # Only tables that explicitly contain a File/Path column header are inspected.
     table_symbols: List[Dict[str, str]] = []
     in_key_components = False
-    table_row_pattern = re.compile(r"\|\s*`?([A-Za-z0-9_]+)`?\s*\|\s*`?([^`|\s]+)`?\s*\|")
+    pending_header: Optional[List[str]] = None
+    current_table_active = False
+    sym_idx = -1
+    file_idx = -1
 
     for line in lines:
         if line.startswith("## Key Components"):
             in_key_components = True
+            pending_header = None
+            current_table_active = False
             continue
         elif in_key_components and line.startswith("## "):
             in_key_components = False
+            pending_header = None
+            current_table_active = False
             continue
 
-        if in_key_components and line.strip().startswith("|"):
-            lower = line.lower()
-            if any(k in lower for k in ["class / function", "component", "|---", "|:---", "| — |", "| - |"]):
-                continue
-            m = table_row_pattern.search(line)
-            if m:
-                sym_name = m.group(1).strip()
-                file_rel = m.group(2).strip()
-                header_keywords = {"component", "file", "purpose", "class", "function", "description"}
-                if sym_name.lower() in header_keywords or file_rel.lower() in header_keywords:
-                    continue
-                if sym_name and file_rel and not file_rel.startswith("—"):
-                    table_symbols.append({"symbol": sym_name, "file": file_rel})
+        if not in_key_components:
+            continue
+
+        stripped = line.strip()
+        if not stripped.startswith("|"):
+            pending_header = None
+            current_table_active = False
+            continue
+
+        raw_cells = [c.strip() for c in stripped.strip("|").split("|")]
+        # Check if separator row (e.g. |---|---| or |:---|---:|)
+        is_separator = (
+            len(raw_cells) > 0
+            and all(re.match(r"^:?-{2,}:?$", c) for c in raw_cells if c)
+        )
+
+        if is_separator:
+            if pending_header:
+                file_idx = -1
+                for i, col in enumerate(pending_header):
+                    col_lower = col.lower()
+                    if any(w in col_lower for w in ["file", "path", "source", "location"]):
+                        file_idx = i
+                        break
+
+                sym_idx = -1
+                for i, col in enumerate(pending_header):
+                    if i == file_idx:
+                        continue
+                    col_lower = col.lower()
+                    if any(w in col_lower for w in ["class", "function", "symbol", "component", "name", "element", "method", "tool"]):
+                        sym_idx = i
+                        break
+
+                if sym_idx == -1 and file_idx != -1:
+                    sym_idx = 0 if file_idx != 0 else 1
+
+                current_table_active = (file_idx != -1 and sym_idx != -1)
+                pending_header = None
+            continue
+
+        if pending_header is None and not current_table_active:
+            # Possible header row
+            pending_header = raw_cells
+            continue
+
+        if current_table_active:
+            if len(raw_cells) > max(sym_idx, file_idx):
+                sym_val = raw_cells[sym_idx].strip(" `").strip()
+                file_val = raw_cells[file_idx].strip(" `").strip()
+                header_keywords = {"component", "file", "path", "purpose", "class", "function", "description", "tool", "access"}
+                if (
+                    sym_val
+                    and file_val
+                    and not sym_val.startswith("—")
+                    and not file_val.startswith("—")
+                    and not file_val.startswith("-")
+                    and sym_val.lower() not in header_keywords
+                    and file_val.lower() not in header_keywords
+                ):
+                    table_symbols.append({"symbol": sym_val, "file": file_val})
 
     # Extract wiki-links [[KI_*.md]]
     wiki_links = []

ki_manager-2.3.2.dev1/src/ki_manager/scripts/find_unmapped_files.py

@@ -0,0 +1,143 @@
+import os
+import sys
+import argparse
+import json
+from pathlib import Path
+from typing import List
+
+# Add path to ki_utils
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ki_utils
+
+
+def _scan_path(target_path: str, project_root: str, mapped_paths: set, exclude_patterns: set, ignored_exts: set) -> List[str]:
+    abs_target = os.path.abspath(os.path.join(project_root, target_path))
+    if not ki_utils.is_subpath(abs_target, project_root) or not os.path.exists(abs_target):
+        return []
+
+    unmapped = []
+    if os.path.isfile(abs_target):
+        rel_to_project = os.path.relpath(abs_target, project_root).replace("\\", "/")
+        fname = os.path.basename(abs_target)
+        if fname.startswith(".") or any(fname.endswith(ext) for ext in ignored_exts):
+            return []
+        if ki_utils.should_exclude(fname, rel_to_project, exclude_patterns):
+            return []
+        if abs_target in mapped_paths:
+            return []
+        for mapped in mapped_paths:
+            if os.path.isdir(mapped) and abs_target.startswith(os.path.join(mapped, "")):
+                return []
+        return [rel_to_project]
+
+    for root, dirs, files in os.walk(abs_target):
+        dirs[:] = [
+            d for d in dirs
+            if not d.startswith(".")
+            and not ki_utils.should_exclude(d, os.path.relpath(os.path.join(root, d), project_root), exclude_patterns)
+        ]
+
+        for f in files:
+            if f.startswith(".") or any(f.endswith(ext) for ext in ignored_exts):
+                continue
+
+            full_path = os.path.abspath(os.path.join(root, f))
+            rel_to_project = os.path.relpath(full_path, project_root).replace("\\", "/")
+            if ki_utils.should_exclude(f, rel_to_project, exclude_patterns):
+                continue
+
+            if full_path in mapped_paths:
+                continue
+
+            is_parent_mapped = False
+            for mapped in mapped_paths:
+                if os.path.isdir(mapped):
+                    if full_path.startswith(os.path.join(mapped, "")):
+                        is_parent_mapped = True
+                        break
+
+            if not is_parent_mapped:
+                unmapped.append(rel_to_project)
+
+    return unmapped
+
+
+def get_unmapped_files(target_path: str = ".") -> List[str]:
+    """Returns a sorted list of unmapped files relative to project root."""
+    project_root = ki_utils.get_project_root()
+    doc_config = ki_utils.get_doc_config()
+
+    if not project_root or not doc_config:
+        return []
+
+    # 1. Collect all files that are already mapped in doc_config.json
+    mapped_paths = set()
+    knowledge_items = doc_config.get("knowledge_items", {})
+
+    for ki in knowledge_items.values():
+        depends_on = ki.get("depends_on", [])
+        for p in depends_on:
+            abs_p = os.path.abspath(os.path.join(project_root, p))
+            mapped_paths.add(abs_p)
+
+    ignored_exts = {'.pyc', '.pyo', '.pyd', '.obj', '.dll', '.exe', '.bin'}
+    exclude_patterns = ki_utils.get_exclude_patterns()
+
+    norm_target = (target_path or ".").strip()
+
+    # If target is root/empty, scope to tracked_modules if defined
+    if norm_target in (".", ""):
+        tracked_modules = doc_config.get("coverage_settings", {}).get("tracked_modules") or doc_config.get("tracked_modules", [])
+        target_dirs = set()
+        if isinstance(tracked_modules, list) and tracked_modules:
+            for m in tracked_modules:
+                mod_path = m[0] if isinstance(m, (list, tuple)) else m
+                if isinstance(mod_path, str) and mod_path.strip():
+                    norm_p = mod_path.replace("\\", "/").strip("/")
+                    top_segment = norm_p.split("/")[0] if "/" in norm_p else norm_p
+                    if top_segment:
+                        target_dirs.add(top_segment)
+
+        if target_dirs:
+            unmapped_set = set()
+            for td in sorted(target_dirs):
+                unmapped_set.update(_scan_path(td, project_root, mapped_paths, exclude_patterns, ignored_exts))
+            return sorted(unmapped_set)
+        else:
+            return sorted(_scan_path(".", project_root, mapped_paths, exclude_patterns, ignored_exts))
+
+    return sorted(_scan_path(norm_target, project_root, mapped_paths, exclude_patterns, ignored_exts))
+
+
+def find_unmapped_files(target_path: str = "."):
+    project_root = ki_utils.get_project_root()
+    doc_config = ki_utils.get_doc_config()
+
+    if not project_root or not doc_config:
+        print("Error: Could not resolve project root or doc_config.json")
+        return
+
+    display_target = (target_path or ".").strip()
+    if display_target != ".":
+        abs_target = os.path.abspath(os.path.join(project_root, display_target))
+        if not os.path.exists(abs_target):
+            print(f"Error: Target path '{display_target}' does not exist.")
+            return
+
+    unmapped = get_unmapped_files(display_target)
+    if unmapped:
+        print(f"### Unmapped Files in '{display_target}':")
+        for f in unmapped:
+            print(f"- {f}")
+    else:
+        print(f"All files in '{display_target}' are already mapped in doc_config.json.")
+
+
+if __name__ == "__main__":
+    if sys.platform == "win32":
+        sys.stdout.reconfigure(encoding="utf-8")
+    parser = argparse.ArgumentParser(description="Find files in a directory not covered by any KI in doc_config.json")
+    parser.add_argument("path", nargs="?", default=".", help="Relative path from project root to scan (default: tracked_modules or .)")
+    args = parser.parse_args()
+
+    find_unmapped_files(args.path)

{ki_manager-2.3.1 → ki_manager-2.3.2.dev1}/src/ki_manager/scripts/ki_utils.py

@@ -335,6 +335,34 @@ def get_local_config() -> dict:
     return {}
 
 
+def load_gitignore_patterns(project_root: str = None) -> set:
+    """Parses .gitignore file in project_root if present, returning a set of pattern strings."""
+    if not project_root:
+        project_root = get_project_root()
+    if not project_root or not os.path.isdir(project_root):
+        return set()
+
+    gitignore_path = os.path.join(project_root, ".gitignore")
+    if not os.path.isfile(gitignore_path):
+        return set()
+
+    patterns = set()
+    try:
+        with open(gitignore_path, "r", encoding="utf-8", errors="replace") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#") or line.startswith("!"):
+                    continue
+                norm = line.replace("\\", "/").rstrip("/")
+                if norm.startswith("/"):
+                    norm = norm.lstrip("/")
+                if norm:
+                    patterns.add(norm)
+    except Exception:
+        pass
+    return patterns
+
+
 DEFAULT_EXCLUDED_DIRS = {
     ".git", "__pycache__", "node_modules", ".venv", "venv", "dist", "build",
     ".mypy_cache", ".pytest_cache", ".ruff_cache",
@@ -344,33 +372,45 @@ DEFAULT_EXCLUDED_DIRS = {
 def get_exclude_patterns() -> set:
     """
     Returns the set of directory/file exclude patterns.
-    Combines default excluded dirs with exclude_patterns from:
+    Combines default excluded dirs with exclude_patterns and exclude from:
     1. config.json (machine-specific)
-    2. doc_config.json (coverage_settings.exclude_patterns or top-level exclude_patterns)
+    2. doc_config.json (coverage_settings.exclude_patterns, coverage_settings.exclude,
+       top-level exclude_patterns, top-level exclude)
     3. ki_config.json
+    4. .gitignore in project root
     """
     patterns = set(DEFAULT_EXCLUDED_DIRS)
 
+    def _add_from_cfg(cfg_dict, key):
+        val = cfg_dict.get(key, [])
+        if isinstance(val, list):
+            for p in val:
+                if p:
+                    patterns.add(str(p))
+        elif isinstance(val, str) and val:
+            patterns.add(val)
+
     # 1. config.json
     local_cfg = get_local_config()
-    for p in local_cfg.get("exclude_patterns", []):
-        if p:
-            patterns.add(str(p))
+    _add_from_cfg(local_cfg, "exclude_patterns")
+    _add_from_cfg(local_cfg, "exclude")
 
     # 2. doc_config.json
     doc_cfg = get_doc_config()
-    for p in doc_cfg.get("exclude_patterns", []):
-        if p:
-            patterns.add(str(p))
-    for p in doc_cfg.get("coverage_settings", {}).get("exclude_patterns", []):
-        if p:
-            patterns.add(str(p))
+    _add_from_cfg(doc_cfg, "exclude_patterns")
+    _add_from_cfg(doc_cfg, "exclude")
+    cov_cfg = doc_cfg.get("coverage_settings", {})
+    if isinstance(cov_cfg, dict):
+        _add_from_cfg(cov_cfg, "exclude_patterns")
+        _add_from_cfg(cov_cfg, "exclude")
 
     # 3. ki_config.json
     ki_cfg = get_ki_cfg()
-    for p in ki_cfg.get("exclude_patterns", []):
-        if p:
-            patterns.add(str(p))
+    _add_from_cfg(ki_cfg, "exclude_patterns")
+    _add_from_cfg(ki_cfg, "exclude")
+
+    # 4. .gitignore
+    patterns.update(load_gitignore_patterns())
 
     return patterns
 
@@ -389,15 +429,17 @@ def should_exclude(name: str, rel_path: str = "", patterns: set = None) -> bool:
     norm_rel = rel_path.replace("\\", "/").strip("/") if rel_path else ""
 
     for pat in patterns:
-        if fnmatch.fnmatch(name, pat):
+        norm_pat = pat.replace("\\", "/").strip("/")
+        if not norm_pat:
+            continue
+        if fnmatch.fnmatch(name, norm_pat):
             return True
         if norm_rel:
-            norm_pat = pat.replace("\\", "/").strip("/")
             if norm_rel == norm_pat or norm_rel.startswith(norm_pat + "/"):
                 return True
             if fnmatch.fnmatch(norm_rel, norm_pat):
                 return True
-            if any(fnmatch.fnmatch(comp, pat) for comp in norm_rel.split("/")):
+            if any(fnmatch.fnmatch(comp, norm_pat) for comp in norm_rel.split("/")):
                 return True
 
     return False

ki_manager-2.3.1/src/ki_manager/scripts/find_unmapped_files.py

@@ -1,101 +0,0 @@
-import os
-import sys
-import argparse
-import json
-from pathlib import Path
-from typing import List
-
-# Add path to ki_utils
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import ki_utils
-
-def get_unmapped_files(target_path: str = ".") -> List[str]:
-    """Returns a sorted list of unmapped files relative to project root."""
-    project_root = ki_utils.get_project_root()
-    doc_config = ki_utils.get_doc_config()
-
-    if not project_root or not doc_config:
-        return []
-
-    # 1. Collect all files that are already mapped in doc_config.json
-    mapped_paths = set()
-    knowledge_items = doc_config.get("knowledge_items", {})
-
-    for ki in knowledge_items.values():
-        depends_on = ki.get("depends_on", [])
-        for p in depends_on:
-            abs_p = os.path.abspath(os.path.join(project_root, p))
-            mapped_paths.add(abs_p)
-
-    # 2. Scan the target directory
-    abs_target = os.path.abspath(os.path.join(project_root, target_path))
-    if not ki_utils.is_subpath(abs_target, project_root):
-        return []
-    if not os.path.exists(abs_target):
-        return []
-
-    unmapped = []
-    ignored_exts = {'.pyc', '.pyo', '.pyd', '.obj', '.dll', '.exe', '.bin'}
-    exclude_patterns = ki_utils.get_exclude_patterns()
-
-    for root, dirs, files in os.walk(abs_target):
-        dirs[:] = [
-            d for d in dirs
-            if not d.startswith(".")
-            and not ki_utils.should_exclude(d, os.path.relpath(os.path.join(root, d), project_root), exclude_patterns)
-        ]
-
-        for f in files:
-            if f.startswith(".") or any(f.endswith(ext) for ext in ignored_exts):
-                continue
-
-            full_path = os.path.abspath(os.path.join(root, f))
-            rel_to_project = os.path.relpath(full_path, project_root).replace("\\", "/")
-            if ki_utils.should_exclude(f, rel_to_project, exclude_patterns):
-                continue
-
-            if full_path in mapped_paths:
-                continue
-
-            is_parent_mapped = False
-            for mapped in mapped_paths:
-                if os.path.isdir(mapped):
-                    if full_path.startswith(os.path.join(mapped, "")):
-                        is_parent_mapped = True
-                        break
-
-            if not is_parent_mapped:
-                unmapped.append(rel_to_project)
-
-    return sorted(unmapped)
-
-
-def find_unmapped_files(target_path: str):
-    project_root = ki_utils.get_project_root()
-    doc_config = ki_utils.get_doc_config()
-
-    if not project_root or not doc_config:
-        print("Error: Could not resolve project root or doc_config.json")
-        return
-
-    abs_target = os.path.abspath(os.path.join(project_root, target_path))
-    if not os.path.exists(abs_target):
-        print(f"Error: Target path '{target_path}' does not exist.")
-        return
-
-    unmapped = get_unmapped_files(target_path)
-    if unmapped:
-        print(f"### Unmapped Files in '{target_path}':")
-        for f in unmapped:
-            print(f"- {f}")
-    else:
-        print(f"All files in '{target_path}' are already mapped in doc_config.json.")
-
-if __name__ == "__main__":
-    if sys.platform == "win32":
-        sys.stdout.reconfigure(encoding="utf-8")
-    parser = argparse.ArgumentParser(description="Find files in a directory not covered by any KI in doc_config.json")
-    parser.add_argument("path", help="Relative path from project root to scan")
-    args = parser.parse_args()
-    
-    find_unmapped_files(args.path)