nacho-cli 0.1.0__tar.gz

nacho_cli-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: nacho-cli
+Version: 0.1.0
+Summary: Nacho CLI — push, pull, and search context files; set up the Nacho builder
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"

nacho_cli-0.1.0/nacho/api_client.py

@@ -0,0 +1,114 @@
+import httpx
+
+from nacho.config import get_api_url, load_token
+
+
+class APIClient:
+    def __init__(self):
+        self.base_url = get_api_url()
+        self.token = load_token()
+
+    @property
+    def headers(self) -> dict:
+        h = {"Content-Type": "application/json"}
+        if self.token:
+            h["Authorization"] = f"Bearer {self.token}"
+        return h
+
+    def login(self, email: str, password: str) -> dict:
+        resp = httpx.post(
+            f"{self.base_url}/auth/login",
+            json={"email": email, "password": password},
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def push(self, file_path: str, name: str, title: str, **kwargs) -> dict:
+        with open(file_path, "rb") as f:
+            files = {"file": (file_path, f, "text/markdown")}
+            data = {"name": name, "title": title}
+            data.update({k: v for k, v in kwargs.items() if v is not None})
+            headers = {}
+            if self.token:
+                headers["Authorization"] = f"Bearer {self.token}"
+            resp = httpx.post(
+                f"{self.base_url}/contexts",
+                files=files,
+                data=data,
+                headers=headers,
+            )
+        resp.raise_for_status()
+        return resp.json()
+
+    def push_version(self, context_id: str, file_path: str, changelog: str | None = None) -> dict:
+        with open(file_path, "rb") as f:
+            files = {"file": (file_path, f, "text/markdown")}
+            data = {}
+            if changelog:
+                data["changelog"] = changelog
+            headers = {}
+            if self.token:
+                headers["Authorization"] = f"Bearer {self.token}"
+            resp = httpx.post(
+                f"{self.base_url}/contexts/{context_id}/versions",
+                files=files,
+                data=data,
+                headers=headers,
+            )
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_my_context(self, name: str) -> dict | None:
+        resp = httpx.get(f"{self.base_url}/auth/me", headers=self.headers)
+        resp.raise_for_status()
+        username = resp.json()["username"]
+        resp = httpx.get(f"{self.base_url}/contexts/{username}/{name}", headers=self.headers)
+        if resp.status_code == 404:
+            return None
+        resp.raise_for_status()
+        return resp.json()
+
+    def pull(self, username: str, context_name: str, version: int | None = None) -> bytes:
+        # First get context info
+        resp = httpx.get(
+            f"{self.base_url}/contexts/{username}/{context_name}",
+            headers=self.headers,
+        )
+        resp.raise_for_status()
+        context = resp.json()
+
+        params = {}
+        if version:
+            params["version"] = version
+        resp = httpx.get(
+            f"{self.base_url}/contexts/{context['id']}/download",
+            params=params,
+            headers=self.headers,
+            follow_redirects=True,
+        )
+        resp.raise_for_status()
+        return resp.content
+
+    def upvote(self, username: str, context_name: str) -> dict:
+        resp = httpx.get(
+            f"{self.base_url}/contexts/{username}/{context_name}",
+            headers=self.headers,
+        )
+        resp.raise_for_status()
+        context = resp.json()
+
+        resp = httpx.post(
+            f"{self.base_url}/contexts/{context['id']}/upvote",
+            headers=self.headers,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def search(self, query: str, page: int = 1) -> dict:
+        resp = httpx.get(
+            f"{self.base_url}/contexts/search",
+            params={"q": query, "page": page},
+            headers=self.headers,
+        )
+        resp.raise_for_status()
+        return resp.json()

nacho_cli-0.1.0/nacho/commands.py

@@ -0,0 +1,411 @@
+import argparse
+import getpass
+import json
+import os
+import shutil
+import subprocess
+import sys
+from importlib import resources as importlib_resources
+from pathlib import Path
+
+from nacho.api_client import APIClient
+from nacho.config import clear_token, load_tracked_contexts, save_token, save_tracked_context
+
+
+# ── Context Hub commands ─────────────────────────────────────────────
+
+
+def cmd_login(args):
+    """Login and store API token."""
+    client = APIClient()
+    email = input("Email: ")
+    password = getpass.getpass("Password: ")
+
+    try:
+        data = client.login(email, password)
+        save_token(data["access_token"])
+        print("Logged in successfully!")
+        print("Tip: For long-lived access, create an API token at https://nacho.bot/settings")
+    except Exception as e:
+        print(f"Login failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_token(args):
+    """Store an API token directly."""
+    token = args.token or getpass.getpass("API Token: ")
+    save_token(token)
+    print("Token saved.")
+
+
+def cmd_logout(args):
+    """Clear stored credentials."""
+    clear_token()
+    print("Logged out.")
+
+
+def _push_tracked(client, file_path, tracked_meta, changelog=None):
+    """Push a new version for a tracked context. Returns True on success."""
+    name = tracked_meta["name"]
+    existing = client.get_my_context(name)
+    if not existing:
+        print(f"Error: remote context '{name}' not found for tracked file '{file_path}'", file=sys.stderr)
+        return False
+    result = client.push_version(existing["id"], file_path, changelog=changelog)
+    print(f"Pushed {existing['owner_username']}/{existing['name']} v{result['version']}")
+    return True
+
+
+def cmd_push(args):
+    """Push a context file."""
+    client = APIClient()
+    file_path = args.file
+    tracked = load_tracked_contexts()
+
+    # nacho push .  — push all tracked contexts
+    if file_path == ".":
+        if not tracked:
+            print("Error: no tracked contexts in .nacho/contexts.yml", file=sys.stderr)
+            sys.exit(1)
+        failed = False
+        for fpath, meta in tracked.items():
+            try:
+                if not _push_tracked(client, fpath, meta, changelog=args.changelog):
+                    failed = True
+            except Exception as e:
+                print(f"Push failed for {fpath}: {e}", file=sys.stderr)
+                failed = True
+        if failed:
+            sys.exit(1)
+        return
+
+    # nacho push <file>
+    if file_path in tracked:
+        try:
+            _push_tracked(client, file_path, tracked[file_path], changelog=args.changelog)
+        except Exception as e:
+            print(f"Push failed: {e}", file=sys.stderr)
+            sys.exit(1)
+        return
+
+    # Untracked file — first push, --name required
+    name = args.name
+    if not name:
+        print("Error: --name is required for first push of an untracked file", file=sys.stderr)
+        sys.exit(1)
+
+    title = args.title or name
+
+    try:
+        result = client.push(
+            file_path=file_path,
+            name=name,
+            title=title,
+            short_description=args.description,
+            tags=args.tags or "",
+            license=args.license,
+        )
+        context = result["context"]
+        version = result["version"]
+        print(f"Pushed {context['owner_username']}/{context['name']} v{version['version']}")
+
+        meta = {"name": name, "title": title}
+        if args.description:
+            meta["description"] = args.description
+        if args.tags:
+            meta["tags"] = args.tags
+        if args.license:
+            meta["license"] = args.license
+        save_tracked_context(file_path, meta)
+    except Exception as e:
+        print(f"Push failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_pull(args):
+    """Pull a context file."""
+    client = APIClient()
+
+    ref = args.ref
+    if "/" not in ref:
+        print("Error: ref must be in format 'username/context-name'", file=sys.stderr)
+        sys.exit(1)
+
+    username, context_name = ref.split("/", 1)
+
+    try:
+        content = client.pull(username, context_name, version=args.version)
+        output = args.output or f"{context_name}.md"
+
+        if os.path.exists(output) and not args.force:
+            answer = input(f"File '{output}' already exists. Replace? [y/N] ").strip().lower()
+            if answer not in ("y", "yes"):
+                print("Cancelled.")
+                return
+
+        with open(output, "wb") as f:
+            f.write(content)
+        print(f"Downloaded to {output}")
+
+        if client.token:
+            try:
+                owned = client.get_my_context(context_name)
+                if owned:
+                    save_tracked_context(output, {
+                        "name": context_name,
+                        "title": owned.get("title", context_name),
+                    })
+            except Exception:
+                pass
+    except Exception as e:
+        print(f"Pull failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_upvote(args):
+    """Toggle upvote on a context."""
+    client = APIClient()
+
+    ref = args.ref
+    if "/" not in ref:
+        print("Error: ref must be in format 'username/context-name'", file=sys.stderr)
+        sys.exit(1)
+
+    username, context_name = ref.split("/", 1)
+
+    try:
+        result = client.upvote(username, context_name)
+        if result["upvoted"]:
+            print(f"Upvoted {ref} ({result['upvote_count']} upvotes)")
+        else:
+            print(f"Removed upvote from {ref} ({result['upvote_count']} upvotes)")
+    except Exception as e:
+        print(f"Upvote failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_search(args):
+    """Search for contexts."""
+    client = APIClient()
+
+    try:
+        result = client.search(args.query)
+        items = result.get("items", [])
+        if not items:
+            print("No results found.")
+            return
+
+        for context in items:
+            tags = ", ".join(context.get("tags", []))
+            print(f"  {context['owner_username']}/{context['name']} - {context['title']}")
+            if context.get("short_description"):
+                print(f"    {context['short_description']}")
+            if tags:
+                print(f"    Tags: {tags}")
+            print()
+    except Exception as e:
+        print(f"Search failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+# ── Builder setup commands ───────────────────────────────────────────
+
+
+def _setup_mcp_server():
+    """Register the Nacho MCP server with Claude Code (user scope)."""
+    try:
+        result = subprocess.run(
+            ["claude", "mcp", "list"],
+            capture_output=True, text=True, timeout=10,
+        )
+        if "nacho" in result.stdout:
+            print("  MCP server already registered")
+            return
+    except Exception:
+        pass
+
+    try:
+        result = subprocess.run(
+            ["claude", "mcp", "add", "--scope", "user", "nacho", "--", "uvx", "nacho-mcp"],
+            capture_output=True, text=True, timeout=30,
+        )
+        if result.returncode == 0:
+            print("  MCP server registered")
+        else:
+            print("  MCP server ready")
+    except Exception as e:
+        print(f"  Warning: Could not register MCP server: {e}", file=sys.stderr)
+
+
+def _setup_slash_command():
+    """Copy nachoinit.md to ~/.claude/commands/."""
+    commands_dir = Path.home() / ".claude" / "commands"
+    commands_dir.mkdir(parents=True, exist_ok=True)
+    dest = commands_dir / "nachoinit.md"
+
+    source = importlib_resources.files("nacho").joinpath("data", "nachoinit.md")
+    dest.write_text(source.read_text())
+    print("  /nachoinit command installed")
+
+
+def _setup_permissions():
+    """Add mcp__nacho__* to global Claude Code permissions."""
+    settings_file = Path.home() / ".claude" / "settings.json"
+
+    settings = {}
+    if settings_file.exists():
+        try:
+            settings = json.loads(settings_file.read_text())
+        except (json.JSONDecodeError, OSError):
+            settings = {}
+
+    permissions = settings.setdefault("permissions", {})
+    allow = permissions.setdefault("allow", [])
+
+    nacho_rule = "mcp__nacho__*"
+    if nacho_rule not in allow:
+        allow.append(nacho_rule)
+        settings_file.parent.mkdir(parents=True, exist_ok=True)
+        settings_file.write_text(json.dumps(settings, indent=2) + "\n")
+        print("  Nacho tool permissions configured")
+    else:
+        print("  Permissions already configured")
+
+
+def _setup_project_permissions(project_dir: Path):
+    """Create .claude/settings.json in the project with dev tool permissions."""
+    settings_dir = project_dir / ".claude"
+    settings_dir.mkdir(parents=True, exist_ok=True)
+    settings_file = settings_dir / "settings.json"
+
+    settings = {
+        "permissions": {
+            "defaultMode": "acceptEdits",
+            "allow": [
+                "Bash(mkdir *)",
+                "Bash(cp *)",
+                "Bash(npm *)",
+                "Bash(npx *)",
+                "Bash(node *)",
+                "Bash(pnpm *)",
+                "Bash(yarn *)",
+                "Bash(uv *)",
+                "Bash(pip *)",
+                "Bash(pip3 *)",
+                "Bash(python *)",
+                "Bash(python3 *)",
+                "Bash(source *)",
+                "Bash(go *)",
+                "Bash(cargo *)",
+                "Bash(curl *)",
+                "Bash(git *)",
+                "Bash(mix *)",
+                "Bash(elixir *)",
+                "mcp__nacho__*",
+            ],
+        }
+    }
+    settings_file.write_text(json.dumps(settings, indent=2) + "\n")
+    print("  Project permissions configured")
+
+
+def cmd_init(args):
+    """Set up Claude Code integration and launch /nachoinit."""
+    if not shutil.which("claude"):
+        print("Claude Code is not installed.")
+        print("Get it at: https://claude.ai/download")
+        sys.exit(1)
+
+    print("Setting up Nacho for Claude Code...\n")
+    _setup_mcp_server()
+    _setup_slash_command()
+    _setup_permissions()
+
+    project_dir = Path.cwd()
+    _setup_project_permissions(project_dir)
+
+    print("\nLaunching Claude Code...")
+    print("(First launch may take a moment while the Nacho tools are downloaded)\n")
+    sys.stdout.flush()
+    os.execlp("claude", "claude", "/nachoinit")
+
+
+# ── Entry point ──────────────────────────────────────────────────────
+
+
+def main():
+    import importlib.metadata
+
+    try:
+        version = importlib.metadata.version("nacho-cli")
+    except importlib.metadata.PackageNotFoundError:
+        version = "dev"
+
+    parser = argparse.ArgumentParser(
+        prog="nacho",
+        description="Nacho CLI — build apps and manage context files.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {version}")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # init
+    subparsers.add_parser("init", help="Set up Claude Code + launch /nachoinit builder wizard")
+
+    # login
+    subparsers.add_parser("login", help="Login with email/password")
+
+    # token
+    token_parser = subparsers.add_parser("token", help="Store an API token")
+    token_parser.add_argument("token", nargs="?", help="The API token")
+
+    # logout
+    subparsers.add_parser("logout", help="Clear stored credentials")
+
+    # push
+    push_parser = subparsers.add_parser("push", help="Push a context file")
+    push_parser.add_argument("file", help="Path to .md file, or '.' to push all tracked contexts")
+    push_parser.add_argument("--name", help="Context name (required for first push)")
+    push_parser.add_argument("--title", help="Context title")
+    push_parser.add_argument("--description", help="Short description")
+    push_parser.add_argument("--tags", help="Comma-separated tags")
+    push_parser.add_argument("--license", help="License")
+    push_parser.add_argument("--changelog", help="Changelog for this version")
+
+    # pull
+    pull_parser = subparsers.add_parser("pull", help="Pull a context file")
+    pull_parser.add_argument("ref", help="username/context-name")
+    pull_parser.add_argument("--version", type=int, help="Specific version")
+    pull_parser.add_argument("-o", "--output", help="Output filename")
+    pull_parser.add_argument("-f", "--force", action="store_true", help="Overwrite without prompting")
+
+    # search
+    search_parser = subparsers.add_parser("search", help="Search for contexts")
+    search_parser.add_argument("query", help="Search query")
+
+    # upvote
+    upvote_parser = subparsers.add_parser("upvote", help="Toggle upvote on a context")
+    upvote_parser.add_argument("ref", help="username/context-name")
+
+    args = parser.parse_args()
+
+    commands = {
+        "init": cmd_init,
+        "login": cmd_login,
+        "token": cmd_token,
+        "logout": cmd_logout,
+        "push": cmd_push,
+        "pull": cmd_pull,
+        "search": cmd_search,
+        "upvote": cmd_upvote,
+    }
+
+    if args.command in commands:
+        commands[args.command](args)
+    elif args.command is None:
+        cmd_init(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

nacho_cli-0.1.0/nacho/config.py

@@ -0,0 +1,71 @@
+import os
+from pathlib import Path
+
+import yaml
+
+DEFAULT_API_URL = "https://nacho.bot/api"
+CREDENTIALS_DIR = Path.home() / ".nacho"
+CREDENTIALS_FILE = CREDENTIALS_DIR / "credentials"
+
+
+def get_api_url() -> str:
+    return os.environ.get("NACHO_API_URL", DEFAULT_API_URL)
+
+
+def save_token(token: str) -> None:
+    CREDENTIALS_DIR.mkdir(parents=True, exist_ok=True)
+    CREDENTIALS_FILE.write_text(token)
+    CREDENTIALS_FILE.chmod(0o600)
+
+
+def load_token() -> str | None:
+    if CREDENTIALS_FILE.exists():
+        return CREDENTIALS_FILE.read_text().strip()
+    return None
+
+
+def clear_token() -> None:
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()
+
+
+def load_context_config(path: str = ".") -> dict:
+    """Load .nacho.yml from the given directory."""
+    config_path = Path(path) / ".nacho.yml"
+    if not config_path.exists():
+        return {}
+    with open(config_path) as f:
+        return yaml.safe_load(f) or {}
+
+
+NACHO_DIR = Path(".nacho")
+CONTEXTS_FILE = NACHO_DIR / "contexts.yml"
+
+
+def load_tracked_contexts(path: str = ".") -> dict:
+    """Read .nacho/contexts.yml and return dict keyed by file path."""
+    contexts_file = Path(path) / CONTEXTS_FILE
+    if not contexts_file.exists():
+        return {}
+    with open(contexts_file) as f:
+        data = yaml.safe_load(f) or {}
+    return data.get("contexts", {})
+
+
+def save_tracked_context(file_path: str, metadata: dict, path: str = ".") -> None:
+    """Upsert one entry into .nacho/contexts.yml, creating .nacho/ dir if needed."""
+    nacho_dir = Path(path) / NACHO_DIR
+    contexts_file = Path(path) / CONTEXTS_FILE
+
+    nacho_dir.mkdir(parents=True, exist_ok=True)
+
+    existing = {}
+    if contexts_file.exists():
+        with open(contexts_file) as f:
+            existing = yaml.safe_load(f) or {}
+
+    contexts = existing.get("contexts", {})
+    contexts[file_path] = metadata
+
+    with open(contexts_file, "w") as f:
+        yaml.dump({"contexts": contexts}, f, default_flow_style=False)