worclaude 1.0.0 → 1.2.0

package/README.md

@@ -1,278 +1,81 @@
-# worclaude
+# Worclaude
 
-A CLI tool that scaffolds a comprehensive Claude Code workflow into any project — derived from 53 tips by Boris Cherny, the creator of Claude Code at Anthropic.
+> One command. 53 best practices. Your Claude Code environment, production-ready.
 
 [![npm version](https://img.shields.io/npm/v/worclaude.svg)](https://www.npmjs.com/package/worclaude)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![license](https://img.shields.io/npm/l/worclaude.svg)](LICENSE)
+[![tests](https://img.shields.io/badge/tests-135%2B%20passing-brightgreen)]()
 
-## Quick Start
-
-```bash
-npm install -g worclaude
-cd your-project
-worclaude init
-```
-
-That's it. The `init` command walks you through project setup interactively.
-
-## What It Does
-
-Claude Code is powerful out of the box, but it gets dramatically better with structured guidance. `worclaude` installs a complete workflow system — agents, slash commands, skills, hooks, and configuration — that turns Claude Code into a disciplined engineering partner. It's the difference between a capable assistant and a well-organized team.
-
-The workflow is based on [53 tips by Boris Cherny](https://www.howborisusesclaudecode.com/), the creator of Claude Code at Anthropic, distilled into a reusable scaffold that works with any tech stack.
-
-## What Gets Installed
-
-```
-your-project/
-├── CLAUDE.md                        # Project-specific guidance for Claude
-├── .claude/
-│   ├── settings.json                # Permissions, hooks, sandbox config
-│   ├── workflow-meta.json           # Version tracking and file hashes
-│   ├── agents/
-│   │   ├── universal/               # 5 always-installed agents
-│   │   └── optional/                # Selected agents by category
-│   ├── commands/                    # 10 slash commands
-│   └── skills/
-│       ├── universal/               # 9 knowledge files
-│       └── templates/               # 3 project-specific placeholders
-├── .mcp.json                        # MCP server configuration
-└── docs/spec/
-    ├── PROGRESS.md                  # Session-to-session tracking
-    └── SPEC.md                      # Project specification template
-```
-
-- **CLAUDE.md** — Lean (<50 lines) project config that Claude reads every session. Points to skills for deeper guidance.
-- **Agents** — Autonomous specialist workers that run in isolation (worktrees) for focused tasks.
-- **Commands** — Slash commands (`/start`, `/end`, `/verify`, etc.) for common workflows.
-- **Skills** — Knowledge files Claude loads on demand — testing philosophy, git conventions, context management, and more.
-- **Settings** — Permissions, hooks, and sandbox configuration tuned for your tech stack.
-
-## Commands
-
-| Command | Purpose |
-|---|---|
-| `worclaude init` | Set up workflow in a new or existing project |
-| `worclaude upgrade` | Update workflow to latest version |
-| `worclaude status` | Show current installation status |
-| `worclaude backup` | Create a backup of Claude setup |
-| `worclaude restore` | Restore from a backup |
-| `worclaude diff` | Compare current setup vs installed version |
-
-## Three Scenarios
-
-`init` detects your project state and adapts:
-
-### 1. Fresh project — full interactive scaffold
-
-No existing `.claude/` directory or `CLAUDE.md`. You get the full setup flow: choose project type, tech stack, languages, and optional agents. Everything is scaffolded from scratch.
-
-### 2. Existing project — smart merge
-
-You already have a `CLAUDE.md` or `.claude/` directory. The tool creates a timestamped backup, then merges intelligently:
-
-- **Missing files** (agents, commands, skills) are added directly
-- **Conflicting files** are saved as `.workflow-ref.md` alongside yours
-- **CLAUDE.md** is analyzed for missing sections — merge interactively or save suggestions to a separate file
-- **Hooks and permissions** offer keep/replace/chain options for conflicts
-
-### 3. Upgrade — update to latest version
-
-You already have `workflow-meta.json` from a previous install. The tool compares file hashes to detect what changed, auto-updates unmodified files, and prompts for files you've customized.
-
-## Agents
-
-### Universal Agents (always installed)
-
-| Agent | Purpose |
-|---|---|
-| plan-reviewer | Reviews plans for ambiguity, missing verification, and scope |
-| code-simplifier | Finds duplication, simplifies complexity, ensures consistency |
-| test-writer | Writes comprehensive unit, integration, and edge case tests |
-| build-validator | Validates build, tests, linting, and type checking |
-| verify-app | Tests actual running application behavior end-to-end |
-
-### Optional Agent Catalog
-
-During `init`, you choose from 18 optional agents across 6 categories. The tool pre-selects categories based on your project type:
-
-| Project Type | Recommended Categories |
-|---|---|
-| Full-stack web | Frontend, Backend, Quality, Documentation |
-| Backend / API | Backend, Quality |
-| Frontend / UI | Frontend, Quality |
-| CLI tool | Quality, Documentation |
-| Data / ML / AI | Data/AI, Backend |
-| Library / Package | Documentation, Quality |
-| DevOps / Infrastructure | DevOps |
-
-**Available categories:**
-
-| Category | Agents |
-|---|---|
-| Frontend | ui-reviewer, style-enforcer |
-| Backend | api-designer, database-analyst, auth-auditor |
-| DevOps | dependency-manager, ci-fixer, docker-helper, deploy-validator |
-| Quality | bug-fixer, security-reviewer, performance-auditor, refactorer |
-| Documentation | doc-writer, changelog-generator |
-| Data / AI | data-pipeline-reviewer, ml-experiment-tracker, prompt-engineer |
-
-After selecting categories, you can fine-tune by adding or removing individual agents.
-
-## Slash Commands
+<!-- GIF goes here once recorded -->
+<!-- ![worclaude init demo](docs/public/demo.gif) -->
 
-All 10 commands are installed in every project:
+[Full Documentation](https://sefaertunc.github.io/Worclaude/) · [Interactive Demo](https://sefaertunc.github.io/Worclaude/demo/) · [npm](https://www.npmjs.com/package/worclaude)
 
-| Command | Purpose |
-|---|---|
-| `/start` | Read PROGRESS.md, report current state and what's next |
-| `/end` | Update PROGRESS.md with session work, blockers, next steps |
-| `/commit-push-pr` | Stage, commit, push, and create PR with description |
-| `/review-plan` | Send implementation plan to plan-reviewer agent |
-| `/techdebt` | Scan for duplicated code, dead code, TODOs, complexity |
-| `/verify` | Run full verification: tests, build, lint, type checks |
-| `/compact-safe` | Compress context; PostCompact hook re-reads key files |
-| `/status` | Report current task, branch, test status, context usage |
-| `/update-claude-md` | Propose CLAUDE.md updates based on session learnings |
-| `/setup` | **Post-install interview** — fills in all project-specific content |
+Worclaude scaffolds a complete Claude Code workflow into any project in seconds. It implements all [53 tips by Boris Cherny](https://www.howborisusesclaudecode.com/) — the creator of Claude Code at Anthropic — as a reusable, upgradable scaffold. One `init` command gives you 23 agents, 10 slash commands, 12 skills, hooks, permissions, and a CLAUDE.md template tuned for your tech stack. Whether you're starting fresh or adding structure to an existing project, Worclaude handles the setup so you can focus on building.
 
-`/setup` is the key post-install action. After running `worclaude init`, open Claude Code and run `/setup`. It interviews you about your project and fills in CLAUDE.md, skills, SPEC.md, and configuration files with real content.
+---
 
-## Skills
+## What You Get
 
-Skills are knowledge files that Claude loads on demand. They keep CLAUDE.md lean while providing deep guidance when needed.
+`worclaude init` installs a production-ready Claude Code workflow:
 
-### Universal Skills (9)
+**Agents (23 total)**
+- 5 universal: plan-reviewer, code-simplifier, test-writer, build-validator, verify-app
+- 18 optional across 6 categories: Backend, Frontend, DevOps, Quality, Documentation, Data/AI
 
-| Skill | What it teaches |
-|---|---|
-| context-management | Context budget, compaction timing, subagent offloading |
-| git-conventions | Branch naming, commits, PR workflow, worktrees |
-| planning-with-files | Implementation plan structure and review process |
-| review-and-handoff | Session endings, handoff format, progress tracking |
-| prompt-engineering | Effective prompting patterns for Claude |
-| verification | Domain-specific verification beyond running tests |
-| testing | Test philosophy, coverage strategy, test structure |
-| claude-md-maintenance | Writing and maintaining rules in CLAUDE.md |
-| subagent-usage | When and how to delegate work to subagents |
+**Slash Commands (10)**
+`/start` `/end` `/commit-push-pr` `/review-plan` `/techdebt` `/verify` `/compact-safe` `/status` `/update-claude-md` `/setup`
 
-### Template Skills (3)
+**Skills (12)**
+- 9 universal knowledge files (testing, git conventions, context management, and more)
+- 3 project-specific templates filled in by `/setup`
 
-These are project-specific placeholders filled in by `/setup`:
+**Hooks**
+- PostToolUse formatter (auto-formats on every write)
+- PostCompact re-injection (re-reads key files after compaction)
+- Stop notifications (desktop alert when Claude finishes)
 
-- **backend-conventions** — Stack-specific backend patterns and conventions
-- **frontend-design-system** — Design system, components, styling approach
-- **project-patterns** — Architectural patterns specific to your codebase
+**Configuration**
+- Pre-configured permissions per tech stack (Node.js, Python, Go, Rust, and more)
+- CLAUDE.md template with progressive disclosure
+- Sandbox, effort, and output defaults ready out of the box
 
-## The Pipeline
+---
 
-The workflow follows a 6-stage pipeline for every significant task:
-
-```
-Design → Review → Execute → Quality → Verify → PR
-```
-
-1. **Design** — Write an implementation plan in a plan file
-2. **Review** — Send plan to `plan-reviewer` agent for critical review
-3. **Execute** — Implement the plan, one step at a time
-4. **Quality** — Run `code-simplifier`, `test-writer` agents
-5. **Verify** — Run `build-validator`, `verify-app` agents, then `/verify`
-6. **PR** — Use `/commit-push-pr` to stage, commit, push, and create a pull request
-
-## Configuration
-
-### Permissions
-
-Settings include allow-lists for common tools, tuned per tech stack:
-
-```json
-{
-  "permissions": {
-    "allow": [
-      "Read(*)", "Glob(*)", "Grep(*)",
-      "Bash(git *)", "Bash(npm test)", "Bash(npx prettier *)"
-    ]
-  }
-}
-```
-
-### Hooks
-
-Three universal hooks are installed:
-
-1. **Format on write** — Auto-formats files after every Write/Edit (prettier, ruff, cargo fmt, gofmt — based on your stack)
-2. **Notification on stop** — Desktop notification when Claude finishes a long task (Linux, macOS, Windows)
-3. **PostCompact re-inject** — Automatically re-reads CLAUDE.md and PROGRESS.md after context compaction
-
-### Sandbox
-
-Default: `auto-allow` mode. Safety comes from structural isolation (worktrees, focused agents) rather than restrictive permissions.
-
-### Effort & Output
-
-- **Effort:** `high` by default, escalate to `max` per session for complex tasks
-- **Output:** `concise` by default, switch to `explanatory` when exploring unfamiliar territory
-
-## After Install — `/setup`
-
-After running `worclaude init`, start Claude Code in your project and run:
+## Quick Start
 
+```bash
+npm install -g worclaude
+cd your-project
+worclaude init
 ```
-/setup
-```
-
-This launches an interactive interview that:
-- Asks about your project's purpose, architecture, and conventions
-- Fills in CLAUDE.md with real project context
-- Populates SPEC.md with your actual tech stack and requirements
-- Configures template skills with your specific patterns
-- Sets up PROGRESS.md with your current state
-
-This is the single most important step after installation. The scaffold provides structure; `/setup` fills it with your project's substance.
-
-## Customization
-
-### Adding custom agents
-
-Create a `.md` file in `.claude/agents/` with a task description and instructions. Agents run autonomously — give them clear scope, success criteria, and verification steps.
 
-### Adding custom commands
+Follow the interactive prompts to select your project type, tech stack, and agents. Then open Claude Code and run `/setup` to fill in your project-specific content.
 
-Create a `.md` file in `.claude/commands/`. Commands are invoked as `/command-name` in Claude Code. Keep them focused on a single workflow.
+For parallel tasks, run Claude with worktrees: `claude --worktree --tmux`
 
-### Adding custom skills
+---
 
-Create a `.md` file in `.claude/skills/`. Skills are loaded on demand when Claude needs domain knowledge. Reference them from CLAUDE.md with `See .claude/skills/your-skill.md`.
-
-### Settings
-
-`settings.json` controls permissions, hooks, and sandbox. Edit directly or use `worclaude upgrade` to merge in new defaults while preserving your customizations.
-
-### CLAUDE.md
-
-CLAUDE.md grows naturally during development. Use `/update-claude-md` to propose additions based on patterns and gotchas discovered during sessions. Keep it under 50 lines — move detailed guidance to skills.
-
-## Philosophy
-
-Six principles guide the workflow design:
-
-1. **Be a dispatcher, not an operator** — Use agents for focused tasks. The main session coordinates; specialists execute.
-2. **Compounding improvement** — CLAUDE.md, skills, and PROGRESS.md accumulate project knowledge over time. Every session makes the next one better.
-3. **Verification multiplies quality** — Tests alone aren't enough. Verify the running application, review plans before executing, validate builds after changes.
-4. **Reduce friction, maintain safety** — Auto-allow sandbox, permissive tool access, auto-formatting. Safety comes from structure (worktrees, focused agents), not restrictions.
-5. **Progressive disclosure** — CLAUDE.md is lean. Skills load on demand. Agents activate when needed. Complexity is available but not imposed.
-6. **Plan before you build** — Write implementation plans in files. Review them with `plan-reviewer`. Execute step by step. This prevents wasted work and catches issues early.
-
-## Why?
+## Commands
 
-Boris Cherny published [53 tips for using Claude Code effectively](https://www.howborisusesclaudecode.com/). They cover everything from CLAUDE.md structure to agent design to session management. The tips are excellent — but implementing them manually in every project is tedious and error-prone.
+| Command | Description |
+|---------|-------------|
+| `worclaude init` | Scaffold workflow into new or existing project |
+| `worclaude upgrade` | Update universal components to latest version |
+| `worclaude status` | Show current workflow state and version |
+| `worclaude backup` | Create timestamped backup of workflow files |
+| `worclaude restore` | Restore from a previous backup |
+| `worclaude diff` | Compare current setup vs latest version |
 
-`worclaude` packages all 53 tips into a single `init` command. You get the full workflow in seconds, customized for your tech stack, with upgrade support to pick up improvements over time.
+The `init` command detects existing setups and merges intelligently — no data is overwritten without your confirmation. Use `upgrade` to pull in new features while preserving your customizations.
 
-## Credits
+See the [full command reference](https://sefaertunc.github.io/Worclaude/reference/commands) for detailed usage and options.
 
-This project is derived from the [53 tips by Boris Cherny](https://www.howborisusesclaudecode.com/), the creator of Claude Code at Anthropic. The tips were analyzed, systematized, and packaged into a reusable CLI tool.
+---
 
-## License
+## Links
 
-MIT
+- [Full Documentation](https://sefaertunc.github.io/Worclaude/)
+- [Interactive Demo](https://sefaertunc.github.io/Worclaude/demo/)
+- [Contributing](CONTRIBUTING.md)
+- [License: MIT](LICENSE)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worclaude",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "CLI tool that scaffolds a comprehensive Claude Code workflow into any project",
   "type": "module",
   "bin": {
@@ -31,6 +31,9 @@
     "test:coverage": "vitest run --coverage",
     "lint": "eslint src/ tests/",
     "format": "prettier --write .",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
     "prepublishOnly": "npm test && npm run lint"
   },
   "keywords": [
@@ -57,6 +60,7 @@
   "devDependencies": {
     "eslint": "^9.22.0",
     "prettier": "^3.5.3",
+    "vitepress": "^1.6.4",
     "vitest": "^3.0.9"
   }
 }

package/src/commands/init.js

@@ -45,12 +45,26 @@ function buildCommandsBlock(languages, useDocker) {
     lines.push('npx eslint .                    # Lint');
     lines.push('npx prettier --write .          # Format');
   }
-  if (languages.includes('rust')) {
+  if (languages.includes('java')) {
     if (lines.length > 1) lines.push('');
-    lines.push('# Rust');
-    lines.push('cargo test                      # Run tests');
-    lines.push('cargo clippy                    # Lint');
-    lines.push('cargo fmt                       # Format');
+    lines.push('# Java');
+    lines.push('mvn test                        # Run tests');
+    lines.push('mvn checkstyle:check            # Lint');
+    lines.push('mvn spotless:apply              # Format');
+  }
+  if (languages.includes('csharp')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# C# / .NET');
+    lines.push('dotnet test                     # Run tests');
+    lines.push('dotnet format --verify-no-changes # Lint');
+    lines.push('dotnet format                   # Format');
+  }
+  if (languages.includes('cpp')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# C / C++');
+    lines.push('cmake --build build && ctest    # Build & test');
+    lines.push('clang-tidy src/*.cpp            # Lint');
+    lines.push('clang-format -i src/*.[ch]pp    # Format');
   }
   if (languages.includes('go')) {
     if (lines.length > 1) lines.push('');
@@ -59,6 +73,69 @@ function buildCommandsBlock(languages, useDocker) {
     lines.push('golangci-lint run               # Lint');
     lines.push('gofmt -w .                      # Format');
   }
+  if (languages.includes('php')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# PHP');
+    lines.push('vendor/bin/phpunit              # Run tests');
+    lines.push('vendor/bin/phpstan analyse      # Lint');
+    lines.push('vendor/bin/php-cs-fixer fix .   # Format');
+  }
+  if (languages.includes('ruby')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# Ruby');
+    lines.push('bundle exec rspec               # Run tests');
+    lines.push('rubocop                         # Lint');
+    lines.push('rubocop -A                      # Format');
+  }
+  if (languages.includes('kotlin')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# Kotlin');
+    lines.push('gradle test                     # Run tests');
+    lines.push('detekt                          # Lint');
+    lines.push('ktlint -F                       # Format');
+  }
+  if (languages.includes('swift')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# Swift');
+    lines.push('swift test                      # Run tests');
+    lines.push('swiftlint                       # Lint');
+    lines.push('swift-format format -r . -i     # Format');
+  }
+  if (languages.includes('rust')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# Rust');
+    lines.push('cargo test                      # Run tests');
+    lines.push('cargo clippy                    # Lint');
+    lines.push('cargo fmt                       # Format');
+  }
+  if (languages.includes('dart')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# Dart / Flutter');
+    lines.push('dart test                       # Run tests');
+    lines.push('dart analyze                    # Lint');
+    lines.push('dart format .                   # Format');
+  }
+  if (languages.includes('scala')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# Scala');
+    lines.push('sbt test                        # Run tests');
+    lines.push('sbt scalafix                    # Lint');
+    lines.push('scalafmt                        # Format');
+  }
+  if (languages.includes('elixir')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# Elixir');
+    lines.push('mix test                        # Run tests');
+    lines.push('mix credo                       # Lint');
+    lines.push('mix format                      # Format');
+  }
+  if (languages.includes('zig')) {
+    if (lines.length > 1) lines.push('');
+    lines.push('# Zig');
+    lines.push('zig build test                  # Run tests');
+    lines.push('zig build                       # Build (lint via compiler)');
+    lines.push('zig fmt .                       # Format');
+  }
   if (useDocker) {
     if (lines.length > 1) lines.push('');
     lines.push('# Docker');

package/src/data/agents.js

@@ -81,16 +81,38 @@ export const PROJECT_TYPES = [
 export const TECH_STACKS = [
   { name: 'Python', value: 'python' },
   { name: 'Node.js / TypeScript', value: 'node' },
-  { name: 'Rust', value: 'rust' },
+  { name: 'Java', value: 'java' },
+  { name: 'C# / .NET', value: 'csharp' },
+  { name: 'C / C++', value: 'cpp' },
   { name: 'Go', value: 'go' },
+  { name: 'PHP', value: 'php' },
+  { name: 'Ruby', value: 'ruby' },
+  { name: 'Kotlin', value: 'kotlin' },
+  { name: 'Swift', value: 'swift' },
+  { name: 'Rust', value: 'rust' },
+  { name: 'Dart / Flutter', value: 'dart' },
+  { name: 'Scala', value: 'scala' },
+  { name: 'Elixir', value: 'elixir' },
+  { name: 'Zig', value: 'zig' },
   { name: 'Other / None', value: 'other' },
 ];
 
 export const FORMATTER_COMMANDS = {
   python: 'ruff format . || true',
   node: 'npx prettier --write . || true',
-  rust: 'cargo fmt || true',
+  java: "google-java-format -i $(find . -name '*.java' 2>/dev/null) || true",
+  csharp: 'dotnet format || true',
+  cpp: "find . -name '*.c' -o -name '*.cpp' -o -name '*.h' -o -name '*.hpp' | xargs clang-format -i || true",
   go: 'gofmt -w . || true',
+  php: 'php-cs-fixer fix . || true',
+  ruby: 'rubocop -A || true',
+  kotlin: 'ktlint -F || true',
+  swift: 'swift-format format -r . -i || true',
+  rust: 'cargo fmt || true',
+  dart: 'dart format . || true',
+  scala: 'scalafmt || true',
+  elixir: 'mix format || true',
+  zig: 'zig fmt . || true',
 };
 
 export const PROJECT_TYPE_DESCRIPTIONS = {

package/templates/settings/cpp.json

@@ -0,0 +1,16 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- C / C++ --",
+      "Bash(gcc:*)", "Bash(g++:*)", "Bash(clang:*)", "Bash(clang++:*)",
+      "Bash(make:*)", "Bash(cmake:*)", "Bash(ctest:*)", "Bash(cpack:*)",
+      "Bash(clang-format:*)", "Bash(clang-tidy:*)",
+      "Bash(valgrind:*)", "Bash(gdb:*)",
+      "Edit(*.c)", "Edit(*.cpp)", "Edit(*.cc)", "Edit(*.cxx)",
+      "Edit(*.h)", "Edit(*.hpp)", "Edit(*.hxx)",
+      "Edit(CMakeLists.txt)", "Edit(*.cmake)",
+      "Edit(Makefile)", "Edit(*.mk)"
+    ]
+  },
+  "formatter": "find . -name '*.c' -o -name '*.cpp' -o -name '*.h' -o -name '*.hpp' | xargs clang-format -i || true"
+}

package/templates/settings/csharp.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- C# / .NET --",
+      "Bash(dotnet:*)", "Bash(nuget:*)",
+      "Edit(*.cs)", "Edit(*.csproj)", "Edit(*.sln)",
+      "Edit(*.props)", "Edit(*.targets)",
+      "Edit(appsettings*.json)", "Edit(launchSettings.json)"
+    ]
+  },
+  "formatter": "dotnet format || true"
+}

package/templates/settings/dart.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- Dart / Flutter --",
+      "Bash(dart:*)", "Bash(flutter:*)",
+      "Bash(pub:*)",
+      "Edit(*.dart)",
+      "Edit(pubspec.yaml)", "Edit(pubspec.lock)",
+      "Edit(analysis_options.yaml)",
+      "Edit(*.g.dart)"
+    ]
+  },
+  "formatter": "dart format . || true"
+}

package/templates/settings/elixir.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- Elixir --",
+      "Bash(elixir:*)", "Bash(elixirc:*)", "Bash(iex:*)",
+      "Bash(mix:*)", "Bash(hex:*)",
+      "Bash(dialyzer:*)", "Bash(credo:*)",
+      "Edit(*.ex)", "Edit(*.exs)", "Edit(*.heex)", "Edit(*.leex)",
+      "Edit(mix.exs)", "Edit(mix.lock)",
+      "Edit(config/*.exs)"
+    ]
+  },
+  "formatter": "mix format || true"
+}

package/templates/settings/java.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- Java --",
+      "Bash(java:*)", "Bash(javac:*)", "Bash(javap:*)",
+      "Bash(mvn:*)", "Bash(mvnw:*)",
+      "Bash(gradle:*)", "Bash(gradlew:*)",
+      "Bash(google-java-format:*)",
+      "Edit(*.java)", "Edit(pom.xml)", "Edit(build.gradle*)",
+      "Edit(settings.gradle*)", "Edit(gradle.properties)"
+    ]
+  },
+  "formatter": "google-java-format -i $(find . -name '*.java' 2>/dev/null) || true"
+}

package/templates/settings/kotlin.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- Kotlin --",
+      "Bash(kotlin:*)", "Bash(kotlinc:*)",
+      "Bash(gradle:*)", "Bash(gradlew:*)",
+      "Bash(ktlint:*)", "Bash(detekt:*)",
+      "Edit(*.kt)", "Edit(*.kts)",
+      "Edit(build.gradle*)", "Edit(settings.gradle*)",
+      "Edit(gradle.properties)"
+    ]
+  },
+  "formatter": "ktlint -F || true"
+}

package/templates/settings/php.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- PHP --",
+      "Bash(php:*)", "Bash(composer:*)",
+      "Bash(phpunit:*)", "Bash(phpstan:*)",
+      "Bash(php-cs-fixer:*)", "Bash(pint:*)",
+      "Bash(artisan:*)", "Bash(sail:*)",
+      "Edit(*.php)", "Edit(composer.json)", "Edit(composer.lock)",
+      "Edit(phpunit.xml*)", "Edit(phpstan.neon*)",
+      "Edit(.php-cs-fixer*)"
+    ]
+  },
+  "formatter": "php-cs-fixer fix . || true"
+}

package/templates/settings/ruby.json

@@ -0,0 +1,16 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- Ruby --",
+      "Bash(ruby:*)", "Bash(irb:*)",
+      "Bash(bundle:*)", "Bash(bundler:*)",
+      "Bash(gem:*)", "Bash(rake:*)",
+      "Bash(rspec:*)", "Bash(rubocop:*)",
+      "Bash(rails:*)",
+      "Edit(*.rb)", "Edit(*.erb)", "Edit(*.rake)",
+      "Edit(Gemfile)", "Edit(Gemfile.lock)", "Edit(Rakefile)",
+      "Edit(.rubocop.yml)"
+    ]
+  },
+  "formatter": "rubocop -A || true"
+}

package/templates/settings/scala.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- Scala --",
+      "Bash(scala:*)", "Bash(scalac:*)",
+      "Bash(sbt:*)", "Bash(mill:*)",
+      "Bash(scalafmt:*)", "Bash(scalafix:*)",
+      "Edit(*.scala)", "Edit(*.sc)", "Edit(*.sbt)",
+      "Edit(build.sbt)", "Edit(project/*.scala)", "Edit(project/*.sbt)",
+      "Edit(.scalafmt.conf)"
+    ]
+  },
+  "formatter": "scalafmt || true"
+}

package/templates/settings/swift.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- Swift --",
+      "Bash(swift:*)", "Bash(swiftc:*)",
+      "Bash(xcodebuild:*)", "Bash(xcrun:*)",
+      "Bash(swift-format:*)", "Bash(swiftlint:*)",
+      "Edit(*.swift)", "Edit(Package.swift)", "Edit(Package.resolved)",
+      "Edit(*.xcodeproj/**)", "Edit(*.xcworkspace/**)"
+    ]
+  },
+  "formatter": "swift-format format -r . -i || true"
+}

package/templates/settings/zig.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "// -- Zig --",
+      "Bash(zig:*)",
+      "Edit(*.zig)", "Edit(build.zig)", "Edit(build.zig.zon)"
+    ]
+  },
+  "formatter": "zig fmt . || true"
+}