synap-git 1.1.1__tar.gz → 1.2.2__tar.gz

{synap_git-1.1.1 → synap_git-1.2.2}/.gitignore

@@ -22,3 +22,6 @@ build/
 .env
 .env.*
 .env.local
+.synapse/
+.synapse/*-wal
+.synapse/*-shm

{synap_git-1.1.1 → synap_git-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synap-git
-Version: 1.1.1
+Version: 1.2.2
 Summary: Persistent structural context infrastructure for AI coding agents.
 Project-URL: Homepage, https://github.com/saahilpal/synap-git
 Project-URL: Repository, https://github.com/saahilpal/synap-git

{synap_git-1.1.1 → synap_git-1.2.2}/src/synap_git/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "1.1.1"
+__version__ = "1.2.2"

{synap_git-1.1.1 → synap_git-1.2.2}/src/synap_git/cli/main.py

@@ -120,22 +120,22 @@ def _jsonable(value: Any) -> Any:
     return value
 
 
-mcp_app = typer.Typer(help="Model Context Protocol (MCP) server commands.")
+mcp_app = typer.Typer(help="Model Context Protocol (MCP) server commands.", no_args_is_help=True)
 app.add_typer(mcp_app, name="mcp")
 
-memory_app = typer.Typer(help="Manage L3 Agent Memory.")
+memory_app = typer.Typer(help="Manage L3 Agent Memory.", no_args_is_help=True)
 app.add_typer(memory_app, name="memory")
 
-lessons_app = typer.Typer(help="Manage Agent Lessons.")
+lessons_app = typer.Typer(help="Manage Agent Lessons.", no_args_is_help=True)
 app.add_typer(lessons_app, name="lessons")
 
-checkpoint_app = typer.Typer(help="Manage Context Checkpoints.")
+checkpoint_app = typer.Typer(help="Manage Context Checkpoints.", no_args_is_help=True)
 app.add_typer(checkpoint_app, name="checkpoint")
 
-wiki_app = typer.Typer(help="Manage L2 Wiki Documentation.")
+wiki_app = typer.Typer(help="Manage L2 Wiki Documentation.", no_args_is_help=True)
 app.add_typer(wiki_app, name="wiki")
 
-usage_app = typer.Typer(help="View AI Usage Tracking.")
+usage_app = typer.Typer(help="View AI Usage Tracking.", no_args_is_help=True)
 app.add_typer(usage_app, name="usage")
 
 
@@ -481,17 +481,26 @@ ollama_url = "{ollama_url}"
 
 def _auto_protect_synap(repository_path: Path) -> None:
     gitignore_path = repository_path / ".gitignore"
+    patterns = [".synap/", ".synapse/", ".synapse/*-wal", ".synapse/*-shm"]
+
     if not gitignore_path.exists():
-        gitignore_path.write_text(".synap/\n")
+        gitignore_path.write_text("\n".join(patterns) + "\n")
         return
 
     content = gitignore_path.read_text()
-    lines = content.splitlines()
-    if ".synap/" not in lines and ".synap" not in lines:
-        if content and not content.endswith("\n"):
-            content += "\n"
-        content += ".synap/\n"
-        gitignore_path.write_text(content)
+    lines = [line.strip() for line in content.splitlines()]
+
+    new_content = content
+    added = False
+    for p in patterns:
+        if p.strip() not in lines and p.strip().rstrip("/") not in lines:
+            if not new_content.endswith("\n"):
+                new_content += "\n"
+            new_content += p + "\n"
+            added = True
+
+    if added:
+        gitignore_path.write_text(new_content)
 
 
 @app.command()
@@ -889,6 +898,7 @@ def logs(
     tail: Annotated[
         bool, typer.Option("--tail", "-t", help="Stream new log entries in real-time.")
     ] = False,
+    lines: Annotated[int, typer.Option("--lines", "-n", help="Number of last lines to show.")] = 50,
     debug: Annotated[
         bool, typer.Option("--debug", "-d", help="Show verbose debug and trace logs.")
     ] = False,
@@ -906,8 +916,8 @@ def logs(
     try:
         with open(log_file, encoding="utf-8") as f:
             if not tail:
-                lines = f.readlines()
-                for line in lines[-50:]:
+                all_lines = f.readlines()
+                for line in all_lines[-lines:]:
                     if not debug and '"level": "debug"' in line.lower():
                         continue
                     console.print(line.strip())
@@ -960,7 +970,24 @@ def update() -> None:
 
     console.print(f"Latest version on PyPI: [bold]{latest_version}[/bold]")
 
-    if current_version == latest_version and install_method != "editable":
+    def is_newer(v_remote: str, v_local: str) -> bool:
+        try:
+            # Attempt to use packaging if available
+            from packaging.version import Version
+
+            return Version(v_remote) > Version(v_local)
+        except (ImportError, Exception):
+            # Fallback to simple semver tuple comparison
+            try:
+
+                def _to_tuple(v: str) -> tuple[int, ...]:
+                    return tuple(int(x) for x in v.split(".") if x.isdigit())
+
+                return _to_tuple(v_remote) > _to_tuple(v_local)
+            except Exception:
+                return v_remote != v_local
+
+    if not is_newer(latest_version, current_version) and install_method != "editable":
         console.print("[green]✓ Synap is already up to date.[/green]")
         return
 
@@ -968,7 +995,11 @@ def update() -> None:
         console.print("\n[yellow]Editable installation detected. Updating via git pull...[/yellow]")
         try:
             subprocess.run(["git", "pull", "origin", "main"], check=True)
-            subprocess.run([sys.executable, "-m", "pip", "install", "-e", "."], check=True)
+            # Try pip, then uv
+            try:
+                subprocess.run([sys.executable, "-m", "pip", "install", "-e", "."], check=True)
+            except Exception:
+                subprocess.run(["uv", "pip", "install", "-e", "."], check=True)
             console.print(
                 "[green]✓ Update successful (Git repository pulled and re-installed)[/green]"
             )
@@ -993,7 +1024,17 @@ def update() -> None:
         f"\n[yellow]Upgrading Synap to {latest_version} using: {' '.join(cmd)}...[/yellow]"
     )
     try:
-        subprocess.run(cmd, check=True)
+        try:
+            subprocess.run(cmd, check=True)
+        except Exception as e:
+            if install_method == "venv" or install_method == "pip":
+                # Fallback to uv if pip fails/is missing
+                console.print(
+                    "[yellow]Pip failed or missing. Attempting upgrade via uv...[/yellow]"
+                )
+                subprocess.run(["uv", "pip", "install", "--upgrade", "synap-git"], check=True)
+            else:
+                raise e
         console.print("[green]✓ Update successful[/green]")
     except Exception as e:
         console.print(f"[bold red]✗ Upgrade failed:[/bold red] {e}")
@@ -1445,54 +1486,62 @@ def mcp_verify(
     table.add_column("Latency (ms)")
     table.add_column("Details")
 
-    def _simulate_mcp_call(tool_name: str, *args: Any, **kwargs: Any) -> bool:
-        start = time.monotonic()
-        try:
-            import uuid
-
-            status = facade.runtime.status()
-            dirty = status.is_dirty
-            warnings = ["Working tree is dirty. Index may be stale."] if dirty else []
-
-            method = getattr(facade, tool_name)
-            data = method(*args, **kwargs)
-
-            response = {
-                "ok": True,
-                "data": data,
-                "warnings": warnings,
-                "trace_id": str(uuid.uuid4()),
-                "dirty_tree": dirty,
-            }
-
-            # Verify strict schema
-            assert "ok" in response
-            assert "data" in response
-            assert "warnings" in response
-            assert "trace_id" in response
-            assert "dirty_tree" in response
-
-            latency = (time.monotonic() - start) * 1000
+    with console.status(
+        "[bold yellow]Verifying MCP transport and tools...[/bold yellow]"
+    ) as status:
 
-            if tool_name == "search":
-                # Check trace payload exists
-                assert "trace" in data, "Trace payload missing in search data"
-
-            details = f"keys: {list(data.keys())}"
-            table.add_row(tool_name, "[green]PASS[/green]", f"{latency:.1f}", details)
-            return True
-        except Exception as e:
-            latency = (time.monotonic() - start) * 1000
-            table.add_row(tool_name, "[red]FAIL[/red]", f"{latency:.1f}", str(e))
-            return False
-
-    results = [
-        _simulate_mcp_call("get_status"),
-        _simulate_mcp_call("verify_system"),
-        _simulate_mcp_call("search", "User"),
-        _simulate_mcp_call("create_checkpoint", "Testing MCP", ["test.py"], "Next", "None"),
-        _simulate_mcp_call("restore_checkpoint", "latest"),
-    ]
+        def _simulate_mcp_call(tool_name: str, *args: Any, **kwargs: Any) -> bool:
+            status.update(
+                f"[bold yellow]Verifying stage: [white]{tool_name}[/white]...[/bold yellow]"
+            )
+            start = time.monotonic()
+            try:
+                import uuid
+
+                status_info = facade.runtime.status()
+                dirty = status_info.is_dirty
+                warnings = ["Working tree is dirty. Index may be stale."] if dirty else []
+
+                method = getattr(facade, tool_name)
+                data = method(*args, **kwargs)
+
+                response = {
+                    "ok": True,
+                    "data": data,
+                    "warnings": warnings,
+                    "trace_id": str(uuid.uuid4()),
+                    "dirty_tree": dirty,
+                }
+
+                # Verify strict schema
+                assert "ok" in response
+                assert "data" in response
+                assert "warnings" in response
+                assert "trace_id" in response
+                assert "dirty_tree" in response
+
+                latency = (time.monotonic() - start) * 1000
+
+                if tool_name == "search":
+                    # Check trace payload exists
+                    assert "trace" in data, "Trace payload missing in search data"
+
+                details = f"keys: {list(data.keys())}"
+                table.add_row(tool_name, "[green]PASS[/green]", f"{latency:.1f}", details)
+                time.sleep(0.1)  # Visual breathing room
+                return True
+            except Exception as e:
+                latency = (time.monotonic() - start) * 1000
+                table.add_row(tool_name, "[red]FAIL[/red]", f"{latency:.1f}", str(e))
+                return False
+
+        results = [
+            _simulate_mcp_call("get_status"),
+            _simulate_mcp_call("verify_system"),
+            _simulate_mcp_call("search", "User"),
+            _simulate_mcp_call("create_checkpoint", "Testing MCP", ["test.py"], "Next", "None"),
+            _simulate_mcp_call("restore_checkpoint", "latest"),
+        ]
 
     console.print(table)
 
@@ -1775,16 +1824,14 @@ def lessons_reject(
 @checkpoint_app.command("create")
 def checkpoint_create(
     path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
-    doing: Annotated[str, typer.Option(help="What the agent is currently doing.")] = "",
+    doing: Annotated[
+        str, typer.Option(help="What the agent is currently doing.")
+    ] = "Manual snapshot",
     files: Annotated[str, typer.Option(help="Comma-separated list of changed files.")] = "",
     next_step: Annotated[str, typer.Option(help="The next step to be taken.")] = "",
     blockers: Annotated[str, typer.Option(help="Current blockers or obstacles.")] = "",
 ) -> None:
     """Create a new context checkpoint."""
-    if not doing:
-        console.print("[red]✗ The --doing option is required.[/red]")
-        raise typer.Exit(1)
-
     runtime = SynapRuntime(_settings(path))
     import uuid
 

{synap_git-1.1.1 → synap_git-1.2.2}/src/synap_git/indexer/daemon.py

@@ -106,26 +106,20 @@ class RuntimeDaemon:
             if self.settings.profile == RuntimeProfile.TEST:
                 self._ui_server.force_exit = True
 
-            # Allow uvicorn to shut down gracefully if it's running
-            if self._ui_server.started:
+            # Allow uvicorn and wiki worker to shut down gracefully
+            timeout = self.settings.shutdown_timeout_seconds
+            self.logger.info("daemon_waiting_for_tasks", timeout=timeout)
+
+            tasks = [server_task, wiki_worker_task]
+            done, pending = await asyncio.wait(
+                tasks, timeout=timeout, return_when=asyncio.ALL_COMPLETED
+            )
+
+            for task in pending:
+                self.logger.warning("daemon_force_cancelling_task", task=task.get_coro())
+                task.cancel()
                 try:
-                    await asyncio.wait_for(
-                        server_task, timeout=self.settings.shutdown_timeout_seconds
-                    )
-                except (TimeoutError, asyncio.CancelledError):
-                    self.logger.warning("daemon_uvicorn_graceful_shutdown_failed")
-
-            if not server_task.done():
-                server_task.cancel()
-                try:
-                    await server_task
-                except (asyncio.CancelledError, Exception):
-                    pass
-
-            if not wiki_worker_task.done():
-                wiki_worker_task.cancel()
-                try:
-                    await wiki_worker_task
+                    await task
                 except (asyncio.CancelledError, Exception):
                     pass
 
@@ -133,7 +127,9 @@ class RuntimeDaemon:
             self.logger.info("daemon_stopped")
 
     def stop(self) -> None:
-        self._stop_event.set()
+        if not self._stop_event.is_set():
+            self.logger.info("daemon_stop_requested")
+            self._stop_event.set()
 
     def health(self) -> DaemonHealth:
         status = self.runtime.status()
@@ -325,8 +321,23 @@ 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:
+                # Check queue depth for progress context
+                try:
+                    with self.runtime.store.connect() as conn:
+                        total_pending = conn.execute(
+                            "SELECT COUNT(*) FROM wiki_queue WHERE status = 'pending'"
+                        ).fetchone()[0]
+                except Exception:
+                    total_pending = 0
+
                 task = await asyncio.to_thread(self.runtime.store.dequeue_wiki)
                 if task:
                     task_id = task["task_id"]
@@ -336,17 +347,59 @@ class RuntimeDaemon:
                     self.logger.info("wiki_worker_processing_task", path=file_path)
 
                     if attempts > 0:
-                        await asyncio.sleep(2**attempts)
+                        await asyncio.sleep(min(30, 2**attempts))
 
+                    start_time = time.time()
                     try:
-                        await asyncio.to_thread(self.runtime.wiki.ensure_wiki_page, file_path)
+                        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.store.update_wiki_queue_status,
                             task_id,
                             "completed",
                             attempts + 1,
                         )
-                        self.logger.info("wiki_worker_completed_task", path=file_path)
+                        elapsed = time.time() - start_time
+                        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:
@@ -356,10 +409,10 @@ class RuntimeDaemon:
                                 "failed",
                                 attempts + 1,
                             )
-                            # Log visibly for daemon output
-                            print(
-                                f"\n[Synapse] ⚠ Wiki generation permanently failed for '{file_path}' after 3 attempts."
-                            )
+                            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,

{synap_git-1.1.1 → synap_git-1.2.2}/src/synap_git/indexer/engine.py

@@ -88,18 +88,26 @@ class SynapRuntime:
 
     def _auto_protect_synap(self) -> None:
         gitignore_path = self.settings.repository_path / ".gitignore"
+        patterns = [".synap/", ".synapse/", ".synapse/*-wal", ".synapse/*-shm"]
         try:
             if not gitignore_path.exists():
-                gitignore_path.write_text(".synap/\n", encoding="utf-8")
+                gitignore_path.write_text("\n".join(patterns) + "\n", encoding="utf-8")
                 return
 
             content = gitignore_path.read_text(encoding="utf-8")
             lines = [line.strip() for line in content.splitlines()]
-            if ".synap/" not in lines and ".synap" not in lines:
-                if content and not content.endswith("\n"):
-                    content += "\n"
-                content += ".synap/\n"
-                gitignore_path.write_text(content, encoding="utf-8")
+
+            new_content = content
+            added = False
+            for p in patterns:
+                if p.strip() not in lines and p.strip().rstrip("/") not in lines:
+                    if not new_content.endswith("\n"):
+                        new_content += "\n"
+                    new_content += p + "\n"
+                    added = True
+
+            if added:
+                gitignore_path.write_text(new_content, encoding="utf-8")
         except Exception as e:
             self.logger.warning("failed_to_auto_protect_synap", error=str(e))
 
@@ -472,7 +480,9 @@ class SynapRuntime:
                 if file_row:
                     file_id = file_row["file_id"]
                     conn.execute("DELETE FROM files WHERE file_id = ?", (file_id,))
-                self.store.set_wiki_status(rel_path, None, "stale")
+
+        for rel_path in deleted:
+            self.store.set_wiki_status(rel_path, None, "stale")
 
         # Get blob OIDs for changed files
         git_oids = {}

{synap_git-1.1.1 → synap_git-1.2.2}/src/synap_git/storage/sqlite.py

@@ -31,7 +31,7 @@ class SynapStore:
         self.path.parent.mkdir(parents=True, exist_ok=True)
         with self.connect() as conn:
             conn.execute("PRAGMA journal_mode=WAL")
-            conn.execute("PRAGMA synchronous=NORMAL")
+            conn.execute("PRAGMA synchronous=FULL")
             conn.execute("PRAGMA foreign_keys=ON")
 
             # Get current user version
@@ -231,7 +231,7 @@ class SynapStore:
         conn.row_factory = sqlite3.Row
         try:
             conn.execute("PRAGMA foreign_keys=ON")
-            conn.execute("PRAGMA synchronous=NORMAL")
+            conn.execute("PRAGMA synchronous=FULL")
             yield conn
             conn.commit()
         except Exception: