k-cli-for-devs 1.0.0__py3-none-any.whl

k_cli/core/smart_router.py

@@ -0,0 +1,230 @@
+"""
+smart_router.py - Cost, Latency & Intent-Adaptive Smart Model Router for K-CLI
+Project Bankai v1.0.0
+
+Provides:
+1. Adaptive Intent Routing: Automatically routes casual chat to ultra-fast & cheap models (Gemini Flash, Claude Haiku, GPT-4o-mini, Groq)
+   and routes architectural planning & heavy coding to premier frontier models (Claude 3.5 Sonnet, Bankai-14B, DeepSeek Coder).
+2. Pinned Default Model: Respects user-pinned default model preferences when 'default' mode is active.
+3. Cost & Latency Financial Optimization: Estimates cumulative cost savings against frontier baselines.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple
+
+from k_cli.core.credentials import CredentialsManager, DevPreferencesManager
+from k_cli.core.intent_sensor import IntentSensor, UserIntent
+from k_cli.core.llm_driver import LLMDriver, ProviderType
+from k_cli.core.models_hub import ModelHub, ModelProvider, ModelSpec
+
+logger = logging.getLogger("k_cli.core.smart_router")
+
+
+class TaskTier(str, Enum):
+    TRIVIAL = "trivial"      # Docstrings, typos, formatting, greetings -> Fast / Cheap (Gemini Flash, Local SLM)
+    STANDARD = "standard"    # Standard functions, bug fixes -> High Throughput (DeepSeek, Groq)
+    COMPLEX = "complex"      # Multi-file refactors, AST verification, planning -> Claude Sonnet, Bankai-14B, GPT-4
+
+
+@dataclass
+class RouteDecision:
+    """Routing outcome with rationale and cost analysis."""
+    task: str
+    tier: TaskTier
+    selected_model: str
+    selected_provider: str
+    estimated_cost_usd: float
+    baseline_gpt4_cost_usd: float
+    savings_usd: float
+    reasoning: str
+
+
+class AdaptiveIntentRouter:
+    """
+    Real-time dynamic model selector based on sensed user intent and active API keys.
+    """
+
+    @classmethod
+    def is_model_live(cls, model_name: str) -> bool:
+        """Checks if a model is actually available (cloud key present or local model installed)."""
+        if not model_name:
+            return False
+        m_lower = model_name.lower().strip()
+        if m_lower in ("mock", "offline", "deterministic", "local_deterministic"):
+            return True
+        # Cloud check
+        if "gemini" in m_lower and (os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY")):
+            return True
+        if "claude" in m_lower and os.environ.get("ANTHROPIC_API_KEY"):
+            return True
+        if ("gpt" in m_lower or "o1" in m_lower or "o3" in m_lower) and os.environ.get("OPENAI_API_KEY"):
+            return True
+        if "deepseek" in m_lower and os.environ.get("DEEPSEEK_API_KEY"):
+            return True
+        if "groq" in m_lower and os.environ.get("GROQ_API_KEY"):
+            return True
+        if ("bedrock" in m_lower or "anthropic.claude" in m_lower) and (os.environ.get("AWS_ACCESS_KEY_ID") or os.environ.get("AWS_PROFILE")):
+            return True
+        
+        # Local Ollama / GGUF check
+        driver = LLMDriver(model_name=model_name)
+        if driver.is_ollama_available():
+            mm = driver.get_model_manager()
+            if mm and mm.has_ollama_model(model_name):
+                return True
+        mm = driver.get_model_manager()
+        if mm:
+            gguf_path = mm.find_local_gguf(model_name)
+            if gguf_path and Path(gguf_path).exists():
+                return True
+        return False
+
+    @classmethod
+    def get_fallback_live_model(cls) -> Tuple[str, str]:
+        """Finds the best active live model or falls back to sovereign verified model."""
+        CredentialsManager.load_all_credentials()
+        if os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY"):
+            return "gemini-2.5-flash", "Active Google Gemini API key ('gemini-2.5-flash')"
+        if os.environ.get("ANTHROPIC_API_KEY"):
+            return "claude-3-5-sonnet-20241022", "Active Anthropic Claude API key"
+        if os.environ.get("OPENAI_API_KEY"):
+            return "gpt-4o-mini", "Active OpenAI API key"
+        if os.environ.get("DEEPSEEK_API_KEY"):
+            return "deepseek-chat", "Active DeepSeek API key"
+        if os.environ.get("GROQ_API_KEY"):
+            return "groq/llama-3.1-8b-instant", "Active Groq API key"
+        
+        driver = LLMDriver()
+        if driver.is_ollama_available():
+            mm = driver.get_model_manager()
+            if mm:
+                models = mm.list_installed_models()
+                if models:
+                    return models[0], f"Installed local model '{models[0]}'"
+            return "qwen2.5-coder:1.5b", "Local Ollama server"
+        
+        return "qwen2.5-coder:1.5b", "Sovereign local engine"
+
+    @classmethod
+    def resolve_model_for_prompt(cls, prompt: str, requested_model: Optional[str] = None) -> Tuple[str, str]:
+        """
+        Determines the optimal model for a given prompt:
+        - If requested_model is specific, verifies availability. If inactive/missing, auto-falls back.
+        - If requested_model is 'default' or 'auto', dynamically senses intent and chooses active model.
+        """
+        CredentialsManager.load_all_credentials()
+
+        if requested_model and requested_model.lower() not in ("auto", "dynamic", "none", "default"):
+            return requested_model.strip(), f"User-selected model: {requested_model.strip()}"
+
+        if requested_model and requested_model.lower() == "default":
+            def_m = DevPreferencesManager.get_default_model()
+            return def_m, f"Using user-pinned default model: {def_m}"
+
+        # Sensed Intent Routing
+        intent_res = IntentSensor.sense(prompt)
+        
+        if intent_res.intent == UserIntent.CHAT:
+            model = DevPreferencesManager.get_fast_chat_model()
+            if cls.is_model_live(model):
+                return model, f"⚡ Fast Chat Path ({intent_res.mode_label}): Routed to low-latency model '{model}'"
+
+        elif intent_res.intent == UserIntent.PLAN:
+            model = DevPreferencesManager.get_frontier_reasoning_model()
+            if cls.is_model_live(model):
+                return model, f"📐 Architectural Planner ({intent_res.mode_label}): Routed to frontier reasoning model '{model}'"
+
+        elif intent_res.intent in (UserIntent.BUILD, UserIntent.TRIAGE, UserIntent.IMMUNITY):
+            model = DevPreferencesManager.get_coding_specialist_model()
+            if cls.is_model_live(model):
+                return model, f"🔨 Autonomous Coding ({intent_res.mode_label}): Routed to compiler-grounded specialist '{model}'"
+
+        # Fallback to verified live model
+        live_m, live_reason = cls.get_fallback_live_model()
+        return live_m, f"Standard route to {live_reason} ('{live_m}')"
+
+
+class SmartModelRouter:
+    """
+    Dynamic Cost & Latency Optimizer Model Router.
+    """
+
+    def __init__(self, hub: Optional[ModelHub] = None):
+        self.hub = hub or ModelHub()
+        self.total_queries_routed: int = 0
+        self.total_saved_usd: float = 0.0
+
+    def analyze_complexity(self, task_prompt: str, context_length: int = 0) -> Tuple[TaskTier, int, str]:
+        """
+        Calculates complexity score (0-100) and returns TaskTier.
+        """
+        text = task_prompt.lower()
+        score = 20  # base standard
+
+        words = set(re.findall(r"[\w-]+", text))
+
+        # Complexity boosters
+        if any(w in text for w in ("architect", "architecture", "refactor", "security", "distributed", "consensus", "concurrency", "lock-free", "ast", "compiler", "multi-thread")):
+            score += 45
+        if any(w in text for w in ("red-team", "adversarial", "cryptographic", "memory leak", "race condition")):
+            score += 30
+        if context_length > 20000:
+            score += 25
+
+        # Simplicity reducers (word boundary safe)
+        if any(w in words for w in ("typo", "docstring", "comment", "format", "rename", "hello", "hi", "hey")) or "add log" in text:
+            score -= 30
+        if len(task_prompt.split()) < 8 and "fix" not in text and score <= 20:
+            score -= 15
+
+        score = max(0, min(100, score))
+
+        if score < 30:
+            return TaskTier.TRIVIAL, score, "Low-complexity conversational/trivial task suitable for fast/local SLM."
+        elif score < 70:
+            return TaskTier.STANDARD, score, "Moderate complexity suitable for high-throughput inference."
+        else:
+            return TaskTier.COMPLEX, score, "High-complexity architectural task requiring frontier reasoning."
+
+    def route(self, task_prompt: str, context_length: int = 0, force_local: bool = False) -> RouteDecision:
+        """
+        Decides the optimal model and estimates costs.
+        """
+        tier, score, reason = self.analyze_complexity(task_prompt, context_length)
+
+        if force_local or tier == TaskTier.TRIVIAL:
+            selected_model = DevPreferencesManager.get_fast_chat_model()
+            provider = "fast-tier"
+            cost = 0.0000
+        elif tier == TaskTier.STANDARD:
+            selected_model = "deepseek-coder"
+            provider = "deepseek"
+            cost = 0.0002
+        else:
+            selected_model = DevPreferencesManager.get_frontier_reasoning_model()
+            provider = "frontier"
+            cost = 0.0030
+
+        # Compare against GPT-4 baseline ($0.030 per 1k input/output avg)
+        baseline_cost = 0.0300
+        savings = max(0.0, baseline_cost - cost)
+
+        self.total_queries_routed += 1
+        self.total_saved_usd += savings
+
+        return RouteDecision(
+            task=task_prompt,
+            tier=tier,
+            selected_model=selected_model,
+            selected_provider=provider,
+            estimated_cost_usd=cost,
+            baseline_gpt4_cost_usd=baseline_cost,
+            savings_usd=savings,
+            reasoning=f"Score: {score}/100. {reason}",
+        )

k_cli/core/storage_manager.py

@@ -0,0 +1,176 @@
+"""
+storage_manager.py - Persistent Local Storage & Session Resumption Engine for K-CLI
+Project Bankai v1.0.0 — Built for AWS "Agents for Humans" Hackathon
+Developer: Krishiv Joshi (@krishivjoshi)
+
+Manages persistent local storage in ~/.kcli/:
+- Multi-turn conversation sessions & checkpoints (~/.kcli/sessions/)
+- API Keys & credentials (~/.kcli/credentials.env)
+- Developer preferences & default models (~/.kcli/preferences.json)
+- Enables 1-flag session continuation: `k-cli -c` or `k-cli --continue`
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+HOME_DIR = Path.home()
+STORAGE_DIR = Path(os.getenv("KCLI_HOME", HOME_DIR / ".kcli")).resolve()
+SESSIONS_DIR = STORAGE_DIR / "sessions"
+CREDS_FILE = STORAGE_DIR / "credentials.env"
+PREFS_FILE = STORAGE_DIR / "preferences.json"
+LATEST_SESSION_FILE = SESSIONS_DIR / "latest_session.json"
+AUDIT_JOURNAL_FILE = STORAGE_DIR / "audit_journal.jsonl"
+
+
+@dataclass
+class SessionTurn:
+    prompt: str
+    response: str
+    code: str = ""
+    success: bool = True
+    attempts: int = 1
+    patches_applied: bool = False
+    timestamp: float = field(default_factory=time.time)
+    routed_model: str = "auto"
+    persona: str = "CODER"
+
+
+@dataclass
+class SessionCheckpoint:
+    session_id: str
+    workspace_dir: str
+    active_model: str
+    active_persona: str
+    context_files: List[str] = field(default_factory=list)
+    history: List[Dict[str, Any]] = field(default_factory=list)
+    git_branch: str = "main"
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    total_tokens: int = 0
+    total_cost_saved: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SessionCheckpoint:
+        return cls(
+            session_id=data.get("session_id", f"session_{int(time.time())}"),
+            workspace_dir=data.get("workspace_dir", "."),
+            active_model=data.get("active_model", "qwen2.5-coder:1.5b"),
+            active_persona=data.get("active_persona", "Fullstack AI Systems Engineer"),
+            context_files=data.get("context_files", []),
+            history=data.get("history", []),
+            git_branch=data.get("git_branch", "main"),
+            created_at=data.get("created_at", time.time()),
+            updated_at=data.get("updated_at", time.time()),
+            total_tokens=data.get("total_tokens", 0),
+            total_cost_saved=data.get("total_cost_saved", 0.0),
+        )
+
+
+class LocalStorageManager:
+    """Enterprise-grade local storage engine for persistent session state and zero-config resume."""
+
+    @classmethod
+    def ensure_dirs(cls) -> None:
+        """Ensures ~/.kcli and ~/.kcli/sessions directories exist with proper permissions."""
+        STORAGE_DIR.mkdir(parents=True, exist_ok=True)
+        SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+
+    @classmethod
+    def save_session(
+        cls,
+        session_id: str,
+        workspace_dir: str,
+        active_model: str,
+        active_persona: str,
+        context_files: List[str],
+        history: List[Dict[str, Any]],
+        git_branch: str = "main",
+        total_tokens: int = 0,
+        total_cost_saved: float = 0.0,
+    ) -> Path:
+        """Persists a session checkpoint to ~/.kcli/sessions/ and updates latest_session.json."""
+        cls.ensure_dirs()
+        checkpoint = SessionCheckpoint(
+            session_id=session_id,
+            workspace_dir=str(Path(workspace_dir).resolve()),
+            active_model=active_model,
+            active_persona=active_persona,
+            context_files=context_files,
+            history=history,
+            git_branch=git_branch,
+            updated_at=time.time(),
+            total_tokens=total_tokens,
+            total_cost_saved=total_cost_saved,
+        )
+
+        # Write timestamped session file
+        session_file = SESSIONS_DIR / f"{session_id}.json"
+        data_json = json.dumps(checkpoint.to_dict(), indent=2)
+        session_file.write_text(data_json, encoding="utf-8")
+
+        # Write pointer to latest session
+        LATEST_SESSION_FILE.write_text(data_json, encoding="utf-8")
+
+        return session_file
+
+    @classmethod
+    def load_latest_session(cls) -> Optional[SessionCheckpoint]:
+        """Loads the most recently saved session checkpoint for -c / --continue flag."""
+        cls.ensure_dirs()
+        if not LATEST_SESSION_FILE.exists():
+            # Check if any session files exist in sessions dir
+            session_files = sorted(SESSIONS_DIR.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+            if not session_files:
+                return None
+            target_file = session_files[0]
+        else:
+            target_file = LATEST_SESSION_FILE
+
+        try:
+            data = json.loads(target_file.read_text(encoding="utf-8"))
+            return SessionCheckpoint.from_dict(data)
+        except Exception:
+            return None
+
+    @classmethod
+    def list_saved_sessions(cls) -> List[Dict[str, Any]]:
+        """Returns metadata for all persisted sessions."""
+        cls.ensure_dirs()
+        results = []
+        for p in sorted(SESSIONS_DIR.glob("*.json"), key=lambda x: x.stat().st_mtime, reverse=True):
+            if p.name == "latest_session.json":
+                continue
+            try:
+                data = json.loads(p.read_text(encoding="utf-8"))
+                results.append({
+                    "session_id": data.get("session_id", p.stem),
+                    "file": str(p),
+                    "model": data.get("active_model", "unknown"),
+                    "turns": len(data.get("history", [])),
+                    "workspace": data.get("workspace_dir", "."),
+                    "updated_at": data.get("updated_at", p.stat().st_mtime),
+                })
+            except Exception:
+                continue
+        return results
+
+    @classmethod
+    def record_activity(cls, event_type: str, details: Dict[str, Any]) -> None:
+        """Appends an immutable event record to ~/.kcli/audit_journal.jsonl."""
+        cls.ensure_dirs()
+        record = {
+            "timestamp": time.time(),
+            "event": event_type,
+            **details,
+        }
+        with open(AUDIT_JOURNAL_FILE, "a", encoding="utf-8") as f:
+            f.write(json.dumps(record) + "\n")

k_cli/core/viewport_engine.py

@@ -0,0 +1,117 @@
+"""
+viewport_engine.py - Hyper-Responsive Auto-Adjusting Viewport & Layout Engine for K-CLI
+Project Bankai v1.0.0
+
+Calculates optimal UI density, pane visibility, modal scaling, and typography
+across all terminal sizes and displays (Compact <90cols, Standard 90-140cols, UltraWide >140cols).
+Ensures zero visual clipping, zero clutter, and automatic responsive adaptation.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from dataclasses import dataclass
+from enum import Enum
+from typing import Tuple, Dict, Any
+
+
+class ViewportMode(str, Enum):
+    COMPACT = "compact"        # < 95 cols: 1-pane focus mode, sidebars collapsed
+    STANDARD = "standard"      # 95 - 140 cols: 2-pane mode (Sidebar + Canvas)
+    ULTRAWIDE = "ultrawide"    # > 140 cols: 3-pane mode (Sidebar + Canvas + Drawer)
+
+
+@dataclass
+class ViewportGeometry:
+    width: int
+    height: int
+    mode: ViewportMode
+    show_left_sidebar: bool
+    show_right_drawer: bool
+    sidebar_width: int
+    drawer_width: int
+    chat_width_fraction: float
+    hud_density: str
+    is_height_constrained: bool
+
+    def to_css_classes(self) -> list[str]:
+        classes = [f"viewport-{self.mode.value}"]
+        if not self.show_left_sidebar:
+            classes.append("hide-sidebar")
+        if not self.show_right_drawer:
+            classes.append("hide-drawer")
+        if self.is_height_constrained:
+            classes.append("height-compact")
+        return classes
+
+
+class ViewportEngine:
+    """
+    Real-time screen geometry and auto-adjusting layout calculator (<0.01ms).
+    """
+
+    @classmethod
+    def get_current_terminal_size(cls) -> Tuple[int, int]:
+        """Gets (columns, rows) of current terminal with graceful fallback."""
+        try:
+            size = shutil.get_terminal_size(fallback=(120, 35))
+            return size.columns, size.lines
+        except Exception:
+            return 120, 35
+
+    @classmethod
+    def compute_geometry(cls, width: Optional[int] = None, height: Optional[int] = None) -> ViewportGeometry:
+        """
+        Calculates optimal layout dimensions and visibility flags based on viewport width & height.
+        """
+        if width is None or height is None:
+            cur_w, cur_h = cls.get_current_terminal_size()
+            width = width if width is not None else cur_w
+            height = height if height is not None else cur_h
+
+        # Prevent degenerate dimensions
+        w = max(40, width)
+        h = max(15, height)
+
+        is_height_compact = h < 26
+
+        if w >= 140:
+            mode = ViewportMode.ULTRAWIDE
+            show_left = True
+            show_right = True
+            left_w = 26
+            right_w = 30
+            density = "full"
+        elif w >= 95:
+            mode = ViewportMode.STANDARD
+            show_left = True
+            show_right = False  # Right drawer hidden to give maximum space to canvas
+            left_w = 22
+            right_w = 0
+            density = "standard"
+        else:
+            mode = ViewportMode.COMPACT
+            show_left = False
+            show_right = False  # Pure 1-pane streamlined focus mode
+            left_w = 0
+            right_w = 0
+            density = "minimal"
+
+        # Calculate chat width ratio
+        occupied = (left_w if show_left else 0) + (right_w if show_right else 0)
+        remaining = max(30, w - occupied)
+        chat_fraction = remaining / w
+
+        return ViewportGeometry(
+            width=w,
+            height=h,
+            mode=mode,
+            show_left_sidebar=show_left,
+            show_right_drawer=show_right,
+            sidebar_width=left_w,
+            drawer_width=right_w,
+            chat_width_fraction=chat_fraction,
+            hud_density=density,
+            is_height_constrained=is_height_compact,
+        )