coreinsight-cli 0.2.0__tar.gz → 0.2.6__tar.gz

{coreinsight_cli-0.2.0 → coreinsight_cli-0.2.6}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: coreinsight-cli
-Version: 0.2.0
+Version: 0.2.6
 Summary: Local-first AI performance profiler that mathematically verifies optimizations for Python, C++, and CUDA
 Author: Varun Jani
-License: MIT
+License: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/Prais3/coreinsight_cli
 Project-URL: Bug Tracker, https://github.com/Prais3/coreinsight_cli/issues
 Keywords: performance,profiling,optimization,llm,cuda,cpp,python,hpc,benchmarking
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -33,6 +33,8 @@ Requires-Dist: pydantic>=2.0
 Requires-Dist: chromadb>=0.5.0
 Requires-Dist: sentence-transformers>=3.0.0
 Requires-Dist: psutil>=5.9
+Provides-Extra: compat
+Requires-Dist: pysqlite3-binary>=0.5.0; extra == "compat"
 Dynamic: license-file
 
 # CoreInsight CLI
@@ -169,6 +171,18 @@ coreinsight configure
 coreinsight configure --pro-key <your-key>
 ```
 
+### `coreinsight configure [--agent-mode <mode>]`
+Choose between single-agent or multi-agent mode.
+Pass `--agent-mode multi` for multi-agent usage.
+```bash
+# Explicit override
+coreinsight configure --agent-mode multi
+coreinsight configure --agent-mode single
+
+# Reset to auto-selection
+coreinsight configure --agent-mode auto
+```
+
 ---
 
 ## Supported languages
@@ -266,3 +280,10 @@ CoreInsight is local-first by design:
   analyse is sent to the provider's API, under your own key
 - The optimization memory store lives at `~/.coreinsight/memory_db` on
   your local filesystem
+
+## Troubleshooting
+
+ChromaDB issue with old SQLite3 versions. To resolve:
+```bash
+pip install pysqlite3-binary # >=0.5.0
+```

{coreinsight_cli-0.2.0 → coreinsight_cli-0.2.6}/README.md

@@ -132,6 +132,18 @@ coreinsight configure
 coreinsight configure --pro-key <your-key>
 ```
 
+### `coreinsight configure [--agent-mode <mode>]`
+Choose between single-agent or multi-agent mode.
+Pass `--agent-mode multi` for multi-agent usage.
+```bash
+# Explicit override
+coreinsight configure --agent-mode multi
+coreinsight configure --agent-mode single
+
+# Reset to auto-selection
+coreinsight configure --agent-mode auto
+```
+
 ---
 
 ## Supported languages
@@ -228,4 +240,11 @@ CoreInsight is local-first by design:
 - **Cloud providers** — only the function code and context you choose to
   analyse is sent to the provider's API, under your own key
 - The optimization memory store lives at `~/.coreinsight/memory_db` on
-  your local filesystem
+  your local filesystem
+
+## Troubleshooting
+
+ChromaDB issue with old SQLite3 versions. To resolve:
+```bash
+pip install pysqlite3-binary # >=0.5.0
+```

coreinsight_cli-0.2.6/coreinsight/__init__.py

@@ -0,0 +1,6 @@
+try:
+    __import__('pysqlite3')
+    import sys
+    sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
+except ImportError:
+    pass  # pysqlite3 not installed — rely on system sqlite3

{coreinsight_cli-0.2.0 → coreinsight_cli-0.2.6}/coreinsight/analyzer.py

@@ -395,4 +395,405 @@ class AnalyzerAgent:
 
         except Exception as e:
             logger.warning(f"generate_test_cases failed for '{func_name}': {e}")
+            return []
+        
+# ---------------------------------------------------------------------------
+# Multi-agent support (v0.2.5)
+# ---------------------------------------------------------------------------
+
+def _build_llm(provider: str, model_name: str, api_keys: dict):
+    """
+    Shared LLM factory for all multi-agent classes.
+    Returns (base_llm, json_llm) — same pattern as AnalyzerAgent.__init__.
+    Raises ValueError on missing credentials.
+    """
+    api_keys = api_keys or {}
+
+    if provider == "openai":
+        if not api_keys.get("openai"):
+            raise ValueError("OpenAI API key required.")
+        llm = ChatOpenAI(
+            model=model_name,
+            api_key=api_keys["openai"],
+            temperature=0.1,
+            model_kwargs={"response_format": {"type": "json_object"}},
+        )
+        return llm, llm
+
+    if provider == "local_server":
+        base_url = api_keys.get("local_url", "http://localhost:1234/v1")
+        llm = ChatOpenAI(
+            model=model_name,
+            api_key="not-needed",
+            base_url=base_url,
+            temperature=0.1,
+            model_kwargs={"response_format": {"type": "json_object"}},
+        )
+        return llm, llm
+
+    if provider == "anthropic":
+        if not api_keys.get("anthropic"):
+            raise ValueError("Anthropic API key required.")
+        llm = ChatAnthropic(
+            model=model_name,
+            api_key=api_keys["anthropic"],
+            temperature=0.1,
+        )
+        return llm, llm
+
+    if provider == "google":
+        if not api_keys.get("google"):
+            raise ValueError("Google Gemini API key required.")
+        llm = ChatGoogleGenerativeAI(
+            model=model_name,
+            google_api_key=api_keys["google"],
+            temperature=0.1,
+            convert_system_message_to_human=True,
+        )
+        return llm, llm
+
+    # Ollama default
+    base = ChatOllama(
+        model=model_name,
+        temperature=0.1,
+        num_predict=4096,
+        num_ctx=8192,
+    )
+    return base, base.bind(format="json")
+
+
+class BottleneckAgent:
+    """
+    Agent 1 — analysis only.
+    Identifies the single most critical bottleneck and returns the same
+    dict structure as AnalyzerAgent.analyze() so process_function cannot
+    tell the difference.  optimized_code is always None from this agent.
+    """
+
+    def __init__(
+        self,
+        provider:   str,
+        model_name: str,
+        api_keys:   dict,
+        model_tier: str,
+    ) -> None:
+        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._prompt = PromptTemplate(
+            template=BOTTLENECK_TEMPLATE,
+            input_variables=[
+                "language", "code_content", "context", "hardware_target",
+            ],
+            partial_variables={
+                "system_prompt":      SYSTEM_PROMPT,
+                "format_instructions": self.parser.get_format_instructions(),
+            },
+        )
+        self._chain = self._prompt | self._json_llm | self.parser
+
+    def analyze(
+        self,
+        code:            str,
+        language:        str,
+        context:         str = "",
+        hardware_target: str = "Generic CPU",
+    ) -> dict:
+        try:
+            return self._chain.invoke({
+                "language":        language,
+                "code_content":    code,
+                "context":         context,
+                "hardware_target": hardware_target,
+            })
+        except OutputParserException:
+            return {
+                "severity":       "Error",
+                "issue":          "AI Output Parsing Failed",
+                "reasoning":      "The model failed to return valid JSON.",
+                "suggestion":     "Try running again or use a larger model.",
+                "bottlenecks":    [],
+                "optimized_code": None,
+            }
+        except Exception as e:
+            return {
+                "severity":       "Error",
+                "issue":          str(e),
+                "reasoning":      "System error during bottleneck analysis.",
+                "suggestion":     "Check LLM API keys and connectivity.",
+                "bottlenecks":    [],
+                "optimized_code": None,
+            }
+
+
+class OptimizerAgent:
+    """
+    Agent 2 — code generation only.
+    Receives the bottleneck analysis result and writes the optimized function.
+    Returns raw code as a string (no JSON, no harness).
+    """
+
+    def __init__(
+        self,
+        provider:   str,
+        model_name: str,
+        api_keys:   dict,
+        model_tier: str,
+    ) -> None:
+        from coreinsight.prompts import OPTIMIZER_TEMPLATE
+        self.model_tier = model_tier
+        self._base_llm, _ = _build_llm(provider, model_name, api_keys)
+        self._template = OPTIMIZER_TEMPLATE
+
+    def _extract_code(self, raw: str) -> str:
+        """Reuse the same extraction logic as AnalyzerAgent."""
+        blocks = re.findall(r"```[a-zA-Z+#]*\s*\n(.*?)```", raw, re.DOTALL)
+        if blocks:
+            return max(blocks, key=len).strip()
+        lines = raw.strip().split("\n")
+        lines = [l for l in lines if not re.match(r"^```", l)]
+        while lines and lines[0].lower().startswith(
+            ("here is", "sure", "certainly", "output:")
+        ) and not lines[0].strip().startswith(("#", "//")):
+            lines.pop(0)
+        return "\n".join(lines).strip()
+
+    def generate(
+        self,
+        func_name:       str,
+        original_code:   str,
+        analysis:        dict,
+        language:        str,
+        context:         str = "",
+        hardware_target: str = "Generic CPU",
+    ) -> str:
+        """
+        Returns the optimized function as a raw code string.
+        Returns original_code on any failure so the pipeline can continue.
+        """
+        try:
+            chain  = PromptTemplate.from_template(self._template) | self._base_llm
+            result = chain.invoke({
+                "language":        language,
+                "func_name":       func_name,
+                "hardware_target": hardware_target,
+                "severity":        analysis.get("severity",  ""),
+                "issue":           analysis.get("issue",     ""),
+                "reasoning":       analysis.get("reasoning", ""),
+                "suggestion":      analysis.get("suggestion",""),
+                "original":        original_code,
+                "context":         context or "None",
+            })
+            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
+                )
+            code = self._extract_code(raw)
+            return code if code else original_code
+        except Exception as e:
+            logger.warning(f"OptimizerAgent.generate failed: {e}")
+            return original_code
+
+
+class HarnessAgent:
+    """
+    Agent 3 — harness generation and fix loop.
+    Owns the entire retry loop so process_function stays clean.
+    Returns (harness_code, success, logs, plot_data) after running in sandbox.
+    """
+
+    def __init__(
+        self,
+        provider:   str,
+        model_name: str,
+        api_keys:   dict,
+        model_tier: str,
+    ) -> None:
+        from coreinsight.prompts import (
+            HARNESS_TEMPLATE_MULTI,
+            FIX_TEMPLATE_MULTI,
+            HARNESS_ADDENDUM_MULTI,
+        )
+        self.model_tier      = model_tier
+        self._base_llm, _    = _build_llm(provider, model_name, api_keys)
+        self._harness_tmpl   = HARNESS_TEMPLATE_MULTI + HARNESS_ADDENDUM_MULTI.get(model_tier, "")
+        self._fix_tmpl       = FIX_TEMPLATE_MULTI     + HARNESS_ADDENDUM_MULTI.get(model_tier, "")
+
+    def _extract_code(self, raw: str) -> str:
+        blocks = re.findall(r"```[a-zA-Z+#]*\s*\n(.*?)```", raw, re.DOTALL)
+        if blocks:
+            return max(blocks, key=len).strip()
+        lines = raw.strip().split("\n")
+        lines = [l for l in lines if not re.match(r"^```", l)]
+        while lines and lines[0].lower().startswith(
+            ("here is", "sure", "certainly", "output:")
+        ) and not lines[0].strip().startswith(("#", "//")):
+            lines.pop(0)
+        return "\n".join(lines).strip()
+
+    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)
+        if isinstance(raw, list):
+            raw = "\n".join(
+                item["text"] if isinstance(item, dict) and "text" in item
+                else str(item)
+                for item in raw
+            )
+        return self._extract_code(raw)
+
+    def _check_speedup(self, success: bool, logs: str) -> bool:
+        if not success:
+            return False
+        try:
+            for line in reversed(logs.strip().split("\n")):
+                parts = line.split(",")
+                if len(parts) == 4 and parts[0].strip().isdigit():
+                    return float(parts[3]) >= 1.05
+        except Exception:
+            pass
+        return False
+
+    def run(
+        self,
+        func_name:       str,
+        original_code:   str,
+        optimized_code:  str,
+        language:        str,
+        context:         str,
+        hardware_target: str,
+        sandbox,                    # CodeSandbox instance
+        max_retries:     int = 2,
+    ) -> tuple:
+        """
+        Generates harness, runs in sandbox, retries on failure.
+        Returns (success, logs, plot_data, retry_count).
+        """
+        try:
+            harness = self._invoke(self._harness_tmpl, {
+                "language":        language,
+                "func_name":       func_name,
+                "original":        original_code,
+                "optimized":       optimized_code,
+                "context":         context,
+                "hardware_target": hardware_target,
+            })
+        except Exception as e:
+            return False, f"Harness generation failed: {e}", None, 0
+
+        success, logs, plot_data = sandbox.execute_benchmark(harness, language)
+        is_valid  = self._check_speedup(success, logs)
+        retries   = 0
+
+        while not is_valid and retries < max_retries:
+            if success and "N,Original_Time" not in logs:
+                logs += "\nERROR: Script ran but did NOT print the CSV table. You MUST print the strict CSV format."
+            elif success:
+                logs += "\nERROR: Optimized code was SLOWER than original. Rewrite to be faster."
+
+            try:
+                harness = self._invoke(self._fix_tmpl, {
+                    "language":   language,
+                    "func_name":  func_name,
+                    "original":   original_code,
+                    "bad_harness":harness,
+                    "error_logs": logs,
+                    "context":    context,
+                })
+            except Exception as e:
+                logs += f"\nFix generation failed: {e}"
+                break
+
+            success, logs, plot_data = sandbox.execute_benchmark(harness, language)
+            is_valid = self._check_speedup(success, logs)
+            retries += 1
+
+        if 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
+            success = False
+
+        return success, logs, plot_data, retries
+
+
+class TestCaseAgent:
+    """
+    Agent 4 — test case generation only.
+    Identical logic to AnalyzerAgent.generate_test_cases but as a
+    standalone class so it can be called from a separate thread.
+    """
+
+    def __init__(
+        self,
+        provider:   str,
+        model_name: str,
+        api_keys:   dict,
+        model_tier: str,
+    ) -> None:
+        self.model_tier   = model_tier
+        self._base_llm, _ = _build_llm(provider, model_name, api_keys)
+
+    def generate(
+        self,
+        func_name:     str,
+        original_code: str,
+        language:      str,
+        context:       str = "",
+        num_cases:     int = 8,
+    ) -> list:
+        """
+        Same return contract as AnalyzerAgent.generate_test_cases:
+        list of {"args": [...], "kwargs": {...}} or [] on failure.
+        """
+        import json as _json
+
+        chain = PromptTemplate.from_template(_TEST_CASES_TEMPLATE) | self._base_llm
+        try:
+            result = chain.invoke({
+                "func_name": func_name,
+                "language":  language,
+                "original":  original_code,
+                "context":   context or "None",
+                "num_cases": num_cases,
+            })
+            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
+                )
+
+            raw = re.sub(r"```[a-zA-Z]*\s*", "", raw).strip()
+            raw = re.sub(r"```",              "", raw).strip()
+            raw = re.sub(r"\bNone\b",  "null",  raw)
+            raw = re.sub(r"\bTrue\b",  "true",  raw)
+            raw = re.sub(r"\bFalse\b", "false", raw)
+            raw = re.sub(r",\s*([\]}])", r"\1", raw)
+
+            match = re.search(r"\[.*\]", raw, re.DOTALL)
+            if match:
+                raw = match.group(0)
+
+            try:
+                cases = _json.loads(raw)
+            except _json.JSONDecodeError:
+                import ast
+                cases = ast.literal_eval(raw)
+
+            return [
+                c for c in cases
+                if isinstance(c, dict)
+                and isinstance(c.get("args"),   list)
+                and isinstance(c.get("kwargs"), dict)
+            ]
+        except Exception as e:
+            logger.warning(f"TestCaseAgent.generate failed for '{func_name}': {e}")
             return []

{coreinsight_cli-0.2.0 → coreinsight_cli-0.2.6}/coreinsight/config.py

@@ -51,6 +51,32 @@ def is_pro(config: dict) -> bool:
 def get_tier_limits(config: dict) -> dict:
     return PRO_TIER_LIMITS if is_pro(config) else FREE_TIER_LIMITS
 
+
+def get_agent_mode(config: dict) -> str:
+    """
+    Returns "multi" or "single".
+
+    Priority:
+      1. Explicit user override stored in config ("agent_mode" key)
+      2. Auto-selection based on model tier:
+           - small / medium local models  → "multi"
+             (focused prompts compensate for smaller context windows)
+           - large / cloud models         → "single"
+             (large models handle full context fine; saves API cost)
+    """
+    explicit = config.get("agent_mode")
+    if explicit in ("single", "multi"):
+        return explicit
+
+    provider   = config.get("provider",   "ollama")
+    model_name = config.get("model_name", "llama3.2")
+    tier       = get_model_tier(provider, model_name)
+
+    from coreinsight.prompts import ModelTier
+    if tier in (ModelTier.SMALL, ModelTier.MEDIUM):
+        return "multi"
+    return "single"
+
 def load_config():
     if not CONFIG_FILE.exists():
         return {"provider": "ollama", "model_name": "llama3.2", "api_keys": {}}
@@ -62,7 +88,7 @@ def save_config(config_data):
     with open(CONFIG_FILE, "w") as f:
         json.dump(config_data, f, indent=4)
 
-def run_configure(pro_key: str = None):
+def run_configure(pro_key: str = None, agent_mode: str = None):
     """Interactive CLI to set up models and API keys."""
     console.print("[bold cyan]⚙️ CoreInsight Configuration[/bold cyan]")
 
@@ -93,6 +119,27 @@ def run_configure(pro_key: str = None):
         except Exception as e:
             console.print("[red]⚠️ Could not verify key. Please check your internet connection or try again later.[/red]")
         return
+
+    if agent_mode is not None:
+        if agent_mode in ("single", "multi"):
+            config["agent_mode"] = agent_mode
+            save_config(config)
+            console.print(
+                f"[bold green]✅ Agent mode set to [cyan]{agent_mode}[/cyan].[/bold green]\n"
+                f"[dim]Use [cyan]coreinsight configure --agent-mode auto[/cyan] "
+                f"to restore automatic selection.[/dim]"
+            )
+        elif agent_mode == "auto":
+            config.pop("agent_mode", None)
+            save_config(config)
+            console.print(
+                "[bold green]✅ Agent mode reset to automatic selection.[/bold green]"
+            )
+        else:
+            console.print(
+                "[red]Invalid agent mode. Choose from: single, multi, auto[/red]"
+            )
+        return
     
     provider = Prompt.ask(
         "Which AI provider do you want to use?",
@@ -121,8 +168,33 @@ def run_configure(pro_key: str = None):
     if provider == "ollama":
         config["model_name"] = Prompt.ask("Ollama model name", default=config.get("model_name", "llama3.2"))
     elif provider == "local_server":
-        config["model_name"] = Prompt.ask("Local model name (optional)", default=config.get("model_name", "local-model"))
-        config["api_keys"]["local_url"] = Prompt.ask("Local Server Base URL", default="http://localhost:1234/v1")
+        console.print(Panel(
+            "[bold]Local inference server setup[/bold]\n\n"
+            "CoreInsight talks to any OpenAI-compatible local server.\n"
+            "Choose the option that matches how you loaded your weights:\n\n"
+            "[bold cyan]Option A — GGUF weights (llama.cpp):[/bold cyan]\n"
+            "  pip install llama-cpp-python\\[server]\n"
+            "  python -m llama_cpp.server --model your_model.gguf --port 1234\n\n"
+            "[bold cyan]Option B — PyTorch / HuggingFace weights (vLLM):[/bold cyan]\n"
+            "  pip install vllm\n"
+            "  python -m vllm.entrypoints.openai.api_server \\\\\n"
+            "      --model /path/to/weights --port 1234\n\n"
+            "[bold cyan]Option C — LM Studio (GUI, easiest):[/bold cyan]\n"
+            "  1. Load your model in LM Studio\n"
+            "  2. Click [bold]Start Server[/bold] (defaults to localhost:1234)\n"
+            "  3. Enter the URL below\n\n"
+            "[dim]All three expose an OpenAI-compatible API on the URL you provide.[/dim]",
+            title="⚙️  Local Inference Server",
+            border_style="cyan",
+        ))
+        config["model_name"] = Prompt.ask(
+            "Model name (shown in server logs, or 'local-model')",
+            default=config.get("model_name", "local-model"),
+        )
+        config["api_keys"]["local_url"] = Prompt.ask(
+            "Server base URL",
+            default=config.get("api_keys", {}).get("local_url", "http://localhost:1234/v1"),
+        )
     elif provider == "openai":
         config["model_name"] = Prompt.ask("OpenAI model name", default="gpt-4o")
         config["api_keys"]["openai"] = Prompt.ask("OpenAI API Key (hidden)", password=True)