synap-git 2.1.6__tar.gz → 2.1.7__tar.gz

{synap_git-2.1.6 → synap_git-2.1.7}/.gitignore

@@ -25,3 +25,7 @@ build/
 .synapse/
 .synapse/*-wal
 .synapse/*-shm
+config.json
+status.json
+fix_exc.py
+test_embed.py

{synap_git-2.1.6 → synap_git-2.1.7}/CHANGELOG.md

@@ -5,7 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.1.5] - 2026-06-11
+## [2.1.7] - 2026-07-29
+
+### Added
+- **AI Engineer Rules**: Created standardized agent rulesets across `AGENTS.md`, `.cursorrules`, `.windsurfrules`, and `.github/copilot-instructions.md`.
+
+### Fixed
+- **Daemon Branch Switching Test Stability**: Resolved timing race condition in daemon branch checkout verification.
+- **CLI Setup Connectivity**: Fixed setup connectivity verification and non-TTY prompt fallback handling.
 
 ## [2.1.6] - 2026-06-29
 

{synap_git-2.1.6 → synap_git-2.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synap-git
-Version: 2.1.6
+Version: 2.1.7
 Summary: Persistent structural context infrastructure for AI coding agents.
 Project-URL: Homepage, https://github.com/saahilpal/synapse
 Project-URL: Repository, https://github.com/saahilpal/synapse
@@ -339,8 +339,8 @@ Initialize the local SQLite database index:
 synap init .
 ```
 
-### 3. Detach Watcher Daemon
-Start background monitoring:
+### 3. Connect IDE / Start MCP
+Launch the unified background daemon and MCP stdio server:
 ```bash
 synap start .
 ```
@@ -372,7 +372,6 @@ All commands support target path arguments:
 * `synap doctor [PATH]` — Verifies database integrity and parsers.
 * `synap run [PATH]` — Runs daemon in foreground.
 * `synap ui [PATH]` — Launches HTML dashboard.
-* `synap mcp start [PATH]` — Hosts MCP stdio server.
 * `synap mcp config [PATH]` — Outputs Cursor connection blocks.
 * `synap mcp verify [PATH]` — Asserts MCP server stability.
 * `synap memory status [PATH]` — Lists lesson counts.
@@ -432,8 +431,7 @@ synap mcp config .
   "mcpServers": {
     "synap": {
       "command": "/usr/local/bin/python",
-      "args": ["-m", "synap_git.cli", "mcp", "start", "/Users/username/repo"],
-      "autoConnect": true
+      "args": ["-m", "synap_git.cli", "start", "/Users/username/repo"]
     }
   }
 }

{synap_git-2.1.6 → synap_git-2.1.7}/README.md

@@ -289,8 +289,8 @@ Initialize the local SQLite database index:
 synap init .
 ```
 
-### 3. Detach Watcher Daemon
-Start background monitoring:
+### 3. Connect IDE / Start MCP
+Launch the unified background daemon and MCP stdio server:
 ```bash
 synap start .
 ```
@@ -322,7 +322,6 @@ All commands support target path arguments:
 * `synap doctor [PATH]` — Verifies database integrity and parsers.
 * `synap run [PATH]` — Runs daemon in foreground.
 * `synap ui [PATH]` — Launches HTML dashboard.
-* `synap mcp start [PATH]` — Hosts MCP stdio server.
 * `synap mcp config [PATH]` — Outputs Cursor connection blocks.
 * `synap mcp verify [PATH]` — Asserts MCP server stability.
 * `synap memory status [PATH]` — Lists lesson counts.
@@ -382,8 +381,7 @@ synap mcp config .
   "mcpServers": {
     "synap": {
       "command": "/usr/local/bin/python",
-      "args": ["-m", "synap_git.cli", "mcp", "start", "/Users/username/repo"],
-      "autoConnect": true
+      "args": ["-m", "synap_git.cli", "start", "/Users/username/repo"]
     }
   }
 }

{synap_git-2.1.6 → synap_git-2.1.7}/src/synap_git/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "2.1.6"
+__version__ = "2.1.7"

{synap_git-2.1.6 → synap_git-2.1.7}/src/synap_git/api/app.py

@@ -104,7 +104,7 @@ def create_app(runtime: SynapRuntime) -> FastAPI:
         except Exception as e:
             import structlog
 
-            structlog.get_logger().error("suppressed_error_caught", exc_info=True)
+            structlog.get_logger().error("suppressed_error_caught", error=str(e))
 
         wiki_path = runtime.wiki.wiki_dir / f"{target}.md"
         exists = await asyncio.to_thread(wiki_path.exists)

{synap_git-2.1.6 → synap_git-2.1.7}/src/synap_git/cli/main.py

@@ -57,7 +57,7 @@ def _custom_call(*args: Any, **kwargs: Any) -> Any:
 app.__call__ = _custom_call  # type: ignore[method-assign]
 
 JSON_OPTION = typer.Option("--json", help="Emit machine-readable JSON.")
-console = Console()
+console = Console(stderr=True)
 
 
 def _settings(
@@ -88,9 +88,19 @@ def _settings(
     return settings
 
 
+def _verify_is_git(path: str) -> None:
+    from synap_git.git.state import GitRepository
+
+    if not GitRepository(Path(path)).state().is_repository:
+        console.print(f"[bold red]Error:[/bold red] '{path}' is not a valid Git repository.")
+        raise typer.Exit(1)
+
+
 def _emit(value: Any, *, json_output: bool) -> None:
     if json_output:
-        console.print(json.dumps(_jsonable(value), indent=2, sort_keys=True))
+        import sys
+
+        print(json.dumps(_jsonable(value), indent=2, sort_keys=True), file=sys.stdout)
         return
     if isinstance(value, str):
         console.print(value)
@@ -529,6 +539,7 @@ def init(
         synap init
         synap init --force --skip-llm
     """
+    _verify_is_git(path)
     settings = _settings(path, json_output=json_output)
     if skip_llm:
         settings.llm_provider = None
@@ -537,12 +548,9 @@ def init(
 
     runtime = SynapRuntime(settings)
     if not quiet and not json_output:
-        with console.status(
-            "[yellow]Initializing Synap runtime and scanning repository...[/yellow]", spinner="dots"
-        ):
-            commit = runtime.bootstrap(force=force)
-    else:
-        commit = runtime.bootstrap(force=force)
+        console.print("[yellow]Initializing Synap runtime and scanning repository...[/yellow]")
+
+    commit = runtime.bootstrap(force=force)
 
     if json_output:
         _emit({"active_commit": commit, "state": "initialized"}, json_output=True)
@@ -646,14 +654,19 @@ def start(
     path: Annotated[str, typer.Argument(help="Repository path to watch.")] = ".",
 ) -> None:
     """Start the Synap daemon in the background."""
+    _verify_is_git(path)
+    import asyncio
+    import os
     import subprocess
     import sys
     import time
 
+    from synap_git.mcp.server import SynapMCPServer
+
     abs_path = Path(path).resolve()
     pid_file = abs_path / ".synap" / "daemon.pid"
 
-    # 1. Check if daemon is already running for the repository
+    is_running = False
     if pid_file.exists():
         try:
             pid = int(pid_file.read_text(encoding="utf-8").strip())
@@ -662,59 +675,78 @@ def start(
                 hb = _read_daemon_heartbeat(abs_path)
                 if hb and "port" in hb:
                     console.print(f"[green]✓ UI available at http://127.0.0.1:{hb['port']}[/green]")
-                return
+                is_running = True
             else:
                 pid_file.unlink()
         except Exception as e:
             import structlog
 
-            structlog.get_logger().error("suppressed_error_caught", exc_info=True)
+            structlog.get_logger().error("suppressed_error_caught", error=str(e))
 
-    # 2. Spawn detached daemon process
-    cmd = [sys.executable, "-m", "synap_git.cli", "daemon-run", abs_path.as_posix()]
-    try:
-        if sys.platform == "win32":
-            subprocess.Popen(
-                cmd,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                stdin=subprocess.DEVNULL,
-                creationflags=0x00000008,  # DETACHED_PROCESS
-            )
-        else:
-            subprocess.Popen(
-                cmd,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                stdin=subprocess.DEVNULL,
-                start_new_session=True,
-            )
-    except Exception as e:
-        console.print(f"[bold red]✗ Failed to start daemon:[/bold red] {e}")
-        raise typer.Exit(1)
+    if not is_running:
+        # 2. Spawn detached daemon process
+        cmd = [sys.executable, "-m", "synap_git.cli", "daemon-run", abs_path.as_posix()]
+        try:
+            if sys.platform == "win32":
+                subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    stdin=subprocess.DEVNULL,
+                    creationflags=0x00000008,  # DETACHED_PROCESS
+                )
+            else:
+                subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    stdin=subprocess.DEVNULL,
+                    start_new_session=True,
+                )
+        except Exception as e:
+            console.print(f"[bold red]✗ Failed to start daemon:[/bold red] {e}")
+            raise typer.Exit(1)
 
-    success = False
-    with console.status(
-        "[yellow]Starting Synap daemon and awaiting health check...[/yellow]", spinner="dots"
-    ):
-        for _ in range(15):  # wait up to 3 seconds
-            time.sleep(0.2)
-            if pid_file.exists():
-                hb = _read_daemon_heartbeat(abs_path)
-                if hb and hb.get("status") in ("healthy", "degraded"):
-                    success = True
-                    port = hb.get("port", 9876)
-                    pid = int(hb.get("pid", 0))
-                    console.print(f"[green]✓ Synap daemon started (PID {pid})[/green]")
-                    console.print("[green]✓ Runtime healthy[/green]")
-                    console.print(f"[green]✓ UI available at http://127.0.0.1:{port}[/green]")
-                    break
+        success = False
+        with console.status(
+            "[yellow]Starting Synap daemon and awaiting health check...[/yellow]", spinner="dots"
+        ):
+            for _ in range(25):  # wait up to 5 seconds for initial heartbeat
+                time.sleep(0.2)
+                if pid_file.exists():
+                    hb = _read_daemon_heartbeat(abs_path)
+                    if hb:
+                        status = hb.get("status")
+                        if status in ("healthy", "degraded", "starting"):
+                            success = True
+                            port = hb.get("port", 9876)
+                            pid = int(hb.get("pid", 0))
+                            console.print(f"[green]✓ Synap daemon started (PID {pid})[/green]")
+                            if status == "starting":
+                                console.print(
+                                    "[yellow]ℹ Daemon is currently indexing in the background...[/yellow]"
+                                )
+                            else:
+                                console.print("[green]✓ Runtime healthy[/green]")
+                            console.print(
+                                f"[green]✓ UI available at http://127.0.0.1:{port}[/green]"
+                            )
+                            break
 
-    if not success:
-        console.print(
-            "[red]✗ Daemon started but did not report healthy status. Check logs in ~/.config/synap/logs/[/red]"
-        )
-        raise typer.Exit(1)
+        if not success:
+            console.print(
+                "[red]✗ Daemon started but did not report healthy status. Check logs in ~/.config/synap/logs/[/red]"
+            )
+            raise typer.Exit(1)
+
+    # 3. Start MCP Server in the foreground
+    settings = _settings(path, json_output=True)
+    runtime = SynapRuntime(settings)
+    server = SynapMCPServer(runtime)
+    try:
+        asyncio.run(server.run())
+    except KeyboardInterrupt:
+        os._exit(0)
 
 
 @app.command("daemon-run", hidden=True)
@@ -820,7 +852,7 @@ def stop(
         except Exception as e:
             import structlog
 
-            structlog.get_logger().error("suppressed_error_caught", exc_info=True)
+            structlog.get_logger().error("suppressed_error_caught", error=str(e))
         success = not _is_process_running(pid)
 
     # Clean up lockfiles
@@ -1271,7 +1303,7 @@ def rollback(
     except Exception as e:
         import structlog
 
-        structlog.get_logger().error("suppressed_error_caught", exc_info=True)
+        structlog.get_logger().error("suppressed_error_caught", error=str(e))
 
     with console.status(
         f"[yellow]Reindexing repository to match {selected_commit}...[/yellow]", spinner="dots"
@@ -1346,7 +1378,7 @@ def repair(
         except Exception as e:
             import structlog
 
-            structlog.get_logger().error("suppressed_error_caught", exc_info=True)
+            structlog.get_logger().error("suppressed_error_caught", error=str(e))
 
     status_info = runtime.status()
     console.print(f"\n[green]✓ Recovery complete. {status_info.files} files restored.[/green]")
@@ -1475,6 +1507,12 @@ def doctor(
                         completed=1,
                         description=f"[green]✓ Daemon active and healthy (PID {daemon_info['pid']}, uptime {daemon_info['uptime_seconds']}s)[/green]",
                     )
+                elif status_str == "STARTING":
+                    progress.update(
+                        task_daemon,
+                        completed=1,
+                        description=f"[green]✓ Daemon is active and currently starting/indexing (PID {daemon_info['pid']})[/green]",
+                    )
                 elif status_str == "STALE":
                     progress.update(
                         task_daemon,
@@ -1509,21 +1547,6 @@ def run(
     start(path)
 
 
-@mcp_app.command("start")
-def mcp_start(
-    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
-) -> None:
-    """Start the MCP server."""
-    settings = _settings(path, json_output=True)
-    runtime = SynapRuntime(settings)
-    runtime.bootstrap()
-
-    from synap_git.mcp.server import SynapMCPServer
-
-    server = SynapMCPServer(runtime)
-    asyncio.run(server.run())
-
-
 @mcp_app.command("config")
 def mcp_config(
     path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
@@ -1534,11 +1557,7 @@ def mcp_config(
 
     config = {
         "mcpServers": {
-            "synap": {
-                "command": sys.executable,
-                "args": ["-m", "synap_git.cli", "mcp", "start", abs_path],
-                "autoConnect": True,
-            }
+            "synap": {"command": sys.executable, "args": ["-m", "synap_git.cli", "start", abs_path]}
         }
     }
     typer.echo(json.dumps(config, indent=2))

{synap_git-2.1.6 → synap_git-2.1.7}/src/synap_git/config.py

@@ -50,7 +50,6 @@ class SynapSettings(BaseSettings):
     repository_path: Path = Field(default=Path(), description="Repository root.")
     state_path: Path = Field(default=Path(".synap"), description="Local runtime state.")
     sqlite_path: Path | None = None
-    object_path: Path | None = None
     log_path: Path | None = None
 
     logging_mode: LoggingMode = LoggingMode.HUMAN
@@ -150,7 +149,6 @@ class SynapSettings(BaseSettings):
         self.repository_path = repository_path
         self.state_path = state_path.resolve()
         self.sqlite_path = self._resolve_optional_path(self.sqlite_path, "synap.db")
-        self.object_path = self._resolve_optional_path(self.object_path, "objects")
         self.log_path = self._resolve_optional_path(self.log_path, "logs")
 
         if self.profile is RuntimeProfile.TEST:
@@ -166,10 +164,6 @@ class SynapSettings(BaseSettings):
 
     def ensure_directories(self) -> None:
         self.state_path.mkdir(parents=True, exist_ok=True)
-        if self.object_path:
-            self.object_path.mkdir(parents=True, exist_ok=True)
-        if self.log_path:
-            self.log_path.mkdir(parents=True, exist_ok=True)
 
     def validate_configuration(self) -> list[str]:
         errors = []

{synap_git-2.1.6 → synap_git-2.1.7}/src/synap_git/diagnostics/logger.py

@@ -56,6 +56,10 @@ def configure_logging(settings: SynapSettings) -> None:
     # Set up stream handler (stderr)
     stream_handler = logging.StreamHandler(sys.stderr)
     stream_handler.setFormatter(logging.Formatter("%(message)s"))
+    if settings.log_level.upper() == "DEBUG":
+        stream_handler.setLevel(logging.DEBUG)
+    else:
+        stream_handler.setLevel(logging.WARNING)
     root_logger.addHandler(stream_handler)
 
     root_logger.setLevel(getattr(logging, settings.log_level.upper(), logging.INFO))

{synap_git-2.1.6 → synap_git-2.1.7}/src/synap_git/git/state.py

@@ -131,7 +131,7 @@ class GitRepository:
             except Exception as e:
                 import structlog
 
-                structlog.get_logger().error("suppressed_error_caught", exc_info=True)
+                structlog.get_logger().error("suppressed_error_caught", error=str(e))
 
             if len(current.commit_parent_hashes) > 1:
                 return GitChange(kind=GitChangeKind.MERGE, previous=previous, current=current)

{synap_git-2.1.6 → synap_git-2.1.7}/src/synap_git/indexer/daemon.py

@@ -75,6 +75,7 @@ class RuntimeDaemon:
         self._ui_server.capture_signals = dummy_capture_signals  # type: ignore[method-assign]
 
         # Initial bootstrap
+        self._write_heartbeat(status="starting")
         await asyncio.to_thread(self.runtime.bootstrap)
 
         with self.runtime.store.connect() as conn:
@@ -128,18 +129,6 @@ class RuntimeDaemon:
             self.logger.info("daemon_stop_requested")
             self._stop_event.set()
 
-            # Force immediate cleanup and exit to avoid thread-join blocking
-            if force_exit:
-                try:
-                    self.runtime.shutdown()
-                    self._delete_heartbeat()
-                except Exception:
-                    pass
-
-                import sys
-
-                sys.exit(0)
-
     def health(self) -> DaemonHealth:
         status = self.runtime.status()
         return DaemonHealth(
@@ -246,7 +235,7 @@ class RuntimeDaemon:
             }
             heartbeat_file.write_text(json.dumps(data, indent=2), encoding="utf-8")
         except Exception as e:
-            self.logger.error("daemon_write_heartbeat_error", exc_info=True)
+            self.logger.error("daemon_write_heartbeat_error", error=str(e))
 
     def _delete_heartbeat(self) -> None:
         heartbeat_file = self.settings.repository_path / ".synap" / "daemon_heartbeat.json"
@@ -256,7 +245,7 @@ class RuntimeDaemon:
             except Exception as e:
                 import structlog
 
-                structlog.get_logger().error("suppressed_error_caught", exc_info=True)
+                structlog.get_logger().error("suppressed_error_caught", error=str(e))
 
         # Cleanup process PID lockfile as well
         pid_file = self.settings.repository_path / ".synap" / "daemon.pid"
@@ -266,7 +255,7 @@ class RuntimeDaemon:
             except Exception as e:
                 import structlog
 
-                structlog.get_logger().error("suppressed_error_caught", exc_info=True)
+                structlog.get_logger().error("suppressed_error_caught", error=str(e))
 
     async def _poll_git_loop(self) -> None:
         while not self._stop_event.is_set():
@@ -302,7 +291,7 @@ class RuntimeDaemon:
 
                 self._write_heartbeat(status="healthy")
             except Exception as e:
-                self.logger.error("daemon_loop_error", exc_info=True)
+                self.logger.error("daemon_loop_error", error=str(e))
                 self._recovery_attempts += 1
                 self._write_heartbeat(status="degraded", last_error=str(e))
 
@@ -334,11 +323,6 @@ class RuntimeDaemon:
 
     async def _wiki_worker_loop(self) -> None:
         self.logger.info("wiki_worker_started")
-        from rich.console import Console
-
-        from synap_git.config import LoggingMode
-
-        console = Console()
 
         while not self._stop_event.is_set():
             try:
@@ -364,39 +348,7 @@ class RuntimeDaemon:
 
                     start_time = time.time()
                     try:
-                        if self.settings.logging_mode == LoggingMode.HUMAN:
-                            with console.status(
-                                f"[bold cyan][Wiki][/bold cyan] Generating: [white]{file_path}[/white] (0.0s) ({total_pending} remaining)"
-                            ) as status:
-                                # Update status periodically with elapsed time
-                                async def _update_status(
-                                    st: float = start_time,
-                                    fp: str = file_path,
-                                    tp: int = total_pending,
-                                ) -> None:
-                                    try:
-                                        while True:
-                                            await asyncio.sleep(0.1)
-                                            elapsed = time.time() - st
-                                            status.update(
-                                                f"[bold cyan][Wiki][/bold cyan] Generating: [white]{fp}[/white] [dim]({elapsed:.1f}s)[/dim] ({tp} remaining)"
-                                            )
-                                    except asyncio.CancelledError:
-                                        pass
-
-                                status_task = asyncio.create_task(_update_status())
-                                try:
-                                    await asyncio.to_thread(
-                                        self.runtime.wiki.ensure_wiki_page, file_path
-                                    )
-                                finally:
-                                    status_task.cancel()
-                                    try:
-                                        await status_task
-                                    except asyncio.CancelledError:
-                                        pass
-                        else:
-                            await asyncio.to_thread(self.runtime.wiki.ensure_wiki_page, file_path)
+                        await asyncio.to_thread(self.runtime.wiki.ensure_wiki_page, file_path)
 
                         await asyncio.to_thread(
                             self.runtime.store.update_wiki_queue_status,
@@ -408,11 +360,6 @@ class RuntimeDaemon:
                         self.logger.info(
                             "wiki_worker_completed_task", path=file_path, elapsed=elapsed
                         )
-
-                        if self.settings.logging_mode == LoggingMode.HUMAN:
-                            print(
-                                f"[bold green]✓[/bold green] Wiki generated: [white]{file_path}[/white] [dim]({elapsed:.1f}s)[/dim]"
-                            )
                     except Exception as ex:
                         self.logger.error("wiki_worker_task_failed", path=file_path, error=str(ex))
                         if attempts + 1 >= 3:
@@ -422,10 +369,6 @@ class RuntimeDaemon:
                                 "failed",
                                 attempts + 1,
                             )
-                            if self.settings.logging_mode == LoggingMode.HUMAN:
-                                print(
-                                    f"[bold red]✗[/bold red] Wiki failed: [white]{file_path}[/white] [dim]({str(ex)})[/dim]"
-                                )
                         else:
                             await asyncio.to_thread(
                                 self.runtime.store.update_wiki_queue_status,
@@ -438,6 +381,6 @@ class RuntimeDaemon:
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                self.logger.error("wiki_worker_loop_error", exc_info=True)
+                self.logger.error("wiki_worker_loop_error", error=str(e))
                 await asyncio.sleep(5.0)
         self.logger.info("wiki_worker_stopped")