coreinsight-cli 0.1.0__py3-none-any.whl

coreinsight/Dockerfile.cpp-sandbox

@@ -0,0 +1,2 @@
+FROM gcc:latest
+WORKDIR /workspace

coreinsight/Dockerfile.python-sandbox

@@ -0,0 +1,3 @@
+FROM python:3.11-slim
+RUN pip install --no-cache-dir numpy pandas scipy matplotlib
+WORKDIR /workspace

coreinsight/analyzer.py

@@ -0,0 +1,374 @@
+import re
+import logging
+from typing import Optional, List
+from pydantic import BaseModel, Field
+
+from langchain_core.output_parsers import JsonOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.exceptions import OutputParserException
+
+from langchain_ollama import ChatOllama
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+
+from coreinsight.prompts import SYSTEM_PROMPT, ANALYSIS_TEMPLATE
+
+logger = logging.getLogger(__name__)
+
+
+class Bottleneck(BaseModel):
+    line: int = Field(description="The approximate line number of the issue in the original code")
+    severity: str = Field(description="Critical, High, Medium, Low")
+    message: str = Field(description="Specific hardware or algorithmic bottleneck at this line")
+    suggestion: str = Field(description="How to fix this specific line")
+
+
+class AuditResult(BaseModel):
+    severity: str = Field(description="Overall severity: Critical, High, Medium, Low")
+    issue: str = Field(description="Brief overall description of the bottleneck")
+    reasoning: str = Field(description="Step-by-step hardware-level reasoning for the proposed changes")
+    suggestion: str = Field(description="Overall specific fix strategy")
+    bottlenecks: List[Bottleneck] = Field(description="List of specific line-level bottlenecks", default_factory=list)
+    optimized_code: Optional[str] = Field(description="The entirely rewritten optimized code, ready to drop in", default=None)
+
+
+_HARNESS_TEMPLATE = """
+You are a strict QA engineer writing a standalone asymptotic scaling benchmark script in {language}.
+
+ORIGINAL FUNCTION (Name: {func_name}):
+{original}
+
+OPTIMIZED FUNCTION:
+{optimized}
+
+GLOBAL DEPENDENCIES (Helper functions/structs required to run the code):
+{context}
+
+Write the complete executable script (e.g., `int main()` or `if __name__ == "__main__":`) that:
+1. Includes necessary imports/headers.
+2. Includes ALL required helper functions or structs from GLOBAL DEPENDENCIES so the script is fully standalone.
+3. Defines BOTH the original and optimized functions exactly as provided above.
+4. Tests multiple data sizes (e.g., N=10, 100, 1000, 5000).
+5. Target Hardware: {hardware_target}. The largest N MUST cross cache boundaries but MUST NOT exceed 20% of available RAM to prevent OOM crashes.
+6. Initializes realistic dummy data for each size N.
+7. Times execution of original vs optimized using high-resolution timers.
+
+CRITICAL TIMING:
+- Python: use `time.perf_counter()`. C++: use `std::chrono::high_resolution_clock`.
+- Clamp: `orig_time = max(end - start, 1e-9)` to prevent zero-division.
+- Speedup: `speedup = orig_time / opt_time`.
+
+ISOLATION RULES (CRITICAL):
+- This runs in an empty Docker container. NO local files exist.
+- DO NOT use local imports. Define everything inline.
+- DO NOT rename the original function — call it exactly `{func_name}`.
+
+OUTPUT FORMAT (CRITICAL):
+Print ONLY this exact CSV to stdout, no other text:
+N,Original_Time,Optimized_Time,Speedup
+10,0.002,0.001,2.00
+
+[PYTHON ONLY]: Also import matplotlib, plot results, and save as `benchmark_plot.png`.
+
+FORMATTING RULE: Wrap your ENTIRE script in a single markdown code block. No text before or after.
+"""
+
+_FIX_TEMPLATE = """
+You are an expert {language} developer. Your previous benchmark script FAILED in an isolated sandbox.
+
+ORIGINAL FUNCTION (Name: {func_name}):
+{original}
+
+GLOBAL DEPENDENCIES:
+{context}
+
+YOUR FAILED SCRIPT:
+{bad_harness}
+
+EXECUTION ERROR LOGS:
+{error_logs}
+
+ISOLATION CONSTRAINTS (CRITICAL):
+- Empty Docker container. No local files. NO local imports.
+- Define `{func_name}` and all GLOBAL DEPENDENCIES inline.
+
+FIX INSTRUCTIONS:
+1. Diagnose the failure from the error logs above.
+2. Fix imports, NameErrors, type mismatches, infinite loops, or OOM issues.
+3. Maintain the CSV stdout format exactly: N,Original_Time,Optimized_Time,Speedup
+4. Use high-resolution timers and clamp with `max(t, 1e-9)`.
+5. [PYTHON ONLY]: Save benchmark plot as `benchmark_plot.png`.
+
+FORMATTING RULE: Wrap your ENTIRE fixed script in a single markdown code block. No text before or after.
+"""
+
+_TEST_CASES_TEMPLATE = """
+You are a QA engineer writing correctness test cases for a function.
+
+FUNCTION NAME: {func_name}
+LANGUAGE: {language}
+
+FUNCTION SIGNATURE AND BODY:
+{original}
+
+GLOBAL DEPENDENCIES (helper functions / structs this function relies on):
+{context}
+
+Your task: generate {num_cases} diverse test cases that call `{func_name}` with different
+arguments. The cases must cover:
+  - Small inputs (N ~ 10)
+  - Medium inputs (N ~ 100-500)
+  - Edge cases: empty collections, single-element, all-zeros, negative values (where applicable)
+  - Boundary conditions specific to this function's logic
+
+OUTPUT FORMAT — respond with ONLY a valid JSON array, nothing else. No markdown fences,
+no explanation. Each element must be a JSON object with exactly two keys:
+  "args"  : a JSON array of positional arguments (use only JSON-serialisable types:
+            numbers, strings, booleans, arrays, objects — NO numpy, NO bytes)
+  "kwargs": a JSON object of keyword arguments (may be empty {{}})
+
+Example (do NOT copy this — generate cases specific to {func_name}):
+[
+  {{"args": [[1, 2, 3]], "kwargs": {{}}}},
+  {{"args": [[]], "kwargs": {{}}}},
+  {{"args": [[9, -1, 4, 0, 7]], "kwargs": {{"reverse": true}}}}
+]
+
+CONSTRAINTS:
+- All values must be plain JSON types — no numpy arrays, no custom objects.
+- If the function operates on a matrix, represent it as a list-of-lists.
+- If the function takes a size integer N, generate concrete data of that size inline.
+- Do NOT include function calls or expressions — only literal values.
+- Produce exactly {num_cases} test cases.
+"""
+
+
+class AnalyzerAgent:
+    def __init__(self, provider="ollama", model_name="llama3.2", api_keys=None):
+        self.parser = JsonOutputParser(pydantic_object=AuditResult)
+        self.provider = provider
+        api_keys = api_keys or {}
+
+        if provider == "openai":
+            if not api_keys.get("openai"):
+                raise ValueError("OpenAI API Key required.")
+            self.base_llm = ChatOpenAI(
+                model=model_name,
+                api_key=api_keys["openai"],
+                temperature=0.1,
+                model_kwargs={"response_format": {"type": "json_object"}},
+            )
+            self.json_llm = self.base_llm
+
+        elif provider == "local_server":
+            base_url = api_keys.get("local_url", "http://localhost:1234/v1")
+            self.base_llm = ChatOpenAI(
+                model=model_name,
+                api_key="not-needed",
+                base_url=base_url,
+                temperature=0.1,
+                model_kwargs={"response_format": {"type": "json_object"}},
+            )
+            self.json_llm = self.base_llm
+
+        elif provider == "anthropic":
+            if not api_keys.get("anthropic"):
+                raise ValueError("Anthropic API Key required.")
+            self.base_llm = ChatAnthropic(
+                model=model_name,
+                api_key=api_keys["anthropic"],
+                temperature=0.1,
+            )
+            # Anthropic doesn't support response_format; JSON is enforced via prompt only
+            self.json_llm = self.base_llm
+
+        elif provider == "google":
+            if not api_keys.get("google"):
+                raise ValueError("Google Gemini API Key required.")
+            self.base_llm = ChatGoogleGenerativeAI(
+                model=model_name,
+                google_api_key=api_keys["google"],
+                temperature=0.1,
+                convert_system_message_to_human=True,
+            )
+            self.json_llm = self.base_llm
+
+        else:  # Ollama default
+            self.base_llm = ChatOllama(
+                model=model_name,
+                temperature=0.1,
+                num_predict=4096,
+                num_ctx=8192,
+            )
+            self.json_llm = self.base_llm.bind(format="json")
+
+        self.prompt = PromptTemplate(
+            template=ANALYSIS_TEMPLATE + "\n\n{format_instructions}",
+            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"):
+        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 the analysis again or use a larger parameter model.",
+                "bottlenecks": [],
+                "optimized_code": None,
+            }
+        except Exception as e:
+            return {
+                "severity": "Error",
+                "issue": str(e),
+                "reasoning": "System error during analysis pipeline.",
+                "suggestion": "Check LLM API keys and connectivity.",
+                "bottlenecks": [],
+                "optimized_code": None,
+            }
+
+    def _extract_executable_code(self, response_text: str) -> str:
+        """Extract the first/longest fenced code block from model output."""
+        blocks = re.findall(r"```[a-zA-Z+#]*\s*\n(.*?)```", response_text, re.DOTALL)
+        if blocks:
+            return max(blocks, key=len).strip()
+
+        # Fallback: strip fence markers line by line to avoid corrupting code
+        lines = response_text.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_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)
+        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
+            )
+        return self._extract_executable_code(raw)
+
+    def generate_harness(
+        self,
+        func_name: str,
+        original_code: str,
+        optimized_code: str,
+        language: str,
+        context: str = "",
+        hardware_target: str = "Generic CPU",
+    ) -> str:
+        try:
+            return self._invoke_code_chain(
+                _HARNESS_TEMPLATE,
+                {
+                    "language": language,
+                    "func_name": func_name,
+                    "original": original_code,
+                    "optimized": optimized_code,
+                    "context": context,
+                    "hardware_target": hardware_target,
+                },
+                language,
+            )
+        except Exception as e:
+            is_python = language.lower() == "python"
+            opener = "#" if is_python else "//"
+            entry = 'if __name__ == "__main__":' if is_python else "int main() {"
+            stub = "    pass" if is_python else "    return 1;\n}"
+            return f"{opener} Failed to generate harness: {e}\n{entry}\n{stub}"
+
+    def fix_harness(
+        self,
+        func_name: str,
+        original_code: str,
+        bad_harness: str,
+        error_logs: str,
+        language: str,
+        context: str = "",
+    ) -> str:
+        try:
+            return self._invoke_code_chain(
+                _FIX_TEMPLATE,
+                {
+                    "language": language,
+                    "func_name": func_name,
+                    "original": original_code,
+                    "bad_harness": bad_harness,
+                    "error_logs": error_logs,
+                    "context": context,
+                },
+                language,
+            )
+        except Exception as e:
+            is_python = language.lower() == "python"
+            opener = "#" if is_python else "//"
+            return f"{opener} Failed to fix harness: {e}"
+        
+    def generate_test_cases(
+        self,
+        func_name: str,
+        original_code: str,
+        language: str,
+        context: str = "",
+        num_cases: int = 8,
+    ) -> list:
+        """
+        Ask the LLM to generate diverse, JSON-serialisable test cases for
+        `func_name` so the sandbox can run correctness verification.
+
+        Returns a list of {"args": [...], "kwargs": {...}} dicts, or an
+        empty list if generation or parsing fails (sandbox skips gracefully).
+        """
+        import 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
+                )
+
+            # Strip markdown fences if the model wrapped anyway
+            raw = re.sub(r"```[a-zA-Z]*\s*", "", raw).strip()
+
+            cases = json.loads(raw)
+
+            # Validate structure — drop malformed entries silently
+            return [
+                case for case in cases
+                if isinstance(case, dict)
+                and isinstance(case.get("args"), list)
+                and isinstance(case.get("kwargs"), dict)
+            ]
+
+        except Exception as e:
+            logger.warning(f"generate_test_cases failed for '{func_name}': {e}")
+            return []

coreinsight/config.py

@@ -0,0 +1,51 @@
+import json
+from pathlib import Path
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+
+console = Console()
+CONFIG_FILE = Path.home() / ".coreinsight" / "config.json"
+
+def load_config():
+    if not CONFIG_FILE.exists():
+        return {"provider": "ollama", "model_name": "llama3.2", "api_keys": {}}
+    with open(CONFIG_FILE, "r") as f:
+        return json.load(f)
+
+def save_config(config_data):
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config_data, f, indent=4)
+
+def run_configure():
+    """Interactive CLI to set up models and API keys."""
+    console.print("[bold cyan]⚙️ CoreInsight Configuration[/bold cyan]")
+    
+    config = load_config()
+    
+    provider = Prompt.ask(
+        "Which AI provider do you want to use?", 
+        choices=["ollama", "local_server", "openai", "anthropic", "google"], 
+        default=config.get("provider", "ollama")
+    )
+    
+    config["provider"] = provider
+    
+    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")
+    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)
+    elif provider == "anthropic":
+        config["model_name"] = Prompt.ask("Claude model name", default="claude-3-5-sonnet-latest")
+        config["api_keys"]["anthropic"] = Prompt.ask("Anthropic API Key (hidden)", password=True)
+    elif provider == "google":
+        config["model_name"] = Prompt.ask("Gemini model name", default="gemini-1.5-pro")
+        config["api_keys"]["google"] = Prompt.ask("Google Gemini API Key (hidden)", password=True)
+
+    save_config(config)
+    console.print("\n[bold green]✅ Configuration saved successfully![/bold green]")
+    console.print(f"CoreInsight is now using [bold]{provider}[/bold] ({config['model_name']}).")

coreinsight/hardware.py

@@ -0,0 +1,45 @@
+import platform
+import psutil
+import subprocess
+
+class HardwareDetector:
+    @staticmethod
+    def get_system_specs() -> dict:
+        """Dynamically detects the host system's CPU, RAM, and GPU."""
+        specs = {
+            "os": platform.system(),
+            "cpu_cores": psutil.cpu_count(logical=False),
+            "cpu_threads": psutil.cpu_count(logical=True),
+            "ram_gb": round(psutil.virtual_memory().total / (1024**3), 2),
+            "gpu": "None detected",
+            "vram_gb": 0.0
+        }
+        
+        # Attempt to detect NVIDIA GPU and VRAM
+        try:
+            smi_output = subprocess.check_output(
+                ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
+                encoding="utf-8",
+                stderr=subprocess.DEVNULL
+            ).strip()
+            
+            if smi_output:
+                # E.g., "NVIDIA GeForce RTX 4090, 24564 MiB"
+                parts = smi_output.split(',')
+                specs["gpu"] = parts[0].strip()
+                specs["vram_gb"] = round(int(parts[1].replace('MiB', '').strip()) / 1024, 2)
+        except Exception:
+            pass # No NVIDIA GPU found or drivers not installed
+
+        return specs
+
+    @staticmethod
+    def format_for_llm(specs: dict) -> str:
+        """Formats the dictionary into a readable block for the LLM prompt."""
+        return (
+            f"OS: {specs['os']} | "
+            f"CPU: {specs['cpu_cores']} Cores ({specs['cpu_threads']} Threads) | "
+            f"System RAM: {specs['ram_gb']} GB | "
+            f"GPU: {specs['gpu']} | "
+            f"GPU VRAM: {specs['vram_gb']} GB"
+        )

coreinsight/indexer.py

@@ -0,0 +1,97 @@
+import os
+from pathlib import Path
+from rich.console import Console
+from rich.progress import track
+import chromadb
+from chromadb.utils import embedding_functions
+
+from coreinsight.parser import CodeParser
+
+console = Console()
+
+class RepoIndexer:
+    def __init__(self, repo_path: str):
+        self.repo_path = Path(repo_path)
+        self.db_path = self.repo_path / ".coreinsight_db"
+        self.parser = CodeParser()
+        
+        # Initialize local ChromaDB
+        self.chroma_client = chromadb.PersistentClient(path=str(self.db_path))
+        
+        # Use a lightweight, fast local embedding model
+        self.embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
+            model_name="all-MiniLM-L6-v2"
+        )
+        
+        self.collection = self.chroma_client.get_or_create_collection(
+            name="codebase_context",
+            embedding_function=self.embedding_fn
+        )
+
+    def index_repository(self):
+        """Scans the repo and embeds all code blocks into the vector DB."""
+        valid_extensions = {".py", ".cpp", ".cc", ".h", ".hpp", ".cu", ".cuh"}
+        files_to_index = []
+        
+        for root, _, files in os.walk(self.repo_path):
+            if ".coreinsight_db" in root or ".git" in root or "venv" in root:
+                continue
+            for file in files:
+                path = Path(root) / file
+                if path.suffix in valid_extensions:
+                    files_to_index.append(path)
+                    
+        if not files_to_index:
+            console.print("[yellow]No source files found to index.[/yellow]")
+            return
+
+        console.print(f"[cyan]Found {len(files_to_index)} files. Building vector index...[/cyan]")
+        
+        documents = []
+        metadatas = []
+        ids = []
+        
+        for filepath in track(files_to_index, description="Parsing and Embedding..."):
+            try:
+                content = filepath.read_bytes()
+                # Use your existing AST parser to chunk the file!
+                functions = self.parser.parse_file(str(filepath), content)
+                
+                for idx, func in enumerate(functions):
+                    documents.append(func['code'])
+                    metadatas.append({
+                        "file": str(filepath.relative_to(self.repo_path)),
+                        "name": func['name'],
+                        "language": func['language']
+                    })
+                    ids.append(f"{filepath.name}_{func['name']}_{idx}")
+            except Exception as e:
+                console.print(f"[dim red]Skipped {filepath.name}: {e}[/dim red]")
+
+        if documents:
+            # Batch add to ChromaDB
+            self.collection.add(
+                documents=documents,
+                metadatas=metadatas,
+                ids=ids
+            )
+            console.print(f"[bold green]✅ Successfully indexed {len(documents)} code chunks into local Vector DB![/bold green]")
+
+    def get_context_for_code(self, code_snippet: str, n_results: int = 3) -> str:
+        """Retrieves related code (like structs/classes) to feed to the LLM."""
+        if self.collection.count() == 0:
+            return ""
+            
+        results = self.collection.query(
+            query_texts=[code_snippet],
+            n_results=n_results
+        )
+        
+        if not results['documents'] or not results['documents'][0]:
+            return ""
+            
+        context_blocks = []
+        for doc, meta in zip(results['documents'][0], results['metadatas'][0]):
+            context_blocks.append(f"// From {meta['file']} ({meta['name']}):\n{doc}")
+            
+        return "\n\n".join(context_blocks)