ki-manager 2.3.1.dev1__py3-none-any.whl → 2.3.2.dev1__py3-none-any.whl

ki_manager/__init__.py

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

ki_manager/cli.py

@@ -144,11 +144,14 @@ def main():
     if command == "install-skills":
         install_skills(sys.argv[2:])
     elif command in ("--version", "-v"):
-        import importlib.metadata
         try:
-            v = importlib.metadata.version("ki-manager")
+            from . import __version__ as v
         except Exception:
-            v = "unknown"
+            import importlib.metadata
+            try:
+                v = importlib.metadata.version("ki-manager")
+            except Exception:
+                v = "unknown"
         print(f"ki-manager {v}")
         sys.exit(0)
     else:

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/scripts/find_unmapped_files.py

@@ -9,34 +9,26 @@ from typing import List
 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
+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):
-        return []
-    if not os.path.exists(abs_target):
+    if not ki_utils.is_subpath(abs_target, project_root) or not os.path.exists(abs_target):
         return []
 
     unmapped = []
-    ignored_exts = {'.pyc', '.pyo', '.pyd', '.obj', '.dll', '.exe', '.bin'}
-    exclude_patterns = ki_utils.get_exclude_patterns()
+    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[:] = [
@@ -67,10 +59,57 @@ def get_unmapped_files(target_path: str = ".") -> List[str]:
             if not is_parent_mapped:
                 unmapped.append(rel_to_project)
 
-    return sorted(unmapped)
+    return unmapped
 
 
-def find_unmapped_files(target_path: str):
+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()
 
@@ -78,24 +117,27 @@ def find_unmapped_files(target_path: str):
         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
+    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(target_path)
+    unmapped = get_unmapped_files(display_target)
     if unmapped:
-        print(f"### Unmapped Files in '{target_path}':")
+        print(f"### Unmapped Files in '{display_target}':")
         for f in unmapped:
             print(f"- {f}")
     else:
-        print(f"All files in '{target_path}' are already mapped in doc_config.json.")
+        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", help="Relative path from project root to scan")
+    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/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.dev1.dist-info → ki_manager-2.3.2.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ki-manager
-Version: 2.3.1.dev1
+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.dev1.dist-info → ki_manager-2.3.2.dev1.dist-info}/RECORD

@@ -1,19 +1,19 @@
-ki_manager/__init__.py,sha256=MAN4L7RnYO2ztV2ZzLJdo7eI_mXUiEYRT60LTrll54g,104
-ki_manager/cli.py,sha256=sQZQDYh4Z8GOqQlT4Y2X60PZK27jSnhHhv5tW-RR7f0,4752
+ki_manager/__init__.py,sha256=enfAcDoPGKB3xfHgl54qRK3vJ557ZWc7PaeC2q5BqxQ,104
+ki_manager/cli.py,sha256=LQzThkf2PBhZTu4sTAmG6Zzj9XHCBl-PJ8ag-jrcKms,4854
 ki_manager/server.py,sha256=tq90-lKx3mBHuM5MAOhbeGp8lAHqyuBVAh_8sYrrRLk,105625
 ki_manager/scripts/add_ki_to_config.py,sha256=v7YhEVRpbD4U2x6FuGKuX3ZDp6CbXp8VnsoqWX9SJh8,2527
 ki_manager/scripts/analyze_module.py,sha256=UX2M4rrilLkztcMkDliOPeBDcRiUDUCo6f3SOqCEbd0,3945
 ki_manager/scripts/audit_coverage.py,sha256=O15QCSmBByB-yMo8C5debq_QGUr5NCA8EMDlzke1Y5s,16585
-ki_manager/scripts/check_ki_drift.py,sha256=3BP5XVWyHH-Np96CTQD_lLI4QRL_ba48RJ3-WhRpB04,14036
+ki_manager/scripts/check_ki_drift.py,sha256=OTPJeYdm3pkkZ8GpracEl_ZZwRIbAHNgmTcEPXMAMzE,15994
 ki_manager/scripts/finalize_ki_scaffolds.py,sha256=0BSr6J0WtMKpywvCzWKfesqkDMDbpHfFN5FYqAo_vDM,5784
-ki_manager/scripts/find_unmapped_files.py,sha256=sNuUiNamQL5lYHXNBogfEjXe-CFJ3j98xURnIIkCKbs,3481
+ki_manager/scripts/find_unmapped_files.py,sha256=t0IS8Zriey61xf_kdKVmqFz9imqiEcG5268ZWaSQEao,5597
 ki_manager/scripts/generate_dir_index.py,sha256=ODIgA7QxhdBMLViRTk5CK4vv5XrZcqSoCz1KrChTWPo,5381
 ki_manager/scripts/generate_ki_scaffolds.py,sha256=LzvTMu13QySVdxvnOEdGXlVp6xDP0Nxb-VU9ShFdb88,27097
 ki_manager/scripts/git_diff_secured.py,sha256=zTTmqGshPRALwYgU8TIeCU7W4FbhcHz9MlCB-f7cCnk,2662
 ki_manager/scripts/ki_dependency_analyzer.py,sha256=378pSZZX_nAAoh9QTFb_A5yqdKFfp8G7iqis0dJu6eg,9794
 ki_manager/scripts/ki_graph_visualize.py,sha256=3Xg6WrWliREeCUxKjmeivBYT56lFBbC3Jot7uD2e81g,9102
 ki_manager/scripts/ki_search.py,sha256=YAHkPKWx3AVh6n1ivsaHu_0-QowoqpyAwUtZ-LcBrnM,11670
-ki_manager/scripts/ki_utils.py,sha256=L056zbYD88MI789Zj-s8kIUZKGTeF5dbKEy9mbjUAUs,20909
+ki_manager/scripts/ki_utils.py,sha256=3z8wwMxB7fV0CdvM4nJVCIO1_D4qvFZ9hjgau7L1kzk,22394
 ki_manager/scripts/knowledge_engine.py,sha256=H81WiwSnQh-fXVEakzAUXNcxs8JhYamBFUxAqdnOTSM,9862
 ki_manager/scripts/sync_agents_md.py,sha256=0Lbx8MidQXmysw4HHrnighXMemsmIp4CAqvnbVY7_WE,5982
 ki_manager/templates/KI_template.md,sha256=s7GKEqt5PlmOZ7V_IytU6h0viTedW_ZKeJ8w_t3wJFA,875
@@ -24,8 +24,8 @@ ki_manager/workflows/create-adr.md,sha256=dx5uX5UFnxuztXXEf13JQU6FEZfMcKWQf2_g1y
 ki_manager/workflows/expand-knowledge.md,sha256=cfa4WOj2rUNlSTVmLmyhij_OHxRp1HUSLvBUeBjjNjs,6448
 ki_manager/workflows/scaffold-knowledge.md,sha256=xhnNQeKu0yzJrPIrnLXzFbSSwk1v8H2CzAymiwqKUNc,8284
 ki_manager/workflows/sync-knowledge.md,sha256=wyYbVeYWy0autJCK34eOlyyPeoW0Ks1hAEkHjvmrTU4,4255
-ki_manager-2.3.1.dev1.dist-info/METADATA,sha256=oa1BgfRjEHnVWOSE4ehi4KbMDPfXBXRtHC7yS9apnZs,11217
-ki_manager-2.3.1.dev1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-ki_manager-2.3.1.dev1.dist-info/entry_points.txt,sha256=V-NMpOuZiRNc4hDwZ0AcWnEltRkc_T4WD_sUxOQf7TE,94
-ki_manager-2.3.1.dev1.dist-info/licenses/LICENSE,sha256=KBvPtUXGgjjiHBWYvaNazfiZ_U-VYaqisz_yVCUfOBs,1072
-ki_manager-2.3.1.dev1.dist-info/RECORD,,
+ki_manager-2.3.2.dev1.dist-info/METADATA,sha256=kftq-bPgBdkGhnx4GVl2jKZAbaHckhprULGTvJQ4eYY,11217
+ki_manager-2.3.2.dev1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+ki_manager-2.3.2.dev1.dist-info/entry_points.txt,sha256=V-NMpOuZiRNc4hDwZ0AcWnEltRkc_T4WD_sUxOQf7TE,94
+ki_manager-2.3.2.dev1.dist-info/licenses/LICENSE,sha256=KBvPtUXGgjjiHBWYvaNazfiZ_U-VYaqisz_yVCUfOBs,1072
+ki_manager-2.3.2.dev1.dist-info/RECORD,,