codetex 0.1.0__py3-none-any.whl

codetex/__init__.py

@@ -0,0 +1,3 @@
+"""Codetex — LLM-friendly repo summarizer."""
+
+__version__ = "0.1.0"

codetex/claude_code.py

@@ -0,0 +1,69 @@
+"""Claude Code CLI provider — shells out to `claude -p`."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+
+from codetex.provider import LLMError, SummarizeResult
+
+
+class ClaudeCodeProvider:
+    def __init__(self, max_concurrent: int = 2) -> None:
+        self._semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def summarize(
+        self, prompt: str, system: str | None = None
+    ) -> SummarizeResult:
+        async with self._semaphore:
+            cmd: list[str] = ["claude", "-p", "--output-format", "json"]
+            if system:
+                cmd.extend(["--system-prompt", system])
+            cmd.append(prompt)
+
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    *cmd,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, stderr = await proc.communicate()
+            except FileNotFoundError:
+                raise LLMError(
+                    "Claude Code CLI not found. "
+                    "Install it from https://claude.ai/code "
+                    "or use --provider anthropic."
+                )
+
+            if proc.returncode != 0:
+                raise LLMError(
+                    f"Claude Code CLI failed (exit {proc.returncode}): "
+                    f"{stderr.decode(errors='replace').strip()}"
+                )
+
+            try:
+                data = json.loads(stdout.decode())
+            except (json.JSONDecodeError, UnicodeDecodeError) as e:
+                raise LLMError(f"Failed to parse Claude Code response: {e}") from e
+
+            if data.get("is_error"):
+                msg = data.get("result", "unknown error")
+                raise LLMError(f"Claude Code error: {msg}")
+
+            usage = data.get("usage", {})
+            return SummarizeResult(
+                text=data.get("result", ""),
+                input_tokens=usage.get("input_tokens", 0),
+                output_tokens=usage.get("output_tokens", 0),
+            )
+
+    async def summarize_batch(
+        self,
+        prompts: list[str],
+        system: str | None = None,
+    ) -> list[SummarizeResult | LLMError]:
+        tasks = [self.summarize(p, system) for p in prompts]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        return [
+            r if isinstance(r, SummarizeResult) else LLMError(str(r)) for r in results
+        ]

codetex/cli.py

@@ -0,0 +1,149 @@
+"""CLI interface using Typer."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from codetex.indexer import index
+from codetex.provider import LLMProviderBase
+
+
+def _build_provider(provider_name: str, max_concurrent: int | None) -> LLMProviderBase:
+    if provider_name == "claude-code":
+        from codetex.claude_code import ClaudeCodeProvider
+        return ClaudeCodeProvider(max_concurrent=max_concurrent or 2)
+    elif provider_name == "anthropic":
+        from codetex.llm import AnthropicProvider
+        return AnthropicProvider(max_concurrent=max_concurrent or 5)
+    else:
+        raise ValueError(
+            f"Unknown provider: {provider_name!r}."
+            " Choose 'claude-code' or 'anthropic'."
+        )
+
+
+app = typer.Typer(
+    name="codetex",
+    help="LLM-friendly repo summarizer",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+async def _run_index(
+    path: Path,
+    folder: str | None,
+    force: bool,
+    dry_run: bool,
+    provider: LLMProviderBase,
+) -> None:
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Indexing...", total=None)
+
+        async def on_progress(step: str, current: int, total: int) -> None:
+            progress.update(task, description=step)
+
+        result = await index(
+            repo_path=path,
+            folder=folder,
+            force=force,
+            dry_run=dry_run,
+            on_progress=on_progress,
+            provider=provider,
+        )
+
+    console.print()
+    if result.mode == "dry_run":
+        console.print(
+            f"[yellow]Dry run:[/yellow] would index {result.files_indexed} files"
+        )
+        if result.files_added:
+            console.print(f"  Added: {result.files_added}")
+        if result.files_modified:
+            console.print(f"  Modified: {result.files_modified}")
+        if result.files_deleted:
+            console.print(f"  Deleted: {result.files_deleted}")
+    elif result.mode == "full":
+        console.print(
+            f"[green]Indexed {result.files_indexed} files[/green] "
+            f"({result.llm_calls} LLM calls, {result.tokens_used:,} tokens, "
+            f"{result.duration_seconds:.1f}s)"
+        )
+        console.print("  Output: .codetex/SUMMARY.md")
+        console.print(f"  Commit: {result.commit_sha[:7]}")
+    else:
+        console.print(
+            f"[green]Synced[/green] "
+            f"+{result.files_added} ~{result.files_modified} -{result.files_deleted} "
+            f"({result.llm_calls} LLM calls, {result.tokens_used:,} tokens, "
+            f"{result.duration_seconds:.1f}s)"
+        )
+        if result.files_indexed == 0 and result.files_deleted == 0:
+            console.print("  No changes detected")
+        console.print(f"  Commit: {result.commit_sha[:7]}")
+
+
+@app.command(name="index")
+def index_cmd(
+    path: Annotated[
+        Path,
+        typer.Argument(help="Path to the git repository"),
+    ] = Path("."),
+    folder: Annotated[
+        str | None,
+        typer.Option("--folder", "-f", help="Only index files under this path"),
+    ] = None,
+    force: Annotated[
+        bool,
+        typer.Option("--force", help="Force full re-index"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run", help="Show what would be indexed without calling LLM"
+        ),
+    ] = False,
+    provider_name: Annotated[
+        str,
+        typer.Option("--provider", "-p", help="LLM provider: claude-code or anthropic"),
+    ] = "claude-code",
+    max_concurrent: Annotated[
+        int | None,
+        typer.Option(
+            "--max-concurrent",
+            help="Max parallel LLM calls (default: 2 for claude-code, 5 for anthropic)",
+        ),
+    ] = None,
+) -> None:
+    """Index a repository and generate .codetex/SUMMARY.md."""
+    try:
+        provider = _build_provider(provider_name, max_concurrent)
+        asyncio.run(_run_index(path, folder, force, dry_run, provider))
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def serve() -> None:
+    """Start the MCP server (stdio transport)."""
+    from codetex.server import mcp_server
+
+    mcp_server.run(transport="stdio")
+
+
+def main() -> None:
+    app()

codetex/git.py

@@ -0,0 +1,97 @@
+"""Git subprocess wrapper."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+class GitError(Exception):
+    pass
+
+
+@dataclass
+class DiffResult:
+    added: list[str] = field(default_factory=list)
+    modified: list[str] = field(default_factory=list)
+    deleted: list[str] = field(default_factory=list)
+    renamed: list[tuple[str, str]] = field(default_factory=list)
+
+    @property
+    def total_changed(self) -> int:
+        return len(self.added) + len(self.modified) + len(self.deleted)
+
+
+async def _run(
+    *args: str, cwd: str | Path | None = None
+) -> tuple[str, str]:
+    proc = await asyncio.create_subprocess_exec(
+        "git",
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        cwd=cwd,
+    )
+    stdout_bytes, stderr_bytes = await proc.communicate()
+    stdout = stdout_bytes.decode("utf-8", errors="replace").strip()
+    stderr = stderr_bytes.decode("utf-8", errors="replace").strip()
+    if proc.returncode != 0:
+        raise GitError(f"git {args[0]} failed: {stderr or stdout}")
+    return stdout, stderr
+
+
+async def get_head_sha(repo_path: str | Path) -> str:
+    stdout, _ = await _run("rev-parse", "HEAD", cwd=repo_path)
+    return stdout
+
+
+async def get_repo_name(repo_path: str | Path) -> str:
+    path = Path(repo_path).resolve()
+    return path.name
+
+
+async def list_tracked_files(repo_path: str | Path) -> list[str]:
+    stdout, _ = await _run("ls-files", cwd=repo_path)
+    if not stdout:
+        return []
+    return stdout.splitlines()
+
+
+async def diff_name_status(
+    repo_path: str | Path, old_sha: str, new_sha: str
+) -> DiffResult:
+    stdout, _ = await _run(
+        "diff", "--name-status", f"{old_sha}..{new_sha}", cwd=repo_path
+    )
+    return _parse_diff_output(stdout)
+
+
+async def is_git_repo(path: str | Path) -> bool:
+    try:
+        await _run("rev-parse", "--git-dir", cwd=path)
+        return True
+    except (GitError, FileNotFoundError):
+        return False
+
+
+def _parse_diff_output(output: str) -> DiffResult:
+    result = DiffResult()
+    if not output:
+        return result
+    for line in output.splitlines():
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        status = parts[0]
+        if status == "A":
+            result.added.append(parts[1])
+        elif status == "M":
+            result.modified.append(parts[1])
+        elif status == "D":
+            result.deleted.append(parts[1])
+        elif status.startswith("R") and len(parts) >= 3:
+            result.renamed.append((parts[1], parts[2]))
+            result.added.append(parts[2])
+            result.deleted.append(parts[1])
+    return result

codetex/ignore.py

@@ -0,0 +1,83 @@
+"""File ignore filter using .gitignore-style patterns."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pathspec
+
+DEFAULT_EXCLUDES = {
+    ".git",
+    ".hg",
+    ".svn",
+    "__pycache__",
+    "node_modules",
+    ".venv",
+    "venv",
+    ".env",
+    ".tox",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".pytest_cache",
+    "dist",
+    "build",
+    ".eggs",
+    "*.egg-info",
+    ".codetex",
+}
+
+# Max file size to index (2 MB)
+MAX_FILE_SIZE = 2 * 1024 * 1024
+
+
+class IgnoreFilter:
+    def __init__(self, repo_path: str | Path) -> None:
+        self._repo_path = Path(repo_path)
+        self._spec = self._load_patterns()
+
+    def _load_patterns(self) -> pathspec.PathSpec:
+        patterns: list[str] = []
+        # Default excludes
+        for exc in sorted(DEFAULT_EXCLUDES):
+            patterns.append(exc)
+        # .gitignore
+        gitignore = self._repo_path / ".gitignore"
+        if gitignore.exists():
+            patterns.extend(
+                line
+                for line in gitignore.read_text(
+                    encoding="utf-8", errors="replace"
+                ).splitlines()
+                if line.strip() and not line.startswith("#")
+            )
+        # .codetexignore
+        codetexignore = self._repo_path / ".codetexignore"
+        if codetexignore.exists():
+            patterns.extend(
+                line
+                for line in codetexignore.read_text(
+                    encoding="utf-8", errors="replace"
+                ).splitlines()
+                if line.strip() and not line.startswith("#")
+            )
+        return pathspec.PathSpec.from_lines("gitignore", patterns)
+
+    def is_excluded(self, relative_path: str) -> bool:
+        if self._spec.match_file(relative_path):
+            return True
+        full_path = self._repo_path / relative_path
+        if full_path.is_file():
+            try:
+                if full_path.stat().st_size > MAX_FILE_SIZE:
+                    return True
+                # Binary detection: check for null bytes in first 8KB
+                with open(full_path, "rb") as f:
+                    chunk = f.read(8192)
+                    if b"\x00" in chunk:
+                        return True
+            except OSError:
+                return True
+        return False
+
+    def filter_files(self, files: list[str]) -> list[str]:
+        return [f for f in files if not self.is_excluded(f)]