redsba-code 0.1.0__py3-none-any.whl

redsba/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

redsba/__main__.py

@@ -0,0 +1,12 @@
+from redsba.app import run
+
+
+def main():
+    try:
+        run()
+    except (KeyboardInterrupt, EOFError):
+        pass
+
+
+if __name__ == "__main__":
+    main()

redsba/app.py

@@ -0,0 +1,262 @@
+from prompt_toolkit import prompt
+
+from redsba.config import (ROLES, SLOT_COUNT, empty_slot, find_brain, load_config,
+                           mask, save_config, slot_ready)
+import json
+
+from redsba import chats, skills, tools
+from redsba.providers import PROVIDERS, TEMPLATES, ask, chat_tools, list_gemini_models
+from redsba.ui import clear, menu, spinner
+
+BANNER = """██████╗ ███████╗    ██████╗ ██████╗ ██████╗ ███████╗
+██╔══██╗██╔════╝   ██╔════╝██╔═══██╗██╔══██╗██╔════╝
+██████╔╝███████╗   ██║     ██║   ██║██║  ██║█████╗
+██╔══██╗╚════██║   ██║     ██║   ██║██║  ██║██╔══╝
+██║  ██║███████║   ╚██████╗╚██████╔╝██████╔╝███████╗
+╚═╝  ╚═╝╚══════╝    ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝"""
+
+MAX_STEPS = 20
+SYSTEM_PROMPT = (
+    "Ты агент в терминале redSBA code. Рабочая папка: {root}. "
+    "Для работы с файлами и командами используй инструменты. "
+    "Перед правкой файла сначала прочитай его. Если нужен совет, используй ask_helper "
+    "(не больше трёх раз). Отвечай кратко и по делу."
+)
+
+
+def start_screen():
+    clear()
+    print("redSBA code\n")
+    items = ["chatting", "history", "setting", "exit"]
+    choice = menu("Главное меню", items)
+    return items[choice] if choice is not None else "exit"
+
+
+def history_screen():
+    """Список сохранённых чатов. Возвращает выбранный чат или None."""
+    saved = chats.list_chats()
+    if not saved:
+        clear()
+        print("Сохранённых чатов пока нет.")
+        input("Enter, чтобы вернуться...")
+        return None
+    items = [f"{c['updated']}  {c['title']}" for c in saved] + ["назад"]
+    pick = menu("История чатов", items)
+    if pick is None or pick == len(saved):
+        return None
+    return saved[pick]
+
+
+def pick_gemini_model(slot):
+    """Загружает список моделей Gemini с Google и даёт выбрать стрелками."""
+    if not slot["api_key"]:
+        print("Сначала введите ключ Gemini.")
+        input("Enter...")
+        return
+    clear()
+    print("Загружаю список моделей...")
+    try:
+        models = list_gemini_models(slot["api_key"])
+    except Exception as e:
+        print(f"Не удалось получить список: {e}")
+        input("Enter...")
+        return
+    if not models:
+        print("Google не вернул ни одной модели для этого ключа.")
+        input("Enter...")
+        return
+    pick = menu("Модель Gemini", models)
+    if pick is not None:
+        slot["model"] = models[pick]
+
+
+def edit_slot(cfg, idx):
+    slot = cfg["slots"][idx]
+    while True:
+        clear()
+        print(f"Настройка {slot['name']}\n")
+        items = [
+            f"провайдер: {slot['provider']}",
+            f"роль: {slot['role']}",
+            f"ключ: {mask(slot['api_key'])}",
+            f"base_url: {slot['base_url'] or '(нужен для openai)'}",
+            f"модель: {slot['model'] or '(пусто, введите вручную)'}",
+            "шаблон (Groq, OpenRouter...)",
+            "очистить слот",
+            "назад",
+        ]
+        choice = menu(slot["name"], items)
+        if choice is None or choice == 7:
+            save_config(cfg)
+            return
+        if choice == 0:
+            slot["provider"] = PROVIDERS[(PROVIDERS.index(slot["provider"]) + 1) % len(PROVIDERS)]
+        elif choice == 1:
+            slot["role"] = ROLES[(ROLES.index(slot["role"]) + 1) % len(ROLES)]
+        elif choice == 2:
+            slot["api_key"] = prompt("API-ключ: ", is_password=True).strip()
+        elif choice == 3:
+            slot["base_url"] = prompt("base_url: ", default=slot["base_url"]).strip()
+        elif choice == 4:
+            if slot["provider"] == "gemini":
+                pick_gemini_model(slot)
+            else:
+                value = prompt("модель: ", default=slot["model"]).strip()
+                if value:
+                    slot["model"] = value
+                else:
+                    print("Модель не может быть пустой.")
+                    input("Enter...")
+        elif choice == 5:
+            names = list(TEMPLATES)
+            pick = menu("Шаблон", names)
+            if pick is not None:
+                prov, url = TEMPLATES[names[pick]]
+                slot["provider"], slot["base_url"], slot["model"] = prov, url, ""
+        elif choice == 6:
+            cfg["slots"][idx] = empty_slot(idx + 1)
+            return
+
+
+def settings_screen(cfg):
+    while True:
+        clear()
+        items = []
+        for s in cfg["slots"]:
+            state = "готов" if slot_ready(s) else "не настроен"
+            items.append(f"{s['name']}: {s['provider']}, {s['role']}, {state}")
+        items.append("назад")
+        choice = menu("Настройки", items)
+        if choice is None or choice == len(items) - 1:
+            save_config(cfg)
+            return
+        edit_slot(cfg, choice)
+
+
+def agent_turn(brain, system, history):
+    """Крутит модель, пока она вызывает инструменты, и выводит итоговый ответ."""
+    for _ in range(MAX_STEPS):
+        with spinner("Думаю"):
+            reply = chat_tools(brain, system, history, tools.SPECS)
+        history.append({"role": "assistant", "content": reply["content"],
+                        "tool_calls": reply["tool_calls"]})
+        if reply["content"]:
+            print(reply["content"])
+        if not reply["tool_calls"]:
+            return
+        for call in reply["tool_calls"]:
+            print(f"\n[инструмент] {call['name']} {json.dumps(call['args'], ensure_ascii=False)[:200]}")
+            result = tools.execute(call["name"], call["args"])
+            history.append({"role": "tool", "tool_call_id": call["id"],
+                            "name": call["name"], "content": result})
+    print(f"\nЛимит шагов ({MAX_STEPS}) достигнут. Напишите, как продолжить.")
+
+
+def skill_menu():
+    """Выбор навыка из домашней папки. Выбранный навык добавляется к промпту."""
+    found = skills.find_skills()
+    if not found:
+        print("В домашней папке не найдено папок с SKILL.md.")
+        print("Положите навык в папку, например ~/мой_навык/SKILL.md")
+        return
+    items = [f"{s['name']}: {s['description'][:60]}" for s in found]
+    pick = menu("Выберите навык", items)
+    if pick is None:
+        return
+    chosen = found[pick]
+    if any(s["path"] == chosen["path"] for s in skills.ACTIVE):
+        print("Этот навык уже включён.")
+        return
+    skills.ACTIVE.append(chosen)
+    print(f"Навык включён: {chosen['name']}")
+
+
+def chat_screen(cfg, chat_id=None, history=None):
+    brain = find_brain(cfg)
+    clear()
+    if not brain:
+        print("Нет слота с ролью brain. Откройте setting и настройте один.")
+        input("Enter, чтобы вернуться...")
+        return
+    system = SYSTEM_PROMPT.format(root=tools.ROOT)
+    tools.CONFIG["slots"] = cfg["slots"]
+    history = list(history) if history else []
+    chat_id = chat_id or chats.new_id()
+    def header():
+        clear()
+        print(BANNER)
+        print()
+        print(brain["model"])
+        print()
+
+    header()
+    while True:
+        text = prompt("> ").strip()
+        if not text:
+            continue
+        if text == "/exit":
+            return
+        if text == "/clear":
+            # очищает только экран, история диалога остаётся
+            header()
+            continue
+        if text == "/new":
+            history.clear()
+            chat_id = chats.new_id()
+            header()
+            print("Начат новый чат.")
+            continue
+        if text == "/skill":
+            skill_menu()
+            if skills.ACTIVE:
+                print("Активные навыки: " + ", ".join(s["name"] for s in skills.ACTIVE))
+            continue
+        if text == "/skill clear":
+            skills.ACTIVE.clear()
+            print("Навыки отключены.")
+            continue
+        if text.startswith("/ask "):
+            parts = text.split(maxsplit=2)
+            if len(parts) < 3 or not parts[1].isdigit() or not 0 < int(parts[1]) <= SLOT_COUNT:
+                print("Формат: /ask <номер слота> <вопрос>")
+                continue
+            helper = cfg["slots"][int(parts[1]) - 1]
+            if helper["role"] != "helper" or not slot_ready(helper):
+                print("Этот слот не готов или не имеет роль helper.")
+                continue
+            try:
+                with spinner("Спрашиваю помощника"):
+                    answer = ask(helper, parts[2])
+                print(answer)
+            except Exception as e:
+                print(f"Ошибка: {e}")
+            continue
+        history.append({"role": "user", "content": text})
+        tools.HELPER_CALLS[0] = 0
+        mark = len(history)
+        try:
+            agent_turn(brain, skills.build_system(system), history)
+            chats.save(chat_id, history)
+        except KeyboardInterrupt:
+            del history[mark - 1:]
+            print("\nПрервано.")
+        except Exception as e:
+            del history[mark - 1:]
+            print(f"Ошибка: {e}")
+
+
+def run():
+    cfg = load_config()
+    while True:
+        action = start_screen()
+        if action == "chatting":
+            chat_screen(cfg)
+        elif action == "history":
+            saved = history_screen()
+            if saved:
+                chat_screen(cfg, saved["id"], saved["history"])
+        elif action == "setting":
+            settings_screen(cfg)
+        else:
+            clear()
+            return

redsba/chats.py

@@ -0,0 +1,40 @@
+"""Сохранение чатов в ~/.redsba/chats/ как отдельных JSON-файлов."""
+
+import json
+import time
+from pathlib import Path
+
+CHATS_DIR = Path.home() / ".redsba" / "chats"
+
+
+def new_id():
+    return time.strftime("%Y%m%d-%H%M%S")
+
+
+def save(chat_id, history):
+    """Сохраняет чат. Ключи API сюда не попадают: только сообщения."""
+    first = next((m["content"] for m in history if m["role"] == "user"), "")
+    title = " ".join(first.split())[:60] or "(пусто)"
+    data = {
+        "id": chat_id,
+        "title": title,
+        "updated": time.strftime("%Y-%m-%d %H:%M"),
+        "history": history,
+    }
+    CHATS_DIR.mkdir(parents=True, exist_ok=True)
+    path = CHATS_DIR / f"{chat_id}.json"
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    path.chmod(0o600)
+
+
+def list_chats():
+    """Возвращает сохранённые чаты, новые сверху."""
+    result = []
+    if not CHATS_DIR.exists():
+        return result
+    for p in sorted(CHATS_DIR.glob("*.json"), reverse=True):
+        try:
+            result.append(json.loads(p.read_text(encoding="utf-8")))
+        except (OSError, json.JSONDecodeError):
+            continue
+    return result

redsba/config.py

@@ -0,0 +1,50 @@
+import json
+import os
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".redsba"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+SLOT_COUNT = 3
+ROLES = ["off", "brain", "helper"]
+
+
+def empty_slot(n):
+    return {"name": f"slot {n}", "provider": "openai", "api_key": "",
+            "base_url": "", "model": "", "role": "off"}
+
+
+def load_config():
+    data = {}
+    if CONFIG_FILE.exists():
+        data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+    slots = data.get("slots", [])
+    while len(slots) < SLOT_COUNT:
+        slots.append(empty_slot(len(slots) + 1))
+    return {"slots": slots[:SLOT_COUNT]}
+
+
+def save_config(cfg):
+    CONFIG_DIR.mkdir(mode=0o700, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(cfg, ensure_ascii=False, indent=2), encoding="utf-8")
+    os.chmod(CONFIG_FILE, 0o600)
+
+
+def mask(key):
+    if not key:
+        return "(пусто)"
+    return key[:4] + "****" + key[-4:] if len(key) > 8 else "****"
+
+
+def slot_ready(slot):
+    if not slot["api_key"] or not slot["model"] or slot["role"] == "off":
+        return False
+    if slot["provider"] == "openai":
+        return bool(slot["base_url"])
+    return True
+
+
+def find_brain(cfg):
+    for s in cfg["slots"]:
+        if s["role"] == "brain" and slot_ready(s):
+            return s
+    return None

redsba/providers.py

@@ -0,0 +1,169 @@
+import json
+
+import requests
+
+TEMPLATES = {
+    "Groq": ("openai", "https://api.groq.com/openai/v1"),
+    "OpenRouter": ("openai", "https://openrouter.ai/api/v1"),
+    "Mistral": ("openai", "https://api.mistral.ai/v1"),
+    "DeepSeek": ("openai", "https://api.deepseek.com/v1"),
+    "Gemini": ("gemini", ""),
+}
+PROVIDERS = ["openai", "gemini"]
+
+
+HINTS = {
+    400: "запрос отклонён, проверьте модель и параметры",
+    401: "неверный ключ API",
+    403: "доступ запрещён, проверьте ключ и оплату проекта",
+    404: "модель не найдена, проверьте её имя",
+    413: "запрос слишком большой для лимита, сократите текст или выберите другую модель",
+    429: "превышен лимит запросов, подождите минуту",
+    500: "внутренняя ошибка сервера, попробуйте позже",
+    503: "модель сейчас перегружена, попробуйте через минуту",
+}
+
+
+def _raise(r):
+    """Превращает HTTP-ошибку в обычный текст, без JSON."""
+    if r.status_code < 400:
+        return
+    detail = ""
+    try:
+        err = r.json().get("error", {})
+        detail = err.get("message", "") if isinstance(err, dict) else str(err)
+    except ValueError:
+        detail = r.text
+    detail = " ".join(detail.split())[:200]
+    text = HINTS.get(r.status_code, f"ошибка сервера, код {r.status_code}")
+    raise RuntimeError(f"{text}. {detail}" if detail else text)
+
+
+# ---------- OpenAI-совместимый формат ----------
+
+def _openai_messages(system, history):
+    out = [{"role": "system", "content": system}]
+    for m in history:
+        if m["role"] == "user":
+            out.append({"role": "user", "content": m["content"]})
+        elif m["role"] == "assistant":
+            d = {"role": "assistant", "content": m.get("content") or None}
+            if m.get("tool_calls"):
+                d["tool_calls"] = [
+                    {"id": c["id"], "type": "function",
+                     "function": {"name": c["name"],
+                                  "arguments": json.dumps(c["args"], ensure_ascii=False)}}
+                    for c in m["tool_calls"]
+                ]
+            out.append(d)
+        elif m["role"] == "tool":
+            out.append({"role": "tool", "tool_call_id": m["tool_call_id"],
+                        "content": m["content"]})
+    return out
+
+
+def _chat_openai(slot, system, history, tools):
+    url = slot["base_url"].rstrip("/") + "/chat/completions"
+    body = {"model": slot["model"], "messages": _openai_messages(system, history)}
+    if tools:
+        body["tools"] = [{"type": "function", "function": t} for t in tools]
+    r = requests.post(url, headers={"Authorization": f"Bearer {slot['api_key']}"},
+                      json=body, timeout=180)
+    _raise(r)
+    msg = r.json()["choices"][0]["message"]
+    calls = []
+    for i, tc in enumerate(msg.get("tool_calls") or []):
+        try:
+            args = json.loads(tc["function"].get("arguments") or "{}")
+        except json.JSONDecodeError:
+            args = {}
+        calls.append({"id": tc.get("id") or f"call_{i}",
+                      "name": tc["function"]["name"], "args": args})
+    return {"content": msg.get("content") or "", "tool_calls": calls}
+
+
+# ---------- Gemini API ----------
+
+def _gemini_contents(history):
+    contents = []
+    for m in history:
+        if m["role"] == "user":
+            contents.append({"role": "user", "parts": [{"text": m["content"]}]})
+        elif m["role"] == "assistant":
+            parts = []
+            if m.get("content"):
+                parts.append({"text": m["content"]})
+            for c in m.get("tool_calls", []):
+                # raw сохраняет исходную часть ответа, включая служебные поля Gemini 3
+                parts.append(c.get("raw") or {"functionCall": {"name": c["name"], "args": c["args"]}})
+            if parts:
+                contents.append({"role": "model", "parts": parts})
+        elif m["role"] == "tool":
+            part = {"functionResponse": {"name": m["name"],
+                                         "response": {"result": m["content"]}}}
+            last = contents[-1] if contents else None
+            if last and last["role"] == "user" and any("functionResponse" in p for p in last["parts"]):
+                last["parts"].append(part)
+            else:
+                contents.append({"role": "user", "parts": [part]})
+    return contents
+
+
+def _chat_gemini(slot, system, history, tools):
+    url = ("https://generativelanguage.googleapis.com/v1beta/models/"
+           f"{slot['model']}:generateContent")
+    body = {"contents": _gemini_contents(history)}
+    if system:
+        body["systemInstruction"] = {"parts": [{"text": system}]}
+    if tools:
+        body["tools"] = [{"functionDeclarations": tools}]
+    r = requests.post(url, params={"key": slot["api_key"]}, json=body, timeout=180)
+    _raise(r)
+    parts = r.json()["candidates"][0].get("content", {}).get("parts", [])
+    texts, calls = [], []
+    for i, p in enumerate(parts):
+        if "functionCall" in p:
+            fc = p["functionCall"]
+            calls.append({"id": f"gem_{i}", "name": fc["name"],
+                          "args": fc.get("args", {}), "raw": p})
+        elif "text" in p and not p.get("thought"):
+            texts.append(p["text"])
+    return {"content": "".join(texts), "tool_calls": calls}
+
+
+# ---------- общие функции ----------
+
+def list_gemini_models(api_key):
+    """Возвращает имена текстовых моделей Gemini, доступных этому ключу."""
+    r = requests.get(
+        "https://generativelanguage.googleapis.com/v1beta/models",
+        params={"key": api_key, "pageSize": 1000},
+        timeout=30,
+    )
+    r.raise_for_status()
+    names = []
+    for m in r.json().get("models", []):
+        methods = m.get("supportedGenerationMethods", [])
+        name = m.get("name", "").removeprefix("models/")
+        if "generateContent" in methods and name.startswith("gemini"):
+            names.append(name)
+    return sorted(names, reverse=True)
+
+
+def chat_tools(slot, system, history, tools=None):
+    """Один запрос к модели. Возвращает {"content": str, "tool_calls": [...]}."""
+    try:
+        if slot["provider"] == "gemini":
+            return _chat_gemini(slot, system, history, tools)
+        return _chat_openai(slot, system, history, tools)
+    except requests.exceptions.Timeout:
+        raise RuntimeError("сервер не ответил вовремя, попробуйте ещё раз")
+    except requests.exceptions.ConnectionError:
+        raise RuntimeError("обрыв соединения с сервером, попробуйте ещё раз")
+
+
+def ask(slot, question):
+    """Простой вопрос без инструментов, для /ask."""
+    reply = chat_tools(slot, "Отвечай кратко и по делу.",
+                       [{"role": "user", "content": question}])
+    return reply["content"]

redsba/skills.py

@@ -0,0 +1,94 @@
+"""Навыки в формате Claude: папки с файлом SKILL.md в домашней папке Termux."""
+
+import zipfile
+from pathlib import Path
+
+MAX_SKILL_CHARS = 20000
+MAX_DEPTH = 2
+ACTIVE = []  # выбранные навыки: список словарей {name, description, body}
+
+
+def _parse(text):
+    """Разбирает YAML-шапку между строками ---. Возвращает (meta, body)."""
+    meta = {}
+    body = text
+    if text.startswith("---"):
+        parts = text.split("---", 2)
+        if len(parts) == 3:
+            for line in parts[1].splitlines():
+                if ":" in line:
+                    key, value = line.split(":", 1)
+                    meta[key.strip()] = value.strip().strip('"\'')
+            body = parts[2].strip()
+    return meta, body
+
+
+def _from_zip(path):
+    """Читает SKILL.md из zip-архива: в корне или в одной папке внутри."""
+    try:
+        with zipfile.ZipFile(path) as z:
+            names = [n for n in z.namelist()
+                     if n.rsplit("/", 1)[-1] == "SKILL.md" and n.count("/") <= 1]
+            if not names:
+                return None
+            names.sort(key=lambda n: n.count("/"))
+            with z.open(names[0]) as f:
+                # читаем с ограничением, чтобы огромный архив не забил память
+                raw = f.read(MAX_SKILL_CHARS * 4)
+    except (OSError, zipfile.BadZipFile, KeyError):
+        return None
+    meta, body = _parse(raw.decode("utf-8", errors="replace"))
+    return {
+        "name": meta.get("name") or path.stem,
+        "description": meta.get("description", ""),
+        "body": body[:MAX_SKILL_CHARS],
+        "path": str(path),
+    }
+
+
+def find_skills(base=None):
+    """Ищет папки с SKILL.md до MAX_DEPTH уровней вглубь от базовой папки."""
+    base = Path(base or Path.home())
+    found = []
+
+    def walk(folder, depth):
+        if depth > MAX_DEPTH:
+            return
+        try:
+            children = sorted(folder.iterdir())
+        except OSError:
+            return
+        for child in children:
+            if child.name.startswith("."):
+                continue
+            if child.is_file() and child.suffix.lower() == ".zip":
+                zipped = _from_zip(child)
+                if zipped:
+                    found.append(zipped)
+                continue
+            if not child.is_dir():
+                continue
+            skill_file = child / "SKILL.md"
+            if skill_file.is_file():
+                try:
+                    meta, body = _parse(skill_file.read_text(encoding="utf-8", errors="replace"))
+                except OSError:
+                    continue
+                found.append({
+                    "name": meta.get("name") or child.name,
+                    "description": meta.get("description", ""),
+                    "body": body[:MAX_SKILL_CHARS],
+                    "path": str(child),
+                })
+            walk(child, depth + 1)
+
+    walk(base, 1)
+    return found
+
+
+def build_system(prompt):
+    """Добавляет тексты выбранных навыков к системному промпту."""
+    if not ACTIVE:
+        return prompt
+    blocks = [f"## Навык: {s['name']}\n{s['body']}" for s in ACTIVE]
+    return prompt + "\n\nСледуй инструкциям выбранных навыков:\n\n" + "\n\n".join(blocks)

redsba/tools.py

@@ -0,0 +1,289 @@
+"""Инструменты агента: файлы и команды внутри рабочей папки, с подтверждением."""
+
+import difflib
+import subprocess
+import time
+from html.parser import HTMLParser
+from pathlib import Path
+
+import requests
+
+from redsba.config import slot_ready
+from redsba.providers import ask
+
+ROOT = Path.cwd().resolve()
+# конфиг слотов, передаётся из app.py при запуске чата
+CONFIG = {"slots": []}
+# сколько раз мозг обратился к помощнику за один запрос пользователя
+HELPER_CALLS = [0]
+MAX_HELPER_CALLS = 3
+BACKUP_DIR = ROOT / ".redsba_backup"
+LIMIT = 8000
+# "всегда в этой сессии" для каждого типа действия
+APPROVED = {"write": False, "edit": False, "run": False, "fetch": False}
+
+
+class _TextExtractor(HTMLParser):
+    """Достаёт видимый текст из HTML, пропуская скрипты и стили."""
+
+    SKIP = {"script", "style", "noscript", "svg", "head"}
+
+    def __init__(self):
+        super().__init__()
+        self.parts = []
+        self._skip = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag in self.SKIP:
+            self._skip += 1
+
+    def handle_endtag(self, tag):
+        if tag in self.SKIP and self._skip:
+            self._skip -= 1
+
+    def handle_data(self, data):
+        if not self._skip and data.strip():
+            self.parts.append(data.strip())
+
+SPECS = [
+    {
+        "name": "read_file",
+        "description": "Прочитать текстовый файл рабочей папки. Возвращает строки с номерами.",
+        "parameters": {
+            "type": "object",
+            "properties": {"path": {"type": "string", "description": "путь относительно рабочей папки"}},
+            "required": ["path"],
+        },
+    },
+    {
+        "name": "list_dir",
+        "description": "Показать содержимое папки рабочей папки.",
+        "parameters": {
+            "type": "object",
+            "properties": {"path": {"type": "string", "description": "путь, по умолчанию '.'"}},
+            "required": [],
+        },
+    },
+    {
+        "name": "write_file",
+        "description": "Создать или полностью перезаписать файл. Пользователь подтверждает действие.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "content": {"type": "string", "description": "полное содержимое файла"},
+            },
+            "required": ["path", "content"],
+        },
+    },
+    {
+        "name": "edit_file",
+        "description": ("Заменить точный фрагмент текста в файле. Фрагмент old должен встречаться "
+                        "ровно один раз. Пользователь подтверждает действие."),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "old": {"type": "string", "description": "точный текст для замены"},
+                "new": {"type": "string", "description": "новый текст"},
+            },
+            "required": ["path", "old", "new"],
+        },
+    },
+    {
+        "name": "fetch_url",
+        "description": ("Открыть веб-страницу по адресу http или https и получить её текст. "
+                        "Пользователь подтверждает каждый адрес."),
+        "parameters": {
+            "type": "object",
+            "properties": {"url": {"type": "string", "description": "полный адрес, например https://example.com"}},
+            "required": ["url"],
+        },
+    },
+    {
+        "name": "ask_helper",
+        "description": ("Спросить помощника (слот с ролью helper) и получить его ответ. "
+                        f"Не больше {MAX_HELPER_CALLS} обращений за один запрос пользователя. "
+                        "Используй, когда нужен второй взгляд или подсказка по сложному вопросу."),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "question": {"type": "string", "description": "вопрос помощнику, с нужным контекстом"},
+                "slot": {"type": "integer", "description": "номер слота помощника, по умолчанию первый свободный helper"},
+            },
+            "required": ["question"],
+        },
+    },
+    {
+        "name": "run_command",
+        "description": ("Выполнить shell-команду в рабочей папке, таймаут 60 секунд. "
+                        "Пользователь подтверждает действие."),
+        "parameters": {
+            "type": "object",
+            "properties": {"command": {"type": "string"}},
+            "required": ["command"],
+        },
+    },
+]
+
+
+def _trim(text):
+    if len(text) <= LIMIT:
+        return text
+    return text[:LIMIT] + f"\n... (обрезано, всего {len(text)} символов)"
+
+
+def _path(p):
+    target = (ROOT / p).resolve()
+    if target != ROOT and not target.is_relative_to(ROOT):
+        raise ValueError(f"путь вне рабочей папки: {p}")
+    return target
+
+
+def _confirm(kind, title, details=""):
+    if APPROVED[kind]:
+        return True
+    print(f"\n{title}")
+    if details:
+        print(details)
+    ans = input("Разрешить? [y] да / [n] нет / [a] всегда в этой сессии: ").strip().lower()
+    if ans == "a":
+        APPROVED[kind] = True
+        return True
+    return ans in ("y", "yes", "д", "да")
+
+
+def _backup(path):
+    if not path.exists():
+        return
+    dest = BACKUP_DIR / path.relative_to(ROOT)
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    dest = dest.with_name(f"{dest.name}.{stamp}.bak")
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_bytes(path.read_bytes())
+
+
+def _diff(old, new, name):
+    lines = difflib.unified_diff(old.splitlines(), new.splitlines(),
+                                 fromfile=name, tofile=name, lineterm="")
+    return "\n".join(list(lines)[:80])
+
+
+def _read(p):
+    path = _path(p)
+    if not path.is_file():
+        return f"Не файл: {p}"
+    lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+    return _trim("\n".join(f"{i}\t{line}" for i, line in enumerate(lines, 1)))
+
+
+def _list(p):
+    path = _path(p)
+    if not path.is_dir():
+        return f"Не папка: {p}"
+    items = sorted(path.iterdir(), key=lambda x: (not x.is_dir(), x.name))
+    return "\n".join(f"{x.name}/" if x.is_dir() else x.name for x in items) or "(пусто)"
+
+
+def _write(p, content):
+    path = _path(p)
+    if path.is_dir():
+        return f"Это папка: {p}"
+    if path.exists():
+        old = path.read_text(encoding="utf-8", errors="replace")
+        details = _diff(old, content, p)
+    else:
+        details = "\n".join(content.splitlines()[:30])
+    if not _confirm("write", f"Записать файл: {p}", details):
+        return "Пользователь отклонил запись."
+    _backup(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    return f"Записано: {p} ({len(content)} симв.)"
+
+
+def _edit(p, old, new):
+    path = _path(p)
+    if not path.is_file():
+        return f"Не файл: {p}"
+    if not old:
+        return "Фрагмент old пустой."
+    text = path.read_text(encoding="utf-8", errors="replace")
+    count = text.count(old)
+    if count == 0:
+        return "Фрагмент не найден. Сначала прочитайте файл и возьмите точный текст."
+    if count > 1:
+        return f"Фрагмент встречается {count} раз. Сделайте old уникальнее."
+    updated = text.replace(old, new, 1)
+    if not _confirm("edit", f"Правка файла: {p}", _diff(text, updated, p)):
+        return "Пользователь отклонил правку."
+    _backup(path)
+    path.write_text(updated, encoding="utf-8")
+    return f"Правка применена: {p}"
+
+
+def _fetch(url):
+    if not url.startswith(("http://", "https://")):
+        return "Разрешены только адреса http:// и https://"
+    if not _confirm("fetch", f"Открыть адрес: {url}"):
+        return "Пользователь отклонил открытие адреса."
+    r = requests.get(url, timeout=30, headers={"User-Agent": "redsba-code/0.1"})
+    r.raise_for_status()
+    ctype = r.headers.get("Content-Type", "")
+    if "html" in ctype:
+        parser = _TextExtractor()
+        parser.feed(r.text)
+        text = "\n".join(parser.parts)
+    else:
+        text = r.text
+    return _trim(f"Адрес: {r.url}\n\n{text}")
+
+
+def _ask_helper(question, slot_no=None):
+    if HELPER_CALLS[0] >= MAX_HELPER_CALLS:
+        return f"Лимит обращений к помощнику ({MAX_HELPER_CALLS}) исчерпан. Решайте сами."
+    slots = CONFIG["slots"]
+    if slot_no is not None:
+        if not 1 <= slot_no <= len(slots):
+            return f"Нет слота с номером {slot_no}."
+        helper = slots[slot_no - 1]
+        if helper["role"] != "helper" or not slot_ready(helper):
+            return f"Слот {slot_no} не готов или не имеет роль helper."
+    else:
+        helper = next((s for s in slots if s["role"] == "helper" and slot_ready(s)), None)
+        if helper is None:
+            return "Нет готового слота с ролью helper."
+    HELPER_CALLS[0] += 1
+    answer = ask(helper, question)
+    return f"Ответ помощника ({helper['name']}, обращение {HELPER_CALLS[0]} из {MAX_HELPER_CALLS}):\n{answer}"
+
+
+def _run(command):
+    if not _confirm("run", f"Команда: {command}"):
+        return "Пользователь отклонил команду."
+    proc = subprocess.run(command, shell=True, cwd=ROOT, capture_output=True,
+                          text=True, timeout=60)
+    return _trim(f"код выхода {proc.returncode}\n{proc.stdout}{proc.stderr}")
+
+
+def execute(name, args):
+    """Выполняет инструмент и возвращает текст результата для модели."""
+    try:
+        if name == "read_file":
+            return _read(args["path"])
+        if name == "list_dir":
+            return _list(args.get("path", "."))
+        if name == "write_file":
+            return _write(args["path"], args["content"])
+        if name == "edit_file":
+            return _edit(args["path"], args["old"], args["new"])
+        if name == "run_command":
+            return _run(args["command"])
+        if name == "fetch_url":
+            return _fetch(args["url"])
+        if name == "ask_helper":
+            slot_no = args.get("slot")
+            return _ask_helper(args["question"], int(slot_no) if slot_no is not None else None)
+        return f"Неизвестный инструмент: {name}"
+    except Exception as e:
+        return f"Ошибка: {e}"

redsba/ui.py

@@ -0,0 +1,89 @@
+import itertools
+import os
+import sys
+import threading
+import time
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout
+from prompt_toolkit.layout.containers import HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.styles import Style
+
+STYLE = Style.from_dict({"title": "bold", "sel": "reverse", "hint": "#888888"})
+
+
+def clear():
+    os.system("clear")
+
+
+def menu(title, items):
+    """Выбор стрелками. Возвращает индекс или None (Esc)."""
+    index = [0]
+    kb = KeyBindings()
+
+    @kb.add("up")
+    def _(event):
+        index[0] = (index[0] - 1) % len(items)
+
+    @kb.add("down")
+    def _(event):
+        index[0] = (index[0] + 1) % len(items)
+
+    @kb.add("enter")
+    def _(event):
+        event.app.exit(result=index[0])
+
+    @kb.add("escape")
+    def _(event):
+        event.app.exit(result=None)
+
+    def render():
+        lines = [("class:title", f"{title}\n\n")]
+        for i, item in enumerate(items):
+            if i == index[0]:
+                lines.append(("class:sel", f"  > {item}\n"))
+            else:
+                lines.append(("", f"    {item}\n"))
+        lines.append(("class:hint", "\n стрелки - выбор, Enter - ок, Esc - назад"))
+        return lines
+
+    app = Application(
+        layout=Layout(HSplit([Window(FormattedTextControl(render), always_hide_cursor=True)])),
+        key_bindings=kb,
+        style=STYLE,
+        full_screen=False,
+    )
+    return app.run()
+
+
+class spinner:
+    """Крутилка в строке, пока идёт запрос к модели. Используется как with."""
+
+    FRAMES = "|/-\\"
+
+    def __init__(self, text="Думаю"):
+        self.text = text
+        self._stop = threading.Event()
+        self._thread = None
+
+    def _run(self):
+        for frame in itertools.cycle(self.FRAMES):
+            if self._stop.is_set():
+                break
+            sys.stdout.write(f"\r{frame} {self.text}...")
+            sys.stdout.flush()
+            time.sleep(0.12)
+
+    def __enter__(self):
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+        return self
+
+    def __exit__(self, *exc):
+        self._stop.set()
+        self._thread.join()
+        sys.stdout.write("\r" + " " * (len(self.text) + 6) + "\r")
+        sys.stdout.flush()
+        return False

redsba_code-0.1.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: redsba-code
+Version: 0.1.0
+Summary: Терминальный клиент ИИ со слотами провайдеров (Groq, Gemini, OpenAI-совместимые)
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Requires-Dist: prompt_toolkit>=3.0
+
+# redSBA code
+
+Терминальный клиент ИИ со слотами провайдеров.
+
+## Установка
+
+    pip install .
+
+## Запуск
+
+    redsba
+
+Настройте слот в разделе `setting`: выберите шаблон провайдера, вставьте ключ и введите модель вручную.

redsba_code-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+redsba/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+redsba/__main__.py,sha256=8brjSH7qhBjmPMm_Dhk_JneYd1KrI00L_hDg44Pxu1U,159
+redsba/app.py,sha256=vnpeomFb6-Yzj2vkyk13ZMM8UeGCsmtz9z8ZS-IVNdQ,10794
+redsba/chats.py,sha256=SJIg74vD14-AHTuw7OXdtM39r8TL92ziiGxugPeCGzo,1293
+redsba/config.py,sha256=a-ZIyoLIZcL-MZ_BVDZ1jFFT7dl-lbnguhQFyrw1iN4,1288
+redsba/providers.py,sha256=69yUiqysUQ8k6RAbIboLaWLNxS7LIRXvWMUyA8_iDHI,7294
+redsba/skills.py,sha256=owrCzbmDTrqWFqaH4vIjGC2crUrOmL4DmJkQ3-yz6pg,3500
+redsba/tools.py,sha256=-B0qf8zLGE91-OqdoTapIVLqRxSzFYmsDL4sMhNNlhY,11657
+redsba/ui.py,sha256=4z6jCtWeP5Lxta9mPF9UBpzK4J_WvBiTQqR9L6hEVMM,2493
+redsba_code-0.1.0.dist-info/METADATA,sha256=_IcMa5eGyrQ5v2EbkfxVK-uSkzJARaqG5kzD_WkcgAE,681
+redsba_code-0.1.0.dist-info/WHEEL,sha256=a-udL2m4V_6Yn8b-uKzWb12RjRxwwMo6ohYFM24tpaY,91
+redsba_code-0.1.0.dist-info/entry_points.txt,sha256=TpUyO0wHk1opREZVXsg0S7QB4TDdCzQgEWu8uq5lwug,48
+redsba_code-0.1.0.dist-info/top_level.txt,sha256=9LMtQMgZRtQnzZuPXmCk0_y05k1hxSTKYHjAz7nurA4,7
+redsba_code-0.1.0.dist-info/RECORD,,

redsba_code-0.1.0.dist-info/WHEEL

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

redsba_code-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+redsba = redsba.__main__:main

redsba_code-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+redsba