File size: 7,656 Bytes
697ae7c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | # openTARS — nucleo/visual.py
# Aparência do terminal novo da 5.3 (F8): um híbrido do CLI do Claude Code (● passo, ⎿ resultado, resposta formatada, aviso
# de contexto) com o do opencode (régua com o modo da conversa e barra de estado com pasta e ramo). Só desenho: nada aqui
# decide o que a IA faz. Parte do núcleo: roda dentro do namespace do tars.py, como as outras (ver _carregar_nucleo).
# flake8: noqa
import re as _re
import shutil as _shutil
def _largura_do_terminal(maximo=100):
return max(40, min(maximo, _shutil.get_terminal_size((80, 20)).columns))
def _tempo_curto(segundos):
"""12 -> "12s"; 65 -> "1m 05s"."""
segundos = int(segundos)
return f"{segundos}s" if segundos < 60 else f"{segundos // 60}m {segundos % 60:02d}s"
def _nome_do_motor():
""""llama.cpp" se o app fala com o motor próprio (porta 11435); senão "Ollama"."""
try:
import tars_motor_local
if str(OLLAMA_HOST).rstrip("/") == tars_motor_local.URL:
return "llama.cpp"
except Exception: # noqa: BLE001
pass
return "Ollama"
def _pasta_curta():
"""A pasta atual, com ~ no lugar da pasta pessoal."""
try:
pasta = os.path.realpath(os.getcwd()) # realpath dos dois lados: no macOS /var é /private/var e o ~ não casava
except OSError: # a pasta atual foi apagada: o enfeite não derruba o chat
return ""
casa = os.path.realpath(os.path.expanduser("~"))
if pasta == casa or pasta.startswith(casa + os.sep):
pasta = "~" + pasta[len(casa):]
return pasta if len(pasta) <= 40 else "…" + pasta[-39:]
def _ramo_git():
"""O ramo do git da pasta atual, ou "" (sem git, fora de repositório, ou demorou)."""
try:
r = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], capture_output=True, text=True, timeout=1.0,
cwd=os.getcwd(), env=_env_filho() if "_env_filho" in globals() else None)
return r.stdout.strip() if r.returncode == 0 else ""
except Exception: # noqa: BLE001 (sem git, ou um teste que troca o subprocess: o enfeite nunca derruba o chat)
return ""
def _regua(modo):
"""A linha que separa um pedido do outro, com o modo da conversa à direita (como a barra do opencode)."""
rotulo = " " + t(f"cli.regua.{modo}") + " "
largura = _largura_do_terminal()
return c("─" * max(4, largura - len(rotulo) - 2), Cor.CINZA) + c(rotulo, Cor.CINZA) + c("──", Cor.CINZA)
def _partes_do_status():
"""Modelo, contexto usado, pasta com o ramo, modo (quando não é o padrão) e AGENTS.md: a mesma conta da linha de status."""
modelo = modelo_atual or (modelo_manual if modo_modelo == "MANUAL" else "auto")
usados = estimar_tokens(conversa)
partes = [str(modelo).split("/")[-1], t("cli.status_contexto", pct=min(100, int(100 * usados / max(1, contexto_ia()))))]
ramo = _ramo_git()
partes.append(_pasta_curta() + (f" ⎇ {ramo}" if ramo else ""))
if MODO_PERMISSAO != "perguntar":
partes.append(t(f"cli.status_modo.{MODO_PERMISSAO}"))
if CONTEXTO_PROJETO["caminho"]:
partes.append("AGENTS.md")
return partes
_SELO = "\033[1;38;5;16;48;5;78m" # preto em negrito sobre verde (256 cores): o selo do openTARS na barra (como o do modo no opencode)
def _barra_de_estado(largura):
"""A barra do opencode embaixo da caixa: selo "openTARS", modelo · motor · contexto · pasta ⎇ ramo, e a dica à direita."""
partes = _partes_do_status()
partes.insert(1, _nome_do_motor())
esquerda = " openTARS "
meio = " " + " · ".join(partes)
dica = t("cli.barra_dica")
sobra = largura - len(esquerda) - len(meio) - len(dica) - 1
if sobra < 1:
meio, sobra = meio[:max(0, largura - len(esquerda) - 2)], 0
dica = ""
return _SELO + esquerda + Cor.RESET + c(meio, Cor.CINZA) + " " * sobra + c(dica, Cor.CINZA)
def _pedir_na_caixa(ini, fim):
"""Claude Code: o pedido é digitado dentro de uma caixa de cantos redondos, com a barra de estado logo abaixo. A caixa e a
barra são desenhadas antes e o cursor sobe para dentro; depois do Enter a linha ganha a borda da direita e o cursor desce
além da barra. Só num terminal de verdade com readline (as marcas \\001 e \\002 mantêm a edição da linha certa)."""
largura = _largura_do_terminal() - 1
borda = lambda s: c(s, Cor.CINZA)
sys.stdout.write("\n" + borda("╭" + "─" * (largura - 2) + "╮") + "\n" + borda("│") + " " * (largura - 2) + borda("│") + "\n"
+ borda("╰" + "─" * (largura - 2) + "╯") + "\n" + _barra_de_estado(largura) + "\033[2A\r")
sys.stdout.flush()
try:
linha = input(ini + Cor.CINZA + fim + "│ " + ini + Cor.NEGRITO + Cor.VERDE + fim + "❯ " + ini + Cor.RESET + fim)
except BaseException:
sys.stdout.write("\r\n\033[J") # Ctrl+C ou Ctrl+D: some a caixa de baixo e a barra, a mensagem sai limpa
sys.stdout.flush()
raise
visivel = "│ ❯ " + linha
if len(visivel) <= largura - 2: # coube numa linha: fecha a borda da direita e pula a borda de baixo e a barra
sys.stdout.write("\033[1A\r" + borda("│") + " " + c("❯ ", Cor.NEGRITO + Cor.VERDE) + linha
+ " " * (largura - 1 - len(visivel)) + borda("│") + "\n\033[1B\n")
else: # quebrou em várias linhas: a caixa já se desfez; só limpa o que sobrou embaixo
sys.stdout.write("\033[J")
sys.stdout.flush()
return linha
class _MarkdownTerminal:
"""Formata a resposta, que chega aos pedaços, linha por linha: títulos em negrito, listas com •, **negrito**, `código` em
ciano e blocos de código com uma barra. Só vale num terminal de verdade (a janela e os pipes recebem o texto puro)."""
def __init__(self):
self.buf = ""
self.em_codigo = False
def reiniciar(self):
self.buf, self.em_codigo = "", False
def alimentar(self, texto):
"""Devolve o que já pode ser impresso (as linhas completas); o resto espera a próxima quebra de linha."""
self.buf += texto
if "\n" not in self.buf:
return ""
*linhas, self.buf = self.buf.split("\n")
return "".join(self._linha(l) + "\n" for l in linhas)
def terminar(self):
resto, self.buf = self.buf, ""
saida = self._linha(resto) if resto else ""
self.em_codigo = False
return saida
@staticmethod
def _inline(linha):
linha = _re.sub(r"\*\*(.+?)\*\*", lambda m: Cor.NEGRITO + m.group(1) + Cor.RESET, linha)
return _re.sub(r"`([^`\n]+)`", lambda m: Cor.CIANO + m.group(1) + Cor.RESET, linha)
def _linha(self, linha):
if linha.lstrip().startswith("```"):
self.em_codigo = not self.em_codigo
rotulo = linha.strip().strip("`").strip()
return c("╭─ " + rotulo if self.em_codigo and rotulo else "╭─" if self.em_codigo else "╰─", Cor.CINZA)
if self.em_codigo:
return c("│ ", Cor.CINZA) + linha
m = _re.match(r"^(#{1,6})\s+(.*)$", linha)
if m:
return Cor.NEGRITO + (Cor.CIANO if len(m.group(1)) == 1 else "") + self._inline(m.group(2)) + Cor.RESET
m = _re.match(r"^(\s*)[-*]\s+(.*)$", linha)
if m:
return m.group(1) + c("•", Cor.CINZA) + " " + self._inline(m.group(2))
if linha.startswith("> "):
return c("│ ", Cor.CINZA) + c(self._inline(linha[2:]), Cor.ITALICO)
return self._inline(linha)
_MD = _MarkdownTerminal()
|