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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreinsight-cli
-Version: 0.2.7
+Version: 0.2.8
 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.8}/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:
@@ -738,7 +829,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.7 → coreinsight_cli-0.2.8}/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."""
@@ -803,12 +810,23 @@ def run_demo(lang: str = "python", no_docker: bool = False):
 
     run_analysis(str(demo_dir / entry_file), no_docker=no_docker)
 
-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 +948,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 +977,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)

{coreinsight_cli-0.2.7 → coreinsight_cli-0.2.8}/coreinsight/memory.py

@@ -186,6 +186,77 @@ class OptimizationMemory:
             logger.debug(f"Memory lookup failed: {exc}")
             return None
 
+    def export(self, output_path: str, fmt: str = "csv") -> int:
+        """
+        Export all stored optimizations to CSV or Markdown.
+        Returns the number of records written, or 0 on failure.
+        """
+        import csv as _csv
+        from pathlib import Path as _Path
+
+        if not self._ensure_db():
+            return 0
+
+        try:
+            all_records = self._collection.get(include=["metadatas"])
+            metadatas   = all_records.get("metadatas", []) or []
+        except Exception as e:
+            logger.error(f"Export failed reading store: {e}")
+            return 0
+
+        if not metadatas:
+            return 0
+
+        # Sort most recent first
+        metadatas = sorted(
+            metadatas,
+            key=lambda m: m.get("timestamp", ""),
+            reverse=True,
+        )
+
+        out = _Path(output_path)
+
+        if fmt == "csv":
+            with open(out, "w", newline="", encoding="utf-8") as f:
+                writer = _csv.writer(f)
+                writer.writerow([
+                    "func_name", "language", "severity", "issue",
+                    "avg_speedup", "correctness_cases",
+                    "hardware_evidence", "verified_at", "optimized_code",
+                ])
+                for m in metadatas:
+                    writer.writerow([
+                        m.get("func_name",        ""),
+                        m.get("language",         ""),
+                        m.get("severity",         ""),
+                        m.get("issue",            ""),
+                        m.get("avg_speedup",      ""),
+                        m.get("correctness_cases",""),
+                        m.get("profiler_summary", ""),
+                        m.get("timestamp",        "")[:19].replace("T", " "),
+                        m.get("optimized_code",   ""),
+                    ])
+
+        elif fmt == "md":
+            with open(out, "w", encoding="utf-8") as f:
+                f.write("# CoreInsight Optimization Memory Export\n\n")
+                for i, m in enumerate(metadatas, 1):
+                    lang = m.get("language", "")
+                    f.write(f"## {i}. `{m.get('func_name', 'unknown')}` ({lang})\n\n")
+                    f.write(f"- **Severity:** {m.get('severity', '')}\n")
+                    f.write(f"- **Issue:** {m.get('issue', '')}\n")
+                    f.write(f"- **Avg speedup:** {float(m.get('avg_speedup', 0)):.2f}x\n")
+                    f.write(f"- **Correctness cases:** {m.get('correctness_cases', '')}\n")
+                    f.write(f"- **Verified at:** {m.get('timestamp', '')[:19].replace('T', ' ')}\n")
+                    if m.get("profiler_summary"):
+                        f.write(f"- **Hardware evidence:** {m.get('profiler_summary')}\n")
+                    code = m.get("optimized_code", "").strip()
+                    if code:
+                        f.write(f"\n```{lang}\n{code}\n```\n")
+                    f.write("\n---\n\n")
+
+        return len(metadatas)
+
     def store(
         self,
         original_code:  str,

{coreinsight_cli-0.2.7 → coreinsight_cli-0.2.8}/coreinsight/tui.py

@@ -22,8 +22,10 @@ from textual.widgets import (
     DirectoryTree,
     Footer,
     Header,
+    Input,
     Label,
     RichLog,
+    Select,
     Static,
     Switch,
 )
@@ -107,9 +109,17 @@ class MemoryModal(ModalScreen):
     MemoryModal #memory-log {
         height: 1fr;
     }
-    MemoryModal #close-memory {
+    MemoryModal #memory-buttons {
         margin-top: 1;
-        width: 100%;
+        align: center middle;
+    }
+    MemoryModal #memory-buttons Button {
+        margin: 0 1;
+    }
+    MemoryModal #export-status {
+        height: 1;
+        margin-top: 1;
+        color: $success;
     }
     """
 
@@ -117,7 +127,11 @@ class MemoryModal(ModalScreen):
         with Container():
             yield Label("Optimization Memory", id="memory-title")
             yield RichLog(id="memory-log", highlight=True, markup=True)
-            yield Button("Close  [Esc]", id="close-memory", variant="default")
+            with Horizontal(id="memory-buttons"):
+                yield Button("Export CSV", id="export-csv", variant="primary")
+                yield Button("Export MD",  id="export-md",  variant="primary")
+                yield Button("Close [Esc]",id="close-memory",variant="default")
+            yield Label("", id="export-status")
 
     def on_mount(self) -> None:
         log = self.query_one("#memory-log", RichLog)
@@ -194,6 +208,27 @@ class MemoryModal(ModalScreen):
     @on(Button.Pressed, "#close-memory")
     def close(self) -> None:
         self.dismiss()
+        
+    @on(Button.Pressed, "#export-csv")
+    def export_csv(self) -> None:
+        self._do_export("csv")
+
+    @on(Button.Pressed, "#export-md")
+    def export_md(self) -> None:
+        self._do_export("md")
+
+    def _do_export(self, fmt: str) -> None:
+        from pathlib import Path
+        from coreinsight.memory import OptimizationMemory
+
+        out  = Path.cwd() / f"coreinsight_memory_export.{fmt}"
+        mem  = OptimizationMemory()
+        count = mem.export(str(out), fmt=fmt)
+        status = self.query_one("#export-status", Label)
+        if count:
+            status.update(f"[green]Exported {count} record(s) to {out.name}[/green]")
+        else:
+            status.update("[yellow]Nothing to export.[/yellow]")
 
 
 # ---------------------------------------------------------------------------
@@ -253,65 +288,219 @@ class ConfirmModal(ModalScreen[bool]):
 # Settings modal
 # ---------------------------------------------------------------------------
 
-class SettingsModal(ModalScreen):
-    """Read-only settings viewer. Directs user to coreinsight configure for changes."""
+class ConfigureModal(ModalScreen):
+    """Full configure screen — replaces coreinsight configure for TUI users."""
 
-    BINDINGS = [Binding("escape,q", "dismiss", "Close")]
+    BINDINGS = [Binding("escape", "dismiss", "Cancel")]
 
     DEFAULT_CSS = """
-    SettingsModal {
+    ConfigureModal {
         align: center middle;
     }
-    SettingsModal > Container {
-        width: 60;
-        height: 22;
+    ConfigureModal > Container {
+        width: 70;
+        height: 36;
         background: $surface;
         border: thick $primary;
         padding: 1 2;
     }
-    SettingsModal .setting-row {
-        height: 1;
+    ConfigureModal .field-label {
+        color: $text-muted;
+        margin-top: 1;
+    }
+    ConfigureModal Input {
+        margin-bottom: 1;
+    }
+    ConfigureModal Select {
         margin-bottom: 1;
     }
-    SettingsModal #close-settings {
+    ConfigureModal #configure-buttons {
+        margin-top: 1;
+        align: center middle;
+    }
+    ConfigureModal Button {
+        margin: 0 1;
+        min-width: 16;
+    }
+    ConfigureModal #configure-status {
+        height: 1;
+        color: $success;
         margin-top: 1;
-        width: 100%;
     }
     """
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._config = load_config()
+
     def compose(self) -> ComposeResult:
-        config    = load_config()
-        pro_user  = is_pro(config)
-        provider  = config.get("provider",   "ollama")
-        model     = config.get("model_name", "llama3.2")
-        tier      = "Pro" if pro_user else "Free"
-        tier_col  = "bold green" if pro_user else "bold yellow"
+        config     = self._config
+        provider   = config.get("provider",   "ollama")
+        model      = config.get("model_name", "llama3.2")
         agent_mode = config.get("agent_mode", "auto")
+        local_url  = config.get("api_keys", {}).get("local_url", "http://localhost:1234/v1")
+        api_keys   = config.get("api_keys", {})
 
         with Container():
-            yield Label("Current Configuration", id="settings-title")
-            yield Static(f"  Tier      : [{tier_col}]{tier}[/{tier_col}]", classes="setting-row")
-            yield Static(f"  Provider  : [cyan]{provider}[/cyan]",          classes="setting-row")
-            yield Static(f"  Model     : [cyan]{model}[/cyan]",              classes="setting-row")
-            yield Static(f"  Agent mode: [cyan]{agent_mode}[/cyan]",         classes="setting-row")
-            yield Static("", classes="setting-row")
-            yield Static(
-                "  To change settings, run:\n"
-                "  [cyan]coreinsight configure[/cyan]",
-                classes="setting-row",
+            yield Label("Configure CoreInsight", id="configure-title")
+
+            yield Label("Provider", classes="field-label")
+            yield Select(
+                [
+                    ("Ollama (local, free)",        "ollama"),
+                    ("Local Server (LM Studio etc)","local_server"),
+                    ("OpenAI",                      "openai"),
+                    ("Anthropic",                   "anthropic"),
+                    ("Google Gemini",               "google"),
+                ],
+                value=provider,
+                id="provider-select",
             )
-            if not pro_user:
-                yield Static(
-                    f"\n  [yellow]Unlock Pro (free during beta):[/yellow]\n"
-                    f"  [cyan underline]{PRO_WAITLIST_URL}[/cyan underline]",
-                    classes="setting-row",
-                )
-            yield Button("Close  [Esc]", id="close-settings", variant="default")
 
-    @on(Button.Pressed, "#close-settings")
-    def close(self) -> None:
-        self.dismiss()
+            yield Label("Model name", classes="field-label")
+            yield Input(value=model, placeholder="e.g. llama3.2, gpt-4o, claude-opus-4-5", id="model-input")
+
+            yield Label("Agent mode", classes="field-label")
+            yield Select(
+                [
+                    ("Auto (recommended)", "auto"),
+                    ("Single agent",       "single"),
+                    ("Multi agent",        "multi"),
+                ],
+                value=agent_mode,
+                id="agent-mode-select",
+            )
+
+            # Local server URL — shown only for local_server
+            yield Label("Local server URL", classes="field-label", id="local-url-label")
+            yield Input(
+                value=local_url,
+                placeholder="http://localhost:1234/v1",
+                id="local-url-input",
+            )
 
+            # API key fields — shown per provider
+            yield Label("OpenAI API key", classes="field-label", id="openai-label")
+            yield Input(
+                value=api_keys.get("openai", ""),
+                placeholder="sk-...",
+                password=True,
+                id="openai-input",
+            )
+
+            yield Label("Anthropic API key", classes="field-label", id="anthropic-label")
+            yield Input(
+                value=api_keys.get("anthropic", ""),
+                placeholder="sk-ant-...",
+                password=True,
+                id="anthropic-input",
+            )
+
+            yield Label("Google API key", classes="field-label", id="google-label")
+            yield Input(
+                value=api_keys.get("google", ""),
+                placeholder="AIza...",
+                password=True,
+                id="google-input",
+            )
+
+            yield Label("Pro key", classes="field-label")
+            yield Input(
+                value=config.get("pro_key", ""),
+                placeholder="Your CoreInsight Pro key",
+                password=True,
+                id="pro-key-input",
+            )
+
+            with Horizontal(id="configure-buttons"):
+                yield Button("Save",   id="configure-save",   variant="success")
+                yield Button("Cancel", id="configure-cancel", variant="default")
+
+            yield Label("", id="configure-status")
+
+    def on_mount(self) -> None:
+        self._refresh_visibility(self._config.get("provider", "ollama"))
+
+    @on(Select.Changed, "#provider-select")
+    def provider_changed(self, event: Select.Changed) -> None:
+        self._refresh_visibility(str(event.value))
+
+    def _refresh_visibility(self, provider: str) -> None:
+        """Show only the fields relevant to the selected provider."""
+        local_ids    = ["local-url-label",   "local-url-input"]
+        openai_ids   = ["openai-label",       "openai-input"]
+        anthropic_ids= ["anthropic-label",    "anthropic-input"]
+        google_ids   = ["google-label",       "google-input"]
+
+        all_conditional = local_ids + openai_ids + anthropic_ids + google_ids
+
+        # Hide everything first
+        for wid in all_conditional:
+            try:
+                self.query_one(f"#{wid}").display = False
+            except Exception:
+                pass
+
+        # Show relevant ones
+        show = {
+            "local_server": local_ids,
+            "openai":       openai_ids,
+            "anthropic":    anthropic_ids,
+            "google":       google_ids,
+        }.get(provider, [])
+
+        for wid in show:
+            try:
+                self.query_one(f"#{wid}").display = True
+            except Exception:
+                pass
+
+    @on(Button.Pressed, "#configure-save")
+    def save(self) -> None:
+        import json
+        from pathlib import Path
+
+        provider   = str(self.query_one("#provider-select",   Select).value)
+        model      = self.query_one("#model-input",            Input).value.strip()
+        agent_mode = str(self.query_one("#agent-mode-select",  Select).value)
+        pro_key    = self.query_one("#pro-key-input",          Input).value.strip()
+
+        if not model:
+            self.query_one("#configure-status", Label).update(
+                "[red]Model name cannot be empty.[/red]"
+            )
+            return
+
+        # Build updated config
+        config = dict(self._config)
+        config["provider"]   = provider
+        config["model_name"] = model
+        config["agent_mode"] = agent_mode
+
+        api_keys = dict(config.get("api_keys", {}))
+        api_keys["local_url"]  = self.query_one("#local-url-input",  Input).value.strip()
+        api_keys["openai"]     = self.query_one("#openai-input",     Input).value.strip()
+        api_keys["anthropic"]  = self.query_one("#anthropic-input",  Input).value.strip()
+        api_keys["google"]     = self.query_one("#google-input",     Input).value.strip()
+        config["api_keys"] = api_keys
+
+        if pro_key:
+            config["pro_key"] = pro_key
+
+        config_dir  = Path.home() / ".coreinsight"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        config_path = config_dir / "config.json"
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+
+        self.query_one("#configure-status", Label).update(
+            "[green]Saved. Restart coreinsight view to apply changes.[/green]"
+        )
+        self._config = config
+
+    @on(Button.Pressed, "#configure-cancel")
+    def cancel(self) -> None:
+        self.dismiss()
 
 # ---------------------------------------------------------------------------
 # Main TUI App
@@ -323,12 +512,13 @@ class CoreInsightApp(App):
     CSS_PATH = None   # all CSS inline below
 
     BINDINGS = [
-        Binding("q",     "quit",           "Quit"),
-        Binding("a",     "analyze",        "Analyze"),
-        Binding("i",     "index",          "Index"),
-        Binding("m",     "view_memory",    "Memory"),
-        Binding("s",     "view_settings",  "Settings"),
-        Binding("ctrl+c","quit",           "Quit", show=False),
+        Binding("q",      "quit",           "Quit"),
+        Binding("a",      "analyze",        "Analyze"),
+        Binding("i",      "index",          "Index"),
+        Binding("m",      "view_memory",    "Memory"),
+        Binding("c",      "configure",      "Configure"),
+        Binding("d",      "demo",           "Demo"),
+        Binding("ctrl+c", "quit",           "Quit", show=False),
     ]
 
     CSS = """
@@ -456,10 +646,11 @@ class CoreInsightApp(App):
 
                 with Vertical(id="action-panel"):
                     yield Label("Actions", id="action-label")
-                    yield Button("Analyze [a]",      id="btn-analyze",  variant="success")
-                    yield Button("Index   [i]",      id="btn-index",    variant="primary")
-                    yield Button("Memory  [m]",      id="btn-memory",   variant="default")
-                    yield Button("Settings [s]",     id="btn-settings", variant="default")
+                    yield Button("Analyze   [a]",   id="btn-analyze",   variant="success")
+                    yield Button("Index     [i]",   id="btn-index",     variant="primary")
+                    yield Button("Demo      [d]",   id="btn-demo",      variant="primary")
+                    yield Button("Memory    [m]",   id="btn-memory",    variant="default")
+                    yield Button("Configure [c]",   id="btn-configure", variant="default")
                     with Horizontal(id="no-docker-row"):
                         yield Switch(value=False, id="no-docker-switch")
                         yield Label("Skip Docker", id="no-docker-label")
@@ -562,9 +753,46 @@ class CoreInsightApp(App):
     def action_view_memory(self) -> None:
         self.push_screen(MemoryModal())
 
-    @on(Button.Pressed, "#btn-settings")
-    def action_view_settings(self) -> None:
-        self.push_screen(SettingsModal())
+    @on(Button.Pressed, "#btn-configure")
+    def action_configure(self) -> None:
+        self.push_screen(ConfigureModal())
+        
+    @on(Button.Pressed, "#btn-demo")
+    def action_demo(self) -> None:
+        if self._busy:
+            self._set_status("Already running — please wait.")
+            return
+        no_docker = self.query_one("#no-docker-switch", Switch).value
+        self._start_demo(no_docker)
+
+    @work(thread=True)
+    def _start_demo(self, no_docker: bool) -> None:
+        from coreinsight.main import run_demo
+
+        log = self.query_one("#output-log", RichLog)
+        tui_console = TuiConsole(log)
+        self._busy = True
+
+        self.call_from_thread(self._set_status, "Running demo...")
+        self.call_from_thread(
+            log.write,
+            "\n[bold cyan]Running built-in Python demo...[/bold cyan]\n"
+        )
+
+        # Temporarily patch the demo's console output into the TUI
+        import coreinsight.main as _main
+        _prev = _main.console
+        _main.console = tui_console
+        try:
+            run_demo(lang="python", no_docker=no_docker)
+        except SystemExit:
+            pass
+        except Exception as exc:
+            self.call_from_thread(log.write, f"[red]Demo error: {exc}[/red]")
+        finally:
+            _main.console = _prev
+            self._busy = False
+            self.call_from_thread(self._set_status, "Demo complete.")
 
     # ── Workers ───────────────────────────────────────────────────────────
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreinsight-cli
-Version: 0.2.7
+Version: 0.2.8
 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.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "coreinsight-cli"
-version = "0.2.7"
+version = "0.2.8"
 description = "Local-first AI performance profiler that mathematically verifies optimizations for Python, C++, and CUDA"
 license = {text = "GPL-3.0-or-later"}
 authors = [