claude-ai-clone-client 3.0.0__tar.gz

claude_ai_clone_client-3.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: claude-ai-clone-client
+Version: 3.0.0
+Summary: CLI client for the local self-hosted AI platform — no external APIs, fully local
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.32.3

claude_ai_clone_client-3.0.0/ai_cli.py

@@ -0,0 +1,916 @@
+"""CLI for the local AI platform.
+
+Commands:
+  ai health                        Check backend health
+  ai hardware                      Show hardware info
+  ai model list                    List installed models
+  ai model versions <model_id>     List versions of a model
+  ai model download <repo-url>     Download from GitHub releases
+  ai model add <path-or-url>       Import from local path or GitHub URL
+  ai model use <name>[:version]    Load a model (optionally set version)
+  ai model update                  Check all sources for new versions
+  ai source list                   List tracked sources
+  ai source add                    Add a GitHub repo to track
+  ai source remove <model_id>      Remove a tracked source
+  ai chat --model <id>             Interactive chat
+  ai ask --model <id> --prompt ..  One-shot prompt
+  ai run <model_id>                Load model and start chatting
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import requests
+
+DEFAULT_HOST = "http://127.0.0.1:8090"
+
+
+# ── HTTP helpers ───────────────────────────────────────────────
+
+
+def _request(
+    method: str, url: str, payload: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    response = requests.request(method, url, json=payload, timeout=600)
+    response.raise_for_status()
+    return response.json()
+
+
+def _stream_chat(url: str, payload: dict[str, Any]) -> str:
+    with requests.post(url, json=payload, stream=True, timeout=600) as response:
+        response.raise_for_status()
+        final = []
+        for line in response.iter_lines(decode_unicode=True):
+            if not line or not line.startswith("data: "):
+                continue
+            event = json.loads(line[6:])
+            token = event.get("token")
+            if token:
+                print(token, end="", flush=True)
+                final.append(token)
+        print()
+    return "".join(final).strip()
+
+
+def _print_json(data: Any) -> None:
+    print(json.dumps(data, indent=2))
+
+
+def _print_table(rows: list[dict], columns: list[str]) -> None:
+    if not rows:
+        print("(none)")
+        return
+    widths = {col: len(col) for col in columns}
+    for row in rows:
+        for col in columns:
+            widths[col] = max(widths[col], len(str(row.get(col, ""))))
+    header = "  ".join(col.ljust(widths[col]) for col in columns)
+    print(header)
+    print("  ".join("-" * widths[col] for col in columns))
+    for row in rows:
+        print("  ".join(str(row.get(col, "")).ljust(widths[col]) for col in columns))
+
+
+# ── Command handlers ───────────────────────────────────────────
+
+
+def cmd_health(args):
+    data = _request("GET", f"{args.host}/health")
+    _print_json(data)
+
+
+def cmd_hardware(args):
+    data = _request("GET", f"{args.host}/hardware")
+    _print_json(data)
+
+
+def cmd_model_catalog(args):
+    """Browse the curated catalog of free AI models."""
+    data = _request("GET", f"{args.host}/catalog")
+    models = data.get("models", [])
+    if args.json:
+        _print_json(data)
+        return
+
+    # Also get installed models to show status
+    installed_data = _request("GET", f"{args.host}/models")
+    installed_ids = {m["model_id"] for m in installed_data.get("models", [])}
+
+    if args.use_case:
+        models = [m for m in models if args.use_case in m.get("use_case", [])]
+
+    rows = []
+    for m in models:
+        rows.append({
+            "model_id": m["model_id"],
+            "params": m.get("parameters", "?"),
+            "size": f"{m.get('size_gb', '?')} GB",
+            "license": (m.get("license") or "?")[:18],
+            "use_case": ", ".join(m.get("use_case", [])),
+            "status": "installed" if m["model_id"] in installed_ids else "available",
+        })
+    _print_table(rows, ["model_id", "params", "size", "license", "use_case", "status"])
+    print(f"\n  {len(models)} models | To download: ai model download --model-id <id> --url <github-repo> --runtime llama_cpp")
+
+
+def cmd_model_list(args):
+    data = _request("GET", f"{args.host}/models")
+    models = data.get("models", [])
+    if args.json:
+        _print_json(data)
+        return
+    rows = []
+    for m in models:
+        rows.append({
+            "model_id": m["model_id"],
+            "runtime": m["runtime"],
+            "format": m.get("format") or "—",
+            "active_v": f"v{m.get('active_version', '?')}",
+            "versions": len(m.get("versions", [])),
+            "source": m.get("source_repo") or "local",
+        })
+    _print_table(rows, ["model_id", "runtime", "format", "active_v", "versions", "source"])
+
+
+def cmd_model_versions(args):
+    data = _request("GET", f"{args.host}/models/{args.model_id}/versions")
+    versions = data.get("versions", [])
+    if args.json:
+        _print_json(data)
+        return
+    rows = []
+    for v in versions:
+        rows.append({
+            "version": f"v{v['version']}",
+            "tag": v.get("version_tag") or "—",
+            "sha256": (v.get("sha256") or "—")[:12],
+            "size_gb": str(v.get("size_gb") or "—"),
+            "created": (v.get("created_at") or "—")[:19],
+        })
+    _print_table(rows, ["version", "tag", "sha256", "size_gb", "created"])
+
+
+def cmd_model_download(args):
+    """Download a model — supports both direct URLs and GitHub repo discovery."""
+    url = args.url
+
+    # Check if this looks like a GitHub repo (not a direct file URL)
+    if _is_github_repo(url):
+        print(f"Discovering model assets in {url}...")
+        data = _request("GET", f"{args.host}/github/discover", None)
+        # Use query param instead
+        response = requests.get(
+            f"{args.host}/github/discover",
+            params={"repo_url": url},
+            timeout=30,
+        )
+        response.raise_for_status()
+        data = response.json()
+        assets = data.get("assets", [])
+        if not assets:
+            print("No model assets found in this repository's releases.", file=sys.stderr)
+            return
+
+        # Filter by runtime/format if specified
+        pattern = args.asset_pattern or f"*.{_runtime_ext(args.runtime)}"
+        import fnmatch
+        matching = [a for a in assets if fnmatch.fnmatch(a["asset_name"].lower(), pattern.lower())]
+
+        if not matching:
+            print(f"No assets matching '{pattern}'. Available:", file=sys.stderr)
+            for a in assets[:10]:
+                print(f"  {a['asset_name']} ({a['tag']})", file=sys.stderr)
+            return
+
+        # Download the latest matching asset
+        asset = matching[0]
+        print(f"Found: {asset['asset_name']} (tag: {asset['tag']}, {asset['size_bytes'] / 1e9:.1f} GB)")
+        payload = {
+            "model_id": args.model_id,
+            "source_url": asset["download_url"],
+            "runtime": args.runtime,
+            "filename": asset["asset_name"],
+            "format": asset.get("format"),
+            "version_tag": asset["tag"],
+            "license": args.license,
+        }
+    else:
+        # Direct URL download
+        payload = {
+            "model_id": args.model_id,
+            "source_url": url,
+            "runtime": args.runtime,
+            "filename": args.filename,
+            "sha256": args.sha256,
+            "license": args.license,
+            "size_gb": args.size_gb,
+            "format": args.format,
+            "version_tag": args.version_tag,
+        }
+
+    print(f"Downloading {args.model_id}...")
+    data = _request("POST", f"{args.host}/models/download", payload)
+    model = data.get("model", {})
+    print(f"Registered {model.get('model_id')} v{model.get('active_version')} ({model.get('runtime')})")
+
+
+def cmd_model_add(args):
+    """Smart import: detects local path vs GitHub URL."""
+    target = args.target
+
+    # Local path?
+    path = Path(target)
+    if path.exists():
+        payload = {
+            "model_id": args.model_id,
+            "local_path": str(path.resolve()),
+            "runtime": args.runtime,
+            "license": args.license,
+            "format": args.format,
+        }
+        data = _request("POST", f"{args.host}/models/import", payload)
+        model = data.get("model", {})
+        print(f"Imported {model.get('model_id')} v{model.get('active_version')} from {target}")
+        return
+
+    # GitHub URL?
+    if "github.com" in target or "/" in target:
+        # Treat as a download
+        args.url = target
+        args.filename = None
+        args.sha256 = None
+        args.size_gb = None
+        args.version_tag = None
+        args.asset_pattern = None
+        cmd_model_download(args)
+        return
+
+    print(f"Cannot resolve '{target}': not a local path or GitHub URL", file=sys.stderr)
+
+
+def cmd_model_use(args):
+    model_id, _, version_str = args.model_version.partition(":")
+    if version_str:
+        version = int(version_str.lstrip("v"))
+        _request("POST", f"{args.host}/models/set-version", {
+            "model_id": model_id,
+            "version": version,
+        })
+        print(f"Set {model_id} active version to v{version}")
+
+    payload = {"model_id": model_id}
+    if args.threads:
+        payload["threads"] = args.threads
+    data = _request("POST", f"{args.host}/models/load", payload)
+    print(f"Loaded {data.get('loaded_model_id')} v{data.get('loaded_version')} "
+          f"({data.get('loaded_runtime')}, {data.get('threads')} threads)")
+
+
+def cmd_model_update(args):
+    """Check tracked sources for new model versions."""
+    if args.model_id:
+        print(f"Checking updates for {args.model_id}...")
+        data = _request("POST", f"{args.host}/models/update/{args.model_id}")
+    else:
+        print("Checking all tracked sources for updates...")
+        data = _request("POST", f"{args.host}/models/update")
+
+    results = data.get("results", [])
+    if not results:
+        print("No tracked sources configured. Use 'ai source add' first.")
+        return
+
+    for r in results:
+        new = r.get("new_versions", [])
+        skipped = r.get("skipped_existing", 0) + r.get("skipped_duplicate", 0)
+        errors = r.get("errors", [])
+        print(f"\n  {r['model_id']}:")
+        if new:
+            print(f"    New versions downloaded: {', '.join(new)}")
+        else:
+            print(f"    No new versions (skipped {skipped} existing)")
+        for err in errors:
+            print(f"    Error: {err}")
+
+
+def cmd_source_list(args):
+    data = _request("GET", f"{args.host}/sources")
+    sources = data.get("sources", [])
+    if args.json:
+        _print_json(data)
+        return
+    rows = []
+    for s in sources:
+        rows.append({
+            "model_id": s["model_id"],
+            "repo": f"{s['owner']}/{s['repo']}",
+            "runtime": s["runtime"],
+            "pattern": s["asset_pattern"],
+            "auto": "yes" if s.get("auto_update", True) else "no",
+            "checked": (s.get("last_checked") or "never")[:19],
+        })
+    _print_table(rows, ["model_id", "repo", "runtime", "pattern", "auto", "checked"])
+
+
+def cmd_source_add(args):
+    payload = {
+        "repo_url": args.repo_url,
+        "model_id": args.model_id,
+        "runtime": args.runtime,
+        "asset_pattern": args.asset_pattern,
+        "license": args.license,
+    }
+    data = _request("POST", f"{args.host}/sources/add", payload)
+    s = data.get("source", {})
+    print(f"Tracking {s.get('owner')}/{s.get('repo')} -> {s.get('model_id')} (pattern: {s.get('asset_pattern')})")
+
+
+def cmd_source_remove(args):
+    _request("DELETE", f"{args.host}/sources/{args.model_id}")
+    print(f"Removed source: {args.model_id}")
+
+
+def cmd_chat(args):
+    conversation_id = args.conversation_id
+    print("Interactive chat (type 'exit' to quit)")
+    print("-" * 40)
+    while True:
+        try:
+            prompt = input("you> ").strip()
+        except EOFError:
+            break
+        if prompt.lower() in {"exit", "quit", "q"}:
+            break
+        if not prompt:
+            continue
+        payload = {
+            "model_id": args.model,
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": args.temperature,
+            "max_tokens": args.max_tokens,
+            "stream": True,
+            "conversation_id": conversation_id,
+        }
+        print("ai> ", end="", flush=True)
+        _stream_chat(f"{args.host}/chat", payload)
+
+
+def cmd_ask(args):
+    payload = {
+        "model_id": args.model,
+        "messages": [{"role": "user", "content": args.prompt}],
+        "temperature": args.temperature,
+        "max_tokens": args.max_tokens,
+        "stream": False,
+    }
+    result = _request("POST", f"{args.host}/chat", payload)
+    print(result.get("output", ""))
+
+
+def cmd_run(args):
+    payload = {"model_id": args.model_id}
+    if args.threads:
+        payload["threads"] = args.threads
+    data = _request("POST", f"{args.host}/models/load", payload)
+    print(f"Loaded {data.get('loaded_model_id')} v{data.get('loaded_version')}")
+    args.model = args.model_id
+    args.conversation_id = None
+    args.temperature = 0.3
+    args.max_tokens = 512
+    cmd_chat(args)
+
+
+def cmd_task(args):
+    """Intelligent task execution with prompt expansion and deep directory awareness.
+
+    The agent:
+    1. Scans the entire directory tree (current dir + all children)
+    2. Detects languages, frameworks, dependencies
+    3. Reads git status for change context
+    4. Reads relevant file contents based on the task
+    5. Expands the user's prompt into a detailed plan
+    6. Executes the plan with full code output
+    """
+    import subprocess
+
+    prompt_text = args.prompt
+    model = args.model
+    cwd = Path.cwd()
+
+    print("Analyzing project context...")
+
+    # ── Step 1: Deep directory scan ──────────────────────────
+    skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "venv",
+                 "dist", "build", ".next", ".cache", "target", ".tox",
+                 "egg-info", ".eggs", ".mypy_cache", ".pytest_cache"}
+
+    all_files = []
+    lang_counts: dict[str, int] = {}
+    ext_map = {
+        ".py": "Python", ".js": "JavaScript", ".ts": "TypeScript", ".tsx": "TypeScript/React",
+        ".jsx": "React", ".rs": "Rust", ".go": "Go", ".java": "Java", ".c": "C",
+        ".cpp": "C++", ".h": "C/C++ Header", ".rb": "Ruby", ".php": "PHP",
+        ".swift": "Swift", ".kt": "Kotlin", ".sql": "SQL", ".sh": "Shell",
+        ".css": "CSS", ".html": "HTML", ".yaml": "YAML", ".yml": "YAML",
+        ".json": "JSON", ".toml": "TOML", ".md": "Markdown",
+    }
+
+    for p in sorted(cwd.rglob("*")):
+        rel = p.relative_to(cwd)
+        parts = rel.parts
+        if any(part.startswith(".") or any(skip in part for skip in skip_dirs) for part in parts):
+            continue
+        if p.is_file():
+            all_files.append(str(rel))
+            ext = p.suffix.lower()
+            if ext in ext_map:
+                lang = ext_map[ext]
+                lang_counts[lang] = lang_counts.get(lang, 0) + 1
+
+    # Detect primary language
+    sorted_langs = sorted(lang_counts.items(), key=lambda x: -x[1])
+    primary_lang = sorted_langs[0][0] if sorted_langs else "Unknown"
+
+    # ── Step 2: Git context ──────────────────────────────────
+    git_info = ""
+    try:
+        status = subprocess.check_output(["git", "status", "--short"], text=True, cwd=str(cwd), timeout=5).strip()
+        branch = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], text=True, cwd=str(cwd), timeout=5).strip()
+        recent = subprocess.check_output(
+            ["git", "log", "--oneline", "-5"], text=True, cwd=str(cwd), timeout=5
+        ).strip()
+        git_info = f"Branch: {branch}\nRecent commits:\n{recent}\n"
+        if status:
+            git_info += f"Uncommitted changes:\n{status}\n"
+    except Exception:
+        git_info = "(not a git repository)"
+
+    # ── Step 3: Read key project files ───────────────────────
+    config_files = [
+        "README.md", "pyproject.toml", "package.json", "Cargo.toml", "go.mod",
+        "Makefile", "Dockerfile", "docker-compose.yml", "requirements.txt",
+        "tsconfig.json", ".eslintrc.json", "setup.py", "setup.cfg",
+    ]
+    config_excerpts = []
+    for cf in config_files:
+        cf_path = cwd / cf
+        if cf_path.exists():
+            try:
+                content = cf_path.read_text(encoding="utf-8")[:800]
+                config_excerpts.append(f"--- {cf} ---\n{content}")
+            except Exception:
+                pass
+
+    # ── Step 4: Find task-relevant files ─────────────────────
+    # Search for files that might be relevant to the task prompt
+    relevant_files = []
+    keywords = [w.lower() for w in prompt_text.split() if len(w) > 3]
+    for f in all_files:
+        f_lower = f.lower()
+        if any(kw in f_lower for kw in keywords):
+            relevant_files.append(f)
+
+    relevant_contents = []
+    for rf in relevant_files[:5]:  # max 5 relevant files
+        rf_path = cwd / rf
+        try:
+            content = rf_path.read_text(encoding="utf-8")[:2000]
+            relevant_contents.append(f"--- {rf} ---\n{content}")
+        except Exception:
+            pass
+
+    # ── Build context ────────────────────────────────────────
+    context_parts = [
+        f"WORKING DIRECTORY: {cwd}",
+        f"PRIMARY LANGUAGE: {primary_lang}",
+        f"LANGUAGES DETECTED: {', '.join(f'{lang} ({n} files)' for lang, n in sorted_langs[:8])}",
+        f"TOTAL FILES: {len(all_files)}",
+        f"\nGIT STATUS:\n{git_info}",
+    ]
+
+    # File tree (compact)
+    context_parts.append(f"\nFILE TREE ({len(all_files)} files):")
+    for f in all_files[:80]:
+        context_parts.append(f"  {f}")
+    if len(all_files) > 80:
+        context_parts.append(f"  ... and {len(all_files) - 80} more")
+
+    if config_excerpts:
+        context_parts.append("\nPROJECT CONFIG FILES:")
+        context_parts.extend(config_excerpts)
+
+    if relevant_contents:
+        context_parts.append(f"\nTASK-RELEVANT FILES (matched keywords from your prompt):")
+        context_parts.extend(relevant_contents)
+
+    context = "\n".join(context_parts)
+
+    print(f"  Found {len(all_files)} files across {len(lang_counts)} languages")
+    print(f"  Primary language: {primary_lang}")
+    if relevant_files:
+        print(f"  Task-relevant files: {', '.join(relevant_files[:5])}")
+
+    # ── Step 5: Expand prompt into plan ──────────────────────
+    print("\nExpanding task into detailed plan...")
+
+    expand_prompt = (
+        f"You are an expert coding AI agent operating on the user's local machine. "
+        f"You have deep awareness of their entire project.\n\n"
+        f"PROJECT CONTEXT:\n{context}\n\n"
+        f"USER TASK: {prompt_text}\n\n"
+        f"Create a precise, numbered step-by-step plan:\n"
+        f"- For each step, specify the EXACT file path to modify or create\n"
+        f"- Describe the specific code changes (not vague descriptions)\n"
+        f"- Consider how changes interact with existing code\n"
+        f"- Include any new dependencies or configuration changes\n"
+        f"- Consider edge cases and error handling\n"
+        f"- If tests exist, include steps to update them\n\n"
+        f"Be actionable and complete. This plan will be executed."
+    )
+
+    payload = {
+        "model_id": model,
+        "messages": [{"role": "user", "content": expand_prompt}],
+        "temperature": 0.2,
+        "max_tokens": args.max_tokens,
+        "stream": True,
+    }
+
+    print("\n--- Task Plan ---\n")
+    plan = _stream_chat(f"{args.host}/chat", payload)
+    print()
+
+    # ── Step 6: Confirm ──────────────────────────────────────
+    if not args.auto:
+        try:
+            confirm = input("Execute this plan? [y/N] ").strip().lower()
+            if confirm not in {"y", "yes"}:
+                print("Aborted.")
+                return
+        except EOFError:
+            print("Aborted.")
+            return
+
+    # ── Step 7: Execute with full code output ────────────────
+    print("\n--- Executing ---\n")
+
+    execute_prompt = (
+        f"You are an expert coding AI agent. Execute this plan NOW.\n\n"
+        f"PROJECT CONTEXT:\n{context}\n\n"
+        f"PLAN TO EXECUTE:\n{plan}\n\n"
+        f"For each step, output the COMPLETE file contents or code changes.\n"
+        f"Format each file change as:\n"
+        f"```path/to/file.ext\n"
+        f"<complete file content or diff>\n"
+        f"```\n\n"
+        f"Rules:\n"
+        f"- Output COMPLETE, WORKING code — no placeholders, no '...', no truncation\n"
+        f"- Include all imports, error handling, and type annotations\n"
+        f"- Match the existing code style of the project\n"
+        f"- If creating new files, include all necessary boilerplate\n"
+        f"- If modifying existing files, show the complete modified version"
+    )
+
+    exec_payload = {
+        "model_id": model,
+        "messages": [{"role": "user", "content": execute_prompt}],
+        "temperature": 0.1,
+        "max_tokens": args.max_tokens,
+        "stream": True,
+    }
+
+    _stream_chat(f"{args.host}/chat", exec_payload)
+    print("\n\nTask complete.")
+
+
+# ── Helpers ────────────────────────────────────────────────────
+
+
+def _is_github_repo(url: str) -> bool:
+    """Check if URL points to a GitHub repo (not a direct file)."""
+    if not ("github.com" in url or "/" in url):
+        return False
+    # Direct file downloads have extensions
+    path = url.rstrip("/").split("/")[-1] if "/" in url else url
+    return "." not in path or path.endswith(".git")
+
+
+def _runtime_ext(runtime: str) -> str:
+    return {"llama_cpp": "gguf", "onnx": "onnx"}.get(runtime, "safetensors")
+
+
+# ── Argument parser ────────────────────────────────────────────
+
+
+def _fetch_model_names(host: str = DEFAULT_HOST) -> list[str]:
+    """Fetch available model names from the backend for shell completion."""
+    try:
+        resp = requests.get(f"{host}/models/names", timeout=2)
+        resp.raise_for_status()
+        return resp.json().get("names", [])
+    except Exception:
+        return []
+
+
+def cmd_completion(args):
+    """Generate shell completion scripts."""
+    shell = args.shell
+    if shell == "bash":
+        print(_BASH_COMPLETION)
+    elif shell == "zsh":
+        print(_ZSH_COMPLETION)
+    elif shell == "fish":
+        print(_FISH_COMPLETION)
+    elif shell == "names":
+        # Raw model name list — used by completion scripts
+        for name in _fetch_model_names(args.host):
+            print(name)
+
+
+_BASH_COMPLETION = r'''
+# bash completion for ai CLI — add to ~/.bashrc:
+#   eval "$(ai completion bash)"
+
+_ai_complete() {
+    local cur prev words cword
+    _init_completion || return
+
+    case "${words[1]}" in
+        model)
+            case "${words[2]}" in
+                use|versions|update)
+                    COMPREPLY=( $(compgen -W "$(ai completion names 2>/dev/null)" -- "$cur") )
+                    return ;;
+                list|download|add) return ;;
+            esac
+            COMPREPLY=( $(compgen -W "list versions download add use update" -- "$cur") )
+            return ;;
+        source)
+            case "${words[2]}" in
+                remove)
+                    COMPREPLY=( $(compgen -W "$(ai completion names 2>/dev/null)" -- "$cur") )
+                    return ;;
+            esac
+            COMPREPLY=( $(compgen -W "list add remove" -- "$cur") )
+            return ;;
+        chat|ask)
+            case "$prev" in
+                --model)
+                    COMPREPLY=( $(compgen -W "$(ai completion names 2>/dev/null)" -- "$cur") )
+                    return ;;
+            esac
+            return ;;
+        run)
+            if [ $cword -eq 2 ]; then
+                COMPREPLY=( $(compgen -W "$(ai completion names 2>/dev/null)" -- "$cur") )
+                return
+            fi ;;
+        completion) return ;;
+    esac
+    COMPREPLY=( $(compgen -W "health hardware model source chat ask run completion" -- "$cur") )
+}
+complete -F _ai_complete ai
+'''.strip()
+
+_ZSH_COMPLETION = r'''
+# zsh completion for ai CLI — add to ~/.zshrc:
+#   eval "$(ai completion zsh)"
+
+_ai() {
+    local -a model_names
+    _get_model_names() { model_names=(${(f)"$(ai completion names 2>/dev/null)"}) }
+
+    _arguments -C '1:command:(health hardware model source chat ask run completion)' '*::arg:->args'
+
+    case $words[1] in
+        model)
+            _arguments -C '1:subcommand:(list versions download add use update)' '*::arg:->margs'
+            case $words[1] in
+                use|versions|update)
+                    _get_model_names
+                    _describe 'model' model_names ;;
+            esac ;;
+        source)
+            _arguments -C '1:subcommand:(list add remove)' '*::arg:->sargs'
+            case $words[1] in
+                remove) _get_model_names; _describe 'model' model_names ;;
+            esac ;;
+        chat|ask)
+            _arguments '--model[Model ID]:model:->mname'
+            if [[ $state == mname ]]; then
+                _get_model_names
+                _describe 'model' model_names
+            fi ;;
+        run)
+            _get_model_names; _describe 'model' model_names ;;
+    esac
+}
+compdef _ai ai
+'''.strip()
+
+_FISH_COMPLETION = r'''
+# fish completion for ai CLI — add to ~/.config/fish/completions/ai.fish:
+#   ai completion fish > ~/.config/fish/completions/ai.fish
+
+function __ai_model_names
+    ai completion names 2>/dev/null
+end
+complete -c ai -n "__fish_use_subcommand" -a "health hardware model source chat ask run completion"
+complete -c ai -n "__fish_seen_subcommand_from model" -a "list versions download add use update"
+complete -c ai -n "__fish_seen_subcommand_from model; and __fish_seen_subcommand_from use versions update" -a "(__ai_model_names)"
+complete -c ai -n "__fish_seen_subcommand_from source" -a "list add remove"
+complete -c ai -n "__fish_seen_subcommand_from source; and __fish_seen_subcommand_from remove" -a "(__ai_model_names)"
+complete -c ai -n "__fish_seen_subcommand_from chat ask" -l model -a "(__ai_model_names)"
+complete -c ai -n "__fish_seen_subcommand_from run" -a "(__ai_model_names)"
+'''.strip()
+
+
+def build_argparser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ai",
+        description="Self-hosted local AI platform CLI — no external APIs, fully local",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""examples:
+  ai model list
+  ai model download --model-id tinyllama --url owner/repo --runtime llama_cpp
+  ai model download --model-id phi3 --url https://github.com/owner/repo/releases/download/v1/model.gguf --runtime llama_cpp
+  ai model add --model-id my-model --target ./model.gguf --runtime llama_cpp
+  ai model use tinyllama:v2
+  ai model update
+  ai source add --repo-url owner/repo --model-id tinyllama --runtime llama_cpp
+  ai source list
+  ai chat --model tinyllama
+  ai ask --model tinyllama --prompt "Explain quicksort"
+  ai run tinyllama
+""",
+    )
+    parser.add_argument("--host", default=DEFAULT_HOST, help="Backend base URL")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # health
+    sub.add_parser("health", help="Check backend health")
+
+    # hardware
+    sub.add_parser("hardware", help="Show hardware info")
+
+    # ── model subcommands ──────────────────────────────────────
+
+    model_parser = sub.add_parser("model", help="Model management")
+    model_sub = model_parser.add_subparsers(dest="model_command", required=True)
+
+    # model catalog
+    mc = model_sub.add_parser("catalog", help="Browse free models available from GitHub")
+    mc.add_argument("--json", action="store_true", help="Output raw JSON")
+    mc.add_argument("--use-case", choices=["coding", "chat", "general", "completion"],
+                     help="Filter by use case")
+
+    # model list
+    ml = model_sub.add_parser("list", help="List installed models")
+    ml.add_argument("--json", action="store_true", help="Output raw JSON")
+
+    # model versions
+    mv = model_sub.add_parser("versions", help="List versions of a model")
+    mv.add_argument("model_id", help="Model ID")
+    mv.add_argument("--json", action="store_true", help="Output raw JSON")
+
+    # model download
+    md = model_sub.add_parser("download", help="Download from GitHub repo or direct URL")
+    md.add_argument("--model-id", required=True, help="Model identifier")
+    md.add_argument("--url", required=True, help="GitHub repo (owner/repo) or direct asset URL")
+    md.add_argument("--runtime", required=True, choices=["llama_cpp", "transformers", "vllm", "onnx"])
+    md.add_argument("--filename", help="Override filename")
+    md.add_argument("--sha256", help="Expected checksum")
+    md.add_argument("--license", help="License type")
+    md.add_argument("--size-gb", type=float, help="Expected size in GB")
+    md.add_argument("--format", choices=["gguf", "safetensors", "onnx", "pytorch"])
+    md.add_argument("--version-tag", help="Version tag for this download")
+    md.add_argument("--asset-pattern", help="Glob pattern for asset discovery (default: *.gguf)")
+
+    # model add (smart import)
+    ma = model_sub.add_parser("add", help="Import from local path or GitHub URL")
+    ma.add_argument("--model-id", required=True, help="Model identifier")
+    ma.add_argument("--target", required=True, help="Local path or GitHub URL")
+    ma.add_argument("--runtime", required=True, choices=["llama_cpp", "transformers", "vllm", "onnx"])
+    ma.add_argument("--license", help="License type")
+    ma.add_argument("--format", choices=["gguf", "safetensors", "onnx", "pytorch"])
+
+    # model use
+    mu = model_sub.add_parser("use", help="Load a model (optionally set version)")
+    mu.add_argument("model_version", help="model_id or model_id:vN")
+    mu.add_argument("--threads", type=int, help="CPU threads for inference")
+
+    # model update
+    mup = model_sub.add_parser("update", help="Check tracked sources for new versions")
+    mup.add_argument("model_id", nargs="?", help="Specific model to update (default: all)")
+
+    # ── source subcommands ─────────────────────────────────────
+
+    source_parser = sub.add_parser("source", help="Manage tracked GitHub sources")
+    source_sub = source_parser.add_subparsers(dest="source_command", required=True)
+
+    sl = source_sub.add_parser("list", help="List tracked sources")
+    sl.add_argument("--json", action="store_true", help="Output raw JSON")
+
+    sa = source_sub.add_parser("add", help="Track a GitHub repository")
+    sa.add_argument("--repo-url", required=True, help="GitHub repo URL or owner/repo")
+    sa.add_argument("--model-id", required=True, help="Model identifier")
+    sa.add_argument("--runtime", default="llama_cpp", choices=["llama_cpp", "transformers", "vllm", "onnx"])
+    sa.add_argument("--asset-pattern", default="*.gguf", help="Glob pattern for model assets")
+    sa.add_argument("--license", help="License type")
+
+    sr = source_sub.add_parser("remove", help="Stop tracking a source")
+    sr.add_argument("model_id", help="Model ID to untrack")
+
+    # ── chat / ask / run ───────────────────────────────────────
+
+    chat_p = sub.add_parser("chat", help="Interactive chat session")
+    chat_p.add_argument("--model", required=True, help="Model ID")
+    chat_p.add_argument("--temperature", type=float, default=0.3)
+    chat_p.add_argument("--max-tokens", type=int, default=512)
+    chat_p.add_argument("--conversation-id", help="Resume a conversation")
+
+    ask_p = sub.add_parser("ask", help="One-shot prompt")
+    ask_p.add_argument("--model", required=True, help="Model ID")
+    ask_p.add_argument("--prompt", required=True, help="Prompt text")
+    ask_p.add_argument("--temperature", type=float, default=0.3)
+    ask_p.add_argument("--max-tokens", type=int, default=512)
+
+    run_p = sub.add_parser("run", help="Load model and start chatting")
+    run_p.add_argument("model_id", help="Model to load")
+    run_p.add_argument("--threads", type=int, help="CPU threads")
+
+    # task (AI agent)
+    task_p = sub.add_parser("task", help="AI agent: analyze, plan, and execute a coding task")
+    task_p.add_argument("prompt", help="Task description (natural language)")
+    task_p.add_argument("--model", required=True, help="Model ID to use")
+    task_p.add_argument("--auto", action="store_true", help="Execute without confirmation")
+    task_p.add_argument("--max-tokens", type=int, default=2048, help="Max tokens per response")
+
+    # completion
+    comp_p = sub.add_parser("completion", help="Generate shell completion scripts")
+    comp_p.add_argument("shell", choices=["bash", "zsh", "fish", "names"],
+                         help="Shell type (or 'names' for raw model list)")
+
+    return parser
+
+
+COMMAND_DISPATCH = {
+    "health": cmd_health,
+    "hardware": cmd_hardware,
+    "chat": cmd_chat,
+    "ask": cmd_ask,
+    "run": cmd_run,
+    "task": cmd_task,
+    "completion": cmd_completion,
+}
+
+MODEL_DISPATCH = {
+    "catalog": cmd_model_catalog,
+    "list": cmd_model_list,
+    "versions": cmd_model_versions,
+    "download": cmd_model_download,
+    "add": cmd_model_add,
+    "use": cmd_model_use,
+    "update": cmd_model_update,
+}
+
+SOURCE_DISPATCH = {
+    "list": cmd_source_list,
+    "add": cmd_source_add,
+    "remove": cmd_source_remove,
+}
+
+
+def main() -> int:
+    args = build_argparser().parse_args()
+    try:
+        if args.command == "model":
+            handler = MODEL_DISPATCH.get(args.model_command)
+            if handler:
+                handler(args)
+                return 0
+        elif args.command == "source":
+            handler = SOURCE_DISPATCH.get(args.source_command)
+            if handler:
+                handler(args)
+                return 0
+        else:
+            handler = COMMAND_DISPATCH.get(args.command)
+            if handler:
+                handler(args)
+                return 0
+        print(f"Unknown command: {args.command}", file=sys.stderr)
+        return 1
+    except requests.RequestException as exc:
+        print(f"Request failed: {exc}", file=sys.stderr)
+        return 2
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

claude_ai_clone_client-3.0.0/claude_ai_clone_client.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: claude-ai-clone-client
+Version: 3.0.0
+Summary: CLI client for the local self-hosted AI platform — no external APIs, fully local
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.32.3

claude_ai_clone_client-3.0.0/claude_ai_clone_client.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+ai_cli.py
+pyproject.toml
+claude_ai_clone_client.egg-info/PKG-INFO
+claude_ai_clone_client.egg-info/SOURCES.txt
+claude_ai_clone_client.egg-info/dependency_links.txt
+claude_ai_clone_client.egg-info/entry_points.txt
+claude_ai_clone_client.egg-info/requires.txt
+claude_ai_clone_client.egg-info/top_level.txt

claude_ai_clone_client-3.0.0/claude_ai_clone_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

claude_ai_clone_client-3.0.0/claude_ai_clone_client.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ai = ai_cli:main

claude_ai_clone_client-3.0.0/claude_ai_clone_client.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.32.3

claude_ai_clone_client-3.0.0/claude_ai_clone_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+ai_cli

claude_ai_clone_client-3.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "claude-ai-clone-client"
+version = "3.0.0"
+description = "CLI client for the local self-hosted AI platform — no external APIs, fully local"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+dependencies = ["requests>=2.32.3"]
+
+[project.scripts]
+ai = "ai_cli:main"
+
+[tool.setuptools]
+py-modules = ["ai_cli"]

claude_ai_clone_client-3.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+