velune-cli 0.9.0__py3-none-any.whl

velune/repository/project_type.py

@@ -0,0 +1,300 @@
+"""Project type detector — classifies workspaces and builds context profiles."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+
+class ProjectType(Enum):
+    PYTHON_FASTAPI = "python-fastapi"
+    PYTHON_DJANGO = "python-django"
+    PYTHON_FLASK = "python-flask"
+    PYTHON_CLI = "python-cli"
+    PYTHON_GENERIC = "python"
+    NODE_REACT = "node-react"
+    NODE_NEXTJS = "node-nextjs"
+    NODE_EXPRESS = "node-express"
+    NODE_GENERIC = "node"
+    RUST = "rust"
+    GO = "go"
+    JAVA_SPRING = "java-spring"
+    JAVA_GENERIC = "java"
+    DOTNET = "dotnet"
+    FLUTTER = "flutter"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class ProjectProfile:
+    project_type: ProjectType
+    display_name: str
+    primary_language: str
+    detected_frameworks: list[str]
+    entry_points: list[str]
+    test_directories: list[str]
+    config_files: list[str]
+    suggested_model_skill: str  # "coding" | "reasoning" | "balanced"
+    context_hints: list[str]
+    system_prompt_addon: str
+
+
+PROJECT_SYSTEM_PROMPTS: dict[ProjectType, str] = {
+    ProjectType.PYTHON_FASTAPI: (
+        "This is a Python FastAPI project. When suggesting code changes, "
+        "prefer async/await patterns, Pydantic models for validation, "
+        "and dependency injection. Routes are in routers/. Models in models/."
+    ),
+    ProjectType.PYTHON_DJANGO: (
+        "This is a Django project. Follow Django conventions: fat models, "
+        "thin views, use Django ORM patterns, signals, and class-based views "
+        "where appropriate. Settings are in settings.py or settings/."
+    ),
+    ProjectType.PYTHON_FLASK: (
+        "This is a Flask project. Follow Flask patterns: blueprints for "
+        "routing, application factory pattern, SQLAlchemy for ORM if present."
+    ),
+    ProjectType.NODE_REACT: (
+        "This is a React frontend project. Prefer functional components "
+        "with hooks, TypeScript if tsconfig.json exists, and modern React "
+        "patterns. Components in src/components/."
+    ),
+    ProjectType.NODE_NEXTJS: (
+        "This is a Next.js project. Use App Router patterns if app/ exists, "
+        "Pages Router if pages/ exists. Server components by default, "
+        "client components only when needed."
+    ),
+    ProjectType.RUST: (
+        "This is a Rust project. Follow Rust idioms: ownership semantics, "
+        "Result/Option for error handling, no unwrap() in library code. "
+        "Check Cargo.toml for edition and features."
+    ),
+    ProjectType.GO: (
+        "This is a Go project. Follow Go conventions: simple interfaces, "
+        "error returns, goroutines and channels for concurrency. "
+        "Entry point is main.go or cmd/."
+    ),
+}
+
+_DISPLAY_NAMES: dict[ProjectType, str] = {
+    ProjectType.PYTHON_FASTAPI: "Python / FastAPI",
+    ProjectType.PYTHON_DJANGO: "Python / Django",
+    ProjectType.PYTHON_FLASK: "Python / Flask",
+    ProjectType.PYTHON_CLI: "Python / CLI",
+    ProjectType.PYTHON_GENERIC: "Python",
+    ProjectType.NODE_REACT: "Node.js / React",
+    ProjectType.NODE_NEXTJS: "Node.js / Next.js",
+    ProjectType.NODE_EXPRESS: "Node.js / Express",
+    ProjectType.NODE_GENERIC: "Node.js",
+    ProjectType.RUST: "Rust",
+    ProjectType.GO: "Go",
+    ProjectType.JAVA_SPRING: "Java / Spring",
+    ProjectType.JAVA_GENERIC: "Java",
+    ProjectType.DOTNET: ".NET",
+    ProjectType.FLUTTER: "Flutter / Dart",
+    ProjectType.UNKNOWN: "Unknown",
+}
+
+_LANGUAGE_MAP: dict[ProjectType, str] = {
+    ProjectType.PYTHON_FASTAPI: "python",
+    ProjectType.PYTHON_DJANGO: "python",
+    ProjectType.PYTHON_FLASK: "python",
+    ProjectType.PYTHON_CLI: "python",
+    ProjectType.PYTHON_GENERIC: "python",
+    ProjectType.NODE_REACT: "typescript",
+    ProjectType.NODE_NEXTJS: "typescript",
+    ProjectType.NODE_EXPRESS: "javascript",
+    ProjectType.NODE_GENERIC: "javascript",
+    ProjectType.RUST: "rust",
+    ProjectType.GO: "go",
+    ProjectType.JAVA_SPRING: "java",
+    ProjectType.JAVA_GENERIC: "java",
+    ProjectType.DOTNET: "csharp",
+    ProjectType.FLUTTER: "dart",
+    ProjectType.UNKNOWN: "unknown",
+}
+
+
+class ProjectTypeDetector:
+    """Detects the project type of a workspace by inspecting root-level files."""
+
+    def detect(self, workspace: Path) -> ProjectProfile:
+        files = self._list_root_files(workspace)
+        project_type, frameworks = self._classify(workspace, files)
+        entry_points = self._find_entry_points(workspace, project_type)
+        test_dirs = self._find_test_dirs(workspace)
+        config_files = self._find_config_files(workspace, files)
+        context_hints = self._build_context_hints(project_type)
+        system_prompt = PROJECT_SYSTEM_PROMPTS.get(project_type, "")
+
+        return ProjectProfile(
+            project_type=project_type,
+            display_name=_DISPLAY_NAMES.get(project_type, "Unknown"),
+            primary_language=_LANGUAGE_MAP.get(project_type, "unknown"),
+            detected_frameworks=frameworks,
+            entry_points=entry_points,
+            test_directories=test_dirs,
+            config_files=config_files,
+            suggested_model_skill="coding",
+            context_hints=context_hints,
+            system_prompt_addon=system_prompt,
+        )
+
+    def _list_root_files(self, workspace: Path) -> set[str]:
+        try:
+            return {f.name for f in workspace.iterdir() if not f.name.startswith(".")}
+        except Exception:
+            return set()
+
+    def _classify(self, workspace: Path, files: set[str]) -> tuple[ProjectType, list[str]]:
+        # ── Rust ──────────────────────────────────────────────────────
+        if "Cargo.toml" in files:
+            return ProjectType.RUST, ["cargo"]
+
+        # ── Go ────────────────────────────────────────────────────────
+        if "go.mod" in files:
+            return ProjectType.GO, ["go modules"]
+
+        # ── Flutter / Dart ────────────────────────────────────────────
+        if "pubspec.yaml" in files:
+            return ProjectType.FLUTTER, ["flutter", "dart"]
+
+        # ── .NET ──────────────────────────────────────────────────────
+        if any(f.endswith(".csproj") or f.endswith(".sln") for f in files):
+            return ProjectType.DOTNET, ["dotnet"]
+
+        # ── Node / JavaScript / TypeScript ────────────────────────────
+        if "package.json" in files:
+            try:
+                import json
+
+                pkg = json.loads((workspace / "package.json").read_text())
+                deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+                if "next" in deps:
+                    return ProjectType.NODE_NEXTJS, ["nextjs", "react"]
+                if "react" in deps or "react-dom" in deps:
+                    frameworks = ["react"]
+                    if "typescript" in deps or (workspace / "tsconfig.json").exists():
+                        frameworks.append("typescript")
+                    return ProjectType.NODE_REACT, frameworks
+                if "express" in deps:
+                    return ProjectType.NODE_EXPRESS, ["express"]
+            except Exception:
+                pass
+            return ProjectType.NODE_GENERIC, []
+
+        # ── Python ────────────────────────────────────────────────────
+        has_python = (
+            "pyproject.toml" in files
+            or "setup.py" in files
+            or "requirements.txt" in files
+            or any(f.endswith(".py") for f in files)
+        )
+        if has_python:
+            combined = self._read_requirement_sources(workspace)
+            if "fastapi" in combined:
+                frameworks = ["fastapi", "uvicorn"]
+                if "sqlalchemy" in combined:
+                    frameworks.append("sqlalchemy")
+                if "pydantic" in combined:
+                    frameworks.append("pydantic")
+                return ProjectType.PYTHON_FASTAPI, frameworks
+            if "django" in combined:
+                frameworks: list[str] = ["django"]
+                if "drf" in combined or "rest_framework" in combined:
+                    frameworks.append("drf")
+                return ProjectType.PYTHON_DJANGO, frameworks
+            if "flask" in combined:
+                return ProjectType.PYTHON_FLASK, ["flask"]
+            if "typer" in combined or "click" in combined or "argparse" in combined:
+                return ProjectType.PYTHON_CLI, ["cli"]
+            return ProjectType.PYTHON_GENERIC, []
+
+        # ── Java ──────────────────────────────────────────────────────
+        if "pom.xml" in files or "build.gradle" in files:
+            combined = ""
+            for fname in ("pom.xml", "build.gradle"):
+                fp = workspace / fname
+                if fp.exists():
+                    try:
+                        combined += fp.read_text().lower()
+                    except Exception:
+                        pass
+            if "spring" in combined:
+                return ProjectType.JAVA_SPRING, ["spring"]
+            return ProjectType.JAVA_GENERIC, []
+
+        return ProjectType.UNKNOWN, []
+
+    def _read_requirement_sources(self, workspace: Path) -> str:
+        parts: list[str] = []
+        for fname in ("requirements.txt", "requirements.in", "pyproject.toml", "setup.py"):
+            fp = workspace / fname
+            if fp.exists():
+                try:
+                    parts.append(fp.read_text().lower())
+                except Exception:
+                    pass
+        return " ".join(parts)
+
+    def _find_entry_points(self, workspace: Path, pt: ProjectType) -> list[str]:
+        candidates: dict[ProjectType, list[str]] = {
+            ProjectType.PYTHON_FASTAPI: ["main.py", "app/main.py", "src/main.py"],
+            ProjectType.PYTHON_DJANGO: ["manage.py"],
+            ProjectType.PYTHON_FLASK: ["app.py", "run.py", "main.py"],
+            ProjectType.PYTHON_CLI: ["main.py", "cli.py", "__main__.py"],
+            ProjectType.PYTHON_GENERIC: ["main.py", "__main__.py"],
+            ProjectType.NODE_REACT: ["src/main.tsx", "src/App.tsx", "src/index.tsx"],
+            ProjectType.NODE_NEXTJS: ["app/page.tsx", "pages/index.tsx"],
+            ProjectType.NODE_EXPRESS: ["index.js", "server.js", "app.js"],
+            ProjectType.RUST: ["src/main.rs", "src/lib.rs"],
+            ProjectType.GO: ["main.go", "cmd/main.go"],
+        }
+        found = []
+        for rel in candidates.get(pt, []):
+            if (workspace / rel).exists():
+                found.append(rel)
+        return found[:3]
+
+    def _find_test_dirs(self, workspace: Path) -> list[str]:
+        names = ["tests", "test", "__tests__", "spec", "specs", "e2e"]
+        return [d for d in names if (workspace / d).is_dir()]
+
+    def _find_config_files(self, workspace: Path, files: set[str]) -> list[str]:
+        candidates = [
+            "pyproject.toml",
+            "package.json",
+            "Cargo.toml",
+            "go.mod",
+            "tsconfig.json",
+            ".eslintrc.json",
+            "webpack.config.js",
+            "vite.config.ts",
+            "next.config.js",
+            "docker-compose.yml",
+            "Dockerfile",
+            ".env.example",
+        ]
+        return [f for f in candidates if f in files]
+
+    def _build_context_hints(self, pt: ProjectType) -> list[str]:
+        hints: list[str] = []
+        if pt in (
+            ProjectType.PYTHON_FASTAPI,
+            ProjectType.PYTHON_DJANGO,
+            ProjectType.PYTHON_FLASK,
+            ProjectType.PYTHON_GENERIC,
+        ):
+            hints.append("Always check imports and type hints in Python files")
+            hints.append("Prefer pathlib over os.path for file operations")
+        if pt == ProjectType.NODE_REACT:
+            hints.append("Check for TypeScript types in *.d.ts files")
+            hints.append("Components use named exports, not default where possible")
+        if pt == ProjectType.RUST:
+            hints.append("Check Cargo.toml features before suggesting dependencies")
+            hints.append("Use ? operator for error propagation")
+        if pt == ProjectType.GO:
+            hints.append("Follow Go error handling: always check returned errors")
+            hints.append("Check go.sum when suggesting new imports")
+        return hints

velune/repository/rename_journal.py

@@ -0,0 +1,287 @@
+"""Journal tracking symbol renames across the repository."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+import aiosqlite
+
+logger = logging.getLogger("velune.repository.rename_journal")
+
+
+@dataclass
+class RenameRecord:
+    """Record of a symbol rename."""
+
+    symbol_id: str
+    old_name: str
+    new_name: str
+    file_path: str
+    old_line: int
+    new_line: int
+    timestamp: datetime
+
+
+class RenameJournal:
+    """Persistent journal of symbol renames."""
+
+    def __init__(self, db_path: Path) -> None:
+        """Initialize rename journal.
+
+        Args:
+            db_path: Path to SQLite database file
+        """
+        self.db_path = db_path
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    async def initialize(self) -> None:
+        """Initialize database schema."""
+        async with aiosqlite.connect(str(self.db_path)) as db:
+            await db.executescript("""
+                CREATE TABLE IF NOT EXISTS renames (
+                    symbol_id TEXT NOT NULL,
+                    old_name TEXT NOT NULL,
+                    new_name TEXT NOT NULL,
+                    file_path TEXT NOT NULL,
+                    old_line INTEGER NOT NULL,
+                    new_line INTEGER NOT NULL,
+                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    PRIMARY KEY (symbol_id, timestamp)
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_renames_symbol ON renames(symbol_id);
+                CREATE INDEX IF NOT EXISTS idx_renames_file ON renames(file_path);
+                CREATE INDEX IF NOT EXISTS idx_renames_old_name ON renames(old_name);
+                CREATE INDEX IF NOT EXISTS idx_renames_timestamp ON renames(timestamp);
+            """)
+            await db.commit()
+
+    async def record_rename(
+        self,
+        symbol_id: str,
+        old_name: str,
+        new_name: str,
+        file_path: str,
+        old_line: int,
+        new_line: int,
+    ) -> None:
+        """Record a symbol rename.
+
+        Args:
+            symbol_id: Stable symbol ID
+            old_name: Previous symbol name
+            new_name: New symbol name
+            file_path: File path where rename occurred
+            old_line: Previous line number
+            new_line: New line number
+        """
+        async with aiosqlite.connect(str(self.db_path)) as db:
+            await db.execute(
+                """
+                INSERT INTO renames (symbol_id, old_name, new_name, file_path, old_line, new_line)
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (symbol_id, old_name, new_name, file_path, old_line, new_line),
+            )
+            await db.commit()
+
+        logger.debug(f"Recorded rename: {old_name} → {new_name} (id={symbol_id})")
+
+    async def get_renames_for_symbol(self, symbol_id: str) -> list[RenameRecord]:
+        """Get all rename records for a symbol.
+
+        Args:
+            symbol_id: Symbol to get renames for
+
+        Returns:
+            List of rename records in chronological order
+        """
+        records: list[RenameRecord] = []
+        async with aiosqlite.connect(str(self.db_path)) as db:
+            async with db.execute(
+                """
+                SELECT symbol_id, old_name, new_name, file_path, old_line, new_line, timestamp
+                FROM renames WHERE symbol_id = ? ORDER BY timestamp ASC
+                """,
+                (symbol_id,),
+            ) as cursor:
+                async for row in cursor:
+                    record = RenameRecord(
+                        symbol_id=row[0],
+                        old_name=row[1],
+                        new_name=row[2],
+                        file_path=row[3],
+                        old_line=row[4],
+                        new_line=row[5],
+                        timestamp=datetime.fromisoformat(row[6]),
+                    )
+                    records.append(record)
+
+        return records
+
+    async def resolve_name(self, old_name: str, file_path: str) -> str | None:
+        """Resolve an old symbol name to its current name.
+
+        Searches the most recent rename record for the given name and file.
+
+        Args:
+            old_name: Historical symbol name
+            file_path: File path
+
+        Returns:
+            Current name if rename exists, None otherwise
+        """
+        async with aiosqlite.connect(str(self.db_path)) as db:
+            async with db.execute(
+                """
+                SELECT new_name FROM renames
+                WHERE old_name = ? AND file_path = ?
+                ORDER BY timestamp DESC LIMIT 1
+                """,
+                (old_name, file_path),
+            ) as cursor:
+                row = await cursor.fetchone()
+
+        if row:
+            return row[0]
+
+        # Check if there's a chain of renames
+        # (i.e., A→B→C, resolve A to C)
+        current_name = old_name
+        depth = 0
+        max_depth = 10
+
+        while depth < max_depth:
+            next_name = await self.resolve_name(current_name, file_path)
+            if not next_name or next_name == current_name:
+                break
+            current_name = next_name
+            depth += 1
+
+        return current_name if current_name != old_name else None
+
+    async def get_renames_in_file(self, file_path: str) -> list[RenameRecord]:
+        """Get all renames in a specific file.
+
+        Args:
+            file_path: File path to get renames for
+
+        Returns:
+            List of rename records
+        """
+        records: list[RenameRecord] = []
+        async with aiosqlite.connect(str(self.db_path)) as db:
+            async with db.execute(
+                """
+                SELECT symbol_id, old_name, new_name, file_path, old_line, new_line, timestamp
+                FROM renames WHERE file_path = ? ORDER BY timestamp ASC
+                """,
+                (file_path,),
+            ) as cursor:
+                async for row in cursor:
+                    record = RenameRecord(
+                        symbol_id=row[0],
+                        old_name=row[1],
+                        new_name=row[2],
+                        file_path=row[3],
+                        old_line=row[4],
+                        new_line=row[5],
+                        timestamp=datetime.fromisoformat(row[6]),
+                    )
+                    records.append(record)
+
+        return records
+
+    async def detect_rename(
+        self,
+        old_symbols: dict[str, tuple[str, int]],  # name -> (id, line)
+        new_symbols: dict[str, tuple[str, int]],  # name -> (id, line)
+        file_path: str,
+    ) -> list[RenameRecord]:
+        """Detect renames by comparing old and new symbol lists.
+
+        Heuristic: symbols at approximately the same line in the same file
+        with the same ID are considered the same symbol, even if the name changed.
+
+        Args:
+            old_symbols: Map of name -> (symbol_id, line) from previous parse
+            new_symbols: Map of name -> (symbol_id, line) from current parse
+            file_path: File path being analyzed
+
+        Returns:
+            List of detected renames
+        """
+        detected_renames: list[RenameRecord] = []
+
+        # Build reverse map: id -> (name, line)
+        old_by_id = {sym_id: (name, line) for name, (sym_id, line) in old_symbols.items()}
+        new_by_id = {sym_id: (name, line) for name, (sym_id, line) in new_symbols.items()}
+
+        # Find renamed symbols: same ID, different name
+        for symbol_id, (new_name, new_line) in new_by_id.items():
+            if symbol_id in old_by_id:
+                old_name, old_line = old_by_id[symbol_id]
+                if old_name != new_name:
+                    # Rename detected
+                    await self.record_rename(
+                        symbol_id=symbol_id,
+                        old_name=old_name,
+                        new_name=new_name,
+                        file_path=file_path,
+                        old_line=old_line,
+                        new_line=new_line,
+                    )
+
+                    record = RenameRecord(
+                        symbol_id=symbol_id,
+                        old_name=old_name,
+                        new_name=new_name,
+                        file_path=file_path,
+                        old_line=old_line,
+                        new_line=new_line,
+                        timestamp=datetime.now(),
+                    )
+                    detected_renames.append(record)
+
+        return detected_renames
+
+    async def get_all_renames(self) -> list[RenameRecord]:
+        """Get all rename records in the journal.
+
+        Returns:
+            List of all rename records
+        """
+        records: list[RenameRecord] = []
+        async with aiosqlite.connect(str(self.db_path)) as db:
+            async with db.execute(
+                """
+                SELECT symbol_id, old_name, new_name, file_path, old_line, new_line, timestamp
+                FROM renames ORDER BY timestamp ASC
+                """
+            ) as cursor:
+                async for row in cursor:
+                    record = RenameRecord(
+                        symbol_id=row[0],
+                        old_name=row[1],
+                        new_name=row[2],
+                        file_path=row[3],
+                        old_line=row[4],
+                        new_line=row[5],
+                        timestamp=datetime.fromisoformat(row[6]),
+                    )
+                    records.append(record)
+
+        return records
+
+    async def clear_renames_for_file(self, file_path: str) -> None:
+        """Clear all rename records for a file.
+
+        Args:
+            file_path: File path to clear renames for
+        """
+        async with aiosqlite.connect(str(self.db_path)) as db:
+            await db.execute("DELETE FROM renames WHERE file_path = ?", (file_path,))
+            await db.commit()