devmind-cli 0.1.0__py3-none-any.whl

devmind/__init__.py

@@ -0,0 +1,2 @@
+# DevMind: Codebase Memory for Developers
+__version__ = "0.1.0"

devmind/cli.py

@@ -0,0 +1,285 @@
+# pyrefly: ignore [missing-import]
+import typer
+import sys
+import asyncio
+import os
+import logging
+import warnings
+
+# Suppress ResourceWarning and DeprecationWarning from aiohttp/asyncio during garbage collection
+warnings.filterwarnings("ignore", category=ResourceWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+# Suppress Windows proactor event loop SSL bugs during shutdown
+if sys.platform == 'win32':
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+from devmind.memory import initialize_cognee, remember_content, recall_query, improve_memory, forget_memory
+from devmind.ingestion.file_reader import scan_codebase_files
+from devmind.ingestion.git_parser import get_git_history
+from devmind.ingestion.comment_extractor import get_codebase_comments
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("devmind.cli")
+
+def run_async(coro):
+    """
+    Custom asyncio runner that sets an exception handler to swallow 
+    noisy Win32 socket teardown/closed event loop warnings on shutdown.
+    """
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    
+    def silence_exceptions(loop, context):
+        exc = context.get("exception")
+        msg = context.get("message", "")
+        # Swallows Win32 10038/not-a-socket/Event loop is closed warnings during exit
+        if (exc and ("Event loop is closed" in str(exc) or "10038" in str(exc) or "socket" in str(exc))) or "Event loop is closed" in msg or "SSL transport" in msg:
+            return
+        loop.default_exception_handler(context)
+        
+    loop.set_exception_handler(silence_exceptions)
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        try:
+            loop.run_until_complete(loop.shutdown_asyncgens())
+        except Exception:
+            pass
+        loop.close()
+
+app = typer.Typer(
+    name="devmind",
+    help="DevMind – Codebase Memory for Developers. Powered by Cognee.",
+    add_completion=False
+)
+
+async def remember_pipeline(directory: str):
+    """
+    Core async pipeline for scanning files, comments, and git logs,
+    and loading them into Cognee.
+    """
+    # 1. Scan the codebase files
+    files = scan_codebase_files(directory)
+    if not files:
+        typer.echo("No files found to ingest.")
+        return
+        
+    typer.echo(f"Ingesting {len(files)} files into Cognee memory...")
+    
+    # Ingest file contents
+    file_success = 0
+    for idx, file_data in enumerate(files, start=1):
+        rel_path = file_data["relative_path"]
+        content = file_data["content"]
+        
+        tagged_content = f"File Path: {rel_path}\n---\n{content}"
+        dataset_name = rel_path.replace("/", "_").replace("\\", "_").replace(".", "_").replace(" ", "_")
+        
+        logger.info(f"[{idx}/{len(files)}] Processing {rel_path}...")
+        success = await remember_content(tagged_content, dataset_name=dataset_name)
+        if success:
+            file_success += 1
+            
+    typer.echo(f"Successfully remembered {file_success}/{len(files)} files.")
+
+    # 2. Extract and Ingest Git History
+    git_logs = get_git_history(directory, max_commits=20)
+    if git_logs:
+        typer.echo(f"Ingesting git history ({len(git_logs)} commits) into Cognee...")
+        git_success = 0
+        for idx, commit_log in enumerate(git_logs, start=1):
+            dataset_name = f"git_commit_{idx}"
+            success = await remember_content(commit_log, dataset_name=dataset_name)
+            if success:
+                git_success += 1
+        typer.echo(f"Successfully remembered {git_success}/{len(git_logs)} commits.")
+
+    # 3. Extract and Ingest Inline Comments & Docstrings
+    relative_paths = [f["relative_path"] for f in files]
+    comments = get_codebase_comments(directory, relative_paths)
+    if comments:
+        typer.echo(f"Ingesting inline comments ({len(comments)} files containing comments)...")
+        comment_success = 0
+        for idx, comment_block in enumerate(comments, start=1):
+            dataset_name = f"code_comments_{idx}"
+            success = await remember_content(comment_block, dataset_name=dataset_name)
+            if success:
+                comment_success += 1
+        typer.echo(f"Successfully remembered {comment_success}/{len(comments)} comment segments.")
+
+@app.command()
+def remember(
+    directory: str = typer.Option(
+        ".", 
+        "--dir", "-d", 
+        help="The directory of the codebase to ingest."
+    )
+):
+    """
+    Ingest the codebase files into persistent Cognee memory.
+    """
+    initialize_cognee()
+    run_async(remember_pipeline(directory))
+    typer.echo("[Success] Codebase memory ingestion completed.")
+
+@app.command()
+def ask(
+    query: str = typer.Argument(..., help="Your natural language question about the codebase.")
+):
+    """
+    Ask a question about the ingested codebase memory in plain English.
+    """
+    initialize_cognee()
+    
+    typer.echo(f"Querying codebase memory for: '{query}'...")
+    answer = run_async(recall_query(query))
+    
+    typer.echo("\n--- Response ---")
+    typer.echo(answer)
+    typer.echo("----------------")
+
+@app.command()
+def chat():
+    """
+    Start an interactive DevMind terminal chat session to explore your codebase.
+    """
+    initialize_cognee()
+    
+    from rich.console import Console
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+    from rich.prompt import Prompt
+
+    console = Console()
+    console.print(Panel.fit("[bold blue]DevMind Codebase Chat[/bold blue]\n[dim]Type your queries below. Type 'exit' or 'quit' to close.[/dim]", border_style="blue"))
+    
+    while True:
+        try:
+            query = Prompt.ask("\n[bold green]You[/bold green]")
+            if not query.strip():
+                continue
+            if query.lower().strip() in ['exit', 'quit', 'clear']:
+                console.print("[dim]Goodbye![/dim]")
+                break
+                
+            with console.status("[bold cyan]DevMind is thinking...[/bold cyan]", spinner="dots"):
+                answer = run_async(recall_query(query))
+                
+            console.print("\n[bold magenta]DevMind:[/bold magenta]")
+            console.print(Markdown(answer))
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n[dim]Goodbye![/dim]")
+            break
+        except Exception as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+
+@app.command()
+def log(
+    decision: str = typer.Argument(..., help="The Architectural Decision Record (ADR) text to log.")
+):
+    """
+    Log an Architectural Decision Record (ADR) into persistent memory.
+    """
+    initialize_cognee()
+    typer.echo(f"Logging decision: '{decision}'...")
+    
+    tagged_decision = f"Architectural Decision Record:\n{decision}"
+    import time
+    dataset_name = f"adr_decision_{int(time.time())}"
+    
+    success = run_async(remember_content(tagged_decision, dataset_name=dataset_name))
+    if success:
+        typer.echo("[Success] Architectural decision successfully logged.")
+    else:
+        typer.echo("[Error] Failed to log architectural decision.")
+
+@app.command()
+def refresh(
+    directory: str = typer.Option(
+        ".", 
+        "--dir", "-d", 
+        help="The directory of the codebase to refresh."
+    )
+):
+    """
+    Refresh codebase memory by scanning for changed files and refining relationships.
+    """
+    initialize_cognee()
+    typer.echo("Scanning for codebase changes to refresh memory...")
+    run_async(remember_pipeline(directory))
+    
+    typer.echo("Refining the codebase memory graph structure...")
+    # Improve memory on all dataset partitions
+    success = run_async(improve_memory(dataset_name="codebase_memory"))
+    if success:
+        typer.echo("[Success] Memory refresh and relationship refinement completed.")
+    else:
+        typer.echo("[Warning] File changes re-ingested, but relationship refinement had warnings.")
+
+@app.command()
+def forget(
+    file_path: str = typer.Option(
+        None, 
+        "--file", "-f", 
+        help="The relative path of the file memory to forget."
+    ),
+    all_memories: bool = typer.Option(
+        False, 
+        "--all", "-a", 
+        help="Wipe all local memory databases completely."
+    )
+):
+    """
+    Surgically forget a specific file's memory, or completely wipe the local databases.
+    """
+    initialize_cognee()
+    
+    if all_memories:
+        typer.echo("Wiping all local memory databases...")
+        import shutil
+        from devmind.memory import system_path, data_path
+        try:
+            if os.path.exists(system_path):
+                shutil.rmtree(system_path)
+            if os.path.exists(data_path):
+                shutil.rmtree(data_path)
+            typer.echo("[Success] Local memory databases completely wiped.")
+        except Exception as e:
+            typer.echo(f"[Error] Failed to wipe memory folders: {e}")
+        return
+        
+    if file_path:
+        dataset_name = file_path.replace("/", "_").replace("\\", "_").replace(".", "_").replace(" ", "_")
+        typer.echo(f"Removing memory dataset '{dataset_name}'...")
+        success = run_async(forget_memory(dataset_name))
+        if success:
+            typer.echo(f"[Success] Memory of '{file_path}' successfully forgotten.")
+        else:
+            typer.echo(f"[Error] Failed to forget memory of '{file_path}'.")
+    else:
+        typer.echo("[Warning] Please specify either --file <path> to forget a file, or --all to wipe all databases.")
+
+@app.command()
+def dashboard(
+    port: int = typer.Option(8000, "--port", "-p", help="Port to run the dashboard server on.")
+):
+    """
+    Launch the DevMind Web UI dashboard.
+    """
+    import uvicorn
+    typer.echo(f"Starting DevMind Web UI Dashboard on http://localhost:{port} ...")
+    uvicorn.run("devmind.web.app:app", host="127.0.0.1", port=port, reload=False)
+
+@app.command()
+def mcp():
+    """
+    Start the DevMind MCP server for integration with Claude Code.
+    """
+    typer.echo("Starting DevMind MCP Server...")
+    from devmind.integrations.claude_code import mcp as mcp_instance
+    mcp_instance.run()
+
+if __name__ == "__main__":
+    app()

devmind/ingestion/comment_extractor.py

@@ -0,0 +1,91 @@
+import os
+import re
+import logging
+
+logger = logging.getLogger("devmind.comment_extractor")
+
+# Regex to find common developer tags in comments
+TAG_PATTERN = re.compile(r"\b(TODO|FIXME|NOTE|BUG|HACK|WARNING|ADR|DEPRECATED)\b", re.IGNORECASE)
+
+def extract_comments_from_file(file_path: str) -> list[str]:
+    """
+    Parses a single file, extracting inline comments and docstrings
+    that contain key developer tags (TODO, FIXME, NOTE, HACK, etc.).
+    """
+    extracted = []
+    _, ext = os.path.splitext(file_path.lower())
+    
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+            content = f.read()
+
+        lines = content.splitlines()
+
+        # 1. Python parsing (extract hash comments and triple-quoted docstrings)
+        if ext in (".py", ".sh", ".yaml", ".yml", ".ini"):
+            # Inline comment scanner
+            for idx, line in enumerate(lines, start=1):
+                comment_match = re.search(r"#\s*(.*)", line)
+                if comment_match:
+                    comment_text = comment_match.group(1).strip()
+                    if TAG_PATTERN.search(comment_text):
+                        extracted.append(f"Line {idx}: {comment_text}")
+
+            # Simple regex search for docstrings
+            docstrings = re.findall(r'"""(.*?)"""', content, re.DOTALL)
+            docstrings.extend(re.findall(r"'''(.*?)'''", content, re.DOTALL))
+            for doc in docstrings:
+                doc_clean = doc.strip()
+                if doc_clean:
+                    extracted.append(f"Docstring: {doc_clean}")
+
+        # 2. C-Style languages parsing (JS, TS, C, C++, Go, Java, Rust)
+        elif ext in (".js", ".ts", ".jsx", ".tsx", ".c", ".cpp", ".h", ".go", ".java", ".rs", ".css"):
+            # Inline comment scanner (// ...)
+            for idx, line in enumerate(lines, start=1):
+                comment_match = re.search(r"//\s*(.*)", line)
+                if comment_match:
+                    comment_text = comment_match.group(1).strip()
+                    if TAG_PATTERN.search(comment_text):
+                        extracted.append(f"Line {idx}: {comment_text}")
+
+            # Block comment scanner (/* ... */)
+            block_comments = re.findall(r"/\*(.*?)\*/", content, re.DOTALL)
+            for block in block_comments:
+                for idx, block_line in enumerate(block.splitlines(), start=1):
+                    block_line_clean = block_line.strip().lstrip("*").strip()
+                    if TAG_PATTERN.search(block_line_clean):
+                        extracted.append(f"Block Comment: {block_line_clean}")
+
+        # 3. HTML/XML/Markdown C-style comments (<!-- ... -->)
+        elif ext in (".html", ".htm", ".xml", ".md"):
+            html_comments = re.findall(r"<!--(.*?)-->", content, re.DOTALL)
+            for block in html_comments:
+                for block_line in block.splitlines():
+                    block_line_clean = block_line.strip()
+                    if TAG_PATTERN.search(block_line_clean):
+                        extracted.append(f"HTML Comment: {block_line_clean}")
+
+    except Exception as e:
+        logger.error(f"Error parsing comments from {file_path}: {e}")
+        
+    return extracted
+
+def get_codebase_comments(repo_path: str, source_files: list[str]) -> list[str]:
+    """
+    Loops through all project files and extracts formatted comments/docstrings.
+    Returns a list of structured comment records.
+    """
+    all_comments = []
+    logger.info("Scanning codebase for inline comments and docstrings...")
+    
+    for file_path in source_files:
+        abs_path = os.path.join(repo_path, file_path)
+        file_comments = extract_comments_from_file(abs_path)
+        
+        if file_comments:
+            comment_log = [f"File Path: {file_path}"]
+            comment_log.extend(file_comments)
+            all_comments.append("\n".join(comment_log))
+            
+    return all_comments

devmind/ingestion/file_reader.py

@@ -0,0 +1,92 @@
+import os
+import pathlib
+import logging
+
+logger = logging.getLogger("devmind.ingestion.file_reader")
+
+# Common directories to skip during scanning
+IGNORED_DIRS = {
+    ".git",
+    ".github",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "env",
+    "node_modules",
+    ".cognee_store",
+    ".pytest_cache",
+    "dist",
+    "build",
+    "eggs",
+    ".eggs",
+}
+
+# Supported file extensions for codebase reading
+SUPPORTED_EXTENSIONS = {
+    ".py", ".md", ".txt", ".js", ".ts", ".html", ".css", 
+    ".json", ".yaml", ".yml", ".ini", ".toml", ".sh", ".bat"
+}
+
+# Individual configuration files to include even if they don't have standard extensions
+EXPLICIT_FILES = {
+    "requirements.txt",
+    "setup.py",
+    "package.json",
+    "Dockerfile",
+    "Makefile",
+    "LICENSE",
+    "gitignore",
+    ".gitignore",
+    ".env.example",
+}
+
+def is_text_file(file_path: pathlib.Path) -> bool:
+    """
+    Check if a file should be read by extension or filename.
+    """
+    if file_path.suffix.lower() in SUPPORTED_EXTENSIONS:
+        return True
+    if file_path.name in EXPLICIT_FILES:
+        return True
+    return False
+
+def scan_codebase_files(root_dir: str) -> list[dict]:
+    """
+    Recursively scans the root directory for code and documentation files.
+    Returns a list of dicts:
+    [
+        {
+            "relative_path": "path/to/file.py",
+            "absolute_path": "/absolute/path/to/file.py",
+            "content": "file content..."
+        }
+    ]
+    """
+    root_path = pathlib.Path(root_dir).resolve()
+    logger.info(f"Scanning codebase files under: {root_path}")
+    
+    codebase_files = []
+    
+    for dirpath, dirnames, filenames in os.walk(root_path):
+        # Modify dirnames in place to skip ignored directories
+        dirnames[:] = [d for d in dirnames if d not in IGNORED_DIRS]
+        
+        for filename in filenames:
+            file_path = pathlib.Path(dirpath) / filename
+            
+            if is_text_file(file_path):
+                relative_path = file_path.relative_to(root_path)
+                try:
+                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                        content = f.read()
+                    
+                    codebase_files.append({
+                        "relative_path": str(relative_path),
+                        "absolute_path": str(file_path),
+                        "content": content
+                    })
+                except Exception as e:
+                    logger.warning(f"Skipping file {relative_path} due to read error: {e}")
+                    
+    logger.info(f"Scan complete. Found {len(codebase_files)} indexable files.")
+    return codebase_files

devmind/ingestion/git_parser.py

@@ -0,0 +1,72 @@
+import os
+import logging
+from git import Repo
+
+logger = logging.getLogger("devmind.git_parser")
+
+def get_git_history(repo_path: str, max_commits: int = 50) -> list[str]:
+    """
+    Scans the local git history of the project at repo_path.
+    Extracts commit messages, authors, dates, and diffs for each commit,
+    returning a list of formatted text logs ready for Cognee ingestion.
+    """
+    history_logs = []
+    try:
+        # Check if directory has a git repository initialized
+        git_dir = os.path.join(repo_path, ".git")
+        if not os.path.exists(git_dir):
+            logger.warning(f"No git repository found at '{repo_path}'. Skipping git log ingestion.")
+            return history_logs
+
+        repo = Repo(repo_path)
+        if repo.bare:
+            logger.warning(f"Git repository at '{repo_path}' is bare. Skipping git log ingestion.")
+            return history_logs
+
+        # Get commits on active branch
+        try:
+            commits = list(repo.iter_commits(max_count=max_commits))
+        except Exception:
+            logger.warning("No commits found in the repository (possibly empty). Skipping git history.")
+            return history_logs
+
+        logger.info(f"Extracting git history for the last {len(commits)} commits...")
+
+        for commit in commits:
+            commit_info = [
+                f"Commit Hash: {commit.hexsha}",
+                f"Author: {commit.author.name} <{commit.author.email}>",
+                f"Date: {commit.authored_datetime.isoformat()}",
+                f"Message: {commit.message.strip()}"
+            ]
+
+            # Extract list of files modified and the summary diffs
+            changed_files = []
+            if len(commit.parents) > 0:
+                # Diff against parent commit
+                parent = commit.parents[0]
+                diffs = parent.diff(commit, create_patch=True)
+                for d in diffs:
+                    file_path = d.b_path if d.b_path else d.a_path
+                    changed_files.append(file_path)
+                    
+                    # Truncate patch to avoid overwhelming token limits
+                    patch_text = d.diff.decode("utf-8", errors="ignore") if d.diff else ""
+                    if len(patch_text) > 1000:
+                        patch_text = patch_text[:1000] + "\n... [diff truncated for token optimization]"
+                    
+                    commit_info.append(f"\nDiff for {file_path}:\n{patch_text}")
+            else:
+                # Root commit (first commit has no parent)
+                for file_path in commit.stats.files.keys():
+                    changed_files.append(file_path)
+                commit_info.append(f"\nFiles added in root commit: {', '.join(changed_files)}")
+
+            commit_log = "\n".join(commit_info)
+            history_logs.append(commit_log)
+
+        return history_logs
+
+    except Exception as e:
+        logger.error(f"Error parsing git history: {e}", exc_info=True)
+        return history_logs

devmind/integrations/claude_code.py

@@ -0,0 +1,44 @@
+import os
+import time
+import asyncio
+from fastmcp import FastMCP
+from devmind.memory import recall_query, remember_content
+
+# Initialize FastMCP Server
+mcp = FastMCP(
+    "DevMind",
+    dependencies=["cognee", "fastmcp"]
+)
+
+@mcp.tool()
+async def query_codebase_memory(query: str) -> str:
+    """
+    Queries the DevMind persistent codebase memory for details about the codebase structure, 
+    design choices, git commit history, comments, and architectural decisions.
+    """
+    try:
+        answer = await recall_query(query)
+        return answer
+    except Exception as e:
+        return f"Error querying codebase memory: {e}"
+
+@mcp.tool()
+async def log_architectural_decision(decision: str) -> str:
+    """
+    Logs an Architectural Decision Record (ADR) into the codebase's persistent memory.
+    Use this when introducing major design changes, library switches, or design patterns.
+    """
+    try:
+        dataset_name = f"adr_decision_{int(time.time())}"
+        tagged_decision = f"Architectural Decision Record:\n{decision}"
+        success = await remember_content(tagged_decision, dataset_name=dataset_name)
+        if success:
+            return "Successfully logged architectural decision to memory."
+        else:
+            return "Failed to log architectural decision."
+    except Exception as e:
+        return f"Error logging decision: {e}"
+
+if __name__ == "__main__":
+    # Start the MCP server (running over stdin/stdout transport)
+    mcp.run()

devmind/memory.py

@@ -0,0 +1,261 @@
+import os
+import logging
+import random
+import asyncio
+from dotenv import load_dotenv
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("devmind.memory")
+
+# Load dotenv and set project-scoped directories BEFORE importing cognee
+load_dotenv()
+
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+system_path = os.path.join(project_root, ".cognee_system")
+data_path = os.path.join(project_root, ".cognee_data")
+
+os.makedirs(system_path, exist_ok=True)
+os.makedirs(os.path.join(system_path, "databases"), exist_ok=True)
+os.makedirs(data_path, exist_ok=True)
+
+# Set environment variables for Cognee root paths
+os.environ["SYSTEM_ROOT_DIRECTORY"] = system_path
+os.environ["DATA_ROOT_DIRECTORY"] = data_path
+os.environ["CACHE_ROOT_DIRECTORY"] = os.path.join(project_root, ".cognee_cache")
+os.environ["ENABLE_BACKEND_ACCESS_CONTROL"] = "false"
+os.environ["LOG_LEVEL"] = "WARNING"
+
+import cognee
+
+# Global list of keys for rotation
+_GROQ_API_KEYS = []
+
+def load_api_keys():
+    """
+    Loads all available Groq API keys from the environment.
+    Supports a comma-separated list via GROQ_API_KEYS, falling back to GROQ_API_KEY.
+    """
+    global _GROQ_API_KEYS
+    load_dotenv()
+    
+    # Read GROQ_API_KEYS comma-separated list
+    keys_str = os.getenv("GROQ_API_KEYS", "")
+    if keys_str:
+        _GROQ_API_KEYS = [k.strip() for k in keys_str.split(",") if k.strip()]
+    
+    # Fallback to single GROQ_API_KEY if not already in the list
+    single_key = os.getenv("GROQ_API_KEY", "")
+    if single_key and single_key not in _GROQ_API_KEYS:
+        _GROQ_API_KEYS.append(single_key)
+
+def get_random_api_key() -> tuple[str, str, str]:
+    """
+    Selects a random API key from the list (supports both Groq and OpenRouter keys)
+    and returns (key, endpoint, model) appropriate for that provider.
+    """
+    if not _GROQ_API_KEYS:
+        return "", "", ""
+    selected_key = random.choice(_GROQ_API_KEYS)
+    
+    # Auto-detect provider based on key prefix
+    if selected_key.startswith("sk-or-v1-"):
+        endpoint = "https://openrouter.ai/api/v1"
+        model = os.getenv("LLM_MODEL_OPENROUTER", "openrouter/meta-llama/llama-3.3-70b-instruct")
+        provider_name = "OpenRouter"
+    else:
+        endpoint = "https://api.groq.com/openai/v1"
+        model = os.getenv("LLM_MODEL_GROQ", "groq/llama-3.3-70b-versatile")
+        provider_name = "Groq"
+        
+    if len(selected_key) > 10:
+        masked = f"{selected_key[:6]}...{selected_key[-4:]}"
+    else:
+        masked = "***"
+    logger.info(f"Rotating LLM request key -> {masked} ({provider_name} key, model: {model})")
+    return selected_key, endpoint, model
+
+def initialize_cognee():
+    """
+    Loads configuration from .env and verifies LLM & Embedding provider setup.
+    """
+    load_dotenv()
+    load_api_keys()
+    
+    # Disable backend access control and authentication for local CLI use
+    os.environ["ENABLE_BACKEND_ACCESS_CONTROL"] = "false"
+    
+    # Apply storage paths to Cognee configuration
+    cognee.config.system_root_directory(system_path)
+    cognee.config.data_root_directory(data_path)
+    
+    llm_provider = os.getenv("LLM_PROVIDER", "groq").lower()
+    embedding_provider = os.getenv("EMBEDDING_PROVIDER", "fastembed").lower()
+    
+    # Cognee does not natively support "groq" in its LLMProvider enum.
+    # We map "groq" to the "custom" provider utilizing Groq's OpenAI-compatible endpoint.
+    if llm_provider == "groq":
+        groq_key, endpoint, model = get_random_api_key()
+        os.environ["LLM_PROVIDER"] = "custom"
+        os.environ["LLM_ENDPOINT"] = endpoint
+        os.environ["LLM_API_KEY"] = groq_key
+        
+        cognee.config.set_llm_provider("custom")
+        cognee.config.set_llm_endpoint(endpoint)
+        cognee.config.set_llm_api_key(groq_key)
+        cognee.config.set_llm_model(model)
+        if not groq_key:
+            print("[Error] No LLM API keys found. Please set GROQ_API_KEYS or GROQ_API_KEY in your .env file.")
+            import sys
+            sys.exit(1)
+    else:
+        openai_key = os.getenv("OPENAI_API_KEY", "")
+        cognee.config.set_llm_provider(llm_provider)
+        cognee.config.set_llm_model(os.getenv("LLM_MODEL", "openai/gpt-4o-mini"))
+        cognee.config.set_llm_api_key(openai_key)
+        if llm_provider == "openai" and not openai_key:
+            print("[Error] OPENAI_API_KEY is not set in your environment.")
+            import sys
+            sys.exit(1)
+
+    # Configure embedding provider
+    cognee.config.set_embedding_provider(embedding_provider)
+    cognee.config.set_embedding_model(os.getenv("EMBEDDING_MODEL", "BAAI/bge-small-en-v1.5"))
+    cognee.config.set_embedding_dimensions(int(os.getenv("EMBEDDING_DIMENSIONS", "384")))
+    
+    logger.info(f"Initializing DevMind memory layer...")
+    logger.info(f"LLM Provider: {llm_provider} (Mapped to custom OpenAI-compatible endpoint if groq)")
+    logger.info(f"Embedding Provider: {embedding_provider} (Model: {os.getenv('EMBEDDING_MODEL')})")
+    logger.info(f"System Storage Path: {system_path}")
+    logger.info(f"Data Storage Path: {data_path}")
+
+async def remember_content(content: str, dataset_name: str) -> bool:
+    """
+    Ingests text content into Cognee memory under a specified dataset name.
+    """
+    try:
+        # Rotate API key if we are on custom/groq rotation
+        llm_provider = os.getenv("LLM_PROVIDER", "groq").lower()
+        if llm_provider == "groq" or os.environ.get("LLM_PROVIDER") == "custom":
+            groq_key, endpoint, model = get_random_api_key()
+            if groq_key:
+                os.environ["LLM_API_KEY"] = groq_key
+                os.environ["LLM_ENDPOINT"] = endpoint
+                cognee.config.set_llm_endpoint(endpoint)
+                cognee.config.set_llm_api_key(groq_key)
+                cognee.config.set_llm_model(model)
+
+        logger.info(f"Remembering content in dataset '{dataset_name}'...")
+        await cognee.remember(content, dataset_name=dataset_name)
+        logger.info(f"Successfully remembered dataset '{dataset_name}'.")
+        return True
+    except Exception as e:
+        logger.error(f"Error during cognee.remember for '{dataset_name}': {e}", exc_info=True)
+        return False
+
+async def get_all_dataset_names() -> list[str]:
+    """
+    Fetches all registered dataset names from Cognee's relational metadata.
+    """
+    try:
+        from cognee.infrastructure.databases.relational import get_relational_engine
+        from sqlalchemy import select
+        from cognee.modules.data.models import Dataset
+        
+        engine = get_relational_engine()
+        async with engine.get_async_session() as session:
+            stmt = select(Dataset)
+            results = (await session.execute(stmt)).scalars().all()
+            return [d.name for d in results if d.name]
+    except Exception as e:
+        logger.warning(f"Could not fetch dataset names dynamically: {e}")
+        return []
+
+async def recall_query(query: str) -> str:
+    """
+    Queries the Cognee memory graph using natural language.
+    """
+    try:
+        # Rotate API key if we are on custom/groq rotation
+        llm_provider = os.getenv("LLM_PROVIDER", "groq").lower()
+        if llm_provider == "groq" or os.environ.get("LLM_PROVIDER") == "custom":
+            groq_key, endpoint, model = get_random_api_key()
+            if groq_key:
+                os.environ["LLM_API_KEY"] = groq_key
+                os.environ["LLM_ENDPOINT"] = endpoint
+                cognee.config.set_llm_endpoint(endpoint)
+                cognee.config.set_llm_api_key(groq_key)
+                cognee.config.set_llm_model(model)
+
+        logger.info(f"Recalling memory for query: '{query}'...")
+        datasets = await get_all_dataset_names()
+        from cognee.modules.search.types import SearchType
+        query_type = SearchType.RAG_COMPLETION
+        
+        if datasets:
+            logger.info(f"Searching across datasets individually in parallel: {datasets}")
+            # Query each dataset in parallel to bypass Cognee's single-dataset check
+            tasks = [cognee.recall(query_text=query, query_type=query_type, datasets=[d]) for d in datasets]
+            results_lists = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            results = []
+            for r_list in results_lists:
+                if isinstance(r_list, list):
+                    results.extend(r_list)
+                elif isinstance(r_list, Exception):
+                    logger.warning(f"Error recalling from a dataset partition: {r_list}")
+        else:
+            results = await cognee.recall(query_text=query, query_type=query_type)
+            
+        if not results:
+            return "No relevant memories found."
+        
+        # Cognee returns a list of result objects or dictionaries. 
+        # Format the output cleanly for console display.
+        formatted_results = []
+        for index, result in enumerate(results, start=1):
+            if hasattr(result, "text"):
+                formatted_results.append(result.text)
+            elif isinstance(result, dict) and "text" in result:
+                formatted_results.append(result["text"])
+            else:
+                formatted_results.append(str(result))
+                
+        return "\n\n".join(formatted_results)
+    except Exception as e:
+        logger.error(f"Error during cognee.recall for query '{query}': {e}", exc_info=True)
+        return f"Error recalling memory: {e}"
+
+async def improve_memory(dataset_name: str) -> bool:
+    """
+    Re-enriches and prunes relationships for a given dataset in Cognee.
+    """
+    try:
+        logger.info(f"Improving Cognee memory for dataset '{dataset_name}'...")
+        await cognee.improve(dataset=dataset_name)
+        logger.info(f"Successfully improved memory for dataset '{dataset_name}'.")
+        return True
+    except Exception as e:
+        logger.error(f"Error during cognee.improve for '{dataset_name}': {e}", exc_info=True)
+        return False
+
+async def forget_memory(dataset_name: str) -> bool:
+    """
+    Surgically deletes memory associated with a given dataset name.
+    """
+    try:
+        logger.info(f"Forgetting dataset '{dataset_name}' from Cognee memory...")
+        # Since cognee.forget might take dataset or dataset_name depending on local version,
+        # we try dataset first, then fallback to everything or other keywords if required.
+        try:
+            await cognee.forget(dataset=dataset_name)
+        except TypeError:
+            await cognee.forget(dataset_name=dataset_name)
+        logger.info(f"Successfully forgot dataset '{dataset_name}'.")
+        return True
+    except Exception as e:
+        if isinstance(e, AttributeError) and "'NoneType' object has no attribute 'id'" in str(e):
+            logger.info(f"Dataset '{dataset_name}' was not found in memory (it may have already been deleted or never ingested).")
+            return True
+        logger.error(f"Error during cognee.forget for '{dataset_name}': {e}", exc_info=True)
+        return False

devmind/web/app.py

@@ -0,0 +1,86 @@
+import os
+import sys
+import asyncio
+import logging
+
+import warnings
+
+# Suppress ResourceWarning and DeprecationWarning from aiohttp/asyncio during garbage collection
+warnings.filterwarnings("ignore", category=ResourceWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+# Suppress Windows proactor event loop SSL bugs during shutdown
+if sys.platform == 'win32':
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.templating import Jinja2Templates
+from devmind.memory import recall_query, remember_content, initialize_cognee
+from devmind.cli import remember_pipeline
+
+logger = logging.getLogger("devmind.web")
+
+app = FastAPI(title="DevMind Dashboard")
+
+# Initialize Cognee configurations
+initialize_cognee()
+
+# Create templates folder and configuration
+current_dir = os.path.dirname(os.path.abspath(__file__))
+templates_path = os.path.join(current_dir, "templates")
+os.makedirs(templates_path, exist_ok=True)
+templates = Jinja2Templates(directory=templates_path)
+
+@app.get("/", response_class=HTMLResponse)
+async def read_index(request: Request):
+    """
+    Renders the DevMind UI dashboard.
+    """
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.post("/api/ask")
+async def api_ask(payload: dict):
+    """
+    Handles natural language queries about the codebase.
+    """
+    query = payload.get("query", "")
+    if not query:
+        return JSONResponse({"error": "Query cannot be empty"}, status_code=400)
+    
+    try:
+        answer = await recall_query(query)
+        return {"answer": answer}
+    except Exception as e:
+        logger.error(f"Error querying memory: {e}")
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+@app.post("/api/log")
+async def api_log(payload: dict):
+    """
+    Saves an Architectural Decision Record (ADR) into memory.
+    """
+    decision = payload.get("decision", "")
+    if not decision:
+        return JSONResponse({"error": "Decision cannot be empty"}, status_code=400)
+    
+    try:
+        import time
+        dataset_name = f"adr_decision_{int(time.time())}"
+        success = await remember_content(f"Architectural Decision Record:\n{decision}", dataset_name=dataset_name)
+        return {"success": success}
+    except Exception as e:
+        logger.error(f"Error logging decision: {e}")
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+@app.post("/api/remember")
+async def api_remember(background_tasks: BackgroundTasks):
+    """
+    Triggers codebase re-ingestion asynchronously in the background.
+    """
+    try:
+        project_dir = os.getcwd()
+        background_tasks.add_task(remember_pipeline, project_dir)
+        return {"status": "ingested", "message": "Codebase memory re-ingestion started in the background."}
+    except Exception as e:
+        logger.error(f"Error triggering remember: {e}")
+        return JSONResponse({"error": str(e)}, status_code=500)

devmind_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: devmind-cli
+Version: 0.1.0
+Summary: DevMind - Semantic Codebase Memory and Agentic Search for Developers
+Author: Anishp-cell
+Project-URL: Homepage, https://github.com/Anishp-cell/devmind-CLI
+Project-URL: Issues, https://github.com/Anishp-cell/devmind-CLI/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cognee[fastembed]>=0.1.0
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.22.0
+Requires-Dist: gitpython>=3.1.30
+Requires-Dist: fastmcp>=0.1.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: jinja2>=3.1.2
+Requires-Dist: groq>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: isort>=5.12; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+
+# DevMind – Codebase Memory for Developers
+
+> "Your codebase finally has a memory."
+
+DevMind is a developer CLI tool and local web interface that gives your codebase a persistent, queryable memory powered by **Cognee**. It scans source files, git commit history, comments, and architectural decisions, building a hybrid graph-vector knowledge store. This persistent memory allows developers and AI coding assistants (via MCP) to query the codebase in plain English and carry context across infinite sessions.
+
+---
+
+## Features
+
+1. **One-Command Ingestion** (`devmind remember`): Scans the codebase, git logs, and code comments to feed `cognee.remember()`.
+2. **Plain-English Q&A** (`devmind ask "..."`): Uses `cognee.recall()` to retrieve grounded, context-aware answers from the memory graph.
+3. **Decision Logging** (`devmind log "..."`): Records Architecture Decision Records (ADRs) to capture design reasoning.
+4. **Memory Refresh** (`devmind refresh`): Automatically detects modified files, updates the graph, and runs `cognee.improve()`.
+5. **Surgical Forget** (`devmind forget --file ...`): Prunes specific file memory from the knowledge graph using `cognee.forget()`.
+6. **Claude Code MCP Server** (`devmind mcp`): Seamlessly integrates with Claude Code or Cursor via standard Model Context Protocol (MCP).
+7. **Local Dashboard UI** (`devmind dashboard`): Provides a clean visual panel showing memory status, search queries, and recent decisions.
+8. **Smart API Key Rotation**: Automatically detects, formats, and rotates between multiple Groq and OpenRouter API keys to balance rate limits on free-tier LLM access.
+
+---
+
+## Installation & Setup
+
+### 1. Clone the repository
+```bash
+git clone https://github.com/Anishp-cell/devmind-CLI.git
+cd devmind-CLI
+```
+
+### 2. Configure Environment Variables
+Copy `.env.example` to `.env` and fill in your keys:
+```bash
+cp .env.example .env
+```
+To run for **free**, configure your `.env` with a list of rotated API keys:
+```env
+LLM_PROVIDER="groq"
+
+# Add a comma-separated list of Groq keys (gsk_...) and/or OpenRouter keys (sk-or-v1-...)
+# The CLI automatically load-balances and routes requests to the correct endpoints!
+GROQ_API_KEYS="gsk_key1,sk-or-v1-key2,gsk_key3"
+
+EMBEDDING_PROVIDER="fastembed"
+EMBEDDING_MODEL="BAAI/bge-small-en-v1.5"
+EMBEDDING_DIMENSIONS="384"
+```
+
+### 3. Install DevMind
+Install the package in editable mode:
+```bash
+pip install -e .
+```
+
+---
+
+## CLI Command Reference
+
+*   **Ingest Codebase**:
+    ```bash
+    devmind remember
+    ```
+*   **Ask a Question**:
+    ```bash
+    devmind ask "Why did we switch to redis for the queue?"
+    ```
+*   **Log an Architectural Decision (ADR)**:
+    ```bash
+    devmind log "Chose FastAPI for the web UI because it supports async routes natively."
+    ```
+*   **Refresh Changed Memory**:
+    ```bash
+    devmind refresh
+    ```
+*   **Forget a Specific File**:
+    ```bash
+    devmind forget --file devmind/web/app.py
+    ```
+*   **Wipe Local Database Cache**:
+    ```bash
+    devmind forget --all
+    ```
+*   **Launch Web Dashboard**:
+    ```bash
+    devmind dashboard --port 8000
+    ```
+*   **Start MCP Server**:
+    ```bash
+    devmind mcp
+    ```
+
+---
+
+## Running the Mock Demo Project
+
+To test DevMind on a smaller project without polluting your main repo:
+1. Navigate to the demo directory:
+   ```bash
+   cd examples/demo_project
+   ```
+2. Build the memory of the demo:
+   ```bash
+   devmind remember --dir .
+   ```
+3. Query its memory:
+   ```bash
+   devmind ask "What open TODO tasks are left in main.py?"
+   devmind ask "Why do we use SQLite according to our architecture decisions?"
+   ```
+
+---
+
+## Claude Code MCP Integration
+
+To connect Claude Code to DevMind's memory, add the server to your Claude MCP config:
+
+```bash
+claude mcp add devmind "devmind mcp"
+```
+
+Alternatively, configure your project-level `.mcp.json` file in your project root:
+```json
+{
+  "mcpServers": {
+    "devmind": {
+      "command": "devmind",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+---
+
+## AI Assistant Declaration
+
+Per the rules of **The Hangover Part AI Hackathon**, this project declares the use of **Claude** (via the Antigravity IDE agent) as an AI pair programmer.

devmind_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+devmind/__init__.py,sha256=y9-PZTQC2r3AMAK95S8mBrriUKQ8oXl-NpckGK3grDc,64
+devmind/cli.py,sha256=IOmWf42d42rfo0zKVJs02P41mkxt4VYzJP_gN3ppY14,10240
+devmind/memory.py,sha256=wQZroWDg6LK-66mmvR640cBSVBmbL4fYQxQEROe8KwM,11120
+devmind/ingestion/comment_extractor.py,sha256=Q-tMymQ3xPhq8D6tOGyo_jXqxhVkLqOD6blwsLX41Go,3928
+devmind/ingestion/file_reader.py,sha256=9Wetq20moPt5rxGedkxE7zsJajar04pacYOy3glCh3Q,2683
+devmind/ingestion/git_parser.py,sha256=xA0zZeQGTUiCc7S4U1NbF3V7yQOZDgWPqyuhnPSxh3Y,2993
+devmind/integrations/claude_code.py,sha256=w2RKVjz57lyaiu2vhRf1SkcyFlFfJx0WhWTY1V82RNk,1470
+devmind/web/app.py,sha256=btsHTfU4YgZTf1oLc7LH7mAlaEbcxHyPJOQR1U_ugdU,3049
+devmind_cli-0.1.0.dist-info/METADATA,sha256=4NAfTgnBWWRYivqZ31Al4PSJ9Ojx6VPFv_7dmKB34qo,5479
+devmind_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+devmind_cli-0.1.0.dist-info/entry_points.txt,sha256=hVEkT2A4Eon0gRaBlw4KO_gpi6UHq5-qJ99aUO3hRfI,44
+devmind_cli-0.1.0.dist-info/top_level.txt,sha256=_DEg02cn_PSb0audseGNYo2Krcitio-Vuo_7duiIXGA,8
+devmind_cli-0.1.0.dist-info/RECORD,,

devmind_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devmind_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devmind = devmind.cli:app

devmind_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devmind