nogic 0.0.1__py3-none-any.whl

nogic/commands/watch.py

@@ -0,0 +1,167 @@
+"""Watch command for file syncing."""
+
+import json
+import sys
+import time
+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 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.")
+        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.")
+        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.")
+        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]}...")
+
+    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)
+
+    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...")
+        try:
+            sync_service.client.clear_staging(config.project_id)
+        except Exception:
+            pass
+        sync_service.close()
+        raise typer.Exit(1)
+
+    def on_change(path: Path):
+        try:
+            rel = path.relative_to(directory)
+        except ValueError:
+            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}")
+        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)")
+            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)")
+            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]}")
+
+    def on_delete(path: Path):
+        try:
+            rel = path.relative_to(directory)
+        except ValueError:
+            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}")
+            else:
+                if json_mode:
+                    _emit_json("deleted", path=str(rel))
+                else:
+                    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]})")
+
+    monitor = FileMonitor(
+        root_path=directory,
+        on_change=on_change,
+        on_delete=on_delete,
+        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()
+
+    monitor.start()
+    try:
+        while monitor.is_alive():
+            time.sleep(1)
+    except KeyboardInterrupt:
+        if not json_mode:
+            ui.console.print()
+            ui.dim("Stopping...")
+    finally:
+        monitor.stop()
+        sync_service.close()
+
+    if not json_mode:
+        ui.success("Done.")

nogic/config.py

@@ -0,0 +1,157 @@
+"""Configuration management for Nogic CLI."""
+
+import os
+import json
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Optional
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+CONFIG_DIR = ".nogic"
+CONFIG_FILE = "config.json"
+GLOBAL_CONFIG_DIR = Path.home() / ".nogic"
+
+_PRODUCTION_URL = "https://api.nogic.dev"
+
+
+def is_dev_mode() -> bool:
+    """True when NOGIC_API_URL env var overrides the production URL."""
+    return bool(os.getenv("NOGIC_API_URL"))
+
+
+def get_api_url() -> str:
+    """Return NOGIC_API_URL if set, otherwise the production URL."""
+    return os.getenv("NOGIC_API_URL", _PRODUCTION_URL).strip().rstrip("/")
+
+
+def dev_mode_banner() -> str | None:
+    """Return a dev mode banner string, or None if in production mode."""
+    if is_dev_mode():
+        return f"[DEV] Using {get_api_url()}"
+    return None
+
+
+@dataclass
+class Config:
+    api_key: Optional[str]
+    project_id: Optional[str]
+    project_name: Optional[str] = None
+    directory_hash: Optional[str] = None
+
+    @property
+    def api_url(self) -> str:
+        return get_api_url()
+
+    @classmethod
+    def load(cls, directory: Path = Path.cwd()) -> "Config":
+        """
+        Load config from multiple sources (priority order):
+        1. Environment variables
+        2. Global config: ~/.nogic/config.json (api_key)
+        3. Local config: <directory>/.nogic/config.json (project_id, project_name, directory_hash)
+        """
+        api_key = os.getenv("NOGIC_API_KEY")
+        project_id = None
+        project_name = None
+        directory_hash = None
+
+        global_config_path = GLOBAL_CONFIG_DIR / CONFIG_FILE
+        if global_config_path.exists():
+            try:
+                with open(global_config_path, encoding="utf-8") as f:
+                    data = json.load(f)
+                    if not api_key:
+                        api_key = data.get("api_key")
+            except (json.JSONDecodeError, OSError):
+                pass  # Corrupted config - continue with defaults
+
+        local_config_path = directory / CONFIG_DIR / CONFIG_FILE
+        if local_config_path.exists():
+            try:
+                with open(local_config_path, encoding="utf-8") as f:
+                    data = json.load(f)
+                    project_id = data.get("project_id")
+                    project_name = data.get("project_name")
+                    directory_hash = data.get("directory_hash")
+            except (json.JSONDecodeError, OSError):
+                pass  # Corrupted config - continue with defaults
+
+        if api_key:
+            api_key = api_key.strip()
+
+        return cls(
+            api_key=api_key,
+            project_id=project_id,
+            project_name=project_name,
+            directory_hash=directory_hash,
+        )
+
+    def save_global(self):
+        """Save API key to ~/.nogic/config.json (preserves other settings)."""
+        GLOBAL_CONFIG_DIR.mkdir(mode=0o700, exist_ok=True)
+
+        existing = {}
+        config_path = GLOBAL_CONFIG_DIR / CONFIG_FILE
+        if config_path.exists():
+            try:
+                with open(config_path, encoding="utf-8") as f:
+                    existing = json.load(f)
+            except (json.JSONDecodeError, OSError):
+                pass  # Corrupted config - will be overwritten
+
+        if self.api_key:
+            existing["api_key"] = self.api_key
+
+        # Never store api_url on disk
+        existing.pop("api_url", None)
+
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(existing, f, indent=2)
+
+        os.chmod(config_path, 0o600)
+
+    def save_local(self, directory: Path = Path.cwd()):
+        """Save project config to <directory>/.nogic/config.json."""
+        config_dir = directory / CONFIG_DIR
+        config_dir.mkdir(mode=0o700, exist_ok=True)
+
+        data = {}
+        if self.project_id:
+            data["project_id"] = self.project_id
+        if self.project_name:
+            data["project_name"] = self.project_name
+        if self.directory_hash:
+            data["directory_hash"] = self.directory_hash
+
+        config_path = 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)
+
+    def save(self, directory: Path = Path.cwd()):
+        """Save both global and local config."""
+        self.save_global()
+        self.save_local(directory)
+
+
+def get_cli_db_path(project_id: str) -> Path:
+    """Get the CLI's sync database path: ~/.nogic/sync/<project_id>/data.db"""
+    sync_dir = GLOBAL_CONFIG_DIR / "sync" / project_id
+    sync_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
+    return sync_dir / "data.db"
+
+
+def get_language(path: Path) -> Optional[str]:
+    """Get language from file extension."""
+    ext_map = {
+        ".py": "python",
+        ".js": "javascript",
+        ".jsx": "javascript",
+        ".ts": "typescript",
+        ".tsx": "typescript",
+    }
+    return ext_map.get(path.suffix.lower())

nogic/ignore.py

@@ -0,0 +1,109 @@
+"""Gitignore-aware file ignore logic.
+
+Consolidates ignore pattern handling used across sync, watch, and reindex commands.
+Uses pathspec for full .gitignore spec support (gitwildmatch).
+"""
+
+from pathlib import Path
+from typing import Callable
+
+import pathspec
+
+DEFAULT_IGNORE_PATTERNS = [
+    ".git/",
+    "__pycache__/",
+    "*.pyc",
+    ".venv/",
+    "venv/",
+    "env/",
+    "node_modules/",
+    ".nogic/",
+    ".DS_Store",
+    "*.swp",
+    "*.swo",
+    "*.tmp.*",
+    "*~",
+    # Build output directories
+    "dist/",
+    "build/",
+    "out/",
+    ".next/",
+    ".nuxt/",
+    ".output/",
+    # Coverage and test output
+    "coverage/",
+    ".coverage",
+    "htmlcov/",
+    # IDE and editor files
+    ".idea/",
+    ".vscode/",
+    # Bundled/minified files
+    "*.min.js",
+    "*.min.css",
+    "*.bundle.js",
+    "*.chunk.js",
+    # Lock files and binary artifacts
+    "*.lock",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "*.map",
+]
+
+
+def load_gitignore_patterns(root: Path) -> list[str]:
+    """Read .gitignore from root and return pattern lines.
+
+    Skips blank lines and comments. Returns empty list if no .gitignore exists.
+    """
+    gitignore_path = root / ".gitignore"
+    if not gitignore_path.is_file():
+        return []
+
+    try:
+        text = gitignore_path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return []
+
+    patterns = []
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped and not stripped.startswith("#"):
+            patterns.append(stripped)
+    return patterns
+
+
+def build_ignore_matcher(
+    root: Path,
+    extra_patterns: tuple[str, ...] | list[str] = (),
+) -> Callable[[Path], bool]:
+    """Build an ignore checker combining defaults + .gitignore + extra patterns.
+
+    Returns a callable that takes an absolute Path and returns True if it should
+    be ignored. Uses pathspec with gitwildmatch for full .gitignore compatibility.
+    """
+    root = root.resolve()
+
+    all_patterns = (
+        list(DEFAULT_IGNORE_PATTERNS)
+        + load_gitignore_patterns(root)
+        + list(extra_patterns)
+    )
+
+    spec = pathspec.PathSpec.from_lines("gitignore", all_patterns)
+
+    def should_ignore(path: Path) -> bool:
+        try:
+            rel_path = path.relative_to(root)
+        except ValueError:
+            return True
+
+        rel_str = str(rel_path)
+        # pathspec needs forward slashes; on Windows Path uses backslashes
+        rel_str = rel_str.replace("\\", "/")
+        # Append trailing slash for directories so dir patterns match
+        if path.is_dir():
+            rel_str += "/"
+        return spec.match_file(rel_str)
+
+    return should_ignore

nogic/main.py

@@ -0,0 +1,58 @@
+"""Main CLI entry point."""
+
+import atexit
+
+import typer
+
+from nogic import __version__
+from nogic import telemetry
+
+app = typer.Typer(
+    name="nogic",
+    help="Nogic CLI - Code Intelligence for AI Agents.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(f"nogic {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(None, "--version", "-V", callback=version_callback, is_eager=True, help="Show version."),
+):
+    """Nogic CLI - Code Intelligence for AI Agents."""
+    atexit.register(telemetry.shutdown)
+
+
+# Import and register commands
+from nogic.commands.login import login
+from nogic.commands.init import init
+from nogic.commands.watch import watch
+from nogic.commands.sync import sync
+from nogic.commands.reindex import reindex
+from nogic.commands.status import status
+from nogic.commands.projects import projects_app
+from nogic.commands.telemetry_cmd import telemetry_app
+
+app.command()(login)
+app.command()(init)
+app.command()(watch)
+app.command()(sync)
+app.command()(reindex)
+app.command()(status)
+app.add_typer(projects_app, name="projects", help="Manage Nogic projects.")
+app.add_typer(telemetry_app, name="telemetry", help="Manage telemetry settings.")
+
+
+def entry():
+    app()
+
+
+if __name__ == "__main__":
+    entry()

nogic/parsing/__init__.py

@@ -0,0 +1,22 @@
+"""
+Parsing module for extracting code intelligence from source files.
+"""
+
+from .types import (
+    ExtractedFunction,
+    ExtractedClass,
+    ExtractedCall,
+    ExtractedImport,
+    ParseResult,
+)
+from .parser import ParserService, parser_service
+
+__all__ = [
+    "ExtractedFunction",
+    "ExtractedClass",
+    "ExtractedCall",
+    "ExtractedImport",
+    "ParseResult",
+    "ParserService",
+    "parser_service",
+]