coreinsight-cli 0.1.0__tar.gz

coreinsight_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Varun Jani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

coreinsight_cli-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: coreinsight-cli
+Version: 0.1.0
+Summary: Local-first AI performance profiler that mathematically verifies optimizations for Python, C++, and CUDA
+Author: Varun Jani
+License: MIT
+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: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0
+Requires-Dist: docker>=6.0
+Requires-Dist: tree-sitter==0.21.3
+Requires-Dist: tree-sitter-languages
+Requires-Dist: langchain>=0.2.0
+Requires-Dist: langchain-core>=0.2.0
+Requires-Dist: langchain-ollama>=0.1.0
+Requires-Dist: langchain-google-genai>=1.0.0
+Requires-Dist: langchain-openai>=0.1.0
+Requires-Dist: langchain-anthropic>=0.1.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: chromadb>=0.5.0
+Requires-Dist: sentence-transformers>=3.0.0
+Requires-Dist: psutil>=5.9
+Dynamic: license-file
+
+# CoreInsight CLI
+
+CoreInsight is a local-first, hardware-aware AI performance profiler. It shifts performance engineering "left" by parsing your Python, C++, and CUDA code, identifying hardware bottlenecks (like CPU cache thrashing or CUDA warp divergence), and mathematically verifying AI-generated optimizations inside secure Docker sandboxes.
+
+## Prerequisites
+
+* **Python 3.9+**
+* **Docker Desktop / Docker Engine** (Must be running for the sandbox verification)
+* **Ollama** (Optional, if using local models) or API keys for cloud models.
+
+## Installation & Usage
+
+**Required: Install Docker: https://docs.docker.com/engine/install/** 
+
+**Optional (Suggested): Setup OpenAI/Anthropic/Google API keys to load their models**
+
+**1. Build locally:**
+Clone this repository and install it in editable mode:
+```bash
+pip install -e .
+```
+
+**2. Configure CoreInsight CLI:**
+Set up your preferred AI provider (Ollama, local vLLM, OpenAI, Anthropic, or Gemini):
+```bash
+coreinsight configure
+```
+
+**3. Build Global Context (Recommended for multiple files):**
+Index your repository so the AI understands your custom structs, classes, and dependencies across files:
+```bash
+coreinsight index
+```
+
+**4. Test on a file:**
+Analyze a specific file. The CLI will extract hot loops, process them in parallel, verify optimizations in Docker, and output a live Markdown report.
+```bash
+coreinsight analyze <file_name>
+```
+
+**5. Project-Wide Hotspot Scanning:**
+Instead of guessing which files are slow, scan your entire repository. CoreInsight will use static AST analysis to rank the most complex, deeply-nested loops in your project.
+```bash
+coreinsight scan
+```
+
+## Build the Project
+
+Download build:
+```bash
+pip install build
+```
+
+Run the build command to generate wheel file:
+```bash
+python -m build --wheel
+```
+
+To build project elsewhere using wheel file:
+```bash
+pip install dist/coreinsight_cli-*.whl
+```
+
+To build project using source code:
+```bash
+pip install -e .
+```
+
+### Architecture Notes
+CoreInsight runs 100% locally. Code is only transmitted to the AI provider you configure. If you use Ollama or a local server, your proprietary code never leaves your machine.
+
+## Current/Future Features In Progess:
+
+- Improve AST parsing
+- Extract and integrate hardware information for the LLM
+- Improve CLI interface
+- Parallel execution
+- Improve RAG

coreinsight_cli-0.1.0/README.md

@@ -0,0 +1,78 @@
+# CoreInsight CLI
+
+CoreInsight is a local-first, hardware-aware AI performance profiler. It shifts performance engineering "left" by parsing your Python, C++, and CUDA code, identifying hardware bottlenecks (like CPU cache thrashing or CUDA warp divergence), and mathematically verifying AI-generated optimizations inside secure Docker sandboxes.
+
+## Prerequisites
+
+* **Python 3.9+**
+* **Docker Desktop / Docker Engine** (Must be running for the sandbox verification)
+* **Ollama** (Optional, if using local models) or API keys for cloud models.
+
+## Installation & Usage
+
+**Required: Install Docker: https://docs.docker.com/engine/install/** 
+
+**Optional (Suggested): Setup OpenAI/Anthropic/Google API keys to load their models**
+
+**1. Build locally:**
+Clone this repository and install it in editable mode:
+```bash
+pip install -e .
+```
+
+**2. Configure CoreInsight CLI:**
+Set up your preferred AI provider (Ollama, local vLLM, OpenAI, Anthropic, or Gemini):
+```bash
+coreinsight configure
+```
+
+**3. Build Global Context (Recommended for multiple files):**
+Index your repository so the AI understands your custom structs, classes, and dependencies across files:
+```bash
+coreinsight index
+```
+
+**4. Test on a file:**
+Analyze a specific file. The CLI will extract hot loops, process them in parallel, verify optimizations in Docker, and output a live Markdown report.
+```bash
+coreinsight analyze <file_name>
+```
+
+**5. Project-Wide Hotspot Scanning:**
+Instead of guessing which files are slow, scan your entire repository. CoreInsight will use static AST analysis to rank the most complex, deeply-nested loops in your project.
+```bash
+coreinsight scan
+```
+
+## Build the Project
+
+Download build:
+```bash
+pip install build
+```
+
+Run the build command to generate wheel file:
+```bash
+python -m build --wheel
+```
+
+To build project elsewhere using wheel file:
+```bash
+pip install dist/coreinsight_cli-*.whl
+```
+
+To build project using source code:
+```bash
+pip install -e .
+```
+
+### Architecture Notes
+CoreInsight runs 100% locally. Code is only transmitted to the AI provider you configure. If you use Ollama or a local server, your proprietary code never leaves your machine.
+
+## Current/Future Features In Progess:
+
+- Improve AST parsing
+- Extract and integrate hardware information for the LLM
+- Improve CLI interface
+- Parallel execution
+- Improve RAG

coreinsight_cli-0.1.0/coreinsight/Dockerfile.cpp-sandbox

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

coreinsight_cli-0.1.0/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_cli-0.1.0/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_cli-0.1.0/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']}).")