DaveCode Workspace v0.1 Preview

DaveCode Workspace v0.1 Preview introduces a conversational workspace, Google/GitHub app-login support, a curated Creative library, and a Chrome/Edge app-window launcher. The existing terminal interface and engine remain available.

Install (Node.js 22.12+):

npm install -g https://github.com/DMRLZZ/DaveCode/releases/download/workspace-v0.1.0-preview.1/davecode-0.2.0.tgz

Run davecode for the terminal or davecode app for the local workspace. Provider subscriptions and usage charges are separate from DaveCode.

This is an early workspace preview using engine/package 0.2.0. It is not a native packaged desktop app. Google/GitHub login requires owner-configured OAuth clients. Antigravity CLI installation was verified, but a DaveCode adapter is still pending. Creative resources are curated references, not silently installed integrations.

Validation: lint, strict typecheck, build, 721 root tests and 75 UI tests. The packed artifact was installed successfully in an isolated temporary directory and its CLI was verified. Live provider logins were not tested.

DaveCode v0.2.0

First version validated end to end against a real (local, free) model: the autonomous runner
implemented, tested and merged a task on its own with qwen3:8b through Ollama.

Added

• davecode is a standalone npm package: @davecode/core and @davecode/server are bundled in
  and the dashboard ships inside dist/dashboard.

• Dashboard: New task and edit sheets (dependency multi-select that cannot pick the task itself or
  create a cycle), status actions (Start, Mark done, Mark failed, Reopen), Run now, confirmed delete,
  and a Routes editor (add, remove, rename, reorder targets, pin accounts, default route). Both work
  in mock mode.

• PUT /api/routes: replace the route list and default route. Persisted to the global
  config.json (other keys preserved, atomic, locked) and applied to the live engine config
  immediately (Engine.updateRouting, writeGlobalRouting).

• Task graph editing: POST /api/tasks, PATCH /api/tasks/:id and DELETE /api/tasks/:id
  through ProjectBrain (lock, validation, cycle paths in the cycle error, status
  transitions, has_dependents refusal), the task.removed event, optional write methods on
  BrainSource (501 brain_read_only without them) and ProjectBrain.createTask/removeTask.

• Targeted runs: runOnce({ taskId }) and start({ taskId }) on the autonomous runner,
  davecode run --task <id> (replacing the "can only confirm the runner's pick" check) and an
  optional { "taskId" } body on POST /api/runner/start. A task that cannot run is refused with
  task_not_found (404), task_not_runnable or task_blocked (409, naming the dependencies).

Fixed

• Client cancellations (closed connection, Esc in the TUI) no longer put the account in cooldown;
  they are recorded with the new cancelled usage status.
• The builtin executor rejects a finish without any file written (once per pass) and logs why
  a tool call failed.
• run_command accepts a whole command line such as node --test in command.
• write_file/edit_file repair double-escaped newlines sent by small models.
• /api/runner/* forwards RunnerError codes in 409 responses.

Try it for free

ollama pull qwen3:8b
davecode accounts add --provider openai-compatible --label ollama --base-url http://localhost:11434/v1 --model qwen3:8b --yes
davecode start

The davecode-0.2.0.tgz asset below is the standalone CLI: npm install -g ./davecode-0.2.0.tgz.

DaveCode v0.1.0

First release: every phase of the specification is implemented.

Added

• pnpm monorepo with core, server and cli packages, strict TypeScript, Biome and Vitest.
• Shared domain contracts, ProviderError failover classification and the typed EventBus.
• zod configuration schema with ToS-sensitive features disabled by default.
• Architecture, HTTP API and specification documents.
• Dual-brain context system: task graph DAG resolver with cycle paths and status transitions,
  ProjectBrain (STATE.md section helpers, atomic writes, lock file, task.updated events),
  GlobalBrain markdown notes, buildTaskContext with budgeted truncation and the master
  DAVECODE_SYSTEM_PROMPT.
• Provider adapters in @davecode/core: openai, openai-compatible, anthropic, gemini,
  claude-cli (per-account CLAUDE_CONFIG_DIR), codex-cli (per-account CODEX_HOME) and an
  experimental driver-injected gemini-web, all translating to the OpenAI wire format with
  uniform ProviderError mapping, plus the createProviders() registry.
• MIT license, contributing guide, code of conduct, security policy and CI.
• Layered config loader (defaults, global, project, DAVECODE_* env) with file-specific errors.
• SQLite storage (WAL, versioned migrations) with account, usage and audit repositories.
• AES-256-GCM keyring for account secrets with a per-install master key.
• Per-account sandboxes for CLI providers (CLAUDE_CONFIG_DIR, CODEX_HOME) and isolated
  Chromium profiles for experimental browser providers (playwright-core optional).
• Token estimation with js-tiktoken (o200k_base) and a chars/4 fallback.
• Sliding-window quota engine (1 m, 5 h, 24 h) and a SQLite-backed usage tracker.
• Router with quota-aware weighted balancing, backpressure, 5 h quota shift, per-account
  circuit breaker and hot failover (streams fail over only before the first chunk).
• createEngine() composition root wiring config, storage, identity, quotas and the router.
• Fastify gateway: OpenAI-compatible /v1 (JSON + SSE), the full /api surface, live
  /api/events, bearer auth, CORS for the Vite dev server and optional dashboard hosting.
• @davecode/ui web dashboard (Vite, React 19, Tailwind CSS v4): overview with live token burn
  and quota pressure, accounts (add/edit with write-only secrets, gemini-web Terms-of-Service
  gate), traffic with inline failover chains, routes, task graph DAG/board/list with the project
  brain, runner control with a live log console, settings, command palette and keyboard
  shortcuts. Dark by default with a light theme.
• Typed client for every /api endpoint plus an /api/events stream with backoff reconnects,
  and a realistic in-browser mock mode (?mock=1, VITE_DAVECODE_MOCK=1, or automatic when the
  gateway is unreachable).
• Autonomous runner (AutonomousRunner, createRunner): selects the next ready task, works on
  an isolated davecode/task-<id> branch, validates with the configured lint/typecheck/test
  commands, self-repairs up to runner.maxRepairCycles with the exact failure output, runs an
  optional judge, then commits (Conventional Commits) and merges --no-ff or opens a PR with
  gh, updating TASK_GRAPH.json and STATE.md. 24/7 mode with idle polling or runOnce();
  refuses a dirty tree; pause/stop at step boundaries with AbortSignal cancellation.
• Executors: the default builtin OpenAI tool-calling loop over the router (list_dir,
  read_file, write_file, edit_file, search, run_command, finish) with repo path
  confinement and a command allow-list, and opt-in claude-cli delegation using the account's
  sandboxed CLAUDE_CONFIG_DIR.
• Judges: none (default), TypeSafe Jev via the OpenRouter Decisions API (key from
  OPENROUTER_API_KEY / JEV_API_KEY) and llm over your own routes with a zod-validated
  verdict.
• ProjectBrainSource adapter for the gateway; pnpm dev exposes the project brain and runner.
• runner.* config: executor, pullRequests, commitBrain, commandTimeoutMs,
  idlePollMs, maxIterations, maxTaskTokens, allowedCommands and claudeCli.
• davecode CLI (commander, lazy-loaded commands): start (gateway, dashboard, project brain
  and autonomous runner, with a compact banner, live activity log and clean SIGINT/SIGTERM
  shutdown), status (live from /api/* or local state, 1m/5h/24h quota bars), accounts list|add|remove|enable|disable|login plus add-account (interactive Ink prompts with masked
  secrets or a flag form for scripts; gemini-web and multi-account rotation gated behind their
  experimental flags with the ToS warning; login runs the real claude/codex in the
  account's isolated config dir), init (brain scaffold and runner.validate detected from
  package.json), tasks list|next|add|status, config path|show|get (secrets redacted),
  doctor (environment checks with fixes) and run [--once] [--task <id>]. Global --home,
  --json, --no-color/NO_COLOR and --version.
• Chat TUI (davecode chat, or bare davecode in a terminal) built with Ink 8: streaming
  replies over SSE, multiline input, slash commands (/model, /route, /accounts, /tasks,
  /status, /clear, /help, /exit), Esc to cancel, Ctrl+C twice to exit and a status line
  with the serving account, failovers, tokens and 5 h quota; starts an in-process gateway when
  none is running.
• Live runner view for davecode run: state-machine position, current task, repair cycle
  x/max and a log tail, fed by the in-process event bus or a running gateway's /api/events.

Getting started

git clone https://github.com/DMRLZZ/DaveCode.git && cd DaveCode
pnpm install && pnpm build
node packages/cli/bin/davecode.js doctor
node packages/cli/bin/davecode.js start   # gateway + dashboard on :4040

ToS-sensitive features (gemini-web, multi-account rotation) ship disabled. See the README.