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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreinsight-cli
-Version: 0.2.6
+Version: 0.2.7
 Summary: Local-first AI performance profiler that mathematically verifies optimizations for Python, C++, and CUDA
 Author: Varun Jani
 License: GPL-3.0-or-later
@@ -32,6 +32,7 @@ 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: textual>=0.60.0
 Requires-Dist: psutil>=5.9
 Provides-Extra: compat
 Requires-Dist: pysqlite3-binary>=0.5.0; extra == "compat"

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

@@ -18,6 +18,7 @@ FREE_TIER_LIMITS = {
     "max_retries":       2,
     "num_test_cases":    8,
     "hardware_profiling": False,
+    "max_files": 2,
 }
 
 PRO_TIER_LIMITS = {
@@ -25,6 +26,7 @@ PRO_TIER_LIMITS = {
     "max_retries":       5,
     "num_test_cases":    15,
     "hardware_profiling": True,
+    "max_files": None,
 }
 
 SMALL_MODELS  = ["llama3.2:3b", "llama3.2:1b", "codellama:7b", "llama3:7b", "mistral:7b"]
@@ -168,6 +170,7 @@ def run_configure(pro_key: str = None, agent_mode: str = None):
     if provider == "ollama":
         config["model_name"] = Prompt.ask("Ollama model name", default=config.get("model_name", "llama3.2"))
     elif provider == "local_server":
+        from rich.panel import Panel
         console.print(Panel(
             "[bold]Local inference server setup[/bold]\n\n"
             "CoreInsight talks to any OpenAI-compatible local server.\n"

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

@@ -32,7 +32,7 @@ from rich.console import Group
 from coreinsight.config import load_config, run_configure, is_pro, get_tier_limits, PRO_WAITLIST_URL, get_model_tier, get_agent_mode
 from coreinsight.analyzer import AnalyzerAgent, BottleneckAgent, OptimizerAgent, HarnessAgent, TestCaseAgent
 from coreinsight.parser import CodeParser
-from coreinsight.sandbox import CodeSandbox
+from coreinsight.sandbox import CodeSandbox, SANDBOX_SKIPPED_MSG
 from coreinsight.profiler import HardwareProfiler
 from coreinsight.memory import OptimizationMemory
 from coreinsight.indexer import RepoIndexer
@@ -40,6 +40,7 @@ from coreinsight.hardware import HardwareDetector
 from coreinsight.scanner import ProjectScanner
 
 console = Console()
+_default_console = console  # kept for restore after TUI swaps it
 
 # Thread locks to prevent garbled output when multiple threads finish simultaneously
 print_lock = threading.Lock()
@@ -101,17 +102,20 @@ def _run_single_agent(
     while not is_valid and retry_count < max_retries:
         if getattr(sandbox, 'disabled', False):
             break
+        error_hint = ""
         if success:
             if "N,Original_Time" not in logs:
-                logs += "\nERROR: Script ran but DID NOT print the CSV table. You MUST print the strict CSV format."
+                error_hint = "\nERROR: Script ran but DID NOT print the CSV table. You MUST print the strict CSV format."
             else:
-                logs += "\nERROR: Optimized code was SLOWER. Rewrite to be faster."
-        harness_code            = agent.fix_harness(func_name, original_code, harness_code, logs, language, context=context)
+                error_hint = "\nERROR: Optimized code was SLOWER. Rewrite to be faster."
+        harness_code             = agent.fix_harness(func_name, original_code, harness_code, logs + error_hint, language, context=context)
         success, logs, plot_data = sandbox.execute_benchmark(harness_code, language)
         is_valid                 = _check_speedup_success(success, logs)
         retry_count             += 1
 
-    if is_valid and retry_count > 0:
+    if getattr(sandbox, 'disabled', False):
+        pass  # skipped intentionally — don't annotate as failed
+    elif is_valid and retry_count > 0:
         logs = f"(Succeeded after {retry_count} retries)\n" + logs
     elif not is_valid:
         logs    = f"(Failed after {retry_count} retries)\n" + logs
@@ -230,7 +234,8 @@ def process_function(func: dict, language: str, agent: AnalyzerAgent, sandbox: C
         # 3. Verification + AI-free hardware profiling
         verification    = None
         profiler_result = None
-        if is_valid_optimization:
+        docker_active = not getattr(sandbox, 'disabled', False)
+        if is_valid_optimization and docker_active:
             # Multi-agent: test cases already generated in parallel with harness
             # Single-agent: generate them now
             if agent_mode == "multi" and result.get("_test_cases") is not None:
@@ -313,6 +318,13 @@ def format_report_markdown(func_name: str, result: dict, sandbox_res: tuple, msg
 
     # ── Normal sandbox path ─────────────────────────────────────────────
     success, logs, plot_data = sandbox_res
+
+    if logs and SANDBOX_SKIPPED_MSG in logs:
+        md += f"### Verification: Skipped (--no-docker)\n"
+        md += f"> Sandbox and verification were disabled at runtime.\n\n"
+        md += "\n---\n"
+        return md
+
     sandbox_icon = "🟢" if success else "❌"
     md += f"### Verification: {sandbox_icon} {'Success' if success else 'Failed'}\n"
 
@@ -409,6 +421,15 @@ def print_console_report(func_name: str, result: dict, sandbox_res: tuple, msg:
     # ── Normal sandbox path ─────────────────────────────────────────────
     success, logs, plot_data = sandbox_res
 
+    # --no-docker path: render as skipped, not failed
+    if logs and SANDBOX_SKIPPED_MSG in logs:
+        content.append(Text.from_markup(
+            "[dim]Sandbox verification skipped (--no-docker). "
+            "The optimized code above has not been benchmarked or verified.[/dim]"
+        ))
+        console.print(Panel(Group(*content), title=f"Analysis: [bold]{func_name}[/bold]", border_style=color))
+        return
+
     csv_data = parse_csv_logs(logs)
     if csv_data:
         table = Table(show_header=True, header_style="bold magenta", expand=True)
@@ -541,168 +562,177 @@ def _preflight_checks(provider: str, model_name: str, no_docker: bool = False) -
 
     return True
 
-def run_analysis(file_path: str, no_docker: bool = False):
-    path = Path(file_path)
-    if not path.exists() or not path.is_file():
-        console.print(f"[red]Error: File '{file_path}' not found.[/red]")
-        sys.exit(1)
-
-    language = get_language_from_ext(path)
-    if language == "unknown":
-        console.print(f"[red]Error: Unsupported file type '{path.suffix}'. Use .cpp, .cu, or .py[/red]")
-        sys.exit(1)
-
-    config = load_config()
-    provider = config.get("provider", "ollama")
-    model_name = config.get("model_name", "llama3.2")
-    api_keys = config.get("api_keys", {})
-    tier_limits = get_tier_limits(config)
-    pro_user = is_pro(config)
-
-    # ── Preflight: fail fast before AST parsing, image building, or thread spawning ──
-    if not _preflight_checks(provider, model_name, no_docker=no_docker):
-        sys.exit(1)
-
-    tier_label = "[bold green]Pro[/bold green]" if pro_user else "[bold yellow]Free[/bold yellow]"
-    console.print(Panel.fit(f"🚀 CoreInsight: Profiling [bold cyan]{path.name}[/bold cyan] via [bold]{provider}[/bold] · {tier_label}"))
-
-    # 1. PARSE (Synchronous, since it's fast)
-    with console.status("[yellow]Parsing AST and extracting hot loops...[/yellow]"):
-        parser = CodeParser()
-        content_bytes = path.read_bytes()
-        file_content  = content_bytes.decode("utf-8", errors="replace")
-        functions = parser.parse_file(str(path), content_bytes)
+def run_analysis(file_path: str, no_docker: bool = False, tui_console=None):
+    global console
+    _prev_console = console
     
-    if not functions:
-        console.print("[red]No parseable functions found in the file.[/red]")
-        sys.exit(1)
+    if tui_console is not None:
+        console = tui_console
+    
+    try:
+        path = Path(file_path)
+        if not path.exists() or not path.is_file():
+            console.print(f"[red]Error: File '{file_path}' not found.[/red]")
+            sys.exit(1)
+
+        language = get_language_from_ext(path)
+        if language == "unknown":
+            console.print(f"[red]Error: Unsupported file type '{path.suffix}'. Use .cpp, .cu, or .py[/red]")
+            sys.exit(1)
+
+        config = load_config()
+        provider = config.get("provider", "ollama")
+        model_name = config.get("model_name", "llama3.2")
+        api_keys = config.get("api_keys", {})
+        tier_limits = get_tier_limits(config)
+        pro_user = is_pro(config)
+
+        # ── Preflight: fail fast before AST parsing, image building, or thread spawning ──
+        if not _preflight_checks(provider, model_name, no_docker=no_docker):
+            sys.exit(1)
+
+        tier_label = "[bold green]Pro[/bold green]" if pro_user else "[bold yellow]Free[/bold yellow]"
+        console.print(Panel.fit(f"🚀 CoreInsight: Profiling [bold cyan]{path.name}[/bold cyan] via [bold]{provider}[/bold] · {tier_label}"))
+
+        # 1. PARSE (Synchronous, since it's fast)
+        with console.status("[yellow]Parsing AST and extracting hot loops...[/yellow]"):
+            parser = CodeParser()
+            content_bytes = path.read_bytes()
+            file_content  = content_bytes.decode("utf-8", errors="replace")
+            functions = parser.parse_file(str(path), content_bytes)
+        
+        if not functions:
+            console.print("[red]No parseable functions found in the file.[/red]")
+            sys.exit(1)
+
+        max_fn = tier_limits["max_functions"]
+        if max_fn is not None and len(functions) > max_fn:
+            console.print(
+                f"[yellow]⚠ Free tier: analysing the first {max_fn} of {len(functions)} functions. "
+                f"Upgrade to Pro for unlimited → [cyan underline]{PRO_WAITLIST_URL}[/cyan underline][/yellow]"
+            )
+            functions = functions[:max_fn]
 
-    max_fn = tier_limits["max_functions"]
-    if max_fn is not None and len(functions) > max_fn:
-        console.print(
-            f"[yellow]⚠ Free tier: analysing the first {max_fn} of {len(functions)} functions. "
-            f"Upgrade to Pro for unlimited → [cyan underline]{PRO_WAITLIST_URL}[/cyan underline][/yellow]"
-        )
-        functions = functions[:max_fn]
+        console.print(f"[green]✅ Extracted {len(functions)} functional kernels.[/green]\n")
 
-    console.print(f"[green]✅ Extracted {len(functions)} functional kernels.[/green]\n")
+        # Initialize heavy lifters
+        try:
+            hardware_specs_dict = HardwareDetector.get_system_specs()
+            hardware_target_str = HardwareDetector.format_for_llm(hardware_specs_dict)
+            
+            console.print(f"[dim]🎯 Target Hardware Detected: {hardware_target_str}[/dim]")
+
+            model_tier = get_model_tier(provider, model_name)
+            agent      = AnalyzerAgent(provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier)
+            sandbox    = CodeSandbox(disabled=no_docker)
+            db_path    = path.parent / ".coreinsight_db"
+            indexer    = RepoIndexer(str(path.parent)) if db_path.exists() else None
+            profiler   = HardwareProfiler() if pro_user else None
+            memory     = OptimizationMemory()
+
+            # Multi-agent setup — create specialized agents if mode requires it
+            agent_mode  = get_agent_mode(config)
+            multi_agents = None
+            if agent_mode == "multi":
+                multi_agents = {
+                    "bottleneck": BottleneckAgent(provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier),
+                    "optimizer":  OptimizerAgent( provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier),
+                    "harness":    HarnessAgent(   provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier),
+                    "testcase":   TestCaseAgent(  provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier),
+                }
+        except Exception as e:
+            console.print(f"[red]Initialization Error:[/red] {e}")
+            sys.exit(1)
 
-    # Initialize heavy lifters
-    try:
-        hardware_specs_dict = HardwareDetector.get_system_specs()
-        hardware_target_str = HardwareDetector.format_for_llm(hardware_specs_dict)
-        
-        console.print(f"[dim]🎯 Target Hardware Detected: {hardware_target_str}[/dim]")
-
-        model_tier = get_model_tier(provider, model_name)
-        agent      = AnalyzerAgent(provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier)
-        sandbox    = CodeSandbox(disabled=no_docker)
-        db_path    = path.parent / ".coreinsight_db"
-        indexer    = RepoIndexer(str(path.parent)) if db_path.exists() else None
-        profiler   = HardwareProfiler() if pro_user else None
-        memory     = OptimizationMemory()
-
-        # Multi-agent setup — create specialized agents if mode requires it
-        agent_mode  = get_agent_mode(config)
-        multi_agents = None
-        if agent_mode == "multi":
-            multi_agents = {
-                "bottleneck": BottleneckAgent(provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier),
-                "optimizer":  OptimizerAgent( provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier),
-                "harness":    HarnessAgent(   provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier),
-                "testcase":   TestCaseAgent(  provider=provider, model_name=model_name, api_keys=api_keys, model_tier=model_tier),
-            }
-    except Exception as e:
-        console.print(f"[red]Initialization Error:[/red] {e}")
-        sys.exit(1)
+        mode_label = "[bold cyan]Multi-Agent[/bold cyan]" if agent_mode == "multi" else "[dim]Single-Agent[/dim]"
+        console.print(f"[dim]⚙️  Agent mode: {mode_label}[/dim]")
 
-    mode_label = "[bold cyan]Multi-Agent[/bold cyan]" if agent_mode == "multi" else "[dim]Single-Agent[/dim]"
-    console.print(f"[dim]⚙️  Agent mode: {mode_label}[/dim]")
+        mem_count = memory.stats().get("count", 0)
+        if mem_count > 0:
+            console.print(
+                f"[dim]⚡ Optimization memory: [bold cyan]{mem_count}[/bold cyan] "
+                f"verified optimization(s) in local store[/dim]"
+            )
 
-    mem_count = memory.stats().get("count", 0)
-    if mem_count > 0:
-        console.print(
-            f"[dim]⚡ Optimization memory: [bold cyan]{mem_count}[/bold cyan] "
-            f"verified optimization(s) in local store[/dim]"
-        )
+        # Prepare Live Markdown File
+        report_path = path.with_name(f"{path.stem}_coreinsight_report.md")
+        with open(report_path, "w", encoding="utf-8") as f:
+            f.write(f"# CoreInsight Performance Report: `{path.name}`\n\n")
+            f.write("> **Note:** This file updates live as the AI completes hardware verification.\n\n---\n\n")
+        
+        console.print(f"[bold blue]📄 Live report created at:[/bold blue] [underline]{report_path.absolute()}[/underline]\n")
+        console.print("[dim]Analyzing functions in parallel. Results will appear as they complete...[/dim]\n")
 
-    # Prepare Live Markdown File
-    report_path = path.with_name(f"{path.stem}_coreinsight_report.md")
-    with open(report_path, "w", encoding="utf-8") as f:
-        f.write(f"# CoreInsight Performance Report: `{path.name}`\n\n")
-        f.write("> **Note:** This file updates live as the AI completes hardware verification.\n\n---\n\n")
-    
-    console.print(f"[bold blue]📄 Live report created at:[/bold blue] [underline]{report_path.absolute()}[/underline]\n")
-    console.print("[dim]Analyzing functions in parallel. Results will appear as they complete...[/dim]\n")
+        # 2. PARALLEL EXECUTION
+        # Limit max_workers to 4 so we don't overwhelm local Docker engine or local Ollama GPU VRAM
+        max_workers = min(4, len(functions)) 
+        
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Submit all functions to the thread pool
+            future_to_func = {
+                executor.submit(process_function, func, language, agent, sandbox, indexer, hardware_target_str, tier_limits, profiler, file_content, str(path.parent), memory, agent_mode, multi_agents): func
+                for func in functions
+            }
 
-    # 2. PARALLEL EXECUTION
-    # Limit max_workers to 4 so we don't overwhelm local Docker engine or local Ollama GPU VRAM
-    max_workers = min(4, len(functions)) 
-    
-    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-        # Submit all functions to the thread pool
-        future_to_func = {
-            executor.submit(process_function, func, language, agent, sandbox, indexer, hardware_target_str, tier_limits, profiler, file_content, str(path.parent), memory, agent_mode, multi_agents): func
-            for func in functions
-        }
-
-        # As each thread finishes, process its output instantly
-        for future in concurrent.futures.as_completed(future_to_func):
-            func = future_to_func[future]
-            try:
-                func_name, result, sandbox_res, msg, verification, profiler_result, memory_hit, was_valid = future.result()
-
-                # Store if the benchmark actually ran and achieved real speedup.
-                # We use is_valid_optimization (≥1.05x measured speedup) rather
-                # than verification.speedup.verified because timer resolution at
-                # small N frequently causes the cross-check to flag a discrepancy
-                # even when the optimization is genuine.
-                if (
-                    memory_hit is None
-                    and was_valid
-                    and result is not None
-                ):
-                    stored = memory.store(
-                        original_code=func['code'],
-                        func_name=func_name,
-                        language=language,
-                        result=result,
-                        verification=verification,
-                        profiler_result=profiler_result,
-                    )
-                    if stored:
-                        _log(func_name, "💾 Stored in optimization memory", style="dim cyan")
-
-                # 1. Format and save to Markdown file
-                output_md = format_report_markdown(func_name, result, sandbox_res, msg, language, path.parent, verification, profiler_result, memory_hit)
-
-                # Write to File (Safely)
-                with file_lock:
-                    with open(report_path, "a", encoding="utf-8") as f:
-                        f.write(output_md)
-
-                # 2. Print beautiful native UI to the terminal
-                with print_lock:
-                    print_console_report(func_name, result, sandbox_res, msg, language, verification, profiler_result, memory_hit)
-                
-            except Exception as exc:
-                with print_lock:
-                    console.print(f"[bold red]❌ Critical failure in thread processing {func['name']}:[/bold red] {exc}")
-
-    console.print(Panel.fit(f"✅ [bold green]Analysis Complete![/bold green] Final report saved to:\n{report_path.absolute()}"))
-
-    if not pro_user:
-        console.print(Panel(
-            "[bold]Enjoyed CoreInsight?[/bold] Pro unlocks:\n"
-            "  • [cyan]Cloud models[/cyan] (GPT-4o, Claude, Gemini)\n"
-            "  • [cyan]Unlimited functions[/cyan] per file\n"
-            "  • [cyan]5 retry attempts[/cyan] + deeper test coverage\n"
-            "  • [cyan]AI-free hardware profiling[/cyan] — cProfile + perf stat evidence in every report\n\n"
-            f"[bold yellow]Pro is free during beta.[/bold yellow] Request a key:\n"
-            f"[cyan underline]{PRO_WAITLIST_URL}[/cyan underline]",
-            title="⚡  Upgrade to Pro — free during beta",
-            border_style="yellow",
-        ))
+            # As each thread finishes, process its output instantly
+            for future in concurrent.futures.as_completed(future_to_func):
+                func = future_to_func[future]
+                try:
+                    func_name, result, sandbox_res, msg, verification, profiler_result, memory_hit, was_valid = future.result()
+
+                    # Store if the benchmark actually ran and achieved real speedup.
+                    # We use is_valid_optimization (≥1.05x measured speedup) rather
+                    # than verification.speedup.verified because timer resolution at
+                    # small N frequently causes the cross-check to flag a discrepancy
+                    # even when the optimization is genuine.
+                    if (
+                        memory_hit is None
+                        and was_valid
+                        and result is not None
+                    ):
+                        stored = memory.store(
+                            original_code=func['code'],
+                            func_name=func_name,
+                            language=language,
+                            result=result,
+                            verification=verification,
+                            profiler_result=profiler_result,
+                        )
+                        if stored:
+                            _log(func_name, "💾 Stored in optimization memory", style="dim cyan")
+
+                    # 1. Format and save to Markdown file
+                    output_md = format_report_markdown(func_name, result, sandbox_res, msg, language, path.parent, verification, profiler_result, memory_hit)
+
+                    # Write to File (Safely)
+                    with file_lock:
+                        with open(report_path, "a", encoding="utf-8") as f:
+                            f.write(output_md)
+
+                    # 2. Print beautiful native UI to the terminal
+                    with print_lock:
+                        print_console_report(func_name, result, sandbox_res, msg, language, verification, profiler_result, memory_hit)
+                    
+                except Exception as exc:
+                    with print_lock:
+                        console.print(f"[bold red]❌ Critical failure in thread processing {func['name']}:[/bold red] {exc}")
+
+        console.print(Panel.fit(f"✅ [bold green]Analysis Complete![/bold green] Final report saved to:\n{report_path.absolute()}"))
+
+        if not pro_user:
+            console.print(Panel(
+                "[bold]Enjoyed CoreInsight?[/bold] Pro unlocks:\n"
+                "  • [cyan]Cloud models[/cyan] (GPT-4o, Claude, Gemini)\n"
+                "  • [cyan]Unlimited functions[/cyan] per file\n"
+                "  • [cyan]5 retry attempts[/cyan] + deeper test coverage\n"
+                "  • [cyan]AI-free hardware profiling[/cyan] — cProfile + perf stat evidence in every report\n\n"
+                f"[bold yellow]Pro is free during beta.[/bold yellow] Request a key:\n"
+                f"[cyan underline]{PRO_WAITLIST_URL}[/cyan underline]",
+                title="⚡  Upgrade to Pro — free during beta",
+                border_style="yellow",
+            ))
+    finally:
+        console = _prev_console
 
 def run_demo(lang: str = "python", no_docker: bool = False):
     import shutil
@@ -902,6 +932,9 @@ def main_cli():
     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")
 
+    view_parser = subparsers.add_parser("view", help="Launch the interactive TUI")
+    view_parser.add_argument("--dir", default=".", help="Starting directory (default: current)")
+
     scan_parser = subparsers.add_parser("scan", help="Scan directory for complex hotspots")
     scan_parser.add_argument("--dir", default=".", help="Directory to scan")
     scan_parser.add_argument("--top", type=int, default=10, help="Number of hotspots to show")
@@ -913,6 +946,9 @@ def main_cli():
             pro_key=getattr(args, "pro_key", None),
             agent_mode=getattr(args, "agent_mode", None),
         )
+    elif args.command == "view":
+        from coreinsight.tui import run_tui
+        run_tui(start_dir=getattr(args, "dir", "."))
     elif args.command == "demo":
         run_demo(getattr(args, "lang", "python"), no_docker=getattr(args, "no_docker", False))
     elif args.command == "analyze":

{coreinsight_cli-0.2.6 → coreinsight_cli-0.2.7}/coreinsight/sandbox.py

@@ -26,6 +26,7 @@ DOCKERFILES = {
 # ---------------------------------------------------------------------------
 # Verification constants
 # ---------------------------------------------------------------------------
+SANDBOX_SKIPPED_MSG = "Verification skipped (--no-docker)."
 SPEEDUP_DISCREPANCY_TOLERANCE = 0.05  # max relative delta: computed vs reported speedup
 MIN_TIMING_ROWS = 2                   # minimum CSV rows to trust timing statistics
 FLOAT_RTOL = 1e-5                     # relative tolerance for output comparison
@@ -203,7 +204,7 @@ class CodeSandbox:
 
     def execute_benchmark(self, code: str, language: str = "cpp", timeout_seconds: int = 120) -> Tuple[bool, str, Optional[bytes]]:
         if self.disabled:
-            return False, "Verification skipped (--no-docker).", None
+            return False, SANDBOX_SKIPPED_MSG, None
         if not self.client:
             return False, "Docker is not running on the host machine.", None
 
@@ -292,8 +293,8 @@ class CodeSandbox:
     ) -> VerificationResult:
         if self.disabled:
             return VerificationResult(
-                speedup=SpeedupVerification(verified=False, details="Skipped (--no-docker)."),
-                correctness=CorrectnessVerification(verified=False, details="Skipped (--no-docker)."),
+                speedup=SpeedupVerification(verified=False, details=SANDBOX_SKIPPED_MSG),
+                correctness=CorrectnessVerification(verified=False, details=SANDBOX_SKIPPED_MSG),
             )
         speedup_result     = self._verify_speedup(csv_output)
         correctness_result = self._verify_correctness(

coreinsight_cli-0.2.7/coreinsight/tui.py

@@ -0,0 +1,650 @@
+"""
+coreinsight/tui.py — Interactive TUI for CoreInsight
+Launch with: coreinsight view
+"""
+
+from __future__ import annotations
+
+import threading
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.text import Text
+from textual import on, work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Horizontal, Vertical, ScrollableContainer
+from textual.screen import ModalScreen
+from textual.widgets import (
+    Button,
+    Checkbox,
+    DirectoryTree,
+    Footer,
+    Header,
+    Label,
+    RichLog,
+    Static,
+    Switch,
+)
+from textual.widgets._directory_tree import DirEntry
+
+from coreinsight.config import (
+    load_config,
+    is_pro,
+    get_tier_limits,
+    PRO_WAITLIST_URL,
+)
+from coreinsight.memory import OptimizationMemory
+
+# ---------------------------------------------------------------------------
+# Sentinel used to detect --no-docker skips (imported for display logic)
+# ---------------------------------------------------------------------------
+try:
+    from coreinsight.sandbox import SANDBOX_SKIPPED_MSG
+except ImportError:
+    SANDBOX_SKIPPED_MSG = "Verification skipped (--no-docker)."
+
+
+# ---------------------------------------------------------------------------
+# TuiConsole — drop-in replacement for rich.Console that writes to RichLog
+# ---------------------------------------------------------------------------
+
+class _NoopStatus:
+    """Stub so console.status(...) calls don't crash inside the TUI."""
+    def __enter__(self): return self
+    def __exit__(self, *_): pass
+
+
+class TuiConsole:
+    """
+    Mimics the rich.Console API used in main.py so run_analysis() output
+    is captured and displayed in the TUI's RichLog widget in real time.
+    """
+
+    def __init__(self, log_widget: RichLog):
+        self._log = log_widget
+        self._lock = threading.Lock()
+
+    # Main output method — handles str, Rich renderables, Panel, etc.
+    def print(self, *args, **kwargs):
+        with self._lock:
+            for arg in args:
+                try:
+                    self._log.write(arg)
+                except Exception:
+                    self._log.write(str(arg))
+
+    # console.log() is used by _log() helper in main.py
+    def log(self, *args, **kwargs):
+        self.print(*args)
+
+    # console.status() is used for spinners — no-op in TUI
+    def status(self, *args, **kwargs):
+        return _NoopStatus()
+
+
+# ---------------------------------------------------------------------------
+# Memory modal
+# ---------------------------------------------------------------------------
+
+class MemoryModal(ModalScreen):
+    """Full-screen modal showing the optimization memory store."""
+
+    BINDINGS = [Binding("escape,q", "dismiss", "Close")]
+
+    DEFAULT_CSS = """
+    MemoryModal {
+        align: center middle;
+    }
+    MemoryModal > Container {
+        width: 90%;
+        height: 80%;
+        background: $surface;
+        border: thick $primary;
+        padding: 1 2;
+    }
+    MemoryModal #memory-log {
+        height: 1fr;
+    }
+    MemoryModal #close-memory {
+        margin-top: 1;
+        width: 100%;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        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")
+
+    def on_mount(self) -> None:
+        log = self.query_one("#memory-log", RichLog)
+        self._populate(log)
+
+    def _populate(self, log: RichLog) -> None:
+        from rich.table import Table
+
+        mem = OptimizationMemory()
+        stats = mem.stats()
+        count = stats.get("count", 0)
+
+        if count == 0:
+            log.write("[dim]No optimizations stored yet.[/dim]")
+            log.write(
+                f"\nRun [cyan]coreinsight analyze[/cyan] or use the Analyze action "
+                f"to start building your memory store."
+            )
+            return
+
+        try:
+            if not mem._ensure_db():
+                log.write("[red]Could not open memory store.[/red]")
+                return
+            all_records = mem._collection.get(include=["metadatas"])
+            metadatas   = all_records.get("metadatas", []) or []
+            ids         = all_records.get("ids",       []) or []
+        except Exception as exc:
+            log.write(f"[red]Failed to read memory store: {exc}[/red]")
+            return
+
+        table = Table(
+            show_header=True, header_style="bold cyan",
+            expand=True, show_lines=True,
+        )
+        table.add_column("#",          justify="right",  style="dim",        width=4)
+        table.add_column("Function",   justify="left",   style="bold white")
+        table.add_column("Language",   justify="center", style="cyan",       width=10)
+        table.add_column("Speedup",    justify="right",  style="bold green", width=9)
+        table.add_column("Severity",   justify="center",                     width=10)
+        table.add_column("Issue",      justify="left",   style="dim white")
+        table.add_column("Verified",   justify="left",   style="dim",        width=20)
+
+        severity_colors = {
+            "Critical": "red", "High": "yellow",
+            "Medium": "cyan",  "Low": "green",
+        }
+
+        paired = sorted(
+            zip(metadatas, ids),
+            key=lambda x: x[0].get("timestamp", ""),
+            reverse=True,
+        )
+        for i, (meta, rid) in enumerate(paired, start=1):
+            sev   = meta.get("severity", "High")
+            sev_c = severity_colors.get(sev, "white")
+            ts    = meta.get("timestamp", "")[:19].replace("T", " ")
+            issue = (meta.get("issue", "") or "—")[:55]
+            if len(meta.get("issue", "")) > 55:
+                issue += "…"
+            table.add_row(
+                str(i),
+                meta.get("func_name", rid[:12]),
+                meta.get("language", "?"),
+                f"{float(meta.get('avg_speedup', 0)):.2f}x",
+                f"[{sev_c}]{sev}[/{sev_c}]",
+                issue,
+                ts,
+            )
+
+        log.write(table)
+        log.write(f"\n[dim]Store location: ~/.coreinsight/memory_db[/dim]")
+
+    @on(Button.Pressed, "#close-memory")
+    def close(self) -> None:
+        self.dismiss()
+
+
+# ---------------------------------------------------------------------------
+# Confirm modal — used for destructive actions like memory clear
+# ---------------------------------------------------------------------------
+
+class ConfirmModal(ModalScreen[bool]):
+    """Simple yes/no confirmation dialog."""
+
+    BINDINGS = [Binding("escape", "dismiss_false", "Cancel")]
+
+    DEFAULT_CSS = """
+    ConfirmModal {
+        align: center middle;
+    }
+    ConfirmModal > Container {
+        width: 50;
+        height: 10;
+        background: $surface;
+        border: thick $warning;
+        padding: 1 2;
+        align: center middle;
+    }
+    ConfirmModal Horizontal {
+        align: center middle;
+        margin-top: 1;
+    }
+    ConfirmModal Button {
+        margin: 0 1;
+    }
+    """
+
+    def __init__(self, message: str, **kwargs):
+        super().__init__(**kwargs)
+        self._message = message
+
+    def compose(self) -> ComposeResult:
+        with Container():
+            yield Label(self._message, id="confirm-msg")
+            with Horizontal():
+                yield Button("Yes", id="confirm-yes", variant="error")
+                yield Button("No",  id="confirm-no",  variant="default")
+
+    @on(Button.Pressed, "#confirm-yes")
+    def yes(self) -> None:
+        self.dismiss(True)
+
+    @on(Button.Pressed, "#confirm-no")
+    def no(self) -> None:
+        self.dismiss(False)
+
+    def action_dismiss_false(self) -> None:
+        self.dismiss(False)
+
+
+# ---------------------------------------------------------------------------
+# Settings modal
+# ---------------------------------------------------------------------------
+
+class SettingsModal(ModalScreen):
+    """Read-only settings viewer. Directs user to coreinsight configure for changes."""
+
+    BINDINGS = [Binding("escape,q", "dismiss", "Close")]
+
+    DEFAULT_CSS = """
+    SettingsModal {
+        align: center middle;
+    }
+    SettingsModal > Container {
+        width: 60;
+        height: 22;
+        background: $surface;
+        border: thick $primary;
+        padding: 1 2;
+    }
+    SettingsModal .setting-row {
+        height: 1;
+        margin-bottom: 1;
+    }
+    SettingsModal #close-settings {
+        margin-top: 1;
+        width: 100%;
+    }
+    """
+
+    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"
+        agent_mode = config.get("agent_mode", "auto")
+
+        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",
+            )
+            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()
+
+
+# ---------------------------------------------------------------------------
+# Main TUI App
+# ---------------------------------------------------------------------------
+
+class CoreInsightApp(App):
+
+    TITLE    = "CoreInsight"
+    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),
+    ]
+
+    CSS = """
+    /* ── Layout ─────────────────────────────────────────────────────────── */
+    Screen {
+        layout: vertical;
+    }
+
+    #main-area {
+        layout: horizontal;
+        height: 1fr;
+    }
+
+    /* ── Left panel ─────────────────────────────────────────────────────── */
+    #left-panel {
+        width: 32;
+        min-width: 24;
+        layout: vertical;
+        border-right: solid $primary-darken-2;
+    }
+
+    #file-panel {
+        height: 1fr;
+        border-bottom: solid $primary-darken-2;
+        padding: 0 0;
+    }
+
+    #file-label {
+        background: $primary-darken-2;
+        color: $text;
+        padding: 0 1;
+        height: 1;
+    }
+
+    #file-tree {
+        height: 1fr;
+        padding: 0;
+    }
+
+    #selected-count {
+        height: 1;
+        padding: 0 1;
+        color: $text-muted;
+        background: $surface-darken-1;
+    }
+
+    /* ── Action panel ───────────────────────────────────────────────────── */
+    #action-panel {
+        height: auto;
+        padding: 1;
+    }
+
+    #action-label {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+
+    #action-panel Button {
+        width: 100%;
+        margin-bottom: 1;
+    }
+
+    #no-docker-row {
+        height: 3;
+        align: left middle;
+        margin-top: 1;
+    }
+
+    #no-docker-label {
+        padding: 0 1;
+        color: $text-muted;
+    }
+
+    /* ── Right panel (output) ───────────────────────────────────────────── */
+    #right-panel {
+        width: 1fr;
+        layout: vertical;
+    }
+
+    #output-label {
+        background: $primary-darken-2;
+        color: $text;
+        padding: 0 1;
+        height: 1;
+    }
+
+    #output-log {
+        height: 1fr;
+        padding: 0 1;
+    }
+
+    /* ── Status bar ─────────────────────────────────────────────────────── */
+    #status-bar {
+        height: 1;
+        background: $primary-darken-3;
+        color: $text-muted;
+        padding: 0 1;
+        dock: bottom;
+    }
+    """
+
+    def __init__(self, start_dir: str = "."):
+        super().__init__()
+        self._start_dir  = str(Path(start_dir).resolve())
+        self._selected: set[str] = set()
+        self._busy       = False
+
+        config           = load_config()
+        self._pro        = is_pro(config)
+        self._tier_limits = get_tier_limits(config)
+
+    # ── Compose ──────────────────────────────────────────────────────────
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+
+        with Container(id="main-area"):
+
+            # Left panel
+            with Vertical(id="left-panel"):
+                with Vertical(id="file-panel"):
+                    yield Label(" Files", id="file-label")
+                    yield DirectoryTree(self._start_dir, id="file-tree")
+                    yield Label("No files selected", id="selected-count")
+
+                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")
+                    with Horizontal(id="no-docker-row"):
+                        yield Switch(value=False, id="no-docker-switch")
+                        yield Label("Skip Docker", id="no-docker-label")
+
+            # Right panel — live output
+            with Vertical(id="right-panel"):
+                yield Label(" Output", id="output-label")
+                yield RichLog(
+                    id="output-log",
+                    highlight=True,
+                    markup=True,
+                    wrap=True,
+                )
+
+        yield Label(" Ready — select files to begin.", id="status-bar")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        log = self.query_one("#output-log", RichLog)
+        config   = load_config()
+        pro_user = is_pro(config)
+        tier_str = "[bold green]Pro[/bold green]" if pro_user else "[bold yellow]Free[/bold yellow]"
+
+        log.write(f"[bold cyan]CoreInsight[/bold cyan]  {tier_str}")
+        log.write("[dim]Select one or more files in the browser, then press Analyze.[/dim]")
+        if not pro_user:
+            log.write(
+                f"[dim]Free tier: up to 2 files per run. "
+                f"Pro is free during beta → [cyan]{PRO_WAITLIST_URL}[/cyan][/dim]"
+            )
+        log.write("")
+
+    # ── File selection ────────────────────────────────────────────────────
+
+    @on(DirectoryTree.FileSelected)
+    def file_selected(self, event: DirectoryTree.FileSelected) -> None:
+        path = str(event.path)
+
+        # Only allow supported file types
+        supported = {".py", ".cpp", ".cc", ".h", ".hpp", ".cu", ".cuh"}
+        if Path(path).suffix.lower() not in supported:
+            self._set_status(f"Unsupported file type: {Path(path).suffix}")
+            return
+
+        # Toggle selection
+        if path in self._selected:
+            self._selected.discard(path)
+        else:
+            # Enforce free-tier file limit
+            max_files = self._tier_limits.get("max_files")
+            if max_files and len(self._selected) >= max_files:
+                log = self.query_one("#output-log", RichLog)
+                log.write(
+                    f"\n[yellow]Free tier: max {max_files} file(s) per run. "
+                    f"Upgrade to Pro for unlimited → [cyan]{PRO_WAITLIST_URL}[/cyan][/yellow]"
+                )
+                self._set_status(f"Free tier: max {max_files} files. Upgrade to Pro for unlimited.")
+                return
+            self._selected.add(path)
+
+        self._refresh_selected_label()
+
+    def _refresh_selected_label(self) -> None:
+        label = self.query_one("#selected-count", Label)
+        n = len(self._selected)
+        if n == 0:
+            label.update("No files selected")
+        elif n == 1:
+            name = Path(next(iter(self._selected))).name
+            label.update(f"1 selected: {name}")
+        else:
+            label.update(f"{n} files selected")
+
+    # ── Actions ───────────────────────────────────────────────────────────
+
+    @on(Button.Pressed, "#btn-analyze")
+    def action_analyze(self) -> None:
+        if self._busy:
+            self._set_status("Already running — please wait.")
+            return
+        if not self._selected:
+            self._set_status("Select at least one file first.")
+            return
+        no_docker = self.query_one("#no-docker-switch", Switch).value
+        self._start_analysis(list(self._selected), no_docker)
+
+    @on(Button.Pressed, "#btn-index")
+    def action_index(self) -> None:
+        if self._busy:
+            self._set_status("Already running — please wait.")
+            return
+        if not self._selected:
+            self._set_status("Select at least one file to determine its directory.")
+            return
+        # Index the parent directory of the first selected file
+        target_dir = str(Path(next(iter(self._selected))).parent)
+        self._start_index(target_dir)
+
+    @on(Button.Pressed, "#btn-memory")
+    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())
+
+    # ── Workers ───────────────────────────────────────────────────────────
+
+    @work(thread=True)
+    def _start_analysis(self, files: list[str], no_docker: bool) -> None:
+        from coreinsight.main import run_analysis
+
+        log = self.query_one("#output-log", RichLog)
+        tui_console = TuiConsole(log)
+        self._busy = True
+
+        for i, file_path in enumerate(files, 1):
+            name = Path(file_path).name
+            self.call_from_thread(
+                self._set_status,
+                f"Analyzing {name} ({i}/{len(files)})...",
+            )
+            self.call_from_thread(
+                log.write,
+                f"\n[bold cyan]{'─' * 60}[/bold cyan]"
+                f"\n[bold]Analyzing:[/bold] [cyan]{name}[/cyan]\n",
+            )
+            try:
+                run_analysis(file_path, no_docker=no_docker, tui_console=tui_console)
+            except SystemExit:
+                # run_analysis calls sys.exit(1) on bad input — catch it
+                pass
+            except Exception as exc:
+                self.call_from_thread(
+                    log.write,
+                    f"[red]Unexpected error analyzing {name}: {exc}[/red]",
+                )
+
+        self._busy = False
+        self.call_from_thread(
+            self._set_status,
+            f"Done. {len(files)} file(s) analyzed.",
+        )
+
+    @work(thread=True)
+    def _start_index(self, target_dir: str) -> None:
+        from coreinsight.indexer import RepoIndexer
+
+        log = self.query_one("#output-log", RichLog)
+        self._busy = True
+        self.call_from_thread(
+            self._set_status,
+            f"Indexing {target_dir}...",
+        )
+        self.call_from_thread(
+            log.write,
+            f"\n[bold cyan]Indexing directory:[/bold cyan] [cyan]{target_dir}[/cyan]\n",
+        )
+        try:
+            indexer = RepoIndexer(target_dir)
+            indexer.index_repository()
+            self.call_from_thread(
+                log.write,
+                "[bold green]Indexing complete.[/bold green]\n",
+            )
+        except Exception as exc:
+            self.call_from_thread(
+                log.write,
+                f"[red]Indexing failed: {exc}[/red]\n",
+            )
+        finally:
+            self._busy = False
+            self.call_from_thread(self._set_status, "Indexing done.")
+
+    # ── Helpers ───────────────────────────────────────────────────────────
+
+    def _set_status(self, msg: str) -> None:
+        self.query_one("#status-bar", Label).update(f" {msg}")
+
+
+# ---------------------------------------------------------------------------
+# Entry point called from main.py
+# ---------------------------------------------------------------------------
+
+def run_tui(start_dir: str = ".") -> None:
+    """Launch the CoreInsight TUI. Called by `coreinsight view`."""
+    app = CoreInsightApp(start_dir=start_dir)
+    app.run()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreinsight-cli
-Version: 0.2.6
+Version: 0.2.7
 Summary: Local-first AI performance profiler that mathematically verifies optimizations for Python, C++, and CUDA
 Author: Varun Jani
 License: GPL-3.0-or-later
@@ -32,6 +32,7 @@ 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: textual>=0.60.0
 Requires-Dist: psutil>=5.9
 Provides-Extra: compat
 Requires-Dist: pysqlite3-binary>=0.5.0; extra == "compat"

{coreinsight_cli-0.2.6 → coreinsight_cli-0.2.7}/coreinsight_cli.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ coreinsight/profiler.py
 coreinsight/prompts.py
 coreinsight/sandbox.py
 coreinsight/scanner.py
+coreinsight/tui.py
 coreinsight/demo/__init__.py
 coreinsight/demo/bad_loop.py
 coreinsight/demo/data_processor.py

{coreinsight_cli-0.2.6 → coreinsight_cli-0.2.7}/coreinsight_cli.egg-info/requires.txt

@@ -11,6 +11,7 @@ langchain-anthropic>=0.1.0
 pydantic>=2.0
 chromadb>=0.5.0
 sentence-transformers>=3.0.0
+textual>=0.60.0
 psutil>=5.9
 
 [compat]

{coreinsight_cli-0.2.6 → coreinsight_cli-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "coreinsight-cli"
-version = "0.2.6"
+version = "0.2.7"
 description = "Local-first AI performance profiler that mathematically verifies optimizations for Python, C++, and CUDA"
 license = {text = "GPL-3.0-or-later"}
 authors = [
@@ -38,6 +38,7 @@ dependencies = [
     "pydantic>=2.0",
     "chromadb>=0.5.0",
     "sentence-transformers>=3.0.0",
+    "textual>=0.60.0",
     "psutil>=5.9",
 ]