能力标签

🤖 Agent 🔄 工作流 🌐 翻译 🐳 Docker 💻 CLI 🔗 REST API 🧠 Claude ✨ GPT 🖥 本地 LLM

⚙️

Agent工作流

代码工作流AI

基于 TypeScript · 无代码搭建完整 AI 自动化流程

英文名：dvalincode

⭐ 9 Stars 🍴 2 Forks 💻 TypeScript 📄 MIT 🏷 AI 8.0分

8.0AI 综合评分

aiclitypescript工作流

⬇ 下载源码 ZIP ⚙️ 配置说明 📺 TG 频道

✦ AI Skill Hub 推荐

代码工作流AI 是 AI Skill Hub 本期精选Agent工作流之一。综合评分 8.0 分，整体质量较高。我们强烈推荐将其纳入你的 AI 工具库，帮助提升工作效率。

📚 深度解析

代码工作流AI 是一套完整的 AI Agent 自动化工作流方案。随着 AI 能力的不断提升，基于 Agent 的自动化工作流正在成为提升个人和团队效率的核心方式。区别于传统的 RPA 自动化（模拟鼠标键盘操作），AI Agent 工作流通过理解任务意图、动态规划执行路径，能够处理更复杂的非结构化任务。

代码工作流AI 工作流的设计遵循"最小配置，最大复用"原则：核心逻辑已经封装好，用户只需配置自己的 API Key 和业务参数即可快速上手。工作流内置错误处理和重试机制，在网络波动或 API 限速等情况下仍能稳定运行，适合作为生产环境的自动化基础设施。

在实际部署时，建议先在测试环境中运行 3-5 次，验证各个环节的输出结果符合预期，再部署到生产环境。AI Skill Hub 评分 8.0 分，是同类 Agent 工作流中的精选推荐。

📋 工具概览

代码工作流AI 是一套完整的 AI Agent 自动化工作流方案。通过可视化的节点编排，将复杂的多步骤任务拆解为清晰的自动化流程，实现全程无人值守的智能处理。支持与数百种外部服务和 API 无缝集成，适合构建数据处理管线、业务自动化和 AI 辅助决策系统。

GitHub Stars

⭐ 9

开发语言

TypeScript

支持平台

Windows / macOS / Linux

维护状态

轻量级项目，按需更新

开源协议

MIT

AI 综合评分

8.0 分

工具类型

Agent工作流

Forks

📖 中文文档

以下内容由 AI Skill Hub 根据项目信息自动整理，如需查看完整原始文档请访问底部「原始来源」。

📌 核心特色

可视化 Agent 工作流编排，无需编写复杂代码
支持多步骤自动化任务链，实现全流程无人值守
与外部 API、数据库和第三方服务无缝集成
内置错误处理与自动重试机制，保障稳定运行
提供可复用的自动化模板，快速在同类场景部署

🎯 主要使用场景

自动化日常重复性工作，将精力集中于创造性任务
构建数据采集 → 处理 → 输出的完整自动化管线
实现跨平台、跨系统的数据流转和业务协同

以下安装命令基于项目开发语言和类型自动生成，实际以官方 README 为准。

安装命令

# 方式一：npm 全局安装
npm install -g dvalincode

# 方式二：npx 直接运行（无需安装）
npx dvalincode --help

# 方式三：项目依赖安装
npm install dvalincode

# 方式四：从源码运行
git clone https://github.com/arthurpanhku/dvalincode
cd dvalincode
npm install
npm start

📋 安装步骤说明

访问 GitHub 仓库获取工作流文件
在对应平台（Dify / Flowise / Make 等）中找到「导入工作流」功能
上传工作流文件
按照提示配置必要的环境变量和 API Key
运行测试确认流程正常后投入使用

以下用法示例由 AI Skill Hub 整理，涵盖最常见的使用场景。

常用命令 / 代码示例

# 命令行使用
dvalincode --help

# 基本用法
dvalincode [options] <input>

# Node.js 代码中使用
const dvalincode = require('dvalincode');

const result = await dvalincode.run(options);
console.log(result);

以下配置示例基于典型使用场景生成，具体参数请参照官方文档调整。

配置示例

# dvalincode 配置说明
# 查看配置选项
dvalincode --config-example > config.yml

# 常见配置项
# output_dir: ./output
# log_level: info
# workers: 4

# 环境变量（覆盖配置文件）
export DVALINCODE_CONFIG="/path/to/config.yml"

📑 README 深度解析真实文档完整度 40/100 查看 GitHub 原文 →

以下内容由系统直接从 GitHub README 解析整理，保留代码块、表格与列表结构。

简介

English · <a href="README.zh-CN.md">中文</a>

A local-first coding agent: any model, safe by default, small enough to audit, open enough to embed. Three modes — Chat for questions, Cowork for plan-then-execute, Code for autonomous work.

🔑 Controllable · transparent · auditable — the coding agent your security team can actually approve.

Bring your own model — DeepSeek, OpenAI, Claude (via OpenRouter), Groq, Ollama, or any OpenAI-compatible endpoint. Switch with one click, no code changes, no lock-in.

---

🗨️ Chat mode	Read-only Q&A with one-click prompt templates — explain a codebase, find TODOs, review changes, write tests. The agent can read files and search, but never writes.
👥 Cowork mode	Plan-then-execute. The agent drafts a numbered plan, you click Proceed, and every file write asks for explicit approval — with an inline red/green diff before you say yes.
⚡ Code mode	Autonomous agent with full tool access. Run tests, type-check, build, lint — one click via the Routines panel. macOS shell calls run inside a `sandbox-exec` profile with network denied.
🛡️ Audit trail	Every run emits a tamper-evident, hash-chained JSONL log — every file read/written, every command, every approval. A Run Report renders it as Markdown; `dvalincode report verify` proves the chain is intact. Threat model →
🔒 Org policy & `trust`	A company — not the developer — bounds the agent. A `dvalin.policy.json` constrains modes, shell commands, file paths, tools, and models; a repo policy can only ever narrow the machine-level one, never widen it. Each run records the governing policy's hash. `dvalincode trust` prints the install's live security posture — active policy + hashes, audit status, runtime — so a reviewer can verify it directly. Approvability plan →
🖥️ First-class GUI	Modern web UI with code highlighting, file `@`-references, `/` slash commands, Git branch indicator, live token + cost counter, multi-profile LLM config, and a dark / light / system theme switcher.
🖥️ Terminal or web — one binary	Run it bare for an interactive terminal agent (like Claude Code — streaming, inline approvals, red/green diffs), or `dvalincode serve` to host the web GUI for browser/remote use. Both frontends drive the same agent core.
🪶 Zero-dependency binary	Single ~25MB executable per platform. No Node, no Python, no Docker.
🔐 Local-first	Sessions, config, profiles, and audit logs live in `~/.dvalincode/`. `.dvalincodeignore` blocks the agent from reading sensitive files. `AGENTS.md` in your repo becomes persistent project instructions.
💾 Portable & exportable	Export all local data (memory, sessions, config, audit) to one file and import it on another machine — your setup moves with you. Any conversation downloads as a clean Markdown transcript.

---

⭐ What's New in v0.8.0 — 🔒 Governance: controllable · transparent · auditable

🔒 Org policy — a dvalin.policy.json lets a company, not the developer, bound the agent: which modes, shell commands, file paths, tools, and models are allowed. Two layers (machine ~/.dvalincode/policy.json + repo) resolve by narrowing — a repo policy can only ever make the machine policy stricter, never widen it. With no policy file, behavior is identical to before. Enforced at a single chokepoint; every denial is an inline ⛔ Blocked by policy plus a policy_violation audit event.
🔎 dvalincode trust — prints this install's live security posture in one command — active policy + source hashes, audit status, runtime, dependencies — so a reviewer can verify what the agent may and may not do directly, instead of taking claims on trust. --json for tooling.
🧾 Policy-aware audit — every run records the hash of the governing policy (and which files contributed) in run_start, so the tamper-evident log proves which rules were in force.
📐 Approvability plan — the through-line is documented in docs/APPROVABILITY-PLAN.md: make DvalinCode trivially approvable by any company — controllable, transparent, auditable.

<details> <summary>v0.7.0 — 🧪 Desktop app (beta)</summary>

🧠 Portable memory & full data export/import — the upgraded local memory mechanism, plus every session, config, profile, and audit log, can now be bundled into a single file and restored on another machine. Migrate your whole setup in one step: dvalincode export / dvalincode import, or the Export / Import buttons in the GUI Settings panel.
📝 Download any AI interaction as Markdown — every conversation can be saved as a clean Markdown transcript (user turns, assistant replies, tool calls + results, decisions — all inline). Use the download icon on any session in the sidebar, dvalincode session md <id>, or GET /api/sessions/:id/markdown.
🖥️ Native desktop app — a real application window (not a browser tab) over the same engine: DvalinCode.app on macOS, plus Windows/Linux builds. Built with webview-bun using the OS-native webview (WKWebView / WebView2 / WebKitGTK) — no Electron, stays a small self-contained binary.
🧩 A third frontend, one core — the desktop app, terminal UI, and web GUI all drive the same shared turn-runner. The current dvalincode binary is now positioned purely as the CLI (terminal + serve).
Status: the desktop binaries are experimental / unverified — grab them from the latest pre-release and please report how the window behaves on your OS.

</details>

<details> <summary>v0.6.0 — terminal agent · <code>serve</code> · shared turn-runner</summary>

🖥️ Terminal agent — run dvalincode bare for an interactive terminal coding agent, Claude-Code-style: streaming responses, inline [y/N] write approvals with red/green diffs, /mode · /clear · /git · /plan · /compact · /undo · /help, Ctrl-C to interrupt, and a guided first-run provider setup. Defaults to read-only Chat, switchable live.
🌐 dvalincode serve — the web GUI now lives behind a command, so the same binary deploys headless on a server: dvalincode serve --host 0.0.0.0 --no-open.
🧩 One engine, two frontends — the terminal UI and web GUI both drive a shared, transport-agnostic turn-runner (src/agent/session.ts), keeping them at feature parity.

</details>

<details> <summary>v0.5.0 — security-grade audit trail · Run Report · theme switcher</summary>

- 🛡️ Security-grade audit trail — every Cowork/Code run writes a tamper-evident, hash-chained JSONL log to ~/.dvalincode/audit/ (run_start, every tool_call / file_* / shell_exec / approval, run_end). The hash chain makes any after-the-fact edit detectable. No local coding agent ships verifiable behavior logs. Format + threat model → - 📋 Run Report + dvalincode report CLI — a Markdown summary of each run (files read/changed, commands, decisions, test result), rendered as a collapsible card in the GUI and from the CLI:

  dvalincode report --last           # render the most recent run
  dvalincode report <run-id> --format json
  dvalincode report verify <run-id>  # ✓ chain intact / ✗ broken at seq N

- 🎨 Theme switcher — choose dark / light / system in Settings. system follows your OS live; the choice persists across sessions.

</details>

<details> <summary>v0.4.0 — <code>/compact</code> · <code>dvalin.json</code> team playbook · self-contained binaries</summary>

/compact — LLM-based context compaction: replaces conversation history with a structured five-section summary (Goal / Completed / Decisions / Current State / Pending). A divider in the chat thread shows the token reduction (e.g. 8,412 → 1,203 tokens −85%).
dvalin.json team playbook — commit a shared set of automation prompts to your repo. The sidebar loads them automatically and lets teammates run the same one-click routines without any manual setup. Export button converts your personal routines to dvalin.json in one click.
Self-contained binaries — single ~25 MB executable per platform; no Node, no Python, no Docker. Auto-opens your browser on launch. Built with bun --compile so the web UI is bundled alongside the server binary.

</details>

<details> <summary>v0.3.0 — Mode-aware sidebar · one-line installer · multi-profile LLM config</summary>

Mode-aware sidebar — Chat shows quick-prompt Templates, Cowork shows a Projects folder tree, Code shows custom Routines (one-click commands like "Run tests" / "Git status" / "Type check"). Add your own routines from the sidebar — they persist in localStorage.
One-line installer — curl … | bash auto-detects your OS + arch, drops the binary into ~/.dvalincode/, and patches your PATH. No package manager dependencies.
Multi-profile LLM config — save named (provider, model, API key) sets and switch in one click from the sidebar; live per-session cost counter in the topbar so you can compare providers on the fly.

</details>

---

✨ Features

Category	Feature	Notes
Modes	Chat / Cowork / Code	Each with a distinct sidebar (Templates / Projects / Routines) and tool-access policy
Code permissions	Ask Permissions / Plan Mode / Auto Mode / Bypass permissions	Verified behavior: Ask requests approval before writes/commands, Plan is read-only and does not write files, Auto runs operations automatically, Bypass runs without confirmation prompts
Workspaces	Open folder / Import Git / Add worktree	Cowork and Code can switch to a local folder, clone a Git project, or create a Git worktree from the UI
Composer	`@` file references	Type `@` for a fuzzy file search; selected files get inlined into the prompt
	`/` slash commands	`/clear` `/compact` `/git` `/plan` `/undo` `/help`
	Multiline + interrupt	<kbd>Shift</kbd>+<kbd>Enter</kbd> for newline, stop button to abort mid-stream
Tool UI	Inline diffs	`edit_file` and `write_file` results render as red/green unified diff, default folded
	Approval dialog with diff	Cowork mode shows the diff before the change is applied
	Live tool counter + token + cost	Topbar shows session totals in real time
Agent	LLM-based context compaction	`/compact` summarises into Goal / Completed / Decisions / Pending
	Persistent undo stack	`/undo [N]` reverses the last N tool calls
	Run Report	Markdown summary per run (files, commands, decisions, test result) — GUI card + `dvalincode report`
	Git awareness	Branch name in topbar; `git_status` tool; git context auto-injected into prompt
	`AGENTS.md` project memory	Per-repo persistent instructions, auto-loaded each turn
Security	Tamper-evident audit trail	Hash-chained JSONL per run in `~/.dvalincode/audit/`; `dvalincode report verify` detects edits
	macOS shell sandbox	`sandbox-exec` denies network; allows writes only inside cwd + `/tmp`
	`.dvalincodeignore`	gitignore-style exclusion; blocks `read_file` / `list_files` / `search_text`
	Per-action approval	Approve/deny each write / delete / shell call in Cowork mode
Appearance	Theme switcher	Dark / light / system, persisted; `system` follows the OS live
Providers	OpenAI-compatible endpoints	DeepSeek · OpenAI · Groq · OpenRouter · Ollama · custom
	Multi-profile config	Save and switch between named (provider, model, API key) sets
Sessions	Auto-save + restore	All sessions persisted to `~/.dvalincode/sessions/` as JSON
	LLM summary memory	Cross-session summary keeps the agent oriented after restart
Memory	Local user/project memory	Searchable facts, preferences, and decisions in `~/.dvalincode/memory/`; import from Claude/Hermes/Markdown
Data portability	Export / import all data	One bundle of memory + sessions + config + audit — `dvalincode export` / `import`, or GUI Settings → Export / Import
	Markdown transcript	Download any conversation as Markdown — sidebar download icon, `dvalincode session md <id>`, or `/api/sessions/:id/markdown`

---

🚀 Quick Install

🎬 First-time setup

Terminal (default): run dvalincode. On first launch it walks you through a one-time provider setup (pick a provider, paste your API key, choose a model) and saves it to ~/.dvalincode/config.json. Then you're at the prompt — type to chat, /mode to switch between Chat / Cowork / Code, /help for commands.

Web GUI: run dvalincode serve and:

The server starts on http://localhost:3000 and your browser opens automatically.
Click LLM Configuration in the sidebar (bottom-left).
Pick a provider, paste your API key, choose a model, hit Save.
Optional: save the current config as a named profile (e.g. fast, cheap, local-ollama) to switch quickly later.

Both share the same config and sessions in ~/.dvalincode/.

---

🏗️ Build from source

Requires Bun (curl -fsSL https://bun.sh/install | bash).

git clone https://github.com/arthurpanhku/dvalincode
cd dvalincode
npm install
npm run dev:all                 # start backend (3001) + Vite (5173)

Build release binaries for every platform:

bash scripts/build-release.sh   # → release/ with tar.gz / zip + SHA256SUMS.txt
bash scripts/build-release.sh darwin    # macOS only
bash scripts/build-release.sh windows   # Windows only

Before publishing a release:

(cd release && shasum -a 256 -c SHA256SUMS.txt)
unzip -l release/dvalincode-v*-windows-x64.zip | grep 'web/dist/index.html'
tar tzf release/dvalincode-v*-macos-arm64.tar.gz | grep 'DvalinCode.app/Contents/Resources/AppIcon.icns'

Windows smoke test: unzip dvalincode-v*-windows-x64.zip on Windows and run start.bat from the extracted folder. The server should open http://localhost:3000. If it reports an ENOENT path under B:\~BUN\root\web\dist, the compiled Bun virtual path detection has regressed; the packaged binary must resolve web/dist beside the extracted executable.

Note: Bun only allows Windows .exe icon/metadata injection when compiling on Windows. macOS/Linux cross-builds still produce a valid Windows archive, but without an embedded .exe icon.

---

❓ FAQ

<details> <summary>Does it send my code to a third party?</summary> Only what the agent sends to the LLM you configured. Sessions, configs, and profiles all live on your machine in <code>~/.dvalincode/</code>. To exclude sensitive files from the agent's view, drop a <code>.dvalincodeignore</code> in your repo root (gitignore-style patterns). </details>

<details> <summary>Can I run this without an API key?</summary> Yes — use Ollama. Pull a model (<code>ollama pull qwen2.5-coder</code>), then in the LLM Configuration modal pick the Ollama provider. No key, no internet, no per-token cost. </details>

<details> <summary>Why three modes? Can't I just use one?</summary> Each mode has different tool access and safety defaults: Chat is read-only, Cowork requires approval per write, Code is full-auto. Each also has a different sidebar (Templates / Projects / Routines) optimized for that workflow. You can switch any time — the conversation continues. </details>

<details> <summary>Is the shell tool sandboxed?</summary> On macOS, yes — every <code>shell</code> tool invocation is wrapped in <code>sandbox-exec</code> with a profile that denies network access and allows file writes only inside <code>cwd</code>, <code>/tmp</code>, and <code>/var</code>. Linux and Windows sandboxing is planned. </details>

<details> <summary>How do I see what the agent actually did — and is the log trustworthy?</summary> Every run writes a JSONL audit log to <code>~/.dvalincode/audit/run-<timestamp>-<id>.jsonl</code>. Render it with <code>dvalincode report --last</code> (or see the collapsible Run Report card in the GUI). Each record is chained to the previous one with a SHA-256 hash, so any after-the-fact edit is detectable — <code>dvalincode report verify <run-id></code> reports <code>✓ chain intact</code> or the exact position of a break. It's tamper-evident, not tamper-proof: a local attacker who can rewrite the whole file could recompute the chain. The value is forensic/accountability. See <a href="docs/AUDIT-TRAIL.md">docs/AUDIT-TRAIL.md</a> for the full threat model. </details>

<details> <summary>Will it overwrite my files without asking?</summary> Depends on the mode. Chat never writes. Cowork requires approval per file (with inline red/green diff before you click Allow). Code is full-auto — use it for trusted tasks or in a feature branch. </details>

<details> <summary>The macOS binary won't open — "unverified developer"</summary> The binary is unsigned. Run this once to clear the quarantine flag: <pre><code>xattr -dr com.apple.quarantine ~/.dvalincode</code></pre> Or right-click the binary in Finder → Open → confirm once. </details>

<details> <summary>How do I save a routine in Code mode?</summary> Switch to Code mode, click the + next to "ROUTINES" in the sidebar. Enter a name (e.g. "Deploy preview") and a prompt or slash command (e.g. "<code>/git</code>" or "Build the project and deploy to staging"). Routines persist in your browser's <code>localStorage</code>. </details>

<details> <summary>Does <code>AGENTS.md</code> get sent every turn?</summary> Yes — DvalinCode reads <code>AGENTS.md</code> from the project root before each turn and injects it under <code>=== PROJECT INSTRUCTIONS ===</code> in the system prompt. Keep it focused — it counts toward your token budget. </details>

---

🎯 aiskill88 AI 点评 A 级 2026-06-24

高质量的开源AI工作流项目，值得关注