Init Tauri App

init-tauri-app

Scaffolds a new Tauri v2 project pre-loaded with conventions proven in two production apps

(cenno, cull). Delegates version-current boilerplate to the official scaffolder, then applies

a durable convention layer and any opt-in modules the user selects.

When to use

• "Start a new Tauri app", "init a tauri project", "scaffold a tauri desktop app".

Prerequisites (verify before scaffolding)

• node + npm on PATH (node --version)
• cargo + rustc on PATH (cargo --version)
• macOS + Xcode CLT only required if the Swift-sidecar module is selected

Procedure

1. Gather inputs (AskUserQuestion)

Ask, in one batch:

• App name (kebab-case). Validate ^[a-z][a-z0-9-]*$.
• Identifier (reverse-DNS, default com.glebkalinin.<name>).
• Target directory (default ~/ai_projects/<name>). Abort if it exists and is non-empty.
• Frontend framework: react-ts | svelte-kit | vanilla-ts.
• Modules (multi-select): CLI+MCP · SQLite · Tray/Updater · Release/Preflight · Swift sidecar.
• JTBD artifact (optional): a path to a jtbd.json. If not given, the skill auto-discovers

./jtbd.json then ~/jtbd/<name>/jtbd.json. See Step 1.5.

If Swift sidecar selected but host is non-macOS or xcrun --find swift fails: warn and drop it.

1.5 Ingest JTBD (optional, additive)

• Resolve the artifact, first hit wins: explicit path → ./jtbd.json → ~/jtbd/<name>/jtbd.json.

If none found, skip this whole step (the scaffold proceeds with empty product context — no error).

• Confirm: echo the artifact's hook and ask the user to confirm before using it. On decline, skip.
• Validate: the artifact must parse and have name, hook, jtbd. If not, warn and skip

ingestion (never abort the scaffold). render-jtbd.sh exits 3 on invalid input — treat that as "skip".

• Pre-fill: if valid, default the app name to name and identifier to com.glebkalinin.<name>

(still confirm with the user in Step 1 if not already chosen).

• The artifacts are written during Step 3 (core layer) — see the JTBD block there.

2. Scaffold base

cd <parent-of-target>
npm create tauri-app@latest <name> -- --template <framework> --manager npm --yes

Then cd <target> && npm install.

Known upstream fix (current rustc + Tauri 2.11.x): a *bare* scaffold's first cargo check

can fail with error[E0119] on cookie/time (transitive cookie 0.18.1 vs time 0.3.48).

This is not a skill bug — it hits any fresh create-tauri-app. If it occurs, run once in

src-tauri/: cargo update -p time --precise 0.3.47, then re-check.

3. Apply core layer

Copy every file from assets/core/ into the project, applying the renames in the table below,

then run a baseline gate. Substitute <name> (and <identifier> where the token appears) in

AGENTS.md and README.

| asset | destination |

|---|---|

| core/AGENTS.md | AGENTS.md |

| core/CLAUDE.md | .claude/CLAUDE.md |

| core/gitignore | .gitignore (merge: append only house lines not already present; skip lines — including comment headers — that already exist) |

| core/rust-toolchain.toml | src-tauri/rust-toolchain.toml |

| core/node-version | .node-version |

| core/mcp.json | .mcp.json |

| core/capabilities/default.json | src-tauri/capabilities/default.json (overwrite) |

| core/scripts/check-versions.sh | scripts/check-versions.sh (chmod +x) |

| core/README.md | README.md |

| core/CONTRIBUTING.md | CONTRIBUTING.md |

If a JTBD artifact was confirmed in Step 1.5, also:

• Render assets/jtbd/PRODUCT.md.template → docs/PRODUCT.md via

scripts/render-jtbd.sh <artifact> assets/jtbd/PRODUCT.md.template <artifact-path>.

• Render assets/jtbd/guardrails-check.md.template → docs/internal/guardrails-check.md.
• Render assets/jtbd/agents-product-section.md.template and **insert it into AGENTS.md

immediately after the first heading** (so product context leads the file).

• Copy the artifact verbatim to project-root jtbd.json (never modify the source).
• Field→destination details: assets/jtbd/jtbd-map.md.

Create empty tracked dir docs/internal/.gitkeep and docs/.gitkeep.

Enable TS strict: ensure tsconfig.json has strict, noUnusedLocals, noUnusedParameters true.

Gate: cd src-tauri && cargo check and cd .. && npm run build. Both must pass before modules.

4. Compose selected modules

For each selected module, in this order — cli-mcp, sqlite, tray-updater, swift-sidecar,

release-preflight — open assets/modules/<m>/INSERT.md and follow it exactly: it lists files to

copy, Cargo deps to merge into src-tauri/Cargo.toml [dependencies], and insertion points in

src-tauri/src/lib.rs (tauri::generate_handler![...]) and src-tauri/src/main.rs.

After EACH module: cd src-tauri && cargo check. If it fails, fix the just-applied merge

before continuing (failures localize to the current module). For modules with a frontend/script

part, also run the relevant check named in that INSERT.md.

5. Final verification + handoff

• cd src-tauri && cargo check → must pass
• npm run build → must pass
• bash scripts/check-versions.sh → must pass
• Offer git init && git add -A && git commit -m "chore: scaffold via init-tauri-app".
• Print a summary: framework, modules applied, modules skipped (with reason), next commands

(npm run tauri dev).