Kavin python ide.py

"""
Kavin IDE  —  VS Code–style Python IDE
Run:   python kavin_ide_final.py
Needs: Python 3.8+  (tkinter ships with Python on Windows/macOS)
Linux: sudo apt install python3-tk
"""

import tkinter as tk
from tkinter import ttk, filedialog, messagebox, simpledialog
import subprocess, threading, os, sys, re, tempfile, time
from pathlib import Path

# ╔══════════════════════════════════════════════════════════╗
#  VS CODE  EXACT  COLORS
# ╚══════════════════════════════════════════════════════════╝
VS = {
    # backgrounds
    "titlebar":      "#3c3c3c",
    "menubar":       "#3c3c3c",
    "activity":      "#333333",
    "sidebar":       "#252526",
    "sidebar_hdr":   "#252526",
    "editor":        "#1e1e1e",
    "editor_gutter": "#1e1e1e",
    "tab_bar":       "#2d2d2d",
    "tab_active":    "#1e1e1e",
    "tab_inactive":  "#2d2d2d",
    "panel":         "#1e1e1e",
    "panel_hdr":     "#252526",
    "statusbar":     "#007acc",
    "input":         "#3c3c3c",
    "dropdown":      "#252526",
    "dropdown_sel":  "#094771",
    "hover":         "#2a2d2e",
    "selection":     "#264f78",
    "line_hl":       "#2a2a2a",
    "border":        "#474747",
    "sash":          "#474747",
    "scrollbar":     "#424242",

    # text
    "fg":            "#cccccc",
    "fg_dim":        "#858585",
    "fg_muted":      "#5a5a5a",
    "fg_tab_on":     "#ffffff",
    "fg_tab_off":    "#8d8d8d",
    "fg_statusbar":  "#ffffff",
    "fg_line":       "#5a5a5a",
    "fg_line_cur":   "#c6c6c6",
    "fg_sidebar":    "#cccccc",
    "fg_sidebar_hdr":"#bbbbbb",

    # syntax  —  VS Code Dark+  exact
    "kw":    "#569cd6",   # blue        — if for while
    "kw2":   "#c586c0",   # pink        — class def import
    "bi":    "#dcdcaa",   # yellow      — builtins
    "str_":  "#ce9178",   # orange      — strings
    "doc":   "#6a9955",   # green       — docstrings / comments
    "cmt":   "#6a9955",
    "num":   "#b5cea8",   # light green — numbers
    "dec":   "#dcdcaa",   # yellow      — decorators
    "cls_n": "#4ec9b0",   # teal        — class names
    "fn_n":  "#dcdcaa",   # yellow      — function names
    "slf":   "#9cdcfe",   # light blue  — self / cls
    "op":    "#d4d4d4",   # white       — operators
    "param": "#9cdcfe",   # light blue  — params

    # autocomplete popup
    "ac_bg":      "#252526",
    "ac_sel":     "#094771",
    "ac_border":  "#454545",
    "ac_detail":  "#1e1e1e",
    "ac_fg":      "#d4d4d4",
    "ac_dim":     "#858585",

    # kind icon colors
    "ic_kw":    "#569cd6",
    "ic_fn":    "#dcdcaa",
    "ic_cls":   "#4ec9b0",
    "ic_snip":  "#c586c0",
    "ic_mod":   "#9cdcfe",
    "ic_const": "#4fc1ff",
    "ic_var":   "#9cdcfe",

    # run button
    "run_bg":   "#388a34",
    "run_fg":   "#ffffff",

    # error
    "err_line": "#4b1818",
    "err_fg":   "#f48771",
}

# ╔══════════════════════════════════════════════════════════╗
#  AUTOCOMPLETE  DATABASE   (triggers on every letter typed)
# ╚══════════════════════════════════════════════════════════╝
# Format: (label, kind, detail_signature)
_KW = "kw"; _BI = "bi"; _CLS = "cls"; _SNIP = "snip"
_MOD = "mod"; _CONST = "const"

COMPLETIONS = [
    # ── Python keywords ──────────────────────────────────────
    ("False",       _KW,   "bool  False"),
    ("None",        _KW,   "None"),
    ("True",        _KW,   "bool  True"),
    ("and",         _KW,   "and  (logical and)"),
    ("as",          _KW,   "as  alias"),
    ("assert",      _KW,   "assert expression [, message]"),
    ("async",       _KW,   "async def / async for / async with"),
    ("await",       _KW,   "await coroutine"),
    ("break",       _KW,   "break  (exit loop)"),
    ("class",       _KW,   "class Name(Base):"),
    ("continue",    _KW,   "continue  (next iteration)"),
    ("def",         _KW,   "def function_name(params):"),
    ("del",         _KW,   "del object"),
    ("elif",        _KW,   "elif condition:"),
    ("else",        _KW,   "else:"),
    ("except",      _KW,   "except ExceptionType as e:"),
    ("finally",     _KW,   "finally:"),
    ("for",         _KW,   "for item in iterable:"),
    ("from",        _KW,   "from module import name"),
    ("global",      _KW,   "global variable"),
    ("if",          _KW,   "if condition:"),
    ("import",      _KW,   "import module"),
    ("in",          _KW,   "in  (membership test)"),
    ("is",          _KW,   "is  (identity test)"),
    ("lambda",      _KW,   "lambda params: expression"),
    ("nonlocal",    _KW,   "nonlocal variable"),
    ("not",         _KW,   "not expression"),
    ("or",          _KW,   "or  (logical or)"),
    ("pass",        _KW,   "pass  (no-op)"),
    ("raise",       _KW,   "raise ExceptionType(message)"),
    ("return",      _KW,   "return value"),
    ("try",         _KW,   "try:"),
    ("while",       _KW,   "while condition:"),
    ("with",        _KW,   "with expression as alias:"),
    ("yield",       _KW,   "yield value"),
    # ── Built-in functions ───────────────────────────────────
    ("print",       _BI,   "print(*objects, sep=' ', end='\\n', file=None, flush=False)"),
    ("len",         _BI,   "len(s) -> int   Return the length of s"),
    ("range",       _BI,   "range(stop) | range(start, stop[, step])"),
    ("type",        _BI,   "type(object) -> type"),
    ("int",         _BI,   "int(x=0, base=10) -> int"),
    ("str",         _BI,   "str(object='') -> str"),
    ("float",       _BI,   "float(x=0.0) -> float"),
    ("bool",        _BI,   "bool(x=False) -> bool"),
    ("list",        _BI,   "list(iterable=()) -> list"),
    ("dict",        _BI,   "dict(**kwargs) -> dict"),
    ("tuple",       _BI,   "tuple(iterable=()) -> tuple"),
    ("set",         _BI,   "set(iterable=set()) -> set"),
    ("frozenset",   _BI,   "frozenset(iterable=()) -> frozenset"),
    ("bytes",       _BI,   "bytes(source, encoding, errors) -> bytes"),
    ("bytearray",   _BI,   "bytearray(source, encoding, errors) -> bytearray"),
    ("input",       _BI,   "input(prompt='') -> str"),
    ("open",        _BI,   "open(file, mode='r', buffering=-1, encoding=None, ...) -> IO"),
    ("print",       _BI,   "print(*objects, sep=' ', end='\\n')"),
    ("enumerate",   _BI,   "enumerate(iterable, start=0) -> iterator of (index, value)"),
    ("zip",         _BI,   "zip(*iterables) -> iterator of tuples"),
    ("map",         _BI,   "map(function, iterable, ...) -> iterator"),
    ("filter",      _BI,   "filter(function, iterable) -> iterator"),
    ("sorted",      _BI,   "sorted(iterable, *, key=None, reverse=False) -> list"),
    ("reversed",    _BI,   "reversed(sequence) -> iterator"),
    ("sum",         _BI,   "sum(iterable, /, start=0) -> number"),
    ("min",         _BI,   "min(iterable, *, key=None, default=...) -> value"),
    ("max",         _BI,   "max(iterable, *, key=None, default=...) -> value"),
    ("abs",         _BI,   "abs(x) -> number   Return absolute value"),
    ("round",       _BI,   "round(number, ndigits=None) -> number"),
    ("pow",         _BI,   "pow(base, exp, mod=None) -> number"),
    ("divmod",      _BI,   "divmod(a, b) -> (quotient, remainder)"),
    ("repr",        _BI,   "repr(object) -> str"),
    ("hash",        _BI,   "hash(object) -> int"),
    ("id",          _BI,   "id(object) -> int  Return memory address"),
    ("hex",         _BI,   "hex(x) -> str  Convert int to hex string"),
    ("oct",         _BI,   "oct(x) -> str  Convert int to octal string"),
    ("bin",         _BI,   "bin(x) -> str  Convert int to binary string"),
    ("chr",         _BI,   "chr(i) -> str  Return Unicode character"),
    ("ord",         _BI,   "ord(c) -> int  Return Unicode code point"),
    ("format",      _BI,   "format(value, format_spec='') -> str"),
    ("super",       _BI,   "super() -> proxy for parent class"),
    ("object",      _BI,   "object()  Base class of all classes"),
    ("isinstance",  _BI,   "isinstance(object, classinfo) -> bool"),
    ("issubclass",  _BI,   "issubclass(class, classinfo) -> bool"),
    ("hasattr",     _BI,   "hasattr(object, name) -> bool"),
    ("getattr",     _BI,   "getattr(object, name[, default]) -> value"),
    ("setattr",     _BI,   "setattr(object, name, value)"),
    ("delattr",     _BI,   "delattr(object, name)"),
    ("callable",    _BI,   "callable(object) -> bool"),
    ("dir",         _BI,   "dir(object) -> list of names"),
    ("vars",        _BI,   "vars([object]) -> dict"),
    ("globals",     _BI,   "globals() -> dict  Global symbol table"),
    ("locals",      _BI,   "locals() -> dict  Local symbol table"),
    ("any",         _BI,   "any(iterable) -> bool"),
    ("all",         _BI,   "all(iterable) -> bool"),
    ("next",        _BI,   "next(iterator[, default]) -> value"),
    ("iter",        _BI,   "iter(object[, sentinel]) -> iterator"),
    ("exec",        _BI,   "exec(source, globals=None, locals=None)"),
    ("eval",        _BI,   "eval(expression, globals=None, locals=None) -> value"),
    ("compile",     _BI,   "compile(source, filename, mode) -> code"),
    ("__import__",  _BI,   "__import__(name, ...) -> module"),
    ("staticmethod",_BI,   "@staticmethod  — decorator"),
    ("classmethod", _BI,   "@classmethod  — decorator"),
    ("property",    _BI,   "@property  — decorator"),
    ("slice",       _BI,   "slice(stop) | slice(start, stop[, step])"),
    ("complex",     _BI,   "complex(real=0, imag=0) -> complex"),
    ("memoryview",  _BI,   "memoryview(object) -> memoryview"),
    ("NotImplemented",_CONST,"NotImplemented  — singleton"),
    ("Ellipsis",    _CONST,"...  — Ellipsis singleton"),
    # ── Built-in Exceptions ──────────────────────────────────
    ("Exception",           _CLS, "Exception(*args)  Base exception"),
    ("BaseException",       _CLS, "BaseException(*args)"),
    ("ArithmeticError",     _CLS, "ArithmeticError(*args)"),
    ("ValueError",          _CLS, "ValueError(*args)  Inappropriate value"),
    ("TypeError",           _CLS, "TypeError(*args)  Wrong type"),
    ("KeyError",            _CLS, "KeyError(key)  Dict key not found"),
    ("IndexError",          _CLS, "IndexError(*args)  Index out of range"),
    ("AttributeError",      _CLS, "AttributeError(*args)"),
    ("NameError",           _CLS, "NameError(*args)  Name not defined"),
    ("ImportError",         _CLS, "ImportError(*args)"),
    ("ModuleNotFoundError", _CLS, "ModuleNotFoundError(*args)"),
    ("FileNotFoundError",   _CLS, "FileNotFoundError(*args)"),
    ("FileExistsError",     _CLS, "FileExistsError(*args)"),
    ("PermissionError",     _CLS, "PermissionError(*args)"),
    ("IsADirectoryError",   _CLS, "IsADirectoryError(*args)"),
    ("RuntimeError",        _CLS, "RuntimeError(*args)"),
    ("StopIteration",       _CLS, "StopIteration(*args)"),
    ("StopAsyncIteration",  _CLS, "StopAsyncIteration(*args)"),
    ("GeneratorExit",       _CLS, "GeneratorExit(*args)"),
    ("SystemExit",          _CLS, "SystemExit(code)"),
    ("KeyboardInterrupt",   _CLS, "KeyboardInterrupt(*args)"),
    ("NotImplementedError", _CLS, "NotImplementedError(*args)"),
    ("OverflowError",       _CLS, "OverflowError(*args)"),
    ("ZeroDivisionError",   _CLS, "ZeroDivisionError(*args)"),
    ("MemoryError",         _CLS, "MemoryError(*args)"),
    ("RecursionError",      _CLS, "RecursionError(*args)"),
    ("BufferError",         _CLS, "BufferError(*args)"),
    ("EOFError",            _CLS, "EOFError(*args)"),
    ("OSError",             _CLS, "OSError(*args)"),
    ("ConnectionError",     _CLS, "ConnectionError(*args)"),
    ("TimeoutError",        _CLS, "TimeoutError(*args)"),
    ("UnicodeError",        _CLS, "UnicodeError(*args)"),
    ("UnicodeDecodeError",  _CLS, "UnicodeDecodeError(*args)"),
    ("UnicodeEncodeError",  _CLS, "UnicodeEncodeError(*args)"),
    ("AssertionError",      _CLS, "AssertionError(*args)"),
    ("LookupError",         _CLS, "LookupError(*args)"),
    ("SyntaxError",         _CLS, "SyntaxError(*args)"),
    ("IndentationError",    _CLS, "IndentationError(*args)"),
    ("TabError",            _CLS, "TabError(*args)"),
    ("SystemError",         _CLS, "SystemError(*args)"),
    ("ReferenceError",      _CLS, "ReferenceError(*args)"),
    ("Warning",             _CLS, "Warning(*args)"),
    ("DeprecationWarning",  _CLS, "DeprecationWarning(*args)"),
    ("UserWarning",         _CLS, "UserWarning(*args)"),
    # ── Snippets ─────────────────────────────────────────────
    ("__init__",     _SNIP, "def __init__(self, ...):"),
    ("__str__",      _SNIP, "def __str__(self) -> str:"),
    ("__repr__",     _SNIP, "def __repr__(self) -> str:"),
    ("__len__",      _SNIP, "def __len__(self) -> int:"),
    ("__iter__",     _SNIP, "def __iter__(self):"),
    ("__next__",     _SNIP, "def __next__(self):"),
    ("__enter__",    _SNIP, "def __enter__(self):"),
    ("__exit__",     _SNIP, "def __exit__(self, exc_type, exc_val, tb):"),
    ("__getitem__",  _SNIP, "def __getitem__(self, key):"),
    ("__setitem__",  _SNIP, "def __setitem__(self, key, value):"),
    ("__delitem__",  _SNIP, "def __delitem__(self, key):"),
    ("__contains__", _SNIP, "def __contains__(self, item) -> bool:"),
    ("__call__",     _SNIP, "def __call__(self, *args, **kwargs):"),
    ("__main__",     _SNIP, 'if __name__ == "__main__":'),
    # ── Constants ─────────────────────────────────────────────
    ("__name__",    _CONST, "__name__  str  current module name"),
    ("__file__",    _CONST, "__file__  str  path to current file"),
    ("__doc__",     _CONST, "__doc__   str  module docstring"),
    ("__all__",     _CONST, "__all__   list  public API names"),
    ("__version__", _CONST, "__version__  str  package version"),
    ("__author__",  _CONST, "__author__  str  author name"),
    ("__package__", _CONST, "__package__  str  package name"),
    ("__spec__",    _CONST, "__spec__  ModuleSpec"),
    # ── Standard library modules ──────────────────────────────
    ("os",           _MOD, "import os  — Miscellaneous OS interfaces"),
    ("os.path",      _MOD, "import os.path  — Common pathname manipulations"),
    ("sys",          _MOD, "import sys  — System-specific parameters"),
    ("re",           _MOD, "import re  — Regular expression operations"),
    ("json",         _MOD, "import json  — JSON encoder and decoder"),
    ("math",         _MOD, "import math  — Mathematical functions"),
    ("random",       _MOD, "import random  — Generate random numbers"),
    ("datetime",     _MOD, "import datetime  — Date and time types"),
    ("time",         _MOD, "import time  — Time access and conversions"),
    ("pathlib",      _MOD, "import pathlib  — Object-oriented filesystem paths"),
    ("collections",  _MOD, "import collections  — Container datatypes"),
    ("itertools",    _MOD, "import itertools  — Functional tools for iterators"),
    ("functools",    _MOD, "import functools  — Higher-order functions"),
    ("operator",     _MOD, "import operator  — Standard operators as functions"),
    ("typing",       _MOD, "import typing  — Support for type hints"),
    ("dataclasses",  _MOD, "import dataclasses  — Data Classes"),
    ("abc",          _MOD, "import abc  — Abstract Base Classes"),
    ("contextlib",   _MOD, "import contextlib  — Utilities for with-statement contexts"),
    ("io",           _MOD, "import io  — Core tools for working with streams"),
    ("copy",         _MOD, "import copy  — Shallow and deep copy"),
    ("pprint",       _MOD, "import pprint  — Data pretty printer"),
    ("string",       _MOD, "import string  — Common string operations"),
    ("textwrap",     _MOD, "import textwrap  — Text wrapping and filling"),
    ("struct",       _MOD, "import struct  — Interpret bytes as packed binary data"),
    ("enum",         _MOD, "import enum  — Support for enumerations"),
    ("threading",    _MOD, "import threading  — Thread-based parallelism"),
    ("multiprocessing",_MOD,"import multiprocessing  — Process-based parallelism"),
    ("subprocess",   _MOD, "import subprocess  — Subprocess management"),
    ("socket",       _MOD, "import socket  — Low-level networking interface"),
    ("ssl",          _MOD, "import ssl  — TLS/SSL wrapper for socket objects"),
    ("http",         _MOD, "import http  — HTTP modules"),
    ("urllib",       _MOD, "import urllib  — URL handling modules"),
    ("email",        _MOD, "import email  — Email and MIME handling package"),
    ("html",         _MOD, "import html  — HyperText Markup Language support"),
    ("xml",          _MOD, "import xml  — XML processing modules"),
    ("sqlite3",      _MOD, "import sqlite3  — DB-API 2.0 interface for SQLite"),
    ("csv",          _MOD, "import csv  — CSV File Reading and Writing"),
    ("configparser", _MOD, "import configparser  — Configuration file parser"),
    ("argparse",     _MOD, "import argparse  — Parser for command-line options"),
    ("logging",      _MOD, "import logging  — Logging facility for Python"),
    ("unittest",     _MOD, "import unittest  — Unit testing framework"),
    ("doctest",      _MOD, "import doctest  — Test interactive Python examples"),
    ("timeit",       _MOD, "import timeit  — Measure execution time of small code"),
    ("profile",      _MOD, "import profile  — Python profiler"),
    ("hashlib",      _MOD, "import hashlib  — Secure hashes and message digests"),
    ("hmac",         _MOD, "import hmac  — Keyed-Hashing for Message Authentication"),
    ("secrets",      _MOD, "import secrets  — Generate secure random numbers"),
    ("base64",       _MOD, "import base64  — Base16, Base32, Base64 encodings"),
    ("pickle",       _MOD, "import pickle  — Python object serialization"),
    ("shelve",       _MOD, "import shelve  — Python object persistence"),
    ("shutil",       _MOD, "import shutil  — High-level file operations"),
    ("glob",         _MOD, "import glob  — Unix style pathname pattern expansion"),
    ("fnmatch",      _MOD, "import fnmatch  — Unix filename pattern matching"),
    ("tempfile",     _MOD, "import tempfile  — Generate temporary files and dirs"),
    ("platform",     _MOD, "import platform  — Access to underlying platform data"),
    ("signal",       _MOD, "import signal  — Set handlers for asynchronous events"),
    ("gc",           _MOD, "import gc  — Garbage Collector interface"),
    ("inspect",      _MOD, "import inspect  — Inspect live objects"),
    ("traceback",    _MOD, "import traceback  — Print or retrieve stack traceback"),
    ("warnings",     _MOD, "import warnings  — Warning control"),
    ("weakref",      _MOD, "import weakref  — Weak references"),
    ("queue",        _MOD, "import queue  — A synchronized queue class"),
    ("asyncio",      _MOD, "import asyncio  — Asynchronous I/O"),
    ("concurrent",   _MOD, "import concurrent.futures  — Launching parallel tasks"),
    ("tkinter",      _MOD, "import tkinter  — Python interface to Tk GUI toolkit"),
    # ── Popular third-party ───────────────────────────────────
    ("numpy",        _MOD, "import numpy as np  — Numerical computing"),
    ("pandas",       _MOD, "import pandas as pd  — Data analysis and manipulation"),
    ("matplotlib",   _MOD, "import matplotlib.pyplot as plt  — Plotting"),
    ("scipy",        _MOD, "import scipy  — Scientific computing"),
    ("sklearn",      _MOD, "import sklearn  — Machine learning"),
    ("requests",     _MOD, "import requests  — HTTP for Humans"),
    ("flask",        _MOD, "import flask  — Micro web framework"),
    ("django",       _MOD, "import django  — Web framework"),
    ("fastapi",      _MOD, "import fastapi  — Modern fast web framework"),
    ("sqlalchemy",   _MOD, "import sqlalchemy  — Database toolkit"),
    ("pytest",       _MOD, "import pytest  — Testing framework"),
    ("PIL",          _MOD, "from PIL import Image  — Pillow image processing"),
    ("cv2",          _MOD, "import cv2  — OpenCV computer vision"),
    ("torch",        _MOD, "import torch  — PyTorch deep learning"),
    ("tensorflow",   _MOD, "import tensorflow as tf  — TensorFlow"),
    ("pydantic",     _MOD, "import pydantic  — Data validation"),
    ("aiohttp",      _MOD, "import aiohttp  — Async HTTP client/server"),
    ("boto3",        _MOD, "import boto3  — AWS SDK for Python"),
    ("paramiko",     _MOD, "import paramiko  — SSH protocol library"),
    ("cryptography", _MOD, "import cryptography  — Cryptographic recipes"),
    ("rich",         _MOD, "import rich  — Rich text and formatting in terminal"),
    ("click",        _MOD, "import click  — Command line interface creation"),
    ("celery",       _MOD, "import celery  — Distributed task queue"),
    ("redis",        _MOD, "import redis  — Python client for Redis"),
    ("pymongo",      _MOD, "import pymongo  — MongoDB driver"),
]

# ── kind icon + color ──────────────────────────────────────
KIND = {
    _KW:    ("$(symbol-keyword)",  VS["ic_kw"],   "keyword"),
    _BI:    ("$(symbol-function)", VS["ic_fn"],   "function"),
    _CLS:   ("$(symbol-class)",    VS["ic_cls"],  "class"),
    _SNIP:  ("$(symbol-snippet)",  VS["ic_snip"], "snippet"),
    _MOD:   ("$(symbol-module)",   VS["ic_mod"],  "module"),
    _CONST: ("$(symbol-constant)", VS["ic_const"],"constant"),
}
KIND_ICON_CHAR = {
    _KW:    "K", _BI: "F", _CLS: "C", _SNIP: "S", _MOD: "M", _CONST: "V",
}


# ╔══════════════════════════════════════════════════════════╗
#  SYNTAX HIGHLIGHTER
# ╚══════════════════════════════════════════════════════════╝
class Highlighter:
    RULES = [
        ("doc",  r'("""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\')'),
        ("str_", r'(f?"(?:[^"\\]|\\.)*"|f?\'(?:[^\'\\]|\\.)*\')'),
        ("cmt",  r'(#[^\n]*)'),
        ("dec",  r'(@[\w.]+)'),
        ("kw2",  r'\b(class|def|lambda|return|yield|import|from|as|with|async|await|raise|pass|del|global|nonlocal)\b'),
        ("kw",   r'\b(False|None|True|and|assert|break|continue|elif|else|except|finally|for|if|in|is|not|or|try|while)\b'),
        ("cls_n",r'\bclass\s+(\w+)'),
        ("fn_n", r'\bdef\s+(\w+)'),
        ("bi",   r'\b(print|len|range|int|str|float|list|dict|tuple|set|bool|type|input|open|enumerate|zip|map|filter|sorted|reversed|sum|min|max|abs|round|pow|divmod|repr|hash|id|hex|oct|bin|chr|ord|format|super|object|isinstance|issubclass|hasattr|getattr|setattr|delattr|callable|dir|vars|globals|locals|any|all|next|iter|exec|eval|compile|staticmethod|classmethod|property|slice|complex|bytes|bytearray|frozenset|memoryview)\b'),
        ("slf",  r'\b(self|cls)\b'),
        ("num",  r'\b(0x[0-9a-fA-F]+|0b[01]+|0o[0-7]+|\d+\.?\d*([eE][+-]?\d+)?[jJ]?)\b'),
        ("op",   r'(->|:=|==|!=|<=|>=|\*\*|//|[+\-*/%&|^~<>=!])'),
    ]
    TAG_COLOR = {
        "kw": VS["kw"], "kw2": VS["kw2"], "bi": VS["bi"],
        "str_": VS["str_"], "doc": VS["doc"], "cmt": VS["cmt"],
        "num": VS["num"], "dec": VS["dec"], "cls_n": VS["cls_n"],
        "fn_n": VS["fn_n"], "slf": VS["slf"], "op": VS["op"],
    }

    def __init__(self, w):
        self.w = w
        for tag, color in self.TAG_COLOR.items():
            self.w.tag_configure(tag, foreground=color)
        self.w.tag_configure("err_ln", background=VS["err_line"])
        self.w.tag_configure("find_hl", background="#623315", foreground="#ffffff")
        self.w.tag_configure("cur_line", background=VS["line_hl"])
        self._job = None

    def schedule(self, *_):
        if self._job: self.w.after_cancel(self._job)
        self._job = self.w.after(80, self._run)

    def _run(self):
        c = self.w.get("1.0", "end-1c")
        for tag in self.TAG_COLOR:
            self.w.tag_remove(tag, "1.0", "end")
        for tag, pat in self.RULES:
            g = 1 if tag in ("cls_n", "fn_n") else 0
            for m in re.finditer(pat, c):
                try:
                    self.w.tag_add(tag, self._p(c, m.start(g)), self._p(c, m.end(g)))
                except: pass

    def _p(self, c, off):
        ln  = c[:off].count("\n") + 1
        col = off - c[:off].rfind("\n") - 1
        return f"{ln}.{col}"

    def mark_err(self, ln):
        self.w.tag_remove("err_ln", "1.0", "end")
        if ln: self.w.tag_add("err_ln", f"{ln}.0", f"{ln}.end+1c")

    def clr_err(self): self.w.tag_remove("err_ln", "1.0", "end")


# ╔══════════════════════════════════════════════════════════╗
#  LINE NUMBER GUTTER
# ╚══════════════════════════════════════════════════════════╝
class Gutter(tk.Canvas):
    W = 58
    def __init__(self, parent, tw):
        super().__init__(parent, width=self.W,
                         bg=VS["editor_gutter"], highlightthickness=0)
        self.tw = tw
        for ev in ("<KeyRelease>","<MouseWheel>","<Button-4>","<Button-5>",
                   "<<Change>>","<Configure>","<ButtonRelease>"):
            tw.bind(ev, self.redraw, add=True)

    def redraw(self, *_):
        self.delete("all")
        cur = self.tw.index("insert").split(".")[0]
        i = self.tw.index("@0,0")
        while True:
            dl = self.tw.dlineinfo(i)
            if dl is None: break
            ln = int(str(i).split(".")[0])
            fg = VS["fg_line_cur"] if str(ln) == cur else VS["fg_line"]
            self.create_text(self.W - 10, dl[1] + 2, anchor="ne",
                             text=str(ln), fill=fg, font=("Consolas", 12))
            nx = self.tw.index(f"{i}+1line")
            if nx == i: break
            i = nx


# ╔══════════════════════════════════════════════════════════╗
#  INTELLISENSE  POPUP  —  real VS Code style
# ╚══════════════════════════════════════════════════════════╝
class IntelliSense:
    PW  = 480   # popup width
    RH  = 22    # row height
    VIS = 12    # visible rows
    DH  = 68    # detail panel height

    def __init__(self, tw, root):
        self.tw     = tw
        self.root   = root
        self.win    = None
        self.cvs    = None
        self.det    = None
        self.items  = []   # list of (label, kind, detail)
        self.sel    = 0
        self._job   = None
        self.active = False
        # bind every printable key release
        tw.bind("<KeyRelease>",  self._on_key_release)
        tw.bind("<Escape>",      self.hide)
        tw.bind("<FocusOut>",    self.hide)

    # ── word under cursor ────────────────────────────────
    def _cur_word(self):
        idx  = self.tw.index("insert")
        row, col = idx.split(".")
        line = self.tw.get(f"{row}.0", idx)
        m = re.search(r'[\w.]*$', line)
        return m.group().lstrip(".") if m else ""

    # ── trigger after every key ──────────────────────────
    def _on_key_release(self, event):
        sym = event.keysym
        # navigation keys that should not retrigger
        if sym in ("Escape","Up","Down","Return","Tab",
                   "Left","Right","Home","End","Prior","Next",
                   "Shift_L","Shift_R","Control_L","Control_R",
                   "Alt_L","Alt_R","F1","F2","F3","F4","F5",
                   "F6","F7","F8","F9","F10","F11","F12"):
            return
        # hide on backspace/delete if word becomes empty
        if sym in ("BackSpace", "Delete"):
            if len(self._cur_word()) < 1:
                self.hide(); return
        # schedule compute
        if self._job: self.tw.after_cancel(self._job)
        self._job = self.tw.after(60, self._compute)

    def _compute(self):
        word = self._cur_word()
        if not word:
            self.hide(); return
        wl = word.lower()
        # build ranked matches
        prefix, substr = [], []
        seen = set()
        for label, kind, detail in COMPLETIONS:
            ll = label.lower()
            if ll == wl:
                continue   # exact match — no popup needed
            if ll.startswith(wl) and label not in seen:
                prefix.append((label, kind, detail))
                seen.add(label)
        for label, kind, detail in COMPLETIONS:
            if label not in seen and wl in label.lower():
                substr.append((label, kind, detail))
                seen.add(label)
        # sort by length within each group so shortest match comes first
        prefix.sort(key=lambda x: len(x[0]))
        substr.sort(key=lambda x: len(x[0]))
        matches = (prefix + substr)[:20]
        if not matches:
            self.hide(); return
        self.items = matches
        self.sel   = 0
        self._show_popup()

    # ── popup window ─────────────────────────────────────
    def _show_popup(self):
        if not self.win or not self.win.winfo_exists():
            self._build_popup()
        self._reposition()
        self._render()
        self.active = True

    def _build_popup(self):
        self.win = tk.Toplevel(self.root)
        self.win.wm_overrideredirect(True)
        self.win.configure(bg=VS["ac_bg"])
        self.win.attributes("-topmost", True)

        # list canvas
        ch = self.RH * self.VIS
        outer = tk.Frame(self.win, bg=VS["ac_border"], bd=1, relief="flat")
        outer.pack(fill="both", expand=True)
        self.cvs = tk.Canvas(outer, bg=VS["ac_bg"],
                             highlightthickness=0,
                             width=self.PW, height=ch)
        self.sb = tk.Scrollbar(outer, orient="vertical",
                                command=self.cvs.yview,
                                bg=VS["scrollbar"], troughcolor=VS["ac_bg"],
                                width=8, relief="flat", bd=0)
        self.cvs.configure(yscrollcommand=self.sb.set)
        self.sb.pack(side="right", fill="y")
        self.cvs.pack(fill="both", expand=True)

        # detail panel
        self.det = tk.Label(self.win, bg=VS["ac_detail"],
                            fg=VS["fg_dim"],
                            font=("Consolas", 10),
                            anchor="w", justify="left",
                            padx=12, pady=6,
                            wraplength=self.PW - 20,
                            height=3)
        tk.Frame(self.win, bg=VS["ac_border"], height=1).pack(fill="x")
        self.det.pack(fill="x")

        self.cvs.bind("<Button-1>", self._click)

        # attach nav keys to text widget
        self.tw.bind("<Down>",   self._nav_down)
        self.tw.bind("<Up>",     self._nav_up)
        self.tw.bind("<Return>", self._accept_key)
        self.tw.bind("<Tab>",    self._accept_key)

    def _reposition(self):
        try:
            bx, by, _, bh = self.tw.bbox("insert")
        except:
            return
        rx = self.tw.winfo_rootx() + bx
        ry = self.tw.winfo_rooty() + by + bh + 2
        list_h = self.RH * self.VIS
        total  = list_h + self.DH + 2
        sw = self.root.winfo_screenwidth()
        sh = self.root.winfo_screenheight()
        if rx + self.PW > sw: rx = sw - self.PW - 4
        if ry + total   > sh: ry = self.tw.winfo_rooty() + by - total - 2
        self.win.geometry(f"{self.PW}x{total}+{max(0,rx)}+{max(0,ry)}")
        self.win.lift()

    def _render(self):
        self.cvs.delete("all")
        total_h = max(len(self.items) * self.RH, self.RH * self.VIS)
        self.cvs.configure(scrollregion=(0, 0, self.PW, total_h))

        for i, (label, kind, detail) in enumerate(self.items):
            y0 = i * self.RH
            y1 = y0 + self.RH
            bg = VS["ac_sel"] if i == self.sel else VS["ac_bg"]
            # row bg
            self.cvs.create_rectangle(0, y0, self.PW, y1, fill=bg, outline="")

            # kind icon box  (colored square like VS Code)
            icon_char  = KIND_ICON_CHAR.get(kind, "?")
            _, ic_col, klbl = KIND.get(kind, ("?", VS["fg_dim"], ""))
            # colored square
            self.cvs.create_rectangle(6, y0+3, 20, y1-3,
                                      fill=ic_col, outline="")
            self.cvs.create_text(13, y0 + self.RH//2, text=icon_char,
                                 fill="#000000", font=("Consolas", 9, "bold"),
                                 anchor="center")
            # label
            self.cvs.create_text(28, y0 + self.RH//2,
                                 text=label,
                                 fill=VS["fg"] if i == self.sel else VS["ac_fg"],
                                 font=("Consolas", 12),
                                 anchor="w")
            # kind badge right
            self.cvs.create_text(self.PW - 8, y0 + self.RH//2,
                                 text=klbl,
                                 fill=VS["fg_dim"],
                                 font=("Consolas", 10),
                                 anchor="e")

        # scroll selected row into view
        if self.items:
            frac = (self.sel * self.RH) / max(total_h, 1)
            self.cvs.yview_moveto(frac)
            # detail
            label, kind, detail = self.items[self.sel]
            self.det.config(text=f"  {detail}")

    def _nav_down(self, event):
        if not self.active: return
        self.sel = (self.sel + 1) % len(self.items)
        self._render()
        return "break"

    def _nav_up(self, event):
        if not self.active: return
        self.sel = (self.sel - 1) % len(self.items)
        self._render()
        return "break"

    def _accept_key(self, event):
        if not self.active: return "break"
        self._do_accept()
        return "break"

    def _click(self, event):
        row = event.y // self.RH
        if 0 <= row < len(self.items):
            self.sel = row
            self._do_accept()

    def _do_accept(self):
        if not self.items: return
        label = self.items[self.sel][0]
        word  = self._cur_word()
        cur   = self.tw.index("insert")
        r, c  = cur.split(".")
        start = f"{r}.{int(c) - len(word)}"
        self.tw.delete(start, cur)
        self.tw.insert(start, label)
        self.hide()

    def hide(self, *_):
        self.active = False
        # restore normal bindings
        self.tw.bind("<Down>",   lambda e: None)
        self.tw.bind("<Up>",     lambda e: None)
        self.tw.bind("<Return>", lambda e: None)
        self.tw.bind("<Tab>",    self._tab_spaces)
        if self.win and self.win.winfo_exists():
            self.win.destroy()
            self.win = None; self.cvs = None; self.det = None

    def _tab_spaces(self, e):
        self.tw.insert("insert", "    ")
        return "break"


# ╔══════════════════════════════════════════════════════════╗
#  EDITOR TAB
# ╚══════════════════════════════════════════════════════════╝
class EditorTab:
    def __init__(self, nb, root, fn=None):
        self.nb   = nb
        self.root = root
        self.fn   = fn
        self.mod  = False
        self.frame = tk.Frame(nb, bg=VS["editor"])
        nb.add(self.frame, text=self._lbl())

        # layout: gutter | editor
        row = tk.Frame(self.frame, bg=VS["editor"])
        row.pack(fill="both", expand=True)

        self.tw = tk.Text(
            row,
            bg=VS["editor"],     fg=VS["fg"],
            insertbackground="#aeafad",
            selectbackground=VS["selection"],
            selectforeground=VS["fg"],
            font=("Consolas", 13),
            relief="flat", bd=0,
            wrap="none",
            undo=True, maxundo=500,
            padx=8, pady=4,
            highlightthickness=0,
            spacing1=1, spacing3=1,
            exportselection=True,
        )
        self.gut = Gutter(row, self.tw)
        self.gut.pack(side="left", fill="y")

        sy = tk.Scrollbar(row,          orient="vertical",
                          command=self.tw.yview,
                          bg=VS["scrollbar"], troughcolor=VS["editor"],
                          width=10, relief="flat", bd=0)
        sx = tk.Scrollbar(self.frame, orient="horizontal",
                          command=self.tw.xview,
                          bg=VS["scrollbar"], troughcolor=VS["editor"],
                          width=10, relief="flat", bd=0)
        self.tw.configure(yscrollcommand=sy.set, xscrollcommand=sx.set)
        sy.pack(side="right", fill="y")
        self.tw.pack(side="left", fill="both", expand=True)
        sx.pack(fill="x")

        self.hl = Highlighter(self.tw)
        self.ac = IntelliSense(self.tw, root)

        self.tw.bind("<KeyRelease>",    self._changed)
        self.tw.bind("<Tab>",           self._tab)
        self.tw.bind("<Return>",        self._indent)
        self.tw.bind("<BackSpace>",     self._bs)
        self.tw.bind("<Control-z>",     lambda e: (self.tw.edit_undo(), "break")[1])
        self.tw.bind("<Control-y>",     lambda e: (self.tw.edit_redo(), "break")[1])
        self.tw.bind("<Control-slash>", self._comment)
        self.tw.bind("<Control-d>",     self._dup_line)
        # auto-pair
        for o, c in [("(",")"),('"','"'),("'","'"),("[","]"),("{","}")]:
            self.tw.bind(o, lambda e, o=o, c=c: self._pair(o, c))

        if fn and os.path.exists(fn):
            self._load()

    def _lbl(self):
        return f"  {os.path.basename(self.fn) if self.fn else 'Untitled'}  "

    def _load(self):
        try:
            txt = Path(self.fn).read_text(encoding="utf-8")
            self.tw.delete("1.0", "end")
            self.tw.insert("1.0", txt)
            self.hl._run(); self.gut.redraw()
            self.mod = False
        except Exception as ex: messagebox.showerror("Error", str(ex))

    def save(self):
        if not self.fn:
            self.fn = filedialog.asksaveasfilename(
                defaultextension=".py",
                filetypes=[("Python","*.py"),("All files","*.*")])
            if not self.fn: return False
        try:
            Path(self.fn).write_text(self.tw.get("1.0","end-1c"), encoding="utf-8")
            self.mod = False
            self.nb.tab(self.frame, text=self._lbl())
            return True
        except Exception as ex:
            messagebox.showerror("Error", str(ex)); return False

    def content(self): return self.tw.get("1.0","end-1c")

    def _changed(self, *_):
        self.hl.schedule(); self.gut.redraw()
        if not self.mod:
            self.mod = True
            n = os.path.basename(self.fn) if self.fn else "Untitled"
            self.nb.tab(self.frame, text=f"  ● {n}  ")

    def _tab(self, e):
        try:
            sl = self.tw.index("sel.first linestart")
            el = self.tw.index("sel.last lineend")
            for ln in range(int(sl.split(".")[0]), int(el.split(".")[0])+1):
                self.tw.insert(f"{ln}.0", "    ")
        except tk.TclError:
            self.tw.insert("insert", "    ")
        return "break"

    def _indent(self, e):
        idx  = self.tw.index("insert")
        ln   = idx.split(".")[0]
        line = self.tw.get(f"{ln}.0", f"{ln}.end")
        ind  = re.match(r'^(\s*)', line).group(1)
        extra = "    " if line.rstrip().endswith(":") else ""
        self.tw.insert("insert", "\n" + ind + extra)
        self.gut.redraw(); return "break"

    def _bs(self, e):
        idx = self.tw.index("insert"); r, c = idx.split(".")
        if int(c) >= 4 and self.tw.get(f"{r}.{int(c)-4}", idx) == "    ":
            self.tw.delete(f"{r}.{int(c)-4}", idx); return "break"

    def _pair(self, o, c):
        if o == c:  # quotes
            self.tw.insert("insert", o + c)
            self.tw.mark_set("insert", "insert-1c"); return "break"
        self.tw.insert("insert", o + c)
        self.tw.mark_set("insert", "insert-1c"); return "break"

    def _comment(self, e=None):
        try:   s=self.tw.index("sel.first linestart"); en=self.tw.index("sel.last lineend")
        except: s=self.tw.index("insert linestart");   en=self.tw.index("insert lineend")
        lines   = self.tw.get(s, en).split("\n")
        all_c   = all(l.lstrip().startswith("#") for l in lines if l.strip())
        new     = [re.sub(r'^(\s*)# ?',r'\1',l,1) if all_c
                   else re.sub(r'^(\s*)',r'\1# ',l,1) for l in lines]
        self.tw.delete(s, en); self.tw.insert(s, "\n".join(new)); return "break"

    def _dup_line(self, e=None):
        idx = self.tw.index("insert"); ln = idx.split(".")[0]
        line = self.tw.get(f"{ln}.0", f"{ln}.end")
        self.tw.insert(f"{ln}.end", "\n" + line); return "break"


# ╔══════════════════════════════════════════════════════════╗
#  TERMINAL  POPUP  WINDOW
# ╚══════════════════════════════════════════════════════════╝
class Terminal:
    ANSI = re.compile(r'\x1b\[[0-9;]*m')

    def __init__(self, root):
        self.root = root; self.proc = None; self.win = None

    def show(self):
        if self.win and self.win.winfo_exists():
            self.win.lift(); self.win.focus_force(); return
        self.win = tk.Toplevel(self.root)
        self.win.title("Terminal — Kavin IDE")
        self.win.geometry("860x380")
        self.win.configure(bg=VS["panel"])
        rx = self.root.winfo_x() + self.root.winfo_width()//2 - 430
        ry = self.root.winfo_y() + self.root.winfo_height()//2 - 190
        self.win.geometry(f"860x380+{max(0,rx)}+{max(0,ry)}")

        # header
        hdr = tk.Frame(self.win, bg=VS["panel_hdr"], height=30)
        hdr.pack(fill="x"); hdr.pack_propagate(False)
        tk.Label(hdr, text="  TERMINAL", bg=VS["panel_hdr"],
                 fg=VS["fg_dim"], font=("Segoe UI",9,"bold")).pack(side="left", pady=5, padx=6)
        for txt, fg_, cmd in [
            ("✕", "#f48771", lambda: self.win.destroy()),
            ("⏹", VS["fg_dim"], self.stop),
            ("🗑", VS["fg_muted"], self.clear),
        ]:
            b = tk.Button(hdr, text=txt, bg=VS["panel_hdr"], fg=fg_,
                          activebackground=VS["hover"], activeforeground=fg_,
                          relief="flat", font=("Segoe UI",10), cursor="hand2",
                          bd=0, padx=8, command=cmd)
            b.pack(side="right", pady=3)
        tk.Frame(self.win, bg=VS["border"], height=1).pack(fill="x")

        # output
        of = tk.Frame(self.win, bg=VS["panel"]); of.pack(fill="both", expand=True)
        self.out = tk.Text(of, bg=VS["panel"], fg=VS["fg"],
                           font=("Consolas",12), relief="flat",
                           state="disabled", wrap="word",
                           padx=14, pady=8, highlightthickness=0)
        sb_ = tk.Scrollbar(of, command=self.out.yview,
                           bg=VS["scrollbar"], troughcolor=VS["panel"],
                           width=8, relief="flat", bd=0)
        self.out.configure(yscrollcommand=sb_.set)
        sb_.pack(side="right", fill="y"); self.out.pack(fill="both", expand=True)

        self.out.tag_configure("err",  foreground=VS["err_fg"])
        self.out.tag_configure("ok",   foreground="#4ec9b0")
        self.out.tag_configure("info", foreground="#569cd6")
        self.out.tag_configure("dim",  foreground=VS["fg_muted"])
        self.out.tag_configure("prm",  foreground="#dcdcaa")

        # stdin
        ir = tk.Frame(self.win, bg="#141414"); ir.pack(fill="x")
        tk.Label(ir, text="  > ", bg="#141414", fg="#4ec9b0",
                 font=("Consolas",11)).pack(side="left")
        self.svar = tk.StringVar()
        ent = tk.Entry(ir, textvariable=self.svar,
                       bg="#141414", fg=VS["fg"],
                       insertbackground=VS["fg"],
                       relief="flat", font=("Consolas",12),
                       highlightthickness=0)
        ent.pack(fill="x", expand=True, padx=6, pady=5)
        ent.bind("<Return>", self._send)

        self._w("Kavin IDE  Terminal\n", "info")
        self._w("─" * 54 + "\n", "dim")

    def _w(self, text, tag=None):
        if not self.win or not self.win.winfo_exists(): return
        text = self.ANSI.sub("", text)
        self.out.configure(state="normal")
        if tag: self.out.insert("end", text, tag)
        else:   self.out.insert("end", text)
        self.out.see("end"); self.out.configure(state="disabled")

    def run(self, code, fn=None, on_err=None):
        self.show(); self.stop(); self.clear()
        label = os.path.basename(fn) if fn else "untitled.py"
        self._w(f"▶  {label}\n", "prm")
        self._w("─" * 54 + "\n", "dim")

        if fn and os.path.exists(fn):
            script, cwd = fn, os.path.dirname(fn) or "."
        else:
            tmp = tempfile.NamedTemporaryFile(suffix=".py", delete=False,
                                              mode="w", encoding="utf-8")
            tmp.write(code); tmp.flush(); tmp.close()
            script, cwd = tmp.name, os.getcwd()

        def worker():
            t0 = time.time()
            try:
                self.proc = subprocess.Popen(
                    [sys.executable, "-u", script],
                    stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                    stdin=subprocess.PIPE, text=True, cwd=cwd, bufsize=1)
                for line in iter(self.proc.stdout.readline, ""):
                    if self.win and self.win.winfo_exists():
                        self.win.after(0, self._w, line)
                err = self.proc.stderr.read()
                if err:
                    if self.win and self.win.winfo_exists():
                        self.win.after(0, self._w, "\n" + err, "err")
                    m = re.search(r'line (\d+)', err)
                    if on_err and self.win and self.win.winfo_exists():
                        self.win.after(0, on_err, int(m.group(1)) if m else None)
                else:
                    if on_err and self.win and self.win.winfo_exists():
                        self.win.after(0, on_err, None)
                self.proc.wait()
                rc = self.proc.returncode; el = time.time() - t0
                if self.win and self.win.winfo_exists():
                    self.win.after(0, self._w, "─" * 54 + "\n", "dim")
                    msg = f"✓ Exit {rc}  ({el:.2f}s)\n"
                    self.win.after(0, self._w, msg, "ok" if rc == 0 else "err")
            except Exception as ex:
                if self.win and self.win.winfo_exists():
                    self.win.after(0, self._w, f"Error: {ex}\n", "err")
            finally: self.proc = None

        threading.Thread(target=worker, daemon=True).start()

    def _send(self, *_):
        if self.proc and self.proc.stdin:
            try:
                t = self.svar.get() + "\n"
                self.proc.stdin.write(t); self.proc.stdin.flush()
                self._w(f"  {t}", "prm"); self.svar.set("")
            except: pass

    def stop(self):
        if self.proc:
            try: self.proc.terminate()
            except: pass

    def clear(self):
        if not self.win or not self.win.winfo_exists(): return
        self.out.configure(state="normal"); self.out.delete("1.0","end")
        self.out.configure(state="disabled")


# ╔══════════════════════════════════════════════════════════╗
#  FILE  EXPLORER
# ╚══════════════════════════════════════════════════════════╝
FICONS = {".py":"🐍",".txt":"📄",".json":"{}",".md":"📝",
          ".csv":"📊",".html":"🌐",".css":"🎨",".js":"⚡",
          ".sh":"⚙",".toml":"⚙",".yml":"⚙",".yaml":"⚙",
          ".png":"🖼",".jpg":"🖼",".gif":"🖼",".xml":"📋",
          ".ts":"⚡",".tsx":"⚡",".jsx":"⚡",".vue":"🌐"}

class Explorer(tk.Frame):
    def __init__(self, parent, on_open):
        super().__init__(parent, bg=VS["sidebar"])
        self.on_open = on_open
        self.rpath   = None
        self._build()

    def _build(self):
        # project header
        self.hdr = tk.Label(self, text="  EXPLORER",
                            bg=VS["sidebar"], fg=VS["fg_dim"],
                            font=("Segoe UI", 9, "bold"), pady=8, anchor="w")
        self.hdr.pack(fill="x", padx=4)

        # action buttons row
        br = tk.Frame(self, bg=VS["sidebar"]); br.pack(fill="x", padx=6, pady=(0,4))

        def mkbtn(txt, cmd, tooltip=""):
            b = tk.Button(br, text=txt, bg=VS["sidebar"],
                          fg=VS["fg_dim"],
                          activebackground=VS["hover"],
                          activeforeground=VS["fg"],
                          relief="flat", font=("Segoe UI", 9),
                          cursor="hand2", bd=0, padx=6, pady=3,
                          command=cmd)
            b.pack(side="left", padx=1)
            b.bind("<Enter>", lambda e: b.configure(fg=VS["fg"]))
            b.bind("<Leave>", lambda e: b.configure(fg=VS["fg_dim"]))
            return b

        mkbtn("🗁  Open Folder",  self._open_folder)
        mkbtn("📄  Open File",    self._open_file_dlg)
        mkbtn("📄+",              self._new_file, "New File")

        tk.Frame(self, bg=VS["border"], height=1).pack(fill="x")

        # treeview
        s = ttk.Style()
        s.configure("Exp.Treeview",
                    background=VS["sidebar"], foreground=VS["fg_sidebar"],
                    fieldbackground=VS["sidebar"], borderwidth=0,
                    rowheight=22, font=("Segoe UI", 10))
        s.map("Exp.Treeview",
              background=[("selected","#094771")],
              foreground=[("selected","#ffffff")])

        fr = tk.Frame(self, bg=VS["sidebar"]); fr.pack(fill="both", expand=True)
        self.tree = ttk.Treeview(fr, show="tree", style="Exp.Treeview", selectmode="browse")
        sb_ = tk.Scrollbar(fr, command=self.tree.yview,
                           bg=VS["scrollbar"], troughcolor=VS["sidebar"],
                           width=8, relief="flat", bd=0)
        self.tree.configure(yscrollcommand=sb_.set)
        sb_.pack(side="right", fill="y"); self.tree.pack(fill="both", expand=True)

        self.tree.bind("<Double-1>",        self._dbl)
        self.tree.bind("<Return>",          self._dbl)
        self.tree.bind("<<TreeviewOpen>>",  self._expand)
        self.tree.bind("<Button-3>",        self._ctx_menu)

        # right-click context menu
        self.ctx = tk.Menu(self, tearoff=0,
                           bg=VS["dropdown"], fg=VS["fg"],
                           activebackground=VS["dropdown_sel"],
                           activeforeground="#ffffff",
                           relief="flat", bd=0, font=("Segoe UI",9))
        self.ctx.add_command(label="  New File",    command=self._new_file)
        self.ctx.add_command(label="  New Folder",  command=self._new_folder)
        self.ctx.add_separator()
        self.ctx.add_command(label="  Rename",      command=self._rename)
        self.ctx.add_command(label="  Delete",      command=self._delete)

    def _sel_folder(self):
        sel = self.tree.selection()
        if sel:
            v = self.tree.item(sel[0])["values"]
            if v:
                p = str(v[0])
                return p if os.path.isdir(p) else os.path.dirname(p)
        return self.rpath

    def _open_folder(self):
        p = filedialog.askdirectory(title="Open Folder")
        if p: self.load(p)

    def _open_file_dlg(self):
        p = filedialog.askopenfilename(title="Open File",
            filetypes=[("Python","*.py"),("All","*.*")])
        if p: self.on_open(p)

    def _new_file(self):
        folder = self._sel_folder()
        if not folder: messagebox.showinfo("Kavin IDE","Open a folder first."); return
        name = simpledialog.askstring("New File", "File name:",
                                      initialvalue="new_file.py", parent=self)
        if not name: return
        path = os.path.join(folder, name)
        if os.path.exists(path): messagebox.showerror("Error",f"'{name}' already exists."); return
        try: Path(path).write_text("", encoding="utf-8"); self._refresh(); self.on_open(path)
        except Exception as ex: messagebox.showerror("Error", str(ex))

    def _new_folder(self):
        folder = self._sel_folder()
        if not folder: messagebox.showinfo("Kavin IDE","Open a folder first."); return
        name = simpledialog.askstring("New Folder","Folder name:",
                                      initialvalue="new_folder", parent=self)
        if not name: return
        try: os.makedirs(os.path.join(folder, name), exist_ok=True); self._refresh()
        except Exception as ex: messagebox.showerror("Error", str(ex))

    def _rename(self):
        sel = self.tree.selection()
        if not sel: return
        v = self.tree.item(sel[0])["values"]
        if not v: return
        old = str(v[0]); oname = os.path.basename(old)
        nname = simpledialog.askstring("Rename","New name:",
                                       initialvalue=oname, parent=self)
        if not nname or nname == oname: return
        try: os.rename(old, os.path.join(os.path.dirname(old), nname)); self._refresh()
        except Exception as ex: messagebox.showerror("Error", str(ex))

    def _delete(self):
        sel = self.tree.selection()
        if not sel: return
        v = self.tree.item(sel[0])["values"]
        if not v: return
        path = str(v[0]); name = os.path.basename(path)
        if not messagebox.askyesno("Delete", f"Delete '{name}'?\nThis cannot be undone."): return
        try:
            import shutil
            shutil.rmtree(path) if os.path.isdir(path) else os.remove(path)
            self._refresh()
        except Exception as ex: messagebox.showerror("Error", str(ex))

    def _ctx_menu(self, event):
        item = self.tree.identify_row(event.y)
        if item: self.tree.selection_set(item)
        try: self.ctx.tk_popup(event.x_root, event.y_root)
        finally: self.ctx.grab_release()

    def _refresh(self):
        if self.rpath: self.load(self.rpath)

    def load(self, path):
        self.rpath = path
        self.hdr.config(text=f"  {os.path.basename(path).upper()}")
        self.tree.delete(*self.tree.get_children())
        n = self.tree.insert("","end", text=f"  📁 {os.path.basename(path)}",
                             open=True, values=[path,"dir"])
        self._fill(n, path)

    def _fill(self, parent, path):
        try:
            entries = sorted(os.scandir(path),
                             key=lambda e: (not e.is_dir(), e.name.lower()))
            for e in entries:
                if e.name.startswith(".") or e.name in (
                        "__pycache__","node_modules",".git","venv",".env",
                        "dist","build",".DS_Store","Thumbs.db"):
                    continue
                if e.is_dir():
                    n = self.tree.insert(parent,"end",
                                         text=f"  📁 {e.name}",
                                         values=[e.path,"dir"])
                    self.tree.insert(n,"end",text="")  # placeholder
                else:
                    icon = FICONS.get(Path(e.name).suffix, "📄")
                    self.tree.insert(parent,"end",
                                     text=f"  {icon} {e.name}",
                                     values=[e.path,"file"])
        except PermissionError: pass

    def _expand(self, event):
        node = self.tree.focus()
        ch   = self.tree.get_children(node)
        if len(ch)==1 and self.tree.item(ch[0])["text"]=="":
            self.tree.delete(ch[0])
            self._fill(node, str(self.tree.item(node)["values"][0]))

    def _dbl(self, event=None):
        sel = self.tree.selection()
        if not sel: return
        v = self.tree.item(sel[0])["values"]
        if v and str(v[1])=="file": self.on_open(str(v[0]))
        elif v and str(v[1])=="dir": self._expand(None)


# ╔══════════════════════════════════════════════════════════╗
#  ACTIVITY  BAR  (VS Code left icon strip)
# ╚══════════════════════════════════════════════════════════╝
class ActivityBar(tk.Frame):
    ITEMS = [
        ("files",   "⎘",  "Explorer"),
        ("search",  "⌕",  "Search"),
        ("run",     "▶",  "Run"),
        ("settings","⚙",  "Settings"),
    ]
    def __init__(self, parent, on_select):
        super().__init__(parent, bg=VS["activity"], width=46)
        self.pack_propagate(False)
        self._on_select = on_select
        self._active = "files"
        self._btns = {}
        for name, icon, tip in self.ITEMS:
            b = tk.Label(self, text=icon, bg=VS["activity"],
                         fg="#858585", font=("Segoe UI",18),
                         pady=12, cursor="hand2")
            b.pack(fill="x")
            b.bind("<Button-1>", lambda e, n=name: self._click(n))
            b.bind("<Enter>",    lambda e, btn=b: btn.configure(fg="#cccccc"))
            b.bind("<Leave>",    lambda e, btn=b, n=name:
                   btn.configure(fg="#cccccc" if self._active==n else "#858585"))
            self._btns[name] = b
        self._set_active("files")

    def _click(self, name):
        self._set_active(name)
        self._on_select(name)

    def _set_active(self, name):
        if self._active in self._btns:
            self._btns[self._active].configure(fg="#858585")
        self._active = name
        self._btns[name].configure(fg="#cccccc")


# ╔══════════════════════════════════════════════════════════╗
#  STATUS BAR
# ╚══════════════════════════════════════════════════════════╝
class StatusBar(tk.Frame):
    def __init__(self, parent):
        super().__init__(parent, bg=VS["statusbar"], height=22)
        self.pack_propagate(False)
        # left side
        tk.Label(self, text="  ⎇ main", bg=VS["statusbar"], fg="#ffffff",
                 font=("Segoe UI",9), padx=4).pack(side="left")
        self.err_lbl = tk.Label(self, text="", bg=VS["statusbar"], fg="#ffffff",
                                font=("Segoe UI",9))
        self.err_lbl.pack(side="left", padx=8)
        # right side
        self.pos_lbl = tk.Label(self, text="Ln 1, Col 1",
                                bg=VS["statusbar"], fg="#ffffff",
                                font=("Segoe UI",9))
        self.pos_lbl.pack(side="right", padx=10)
        self.lang_lbl = tk.Label(self, text="Python",
                                 bg=VS["statusbar"], fg="#ffffff",
                                 font=("Segoe UI",9))
        self.lang_lbl.pack(side="right", padx=10)
        tk.Label(self, text="UTF-8  LF",
                 bg=VS["statusbar"], fg="#ffffff",
                 font=("Segoe UI",9)).pack(side="right", padx=10)
        tk.Label(self, text="Spaces: 4",
                 bg=VS["statusbar"], fg="#ffffff",
                 font=("Segoe UI",9)).pack(side="right", padx=10)

    def set_pos(self, ln, col): self.pos_lbl.config(text=f"Ln {ln}, Col {col}")
    def set_lang(self, fn):
        ext = Path(fn).suffix.lstrip(".") if fn else "py"
        lang = {"py":"Python","js":"JavaScript","ts":"TypeScript",
                "html":"HTML","css":"CSS","md":"Markdown",
                "json":"JSON","txt":"Text","sh":"Shell"}.get(ext,"Text")
        self.lang_lbl.config(text=lang)
    def set_err(self, has=False):
        self.err_lbl.config(
            text="  ✗ Error" if has else "",
            fg="#f48771" if has else "#ffffff")


# ╔══════════════════════════════════════════════════════════╗
#  STARTER CODE
# ╚══════════════════════════════════════════════════════════╝
STARTER = '''\
# Welcome to Kavin IDE
# IntelliSense triggers on every keystroke — try typing:
#   p  →  shows print, pass, pathlib, pandas, ...
#   pr →  shows print, property, ...
#   de →  shows def, del, ...
#   im →  shows import, ...

def greet(name: str) -> str:
    """Return a greeting message."""
    return f"Hello, {name}!"


class Calculator:
    """A simple calculator with history."""

    def __init__(self):
        self.history: list = []

    def add(self, a: float, b: float) -> float:
        result = a + b
        self.history.append(f"{a} + {b} = {result}")
        return result

    def multiply(self, a: float, b: float) -> float:
        result = a * b
        self.history.append(f"{a} * {b} = {result}")
        return result

    def show_history(self):
        for i, entry in enumerate(self.history, 1):
            print(f"  {i}. {entry}")

    def __repr__(self) -> str:
        return f"Calculator({len(self.history)} operations)"


if __name__ == "__main__":
    print(greet("World"))
    calc = Calculator()
    print(calc.add(10, 5))
    print(calc.multiply(3, 7))
    calc.show_history()
    print(calc)
'''


# ╔══════════════════════════════════════════════════════════╗
#  MAIN  IDE  WINDOW
# ╚══════════════════════════════════════════════════════════╝
class KavinIDE(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Kavin IDE")
        self.geometry("1360x820")
        self.minsize(1000, 640)
        self.configure(bg=VS["editor"])
        self._tabs: dict = {}
        self._apply_styles()
        self._build_layout()
        self._build_menus()
        self._bind_keys()
        self._new_tab(content=STARTER)

    # ── ttk styles ──────────────────────────────────────
    def _apply_styles(self):
        s = ttk.Style(self)
        s.theme_use("clam")
        # notebook tabs — exact VS Code style
        s.configure("TNotebook",
                    background=VS["tab_bar"],
                    borderwidth=0, tabmargins=0)
        s.configure("TNotebook.Tab",
                    background=VS["tab_inactive"],
                    foreground=VS["fg_tab_off"],
                    font=("Segoe UI", 9),
                    padding=[12, 6],
                    borderwidth=0)
        s.map("TNotebook.Tab",
              background=[("selected", VS["tab_active"])],
              foreground=[("selected", VS["fg_tab_on"])])
        # paned
        s.configure("TPanedwindow", background=VS["editor"])
        s.configure("Sash",
                    sashthickness=3,
                    background=VS["sash"],
                    lightcolor=VS["sash"],
                    darkcolor=VS["sash"])
        s.configure("TScrollbar",
                    background=VS["scrollbar"],
                    troughcolor=VS["editor"],
                    arrowcolor=VS["fg_muted"],
                    borderwidth=0, relief="flat")
        s.configure("Exp.Treeview.Heading",
                    background=VS["sidebar"], foreground=VS["fg_dim"])

    # ── layout ──────────────────────────────────────────
    def _build_layout(self):
        # ── title bar (VS Code gray) ──
        tb = tk.Frame(self, bg=VS["titlebar"], height=30)
        tb.pack(fill="x"); tb.pack_propagate(False)

        tk.Label(tb, text="  Kavin IDE",
                 bg=VS["titlebar"], fg=VS["fg"],
                 font=("Segoe UI", 9)).pack(side="left", padx=8)

        # menu labels in title bar area
        for lbl in ["File","Edit","Selection","View","Run","Terminal","Help"]:
            l = tk.Label(tb, text=lbl, bg=VS["titlebar"], fg=VS["fg_dim"],
                         font=("Segoe UI",9), padx=6, cursor="hand2")
            l.pack(side="left")
            l.bind("<Enter>", lambda e, w=l: w.configure(bg=VS["hover"], fg=VS["fg"]))
            l.bind("<Leave>", lambda e, w=l: w.configure(bg=VS["titlebar"], fg=VS["fg_dim"]))

        # top-right: New File + Open Folder + RUN
        self._run_btn = tk.Button(tb, text=" ▶  Run ",
                                  bg=VS["run_bg"], fg=VS["run_fg"],
                                  activebackground="#2d7228",
                                  activeforeground="#ffffff",
                                  relief="flat",
                                  font=("Segoe UI", 9, "bold"),
                                  cursor="hand2", bd=0, padx=10, pady=3,
                                  command=self._run)
        self._run_btn.pack(side="right", padx=8, pady=4)

        def topbtn(text, cmd):
            b = tk.Button(tb, text=text, bg=VS["titlebar"], fg=VS["fg_dim"],
                          activebackground=VS["hover"], activeforeground=VS["fg"],
                          relief="flat", font=("Segoe UI",9),
                          cursor="hand2", bd=0, padx=8, pady=3, command=cmd)
            b.pack(side="right", pady=4, padx=1)
            b.bind("<Enter>", lambda e: b.configure(fg=VS["fg"]))
            b.bind("<Leave>", lambda e: b.configure(fg=VS["fg_dim"]))

        topbtn("🗁 Open Folder", self._open_folder)
        topbtn("📄 New File",    self._new_tab)

        # ── main body: activity bar | sidebar | editor ──
        body = tk.Frame(self, bg=VS["editor"]); body.pack(fill="both", expand=True)

        # activity bar
        self._activity = ActivityBar(body, self._activity_select)
        self._activity.pack(side="left", fill="y")

        # sidebar
        self._sidebar = tk.Frame(body, bg=VS["sidebar"], width=240)
        self._sidebar.pack(side="left", fill="y")
        self._sidebar.pack_propagate(False)

        self._explorer = Explorer(self._sidebar, self._open_file)
        self._explorer.pack(fill="both", expand=True)

        # sidebar / editor divider
        tk.Frame(body, bg=VS["border"], width=1).pack(side="left", fill="y")

        # editor area
        ed_area = tk.Frame(body, bg=VS["editor"]); ed_area.pack(fill="both", expand=True)

        self.nb = ttk.Notebook(ed_area); self.nb.pack(fill="both", expand=True)
        self.nb.bind("<<NotebookTabChanged>>", self._tab_changed)

        # status bar
        self._sb = StatusBar(ed_area); self._sb.pack(fill="x", side="bottom")

        # terminal (popup only)
        self._term = Terminal(self)

    def _activity_select(self, name):
        if name == "run":
            self._run(); return
        if name == "files":
            for w in self._sidebar.winfo_children(): w.pack_forget()
            self._explorer.pack(fill="both", expand=True)

    # ── menus ────────────────────────────────────────────
    def _build_menus(self):
        # VS Code puts menus in the title bar — we attach to the window
        mb = tk.Menu(self, bg=VS["dropdown"], fg=VS["fg"],
                     activebackground=VS["dropdown_sel"],
                     activeforeground="#ffffff",
                     relief="flat", bd=0, tearoff=0)
        self.config(menu=mb)

        def M(lbl):
            m = tk.Menu(mb, tearoff=0,
                        bg=VS["dropdown"], fg=VS["fg"],
                        activebackground=VS["dropdown_sel"],
                        activeforeground="#ffffff",
                        relief="flat", bd=0, font=("Segoe UI",9))
            mb.add_cascade(label=lbl, menu=m); return m

        f = M("File")
        f.add_command(label="New File                Ctrl+N", command=self._new_tab)
        f.add_command(label="Open File...            Ctrl+O", command=self._open_dlg)
        f.add_command(label="Open Folder...          Ctrl+K", command=self._open_folder)
        f.add_separator()
        f.add_command(label="Save                    Ctrl+S", command=self._save)
        f.add_command(label="Save As...        Ctrl+Shift+S", command=self._save_as)
        f.add_separator()
        f.add_command(label="Close Editor            Ctrl+W", command=self._close_tab)
        f.add_separator()
        f.add_command(label="Exit", command=self.quit)

        e = M("Edit")
        e.add_command(label="Undo                    Ctrl+Z",
                      command=lambda: self._ctw() and self._ctw().edit_undo())
        e.add_command(label="Redo                    Ctrl+Y",
                      command=lambda: self._ctw() and self._ctw().edit_redo())
        e.add_separator()
        e.add_command(label="Toggle Line Comment     Ctrl+/",
                      command=lambda: self._ct() and self._ct()._comment())
        e.add_command(label="Duplicate Line          Ctrl+D",
                      command=lambda: self._ct() and self._ct()._dup_line())
        e.add_separator()
        e.add_command(label="Increase Font           Ctrl+=", command=lambda: self._zoom(1))
        e.add_command(label="Decrease Font           Ctrl+-", command=lambda: self._zoom(-1))

        r = M("Run")
        r.add_command(label="Run Python File         Ctrl+R", command=self._run)
        r.add_command(label="Stop",                           command=self._term.stop)
        r.add_separator()
        r.add_command(label="Show Terminal",                  command=self._term.show)
        r.add_command(label="Clear Terminal",                 command=self._term.clear)

        h = M("Help")
        h.add_command(label="Keyboard Shortcuts",  command=self._show_keys)
        h.add_separator()
        h.add_command(label="About Kavin IDE",     command=self._about)

    def _bind_keys(self):
        self.bind("<Control-n>",     lambda e: self._new_tab())
        self.bind("<Control-o>",     lambda e: self._open_dlg())
        self.bind("<Control-k>",     lambda e: self._open_folder())
        self.bind("<Control-s>",     lambda e: self._save())
        self.bind("<Control-S>",     lambda e: self._save_as())
        self.bind("<Control-w>",     lambda e: self._close_tab())
        self.bind("<Control-r>",     lambda e: self._run())
        self.bind("<Control-equal>", lambda e: self._zoom(1))
        self.bind("<Control-minus>", lambda e: self._zoom(-1))

    # ── tab helpers ──────────────────────────────────────
    def _ct(self):
        try:
            return self._tabs.get(self.nb.nametowidget(self.nb.select()))
        except: return None

    def _ctw(self):
        t = self._ct(); return t.tw if t else None

    def _tab_changed(self, *_):
        t = self._ct()
        if not t: return
        self._sb.set_lang(t.fn)
        t.tw.bind("<KeyRelease>",    self._upd_pos, add=True)
        t.tw.bind("<ButtonRelease>", self._upd_pos, add=True)

    def _upd_pos(self, *_):
        t = self._ct()
        if not t: return
        r, c = t.tw.index("insert").split(".")
        self._sb.set_pos(int(r), int(c)+1)

    # ── file actions ─────────────────────────────────────
    def _new_tab(self, fn=None, content=None):
        tab = EditorTab(self.nb, self, fn=fn)
        if content:
            tab.tw.insert("1.0", content)
            tab.hl._run(); tab.mod = False
        self._tabs[tab.frame] = tab
        self.nb.select(tab.frame)
        tab.tw.focus_set()

    def _open_file(self, path):
        for w, t in self._tabs.items():
            if t.fn == path:
                self.nb.select(w); return
        self._new_tab(fn=path)
        self._sb.set_lang(path)

    def _open_dlg(self):
        p = filedialog.askopenfilename(
            filetypes=[("Python","*.py"),("All files","*.*")])
        if p: self._open_file(p)

    def _open_folder(self):
        p = filedialog.askdirectory(title="Open Folder")
        if p: self._explorer.load(p)

    def _save(self):
        t = self._ct()
        if t: t.save(); self._sb.set_lang(t.fn)

    def _save_as(self):
        t = self._ct()
        if t: t.fn = None; t.save()

    def _close_tab(self):
        t = self._ct()
        if not t: return
        if t.mod:
            ans = messagebox.askyesnocancel(
                "Unsaved Changes",
                f"Save '{t.fn or 'Untitled'}' before closing?")
            if ans is None: return
            if ans and not t.save(): return
        self.nb.forget(t.frame)
        del self._tabs[t.frame]

    # ── run ──────────────────────────────────────────────
    def _run(self):
        t = self._ct()
        if not t: return
        t.hl.clr_err(); self._sb.set_err(False)
        if t.fn and t.mod: t.save()

        def on_err(ln):
            if ln: t.hl.mark_err(ln); self._sb.set_err(True)

        self._term.run(t.content(), fn=t.fn, on_err=on_err)

    # ── zoom ─────────────────────────────────────────────
    def _zoom(self, delta):
        import tkinter.font as tkf
        for _, tab in self._tabs.items():
            try:
                size = max(8, min(36,
                    tkf.Font(font=tab.tw.cget("font")).cget("size") + delta))
                tab.tw.configure(font=("Consolas", size))
            except: pass

    # ── help windows ─────────────────────────────────────
    def _show_keys(self):
        win = tk.Toplevel(self)
        win.title("Keyboard Shortcuts — Kavin IDE")
        win.geometry("500x420")
        win.configure(bg=VS["sidebar"])
        tk.Label(win, text="Keyboard Shortcuts",
                 bg=VS["sidebar"], fg=VS["fg"],
                 font=("Segoe UI",13,"bold"), pady=14).pack(anchor="w", padx=20)
        rows = [
            ("Ctrl+N",          "New File"),
            ("Ctrl+O",          "Open File"),
            ("Ctrl+K",          "Open Folder"),
            ("Ctrl+S",          "Save"),
            ("Ctrl+Shift+S",    "Save As"),
            ("Ctrl+W",          "Close Editor"),
            ("Ctrl+R",          "Run File  →  opens Terminal"),
            ("Ctrl+Z / Ctrl+Y", "Undo / Redo"),
            ("Ctrl+/",          "Toggle Line Comment"),
            ("Ctrl+D",          "Duplicate Line"),
            ("Tab",             "Accept autocomplete  |  indent"),
            ("↑ / ↓",           "Navigate autocomplete list"),
            ("Esc",             "Dismiss autocomplete"),
            ("Ctrl+= / Ctrl+-", "Increase / Decrease Font"),
        ]
        for k, d in rows:
            r = tk.Frame(win, bg=VS["sidebar"]); r.pack(fill="x", padx=20, pady=3)
            tk.Label(r, text=k, bg=VS["tab_inactive"], fg=VS["fg"],
                     font=("Consolas",10), width=20, anchor="w",
                     padx=8, relief="flat").pack(side="left")
            tk.Label(r, text=d, bg=VS["sidebar"], fg=VS["fg_dim"],
                     font=("Segoe UI",10), padx=12).pack(side="left")

    def _about(self):
        messagebox.showinfo("Kavin IDE",
            "Kavin IDE  —  VS Code–Style Python IDE\n"
            "Built entirely in Python + tkinter\n\n"
            "Features:\n"
            "  • Exact VS Code Dark+ color theme\n"
            "  • IntelliSense — fires on every keystroke\n"
            "  • 200+ completions: keywords, builtins,\n"
            "    exceptions, snippets, stdlib + popular libs\n"
            "  • VS Code syntax highlighting\n"
            "  • Auto-indent  •  smart bracket pairs\n"
            "  • Error line highlighting after run\n"
            "  • Terminal popup window on Run\n"
            "  • File Explorer with New/Rename/Delete\n"
            "  • Activity bar  •  Multi-tab editing")


# ── entry point ──────────────────────────────────────────
if __name__ == "__main__":
    app = KavinIDE()
    app.mainloop()