coreinsight-cli 0.2.7__tar.gz → 0.2.9__tar.gz

{coreinsight_cli-0.2.7/coreinsight_cli.egg-info → coreinsight_cli-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreinsight-cli
-Version: 0.2.7
+Version: 0.2.9
 Summary: Local-first AI performance profiler that mathematically verifies optimizations for Python, C++, and CUDA
 Author: Varun Jani
 License: GPL-3.0-or-later

{coreinsight_cli-0.2.7 → coreinsight_cli-0.2.9}/coreinsight/analyzer.py

@@ -14,6 +14,35 @@ from langchain_anthropic import ChatAnthropic
 
 from coreinsight.prompts import SYSTEM_PROMPT, ANALYSIS_TEMPLATE, HARNESS_ADDENDUM
 
+# Phrases that appear at the start of a truncated LLM response
+_TRUNCATION_HINTS = (
+    "context length",
+    "context_length_exceeded",
+    "maximum context",
+    "token limit",
+    "finish_reason: length",
+    "finish_reason\":\"length",
+)
+
+def _is_truncated(raw: str) -> bool:
+    """
+    Returns True if the raw LLM output looks like it was cut off mid-generation.
+    Catches both explicit error messages and structural truncation signs.
+    """
+    if not raw or len(raw.strip()) < 20:
+        return True
+    low = raw.lower()
+    if any(hint in low for hint in _TRUNCATION_HINTS):
+        return True
+    stripped = raw.strip()
+    # JSON truncation: opened but never closed
+    if stripped.startswith("{") and not stripped.endswith("}"):
+        return True
+    # Code truncation: opens a block but ends mid-statement
+    if stripped.endswith(("...", "/*", "//", "\"", "'")):
+        return True
+    return False
+
 logger = logging.getLogger(__name__)
 
 
@@ -163,12 +192,15 @@ class AnalyzerAgent:
             self.json_llm = self.base_llm
 
         elif provider == "local_server":
-            base_url = api_keys.get("local_url", "http://localhost:1234/v1")
+            from coreinsight.prompts import ModelTier
+            base_url   = api_keys.get("local_url", "http://localhost:1234/v1")
+            _max_tokens = 2048 if model_tier == ModelTier.SMALL else 4096
             self.base_llm = ChatOpenAI(
                 model=model_name,
                 api_key="not-needed",
                 base_url=base_url,
                 temperature=0.1,
+                max_tokens=_max_tokens,
                 model_kwargs={"response_format": {"type": "json_object"}},
             )
             self.json_llm = self.base_llm
@@ -196,11 +228,20 @@ class AnalyzerAgent:
             self.json_llm = self.base_llm
 
         else:  # Ollama default
+            from coreinsight.prompts import ModelTier
+            # Small models (7B) typically have 4096 native context.
+            # Asking for more causes silent degradation or OOM on the host.
+            # Medium/large local models can handle 8192 comfortably.
+            _ctx = 4096 if model_tier == ModelTier.SMALL else 8192
+            # num_predict: small models need room for JSON + code in one shot.
+            # Capping at 2048 for small prevents runaway generation that hits
+            # the limit mid-JSON and returns truncated garbage.
+            _predict = 2048 if model_tier == ModelTier.SMALL else 4096
             self.base_llm = ChatOllama(
                 model=model_name,
                 temperature=0.1,
-                num_predict=4096,
-                num_ctx=8192,
+                num_predict=_predict,
+                num_ctx=_ctx,
             )
             self.json_llm = self.base_llm.bind(format="json")
 
@@ -258,14 +299,31 @@ class AnalyzerAgent:
     def _invoke_code_chain(self, template: str, variables: dict, language: str) -> str:
         """Shared invocation + extraction logic for harness and fix chains."""
         chain = PromptTemplate.from_template(template) | self.base_llm
-        result = chain.invoke(variables)
+        try:
+            result = chain.invoke(variables)
+        except Exception as e:
+            err = str(e).lower()
+            if any(h in err for h in _TRUNCATION_HINTS):
+                raise RuntimeError(
+                    f"Model hit its context limit. Try a smaller file, fewer functions, "
+                    f"or a model with a larger context window. Detail: {e}"
+                ) from e
+            raise
         raw = result.content if hasattr(result, "content") else str(result)
-        # Handle Anthropic returning a list of content blocks
         if isinstance(raw, list):
             raw = "\n".join(
                 item["text"] if isinstance(item, dict) and "text" in item else str(item)
                 for item in raw
             )
+        if _is_truncated(raw):
+            logger.warning(
+                f"LLM output appears truncated (len={len(raw)}). "
+                f"Model likely hit its context/predict limit."
+            )
+            raise RuntimeError(
+                "Model output was truncated — hit context or token limit. "
+                "Try a model with a larger context window, or reduce the function size."
+            )
         return self._extract_executable_code(raw)
 
     def generate_harness(
@@ -421,12 +479,14 @@ def _build_llm(provider: str, model_name: str, api_keys: dict):
         return llm, llm
 
     if provider == "local_server":
-        base_url = api_keys.get("local_url", "http://localhost:1234/v1")
+        base_url    = api_keys.get("local_url", "http://localhost:1234/v1")
+        _max_tokens = api_keys.pop("_predict", 4096)  # reuse same key as Ollama path
         llm = ChatOpenAI(
             model=model_name,
             api_key="not-needed",
             base_url=base_url,
             temperature=0.1,
+            max_tokens=_max_tokens,
             model_kwargs={"response_format": {"type": "json_object"}},
         )
         return llm, llm
@@ -452,16 +512,33 @@ def _build_llm(provider: str, model_name: str, api_keys: dict):
         )
         return llm, llm
 
-    # Ollama default
+    # Ollama default — context and predict budget are passed in from the
+    # calling agent which knows its own model_tier.
+    # Default to medium-safe values; callers override via kwargs if needed.
+    _ctx     = api_keys.pop("_ctx",     8192)
+    _predict = api_keys.pop("_predict", 4096)
     base = ChatOllama(
         model=model_name,
         temperature=0.1,
-        num_predict=4096,
-        num_ctx=8192,
+        num_predict=_predict,
+        num_ctx=_ctx,
     )
     return base, base.bind(format="json")
 
 
+def _build_llm_tiered(provider: str, model_name: str, api_keys: dict, model_tier: str):
+    """Wraps _build_llm with tier-aware context settings for local providers."""
+    from coreinsight.prompts import ModelTier
+    keys = dict(api_keys or {})
+    if provider == "ollama":
+        keys["_ctx"]     = 4096 if model_tier == ModelTier.SMALL else 8192
+        keys["_predict"] = 2048 if model_tier == ModelTier.SMALL else 4096
+    elif provider == "local_server":
+        # max_tokens controls response length — context window is server-side
+        keys["_predict"] = 2048 if model_tier == ModelTier.SMALL else 4096
+    return _build_llm(provider, model_name, keys)
+
+
 class BottleneckAgent:
     """
     Agent 1 — analysis only.
@@ -480,7 +557,7 @@ class BottleneckAgent:
         from coreinsight.prompts import BOTTLENECK_TEMPLATE, SYSTEM_PROMPT
         self.model_tier = model_tier
         self.parser     = JsonOutputParser(pydantic_object=AuditResult)
-        self._base_llm, self._json_llm = _build_llm(provider, model_name, api_keys)
+        self._base_llm, self._json_llm = _build_llm_tiered(provider, model_name, api_keys, model_tier)
 
         self._prompt = PromptTemplate(
             template=BOTTLENECK_TEMPLATE,
@@ -544,7 +621,7 @@ class OptimizerAgent:
     ) -> None:
         from coreinsight.prompts import OPTIMIZER_TEMPLATE
         self.model_tier = model_tier
-        self._base_llm, _ = _build_llm(provider, model_name, api_keys)
+        self._base_llm, _ = _build_llm_tiered(provider, model_name, api_keys, model_tier)
         self._template = OPTIMIZER_TEMPLATE
 
     def _extract_code(self, raw: str) -> str:
@@ -620,7 +697,7 @@ class HarnessAgent:
             HARNESS_ADDENDUM_MULTI,
         )
         self.model_tier      = model_tier
-        self._base_llm, _    = _build_llm(provider, model_name, api_keys)
+        self._base_llm, _    = _build_llm_tiered(provider, model_name, api_keys, model_tier)
         self._harness_tmpl   = HARNESS_TEMPLATE_MULTI + HARNESS_ADDENDUM_MULTI.get(model_tier, "")
         self._fix_tmpl       = FIX_TEMPLATE_MULTI     + HARNESS_ADDENDUM_MULTI.get(model_tier, "")
 
@@ -638,14 +715,28 @@ class HarnessAgent:
 
     def _invoke(self, template: str, variables: dict) -> str:
         chain  = PromptTemplate.from_template(template) | self._base_llm
-        result = chain.invoke(variables)
-        raw    = result.content if hasattr(result, "content") else str(result)
+        try:
+            result = chain.invoke(variables)
+        except Exception as e:
+            err = str(e).lower()
+            if any(h in err for h in _TRUNCATION_HINTS):
+                raise RuntimeError(
+                    f"Model hit its context limit during harness generation. "
+                    f"Detail: {e}"
+                ) from e
+            raise
+        raw = result.content if hasattr(result, "content") else str(result)
         if isinstance(raw, list):
             raw = "\n".join(
                 item["text"] if isinstance(item, dict) and "text" in item
                 else str(item)
                 for item in raw
             )
+        if _is_truncated(raw):
+            raise RuntimeError(
+                "Harness output was truncated — model hit its token limit. "
+                "Switching to fix loop with truncation note."
+            )
         return self._extract_code(raw)
 
     def _check_speedup(self, success: bool, logs: str) -> bool:
@@ -714,7 +805,9 @@ class HarnessAgent:
             is_valid = self._check_speedup(success, logs)
             retries += 1
 
-        if is_valid and retries > 0:
+        if getattr(sandbox, 'disabled', False):
+            pass  # skipped intentionally — don't annotate as failed
+        elif is_valid and retries > 0:
             logs = f"(Succeeded after {retries} retries)\n" + logs
         elif not is_valid:
             logs    = f"(Failed after {retries} retries)\n" + logs
@@ -738,7 +831,7 @@ class TestCaseAgent:
         model_tier: str,
     ) -> None:
         self.model_tier   = model_tier
-        self._base_llm, _ = _build_llm(provider, model_name, api_keys)
+        self._base_llm, _ = _build_llm_tiered(provider, model_name, api_keys, model_tier)
 
     def generate(
         self,

coreinsight_cli-0.2.9/coreinsight/embeddings.py

@@ -0,0 +1,103 @@
+"""
+coreinsight/embeddings.py — Shared embedding utility
+
+Single source of truth for embedding model loading used by both
+memory.py (OptimizationMemory) and indexer.py (RepoIndexer).
+
+Tries to load all-MiniLM-L6-v2 from local cache first.
+Falls back to a deterministic hash-based embedder when offline
+or when the model has not yet been downloaded.
+"""
+from __future__ import annotations
+
+import hashlib
+import logging
+import math
+import os
+from pathlib import Path
+from typing import List, Tuple
+
+logger = logging.getLogger(__name__)
+
+# All models cached here — never hits the network if already present
+MODEL_CACHE_DIR = Path.home() / ".coreinsight" / "models"
+MODEL_NAME      = "all-MiniLM-L6-v2"
+
+
+class _HashEmbeddingFunction:
+    """
+    Deterministic offline fallback embedder.
+
+    Produces a 384-dim float vector from token overlap — no downloads,
+    no GPU, no network. Semantic quality is lower than MiniLM but RAG
+    and memory lookup still work via keyword/structural matching.
+
+    Run `coreinsight index` once while online to cache the real model.
+    """
+    DIM = 384
+
+    def __call__(self, input: List[str]) -> List[List[float]]:
+        results = []
+        for text in input:
+            tokens = text.lower().split()
+            vec    = [0.0] * self.DIM
+            for tok in tokens:
+                h = int(hashlib.sha256(tok.encode()).hexdigest(), 16)
+                vec[h % self.DIM] += 1.0
+            # L2 normalise so cosine distance works correctly
+            mag = math.sqrt(sum(x * x for x in vec)) or 1.0
+            results.append([x / mag for x in vec])
+        return results
+
+
+def load_embedding_fn() -> Tuple[object, str]:
+    """
+    Load the sentence-transformer embedding function.
+
+    Returns:
+        (embedding_fn, label) where label is a human-readable string
+        indicating which embedder is active — shown in CLI output.
+
+    Strategy:
+        1. Pin HuggingFace cache to ~/.coreinsight/models so the model
+           is never re-downloaded on subsequent runs.
+        2. Probe the model with a dummy call to force-load weights now
+           rather than silently failing later during indexing or lookup.
+        3. On any failure (network error, disk full, offline) fall back
+           to _HashEmbeddingFunction with a visible warning.
+    """
+    MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Pin cache dirs — must be set before chromadb.utils imports torch
+    os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", str(MODEL_CACHE_DIR))
+    os.environ.setdefault("HF_HUB_CACHE",              str(MODEL_CACHE_DIR))
+    # Allow download when online; callers that want strict offline can
+    # set HF_HUB_OFFLINE=1 in their environment before importing.
+    os.environ.setdefault("HF_HUB_OFFLINE", "0")
+
+    try:
+        from chromadb.utils import embedding_functions as _ef
+
+        fn = _ef.SentenceTransformerEmbeddingFunction(model_name=MODEL_NAME)
+
+        # Force-load now so we catch errors here, not mid-analysis.
+        fn(["probe"])
+
+        label = f"{MODEL_NAME} (cached)"
+        logger.debug(f"Embedding model loaded: {label}")
+        return fn, label
+
+    except Exception as exc:
+        logger.warning(
+            f"SentenceTransformer unavailable ({exc}). "
+            f"Using offline hash embedder — semantic quality reduced. "
+            f"Run `coreinsight index` once while online to cache the model."
+        )
+        from rich.console import Console as _Console
+        _Console().print(
+            "[yellow]⚠  Embedding model unavailable (offline or not yet downloaded). "
+            "Using keyword-based fallback — RAG and memory recall will work but with "
+            "reduced semantic accuracy. "
+            "Run [cyan]coreinsight index[/cyan] once while online to cache the model.[/yellow]"
+        )
+        return _HashEmbeddingFunction(), "hash-based (offline fallback)"

{coreinsight_cli-0.2.7 → coreinsight_cli-0.2.9}/coreinsight/indexer.py

@@ -9,62 +9,11 @@ import chromadb
 from chromadb.utils import embedding_functions
 
 from coreinsight.parser import CodeParser
+from coreinsight.embeddings import load_embedding_fn
 
 console = Console()
 logger  = logging.getLogger(__name__)
 
-# Local model cache — never hits the network if model is already here
-_MODEL_CACHE_DIR = Path.home() / ".coreinsight" / "models"
-
-
-class _HashEmbeddingFunction:
-    """
-    Deterministic offline fallback embedder.
-    Produces a 384-dim float vector from token overlap — no downloads, no GPU.
-    Semantic quality is lower than MiniLM but RAG still works via keyword matching.
-    """
-    DIM = 384
-
-    def __call__(self, input: list[str]) -> list[list[float]]:
-        results = []
-        for text in input:
-            tokens = text.lower().split()
-            vec    = [0.0] * self.DIM
-            for tok in tokens:
-                h = int(hashlib.sha256(tok.encode()).hexdigest(), 16)
-                vec[h % self.DIM] += 1.0
-            # L2 normalise
-            mag = math.sqrt(sum(x * x for x in vec)) or 1.0
-            results.append([x / mag for x in vec])
-        return results
-
-
-def _load_embedding_fn():
-    """
-    Try to load SentenceTransformer from local cache.
-    Falls back to _HashEmbeddingFunction if offline or model not cached.
-    """
-    _MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", str(_MODEL_CACHE_DIR))
-    os.environ.setdefault("HF_HUB_OFFLINE", "0")  # allow download when online
-
-    try:
-        fn = embedding_functions.SentenceTransformerEmbeddingFunction(
-            model_name="all-MiniLM-L6-v2",
-        )
-        # Probe: actually load the model now so we catch network errors here
-        # rather than silently later during indexing.
-        fn(["probe"])
-        return fn, "all-MiniLM-L6-v2 (cached)"
-    except Exception as e:
-        logger.warning(f"SentenceTransformer unavailable ({e}). Using offline hash embedder — semantic quality reduced.")
-        console.print(
-            "[yellow]⚠  Embedding model unavailable (offline or not yet downloaded). "
-            "Using keyword-based fallback — RAG will work but with reduced semantic accuracy. "
-            "Run [cyan]coreinsight index[/cyan] once while online to cache the model.[/yellow]"
-        )
-        return _HashEmbeddingFunction(), "hash-based (offline fallback)"
-
 
 class RepoIndexer:
     def __init__(self, repo_path: str):
@@ -82,7 +31,7 @@ class RepoIndexer:
             return True
         try:
             self._chroma_client   = chromadb.PersistentClient(path=str(self.db_path))
-            self._embedding_fn, self._embedding_label = _load_embedding_fn()
+            self._embedding_fn, self._embedding_label = load_embedding_fn()
             self._collection      = self._chroma_client.get_or_create_collection(
                 name="codebase_context",
                 embedding_function=self._embedding_fn,

{coreinsight_cli-0.2.7 → coreinsight_cli-0.2.9}/coreinsight/main.py

@@ -272,8 +272,15 @@ def process_function(func: dict, language: str, agent: AnalyzerAgent, sandbox: C
         return func_name, result, (success, logs, plot_data), None, verification, profiler_result, None, is_valid_optimization
 
     except Exception as e:
+        err_str = str(e)
+        if "context" in err_str.lower() and "limit" in err_str.lower():
+            _log(func_name, f"Context limit hit: {e}", style="bold yellow")
+            return func_name, None, None, (
+                f"⚠️  Context limit: {err_str}\n"
+                f"Try a model with a larger context window, or split the function."
+            ), None, None, None, False
         _log(func_name, f"Failed: {e}", style="bold red")
-        return func_name, None, None, f"❌ Analysis failed: {str(e)}", None, None, None, False
+        return func_name, None, None, f"❌ Analysis failed: {err_str}", None, None, None, False
 
 def parse_csv_logs(logs: str):
     """Safely extracts CSV data from the sandbox logs."""
@@ -734,7 +741,7 @@ def run_analysis(file_path: str, no_docker: bool = False, tui_console=None):
     finally:
         console = _prev_console
 
-def run_demo(lang: str = "python", no_docker: bool = False):
+def run_demo(lang: str = "python", no_docker: bool = False, tui_console=None):
     import shutil
     import importlib.resources
 
@@ -797,18 +804,34 @@ def run_demo(lang: str = "python", no_docker: bool = False):
     # For Python: auto-index so RAG cross-file context is showcased
     if lang == "python":
         console.print("[dim]Auto-indexing demo files to showcase RAG cross-file context...[/dim]")
-        from coreinsight.indexer import RepoIndexer as _RepoIndexer
-        _RepoIndexer(str(demo_dir)).index_repository()
+        try:
+            from coreinsight.indexer import RepoIndexer as _RepoIndexer
+            _RepoIndexer(str(demo_dir)).index_repository()
+        except Exception as _idx_err:
+            # Non-fatal — SQLite write conflicts can occur when running
+            # through the TUI. RAG context will be empty for this run.
+            console.print(f"[dim yellow]Indexing skipped (will retry next run): {_idx_err}[/dim yellow]")
         console.print()
 
-    run_analysis(str(demo_dir / entry_file), no_docker=no_docker)
+    run_analysis(str(demo_dir / entry_file), no_docker=no_docker, tui_console=tui_console)
 
-def _run_memory_cmd(clear: bool):
+def _run_memory_cmd(clear: bool, export_path: str = None, export_fmt: str = "csv"):
     from coreinsight.memory import OptimizationMemory, MEMORY_DIR
     import shutil
 
     mem = OptimizationMemory()
 
+    if export_path:
+        count = mem.export(export_path, fmt=export_fmt)
+        if count:
+            console.print(
+                f"[bold green]✅ Exported {count} optimization(s) to "
+                f"[cyan]{export_path}[/cyan][/bold green]"
+            )
+        else:
+            console.print("[yellow]Nothing to export — memory store is empty.[/yellow]")
+        return
+
     if clear:
         if MEMORY_DIR.exists():
             shutil.rmtree(MEMORY_DIR, ignore_errors=True)
@@ -930,7 +953,12 @@ def main_cli():
     index_parser.add_argument("--dir", default=".", help="Directory to index")
     
     memory_parser = subparsers.add_parser("memory", help="Inspect or clear the local optimization memory")
-    memory_parser.add_argument("--clear", action="store_true", help="Wipe the memory store")
+    memory_parser.add_argument("--clear",  action="store_true", help="Wipe the memory store")
+    memory_parser.add_argument("--export", dest="export_path",  default=None,
+                               help="Export memory to file (e.g. --export optimizations.csv)")
+    memory_parser.add_argument("--format", dest="export_fmt",   default="csv",
+                               choices=["csv", "md"],
+                               help="Export format: csv (default) or md")
 
     view_parser = subparsers.add_parser("view", help="Launch the interactive TUI")
     view_parser.add_argument("--dir", default=".", help="Starting directory (default: current)")
@@ -954,7 +982,11 @@ def main_cli():
     elif args.command == "analyze":
         run_analysis(args.file, no_docker=getattr(args, "no_docker", False))
     elif args.command == "memory":
-        _run_memory_cmd(getattr(args, "clear", False))
+        _run_memory_cmd(
+            clear=getattr(args, "clear", False),
+            export_path=getattr(args, "export_path", None),
+            export_fmt=getattr(args, "export_fmt", "csv"),
+        )
     elif args.command == "scan":
         scanner = ProjectScanner(args.dir)
         scanner.scan_project(max_results=args.top)