ki-manager 2.0.0__py3-none-any.whl

ki_manager/__init__.py

@@ -0,0 +1,2 @@
+"""ki-manager — Knowledge Item MCP server for AI-assisted development."""
+__version__ = "2.0.0"

ki_manager/scripts/add_ki_to_config.py

@@ -0,0 +1,57 @@
+"""
+add_ki_to_config.py
+
+CLI helper: registers a new Knowledge Item in doc_config.json.
+
+Usage:
+    python add_ki_to_config.py <ki_name> <description> <covers_json> <depends_on_json>
+
+Example:
+    python add_ki_to_config.py KI_utils.md "Utility helpers" '["Utilities"]' '["src/utils/"]'
+"""
+
+import sys
+import os
+import json
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ki_utils
+
+
+def add_ki(ki_name: str, description: str, covers: list, depends_on: list):
+    config = ki_utils.get_doc_config()
+    if not config:
+        print("[!] doc_config.json not found or empty")
+        return
+
+    if "knowledge_items" not in config:
+        config["knowledge_items"] = {}
+
+    config["knowledge_items"][ki_name] = {
+        "description": description,
+        "covers": covers,
+        "depends_on": depends_on,
+    }
+
+    with open(ki_utils.get_doc_config_path(), "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=4, ensure_ascii=False)
+
+    print(f"[+] KI registered in doc_config.json: {ki_name}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 5:
+        print("Usage: python add_ki_to_config.py <ki_name> <description> "
+              "<covers_list_json> <depends_on_list_json>")
+        sys.exit(1)
+
+    ki_name = sys.argv[1]
+    description = sys.argv[2]
+    try:
+        covers = json.loads(sys.argv[3])
+        depends_on = json.loads(sys.argv[4])
+    except json.JSONDecodeError:
+        print("[!] Error: covers and depends_on must be valid JSON arrays")
+        sys.exit(1)
+
+    add_ki(ki_name, description, covers, depends_on)

ki_manager/scripts/analyze_module.py

@@ -0,0 +1,103 @@
+import os
+import sys
+import argparse
+import io
+from typing import Dict, List, Optional
+
+# Добавляем путь к скриптам, чтобы импортировать ki_utils
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ki_utils
+
+def format_size(size_bytes: int) -> str:
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.2f} KB"
+    else:
+        return f"{size_bytes / (1024 * 1024):.2f} MB"
+
+def get_tracked_files(config: Dict) -> Dict[str, str]:
+    """Возвращает мапу {путь_к_файлу: имя_KI}"""
+    tracked = {}
+    ki_items = config.get("knowledge_items", {})
+    for ki_name, ki_data in ki_items.items():
+        for file_path in ki_data.get("depends_on", []):
+            tracked[os.path.normpath(file_path)] = ki_name
+    return tracked
+
+def analyze_path(target_path: str, recursive: bool = False):
+    project_root = ki_utils.get_project_root()
+    config = ki_utils.get_doc_config()
+    tracked_map = get_tracked_files(config)
+    
+    # Резолвим абсолютный путь
+    abs_target = os.path.normpath(os.path.join(project_root, target_path))
+
+    if not os.path.exists(abs_target):
+        print(f"Error: Path {target_path} not found.")
+        return
+
+    print(f"### Analysis for: `{target_path}`")
+    print("| Status | File / Directory | Size | KI Link | Density |")
+    print("|:---:|:---|:---|:---|:---|")
+
+    items = []
+    if os.path.isfile(abs_target):
+        items = [abs_target]
+    elif os.path.isdir(abs_target):
+        if recursive:
+            for root, dirs, files in os.walk(abs_target):
+                if any(part in root.split(os.sep) for part in ["__pycache__", ".git", "node_modules", "venv", ".venv"]):
+                    continue
+                for name in files:
+                    items.append(os.path.join(root, name))
+        else:
+            for name in os.listdir(abs_target):
+                items.append(os.path.join(abs_target, name))
+
+    for item_path in sorted(items):
+        try:
+            rel_path = os.path.relpath(item_path, project_root)
+            is_dir = os.path.isdir(item_path)
+            size = 0
+            if is_dir:
+                for root, _, files in os.walk(item_path):
+                    for f in files:
+                        fp = os.path.join(root, f)
+                        if os.path.exists(fp):
+                            size += os.path.getsize(fp)
+            else:
+                size = os.path.getsize(item_path)
+
+            ki_name = tracked_map.get(os.path.normpath(rel_path), "")
+            status = "✅" if ki_name else "❌"
+            
+            density = "-"
+            if ki_name:
+                ki_path = os.path.join(ki_utils.get_knowledge_root(), "knowledge", ki_name)
+                if os.path.exists(ki_path):
+                    ki_size = os.path.getsize(ki_path)
+                    if ki_size > 0:
+                        density_val = size / ki_size
+                        density = f"{density_val:.1f} B_code/B_doc"
+            
+            name_display = f"`{os.path.basename(item_path)}`" + ("/" if is_dir else "")
+            print(f"| {status} | {name_display} | {format_size(size)} | {ki_name} | {density} |")
+        except:
+            continue
+
+def main():
+    # Исправление кодировки для Windows при прямом запуске
+    if sys.platform == "win32":
+        import io
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+
+    parser = argparse.ArgumentParser(description="Analyze module statistics with knowledge context.")
+    parser.add_argument("path", help="Path relative to project root")
+    parser.add_argument("--recursive", action="store_true", help="Recursive analysis")
+    
+    args = parser.parse_args()
+    analyze_path(args.path, args.recursive)
+
+if __name__ == "__main__":
+    main()

ki_manager/scripts/audit_coverage.py

@@ -0,0 +1,406 @@
+"""
+audit_coverage.py
+
+Audit of Knowledge Base coverage for the project.
+
+Compares:
+- Project directories tracked in doc_config.json
+- Knowledge Items registered in doc_config.json
+
+Outputs a coverage matrix with priority recommendations for /expand-knowledge.
+Saves the result to <knowledge_root>/coverage_matrix.md
+
+Usage:
+    .venv/Scripts/python.exe scripts/audit_coverage.py
+    .venv/Scripts/python.exe scripts/audit_coverage.py --root /path/to/project
+    .venv/Scripts/python.exe scripts/audit_coverage.py --no-save
+"""
+
+import os
+import sys
+import json
+import argparse
+from datetime import datetime, timezone
+from pathlib import Path
+
+# Add scripts dir to path so ki_utils is importable
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ki_utils
+
+# ─── Configuration ────────────────────────────────────────────────────────────
+
+def get_knowledge_root():
+    return ki_utils.get_knowledge_root()
+
+
+def get_project_root():
+    return ki_utils.get_project_root()
+
+
+# ─── Data Loading ─────────────────────────────────────────────────────────────
+
+def load_tracked_modules():
+    doc_config = ki_utils.get_doc_config()
+    return doc_config.get("coverage_settings", {}).get("tracked_modules", [])
+
+
+def load_doc_config() -> dict:
+    """Loads doc_config.json."""
+    return ki_utils.get_doc_config()
+
+
+def load_ki_files() -> list:
+    """Returns a list of KI file names."""
+    ki_dir = os.path.join(get_knowledge_root(), "knowledge")
+    if not os.path.isdir(ki_dir):
+        return []
+    return [f for f in os.listdir(ki_dir) if f.startswith("KI_") and f.endswith(".md")]
+
+
+# ─── Metrics ──────────────────────────────────────────────────────────────────
+
+
+
+def get_module_files(project_root: str, module_path: str) -> list:
+    abs_module = os.path.join(project_root, module_path.replace("/", os.sep))
+    if not os.path.isdir(abs_module):
+        return []
+    files_list = []
+    for root, dirs, files in os.walk(abs_module):
+        dirs[:] = [d for d in dirs if d not in EXCLUDED_DIRS]
+        for f in files:
+            if f.endswith((".py", ".ts", ".tsx", ".js", ".jsx")) and not f.startswith("__"):
+                rel_path = os.path.relpath(os.path.join(root, f), project_root)
+                files_list.append(rel_path)
+    return files_list
+
+
+def get_covered_paths(doc_config: dict) -> set:
+    paths = set()
+    for entry in doc_config.get("knowledge_items", {}).values():
+        for p in entry.get("depends_on", []):
+            paths.add(p.replace("/", os.sep).rstrip(os.sep))
+    return paths
+
+
+def is_path_covered(file_path: str, covered_paths: set) -> bool:
+    """Checks if a path is covered by any of the registered KI dependencies."""
+    file_norm = file_path.replace("/", os.sep).lower()
+    for cp in covered_paths:
+        cp_norm = cp.replace("/", os.sep).lower()
+        if file_norm == cp_norm or file_norm.startswith(cp_norm + os.sep):
+            return True
+    return False
+
+
+def has_ki_coverage(module_path: str, ki_files: list, doc_config: dict) -> bool:
+    module_norm = module_path.replace("/", os.sep).rstrip(os.sep) + os.sep
+    for ki_name, entry in doc_config.get("knowledge_items", {}).items():
+        for dep in entry.get("depends_on", []):
+            dep_norm = dep.replace("/", os.sep)
+            if dep_norm.startswith(module_norm):
+                return True
+    return False
+
+
+def get_ki_size(project_root: str, module_path: str, doc_config: dict) -> int:
+    module_norm = module_path.replace("/", os.sep).rstrip(os.sep)
+    total_size = 0
+    ki_dir = os.path.join(get_knowledge_root(), "knowledge")
+
+    for ki_name, entry in doc_config.get("knowledge_items", {}).items():
+        covered = any(
+            dep.replace("/", os.sep).startswith(module_norm)
+            for dep in entry.get("depends_on", [])
+        )
+        if covered:
+            ki_path = os.path.join(ki_dir, ki_name)
+            if os.path.exists(ki_path):
+                total_size += os.path.getsize(ki_path)
+    return total_size
+
+
+def find_untracked_dirs(project_root: str, tracked_modules: list) -> list:
+    tracked_paths = {m[0].replace("/", os.sep).rstrip(os.sep) for m in tracked_modules}
+    untracked = []
+    for item in os.listdir(project_root):
+        abs_item = os.path.join(project_root, item)
+        if not os.path.isdir(abs_item) or item in EXCLUDED_DIRS or item.startswith("."):
+            continue
+        for root, dirs, files in os.walk(abs_item):
+            dirs[:] = [d for d in dirs if d not in EXCLUDED_DIRS and not d.startswith(".")]
+            rel_path = os.path.relpath(root, project_root)
+            norm_rel = rel_path.replace("/", os.sep).rstrip(os.sep)
+            if any(not f.startswith(".") for f in files):
+                is_sub_covered = any(
+                    norm_rel == tp or norm_rel.startswith(tp + os.sep)
+                    for tp in tracked_paths
+                )
+                if not is_sub_covered:
+                    untracked.append(rel_path)
+                    dirs[:] = []
+    return untracked
+
+
+def priority_label(priority: int) -> str:
+    if priority >= 8:
+        return "🔴 Critical"
+    elif priority >= 5:
+        return "🟡 Medium"
+    else:
+        return "🟢 Low"
+
+
+# ─── Matrix Builder ────────────────────────────────────────────────────────────
+
+def build_coverage_matrix(project_root: str, tracked_modules: list) -> dict:
+    doc_config = load_doc_config()
+    ki_files = load_ki_files()
+    covered_paths = get_covered_paths(doc_config)
+
+    ki_complexity = {
+        ki_name: len(entry.get("depends_on", []))
+        for ki_name, entry in doc_config.get("knowledge_items", {}).items()
+    }
+
+    rows = []
+    for module_path, label, importance in tracked_modules:
+        module_files = get_module_files(project_root, module_path)
+        total_files = len(module_files)
+
+        module_total_bytes = 0
+        module_covered_bytes = 0
+        for f in module_files:
+            abs_f = os.path.join(project_root, f)
+            try:
+                f_size = os.path.getsize(abs_f)
+                module_total_bytes += f_size
+                if is_path_covered(f, covered_paths):
+                    module_covered_bytes += f_size
+            except OSError:
+                continue
+
+        size_kb = round(module_total_bytes / 1024, 1)
+        covered_size_kb = round(module_covered_bytes / 1024, 1)
+
+        if module_total_bytes == 0:
+            coverage_pct = 100.0 if os.path.exists(os.path.join(project_root, module_path)) else 0.0
+        else:
+            coverage_pct = (module_covered_bytes / module_total_bytes) * 100
+
+        has_ki = has_ki_coverage(module_path, ki_files, doc_config)
+        ki_size = get_ki_size(project_root, module_path, doc_config)
+        density = round(ki_size / size_kb, 1) if size_kb > 0 else 0.0
+
+        complex_kis = [
+            k for k, v in ki_complexity.items()
+            if v > COMPLEXITY_THRESHOLD and any(
+                dep.startswith(module_path)
+                for dep in doc_config["knowledge_items"][k].get("depends_on", [])
+            )
+        ]
+
+        gap_factor = 1.0 + (100 - coverage_pct) / 50.0
+        if not has_ki:
+            gap_factor += 1.0
+        density_factor = 1.5 if (has_ki and size_kb > 5 and density < DENSITY_THRESHOLD) else 1.0
+        computed_priority = round(importance * gap_factor * (1 + size_kb / 200) * density_factor)
+
+        rows.append({
+            "module": module_path,
+            "label": label,
+            "files": total_files,
+            "size_kb": size_kb,
+            "covered_size_kb": covered_size_kb,
+            "has_ki": has_ki,
+            "ki_size": ki_size,
+            "density": density,
+            "coverage_pct": round(coverage_pct, 1),
+            "importance": importance,
+            "priority": computed_priority,
+            "complex_kis": complex_kis,
+            "status": "✅ Covered" if coverage_pct == 100 else
+                      "⚠️ Partial" if coverage_pct > 0 else "❌ Not Covered"
+        })
+
+    rows.sort(key=lambda r: (-r["priority"], r["label"]))
+    untracked = find_untracked_dirs(project_root, tracked_modules)
+    return {"rows": rows, "untracked": untracked}
+
+
+# ─── Formatters ───────────────────────────────────────────────────────────────
+
+def format_markdown(data: dict, generated_at: str) -> str:
+    rows = data["rows"]
+    untracked = data["untracked"]
+
+    lines = [
+        f"<!-- generated: {generated_at} -->",
+        "# Knowledge Base Coverage Matrix",
+        "",
+        f"> Generated by: `scripts/audit_coverage.py`  ",
+        f"> Date: {generated_at}",
+        "",
+        "## Module Coverage",
+        "",
+        "| Module | Label | KI | Cov | KB | Density | Priority | Status |",
+        "|---|---|:---:|:---:|---:|---:|---|---|",
+    ]
+
+    for r in rows:
+        ki = "✅" if r["has_ki"] else "❌"
+        cov = f"{r['coverage_pct']}%"
+        p = priority_label(r["importance"])
+        warn = ""
+        if r["complex_kis"]:
+            warn += " 🔥"  # Back to fire icon
+        if r["has_ki"] and r["density"] < DENSITY_THRESHOLD and r["size_kb"] > 5:
+            warn += " ❄️"
+        lines.append(
+            f"| `{r['module']}` | {r['label']}{warn} | {ki} | {cov} | "
+            f"{r['size_kb']} | {r['density']} | {p} | {r['status']} |"
+        )
+
+    total_kb = sum(r["size_kb"] for r in rows)
+    covered_kb = sum(r["covered_size_kb"] for r in rows)
+    progress = round(covered_kb / total_kb * 100) if total_kb > 0 else 0
+    fully_covered_count = sum(1 for r in rows if r["coverage_pct"] == 100)
+    total_count = len(rows)
+
+    lines += [
+        "",
+        "## Summary",
+        "",
+        "| Metric | Value |",
+        "|---|---|",
+        f"| ✅ Fully Covered Modules | {fully_covered_count} / {total_count} |",
+        f"| 📚 Total Code Size | {round(total_kb, 1)} KB |",
+        f"| 📖 Documented Code | {round(covered_kb, 1)} KB |",
+        f"| 📊 Full Progress | **{progress}%** |",
+        "",
+    ]
+
+    complex_list = [r for r in rows if r["complex_kis"]]
+    if complex_list:
+        lines += [
+            "## 🚀 Refactoring Opportunities (High Complexity)",
+            "",
+            "The following Knowledge Items are covering too many files (>10). ",
+            "This is a **key area for improvement**: splitting these KIs into smaller, ",
+            "more focused ones will improve documentation maintainability and search precision.",
+            "",
+        ]
+        for r in complex_list:
+            kis = ", ".join(f"🔥 `{k}`" for k in r["complex_kis"])
+            lines.append(f"- **{r['label']}**: {kis} — *Consider splitting by sub-modules*")
+        lines.append("")
+
+    if untracked:
+        lines += [
+            "## ⚠️ Undocumented Areas (Blind Spots)",
+            "",
+            "The following directories contain code but are not included in the audit:",
+            "",
+        ]
+        for u in untracked:
+            lines.append(f"- `{u}`")
+        lines.append("")
+
+    lines += ["## Recommendations for /expand-knowledge", ""]
+    top = [r for r in rows
+           if r["coverage_pct"] < 100
+           or (r["has_ki"] and r["density"] < DENSITY_THRESHOLD and r["size_kb"] > 5)][:5]
+    for i, r in enumerate(top, 1):
+        missing = []
+        if not r["has_ki"]:
+            missing.append("no KI file")
+        elif r["density"] < DENSITY_THRESHOLD:
+            missing.append(f"low knowledge density ({r['density']} bytes/KB)")
+        if r["coverage_pct"] < 100:
+            missing.append(f"only {r['coverage_pct']}% files covered")
+        lines += [
+            f"### {i}. {r['label']} — {priority_label(r['importance'])}",
+            f"- **Path**: `{r['module']}`",
+            f"- **Size**: {r['size_kb']} KB, {r['files']} files",
+            f"- **Gaps**: {', '.join(missing)}",
+            "",
+        ]
+
+    return "\n".join(lines)
+
+
+# ─── Entry Point ──────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Knowledge base coverage audit.")
+    parser.add_argument("--root", default=".", help="Project root directory (default: current)")
+    parser.add_argument("--no-save", action="store_true", help="Do not save coverage_matrix.md")
+    parser.add_argument("--output", default=None, help="Custom output path for coverage_matrix.md")
+    args = parser.parse_args()
+
+    project_root = get_project_root()
+    tracked_modules = load_tracked_modules()
+    if not tracked_modules:
+        print("[!] No tracked_modules found in doc_config.json. Please fill in coverage_settings.")
+        sys.exit(0)
+
+    print(f"[*] Auditing project: {project_root}")
+    data = build_coverage_matrix(project_root, tracked_modules)
+
+    # Terminal output
+    print("\n" + "=" * 70)
+    print("  COVERAGE MATRIX")
+    print("=" * 70)
+    header = f"{'Module':<32} {'KI':^3} {'Cov':>6} | {'Density':>8}"
+    print(header)
+    print("-" * 70)
+    for r in data["rows"]:
+        ki = "✅" if r["has_ki"] else "❌"
+        warn = ""
+        if r["complex_kis"]:
+            warn += " 🔥"
+        if r["has_ki"] and r["density"] < DENSITY_THRESHOLD and r["size_kb"] > 5:
+            warn += " ❄️"
+        
+        module_display = f"{r['label']}{warn}"
+        print(f"{module_display:<32} {ki:^3} {r['coverage_pct']:>5}% | {r['density']:>6.1f} B/KB")
+
+    # Detailed Warnings
+    complex_list = [r for r in data["rows"] if r["complex_kis"]]
+    if complex_list:
+        print("\n🔥 COMPLEXITY WARNING (Consider splitting):")
+        for r in complex_list:
+            kis = ", ".join(r["complex_kis"])
+            print(f"  - {r['label']}: {kis}")
+
+    low_density = [r for r in data["rows"] if r["has_ki"] and r["density"] < DENSITY_THRESHOLD and r["size_kb"] > 5]
+    if low_density:
+        print("\n❄️ LOW DENSITY (Documentation too brief):")
+        for r in low_density:
+            print(f"  - {r['label']} ({r['density']:.1f} B/KB)")
+
+    if data["untracked"]:
+        print("\n⚠️ UNTRACKED AREAS (Blind Spots):")
+        for u in data["untracked"]:
+            print(f"  - {u}")
+
+    # Save Markdown
+    if not args.no_save:
+        generated_at = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        md_content = format_markdown(data, generated_at)
+        output_path = args.output or os.path.join(get_knowledge_root(), "coverage_matrix.md")
+        output_path = os.path.abspath(output_path)
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(md_content)
+        print(f"[+] Matrix saved: {output_path}")
+
+
+EXCLUDED_DIRS = {".git", "__pycache__", "node_modules", ".venv", "venv", "dist", "build"}
+DENSITY_THRESHOLD = 50.0   # KI bytes per 1 KB of code
+COMPLEXITY_THRESHOLD = 10  # Files per one KI
+
+if __name__ == "__main__":
+    if sys.platform == "win32":
+        sys.stdout.reconfigure(encoding="utf-8")
+    main()

ki_manager/scripts/find_unmapped_files.py

@@ -0,0 +1,81 @@
+import os
+import sys
+import argparse
+import json
+from pathlib import Path
+
+# Добавляем путь к ki_utils
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ki_utils
+
+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
+
+    # 1. Собираем все файлы, которые уже замаплены в 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. Сканируем целевую директорию
+    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 = []
+    
+    # Расширения, которые мы обычно игнорируем (артефакты компиляции и т.д.)
+    ignored_exts = {'.pyc', '.pyo', '.pyd', '.obj', '.dll', '.exe', '.bin'}
+    ignored_dirs = {'__pycache__', '.git', '.venv', 'node_modules'}
+
+    for root, dirs, files in os.walk(abs_target):
+        # Фильтруем игнорируемые директории
+        dirs[:] = [d for d in dirs if d not in ignored_dirs]
+        
+        for f in files:
+            if any(f.endswith(ext) for ext in ignored_exts):
+                continue
+                
+            full_path = os.path.abspath(os.path.join(root, f))
+            
+            # Проверяем, замаплен ли файл напрямую
+            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:
+                # Возвращаем путь относительно корня проекта для удобства
+                rel_to_project = os.path.relpath(full_path, project_root)
+                unmapped.append(rel_to_project)
+
+    if unmapped:
+        print(f"### Unmapped Files in '{target_path}':")
+        for f in sorted(unmapped):
+            print(f"- {f}")
+    else:
+        print(f"All files in '{target_path}' are already mapped in doc_config.json.")
+
+if __name__ == "__main__":
+    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)