agent-gyrk 0.2.0__tar.gz

agent_gyrk-0.2.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: agent-gyrk
+Version: 0.2.0
+Summary: agent-gyrk — CLI agentic rodando o modelo GYRK
+Author: Havek
+Project-URL: Homepage, https://gyrk.havek.ai
+Keywords: gyrk,agent,cli,llm,coding-agent
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# agent-gyrk
+
+Agente de código no terminal rodando o **GYRK** (modelo próprio, na nuvem).
+O harness é dono do loop; o GYRK é só uma política de próxima-ação. Ação por turno =
+um JSON travado por gramática (`response_format json_schema`), com `tool` num enum
+fechado das tools ativas. Só stdlib.
+
+## Instalar (comando global, igual claude-code)
+
+```bash
+pipx install agent-gyrk     # cria o comando `gyrk` no PATH
+gyrk                        # free, sem chave (limitado)
+gyrk init                   # cola sua chave pra mais (tier Pro)
+```
+
+## Usar
+
+```bash
+gyrk                      # REPL interativo
+gyrk "liste os .py"       # tarefa única
+gyrk --allow-local "..."  # libera run_bash (off por padrão)
+gyrk --help
+```
+
+## Config (env, sem segredo embutido)
+
+| var | default |
+|---|---|
+| `GYRK_BASE_URL` | endpoint da API GYRK (default api.gyrk.havek.ai) |
+| `GYRK_API_KEY` | (vazio) — Bearer pro gateway autenticado (Fase 3) |
+| `GYRK_ALLOW_LOCAL` | `0` |
+| `GYRK_MAX_TOKENS` | `2048` |
+| `GYRK_TEMP` | `0.2` |
+
+## Tools (MVP)
+
+`list_files`, `read_file`, `grep`, `write_file`, `run_python` — escopadas na pasta
+atual. `run_bash` é gated (`--allow-local`). GYRK puro: zero Claude.

agent_gyrk-0.2.0/README.md

@@ -0,0 +1,38 @@
+# agent-gyrk
+
+Agente de código no terminal rodando o **GYRK** (modelo próprio, na nuvem).
+O harness é dono do loop; o GYRK é só uma política de próxima-ação. Ação por turno =
+um JSON travado por gramática (`response_format json_schema`), com `tool` num enum
+fechado das tools ativas. Só stdlib.
+
+## Instalar (comando global, igual claude-code)
+
+```bash
+pipx install agent-gyrk     # cria o comando `gyrk` no PATH
+gyrk                        # free, sem chave (limitado)
+gyrk init                   # cola sua chave pra mais (tier Pro)
+```
+
+## Usar
+
+```bash
+gyrk                      # REPL interativo
+gyrk "liste os .py"       # tarefa única
+gyrk --allow-local "..."  # libera run_bash (off por padrão)
+gyrk --help
+```
+
+## Config (env, sem segredo embutido)
+
+| var | default |
+|---|---|
+| `GYRK_BASE_URL` | endpoint da API GYRK (default api.gyrk.havek.ai) |
+| `GYRK_API_KEY` | (vazio) — Bearer pro gateway autenticado (Fase 3) |
+| `GYRK_ALLOW_LOCAL` | `0` |
+| `GYRK_MAX_TOKENS` | `2048` |
+| `GYRK_TEMP` | `0.2` |
+
+## Tools (MVP)
+
+`list_files`, `read_file`, `grep`, `write_file`, `run_python` — escopadas na pasta
+atual. `run_bash` é gated (`--allow-local`). GYRK puro: zero Claude.

agent_gyrk-0.2.0/agent_gyrk.egg-info/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: agent-gyrk
+Version: 0.2.0
+Summary: agent-gyrk — CLI agentic rodando o modelo GYRK
+Author: Havek
+Project-URL: Homepage, https://gyrk.havek.ai
+Keywords: gyrk,agent,cli,llm,coding-agent
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# agent-gyrk
+
+Agente de código no terminal rodando o **GYRK** (modelo próprio, na nuvem).
+O harness é dono do loop; o GYRK é só uma política de próxima-ação. Ação por turno =
+um JSON travado por gramática (`response_format json_schema`), com `tool` num enum
+fechado das tools ativas. Só stdlib.
+
+## Instalar (comando global, igual claude-code)
+
+```bash
+pipx install agent-gyrk     # cria o comando `gyrk` no PATH
+gyrk                        # free, sem chave (limitado)
+gyrk init                   # cola sua chave pra mais (tier Pro)
+```
+
+## Usar
+
+```bash
+gyrk                      # REPL interativo
+gyrk "liste os .py"       # tarefa única
+gyrk --allow-local "..."  # libera run_bash (off por padrão)
+gyrk --help
+```
+
+## Config (env, sem segredo embutido)
+
+| var | default |
+|---|---|
+| `GYRK_BASE_URL` | endpoint da API GYRK (default api.gyrk.havek.ai) |
+| `GYRK_API_KEY` | (vazio) — Bearer pro gateway autenticado (Fase 3) |
+| `GYRK_ALLOW_LOCAL` | `0` |
+| `GYRK_MAX_TOKENS` | `2048` |
+| `GYRK_TEMP` | `0.2` |
+
+## Tools (MVP)
+
+`list_files`, `read_file`, `grep`, `write_file`, `run_python` — escopadas na pasta
+atual. `run_bash` é gated (`--allow-local`). GYRK puro: zero Claude.

agent_gyrk-0.2.0/agent_gyrk.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+agent_gyrk.py
+pyproject.toml
+agent_gyrk.egg-info/PKG-INFO
+agent_gyrk.egg-info/SOURCES.txt
+agent_gyrk.egg-info/dependency_links.txt
+agent_gyrk.egg-info/entry_points.txt
+agent_gyrk.egg-info/top_level.txt

agent_gyrk-0.2.0/agent_gyrk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_gyrk-0.2.0/agent_gyrk.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gyrk = agent_gyrk:main

agent_gyrk-0.2.0/agent_gyrk.egg-info/top_level.txt

@@ -0,0 +1 @@
+agent_gyrk

agent_gyrk-0.2.0/agent_gyrk.py

@@ -0,0 +1,809 @@
+#!/usr/bin/env python3
+"""
+agent-gyrk — Fase 1 (MVP): agente de código no terminal rodando o GYRK.
+
+O harness e' dono do loop; o GYRK e' so' um callable HTTP (a tese
+"loop e' serving, modelo e' politica de proxima-acao"). A acao por turno e'
+UM JSON travado por GRAMATICA (response_format json_schema -> GBNF), com `tool`
+restrito a um ENUM fechado das tools ativas -> alucinar tool e' impossivel.
+Provado no phase0_spike.py: 100% JSON valido / 100% roteamento / 100% args.
+
+- GYRK PURO: zero Claude. Quando os guards travam, para com mensagem honesta.
+- Tools escopadas na cwd. `run_bash` GATED (off por padrao; --allow-local liga).
+- Sem segredo embutido: endpoint/modelo/key vem de env.
+- So' stdlib (urllib) -> facil empacotar (pipx) depois.
+
+Uso:
+    python3 agent_gyrk.py                  # REPL interativo
+    python3 agent_gyrk.py "liste os .py"   # tarefa unica e sai
+    python3 agent_gyrk.py --allow-local    # libera run_bash
+
+Env:
+    GYRK_BASE_URL   endpoint da API GYRK (default = https://api.gyrk.havek.ai)
+    GYRK_API_KEY    se setado, vai como Bearer (pronto pro gateway autenticado)
+    GYRK_MODEL      so' rotulo informativo na UI
+    GYRK_ALLOW_LOCAL=1   mesmo que --allow-local
+    GYRK_MAX_TOKENS default 2048
+    GYRK_TEMP       default 0.2
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+
+# ---------- config (env, sem segredo embutido) ----------
+
+WORKSPACE = os.getcwd()
+CONFIG_PATH = os.path.expanduser("~/.config/gyrk/config.json")
+
+# API pública do GYRK (gateway autenticado). A infra de serving fica ATRÁS dela,
+# nunca exposta no cliente. Pra dev local, aponte com `gyrk init --base-url=...`.
+DEFAULT_BASE_URL = "https://api.gyrk.havek.ai"
+
+
+def _load_config():
+    try:
+        if os.path.isfile(CONFIG_PATH):
+            with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return {}
+
+
+_CFG = _load_config()
+# precedência: env > config (~/.config/gyrk) > default
+BASE_URL = (os.environ.get("GYRK_BASE_URL") or _CFG.get("base_url") or DEFAULT_BASE_URL).rstrip("/")
+ENDPOINT = BASE_URL + "/v1/chat/completions"
+API_KEY = (os.environ.get("GYRK_API_KEY") or _CFG.get("api_key") or "").strip()
+MODEL_LABEL = os.environ.get("GYRK_MODEL", "GYRK 1.0")
+MAX_TOKENS = int(os.environ.get("GYRK_MAX_TOKENS", "2048"))
+TEMP = float(os.environ.get("GYRK_TEMP", "0.2"))
+ALLOW_LOCAL = (os.environ.get("GYRK_ALLOW_LOCAL", "") not in ("", "0", "false")) or ("--allow-local" in sys.argv)
+CTX = int(os.environ.get("GYRK_CTX", "8192"))          # janela de contexto do serving
+VERBOSE = ("--verbose" in sys.argv) or ("-v" in sys.argv)
+_SESSION_IN = 0    # tokens de entrada acumulados na sessão
+_SESSION_OUT = 0   # tokens de saída acumulados na sessão
+
+
+# ---------- cores terminal ----------
+
+_USE_COLOR = sys.stdout.isatty()
+
+
+def _c(code, s):
+    return s if not _USE_COLOR else f"\033[{code}m{s}\033[0m"
+
+
+def dim(s):    return _c("2", s)
+def bold(s):   return _c("1", s)
+def cyan(s):   return _c("36", s)
+def green(s):  return _c("32", s)
+def yellow(s): return _c("33", s)
+def red(s):    return _c("31", s)
+def mag(s):    return _c("35", s)
+
+
+class Spinner:
+    FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+    def __init__(self, label="pensando"):
+        self.label = label
+        self._stop = threading.Event()
+        self._t = None
+
+    def _run(self):
+        i, t0 = 0, time.time()
+        while not self._stop.is_set():
+            frame = self.FRAMES[i % len(self.FRAMES)]
+            sys.stdout.write("\r  " + cyan(frame) + dim(f" {self.label}… {time.time()-t0:.0f}s"))
+            sys.stdout.flush()
+            i += 1
+            time.sleep(0.08)
+        sys.stdout.write("\r" + " " * 48 + "\r")
+        sys.stdout.flush()
+
+    def __enter__(self):
+        if _USE_COLOR:
+            self._t = threading.Thread(target=self._run, daemon=True)
+            self._t.start()
+        return self
+
+    def __exit__(self, *exc):
+        self._stop.set()
+        if self._t:
+            self._t.join()
+
+
+# ---------- ferramentas (escopadas na cwd) ----------
+
+def _resolve(path: str) -> str:
+    if not os.path.isabs(path):
+        path = os.path.join(WORKSPACE, path)
+    full = os.path.abspath(path)
+    if not full.startswith(os.path.abspath(WORKSPACE)):
+        raise ValueError("acesso negado fora da pasta atual")
+    return full
+
+
+def list_files(path: str = "."):
+    full = _resolve(path)
+    if not os.path.isdir(full):
+        return {"error": f"não é diretório: {path}"}
+    base = "" if path in (".", "") else path.rstrip("/") + "/"
+    items = []
+    for name in sorted(os.listdir(full)):
+        if name.startswith("."):
+            continue
+        p = os.path.join(full, name)
+        is_dir = os.path.isdir(p)
+        items.append({"path": base + name + ("/" if is_dir else ""),
+                      "is_dir": is_dir,
+                      "size": os.path.getsize(p) if os.path.isfile(p) else None})
+    return {"dir": path, "items": items}
+
+
+def read_file(path: str, start_line: int = 1, end_line: int = None, max_lines: int = 300):
+    full = _resolve(path)
+    if not os.path.isfile(full):
+        return {"error": f"não é arquivo: {path}"}
+    with open(full, "r", encoding="utf-8", errors="replace") as f:
+        all_lines = f.read().splitlines()
+    total = len(all_lines)
+    start = max(1, int(start_line or 1))
+    end = min(int(end_line) if end_line else start + max_lines - 1, start + max_lines - 1, total)
+    chunk = all_lines[start - 1:end]
+    numbered = "\n".join(f"{start + i}\t{ln}" for i, ln in enumerate(chunk))
+    tail = "" if end >= total else f"\n... [linhas {end+1}-{total} não mostradas; peça com start_line/end_line]"
+    return {"path": path, "total_lines": total, "shown": f"{start}-{end}", "content": numbered + tail}
+
+
+_GREP_SKIP = {".git", "node_modules", "venv", ".venv", "__pycache__", ".next", "dist", "build", ".mypy_cache"}
+
+
+def grep(pattern: str, glob: str = None, max_matches: int = 200):
+    import fnmatch
+    try:
+        rx = re.compile(pattern)
+    except re.error as e:
+        return {"error": f"regex inválida: {e}"}
+    matches = []
+    for root, dirs, files in os.walk(WORKSPACE):
+        dirs[:] = [d for d in dirs if d not in _GREP_SKIP and not d.startswith(".")]
+        for fn in files:
+            if glob and not fnmatch.fnmatch(fn, glob):
+                continue
+            fp = os.path.join(root, fn)
+            try:
+                with open(fp, "r", encoding="utf-8", errors="ignore") as f:
+                    for i, line in enumerate(f, 1):
+                        if rx.search(line):
+                            matches.append({"file": os.path.relpath(fp, WORKSPACE),
+                                            "line": i, "text": line.rstrip()[:200]})
+                            if len(matches) >= max_matches:
+                                return {"matches": matches, "truncated": True}
+            except Exception:
+                continue
+    return {"matches": matches, "count": len(matches)}
+
+
+def _validate_python(path: str, content: str):
+    issues = []
+    if not path.endswith(".py"):
+        return issues
+    module_name = os.path.splitext(os.path.basename(path))[0]
+    pat = rf'^\s*(?:from\s+{re.escape(module_name)}\s+import|import\s+{re.escape(module_name)})\b'
+    for ln, line in enumerate(content.splitlines(), 1):
+        if re.match(pat, line):
+            issues.append(f"linha {ln}: `{line.strip()}` é auto-import — {module_name}.py não pode importar de si mesmo. Defina tudo inline.")
+            break
+    import ast
+    try:
+        ast.parse(content)
+    except SyntaxError as e:
+        issues.append(f"SyntaxError linha {e.lineno}: {e.msg}")
+    return issues
+
+
+def write_file(path: str, content: str):
+    full = _resolve(path)
+    os.makedirs(os.path.dirname(full) or ".", exist_ok=True)
+    if len(content) > 1_000_000:
+        return {"error": "conteúdo > 1MB"}
+    stripped = content.strip().lower()
+    instructional = ("olha este", "olha esse", "analisa este", "analisa esse",
+                     "resuma este", "resuma esse", "analyse this", "look at this")
+    if len(content) < 80 and any(stripped.startswith(p) for p in instructional):
+        return {"error": "conteúdo parece ser a instrução do usuário, não o dado a ser salvo",
+                "hint": "não salve a instrução; peça o dado real com {\"final\": \"...\"}."}
+    issues = _validate_python(path, content)
+    if issues:
+        return {"error": "código Python tem problemas — corrija antes de salvar",
+                "issues": issues,
+                "hint": "reescreva SEM os problemas. NÃO importe o próprio arquivo. Defina tudo inline."}
+    with open(full, "w", encoding="utf-8") as f:
+        f.write(content)
+    return {"path": path, "bytes_written": len(content.encode("utf-8")), "ok": True}
+
+
+def edit_file(path: str, old_string: str, new_string: str, replace_all: bool = False):
+    """Edição cirúrgica: troca o trecho EXATO `old_string` por `new_string`."""
+    full = _resolve(path)
+    if not os.path.isfile(full):
+        return {"error": f"não é arquivo: {path}"}
+    with open(full, "r", encoding="utf-8", errors="replace") as f:
+        src = f.read()
+    count = src.count(old_string)
+    if count == 0:
+        return {"error": "old_string não encontrado no arquivo",
+                "hint": "copie o trecho EXATO via read_file (sem o número de linha)."}
+    if count > 1 and not replace_all:
+        return {"error": f"old_string aparece {count}x — ambíguo",
+                "hint": "inclua mais contexto pra ficar único, ou passe replace_all=true."}
+    new_src = src.replace(old_string, new_string) if replace_all else src.replace(old_string, new_string, 1)
+    issues = _validate_python(path, new_src)
+    if issues:
+        return {"error": "resultado Python tem problemas — revise", "issues": issues}
+    with open(full, "w", encoding="utf-8") as f:
+        f.write(new_src)
+    return {"path": path, "replaced": count if replace_all else 1, "ok": True}
+
+
+def note(text: str):
+    """Anota um fato na memória persistente (sobrevive à compactação de contexto)."""
+    _SCRATCHPAD.append(text.strip())
+    return {"ok": True, "notas": len(_SCRATCHPAD)}
+
+
+def run_python(code: str, timeout: int = 30):
+    try:
+        proc = subprocess.run(["python3", "-c", code], capture_output=True,
+                              text=True, timeout=timeout, cwd=WORKSPACE)
+        out, err = proc.stdout, proc.stderr
+        if len(out) > 5000: out = out[:5000] + "\n...[stdout truncado]"
+        if len(err) > 5000: err = err[:5000] + "\n...[stderr truncado]"
+        result = {"exit_code": proc.returncode, "stdout": out, "stderr": err}
+        if proc.returncode != 0 and "ModuleNotFoundError" in err:
+            result["hint"] = "Pacote não instalado. Use só stdlib (math, re, json, os) ou run_bash com pip."
+        return result
+    except subprocess.TimeoutExpired:
+        return {"error": f"timeout após {timeout}s"}
+    except Exception as e:
+        return {"error": f"{type(e).__name__}: {e}"}
+
+
+def run_bash(command: str, timeout: int = 30):
+    try:
+        proc = subprocess.run(command, shell=True, capture_output=True,
+                              text=True, timeout=timeout, cwd=WORKSPACE)
+        out, err = proc.stdout, proc.stderr
+        if len(out) > 5000: out = out[:5000] + "\n...[stdout truncado]"
+        if len(err) > 5000: err = err[:5000] + "\n...[stderr truncado]"
+        return {"exit_code": proc.returncode, "stdout": out, "stderr": err}
+    except subprocess.TimeoutExpired:
+        return {"error": f"timeout após {timeout}s"}
+    except Exception as e:
+        return {"error": f"{type(e).__name__}: {e}"}
+
+
+# memória persistente do agente (sobrevive à compactação do contexto 8k)
+_SCRATCHPAD = []
+
+
+# Catalogo: (nome, fn, args_desc, quando). run_bash so' entra se ALLOW_LOCAL.
+# A MESMA lista vira o enum da gramatica E a tabela do prompt -> 1 fonte de verdade.
+def build_tools():
+    specs = [
+        ("list_files", list_files, "path", "listar arquivos de uma pasta"),
+        ("read_file",  read_file,  "path, start_line, end_line", "ler arquivo (mostra nº de linha)"),
+        ("grep",       grep,       "pattern, glob (opcional), max_matches (200)", "buscar texto no código"),
+        ("write_file", write_file, "path, content", "CRIAR/refazer arquivo inteiro"),
+        ("edit_file",  edit_file,  "path, old_string, new_string, replace_all", "editar trecho EXATO de arquivo existente"),
+        ("run_python", run_python, "code, timeout (30)", "rodar Python (verificar por execução)"),
+        ("note",       note,       "text", "guardar um fato na memória (sobrevive à compactação)"),
+    ]
+    if ALLOW_LOCAL:
+        specs.append(("run_bash", run_bash, "command, timeout (30)", "rodar comando no shell (cwd)"))
+    return specs
+
+
+TOOL_SPECS = build_tools()
+TOOLS = {name: fn for name, fn, _, _ in TOOL_SPECS}
+TOOL_NAMES = list(TOOLS)
+
+
+# ---------- gramatica da acao (anyOf: tool | final) ----------
+
+ACTION_SCHEMA = {
+    "anyOf": [
+        {"type": "object",
+         "properties": {"thought": {"type": "string"},
+                        "tool": {"type": "string", "enum": TOOL_NAMES},
+                        "args": {"type": "object", "additionalProperties": True}},
+         "required": ["thought", "tool", "args"], "additionalProperties": False},
+        {"type": "object",
+         "properties": {"thought": {"type": "string"}, "final": {"type": "string"}},
+         "required": ["thought", "final"], "additionalProperties": False},
+    ]
+}
+
+
+# ---------- system prompt (tabela de tools dinamica) ----------
+
+def build_system_prompt():
+    table = "\n".join(f"| {n} | {a} | {q} |" for n, _, a, q in TOOL_SPECS)
+    bash_note = ("" if ALLOW_LOCAL else
+                 "\n(`run_bash` está DESLIGADO nesta sessão — não há shell; use run_python pra cálculos.)")
+    return f"""Você é o gyrk — assistente + agente de código rodando no terminal. Pasta atual: `{WORKSPACE}`.
+
+## FORMATO (RÍGIDO)
+Responda SEMPRE com UM objeto JSON, sem texto fora, sem markdown.
+A. Tool:  {{"thought":"<por que>","tool":"<nome>","args":{{...}}}}
+B. Final: {{"thought":"<por que terminei>","final":"<texto natural ao usuário>"}}
+
+## QUANDO USAR CADA UM
+| Entrada | Esquema | Por quê |
+|---|---|---|
+| Saudação ("oi", "obrigado") | B | conversa |
+| Pergunta de fato ("capital do BR?") | B | sei a resposta |
+| Resumir / traduzir / classificar texto colado | B | compreensão, sem código |
+| Listar / ler / buscar arquivos | A | precisa do disco |
+| Criar arquivo / código | A: write_file | é uma criação |
+| Contar exato / regex / cálculo | A: run_python | precisa precisão |
+| Entrada incompleta / ambígua | B perguntando | falta info |
+
+REGRA DE OURO: se sua resposta seria prosa, NÃO use tool — vai direto no `final`.
+
+## FERRAMENTAS
+| nome | args | quando |
+|---|---|---|
+{table}{bash_note}
+
+- **Editar vs criar:** pra MUDAR um arquivo existente use `edit_file` (leia antes com read_file e copie o trecho EXATO — `old_string` é o texto do arquivo SEM o número de linha). `write_file` só pra criar/refazer do zero (apaga o conteúdo).
+- **Verifique por execução:** antes de um `final` de sucesso, RODE (run_python) e confira exit_code 0. Sem ter executado, nunca diga "funcionou".
+- **Memória:** use `note` pra guardar fatos importantes — eles sobrevivem quando o histórico é compactado.
+
+## ANTI-PADRÕES (críticos)
+1. **Não anuncie ação sem fazer.** Se o thought diz "vou usar X", o MESMO JSON precisa ter `"tool"` — não pode ter `"final"`. NUNCA declare sucesso de algo que não executou neste step.
+2. **`final` é texto natural, NUNCA outro JSON.**
+3. **Não invente conteúdo que o usuário não passou.** Se a entrada está incompleta, peça.
+4. **Não cole texto longo dentro de run_python.** Salve com write_file primeiro.
+5. **Não escreva `from X import *` dentro de `X.py`.** Auto-import quebra.
+6. **Não declare "executado com sucesso" sem uma tool de execução prévia.**
+
+## EXEMPLOS
+> oi
+{{"thought":"saudação","final":"Oi! Em que posso ajudar?"}}
+> qual a capital do brasil?
+{{"thought":"fato — respondo com contexto","final":"A capital é Brasília, inaugurada em 1960, projetada por Lúcio Costa e Oscar Niemeyer."}}
+> <texto longo colado> resuma
+{{"thought":"resumir é compreensão pura, sem tool","final":"<resumo em 2-4 frases>"}}
+> liste os arquivos aqui
+{{"thought":"explorar","tool":"list_files","args":{{"path":"."}}}}
+> ache onde importa requests
+{{"thought":"buscar no código","tool":"grep","args":{{"pattern":"import requests"}}}}
+> crie um hello.py que printa hi
+{{"thought":"código simples","tool":"write_file","args":{{"path":"hello.py","content":"print('hi')\\n"}}}}
+> quantas vezes 'X' aparece no texto colado? (precisão)
+Step 1: {{"thought":"salvo o texto","tool":"write_file","args":{{"path":"input.txt","content":"<texto cru>"}}}}
+Step 2: {{"thought":"conto case-insensitive","tool":"run_python","args":{{"code":"print(open('input.txt').read().lower().count('x'))"}}}}
+
+## MULTI-STEP
+Quando o usuário pede VÁRIAS coisas, faça UMA por step e só dê `final` quando TODAS estiverem feitas, descrevendo o que foi de fato feito.
+
+## TÉRMINO
+Esquema B com fato observado (não com "vou fazer"). Após 2 erros do mesmo tipo, pare e explique no final.
+"""
+
+
+SYSTEM_PROMPT = build_system_prompt()
+
+
+# ---------- parser resiliente (cinto + suspensório, mesmo com gramatica) ----------
+
+def _fix_bad_escapes(s: str) -> str:
+    return re.sub(r'\\(?!["\\/bfnrtu])', '', s)
+
+
+def parse_action(text: str):
+    text = re.sub(r"```(?:json)?\s*", "", text).replace("```", "").strip()
+    decoder = json.JSONDecoder()
+
+    def looks_clean(obj):
+        if not isinstance(obj, dict):
+            return False
+        if "final" in obj and isinstance(obj["final"], str):
+            f = obj["final"].strip()
+            if f.startswith("{") and ('"tool"' in f or '"final"' in f):
+                return False
+        return True
+
+    thought_only = None
+    for src in (text, _fix_bad_escapes(text)):
+        n, i = len(src), 0
+        while i < n:
+            if src[i] == "{":
+                try:
+                    obj, end = decoder.raw_decode(src, i)
+                except json.JSONDecodeError:
+                    obj, end = None, None
+                if isinstance(obj, dict) and looks_clean(obj):
+                    if "tool" in obj or "final" in obj:
+                        return obj
+                    if thought_only is None and isinstance(obj.get("thought"), str) and obj["thought"].strip():
+                        thought_only = {"thought": "(promovido)", "final": obj["thought"].strip()}
+                if end is not None:
+                    i = end
+                    continue
+            i += 1
+        if _fix_bad_escapes(text) == text:
+            break
+    return thought_only
+
+
+COMPREHENSION_VERBS = ("resuma", "resumir", "traduza", "traduzir", "classifique",
+                       "classificar", "qual o tom", "explique este", "explique esse",
+                       "do que se trata", "qual é a ideia")
+
+
+def run_tool(action, user_input=""):
+    name = action.get("tool")
+    args = action.get("args", {}) or {}
+    if name not in TOOLS:
+        return {"error": f"ferramenta desconhecida: {name}. disponíveis: {TOOL_NAMES}"}
+    if name in ("write_file", "run_python", "run_bash") and user_input:
+        if any(v in user_input.lower() for v in COMPREHENSION_VERBS):
+            return {"error": f"{name} bloqueado: compreensão (resumir/traduzir/classificar) vai DIRETO no final, sem tool",
+                    "hint": "responda com {\"thought\":\"compreensão direta\",\"final\":\"<resposta em prosa>\"}."}
+    try:
+        return TOOLS[name](**args)
+    except TypeError as e:
+        return {"error": f"args inválidos para {name}: {e}"}
+    except Exception as e:
+        return {"error": f"{type(e).__name__}: {e}"}
+
+
+# ---------- compactação de contexto (cabe no ctx 8192 do GYRK) ----------
+
+CHAR_BUDGET = 16000  # ~4k tokens de input; deixa folga pros 2048 de saída no ctx 8192
+
+
+def build_request_messages(messages):
+    """Compacta o histórico pra caber no ctx, SEM mutar a lista canônica.
+    Mantém a 1ª msg (system+tarefa), injeta as notas + um resumo dos passos
+    antigos descartados, e mantém os turnos recentes que couberem (alternância
+    user/assistant preservada — exigência do template do modelo)."""
+    head, rest = messages[0], messages[1:]
+    kept, total = [], len(head["content"])
+    for m in reversed(rest):
+        if total + len(m["content"]) > CHAR_BUDGET and kept:
+            break
+        kept.append(m)
+        total += len(m["content"])
+    kept.reverse()
+    while kept and kept[0]["role"] == "user":  # após head(user), o 1º mantido deve ser assistant
+        kept.pop(0)
+    dropped = rest[:len(rest) - len(kept)]
+    extras = []
+    if _SCRATCHPAD:
+        extras.append("NOTAS (memória persistente):\n- " + "\n- ".join(_SCRATCHPAD))
+    if dropped:
+        acts = []
+        for m in dropped:
+            if m["role"] == "assistant":
+                try:
+                    a = json.loads(m["content"])
+                    if a.get("tool"):
+                        acts.append(a["tool"])
+                except Exception:
+                    pass
+        extras.append(f"[{len(dropped)} mensagens antigas compactadas. Tools já usadas: {', '.join(acts) or 'várias'}]")
+    if extras:
+        head = {"role": "user", "content": head["content"] + "\n\n" + "\n\n".join(extras)}
+    return [head] + kept
+
+
+# ---------- cliente HTTP do GYRK (a unica peca nova; provada pelo spike) ----------
+
+def gyrk_generate(messages):
+    body = json.dumps({
+        "messages": messages,
+        "temperature": TEMP, "top_p": 0.9, "seed": 7, "max_tokens": MAX_TOKENS,
+        "response_format": {"type": "json_schema",
+                            "json_schema": {"name": "action", "schema": ACTION_SCHEMA}},
+    }).encode()
+    headers = {"Content-Type": "application/json"}
+    if API_KEY:
+        headers["Authorization"] = f"Bearer {API_KEY}"
+    last = ""
+    for attempt in range(6):
+        try:
+            req = urllib.request.Request(ENDPOINT, data=body, headers=headers)
+            resp = json.loads(urllib.request.urlopen(req, timeout=180 if attempt == 0 else 90).read())
+            return resp["choices"][0]["message"]["content"], resp.get("usage", {})
+        except urllib.error.HTTPError as e:
+            last = (e.read().decode("utf-8", "ignore") if hasattr(e, "read") else str(e))[:300]
+            if "Loading model" in last or e.code in (502, 503):
+                time.sleep(min(5 * (attempt + 1), 20))
+                continue
+            if e.code == 429:  # cota/rate-limit do gateway
+                try:
+                    j = json.loads(last)
+                    msg, up = j.get("error", "limite atingido"), j.get("upgrade")
+                except Exception:
+                    msg, up = "limite atingido", None
+                raise RuntimeError(msg + (f" — pegue uma chave em {up}" if up else "") +
+                                   ".  Já tem chave? rode: gyrk init")
+            if e.code in (401, 403):
+                raise RuntimeError("chave inválida ou sem acesso.  Configure com: gyrk init")
+            raise RuntimeError(f"HTTP {e.code}: {last}")
+        except (urllib.error.URLError, TimeoutError) as e:
+            last = str(e)
+            time.sleep(min(5 * (attempt + 1), 20))
+    raise RuntimeError(f"GYRK indisponível após retries: {last}")
+
+
+# ---------- loop do agente (GYRK puro; guards param honestamente) ----------
+
+def run_task(task: str, max_steps: int = 12):
+    global _SESSION_IN, _SESSION_OUT
+    _SCRATCHPAD.clear()
+    messages = [{"role": "user", "content": SYSTEM_PROMPT + "\n\nENTRADA DO USUÁRIO: " + task}]
+    recent, consecutive_errors, parse_fails, last_ctx = [], 0, 0, 0
+
+    def add_user(text):
+        if messages and messages[-1]["role"] == "user":
+            messages[-1]["content"] += "\n\n" + text
+        else:
+            messages.append({"role": "user", "content": text})
+
+    try:
+        for step in range(1, max_steps + 1):
+            try:
+                with Spinner():
+                    raw, usage = gyrk_generate(build_request_messages(messages))
+            except RuntimeError as e:
+                print("  " + red("✗ " + str(e)))
+                return
+            _SESSION_IN += usage.get("prompt_tokens", 0)
+            _SESSION_OUT += usage.get("completion_tokens", 0)
+            last_ctx = usage.get("prompt_tokens", 0) or last_ctx
+            action = parse_action(raw)
+
+            if action is None:
+                parse_fails += 1
+                if parse_fails >= 2:
+                    print("  " + red("✗ o modelo não retornou um JSON válido."))
+                    if VERBOSE:
+                        print(dim("  " + raw[:300].replace("\n", "\n  ")))
+                    return
+                messages.append({"role": "assistant", "content": raw[:500]})
+                add_user("ERRO: responda com UM JSON: {\"thought\":...,\"tool\":...,\"args\":...} ou {\"thought\":...,\"final\":...}.")
+                continue
+
+            if VERBOSE:
+                print("  " + dim(f"step {step} · ") + mag(action.get("thought", "")))
+
+            # ----- FINAL -----
+            if "final" in action:
+                final_text = action.get("final") or ""
+                fake_words = ["foi executado com sucesso", "executei o", "rodei o", "abri o",
+                              "testado com sucesso", "funcionou perfeitamente", "executou com sucesso"]
+                if any(w in final_text.lower() for w in fake_words):
+                    had_exec = any(m["role"] == "user" and m["content"].startswith("OBSERVATION:")
+                                   and "exit_code" in m["content"] for m in messages)
+                    if not had_exec:
+                        if VERBOSE:
+                            print(dim("  [fake-final — forçando execução real]"))
+                        messages.append({"role": "assistant", "content": json.dumps(action, ensure_ascii=False)})
+                        add_user("ERRO: 'final' afirma sucesso mas nenhum run_python/run_bash rodou. Execute agora ou reescreva 'final' só com o que foi feito.")
+                        continue
+                print()
+                print(render_final(final_text))
+                return
+
+            # ----- TOOL -----
+            if "tool" in action:
+                tool = action.get("tool")
+                args = action.get("args", {}) or {}
+                sig = json.dumps({"tool": tool, "args": args}, sort_keys=True, ensure_ascii=False)
+                recent.append(sig)
+                if len(recent) >= 3 and recent[-3:] == [sig, sig, sig]:
+                    print("  " + red("✗ repetindo a mesma ação — parando. Reformule a tarefa."))
+                    return
+
+                print("  " + cyan("→ ") + bold(str(tool)) + "  " + dim(short_args(args)))
+                result = run_tool(action, user_input=task)
+                result_str = json.dumps(result, ensure_ascii=False)
+                if len(result_str) > 1500:
+                    result_str = result_str[:1500] + "...[truncado]"
+
+                is_exec = tool in ("run_python", "run_bash")
+                is_error = isinstance(result, dict) and (result.get("error") or (is_exec and result.get("exit_code", 0) != 0))
+                print("    " + (red("✗ " + summarize_result(tool, result)) if is_error
+                                else dim("✓ " + summarize_result(tool, result))))
+
+                consecutive_errors = consecutive_errors + 1 if is_error else 0
+                if consecutive_errors >= 3:
+                    print("  " + red("✗ 3 erros seguidos — parando."))
+                    return
+
+                messages.append({"role": "assistant", "content": json.dumps(action, ensure_ascii=False)})
+                obs = "OBSERVATION: " + result_str
+                if consecutive_errors == 2:
+                    obs += ("\n\n[REFLITA] 2 erros seguidos. No próximo `thought` diga: (1) a causa raiz, "
+                            "(2) por que a abordagem falhou, (3) uma abordagem DIFERENTE. Depois execute a nova "
+                            "abordagem — ou termine com {\"final\":...} explicando, se não houver saída.")
+                obs += "\n\nResponda com UM JSON: próxima ferramenta ou {\"thought\":...,\"final\":...}."
+                add_user(obs)
+
+        print("  " + yellow(f"[parou após {max_steps} passos sem concluir]"))
+    finally:
+        if last_ctx:
+            print_footer(last_ctx)
+
+
+# ---------- UI (clean & profissional) ----------
+
+def fmt_tok(n):
+    n = n or 0
+    return f"{n/1000:.1f}k" if n >= 1000 else str(int(n))
+
+
+def ctx_bar(used, total, width=12):
+    frac = min(1.0, (used or 0) / total) if total else 0.0
+    fill = int(round(frac * width))
+    return "▓" * fill + "░" * (width - fill)
+
+
+def short_args(args):
+    for k in ("path", "pattern", "command", "code", "text", "old_string"):
+        if k in args and args[k] is not None:
+            v = str(args[k]).replace("\n", " ").strip()
+            return (v[:54] + "…") if len(v) > 54 else v
+    return ""
+
+
+def summarize_result(tool, result):
+    if not isinstance(result, dict):
+        return str(result)[:60]
+    if result.get("error"):
+        return str(result["error"])[:70]
+    if "exit_code" in result:
+        out = (result.get("stdout") or "").strip().splitlines()
+        return f"exit {result['exit_code']}" + (f"  ·  {out[0][:46]}" if out else "")
+    if "items" in result:
+        n = len(result["items"])
+        return f"{n} item" + ("" if n == 1 else "s")
+    if "matches" in result:
+        n = result.get("count", len(result.get("matches", [])))
+        return f"{n} ocorrência" + ("" if n == 1 else "s")
+    if "total_lines" in result:
+        return f"{result['total_lines']} linhas (mostrando {result.get('shown', '')})"
+    if "bytes_written" in result:
+        return f"salvo · {result['bytes_written']} bytes"
+    if "replaced" in result:
+        n = result["replaced"]
+        return f"{n} troca" + ("" if n == 1 else "s")
+    if "notas" in result:
+        return "anotado"
+    return "ok"
+
+
+def render_final(text):
+    lines = (text or "").split("\n")
+    out = ["  " + green(bold("● ")) + green(lines[0])]
+    out += ["    " + green(ln) for ln in lines[1:]]
+    return "\n".join(out)
+
+
+def print_footer(ctx_used):
+    pct = int(min(100, (ctx_used or 0) / CTX * 100)) if CTX else 0
+    print()
+    print("  " + dim("─" * 46))
+    print("  " + dim("contexto ") + cyan(ctx_bar(ctx_used, CTX)) +
+          dim(f" {fmt_tok(ctx_used)}/{fmt_tok(CTX)} ({pct}%)   ·   ") +
+          dim(f"sessão {fmt_tok(_SESSION_IN)}↓ {fmt_tok(_SESSION_OUT)}↑ tokens"))
+
+
+# ---------- REPL ----------
+
+def banner():
+    print()
+    print("  " + bold(cyan("◆ GYRK")) + dim("   agente de código  ·  v" + VERSION))
+    print("  " + dim(WORKSPACE + ("   ·   shell on" if ALLOW_LOCAL else "")))
+    print()
+
+
+VERSION = "0.2.0"
+USAGE = """agent-gyrk — agente de código no terminal rodando o modelo GYRK.
+
+uso:
+  gyrk                      abre o REPL interativo (digite tarefas)
+  gyrk "sua tarefa"         roda uma tarefa e sai
+  gyrk init                 configura sua chave de API (ou: gyrk init --key=...)
+  gyrk --allow-local ...    libera run_bash (off por padrão)
+  gyrk -v | --verbose       mostra o raciocínio passo a passo (debug)
+  gyrk --help | --version
+
+env:
+  GYRK_BASE_URL   endpoint da API GYRK (default https://api.gyrk.havek.ai)
+  GYRK_API_KEY    Bearer pro gateway autenticado (Fase 3)
+  GYRK_ALLOW_LOCAL=1   mesmo que --allow-local
+  GYRK_CTX        janela de contexto (default 8192)
+"""
+
+
+def cmd_init(flags):
+    key, base = "", ""
+    for a in flags:
+        if a.startswith("--key="):
+            key = a.split("=", 1)[1].strip()
+        if a.startswith("--base-url="):
+            base = a.split("=", 1)[1].strip()
+    if not key:
+        try:
+            key = input("Cole sua chave GYRK (gyrk_live_...) [enter = free]: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return
+    cfg = _load_config()
+    if key:
+        cfg["api_key"] = key
+    if base:
+        cfg["base_url"] = base.rstrip("/")
+    os.makedirs(os.path.dirname(CONFIG_PATH), exist_ok=True)
+    with open(CONFIG_PATH, "w", encoding="utf-8") as f:
+        json.dump(cfg, f, indent=2)
+    try:
+        os.chmod(CONFIG_PATH, 0o600)
+    except Exception:
+        pass
+    print("  " + green("✓") + dim(f" config salva em {CONFIG_PATH}"))
+    print("  " + dim(f"chave: {key[:14]}…  (tier definido no servidor)" if key else "sem chave = tier free (limitado)"))
+
+
+def main():
+    flags = sys.argv[1:]
+    if "--version" in flags or "-V" in flags:
+        print(f"agent-gyrk {VERSION}")
+        return
+    if "--help" in flags or "-h" in flags:
+        print(USAGE)
+        return
+    if flags and flags[0] == "init":
+        cmd_init(flags[1:])
+        return
+    argv = [a for a in flags if not a.startswith("-")]
+    oneshot = " ".join(argv).strip()
+    banner()
+    if oneshot:
+        run_task(oneshot)
+        print()
+        return
+    print("  " + dim("digite uma tarefa  ·  'exit' pra sair") + "\n")
+    while True:
+        try:
+            task = input(bold(green("gyrk> "))).strip()
+        except (EOFError, KeyboardInterrupt):
+            print(dim("\n  tchau 👋\n"))
+            break
+        if not task:
+            continue
+        if task.lower() in ("exit", "quit", "sair", ":q"):
+            print(dim("  tchau 👋\n"))
+            break
+        try:
+            run_task(task)
+        except KeyboardInterrupt:
+            print(yellow("\n  [tarefa interrompida]"))
+        print()
+
+
+if __name__ == "__main__":
+    main()

agent_gyrk-0.2.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agent-gyrk"
+version = "0.2.0"
+description = "agent-gyrk — CLI agentic rodando o modelo GYRK"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = []  # só stdlib — nada pra compilar, instala instantâneo
+keywords = ["gyrk", "agent", "cli", "llm", "coding-agent"]
+authors = [{ name = "Havek" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Environment :: Console",
+  "Topic :: Software Development",
+]
+
+[project.urls]
+Homepage = "https://gyrk.havek.ai"
+
+[project.scripts]
+gyrk = "agent_gyrk:main"
+
+[tool.setuptools]
+py-modules = ["agent_gyrk"]

agent_gyrk-0.2.0/setup.cfg

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