knowledge-master 0.2.0__tar.gz → 0.4.0__tar.gz

{knowledge_master-0.2.0 → knowledge_master-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: knowledge-master
-Version: 0.2.0
+Version: 0.4.0
 Summary: Local-first knowledge graph for developers. Your AI agent's permanent memory.
 Author: Milenko Mitrovic
 License: MIT
@@ -28,6 +28,11 @@ Requires-Dist: rich<15.0,>=14.0.0
 Requires-Dist: fastapi<1.0,>=0.115.0
 Requires-Dist: uvicorn<1.0,>=0.34.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: tree-sitter>=0.23.0
+Requires-Dist: tree-sitter-javascript>=0.23.0
+Requires-Dist: tree-sitter-typescript>=0.23.0
+Requires-Dist: tree-sitter-go>=0.23.0
+Requires-Dist: tree-sitter-rust>=0.23.0
 Provides-Extra: office
 Requires-Dist: python-docx<2.0,>=1.1.0; extra == "office"
 Requires-Dist: openpyxl<4.0,>=3.1.0; extra == "office"

{knowledge_master-0.2.0 → knowledge_master-0.4.0}/knowledge_master/cli.py

@@ -460,5 +460,75 @@ def who_owns(file: str = typer.Argument(..., help="File path to check ownership"
         console.print("[dim]Run 'km index <repo>' first to extract ownership.[/]")
 
 
+@app.command()
+def upgrade():
+    """Upgrade graph schema to the latest version."""
+    from .migrations import check_and_migrate, get_schema_version, CURRENT_SCHEMA_VERSION
+
+    graph = store.get_graph()
+    current = get_schema_version(graph)
+    console.print(f"[bold]Current schema:[/] v{current}")
+    console.print(f"[bold]Target schema:[/]  v{CURRENT_SCHEMA_VERSION}")
+
+    if current == CURRENT_SCHEMA_VERSION:
+        console.print("[green]✓ Already up to date[/]")
+        return
+
+    result = check_and_migrate(graph, auto_migrate=True)
+    for step in result["steps"]:
+        console.print(f"  [green]✓[/] {step}")
+    console.print(f"\n[green]✓ Upgraded to v{CURRENT_SCHEMA_VERSION}[/]")
+
+
+@app.command()
+def prune(
+    older_than: int = typer.Option(30, help="Remove chunks not re-indexed in this many days"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be removed"),
+):
+    """Remove stale/orphaned data from the knowledge graph."""
+    graph = store.get_graph()
+
+    # Find orphaned chunks (no PART_OF edge)
+    orphaned = graph.query("MATCH (c:Chunk) WHERE NOT (c)-[:PART_OF]->() RETURN count(c)")
+    orphan_count = orphaned.result_set[0][0] if orphaned.result_set else 0
+
+    # Find documents with no chunks
+    empty_docs = graph.query(
+        "MATCH (d:Document) WHERE NOT ()-[:PART_OF]->(d) AND NOT (d)-[:IN_REPO]->() RETURN count(d)"
+    )
+    empty_count = empty_docs.result_set[0][0] if empty_docs.result_set else 0
+
+    # Find stale chunks (indexed_at older than threshold)
+    # FalkorDB timestamp() returns ms since epoch
+    threshold_ms = older_than * 86400 * 1000
+    stale = graph.query(
+        """MATCH (c:Chunk)
+           WHERE c.indexed_at IS NOT NULL AND (timestamp() - c.indexed_at) > $threshold
+           RETURN count(c)""",
+        params={"threshold": threshold_ms},
+    )
+    stale_count = stale.result_set[0][0] if stale.result_set else 0
+
+    console.print("[bold]Prune analysis:[/]")
+    console.print(f"  Orphaned chunks (no document link): {orphan_count}")
+    console.print(f"  Empty documents (no chunks):        {empty_count}")
+    console.print(f"  Stale chunks (>{older_than} days):        {stale_count}")
+
+    if dry_run:
+        console.print("\n[yellow]Dry run — nothing removed.[/]")
+        return
+
+    total = 0
+    if orphan_count > 0:
+        graph.query("MATCH (c:Chunk) WHERE NOT (c)-[:PART_OF]->() DELETE c")
+        total += orphan_count
+
+    if empty_count > 0:
+        graph.query("MATCH (d:Document) WHERE NOT ()-[:PART_OF]->(d) AND NOT (d)-[:IN_REPO]->() DELETE d")
+        total += empty_count
+
+    console.print(f"\n[green]✓ Removed {total} stale nodes[/]")
+
+
 if __name__ == "__main__":
     app()

knowledge_master-0.4.0/knowledge_master/migrations.py

@@ -0,0 +1,89 @@
+"""Schema versioning and migrations for the knowledge graph."""
+
+CURRENT_SCHEMA_VERSION = 4  # v0.4.0
+
+# Migration definitions: version -> function that upgrades from previous version
+MIGRATIONS = {}
+
+
+def get_schema_version(graph) -> int:
+    """Get current schema version from graph metadata."""
+    try:
+        result = graph.query("MATCH (m:_Meta {key: 'schema_version'}) RETURN m.value")
+        if result.result_set:
+            return int(result.result_set[0][0])
+    except Exception:
+        pass
+    return 0  # no version = legacy graph
+
+
+def set_schema_version(graph, version: int):
+    """Store schema version in graph metadata."""
+    graph.query(
+        "MERGE (m:_Meta {key: 'schema_version'}) SET m.value = $version",
+        params={"version": version},
+    )
+
+
+def check_and_migrate(graph, auto_migrate: bool = True) -> dict:
+    """Check schema version and migrate if needed.
+
+    Returns: {"current": int, "target": int, "migrated": bool, "steps": list}
+    """
+    current = get_schema_version(graph)
+    target = CURRENT_SCHEMA_VERSION
+
+    if current == target:
+        return {"current": current, "target": target, "migrated": False, "steps": []}
+
+    if current > target:
+        raise RuntimeError(
+            f"Graph schema v{current} is newer than this version supports (v{target}). "
+            "Please upgrade knowledge-master."
+        )
+
+    if not auto_migrate:
+        raise RuntimeError(
+            f"Graph schema v{current} needs migration to v{target}. Run: km upgrade"
+        )
+
+    steps = []
+    for v in range(current + 1, target + 1):
+        migration_fn = MIGRATIONS.get(v)
+        if migration_fn:
+            migration_fn(graph)
+            steps.append(f"v{v-1} → v{v}: {migration_fn.__doc__ or 'applied'}")
+        else:
+            steps.append(f"v{v-1} → v{v}: no-op (compatible)")
+
+    set_schema_version(graph, target)
+    return {"current": current, "target": target, "migrated": True, "steps": steps}
+
+
+# --- Migrations ---
+
+def _migrate_to_v1(graph):
+    """Add indexed_at timestamp to existing chunks missing it."""
+    graph.query("MATCH (c:Chunk) WHERE c.indexed_at IS NULL SET c.indexed_at = timestamp()")
+
+
+def _migrate_to_v2(graph):
+    """Add OWNS relationships from ownership extraction."""
+    pass  # OWNS edges are created by extract_ownership, no schema change needed
+
+
+def _migrate_to_v3(graph):
+    """Add lang property to IMPORTS edges and Function nodes."""
+    graph.query("MATCH (f:Function) WHERE f.lang IS NULL SET f.lang = 'python'")
+    graph.query("MATCH ()-[e:IMPORTS]->() WHERE e.lang IS NULL SET e.lang = 'python'")
+
+
+def _migrate_to_v4(graph):
+    """Add content_hash to Chunk nodes for deduplication."""
+    pass  # New chunks will have hash, old ones are fine without
+
+
+MIGRATIONS[1] = _migrate_to_v1
+MIGRATIONS[2] = _migrate_to_v2
+MIGRATIONS[3] = _migrate_to_v3
+MIGRATIONS[4] = _migrate_to_v4

{knowledge_master-0.2.0 → knowledge_master-0.4.0}/knowledge_master/parsers/git_repo.py

@@ -9,7 +9,7 @@ from rich.progress import Progress
 
 from .. import chunking, embeddings, store
 from ..intelligence import extract_all
-from ..static_analysis import build_import_graph
+from ..static_analysis import build_import_graph_all
 
 INDEXABLE_EXTENSIONS = {
     ".py", ".ts", ".tsx", ".js", ".rs", ".go", ".java",
@@ -46,6 +46,8 @@ def index_repo(repo_path: str, graph=None, branch: str = "HEAD", on_progress=Non
     tracked = repo.git.ls_files().splitlines()
     indexable = [f for f in tracked if _should_index(f)]
     total = len(indexable)
+    indexed_files = []
+    failed_files = []
 
     with Progress(disable=not sys.stdout.isatty()) as progress:
         task = progress.add_task(f"Indexing {repo_name}", total=total)
@@ -53,19 +55,26 @@ def index_repo(repo_path: str, graph=None, branch: str = "HEAD", on_progress=Non
             full_path = os.path.join(repo_path, filepath)
             try:
                 _index_file(graph, full_path, filepath, repo_name, repo)
+                indexed_files.append(filepath)
             except Exception as e:
+                failed_files.append((filepath, str(e)))
                 progress.console.print(f"  [yellow]skip {filepath}: {e}[/]")
             progress.advance(task)
             if on_progress:
                 on_progress(i + 1, total, filepath)
 
+    # If more than 50% failed, warn (possible systemic issue)
+    if total > 0 and len(failed_files) > total * 0.5:
+        import sys as _sys
+        print(f"WARNING: {len(failed_files)}/{total} files failed. Possible systemic issue.", file=_sys.stderr)
+
     # Run intelligence extraction
     intel = extract_all(repo_path, graph)
 
-    # Run static analysis (import graph, symbols)
-    static = build_import_graph(repo_path, graph)
+    # Run static analysis (import graph, symbols) — all languages
+    static = build_import_graph_all(repo_path, graph)
 
-    return {"repo": repo_name, "files_indexed": total, "intelligence": intel, "static_analysis": static}
+    return {"repo": repo_name, "files_indexed": len(indexed_files), "files_failed": len(failed_files), "intelligence": intel, "static_analysis": static}
 
 
 def _should_index(filepath: str) -> bool:

knowledge_master-0.4.0/knowledge_master/static_analysis.py

@@ -0,0 +1,306 @@
+"""Static analysis — extract import graphs, symbols, and call relationships from code."""
+
+import ast
+import os
+from pathlib import Path
+
+
+def extract_python_graph(file_path: str) -> dict:
+    """Extract imports, exports (top-level functions/classes), and calls from a Python file."""
+    try:
+        source = Path(file_path).read_text(errors="ignore")
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError):
+        return {"imports": [], "exports": [], "calls": [], "path": file_path}
+
+    imports = []
+    exports = []
+    calls = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append({"module": alias.name, "alias": alias.asname, "names": []})
+        elif isinstance(node, ast.ImportFrom):
+            imports.append({
+                "module": node.module or "",
+                "names": [a.name for a in node.names],
+                "level": node.level,
+            })
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if node.col_offset == 0:  # top-level function
+                exports.append({"name": node.name, "type": "function", "line": node.lineno})
+        elif isinstance(node, ast.ClassDef):
+            if node.col_offset == 0:  # top-level class
+                bases = [_node_name(b) for b in node.bases]
+                exports.append({"name": node.name, "type": "class", "line": node.lineno, "bases": bases})
+
+    return {"imports": imports, "exports": exports, "calls": calls, "path": file_path}
+
+
+def resolve_import(module: str, level: int, source_file: str, repo_root: str) -> str | None:
+    """Resolve an import to a file path within the repo."""
+    if level > 0:
+        # Relative import: go up `level` directories from source file's package
+        source_dir = Path(os.path.join(repo_root, source_file)).parent
+        for _ in range(level - 1):
+            source_dir = source_dir.parent
+        parts = module.split(".") if module else []
+        candidate = source_dir / Path(*parts) if parts else source_dir
+    else:
+        # Absolute import — check if it's a local module
+        parts = module.split(".")
+        candidate = Path(repo_root) / Path(*parts)
+
+    # Try as module.py or package/__init__.py
+    as_file = str(candidate) + ".py"
+    as_pkg = str(candidate / "__init__.py")
+
+    if os.path.exists(as_file):
+        return os.path.relpath(as_file, repo_root)
+    if os.path.exists(as_pkg):
+        return os.path.relpath(as_pkg, repo_root)
+
+    return None
+
+
+def build_import_graph(repo_path: str, graph):
+    """Walk a repo, extract Python imports, store as IMPORTS edges between File nodes."""
+    repo_path = str(Path(repo_path).resolve())
+    repo_name = Path(repo_path).name
+    py_files = list(Path(repo_path).rglob("*.py"))
+    py_files = [f for f in py_files if not any(
+        p in f.parts for p in (".venv", "venv", "node_modules", "__pycache__", ".git", "site-packages")
+    )]
+
+    file_exports = {}  # relative_path -> [exported symbols]
+    file_imports = {}  # relative_path -> [import info]
+
+    # Pass 1: collect exports and imports
+    for py_file in py_files:
+        relative = os.path.relpath(str(py_file), repo_path)
+        result = extract_python_graph(str(py_file))
+        file_exports[relative] = result["exports"]
+        file_imports[relative] = result["imports"]
+
+        # Store Function/Class nodes
+        for export in result["exports"]:
+            node_type = "Function" if export["type"] == "function" else "Class"
+            graph.query(
+                f"MERGE (s:{node_type} {{name: $name, file: $file, repo: $repo}}) SET s.line = $line",
+                params={"name": export["name"], "file": relative, "repo": repo_name, "line": export["line"]},
+            )
+            # Link symbol to file
+            graph.query(
+                f"""MATCH (s:{node_type} {{name: $name, file: $file}}), (d:Document {{path: $file}})
+                    MERGE (s)-[:DEFINED_IN]->(d)""",
+                params={"name": export["name"], "file": relative},
+            )
+
+    # Pass 2: resolve imports to file paths, create IMPORTS edges
+    edges_created = 0
+    for source_file, imports in file_imports.items():
+        for imp in imports:
+            module = imp.get("module", "")
+            level = imp.get("level", 0)
+            names = imp.get("names", [])
+
+            if module:
+                # from module import X  or  import module
+                target_file = resolve_import(module, level, source_file, repo_path)
+                if target_file and target_file in file_exports:
+                    graph.query(
+                        """MERGE (src:Document {path: $src})
+                           MERGE (dst:Document {path: $dst})
+                           MERGE (src)-[:IMPORTS {names: $names}]->(dst)""",
+                        params={"src": source_file, "dst": target_file, "names": names},
+                    )
+                    edges_created += 1
+            elif level > 0 and names:
+                # from . import module1, module2 — each name is a sibling module
+                for name in names:
+                    target_file = resolve_import(name, level, source_file, repo_path)
+                    if target_file and target_file in file_exports:
+                        graph.query(
+                            """MERGE (src:Document {path: $src})
+                               MERGE (dst:Document {path: $dst})
+                               MERGE (src)-[:IMPORTS {names: $imp_names}]->(dst)""",
+                            params={"src": source_file, "dst": target_file, "imp_names": [name]},
+                        )
+                        edges_created += 1
+
+    return {"files_analyzed": len(py_files), "import_edges": edges_created, "symbols": sum(len(v) for v in file_exports.values())}
+
+
+def _node_name(node) -> str:
+    """Get string name from an AST node."""
+    if isinstance(node, ast.Name):
+        return node.id
+    elif isinstance(node, ast.Attribute):
+        return f"{_node_name(node.value)}.{node.attr}"
+    return ""
+
+
+def build_import_graph_all(repo_path: str, graph):
+    """Build import graph for all supported languages in the repo."""
+    repo_path = str(Path(repo_path).resolve())
+    results = {"python": {}, "typescript": {}, "go": {}, "rust": {}}
+
+    # Python (AST-based)
+    results["python"] = build_import_graph(repo_path, graph)
+
+    # TypeScript/JavaScript (tree-sitter)
+    results["typescript"] = _build_ts_import_graph(repo_path, graph)
+
+    # Go (tree-sitter)
+    results["go"] = _build_go_import_graph(repo_path, graph)
+
+    # Rust (tree-sitter)
+    results["rust"] = _build_rust_import_graph(repo_path, graph)
+
+    total_edges = sum(r.get("import_edges", 0) for r in results.values())
+    total_symbols = sum(r.get("symbols", 0) for r in results.values())
+    total_files = sum(r.get("files_analyzed", 0) for r in results.values())
+
+    return {"files_analyzed": total_files, "import_edges": total_edges, "symbols": total_symbols, "by_language": results}
+
+
+def _build_ts_import_graph(repo_path: str, graph) -> dict:
+    """Build import graph for TypeScript/JavaScript files."""
+    from .ts_parsers import extract_typescript_graph, resolve_ts_import
+
+    skip = {".git", "node_modules", "dist", "build", ".venv", "__pycache__"}
+    ts_files = []
+    for ext in (".ts", ".tsx", ".js", ".jsx"):
+        for f in Path(repo_path).rglob(f"*{ext}"):
+            if not any(p in f.parts for p in skip):
+                ts_files.append(f)
+
+    if not ts_files:
+        return {"files_analyzed": 0, "import_edges": 0, "symbols": 0}
+
+    edges = 0
+    symbols = 0
+    for ts_file in ts_files:
+        relative = os.path.relpath(str(ts_file), repo_path)
+        try:
+            result = extract_typescript_graph(str(ts_file))
+        except Exception:
+            continue
+
+        # Store exports as symbols
+        for export in result["exports"]:
+            graph.query(
+                "MERGE (f:Function {name: $name, file: $file}) SET f.line = $line, f.lang = 'typescript'",
+                params={"name": export["name"], "file": relative, "line": export.get("line", 0)},
+            )
+            symbols += 1
+
+        # Resolve imports and create edges
+        for imp in result["imports"]:
+            target = resolve_ts_import(imp["module"], relative, repo_path)
+            if target:
+                graph.query(
+                    """MERGE (src:Document {path: $src})
+                       MERGE (dst:Document {path: $dst})
+                       MERGE (src)-[:IMPORTS {names: $names, lang: 'typescript'}]->(dst)""",
+                    params={"src": relative, "dst": target, "names": imp.get("names", [])},
+                )
+                edges += 1
+
+    return {"files_analyzed": len(ts_files), "import_edges": edges, "symbols": symbols}
+
+
+def _build_go_import_graph(repo_path: str, graph) -> dict:
+    """Build import graph for Go files."""
+    from .ts_parsers import extract_go_graph, resolve_go_import
+
+    skip = {".git", "vendor", "node_modules"}
+    go_files = [f for f in Path(repo_path).rglob("*.go") if not any(p in f.parts for p in skip)]
+
+    if not go_files:
+        return {"files_analyzed": 0, "import_edges": 0, "symbols": 0}
+
+    # Read go.mod for module name
+    go_module = ""
+    gomod = Path(repo_path) / "go.mod"
+    if gomod.exists():
+        for line in gomod.read_text().splitlines():
+            if line.startswith("module "):
+                go_module = line.split()[1]
+                break
+
+    edges = 0
+    symbols = 0
+    for go_file in go_files:
+        relative = os.path.relpath(str(go_file), repo_path)
+        try:
+            result = extract_go_graph(str(go_file))
+        except Exception:
+            continue
+
+        for export in result["exports"]:
+            graph.query(
+                "MERGE (f:Function {name: $name, file: $file}) SET f.line = $line, f.lang = 'go'",
+                params={"name": export["name"], "file": relative, "line": export.get("line", 0)},
+            )
+            symbols += 1
+
+        for imp in result["imports"]:
+            target = resolve_go_import(imp["module"], repo_path, go_module)
+            if target:
+                graph.query(
+                    """MERGE (src:Document {path: $src})
+                       MERGE (dst:Document {path: $dst})
+                       MERGE (src)-[:IMPORTS {names: $names, lang: 'go'}]->(dst)""",
+                    params={"src": relative, "dst": target, "names": []},
+                )
+                edges += 1
+
+    return {"files_analyzed": len(go_files), "import_edges": edges, "symbols": symbols}
+
+
+def _build_rust_import_graph(repo_path: str, graph) -> dict:
+    """Build import graph for Rust files."""
+    from .ts_parsers import extract_rust_graph
+
+    skip = {".git", "target", "node_modules"}
+    rs_files = [f for f in Path(repo_path).rglob("*.rs") if not any(p in f.parts for p in skip)]
+
+    if not rs_files:
+        return {"files_analyzed": 0, "import_edges": 0, "symbols": 0}
+
+    edges = 0
+    symbols = 0
+    for rs_file in rs_files:
+        relative = os.path.relpath(str(rs_file), repo_path)
+        try:
+            result = extract_rust_graph(str(rs_file))
+        except Exception:
+            continue
+
+        for export in result["exports"]:
+            graph.query(
+                "MERGE (f:Function {name: $name, file: $file}) SET f.line = $line, f.lang = 'rust'",
+                params={"name": export["name"], "file": relative, "line": export.get("line", 0)},
+            )
+            symbols += 1
+
+        # Rust mod resolution: mod foo -> foo.rs or foo/mod.rs
+        for imp in result["imports"]:
+            if imp.get("is_mod"):
+                mod_name = imp["module"]
+                src_dir = Path(os.path.join(repo_path, relative)).parent
+                for candidate in [src_dir / f"{mod_name}.rs", src_dir / mod_name / "mod.rs"]:
+                    if candidate.exists():
+                        target = os.path.relpath(str(candidate), repo_path)
+                        graph.query(
+                            """MERGE (src:Document {path: $src})
+                               MERGE (dst:Document {path: $dst})
+                               MERGE (src)-[:IMPORTS {names: [], lang: 'rust'}]->(dst)""",
+                            params={"src": relative, "dst": target},
+                        )
+                        edges += 1
+                        break
+
+    return {"files_analyzed": len(rs_files), "import_edges": edges, "symbols": symbols}

{knowledge_master-0.2.0 → knowledge_master-0.4.0}/knowledge_master/store.py

@@ -1,5 +1,7 @@
 """FalkorDB graph store - nodes, edges, vector search, and graph traversal."""
 
+import hashlib
+
 from falkordb import FalkorDB
 
 GRAPH_NAME = "knowledge"
@@ -7,11 +9,35 @@ GRAPH_NAME = "knowledge"
 # Vector dimension for nomic-embed-text
 VECTOR_DIM = 768
 
+_graph_instance = None
+
 
 def get_graph(host: str = "localhost", port: int = 6379):
-    """Get FalkorDB graph instance."""
+    """Get FalkorDB graph instance with schema version check."""
+    global _graph_instance
+    if _graph_instance is not None:
+        return _graph_instance
+
     db = FalkorDB(host=host, port=port)
-    return db.select_graph(GRAPH_NAME)
+    graph = db.select_graph(GRAPH_NAME)
+
+    # Check and auto-migrate schema
+    from .migrations import check_and_migrate
+    check_and_migrate(graph, auto_migrate=True)
+
+    _graph_instance = graph
+    return graph
+
+
+def reset_graph_instance():
+    """Reset cached graph instance (for testing)."""
+    global _graph_instance
+    _graph_instance = None
+
+
+def content_hash(text: str) -> str:
+    """Compute content hash for deduplication."""
+    return hashlib.sha256(text.encode()).hexdigest()[:16]
 
 
 def init_schema(graph):
@@ -35,20 +61,32 @@ def init_schema(graph):
 
 
 def upsert_chunk(graph, chunk_id: str, text: str, embedding: list[float], metadata: dict):
-    """Insert or update a chunk node with embedding."""
+    """Insert or update a chunk node with embedding. Skips if content unchanged (dedup)."""
+    chash = content_hash(text)
+
+    # Check if chunk exists with same content hash — skip if unchanged
+    existing = graph.query(
+        "MATCH (c:Chunk {id: $id}) RETURN c.content_hash",
+        params={"id": chunk_id},
+    )
+    if existing.result_set and existing.result_set[0][0] == chash:
+        return False  # skip — content unchanged
+
     graph.query(
         """MERGE (c:Chunk {id: $id})
            SET c.text = $text, c.embedding = vecf32($embedding),
                c.source = $source, c.source_type = $source_type,
-               c.indexed_at = timestamp()""",
+               c.content_hash = $hash, c.indexed_at = timestamp()""",
         params={
             "id": chunk_id,
             "text": text,
             "embedding": embedding,
             "source": metadata.get("source", ""),
             "source_type": metadata.get("source_type", ""),
+            "hash": chash,
         },
     )
+    return True  # inserted/updated
 
 
 def upsert_document(graph, path: str, doc_type: str, metadata: dict):

knowledge_master-0.4.0/knowledge_master/ts_parsers.py

@@ -0,0 +1,192 @@
+"""Tree-sitter based import graph extraction for TypeScript, Go, and Rust."""
+
+import os
+from pathlib import Path
+
+from tree_sitter import Language, Parser
+import tree_sitter_typescript as ts_ts
+import tree_sitter_go as ts_go
+import tree_sitter_rust as ts_rust
+import tree_sitter_javascript as ts_js
+
+# Initialize languages
+TYPESCRIPT = Language(ts_ts.language_typescript())
+TSX = Language(ts_ts.language_tsx())
+JAVASCRIPT = Language(ts_js.language())
+GO = Language(ts_go.language())
+RUST = Language(ts_rust.language())
+
+
+def extract_typescript_graph(file_path: str) -> dict:
+    """Extract imports and exports from a TypeScript/JavaScript file."""
+    source = Path(file_path).read_bytes()
+    lang = TSX if file_path.endswith(".tsx") else (JAVASCRIPT if file_path.endswith(".js") else TYPESCRIPT)
+    parser = Parser(lang)
+    tree = parser.parse(source)
+
+    imports = []
+    exports = []
+
+    for node in _walk(tree.root_node):
+        # import { X } from './module'  |  import X from 'module'
+        if node.type == "import_statement":
+            source_node = node.child_by_field_name("source")
+            if source_node:
+                module = source_node.text.decode().strip("'\"")
+                names = []
+                for child in node.children:
+                    if child.type == "import_clause":
+                        for spec in _walk(child):
+                            if spec.type == "identifier":
+                                names.append(spec.text.decode())
+                            elif spec.type == "import_specifier":
+                                name_node = spec.child_by_field_name("name")
+                                if name_node:
+                                    names.append(name_node.text.decode())
+                imports.append({"module": module, "names": names})
+
+        # require('module')
+        elif node.type == "call_expression":
+            func = node.child_by_field_name("function")
+            if func and func.text == b"require":
+                args = node.child_by_field_name("arguments")
+                if args and args.child_count > 1:
+                    arg = args.children[1]
+                    if arg.type == "string":
+                        imports.append({"module": arg.text.decode().strip("'\""), "names": []})
+
+        # export function/class/const
+        elif node.type in ("export_statement", "export_default_declaration"):
+            decl = node.child_by_field_name("declaration")
+            if decl:
+                name_node = decl.child_by_field_name("name")
+                if name_node:
+                    exports.append({"name": name_node.text.decode(), "type": decl.type, "line": decl.start_point[0] + 1})
+            # export { x, y }
+            for child in node.children:
+                if child.type == "export_clause":
+                    for spec in _walk(child):
+                        if spec.type == "export_specifier":
+                            name_node = spec.child_by_field_name("name")
+                            if name_node:
+                                exports.append({"name": name_node.text.decode(), "type": "re-export", "line": spec.start_point[0] + 1})
+
+        # Top-level function/class declarations
+        elif node.type in ("function_declaration", "class_declaration") and node.parent.type in ("program", "export_statement"):
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                exports.append({"name": name_node.text.decode(), "type": node.type, "line": node.start_point[0] + 1})
+
+    return {"imports": imports, "exports": exports, "path": file_path}
+
+
+def extract_go_graph(file_path: str) -> dict:
+    """Extract imports and exports from a Go file."""
+    source = Path(file_path).read_bytes()
+    parser = Parser(GO)
+    tree = parser.parse(source)
+
+    imports = []
+    exports = []
+
+    for node in _walk(tree.root_node):
+        # import "pkg" or import ( "pkg1"; "pkg2" )
+        if node.type == "import_declaration":
+            for child in _walk(node):
+                if child.type == "import_spec":
+                    path_node = child.child_by_field_name("path")
+                    if path_node:
+                        module = path_node.text.decode().strip('"')
+                        imports.append({"module": module, "names": []})
+                elif child.type == "interpreted_string_literal":
+                    imports.append({"module": child.text.decode().strip('"'), "names": []})
+
+        # Exported functions (capitalized)
+        elif node.type == "function_declaration":
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                name = name_node.text.decode()
+                if name[0].isupper():  # Go exports are capitalized
+                    exports.append({"name": name, "type": "function", "line": node.start_point[0] + 1})
+
+        # Exported types
+        elif node.type == "type_declaration":
+            for spec in node.children:
+                if spec.type == "type_spec":
+                    name_node = spec.child_by_field_name("name")
+                    if name_node:
+                        name = name_node.text.decode()
+                        if name[0].isupper():
+                            exports.append({"name": name, "type": "type", "line": spec.start_point[0] + 1})
+
+    return {"imports": imports, "exports": exports, "path": file_path}
+
+
+def extract_rust_graph(file_path: str) -> dict:
+    """Extract use statements and pub items from a Rust file."""
+    source = Path(file_path).read_bytes()
+    parser = Parser(RUST)
+    tree = parser.parse(source)
+
+    imports = []
+    exports = []
+
+    for node in _walk(tree.root_node):
+        # use std::collections::HashMap;  |  use crate::module::Item;
+        if node.type == "use_declaration":
+            path_text = ""
+            for child in _walk(node):
+                if child.type in ("scoped_identifier", "identifier", "use_wildcard", "scoped_use_list"):
+                    path_text = child.text.decode()
+                    break
+            if path_text:
+                module = path_text.split("::")[0]
+                names = path_text.split("::")[-1:] if "::" in path_text else []
+                imports.append({"module": module, "path": path_text, "names": names})
+
+        # mod declarations
+        elif node.type == "mod_item":
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                imports.append({"module": name_node.text.decode(), "names": [], "is_mod": True})
+
+        # pub fn / pub struct / pub enum
+        elif node.type in ("function_item", "struct_item", "enum_item", "impl_item"):
+            is_pub = any(c.type == "visibility_modifier" for c in node.children)
+            name_node = node.child_by_field_name("name")
+            if name_node and is_pub:
+                exports.append({"name": name_node.text.decode(), "type": node.type.replace("_item", ""), "line": node.start_point[0] + 1})
+
+    return {"imports": imports, "exports": exports, "path": file_path}
+
+
+def resolve_ts_import(module: str, source_file: str, repo_root: str) -> str | None:
+    """Resolve a TypeScript/JS import to a file path."""
+    if not module.startswith("."):
+        return None  # external package
+
+    source_dir = Path(os.path.join(repo_root, source_file)).parent
+    candidate = source_dir / module
+
+    for suffix in [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"]:
+        path = str(candidate) + suffix
+        if os.path.exists(path):
+            return os.path.relpath(path, repo_root)
+    return None
+
+
+def resolve_go_import(module: str, repo_root: str, go_module: str = "") -> str | None:
+    """Resolve a Go import to a directory in the repo."""
+    if go_module and module.startswith(go_module):
+        relative = module[len(go_module):].lstrip("/")
+        candidate = os.path.join(repo_root, relative)
+        if os.path.isdir(candidate):
+            return relative
+    return None
+
+
+def _walk(node):
+    """Recursively walk tree-sitter nodes."""
+    yield node
+    for child in node.children:
+        yield from _walk(child)

{knowledge_master-0.2.0 → knowledge_master-0.4.0}/knowledge_master.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: knowledge-master
-Version: 0.2.0
+Version: 0.4.0
 Summary: Local-first knowledge graph for developers. Your AI agent's permanent memory.
 Author: Milenko Mitrovic
 License: MIT
@@ -28,6 +28,11 @@ Requires-Dist: rich<15.0,>=14.0.0
 Requires-Dist: fastapi<1.0,>=0.115.0
 Requires-Dist: uvicorn<1.0,>=0.34.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: tree-sitter>=0.23.0
+Requires-Dist: tree-sitter-javascript>=0.23.0
+Requires-Dist: tree-sitter-typescript>=0.23.0
+Requires-Dist: tree-sitter-go>=0.23.0
+Requires-Dist: tree-sitter-rust>=0.23.0
 Provides-Extra: office
 Requires-Dist: python-docx<2.0,>=1.1.0; extra == "office"
 Requires-Dist: openpyxl<4.0,>=3.1.0; extra == "office"

{knowledge_master-0.2.0 → knowledge_master-0.4.0}/knowledge_master.egg-info/SOURCES.txt

@@ -9,10 +9,12 @@ knowledge_master/cli.py
 knowledge_master/connectors.py
 knowledge_master/embeddings.py
 knowledge_master/intelligence.py
+knowledge_master/migrations.py
 knowledge_master/rerank.py
 knowledge_master/server.py
 knowledge_master/static_analysis.py
 knowledge_master/store.py
+knowledge_master/ts_parsers.py
 knowledge_master/watcher.py
 knowledge_master/web.py
 knowledge_master.egg-info/PKG-INFO

{knowledge_master-0.2.0 → knowledge_master-0.4.0}/knowledge_master.egg-info/requires.txt

@@ -7,6 +7,11 @@ rich<15.0,>=14.0.0
 fastapi<1.0,>=0.115.0
 uvicorn<1.0,>=0.34.0
 pyyaml>=6.0
+tree-sitter>=0.23.0
+tree-sitter-javascript>=0.23.0
+tree-sitter-typescript>=0.23.0
+tree-sitter-go>=0.23.0
+tree-sitter-rust>=0.23.0
 
 [dev]
 pytest>=8.0

{knowledge_master-0.2.0 → knowledge_master-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "knowledge-master"
-version = "0.2.0"
+version = "0.4.0"
 description = "Local-first knowledge graph for developers. Your AI agent's permanent memory."
 requires-python = ">=3.11"
 license = {text = "MIT"}
@@ -27,6 +27,11 @@ dependencies = [
     "fastapi>=0.115.0,<1.0",
     "uvicorn>=0.34.0,<1.0",
     "pyyaml>=6.0",
+    "tree-sitter>=0.23.0",
+    "tree-sitter-javascript>=0.23.0",
+    "tree-sitter-typescript>=0.23.0",
+    "tree-sitter-go>=0.23.0",
+    "tree-sitter-rust>=0.23.0",
 ]
 
 [project.optional-dependencies]

knowledge_master-0.2.0/knowledge_master/static_analysis.py

@@ -1,141 +0,0 @@
-"""Static analysis — extract import graphs, symbols, and call relationships from code."""
-
-import ast
-import os
-from pathlib import Path
-
-
-def extract_python_graph(file_path: str) -> dict:
-    """Extract imports, exports (top-level functions/classes), and calls from a Python file."""
-    try:
-        source = Path(file_path).read_text(errors="ignore")
-        tree = ast.parse(source)
-    except (SyntaxError, ValueError):
-        return {"imports": [], "exports": [], "calls": [], "path": file_path}
-
-    imports = []
-    exports = []
-    calls = []
-
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                imports.append({"module": alias.name, "alias": alias.asname, "names": []})
-        elif isinstance(node, ast.ImportFrom):
-            imports.append({
-                "module": node.module or "",
-                "names": [a.name for a in node.names],
-                "level": node.level,
-            })
-        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            if node.col_offset == 0:  # top-level function
-                exports.append({"name": node.name, "type": "function", "line": node.lineno})
-        elif isinstance(node, ast.ClassDef):
-            if node.col_offset == 0:  # top-level class
-                bases = [_node_name(b) for b in node.bases]
-                exports.append({"name": node.name, "type": "class", "line": node.lineno, "bases": bases})
-
-    return {"imports": imports, "exports": exports, "calls": calls, "path": file_path}
-
-
-def resolve_import(module: str, level: int, source_file: str, repo_root: str) -> str | None:
-    """Resolve an import to a file path within the repo."""
-    if level > 0:
-        # Relative import: go up `level` directories from source file's package
-        source_dir = Path(os.path.join(repo_root, source_file)).parent
-        for _ in range(level - 1):
-            source_dir = source_dir.parent
-        parts = module.split(".") if module else []
-        candidate = source_dir / Path(*parts) if parts else source_dir
-    else:
-        # Absolute import — check if it's a local module
-        parts = module.split(".")
-        candidate = Path(repo_root) / Path(*parts)
-
-    # Try as module.py or package/__init__.py
-    as_file = str(candidate) + ".py"
-    as_pkg = str(candidate / "__init__.py")
-
-    if os.path.exists(as_file):
-        return os.path.relpath(as_file, repo_root)
-    if os.path.exists(as_pkg):
-        return os.path.relpath(as_pkg, repo_root)
-
-    return None
-
-
-def build_import_graph(repo_path: str, graph):
-    """Walk a repo, extract Python imports, store as IMPORTS edges between File nodes."""
-    repo_path = str(Path(repo_path).resolve())
-    repo_name = Path(repo_path).name
-    py_files = list(Path(repo_path).rglob("*.py"))
-    py_files = [f for f in py_files if not any(
-        p in f.parts for p in (".venv", "venv", "node_modules", "__pycache__", ".git", "site-packages")
-    )]
-
-    file_exports = {}  # relative_path -> [exported symbols]
-    file_imports = {}  # relative_path -> [import info]
-
-    # Pass 1: collect exports and imports
-    for py_file in py_files:
-        relative = os.path.relpath(str(py_file), repo_path)
-        result = extract_python_graph(str(py_file))
-        file_exports[relative] = result["exports"]
-        file_imports[relative] = result["imports"]
-
-        # Store Function/Class nodes
-        for export in result["exports"]:
-            node_type = "Function" if export["type"] == "function" else "Class"
-            graph.query(
-                f"MERGE (s:{node_type} {{name: $name, file: $file, repo: $repo}}) SET s.line = $line",
-                params={"name": export["name"], "file": relative, "repo": repo_name, "line": export["line"]},
-            )
-            # Link symbol to file
-            graph.query(
-                f"""MATCH (s:{node_type} {{name: $name, file: $file}}), (d:Document {{path: $file}})
-                    MERGE (s)-[:DEFINED_IN]->(d)""",
-                params={"name": export["name"], "file": relative},
-            )
-
-    # Pass 2: resolve imports to file paths, create IMPORTS edges
-    edges_created = 0
-    for source_file, imports in file_imports.items():
-        for imp in imports:
-            module = imp.get("module", "")
-            level = imp.get("level", 0)
-            names = imp.get("names", [])
-
-            if module:
-                # from module import X  or  import module
-                target_file = resolve_import(module, level, source_file, repo_path)
-                if target_file and target_file in file_exports:
-                    graph.query(
-                        """MERGE (src:Document {path: $src})
-                           MERGE (dst:Document {path: $dst})
-                           MERGE (src)-[:IMPORTS {names: $names}]->(dst)""",
-                        params={"src": source_file, "dst": target_file, "names": names},
-                    )
-                    edges_created += 1
-            elif level > 0 and names:
-                # from . import module1, module2 — each name is a sibling module
-                for name in names:
-                    target_file = resolve_import(name, level, source_file, repo_path)
-                    if target_file and target_file in file_exports:
-                        graph.query(
-                            """MERGE (src:Document {path: $src})
-                               MERGE (dst:Document {path: $dst})
-                               MERGE (src)-[:IMPORTS {names: $imp_names}]->(dst)""",
-                            params={"src": source_file, "dst": target_file, "imp_names": [name]},
-                        )
-                        edges_created += 1
-
-    return {"files_analyzed": len(py_files), "import_edges": edges_created, "symbols": sum(len(v) for v in file_exports.values())}
-
-
-def _node_name(node) -> str:
-    """Get string name from an AST node."""
-    if isinstance(node, ast.Name):
-        return node.id
-    elif isinstance(node, ast.Attribute):
-        return f"{_node_name(node.value)}.{node.attr}"
-    return ""