tiller-ai 0.1.0

package/README.md

@@ -0,0 +1,138 @@
+# tiller-ai
+
+Scaffold Claude Code projects with a structured vibe loop — branch, build, commit, land.
+
+## What is this?
+
+Tiller is a thin scaffold for Claude Code that turns a blank repo into a project Claude knows how to navigate. It installs a set of slash commands (skills), two `CLAUDE.md` files (one user-facing, one Tiller-managed), hooks for formatting and secret scanning, and shared tracking files. Once scaffolded, you describe work with `/vibe`, save checkpoints with `/save`, and ship with `/land` — and Claude follows the loop without you having to re-explain your workflow every session.
+
+## Quick start
+
+```bash
+# 1. Scaffold a new project
+npx tiller-ai init
+
+# 2. Open in Claude Code and run setup
+/setup
+
+# 3. Start working
+/vibe add a login page
+```
+
+## Skills
+
+| Command | What it does |
+|---|---|
+| `/setup` | First-run: understand the project and fill in `CLAUDE.md` |
+| `/vibe [idea]` | Start or continue work on something |
+| `/save` | Commit current progress on the feature branch |
+| `/land` | Merge completed feature to main (solo) or open a PR (team) |
+| `/recap` | Read-only status — active feature, notes |
+
+## Modes
+
+Tiller has two modes that control how Claude communicates:
+
+**`simple`** — for non-technical users. Claude builds without narrating steps, surfaces only blockers, and keeps responses short and outcome-focused.
+
+**`detailed`** — for technical users. Claude proposes an approach and waits for confirmation before touching files, narrates decisions, and surfaces trade-offs.
+
+Switch modes at any time:
+
+```bash
+npx tiller-ai mode simple
+npx tiller-ai mode detailed
+```
+
+Use `--project` to update the shared project default instead of your personal override:
+
+```bash
+npx tiller-ai mode detailed --project
+```
+
+Or just update the `Mode:` line in your root `CLAUDE.md`.
+
+## Workflows
+
+Tiller supports two workflows that affect how `/land` behaves:
+
+**`solo`** — single developer. `/land` merges the feature branch into main locally and deletes the branch.
+
+**`team`** — multiple developers. `/land` pushes the branch and opens a PR (via `gh` CLI if available, otherwise prints the URL). The branch is not deleted locally.
+
+The workflow is set during `init` and stored in `.claude/.tiller.json`. Each developer can override it locally in `.tiller.local.json` (gitignored).
+
+## What gets scaffolded
+
+```
+your-project/
+├── CLAUDE.md                              # User-facing: project context, verify command, mode, workflow
+├── .gitignore                             # Ignores vibestate.md, .tiller.local.json, common build artifacts
+├── changelog.md                           # Shared done log — updated by /land on each merge
+├── vibestate.md                           # Per-dev: active feature, milestone checklist, notes (gitignored)
+├── .claude/
+│   ├── CLAUDE.md                          # Tiller-managed: vibe loop rules, skill docs
+│   ├── settings.json                      # Hook registrations (PostToolUse, PreToolUse, UserPromptSubmit)
+│   ├── .tiller.json                       # Manifest: version, mode, workflow, runCommand, managedFiles
+│   ├── hooks/
+│   │   ├── post-write.sh                  # PostToolUse: run formatter after file writes
+│   │   ├── secret-scan.sh                 # PreToolUse: block writes containing secrets
+│   │   └── session-resume.sh              # UserPromptSubmit: orient Claude at session start
+│   └── skills/
+│       ├── setup/SKILL.md                 # /setup skill
+│       ├── vibe/SKILL.md                  # /vibe skill
+│       ├── save/SKILL.md                  # /save skill
+│       ├── land/SKILL.md                  # /land skill
+│       └── recap/SKILL.md                 # /recap skill
+```
+
+**Per-dev local overrides** — `.tiller.local.json` (gitignored, not scaffolded) lets individual developers override `mode` and `workflow` without touching shared files.
+
+## The vibe loop
+
+Every piece of work follows this loop:
+
+1. **Orient** — Claude reads `CLAUDE.md` and `vibestate.md` to understand project state and pick up any in-progress work
+2. **Confirm** — in `detailed` mode, Claude writes out the proposed approach and waits for a go-ahead before touching files
+3. **Build** — Claude implements, runs the verify command after each chunk, and fixes failures before moving on
+4. **Save** — Claude reminds you to `/save` when stable and `/land` when the feature is done
+
+`vibestate.md` tracks the active branch, milestone checklist, and session notes. `changelog.md` is the shared done log — updated by `/land` whenever a feature merges, so team members can see what's been shipped.
+
+## CLI reference
+
+### `npx tiller-ai init`
+
+Scaffold a new project interactively. Prompts for project name, description, run/verify command, mode, and workflow. Writes all files and makes an initial git commit.
+
+```bash
+npx tiller-ai init
+```
+
+### `npx tiller-ai upgrade`
+
+Update Tiller-managed files (`.claude/CLAUDE.md`, `settings.json`, hooks, skills) to the latest version without touching your `CLAUDE.md`, `vibestate.md`, or `changelog.md`.
+
+```bash
+npx tiller-ai upgrade
+```
+
+### `npx tiller-ai mode <mode>`
+
+Switch the project mode between `simple` and `detailed`. Without `--project`, writes to `.tiller.local.json` (your personal override). With `--project`, updates the shared `CLAUDE.md`.
+
+```bash
+npx tiller-ai mode simple
+npx tiller-ai mode detailed
+npx tiller-ai mode detailed --project   # update shared project default
+```
+
+## Requirements
+
+- Node 22+
+- [Claude Code](https://claude.ai/code)
+- git
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,1183 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { intro, outro, spinner } from "@clack/prompts";
+import { resolve, basename } from "path";
+
+// src/scaffold/index.ts
+import { join as join2 } from "path";
+
+// src/utils/fs.ts
+import { mkdir, writeFile as fsWriteFile } from "fs/promises";
+import { dirname } from "path";
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function writeFile(filePath, content) {
+  await ensureDir(dirname(filePath));
+  await fsWriteFile(filePath, content, "utf-8");
+}
+
+// src/utils/git.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+function exec(cmd, cwd) {
+  execSync(cmd, { cwd, stdio: "pipe" });
+}
+function isGitRepo(cwd) {
+  return existsSync(join(cwd, ".git"));
+}
+function gitInit(cwd) {
+  exec("git init", cwd);
+  try {
+    exec("git checkout -b main", cwd);
+  } catch {
+  }
+}
+function gitAdd(cwd, pattern = "-A") {
+  exec(`git add ${pattern}`, cwd);
+}
+function gitCommit(cwd, message) {
+  exec(`git commit -m "${message.replace(/"/g, '\\"')}"`, cwd);
+}
+
+// src/scaffold/claude-md.ts
+function generateRootClaudeMd(config) {
+  const description = config.description || "<!-- Run /setup to fill this in -->";
+  const runCommand = config.runCommand || "# not set \u2014 run /setup to configure";
+  const modeLabel = config.mode === "detailed" ? "detailed" : "simple";
+  const workflowLabel = config.workflow === "team" ? "team" : "solo";
+  return `# ${config.projectName}
+
+${description}
+
+## Verify command
+
+\`\`\`
+${runCommand}
+\`\`\`
+
+## Mode
+
+${modeLabel}
+
+## Workflow
+
+${workflowLabel}
+`;
+}
+function generateDotClaudeMd(_config) {
+  return `# Tiller \u2014 How to work
+
+> These rules are managed by Tiller. Do not edit manually.
+
+## Modes
+
+The mode is set in CLAUDE.md (or overridden locally in \`.tiller.local.json\`). Read it at the start of every session.
+
+### simple
+
+The user is non-technical. They want to describe what they want and have it built for them.
+
+- Do not explain your technical decisions unless asked
+- Do not narrate steps as you do them
+- Do not ask about tooling, frameworks, file structure, or verify commands
+- When something goes wrong, fix it yourself first \u2014 only surface it if you can't resolve it
+- Keep all communication short and outcome-focused: "Done. Here's what changed."
+
+### detailed
+
+The user is technical and wants to stay in control.
+
+- Before touching files: write out your proposed approach, list files you'll create or modify, wait for explicit confirmation
+- Narrate what you're doing and why
+- Surface decisions and trade-offs before making them
+- When something goes wrong, explain what happened and what you plan to do
+
+## Workflows
+
+The workflow is set in CLAUDE.md (or overridden locally in \`.tiller.local.json\`).
+
+### solo
+
+Single developer or local-only flow. /land merges directly to main.
+
+### team
+
+Multiple developers. /land pushes the feature branch and opens a PR. Merging happens on GitHub/GitLab after review and CI.
+
+## Vibe loop
+
+Every piece of work follows this loop:
+
+1. **Orient** \u2014 read CLAUDE.md, vibestate.md (local), and changelog.md (shared)
+2. **Confirm** \u2014 in detailed mode, enter plan mode with milestones and wait for approval
+3. **Build** \u2014 implement milestone by milestone; each milestone includes tests, verify, and auto-commit
+4. **Complete** \u2014 announce feature done, suggest /land
+
+## File discipline
+
+- Never commit directly to main
+- Always work on a feature branch (feature/<name>)
+- Run the verify command before every snapshot and land
+- \`vibestate.md\` is gitignored \u2014 it tracks your local active feature state
+- \`changelog.md\` is committed and shared \u2014 it tracks the project's done log
+
+## Per-dev overrides
+
+Create \`.tiller.local.json\` (gitignored) to override mode or workflow personally:
+\`\`\`json
+{ "mode": "simple", "workflow": "solo" }
+\`\`\`
+Skills read \`.tiller.local.json\` first, then fall back to CLAUDE.md.
+
+## Skills
+
+- **/setup** \u2014 first-run: understand the project and configure CLAUDE.md
+- **/vibe** [idea] \u2014 milestone-driven development: plan, build, test, auto-commit. Every 3 landed features, automatically runs a background tech debt cleanup before planning.
+- **/snapshot** \u2014 commit current progress on the feature branch
+- **/land** \u2014 merge or PR depending on workflow
+- **/recap** \u2014 read-only status of all work
+
+## Rules
+
+- Do not skip the verify step
+- Do not touch unrelated files
+- Do not make architectural changes without explicit confirmation in detailed mode
+- Keep commits atomic and descriptive
+`;
+}
+
+// src/scaffold/vibestate.ts
+function generateVibestate(_config) {
+  return `# vibestate.md \u2014 local only, do not commit
+
+> Tracks your active feature work. Gitignored \u2014 each dev has their own copy.
+
+## Active feature
+
+None \u2014 on main, ready to start something.
+
+## Notes
+
+<!-- Add context, gotchas, decisions here -->
+`;
+}
+
+// src/scaffold/changelog.ts
+function generateChangelog(config) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `# changelog.md \u2014 ${config.projectName}
+
+> Shared project history. Updated by /vibe, /snapshot, and /land. Committed and shared.
+
+## Done
+
+- [${today}] v0 \u2014 initial scaffold
+`;
+}
+
+// src/scaffold/settings-json.ts
+function generateSettingsJson(_config) {
+  const settings = {
+    hooks: {
+      PostToolUse: [
+        {
+          matcher: "Edit|Write|MultiEdit",
+          hooks: [
+            {
+              type: "command",
+              command: 'bash .claude/hooks/post-write.sh "$CLAUDE_FILE_PATHS"'
+            }
+          ]
+        }
+      ],
+      PreToolUse: [
+        {
+          matcher: "Bash",
+          hooks: [
+            {
+              type: "command",
+              command: "bash .claude/hooks/secret-scan.sh"
+            }
+          ]
+        }
+      ],
+      SessionStart: [
+        {
+          matcher: "clear",
+          hooks: [
+            {
+              type: "command",
+              command: "bash .claude/hooks/session-resume.sh"
+            }
+          ]
+        }
+      ]
+    },
+    permissions: {
+      allow: [
+        "Bash(git:*)",
+        "Bash(npm:*)",
+        "Bash(npx:*)",
+        "Bash(node:*)",
+        "Bash(echo:*)"
+      ]
+    }
+  };
+  return JSON.stringify(settings, null, 2);
+}
+
+// src/scaffold/gitignore.ts
+function generateGitignore(_config) {
+  return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+build/
+.next/
+out/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Editor
+.DS_Store
+*.swp
+*.swo
+.idea/
+.vscode/
+
+# Logs
+*.log
+npm-debug.log*
+
+# TypeScript
+*.tsbuildinfo
+
+# Tiller \u2014 local-only files (per-dev, not shared)
+vibestate.md
+.tiller.local.json
+`;
+}
+
+// src/scaffold/tiller-manifest.ts
+var MANAGED_FILES = [
+  ".claude/CLAUDE.md",
+  ".claude/settings.json",
+  ".claude/hooks/post-write.sh",
+  ".claude/hooks/secret-scan.sh",
+  ".claude/skills/setup/SKILL.md",
+  ".claude/skills/vibe/SKILL.md",
+  ".claude/skills/snapshot/SKILL.md",
+  ".claude/skills/recap/SKILL.md",
+  ".claude/skills/land/SKILL.md",
+  ".claude/skills/tech-debt/SKILL.md"
+];
+function generateTillerManifest(config, version) {
+  const manifest = {
+    version,
+    mode: config.mode,
+    workflow: config.workflow,
+    runCommand: config.runCommand,
+    managedFiles: MANAGED_FILES
+  };
+  return JSON.stringify(manifest, null, 2);
+}
+
+// src/scaffold/hooks/post-write.ts
+function generatePostWriteHook(_config) {
+  return `#!/usr/bin/env bash
+# post-write.sh \u2014 auto-format after file edits
+# Managed by Tiller. Silent fail if formatter not available.
+
+set -euo pipefail
+
+FILES="$1"
+
+if [ -z "$FILES" ]; then
+  exit 0
+fi
+
+# Try prettier
+if command -v prettier &>/dev/null; then
+  echo "$FILES" | tr ' ' '\\n' | xargs prettier --write --ignore-unknown 2>/dev/null || true
+  exit 0
+fi
+
+# Try biome
+if command -v biome &>/dev/null; then
+  echo "$FILES" | tr ' ' '\\n' | xargs biome format --write 2>/dev/null || true
+  exit 0
+fi
+
+# No formatter found \u2014 that's fine
+exit 0
+`;
+}
+
+// src/scaffold/hooks/secret-scan.ts
+function generateSecretScanHook(_config) {
+  return `#!/usr/bin/env bash
+# secret-scan.sh \u2014 block commits that contain secrets
+# Managed by Tiller. Called as PreToolUse hook on Bash commands.
+
+set -euo pipefail
+
+# Read the tool input from stdin
+INPUT=$(cat)
+
+# Only run on git commit commands
+COMMAND=$(echo "$INPUT" | python3 -c "import sys, json; data = json.load(sys.stdin); print(data.get('command', ''))" 2>/dev/null || echo "")
+
+if [[ "$COMMAND" != *"git commit"* ]]; then
+  exit 0
+fi
+
+# Get staged files
+STAGED=$(git diff --cached --name-only 2>/dev/null || true)
+
+if [ -z "$STAGED" ]; then
+  exit 0
+fi
+
+# Patterns that look like secrets
+SECRET_PATTERNS=(
+  'sk-[a-zA-Z0-9]{20,}'
+  'ghp_[a-zA-Z0-9]{36}'
+  'gho_[a-zA-Z0-9]{36}'
+  'github_pat_[a-zA-Z0-9_]{82}'
+  'xoxb-[0-9]+-[a-zA-Z0-9]+'
+  'AKIA[0-9A-Z]{16}'
+  'eyJ[a-zA-Z0-9_-]+\\.[a-zA-Z0-9_-]+\\.[a-zA-Z0-9_-]+'
+  'AIza[0-9A-Za-z_-]{35}'
+  'password\\s*=\\s*["\\'\\''"][^"\\'']+["\\'\\''"]'
+  'secret\\s*=\\s*["\\'\\''"][^"\\'']+["\\'\\''"]'
+  'api[_-]?key\\s*=\\s*["\\'\\''"][^"\\'']+["\\'\\''"]'
+)
+
+FOUND=""
+for PATTERN in "\${SECRET_PATTERNS[@]}"; do
+  MATCHES=$(git diff --cached | grep -iE "$PATTERN" 2>/dev/null || true)
+  if [ -n "$MATCHES" ]; then
+    FOUND="$FOUND\\n$MATCHES"
+  fi
+done
+
+if [ -n "$FOUND" ]; then
+  echo '{"permissionDecision":"deny","denyReason":"Potential secrets detected in staged changes. Remove secrets before committing."}'
+  exit 0
+fi
+
+exit 0
+`;
+}
+
+// src/scaffold/hooks/session-resume.ts
+function generateSessionResumeHook(_config) {
+  return `#!/usr/bin/env bash
+# Injected into context on SessionStart(clear)
+if grep -q "Status: executing" vibestate.md 2>/dev/null; then
+  PLAN_FILE=$(grep "Plan:" vibestate.md | head -1 | sed 's/Plan: //')
+  echo "You are in the middle of a /vibe milestone build."
+  echo "Read vibestate.md for milestone progress and \${PLAN_FILE:-the plan file} for full context."
+  echo "Resume the milestone loop from where you left off. Auto-commit after each milestone."
+fi
+`;
+}
+
+// src/scaffold/skills/vibe.ts
+function generateVibeSkill(config) {
+  return `---
+name: vibe
+description: Start or continue working on an idea. Usage: /vibe [idea description]
+---
+
+# /vibe \u2014 Start or continue work
+
+## Step 1: Orient
+
+Read \`CLAUDE.md\`, \`vibestate.md\`, and \`changelog.md\` to understand current state.
+Run \`git branch\` and \`git status\`.
+
+State the current mode from CLAUDE.md: "Mode: <mode>".
+
+**If mode is simple:** Do not narrate the orient step.
+**If mode is detailed:** Summarize the current state in 2-3 sentences.
+
+## Step 2: Branch routing
+
+**$ARGUMENTS provided** \u2192 check if a branch named \`feature/<kebab-case-of-arguments>\` already exists locally or remotely.
+  - If it exists: switch to it. Read \`vibestate.md\` for current state. Ask: "Found existing branch feature/<name>. Continue where we left off, or do you want to revisit the plan first?"
+    - Continue \u2192 pick up from the next unchecked milestone
+    - Revisit \u2192 summarize what's done so far, discuss before building
+  - If it doesn't exist: create it from main.
+    - **simple:** Say: "On it."
+    - **detailed:** State: "Starting work on: <idea>"
+
+**Already on a feature branch** \u2192 continue.
+  - **simple:** Say nothing unless asked.
+  - **detailed:** State: "Continuing work on: <branch-name>"
+
+**Neither** \u2192 list open feature branches briefly, ask what to work on.
+
+## Step 2.5: Tech debt check
+
+Before planning, check if a tech debt cleanup is due:
+
+1. Count lines in \`changelog.md\` matching the pattern \`- [[^]]*] landed feature/\` \u2014 this is \`landedCount\`
+2. Read \`.claude/.tiller-tech-debt.json\` \u2014 get \`lastTechDebtAtFeature\` and \`threshold\` (default threshold: 3)
+3. If \`(landedCount - lastTechDebtAtFeature) >= threshold\`:
+   - Use the **Task tool** (foreground, \`subagent_type: "general-purpose"\`) with the contents of \`.claude/skills/tech-debt/SKILL.md\` as the prompt
+   - Wait for the agent to complete before continuing
+4. Continue to Step 3 regardless of whether the tech debt agent ran
+
+## Step 3: Plan milestones
+
+**If mode is simple:** Explore the codebase and break the work into 2\u20135 milestones internally. Do not show this plan to the user.
+
+**If mode is detailed:** Call \`EnterPlanMode\`. In the plan file, write:
+- High-level approach (2\u20133 sentences)
+- 2\u20135 numbered milestones, each with: what gets built + what gets tested
+- Files to create or modify
+- Any trade-offs worth noting
+- **Execution rules** (embed verbatim): After plan approval, read \`vibestate.md\` to find the milestone checklist, then execute the milestone loop: for each remaining milestone, announce "Milestone X/N: <description>", build functionality, add or update tests, run \`${config.runCommand}\` and fix failures, run \`git add -A && git commit -m "<milestone>"\`, update \`vibestate.md\` checkboxes and \`changelog.md\` Done section then amend commit, report "Saved: <description> (X/N)". When all milestones are done, summarize what was built and suggest \`/land\`.
+
+  Before exiting plan mode, write the milestone checklist to the \`Active feature\` section of \`vibestate.md\` with \`Status: executing\` and the plan file path.
+
+## Step 4: Build milestone by milestone
+
+For each milestone:
+1. **detailed only:** Announce: "Milestone X/N: <description>"
+2. Build the functionality
+3. Add or update tests for what was built
+4. Run \`${config.runCommand}\` \u2014 **simple:** fix failures silently. **detailed:** fix before continuing.
+5. \`git add -A && git commit -m "<milestone description>"\`
+6. Update \`vibestate.md\` milestone checkboxes (detailed) and add entry to \`changelog.md\` Done section. Amend: \`git commit --amend --no-edit\`
+7. **simple:** Say: "Saved: <what changed>". **detailed:** Report: "Saved: <description> (X/N)"
+
+## Step 5: Complete
+
+**simple:** Say: "Feature complete. Type /land when ready to merge."
+**detailed:** Summarize everything that was built across all milestones. Suggest \`/land\` to merge.
+
+## If something goes wrong
+
+**simple:** Fix it yourself first. Only tell the user if you genuinely can't resolve it.
+**detailed:** Explain what happened and what you plan to do.
+`;
+}
+
+// src/scaffold/skills/snapshot.ts
+function generateSnapshotSkill(config) {
+  return `---
+name: snapshot
+description: Save current progress with a commit on the feature branch
+---
+
+# /snapshot \u2014 Save progress
+
+## Step 1: Check branch
+
+Run \`git branch --show-current\`.
+
+If on \`main\`:
+- **simple:** Say: "You're on main \u2014 use /vibe to start a feature first." Stop.
+- **detailed:** Warn: "You're on main. Snapshot is for feature branches. Use /vibe to start a feature branch first." Stop.
+
+## Step 2: Run verify
+
+Run \`${config.runCommand}\`
+
+If it fails:
+- **simple:** Say: "Something's broken, let me fix it first." Fix it, then continue.
+- **detailed:** Show the error output. Do NOT commit. Say: "Verify failed. Fix the errors and try /snapshot again." Stop.
+
+## Step 3: Describe changes
+
+If $ARGUMENTS is provided, use that as the commit message.
+
+Otherwise, run \`git diff --stat HEAD\` and infer a short, descriptive commit message.
+
+Format: \`<verb> <what> \u2014 <brief detail if needed>\`
+
+## Step 4: Commit
+
+\`\`\`
+git add -A
+git commit -m "<message>"
+\`\`\`
+
+## Step 5: Update changelog.md
+
+Add an entry to the Done section of \`changelog.md\`:
+\`\`\`
+- [YYYY-MM-DD] <message>
+\`\`\`
+
+Run \`git add changelog.md && git commit --amend --no-edit\`.
+
+## Step 6: Confirm
+
+- **simple:** Say: "Saved. Keep going or type /land when you're done."
+- **detailed:** Say: "Snapshot saved: <message>. Use /land when this feature is ready to merge."
+`;
+}
+
+// src/scaffold/skills/recap.ts
+function generateRecapSkill(_config) {
+  return `---
+name: recap
+description: Read-only status of all work \u2014 completed and in progress
+---
+
+# /recap \u2014 Project status
+
+> Read-only. No file modifications. No suggestions. No internal monologue.
+
+## Gather everything silently first
+
+Run all of these before writing any output:
+
+1. Read \`vibestate.md\` (active feature, local state)
+2. Read \`changelog.md\` (shared done log)
+3. \`git log main --oneline\`
+4. \`git branch --list 'feature/*'\`
+5. For each feature branch: \`git log main..<branch> --oneline\`
+
+## Then produce output based on mode
+
+Read mode from CLAUDE.md.
+
+**If mode is simple:** Translate everything into plain English. No hashes, no branch names, no git jargon.
+
+Format:
+
+---
+
+**Working on:** <what's currently being built, from vibestate.md \u2014 or "nothing, ready to start">
+
+**Done**
+- <plain English description of what was built>
+...
+
+**In progress**
+- <plain English description of what's being worked on>
+...
+
+---
+
+If there's nothing in progress: omit the "In progress" section.
+If there's nothing done yet: say "Nothing completed yet."
+
+**If mode is detailed:** Include technical details.
+
+Format:
+
+---
+
+**Active:** <active feature from vibestate.md, or "none">
+
+**Completed (main)**
+<hash> <message>
+...
+
+**In progress**
+feature/<name>
+  <hash> <message>
+  ...
+
+<X> features landed, <Y> in progress.
+
+---
+
+Nothing else. No commentary, no second-guessing, no re-running commands.
+`;
+}
+
+// src/scaffold/skills/land.ts
+function generateLandSkill(config) {
+  return `---
+name: land
+description: Merge completed feature to main and clean up the branch
+---
+
+# /land \u2014 Merge feature to main
+
+## Step 1: Check branch
+
+Run \`git branch --show-current\`.
+
+If on \`main\`:
+- **simple:** Say: "You're already on main." Stop.
+- **detailed:** Error: "You're already on main. Switch to the feature branch you want to land." Stop.
+
+Save the current branch name as \`<feature-branch>\`.
+
+## Step 2: Run verify
+
+Run \`${config.runCommand}\`
+
+If it fails:
+- **simple:** Say: "Something's not working, let me sort it out." Fix it first.
+- **detailed:** Show the error output. Do NOT proceed. Say: "Verify failed. Fix the errors and try /land again." Stop.
+
+## Step 3: Commit any uncommitted changes
+
+Run \`git status --porcelain\`.
+
+If there are uncommitted changes:
+\`\`\`
+git add -A
+git commit -m "wip: save before landing"
+\`\`\`
+
+## Step 4: Check workflow
+
+Read workflow from \`.tiller.local.json\` if it exists, otherwise from CLAUDE.md or \`.tiller.json\`. Default: solo.
+
+**If workflow is solo** \u2192 go to Step 5a (local merge).
+**If workflow is team** \u2192 go to Step 5b (open PR).
+
+## Step 5a: Solo \u2014 merge to main
+
+\`\`\`
+git checkout main
+git merge --no-ff <feature-branch> -m "land: <feature-branch>"
+git branch -d <feature-branch>
+\`\`\`
+
+Then go to Step 6.
+
+## Step 5b: Team \u2014 open PR
+
+Push the branch:
+\`\`\`
+git push origin <feature-branch>
+\`\`\`
+
+Check if \`gh\` CLI is available: run \`which gh\`.
+
+**If gh is available:**
+\`\`\`
+gh pr create --fill
+\`\`\`
+Print the PR URL. Say: "PR opened. Merge happens on GitHub after review and CI."
+
+**If gh is not available:**
+Run \`git remote get-url origin\` to get the remote URL. Convert to a browser URL if needed.
+Say: "Push done. Open a PR at: <remote-url>/compare/<feature-branch>"
+
+Then go to Step 6 (do NOT delete the branch locally \u2014 it will be deleted after the PR merges remotely).
+
+## Step 6: Update changelog.md
+
+1. Add an entry to the Done section of \`changelog.md\`:
+   - **solo:** \`- [YYYY-MM-DD] landed <feature-branch>\`
+   - **team:** \`- [YYYY-MM-DD] PR opened: <feature-branch>\`
+2. Clear the \`Active feature\` section of \`vibestate.md\`: set it to "None \u2014 on main, ready to start something."
+3. Commit:
+   \`\`\`
+   git add changelog.md vibestate.md && git commit -m "update changelog: landed <feature-branch>"
+   \`\`\`
+   **team:** commit to the feature branch before pushing (or amend if already pushed).
+
+## Step 7: Confirm
+
+- **simple:** Say: "Done. Run \`/clear\` to reset context before starting your next feature, then \`/vibe\` to continue."
+- **detailed:** Say: "Feature landed on main. Run \`/clear\` to reset context before your next feature, then \`/vibe\` to continue."
+`;
+}
+
+// src/scaffold/skills/setup.ts
+function generateSetupSkill(_config) {
+  return `---
+name: setup
+description: First-run setup \u2014 understand the project and configure CLAUDE.md
+---
+
+# /setup \u2014 Configure this project
+
+> Run this once after \`tiller-ai init\`.
+
+## Step 1: Ask about mode first
+
+Ask only this question to start:
+
+> "How do you want to work together?
+> - **Simple** \u2014 just tell me what to build, I'll handle all the technical decisions.
+> - **Detailed** \u2014 I'll explain my thinking and check in with you before making decisions."
+
+Wait for their answer. Default to simple if they're unsure.
+
+---
+
+## If mode is SIMPLE
+
+The user is non-technical. Handle everything yourself, ask as little as possible.
+
+**Step 2: Ask what the project is**
+
+Ask one question: "What are you building?"
+
+Listen to their answer. That's enough \u2014 use it as the description.
+
+**Step 3: Derive the verify command yourself**
+
+Look at the project files silently. Do not ask the user about this.
+
+- \`package.json\` with a \`test\` script \u2192 \`npm test\`
+- \`package.json\` without a \`test\` script \u2192 \`npm run build\` if build script exists, else \`node --check index.js\`
+- \`pyproject.toml\` or \`setup.py\` \u2192 \`pytest\`
+- \`Cargo.toml\` \u2192 \`cargo test\`
+- \`go.mod\` \u2192 \`go test ./...\`
+- \`Makefile\` with a \`test\` target \u2192 \`make test\`
+- Nothing recognizable \u2192 \`echo ok\` (can be updated later)
+
+**Step 4: Update CLAUDE.md and commit**
+
+Rewrite \`CLAUDE.md\` with the project name, their description, the verify command you derived, and mode: simple.
+
+Update \`runCommand\` and \`mode\` in \`.claude/.tiller.json\`.
+
+\`\`\`
+git add CLAUDE.md .claude/.tiller.json
+git commit -m "chore: configure project via /setup"
+\`\`\`
+
+Say: "All set. Just tell me what you want to build and I'll take it from there."
+
+---
+
+## If mode is DETAILED
+
+The user is technical and wants to stay in the loop.
+
+**Step 2: Ask about the project**
+
+Ask: "What are you building?" \u2014 let them describe it.
+
+If there's already a README or package.json, read it first and confirm your understanding instead of asking blind.
+
+**Step 3: Ask about the verify command**
+
+Ask: "What command should I run to verify everything's working after a change?"
+
+Give suggestions based on what you see in the project. If they don't know yet, suggest \`echo ok\` as a placeholder.
+
+**Step 4: Update CLAUDE.md and commit**
+
+Rewrite \`CLAUDE.md\` with the project name, description, verify command, and mode: detailed.
+
+Update \`runCommand\` and \`mode\` in \`.claude/.tiller.json\`.
+
+\`\`\`
+git add CLAUDE.md .claude/.tiller.json
+git commit -m "chore: configure project via /setup"
+\`\`\`
+
+Say: "All set. Use /vibe to start working."
+`;
+}
+
+// src/scaffold/skills/tech-debt.ts
+function generateTechDebtSkill(config) {
+  return `---
+name: tech-debt
+description: Internal skill \u2014 spawned by /vibe to fix one small tech debt item. Not user-invocable directly.
+---
+
+# Tech Debt Agent
+
+You are a focused tech debt cleanup agent. Your job: find and fix **one small, non-invasive tech debt item**, merge it to main, then exit cleanly.
+
+## What to look for
+
+Scan the codebase for ONE item from these categories (pick the smallest/safest):
+
+- **Clutter:** dead code, unused imports/exports, stale TODOs, commented-out code
+- **Duplication:** duplicated logic extractable into a shared helper
+- **Readability:** functions with high cognitive complexity, unclear names, missing comments on non-obvious logic
+- **Correctness risks:** unhandled promise rejections, missing \`await\`, unsafe type assertions (\`as X\`), hardcoded values that should be constants
+- **Inconsistency:** patterns done differently in one place vs. the rest of the codebase
+- **Test health:** happy-path-only tests missing obvious error cases
+- **Dependency hygiene:** packages imported but barely used (could be inlined or removed)
+
+## Guardrails \u2014 you MUST NOT
+
+- Touch more than 3 files
+- Change any public API or exported interface
+- Refactor anything that changes observable behavior
+- Split, merge, or move files (structural changes)
+- Rename anything used across many files
+- Modify CI/CD, build config, or dependency versions
+- If nothing safe is found, skip entirely and report "codebase is clean"
+
+## Steps
+
+1. Explore the codebase and identify the single smallest, most non-invasive item to fix
+2. If nothing safe is found: skip to the "Report" step with "codebase is clean"
+3. Note the current branch: \`git branch --show-current\`
+4. Stash any uncommitted work: \`git stash\`
+5. \`git checkout main\`
+6. Create a chore branch: \`git checkout -b chore/tech-debt-<short-desc>\` (use kebab-case, max 4 words)
+7. Fix the item
+8. Run \`${config.runCommand}\` \u2014 if it fails, revert the change and skip (report "skipped \u2014 verify failed")
+9. \`git add -A && git commit -m "chore: tech debt \u2014 <short-desc>"\`
+10. \`git checkout main && git merge --no-ff chore/tech-debt-<short-desc> -m "chore: tech debt \u2014 <short-desc>"\`
+11. \`git branch -d chore/tech-debt-<short-desc>\`
+12. \`git checkout <original-branch> && git stash pop\` (restore original state)
+13. Update \`.claude/.tiller-tech-debt.json\`: set \`lastTechDebtAtFeature\` to the current count of landed features (lines matching \`- [.*] landed feature/\` in \`changelog.md\`)
+
+## Report
+
+**simple mode:** "Cleaned up a bit."
+**detailed mode:** "Tech debt fixed: <what was done and why it mattered>"
+
+If skipped: **simple:** say nothing. **detailed:** "Tech debt check: codebase is clean."
+`;
+}
+
+// src/scaffold/tech-debt-state.ts
+function generateTechDebtState() {
+  return JSON.stringify(
+    {
+      lastTechDebtAtFeature: 0,
+      threshold: 3
+    },
+    null,
+    2
+  );
+}
+
+// src/scaffold/index.ts
+var TILLER_VERSION = "0.1.0";
+async function scaffold(config, targetDir) {
+  const p = (rel) => join2(targetDir, rel);
+  await writeFile(p("CLAUDE.md"), generateRootClaudeMd(config));
+  await writeFile(p(".gitignore"), generateGitignore(config));
+  await writeFile(p("changelog.md"), generateChangelog(config));
+  await writeFile(p("vibestate.md"), generateVibestate(config));
+  await writeFile(p(".claude/CLAUDE.md"), generateDotClaudeMd(config));
+  await writeFile(p(".claude/settings.json"), generateSettingsJson(config));
+  await writeFile(p(".claude/.tiller.json"), generateTillerManifest(config, TILLER_VERSION));
+  await writeFile(p(".claude/.tiller-tech-debt.json"), generateTechDebtState());
+  await writeFile(p(".claude/hooks/post-write.sh"), generatePostWriteHook(config));
+  await writeFile(p(".claude/hooks/secret-scan.sh"), generateSecretScanHook(config));
+  await writeFile(p(".claude/hooks/session-resume.sh"), generateSessionResumeHook(config));
+  await writeFile(p(".claude/skills/setup/SKILL.md"), generateSetupSkill(config));
+  await writeFile(p(".claude/skills/vibe/SKILL.md"), generateVibeSkill(config));
+  await writeFile(p(".claude/skills/snapshot/SKILL.md"), generateSnapshotSkill(config));
+  await writeFile(p(".claude/skills/recap/SKILL.md"), generateRecapSkill(config));
+  await writeFile(p(".claude/skills/land/SKILL.md"), generateLandSkill(config));
+  await writeFile(p(".claude/skills/tech-debt/SKILL.md"), generateTechDebtSkill(config));
+  if (!isGitRepo(targetDir)) {
+    gitInit(targetDir);
+  }
+  gitAdd(targetDir);
+  gitCommit(targetDir, "chore: initial tiller scaffold");
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  const targetDir = resolve(process.cwd());
+  const projectName = basename(targetDir);
+  intro("tiller-ai init");
+  const config = {
+    projectName,
+    description: "",
+    runCommand: "",
+    mode: "simple",
+    workflow: "solo"
+  };
+  const s = spinner();
+  s.start("Scaffolding...");
+  try {
+    await scaffold(config, targetDir);
+    s.stop("Done.");
+  } catch (err) {
+    s.stop("Failed.");
+    throw err;
+  }
+  outro(
+    `Scaffolded in ./${projectName}
+
+  claude
+
+Then run /setup to configure the project with AI assistance.`
+  );
+}
+
+// src/commands/upgrade.ts
+import { intro as intro2, outro as outro2, confirm, spinner as spinner2, isCancel, cancel } from "@clack/prompts";
+import { readFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+var TILLER_VERSION2 = "0.1.0";
+async function upgradeCommand() {
+  intro2("tiller-ai upgrade \u2014 update hooks and skills");
+  const manifestPath = resolve2(process.cwd(), ".claude/.tiller.json");
+  if (!existsSync2(manifestPath)) {
+    cancel("No .claude/.tiller.json found. Is this a Tiller project? Run tiller-ai init to start a new project.");
+    process.exit(1);
+  }
+  let manifest;
+  try {
+    const raw = await readFile(manifestPath, "utf-8");
+    manifest = JSON.parse(raw);
+  } catch {
+    cancel("Failed to read .claude/.tiller.json. The file may be corrupted.");
+    process.exit(1);
+  }
+  const go = await confirm({
+    message: `Upgrade Tiller files from v${manifest.version} to v${TILLER_VERSION2}? (managed files will be overwritten)`
+  });
+  if (isCancel(go) || !go) {
+    cancel("Upgrade cancelled.");
+    process.exit(0);
+  }
+  const config = {
+    projectName: "",
+    description: "",
+    runCommand: manifest.runCommand,
+    mode: manifest.mode,
+    workflow: manifest.workflow ?? "solo"
+  };
+  const s = spinner2();
+  s.start("Upgrading...");
+  try {
+    await writeFile(".claude/CLAUDE.md", generateDotClaudeMd(config));
+    await writeFile(".claude/hooks/post-write.sh", generatePostWriteHook(config));
+    await writeFile(".claude/hooks/secret-scan.sh", generateSecretScanHook(config));
+    await writeFile(".claude/skills/setup/SKILL.md", generateSetupSkill(config));
+    await writeFile(".claude/skills/vibe/SKILL.md", generateVibeSkill(config));
+    await writeFile(".claude/skills/snapshot/SKILL.md", generateSnapshotSkill(config));
+    await writeFile(".claude/skills/recap/SKILL.md", generateRecapSkill(config));
+    await writeFile(".claude/skills/land/SKILL.md", generateLandSkill(config));
+    await writeFile(".claude/skills/tech-debt/SKILL.md", generateTechDebtSkill(config));
+    await writeFile(".claude/.tiller.json", generateTillerManifest(config, TILLER_VERSION2));
+    s.stop("Done!");
+  } catch (err) {
+    s.stop("Failed.");
+    throw err;
+  }
+  outro2(`Upgraded to v${TILLER_VERSION2}. Managed files: ${MANAGED_FILES.length}`);
+}
+
+// src/commands/mode.ts
+import { intro as intro3, outro as outro3, spinner as spinner3, cancel as cancel2 } from "@clack/prompts";
+import { readFile as readFile2, writeFile as fsWriteFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+var TILLER_VERSION3 = "0.1.0";
+async function modeCommand(newMode, options) {
+  intro3("tiller-ai mode \u2014 switch between simple and detailed");
+  if (newMode !== "simple" && newMode !== "detailed") {
+    cancel2('Mode must be "simple" or "detailed".');
+    process.exit(1);
+  }
+  const manifestPath = resolve3(process.cwd(), ".claude/.tiller.json");
+  if (!existsSync3(manifestPath)) {
+    cancel2("No .claude/.tiller.json found. Is this a Tiller project?");
+    process.exit(1);
+  }
+  let manifest;
+  try {
+    const raw = await readFile2(manifestPath, "utf-8");
+    manifest = JSON.parse(raw);
+  } catch {
+    cancel2("Failed to read .claude/.tiller.json.");
+    process.exit(1);
+  }
+  const localPath = resolve3(process.cwd(), ".tiller.local.json");
+  const isProjectScope = options.project === true;
+  if (!isProjectScope) {
+    let localMode;
+    if (existsSync3(localPath)) {
+      try {
+        const raw = await readFile2(localPath, "utf-8");
+        const local = JSON.parse(raw);
+        localMode = local.mode;
+      } catch {
+      }
+    }
+    if (localMode === newMode) {
+      outro3(`Already in ${newMode} mode (local override).`);
+      return;
+    }
+  } else {
+    if (manifest.mode === newMode) {
+      outro3(`Already in ${newMode} mode (project default).`);
+      return;
+    }
+  }
+  const rootClaudePath = resolve3(process.cwd(), "CLAUDE.md");
+  let projectName = manifest.projectName ?? "";
+  let description = manifest.description ?? "";
+  if (existsSync3(rootClaudePath)) {
+    try {
+      const raw = await readFile2(rootClaudePath, "utf-8");
+      const nameMatch = raw.match(/^# (.+)$/m);
+      const descMatch = raw.match(/^# .+\n\n(.+)/m);
+      if (nameMatch) projectName = nameMatch[1];
+      if (descMatch) description = descMatch[1];
+    } catch {
+    }
+  }
+  const s = spinner3();
+  if (isProjectScope) {
+    s.start(`Switching project default to ${newMode} mode...`);
+    const config = {
+      projectName,
+      description,
+      runCommand: manifest.runCommand,
+      mode: newMode,
+      workflow: manifest.workflow ?? "solo"
+    };
+    try {
+      await writeFile("CLAUDE.md", generateRootClaudeMd(config));
+      await writeFile(".claude/.tiller.json", generateTillerManifest(config, TILLER_VERSION3));
+      s.stop("Done!");
+    } catch (err) {
+      s.stop("Failed.");
+      throw err;
+    }
+    outro3(`Project default mode set to ${newMode}. Commit CLAUDE.md and .tiller.json to share with the team.`);
+  } else {
+    s.start(`Setting personal mode to ${newMode}...`);
+    let existing = {};
+    if (existsSync3(localPath)) {
+      try {
+        const raw = await readFile2(localPath, "utf-8");
+        existing = JSON.parse(raw);
+      } catch {
+      }
+    }
+    const local = { ...existing, mode: newMode };
+    try {
+      await fsWriteFile2(localPath, JSON.stringify(local, null, 2), "utf-8");
+      s.stop("Done!");
+    } catch (err) {
+      s.stop("Failed.");
+      throw err;
+    }
+    outro3(`Personal mode set to ${newMode} in .tiller.local.json (gitignored). Use --project to change the shared default.`);
+  }
+}
+
+// src/commands/workflow.ts
+import { intro as intro4, outro as outro4, spinner as spinner4, cancel as cancel3 } from "@clack/prompts";
+import { readFile as readFile3, writeFile as fsWriteFile3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+var TILLER_VERSION4 = "0.1.0";
+async function workflowCommand(newWorkflow, options) {
+  intro4("tiller-ai workflow \u2014 switch between solo and team");
+  if (newWorkflow !== "solo" && newWorkflow !== "team") {
+    cancel3('Workflow must be "solo" or "team".');
+    process.exit(1);
+  }
+  const manifestPath = resolve4(process.cwd(), ".claude/.tiller.json");
+  if (!existsSync4(manifestPath)) {
+    cancel3("No .claude/.tiller.json found. Is this a Tiller project?");
+    process.exit(1);
+  }
+  let manifest;
+  try {
+    const raw = await readFile3(manifestPath, "utf-8");
+    manifest = JSON.parse(raw);
+  } catch {
+    cancel3("Failed to read .claude/.tiller.json.");
+    process.exit(1);
+  }
+  const localPath = resolve4(process.cwd(), ".tiller.local.json");
+  const isProjectScope = options.project === true;
+  if (!isProjectScope) {
+    let localWorkflow;
+    if (existsSync4(localPath)) {
+      try {
+        const raw = await readFile3(localPath, "utf-8");
+        const local = JSON.parse(raw);
+        localWorkflow = local.workflow;
+      } catch {
+      }
+    }
+    if (localWorkflow === newWorkflow) {
+      outro4(`Already on ${newWorkflow} workflow (local override).`);
+      return;
+    }
+  } else {
+    if ((manifest.workflow ?? "solo") === newWorkflow) {
+      outro4(`Already on ${newWorkflow} workflow (project default).`);
+      return;
+    }
+  }
+  const rootClaudePath = resolve4(process.cwd(), "CLAUDE.md");
+  let projectName = manifest.projectName ?? "";
+  let description = manifest.description ?? "";
+  if (existsSync4(rootClaudePath)) {
+    try {
+      const raw = await readFile3(rootClaudePath, "utf-8");
+      const nameMatch = raw.match(/^# (.+)$/m);
+      const descMatch = raw.match(/^# .+\n\n(.+)/m);
+      if (nameMatch) projectName = nameMatch[1];
+      if (descMatch) description = descMatch[1];
+    } catch {
+    }
+  }
+  const s = spinner4();
+  if (isProjectScope) {
+    s.start(`Switching project default to ${newWorkflow} workflow...`);
+    const config = {
+      projectName,
+      description,
+      runCommand: manifest.runCommand,
+      mode: manifest.mode ?? "detailed",
+      workflow: newWorkflow
+    };
+    try {
+      await fsWriteFile3(rootClaudePath, generateRootClaudeMd(config), "utf-8");
+      await fsWriteFile3(manifestPath, generateTillerManifest(config, TILLER_VERSION4), "utf-8");
+      s.stop("Done!");
+    } catch (err) {
+      s.stop("Failed.");
+      throw err;
+    }
+    outro4(`Project default workflow set to ${newWorkflow}. Commit CLAUDE.md and .tiller.json to share with the team.`);
+  } else {
+    s.start(`Setting personal workflow to ${newWorkflow}...`);
+    let existing = {};
+    if (existsSync4(localPath)) {
+      try {
+        const raw = await readFile3(localPath, "utf-8");
+        existing = JSON.parse(raw);
+      } catch {
+      }
+    }
+    const local = { ...existing, workflow: newWorkflow };
+    try {
+      await fsWriteFile3(localPath, JSON.stringify(local, null, 2), "utf-8");
+      s.stop("Done!");
+    } catch (err) {
+      s.stop("Failed.");
+      throw err;
+    }
+    outro4(`Personal workflow set to ${newWorkflow} in .tiller.local.json (gitignored). Use --project to change the shared default.`);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("tiller").description("Scaffold Claude Code projects with a structured vibe loop").version("0.1.0");
+program.command("init").description("Scaffold Tiller files in the current directory").action(initCommand);
+program.command("upgrade").description("Update hooks and skills in an existing Tiller project").action(upgradeCommand);
+program.command("mode").description("Switch between simple and detailed mode").argument("<mode>", "Mode: simple or detailed").option("--project", "Set the shared project default instead of your personal override").action(modeCommand);
+program.command("workflow").description("Switch between solo and team workflow").argument("<workflow>", "Workflow: solo or team").option("--project", "Set the shared project default instead of your personal override").action(workflowCommand);
+program.parse();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "tiller-ai",
+  "version": "0.1.0",
+  "description": "Scaffold Claude Code projects with a structured vibe loop",
+  "type": "module",
+  "bin": {
+    "tiller-ai": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "regen": "tsx scripts/regen-skills.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "ai-workflow",
+    "scaffold",
+    "cli",
+    "vibe-coding",
+    "developer-tools",
+    "code-generation",
+    "project-scaffold"
+  ],
+  "license": "MIT"
+}