cortexcode 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

cortexcode/cli/cli_bundle.py

@@ -0,0 +1,143 @@
+"""Bundle management - export/import pre-indexed code graphs."""
+
+import gzip
+import json
+import shutil
+import zipfile
+from pathlib import Path
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+
+BUNDLE_VERSION = "1.0"
+
+
+def export_bundle(index_path: Path, output_path: Path, name: str = None) -> Path:
+    """Export index as a shareable bundle."""
+    if not index_path.exists():
+        raise FileNotFoundError(f"Index not found at {index_path}")
+
+    with open(index_path) as f:
+        index_data = json.load(f)
+
+    bundle_name = name or index_data.get("project_root", "project")
+    bundle_name = Path(bundle_name).name
+
+    bundle_data = {
+        "version": BUNDLE_VERSION,
+        "name": bundle_name,
+        "exported": str(Path.cwd()),
+        "index": index_data,
+    }
+
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if not output_path.suffix:
+        output_path = output_path / f"{bundle_name}.ccb"
+
+    with gzip.open(output_path, "wt", encoding="utf-8") as f:
+        json.dump(bundle_data, f)
+
+    return output_path
+
+
+def import_bundle(bundle_path: Path, output_dir: Path) -> Path:
+    """Import a bundle and return the index path."""
+    with gzip.open(bundle_path, "rt", encoding="utf-8") as f:
+        bundle_data = json.load(f)
+
+    if bundle_data.get("version") != BUNDLE_VERSION:
+        raise ValueError(f"Unsupported bundle version: {bundle_data.get('version')}")
+
+    index_data = bundle_data["index"]
+
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    index_path = output_dir / "index.json"
+    with open(index_path, "w") as f:
+        json.dump(index_data, f, indent=2)
+
+    return index_path
+
+
+def list_bundle_info(bundle_path: Path) -> dict:
+    """Get info about a bundle without importing it."""
+    with gzip.open(bundle_path, "rt", encoding="utf-8") as f:
+        bundle_data = json.load(f)
+
+    index = bundle_data.get("index", {})
+    files = index.get("files", {})
+    symbols = sum(len(f.get("symbols", [])) for f in files.values())
+
+    return {
+        "name": bundle_data.get("name"),
+        "version": bundle_data.get("version"),
+        "exported_from": bundle_data.get("exported"),
+        "files": len(files),
+        "symbols": symbols,
+    }
+
+
+def handle_bundle_export(console: Console, path: str, output: str, name: str = None) -> None:
+    """CLI handler for bundle export."""
+    path = Path(path)
+    index_path = path / ".cortexcode" / "index.json"
+
+    if not index_path.exists():
+        console.print(f"[red]No index found at {index_path}[/red]")
+        console.print("Run [cyan]cortexcode index[/cyan] first")
+        return
+
+    output_path = Path(output) if output else Path.cwd()
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task("Exporting bundle...", total=None)
+        result = export_bundle(index_path, output_path, name)
+
+    size_kb = result.stat().st_size / 1024
+    console.print(f"[green]✓[/green] Bundle exported: {result} ({size_kb:.1f} KB)")
+
+
+def handle_bundle_import(console: Console, bundle_path: str, output: str = None) -> None:
+    """CLI handler for bundle import."""
+    bundle_path = Path(bundle_path)
+
+    if not bundle_path.exists():
+        console.print(f"[red]Bundle not found: {bundle_path}[/red]")
+        return
+
+    output_dir = Path(output) if output else Path.cwd() / ".cortexcode"
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task("Importing bundle...", total=None)
+        result = import_bundle(bundle_path, output_dir)
+
+    console.print(f"[green]✓[/green] Bundle imported: {result}")
+
+
+def handle_bundle_info(console: Console, bundle_path: str) -> None:
+    """CLI handler for bundle info."""
+    bundle_path = Path(bundle_path)
+
+    if not bundle_path.exists():
+        console.print(f"[red]Bundle not found: {bundle_path}[/red]")
+        return
+
+    info = list_bundle_info(bundle_path)
+
+    console.print(f"\n[bold cyan]Bundle: {info['name']}[/bold cyan]")
+    console.print(f"  Version:    {info['version']}")
+    console.print(f"  Exported:   {info['exported_from']}")
+    console.print(f"  Files:      {info['files']}")
+    console.print(f"  Symbols:    {info['symbols']}")

cortexcode/cli/cli_githook.py

@@ -0,0 +1,106 @@
+"""Git hook integration for auto-indexing."""
+
+import os
+import shutil
+import stat
+from pathlib import Path
+
+from rich.console import Console
+
+
+def install_githook(console: Console, hook_type: str = "post-commit") -> None:
+    """Install git hook for auto-indexing."""
+    git_dir = Path.cwd() / ".git"
+    hooks_dir = git_dir / "hooks"
+    
+    if not git_dir.exists():
+        console.print("[red]Not a git repository[/red]")
+        return
+    
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    
+    hook_content = f"""#!/bin/sh
+# CortexCode auto-index hook
+# Generated by cortexcode githook install
+
+# Only run on post-commit
+if [ "$CORTEXCODE_HOOK" != "post-commit" ]; then
+    exit 0
+fi
+
+# Check if index exists
+if [ -f ".cortexcode/index.json" ]; then
+    # Only re-index if there were changes to code files
+    CHANGED_FILES=$(git diff-tree -r --name-only --no-commit-id HEAD~1 HEAD -- "*.py" "*.js" "*.ts" "*.jsx" "*.tsx" "*.go" "*.rs" "*.java" "*.cs" 2>/dev/null)
+    if [ -n "$CHANGED_FILES" ]; then
+        cortexcode index -i 2>/dev/null || true
+    fi
+fi
+"""
+    
+    hook_path = hooks_dir / hook_type
+    hook_path.write_text(hook_content)
+    
+    hook_path.chmod(hook_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    
+    console.print(f"[green]✓[/green] Installed {hook_type} hook at {hook_path}")
+    console.print(f"[dim]Run 'CORTEXCODE_HOOK=post-commit git commit ...' to trigger auto-index[/dim]")
+
+
+def uninstall_githook(console: Console, hook_type: str = "post-commit") -> None:
+    """Remove git hook."""
+    git_dir = Path.cwd() / ".git"
+    hook_path = git_dir / "hooks" / hook_type
+    
+    if hook_path.exists():
+        hook_path.unlink()
+        console.print(f"[green]✓[/green] Removed {hook_type} hook")
+    else:
+        console.print(f"[yellow]No {hook_type} hook found[/yellow]")
+
+
+def install_pre_commit(console: Console) -> None:
+    """Install pre-commit hook for code quality checks."""
+    git_dir = Path.cwd() / ".git"
+    hooks_dir = git_dir / "hooks"
+    
+    if not git_dir.exists():
+        console.print("[red]Not a git repository[/red]")
+        return
+    
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    
+    hook_content = """#!/bin/sh
+# CortexCode pre-commit hook
+# Runs security scan before commit
+
+# Run security scan on staged files
+STAGED_PY=$(git diff --cached --name-only --diff-filter=ACM | grep '\\.py$' | head -10)
+if [ -n "$STAGED_PY" ]; then
+    echo "Running CortexCode security scan..."
+    cortexcode scan 2>/dev/null | head -20
+fi
+"""
+    
+    hook_path = hooks_dir / "pre-commit"
+    hook_path.write_text(hook_content)
+    
+    hook_path.chmod(hook_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    
+    console.print(f"[green]✓[/green] Installed pre-commit hook")
+    console.print(f"[dim]Security scan will run before each commit[/dim]")
+
+
+def handle_githook_install(console: Console, hook_type: str) -> None:
+    """CLI handler for githook install."""
+    install_githook(console, hook_type)
+
+
+def handle_githook_uninstall(console: Console, hook_type: str) -> None:
+    """CLI handler for githook uninstall."""
+    uninstall_githook(console, hook_type)
+
+
+def handle_githook_precommit(console: Console) -> None:
+    """CLI handler for pre-commit install."""
+    install_pre_commit(console)

cortexcode/cli/cli_jobs.py

@@ -0,0 +1,145 @@
+"""Background job tracking for indexing operations."""
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+
+JOBS_FILE = Path.home() / ".cortexcode" / "jobs.json"
+
+
+class JobTracker:
+    """Track background indexing jobs."""
+    
+    def __init__(self):
+        self.jobs: dict[str, dict] = {}
+        self.load()
+    
+    def load(self):
+        """Load jobs from disk."""
+        if JOBS_FILE.exists():
+            try:
+                self.jobs = json.loads(JOBS_FILE.read_text())
+            except:
+                self.jobs = {}
+    
+    def save(self):
+        """Save jobs to disk."""
+        JOBS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        JOBS_FILE.write_text(json.dumps(self.jobs, indent=2))
+    
+    def create(self, job_type: str, path: str, description: str = "") -> str:
+        """Create a new job."""
+        job_id = f"{job_type}_{int(time.time())}"
+        self.jobs[job_id] = {
+            "id": job_id,
+            "type": job_type,
+            "path": path,
+            "description": description,
+            "status": "running",
+            "created": time.time(),
+            "updated": time.time(),
+            "progress": 0,
+            "total": 100,
+            "message": "Starting...",
+        }
+        self.save()
+        return job_id
+    
+    def update(self, job_id: str, progress: int = None, total: int = None, message: str = None, status: str = None):
+        """Update a job."""
+        if job_id in self.jobs:
+            if progress is not None:
+                self.jobs[job_id]["progress"] = progress
+            if total is not None:
+                self.jobs[job_id]["total"] = total
+            if message is not None:
+                self.jobs[job_id]["message"] = message
+            if status is not None:
+                self.jobs[job_id]["status"] = status
+            self.jobs[job_id]["updated"] = time.time()
+            self.save()
+    
+    def complete(self, job_id: str, message: str = "Done"):
+        """Mark a job as complete."""
+        self.update(job_id, status="completed", message=message, progress=100)
+    
+    def fail(self, job_id: str, message: str = "Failed"):
+        """Mark a job as failed."""
+        self.update(job_id, status="failed", message=message)
+    
+    def get(self, job_id: str) -> dict | None:
+        """Get a job by ID."""
+        return self.jobs.get(job_id)
+    
+    def list(self, status: str = None) -> list[dict]:
+        """List all jobs, optionally filtered by status."""
+        jobs = list(self.jobs.values())
+        if status:
+            jobs = [j for j in jobs if j["status"] == status]
+        return sorted(jobs, key=lambda x: x["updated"], reverse=True)
+    
+    def clear(self, completed: bool = True):
+        """Clear completed or all jobs."""
+        if completed:
+            self.jobs = {k: v for k, v in self.jobs.items() if v["status"] == "running"}
+        else:
+            self.jobs = {}
+        self.save()
+
+
+def handle_jobs_list(console: Console, status: str = None) -> None:
+    """List all background jobs."""
+    tracker = JobTracker()
+    jobs = tracker.list(status)
+    
+    if not jobs:
+        console.print("[dim]No jobs found[/dim]")
+        return
+    
+    console.print(f"\n[bold]Background Jobs:[/bold]\n")
+    for job in jobs:
+        status_icon = {"running": "🔄", "completed": "✓", "failed": "✗"}[job["status"]]
+        status_color = {"running": "cyan", "completed": "green", "failed": "red"}[job["status"]]
+        
+        progress = job.get("progress", 0)
+        total = job.get("total", 100)
+        pct = int(progress / total * 100) if total > 0 else 0
+        
+        console.print(f"  {status_icon} [{status_color}]{job['id']}[/{status_color}]")
+        console.print(f"      {job['type']}: {job.get('path', 'N/A')}")
+        console.print(f"      Status: {job['status']} ({pct}%) - {job.get('message', '')}")
+        console.print()
+
+
+def handle_jobs_clear(console: Console, all: bool = False) -> None:
+    """Clear completed jobs."""
+    tracker = JobTracker()
+    tracker.clear(completed=not all)
+    console.print("[green]✓[/green] Jobs cleared")
+
+
+def handle_jobs_watch(console: Console, job_id: str) -> None:
+    """Watch a job's progress."""
+    tracker = JobTracker()
+    
+    while True:
+        job = tracker.get(job_id)
+        if not job:
+            console.print(f"[red]Job not found: {job_id}[/red]")
+            return
+        
+        progress = job.get("progress", 0)
+        total = job.get("total", 100)
+        pct = int(progress / total * 100) if total > 0 else 0
+        
+        console.print(f"\r[{job['status']}] {job['message']} ({pct}%)", end="")
+        
+        if job["status"] != "running":
+            console.print()
+            break
+        
+        time.sleep(1)

cortexcode/cli/cli_package.py

@@ -0,0 +1,201 @@
+"""Package indexing - index external packages (pip, npm, etc.)."""
+
+import importlib.util
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+
+LANGUAGE_LOCATIONS = {
+    "python": {
+        "site_packages": lambda: Path(sys.prefix) / "Lib" / "site-packages",
+        "src_patterns": ["**/*.py"],
+    },
+    "javascript": {
+        "site_packages": lambda: Path.cwd() / "node_modules",
+        "src_patterns": ["**/*.js", "**/*.ts", "**/*.jsx", "**/*.tsx"],
+    },
+    "typescript": {
+        "site_packages": lambda: Path.cwd() / "node_modules",
+        "src_patterns": ["**/*.ts", "**/*.tsx"],
+    },
+}
+
+
+def find_package_location(package_name: str, language: str) -> Path | None:
+    """Find where a package is installed."""
+    if language == "python":
+        try:
+            spec = importlib.util.find_spec(package_name)
+            if spec and spec.submodule_search_locations:
+                return Path(spec.submodule_search_locations[0]).parent
+        except Exception:
+            pass
+        
+        site_packages = Path(sys.prefix) / "Lib" / "site-packages"
+        if (site_packages / package_name).exists():
+            return site_packages / package_name
+        if (site_packages / f"{package_name}-*").exists():
+            for p in site_packages.glob(f"{package_name}-*"):
+                return p
+    
+    elif language in ("javascript", "typescript"):
+        node_modules = Path.cwd() / "node_modules" / package_name
+        if node_modules.exists():
+            return node_modules
+    
+    return None
+
+
+def index_package(package_name: str, language: str, output_dir: Path) -> dict:
+    """Index a package and return the index data."""
+    package_path = find_package_location(package_name, language)
+    
+    if not package_path:
+        raise FileNotFoundError(f"Package '{package_name}' not found. Install it first: pip install {package_name}")
+    
+    index_data = {
+        "project_root": str(package_path),
+        "last_indexed": "2024-01-01T00:00:00",
+        "languages": [language],
+        "files": {},
+        "call_graph": {},
+    }
+    
+    if language == "python":
+        for py_file in package_path.rglob("*.py"):
+            if "__pycache__" in str(py_file) or ".pyc" in str(py_file):
+                continue
+            
+            try:
+                content = py_file.read_text(encoding="utf-8", errors="ignore")
+            except:
+                continue
+            
+            symbols = []
+            for line_num, line in enumerate(content.split("\n"), 1):
+                line = line.strip()
+                
+                if line.startswith("def "):
+                    func_name = line[4:].split("(")[0].strip()
+                    if func_name and not func_name.startswith("_"):
+                        symbols.append({
+                            "name": func_name,
+                            "type": "function",
+                            "line": line_num,
+                            "params": [],
+                        })
+                
+                elif line.startswith("class "):
+                    class_name = line[6:].split("(")[0].strip()
+                    if class_name and not class_name.startswith("_"):
+                        symbols.append({
+                            "name": class_name,
+                            "type": "class",
+                            "line": line_num,
+                        })
+            
+            if symbols:
+                rel_path = py_file.relative_to(package_path)
+                index_data["files"][str(rel_path)] = {"symbols": symbols}
+    
+    elif language in ("javascript", "typescript"):
+        for js_file in package_path.rglob("*.js"):
+            try:
+                content = js_file.read_text(encoding="utf-8", errors="ignore")
+            except:
+                continue
+            
+            symbols = []
+            for line_num, line in enumerate(content.split("\n"), 1):
+                line = line.strip()
+                
+                if line.startswith("function ") or line.startswith("const ") and " = " in line:
+                    if "function " in line:
+                        func_name = line.split("function ")[1].split("(")[0].strip()
+                        sym_type = "function"
+                    else:
+                        func_name = line.split("const ")[1].split(" = ")[0].strip()
+                        sym_type = "function"
+                    
+                    if func_name and not func_name.startswith("_"):
+                        symbols.append({
+                            "name": func_name,
+                            "type": sym_type,
+                            "line": line_num,
+                        })
+                
+                elif line.startswith("class "):
+                    class_name = line.split("class ")[1].split(" ")[0].strip()
+                    if class_name and not class_name.startswith("_"):
+                        symbols.append({
+                            "name": class_name,
+                            "type": "class",
+                            "line": line_num,
+                        })
+            
+            if symbols:
+                rel_path = js_file.relative_to(package_path)
+                index_data["files"][str(rel_path)] = {"symbols": symbols}
+    
+    return index_data
+
+
+def handle_package_index(console: Console, package_name: str, language: str, output: str = None) -> None:
+    """CLI handler for package indexing."""
+    output_dir = Path(output) if output else Path.cwd() / ".cortexcode"
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task(f"Indexing package {package_name}...", total=None)
+        
+        try:
+            index_data = index_package(package_name, language, output_dir)
+            
+            output_dir.mkdir(parents=True, exist_ok=True)
+            index_path = output_dir / "index.json"
+            
+            existing = {}
+            if index_path.exists():
+                try:
+                    existing = json.loads(index_path.read_text())
+                except:
+                    pass
+            
+            for k, v in index_data.get("files", {}).items():
+                if k not in existing.get("files", {}):
+                    existing.setdefault("files", {})[k] = v
+            
+            index_path.write_text(json.dumps(existing, indent=2))
+            
+            console.print(f"[green]✓[/green] Indexed package: {package_name}")
+            console.print(f"  Files: {len(index_data.get('files', {}))}")
+            
+        except FileNotFoundError as e:
+            console.print(f"[red]Error:[/red] {e}")
+            console.print(f"[dim]Install with: pip install {package_name}[/dim]")
+
+
+def handle_package_list(console: Console) -> None:
+    """List available packages in site-packages/node_modules."""
+    console.print("\n[bold]Python packages:[/bold]")
+    site_packages = Path(sys.prefix) / "Lib" / "site-packages"
+    if site_packages.exists():
+        for p in sorted(site_packages.iterdir())[:20]:
+            if p.is_dir() and not p.name.startswith("_"):
+                console.print(f"  • {p.name}")
+    
+    console.print("\n[bold]JavaScript packages:[/bold]")
+    node_modules = Path.cwd() / "node_modules"
+    if node_modules.exists():
+        for p in sorted(node_modules.iterdir())[:20]:
+            if p.is_dir() and not p.name.startswith("_"):
+                console.print(f"  • {p.name}")