convez.ai
AgenteDesenvolvimento WebIntermediário
Juanshep1

Vcode – Agent de Codificação Terminal em Vanta

Juanshep1/vcode

Agent terminal para codificação Vanta com visão e execução live

Ver no GitHub
InicialPluginScore · de 0 a 100

Agent inspirado em Claude Code que lê, escreve, edita, executa e depura programas em Vanta (linguagem de programação) diretamente do terminal. Oferece visão computacional, streaming em tempo real, checklists de tarefas, subagents para operações complexas e integração com múltiplos provedores de API.

Instalação

$npx convez-ai Juanshep1/vcode

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 4 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Desenvolver e debugar programas Vanta interativamente no terminal
  • Processar screenshots e mockups visuais para gerar código
  • Automatizar tarefas de programação com subagents em paralelo
  • Integração com IDE nativa iOS (Vanta Pocket)

Veredito

Ferramenta madura e bem-integrada para quem trabalha com Vanta. Destaca-se por visão computacional, streaming e orquestração de subagents, mas requer instalação local e conhecimento prévio da linguagem Vanta.

README

A tradução para o português deste README ainda está na fila.

██╗   ██╗ █████╗ ███╗   ██╗████████╗ █████╗
██║   ██║██╔══██╗████╗  ██║╚══██╔══╝██╔══██╗
██║   ██║███████║██╔██╗ ██║   ██║   ███████║
╚██╗ ██╔╝██╔══██║██║╚██╗██║   ██║   ██╔══██║
 ╚████╔╝ ██║  ██║██║ ╚████║   ██║   ██║  ██║
  ╚═══╝  ╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚═╝  ╚═╝   c o d e

A Claude Code–style terminal coding agent that speaks Vanta. It reads, writes, edits, runs, and debugs .va programs for you from a chat prompt — with live diffs, a thinking spinner, themes, and your choice of model.

✨ New in v5.1

  • Vanta 5.0 fluency — the agent now knows the whole Vanta 5.0 standard library (unique, zip, flatten, merge, get(m, k, fallback), clamp, format_number, format_date / parse_date, sort(xs, "desc") and friends) and reaches for them instead of reinventing them.
  • 📱 vcode in your pocket — Vanta Pocket, the native iOS IDE for Vanta, ships vcode as a chat panel: same bring-your-own-key setup (Anthropic or OpenRouter), and it writes, runs, and fixes programs right on the phone.

✨ New in v5.0

  • 👁 Vision — drag an image into the terminal, or copy one and press Ctrl-V right in the prompt (an [image #1] tag appears), and vcode sees it: screenshots, UI mockups, error photos. The agent can also read_file any .png/.jpg itself to look at charts and assets it generated. Works on Anthropic and on vision models via OpenRouter/Ollama Cloud.
  • ⚡ Streaming — replies render live, token by token, like Claude Code (/stream toggles; falls back to blocking automatically).
  • ☑ Task checklists — on multi-step builds the agent puts up a live ☐ / ▸ / ✔ todo list and updates it as it works (/todos re-shows it).
  • ◇ Subagents — big side-quests (broad searches, analyzing many files) run in a spawned subagent that reports back, keeping your context lean.
  • ⚗ vanta_eval — the agent test-runs Vanta snippets in-place before committing them to files.
  • 🩺 /doctor — one command checks your whole Vanta toolchain (vanta · vc · vself · vanbrew), key, vision support, and terminal.
  • A fresh coat of paint — new default dusk theme (violet → gold), toolchain and git branch in the banner, a context meter above the prompt, and claude-fable-5 as the default Anthropic model.

Install

vanbrew install vcode    # or:  curl -fsSL https://raw.githubusercontent.com/Juanshep1/vcode/main/install.sh | sh
vcode                    # first run walks you through adding an API key

That's it. On first launch vcode asks you to pick a provider and paste an API key right in the terminal (saved locally to ~/.vanta-code/config.json) — no export needed. Change it anytime with /provider or /key. Prefer env vars? You can still set ANTHROPIC_API_KEY / OPENROUTER_API_KEY / OLLAMA_API_KEY and vcode will use them.

For the Run features (run_vanta / run_app) you need the vanta CLI: vanbrew install vanta. Everything else works without it.


🧩 Skills (Claude Code compatible)

Skills are reusable expertise the agent loads on demand. A skill is just a folder with a SKILL.md (YAML frontmatter name/description + markdown instructions, optionally bundling scripts). vcode reads them from:

  • ~/.vanta-code/skills/<name>/SKILL.md (and ./.vanta-code/skills/ per-project)
  • ~/.claude/skills/<name>/SKILL.md — so your existing Claude Code skills work as-is.

The agent sees each skill's name + description, and calls the use_skill tool to load a skill's full instructions when a task matches. Browse them with /skills.

⭐ My Skills — your favourites, one keystroke away. With hundreds installed, you don't want to scroll the whole list every time. In /skills, highlight a skill and press Enter to pin it to My Skills (pinned ones show a ★). Then:

  • /myskills opens a short browser of just your pinned skills — press Enter on one to load it into the conversation, so the agent applies it to your next request.
  • Your pinned skills also appear right in the / menu and are typeable directly — e.g. just type /pdf to load the pdf skill. /skills remove <name> unpins.

Pins persist to ~/.vanta-code/myskills.json.

Reference a skill right in your prompt with #skill-name — no need to load it first. Writing "make a #pdf invoice generator" inlines the pdf skill's instructions into just that message. Tab-completes (#pd→#pdf), and only expands when the name matches an installed skill, so ordinary # (issue #5, C#) is left alone.

Grab a pile in one command: /skills install clones Anthropic's official skills (pdf, docx, xlsx, pptx, frontend-design, mcp-builder, skill-creator, webapp-testing, canvas-design, brand-guidelines, …) into your skills folder. Add any other repo with /skills install owner/repo (or a full git URL). With hundreds of skills installed, vcode keeps the prompt lean (it lists names only and the agent uses find_skill to search them on demand). vcode also ships vanta-web-app and vanta-game skills, so it's an expert at building Vanta apps and games out of the box.

mkdir -p ~/.vanta-code/skills/my-skill
cat > ~/.vanta-code/skills/my-skill/SKILL.md <<'EOF'
---
name: my-skill
description: What this is for and when to use it.
---
Step-by-step instructions the agent should follow...
EOF

📱 On a phone (Android or iPhone)

vcode and Vanta are pure Python, so they run in a mobile terminal app. You'll need an API key and internet.

Android — Termux

Install Termux from F-Droid (the Play Store build is outdated). Then:

pkg update -y && pkg install -y python curl
curl -fsSL https://raw.githubusercontent.com/Juanshep1/vanbrew/main/install.sh | sh
. ~/.bashrc 2>/dev/null ; . ~/.profile 2>/dev/null
vanbrew install vcode                     # pulls vanta automatically
vcode                                     # it'll prompt you for an API key

vcode not found / "no formula named vcode"? You have an older bundled catalog — re-run the installer line above (it fetches the latest Vanbrew), or run vanbrew update first, then vanbrew install vcode.

iPhone / iPad — iSH

Install iSH from the App Store (a tiny Linux shell). Then:

apk update && apk add python3 curl ca-certificates   # ca-certificates is REQUIRED (else HTTPS fails)
curl -fsSL https://raw.githubusercontent.com/Juanshep1/vanbrew/main/install.sh | sh
. ~/.profile
vanbrew install vcode                     # pulls vanta automatically
vcode                                     # it'll prompt you for an API key

vcode not found / "no formula named vcode"? Your bundled catalog is old. Re-run the installer line above (it fetches the latest Vanbrew), or run vanbrew update first, then vanbrew install vcode. iSH ships without CA certs, so if downloads fail with a TLS/SSL error, run apk add ca-certificates.

Any terminal with Python (fallback — also works in a-Shell on iOS)

If a package manager or the installer isn't available, download the two files with Python itself and make them commands with aliases:

mkdir -p ~/bin
python3 -c "import urllib.request as u;[u.urlretrieve(a,b) for a,b in [('https://raw.githubusercontent.com/Juanshep1/vcode/main/vcode.py', __import__('os').path.expanduser('~/bin/vcode.py')),('https://raw.githubusercontent.com/Juanshep1/vanta/main/vanta.py', __import__('os').path.expanduser('~/bin/vanta.py'))]]"
echo "alias vcode='python3 ~/bin/vcode.py'" >> ~/.profile
echo "alias vanta='python3 ~/bin/vanta.py'" >> ~/.profile
. ~/.profile
export OPENROUTER_API_KEY="sk-or-..."
vcode

To keep your key, append it too: echo 'export OPENROUTER_API_KEY="sk-or-..."' >> ~/.profile.

On phones (servers + web apps work on-device): serve() is pure Python sockets, so Vanta runs a real web server right on your phone. When you ask vcode to build a visual app, it serves it and opens http://localhost:<port>/ in your phone's browser (and prints a tappable link). On Termux, pkg install termux-api lets it auto-open; otherwise just tap the printed URL. (For visual apps on a phone, prefer a serve() app over the file:// pattern — mobile browsers restrict file://.) The only desktop-only bit is the movable app window; iSH is emulated, so it's slower than Termux.

Phone-keyboard tips

The terminal UI is mobile-hardened (it survives laggy/split key input and the app being backgrounded, uses narrow-screen layout, and ASCII-safe glyphs). To reach keys a soft keyboard lacks, use your terminal's extra-keys row (Termux shows one above the keyboard; Terminus/Termius has an accessory bar) for Esc, Tab, Ctrl, and the arrow keys.

  • Permission modes: Shift+Tab cycles them — but if your keyboard can't send it, just run /mode (cycles default → auto-accept → plan), or /auto / /plan.
  • Slash commands: press / on an empty line to open a dropdown — arrow ↑/↓ to browse (your pinned skills are at the top), Enter/Tab to pick. Or just keep typing and it collapses to an inline autosuggest (command in blue, rest as faint ghost) you accept with Tab.
  • Long prompts word-wrap onto aligned continuation lines instead of scrolling off to the right.
  • @file and #skill completion work with the Tab key from the extra-keys row.

What it does

╭──────────────────────────────────────────╮
│ ✻  Welcome to Vanta Code                   │
╰──────────────────────────────────────────╯
› build a draggable tip calculator and run it

⏺ I'll write it and pop it open.
⏺ Write(tipjar.va)
  ⎿  +38 lines
⏺ Open app(tipjar.va)
  ⎿  window opened
⏺ Done — drag it by the header.
  • Speaks Vanta natively — its system prompt is a compact, accurate Vanta reference (plain-English syntax, serve/http_get/filesystem builtins, the {{ }} brace rule), so the code it writes actually runs.
  • Real tools (17) — read_file (text and images), write_file, edit_file (surgical find/replace), search (grep), glob, make_dir, move_path, delete_path, run_vanta, run_app (pops the app in a movable window), bash, use_skill/find_skill, set_todos (live checklist), vanta_eval (snippet runner), and agent (subagents). Full filesystem access; writes are frictionless, deletes/shell confirm once.
  • Live diffs — every write/edit shows a Claude-Code-style diff (+ green, - red, with line numbers).
  • Builds from scratch — ask for an app and it writes fresh .va code, makes a folder for it, runs it, and fixes its own errors.
  • Looks the part — welcome wordmark, ⏺/⎿ tool lines, a thinking spinner, markdown-rendered replies, and a bordered prompt.

Bring your own key

vcode thinks with an LLM, so it uses your API key from the environment — nothing is hard-coded or stored on a server:

Set thisProvider
ANTHROPIC_API_KEYClaude, directly
OPENROUTER_API_KEYOpenRouter (all ~337 models)
OLLAMA_API_KEYOllama Cloud (full cloud catalog)

Switch live with /provider. The /model picker fetches the provider's full live model list — just type to filter (e.g. claude, qwen).

Commands & shortcuts

/helpshow help
/provider [name]switch Anthropic / OpenRouter / Ollama
/model [n|name]pick a model (type to filter the full list)
/themescolor theme: dusk · ember · synthwave · matrix · ice · gold · mono
Ctrl-Vpaste an image from the clipboard into the chat (text pastes too)
/pastesame as Ctrl-V, as a command
/doctorhealth-check the Vanta toolchain, key, vision, terminal
/streamtoggle live streaming output
/todosre-show the agent's current checklist
/initscan the project and write a VANTA.md (auto-loaded next time)
/skillsbrowse skills; Enter pins one to My Skills (★)
/myskillsyour pinned skills; Enter loads one to use (also: /<skill-name>)
/resumereload your last session (or start with vcode --continue)
/compactsummarize the conversation (also automatic)
/auto, /cwd, /clear, /exit…
Escinterrupt the agent mid-task
!commandrun a shell command directly
@pathinline a file's contents into your message
#skill-namereference a Skill inline in your prompt (e.g. make a #pdf invoice)
"""start a multi-line message (end with """)
↑ / ↓recall previous prompts

Themes

Seven gradient themes, set with /themes and remembered across sessions:

dusk (default) · ember · synthwave · matrix · ice · gold · mono

Honest scope

A single self-contained Python file, standard library only. It's a clean, line-based REPL styled to look like Claude Code — banner, tool rendering, spinner, diffs, streamed replies, vision input — not a full raw-mode TUI. It runs Vanta programs to verify them and pops visual/web apps in a movable window. Images attach via dragged-in paths, Ctrl-V, or /paste (the terminal provides drag-and-drop as a pasted path; vcode detects and reads the file, and Ctrl-V reads the clipboard through pbpaste/osascript/xclip).

Requirements

  • Python 3 (no third-party packages)
  • An API key (above)
  • Optional: the vanta CLI for running programs; Chrome for the movable app windows.

License

MIT — see LICENSE.

Ver o original no GitHub

Bom para

Relacionados