llmkit-cli 0.1.0__tar.gz

llmkit_cli-0.1.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: llmkit-cli
+Version: 0.1.0
+Summary: Run any LLM with one config file. No framework lock-in.
+License: MIT
+Project-URL: Homepage, https://github.com/abinzagr/llmkit
+Project-URL: Repository, https://github.com/abinzagr/llmkit
+Keywords: llm,ai,openai,anthropic,groq,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Requires-Dist: openai
+Requires-Dist: anthropic
+Requires-Dist: groq
+Provides-Extra: all
+Requires-Dist: together; extra == "all"
+Requires-Dist: mistralai; extra == "all"
+Requires-Dist: chromadb; extra == "all"
+Requires-Dist: mcp; extra == "all"
+
+# llmkit
+
+Run any LLM — local or via API — with one config file. No framework lock-in. Works on Windows, Mac, Linux.
+
+```bash
+llmkit run "explain this codebase in one sentence"
+```
+
+## Install
+
+```bash
+# Linux
+bash install.sh
+
+# Mac
+bash install.mac.sh
+
+# Windows (PowerShell as admin)
+./install.ps1
+```
+
+Each script installs deps, sets up Ollama if needed, and adds `llmkit` to your PATH.
+
+## Configure
+
+Edit `llm.yaml` (or run `llmkit init` for a guided setup):
+
+```yaml
+provider: groq          # local | openai | anthropic | groq | together | deepseek | mistral
+model: llama-3.3-70b-versatile
+mode: chat
+```
+
+For API providers, copy `.env.example` to `.env` and add your key.
+
+## Commands
+
+```bash
+# One-shot prompt
+llmkit run "explain this codebase in one sentence"
+
+# Validate config + check provider reachability
+llmkit check
+
+# Interactive wizard to create llm.yaml
+llmkit init
+
+# Pin current model to llm.lock (commit this file)
+llmkit lock
+
+# Generate a commit message from staged changes
+llmkit commit
+
+# Generate a PR title + body vs main/master
+llmkit pr
+
+# Review staged/unstaged diff for bugs
+llmkit review
+
+# Run a coding agent on a task
+llmkit agent "refactor this module to use dataclasses"
+
+# Plan only — no tools executed, just a numbered plan
+llmkit agent --plan "add pagination to the API"
+
+# Approve mode — confirm each shell command before it runs
+llmkit agent --approve "run the test suite and fix any failures"
+```
+
+## Examples
+
+```bash
+# Chat
+python examples/chat.py
+node examples/chat.js          # all providers including Anthropic
+
+# Streaming
+python examples/stream.py
+node examples/stream.js        # all providers including Anthropic
+
+# Function calling / tools
+python examples/tools.py
+
+# Vision (image input)
+python examples/vision.py
+
+# Multi-round conversation
+python examples/multiround.py
+
+# Embeddings + cosine similarity
+python examples/embed.py
+
+# Coding agent
+python examples/agent.py
+
+# MCP agent (connects to MCP servers defined in llm.yaml)
+python examples/mcp_agent.py
+```
+
+## Local models (via Ollama)
+
+| Model | Config |
+|---|---|
+| Llama 4 | `model: llama4` |
+| Qwen 3 | `model: qwen3` |
+| DeepSeek R1 | `model: deepseek-r1` |
+| Mistral | `model: mistral` |
+| Phi-4 | `model: phi4` |
+| Gemma 3 | `model: gemma3` |
+
+## API providers
+
+| Provider | Env key | Fast cheap model |
+|---|---|---|
+| OpenAI | `OPENAI_API_KEY` | `gpt-4o-mini` |
+| Anthropic | `ANTHROPIC_API_KEY` | `claude-3-5-haiku-20241022` |
+| Groq | `GROQ_API_KEY` | `llama-3.1-8b-instant` |
+| Together | `TOGETHER_API_KEY` | `meta-llama/Llama-3.3-70B-Instruct-Turbo` |
+| DeepSeek | `DEEPSEEK_API_KEY` | `deepseek-chat` |
+| Mistral | `MISTRAL_API_KEY` | `mistral-small-latest` |
+
+## 5-minute team setup
+
+```bash
+# 1 — clone
+git clone https://github.com/your-org/llmkit
+cd llmkit
+
+# 2 — install deps + register llmkit command
+bash install.sh          # Mac: bash install.mac.sh  |  Windows: ./install.ps1
+
+# 3 — set one API key (Groq free tier works)
+echo "GROQ_API_KEY=your_key_here" > .env
+
+# 4 — verify everything is wired up
+llmkit check
+
+# 5 — run your first prompt
+llmkit run "explain this codebase in one sentence"
+```
+
+No server. No IDE extension. No code to write. Switch providers by editing one line in `llm.yaml`.
+
+## llm.lock
+
+Run `llmkit lock` to pin your model runtime. Commit `llm.lock` alongside your code:
+
+```yaml
+# Auto-generated — commit this file to pin your model runtime
+locked_at: "2026-06-26T12:00:00Z"
+provider: groq
+model: llama-3.3-70b-versatile
+mode: chat
+```
+
+Same idea as `package-lock.json` — reproducible environments, no surprise model swaps between teammates.
+
+## Switch providers
+
+Change one line in `llm.yaml`, run `llmkit check`, done:
+
+```yaml
+# was: provider: groq
+provider: anthropic
+model: claude-3-5-haiku-20241022
+```
+
+No code changes. No redeploy. Works in CI too.

llmkit_cli-0.1.0/README.md

@@ -0,0 +1,168 @@
+# llmkit
+
+Run any LLM — local or via API — with one config file. No framework lock-in. Works on Windows, Mac, Linux.
+
+```bash
+llmkit run "explain this codebase in one sentence"
+```
+
+## Install
+
+```bash
+# Linux
+bash install.sh
+
+# Mac
+bash install.mac.sh
+
+# Windows (PowerShell as admin)
+./install.ps1
+```
+
+Each script installs deps, sets up Ollama if needed, and adds `llmkit` to your PATH.
+
+## Configure
+
+Edit `llm.yaml` (or run `llmkit init` for a guided setup):
+
+```yaml
+provider: groq          # local | openai | anthropic | groq | together | deepseek | mistral
+model: llama-3.3-70b-versatile
+mode: chat
+```
+
+For API providers, copy `.env.example` to `.env` and add your key.
+
+## Commands
+
+```bash
+# One-shot prompt
+llmkit run "explain this codebase in one sentence"
+
+# Validate config + check provider reachability
+llmkit check
+
+# Interactive wizard to create llm.yaml
+llmkit init
+
+# Pin current model to llm.lock (commit this file)
+llmkit lock
+
+# Generate a commit message from staged changes
+llmkit commit
+
+# Generate a PR title + body vs main/master
+llmkit pr
+
+# Review staged/unstaged diff for bugs
+llmkit review
+
+# Run a coding agent on a task
+llmkit agent "refactor this module to use dataclasses"
+
+# Plan only — no tools executed, just a numbered plan
+llmkit agent --plan "add pagination to the API"
+
+# Approve mode — confirm each shell command before it runs
+llmkit agent --approve "run the test suite and fix any failures"
+```
+
+## Examples
+
+```bash
+# Chat
+python examples/chat.py
+node examples/chat.js          # all providers including Anthropic
+
+# Streaming
+python examples/stream.py
+node examples/stream.js        # all providers including Anthropic
+
+# Function calling / tools
+python examples/tools.py
+
+# Vision (image input)
+python examples/vision.py
+
+# Multi-round conversation
+python examples/multiround.py
+
+# Embeddings + cosine similarity
+python examples/embed.py
+
+# Coding agent
+python examples/agent.py
+
+# MCP agent (connects to MCP servers defined in llm.yaml)
+python examples/mcp_agent.py
+```
+
+## Local models (via Ollama)
+
+| Model | Config |
+|---|---|
+| Llama 4 | `model: llama4` |
+| Qwen 3 | `model: qwen3` |
+| DeepSeek R1 | `model: deepseek-r1` |
+| Mistral | `model: mistral` |
+| Phi-4 | `model: phi4` |
+| Gemma 3 | `model: gemma3` |
+
+## API providers
+
+| Provider | Env key | Fast cheap model |
+|---|---|---|
+| OpenAI | `OPENAI_API_KEY` | `gpt-4o-mini` |
+| Anthropic | `ANTHROPIC_API_KEY` | `claude-3-5-haiku-20241022` |
+| Groq | `GROQ_API_KEY` | `llama-3.1-8b-instant` |
+| Together | `TOGETHER_API_KEY` | `meta-llama/Llama-3.3-70B-Instruct-Turbo` |
+| DeepSeek | `DEEPSEEK_API_KEY` | `deepseek-chat` |
+| Mistral | `MISTRAL_API_KEY` | `mistral-small-latest` |
+
+## 5-minute team setup
+
+```bash
+# 1 — clone
+git clone https://github.com/your-org/llmkit
+cd llmkit
+
+# 2 — install deps + register llmkit command
+bash install.sh          # Mac: bash install.mac.sh  |  Windows: ./install.ps1
+
+# 3 — set one API key (Groq free tier works)
+echo "GROQ_API_KEY=your_key_here" > .env
+
+# 4 — verify everything is wired up
+llmkit check
+
+# 5 — run your first prompt
+llmkit run "explain this codebase in one sentence"
+```
+
+No server. No IDE extension. No code to write. Switch providers by editing one line in `llm.yaml`.
+
+## llm.lock
+
+Run `llmkit lock` to pin your model runtime. Commit `llm.lock` alongside your code:
+
+```yaml
+# Auto-generated — commit this file to pin your model runtime
+locked_at: "2026-06-26T12:00:00Z"
+provider: groq
+model: llama-3.3-70b-versatile
+mode: chat
+```
+
+Same idea as `package-lock.json` — reproducible environments, no surprise model swaps between teammates.
+
+## Switch providers
+
+Change one line in `llm.yaml`, run `llmkit check`, done:
+
+```yaml
+# was: provider: groq
+provider: anthropic
+model: claude-3-5-haiku-20241022
+```
+
+No code changes. No redeploy. Works in CI too.

llmkit_cli-0.1.0/agent_cmd.py

@@ -0,0 +1,301 @@
+import os
+import sys
+import json
+import subprocess
+import yaml
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT))
+
+MAX_STEPS = 10
+WORKSPACE = Path.cwd().resolve()
+
+TOOLS_SCHEMA = [
+    {"type": "function", "function": {
+        "name": "read_file",
+        "description": "Read a file's contents",
+        "parameters": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]},
+    }},
+    {"type": "function", "function": {
+        "name": "write_file",
+        "description": "Create or overwrite a file",
+        "parameters": {"type": "object", "properties": {
+            "path": {"type": "string"}, "content": {"type": "string"}
+        }, "required": ["path", "content"]},
+    }},
+    {"type": "function", "function": {
+        "name": "run_shell",
+        "description": "Run a shell command and return output",
+        "parameters": {"type": "object", "properties": {"command": {"type": "string"}}, "required": ["command"]},
+    }},
+    {"type": "function", "function": {
+        "name": "list_dir",
+        "description": "List files and folders in a directory",
+        "parameters": {"type": "object", "properties": {"path": {"type": "string"}}, "required": []},
+    }},
+]
+
+ALL_TOOL_NAMES = {t["function"]["name"] for t in TOOLS_SCHEMA}
+
+
+def _active_tools(config):
+    allowed = config.get("tools")
+    if allowed is None:
+        return TOOLS_SCHEMA
+    allowed_set = set(allowed)
+    return [t for t in TOOLS_SCHEMA if t["function"]["name"] in allowed_set]
+
+
+def _guard(path):
+    p = Path(path).resolve()
+    if not p.is_relative_to(WORKSPACE):
+        return None, f"Blocked: {p} is outside workspace"
+    return p, None
+
+
+def _read_file(path):
+    p, err = _guard(path)
+    if err:
+        return err
+    try:
+        return p.read_text(encoding="utf-8")
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _write_file(path, content):
+    p, err = _guard(path)
+    if err:
+        return err
+    try:
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content, encoding="utf-8")
+        return f"Written: {p}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _run_shell(command, approve):
+    if approve:
+        print(f"\n  [approve] run: {command}")
+        if input("  Allow? [y/N]: ").strip().lower() != "y":
+            return "Skipped."
+    try:
+        result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=30)
+        out = result.stdout.strip()
+        err = result.stderr.strip()
+        if result.returncode != 0:
+            return f"Exit {result.returncode}\n{err or out or '(no output)'}"
+        return out or err or "(no output)"
+    except subprocess.TimeoutExpired:
+        return "Error: timed out after 30s"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _list_dir(path="."):
+    p, err = _guard(path or ".")
+    if err:
+        return err
+    try:
+        entries = sorted(p.iterdir(), key=lambda e: (e.is_file(), e.name))
+        return "\n".join(f"{'[dir] ' if e.is_dir() else '      '}{e.name}" for e in entries)
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _call_tool(name, args, approve):
+    if name == "read_file":
+        return _read_file(args.get("path", ""))
+    if name == "write_file":
+        return _write_file(args.get("path", ""), args.get("content", ""))
+    if name == "run_shell":
+        return _run_shell(args.get("command", ""), approve)
+    if name == "list_dir":
+        return _list_dir(args.get("path", "."))
+    return f"Error: unknown tool '{name}'"
+
+
+def _check_budget(used, budget):
+    if budget is None:
+        return False
+    limit   = budget.get("max_tokens_per_run")
+    warn_at = budget.get("warn_at")
+    if warn_at and used >= warn_at and (not limit or used < limit):
+        print(f"  [budget] {used}/{limit or '?'} tokens used — approaching limit")
+    if limit is not None and used >= limit:
+        print(f"\nAgent: budget reached ({used}/{limit} tokens). Stopping.")
+        return True
+    return False
+
+
+def _run_openai(task, config, plan_only, approve):
+    from providers.utils import openai_client
+    provider = config["provider"]
+    model = config["model"]
+    budget = config.get("budget")
+    tools = _active_tools(config)
+    client = openai_client(provider)
+    system = (
+        "Output a numbered step-by-step plan only. Do not call any tools. Be concise."
+        if plan_only else
+        "You are a coding agent. Complete the task using tools. Summarize when done."
+    )
+    messages = [{"role": "system", "content": system}, {"role": "user", "content": task}]
+    tokens_used = 0
+    for _ in range(MAX_STEPS):
+        kwargs = {"model": model, "messages": messages}
+        if not plan_only and tools:
+            kwargs["tools"] = tools
+        response = client.chat.completions.create(**kwargs)
+        tokens_used += getattr(response.usage, "total_tokens", 0)
+        msg = response.choices[0].message
+        assistant_msg = {"role": "assistant", "content": msg.content}
+        if msg.tool_calls:
+            assistant_msg["tool_calls"] = [
+                {"id": c.id, "type": "function",
+                 "function": {"name": c.function.name, "arguments": c.function.arguments}}
+                for c in msg.tool_calls
+            ]
+        messages.append(assistant_msg)
+        if _check_budget(tokens_used, budget):
+            return
+        if not getattr(msg, "tool_calls", None):
+            if msg.content:
+                print(f"\nAgent: {msg.content}")
+            return
+        for call in msg.tool_calls:
+            try:
+                args = json.loads(call.function.arguments)
+            except Exception:
+                args = {}
+            print(f"  -> {call.function.name}({args})")
+            try:
+                result = _call_tool(call.function.name, args, approve)
+            except Exception as e:
+                result = f"Error: {e}"
+            print(f"    {str(result)[:200]}")
+            messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
+    print("Agent: reached max steps.")
+
+
+def _run_anthropic(task, config, plan_only, approve):
+    import anthropic
+    key = os.getenv("ANTHROPIC_API_KEY")
+    if not key:
+        raise RuntimeError("API key not set for 'anthropic'. Add ANTHROPIC_API_KEY to your .env file.")
+    model = config["model"]
+    budget = config.get("budget")
+    tools = _active_tools(config)
+    client = anthropic.Anthropic(api_key=key)
+    system = (
+        "Output a numbered step-by-step plan only. Do not call any tools. Be concise."
+        if plan_only else
+        "You are a coding agent. Complete the task using tools. Summarize when done."
+    )
+    anthropic_tools = [
+        {"name": t["function"]["name"],
+         "description": t["function"]["description"],
+         "input_schema": t["function"]["parameters"]}
+        for t in tools
+    ]
+    messages = [{"role": "user", "content": task}]
+    tokens_used = 0
+    for _ in range(MAX_STEPS):
+        kwargs = {"model": model, "max_tokens": 4096, "system": system, "messages": messages}
+        if not plan_only and anthropic_tools:
+            kwargs["tools"] = anthropic_tools
+        response = client.messages.create(**kwargs)
+        tokens_used += (getattr(response.usage, "input_tokens", 0)
+                        + getattr(response.usage, "output_tokens", 0))
+        if _check_budget(tokens_used, budget):
+            return
+        tool_results = []
+        for block in response.content:
+            if block.type == "tool_use":
+                print(f"  -> {block.name}({block.input})")
+                result = _call_tool(block.name, block.input, approve)
+                print(f"    {str(result)[:200]}")
+                tool_results.append({"type": "tool_result", "tool_use_id": block.id, "content": result})
+            elif block.type == "text" and block.text:
+                if response.stop_reason != "tool_use":
+                    print(f"\nAgent: {block.text}")
+        if response.stop_reason == "end_turn" or not tool_results:
+            return
+        messages += [
+            {"role": "assistant", "content": response.content},
+            {"role": "user", "content": tool_results},
+        ]
+    print("Agent: reached max steps.")
+
+
+def main():
+    argv = sys.argv[1:]
+    if argv and argv[0] == "agent":
+        argv = argv[1:]
+    plan_only = "--plan" in argv
+    approve   = "--approve" in argv
+    task      = " ".join(a for a in argv if not a.startswith("--")).strip()
+
+    if not task:
+        print("Usage: llmkit agent [--plan] [--approve] \"task\"")
+        sys.exit(1)
+
+    with open(Path.cwd() / "llm.yaml") as f:
+        config = yaml.safe_load(f)
+
+    provider = config.get("provider", "")
+
+    if provider == "local":
+        print("Agent requires function calling. Use openai/groq/anthropic/deepseek/together/mistral in llm.yaml.")
+        sys.exit(1)
+
+    mode_label = "plan" if plan_only else ("approve-agent" if approve else "agent")
+    print(f"llmkit {mode_label} | {provider} / {config['model']}")
+    budget = config.get("budget") or {}
+    if budget.get("max_tokens_per_run"):
+        parts = [f"max {budget['max_tokens_per_run']} tokens"]
+        if budget.get("warn_at"):
+            parts.append(f"warn at {budget['warn_at']}")
+        print(f"Budget: {', '.join(parts)}")
+    active = _active_tools(config)
+    unknown = set(config.get("tools") or []) - ALL_TOOL_NAMES
+    if unknown:
+        print(f"Warning: unknown tools in llm.yaml: {sorted(unknown)}")
+    if len(active) < len(TOOLS_SCHEMA):
+        print(f"Tools: {[t['function']['name'] for t in active]}")
+    print(f"Workspace: {WORKSPACE}\n")
+
+    def _run(cfg):
+        if cfg["provider"] == "anthropic":
+            _run_anthropic(task, cfg, plan_only, approve)
+        else:
+            _run_openai(task, cfg, plan_only, approve)
+
+    fallback_cfgs = [
+        {**config, "provider": fb["provider"], "model": fb["model"]}
+        for fb in config.get("fallback", [])
+        if fb.get("provider") and fb.get("model")
+    ]
+
+    try:
+        _run(config)
+    except Exception as primary_err:
+        if not fallback_cfgs:
+            raise
+        print(f"  Primary provider failed: {primary_err}")
+        last_err = primary_err
+        for fb in fallback_cfgs:
+            print(f"  Trying fallback: {fb['provider']} / {fb['model']}")
+            try:
+                _run(fb)
+                last_err = None
+                break
+            except Exception as err:
+                last_err = err
+                continue
+        if last_err:
+            raise last_err