codebase-cortex 0.1.0__py3-none-any.whl

codebase_cortex/git/diff_parser.py

@@ -0,0 +1,185 @@
+"""Parse git diffs into structured data."""
+
+from __future__ import annotations
+
+import os
+import re
+
+from git import Repo
+
+from codebase_cortex.state import FileChange
+
+CODE_EXTENSIONS = {
+    ".py", ".js", ".ts", ".tsx", ".jsx", ".java", ".go", ".rs",
+    ".rb", ".php", ".c", ".cpp", ".h", ".hpp", ".cs", ".swift",
+    ".kt", ".scala", ".sh", ".bash", ".yml", ".yaml", ".toml",
+    ".json", ".md", ".rst", ".txt",
+}
+SKIP_DIRS = {
+    ".git", ".venv", "venv", "node_modules", "__pycache__",
+    ".pytest_cache", "dist", "build", ".eggs", ".tox",
+    ".mypy_cache", ".ruff_cache", ".cortex",
+}
+
+
+def get_recent_diff(repo_path: str, commits: int = 1) -> str:
+    """Get the unified diff for the most recent commit(s).
+
+    Args:
+        repo_path: Path to the git repository.
+        commits: Number of recent commits to include.
+
+    Returns:
+        Unified diff text, or empty string if no commits.
+    """
+    repo = Repo(repo_path)
+    if repo.head.is_detached or not list(repo.iter_commits(max_count=1)):
+        return ""
+
+    commits_list = list(repo.iter_commits(max_count=commits + 1))
+    if len(commits_list) < 2:
+        # Only one commit — show the root commit diff
+        return repo.git.diff_tree("--root", "--patch", "HEAD")
+
+    old = commits_list[-1]
+    return repo.git.diff(old.hexsha, "HEAD")
+
+
+def get_staged_diff(repo_path: str) -> str:
+    """Get the diff of currently staged changes.
+
+    Args:
+        repo_path: Path to the git repository.
+
+    Returns:
+        Unified diff of staged changes.
+    """
+    repo = Repo(repo_path)
+    return repo.git.diff("--cached")
+
+
+def parse_diff(diff_text: str) -> list[FileChange]:
+    """Parse unified diff text into structured FileChange objects.
+
+    Args:
+        diff_text: Raw unified diff output.
+
+    Returns:
+        List of FileChange dicts with path, status, additions, deletions, diff.
+    """
+    if not diff_text.strip():
+        return []
+
+    files: list[FileChange] = []
+    # Split on diff headers
+    file_diffs = re.split(r"(?=^diff --git )", diff_text, flags=re.MULTILINE)
+
+    for file_diff in file_diffs:
+        if not file_diff.strip():
+            continue
+
+        # Extract file path
+        header_match = re.match(r"diff --git a/(.*?) b/(.*)", file_diff)
+        if not header_match:
+            continue
+
+        old_path = header_match.group(1)
+        new_path = header_match.group(2)
+
+        # Determine status
+        if "new file mode" in file_diff:
+            status = "added"
+        elif "deleted file mode" in file_diff:
+            status = "deleted"
+        elif old_path != new_path:
+            status = "renamed"
+        else:
+            status = "modified"
+
+        # Count additions and deletions
+        additions = 0
+        deletions = 0
+        for line in file_diff.split("\n"):
+            if line.startswith("+") and not line.startswith("+++"):
+                additions += 1
+            elif line.startswith("-") and not line.startswith("---"):
+                deletions += 1
+
+        files.append(
+            FileChange(
+                path=new_path,
+                status=status,
+                additions=additions,
+                deletions=deletions,
+                diff=file_diff,
+            )
+        )
+
+    return files
+
+
+def get_full_codebase_summary(repo_path: str) -> str:
+    """Walk all source files in a repo and build a virtual diff summary.
+
+    This is intended for documenting existing projects that have no
+    documentation yet.  It produces a structured text block that looks
+    like a diff and can be passed directly to the CodeAnalyzer LLM.
+
+    Args:
+        repo_path: Absolute path to the root of the repository.
+
+    Returns:
+        A formatted string summarising every source file (path, line
+        count, first 200 lines).  The total output is truncated to
+        ~50 000 characters to stay within LLM context limits.
+    """
+    max_chars = 50_000
+    max_preview_lines = 200
+
+    parts: list[str] = []
+    file_count = 0
+
+    for dirpath, dirnames, filenames in os.walk(repo_path):
+        # Prune directories we should skip (in-place so os.walk skips them)
+        dirnames[:] = [
+            d for d in dirnames if d not in SKIP_DIRS
+        ]
+
+        for filename in sorted(filenames):
+            ext = os.path.splitext(filename)[1]
+            if ext not in CODE_EXTENSIONS:
+                continue
+
+            full_path = os.path.join(dirpath, filename)
+            rel_path = os.path.relpath(full_path, repo_path)
+
+            try:
+                with open(full_path, "r", encoding="utf-8", errors="replace") as fh:
+                    lines = fh.readlines()
+            except (OSError, UnicodeDecodeError):
+                continue
+
+            line_count = len(lines)
+            preview = "".join(lines[:max_preview_lines])
+            if line_count > max_preview_lines:
+                preview += f"\n... ({line_count - max_preview_lines} more lines)\n"
+
+            entry = (
+                f"--- /dev/null\n"
+                f"+++ b/{rel_path}\n"
+                f"## File: {rel_path} | {line_count} lines\n"
+                f"{preview}\n"
+            )
+            parts.append(entry)
+            file_count += 1
+
+    header = (
+        f"# Full Codebase Summary — {file_count} files\n"
+        f"# Repository: {repo_path}\n\n"
+    )
+    body = header + "\n".join(parts)
+
+    if len(body) > max_chars:
+        body = body[:max_chars] + "\n\n... [truncated at 50000 characters]\n"
+
+    return body

codebase_cortex/git/github_client.py

@@ -0,0 +1,46 @@
+"""GitHub client for remote repository access (optional)."""
+
+from __future__ import annotations
+
+from github import Github, Auth
+
+from codebase_cortex.config import Settings
+
+
+def get_github_client(settings: Settings) -> Github | None:
+    """Create a GitHub client if a token is available.
+
+    Returns None if no token is configured.
+    """
+    if not settings.github_token:
+        return None
+    return Github(auth=Auth.Token(settings.github_token))
+
+
+def get_repo_info(settings: Settings) -> dict | None:
+    """Get basic repository info from GitHub.
+
+    Returns:
+        Dict with repo name, description, default branch, etc.
+        None if GitHub is not configured or repo_path is local.
+    """
+    client = get_github_client(settings)
+    if client is None:
+        return None
+
+    repo_path = settings.repo_path
+    if not repo_path.startswith("https://github.com"):
+        return None
+
+    # Extract owner/repo from URL
+    parts = repo_path.rstrip("/").split("/")
+    repo_name = f"{parts[-2]}/{parts[-1]}"
+
+    repo = client.get_repo(repo_name)
+    return {
+        "name": repo.full_name,
+        "description": repo.description,
+        "default_branch": repo.default_branch,
+        "language": repo.language,
+        "stars": repo.stargazers_count,
+    }

codebase_cortex/graph.py

@@ -0,0 +1,111 @@
+"""LangGraph StateGraph definition for the Cortex pipeline."""
+
+from __future__ import annotations
+
+from langgraph.graph import StateGraph, START, END
+
+from codebase_cortex.state import CortexState
+
+
+async def code_analyzer_node(state: CortexState) -> dict:
+    """Analyze git diffs and identify changes."""
+    from codebase_cortex.agents.code_analyzer import CodeAnalyzerAgent
+    from codebase_cortex.config import get_llm
+
+    agent = CodeAnalyzerAgent(get_llm())
+    return await agent.run(state)
+
+
+async def semantic_finder_node(state: CortexState) -> dict:
+    """Find semantically related documentation."""
+    from codebase_cortex.agents.semantic_finder import SemanticFinderAgent
+    from codebase_cortex.config import get_llm
+
+    agent = SemanticFinderAgent(get_llm())
+    return await agent.run(state)
+
+
+async def doc_writer_node(state: CortexState) -> dict:
+    """Write or update Notion documentation pages."""
+    from codebase_cortex.agents.doc_writer import DocWriterAgent
+    from codebase_cortex.config import get_llm
+
+    agent = DocWriterAgent(get_llm())
+    return await agent.run(state)
+
+
+async def task_creator_node(state: CortexState) -> dict:
+    """Create tasks for undocumented areas."""
+    from codebase_cortex.agents.task_creator import TaskCreatorAgent
+    from codebase_cortex.config import get_llm
+
+    agent = TaskCreatorAgent(get_llm())
+    return await agent.run(state)
+
+
+async def sprint_reporter_node(state: CortexState) -> dict:
+    """Generate sprint summary report."""
+    from codebase_cortex.agents.sprint_reporter import SprintReporterAgent
+    from codebase_cortex.config import get_llm
+
+    agent = SprintReporterAgent(get_llm())
+    return await agent.run(state)
+
+
+def should_run_docs(state: CortexState) -> str:
+    """Route based on whether we have analysis results to act on."""
+    if state.get("analysis"):
+        return "semantic_finder"
+    return "end"
+
+
+def should_run_sprint(state: CortexState) -> str:
+    """Route to sprint reporter if there are doc updates to report."""
+    if state.get("doc_updates") or state.get("tasks_created"):
+        return "sprint_reporter"
+    return "end"
+
+
+def build_graph() -> StateGraph:
+    """Build and compile the Cortex pipeline graph.
+
+    Pipeline flow:
+        code_analyzer -> semantic_finder -> doc_writer -> task_creator -> [sprint_reporter] -> END
+    """
+    graph = StateGraph(CortexState)
+
+    # Add nodes
+    graph.add_node("code_analyzer", code_analyzer_node)
+    graph.add_node("semantic_finder", semantic_finder_node)
+    graph.add_node("doc_writer", doc_writer_node)
+    graph.add_node("task_creator", task_creator_node)
+    graph.add_node("sprint_reporter", sprint_reporter_node)
+
+    # Entry point
+    graph.add_edge(START, "code_analyzer")
+
+    # Conditional: only proceed if analysis produced results
+    graph.add_conditional_edges(
+        "code_analyzer",
+        should_run_docs,
+        {"semantic_finder": "semantic_finder", "end": END},
+    )
+
+    # Linear flow through doc pipeline
+    graph.add_edge("semantic_finder", "doc_writer")
+    graph.add_edge("doc_writer", "task_creator")
+
+    # Conditional: sprint reporter only on schedule
+    graph.add_conditional_edges(
+        "task_creator",
+        should_run_sprint,
+        {"sprint_reporter": "sprint_reporter", "end": END},
+    )
+    graph.add_edge("sprint_reporter", END)
+
+    return graph
+
+
+def compile_graph():
+    """Build and compile the graph, ready for invocation."""
+    return build_graph().compile()

codebase_cortex/mcp_client.py

@@ -0,0 +1,94 @@
+"""Notion MCP client connection via Streamable HTTP."""
+
+from __future__ import annotations
+
+import json
+import logging
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from mcp.client.streamable_http import streamablehttp_client
+from mcp import ClientSession
+
+from codebase_cortex.auth.token_store import get_valid_token
+from codebase_cortex.config import Settings
+from codebase_cortex.utils.rate_limiter import NotionRateLimiter
+
+NOTION_MCP_URL = "https://mcp.notion.com/mcp"
+
+rate_limiter = NotionRateLimiter()
+
+
+class LoggingSession:
+    """Wrapper around ClientSession that logs all tool calls."""
+
+    def __init__(self, session: ClientSession):
+        self._session = session
+        self._logger = logging.getLogger("cortex")
+
+    async def call_tool(self, name: str, arguments: dict | None = None):
+        args_str = json.dumps(arguments, default=str)[:500] if arguments else "{}"
+        self._logger.debug(f"MCP CALL: {name}({args_str})")
+
+        result = await self._session.call_tool(name, arguments=arguments)
+
+        if result.isError:
+            self._logger.debug(f"MCP ERROR: {name} -> {result.content}")
+        else:
+            preview = ""
+            if result.content:
+                preview = result.content[0].text[:300]
+            self._logger.debug(f"MCP OK: {name} -> {preview}...")
+
+        return result
+
+    async def list_tools(self):
+        return await self._session.list_tools()
+
+    async def initialize(self):
+        return await self._session.initialize()
+
+
+@asynccontextmanager
+async def notion_mcp_session(settings: Settings) -> AsyncGenerator[ClientSession, None]:
+    """Create a raw MCP client session to Notion.
+
+    Handles token refresh and provides a connected session.
+    Wraps in LoggingSession when verbose mode is active.
+    """
+    token = await get_valid_token(settings.notion_token_path)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    async with streamablehttp_client(NOTION_MCP_URL, headers=headers) as (
+        read_stream,
+        write_stream,
+        _,
+    ):
+        async with ClientSession(read_stream, write_stream) as session:
+            await session.initialize()
+            from codebase_cortex.utils.logging import is_verbose
+            if is_verbose():
+                yield LoggingSession(session)
+            else:
+                yield session
+
+
+async def get_notion_tools(settings: Settings) -> list:
+    """Get LangChain-compatible tools from the Notion MCP server.
+
+    Returns a list of tools that can be bound to LangChain agents.
+    """
+    token = await get_valid_token(settings.notion_token_path)
+
+    client = MultiServerMCPClient(
+        {
+            "notion": {
+                "url": NOTION_MCP_URL,
+                "transport": "streamable_http",
+                "headers": {"Authorization": f"Bearer {token}"},
+            }
+        }
+    )
+    async with client:
+        return client.get_tools()