codecortex-context-engine 0.1.0a1__py3-none-any.whl

codecortex/engines/builtin/factory.py

@@ -0,0 +1,26 @@
+"""Default local engine assembly."""
+
+from __future__ import annotations
+
+from codecortex.config import CortexConfig
+from codecortex.core.contracts import MemoryStore
+from codecortex.engines.builtin.memory import MemoryEngine
+from codecortex.engines.builtin.repository import RepositoryEngine
+from codecortex.engines.builtin.symbols import SymbolEngine
+from codecortex.engines.builtin.validation import ValidationEngine
+from codecortex.engines.registry import EngineRegistry
+from codecortex.memory import JsonMemoryStore
+
+
+def build_default_registry(
+    config: CortexConfig,
+    memory_store: MemoryStore | None = None,
+) -> EngineRegistry:
+    config.ensure_directories()
+    memory = memory_store or JsonMemoryStore(config.memory_dir)
+    registry = EngineRegistry()
+    registry.register(RepositoryEngine(config.project_root))
+    registry.register(SymbolEngine(config.project_root))
+    registry.register(MemoryEngine(memory))
+    registry.register(ValidationEngine(config.project_root))
+    return registry

codecortex/engines/builtin/memory.py

@@ -0,0 +1,35 @@
+"""Memory search engine."""
+
+from __future__ import annotations
+
+from codecortex.core.contracts import Engine, MemoryStore
+from codecortex.core.models import AgentRequest, Capability, ContextChunk, EngineResult
+
+
+class MemoryEngine(Engine):
+    capability = Capability.MEMORY
+
+    def __init__(self, store: MemoryStore, namespace: str = "project") -> None:
+        self.store = store
+        self.namespace = namespace
+
+    async def health(self) -> bool:
+        return True
+
+    async def execute(self, request: AgentRequest) -> EngineResult:
+        matches = await self.store.search(self.namespace, request.query, limit=10)
+        content = "\n\n".join(matches) if matches else "No matching project memory found."
+        return EngineResult(
+            capability=self.capability,
+            content=content,
+            chunks=[
+                ContextChunk(
+                    source="project-memory",
+                    content=content,
+                    tokens=max(1, len(content) // 4),
+                    relevance=0.75 if matches else 0.20,
+                    metadata={"matches": len(matches)},
+                )
+            ],
+            metadata={"matches": len(matches)},
+        )

codecortex/engines/builtin/repository.py

@@ -0,0 +1,73 @@
+"""Graph-backed local repository intelligence engine."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from codecortex.core.contracts import Engine
+from codecortex.core.models import AgentRequest, Capability, ContextChunk, EngineResult
+from codecortex.indexing import ProjectIndexer
+
+
+class RepositoryEngine(Engine):
+    capability = Capability.REPOSITORY
+
+    def __init__(self, project_root: Path, max_files: int = 5_000) -> None:
+        self.project_root = project_root.resolve()
+        self.max_files = max_files
+
+    async def health(self) -> bool:
+        return self.project_root.exists() and self.project_root.is_dir()
+
+    async def execute(self, request: AgentRequest) -> EngineResult:
+        graph = ProjectIndexer(self.project_root, max_files=self.max_files).build()
+        graph_path = self.project_root / ".codecortex" / "index" / "graph.json"
+        graph.save(graph_path)
+
+        counts = graph.counts()
+        matches = graph.search(request.query)
+        import_edges = sum(1 for edge in graph.edges if edge.kind == "imports")
+        define_edges = sum(1 for edge in graph.edges if edge.kind == "defines")
+
+        summary = [
+            f"Project root: {self.project_root}",
+            f"Graph nodes: {len(graph.nodes)}",
+            f"Graph edges: {len(graph.edges)}",
+            f"Files: {counts.get('file', 0)}",
+            f"Symbols: {define_edges}",
+            f"Import relationships: {import_edges}",
+        ]
+        if matches:
+            summary.append(
+                "Relevant graph nodes:\n"
+                + "\n".join(
+                    f"- {node.kind}: {node.name}"
+                    + (f" ({node.path}:{node.line or 1})" if node.path else "")
+                    for node in matches
+                )
+            )
+
+        content = "\n".join(summary)
+        return EngineResult(
+            capability=self.capability,
+            content=content,
+            chunks=[
+                ContextChunk(
+                    source="repository-graph",
+                    content=content,
+                    tokens=max(1, len(content) // 4),
+                    relevance=0.85,
+                    metadata={
+                        "nodes": len(graph.nodes),
+                        "edges": len(graph.edges),
+                        "matches": len(matches),
+                    },
+                )
+            ],
+            metadata={
+                "nodes": len(graph.nodes),
+                "edges": len(graph.edges),
+                "node_counts": counts,
+                "graph_path": str(graph_path),
+            },
+        )

codecortex/engines/builtin/symbols.py

@@ -0,0 +1,89 @@
+"""Local multi-language symbol intelligence engine."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from codecortex.core.contracts import Engine
+from codecortex.core.models import AgentRequest, Capability, ContextChunk, EngineResult
+from codecortex.symbols import SymbolProviderRegistry, SymbolRecord
+
+_EXCLUDED = {".git", ".codecortex", ".venv", "venv", "node_modules", "__pycache__"}
+
+
+class SymbolEngine(Engine):
+    capability = Capability.SYMBOLS
+
+    def __init__(self, project_root: Path, max_files: int = 5_000) -> None:
+        self.project_root = project_root.resolve()
+        self.max_files = max_files
+        self.providers = SymbolProviderRegistry()
+
+    async def health(self) -> bool:
+        return self.project_root.exists() and self.project_root.is_dir()
+
+    def _symbols(self) -> list[SymbolRecord]:
+        symbols: list[SymbolRecord] = []
+        count = 0
+        for path in self.project_root.rglob("*"):
+            if count >= self.max_files:
+                break
+            if not path.is_file() or not self.providers.supports(path):
+                continue
+            relative = path.relative_to(self.project_root)
+            if any(part in _EXCLUDED for part in relative.parts):
+                continue
+            count += 1
+            try:
+                source = path.read_text(encoding="utf-8")
+            except (OSError, UnicodeDecodeError):
+                continue
+            symbols.extend(self.providers.extract(path, source))
+        return symbols
+
+    async def execute(self, request: AgentRequest) -> EngineResult:
+        symbols = self._symbols()
+        terms = {
+            term.lower().strip(".,:;()[]{}")
+            for term in request.query.split()
+            if len(term) > 2
+        }
+        ranked: list[tuple[int, SymbolRecord]] = []
+        for symbol in symbols:
+            name = symbol.name.lower()
+            path = str(symbol.path.relative_to(self.project_root)).lower()
+            score = sum(
+                5 if term == name else 3 if term in name else 1 if term in path else 0
+                for term in terms
+            )
+            if score:
+                ranked.append((score, symbol))
+        ranked.sort(key=lambda item: (-item[0], item[1].line, item[1].name))
+        matches = [symbol for _, symbol in ranked[:50]]
+        lines = [
+            (
+                f"{symbol.language}:{symbol.kind} {symbol.name} — "
+                f"{symbol.path.relative_to(self.project_root)}:{symbol.line}"
+            )
+            for symbol in matches
+        ]
+        content = "\n".join(lines) if lines else "No matching symbols found."
+        languages = sorted({symbol.language for symbol in symbols})
+        return EngineResult(
+            capability=self.capability,
+            content=content,
+            chunks=[
+                ContextChunk(
+                    source="symbol-index",
+                    content=content,
+                    tokens=max(1, len(content) // 4),
+                    relevance=0.90 if matches else 0.30,
+                    metadata={"matches": len(matches), "languages": languages},
+                )
+            ],
+            metadata={
+                "symbols_indexed": len(symbols),
+                "matches": len(matches),
+                "languages": languages,
+            },
+        )

codecortex/engines/builtin/validation.py

@@ -0,0 +1,54 @@
+"""Local validation engine."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from codecortex.core.contracts import Engine
+from codecortex.core.models import AgentRequest, Capability, ContextChunk, EngineResult
+
+
+class ValidationEngine(Engine):
+    capability = Capability.VALIDATION
+
+    def __init__(self, project_root: Path, max_files: int = 2_000) -> None:
+        self.project_root = project_root.resolve()
+        self.max_files = max_files
+
+    async def health(self) -> bool:
+        return self.project_root.exists() and self.project_root.is_dir()
+
+    async def execute(self, request: AgentRequest) -> EngineResult:
+        del request
+        checked = 0
+        issues: list[str] = []
+        for path in self.project_root.rglob("*.py"):
+            if checked >= self.max_files:
+                break
+            if any(part in {".git", ".codecortex", ".venv", "venv", "__pycache__"} for part in path.parts):
+                continue
+            checked += 1
+            try:
+                ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+            except SyntaxError as exc:
+                relative = path.relative_to(self.project_root)
+                issues.append(f"{relative}:{exc.lineno}: {exc.msg}")
+            except (OSError, UnicodeDecodeError):
+                continue
+
+        content = "Python syntax validation passed." if not issues else "\n".join(issues[:100])
+        return EngineResult(
+            capability=self.capability,
+            content=content,
+            chunks=[
+                ContextChunk(
+                    source="validation",
+                    content=content,
+                    tokens=max(1, len(content) // 4),
+                    relevance=0.95,
+                    metadata={"issues": len(issues), "checked": checked},
+                )
+            ],
+            metadata={"checked": checked, "issues": len(issues)},
+        )

codecortex/engines/registry.py

@@ -0,0 +1,26 @@
+"""Capability-based engine registry."""
+
+from __future__ import annotations
+
+from codecortex.core.contracts import Engine
+from codecortex.core.models import Capability
+
+
+class EngineRegistry:
+    def __init__(self) -> None:
+        self._engines: dict[Capability, Engine] = {}
+
+    def register(self, engine: Engine) -> None:
+        self._engines[engine.capability] = engine
+
+    def get(self, capability: Capability) -> Engine | None:
+        return self._engines.get(capability)
+
+    def capabilities(self) -> list[Capability]:
+        return list(self._engines)
+
+    async def health(self) -> dict[Capability, bool]:
+        result: dict[Capability, bool] = {}
+        for capability, engine in self._engines.items():
+            result[capability] = await engine.health()
+        return result

codecortex/entrypoint.py

@@ -0,0 +1,266 @@
+"""Extended public CLI surface for packaging, backends, agent setup, and edits."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+import codecortex.cli as cli_module
+from codecortex.backends import (
+    BACKENDS,
+    BackendManager,
+    ContextBackendAdapter,
+    GraphBackendAdapter,
+    SymbolBackendAdapter,
+)
+from codecortex.cli import app
+from codecortex.editing import EditService
+from codecortex.integrations import AgentConfigurator, AgentTarget
+from codecortex.mcp.extended import run_stdio as extended_run_stdio
+from codecortex.runtime import build_runtime
+from codecortex.setup import ProjectSetup
+
+cli_module.run_stdio = extended_run_stdio
+
+console = Console()
+backend_app = typer.Typer(help="Install and inspect isolated intelligence backends.")
+agents_app = typer.Typer(help="Detect and configure coding-agent integrations.")
+edit_app = typer.Typer(help="Perform guarded language-server semantic edits.")
+app.add_typer(backend_app, name="backend")
+app.add_typer(agents_app, name="agents")
+app.add_typer(edit_app, name="edit")
+
+
+def _manager() -> BackendManager:
+    return BackendManager(timeout_seconds=1200)
+
+
+def _targets(value: str) -> tuple[str, ...]:
+    if value == "all":
+        return tuple(BACKENDS)
+    if value not in BACKENDS:
+        raise typer.BadParameter(f"expected one of: all, {', '.join(BACKENDS)}")
+    return (value,)
+
+
+def _adapter(key: str, root: Path, manager: BackendManager):
+    if key == "graph":
+        return GraphBackendAdapter(root, manager)
+    if key == "symbols":
+        return SymbolBackendAdapter(root, manager)
+    if key == "context":
+        return ContextBackendAdapter(root, manager)
+    raise KeyError(key)
+
+
+def _edit_service(path: Path) -> EditService:
+    return EditService(build_runtime(path.expanduser().resolve()))
+
+
+@app.command("version")
+def version_command() -> None:
+    try:
+        current = version("codecortex-context-engine")
+    except PackageNotFoundError:
+        current = "0+unknown"
+    console.print(current)
+
+
+@backend_app.command("list")
+def backend_list() -> None:
+    manager = _manager()
+    table = Table(title="CodeCortex Backends")
+    table.add_column("Backend")
+    table.add_column("Installed")
+    table.add_column("Revision")
+    table.add_column("Capabilities")
+    for key, spec in BACKENDS.items():
+        table.add_row(
+            key,
+            "yes" if manager.is_installed(spec) else "no",
+            spec.revision[:12],
+            ", ".join(spec.capabilities),
+        )
+    console.print(table)
+
+
+@backend_app.command("install")
+def backend_install(
+    target: Annotated[str, typer.Argument(help="graph, symbols, context, or all")] = "all",
+) -> None:
+    manager = _manager()
+    failures: list[str] = []
+    for key in _targets(target):
+        spec = BACKENDS[key]
+        console.print(f"Installing [bold]{key}[/bold] at {spec.revision[:12]}…")
+        try:
+            command = manager.ensure(spec)
+            console.print(f"[green]✓[/green] {key}: {command}")
+        except Exception as exc:
+            failures.append(key)
+            console.print(f"[red]✗[/red] {key}: {type(exc).__name__}: {exc}")
+    if failures:
+        raise typer.Exit(code=2)
+
+
+@backend_app.command("doctor")
+def backend_doctor(
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+) -> None:
+    root = path.expanduser().resolve()
+    manager = _manager()
+    table = Table(title="Backend Health")
+    table.add_column("Backend")
+    table.add_column("Installed")
+    table.add_column("Healthy")
+    table.add_column("Contract")
+    failed = False
+    for key in BACKENDS:
+        adapter = _adapter(key, root, manager)
+        status = adapter.status()
+        table.add_row(
+            key,
+            "yes" if status.installed else "no",
+            "yes" if status.healthy else "no",
+            f"v{status.contract_version}",
+        )
+        if status.installed and not status.healthy:
+            failed = True
+    console.print(table)
+    if failed:
+        raise typer.Exit(code=2)
+
+
+@backend_app.command("remove")
+def backend_remove(
+    target: Annotated[str, typer.Argument(help="graph, symbols, context, or all")],
+) -> None:
+    manager = _manager()
+    for key in _targets(target):
+        manager.remove(BACKENDS[key])
+        console.print(f"[green]Removed[/green] {key}")
+
+
+@agents_app.command("detect")
+def agents_detect(
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+) -> None:
+    found = AgentConfigurator(path).detect()
+    if not found:
+        console.print("No supported coding agents detected.")
+        return
+    for target in found:
+        console.print(target.value)
+
+
+@agents_app.command("configure")
+def agents_configure(
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+    target: Annotated[list[AgentTarget] | None, typer.Option("--target", "-t")] = None,
+    all_supported: Annotated[bool, typer.Option("--all")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+) -> None:
+    configurator = AgentConfigurator(path)
+    selected = tuple(AgentTarget) if all_supported else tuple(target or configurator.detect())
+    mutations = configurator.configure(selected, dry_run=dry_run)
+    for item in mutations:
+        state = (
+            "would update"
+            if dry_run and item.changed
+            else "updated"
+            if item.changed
+            else "unchanged"
+        )
+        console.print(f"{item.target.value}: {state} {item.path}")
+        if item.backup:
+            console.print(f"  backup: {item.backup}")
+
+
+@edit_app.command("rename")
+def edit_rename(
+    relative_path: Annotated[str, typer.Argument(help="Repository-relative file")],
+    name_path: Annotated[str, typer.Argument(help="Semantic symbol name path")],
+    new_name: Annotated[str, typer.Argument(help="New symbol name")],
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+) -> None:
+    console.print_json(data=_edit_service(path).rename(relative_path, name_path, new_name))
+
+
+@edit_app.command("replace")
+def edit_replace(
+    relative_path: Annotated[str, typer.Argument()],
+    name_path: Annotated[str, typer.Argument()],
+    body_file: Annotated[Path, typer.Option("--body-file")],
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+) -> None:
+    body = body_file.read_text(encoding="utf-8")
+    console.print_json(data=_edit_service(path).replace(relative_path, name_path, body))
+
+
+@edit_app.command("insert-before")
+def edit_insert_before(
+    relative_path: Annotated[str, typer.Argument()],
+    name_path: Annotated[str, typer.Argument()],
+    body_file: Annotated[Path, typer.Option("--body-file")],
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+) -> None:
+    body = body_file.read_text(encoding="utf-8")
+    console.print_json(data=_edit_service(path).insert_before(relative_path, name_path, body))
+
+
+@edit_app.command("insert-after")
+def edit_insert_after(
+    relative_path: Annotated[str, typer.Argument()],
+    name_path: Annotated[str, typer.Argument()],
+    body_file: Annotated[Path, typer.Option("--body-file")],
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+) -> None:
+    body = body_file.read_text(encoding="utf-8")
+    console.print_json(data=_edit_service(path).insert_after(relative_path, name_path, body))
+
+
+@app.command("bootstrap")
+def bootstrap(
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+    install_backends: Annotated[bool, typer.Option("--backends/--no-backends")] = True,
+    configure_agents: Annotated[bool, typer.Option("--agents/--no-agents")] = True,
+    strict: Annotated[bool, typer.Option("--strict")] = False,
+) -> None:
+    root = path.expanduser().resolve()
+    result = ProjectSetup(root).run()
+    console.print(
+        f"Core ready: {result.index.tracked} files, {result.symbols} symbols, "
+        f"{result.graph_nodes} graph nodes."
+    )
+    failures: list[str] = []
+    if install_backends:
+        manager = _manager()
+        for key, spec in BACKENDS.items():
+            try:
+                manager.ensure(spec)
+                console.print(f"[green]✓[/green] backend {key}")
+            except Exception as exc:
+                failures.append(key)
+                console.print(f"[yellow]![/yellow] backend {key}: {type(exc).__name__}: {exc}")
+    if configure_agents:
+        configurator = AgentConfigurator(root)
+        for mutation in configurator.configure():
+            console.print(f"[green]✓[/green] agent {mutation.target.value}: {mutation.path}")
+    if strict and failures:
+        raise typer.Exit(code=2)
+
+
+@app.command("backend-status")
+def backend_status(
+    path: Annotated[Path, typer.Option("--path", "-p")] = Path("."),
+) -> None:
+    root = path.expanduser().resolve()
+    manager = _manager()
+    payload = {key: asdict(_adapter(key, root, manager).status()) for key in BACKENDS}
+    console.print_json(data=payload)

codecortex/evaluation/__init__.py

@@ -0,0 +1,55 @@
+"""Benchmark and external evaluation infrastructure."""
+
+from codecortex.evaluation.external import (
+    DeterministicGrader,
+    EvaluationCase,
+    EvaluationExpectation,
+    EvaluationOutput,
+    EvaluationReport,
+    ExternalEvaluationSuite,
+    SubprocessEvaluationTarget,
+)
+from codecortex.evaluation.production import (
+    AgentProtocolResult,
+    BenchmarkCaseSpec,
+    InstrumentedAgentRunner,
+    ObservedMetrics,
+    ProductionBenchmarkReport,
+    ProductionBenchmarkRunner,
+    RepositorySpec,
+    ScenarioResult,
+    SetupMeasurement,
+    load_repository_specs,
+)
+from codecortex.evaluation.regression import (
+    BenchmarkHistory,
+    BenchmarkSnapshot,
+    GateReport,
+    MetricPolicy,
+    RegressionGate,
+)
+
+__all__ = [
+    "AgentProtocolResult",
+    "BenchmarkCaseSpec",
+    "BenchmarkHistory",
+    "BenchmarkSnapshot",
+    "DeterministicGrader",
+    "EvaluationCase",
+    "EvaluationExpectation",
+    "EvaluationOutput",
+    "EvaluationReport",
+    "ExternalEvaluationSuite",
+    "GateReport",
+    "InstrumentedAgentRunner",
+    "MetricPolicy",
+    "ObservedMetrics",
+    "ProductionBenchmarkReport",
+    "ProductionBenchmarkRunner",
+    "RegressionGate",
+    "RepositorySpec",
+    "ScenarioResult",
+    "SetupMeasurement",
+    "SubprocessEvaluationTarget",
+    "load_repository_specs",
+]