llmkit-cli 0.1.0__py3-none-any.whl

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

check.py

@@ -0,0 +1,74 @@
+import os
+import sys
+import yaml
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT))
+
+VALID_PROVIDERS = {"local", "openai", "anthropic", "groq", "together", "deepseek", "mistral"}
+
+API_KEY_ENV = {
+    "openai":   "OPENAI_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY",
+    "groq":     "GROQ_API_KEY",
+    "together": "TOGETHER_API_KEY",
+    "deepseek": "DEEPSEEK_API_KEY",
+    "mistral":  "MISTRAL_API_KEY",
+}
+
+
+def _load_config():
+    path = Path.cwd() / "llm.yaml"
+    if not path.exists():
+        print("FAIL  llm.yaml not found — run: llmkit init")
+        sys.exit(1)
+    try:
+        with open(path) as f:
+            return yaml.safe_load(f)
+    except Exception as e:
+        print(f"FAIL  llm.yaml parse error: {e}")
+        sys.exit(1)
+
+
+def _check_key(provider):
+    if provider == "local":
+        import requests
+        try:
+            res = requests.get("http://localhost:11434/api/tags", timeout=3)
+            if res.status_code != 200:
+                print(f"FAIL  Port 11434 responded but not Ollama (status {res.status_code})")
+                return False
+            print("OK    Ollama reachable at localhost:11434")
+            return True
+        except Exception:
+            print("FAIL  Ollama not reachable — run: ollama serve")
+            return False
+    env_var = API_KEY_ENV.get(provider, "")
+    key = os.getenv(env_var) if env_var else None
+    if not key:
+        print(f"FAIL  {env_var} not set — add it to your .env file")
+        return False
+    print(f"OK    {env_var} set ({len(key)} chars)")
+    return True
+
+
+def main():
+    config = _load_config()
+    provider = config.get("provider")
+    model = config.get("model")
+    if not provider or not model:
+        print("FAIL  llm.yaml missing required field (provider or model)")
+        sys.exit(1)
+    if provider not in VALID_PROVIDERS:
+        print(f"FAIL  unknown provider '{provider}'")
+        sys.exit(1)
+    print(f"      provider : {provider}")
+    print(f"      model    : {model}")
+    print(f"      mode     : {config.get('mode', 'chat')}")
+    if not _check_key(provider):
+        sys.exit(1)
+    print("OK    all checks passed")

cli.py

@@ -0,0 +1,98 @@
+import os
+import sys
+import importlib
+import yaml
+from dotenv import load_dotenv
+from pathlib import Path
+
+load_dotenv()
+
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT))
+
+GIT_COMMANDS = {"commit", "pr", "review"}
+PHASE_A_CMDS = {"check", "lock", "init", "env"}
+KNOWN_COMMANDS = GIT_COMMANDS | PHASE_A_CMDS | {"agent", "run"}
+
+providers_map = {
+    "local": "providers.local",
+    "openai": "providers.openai",
+    "anthropic": "providers.anthropic",
+    "groq": "providers.groq",
+    "together": "providers.together",
+    "deepseek": "providers.deepseek",
+    "mistral": "providers.mistral",
+}
+
+
+def _usage():
+    print("Usage: llmkit run \"your question here\"")
+    print("       llmkit commit|pr|review|check|lock|init|env|agent [--plan|--approve]")
+
+
+def main():
+    if len(sys.argv) < 2:
+        _usage()
+        sys.exit(1)
+
+    cmd = sys.argv[1]
+
+    if cmd not in KNOWN_COMMANDS:
+        print(f"Unknown command: {cmd}")
+        _usage()
+        sys.exit(1)
+
+    if cmd in GIT_COMMANDS:
+        import git_cmds
+        ok = getattr(git_cmds, cmd)()
+        sys.exit(0 if ok is not False else 1)
+
+    if cmd in PHASE_A_CMDS:
+        importlib.import_module(cmd).main()
+        sys.exit(0)
+
+    if cmd == "agent":
+        import agent_cmd
+        agent_cmd.main()
+        sys.exit(0)
+
+    if cmd == "run":
+        if len(sys.argv) < 3:
+            print("Usage: llmkit run \"your question here\"")
+            sys.exit(1)
+        sys.argv = [sys.argv[0]] + sys.argv[2:]
+
+    prompt = " ".join(sys.argv[1:])
+
+    with open(Path.cwd() / "llm.yaml") as f:
+        config = yaml.safe_load(f)
+
+    provider = config["provider"]
+    model = config["model"]
+
+    if provider not in providers_map:
+        print(f"Unknown provider: {provider}")
+        sys.exit(1)
+
+    send_message = importlib.import_module(providers_map[provider]).send_message
+    try:
+        print(send_message(prompt, model))
+    except Exception as primary_err:
+        for fb in config.get("fallback", []):
+            fb_provider = fb.get("provider", "")
+            fb_model = fb.get("model", "")
+            if not fb_provider or fb_provider not in providers_map:
+                continue
+            try:
+                fb_send = importlib.import_module(providers_map[fb_provider]).send_message
+                print(fb_send(prompt, fb_model))
+                raise SystemExit(0)
+            except SystemExit:
+                raise
+            except Exception:
+                continue
+        raise primary_err
+
+
+if __name__ == "__main__":
+    main()

env.py

@@ -0,0 +1,65 @@
+import os
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).parent
+
+PROVIDERS = {
+    "openai":    "OPENAI_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY",
+    "groq":      "GROQ_API_KEY",
+    "together":  "TOGETHER_API_KEY",
+    "deepseek":  "DEEPSEEK_API_KEY",
+    "mistral":   "MISTRAL_API_KEY",
+}
+
+
+def _read_env():
+    env_path = Path.cwd() / ".env"
+    if not env_path.exists():
+        return {}
+    lines = env_path.read_text().splitlines()
+    result = {}
+    for line in lines:
+        line = line.strip()
+        if line and not line.startswith("#") and "=" in line:
+            k, _, v = line.partition("=")
+            result[k.strip()] = v.strip()
+    return result
+
+
+def _write_env(data):
+    env_path = Path.cwd() / ".env"
+    lines = ["# llmkit environment — do not commit this file"]
+    for k, v in sorted(data.items()):
+        lines.append(f"{k}={v}")
+    env_path.write_text("\n".join(lines) + "\n")
+
+
+def main():
+    existing = _read_env()
+    print("llmkit env — set API keys for your providers")
+    print("Press Enter to keep existing value, '-' to clear.\n")
+
+    updated = dict(existing)
+    changed = False
+
+    for provider, var in PROVIDERS.items():
+        current = existing.get(var, "")
+        display = f"{current[:8]}..." if len(current) > 8 else (current or "not set")
+        val = input(f"  {var} [{display}]: ").strip()
+        if val == "-":
+            updated.pop(var, None)
+            changed = True
+        elif val:
+            updated[var] = val
+            changed = True
+
+    if not changed:
+        print("\nNo changes.")
+        return
+
+    _write_env(updated)
+    set_keys = [k for k in PROVIDERS.values() if updated.get(k)]
+    print(f"\nWritten .env  ({len(set_keys)} keys set)")
+    print("Make sure .env is in your .gitignore.")

git.py

@@ -0,0 +1,2 @@
+# Renamed to git_cmds.py to avoid shadowing the gitpython package.
+# This file is intentionally empty.

git_cmds.py

@@ -0,0 +1,140 @@
+import os
+import sys
+import subprocess
+import importlib
+import yaml
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT))
+
+MAX_DIFF_CHARS = 12000
+
+PROVIDERS_MAP = {
+    "local": "providers.local",
+    "openai": "providers.openai",
+    "anthropic": "providers.anthropic",
+    "groq": "providers.groq",
+    "together": "providers.together",
+    "deepseek": "providers.deepseek",
+    "mistral": "providers.mistral",
+}
+
+
+def _config():
+    with open(Path.cwd() / "llm.yaml") as f:
+        return yaml.safe_load(f)
+
+
+def _send(prompt):
+    config = _config()
+    provider = config["provider"]
+    model = config["model"]
+    if provider not in PROVIDERS_MAP:
+        print(f"Unknown provider: {provider}")
+        sys.exit(1)
+    send_message = importlib.import_module(PROVIDERS_MAP[provider]).send_message
+    try:
+        return send_message(prompt, model)
+    except Exception as primary_err:
+        for fb in config.get("fallback", []):
+            fb_provider = fb.get("provider", "")
+            fb_model = fb.get("model", "")
+            if not fb_provider or fb_provider not in PROVIDERS_MAP:
+                continue
+            print(f"  Fallback: {fb_provider} / {fb_model}")
+            try:
+                fb_send = importlib.import_module(PROVIDERS_MAP[fb_provider]).send_message
+                return fb_send(prompt, fb_model)
+            except Exception:
+                continue
+        raise primary_err
+
+
+def _diff(cached=True):
+    args = ["git", "diff"] + (["--cached"] if cached else [])
+    result = subprocess.run(args, capture_output=True, text=True)
+    if result.returncode != 0:
+        err = result.stderr.strip() or f"git diff exited with code {result.returncode}"
+        return None, err
+    return result.stdout.strip(), None
+
+
+def _branch_diff():
+    # Try to detect default branch from origin/HEAD
+    sym = subprocess.run(
+        ["git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+        capture_output=True, text=True
+    )
+    origin_base = sym.stdout.strip().split("/")[-1] if sym.returncode == 0 else None
+
+    bases = list(dict.fromkeys(filter(None, [origin_base, "main", "master"])))
+    result = None
+    for base in bases:
+        result = subprocess.run(
+            ["git", "diff", f"{base}...HEAD"],
+            capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            return result.stdout.strip(), None
+    if result is None:
+        return None, "no base branch to diff against"
+    last_err = result.stderr.strip() if result.returncode != 0 else None
+    return None, last_err
+
+
+def commit():
+    diff, err = _diff(cached=True)
+    if err:
+        print(f"git error: {err}")
+        return False
+    if not diff:
+        print("Nothing staged. Run: git add <files>")
+        return False
+    prompt = (
+        "Write a concise git commit message for this diff. "
+        "Output only the message, no explanation.\n\n"
+        + diff[:MAX_DIFF_CHARS]
+    )
+    print(_send(prompt))
+    return True
+
+
+def pr():
+    diff, err = _branch_diff()
+    if err:
+        print(f"git error: {err}")
+        return False
+    if not diff:
+        print("No diff found vs default branch.")
+        return False
+    prompt = (
+        "Write a GitHub pull request title and body for this diff. Be concise.\n\n"
+        + diff[:MAX_DIFF_CHARS]
+    )
+    print(_send(prompt))
+    return True
+
+
+def review():
+    diff, err = _diff(cached=True)
+    if err:
+        print(f"git error: {err}")
+        return False
+    if not diff:
+        diff, err = _diff(cached=False)
+        if err:
+            print(f"git error: {err}")
+            return False
+    if not diff:
+        print("No changes to review.")
+        return False
+    prompt = (
+        "Review this code diff. Flag bugs, security issues, and improvements. Be concise.\n\n"
+        + diff[:MAX_DIFF_CHARS]
+    )
+    print(_send(prompt))
+    return True

init.py

@@ -0,0 +1,63 @@
+import sys
+import yaml
+from pathlib import Path
+
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT))
+
+PROVIDERS = ["local", "openai", "anthropic", "groq", "together", "deepseek", "mistral"]
+
+DEFAULTS = {
+    "local":     "llama3.2",
+    "openai":    "gpt-4o-mini",
+    "anthropic": "claude-3-5-haiku-20241022",
+    "groq":      "llama-3.3-70b-versatile",
+    "together":  "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    "deepseek":  "deepseek-chat",
+    "mistral":   "mistral-small-latest",
+}
+
+API_KEY_ENV = {
+    "openai":    "OPENAI_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY",
+    "groq":      "GROQ_API_KEY",
+    "together":  "TOGETHER_API_KEY",
+    "deepseek":  "DEEPSEEK_API_KEY",
+    "mistral":   "MISTRAL_API_KEY",
+}
+
+
+def _ask(label, default):
+    val = input(f"  {label} [{default}]: ").strip()
+    return val if val else default
+
+
+def _write_config(provider, model, mode):
+    config = {"provider": provider, "model": model}
+    if mode != "chat":
+        config["mode"] = mode
+    with open(Path.cwd() / "llm.yaml", "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+    print(f"\nCreated llm.yaml  ({provider} / {model}  mode={mode})")
+    env_var = API_KEY_ENV.get(provider, "")
+    if env_var:
+        print(f"Add {env_var} to your .env file before running.")
+
+
+def main():
+    config_path = Path.cwd() / "llm.yaml"
+    if config_path.exists():
+        if input("llm.yaml already exists. Overwrite? [y/N]: ").strip().lower() != "y":
+            print("Aborted.")
+            return
+    print(f"Providers: {', '.join(PROVIDERS)}")
+    provider = _ask("provider", "groq")
+    if provider not in PROVIDERS:
+        print(f"Unknown provider '{provider}'. Choose from: {', '.join(PROVIDERS)}")
+        sys.exit(1)
+    model = _ask("model", DEFAULTS[provider])
+    mode  = _ask("mode  (chat / coding / autonomous)", "chat")
+    if mode not in ("chat", "coding", "autonomous"):
+        print(f"Unknown mode '{mode}'. Choose: chat, coding, autonomous")
+        sys.exit(1)
+    _write_config(provider, model, mode)

llmkit_cli-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,22 @@
+agent_cmd.py,sha256=9aHCv4vwNq2momIciawNyZiFBAQbVRnEzMKn3Wn_8Ew,10679
+check.py,sha256=Q43e1z6HKAvhwYV0JUmHgfOEOwjoDjG-rrrdeS1eXzk,2226
+cli.py,sha256=NRigdwC3aseiE9MDNu5TNlyC3ul8FDOi6Hu5HLwrUBY,2543
+env.py,sha256=eZLfIzrRKYmGsOk1oxErD5MBm7Hf2wCHmVgiazcDR1s,1799
+git.py,sha256=5JwhUKT6sYDkcCthUL3tvwVLILog6accr0Wi8MiBOUA,103
+git_cmds.py,sha256=9u9DOojmmJ2-Ao6jXDlpMPJZYaLPvgTbVR2Gk6Zq2NQ,3969
+init.py,sha256=ZU_Obczr7iF4FppzXh5AMRIx5NXB5m5FBpHe-l73tqI,2062
+lock.py,sha256=7YBj_3y8pA2ZTEQydkG9m03Yx-wDXaGZC5CGX2S4Mb8,1434
+providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+providers/anthropic.py,sha256=ybADRUQHLpW7u07PcMdGeEqvFdcY0jf59DC_w_VRr40,476
+providers/deepseek.py,sha256=3GX8Aaj_wAkdK0HOP7PJmEeP3w1-kzRrHy6cvVTWJ0k,493
+providers/groq.py,sha256=Tl80ZEOjbJ7p6zV3Wjre5VrGWhf7xfYeao6DjVHvo1g,442
+providers/local.py,sha256=Fe0GpSTnpNUqKbL6zbm9RgpMCSfkMpQuQ7lT8CApD8M,792
+providers/mistral.py,sha256=PO-PzwmbNx3yvsJLmFaQ746ycceB354BJ4c6mcLuIR0,313
+providers/openai.py,sha256=N8i4g2sXXJ4WiAzlkcetTDNT0EbQ2ZpRHfE5QPTFAD4,445
+providers/together.py,sha256=2u1njEat6fDqGqWRmbzZt5AoiXOGgjX2RctWtLcseEo,485
+providers/utils.py,sha256=NCJSgRdSctKZsv3eY6YsbUPNYSnxWIUoAs7buThnpwc,872
+llmkit_cli-0.1.0.dist-info/METADATA,sha256=ALvlMLKmiqTKc-igCHw-BrB0VGV_4G6Rs2csetB5fvU,4856
+llmkit_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+llmkit_cli-0.1.0.dist-info/entry_points.txt,sha256=6UgaPStSt-qiZ5aL1xRi-xoxSSqOlzF8zFsSxnGSWhA,36
+llmkit_cli-0.1.0.dist-info/top_level.txt,sha256=7lMT6GaGf6jeGLt5kzJ4-yaJfDTY3E6yylLV5JnJjgI,57
+llmkit_cli-0.1.0.dist-info/RECORD,,

llmkit_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

llmkit_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+llmkit = cli:main

llmkit_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,9 @@
+agent_cmd
+check
+cli
+env
+git
+git_cmds
+init
+lock
+providers

lock.py

@@ -0,0 +1,43 @@
+import sys
+import yaml
+from datetime import datetime, timezone
+from pathlib import Path
+
+ROOT = Path(__file__).parent
+LLMKIT_VERSION = "1.1.0"
+
+
+def _load_config():
+    path = Path.cwd() / "llm.yaml"
+    if not path.exists():
+        print("FAIL  llm.yaml not found — run: llmkit init")
+        sys.exit(1)
+    try:
+        with open(path) as f:
+            config = yaml.safe_load(f)
+    except Exception as e:
+        print(f"FAIL  llm.yaml parse error: {e}")
+        sys.exit(1)
+    if not config.get("provider") or not config.get("model"):
+        print("FAIL  llm.yaml missing provider or model")
+        sys.exit(1)
+    return config
+
+
+def main():
+    config = _load_config()
+    data = {
+        "locked_at":      datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "provider":       config["provider"],
+        "model":          config["model"],
+        "mode":           config.get("mode", "chat"),
+        "llmkit_version": LLMKIT_VERSION,
+    }
+    lock_path = Path.cwd() / "llm.lock"
+    with open(lock_path, "w") as f:
+        f.write("# Auto-generated by: llmkit lock\n")
+        f.write("# Commit this file to pin your model runtime.\n\n")
+        yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+    print(f"Locked  {config['provider']} / {config['model']}  ({data['mode']})")
+    print(f"Written {lock_path}")
+    print("Tip: commit llm.lock to pin your model runtime across the team.")

providers/anthropic.py

@@ -0,0 +1,14 @@
+import os
+import anthropic
+
+def send_message(prompt, model="claude-3-5-haiku-20241022"):
+    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.")
+    client = anthropic.Anthropic(api_key=key)
+    message = client.messages.create(
+        model=model,
+        max_tokens=4096,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return message.content[0].text

providers/deepseek.py

@@ -0,0 +1,13 @@
+import os
+from openai import OpenAI
+
+def send_message(prompt, model="deepseek-chat"):
+    key = os.getenv("DEEPSEEK_API_KEY")
+    if not key:
+        raise RuntimeError("API key not set for 'deepseek'. Add DEEPSEEK_API_KEY to your .env file.")
+    client = OpenAI(api_key=key, base_url="https://api.deepseek.com/v1")
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content

providers/groq.py

@@ -0,0 +1,13 @@
+import os
+from groq import Groq
+
+def send_message(prompt, model="llama-3.1-8b-instant"):
+    key = os.getenv("GROQ_API_KEY")
+    if not key:
+        raise RuntimeError("API key not set for 'groq'. Add GROQ_API_KEY to your .env file.")
+    client = Groq(api_key=key)
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content

providers/local.py

@@ -0,0 +1,20 @@
+import requests
+
+def send_message(prompt, model="llama3.2"):
+    try:
+        response = requests.post(
+            "http://localhost:11434/api/generate",
+            json={"model": model, "prompt": prompt, "stream": False},
+            timeout=120
+        )
+        data = response.json()
+        if "error" in data:
+            raise RuntimeError(f"Ollama error: {data['error']}")
+        text = data.get("response")
+        if text is None:
+            raise RuntimeError(f"Unexpected Ollama response: {data}")
+        return text
+    except requests.exceptions.ConnectionError:
+        raise RuntimeError("Ollama is not running. Start it with: ollama serve")
+    except requests.exceptions.Timeout:
+        raise RuntimeError("Ollama timed out. Try a smaller model or increase timeout.")

providers/mistral.py

@@ -0,0 +1,9 @@
+from providers.utils import openai_client
+
+def send_message(prompt, model="mistral-small-latest"):
+    client = openai_client("mistral")
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content

providers/openai.py

@@ -0,0 +1,13 @@
+import os
+from openai import OpenAI
+
+def send_message(prompt, model="gpt-4o-mini"):
+    key = os.getenv("OPENAI_API_KEY")
+    if not key:
+        raise RuntimeError("API key not set for 'openai'. Add OPENAI_API_KEY to your .env file.")
+    client = OpenAI(api_key=key)
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content

providers/together.py

@@ -0,0 +1,13 @@
+import os
+from together import Together
+
+def send_message(prompt, model="meta-llama/Llama-3.3-70B-Instruct-Turbo"):
+    key = os.getenv("TOGETHER_API_KEY")
+    if not key:
+        raise RuntimeError("API key not set for 'together'. Add TOGETHER_API_KEY to your .env file.")
+    client = Together(api_key=key)
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content

providers/utils.py

@@ -0,0 +1,28 @@
+import os
+
+BASE_URLS = {
+    "groq":     "https://api.groq.com/openai/v1",
+    "deepseek": "https://api.deepseek.com/v1",
+    "together": "https://api.together.xyz/v1",
+    "mistral":  "https://api.mistral.ai/v1",
+}
+
+API_KEY_NAMES = {
+    "openai":   "OPENAI_API_KEY",
+    "groq":     "GROQ_API_KEY",
+    "deepseek": "DEEPSEEK_API_KEY",
+    "together": "TOGETHER_API_KEY",
+    "mistral":  "MISTRAL_API_KEY",
+}
+
+def openai_client(provider):
+    from openai import OpenAI
+    env_var = API_KEY_NAMES.get(provider, "")
+    key = os.getenv(env_var) if env_var else None
+    if not key:
+        hint = env_var if env_var else "unknown provider"
+        raise RuntimeError(f"API key not set for '{provider}'. Add {hint} to your .env file.")
+    kwargs = {"api_key": key}
+    if provider in BASE_URLS:
+        kwargs["base_url"] = BASE_URLS[provider]
+    return OpenAI(**kwargs)