seedcode-cli 6.1.5__py3-none-any.whl

seedcode/apps/discovery.py

@@ -0,0 +1,241 @@
+"""Application discovery across trusted Windows sources.
+
+The ladder, cheapest and most trustworthy first (all injectable):
+
+1. **Start Menu shortcuts** (``.lnk``) — the canonical user-visible app list;
+   both per-user and all-users Start Menus are scanned.
+2. **App Paths registry** — per-machine/per-user registered executables
+   (``HKLM\\...\\App Paths\\spotify.exe``).
+3. **Uninstall registrations** — installed-app metadata (name, install
+   location, display icon), the same source "Add/Remove Programs" reads.
+4. **PATH lookup** — ``shutil.which`` for CLI tools and portable apps.
+
+Every source is matched case-insensitively on the requested name; the
+requester gets one :class:`AppInfo` with the safest available launch target.
+Non-Windows platforms return "not found" rather than guessing.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from ..core.errors import ApplicationNotFoundError
+
+
+@dataclass(slots=True)
+class AppInfo:
+    """One discovered application."""
+
+    name: str
+    source: str                    # start_menu | app_paths | uninstall | path
+    target: str = ""               # shortcut path or executable
+    exe: str = ""                  # resolved executable path ("" when unknown)
+    install_location: str = ""
+    pid: int = 0                   # set by the launcher/verifier, not discovery
+    matched: str = ""              # which discovery key matched
+
+    def describe(self) -> str:
+        via = f" via {self.source}" if self.source else ""
+        return f'"{self.name}"{via}'
+
+
+# Directory-name fragments for the two Start Menu program folders.
+_START_MENU_DIRS = (
+    Path(os.environ.get("APPDATA", "")) / "Microsoft" / "Windows" / "Start Menu" / "Programs",
+    Path(os.environ.get("PROGRAMDATA", "")) / "Microsoft" / "Windows" / "Start Menu" / "Programs",
+)
+
+
+def _iter_start_menu() -> list[Path]:
+    shortcuts: list[Path] = []
+    for base in _START_MENU_DIRS:
+        try:
+            if base.is_dir():
+                shortcuts.extend(base.rglob("*.lnk"))
+        except OSError:
+            continue
+    return shortcuts
+
+
+def _shortcut_display_name(path: Path) -> str:
+    """A .lnk file's user-visible name: its stem (no resolution needed)."""
+    return path.stem.strip()
+
+
+def _match_name(haystack: str, needle: str) -> bool:
+    """Case-insensitive whole-word-ish containment match."""
+    h = " ".join(haystack.lower().split())
+    n = " ".join(needle.lower().split())
+    return bool(n) and (n == h or n in h)
+
+
+# --- source 2: App Paths -----------------------------------------------------------
+def _app_paths() -> dict[str, AppInfo]:
+    """``App Paths`` registrations: exe name -> full path (best-effort)."""
+    found: dict[str, AppInfo] = {}
+    if os.name != "nt":
+        return found
+    try:
+        import winreg
+
+        for hive, flag in ((winreg.HKEY_LOCAL_MACHINE, 0), (winreg.HKEY_CURRENT_USER, 0)):
+            try:
+                root = winreg.OpenKey(hive, r"Software\Microsoft\Windows\CurrentVersion\App Paths", 0, winreg.KEY_READ | flag)
+            except OSError:
+                continue
+            with root:
+                i = 0
+                while True:
+                    try:
+                        subkey_name = winreg.EnumKey(root, i)
+                    except OSError:
+                        break
+                    i += 1
+                    try:
+                        with winreg.OpenKey(root, subkey_name) as sub:
+                            exe_path, _t = winreg.QueryValueEx(sub, "")
+                    except OSError:
+                        continue
+                    name = Path(subkey_name).stem
+                    found[name.lower()] = AppInfo(
+                        name=name, source="app_paths",
+                        target=str(exe_path or ""), exe=str(exe_path or ""),
+                        matched=subkey_name,
+                    )
+    except ImportError:
+        pass
+    return found
+
+
+# --- source 3: uninstall registrations ----------------------------------------------
+def _uninstall_apps() -> dict[str, AppInfo]:
+    """Display-name/install-location entries from the uninstall keys."""
+    found: dict[str, AppInfo] = {}
+    if os.name != "nt":
+        return found
+    try:
+        import winreg
+
+        paths = (
+            r"Software\Microsoft\Windows\CurrentVersion\Uninstall",
+            r"Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall",
+        )
+        for hive in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER):
+            for subpath in paths:
+                try:
+                    root = winreg.OpenKey(hive, subpath, 0, winreg.KEY_READ)
+                except OSError:
+                    continue
+                with root:
+                    i = 0
+                    while True:
+                        try:
+                            subkey_name = winreg.EnumKey(root, i)
+                        except OSError:
+                            break
+                        i += 1
+                        try:
+                            with winreg.OpenKey(root, subkey_name) as sub:
+                                display, _t = winreg.QueryValueEx(sub, "DisplayName")
+                                try:
+                                    loc, _t2 = winreg.QueryValueEx(sub, "InstallLocation")
+                                except OSError:
+                                    loc = ""
+                        except OSError:
+                            continue
+                        name = str(display or "").strip()
+                        if not name:
+                            continue
+                        entry = AppInfo(
+                            name=name, source="uninstall",
+                            install_location=str(loc or ""),
+                            matched=subkey_name,
+                        )
+                        found.setdefault(name.lower(), entry)
+    except ImportError:
+        pass
+    return found
+
+
+# --- the discovery facade -------------------------------------------------------------
+def find_app(name: str, *, start_menu: list[Path] | None = None) -> AppInfo:
+    """Locate an installed application by (fuzzy) name.
+
+    ``start_menu`` injects the shortcut list for tests. Raises
+    :class:`ApplicationNotFoundError` when every source misses.
+    """
+    wanted = (name or "").strip()
+    if not wanted:
+        raise ApplicationNotFoundError("An application name is required.")
+
+    # 1) Start Menu shortcuts — the canonical list. Prefer exact stem matches.
+    shortcuts = _iter_start_menu() if start_menu is None else start_menu
+    exact: Path | None = None
+    partial: Path | None = None
+    for path in shortcuts:
+        display = _shortcut_display_name(path)
+        if display.lower() == wanted.lower():
+            exact = path
+            break
+        if partial is None and _match_name(display, wanted):
+            partial = path
+    chosen = exact or partial
+    if chosen is not None:
+        return AppInfo(
+            name=_shortcut_display_name(chosen), source="start_menu",
+            target=str(chosen), matched=str(chosen),
+        )
+
+    # 2) App Paths (spotify.exe -> full path).
+    for app_name, info in _app_paths().items():
+        if _match_name(app_name, wanted):
+            return info
+
+    # 3) Uninstall registrations (covers apps without Start Menu entries).
+    for app_name, info in _uninstall_apps().items():
+        if _match_name(app_name, wanted):
+            # Uninstall entries know the location but not the exe; a launch
+            # attempt will resolve the target from the install location.
+            if info.install_location:
+                loc = Path(info.install_location)
+                for candidate in (wanted.lower(), wanted.lower().replace(" ", "")):
+                    exe = loc / f"{candidate}.exe"
+                    if exe.is_file():
+                        info.exe = str(exe)
+                        info.target = str(exe)
+                        break
+            return info
+
+    # 4) PATH — CLI tools and portable apps.
+    which = shutil.which(wanted)
+    if which:
+        return AppInfo(
+            name=wanted, source="path", target=which, exe=which, matched=which
+        )
+
+    raise ApplicationNotFoundError(
+        f'"{wanted}" is not installed (searched Start Menu, App Paths, '
+        "installed-app registrations, and PATH)."
+    )
+
+
+def installed_apps(*, start_menu: list[Path] | None = None) -> list[AppInfo]:
+    """Every discoverable app (Start Menu + App Paths), name-deduplicated.
+
+    Used by memory and by "what can I open?" queries; not for matching.
+    """
+    seen: dict[str, AppInfo] = {}
+    shortcuts = _iter_start_menu() if start_menu is None else start_menu
+    for path in shortcuts:
+        display = _shortcut_display_name(path)
+        if display and display.lower() not in seen:
+            seen[display.lower()] = AppInfo(
+                name=display, source="start_menu", target=str(path), matched=str(path)
+            )
+    for key, info in _app_paths().items():
+        seen.setdefault(key, info)
+    return sorted(seen.values(), key=lambda a: a.name.lower())

seedcode/apps/installer.py

@@ -0,0 +1,164 @@
+"""Permission-gated application installation (missing-app workflow).
+
+When a requested application is not installed, the flow is:
+
+    missing app → resolve a trusted source → SHOW the user exactly what will
+    be installed and from where → explicit confirmation (INSTALL category,
+    never remembered) → download/execute → verify installed → launch.
+
+Security properties:
+
+* The INSTALL category is **sensitive**: "always allow" is impossible by
+  construction (the permission layer downgrades it), so every install asks.
+* Only **trusted sources** are eligible: Winget (preferred), Microsoft
+  Store, or a caller-supplied official vendor URL. Arbitrary URLs the model
+  produces are refused by :func:`_trusted_source`.
+* The model cannot mark anything trusted; trust comes from the winget
+  manifest registry or a user-supplied URL, never from model output.
+* Installers are executed only after the user confirms the exact source
+  shown to them.
+
+The actual winget invocation is injectable so tests never touch a system.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import Any
+
+from ..core.errors import ApplicationNotFoundError, SecurityError
+from .discovery import AppInfo
+
+# Seconds before a winget invocation is declared wedged.
+_WINGET_TIMEOUT_S = 600
+
+
+@dataclass(slots=True)
+class InstallPlan:
+    """What would be installed, shown to the user before confirmation."""
+
+    app_name: str
+    mechanism: str        # winget | store | manual
+    package_id: str = ""  # winget package id, when known
+    source: str = ""      # human-readable source description
+    detail: str = ""
+
+    def describe(self) -> str:
+        lines = [f"Install {self.app_name} via {self.mechanism}"]
+        if self.package_id:
+            lines.append(f"  package: {self.package_id}")
+        if self.source:
+            lines.append(f"  source: {self.source}")
+        return "\n".join(lines)
+
+
+@dataclass(slots=True)
+class InstallResult:
+    success: bool
+    app_name: str
+    detail: str = ""
+
+
+# --- trusted source resolution ------------------------------------------------------
+def _winget_package(app_name: str, run: Any = None) -> InstallPlan | None:
+    """A winget plan for ``app_name``, or None when winget can't find one."""
+    if shutil.which("winget") is None:
+        return None
+    if run is None:
+        def run(args: list[str]) -> subprocess.CompletedProcess:
+            return subprocess.run(  # noqa: S603 — fixed argv, no shell
+                args, capture_output=True, text=True, timeout=60
+            )
+    try:
+        search = run(["winget", "search", "--id", app_name, "--accept-source-agreements"])
+        out = (search.stdout or "") + (search.stderr or "")
+        # winget prints a table; any non-error row mentioning the name counts.
+        if search.returncode == 0 and app_name.lower() in out.lower():
+            return InstallPlan(
+                app_name=app_name, mechanism="winget", package_id=app_name,
+                source="winget (curated package registry)",
+                detail=f"winget found a package matching '{app_name}'",
+            )
+    except Exception:
+        return None
+    return None
+
+
+def resolve_install_plan(app_name: str, *, run: Any = None) -> InstallPlan:
+    """A trusted install plan for a missing app, or an error.
+
+    Only winget is currently wired; Microsoft Store routes through winget on
+    modern Windows. If nothing trusted exists, the user is told to install
+    it manually — SeedCode never fetches an arbitrary installer URL.
+    """
+    plan = _winget_package(app_name, run=run)
+    if plan is not None:
+        return plan
+    raise SecurityError(
+        f'No trusted installation source found for "{app_name}". SeedCode '
+        "will not download installers from arbitrary websites. Install it "
+        "manually (official site or Microsoft Store), then ask me to open it."
+    )
+
+
+def install_app(
+    app_name: str,
+    *,
+    confirm: Any,
+    run: Any = None,
+    find: Any = None,
+    launch: Any = None,
+) -> InstallResult:
+    """The guarded install workflow. ``confirm(plan_description) -> bool``.
+
+    ``confirm`` is wired to the interactive permission dialog by the caller
+    (skill/tools layer); it is asked AFTER the plan (mechanism + package +
+    source) is shown and is the only path to executing anything.
+    """
+    from ..core.errors import OperatorError
+
+    try:
+        plan = resolve_install_plan(app_name, run=run)
+    except OperatorError:
+        raise
+
+    if not confirm(plan.describe()):
+        return InstallResult(
+            False, app_name, "installation declined by the user"
+        )
+
+    # Execute via winget with a fixed, audited argv.
+    if run is None:
+        def run(args: list[str], **kw: Any) -> subprocess.CompletedProcess:
+            return subprocess.run(  # noqa: S603 — fixed argv, no shell
+                args, capture_output=True, text=True, timeout=_WINGET_TIMEOUT_S
+            )
+    try:
+        proc = run([
+            "winget", "install", "--id", plan.package_id,
+            "--accept-source-agreements", "--accept-package-agreements",
+        ])
+    except Exception as exc:
+        return InstallResult(False, app_name, f"installer failed to run: {exc}")
+    ok = getattr(proc, "returncode", 1) == 0
+    if not ok:
+        tail = ((getattr(proc, "stderr", "") or "") or (getattr(proc, "stdout", "") or "")).strip()
+        return InstallResult(False, app_name, f"installer returned an error: {tail[:300]}")
+
+    # Verify installation actually happened (discovery must now find it).
+    if find is None:
+        from .discovery import find_app as find
+    try:
+        find(app_name)
+    except ApplicationNotFoundError:
+        return InstallResult(
+            False, app_name,
+            "installer reported success but the app is not discoverable yet; "
+            "it may need a moment or a fresh Start Menu index",
+        )
+    return InstallResult(True, app_name, f"installed {app_name} via {plan.mechanism}")
+
+
+__all__ = ["InstallPlan", "InstallResult", "resolve_install_plan", "install_app"]

seedcode/apps/launcher.py

@@ -0,0 +1,156 @@
+"""Application launching with state-based waiting and duplicate avoidance.
+
+The launch workflow never spawns blindly:
+
+1. **Running?** Match open windows against the app name (via the windows
+   driver, which already excludes SeedCode's own console). A visible window
+   means *focus the existing instance* instead of launching a duplicate.
+2. **Launch** through the safest target: a Start Menu shortcut
+   (``os.startfile`` resolves it), then a resolved executable, then the
+   shell ``start`` fallback — never a guessed bare ``subprocess`` call.
+3. **Wait for state, not for a timer:** poll for a matching window/process
+   up to ``MAX_WAIT_WINDOW_S`` instead of a fixed sleep.
+4. **Verify** and return a structured result; the caller (skill) reports
+   success only when evidence exists.
+
+All OS interaction is injectable for tests.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import time
+from dataclasses import dataclass
+from typing import Any
+
+from ..core.errors import ApplicationLaunchError, ApplicationNotFoundError
+from ..core.limits import MAX_WAIT_WINDOW_S, MAX_WAIT_POLL_S, clamp_wait
+from .discovery import AppInfo, find_app
+from .verifier import app_running, wait_for_app_window
+
+
+@dataclass(slots=True)
+class LaunchResult:
+    """Structured outcome of one open-app attempt."""
+
+    success: bool
+    application: str
+    focused_existing: bool = False
+    window_detected: bool = False
+    window_title: str = ""
+    pid: int = 0
+    detail: str = ""
+
+    def describe(self) -> str:
+        return self.detail or (f"{self.application}: "
+                               + ("focused existing window" if self.focused_existing
+                                  else "launched")
+                               + (" (window verified)" if self.window_detected else ""))
+
+
+def focus_existing(app: AppInfo, windows_driver: Any = None) -> LaunchResult | None:
+    """Focus a running instance if one exists; None when not running.
+
+    Matching uses the window list (titles already exclude our console) and,
+    where available, the owning process name — never a blind title guess.
+    """
+    if windows_driver is None:
+        from ..computer import windows as windows_driver  # type: ignore
+    needle = app.name.lower()
+    try:
+        wins = windows_driver.list_windows()
+    except Exception:
+        return None
+    for w in wins:
+        title = (getattr(w, "title", "") or "").lower()
+        if needle in title:
+            try:
+                windows_driver.focus_window(w.title)
+            except Exception:
+                pass  # focus is best-effort; window evidence stands
+            return LaunchResult(
+                success=True, application=app.name, focused_existing=True,
+                window_detected=True, window_title=getattr(w, "title", ""),
+                pid=int(getattr(w, "pid", 0) or 0),
+                detail=f'focused existing window "{getattr(w, "title", "")}"',
+            )
+    return None
+
+
+def launch_app(
+    name: str,
+    *,
+    find: Any = find_app,
+    windows_driver: Any = None,
+    startfile: Any = None,
+    popen: Any = None,
+    wait_s: float = MAX_WAIT_WINDOW_S,
+) -> LaunchResult:
+    """Open an application: reuse → launch → wait → verify.
+
+    Injectable parameters exist purely for tests; production callers pass
+    only ``name``.
+    """
+    if startfile is None:
+        def startfile(target: str) -> None:
+            os.startfile(target)  # noqa: S606 — shell-resolved launch
+    if popen is None:
+        def popen(argv: list[str]) -> subprocess.Popen:
+            return subprocess.Popen(  # noqa: S603 — resolved target only
+                argv, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+            )
+
+    try:
+        app = find(name)
+    except ApplicationNotFoundError:
+        raise  # the caller (skill) turns this into the install-permission flow
+
+    # Step 1: already running? Focus, don't duplicate.
+    existing = focus_existing(app, windows_driver)
+    if existing is not None:
+        return existing
+
+    # Step 2: launch via the safest target.
+    target = app.target or app.exe
+    if not target:
+        raise ApplicationLaunchError(
+            f'"{app.name}" is installed but exposes no launchable target.'
+        )
+    launched_via = "shortcut" if app.source == "start_menu" else "executable"
+    try:
+        if app.source == "start_menu" or target.lower().endswith(".lnk"):
+            startfile(target)
+        else:
+            popen([target])
+    except OSError as exc:
+        raise ApplicationLaunchError(f'Could not launch "{app.name}": {exc}')
+
+    # Step 3+4: state-based wait for a real window (no blind sleep).
+    window = wait_for_app_window(app, windows_driver, timeout_s=wait_s)
+    if window is not None:
+        return LaunchResult(
+            success=True, application=app.name, window_detected=True,
+            window_title=window, pid=app.pid,
+            detail=f'launched {app.name} via {launched_via}; window "{window}" detected',
+        )
+    # No window yet: accept a running process as weaker evidence.
+    pid = app_running(app, windows_driver)
+    if pid:
+        return LaunchResult(
+            success=True, application=app.name, window_detected=False,
+            pid=pid, detail=f"launched {app.name} (process running, no window yet)",
+        )
+    return LaunchResult(
+        success=False, application=app.name,
+        detail=f"launched {app.name} but no window or process evidence within {wait_s:g}s",
+    )
+
+
+def open_or_raise(name: str, **kw: Any) -> LaunchResult:
+    """Convenience wrapper: find+launch, translating discovery misses."""
+    return launch_app(name, **kw)
+
+
+__all__ = ["LaunchResult", "launch_app", "focus_existing", "open_or_raise"]

seedcode/apps/verifier.py

@@ -0,0 +1,119 @@
+"""Application launch verification: evidence, not assumptions.
+
+``launch`` alone proves nothing on Windows — the shell accepts the request
+and the app may crash a second later. This module checks for *evidence*
+that the application actually came up:
+
+* a window whose title matches the app (strong evidence), or
+* a running process whose name matches (weaker evidence), via the window
+  list's owning pids (psutil when present, best-effort).
+
+``wait_for_app_window`` polls — it never sleeps blindly — and returns the
+matched window title, or None after the bounded timeout.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from ..core.limits import MAX_WAIT_WINDOW_S, MAX_WAIT_POLL_S, clamp_wait
+from .discovery import AppInfo
+
+
+def _process_names() -> set[int]:
+    """Pids of running processes whose name plausibly matches apps (best-effort)."""
+    pids: set[int] = set()
+    try:
+        import psutil  # type: ignore
+
+        for proc in psutil.process_iter(["pid"]):
+            try:
+                pids.add(int(proc.info["pid"]))
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return pids
+
+
+def _window_fragments(app: AppInfo) -> list[str]:
+    """Title fragments that identify this app's windows."""
+    name = (app.name or "").lower().strip()
+    fragments = [name] if name else []
+    exe = (app.exe or "")
+    if exe:
+        stem = exe.replace("\\", "/").rsplit("/", 1)[-1]
+        stem = stem[:-4] if stem.lower().endswith(".exe") else stem
+        if stem:
+            fragments.append(stem.lower())
+    return fragments
+
+
+def find_app_window(app: AppInfo, windows_driver: Any = None) -> str | None:
+    """The title of a window belonging to ``app``, or None."""
+    if windows_driver is None:
+        from ..computer import windows as windows_driver  # type: ignore
+    try:
+        wins = windows_driver.list_windows()
+    except Exception:
+        return None
+    fragments = _window_fragments(app)
+    # Prefer process-id equality when the window carries one.
+    for w in wins:
+        if app.pid and int(getattr(w, "pid", 0) or 0) == app.pid:
+            return getattr(w, "title", "")
+    for w in wins:
+        title = (getattr(w, "title", "") or "").lower()
+        if any(f and f in title for f in fragments):
+            return getattr(w, "title", "")
+    return None
+
+
+def app_running(app: AppInfo, windows_driver: Any = None) -> int:
+    """The app's running pid (from windows/processes), or 0."""
+    if windows_driver is None:
+        from ..computer import windows as windows_driver  # type: ignore
+    try:
+        wins = windows_driver.list_windows()
+    except Exception:
+        wins = []
+    fragments = _window_fragments(app)
+    for w in wins:
+        title = (getattr(w, "title", "") or "").lower()
+        if any(f and f in title for f in fragments):
+            pid = int(getattr(w, "pid", 0) or 0)
+            if pid:
+                return pid
+    # No window: consult live processes by exe stem.
+    live = _process_names()
+    if not live:
+        return 0
+    try:
+        import psutil  # type: ignore
+
+        exe_stem = (app.exe or "").replace("\\", "/").rsplit("/", 1)[-1].lower()
+        for proc in psutil.process_iter(["pid", "name"]):
+            name = (proc.info.get("name") or "").lower()
+            if exe_stem and name == exe_stem:
+                return int(proc.info["pid"])
+    except Exception:
+        pass
+    return 0
+
+
+def wait_for_app_window(
+    app: AppInfo, windows_driver: Any = None, timeout_s: float = MAX_WAIT_WINDOW_S
+) -> str | None:
+    """Poll for the app's window until it appears or the timeout elapses."""
+    deadline = time.monotonic() + clamp_wait(timeout_s, MAX_WAIT_WINDOW_S)
+    while True:
+        title = find_app_window(app, windows_driver)
+        if title:
+            return title
+        if time.monotonic() >= deadline:
+            return None
+        time.sleep(MAX_WAIT_POLL_S)
+
+
+__all__ = ["find_app_window", "app_running", "wait_for_app_window"]

seedcode/assets/logo.txt

@@ -0,0 +1,15 @@
+ ███████╗███████╗███████╗██████╗      ██████╗ ██████╗ ██████╗ ███████╗
+ ██╔════╝██╔════╝██╔════╝██╔══██╗    ██╔════╝██╔═══██╗██╔══██╗██╔════╝
+ ███████╗█████╗  █████╗  ██║  ██║    ██║     ██║   ██║██║  ██║█████╗
+ ╚════██║██╔══╝  ██╔══╝  ██║  ██║    ██║     ██║   ██║██║  ██║██╔══╝
+ ███████║███████╗███████╗██████╔╝    ╚██████╗╚██████╔╝██████╔╝███████╗
+ ╚══════╝╚══════╝╚══════╝╚═════╝      ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
+
+                    S E E D   C O D E
+
+              Plant ideas. Grow code.
+
+                    Created by
+                 Al Shahriar Sowan
+
+        Vibe coded with GPT-5o & Claude Opus 4.8