velune-cli 0.9.0__py3-none-any.whl

velune/providers/task_classifier.py

@@ -0,0 +1,288 @@
+"""Task classification based on prompt content and context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class TaskType(StrEnum):
+    """Task type categories for routing."""
+
+    CODING = "coding"
+    REASONING = "reasoning"
+    SUMMARIZATION = "summarization"
+    GENERAL = "general"
+    EMBEDDING = "embedding"
+
+
+class ComplexityLevel(StrEnum):
+    """Task complexity estimation."""
+
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+@dataclass
+class TaskProfile:
+    """Profile of a task for routing decisions."""
+
+    task_type: TaskType
+    complexity: ComplexityLevel
+    latency_sensitive: bool
+    requires_long_context: bool
+    requires_tools: bool
+    estimated_tokens: int = 0
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class TaskClassifier:
+    """Classifies prompts and context into task profiles for routing."""
+
+    # Coding-related keywords
+    CODING_KEYWORDS = {
+        "implement",
+        "write",
+        "code",
+        "function",
+        "class",
+        "method",
+        "fix",
+        "bug",
+        "error",
+        "debug",
+        "refactor",
+        "rewrite",
+        "modify",
+        "change",
+        "update",
+        "add",
+        "remove",
+        "delete",
+        "script",
+        "program",
+        "algorithm",
+        "library",
+        "framework",
+        "test",
+        "unittest",
+        "pytest",
+        "jest",
+        "mocha",
+        "sql",
+        "query",
+        "database",
+        "schema",
+    }
+
+    # Reasoning-related keywords
+    REASONING_KEYWORDS = {
+        "explain",
+        "why",
+        "how",
+        "analyze",
+        "reason",
+        "infer",
+        "deduce",
+        "conclude",
+        "derive",
+        "solve",
+        "think",
+        "understand",
+        "interpret",
+        "clarify",
+        "elaborate",
+        "compare",
+        "contrast",
+        "difference",
+        "similarity",
+        "logic",
+        "argument",
+        "evidence",
+        "proof",
+    }
+
+    # Summarization-related keywords
+    SUMMARIZATION_KEYWORDS = {
+        "summarize",
+        "summary",
+        "tldr",
+        "brief",
+        "overview",
+        "outline",
+        "abstract",
+        "condense",
+        "digest",
+        "recap",
+        "highlight",
+        "extract",
+        "key",
+        "main",
+        "point",
+        "synopsis",
+        "gist",
+    }
+
+    # Quick question patterns (low complexity)
+    QUICK_PATTERNS = {
+        "what is",
+        "what's",
+        "who is",
+        "who's",
+        "when is",
+        "where is",
+        "how many",
+        "how much",
+        "why",
+        "define",
+        "meaning",
+    }
+
+    def classify(self, prompt: str, context: dict[str, Any] | None = None) -> TaskProfile:
+        """Classify a prompt into a task profile.
+
+        Args:
+            prompt: The user prompt/question
+            context: Optional context dict with keys like:
+                - code: Code snippets present
+                - retrieved_context: Retrieved knowledge base content
+                - context_tokens: Estimated context token count
+
+        Returns:
+            TaskProfile with task type, complexity, and routing hints
+        """
+        context = context or {}
+
+        # Estimate prompt length in tokens (rough: 1 token ~= 4 chars)
+        prompt_tokens = max(1, len(prompt) // 4)
+        context_tokens = context.get("context_tokens", 0)
+        total_tokens = prompt_tokens + context_tokens
+
+        # Classify task type
+        task_type = self._classify_task_type(prompt)
+
+        # Estimate complexity
+        complexity = self._estimate_complexity(prompt, task_type, total_tokens, context)
+
+        # Determine if latency sensitive
+        latency_sensitive = self._is_latency_sensitive(prompt, task_type, complexity)
+
+        # Check if long context needed
+        requires_long_context = total_tokens > 8000
+
+        # Check if tools needed
+        requires_tools = self._requires_tools(prompt, context)
+
+        return TaskProfile(
+            task_type=task_type,
+            complexity=complexity,
+            latency_sensitive=latency_sensitive,
+            requires_long_context=requires_long_context,
+            requires_tools=requires_tools,
+            estimated_tokens=total_tokens,
+            metadata={
+                "prompt_tokens": prompt_tokens,
+                "context_tokens": context_tokens,
+            },
+        )
+
+    def _classify_task_type(self, prompt: str) -> TaskType:
+        """Classify the primary task type from prompt keywords."""
+        lower = prompt.lower()
+
+        # Check coding keywords
+        coding_matches = sum(1 for kw in self.CODING_KEYWORDS if kw in lower)
+        reasoning_matches = sum(1 for kw in self.REASONING_KEYWORDS if kw in lower)
+        summarization_matches = sum(1 for kw in self.SUMMARIZATION_KEYWORDS if kw in lower)
+
+        # Return task type with most matches
+        max_matches = max(coding_matches, reasoning_matches, summarization_matches)
+
+        if max_matches == 0:
+            return TaskType.GENERAL
+
+        if coding_matches == max_matches:
+            return TaskType.CODING
+        if reasoning_matches == max_matches:
+            return TaskType.REASONING
+        if summarization_matches == max_matches:
+            return TaskType.SUMMARIZATION
+
+        return TaskType.GENERAL
+
+    def _estimate_complexity(
+        self,
+        prompt: str,
+        task_type: TaskType,
+        total_tokens: int,
+        context: dict[str, Any],
+    ) -> ComplexityLevel:
+        """Estimate task complexity based on prompt and context."""
+        prompt.lower()
+
+        # Short prompts with no code/context => LOW
+        if len(prompt) < 50 and total_tokens < 500:
+            if task_type == TaskType.GENERAL and "code" not in context:
+                return ComplexityLevel.LOW
+
+        # Long prompts with code/context => HIGH
+        if total_tokens > 4000 and "code" in context:
+            return ComplexityLevel.HIGH
+
+        # Reasoning/complex analysis => at least MEDIUM
+        if task_type in (TaskType.REASONING, TaskType.SUMMARIZATION):
+            if total_tokens > 2000:
+                return ComplexityLevel.HIGH
+            return ComplexityLevel.MEDIUM
+
+        # Coding with substantial context => HIGH
+        if task_type == TaskType.CODING and total_tokens > 3000:
+            return ComplexityLevel.HIGH
+
+        # Default to MEDIUM
+        return ComplexityLevel.MEDIUM
+
+    def _is_latency_sensitive(
+        self,
+        prompt: str,
+        task_type: TaskType,
+        complexity: ComplexityLevel,
+    ) -> bool:
+        """Determine if response latency is critical."""
+        # Short quick questions are latency sensitive
+        if complexity == ComplexityLevel.LOW:
+            lower = prompt.lower()
+            return any(pattern in lower for pattern in self.QUICK_PATTERNS)
+
+        # Complex reasoning/analysis can wait
+        if complexity == ComplexityLevel.HIGH:
+            return False
+
+        # Quick questions/definitions
+        lower = prompt.lower()
+        quick_match = any(pattern in lower for pattern in self.QUICK_PATTERNS)
+        if quick_match:
+            return True
+
+        # Default: not latency sensitive for medium complexity
+        return False
+
+    def _requires_tools(self, prompt: str, context: dict[str, Any]) -> bool:
+        """Determine if the task likely needs external tools/APIs."""
+        tool_keywords = {
+            "api",
+            "request",
+            "fetch",
+            "call",
+            "network",
+            "http",
+            "search",
+            "browse",
+            "lookup",
+            "query",
+            "database",
+        }
+        lower = prompt.lower()
+        return any(kw in lower for kw in tool_keywords)

velune/repository/__init__.py

@@ -0,0 +1,33 @@
+"""Repository Cognition Engine for AST parsing, Git tracking, and dependency graphs."""
+
+from velune.repository.ast_parser import ASTParser, Symbol, SymbolKind
+from velune.repository.cognition import RepositoryCognitionService
+from velune.repository.parser import RepositorySnapshotParser
+from velune.repository.rename_journal import RenameJournal
+from velune.repository.schemas import (
+    RepositoryEdge,
+    RepositoryFile,
+    RepositoryLanguage,
+    RepositorySnapshot,
+    RepositorySymbol,
+    RepositorySymbolKind,
+)
+from velune.repository.symbol_registry import SymbolRegistry
+
+__all__ = [
+    "RepositoryCognitionService",
+    "RepositoryLanguage",
+    "RepositorySymbolKind",
+    "RepositorySymbol",
+    "RepositoryFile",
+    "RepositoryEdge",
+    "RepositorySnapshot",
+    # Async AST parser (canonical for SymbolRegistry / RenameJournal)
+    "ASTParser",
+    "Symbol",
+    "SymbolKind",
+    "SymbolRegistry",
+    "RenameJournal",
+    # Sync snapshot parser (used by indexer / incremental indexer / tools)
+    "RepositorySnapshotParser",
+]

velune/repository/analyzer.py

@@ -0,0 +1,127 @@
+"""Architectural layer classifier and design pattern analyzer."""
+
+from pathlib import Path
+
+
+class CodebaseAnalyzer:
+    """Analyzes the repository's architectural layered structure and checks for design violations."""
+
+    def __init__(self, root_path: Path) -> None:
+        self.root_path = root_path.resolve()
+
+    def classify_architecture_layers(self, file_paths: list[str]) -> dict[str, list[str]]:
+        """Groups files into functional architectural layers based on folder topology."""
+        layers: dict[str, list[str]] = {
+            "kernel": [],
+            "providers": [],
+            "models": [],
+            "memory": [],
+            "context": [],
+            "intent": [],
+            "repository": [],
+            "retrieval": [],
+            "execution": [],
+            "cognition": [],
+            "cli": [],
+            "tools": [],
+            "plugins": [],
+            "telemetry": [],
+            "other": [],
+        }
+
+        for path in file_paths:
+            # Normalize to forward slashes
+            norm = path.replace("\\", "/")
+            classified = False
+
+            for layer in layers.keys():
+                if f"velune/{layer}/" in norm or norm.startswith(f"{layer}/"):
+                    layers[layer].append(norm)
+                    classified = True
+                    break
+
+            if not classified:
+                layers["other"].append(norm)
+
+        return layers
+
+    def detect_dependency_violations(
+        self, layers: dict[str, list[str]], import_edges: list[tuple]
+    ) -> list[dict[str, str]]:
+        """Identifies circular dependencies or violations of layered architectural boundaries.
+
+        Rules:
+        - Kernel layer MUST NOT import higher levels (cli, cognition, retrieval).
+        - Providers layer MUST NOT import cli or cognition.
+        - Higher levels can import kernel/providers freely.
+        """
+        violations: list[dict[str, str]] = []
+
+        # Build mapping of file to its layer
+        layer_by_file: dict[str, str] = {}
+        for layer, files in layers.items():
+            for f in files:
+                layer_by_file[f] = layer
+
+        # Layer importance hierarchy (lower number is more fundamental/lower layer)
+        hierarchy = {
+            "kernel": 0,
+            "providers": 1,
+            "models": 2,
+            "memory": 3,
+            "context": 4,
+            "intent": 5,
+            "repository": 5,
+            "retrieval": 6,
+            "tools": 7,
+            "execution": 8,
+            "cognition": 9,
+            "plugins": 9,
+            "cli": 10,
+            "telemetry": 0,  # Telemetry can be imported everywhere
+            "other": 10,
+        }
+
+        for source, target in import_edges:
+            src_layer = layer_by_file.get(source)
+            tgt_layer = layer_by_file.get(target)
+
+            if src_layer and tgt_layer:
+                src_val = hierarchy.get(src_layer, 10)
+                tgt_val = hierarchy.get(tgt_layer, 10)
+
+                # Violation: Lower layer imports a strictly higher layer (excluding telemetry)
+                if src_val < tgt_val and tgt_layer != "telemetry":
+                    violations.append(
+                        {
+                            "source": source,
+                            "target": target,
+                            "source_layer": src_layer,
+                            "target_layer": tgt_layer,
+                            "rule": f"Layer violation: Fundamental '{src_layer}' layer imports higher-level '{tgt_layer}' layer.",
+                        }
+                    )
+
+        return violations
+
+    def detect_framework_footprint(self, code_files: dict[str, str]) -> list[str]:
+        """Detects specific framework libraries and dependencies active in the codebase."""
+        footprints: set[str] = set()
+
+        for code in code_files.values():
+            if "import typer" in code or "from typer" in code:
+                footprints.add("Typer (CLI)")
+            if "import langgraph" in code or "from langgraph" in code:
+                footprints.add("LangGraph (Orchestration)")
+            if "import qdrant_client" in code or "from qdrant_client" in code:
+                footprints.add("Qdrant (Vector DB)")
+            if "import sqlite3" in code or "from sqlite3" in code:
+                footprints.add("SQLite (Episodic Storage)")
+            if "import tree_sitter" in code or "from tree_sitter" in code:
+                footprints.add("Tree-sitter (AST Parsing)")
+            if "import networkx" in code or "from networkx" in code:
+                footprints.add("NetworkX (Graph Traversal)")
+            if "import psutil" in code or "from psutil" in code:
+                footprints.add("psutil (Subprocess Limits)")
+
+        return list(footprints)