nogic 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

nogic/__init__.py

@@ -1,3 +1,3 @@
 """Nogic CLI package."""
 
-__version__ = "0.0.1"
+__version__ = "0.1.0"

nogic/commands/init.py

@@ -17,7 +17,6 @@ def init(
     project_id: Annotated[Optional[str], typer.Option("--project-id", "-p", help="Use existing project ID.")] = None,
     name: Annotated[Optional[str], typer.Option("--name", "-n", help="Project name.")] = None,
     link: Annotated[bool, typer.Option("--link", help="Re-link an existing project.")] = False,
-    yes: Annotated[bool, typer.Option("--yes", "-y", help="Accept defaults, skip prompts.")] = False,
 ):
     """Initialize a Nogic project in a directory."""
     directory = directory.resolve()
@@ -58,7 +57,7 @@ def init(
             ui.info(f"Found existing project '{existing_project.name}'")
             ui.kv("Project ID", existing_project.id)
 
-            if yes or typer.confirm("Use this project?", default=True):
+            if typer.confirm("Use this project?", default=True):
                 config.project_id = existing_project.id
                 config.project_name = existing_project.name
                 config.directory_hash = dir_hash
@@ -68,7 +67,7 @@ def init(
                 ui.console.print("  1. Wipe graph data and reuse this project")
                 ui.console.print("  2. Abort")
 
-                choice = "1" if yes else typer.prompt("Choose option", default="1")
+                choice = typer.prompt("Choose option", default="1")
 
                 if choice == "1":
                     with ui.status_spinner("Wiping graph data..."):
@@ -82,7 +81,7 @@ def init(
                     ui.dim("Aborted.")
                     raise typer.Exit(0)
         else:
-            project_name = name or (directory.name if yes else typer.prompt("Project name", default=directory.name))
+            project_name = name or typer.prompt("Project name", default=directory.name)
 
             try:
                 with ui.status_spinner("Creating project..."):
@@ -96,7 +95,7 @@ def init(
                 if e.response.status_code == 409:
                     data = e.response.json()
                     ui.warn(f"Project already exists: {data.get('project_name')}")
-                    if yes or typer.confirm("Use this project?", default=True):
+                    if typer.confirm("Use this project?", default=True):
                         config.project_id = data.get("project_id")
                         config.project_name = data.get("project_name")
                         config.directory_hash = dir_hash

nogic/commands/reindex.py

@@ -1,8 +1,5 @@
 """Reindex command - wipe graph data and re-index from scratch."""
 
-import json as _json
-import sys
-import time
 from pathlib import Path
 from typing import Annotated, Optional
 
@@ -16,24 +13,15 @@ from nogic.api import NogicClient
 from nogic import ui
 
 
-def _emit_json(event: str, **kwargs):
-    """Emit a single NDJSON line to stdout."""
-    payload = {"event": event, "timestamp": int(time.time()), **kwargs}
-    sys.stdout.write(_json.dumps(payload) + "\n")
-    sys.stdout.flush()
-
-
 def reindex(
     directory: Annotated[Path, typer.Argument(help="Path to the project directory.")] = Path("."),
     ignore: Annotated[Optional[list[str]], typer.Option("--ignore", help="Patterns to ignore.")] = None,
     yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation.")] = False,
-    format: Annotated[Optional[str], typer.Option("--format", help="Output format: text or json.")] = None,
 ):
     """Wipe graph data and re-index the entire project."""
     directory = directory.resolve()
     nogic_dir = directory / CONFIG_DIR
     ignore = ignore or []
-    json_mode = format == "json"
 
     if not nogic_dir.exists():
         ui.error("Not a Nogic project.")
@@ -52,66 +40,50 @@ def reindex(
         ui.dim("Run `nogic init` to initialize your project.")
         raise typer.Exit(1)
 
-    if not json_mode:
-        if is_dev_mode():
-            ui.dev_banner(get_api_url())
-
-        if not yes:
-            ui.banner("nogic reindex")
-            ui.kv("Project", config.project_name or f"{config.project_id[:8]}...")
-            ui.kv("Directory", str(directory))
-            ui.console.print()
-            ui.warn("This will delete all graph data and re-index from scratch.")
-            ui.console.print()
-            if not typer.confirm("Continue?", default=False):
-                ui.dim("Aborted.")
-                raise typer.Exit(0)
+    if is_dev_mode():
+        ui.dev_banner(get_api_url())
+
+    if not yes:
+        ui.banner("nogic reindex")
+        ui.kv("Project", config.project_name or f"{config.project_id[:8]}...")
+        ui.kv("Directory", str(directory))
+        ui.console.print()
+        ui.warn("This will delete all graph data and re-index from scratch.")
+        ui.console.print()
+        if not typer.confirm("Continue?", default=False):
+            ui.dim("Aborted.")
+            raise typer.Exit(0)
 
     client = NogicClient(config)
     nodes_deleted = 0
 
     try:
-        if json_mode:
-            _emit_json("progress", phase="wiping")
-        else:
-            wipe_ctx = ui.status_spinner("Wiping graph data...")
-            wipe_ctx.__enter__()
-
-        try:
-            result = client.wipe_project_graph(config.project_id)
-            nodes_deleted = result.nodes_deleted
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                pass
-            else:
-                if json_mode:
-                    _emit_json("error", message=f"Error wiping graph ({e.response.status_code})")
+        with ui.status_spinner("Wiping graph data..."):
+            try:
+                result = client.wipe_project_graph(config.project_id)
+                nodes_deleted = result.nodes_deleted
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code == 404:
+                    pass
                 else:
                     ui.error(f"Error wiping graph ({e.response.status_code})")
-                raise typer.Exit(1)
-
-        if not json_mode:
-            wipe_ctx.__exit__(None, None, None)
+                    raise typer.Exit(1)
 
-        if json_mode:
-            _emit_json("wiped", nodes_deleted=nodes_deleted)
-        elif nodes_deleted:
+        if nodes_deleted:
             ui.info(f"Deleted {nodes_deleted} nodes")
 
         should_ignore = build_ignore_matcher(directory, extra_patterns=ignore)
-        log_fn = (lambda msg: None) if json_mode else (lambda msg: ui.dim(f"  {msg}"))
-        sync_service = SyncService(config, directory, log=log_fn, json_mode=json_mode)
+        sync_service = SyncService(config, directory, log=lambda msg: ui.dim(f"  {msg}"))
 
         sync_service.initial_scan(directory, should_ignore)
         sync_service.close()
 
-        if not json_mode:
-            ui.console.print()
-            ui.success("Reindex complete!")
-            if nodes_deleted > 0:
-                ui.dim(f"  Old nodes deleted: {nodes_deleted}")
-            ui.console.print()
-            ui.dim("Run 'nogic watch' to continue monitoring for changes.")
+        ui.console.print()
+        ui.success("Reindex complete!")
+        if nodes_deleted > 0:
+            ui.dim(f"  Old nodes deleted: {nodes_deleted}")
+        ui.console.print()
+        ui.dim("Run 'nogic watch' to continue monitoring for changes.")
 
     finally:
         client.close()

nogic/commands/status.py

@@ -1,10 +1,8 @@
 """Status command - show project status and verify configuration."""
 
-import json
-import sys
 from pathlib import Path
 from datetime import datetime
-from typing import Annotated, Optional
+from typing import Annotated
 
 import httpx
 import typer
@@ -17,28 +15,19 @@ from nogic import ui
 
 def status(
     directory: Annotated[Path, typer.Argument(help="Path to the project directory.")] = Path("."),
-    format: Annotated[Optional[str], typer.Option("--format", help="Output format: text or json.")] = None,
 ):
     """Show project status and verify configuration."""
     directory = directory.resolve()
     nogic_dir = directory / CONFIG_DIR
     current_dir_hash = get_directory_hash(str(directory))
-    json_mode = format == "json"
 
     if not nogic_dir.exists():
-        if json_mode:
-            _emit_json_status(error="Not a Nogic project.")
-        else:
-            ui.error("Not a Nogic project.")
-            ui.dim("Run `nogic init` to initialize your project.")
+        ui.error("Not a Nogic project.")
+        ui.dim("Run `nogic init` to initialize your project.")
         raise typer.Exit(1)
 
     config = Config.load(directory)
 
-    if json_mode:
-        _status_json(directory, config, current_dir_hash)
-        return
-
     if is_dev_mode():
         ui.dev_banner(get_api_url())
 
@@ -106,57 +95,6 @@ def status(
     ui.console.print()
 
 
-def _status_json(directory: Path, config: Config, dir_hash: str):
-    """Output status as a single JSON object to stdout."""
-    result: dict = {
-        "project_name": config.project_name or None,
-        "project_id": config.project_id or None,
-        "directory": str(directory),
-        "logged_in": bool(config.api_key),
-        "backend": None,
-    }
-
-    if config.api_key and config.project_id:
-        client = NogicClient(config)
-        try:
-            backend_project = client.get_project_by_directory(dir_hash)
-            if backend_project:
-                result["backend"] = {
-                    "status": "connected",
-                    "project_name": backend_project.name,
-                    "project_id": backend_project.id,
-                    "created_at": backend_project.created_at,
-                    "updated_at": backend_project.updated_at,
-                }
-            else:
-                result["backend"] = {"status": "not_found"}
-        except httpx.HTTPStatusError as e:
-            result["backend"] = {
-                "status": "error",
-                "error": f"HTTP {e.response.status_code}",
-            }
-        except httpx.RequestError as e:
-            result["backend"] = {
-                "status": "error",
-                "error": str(e),
-            }
-        finally:
-            client.close()
-    elif not config.api_key:
-        result["backend"] = {"status": "not_logged_in"}
-    else:
-        result["backend"] = {"status": "not_configured"}
-
-    sys.stdout.write(json.dumps(result) + "\n")
-    sys.stdout.flush()
-
-
-def _emit_json_status(**kwargs):
-    """Emit a JSON status object with error info."""
-    sys.stdout.write(json.dumps(kwargs) + "\n")
-    sys.stdout.flush()
-
-
 def _format_datetime(dt_string: str) -> str:
     try:
         dt = datetime.fromisoformat(dt_string.replace("Z", "+00:00"))

nogic/commands/sync.py

@@ -14,13 +14,11 @@ from nogic import telemetry, ui
 def sync(
     directory: Annotated[Path, typer.Argument(help="Path to the directory to sync.")] = Path("."),
     ignore: Annotated[Optional[list[str]], typer.Option("--ignore", help="Patterns to ignore.")] = None,
-    format: Annotated[Optional[str], typer.Option("--format", help="Output format: text or json.")] = None,
 ):
     """One-time sync of a directory to backend."""
     directory = directory.resolve()
     nogic_dir = directory / ".nogic"
     ignore = ignore or []
-    json_mode = format == "json"
 
     if not nogic_dir.exists():
         ui.error("Not a Nogic project.")
@@ -39,22 +37,22 @@ def sync(
         ui.dim("Run `nogic init` to initialize your project.")
         raise typer.Exit(1)
 
-    if not json_mode:
-        if is_dev_mode():
-            ui.dev_banner(get_api_url())
-        ui.banner("nogic sync", str(directory))
-        ui.kv("Project", f"{config.project_id[:8]}...")
+    if is_dev_mode():
+        ui.dev_banner(get_api_url())
 
-    log_fn = (lambda msg: None) if json_mode else (lambda msg: ui.dim(f"  {msg}"))
-    sync_service = SyncService(config, directory, log=log_fn, json_mode=json_mode)
+    ui.banner("nogic sync", str(directory))
+    ui.kv("Project", f"{config.project_id[:8]}...")
+
+    should_ignore = build_ignore_matcher(directory, extra_patterns=ignore)
+
+    sync_service = SyncService(config, directory, log=lambda msg: ui.dim(f"  {msg}"))
 
     try:
-        sync_service.initial_scan(directory, build_ignore_matcher(directory, extra_patterns=ignore))
+        sync_service.initial_scan(directory, should_ignore)
         telemetry.capture("cli_sync", {"status": "success"})
     except KeyboardInterrupt:
-        if not json_mode:
-            ui.console.print()
-            ui.dim("Interrupted. Cleaning up...")
+        ui.console.print()
+        ui.dim("Interrupted. Cleaning up...")
         try:
             sync_service.client.clear_staging(config.project_id)
         except Exception:
@@ -67,6 +65,5 @@ def sync(
     finally:
         sync_service.close()
 
-    if not json_mode:
-        ui.console.print()
-        ui.success("Done.")
+    ui.console.print()
+    ui.success("Done.")

nogic/commands/watch.py

@@ -1,7 +1,5 @@
 """Watch command for file syncing."""
 
-import json
-import sys
 import time
 from pathlib import Path
 from typing import Annotated, Optional
@@ -14,71 +12,48 @@ from nogic.watcher import FileMonitor, SyncService
 from nogic import ui
 
 
-def _emit_json(event: str, **kwargs):
-    """Emit a single NDJSON line to stdout."""
-    payload = {"event": event, "timestamp": int(time.time()), **kwargs}
-    sys.stdout.write(json.dumps(payload) + "\n")
-    sys.stdout.flush()
-
-
 def watch(
     directory: Annotated[Path, typer.Argument(help="Path to the directory to watch.")] = Path("."),
     ignore: Annotated[Optional[list[str]], typer.Option("--ignore", help="Patterns to ignore.")] = None,
-    format: Annotated[Optional[str], typer.Option("--format", help="Output format: text or json.")] = None,
 ):
     """Watch a directory for file changes and sync to backend."""
     directory = directory.resolve()
     nogic_dir = directory / ".nogic"
     ignore = ignore or []
-    json_mode = format == "json"
 
     if not nogic_dir.exists():
-        if json_mode:
-            _emit_json("error", message="Not a Nogic project. Run `nogic init` to initialize.")
-        else:
-            ui.error("Not a Nogic project.")
-            ui.dim("Run `nogic init` to initialize your project.")
+        ui.error("Not a Nogic project.")
+        ui.dim("Run `nogic init` to initialize your project.")
         raise typer.Exit(1)
 
     config = Config.load(directory)
 
     if not config.api_key:
-        if json_mode:
-            _emit_json("error", message="Not logged in. Run `nogic login` to authenticate.")
-        else:
-            ui.error("Not logged in.")
-            ui.dim("Run `nogic login` to authenticate.")
+        ui.error("Not logged in.")
+        ui.dim("Run `nogic login` to authenticate.")
         raise typer.Exit(1)
 
     if not config.project_id:
-        if json_mode:
-            _emit_json("error", message="No project configured. Run `nogic init` to initialize.")
-        else:
-            ui.error("No project configured.")
-            ui.dim("Run `nogic init` to initialize your project.")
+        ui.error("No project configured.")
+        ui.dim("Run `nogic init` to initialize your project.")
         raise typer.Exit(1)
 
-    if not json_mode:
-        if is_dev_mode():
-            ui.dev_banner(get_api_url())
-        ui.banner("nogic watch", str(directory))
-        ui.kv("Project", f"{config.project_id[:8]}...")
+    if is_dev_mode():
+        ui.dev_banner(get_api_url())
 
-    log_fn = (lambda msg: None) if json_mode else (lambda msg: ui.dim(f"  {msg}"))
-    sync_service = SyncService(config, directory, log=log_fn, json_mode=json_mode)
+    ui.banner("nogic watch", str(directory))
+    ui.kv("Project", f"{config.project_id[:8]}...")
+
+    sync_service = SyncService(config, directory, log=lambda msg: ui.dim(f"  {msg}"))
 
     should_ignore = build_ignore_matcher(directory, extra_patterns=ignore)
 
     # Initial scan
     try:
         sync_service.initial_scan(directory, should_ignore)
-        if json_mode:
-            files_indexed = len(sync_service._file_cache)
-            _emit_json("initial_scan_complete", files_indexed=files_indexed)
     except KeyboardInterrupt:
-        if not json_mode:
-            ui.console.print()
-            ui.dim("Interrupted during initial scan. Cleaning up...")
+        ui.console.print()
+        ui.dim("Interrupted during initial scan. Cleaning up...")
         try:
             sync_service.client.clear_staging(config.project_id)
         except Exception:
@@ -93,27 +68,15 @@ def watch(
             return
         try:
             if sync_service.sync_file_immediate(path):
-                if json_mode:
-                    _emit_json("synced", path=str(rel))
-                else:
-                    ui.console.print(f"  [green]SYNCED[/] {rel}")
+                ui.console.print(f"  [green]SYNCED[/] {rel}")
         except Exception as e:
             err_msg = str(e)
             if "413" in err_msg:
-                if json_mode:
-                    _emit_json("skip", path=str(rel), reason="file too large")
-                else:
-                    ui.console.print(f"  [yellow]SKIP[/] {rel} (file too large for API)")
+                ui.console.print(f"  [yellow]SKIP[/] {rel} (file too large for API)")
             elif "503" in err_msg or "502" in err_msg:
-                if json_mode:
-                    _emit_json("error", path=str(rel), message="backend unavailable")
-                else:
-                    ui.console.print(f"  [red]ERROR[/] {rel} (backend unavailable, will sync on next change)")
+                ui.console.print(f"  [red]ERROR[/] {rel} (backend unavailable, will sync on next change)")
             else:
-                if json_mode:
-                    _emit_json("error", path=str(rel), message=err_msg[:120])
-                else:
-                    ui.console.print(f"  [red]ERROR[/] {rel}: {err_msg[:120]}")
+                ui.console.print(f"  [red]ERROR[/] {rel}: {err_msg[:120]}")
 
     def on_delete(path: Path):
         try:
@@ -122,20 +85,11 @@ def watch(
             return
         try:
             if sync_service.delete_file_immediate(path):
-                if json_mode:
-                    _emit_json("deleted", path=str(rel))
-                else:
-                    ui.console.print(f"  [red]DELETED[/] {rel}")
+                ui.console.print(f"  [red]DELETED[/] {rel}")
             else:
-                if json_mode:
-                    _emit_json("deleted", path=str(rel))
-                else:
-                    ui.console.print(f"  [dim]DELETED[/] {rel} (not indexed)")
+                ui.console.print(f"  [dim]DELETED[/] {rel} (not indexed)")
         except Exception as e:
-            if json_mode:
-                _emit_json("error", path=str(rel), message=str(e)[:80])
-            else:
-                ui.console.print(f"  [red]DELETED[/] {rel} (error: {str(e)[:80]})")
+            ui.console.print(f"  [red]DELETED[/] {rel} (error: {str(e)[:80]})")
 
     monitor = FileMonitor(
         root_path=directory,
@@ -144,24 +98,19 @@ def watch(
         should_ignore=should_ignore,
     )
 
-    if json_mode:
-        _emit_json("ready", message="Watching for changes...")
-    else:
-        ui.console.print()
-        ui.info("Watching for changes... (Ctrl+C to stop)")
-        ui.console.print()
+    ui.console.print()
+    ui.info("Watching for changes... (Ctrl+C to stop)")
+    ui.console.print()
 
     monitor.start()
     try:
         while monitor.is_alive():
             time.sleep(1)
     except KeyboardInterrupt:
-        if not json_mode:
-            ui.console.print()
-            ui.dim("Stopping...")
+        ui.console.print()
+        ui.dim("Stopping...")
     finally:
         monitor.stop()
         sync_service.close()
 
-    if not json_mode:
-        ui.success("Done.")
+    ui.success("Done.")

nogic/watcher/sync.py

@@ -2,11 +2,8 @@
 
 import asyncio
 import hashlib
-import json as _json
 import logging
 import os
-import sys
-import time
 from pathlib import Path
 from typing import Callable, Optional
 
@@ -76,22 +73,14 @@ class SyncService:
         config: Config,
         root_path: Path,
         log: Optional[Callable[[str], None]] = None,
-        json_mode: bool = False,
     ):
         self.config = config
         self.root_path = root_path
         self.log = log or print
-        self.json_mode = json_mode
         self._client: Optional[NogicClient] = None
         # In-memory cache of file info for current session
         self._file_cache: dict[str, dict] = {}  # path -> {hash, content, language}
 
-    def _emit_json(self, event: str, **kwargs):
-        """Emit a single NDJSON progress line to stdout (json_mode only)."""
-        payload = {"event": event, "timestamp": int(time.time()), **kwargs}
-        sys.stdout.write(_json.dumps(payload) + "\n")
-        sys.stdout.flush()
-
     @property
     def client(self) -> NogicClient:
         if self._client is None:
@@ -158,37 +147,40 @@ class SyncService:
 
         Returns list of {path, hash, content, language} for supported files.
         """
-        # Collect files using os.walk for directory pruning (skips ignored dirs entirely)
-        if not self.json_mode:
-            console = Console()
-            ctx = console.status("[bold blue]Finding files...", spinner="dots")
-            ctx.__enter__()
-
-        all_files = []
-        for dirpath, dirnames, filenames in os.walk(root_path):
-            dp = Path(dirpath)
-            dirnames[:] = [
-                d for d in dirnames
-                if not ignore_check(dp / d)
-            ]
-            for fname in filenames:
-                fpath = dp / fname
-                if not ignore_check(fpath):
-                    all_files.append(fpath)
+        console = Console()
 
-        if not self.json_mode:
-            ctx.__exit__(None, None, None)
+        # Collect files using os.walk for directory pruning (skips ignored dirs entirely)
+        with console.status("[bold blue]Finding files...", spinner="dots"):
+            all_files = []
+            for dirpath, dirnames, filenames in os.walk(root_path):
+                dp = Path(dirpath)
+                # Prune ignored directories in-place so os.walk doesn't descend
+                dirnames[:] = [
+                    d for d in dirnames
+                    if not ignore_check(dp / d)
+                ]
+                for fname in filenames:
+                    fpath = dp / fname
+                    if not ignore_check(fpath):
+                        all_files.append(fpath)
 
         files_info = []
         supported_count = 0
         skipped_large = 0
-        total_files = len(all_files)
 
-        if self.json_mode:
-            # Emit progress via NDJSON
-            for i, path in enumerate(all_files):
-                if i % 50 == 0 or i == total_files - 1:
-                    self._emit_json("progress", phase="scanning", current=i + 1, total=total_files)
+        # Scan with progress bar
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            MofNCompleteColumn(),
+            TimeElapsedColumn(),
+            transient=False,
+        ) as progress:
+            task = progress.add_task("Scanning files", total=len(all_files))
+
+            for path in all_files:
+                progress.update(task, advance=1)
 
                 language = get_language(path)
                 if not language:
@@ -218,49 +210,6 @@ class SyncService:
                     "language": language,
                 })
                 supported_count += 1
-        else:
-            # Rich progress bar
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                BarColumn(),
-                MofNCompleteColumn(),
-                TimeElapsedColumn(),
-                transient=False,
-            ) as progress:
-                task = progress.add_task("Scanning files", total=total_files)
-
-                for path in all_files:
-                    progress.update(task, advance=1)
-
-                    language = get_language(path)
-                    if not language:
-                        continue
-
-                    try:
-                        file_size = path.stat().st_size
-                    except OSError:
-                        continue
-
-                    if file_size > MAX_SINGLE_FILE_BYTES:
-                        skipped_large += 1
-                        continue
-
-                    try:
-                        content = path.read_text(encoding="utf-8")
-                    except (OSError, UnicodeDecodeError):
-                        continue
-
-                    rel_path = str(path.relative_to(root_path))
-                    content_hash = self.compute_hash(content)
-
-                    files_info.append({
-                        "path": rel_path,
-                        "hash": content_hash,
-                        "content": content,
-                        "language": language,
-                    })
-                    supported_count += 1
 
         msg = f"Found {supported_count} supported files ({len(all_files)} total)"
         if skipped_large > 0:
@@ -352,61 +301,47 @@ class SyncService:
         # Phase 1: Parallel upload
         self.log(f"Phase 1: Uploading {total_files} files in {num_batches} batches...")
 
-        if self.json_mode:
-            self._emit_json("progress", phase="uploading", current=0, total=num_batches)
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            MofNCompleteColumn(),
+            TimeElapsedColumn(),
+            transient=False,
+        ) as progress:
+            upload_task = progress.add_task(
+                "Uploading batches",
+                total=num_batches
+            )
 
+            # Run parallel uploads
             try:
                 result = asyncio.run(
-                    self._upload_batches_parallel_json(batches, num_batches)
+                    self._upload_batches_parallel(batches, progress, upload_task)
                 )
             except Exception as e:
-                self._emit_json("error", message=f"Parallel upload failed: {e}")
+                self.log(f"Parallel upload failed: {e}")
+                # Clear staging and fall back to legacy
                 try:
                     self.client.clear_staging(self.config.project_id)
                 except Exception:
                     pass
                 self.log("Falling back to legacy mode...")
                 return self._sync_files_legacy(files_info)
-        else:
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                BarColumn(),
-                MofNCompleteColumn(),
-                TimeElapsedColumn(),
-                transient=False,
-            ) as progress:
-                upload_task = progress.add_task(
-                    "Uploading batches",
-                    total=num_batches
-                )
-
-                try:
-                    result = asyncio.run(
-                        self._upload_batches_parallel(batches, progress, upload_task)
-                    )
-                except Exception as e:
-                    self.log(f"Parallel upload failed: {e}")
-                    try:
-                        self.client.clear_staging(self.config.project_id)
-                    except Exception:
-                        pass
-                    self.log("Falling back to legacy mode...")
-                    return self._sync_files_legacy(files_info)
 
         total_uploaded = result['total_parsed']
         total_staged = result['total_staged']
         total_skipped = result.get('total_skipped', 0)
 
+        # If backend doesn't return files_skipped, calculate from totals
         if total_skipped == 0 and total_staged < total_uploaded:
             total_skipped = total_uploaded - total_staged
 
         self.log(f"Uploaded {total_uploaded} files ({total_staged} staged, {total_skipped} unchanged)")
 
+        # Skip Phase 2 if all files are unchanged
         if total_staged == 0:
             self.log("All files unchanged, nothing to index")
-            if self.json_mode:
-                self._emit_json("complete", files_indexed=0, nodes_created=0, edges_created=0)
             return True
 
         # Phase 2: Finalize with streaming progress
@@ -418,7 +353,17 @@ class SyncService:
         total_edges = 0
         all_errors = []
 
-        if self.json_mode:
+        # Track tasks by stage name
+        stage_tasks: dict = {}
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description:<12}"),
+            BarColumn(),
+            MofNCompleteColumn(),
+            TimeElapsedColumn(),
+            transient=False,
+        ) as progress:
             try:
                 for event in self.client.finalize_stream(self.config.project_id):
                     if event.stage == "complete":
@@ -428,86 +373,39 @@ class SyncService:
                         total_edges = event.edges_created or 0
                         if event.errors:
                             all_errors.extend(event.errors)
-                        self._emit_json(
-                            "complete",
-                            files_indexed=total_indexed,
-                            files_skipped=total_skipped,
-                            nodes_created=total_nodes,
-                            edges_created=total_edges,
-                            errors=len(all_errors),
-                        )
+                        for task_id in stage_tasks.values():
+                            progress.update(task_id, completed=progress.tasks[task_id].total)
                         break
 
                     if event.stage == "error":
-                        self._emit_json("error", message=event.message or "Processing error")
+                        all_errors.append({"path": "finalize", "error": event.message})
                         break
 
                     stage = event.stage
                     current = event.current or 0
                     total = event.total or 0
-                    label = STAGE_LABELS.get(stage, stage)
-                    self._emit_json("progress", phase="processing", stage=stage, label=label, current=current, total=total)
+
+                    if stage not in stage_tasks:
+                        task_total = total if total > 0 else 100
+                        label = STAGE_LABELS.get(stage, stage)
+                        stage_tasks[stage] = progress.add_task(
+                            label,
+                            total=task_total,
+                        )
+
+                    task_id = stage_tasks[stage]
+
+                    if total > 0 and progress.tasks[task_id].total != total:
+                        progress.update(task_id, total=total)
+
+                    progress.update(task_id, completed=current)
 
             except httpx.HTTPStatusError as e:
-                self._emit_json("error", message=f"Finalize error: {e.response.status_code}")
+                self.log(f"Finalize error: {e.response.status_code}")
                 raise
             except httpx.RequestError as e:
-                self._emit_json("error", message=f"Request error during finalize: {e}")
+                self.log(f"Request error during finalize: {e}")
                 raise
-        else:
-            # Rich progress for terminal
-            stage_tasks: dict = {}
-
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description:<12}"),
-                BarColumn(),
-                MofNCompleteColumn(),
-                TimeElapsedColumn(),
-                transient=False,
-            ) as progress:
-                try:
-                    for event in self.client.finalize_stream(self.config.project_id):
-                        if event.stage == "complete":
-                            total_indexed = event.files_indexed or 0
-                            total_skipped = event.files_skipped or 0
-                            total_nodes = event.nodes_created or 0
-                            total_edges = event.edges_created or 0
-                            if event.errors:
-                                all_errors.extend(event.errors)
-                            for task_id in stage_tasks.values():
-                                progress.update(task_id, completed=progress.tasks[task_id].total)
-                            break
-
-                        if event.stage == "error":
-                            all_errors.append({"path": "finalize", "error": event.message})
-                            break
-
-                        stage = event.stage
-                        current = event.current or 0
-                        total = event.total or 0
-
-                        if stage not in stage_tasks:
-                            task_total = total if total > 0 else 100
-                            label = STAGE_LABELS.get(stage, stage)
-                            stage_tasks[stage] = progress.add_task(
-                                label,
-                                total=task_total,
-                            )
-
-                        task_id = stage_tasks[stage]
-
-                        if total > 0 and progress.tasks[task_id].total != total:
-                            progress.update(task_id, total=total)
-
-                        progress.update(task_id, completed=current)
-
-                except httpx.HTTPStatusError as e:
-                    self.log(f"Finalize error: {e.response.status_code}")
-                    raise
-                except httpx.RequestError as e:
-                    self.log(f"Request error during finalize: {e}")
-                    raise
 
         # Summary
         if total_skipped > 0:
@@ -524,62 +422,6 @@ class SyncService:
 
         return True
 
-    async def _upload_batches_parallel_json(
-        self,
-        batches: list[list[dict]],
-        num_batches: int,
-        max_concurrent: int = MAX_CONCURRENT,
-    ) -> dict:
-        """Upload all batches in parallel, emitting NDJSON progress."""
-        semaphore = asyncio.Semaphore(max_concurrent)
-        results = {"total_parsed": 0, "total_staged": 0, "total_skipped": 0, "errors": []}
-        completed = 0
-        lock = asyncio.Lock()
-
-        async with httpx.AsyncClient(
-            timeout=60.0,
-            limits=httpx.Limits(max_connections=max_concurrent + 2, max_keepalive_connections=max_concurrent),
-        ) as client:
-            async def upload_one(batch: list[dict], batch_num: int) -> dict:
-                nonlocal completed
-                async with semaphore:
-                    resp = await client.post(
-                        f"{self.config.api_url}/v1/index/upload",
-                        json={
-                            "project_id": self.config.project_id,
-                            "files": batch,
-                        },
-                        headers={
-                            "Authorization": f"Bearer {self.config.api_key}",
-                            "Content-Type": "application/json",
-                        },
-                    )
-                    resp.raise_for_status()
-                    data = resp.json()
-
-                    async with lock:
-                        completed += 1
-                        self._emit_json("progress", phase="uploading", current=completed, total=num_batches)
-
-                    return data
-
-            tasks = [upload_one(batch, i) for i, batch in enumerate(batches)]
-            responses = await asyncio.gather(*tasks, return_exceptions=True)
-
-        for resp in responses:
-            if isinstance(resp, Exception):
-                results["errors"].append(str(resp))
-                logger.error(f"Batch upload failed: {resp}")
-            elif isinstance(resp, dict):
-                results["total_parsed"] += resp.get("files_parsed", 0)
-                results["total_staged"] = max(results["total_staged"], resp.get("total_staged", 0))
-                results["total_skipped"] += resp.get("files_skipped", 0)
-
-        if results["errors"]:
-            raise Exception(f"{len(results['errors'])} batches failed: {results['errors'][0]}")
-
-        return results
-
     async def _upload_batches_parallel(
         self,
         batches: list[list[dict]],
@@ -651,10 +493,9 @@ class SyncService:
     def _upload_files_batched(self, files: list[dict]) -> bool:
         """Upload files in batches with progress."""
         if not files:
-            if self.json_mode:
-                self._emit_json("complete", files_indexed=0, nodes_created=0, edges_created=0)
             return True
 
+        # Prepare files for upload (include hash for server-side dedup)
         upload_files = [
             {
                 "path": f["path"],
@@ -674,14 +515,29 @@ class SyncService:
         total_nodes = 0
         total_edges = 0
         all_errors = []
-        files_done = 0
 
-        if self.json_mode:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            MofNCompleteColumn(),
+            TimeElapsedColumn(),
+            transient=False,
+        ) as progress:
+            upload_task = progress.add_task(
+                f"Uploading files",
+                total=total_files
+            )
+
+            files_done = 0
             for batch_num, batch in enumerate(batches):
-                self._emit_json("progress", phase="uploading", current=batch_num, total=num_batches,
-                                description=f"Uploading batch {batch_num + 1}/{num_batches}")
+                progress.update(
+                    upload_task,
+                    description=f"Uploading batch {batch_num + 1}/{num_batches}"
+                )
+
                 try:
-                    result = self._send_batch_stream(batch)
+                    result = self._send_batch_stream(batch, progress)
                     if result:
                         total_indexed += result.files_indexed or 0
                         total_skipped += result.files_skipped or 0
@@ -690,52 +546,10 @@ class SyncService:
                         if result.errors:
                             all_errors.extend(result.errors)
                 except Exception as e:
-                    self._emit_json("error", message=f"Batch {batch_num + 1} failed: {e}")
+                    self.log(f"  [ERROR] Batch {batch_num + 1} failed: {e}")
 
                 files_done += len(batch)
-
-            self._emit_json(
-                "complete",
-                files_indexed=total_indexed,
-                files_skipped=total_skipped,
-                nodes_created=total_nodes,
-                edges_created=total_edges,
-                errors=len(all_errors),
-            )
-        else:
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                BarColumn(),
-                MofNCompleteColumn(),
-                TimeElapsedColumn(),
-                transient=False,
-            ) as progress:
-                upload_task = progress.add_task(
-                    "Uploading files",
-                    total=total_files
-                )
-
-                for batch_num, batch in enumerate(batches):
-                    progress.update(
-                        upload_task,
-                        description=f"Uploading batch {batch_num + 1}/{num_batches}"
-                    )
-
-                    try:
-                        result = self._send_batch_stream(batch, progress)
-                        if result:
-                            total_indexed += result.files_indexed or 0
-                            total_skipped += result.files_skipped or 0
-                            total_nodes += result.nodes_created or 0
-                            total_edges += result.edges_created or 0
-                            if result.errors:
-                                all_errors.extend(result.errors)
-                    except Exception as e:
-                        self.log(f"  [ERROR] Batch {batch_num + 1} failed: {e}")
-
-                    files_done += len(batch)
-                    progress.update(upload_task, completed=files_done)
+                progress.update(upload_task, completed=files_done)
 
         # Summary
         if total_skipped > 0:
@@ -744,7 +558,7 @@ class SyncService:
             self.log(f"Indexed {total_indexed} files, {total_nodes} nodes, {total_edges} edges")
         if all_errors:
             self.log(f"Errors ({len(all_errors)}):")
-            for err in all_errors[:10]:
+            for err in all_errors[:10]:  # Show first 10 errors
                 self.log(f"  {err.get('path', 'unknown')}: {err.get('error', 'unknown error')}")
             if len(all_errors) > 10:
                 self.log(f"  ... and {len(all_errors) - 10} more errors")

{nogic-0.0.1.dist-info → nogic-0.1.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: nogic
-Version: 0.0.1
+Version: 0.1.0
 Summary: Code intelligence CLI for AI agents — index, search, and understand codebases via graph + vector embeddings.
 Project-URL: Homepage, https://nogic.dev
 Project-URL: Repository, https://github.com/nogic-dev/cli
 Project-URL: Documentation, https://docs.nogic.dev
-Author-email: Nogic <support@nogic.dev>
+Author-email: Nogic <hello@nogic.dev>
 License-Expression: MIT
 License-File: LICENSE
 Keywords: ai-agents,code-graph,code-intelligence,embeddings,mcp,tree-sitter

{nogic-0.0.1.dist-info → nogic-0.1.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-nogic/__init__.py,sha256=mrqbp3Uwau7m5t8uqo6Eq7az13oFNOWlx9Q1ETCRBHo,47
+nogic/__init__.py,sha256=8fFCEtduZTo1cQhZMEh-gMTcaFr38C36_E8Z1NAEZMM,47
 nogic/config.py,sha256=LPjsIPHjhERh0LkFIKe6n2z-RdkibOFvIlMQFTkBaAs,5006
 nogic/ignore.py,sha256=Q2uumbWVAXW201GAahvEEtgipqQmTPf49W_SEpyVyDk,2695
 nogic/main.py,sha256=AdAbbnXlxcbek8nTxL44-ZTNc1sqzWGIlWu-jzXK_9M,1399
@@ -7,14 +7,14 @@ nogic/ui.py,sha256=nCBHktKX2nOwMDv-Duvof-hBvfTkOiCGB41Lx0Rj_QI,1316
 nogic/api/__init__.py,sha256=fK108K0urB8LhB56bY5o1qUq_Pj_TQFP9YEP4xMVH1E,375
 nogic/api/client.py,sha256=BwdC3gyYPEGyY6lFDYXA8c3wrccuIq_pejalogrLeWk,12779
 nogic/commands/__init__.py,sha256=eMuQR40Ye6ei4XbISb4dO1BwFk5RRqKIKGMxrztVu9Y,28
-nogic/commands/init.py,sha256=nXUaO1qC8bFuxUCbeueNiJDyPBbphnfRrpHU2MXFZGo,5217
+nogic/commands/init.py,sha256=JWbm1AUyry4hAn-cOSFB8fG3uTTHJ5OL7yuQYQcWh_c,5056
 nogic/commands/login.py,sha256=dYR6HeveQej1Rgclz2DsT5Kq7qqoSfOad2f4iFtv4bI,2251
 nogic/commands/projects.py,sha256=I4DTWPJdgUgQDAmFUZT99CYU_ZXlNChU07CptuDAZa0,4422
-nogic/commands/reindex.py,sha256=2A1N2Ze6E064lcnlUa39Jr2xLAQq22-QeV8vRPSz3Io,4027
-nogic/commands/status.py,sha256=5ZdaLDdanCgSBL8ALoVban1vs7pdivyoSvwsoUP6ItI,6071
-nogic/commands/sync.py,sha256=b64uM2oUJDDGzn2Jc5ka9iFxnxafi1pKUYKgQpYANoE,2447
+nogic/commands/reindex.py,sha256=YY1-B-zJHuGiGqrta0AREWVdLKMJ8AxkcBj7Q0yPurY,2998
+nogic/commands/status.py,sha256=GtfWV3W28J3N0WBIlIXon7pbnGtXi7dlILQw-RnYR3I,3959
+nogic/commands/sync.py,sha256=aBt2gEE7t1TZMhAT3hvy2-z0Ox4BZSl4RxTd_ahCLW4,2160
 nogic/commands/telemetry_cmd.py,sha256=zFArvmYN-CTBAE8jgowWE9CMOniFdyufkQZS7lTcIaw,1796
-nogic/commands/watch.py,sha256=mHqUwBy-0zsAN7ZrpJI8aRVW4VReBqLV6epjIyFQki8,5769
+nogic/commands/watch.py,sha256=xO1CWC2MLBcB7rNX0zrtdxfcd4SzXghCg-hAB6xYlIw,3615
 nogic/parsing/__init__.py,sha256=PdfNe7OlMIx7pXUV73XCEts-gJbKDWl6d37Xgk5Dq1I,417
 nogic/parsing/js_extractor.py,sha256=m9SWP93byQqB-zcKdPqXdVkL2B_iM2kp1dj_6fUnwA4,25580
 nogic/parsing/parser.py,sha256=TgIVWGizdca606MV5gSdbQXFqsuzver5dKR3UMoYPg8,7051
@@ -27,9 +27,9 @@ nogic/storage/symbols.py,sha256=2aBKbqmyyAUCOzKLPJUecp49YkgGz_I3gj0esCZl-r8,6287
 nogic/watcher/__init__.py,sha256=NXX_7l69rhPc0EmNpGuV9uuFrqYqw2g9ulod5280f-c,238
 nogic/watcher/monitor.py,sha256=zSz6YLB0Wzp3u3bXITn6LuTFZ3uZ66l_Dg12S4KDE9s,2289
 nogic/watcher/storage.py,sha256=zrYK81CFxTFDPoFwFazbJi6EKna-bUkX2nofetUxiVU,5924
-nogic/watcher/sync.py,sha256=JZwDzYxbRFEufYDIGF9ND0UWxb0uySr1MWLTcr-R9d4,32703
-nogic-0.0.1.dist-info/METADATA,sha256=rKY5eGXtfCqBrRxzCnvSMvJY1p5e4LC3mfxUw8fus-U,4555
-nogic-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nogic-0.0.1.dist-info/entry_points.txt,sha256=_mT_cZ1fXzhogKq9r5T7c_qI7xAgcniKzftL0P6xTuQ,43
-nogic-0.0.1.dist-info/licenses/LICENSE,sha256=x8apHaKgnADt4dR_45yHyL-OBaRP8310XzD2jv8HRWg,1062
-nogic-0.0.1.dist-info/RECORD,,
+nogic/watcher/sync.py,sha256=uX2V3i4Opp5D3YWYetgS-CGzrCCRld4h2H7SOux9sqI,24543
+nogic-0.1.0.dist-info/METADATA,sha256=NkdOuP7qTlg5zt7Xp9_Ze-hQzQxEMh3XgfTHAnmR_vM,4553
+nogic-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nogic-0.1.0.dist-info/entry_points.txt,sha256=_mT_cZ1fXzhogKq9r5T7c_qI7xAgcniKzftL0P6xTuQ,43
+nogic-0.1.0.dist-info/licenses/LICENSE,sha256=x8apHaKgnADt4dR_45yHyL-OBaRP8310XzD2jv8HRWg,1062
+nogic-0.1.0.dist-info/RECORD,,