0.0.7 · on pub.dev

One binary for the whole Flutter workflow.

Name: Artisan
Author: FlutterSDK

Artisan is a composable CLI framework and stdio MCP server for Flutter and Dart. Scaffolding, code generation, transactional plugin installs, hot reload, a REPL, and AI agent tool surfaces, all in one pure-Dart binary.

21 commands, auto-discovered through providers and reachable as dart run fluttersdk_artisan <command>. The same substrate powers your terminal and an agent over artisan_* MCP tools.

Documentation View on pub.dev

terminal

dart pub add fluttersdk_artisan
dart run fluttersdk_artisan list

Powered by our Sponsors

Helping us build the future of Flutter development.

Become a Sponsor arrow_forward

Why artisan?

One substrate, three audiences.

Artisan is pure Dart (SDK 3.4+). Flutter is optional, needed only when a command drives a running app. The same 21 commands serve your terminal, your scaffolding pipeline, and an AI agent over artisan_* tools.

terminal

A CLI framework

Best for

Own the running Flutter process and scaffold new code from the terminal. Commands auto-discover through providers, so adding one is a single file under lib/app/commands/, never a hand-wired registry.

dart run fluttersdk_artisan make:command

extension

A plugin system

Best for

Extend the substrate with third-party command packs. Installs are transactional: atomic writes across .artisan/plugins.json and its generated barrel, so concurrent readers never see partial state.

dart run fluttersdk_artisan plugin:install

smart_toy

An MCP server

Best for

AI agents (Claude Code, Cursor, Windsurf). One stdio JSON-RPC server exposes 10 substrate tools plus any plugin-contributed tools, so the agent drives your running app with the same commands you type by hand.

dart run fluttersdk_artisan mcp:serve

verified

Every plugin install is transactional: write to a .tmp file, then rename. A failed install leaves the registry exactly as it found it, and editors or lint daemons reading the barrel never observe a half-written state.

Most Flutter teams stitch the workflow together by hand: a shell script for codegen, a separate tool for hot reload, a third for installing helpers, and nothing at all for the AI agent that now lives in the editor. Artisan collapses all of it into one binary.

The framework itself is runtime-free. Twenty of twenty-one commands run with no Flutter binding; only tinker dials a live VM Service. That is what lets artisan ship as a pure-Dart package the consumer wrapper extends with optional Flutter context.

Because every command is just a registered provider, the surface scales the same way for everyone. A command you scaffold with make:command shows up in list, and, if it opts in, as an artisan_* tool the agent can call, no extra wiring.

What artisan ships

21 commands, one binary.

Grouped by intent: scaffolding and codegen, lifecycle over a running app, and an agent-facing MCP surface. All auto-discovered, all reachable from dart run fluttersdk_artisan.

auto_fix_high Scaffolding & codegen

Generate plugins, commands, and a fast-path CLI bundle from stubs, then keep the auto-discovery index in sync.

extension

Plugin scaffolding

make:plugin writes a full plugin skeleton with an install.yaml manifest, ready to publish and register in any consumer project.

add_box

Command scaffolding

make:command generates an ArtisanCommand subclass and rewrites the discovery barrel, so the new command appears in list immediately.

bolt

AOT fast-path CLI

make:fast-cli writes a bin/fsa wrapper and pre-compiles an AOT cache for roughly 50ms startup, no JIT warm-up on every invocation.

play_circle Lifecycle & introspection

Own the running Flutter process from spawn to stop, with state shared through ~/.artisan/state.json.

play_circle

Process ownership

start, stop, status, and logs spawn flutter run detached and record the VM Service URI for everything else to read.

bolt

Hot reload & restart

reload sends r and keeps Dart state; hot-restart sends R and drops it. No DevTools window needed.

code

tinker REPL & doctor

tinker evaluates Dart expressions against the live isolate over VM Service; doctor runs preflight checks on flutter, dart, and port availability.

smart_toy Built for AI agents

A stdio JSON-RPC MCP server that surfaces the substrate, and any plugin tools, to Claude Code, Cursor, and Windsurf.

hub

10 substrate tools

mcp:serve exposes the lifecycle and introspection commands as artisan_* tools, plus any tool a registered plugin contributes.

cable

Decoupled tool surface

MCP decouples the tool surface from the implementation. The agent calls artisan_reload; whether that maps to a keypress or a plugin command is the substrate's concern, not the agent's.

settings_input_component

Idempotent MCP install

mcp:install adds the server entry to .mcp.json without touching other servers; mcp:uninstall reverses exactly that one entry.

Drive it

From install to agent in four commands.

Add the package, scaffold a plugin, serve the MCP surface, list the registry. The agent over MCP calls the exact same commands.

dart run fluttersdk_artisan

$ dart pub add fluttersdk_artisan
+ fluttersdk_artisan 0.0.6 (resolved, 0 changes)

$ dart run fluttersdk_artisan make:plugin
[MAKE] scaffolded plugin skeleton + install.yaml manifest

$ dart run fluttersdk_artisan list
lifecycle    start  stop  status  logs  restart  reload  hot-restart
make         make:plugin  make:command  make:fast-cli
plugin       plugin:install  plugin:uninstall  plugins:refresh
mcp          mcp:serve  mcp:install  mcp:uninstall
introspect   list  help  doctor  tinker

$ dart run fluttersdk_artisan mcp:serve
[MCP ] stdio JSON-RPC server up · 10 substrate tools exposed

One substrate, two callers, identical contract

Every command you type resolves through the same provider registry the MCP server reads. There is no second source of truth, no separate scripting layer between the human and the agent.

Run dart run fluttersdk_artisan list and you see the full registry grouped by namespace. The agent sees the allowlisted slice of that same registry as artisan_* tools.

Scaffolding and installer commands stay out of the agent surface on purpose: source mutation is routed through the client's own file tools, while the substrate exposes only the safe, observable verbs.

Browse all 21 commands arrow_forward

MCP-first

10 substrate tools for AI agents.

A single stdio JSON-RPC server exposes the safe substrate verbs as artisan_* tools, plus any tool a registered plugin adds. Wire it once with mcp:install, or drop the command into .mcp.json for Cursor and Windsurf.

artisan_start lifecycle

Boots flutter run detached and records the VM Service URI to ~/.artisan/state.json.

artisan_stop lifecycle

Stops the running flutter app and clears the recorded state file.

artisan_status lifecycle

Returns JSON status for the recorded flutter app, running or not.

artisan_logs observe

Returns the captured flutter run log, optionally followed.

artisan_restart lifecycle

Stops and starts the running flutter app in one call.

artisan_reload lifecycle

Hot reloads the running app (sends r). Dart state preserved.

artisan_hot_restart lifecycle

Hot restarts the running app (sends R). Drops Dart state, keeps the process.

artisan_list introspect

Lists every registered command grouped by namespace.

artisan_doctor introspect

Runs environment preflight checks: flutter, dart, port availability.

artisan_tinker introspect

Connected REPL into the running app, evaluating Dart over VM Service.

Wire it into Claude Code in one command:

terminal

claude mcp add --transport stdio fluttersdk -- dart run fluttersdk_artisan mcp:serve

Put the whole workflow in one binary.

One install, 21 commands, one MCP server. Scaffold, generate, drive the running app, and hand an agent the same tools you use, all from pure Dart.

terminal

dart pub add fluttersdk_artisan
dart run fluttersdk_artisan list

Star on GitHub inventory_2 View on pub.dev