fg-devkit 1.24.1 → 1.24.3

package/README.md

@@ -95,11 +95,13 @@ To use the shared AI rules from [feelgood/fg-ai-rules](https://github.com/feelgo
 pnpm exec fgd setup-ai-rules
 ```
 
-It enables the `fg-core` and `fg-frontend` plugins in `.claude/settings.json`, adds the `fg` marketplace
-to Claude Code if it is missing, and installs the plugins once for the user, disabled at user scope. The
+It adds the `fg` marketplace to Claude Code if it is missing and asks which of its plugins the repo
+should use (the repo's current choice, or `fg-core` and `fg-frontend`, is preselected; pass
+`--plugins=fg-core,fg-backend` to skip the question). It enables those in `.claude/settings.json` and
+installs them once for the user, disabled at user scope. The
 repo's `.claude/settings.json` then switches them on, so every repo that commits that file gets the rules
-and other repos don't. Each developer runs it once on their machine; commit `.claude/settings.json` in
-each repo. Needs Claude Code and SSH access to `feelgood/fg-ai-rules`.
+and other repos don't. When `.claude/settings.json` changed it commits that file on its own
+(`chore(repo): enable fg-ai-rules Claude Code plugins`). Each developer runs it once on their machine. Needs Claude Code and SSH access to `feelgood/fg-ai-rules`.
 
 Run full consumer setup in one command:
 
@@ -108,7 +110,7 @@ pnpm exec fgd full-consumer-setup
 ```
 
 It syncs the consumer scripts, Lefthook, configs and dependency policy, runs `pnpm install`, and finishes with
-`setup-ai-rules`. Without Claude Code that last step only prints a warning.
+`setup-ai-rules`, which commits `.claude/settings.json`. Without Claude Code that last step only prints a warning.
 
 ## Dependency policy update workflow
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fg-devkit",
-  "version": "1.24.1",
+  "version": "1.24.3",
   "description": "Shared configs, scripts, and DX tooling for Vue / TypeScript frontend repos",
   "type": "module",
   "license": "UNLICENSED",

package/scaffold/vue/package.json

@@ -32,7 +32,7 @@
     "@intlify/unplugin-vue-i18n": "11.2.6",
     "@tanstack/vue-query-devtools": "6.3.3",
     "@types/node": "22.16.5",
-    "fg-devkit": "1.24.1",
+    "fg-devkit": "1.24.3",
     "@vitejs/plugin-vue": "6.0.10",
     "tailwindcss": "4.3.3",
     "tsx": "4.23.15",

package/scripts/fg-devkit.mjs

@@ -577,7 +577,7 @@ Commands:
   sync-vite-plugin-vue-inspector  Add/pin vite-plugin-vue-inspector, wire vite.config, install, commit
   sync-consumer-scripts           Enforce standard fgd scripts in consumer package.json
   setup-lefthook                  Write lefthook.yml and install the git hooks
-  setup-ai-rules                  Enable the fg-ai-rules Claude Code plugins in this repo, install them once per machine
+  setup-ai-rules [--plugins=a,b]  Pick the fg-ai-rules Claude Code plugins for this repo, install them once per machine, commit
   full-consumer-setup             Run: scripts -> lefthook -> step 3 -> step 2 -> pnpm install -> AI rules
   create-release [release|candidate] [patch|minor|major] [--skip-release-notes]
                                  Stable release or candidate (X.Y.Z-rc.N); omit = interactive menu
@@ -1091,14 +1091,14 @@ async function runInteractiveMenu() {
             description: 'Write lefthook.yml and install the git hooks',
           },
           {
-            name: 'AI rules',
+            name: tagged('AI rules', { interactive: true, autoCommit: true }),
             value: 'ai-rules',
-            description: 'Enable the fg-ai-rules plugins in .claude/settings.json and install them for Claude Code',
+            description: 'Pick the fg-ai-rules plugins for this repo, install them for Claude Code and commit .claude/settings.json',
           },
           {
             name: 'Full setup',
             value: 'full-consumer-setup',
-            description: 'Sync scripts, Lefthook, configs and dependency policy, pnpm install, then set up AI rules',
+            description: 'Sync scripts, Lefthook, configs and dependency policy, pnpm install, then set up AI rules (commits .claude/settings.json)',
           },
           { name: 'Cancel', value: 'cancel' },
         ],

package/scripts/setup-ai-rules.mjs

@@ -2,32 +2,41 @@
 /**
  * Set up the shared AI rules from feelgood/fg-ai-rules for Claude Code in the current repo:
  *
- *   1. Add the `fg` marketplace and enable fg-core and fg-frontend in .claude/settings.json,
- *      keeping every other setting.
- *   2. Add the marketplace to Claude Code on this machine if it is missing.
+ *   1. Add the `fg` marketplace to Claude Code on this machine if it is missing, or refresh it.
+ *   2. Ask which of its plugins the repo should use (a checklist; the repo's current choice, or
+ *      fg-core and fg-frontend, is preselected) and write them to .claude/settings.json, keeping
+ *      every other setting. --plugins=fg-core,fg-backend picks them without asking.
  *   3. Install the plugins once for the user (`--scope user`) and disable them at user scope.
  *      Claude Code doesn't install plugins from a repo's settings file on its own, and a
  *      project-scope install only covers one repo. A user-scope install covers every repo, and
  *      disabling it at user scope leaves the repo's .claude/settings.json to switch it on.
  *
+ *   4. Commit .claude/settings.json when it changed (only that file).
+ *
  * Safe to run again: it only changes what is missing. Once a developer has run it in any repo,
  * every other repo that commits the same .claude/settings.json works without running it again.
  *
  * Usage:
- *   pnpm exec fg-devkit setup-ai-rules
+ *   pnpm exec fg-devkit setup-ai-rules [--plugins=fg-core,fg-frontend]
  */
 
 import { spawnSync } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 
+import { fileDiffersFromHead, readJson, runGit } from './lib/common.mjs'
+
 const TAG = '[setup-ai-rules]'
 const MARKETPLACE = 'fg'
 const MARKETPLACE_REPO = 'feelgood/fg-ai-rules'
-const PLUGINS = ['fg-core', 'fg-frontend']
+const DEFAULT_PLUGINS = ['fg-core', 'fg-frontend']
+const pluginsArg = process.argv.slice(2).find((arg) => arg.startsWith('--plugins='))
 
 const projectRoot = fs.realpathSync(process.cwd())
-const settingsPath = path.join(projectRoot, '.claude', 'settings.json')
+const SETTINGS_FILE = '.claude/settings.json'
+const COMMIT_MESSAGE = 'chore(repo): enable fg-ai-rules Claude Code plugins'
+const settingsPath = path.join(projectRoot, SETTINGS_FILE)
+const GIT = { cwd: projectRoot, tag: TAG }
 
 function claude(args, { capture = false } = {}) {
   const result = spawnSync('claude', args, {
@@ -59,69 +68,147 @@ function claudeJson(args) {
   }
 }
 
-/** Add the marketplace and enabled plugins to .claude/settings.json. Returns true when it changed. */
-function updateSettings() {
-  let settings = {}
-  if (fs.existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
-    } catch (err) {
-      console.error(`${TAG} Could not parse ${settingsPath}: ${err.message}`)
-      process.exit(1)
+function readSettings() {
+  if (!fs.existsSync(settingsPath)) return {}
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+  } catch (err) {
+    console.error(`${TAG} Could not parse ${settingsPath}: ${err.message}`)
+    process.exit(1)
+  }
+}
+
+/** Plugins this repo enables from the marketplace. */
+function enabledInRepo(settings) {
+  return Object.entries(settings.enabledPlugins ?? {})
+    .filter(([id, enabled]) => enabled && id.endsWith(`@${MARKETPLACE}`))
+    .map(([id]) => id.slice(0, -`@${MARKETPLACE}`.length))
+}
+
+/** Plugins listed in the marketplace on this machine: `[{ name, description }]`. */
+function marketplacePlugins(installLocation) {
+  try {
+    return readJson(path.join(installLocation, '.claude-plugin', 'marketplace.json')).plugins ?? []
+  } catch {
+    return []
+  }
+}
+
+async function choosePlugins(available, settings) {
+  const names = available.map((plugin) => plugin.name)
+  if (pluginsArg) {
+    const chosen = pluginsArg.slice('--plugins='.length).split(',').filter(Boolean)
+    const unknown = chosen.filter((name) => !names.includes(name))
+    if (unknown.length > 0) {
+      console.error(`${TAG} Unknown plugin(s): ${unknown.join(', ')}. Available: ${names.join(', ')}`)
+      return null
     }
+    return chosen
   }
+  const current = enabledInRepo(settings).filter((name) => names.includes(name))
+  const preselected = current.length > 0 ? current : DEFAULT_PLUGINS.filter((name) => names.includes(name))
+  if (!process.stdin.isTTY) return preselected
+  const checkbox = (await import('@inquirer/checkbox')).default
+  return checkbox({
+    message: 'Which fg-ai-rules plugins should this repo use?',
+    choices: available.map((plugin) => ({
+      name: plugin.name,
+      value: plugin.name,
+      description: plugin.description,
+      checked: preselected.includes(plugin.name),
+    })),
+    required: true,
+  })
+}
+
+/** Enable the chosen plugins in .claude/settings.json and drop the other fg ones. Returns true when it changed. */
+function updateSettings(settings, plugins) {
   const before = JSON.stringify(settings)
   settings.extraKnownMarketplaces = {
     ...settings.extraKnownMarketplaces,
     [MARKETPLACE]: { source: { source: 'github', repo: MARKETPLACE_REPO }, autoUpdate: true },
   }
-  settings.enabledPlugins = {
-    ...settings.enabledPlugins,
-    ...Object.fromEntries(PLUGINS.map((plugin) => [`${plugin}@${MARKETPLACE}`, true])),
-  }
+  const others = Object.entries(settings.enabledPlugins ?? {}).filter(([id]) => !id.endsWith(`@${MARKETPLACE}`))
+  settings.enabledPlugins = Object.fromEntries([
+    ...others,
+    ...plugins.map((plugin) => [`${plugin}@${MARKETPLACE}`, true]),
+  ])
   if (JSON.stringify(settings) === before) return false
   fs.mkdirSync(path.dirname(settingsPath), { recursive: true })
   fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`)
   return true
 }
 
-function printManualSteps() {
-  console.log(`${TAG} Run these from the repo root, then restart Claude Code:`)
+/** Commit .claude/settings.json on its own when it differs from HEAD. */
+function commitSettings() {
+  if (runGit(['rev-parse', '--is-inside-work-tree'], { ...GIT, capture: true }).status !== 0) {
+    console.log(`${TAG} Not a git repository; commit ${SETTINGS_FILE} yourself.`)
+    return 0
+  }
+  if (!fileDiffersFromHead(SETTINGS_FILE, GIT)) return 0
+  const status =
+    runGit(['add', '--', SETTINGS_FILE], GIT).status ||
+    runGit(['commit', '-m', COMMIT_MESSAGE, '--', SETTINGS_FILE], GIT).status
+  if (status !== 0) console.error(`${TAG} Could not commit ${SETTINGS_FILE}.`)
+  return status
+}
+
+function printManualSteps(plugins) {
+  console.log(`${TAG} Run these, then restart Claude Code:`)
   console.log(`  claude plugin marketplace add ${MARKETPLACE_REPO}`)
-  for (const plugin of PLUGINS) {
+  for (const plugin of plugins) {
     console.log(`  claude plugin install ${plugin}@${MARKETPLACE} --scope user`)
     console.log(`  claude plugin disable ${plugin}@${MARKETPLACE} --scope user`)
   }
 }
 
-function main() {
+async function main() {
   if (!fs.existsSync(path.join(projectRoot, 'package.json'))) {
     console.error(`${TAG} Run from the repo root (no package.json in ${projectRoot}).`)
     return 1
   }
 
-  const settingsChanged = updateSettings()
-  console.log(`${TAG} ${settingsChanged ? 'Updated' : 'Already up to date:'} .claude/settings.json`)
-
   const marketplaces = claudeJson(['plugin', 'marketplace', 'list'])
   if (marketplaces === null) {
     const missing = claude(['--version'], { capture: true }).missing
     console.error(`${TAG} ${missing ? 'Claude Code (claude) is not installed.' : 'Could not read Claude Code plugins.'}`)
-    printManualSteps()
+    printManualSteps(DEFAULT_PLUGINS)
     return 1
   }
 
-  if (!marketplaces.some((marketplace) => marketplace.name === MARKETPLACE)) {
+  let marketplace = marketplaces.find((entry) => entry.name === MARKETPLACE)
+  if (marketplace) {
+    // Refresh so the checklist shows plugins added to fg-ai-rules since the last update.
+    claude(['plugin', 'marketplace', 'update', MARKETPLACE], { capture: true })
+  } else {
     console.log(`${TAG} Adding the ${MARKETPLACE} marketplace (${MARKETPLACE_REPO})…`)
     if (claude(['plugin', 'marketplace', 'add', MARKETPLACE_REPO]).status !== 0) {
       console.error(`${TAG} Could not add the marketplace. Check that you can clone ${MARKETPLACE_REPO} over SSH.`)
       return 1
     }
+    marketplace = claudeJson(['plugin', 'marketplace', 'list'])?.find((entry) => entry.name === MARKETPLACE)
   }
 
+  const available = marketplacePlugins(marketplace?.installLocation ?? '')
+  if (available.length === 0) {
+    console.error(`${TAG} Could not read the plugins in the ${MARKETPLACE} marketplace.`)
+    return 1
+  }
+
+  const settings = readSettings()
+  const plugins = await choosePlugins(available, settings)
+  if (!plugins) return 1
+  if (plugins.length === 0) {
+    console.error(`${TAG} No plugins chosen.`)
+    return 1
+  }
+
+  const settingsChanged = updateSettings(settings, plugins)
+  console.log(`${TAG} ${settingsChanged ? 'Updated' : 'Already up to date:'} ${SETTINGS_FILE} (${plugins.join(', ')})`)
+
   const installed = claudeJson(['plugin', 'list']) ?? []
   let failed = false
-  for (const plugin of PLUGINS) {
+  for (const plugin of plugins) {
     const id = `${plugin}@${MARKETPLACE}`
     if (installed.some((entry) => entry.id === id && entry.scope === 'user')) {
       console.log(`${TAG} ${plugin} is already installed.`)
@@ -140,13 +227,13 @@ function main() {
     }
   }
   if (failed) {
-    printManualSteps()
+    printManualSteps(plugins)
     return 1
   }
 
+  if (commitSettings() !== 0) return 1
   console.log(`${TAG} Done. Restart Claude Code to load the rules.`)
-  if (settingsChanged) console.log(`${TAG} Commit .claude/settings.json so other repos and teammates get the same plugins.`)
   return 0
 }
 
-process.exit(main())
+process.exit(await main())