glebis/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)

1. 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).
2. Confirm: echo the artifact's hook and ask the user to confirm before using it. On decline, skip.
3. 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".
4. 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).
5. 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).