nogic 0.0.1__py3-none-any.whl

nogic/commands/projects.py

@@ -0,0 +1,138 @@
+"""Projects command - list and manage projects."""
+
+from pathlib import Path
+from typing import Annotated
+
+import httpx
+import typer
+
+from nogic.config import Config
+from nogic.api import NogicClient
+from nogic.api.client import get_directory_hash
+from nogic import ui
+
+projects_app = typer.Typer(no_args_is_help=True, rich_markup_mode="rich")
+
+
+def _require_auth() -> Config:
+    config = Config.load()
+    if not config.api_key:
+        ui.error("Not logged in.")
+        ui.dim("Run `nogic login` to authenticate.")
+        raise typer.Exit(1)
+    return config
+
+
+@projects_app.command("list")
+def list_projects(
+    verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Show detailed info.")] = False,
+):
+    """List your projects."""
+    config = _require_auth()
+
+    client = NogicClient(config)
+    try:
+        with ui.status_spinner("Fetching projects..."):
+            projects_list = client.list_projects()
+
+        if not projects_list:
+            ui.info("No projects found.")
+            ui.dim("Create one with: nogic init")
+            return
+
+        ui.banner("nogic projects", f"{len(projects_list)} project(s)")
+        for p in projects_list:
+            marker = " [green]*[/]" if p.id == config.project_id else ""
+            ui.console.print(f"  [bold]{p.name}[/] [dim]({p.id[:8]}...)[/]{marker}")
+            if verbose:
+                if p.directory_hash:
+                    ui.dim(f"    Hash: {p.directory_hash[:16]}...")
+                if p.created_at:
+                    ui.dim(f"    Created: {p.created_at}")
+
+        if config.project_id:
+            ui.console.print()
+            ui.dim("  * = current project")
+
+    except httpx.HTTPStatusError as e:
+        ui.error(f"Error ({e.response.status_code})")
+        raise typer.Exit(1)
+    finally:
+        client.close()
+
+
+@projects_app.command("use")
+def use_project(
+    project_id: Annotated[str, typer.Argument(help="Project ID (prefix match).")],
+):
+    """Set the current project by ID."""
+    cwd = Path.cwd()
+    config = _require_auth()
+
+    client = NogicClient(config)
+    try:
+        with ui.status_spinner("Fetching projects..."):
+            projects_list = client.list_projects()
+        matched = [p for p in projects_list if p.id.startswith(project_id)]
+
+        if not matched:
+            ui.error(f"No project found matching: {project_id}")
+            raise typer.Exit(1)
+        if len(matched) > 1:
+            ui.error(f"Multiple projects match '{project_id}':")
+            for p in matched:
+                ui.console.print(f"  {p.name} ({p.id})")
+            raise typer.Exit(1)
+
+        config.project_id = matched[0].id
+        config.save_local(cwd)
+        ui.success(f"Now using project: {matched[0].name}")
+
+    except httpx.HTTPStatusError as e:
+        ui.error(f"Error ({e.response.status_code})")
+        raise typer.Exit(1)
+    finally:
+        client.close()
+
+
+@projects_app.command("create")
+def create_project(
+    name: Annotated[str, typer.Argument(help="Project name.")],
+    use: Annotated[bool, typer.Option("--use", help="Set as current project.")] = False,
+    link: Annotated[bool, typer.Option("--link", help="Link to current directory.")] = False,
+):
+    """Create a new project."""
+    cwd = Path.cwd()
+    config = _require_auth()
+
+    dir_hash = get_directory_hash(str(cwd)) if link else None
+
+    client = NogicClient(config)
+    try:
+        with ui.status_spinner("Creating project..."):
+            project = client.create_project(name, dir_hash)
+
+        ui.success(f"Created project: {project.name}")
+        ui.kv("Project ID", project.id)
+        if link:
+            ui.kv("Linked to", str(cwd))
+
+        if use or link:
+            config.project_id = project.id
+            config.project_name = project.name
+            if link:
+                config.directory_hash = dir_hash
+            config.save_local(cwd)
+            ui.dim("Set as current project.")
+
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 409:
+            data = e.response.json()
+            ui.error("A project already exists for this directory.")
+            ui.kv("Project", f"{data.get('project_name')} ({data.get('project_id')[:8]}...)", indent=4)
+            ui.dim("  Use 'nogic init' to reuse the existing project.")
+        else:
+            ui.error(f"Error ({e.response.status_code})")
+        raise typer.Exit(1)
+    finally:
+        client.close()

nogic/commands/reindex.py

@@ -0,0 +1,117 @@
+"""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
+
+import httpx
+import typer
+
+from nogic.config import Config, CONFIG_DIR, is_dev_mode, get_api_url
+from nogic.ignore import build_ignore_matcher
+from nogic.watcher import SyncService
+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.")
+        ui.dim("Run `nogic init` to initialize your project.")
+        raise typer.Exit(1)
+
+    config = Config.load(directory)
+
+    if not config.api_key:
+        ui.error("Not logged in.")
+        ui.dim("Run `nogic login` to authenticate.")
+        raise typer.Exit(1)
+
+    if not config.project_id:
+        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())
+
+        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})")
+                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)
+
+        if json_mode:
+            _emit_json("wiped", nodes_deleted=nodes_deleted)
+        elif 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.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.")
+
+    finally:
+        client.close()

nogic/commands/status.py

@@ -0,0 +1,165 @@
+"""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
+
+import httpx
+import typer
+
+from nogic.config import Config, CONFIG_DIR, is_dev_mode, get_api_url
+from nogic.api import NogicClient
+from nogic.api.client import get_directory_hash
+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.")
+        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())
+
+    ui.banner("nogic status")
+
+    ui.section("Local Configuration")
+    ui.kv("Directory", str(directory))
+    ui.kv("Project ID", config.project_id or "(not set)")
+    ui.kv("Project Name", config.project_name or "(not set)")
+    ui.kv("Directory Hash", f"{current_dir_hash[:16]}...")
+    ui.kv("Logged in", "Yes" if config.api_key else "[red]No[/]")
+
+    if config.directory_hash and config.directory_hash != current_dir_hash:
+        ui.console.print()
+        ui.warn("Directory hash mismatch!")
+        ui.kv("Config hash", f"{config.directory_hash[:16]}...", indent=4)
+        ui.kv("Current hash", f"{current_dir_hash[:16]}...", indent=4)
+        ui.dim("    Project may have been moved. Run 'nogic init --link' to update.")
+
+    # Backend verification
+    if config.api_key and config.project_id:
+        client = NogicClient(config)
+        try:
+            with ui.status_spinner("Checking backend..."):
+                backend_project = client.get_project_by_directory(current_dir_hash)
+
+            ui.section("Backend Status")
+            if backend_project:
+                ui.kv("Project found", backend_project.name)
+                ui.kv("Project ID", backend_project.id)
+                if backend_project.created_at:
+                    ui.kv("Created", _format_datetime(backend_project.created_at))
+                if backend_project.updated_at:
+                    ui.kv("Updated", _format_datetime(backend_project.updated_at))
+
+                if backend_project.id != config.project_id:
+                    ui.console.print()
+                    ui.warn("Project ID mismatch!")
+                    ui.kv("Local config", config.project_id, indent=4)
+                    ui.kv("Backend", backend_project.id, indent=4)
+                    ui.dim("    Run 'nogic init --link' to fix.")
+            else:
+                ui.dim("  No project found for this directory in backend")
+                if config.project_id:
+                    ui.dim(f"  Local config has project ID: {config.project_id}")
+                    ui.dim("  Consider running 'nogic init --link' to link it.")
+
+        except httpx.HTTPStatusError as e:
+            ui.section("Backend Status")
+            ui.error(f"Error ({e.response.status_code})")
+            if e.response.status_code == 401:
+                ui.dim("  Authentication failed. Run: nogic login")
+        except httpx.RequestError:
+            ui.section("Backend Status")
+            ui.error("Connection failed")
+        finally:
+            client.close()
+    elif not config.api_key:
+        ui.section("Backend Status")
+        ui.dim("  Not logged in. Run `nogic login` to authenticate.")
+    else:
+        ui.section("Backend Status")
+        ui.dim("  No project configured. Run `nogic init` to set up.")
+
+    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"))
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except (ValueError, AttributeError):
+        return dt_string

nogic/commands/sync.py

@@ -0,0 +1,72 @@
+"""Sync command - one-time full sync to backend."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from nogic.config import Config, is_dev_mode, get_api_url
+from nogic.ignore import build_ignore_matcher
+from nogic.watcher import SyncService
+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.")
+        ui.dim("Run `nogic init` to initialize your project.")
+        raise typer.Exit(1)
+
+    config = Config.load(directory)
+
+    if not config.api_key:
+        ui.error("Not logged in.")
+        ui.dim("Run `nogic login` to authenticate.")
+        raise typer.Exit(1)
+
+    if not config.project_id:
+        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 sync", str(directory))
+        ui.kv("Project", f"{config.project_id[:8]}...")
+
+    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)
+
+    try:
+        sync_service.initial_scan(directory, build_ignore_matcher(directory, extra_patterns=ignore))
+        telemetry.capture("cli_sync", {"status": "success"})
+    except KeyboardInterrupt:
+        if not json_mode:
+            ui.console.print()
+            ui.dim("Interrupted. Cleaning up...")
+        try:
+            sync_service.client.clear_staging(config.project_id)
+        except Exception:
+            pass
+        telemetry.capture("cli_sync", {"status": "interrupted"})
+        raise typer.Exit(1)
+    except Exception as e:
+        telemetry.capture("cli_sync", {"status": "error", "error": str(e)})
+        raise
+    finally:
+        sync_service.close()
+
+    if not json_mode:
+        ui.console.print()
+        ui.success("Done.")

nogic/commands/telemetry_cmd.py

@@ -0,0 +1,65 @@
+"""Telemetry management commands."""
+
+import json
+import os
+
+import typer
+
+from nogic.config import GLOBAL_CONFIG_DIR, CONFIG_FILE
+from nogic import ui
+
+telemetry_app = typer.Typer(no_args_is_help=True, rich_markup_mode="rich")
+
+
+def _load_global_config() -> dict:
+    config_path = GLOBAL_CONFIG_DIR / CONFIG_FILE
+    if config_path.exists():
+        try:
+            with open(config_path, encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def _save_global_config(data: dict):
+    GLOBAL_CONFIG_DIR.mkdir(mode=0o700, exist_ok=True)
+    config_path = GLOBAL_CONFIG_DIR / CONFIG_FILE
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+    os.chmod(config_path, 0o600)
+
+
+@telemetry_app.command("status")
+def telemetry_status():
+    """Show current telemetry status."""
+    config = _load_global_config()
+    enabled = config.get("telemetry_enabled", True) is not False
+
+    if enabled:
+        ui.success("Telemetry is enabled")
+        ui.dim("  Run `nogic telemetry disable` to opt out")
+    else:
+        ui.warn("Telemetry is disabled")
+        ui.dim("  Run `nogic telemetry enable` to enable")
+
+    ui.console.print()
+    ui.dim("Telemetry helps us improve Nogic. All data is anonymized.")
+
+
+@telemetry_app.command("enable")
+def telemetry_enable():
+    """Enable telemetry."""
+    config = _load_global_config()
+    config["telemetry_enabled"] = True
+    _save_global_config(config)
+    ui.success("Telemetry enabled")
+
+
+@telemetry_app.command("disable")
+def telemetry_disable():
+    """Disable telemetry."""
+    config = _load_global_config()
+    config["telemetry_enabled"] = False
+    _save_global_config(config)
+    ui.success("Telemetry disabled")