jarvis-cli-ck 1.0.0__py3-none-any.whl

core/llm_engine.py

@@ -0,0 +1,347 @@
+"""
+llm_engine.py — LLM interface for Jarvis CLI.
+
+Primary:  Ollama (local, phi3:mini, CPU-friendly, streaming).
+Fallback 1: NVIDIA NIM DeepSeek V4 Flash (cloud, fast).
+Fallback 2: NVIDIA NIM Llama 3.1 8B Instruct (cloud, backup).
+
+Both are lazy-loaded — never imported at module level.
+Reads API keys from ~/.jarvis/config.yaml.
+"""
+
+from pathlib import Path
+from typing import Dict, Generator, List, Optional
+
+import yaml
+
+from utils.logger import log
+from utils.language_detect import detect
+
+# ── Config path ───────────────────────────────────────────────────────────────
+_CONFIG_PATH = Path.home() / ".jarvis" / "config.yaml"
+
+# ── Defaults (overridden by config.yaml) ─────────────────────────────────────
+DEFAULT_OLLAMA_MODEL = "phi3:mini"
+
+NIM_API_URL = "https://integrate.api.nvidia.com/v1/chat/completions"
+TIMEOUT = 30  # increased to 30 seconds for larger model API calls and cold-starts
+
+# ── NIM Models Map ────────────────────────────────────────────────────────────
+NIM_MODELS = {
+    "deepseek_v4_pro": {
+        "id": "deepseek-ai/deepseek-v4-pro",
+        "key_name": "deepseek_v4_pro"
+    },
+    "llama_3_3_70b_instruct": {
+        "id": "meta/llama-3.3-70b-instruct",
+        "key_name": "llama_3_3_70b_instruct"
+    },
+    "mistral_large_3_675b_instruct_2512": {
+        "id": "mistralai/mistral-large-3-675b-instruct-2512",
+        "key_name": "mistral_large_3_675b_instruct_2512"
+    },
+    "llama_3_2_11b_vision_instruct": {
+        "id": "meta/llama-3.2-11b-vision-instruct",
+        "key_name": "llama_3_2_11b_vision_instruct"
+    },
+    "deepseek_v4_flash": {
+        "id": "deepseek-ai/deepseek-v4-flash",
+        "key_name": "deepseek_v4_flash"
+    },
+    "llama_3_1_8b_instruct": {
+        "id": "meta/llama-3.1-8b-instruct",
+        "key_name": "llama_3_1_8b_instruct"
+    }
+}
+
+
+def _load_config() -> Dict:
+    """Load Jarvis config from ~/.jarvis/config.yaml.
+
+    Returns:
+        Config dict, or empty dict if file is missing.
+    """
+    if not _CONFIG_PATH.exists():
+        return {}
+    try:
+        with _CONFIG_PATH.open("r") as f:
+            return yaml.safe_load(f) or {}
+    except Exception as exc:
+        log.error(f"Config load failed: {exc}")
+        return {}
+
+
+def _get_model() -> str:
+    """Return the configured Ollama model name.
+
+    Returns:
+        Model name string from config, or DEFAULT_OLLAMA_MODEL.
+    """
+    cfg = _load_config()
+    return cfg.get("jarvis", {}).get("llm_model", DEFAULT_OLLAMA_MODEL)
+
+
+def _get_nim_keys() -> Dict[str, str]:
+    """Return the NVIDIA NIM API keys from config.
+
+    Returns:
+        Dict mapping model key name to api key value.
+    """
+    cfg = _load_config()
+    nim_keys = cfg.get("apis", {}).get("nvidia_nim", {})
+    if isinstance(nim_keys, dict):
+        return nim_keys
+    return {}
+
+
+# ── Ollama streaming ──────────────────────────────────────────────────────────
+
+def stream_ollama(
+    messages: List[Dict[str, str]],
+    model: Optional[str] = None,
+) -> Generator[str, None, None]:
+    """Stream a chat completion from Ollama (local, CPU-safe).
+
+    Lazy-loads the ollama library on first call.
+    Yields token strings as they arrive.
+
+    Args:
+        messages: List of {"role": ..., "content": ...} dicts.
+        model: Ollama model name. Defaults to config value.
+
+    Yields:
+        Token strings from the LLM response.
+
+    Raises:
+        RuntimeError: If Ollama is not running or model is unavailable.
+    """
+    try:
+        import ollama  # lazy-load
+    except ImportError:
+        raise RuntimeError("ollama package not installed. Run: pip install ollama")
+
+    m = model or _get_model()
+    log.debug(f"Ollama stream started.")
+
+    try:
+        stream = ollama.chat(
+            model=m,
+            messages=messages,
+            stream=True,
+        )
+        for chunk in stream:
+            token = chunk.get("message", {}).get("content", "")
+            if token:
+                yield token
+    except Exception as exc:
+        raise RuntimeError(f"Ollama error: {exc}") from exc
+
+
+# ── NVIDIA NIM streaming ──────────────────────────────────────────────────────
+
+def stream_nim(
+    messages: List[Dict[str, str]],
+    model_key: str,
+    max_tokens: int = 256,
+) -> Generator[str, None, None]:
+    """Stream a chat completion from NVIDIA NIM API (cloud).
+
+    Lazy-loads requests. Reads API keys from ~/.jarvis/config.yaml.
+    Yields token strings as they arrive via SSE.
+
+    Args:
+        messages: List of {"role": ..., "content": ...} dicts.
+        model_key: Key name in NIM_MODELS (e.g. "deepseek_v4_pro").
+
+    Yields:
+        Token strings from the LLM response.
+
+    Raises:
+        RuntimeError: If API key is missing or request fails.
+    """
+    import json
+    import requests
+
+    if model_key not in NIM_MODELS:
+        raise RuntimeError(f"Unknown NIM model key: {model_key}")
+
+    model_info = NIM_MODELS[model_key]
+    model_id = model_info["id"]
+    key_name = model_info["key_name"]
+
+    keys = _get_nim_keys()
+    key = keys.get(key_name)
+
+    if not key:
+        raise RuntimeError(
+            f"NVIDIA NIM API key for {key_name} not found in config."
+        )
+
+    headers = {
+        "Authorization": f"Bearer {key}",
+        "Content-Type": "application/json",
+        "Accept": "text/event-stream",
+    }
+    payload = {
+        "model": model_id,
+        "messages": messages,
+        "stream": True,
+        "max_tokens": max_tokens,
+    }
+
+    try:
+        with requests.post(
+            NIM_API_URL,
+            headers=headers,
+            json=payload,
+            stream=True,
+            timeout=TIMEOUT,
+        ) as resp:
+            resp.raise_for_status()
+            for line in resp.iter_lines():
+                if not line:
+                    continue
+                decoded = line.decode("utf-8")
+                if decoded.startswith("data: "):
+                    data_str = decoded[6:]
+                    if data_str.strip() == "[DONE]":
+                        break
+                    try:
+                        data = json.loads(data_str)
+                        choices = data.get("choices")
+                        if choices:
+                            token = choices[0].get("delta", {}).get("content", "")
+                            if token:
+                                yield token
+                    except json.JSONDecodeError:
+                        continue
+    except requests.RequestException as exc:
+        raise RuntimeError(f"NVIDIA NIM API error for {model_id}: {exc}") from exc
+
+
+# ── Public interface ──────────────────────────────────────────────────────────
+
+def stream(
+    messages: List[Dict[str, str]],
+    model: Optional[str] = None,
+    max_tokens: int = 256,
+) -> Generator[str, None, None]:
+    """Stream tokens from Ollama, falling back to NIM engines sequentially.
+
+    This is the primary entry point for all LLM calls in Jarvis.
+
+    Args:
+        messages: List of {"role": ..., "content": ...} dicts.
+        model: Optional model override.
+
+    Yields:
+        Token strings.
+    """
+    # ── Language detection & System Prompt Injection ──
+    # Check the last user message to detect language
+    user_content = ""
+    for msg in reversed(messages):
+        if msg.get("role") == "user":
+            user_content = msg.get("content", "")
+            break
+            
+    lang = detect(user_content)
+    
+    # Inject language prompt at the start of conversation
+    lang_instructions = "Respond in English."
+    if lang == "tamil":
+        lang_instructions = "Respond in Tamil using Tamil script (Unicode)."
+    elif lang == "tanglish":
+        lang_instructions = (
+            "Respond in Tanglish — Tamil words written in English letters/script, "
+            "mixed naturally with English. Example: 'Nalla idea da, let me check panren.'"
+        )
+
+    # Check if a system prompt exists, otherwise create one
+    system_index = -1
+    for idx, msg in enumerate(messages):
+        if msg.get("role") == "system":
+            system_index = idx
+            break
+
+    system_content = (
+        f"You are Jarvis — a sharp, friendly AI partner built into a terminal. {lang_instructions} "
+        "Your personality: smart, concise, professional, and warmly human. "
+        "You speak like a knowledgeable friend, not a corporate chatbot. "
+        "RULES you must always follow:\n"
+        "1. Keep replies SHORT by default. 1-3 sentences max for casual conversation. Only elaborate when the user asks a technical or detailed question.\n"
+        "2. For greetings like 'hi', 'hello', 'hey' — reply with ONE casual, friendly line. No bullet points, no long intros.\n"
+        "3. Never wrap responses in markdown code fences (``` or ''').\n"
+        "4. Never prefix your response with 'Jarvis:' or 'Assistant:'.\n"
+        "5. Do NOT pad responses with unnecessary phrases like 'I am here to assist you with anything you need' — be direct.\n"
+        "6. If the user asks a technical question, answer it clearly and precisely. Use brief bullet points only when truly needed.\n"
+        "7. Match the user's energy — casual query = casual short reply; serious task = focused professional reply."
+    )
+
+    if system_index >= 0:
+        messages[system_index]["content"] = messages[system_index]["content"] + f" {lang_instructions}"
+    else:
+        messages.insert(0, {"role": "system", "content": system_content})
+
+    # Try local Ollama first
+    try_ollama = True
+    nim_model = None
+    if model:
+        if model.startswith("nim:"):
+            try_ollama = False
+            nim_model = model.replace("nim:", "")
+        elif model in NIM_MODELS:
+            try_ollama = False
+            nim_model = model
+
+    if try_ollama:
+        if ping_ollama():
+            try:
+                yield from stream_ollama(messages, model)
+                return
+            except Exception as ollama_err:
+                log.warn(f"Ollama unavailable: {ollama_err}. Falling back to Cloud NIM...")
+        else:
+            log.debug("Ollama is not running. Falling back to Cloud NIM...")
+
+    # Dynamic fallback list (optimized for instant response and verified active models first)
+    fallbacks = [
+        "deepseek_v4_flash",
+        "llama_3_2_11b_vision_instruct",
+        "llama_3_1_8b_instruct",
+        "mistral_large_3_675b_instruct_2512",
+        "deepseek_v4_pro",
+        "llama_3_3_70b_instruct"
+    ]
+    
+    # If the user requested a specific NIM model via model override
+    if nim_model and nim_model in NIM_MODELS:
+        fallbacks = [nim_model] + [f for f in fallbacks if f != nim_model]
+
+    for model_key in fallbacks:
+        # Check if the key exists in our config
+        keys = _get_nim_keys()
+        if NIM_MODELS[model_key]["key_name"] in keys:
+            try:
+                yield from stream_nim(messages, model_key, max_tokens=max_tokens)
+                return
+            except Exception as e:
+                log.warn(f"NIM {model_key} failed: {e}. Trying next fallback...")
+    
+    log.error(f"All LLM backends failed.")
+    yield "⚠ Jarvis: No LLM backend available. Start Ollama or check internet connection."
+
+
+def ping_ollama() -> bool:
+    """Check if Ollama is running and accessible.
+
+    Returns:
+        True if Ollama is reachable, False otherwise.
+    """
+    try:
+        import requests
+        # Use 1.0 second timeout for fast localhost connection check
+        resp = requests.get("http://localhost:11434", timeout=1.0)
+        return resp.status_code == 200
+    except Exception:
+        return False

core/mode_toggle.py

@@ -0,0 +1,70 @@
+"""
+mode_toggle.py — Simplified mode toggle state for Jarvis CLI, supporting Chat Mode only.
+"""
+
+from enum import Enum
+from typing import Callable, List
+
+
+class Mode(Enum):
+    """Available Jarvis operating modes. Only CHAT is supported now."""
+    CHAT = "chat"
+
+
+def get() -> Mode:
+    """Return the current active mode (always CHAT).
+
+    Returns:
+        Mode.CHAT
+    """
+    return Mode.CHAT
+
+
+def set_mode(mode: Mode) -> None:
+    """Mock setting active mode (always CHAT).
+
+    Args:
+        mode: The Mode to switch to.
+    """
+    pass
+
+
+def toggle() -> Mode:
+    """Toggling is a no-op, always remains in CHAT mode.
+
+    Returns:
+        Mode.CHAT
+    """
+    return Mode.CHAT
+
+
+def is_voice() -> bool:
+    """Voice mode is completely removed.
+
+    Returns:
+        False
+    """
+    return False
+
+
+def is_chat() -> bool:
+    """Jarvis is always in chat mode now.
+
+    Returns:
+        True
+    """
+    return True
+
+
+def on_change(callback: Callable[[Mode], None]) -> None:
+    """Register callback (no-op)."""
+    pass
+
+
+def label() -> str:
+    """Return 'CHAT'.
+
+    Returns:
+        "CHAT"
+    """
+    return "CHAT"

core/router.py

@@ -0,0 +1,198 @@
+"""
+router.py — Intent-based request dispatcher for Jarvis CLI.
+
+Receives a user query, classifies the intent via intent_parser,
+dispatches to the appropriate module handler, and returns the response.
+Falls back to the LLM engine for general conversation.
+"""
+
+from typing import Dict, Optional
+
+from core import session
+from core.llm_engine import stream
+from utils.intent_parser import parse
+from utils.logger import log
+from utils.language_detect import detect
+
+_SYSTEM_PROMPT = (
+    "You are Jarvis — a sharp, friendly AI partner built into a terminal. "
+    "Your personality: smart, concise, professional, and warmly human. "
+    "You speak like a knowledgeable friend, not a corporate chatbot. "
+    "RULES: "
+    "1. Keep replies SHORT — 1-3 sentences for casual chat. "
+    "2. For greetings like 'hi', 'hello', 'hey' reply with ONE casual line. "
+    "3. Never use markdown code fences (``` or '''). "
+    "4. Never prefix with 'Jarvis:' or 'Assistant:'. "
+    "5. No padding phrases. Be direct. "
+    "6. For technical questions answer precisely; brief bullets only when truly needed. "
+    "7. Match the user's energy — casual = short, technical = focused."
+)
+
+
+def route(query: str) -> str:
+    """Route a user query to the correct module and return the response.
+
+    Classification priority:
+    1. Keyword intent matching (fast, offline)
+    2. Module handler (if intent found)
+    3. LLM general chat fallback (Ollama → NIM)
+
+    Args:
+        query: Raw user input string.
+
+    Returns:
+        Response string to display/speak to the user.
+    """
+    if not query.strip():
+        return ""
+
+    session.add_message("user", query)
+    context = _build_context()
+
+    # Detect language of user query
+    lang = detect(query)
+
+    intent, confidence = parse(query)
+    log.debug(f"Intent: {intent} (confidence={confidence:.2f})")
+
+    response = _dispatch(intent, query, context)
+    
+    # If the response is generated by a module (not general chat) and language is Tamil/Tanglish,
+    # localize/translate the response to the user's preferred language.
+    if intent != "UNKNOWN" and response and not response.startswith("⚠"):
+        response = _localize_response(response, lang)
+
+    session.add_message("assistant", response)
+    return response
+
+
+def _localize_response(response: str, lang: str) -> str:
+    """Localize/Translate the response into Tamil or Tanglish."""
+    if lang == "tamil":
+        instruction = "Translate/respond to the following information in Tamil (using Tamil Unicode script):"
+    elif lang == "tanglish":
+        instruction = (
+            "Translate/respond to the following information in natural Tanglish "
+            "(Tamil words spelled in English, mixed with English naturally). "
+            "Keep it short, simple, and friendly. "
+            "Example: 'Iniku date vanthu Wednesday, July 1st da. Time 10:15 PM aachu.'"
+        )
+    else:
+        return response
+
+    messages = [
+        {
+            "role": "system",
+            "content": "You are a translator/localizer. Keep the response concise, matching the exact meaning of the input."
+        },
+        {
+            "role": "user",
+            "content": f"{instruction}\n\n{response}"
+        }
+    ]
+    tokens = []
+    try:
+        from core.llm_engine import stream as llm_stream
+        for token in llm_stream(messages):
+            tokens.append(token)
+        return "".join(tokens)
+    except Exception as exc:
+        log.warn(f"Localization failed: {exc}")
+        return response
+
+
+def _dispatch(intent: str, query: str, context: Dict) -> str:
+    """Dispatch to the correct module handler based on intent.
+
+    Args:
+        intent: Classified intent name.
+        query: Original user query.
+        context: Session context dict.
+
+    Returns:
+        Response string from the handler.
+    """
+    try:
+        if intent == "NEWS":
+            from modules.news import handle
+            return handle(query, context)
+
+        elif intent == "TIME" or intent == "CALENDAR":
+            from modules.time_cal import handle
+            return handle(query, context)
+
+        elif intent == "MAPS":
+            from modules.maps import handle
+            return handle(query, context)
+
+        elif intent == "SYSTEM":
+            from modules.system_diag import handle
+            return handle(query, context)
+
+        elif intent == "FILE":
+            from modules.file_manager import handle
+            return handle(query, context)
+            
+        elif intent == "WEB_DEV":
+            from modules.web_developer import handle
+            return handle(query, context)
+
+        elif intent == "CODE":
+            from modules.coder import handle
+            return handle(query, context)
+
+        elif intent == "VIRUS":
+            from modules.virus_scanner import handle
+            return handle(query, context)
+
+        elif intent == "COMMAND":
+            from modules.command_runner import handle
+            return handle(query, context)
+
+        else:
+            # General LLM chat fallback — short by default for casual queries
+            # Use more tokens only if the query looks complex (> 8 words)
+            word_count = len(query.split())
+            tokens_cap = 512 if word_count > 8 else 256
+            return _llm_chat(query, max_tokens=tokens_cap)
+
+
+    except Exception as exc:
+        log.error(f"Handler error for intent {intent}: {exc}", exc_info=True)
+        return f"⚠ Sorry, I ran into an error: {exc}"
+
+
+def _llm_chat(query: str, max_tokens: int = 256) -> str:
+    """Send the query to the LLM and collect the full streamed response.
+
+    Args:
+        query: User query for general chat.
+        max_tokens: Token cap for the response.
+
+    Returns:
+        Complete LLM response string.
+    """
+    messages = [
+        {"role": "system", "content": _SYSTEM_PROMPT},
+        *session.history_as_dicts(n=10),
+    ]
+    tokens = []
+    try:
+        for token in stream(messages, max_tokens=max_tokens):
+            tokens.append(token)
+        return "".join(tokens)
+    except Exception as exc:
+        log.error(f"LLM chat failed: {exc}")
+        return f"⚠ LLM error: {exc}"
+
+
+def _build_context() -> Dict:
+    """Build a context dict for module handlers.
+
+    Returns:
+        Dict with session summary and history reference.
+    """
+    return {
+        "history": session.get_history(n=5),
+        "summary": session.summary(),
+    }