@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/onecode/codebase/storage.py

@@ -1,153 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from pathlib import Path
-
-from sqlalchemy import Column, String, Text, Integer, Float, create_engine, Index
-from sqlalchemy.orm import declarative_base, sessionmaker
-
-from onecode.codebase.chunker import CodeChunk
-from onecode.config import ONECODE_DIR
-
-Base = declarative_base()
-
-
-class ChunkRecord(Base):
-    __tablename__ = "chunks"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    file_path = Column(String(1024), nullable=False, index=True)
-    start_line = Column(Integer, nullable=False)
-    end_line = Column(Integer, nullable=False)
-    content = Column(Text, nullable=False)
-    language = Column(String(64), default="")
-    file_mtime = Column(Float, default=0.0)
-
-    __table_args__ = (
-        Index("idx_file_path", "file_path"),
-        Index("idx_language", "language"),
-    )
-
-
-class CodebaseStorage:
-    def __init__(self, project_dir: Path):
-        project_key = hashlib.sha256(str(project_dir.resolve()).encode()).hexdigest()[:16]
-        db_dir = ONECODE_DIR / "codebase" / "indexes" / project_key
-        db_dir.mkdir(parents=True, exist_ok=True)
-        self.db_path = db_dir / "index.db"
-        self.engine = create_engine(f"sqlite:///{self.db_path}", echo=False)
-        with self.engine.connect() as conn:
-            conn.exec_driver_sql("PRAGMA journal_mode=WAL")
-        Base.metadata.create_all(self.engine)
-        self.Session = sessionmaker(bind=self.engine)
-
-    def save_chunks(self, chunks: list[CodeChunk], mtime: float = 0.0) -> None:
-        if not chunks:
-            return
-        file_path = chunks[0].file_path
-        with self.Session() as s:
-            s.query(ChunkRecord).filter_by(file_path=file_path).delete()
-            for c in chunks:
-                s.add(ChunkRecord(
-                    file_path=c.file_path,
-                    start_line=c.start_line,
-                    end_line=c.end_line,
-                    content=c.content,
-                    language=c.language,
-                    file_mtime=mtime,
-                ))
-            s.commit()
-
-    def save_chunks_batch(self, files_chunks: list[tuple[list[CodeChunk], float]]) -> None:
-        if not files_chunks:
-            return
-        with self.Session() as s:
-            for chunks, mtime in files_chunks:
-                if not chunks:
-                    continue
-                file_path = chunks[0].file_path
-                s.query(ChunkRecord).filter_by(file_path=file_path).delete()
-                for c in chunks:
-                    s.add(ChunkRecord(
-                        file_path=c.file_path,
-                        start_line=c.start_line,
-                        end_line=c.end_line,
-                        content=c.content,
-                        language=c.language,
-                        file_mtime=mtime,
-                    ))
-            s.commit()
-
-    def remove_file(self, file_path: str) -> None:
-        with self.Session() as s:
-            s.query(ChunkRecord).filter_by(file_path=file_path).delete()
-            s.commit()
-
-    def remove_directory(self, dir_path: str) -> None:
-        prefix = dir_path.rstrip("/") + "/"
-        with self.Session() as s:
-            s.query(ChunkRecord).filter(
-                ChunkRecord.file_path.like(f"{prefix}%")
-            ).delete(synchronize_session=False)
-            s.commit()
-
-    def get_file_mtime(self, file_path: str) -> float:
-        with self.Session() as s:
-            record = (
-                s.query(ChunkRecord.file_mtime)
-                .filter_by(file_path=file_path)
-                .order_by(ChunkRecord.file_mtime.desc())
-                .first()
-            )
-            return record[0] if record else 0.0
-
-    def get_indexed_files(self) -> set[str]:
-        with self.Session() as s:
-            rows = s.query(ChunkRecord.file_path).distinct().all()
-            return {row[0] for row in rows}
-
-    def get_all_chunks(self) -> list[CodeChunk]:
-        with self.Session() as s:
-            records = s.query(ChunkRecord).all()
-            return [
-                CodeChunk(
-                    file_path=r.file_path,
-                    start_line=r.start_line,
-                    end_line=r.end_line,
-                    content=r.content,
-                    language=r.language,
-                )
-                for r in records
-            ]
-
-    def get_chunks_for_file(self, file_path: str) -> list[CodeChunk]:
-        with self.Session() as s:
-            records = (
-                s.query(ChunkRecord)
-                .filter_by(file_path=file_path)
-                .order_by(ChunkRecord.start_line)
-                .all()
-            )
-            return [
-                CodeChunk(
-                    file_path=r.file_path,
-                    start_line=r.start_line,
-                    end_line=r.end_line,
-                    content=r.content,
-                    language=r.language,
-                )
-                for r in records
-            ]
-
-    def chunk_count(self) -> int:
-        with self.Session() as s:
-            return s.query(ChunkRecord).count()
-
-    def file_count(self) -> int:
-        with self.Session() as s:
-            return s.query(ChunkRecord.file_path).distinct().count()
-
-    def clear_all(self) -> None:
-        with self.Session() as s:
-            s.query(ChunkRecord).delete()
-            s.commit()

package/onecode/codebase/tools.py

@@ -1,59 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Callable, Optional
-
-from onecode.agent.tools.registry import Tool, ToolResult, ToolSpec
-
-if TYPE_CHECKING:
-    from onecode.codebase import CodebaseEngine
-
-
-class CodebaseSearchTool(Tool):
-    def __init__(self, engine_factory: Callable[[], Optional[CodebaseEngine]]):
-        self._engine_factory = engine_factory
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="codebase_search",
-            description="Search the indexed codebase for code relevant to a query. "
-                        "Returns code chunks with file paths and line numbers. "
-                        "Use this to find relevant code before making changes.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "query": {
-                        "type": "string",
-                        "description": "Search query describing what you're looking for",
-                    },
-                    "top_k": {
-                        "type": "integer",
-                        "description": "Number of results to return (1-20)",
-                        "default": 5,
-                    },
-                },
-                "required": ["query"],
-            },
-            is_read_only=True,
-        )
-
-    async def run(self, tool_input: dict) -> ToolResult:
-        query = tool_input.get("query", "")
-        top_k = min(max(int(tool_input.get("top_k", 5)), 1), 20)
-        if not query:
-            return ToolResult(content="Please provide a search query.")
-        try:
-            engine = self._engine_factory()
-            if engine is None:
-                return ToolResult(content="Codebase engine not available. Is it enabled in config?")
-            chunks = await engine.retrieve(query, top_k=top_k)
-            if not chunks:
-                return ToolResult(content="No results found. Try a different query.")
-            parts: list[str] = []
-            for i, c in enumerate(chunks, 1):
-                parts.append(
-                    f"[{i}] {c.file_path}:{c.start_line}-{c.end_line}\n"
-                    f"```\n{c.content}\n```"
-                )
-            return ToolResult(content="\n\n".join(parts))
-        except Exception as e:
-            return ToolResult(content=f"Search failed: {e}", is_error=True)