aider-vision-core 0.90.5.dev0__tar.gz → 0.90.7.dev0__tar.gz

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aider-vision-core
-Version: 0.90.5.dev0
+Version: 0.90.7.dev0
 Summary: aider-vision-core: Aider fork with headless API, submodule git, and web integration
 Project-URL: Homepage, https://github.com/Digital-Defiance/aider-vision-core
 Classifier: Development Status :: 4 - Beta

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.90.5.dev0'
-__version_tuple__ = version_tuple = (0, 90, 5, 'dev0')
+__version__ = version = '0.90.7.dev0'
+__version_tuple__ = version_tuple = (0, 90, 7, 'dev0')
 
-__commit_id__ = commit_id = 'g8ffcb8225'
+__commit_id__ = commit_id = 'gd0a7f6a71'

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/coders/base_coder.py

@@ -29,7 +29,6 @@ from typing import List
 from rich.console import Console
 
 from aider_vision_core import __version__, models, prompts, urls, utils
-from aider_vision_core.brand import version_banner
 from aider_vision_core.analytics import Analytics
 from aider_vision_core.commands import Commands
 from aider_vision_core.exceptions import LiteLLMExceptions
@@ -210,7 +209,7 @@ class Coder:
 
     def get_announcements(self):
         lines = []
-        lines.append(version_banner())
+        lines.append(f"Aider v{__version__}")
 
         # Model
         main_model = self.main_model

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/event_io.py

@@ -5,7 +5,10 @@ Headless I/O that emits structured events for web/API consumers.
 from __future__ import annotations
 
 import json
-from typing import Any, Callable
+import os
+from typing import Any, Callable, TextIO
+
+from rich.console import Console
 
 from aider_vision_core.io import InputOutput
 
@@ -24,7 +27,21 @@ class EventIO(InputOutput):
         echo_to_console: bool = False,
         **kwargs,
     ):
-        super().__init__(fancy_input=False, **kwargs)
+        kwargs.setdefault("fancy_input", False)
+        kwargs.setdefault("pretty", False)
+        self._null_sink: TextIO | None = None
+        if not echo_to_console and kwargs.get("output") is None:
+            self._null_sink = open(os.devnull, "w", encoding="utf-8")
+            kwargs["output"] = self._null_sink
+        super().__init__(**kwargs)
+        sink = self.output if self.output is not None else self._null_sink
+        if sink is None:
+            self._null_sink = open(os.devnull, "w", encoding="utf-8")
+            sink = self._null_sink
+            self.output = sink
+        # InputOutput attaches Console to stdout; when the desktop app spawns core with
+        # stdout closed, Rich writes raise BrokenPipeError.
+        self.console = Console(file=sink, force_terminal=False, no_color=True)
         self.on_event = on_event
         self.echo_to_console = echo_to_console
         self.events: list[dict[str, Any]] = []
@@ -91,7 +108,24 @@ class EventIO(InputOutput):
             "EventIO does not support interactive input; send messages via Session.run_message()."
         )
 
+    def _tool_message(self, message="", strip=True, color=None):
+        if self.echo_to_console:
+            try:
+                super()._tool_message(message, strip, color)
+            except BrokenPipeError:
+                pass
+
+    def print(self, message=""):
+        if self.echo_to_console:
+            try:
+                super().print(message)
+            except BrokenPipeError:
+                pass
+
     def ai_output(self, content):
         self.emit("assistant_complete", text=content or "")
         if self.echo_to_console:
-            super().ai_output(content)
+            try:
+                super().ai_output(content)
+            except BrokenPipeError:
+                pass

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/git_workspace.py

@@ -124,18 +124,42 @@ def _submodule_status_paths(super_root: str) -> list[str]:
         line = line.strip()
         if not line:
             continue
+        # Format: [+-]<sha> <path> [(describe)]
         parts = line.split()
         if len(parts) >= 2:
-            paths.append(parts[-1])
+            paths.append(parts[1])
     return paths
 
 
+def _normalize_submodule_rel_path(path: str) -> str:
+    return path.replace("\\", "/").strip("/")
+
+
 def discover_submodule_paths_with_git(super_root: str) -> list[str]:
-    """Prefer git submodule status; fall back to parsing .gitmodules."""
-    paths = _submodule_status_paths(super_root)
-    if paths:
-        return paths
-    return discover_submodule_paths(super_root)
+    """
+    Submodule roots relative to the superproject, including nested (recursive) paths.
+
+    Merges ``git submodule status --recursive`` with a ``.gitmodules`` walk so
+    uninitialized or partially-checked-out nested submodules are still discovered.
+    """
+    root = Path(super_root)
+    candidates: list[str] = []
+    candidates.extend(_submodule_status_paths(super_root))
+    candidates.extend(discover_submodule_paths(super_root))
+
+    seen: set[str] = set()
+    valid: list[str] = []
+    for raw in candidates:
+        rel = _normalize_submodule_rel_path(raw)
+        if not rel or rel in seen:
+            continue
+        if not (root / rel).is_dir():
+            continue
+        seen.add(rel)
+        valid.append(rel)
+
+    # Deepest paths first (helps commit/undo ordering for nested gitlinks).
+    return sorted(valid, key=lambda p: (-p.count("/"), p))
 
 
 def create_git_workspace(io, fnames, git_dname, **git_repo_kwargs):
@@ -180,6 +204,7 @@ class RepoSet:
         self.repos: list[GitRepo] = [primary]
         seen_roots = {primary.root}
 
+        # submodule_paths are deepest-first; init every nested checkout we can open.
         for rel_path in submodule_paths:
             abs_path = Path(primary.root) / rel_path
             if not abs_path.is_dir():
@@ -195,6 +220,9 @@ class RepoSet:
 
         self.repos.sort(key=lambda r: len(Path(r.root).parts), reverse=True)
         self.last_commit_batch: list[dict] = []
+        self.submodule_rel_paths = frozenset(
+            _normalize_submodule_rel_path(p) for p in submodule_paths
+        )
 
     def repo_by_root(self, root: str) -> GitRepo | None:
         for repo in self.repos:
@@ -247,9 +275,6 @@ class RepoSet:
         abs_path = self._abs_path(path)
         return abs_path.relative_to(Path(self.root)).as_posix()
 
-    def abs_root_path(self, path):
-        return self.primary.abs_root_path(path)
-
     def normalize_path(self, path):
         return self.primary.normalize_path(self.path_in_workspace(path))
 
@@ -266,12 +291,26 @@ class RepoSet:
             if str(prefix) == ".":
                 prefix = Path("")
             for fname in repo.get_tracked_files():
+                posix_fname = fname.replace("\\", "/")
+                if not prefix:
+                    workspace_rel = posix_fname
+                    if workspace_rel in self.submodule_rel_paths:
+                        continue
+                    if self.primary.is_submodule_gitlink(posix_fname):
+                        continue
+                elif prefix:
+                    workspace_rel = f"{prefix.as_posix()}/{posix_fname}"
+                    if workspace_rel in self.submodule_rel_paths:
+                        continue
                 if prefix:
                     files.add((prefix / fname).as_posix())
                 else:
                     files.add(fname)
         return sorted(files)
 
+    def abs_root_path(self, path):
+        return str(self._abs_path(path))
+
     def ignored_file(self, fname):
         return self.primary.ignored_file(self.path_in_workspace(str(fname)))
 

aider_vision_core-0.90.7.dev0/aider_vision_core/headless_stdio.py

@@ -0,0 +1,28 @@
+"""
+Redirect or no-op terminal I/O when core runs under the Vision desktop spawn.
+"""
+
+from __future__ import annotations
+
+import os
+import signal
+import sys
+from typing import TextIO
+
+_installed = False
+_null_out: TextIO | None = None
+
+
+def headless_enabled() -> bool:
+    return os.environ.get("AIDER_VISION_HEADLESS") == "1"
+
+
+def install_headless_stdio() -> None:
+    global _installed, _null_out
+    if _installed or not headless_enabled():
+        return
+    _installed = True
+    if hasattr(signal, "SIGPIPE"):
+        signal.signal(signal.SIGPIPE, signal.SIG_IGN)
+    _null_out = open(os.devnull, "w", encoding="utf-8")
+    sys.stdout = _null_out

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/http_api.py

@@ -25,6 +25,10 @@ from pydantic import BaseModel, Field
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request
 
+from aider_vision_core.headless_stdio import install_headless_stdio
+
+install_headless_stdio()
+
 from aider_vision_core.git_undo import undo_last_aider_commit_for_coder
 from aider_vision_core.http_auth import auth_enabled, configure_auth, get_token_from_env, verify_bearer
 from aider_vision_core.session import Session
@@ -88,6 +92,15 @@ class SessionInfo(BaseModel):
     files_in_chat: list[str]
 
 
+class CommandInfo(BaseModel):
+    name: str
+    summary: str
+
+
+class CommandListResponse(BaseModel):
+    commands: list[CommandInfo]
+
+
 def _sse_pack(event: dict[str, Any]) -> str:
     return f"data: {json.dumps(event, ensure_ascii=False)}\n\n"
 
@@ -146,13 +159,39 @@ def delete_session(session_id: str):
     return {"deleted": session_id}
 
 
+@app.get("/sessions/{session_id}/commands", response_model=CommandListResponse)
+def list_commands(session_id: str):
+    session = _get_session(session_id)
+    commands = session.coder.commands.get_commands()
+    items: list[CommandInfo] = []
+    for cmd in sorted(commands):
+        key = cmd[1:].replace("-", "_")
+        method = getattr(session.coder.commands, f"cmd_{key}", None)
+        summary = ""
+        if method and method.__doc__:
+            summary = method.__doc__.strip().split("\n")[0]
+        items.append(CommandInfo(name=cmd, summary=summary))
+    return CommandListResponse(commands=items)
+
+
 @app.post("/sessions/{session_id}/messages")
 def post_message(session_id: str, body: MessageRequest):
     session = _get_session(session_id)
 
     def generate():
-        for event in session.run_message(body.content, preproc=body.preproc):
-            yield _sse_pack(event)
+        try:
+            for event in session.run_message(body.content, preproc=body.preproc):
+                yield _sse_pack(event)
+        except (BrokenPipeError, ConnectionResetError) as err:
+            yield _sse_pack({"type": "error", "text": str(err)})
+            yield _sse_pack({"type": "done", "error": True})
+        except OSError as err:
+            if err.errno != 32:
+                raise
+            yield _sse_pack({"type": "error", "text": str(err)})
+            yield _sse_pack({"type": "done", "error": True})
+        except GeneratorExit:
+            return
 
     return StreamingResponse(
         generate(),

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/io.py

@@ -40,7 +40,7 @@ from .editor import pipe_editor
 from .utils import is_image_file
 
 # Constants
-NOTIFICATION_MESSAGE = "Aider Vision Core is waiting for your input"
+NOTIFICATION_MESSAGE = "Aider is waiting for your input"
 
 
 def ensure_hash_prefix(color):
@@ -987,14 +987,10 @@ class InputOutput:
 
     def tool_error(self, message="", strip=True):
         self.num_error_outputs += 1
-        from aider_vision_core.brand import format_user_error
-
-        self._tool_message(format_user_error(message), strip, self.tool_error_color)
+        self._tool_message(message, strip, self.tool_error_color)
 
     def tool_warning(self, message="", strip=True):
-        from aider_vision_core.brand import format_user_error
-
-        self._tool_message(format_user_error(message), strip, self.tool_warning_color)
+        self._tool_message(message, strip, self.tool_warning_color)
 
     def tool_output(self, *messages, log_only=False, bold=False):
         if messages:

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/repo.py

@@ -430,6 +430,21 @@ class GitRepo:
 
         return diffs
 
+    def is_submodule_gitlink(self, path: str) -> bool:
+        """True when ``path`` is a submodule gitlink in this repo (mode 160000)."""
+        if not self.repo:
+            return False
+        path = self.normalize_path(path)
+        try:
+            out = self.repo.git.ls_files("-s", "--", path)
+        except ANY_GIT_ERROR:
+            return False
+        if not out or not str(out).strip():
+            return False
+        first_line = str(out).strip().splitlines()[0]
+        parts = first_line.split()
+        return len(parts) >= 1 and parts[0] == "160000"
+
     def get_tracked_files(self):
         if not self.repo:
             return []
@@ -484,6 +499,7 @@ class GitRepo:
             self.io.tool_error(f"Unable to read staged files: {err}")
 
         res = [fname for fname in files if not self.ignored_file(fname)]
+        res = [fname for fname in res if not self.is_submodule_gitlink(fname)]
 
         return res
 

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/repomap.py

@@ -1,7 +1,6 @@
 import colorsys
 import math
 import os
-import pickle
 import random
 import shutil
 import sqlite3
@@ -33,16 +32,15 @@ Tag = namedtuple("Tag", "rel_fname fname line name kind".split())
 SQLITE_ERRORS = (sqlite3.OperationalError, sqlite3.DatabaseError, OSError)
 
 
-CACHE_VERSION = 5
+CACHE_VERSION = 3
 if USING_TSL_PACK:
-    CACHE_VERSION = 5
+    CACHE_VERSION = 4
 
 UPDATING_REPO_MAP_MESSAGE = "Updating repo map"
 
 
 class RepoMap:
-    # Distinct from upstream `.aider.tags.cache.*` (pickles reference old `aider` module).
-    TAGS_CACHE_DIR = f".aider-vision-core.tags.cache.v{CACHE_VERSION}"
+    TAGS_CACHE_DIR = f".aider.tags.cache.v{CACHE_VERSION}"
 
     warned_files = set()
 
@@ -232,22 +230,6 @@ class RepoMap:
         except FileNotFoundError:
             self.io.tool_warning(f"File not found error: {fname}")
 
-    def _tags_cache_get(self, cache_key):
-        try:
-            return self.TAGS_CACHE.get(cache_key)  # Issue #1308
-        except SQLITE_ERRORS as e:
-            self.tags_cache_error(e)
-            return self.TAGS_CACHE.get(cache_key)
-        except (ModuleNotFoundError, pickle.UnpicklingError, AttributeError):
-            self._drop_tags_cache_key(cache_key)
-            return None
-
-    def _drop_tags_cache_key(self, cache_key):
-        try:
-            del self.TAGS_CACHE[cache_key]
-        except Exception:
-            pass
-
     def get_tags(self, fname, rel_fname):
         # Check if the file is in the cache and if the modification time has not changed
         file_mtime = self.get_mtime(fname)
@@ -255,7 +237,11 @@ class RepoMap:
             return []
 
         cache_key = fname
-        val = self._tags_cache_get(cache_key)
+        try:
+            val = self.TAGS_CACHE.get(cache_key)  # Issue #1308
+        except SQLITE_ERRORS as e:
+            self.tags_cache_error(e)
+            val = self.TAGS_CACHE.get(cache_key)
 
         if val is not None and val.get("mtime") == file_mtime:
             try:
@@ -263,8 +249,6 @@ class RepoMap:
             except SQLITE_ERRORS as e:
                 self.tags_cache_error(e)
                 return self.TAGS_CACHE[cache_key]["data"]
-            except (ModuleNotFoundError, pickle.UnpicklingError, AttributeError):
-                self._drop_tags_cache_key(cache_key)
 
         # miss!
         data = list(self.get_tags_raw(fname, rel_fname))

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/report.py

@@ -7,7 +7,6 @@ import urllib.parse
 import webbrowser
 
 from aider_vision_core import __version__
-from aider_vision_core.brand import DISPLAY_CORE, PRODUCT_CORE, launcher_context_lines
 from aider_vision_core.urls import github_issues
 from aider_vision_core.versioncheck import VERSION_CHECK_FNAME
 
@@ -45,23 +44,15 @@ def report_github_issue(issue_text, title=None, confirm=True):
     :param confirm: Whether to ask for confirmation before opening the browser (default: True)
     :return: None
     """
-    version_info = f"{DISPLAY_CORE} ({PRODUCT_CORE}) version: {__version__}\n"
+    version_info = f"Aider version: {__version__}\n"
     python_version = f"Python version: {sys.version.split()[0]}\n"
     platform_info = f"Platform: {platform.platform()}\n"
     python_info = get_python_info() + "\n"
     os_info = get_os_info() + "\n"
     git_info = get_git_info() + "\n"
-    launcher_info = "\n".join(launcher_context_lines())
 
     system_info = (
-        version_info
-        + python_version
-        + platform_info
-        + python_info
-        + os_info
-        + git_info
-        + (launcher_info + "\n" if launcher_info else "")
-        + "\n"
+        version_info + python_version + platform_info + python_info + os_info + git_info + "\n"
     )
 
     issue_text = system_info + issue_text
@@ -72,15 +63,10 @@ def report_github_issue(issue_text, title=None, confirm=True):
     issue_url = f"{github_issues}?{urllib.parse.urlencode(params)}"
 
     if confirm:
-        from aider_vision_core.brand import is_launched_by_vision, user_facing_name
-
-        product = user_facing_name() if is_launched_by_vision() else DISPLAY_CORE
         print(f"\n# {title}\n")
         print(issue_text.strip())
         print()
-        print(f"Please consider reporting this bug to help improve {product}!")
-        if is_launched_by_vision():
-            print(f"(Technical details above refer to {DISPLAY_CORE}.)")
+        print("Please consider reporting this bug to help improve aider!")
         prompt = "Open a GitHub Issue pre-filled with the above error in your browser? (Y/n) "
         confirmation = input(prompt).strip().lower()
 

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/scrape.py

@@ -8,9 +8,7 @@ import pypandoc
 from aider_vision_core import __version__, urls, utils
 from aider_vision_core.dump import dump  # noqa: F401
 
-from aider_vision_core.brand import PRODUCT_CORE
-
-aider_user_agent = f"{PRODUCT_CORE}/{__version__} +{urls.website}"
+aider_user_agent = f"Aider/{__version__} +{urls.website}"
 
 # Playwright is nice because it has a simple way to install dependencies on most
 # platforms.

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/session.py

@@ -105,7 +105,20 @@ class Session:
         assistant_text = []
 
         try:
-            for chunk in self.coder.run_stream(message):
+            self.coder.init_before_message()
+            self.io.user_input(message)
+
+            user_msg = message
+            if preproc:
+                user_msg = self.coder.preproc_user_input(message)
+
+            if user_msg is None:
+                for event in self.io.drain_events():
+                    yield event
+                yield self.io.emit("done", assistant_text="")
+                return
+
+            for chunk in self.coder.send_message(user_msg):
                 if chunk:
                     assistant_text.append(chunk)
                     event = self.io.emit("token", text=chunk)
@@ -126,6 +139,9 @@ class Session:
                 payload["commits"] = self.coder.aider_commit_stack[-1]
 
             yield self.io.emit("done", **payload)
+        except BrokenPipeError as err:
+            yield self.io.emit("error", text=str(err))
+            yield self.io.emit("done", assistant_text="".join(assistant_text), error=True)
         except Exception as err:
             yield self.io.emit("error", text=str(err))
             yield self.io.emit("done", assistant_text="".join(assistant_text), error=True)

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/vision_serve.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 
 
@@ -31,7 +32,13 @@ def run(argv: list[str] | None = None) -> None:
 
     validate_listen_address(args.host)
     configure_auth(args.host)
-    print(startup_message(args.host))
+
+    if os.environ.get("AIDER_VISION_HEADLESS") == "1":
+        from aider_vision_core.headless_stdio import install_headless_stdio
+
+        install_headless_stdio()
+    else:
+        print(startup_message(args.host))
 
     try:
         import uvicorn
@@ -44,4 +51,6 @@ def run(argv: list[str] | None = None) -> None:
         host=args.host,
         port=args.port,
         reload=args.reload,
+        log_level="warning",
+        access_log=not os.environ.get("AIDER_VISION_HEADLESS"),
     )

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core/waiting.py

@@ -13,6 +13,7 @@ Use it like:
     spinner.stop()
 """
 
+import os
 import sys
 import threading
 import time
@@ -20,6 +21,10 @@ import time
 from rich.console import Console
 
 
+def _headless() -> bool:
+    return os.environ.get("AIDER_VISION_HEADLESS") == "1"
+
+
 class Spinner:
     """
     Minimal spinner that scans a single marker back and forth across a line.
@@ -35,7 +40,7 @@ class Spinner:
         self.start_time = time.time()
         self.last_update = 0.0
         self.visible = False
-        self.is_tty = sys.stdout.isatty()
+        self.is_tty = not _headless() and sys.stdout.isatty()
         self.console = Console()
 
         # Pre-render the animation frames using pure ASCII so they will
@@ -185,11 +190,15 @@ class WaitingSpinner:
 
     def start(self):
         """Start the spinner in a background thread."""
+        if _headless():
+            return
         if not self._thread.is_alive():
             self._thread.start()
 
     def stop(self):
         """Request the spinner to stop and wait briefly for the thread to exit."""
+        if _headless():
+            return
         self._stop_event.set()
         if self._thread.is_alive():
             self._thread.join(timeout=self.delay)

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aider-vision-core
-Version: 0.90.5.dev0
+Version: 0.90.7.dev0
 Summary: aider-vision-core: Aider fork with headless API, submodule git, and web integration
 Project-URL: Homepage, https://github.com/Digital-Defiance/aider-vision-core
 Classifier: Development Status :: 4 - Beta

{aider_vision_core-0.90.5.dev0 → aider_vision_core-0.90.7.dev0}/aider_vision_core.egg-info/SOURCES.txt

@@ -28,7 +28,6 @@ aider_vision_core/_version.py
 aider_vision_core/analytics.py
 aider_vision_core/args.py
 aider_vision_core/args_formatter.py
-aider_vision_core/brand.py
 aider_vision_core/cli_serve.py
 aider_vision_core/commands.py
 aider_vision_core/copypaste.py
@@ -42,6 +41,7 @@ aider_vision_core/format_settings.py
 aider_vision_core/git_undo.py
 aider_vision_core/git_workspace.py
 aider_vision_core/gui.py
+aider_vision_core/headless_stdio.py
 aider_vision_core/help.py
 aider_vision_core/help_pats.py
 aider_vision_core/history.py
@@ -291,7 +291,6 @@ benchmark/swe-bench.txt
 benchmark/swe_bench.py
 benchmark/test_benchmark.py
 docker/Dockerfile
-docs/products.md
 requirements/common-constraints.txt
 requirements/pydub.in
 requirements/python-compat.in