NeoShell 2.2__py3-none-any.whl

neoshell.py

@@ -0,0 +1,1403 @@
+#!/usr/bin/env python3
+"""neoshell 2 - a CMD-style shell written in Python, with live syntax highlighting.
+
+    pip install prompt_toolkit psutil
+    python neoshell.py                    interactive shell
+    python neoshell.py -c "dir /b & ver"  run one line and exit
+    neoshell --install / --uninstall      add / remove the Windows Terminal profile
+    neoshell --no-install                 start without auto-registering the profile
+
+When built into neoshell.exe (see build_exe.bat) it registers its own Windows
+Terminal profile, with icon and color scheme, the first time it runs.
+
+Uses CMD command names and syntax (dir, copy, del, tasklist, findstr, %VAR%,
+&, &&, ||, if exist ...). On Windows, any CMD command not built in here
+(assoc, mklink, vol, ...) is passed through to the real cmd.exe.
+"""
+import ast
+import contextlib
+import datetime
+import fnmatch
+import getpass
+import glob
+import io
+import json
+import operator
+import os
+import platform
+import random
+import re
+import shutil
+import socket
+import subprocess
+import sys
+import time
+
+IS_WIN = os.name == "nt"
+if IS_WIN:
+    os.system("")  # turn on ANSI escape support in the console
+
+try:
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+    from prompt_toolkit.completion import Completer, Completion
+    from prompt_toolkit.history import FileHistory
+    from prompt_toolkit.lexers import Lexer
+    HAVE_PT = True
+except ImportError:
+    HAVE_PT = False
+    Lexer = Completer = object
+try:
+    import psutil
+except ImportError:
+    psutil = None
+
+VERSION = "2.2"
+HIST = os.path.expanduser("~/.neoshell_history")
+aliases = {}          # doskey macros
+dir_stack = []        # pushd / popd
+last_status = 0       # %ERRORLEVEL%
+last_dur = 0.0
+old_dir = None
+session = None
+_which_cache = {}
+_prog_cache = None
+
+WIN_INTERNAL = {"assoc", "attrib", "chcp", "cmd", "ftype", "label", "mklink", "vol",
+                "verify", "for", "call", "ipconfig", "ping", "netstat", "systeminfo"}
+GLOB_CMDS = {"type", "copy", "xcopy", "move", "del", "erase", "ren", "rename"}
+
+
+class Op(str):
+    """An unquoted operator token such as | & && || > >> <"""
+
+
+class Q(str):
+    """A token that was written in double quotes (never glob-expanded)."""
+
+
+# ---------------------------------------------------------------- helpers
+def paint(s, code):
+    return f"\033[{code}m{s}\033[0m" if sys.stdout.isatty() else s
+
+
+EXT_COLORS = {".exe": "32", ".bat": "32", ".cmd": "32", ".com": "32", ".sh": "32",
+              ".py": "33", ".js": "33", ".zip": "31", ".7z": "31", ".rar": "31",
+              ".gz": "31", ".png": "35", ".jpg": "35", ".jpeg": "35", ".gif": "35",
+              ".mp3": "35", ".mp4": "35"}
+
+
+def colorize_name(path, name):
+    if os.path.isdir(path):
+        return paint(name, "1;34")
+    code = EXT_COLORS.get(os.path.splitext(name)[1].lower())
+    return paint(name, code) if code else name
+
+
+def env_get(name):
+    if name in os.environ:
+        return os.environ[name]
+    up = name.upper()
+    return next((v for k, v in os.environ.items() if k.upper() == up), None)
+
+
+def expand_vars(line):
+    def sub(m):
+        name = m.group(1)
+        u = name.upper()
+        if u == "ERRORLEVEL": return str(last_status)
+        if u == "CD": return os.getcwd()
+        if u == "DATE": return datetime.date.today().strftime("%m/%d/%Y")
+        if u == "TIME": return datetime.datetime.now().strftime("%H:%M:%S.%f")[:-4]
+        if u == "RANDOM": return str(random.randint(0, 32767))
+        v = env_get(name)
+        return v if v is not None else m.group(0)
+    return re.sub(r"%([^%\s]+)%", sub, line)
+
+
+def tokenize(line):
+    """Split a CMD line. Only double quotes quote; backslashes are literal."""
+    toks, cur, quoted, inq, i = [], [], False, False, 0
+
+    def flush():
+        nonlocal cur, quoted
+        if cur or quoted:
+            s = "".join(cur)
+            toks.append(Q(s) if quoted else s)
+        cur, quoted = [], False
+
+    while i < len(line):
+        ch = line[i]
+        if ch == '"':
+            inq, quoted = not inq, True
+        elif inq:
+            cur.append(ch)
+        elif ch.isspace():
+            flush()
+        elif line[i:i + 2] in ("&&", "||", ">>"):
+            flush(); toks.append(Op(line[i:i + 2])); i += 1
+        elif ch in "&|<>":
+            flush(); toks.append(Op(ch))
+        else:
+            cur.append(ch)
+        i += 1
+    flush()
+    return toks
+
+
+def expand_aliases(tokens):
+    out, at_cmd = [], True
+    for t in tokens:
+        if at_cmd and not isinstance(t, Op) and str(t).lower() in aliases:
+            out.extend(tokenize(aliases[str(t).lower()]))
+        else:
+            out.append(t)
+        at_cmd = isinstance(t, Op) and t in ("&&", "||", "&", "|")
+    return out
+
+
+def split_flags(args):
+    """Separate /flags from other arguments."""
+    flags, rest = [], []
+    for a in args:
+        if re.fullmatch(r"/[A-Za-z?][A-Za-z0-9:,\-]*", a) and not (len(a) > 3 and os.path.exists(a)):
+            flags.append(a.lower())
+        else:
+            rest.append(a)
+    return flags, rest
+
+
+def human(n):
+    for u in ("B", "K", "M", "G", "T"):
+        if n < 1024:
+            return f"{n:.0f}{u}"
+        n /= 1024
+    return f"{n:.1f}P"
+
+
+def git_branch():
+    d = os.getcwd()
+    while True:
+        g = os.path.join(d, ".git")
+        if os.path.isdir(g):
+            try:
+                with open(os.path.join(g, "HEAD")) as f:
+                    head = f.read().strip()
+                return head[16:] if head.startswith("ref: refs/heads/") else head[:7]
+            except OSError:
+                return ""
+        parent = os.path.dirname(d)
+        if parent == d:
+            return ""
+        d = parent
+
+
+# --- tiny safe arithmetic for `set /a`
+def _shl(a, b):
+    if not 0 <= b < 64:
+        raise ValueError
+    return a << b
+
+
+_BIN = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
+        ast.Div: lambda a, b: int(a / b), ast.Mod: operator.mod, ast.LShift: _shl,
+        ast.RShift: operator.rshift, ast.BitAnd: operator.and_,
+        ast.BitOr: operator.or_, ast.BitXor: operator.xor}
+
+
+def calc(expr):
+    def ev(n):
+        if isinstance(n, ast.Expression): return ev(n.body)
+        if isinstance(n, ast.Constant) and isinstance(n.value, int): return n.value
+        if isinstance(n, ast.Name):
+            v = env_get(n.id)
+            return int(v) if v and re.fullmatch(r"-?\d+", v) else 0
+        if isinstance(n, ast.BinOp) and type(n.op) in _BIN:
+            return _BIN[type(n.op)](ev(n.left), ev(n.right))
+        if isinstance(n, ast.UnaryOp):
+            v = ev(n.operand)
+            if isinstance(n.op, ast.USub): return -v
+            if isinstance(n.op, ast.UAdd): return v
+            if isinstance(n.op, ast.Invert): return ~v
+        raise ValueError("bad expression")
+    return ev(ast.parse(expr.strip(), mode="eval"))
+
+
+# ---------------------------------------------------------------- builtins
+BUILTINS, HELP = {}, {}
+
+
+def builtin(*names, doc=""):
+    def deco(f):
+        for n in names:
+            BUILTINS[n] = f
+        HELP[names[0]] = doc
+        return f
+    return deco
+
+
+@builtin("cd", "chdir", doc="Show or change directory.  cd -  goes back")
+def b_cd(a):
+    global old_dir
+    _, rest = split_flags(a)
+    if not rest:
+        print(os.getcwd()); return 0
+    target = " ".join(rest)
+    if target == "-" and old_dir:
+        target = old_dir
+    here = os.getcwd()
+    try:
+        os.chdir(target)
+        old_dir = here
+        return 0
+    except OSError:
+        print("The system cannot find the path specified."); return 1
+
+
+@builtin("pushd", doc="Save the current directory and change to another")
+def b_pushd(a):
+    here = os.getcwd()
+    rc = b_cd(a)
+    if rc == 0 and a:
+        dir_stack.append(here)
+    return rc
+
+
+@builtin("popd", doc="Return to the last pushd directory")
+def b_popd(a):
+    if not dir_stack:
+        return 0
+    return b_cd([dir_stack.pop()])
+
+
+@builtin("cls", doc="Clear the screen")
+def b_cls(a):
+    print("\033[2J\033[3J\033[H", end="", flush=True); return 0
+
+
+@builtin("echo", doc="Print text")
+def b_echo(a):
+    print("ECHO is on." if not a else " ".join(a)); return 0
+
+
+@builtin("title", doc="Set the window title")
+def b_title(a):
+    sys.stdout.write(f"\033]0;{' '.join(a)}\007"); sys.stdout.flush(); return 0
+
+
+@builtin("exit", doc="Quit")
+def b_exit(a):
+    _, rest = split_flags(a)
+    sys.exit(int(rest[0]) if rest and rest[0].isdigit() else 0)
+
+
+@builtin("ver", doc="Show version")
+def b_ver(a):
+    if IS_WIN:
+        print(f"\nMicrosoft Windows [Version {platform.version()}]")
+    print(f"neoshell {VERSION} on {platform.system()} {platform.release()}"); return 0
+
+
+@builtin("hostname", doc="Show computer name")
+def b_hostname(a): print(socket.gethostname()); return 0
+
+
+@builtin("whoami", doc="Show current user")
+def b_whoami(a):
+    print(f"{socket.gethostname()}\\{getpass.getuser()}" if IS_WIN else getpass.getuser()); return 0
+
+
+@builtin("date", doc="Show the date")
+def b_date(a):
+    d = datetime.datetime.now().strftime("%a %m/%d/%Y")
+    print(d if "/t" in [x.lower() for x in a] else f"The current date is: {d}"); return 0
+
+
+@builtin("time", doc="Show the time")
+def b_time(a):
+    now = datetime.datetime.now()
+    if "/t" in [x.lower() for x in a]:
+        print(now.strftime("%I:%M %p"))
+    else:
+        print("The current time is: " + now.strftime("%H:%M:%S.%f")[:-4])
+    return 0
+
+
+@builtin("dir", doc="List files. /b bare  /w wide  /s recurse  /ad dirs only  /o:n|s|d|e sort (-x reverses)")
+def b_dir(a):
+    fl, specs = split_flags(a)
+    bare, wide, rec, only_dirs = "/b" in fl, "/w" in fl, "/s" in fl, "/ad" in fl
+    order = next((f[3:] for f in fl if f.startswith("/o:")), "gn")
+    mode = order.lstrip("-g")[:1] or "n"
+    rev = order.startswith("-")
+
+    def key(p):
+        try:
+            st = os.stat(p)
+        except OSError:
+            return (False, "")
+        k = {"n": os.path.basename(p).lower(), "s": st.st_size, "d": st.st_mtime,
+             "e": os.path.splitext(p)[1].lower()}.get(mode, "")
+        return (not os.path.isdir(p), k)
+
+    def show(d, entries):
+        if only_dirs:
+            entries = [e for e in entries if os.path.isdir(e)]
+        entries.sort(key=key, reverse=rev)
+        if not bare:
+            print(f"\n Directory of {os.path.abspath(d)}\n")
+        nf = nd = size = 0
+        cells = []
+        for e in entries:
+            try:
+                st = os.stat(e)
+            except OSError:
+                continue
+            name, isdir = os.path.basename(e), os.path.isdir(e)
+            if isdir: nd += 1
+            else: nf += 1; size += st.st_size
+            if bare:
+                print(colorize_name(e, e if rec else name))
+            elif wide:
+                cells.append((e, f"[{name}]" if isdir else name))
+            else:
+                t = datetime.datetime.fromtimestamp(st.st_mtime).strftime("%m/%d/%Y  %I:%M %p")
+                col = "<DIR>".ljust(14) if isdir else f"{st.st_size:>14,}"
+                print(f"{t}    {col} {colorize_name(e, name)}")
+        if wide and cells:
+            w = max(len(l) for _, l in cells) + 2
+            per = max(1, shutil.get_terminal_size().columns // w)
+            for i in range(0, len(cells), per):
+                print("".join(colorize_name(e, l.ljust(w)) for e, l in cells[i:i + per]))
+        if not bare:
+            print(f"{nf:>16} File(s) {size:>14,} bytes")
+            try:
+                free = shutil.disk_usage(d).free
+            except OSError:
+                free = 0
+            print(f"{nd:>16} Dir(s)  {free:>14,} bytes free")
+
+    found = False
+    for spec in specs or ["."]:
+        if rec:
+            base, pat = (spec, "*") if os.path.isdir(spec) else (os.path.dirname(spec) or ".", os.path.basename(spec))
+            for root, _, _ in os.walk(base):
+                ents = [os.path.join(root, n) for n in os.listdir(root) if fnmatch.fnmatch(n, pat)]
+                if ents:
+                    show(root, ents); found = True
+        elif os.path.isdir(spec):
+            show(spec, [os.path.join(spec, n) for n in os.listdir(spec)]); found = True
+        else:
+            hits = glob.glob(spec)
+            if hits:
+                show(os.path.dirname(spec) or ".", hits); found = True
+    if not found:
+        print("File Not Found"); return 1
+    return 0
+
+
+@builtin("tree", doc="Draw a directory tree. /f includes files")
+def b_tree(a):
+    fl, rest = split_flags(a)
+    root, files = (rest[0] if rest else "."), "/f" in fl
+    print(os.path.abspath(root))
+
+    def walk(d, prefix):
+        try:
+            names = sorted(os.listdir(d), key=str.lower)
+        except OSError:
+            return
+        items = [n for n in names if files or os.path.isdir(os.path.join(d, n))]
+        for i, n in enumerate(items):
+            last, p = i == len(items) - 1, os.path.join(d, n)
+            print(prefix + ("└── " if last else "├── ") + colorize_name(p, n))
+            if os.path.isdir(p) and not os.path.islink(p):
+                walk(p, prefix + ("    " if last else "│   "))
+    walk(root, "")
+    return 0
+
+
+@builtin("type", doc="Print file contents")
+def b_type(a):
+    _, files = split_flags(a)
+    rc = 0
+    for f in files:
+        try:
+            with open(f, encoding="utf-8", errors="replace") as fh:
+                sys.stdout.write(fh.read())
+        except OSError:
+            print("The system cannot find the file specified."); rc = 1
+    return rc
+
+
+@builtin("more", doc="Page through a file or piped text")
+def b_more(a):
+    _, files = split_flags(a)
+    lines = []
+    for f in files:
+        try:
+            with open(f, encoding="utf-8", errors="replace") as fh:
+                lines += fh.read().splitlines()
+        except OSError:
+            print("Cannot access file " + f); return 1
+    if not files:
+        lines = sys.stdin.read().splitlines()
+    page = max(5, shutil.get_terminal_size().lines - 1)
+    for i, ln in enumerate(lines):
+        print(ln)
+        if sys.stdout.isatty() and (i + 1) % page == 0 and i + 1 < len(lines):
+            try:
+                if sys.__stdin__.readline().strip().lower() == "q":
+                    break
+            except Exception:
+                break
+    return 0
+
+
+@builtin("copy", doc="Copy files")
+def b_copy(a):
+    _, args = split_flags(a)
+    if len(args) < 2:
+        print("The syntax of the command is incorrect."); return 1
+    *srcs, dst = args
+    if len(srcs) > 1 and not os.path.isdir(dst):
+        print("The syntax of the command is incorrect."); return 1
+    n, rc = 0, 0
+    for s in srcs:
+        try:
+            shutil.copy2(s, dst); n += 1
+        except OSError:
+            print("The system cannot find the file specified."); rc = 1
+    print(f"        {n} file(s) copied.")
+    return rc
+
+
+@builtin("xcopy", doc="Copy files and folders. /e includes subfolders")
+def b_xcopy(a):
+    _, args = split_flags(a)
+    if len(args) < 2:
+        print("Invalid number of parameters"); return 4
+    src, dst = args[0], args[1]
+    try:
+        if os.path.isdir(src):
+            shutil.copytree(src, dst, dirs_exist_ok=True)
+        else:
+            shutil.copy2(src, dst)
+        print("File(s) copied"); return 0
+    except OSError:
+        print(f"File not found - {src}"); return 4
+
+
+@builtin("move", doc="Move files or folders")
+def b_move(a):
+    _, args = split_flags(a)
+    if len(args) < 2:
+        print("The syntax of the command is incorrect."); return 1
+    *srcs, dst = args
+    for s in srcs:
+        try:
+            shutil.move(s, dst)
+        except (OSError, shutil.Error):
+            print("The system cannot find the file specified."); return 1
+    print(f"        {len(srcs)} file(s) moved.")
+    return 0
+
+
+@builtin("ren", "rename", doc="Rename a file or folder")
+def b_ren(a):
+    _, args = split_flags(a)
+    if len(args) != 2:
+        print("The syntax of the command is incorrect."); return 1
+    try:
+        os.rename(args[0], os.path.join(os.path.dirname(args[0]), args[1])); return 0
+    except OSError:
+        print("The system cannot find the file specified."); return 1
+
+
+@builtin("del", "erase", doc="Delete files. /q quiet  /s include subfolders")
+def b_del(a):
+    fl, pats = split_flags(a)
+    targets = []
+    for p in pats:
+        targets += glob.glob(p)
+        if "/s" in fl:
+            targets += glob.glob(os.path.join("**", os.path.basename(p)), recursive=True)
+    rc = 0
+    if not targets:
+        print("Could Not Find " + (os.path.abspath(pats[0]) if pats else "")); return 1
+    for t in dict.fromkeys(targets):
+        try:
+            if os.path.isdir(t):
+                for n in os.listdir(t):
+                    f = os.path.join(t, n)
+                    if os.path.isfile(f): os.remove(f)
+            else:
+                os.remove(t)
+        except OSError:
+            print(f"Access is denied: {t}"); rc = 1
+    return rc
+
+
+@builtin("md", "mkdir", doc="Make directories")
+def b_md(a):
+    _, dirs = split_flags(a)
+    rc = 0
+    for d in dirs:
+        try:
+            os.makedirs(d)
+        except FileExistsError:
+            print(f"A subdirectory or file {d} already exists."); rc = 1
+        except OSError:
+            print("The system cannot find the path specified."); rc = 1
+    return rc
+
+
+@builtin("rd", "rmdir", doc="Remove directories. /s whole tree  /q no prompt")
+def b_rd(a):
+    fl, dirs = split_flags(a)
+    for d in dirs:
+        try:
+            if "/s" in fl:
+                if "/q" not in fl and input(f"{d}, Are you sure (Y/N)? ").strip().lower() != "y":
+                    continue
+                shutil.rmtree(d)
+            else:
+                os.rmdir(d)
+        except FileNotFoundError:
+            print("The system cannot find the file specified."); return 1
+        except OSError:
+            print("The directory is not empty."); return 145
+    return 0
+
+
+@builtin("set", doc="Show/set variables.  set X=1   set /a X=X+2   set /p X=Prompt")
+def b_set(a):
+    fl, rest = split_flags(a)
+    text = " ".join(rest)
+    if "/a" in fl:
+        res = None
+        for part in text.split(","):
+            m = re.fullmatch(r"\s*(\w+)\s*(<<|>>|[-+*/%&|^])?=\s*(.+)", part)
+            try:
+                if m:
+                    name, op, rhs = m.groups()
+                    val = calc(rhs)
+                    if op:
+                        val = calc(f"{env_get(name) or 0}{op}({val})")
+                    os.environ[name] = str(val); res = val
+                else:
+                    res = calc(part)
+            except (ValueError, SyntaxError, ZeroDivisionError):
+                print("Invalid number. Numeric constants are either decimal."); return 1
+        print(res); return 0
+    if "/p" in fl:
+        name, _, prompt = text.partition("=")
+        os.environ[name.strip()] = input(prompt)
+        return 0
+    if not text:
+        for k, v in sorted(os.environ.items(), key=lambda kv: kv[0].upper()):
+            print(f"{k}={v}")
+        return 0
+    if "=" in text:
+        k, v = text.split("=", 1)
+        if v: os.environ[k.strip()] = v
+        else: os.environ.pop(k.strip(), None)
+        return 0
+    hits = [(k, v) for k, v in os.environ.items() if k.upper().startswith(text.upper())]
+    for k, v in sorted(hits):
+        print(f"{k}={v}")
+    if not hits:
+        print(f"Environment variable {text} not defined"); return 1
+    return 0
+
+
+@builtin("path", doc="Show or set PATH")
+def b_path(a):
+    if not a:
+        print("PATH=" + os.environ.get("PATH", ""))
+    else:
+        text = " ".join(a).lstrip("=")
+        os.environ["PATH"] = "" if text == ";" else text
+        _which_cache.clear()
+    return 0
+
+
+@builtin("doskey", doc="Define macros.  doskey ll=dir /w   doskey /macros")
+def b_doskey(a):
+    text = " ".join(a)
+    if not text or text.lower() == "/macros":
+        for k, v in sorted(aliases.items()): print(f"{k}={v}")
+    elif "=" in text:
+        k, v = text.split("=", 1)
+        if v.strip(): aliases[k.strip().lower()] = v.strip()
+        else: aliases.pop(k.strip().lower(), None)
+    return 0
+
+
+@builtin("where", doc="Locate programs on PATH")
+def b_where(a):
+    _, names = split_flags(a)
+    dirs = [os.getcwd()] + [d for d in os.environ.get("PATH", "").split(os.pathsep) if d]
+    exts = [""] + (os.environ.get("PATHEXT", ".COM;.EXE;.BAT;.CMD").split(";") if IS_WIN else [])
+    seen = set()
+    for n in names:
+        for d in dirs:
+            for e in exts:
+                for hit in glob.glob(os.path.join(glob.escape(d), n + e)):
+                    if os.path.isfile(hit) and (IS_WIN or os.access(hit, os.X_OK)) and hit not in seen:
+                        seen.add(hit); print(hit)
+    if not seen:
+        print("INFO: Could not find files for the given pattern(s)."); return 1
+    return 0
+
+
+@builtin("find", doc='Search text: find [/i] [/v] [/c] [/n] "text" [files]')
+def b_find(a):
+    fl, rest = split_flags(a)
+    if not rest:
+        print("FIND: Parameter format not correct"); return 2
+    needle, files = rest[0], rest[1:]
+    ci, inv, cnt, nums = "/i" in fl, "/v" in fl, "/c" in fl, "/n" in fl
+    total = 0
+
+    def scan(lines, label=None):
+        n = hits = 0
+        if label and not cnt:
+            print(f"\n---------- {label.upper()}")
+        for ln in lines:
+            n += 1
+            s = ln.rstrip("\n")
+            ok = (needle.lower() in s.lower()) if ci else (needle in s)
+            if ok != inv:
+                hits += 1
+                if not cnt:
+                    print((f"[{n}]" if nums else "") + s)
+        if cnt:
+            print(f"---------- {label.upper()}: {hits}" if label else hits)
+        return hits
+
+    if not files:
+        total = scan(sys.stdin)
+    for f in files:
+        try:
+            with open(f, encoding="utf-8", errors="replace") as fh:
+                total += scan(fh, f)
+        except OSError:
+            print(f"File not found - {f.upper()}")
+    return 0 if total else 1
+
+
+@builtin("findstr", doc="Search with /i /n /v /r /s /c:\"phrase\"  (space = OR of words)")
+def b_findstr(a):
+    ci = nums = inv = regex = sub = False
+    lits, rest = [], []
+    for x in a:
+        xl = x.lower()
+        if xl.startswith("/c:"): lits.append(x[3:])
+        elif xl == "/i": ci = True
+        elif xl == "/n": nums = True
+        elif xl == "/v": inv = True
+        elif xl == "/r": regex = True
+        elif xl == "/s": sub = True
+        elif re.fullmatch(r"/[A-Za-z]", x): pass
+        else: rest.append(x)
+    if not lits:
+        if not rest:
+            print("FINDSTR: Bad command line"); return 2
+        pat = rest.pop(0)
+        lits = [pat] if regex else pat.split()
+    try:
+        rx = re.compile("|".join(lits if regex else map(re.escape, lits)), re.I if ci else 0)
+    except re.error:
+        print("FINDSTR: Bad regular expression"); return 2
+
+    files = []
+    for spec in rest:
+        if sub:
+            base, pat2 = os.path.dirname(spec) or ".", os.path.basename(spec)
+            for root, _, names in os.walk(base):
+                files += [os.path.join(root, n) for n in names if fnmatch.fnmatch(n, pat2)]
+        else:
+            files += glob.glob(spec) or [spec]
+    prefix = len(files) > 1 or sub
+    tty = sys.stdout.isatty()
+
+    def scan(lines, label):
+        found = 0
+        for n, ln in enumerate(lines, 1):
+            s = ln.rstrip("\n")
+            if bool(rx.search(s)) != inv:
+                found += 1
+                if tty and not inv:
+                    s = rx.sub(lambda m: f"\033[1;31m{m.group()}\033[0m", s)
+                head = (f"{label}:" if label and prefix else "") + (f"{n}:" if nums else "")
+                print(head + s)
+        return found
+
+    total = 0
+    if not files:
+        total = scan(sys.stdin, None)
+    for f in files:
+        try:
+            with open(f, encoding="utf-8", errors="replace") as fh:
+                total += scan(fh, f)
+        except OSError:
+            print(f"FINDSTR: Cannot open {f}")
+    return 0 if total else 1
+
+
+@builtin("tasklist", doc='List processes. /fi "imagename eq x" or "pid eq n" to filter')
+def b_tasklist(a):
+    if not psutil:
+        print("Install psutil first: pip install psutil"); return 1
+    fl, rest = split_flags(a)
+    flt = None
+    if "/fi" in fl and rest:
+        m = re.fullmatch(r"\s*(imagename|pid)\s+(eq|ne)\s+(.+?)\s*", rest[0], re.I)
+        if m: flt = (m.group(1).lower(), m.group(2).lower(), m.group(3).lower())
+    rows = []
+    for p in psutil.process_iter(["pid", "name", "memory_info"]):
+        i = p.info
+        name = i["name"] or "?"
+        if flt:
+            v = name.lower() if flt[0] == "imagename" else str(i["pid"])
+            if (v == flt[2]) != (flt[1] == "eq"):
+                continue
+        rows.append((name, i["pid"], i["memory_info"].rss // 1024 if i["memory_info"] else 0))
+    if not rows:
+        print("INFO: No tasks are running which match the specified criteria."); return 0
+    rows.sort(key=lambda r: r[0].lower())
+    print(f"{'Image Name':<28}{'PID':>8}{'Mem Usage':>16}")
+    print("=" * 27 + " " + "=" * 8 + " " + "=" * 15)
+    for n, pid, mem in rows:
+        print(f"{n[:27]:<28}{pid:>8}{mem:>13,} K")
+    return 0
+
+
+@builtin("taskkill", doc="Kill a process: taskkill /pid N  or  /im name  [/f]")
+def b_taskkill(a):
+    if not psutil:
+        print("Install psutil first: pip install psutil"); return 1
+    pid = im = None
+    force = False
+    it = iter(a)
+    for x in it:
+        xl = x.lower()
+        if xl == "/pid": pid = next(it, None)
+        elif xl == "/im": im = next(it, None)
+        elif xl == "/f": force = True
+    victims = []
+    for p in psutil.process_iter(["pid", "name"]):
+        if (pid and str(p.info["pid"]) == pid) or (im and (p.info["name"] or "").lower() == im.lower()):
+            victims.append(p)
+    if not victims:
+        print(f'ERROR: The process "{pid or im}" not found.'); return 128
+    rc = 0
+    for p in victims:
+        try:
+            p.kill() if force else p.terminate()
+            print(f'SUCCESS: Sent termination signal to the process "{p.info["name"]}" with PID {p.info["pid"]}.')
+        except Exception as e:
+            print(f"ERROR: {e}"); rc = 1
+    return rc
+
+
+@builtin("sysinfo", doc="CPU, memory and disk summary")
+def b_sysinfo(a):
+    if not psutil:
+        print("Install psutil first: pip install psutil"); return 1
+    vm, d = psutil.virtual_memory(), psutil.disk_usage(os.path.abspath(os.sep))
+    print(f"CPU   {psutil.cpu_percent(interval=0.3)}%  ({psutil.cpu_count()} logical cores)")
+    print(f"RAM   {human(vm.used)} / {human(vm.total)}  ({vm.percent}%)")
+    print(f"Disk  {human(d.used)} / {human(d.total)}  ({d.percent}%)")
+    return 0
+
+
+@builtin("history", doc="Show command history")
+def b_history(a):
+    if session:
+        for i, s in enumerate(session.history.get_strings(), 1):
+            print(f"{i:>5}  {s}")
+    return 0
+
+
+@builtin("start", doc="Open a file/URL with its default app, or launch a program")
+def b_start(a):
+    a = list(a)
+    if a and a[0] == "":
+        a.pop(0)
+    if not a:
+        return 0
+    try:
+        if len(a) == 1 and hasattr(os, "startfile"):
+            os.startfile(a[0])
+        elif len(a) == 1:
+            subprocess.Popen(["open" if sys.platform == "darwin" else "xdg-open", a[0]])
+        else:
+            subprocess.Popen(a)
+        return 0
+    except OSError as e:
+        print(f"Cannot start: {e}"); return 1
+
+
+@builtin("timeout", doc="Wait N seconds:  timeout /t 5")
+def b_timeout(a):
+    nums = [x for x in a if x.lstrip("-").isdigit()]
+    n = int(nums[0]) if nums else 5
+    try:
+        for i in range(n, 0, -1):
+            print(f"\rWaiting for {i} seconds, press Ctrl+C to quit ...", end="", flush=True)
+            time.sleep(1)
+    except KeyboardInterrupt:
+        pass
+    print()
+    return 0
+
+
+@builtin("pause", doc="Wait for Enter")
+def b_pause(a):
+    try:
+        input("Press Enter to continue . . . ")
+    except EOFError:
+        pass
+    return 0
+
+
+@builtin("help", doc="List commands, or help <command>")
+def b_help(a):
+    if a:
+        n = a[0].lower()
+        if n in HELP:
+            print(f"{n}: {HELP[n]}"); return 0
+        if IS_WIN:
+            return subprocess.run(["cmd", "/c", "help", n]).returncode
+        print("No help for that command."); return 1
+    print(f"neoshell {VERSION} built-in commands:\n")
+    for n in sorted(HELP):
+        print(f"  {paint(n.ljust(10), '1;32')} {HELP[n]}")
+    print("\nSyntax:  a & b   a && b   a || b   a | b   > >> <   %VAR%   %ERRORLEVEL%")
+    print("         if [not] exist X cmd   if [not] errorlevel N cmd   if a==b cmd   rem comment")
+    if IS_WIN:
+        print("Anything else CMD knows (assoc, mklink, vol, ...) is passed to cmd.exe.")
+    return 0
+
+
+# ---------------------------------------------------------------- execution
+def run_command(argv, data, last, redir):
+    """Run one command. Returns (stdout_bytes_or_None, status)."""
+    name = str(argv[0]).lower()
+    m = re.fullmatch(r"(cd|chdir)(\.\.+|[\\/])", name)       # cd.. and cd\
+    if m:
+        argv, name = [m.group(1), m.group(2)] + list(argv[1:]), m.group(1)
+    elif name.startswith(("echo.", "echo/")):                # echo. prints a blank line
+        argv, name = ["echo", str(argv[0])[5:]] + list(argv[1:]), "echo"
+
+    capture = (not last) or redir
+    fn = BUILTINS.get(name)
+    if fn:
+        args = []
+        for x in argv[1:]:
+            if name in GLOB_CMDS and not isinstance(x, Q) and any(c in x for c in "*?["):
+                args += sorted(glob.glob(x)) or [str(x)]
+            else:
+                args.append(str(x))
+        buf, old_in = io.StringIO(), sys.stdin
+        if data is not None:
+            sys.stdin = io.StringIO(data.decode("utf-8", "replace"))
+        try:
+            with (contextlib.redirect_stdout(buf) if capture else contextlib.nullcontext()):
+                st = fn(args)
+        except KeyboardInterrupt:
+            st = 130
+        finally:
+            sys.stdin = old_in
+        return (buf.getvalue().encode() if capture else None), (st or 0)
+
+    argv = [str(x) for x in argv]
+    pipe = subprocess.PIPE if capture else None
+    try:
+        p = subprocess.run(argv, input=data, stdout=pipe)
+    except OSError:
+        if IS_WIN:      # let the real cmd.exe handle its own internal commands
+            try:
+                p = subprocess.run(["cmd", "/c"] + argv, input=data, stdout=pipe)
+            except KeyboardInterrupt:
+                return None, 130
+        else:
+            print(paint(f"'{argv[0]}' is not recognized as an internal or external command,\n"
+                        "operable program or batch file.", "31"))
+            return None, 9009
+    except KeyboardInterrupt:
+        return None, 130
+    return (p.stdout if capture else None), p.returncode
+
+
+def devnull(path):
+    return os.devnull if path.lower() == "nul" else os.path.expanduser(path)
+
+
+def run_if(t):
+    i = 1
+    ci = False
+    if i < len(t) and str(t[i]).lower() == "/i":
+        ci = True; i += 1
+    neg = False
+    if i < len(t) and str(t[i]).lower() == "not":
+        neg = True; i += 1
+    kind = str(t[i]).lower() if i < len(t) else ""
+    try:
+        if kind == "exist":
+            cond, i = os.path.exists(str(t[i + 1])), i + 2
+        elif kind == "errorlevel":
+            cond, i = last_status >= int(t[i + 1]), i + 2
+        elif kind == "defined":
+            cond, i = env_get(str(t[i + 1])) is not None, i + 2
+        else:
+            s = str(t[i])
+            if "==" in s and not (s == "==" and not isinstance(t[i], Q)):
+                x, y = s.split("==", 1); i += 1          # a==b  or  "a"=="b"
+            else:
+                x, y = s, str(t[i + 2]); i += 3          # a == b
+            cond = (x.lower() == y.lower()) if ci else (x == y)
+    except (IndexError, ValueError):
+        print("The syntax of the command is incorrect."); return 1
+    rest = t[i:]
+    if cond != neg and rest:
+        return run_tokens(rest)
+    return last_status
+
+
+def run_pipeline(toks):
+    if not isinstance(toks[0], Q) and str(toks[0]).lower() == "if":
+        return run_if(toks)
+    cmds, cur = [], []
+    for t in toks:
+        if isinstance(t, Op) and t == "|":
+            cmds.append(cur); cur = []
+        else:
+            cur.append(t)
+    cmds.append(cur)
+    data, st = None, 0
+    for n, c in enumerate(cmds):
+        argv, out, inp, j = [], None, None, 0
+        while j < len(c):
+            t = c[j]
+            if isinstance(t, Op) and t in (">", ">>") and j + 1 < len(c):
+                out = (str(t), str(c[j + 1])); j += 2
+            elif isinstance(t, Op) and t == "<" and j + 1 < len(c):
+                inp = str(c[j + 1]); j += 2
+            else:
+                argv.append(t); j += 1
+        if not argv:
+            continue
+        if inp:
+            try:
+                with open(devnull(inp), "rb") as f:
+                    data = f.read()
+            except OSError:
+                print("The system cannot find the file specified."); return 1
+        data, st = run_command(argv, data, n == len(cmds) - 1, out is not None)
+        if out and data is not None:
+            try:
+                with open(devnull(out[1]), "ab" if out[0] == ">>" else "wb") as f:
+                    f.write(data)
+            except OSError:
+                print("Access is denied."); st = 1
+            data = None
+    return st
+
+
+def run_tokens(tokens):
+    global last_status
+    groups, cur, op = [], [], "&"
+    for t in tokens:
+        if isinstance(t, Op) and t in ("&", "&&", "||"):
+            groups.append((op, cur)); cur, op = [], str(t)
+        else:
+            cur.append(t)
+    groups.append((op, cur))
+    for op, toks in groups:
+        if (op == "&&" and last_status != 0) or (op == "||" and last_status == 0):
+            continue
+        if toks:
+            last_status = run_pipeline(toks)
+    return last_status
+
+
+def run_line(line):
+    line = line.strip()
+    if not line or line.startswith("::") or re.match(r"(?i)rem(\s|$)", line):
+        return
+    toks = expand_aliases(tokenize(expand_vars(line)))
+    try:
+        run_tokens(toks)
+    finally:
+        _which_cache.clear()
+
+
+# ---------------------------------------------------------------- highlighting
+def is_command(name):
+    low = name.lower()
+    if low in BUILTINS or low in aliases or (IS_WIN and low in WIN_INTERNAL):
+        return True
+    if low not in _which_cache:
+        _which_cache[low] = bool(shutil.which(name)) or os.path.isfile(name)
+    return _which_cache[low]
+
+
+def arg_style(t):
+    if t.startswith('"'): return "fg:ansiyellow"
+    if t.startswith("%"): return "fg:ansiblue bold"
+    if re.fullmatch(r"[/-][A-Za-z?][\w:,-]*", t): return "fg:ansicyan"
+    if re.fullmatch(r"\d+", t): return "fg:ansimagenta"
+    if os.path.exists(os.path.expandvars(t)): return "underline"
+    return ""
+
+
+class CmdLexer(Lexer):
+    TOK = re.compile(r'"[^"]*"?|%[^%\s"]*%?|&&|\|\||>>|[&|<>]|\s+|[^\s"%&|<>]+')
+    CHAIN = ("&&", "||", "&", "|")
+
+    def lex_document(self, document):
+        lines = document.lines
+
+        def get_line(n):
+            line = lines[n]
+            if re.match(r"\s*(::|rem(\s|$))", line, re.I):
+                return [("fg:ansibrightblack italic", line)]
+            out, state, skip = [], "cmd", 0
+            for m in self.TOK.finditer(line):
+                t = m.group()
+                if t.isspace():
+                    out.append(("", t)); continue
+                if t in ("&&", "||", "&", "|", ">", ">>", "<"):
+                    out.append(("fg:ansimagenta bold", t))
+                    state = "cmd" if t in self.CHAIN else "arg"
+                    continue
+                bare = t.strip('"')
+                low = bare.lower()
+                style = ""
+                if state == "cmd":
+                    if low == "if":
+                        style, state = "fg:ansimagenta bold", "if"
+                    else:
+                        style = "fg:ansigreen bold" if is_command(bare) else "fg:ansired"
+                        state = "arg"
+                elif state == "if":
+                    if low in ("not", "/i"):
+                        style = "fg:ansimagenta"
+                    elif low in ("exist", "errorlevel", "defined"):
+                        style, state, skip = "fg:ansimagenta", "skip", 1
+                    elif "==" in bare and bare != "==":
+                        state = "cmd"
+                    else:
+                        state, skip = "skip", 2
+                elif state == "skip":
+                    skip -= 1
+                    if skip <= 0:
+                        state = "cmd"
+                out.append((style or arg_style(t), t))
+            return out
+        return get_line
+
+
+def programs():
+    global _prog_cache
+    if _prog_cache is None:
+        exts = tuple(e.lower() for e in os.environ.get("PATHEXT", ".COM;.EXE;.BAT;.CMD").split(";")) if IS_WIN else ()
+        found = set()
+        for d in os.environ.get("PATH", "").split(os.pathsep):
+            try:
+                for n in os.listdir(d):
+                    if IS_WIN:
+                        base, ext = os.path.splitext(n)
+                        if ext.lower() in exts: found.add(base.lower())
+                    elif os.access(os.path.join(d, n), os.X_OK):
+                        found.add(n)
+            except OSError:
+                pass
+        _prog_cache = found
+    return _prog_cache
+
+
+class CmdCompleter(Completer):
+    DIR_CMDS = {"cd", "chdir", "rd", "rmdir", "pushd", "tree"}
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        m = re.search(r'("[^"]*|[^\s&|<>"]*)$', text)
+        raw, before = m.group(1), text[:m.start()]
+        word, quote, start = raw.lstrip('"'), raw.startswith('"'), -len(raw)
+        seg = re.split(r"&&|\|\||[&|]", before)[-1].split()
+        at_cmd = not seg and not re.search(r"[<>]\s*$", before)
+
+        if word.startswith("%"):
+            pre = word[1:].upper()
+            for k in sorted(os.environ):
+                if k.upper().startswith(pre):
+                    yield Completion(f"%{k}%", start_position=start, display_meta="variable")
+            return
+        if at_cmd and not re.search(r"[\\/]", word):
+            pool = {n: "builtin" for n in BUILTINS}
+            pool.update({n: "macro" for n in aliases})
+            for n in programs():
+                pool.setdefault(n, "program")
+            for n in sorted(pool):
+                if n.lower().startswith(word.lower()):
+                    yield Completion(n, start_position=start, display_meta=pool[n])
+            return
+        dirs_only = bool(seg) and seg[0].lower() in self.DIR_CMDS
+        d, base = os.path.split(word)
+        try:
+            names = os.listdir(os.path.expanduser(d) if d else ".")
+        except OSError:
+            return
+        for n in sorted(names, key=str.lower):
+            if not n.lower().startswith(base.lower()):
+                continue
+            full = os.path.join(d, n) if d else n
+            isdir = os.path.isdir(full)
+            if dirs_only and not isdir:
+                continue
+            out = full + (os.sep if isdir else "")
+            if " " in out or quote:
+                out = '"' + out + ("" if isdir else '"')
+            yield Completion(out, start_position=start, display=n + (os.sep if isdir else ""))
+
+
+# ---------------------------------------------------------------- Windows Terminal profile
+PROFILE_GUID = "{9d4b7e32-6a1c-4c8f-b5d0-3e8a2f1c7b64}"
+FROZEN = getattr(sys, "frozen", False)      # True when running as neoshell.exe
+TERM_SCHEME = {
+    "name": "neoshell",
+    "background": "#0F1420", "foreground": "#D7DEEA",
+    "cursorColor": "#4DE1FF", "selectionBackground": "#25324D",
+    "black": "#1B2233", "red": "#FF6B81", "green": "#5BEAA0", "yellow": "#FFD479",
+    "blue": "#6EA8FF", "purple": "#C792FF", "cyan": "#4DE1FF", "white": "#D7DEEA",
+    "brightBlack": "#5C6B8A", "brightRed": "#FF8FA1", "brightGreen": "#8BF5BE",
+    "brightYellow": "#FFE3A0", "brightBlue": "#9CC4FF", "brightPurple": "#DDB8FF",
+    "brightCyan": "#8CEBFF", "brightWhite": "#FFFFFF",
+}
+
+
+def _profile_paths():
+    local = os.environ.get("LOCALAPPDATA")       # only set on Windows
+    if not local:
+        return None
+    return (os.path.join(local, "neoshell"),
+            os.path.join(local, "Microsoft", "Windows Terminal", "Fragments", "neoshell"))
+
+
+def _resource(name):
+    base = getattr(sys, "_MEIPASS", os.path.dirname(os.path.abspath(__file__)))
+    return os.path.join(base, name)
+
+
+def _self_path():
+    return os.path.abspath(sys.executable if FROZEN else __file__)
+
+
+def _profile_command(inst):
+    if FROZEN:
+        return f'"{os.path.join(inst, "neoshell.exe")}"'
+    return f'"{sys.executable}" "{os.path.join(inst, "neoshell.py")}"'
+
+
+def _remove_legacy():
+    """Remove the profile + install folder from when this program was called pyshell."""
+    local = os.environ.get("LOCALAPPDATA")
+    if not local:
+        return False
+    old_frag = os.path.join(local, "Microsoft", "Windows Terminal", "Fragments", "pyshell")
+    found = os.path.isdir(old_frag) or os.path.isdir(os.path.join(local, "pyshell"))
+    shutil.rmtree(old_frag, ignore_errors=True)
+    shutil.rmtree(os.path.join(local, "pyshell"), ignore_errors=True)
+    return found
+
+
+def install_profile():
+    """Copy neoshell to %LOCALAPPDATA%\\neoshell and register a Windows Terminal profile.
+
+    Uses a Windows Terminal "fragment" file, so the user's settings.json is never edited."""
+    paths = _profile_paths()
+    if not paths:
+        print("Windows Terminal profiles need Windows."); return False
+    inst, frag_dir = paths
+    target = os.path.join(inst, "neoshell.exe" if FROZEN else "neoshell.py")
+    try:
+        os.makedirs(inst, exist_ok=True)
+        if _self_path().lower() != os.path.abspath(target).lower():
+            shutil.copy2(_self_path(), target)
+        icon = os.path.join(inst, "neoshell.ico")
+        if os.path.isfile(_resource("neoshell.ico")):
+            shutil.copy2(_resource("neoshell.ico"), icon)
+        profile = {"guid": PROFILE_GUID, "name": "neoshell", "commandline": _profile_command(inst),
+                   "startingDirectory": "%USERPROFILE%", "colorScheme": "neoshell",
+                   "tabTitle": "neoshell", "padding": "10", "cursorShape": "bar"}
+        if os.path.isfile(icon):
+            profile["icon"] = icon
+        os.makedirs(frag_dir, exist_ok=True)
+        with open(os.path.join(frag_dir, "neoshell.json"), "w", encoding="utf-8") as f:
+            json.dump({"profiles": [profile], "schemes": [TERM_SCHEME]}, f, indent=2)
+    except OSError as e:
+        print(paint(f"Could not install the profile: {e}", "31")); return False
+    if _remove_legacy():
+        print("  (removed the old 'pyshell' profile)")
+    print(paint("Windows Terminal profile installed.", "32"))
+    print(f"  Restart Windows Terminal, then pick 'neoshell' from the dropdown (the arrow next to +).")
+    print(f"  Make it the default: Settings > Startup > Default profile.  Installed in {inst}")
+    return True
+
+
+def uninstall_profile():
+    paths = _profile_paths()
+    if not paths:
+        print("Nothing to remove (not Windows)."); return False
+    inst, frag_dir = paths
+    shutil.rmtree(frag_dir, ignore_errors=True)
+    shutil.rmtree(inst, ignore_errors=True)
+    _remove_legacy()
+    print("Profile removed. Restart Windows Terminal." +
+          (f"\nIf {inst} is still there, close neoshell and delete it." if os.path.isdir(inst) else ""))
+    return True
+
+
+def profile_current():
+    """True if the registered profile already points at an up-to-date install."""
+    paths = _profile_paths()
+    if not paths:
+        return True
+    inst, frag_dir = paths
+    if os.path.isdir(os.path.join(os.path.dirname(frag_dir), "pyshell")):
+        return False                             # old pyshell profile still registered
+    if os.path.dirname(_self_path()).lower() == os.path.abspath(inst).lower():
+        return True                              # we ARE the installed copy
+    try:
+        with open(os.path.join(frag_dir, "neoshell.json"), encoding="utf-8") as f:
+            if json.load(f)["profiles"][0]["commandline"] != _profile_command(inst):
+                return False
+        if FROZEN:                               # newer exe than the installed one -> update it
+            return os.path.getsize(os.path.join(inst, "neoshell.exe")) == os.path.getsize(sys.executable)
+    except (OSError, ValueError, KeyError, IndexError):
+        return False
+    return True
+
+
+def start_in_home():
+    """Don't leave the user in System32 / Program Files / neoshell's own folder.
+
+    Double-clicking the exe starts it in an awkward place. In those cases move to the
+    logged-in user's folder. If the user opened neoshell in a folder on purpose (for
+    example "Open in Terminal" from Explorer), leave it alone."""
+    home = os.path.expanduser("~")
+    if not os.path.isdir(home):
+        return
+    norm = lambda x: os.path.abspath(x).lower().rstrip("\\/")
+    here = norm(os.getcwd())
+    exact = {norm(os.path.dirname(_self_path()))}
+    if _profile_paths():
+        exact.add(norm(_profile_paths()[0]))
+    prefixes = [norm(os.environ[v]) for v in ("SystemRoot", "ProgramFiles", "ProgramFiles(x86)")
+                if os.environ.get(v)]
+    if here in exact or any(here == p or here.startswith(p + os.sep) for p in prefixes):
+        os.chdir(home)
+
+
+# ---------------------------------------------------------------- main loop
+def prompt_text():
+    parts = [("fg:ansiblue bold", os.getcwd())]
+    br = git_branch()
+    if br:
+        parts.append(("fg:ansimagenta", f" ({br})"))
+    parts.append(("fg:ansigreen bold" if last_status == 0 else "fg:ansired bold", " > "))
+    return parts
+
+
+def rprompt_text():
+    bits = []
+    if last_status:
+        bits.append(("fg:ansired", f"x{last_status} "))
+    if last_dur >= 1:
+        bits.append(("fg:ansibrightblack", f"{last_dur:.1f}s "))
+    bits.append(("fg:ansibrightblack", time.strftime("%H:%M")))
+    return bits
+
+
+LOGO = ["┏┓╻┏━╸┏━┓┏━┓╻ ╻┏━╸╻  ╻  ",
+        "┃┗┫┣╸ ┃ ┃┗━┓┣━┫┣╸ ┃  ┃  ",
+        "╹ ╹┗━╸┗━┛┗━┛╹ ╹┗━╸┗━╸┗━╸"]
+
+
+def banner():
+    """Gradient ASCII logo (cyan -> violet, same colors as the app icon)."""
+    if not sys.stdout.isatty():
+        print(f"neoshell {VERSION}"); return
+    c1, c2 = (77, 225, 255), (199, 146, 255)
+    width = max(len(r) for r in LOGO)
+    print()
+    for row in LOGO:
+        out = ""
+        for x, ch in enumerate(row):
+            t = x / max(1, width - 1)
+            r, g, b = (int(c1[i] + (c2[i] - c1[i]) * t) for i in range(3))
+            out += f"\033[38;2;{r};{g};{b}m{ch}"
+        print("  " + out + "\033[0m")
+    print(f"  \033[90mCMD-style shell · v{VERSION} · type \033[0m\033[1mhelp\033[0m\033[90m for commands\033[0m\n")
+
+
+def main():
+    global session, last_dur
+    argv = sys.argv[1:]
+    if "--uninstall" in argv:
+        return 0 if uninstall_profile() else 1
+    if "--install" in argv:
+        return 0 if install_profile() else 1
+    no_install = "--no-install" in argv
+    if argv[:1] == ["-c"]:
+        try:
+            run_line(" ".join(argv[1:]))
+        except SystemExit as e:
+            return e.code or 0
+        return last_status
+
+    old_hist = os.path.expanduser("~/.pyshell_history")
+    if os.path.isfile(old_hist) and not os.path.isfile(HIST):
+        with contextlib.suppress(OSError):
+            shutil.copy2(old_hist, HIST)
+    if HAVE_PT:
+        session = PromptSession(history=FileHistory(HIST), auto_suggest=AutoSuggestFromHistory(),
+                                lexer=CmdLexer(), completer=CmdCompleter(),
+                                complete_while_typing=False)
+        read = lambda: session.prompt(prompt_text, rprompt=rprompt_text)
+    else:
+        print("(tip: pip install prompt_toolkit for syntax highlighting and tab completion)")
+        read = lambda: input(f"{os.getcwd()}> ")
+
+    start_in_home()
+    b_title(["neoshell"])
+    banner()
+    if FROZEN and not no_install and _profile_paths() and not profile_current():
+        install_profile()
+        print()
+    while True:
+        try:
+            line = read()
+        except KeyboardInterrupt:
+            continue
+        except EOFError:
+            print(); break
+        t0 = time.time()
+        try:
+            run_line(line)
+        except SystemExit as e:
+            return e.code or 0
+        except KeyboardInterrupt:
+            print("^C")
+        except Exception as e:
+            print(paint(f"neoshell error: {e}", "31"))
+        last_dur = time.time() - t0
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())