nelgraph 1.0.0__py3-none-any.whl

nelgraph/__init__.py

@@ -0,0 +1,185 @@
+"""
+GraphRAG Knowledge Base — Internal Python Module
+
+Cách dùng nhanh nhất:
+
+    import graphrag
+    graphrag.configure(codebase_path="/path/to/project", openrouter_api_key="sk-...")
+    graphrag.run_init()
+
+    ctx = graphrag.get_function_context("processOrder")
+    snap = graphrag.get_snapshot()
+    changes = graphrag.get_changes("abc123f")
+    graphrag.mark_tested("processOrder")
+"""
+
+# --- Public API ---
+from nelgraph.knowledge_base import (
+    get_function_context,
+    get_snapshot,
+    get_changes,
+    mark_tested,
+    search,
+    run_init,
+    run_sync,
+)
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "configure",
+    "get_function_context",
+    "get_snapshot",
+    "get_changes",
+    "mark_tested",
+    "search",
+    "run_init",
+    "run_sync",
+]
+
+
+def configure(
+    codebase_path: str = None,
+    openrouter_api_key: str = None,
+    neo4j_uri: str = None,
+    neo4j_password: str = None,
+    neo4j_user: str = None,
+    llm_model: str = None,
+    embedding_model: str = None,
+    embedding_dimensions: int = None,
+):
+    """
+    Cấu hình graphrag bằng code thay vì .env file.
+    Gọi hàm này TRƯỚC khi dùng bất kỳ function nào khác.
+
+    Args:
+        codebase_path:        Đường dẫn tuyệt đối đến codebase cần analyze.
+        openrouter_api_key:   API key của OpenRouter.
+        neo4j_uri:            URI kết nối Neo4j (default: bolt://127.0.0.1:7687).
+        neo4j_password:       Password Neo4j.
+        neo4j_user:           Username Neo4j (default: neo4j).
+        llm_model:            Model ID trên OpenRouter cho LLM enrichment.
+        embedding_model:      Model ID trên OpenRouter cho embeddings.
+        embedding_dimensions: Số chiều vector (default: 512).
+
+    Ví dụ:
+        graphrag.configure(
+            codebase_path="/home/user/opensourcepos",
+            openrouter_api_key="sk-or-...",
+        )
+    """
+    import os
+    import nelgraph.config as _cfg
+
+    if codebase_path:
+        import os as _os
+        codebase_path = _os.path.abspath(codebase_path).replace("\\", "/")
+        _cfg.CODEBASE_PATH = codebase_path
+        os.environ["CODEBASE_PATH"] = codebase_path
+
+        # Recalculate dependent paths
+        _cfg.GRAPHRAG_DATA_DIR = _os.path.join(codebase_path, ".graphrag_data").replace("\\", "/")
+        _cfg.NEO4J_DATA_DIR = _os.path.join(_cfg.GRAPHRAG_DATA_DIR, "neo4j", "data").replace("\\", "/")
+        _cfg.NEO4J_LOGS_DIR = _os.path.join(_cfg.GRAPHRAG_DATA_DIR, "neo4j", "logs").replace("\\", "/")
+        _cfg.CHROMA_PATH = _os.path.join(_cfg.GRAPHRAG_DATA_DIR, "chromadb").replace("\\", "/")
+        _cfg.SYNC_STATE_PATH = _os.path.join(_cfg.GRAPHRAG_DATA_DIR, "sync_state.json").replace("\\", "/")
+
+    if openrouter_api_key:
+        _cfg.OPENROUTER_API_KEY = openrouter_api_key
+        os.environ["OPENROUTER_API_KEY"] = openrouter_api_key
+        # Reset lazy clients so they pick up the new key
+        _reset_ai_clients()
+
+    if neo4j_uri:
+        _cfg.NEO4J_URI = neo4j_uri
+        os.environ["NEO4J_URI"] = neo4j_uri
+
+    if neo4j_password:
+        _cfg.NEO4J_PASSWORD = neo4j_password
+        os.environ["NEO4J_PASSWORD"] = neo4j_password
+        # Reset Neo4j singleton
+        import nelgraph.graph.neo4j_client as _nc
+        _nc._client = None
+
+    if neo4j_user:
+        _cfg.NEO4J_USER = neo4j_user
+
+    if llm_model:
+        _cfg.LLM_MODEL = llm_model
+
+    if embedding_model:
+        _cfg.EMBEDDING_MODEL = embedding_model
+
+    if embedding_dimensions:
+        _cfg.EMBEDDING_DIMENSIONS = embedding_dimensions
+
+
+def _reset_ai_clients():
+    """Reset tất cả lazy OpenAI client singletons để pick up config mới."""
+    try:
+        import nelgraph.embeddings.embedder as _emb
+        _emb._openai_client = None
+    except Exception:
+        pass
+    try:
+        import nelgraph.extractors.testing_enricher as _te
+        _te._client_ai = None
+    except Exception:
+        pass
+    try:
+        import nelgraph.extractors.llm_extractor as _le
+        _le._client = None
+    except Exception:
+        pass
+    try:
+        import nelgraph.community.summarizer as _sm
+        _sm._client_ai = None
+    except Exception:
+        pass
+
+
+def status() -> dict:
+    """
+    Trả về trạng thái hiện tại của graph.
+    Không cần Neo4j đang chạy — nếu không kết nối được thì báo offline.
+
+    Returns:
+        {
+            "neo4j": "connected" | "offline",
+            "codebase_path": "...",
+            "last_sync": "...",
+            "total_functions": 0,
+            "enriched_functions": 0,
+        }
+    """
+    import nelgraph.config as _cfg
+    from nelgraph.initialize_graph import _load_sync_state
+
+    result = {
+        "neo4j": "offline",
+        "codebase_path": _cfg.CODEBASE_PATH,
+        "last_sync": None,
+        "total_functions": 0,
+        "enriched_functions": 0,
+    }
+
+    sync_state = _load_sync_state()
+    if sync_state:
+        result["last_sync"] = sync_state.get("last_sync_time")
+
+    try:
+        from nelgraph.graph.neo4j_client import get_client
+        client = get_client()
+        stats = client.run("""
+            OPTIONAL MATCH (f:Function) WITH count(f) as total
+            OPTIONAL MATCH (f2:Function) WHERE f2.how_it_works IS NOT NULL
+            RETURN total, count(f2) as enriched
+        """)
+        if stats:
+            result["neo4j"] = "connected"
+            result["total_functions"] = stats[0]["total"]
+            result["enriched_functions"] = stats[0]["enriched"]
+    except Exception:
+        pass
+
+    return result

nelgraph/cli.py

@@ -0,0 +1,144 @@
+import click
+from rich.console import Console
+import os
+import sys
+import requests
+import nelgraph
+
+if sys.platform.startswith("win"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+console = Console()
+
+def _check_for_updates():
+    try:
+        # Check PyPI version dynamically (timeout after 2s to prevent CLI blocking)
+        res = requests.get("https://pypi.org/pypi/nelgraph/json", timeout=2)
+        latest = res.json()["info"]["version"]
+        from nelgraph import __version__
+        if latest != __version__:
+            console.print(
+                f"[yellow]Update available: {__version__} → {latest}[/yellow]\n"
+                f"Run: [bold]pip install --upgrade nelgraph[/bold]"
+            )
+    except Exception:
+        pass
+
+@click.group()
+def main():
+    """nelgraph — Codebase Knowledge Graph & Semantic Search CLI"""
+    _check_for_updates()
+
+def _install_git_hook(codebase_path: str):
+    git_dir = os.path.join(codebase_path, ".git")
+    if not os.path.exists(git_dir):
+        return
+    hooks_dir = os.path.join(git_dir, "hooks")
+    os.makedirs(hooks_dir, exist_ok=True)
+    hook_path = os.path.join(hooks_dir, "post-commit")
+    
+    # Simple shell hook to run nelgraph sync in background silently
+    hook_content = """#!/bin/sh
+# Auto-sync graph in background after commit
+nelgraph sync --silent &
+"""
+    try:
+        with open(hook_path, "w", newline="\n", encoding="utf-8") as f:
+            f.write(hook_content)
+        # Make hook executable
+        import stat
+        st = os.stat(hook_path)
+        os.chmod(hook_path, st.st_mode | stat.S_IEXEC)
+        console.print("[green]✓ Git post-commit hook installed successfully.[/green]")
+    except Exception as e:
+        console.print(f"[yellow]⚠ Warning: Could not install Git post-commit hook: {e}[/yellow]")
+
+@main.command()
+@click.option("--key", help="OpenRouter API key")
+@click.option("--path", default=".", help="Path to codebase (default: current dir)")
+def init(key, path):
+    """
+    Khởi tạo GraphRAG cho project hiện tại.
+    Tạo .env, start Neo4j Docker, parse + enrich toàn bộ codebase.
+    """
+    abs_path = os.path.abspath(path).replace("\\", "/")
+    
+    # Load env from target path if exists
+    from dotenv import load_dotenv
+    env_path = os.path.join(abs_path, ".env")
+    if os.path.exists(env_path):
+        load_dotenv(env_path)
+        
+    api_key = key or os.getenv("OPENROUTER_API_KEY")
+    if not api_key:
+        api_key = click.prompt("OpenRouter API key", hide_input=True)
+        
+    # Write or update .env in target directory
+    lines = []
+    if os.path.exists(env_path):
+        with open(env_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+            
+    has_key = False
+    has_path = False
+    new_lines = []
+    for line in lines:
+        if line.strip().startswith("OPENROUTER_API_KEY="):
+            new_lines.append(f"OPENROUTER_API_KEY={api_key}\n")
+            has_key = True
+        elif line.strip().startswith("CODEBASE_PATH="):
+            new_lines.append(f"CODEBASE_PATH={abs_path}\n")
+            has_path = True
+        else:
+            new_lines.append(line)
+            
+    if not has_key:
+        new_lines.append(f"OPENROUTER_API_KEY={api_key}\n")
+    if not has_path:
+        new_lines.append(f"CODEBASE_PATH={abs_path}\n")
+        
+    with open(env_path, "w", encoding="utf-8") as f:
+        f.writelines(new_lines)
+        
+    console.print(f"[green]✓ Configured {env_path}[/green]")
+    
+    # Programmatically configure nelgraph
+    nelgraph.configure(codebase_path=abs_path, openrouter_api_key=api_key)
+    
+    # Run full initialization pipeline
+    nelgraph.run_init()
+    
+    # Install git post-commit hook
+    _install_git_hook(abs_path)
+
+@main.command()
+@click.option("--silent", is_flag=True, help="Run silently without printing to stdout")
+def sync(silent):
+    """Sync thủ công — parse files đã thay đổi kể từ lần sync cuối."""
+    if silent:
+        # Redirect stdout/stderr to devnull
+        sys.stdout = open(os.devnull, 'w')
+        sys.stderr = open(os.devnull, 'w')
+        
+    # Run sync pipeline
+    nelgraph.run_sync()
+
+@main.command()
+def status():
+    """Xem trạng thái graph hiện tại."""
+    # Run status helper
+    from nelgraph.initialize_graph import run_status
+    run_status()
+
+@main.command()
+def watch():
+    """Chạy file watcher — tự sync khi có file thay đổi."""
+    from nelgraph.updater.watcher import start_watcher
+    start_watcher()
+
+if __name__ == "__main__":
+    main()

nelgraph/community/__init__.py

@@ -0,0 +1 @@
+# GraphRAG Community Detection and Summarization Package

nelgraph/community/detector.py

@@ -0,0 +1,68 @@
+import networkx as nx
+import igraph as ig
+import leidenalg
+from nelgraph.graph.neo4j_client import get_client
+
+
+def build_networkx_graph() -> nx.Graph:
+    """Convert Neo4j graph to NetworkX graph for algorithms."""
+    client = get_client()
+
+    G = nx.Graph()
+
+    # Get all nodes
+    nodes = client.run("MATCH (n) WHERE n.name IS NOT NULL RETURN elementId(n) as id, labels(n) as labels, n.name as name")
+    for record in nodes:
+        G.add_node(record["id"], name=record["name"], label=record["labels"][0] if record["labels"] else "Unknown")
+
+    # Get all edges
+    edges = client.run("MATCH (a)-[r]->(b) WHERE a.name IS NOT NULL AND b.name IS NOT NULL RETURN elementId(a) as from_id, elementId(b) as to_id, type(r) as rel_type")
+    for record in edges:
+        G.add_edge(record["from_id"], record["to_id"], rel_type=record["rel_type"])
+
+    print(f"[Community] NetworkX graph: {G.number_of_nodes()} nodes, {G.number_of_edges()} edges")
+    return G
+
+
+def detect_communities() -> dict:
+    """
+    Run Leiden algorithm via igraph/leidenalg.
+    Returns mapping node_id -> community_id.
+    Saves community_id to Neo4j nodes.
+    """
+    G = build_networkx_graph()
+    if G.number_of_nodes() == 0:
+        print("[Community] Empty graph, skipping community detection.")
+        return {}
+
+    # Convert NetworkX to igraph
+    nx_nodes = list(G.nodes())
+    node_id_map = {n: i for i, n in enumerate(nx_nodes)}
+
+    ig_graph = ig.Graph()
+    ig_graph.add_vertices(len(nx_nodes))
+
+    for u, v in G.edges():
+        ig_graph.add_edge(node_id_map[u], node_id_map[v])
+
+    # Run Leiden algorithm
+    partition = leidenalg.find_partition(ig_graph, leidenalg.ModularityVertexPartition)
+
+    # Build result mapping: neo4j_node_id -> community_id
+    result = {}
+    for community_id, members in enumerate(partition):
+        for member_idx in members:
+            neo4j_id = nx_nodes[member_idx]
+            result[neo4j_id] = community_id
+
+    print(f"[Community] Detected {len(partition)} communities.")
+
+    # Save community IDs to Neo4j
+    client = get_client()
+    for node_id, community_id in result.items():
+        client.run("""
+            MATCH (n) WHERE elementId(n) = $node_id
+            SET n.community_id = $community_id
+        """, {"node_id": node_id, "community_id": community_id})
+
+    return result

nelgraph/community/summarizer.py

@@ -0,0 +1,208 @@
+import openai
+import re
+from nelgraph.graph.neo4j_client import get_client
+
+_client_ai = None
+
+def _get_client_ai():
+    global _client_ai
+    if _client_ai is None:
+        import nelgraph.config as config
+        _client_ai = openai.OpenAI(
+            api_key=config.OPENROUTER_API_KEY,
+            base_url=config.OPENROUTER_BASE_URL,
+        )
+    return _client_ai
+
+
+def get_community_members(community_id: int) -> list[dict]:
+    """Get all nodes belonging to a community."""
+    client = get_client()
+    result = client.run("""
+        MATCH (n) WHERE n.community_id = $cid AND n.name IS NOT NULL
+        RETURN labels(n) as labels, n.name as name, n.description as description
+        LIMIT 50
+    """, {"cid": community_id})
+
+    return [{"type": r["labels"][0], "name": r["name"], "description": r["description"]} for r in result]
+
+
+def summarize_community(community_id: int) -> str:
+    """Use LLM to create a brief summary (~200 tokens) for a community."""
+    members = get_community_members(community_id)
+    if not members:
+        return ""
+
+    members_text = "\n".join([f"- [{m['type']}] {m['name']}: {m['description'] or ''}" for m in members[:30]])
+
+    prompt = f"""You are summarizing a cluster of related code elements for a developer knowledge graph.
+
+Community members:
+{members_text}
+
+Write a 2-3 sentence summary of this community that answers:
+1. What is the main purpose/theme of this group?
+2. What are the key elements?
+3. Any notable risks, tasks, or decisions?
+
+Keep it under 200 words. Be specific, not generic."""
+
+    import nelgraph.config as config
+    response = _get_client_ai().chat.completions.create(
+        model=config.LLM_MODEL,
+        max_tokens=300,
+        messages=[{"role": "user", "content": prompt}]
+    )
+
+    return response.choices[0].message.content.strip()
+
+
+def infer_community_name(community_id: int, summary: str) -> str:
+    """Use LLM to give a short name to a community."""
+    import nelgraph.config as config
+    response = _get_client_ai().chat.completions.create(
+        model=config.LLM_MODEL,
+        max_tokens=20,
+        messages=[{"role": "user", "content": f"Give a 2-4 word name for this code community. Return ONLY the name:\n\n{summary}"}]
+    )
+    return response.choices[0].message.content.strip()
+
+
+def summarize_all_communities():
+    """Summarize all communities and save to Neo4j and ChromaDB."""
+    client = get_client()
+
+    import chromadb
+    from nelgraph.config import CHROMA_PATH
+    from nelgraph.embeddings.embedder import embed_texts
+
+    chroma = chromadb.PersistentClient(path=CHROMA_PATH)
+    try:
+        chroma.delete_collection("community_summaries")
+    except Exception:
+        pass
+    comm_collection = chroma.get_or_create_collection("community_summaries")
+
+    # Get list of community IDs
+    result = client.run("MATCH (n) WHERE n.community_id IS NOT NULL RETURN DISTINCT n.community_id as cid ORDER BY cid")
+    community_ids = [r["cid"] for r in result]
+
+    print(f"[Community] Summarizing {len(community_ids)} communities...")
+
+    llm_count = 0
+    auto_count = 0
+
+    batch_ids, batch_docs, batch_metas = [], [], []
+
+    for cid in community_ids:
+        members = get_community_members(cid)
+        if not members:
+            continue
+
+        size = len(members)
+        if size < 3:
+            # Auto summarization for small communities
+            if size == 1:
+                name = f"Node: {members[0]['name']}"
+                summary = f"Isolated cluster containing element: {members[0]['name']} ({members[0]['type']})."
+            else:
+                name = f"Pair: {members[0]['name']} & {members[1]['name']}"
+                summary = f"Small cluster containing elements: {members[0]['name']} ({members[0]['type']}) and {members[1]['name']} ({members[1]['type']})."
+            auto_count += 1
+        else:
+            # LLM summarization for significant communities
+            members_text = "\n".join([f"- [{m['type']}] {m['name']}: {m['description'] or ''}" for m in members[:30]])
+            prompt = f"""You are summarizing a cluster of related code elements for a developer knowledge graph.
+
+Community members:
+{members_text}
+
+Task:
+1. Write a 2-3 sentence summary of this community that describes its main purpose/theme, key elements, and any notable risks, tasks, or decisions.
+2. Provide a short, 2-4 word name for this community.
+
+Return your response in the following format:
+NAME: <your 2-4 word name>
+SUMMARY: <your 2-3 sentence summary>"""
+
+            try:
+                import nelgraph.config as config
+                response = _get_client_ai().chat.completions.create(
+                    model=config.LLM_MODEL,
+                    max_tokens=350,
+                    messages=[{"role": "user", "content": prompt}]
+                )
+                text = response.choices[0].message.content.strip()
+
+                # Parse the name and summary
+                name = f"Community {cid}"
+                summary = ""
+
+                # Extract NAME
+                name_match = re.search(r"NAME:\s*(.*)", text, re.IGNORECASE)
+                if name_match:
+                    name = name_match.group(1).strip()
+                    name = name.strip('"\'*` ')
+
+                # Extract SUMMARY
+                summary_match = re.search(r"SUMMARY:\s*([\s\S]*)", text, re.IGNORECASE)
+                if summary_match:
+                    summary = summary_match.group(1).strip()
+                else:
+                    # Fallback parser
+                    lines = [line.strip() for line in text.split("\n") if line.strip()]
+                    summary_lines = [l for l in lines if not l.upper().startswith("NAME:")]
+                    summary = " ".join(summary_lines)
+
+                if not summary:
+                    summary = text
+
+            except Exception as e:
+                name = f"Community {cid}"
+                summary = f"Cluster of related code elements including {members[0]['name']}."
+            llm_count += 1
+
+        # Create Community node in Neo4j
+        client.run("""
+            MERGE (c:Community {id: $cid})
+            SET c.name = $name, c.summary = $summary
+        """, {"cid": cid, "name": name, "summary": summary})
+
+        # Create BELONGS_TO edges
+        client.run("""
+            MATCH (c:Community {id: $cid})
+            MATCH (n) WHERE n.community_id = $cid AND NOT n:Community
+            MERGE (n)-[:BELONGS_TO]->(c)
+        """, {"cid": cid})
+
+        # Queue for ChromaDB embedding
+        batch_ids.append(str(cid))
+        batch_docs.append(summary)
+        batch_metas.append({"id": cid, "name": name})
+
+        if size < 3:
+            print(f"  Community {cid} (Auto): '{name}'")
+        else:
+            print(f"  Community {cid} (LLM): '{name}'")
+
+    # Embed and upsert in ChromaDB using batches
+    if batch_docs:
+        print(f"[Chroma] Embedding {len(batch_docs)} community summaries...")
+        try:
+            all_vectors = []
+            for i in range(0, len(batch_docs), 50):
+                slice_docs = batch_docs[i:i+50]
+                vectors = embed_texts(slice_docs)
+                all_vectors.extend(vectors)
+
+            comm_collection.upsert(
+                ids=batch_ids,
+                documents=batch_docs,
+                metadatas=batch_metas,
+                embeddings=all_vectors
+            )
+            print("[Chroma] All community summaries embedded.")
+        except Exception as e:
+            print(f"[Chroma] Error embedding community summaries: {e}")
+
+    print(f"[Community] Summarization done. LLM calls: {llm_count}, Auto: {auto_count}.")

nelgraph/config.py

@@ -0,0 +1,79 @@
+import os
+from dotenv import load_dotenv
+
+# Load .env from the current working directory first, and fall back to the config directory
+load_dotenv()
+config_dir = os.path.dirname(os.path.abspath(__file__))
+load_dotenv(os.path.join(config_dir, ".env"))
+
+PROJECT_NAME = os.getenv("PROJECT_NAME", "GraphRAG-Project")
+
+
+
+# Target project to index. By default, it is the current working directory.
+CODEBASE_PATH = os.getenv("CODEBASE_PATH")
+if not CODEBASE_PATH:
+    CODEBASE_PATH = "."
+
+# If it's a relative path, resolve it relative to the current working directory
+if not os.path.isabs(CODEBASE_PATH):
+    CODEBASE_PATH = os.path.abspath(CODEBASE_PATH)
+
+CODEBASE_PATH = CODEBASE_PATH.replace("\\", "/")
+
+# GraphRAG data directory — stored inside the target codebase's .graphrag_data/
+GRAPHRAG_DATA_DIR = os.getenv("GRAPHRAG_DATA_DIR")
+if not GRAPHRAG_DATA_DIR:
+    GRAPHRAG_DATA_DIR = os.path.join(CODEBASE_PATH, ".graphrag_data")
+GRAPHRAG_DATA_DIR = GRAPHRAG_DATA_DIR.replace("\\", "/")
+
+# Supported languages for AST parsing
+SUPPORTED_LANGUAGES = {
+    ".py": "python",
+    ".js": "javascript",
+    ".ts": "typescript",
+    ".jsx": "javascript",
+    ".tsx": "typescript",
+    ".php": "php",
+}
+
+# Directories to skip during parsing
+IGNORE_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist", "build", ".next", ".cursor", ".claude", ".codex", ".gemini", ".ai-log"}
+tool_dir_name = os.path.basename(config_dir)
+if tool_dir_name and os.path.abspath(CODEBASE_PATH) != os.path.abspath(config_dir):
+    IGNORE_DIRS.add(tool_dir_name)
+
+# OpenRouter API (used for both LLM and embeddings)
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+
+# Model IDs on OpenRouter
+LLM_MODEL = os.getenv("LLM_MODEL", "deepseek/deepseek-v4-flash")
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "openai/text-embedding-3-large")
+EMBEDDING_DIMENSIONS = int(os.getenv("EMBEDDING_DIMENSIONS", "512"))
+ENRICH_MIN_COMPLEXITY = int(os.getenv("ENRICH_MIN_COMPLEXITY", "2"))
+
+# Neo4j
+NEO4J_URI = os.getenv("NEO4J_URI", "bolt://127.0.0.1:7687")
+import sys
+if sys.platform == "win32" and "localhost" in NEO4J_URI:
+    NEO4J_URI = NEO4J_URI.replace("localhost", "127.0.0.1")
+NEO4J_USER = os.getenv("NEO4J_USER", "neo4j")
+NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD", "graphrag123")
+
+# Neo4j data directories (for Docker volume mounts)
+NEO4J_DATA_DIR = os.path.join(GRAPHRAG_DATA_DIR, "neo4j", "data").replace("\\", "/")
+NEO4J_LOGS_DIR = os.path.join(GRAPHRAG_DATA_DIR, "neo4j", "logs").replace("\\", "/")
+
+# ChromaDB
+CHROMA_PATH = os.getenv("CHROMA_PATH")
+if not CHROMA_PATH:
+    CHROMA_PATH = os.path.join(GRAPHRAG_DATA_DIR, "chromadb")
+CHROMA_PATH = CHROMA_PATH.replace("\\", "/")
+
+# Sync state file for incremental updates
+SYNC_STATE_PATH = os.path.join(GRAPHRAG_DATA_DIR, "sync_state.json").replace("\\", "/")
+
+# GitHub (optional)
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN", "")
+GITHUB_REPO = os.getenv("GITHUB_REPO", "")  # format: "owner/repo"

nelgraph/core/__init__.py

@@ -0,0 +1 @@
+# GraphRAG Core package