fg-devkit 1.23.1 → 1.24.1

package/README.md

@@ -89,12 +89,27 @@ To set up Lefthook git hooks:
 pnpm exec fgd setup-lefthook
 ```
 
+To use the shared AI rules from [feelgood/fg-ai-rules](https://github.com/feelgood/fg-ai-rules) in Claude Code:
+
+```bash
+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
+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`.
+
 Run full consumer setup in one command:
 
 ```bash
 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.
+
 ## Dependency policy update workflow
 
 Check outdated policy versions:

package/configs/dependency-policy.vue-workspace.json

@@ -18,7 +18,7 @@
       "@lexical/link": "0.52.0",
       "@piwikpro/vue-piwik-pro": "2.0.0",
       "@sentry/vue": "11.7.0",
-      "@tanstack/vue-query": "5.104.2",
+      "@tanstack/vue-query": "5.104.3",
       "@types/leaflet": "1.9.22",
       "@unhead/vue": "2.0.5",
       "@vue-leaflet/vue-leaflet": "0.10.1",
@@ -38,7 +38,7 @@
       "lodash-es": "4.18.1",
       "markdown-it": "15.0.2",
       "pinia": "4.1.0",
-      "playwright": "1.64.0",
+      "playwright": "1.64.1",
       "quill": "2.0.3",
       "randexp": "0.5.3",
       "register-service-worker": "1.7.2",
@@ -56,14 +56,14 @@
     "devDependencies": {
       "@chromatic-com/storybook": "5.5.1",
       "@eslint/js": "9.39.1",
-      "@intlify/unplugin-vue-i18n": "11.2.5",
-      "@playwright/test": "1.64.0",
+      "@intlify/unplugin-vue-i18n": "11.2.6",
+      "@playwright/test": "1.64.1",
       "@storybook/addon-a11y": "10.6.2",
       "@storybook/addon-docs": "10.6.2",
       "@storybook/addon-vitest": "10.6.2",
       "@storybook/vue3": "10.6.2",
       "@storybook/vue3-vite": "10.6.2",
-      "@tanstack/vue-query-devtools": "6.3.2",
+      "@tanstack/vue-query-devtools": "6.3.3",
       "@tsconfig/node22": "22.0.6",
       "@types/lodash-es": "4.17.12",
       "@types/node": "22.16.5",
@@ -92,7 +92,7 @@
     "@tailwindcss/vite": "4.3.3",
     "@vitejs/plugin-vue": "6.0.10",
     "axios": "1.20.0",
-    "dotenv": "18.0.7",
+    "dotenv": "18.0.8",
     "qrcode.vue": "3.11.0",
     "tailwindcss": "4.3.3",
     "vite": "8.3.4",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fg-devkit",
-  "version": "1.23.1",
+  "version": "1.24.1",
   "description": "Shared configs, scripts, and DX tooling for Vue / TypeScript frontend repos",
   "type": "module",
   "license": "UNLICENSED",
@@ -26,8 +26,7 @@
     "./release-notes/format": "./release-notes/format.ts",
     "./release-notes/types": "./release-notes/types.ts",
     "./configs/cliff.toml": "./configs/cliff.toml",
-    "./configs/cliff.user.toml": "./configs/cliff.user.toml",
-    "./cursor-rules/core-coding-standards.mdc": "./.cursor/rules/core-coding-standards.mdc"
+    "./configs/cliff.user.toml": "./configs/cliff.user.toml"
   },
   "files": [
     "configs",
@@ -36,8 +35,7 @@
     "!**/node_modules",
     "!**/node_modules/**",
     "scripts",
-    "tsconfig.json",
-    ".cursor/rules/core-coding-standards.mdc"
+    "tsconfig.json"
   ],
   "engines": {
     "node": ">=22.13.0"

package/scaffold/vue/package.json

@@ -16,11 +16,11 @@
   },
   "dependencies": {
     "@tailwindcss/vite": "4.3.3",
-    "@tanstack/vue-query": "5.104.2",
+    "@tanstack/vue-query": "5.104.3",
     "axios": "1.20.0",
     "content-disposition-header": "0.6.0",
     "date-fns": "4.4.0",
-    "dotenv": "18.0.7",
+    "dotenv": "18.0.8",
     "fds-vue-core": "8.11.0",
     "pinia": "4.1.0",
     "qrcode.vue": "3.11.0",
@@ -29,10 +29,10 @@
     "vue-router": "5.4.0"
   },
   "devDependencies": {
-    "@intlify/unplugin-vue-i18n": "11.2.5",
-    "@tanstack/vue-query-devtools": "6.3.2",
+    "@intlify/unplugin-vue-i18n": "11.2.6",
+    "@tanstack/vue-query-devtools": "6.3.3",
     "@types/node": "22.16.5",
-    "fg-devkit": "1.23.1",
+    "fg-devkit": "1.24.1",
     "@vitejs/plugin-vue": "6.0.10",
     "tailwindcss": "4.3.3",
     "tsx": "4.23.15",

package/scripts/fg-devkit.mjs

@@ -23,7 +23,6 @@
  *   pnpm exec fg-devkit sync-tooling-configs   (tooling sync only; overwrites config files)
  *   pnpm exec fg-devkit sync-dependency-check-suppressions-commit [--all]
  *   pnpm exec fg-devkit sync-vscode-settings
- *   pnpm exec fg-devkit sync-core-coding-standards
  *   pnpm exec fg-devkit sync-consumer-scripts
  *   pnpm exec fg-devkit setup-lefthook
  *   pnpm exec fg-devkit full-consumer-setup
@@ -165,6 +164,7 @@ function runSetupLefthook() {
  * - Step 3: sync project configs
  * - Step 2: sync dependency policy
  * - Then run pnpm install
+ * - Set up the fg-ai-rules Claude Code plugins (a failure only warns, e.g. without Claude Code)
  */
 function runFullConsumerSetup() {
   console.log('[fg-devkit] Running full consumer sync and setup')
@@ -184,7 +184,13 @@ function runFullConsumerSetup() {
   const step2 = runNode('sync-dependency-policy.mjs')
   if (step2 !== 0) return step2
 
-  return runPnpmInstall()
+  const installStep = runPnpmInstall()
+  if (installStep !== 0) return installStep
+
+  if (runNode('setup-ai-rules.mjs') !== 0) {
+    console.warn('[fg-devkit] AI rules were not set up. Run "fgd setup-ai-rules" when Claude Code is available.')
+  }
+  return 0
 }
 
 /** Maintainer flow: run full repo vulnerability audit in fg-devkit root. */
@@ -471,7 +477,6 @@ function runSyncConfigTarget(target) {
   if (target === 'prettier') return syncFileFromTemplate('configs/prettier.sync-stub.js', 'prettier.config.js')
   if (target === 'tsconfig') return syncFileFromTemplate('configs/tsconfig.app.sync.json', 'tsconfig.json')
   if (target === 'dependency-check') return runNode('sync-dependency-check-suppressions-commit.mjs')
-  if (target === 'cursor') return runNode('sync-core-coding-standards.mjs')
   if (target === 'vue-inspector') return runNode('sync-vite-plugin-vue-inspector.mjs')
   if (target === 'all') return runNode('sync-project-configs.mjs')
   console.error(`[fg-devkit] Unknown config sync target: ${target}`)
@@ -504,9 +509,9 @@ const DIRECT_COMMANDS = {
   'sync-tooling-configs': 'sync-tooling-configs.mjs',
   'sync-dependency-check-suppressions-commit': 'sync-dependency-check-suppressions-commit.mjs',
   'sync-vscode-settings': 'sync-vscode-settings.mjs',
-  'sync-core-coding-standards': 'sync-core-coding-standards.mjs',
   'sync-vite-plugin-vue-inspector': 'sync-vite-plugin-vue-inspector.mjs',
   'sync-consumer-scripts': 'sync-consumer-scripts.mjs',
+  'setup-ai-rules': 'setup-ai-rules.mjs',
   'sync-release-notes-config': 'sync-release-notes-config.mjs',
   'generate-release-notes': 'generate-release-notes.mjs',
   'verify-release-notes': 'verify-release-notes.mjs',
@@ -569,11 +574,11 @@ Commands:
   sync-dependency-check-suppressions-commit [--all]
                                  Write the dependency-check suppressions that match pnpm audit findings and auto-commit (--all: copy every entry)
   sync-vscode-settings            Copy shared VS Code settings into .vscode/settings.json
-  sync-core-coding-standards      Copy .cursor core coding standards with consumer package name
   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
-  full-consumer-setup             Run: scripts -> lefthook -> step 3 -> step 2 -> pnpm install
+  setup-ai-rules                  Enable the fg-ai-rules Claude Code plugins in this repo, install them once per machine
+  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
                                  (alias: createRelease)
@@ -1061,7 +1066,6 @@ async function runInteractiveMenu() {
             value: 'dependency-check',
             description: 'Write the suppressions that match pnpm audit findings',
           },
-          { name: 'Cursor rules', value: 'cursor', description: 'Write .cursor/rules/core-coding-standards.mdc' },
           {
             name: autoCommit('Vue inspector'),
             value: 'vue-inspector',
@@ -1086,10 +1090,15 @@ async function runInteractiveMenu() {
             value: 'lefthook',
             description: 'Write lefthook.yml and install the git hooks',
           },
+          {
+            name: 'AI rules',
+            value: 'ai-rules',
+            description: 'Enable the fg-ai-rules plugins in .claude/settings.json and install them for Claude Code',
+          },
           {
             name: 'Full setup',
             value: 'full-consumer-setup',
-            description: 'Sync scripts, Lefthook, configs and dependency policy, then pnpm install',
+            description: 'Sync scripts, Lefthook, configs and dependency policy, pnpm install, then set up AI rules',
           },
           { name: 'Cancel', value: 'cancel' },
         ],
@@ -1097,6 +1106,7 @@ async function runInteractiveMenu() {
         loop: false,
       })
       if (choice === 'cancel') continue
+      if (choice === 'ai-rules') return runSelectedAction(() => runNode('setup-ai-rules.mjs'))
       return runSelectedAction(() => (choice === 'lefthook' ? runSetupLefthook() : runFullConsumerSetup()))
     }
 

package/scripts/setup-ai-rules.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * 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.
+ *   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.
+ *
+ * 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
+ */
+
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const TAG = '[setup-ai-rules]'
+const MARKETPLACE = 'fg'
+const MARKETPLACE_REPO = 'feelgood/fg-ai-rules'
+const PLUGINS = ['fg-core', 'fg-frontend']
+
+const projectRoot = fs.realpathSync(process.cwd())
+const settingsPath = path.join(projectRoot, '.claude', 'settings.json')
+
+function claude(args, { capture = false } = {}) {
+  const result = spawnSync('claude', args, {
+    cwd: projectRoot,
+    encoding: 'utf8',
+    stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+  })
+  if (result.error) return { status: 1, stdout: '', missing: result.error.code === 'ENOENT' }
+  return { status: result.status ?? 1, stdout: result.stdout ?? '' }
+}
+
+/** Last JSON line of a command that prints one result line with --json. */
+function claudeJsonLine(args) {
+  const lines = claude([...args, '--json'], { capture: true }).stdout.trim().split('\n')
+  try {
+    return JSON.parse(lines.at(-1))
+  } catch {
+    return null
+  }
+}
+
+function claudeJson(args) {
+  const result = claude([...args, '--json'], { capture: true })
+  if (result.status !== 0) return null
+  try {
+    return JSON.parse(result.stdout)
+  } catch {
+    return null
+  }
+}
+
+/** 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)
+    }
+  }
+  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])),
+  }
+  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:`)
+  console.log(`  claude plugin marketplace add ${MARKETPLACE_REPO}`)
+  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() {
+  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()
+    return 1
+  }
+
+  if (!marketplaces.some((marketplace) => marketplace.name === MARKETPLACE)) {
+    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
+    }
+  }
+
+  const installed = claudeJson(['plugin', 'list']) ?? []
+  let failed = false
+  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.`)
+    } else {
+      console.log(`${TAG} Installing ${plugin}…`)
+      if (claude(['plugin', 'install', id, '--scope', 'user']).status !== 0) {
+        failed = true
+        continue
+      }
+    }
+    // Off at user scope, so only repos whose .claude/settings.json enables it load it.
+    const disabled = claudeJsonLine(['plugin', 'disable', id, '--scope', 'user'])
+    if (!disabled || (disabled.outcome !== 'ok' && !disabled.alreadyInGoalState)) {
+      console.error(`${TAG} Could not disable ${plugin} at user scope: ${disabled?.message ?? 'unknown error'}`)
+      failed = true
+    }
+  }
+  if (failed) {
+    printManualSteps()
+    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())

package/scripts/sync-node-toolchain.mjs

@@ -13,7 +13,6 @@
  */
 
 import fs from 'node:fs'
-import path from 'node:path'
 
 import {
   collectNodeToolchainPolicyViolations,

package/scripts/sync-pnpm-toolchain.mjs

@@ -7,7 +7,6 @@
  */
 
 import fs from 'node:fs'
-import path from 'node:path'
 
 import {
   collectToolchainPolicyViolations,

package/.cursor/rules/core-coding-standards.mdc

@@ -1,291 +0,0 @@
----
-description: Core coding standards for Vue / fds-vue-core frontend projects
-alwaysApply: true
----
-
-# Core Coding Standards
-
-## Keep changes focused
-
-- Make the smallest safe change that solves the request.
-- Avoid unrelated refactors in the same task.
-- Preserve existing behavior unless a behavior change is requested.
-
-## Code comments
-
-- Do not add comments in code unless the user explicitly asks for them.
-- Prefer self-explanatory naming and structure over inline comments.
-- When updating existing code, do not add new comments or expand existing ones unless requested.
-- Exception: update comments only when they are required to keep an existing comment accurate after a behavior change in the same task.
-
-## Communication efficiency
-
-- Do not waste tokens: keep responses concise, high-signal, and scoped to the request.
-- Prefer short summaries over long explanations unless deeper detail is explicitly requested.
-
-## Evidence-first implementation
-
-- Never guess or hallucinate APIs, component props, or framework behavior.
-- Verify implementation details against authoritative sources first (official docs, project code, and library types/source).
-- If documentation is missing or ambiguous, state uncertainty explicitly and choose the safest validated approach.
-
-## Match project conventions
-
-- Follow established naming, file structure, and component patterns.
-- Reuse existing utilities and query/composable patterns before adding new ones.
-- Keep TypeScript types explicit at API boundaries.
-
-## Strict TypeScript
-
-- Keep TypeScript and Vue template typing strict (`strict: true`, `strictTemplates: true`).
-- Do not introduce `any`; use `unknown` for unsafe input and narrow before use.
-- Type API boundaries explicitly (request payloads, response DTOs, mutation variables, callback contracts).
-- Prefer named reusable types under `src/types/<domain>/` for shared domain shapes; re-export from `src/types/index.ts`. Do not keep shared interfaces in views, stores, or query files.
-- Avoid non-null assertions unless guarded by `enabled` checks or equivalent runtime guarantees.
-
-## API boundaries
-
-- Components and views should not call low-level HTTP/API clients directly for feature data fetching.
-- Centralize HTTP and endpoint wiring in a dedicated API layer (for example `src/api/endpoints/*` or the convention used in the repo).
-- Consume server state through query/mutation hooks (for example `src/queries/*` or equivalent), not ad-hoc fetches in UI code.
-
-## Query strings
-
-- Build query strings with `URLSearchParams` (or a shared helper that wraps it).
-- Do not concatenate `key=value` fragments with `&`.
-- Let `URLSearchParams` encode values. Do not interpolate untrusted or user-entered values into URLs.
-- `toString()` has no leading `?`. Prefix it when appending to a path, and skip empty values instead of emitting empty keys.
-- For list views, derive the query string in the view from route filter state (`requestQueryParams` computed). The API layer should accept the query string, not reconstruct filters.
-
-## State-management boundaries
-
-- Use TanStack Query for server state and caching. Do not add Vuex for new work.
-- Use Pinia only for client/app state that is not owned by the server (for example `src/pinia/*`).
-- Do not duplicate the same state across the query cache and Pinia unless the project explicitly documents that pattern.
-- When a project is migrating Vuex → Query/Pinia, follow that repo’s local migration rules (if present) instead of expanding Vuex.
-
-## TanStack Query server-state conventions
-
-- Use TanStack Query for server state; avoid duplicating server data in ad-hoc local state.
-- Keep API calls in the API layer and expose query/mutation hooks from a dedicated hooks folder.
-- Build query keys as stable arrays of serializable primitives; when using refs, key by `.value` in a computed key.
-- Prefer shared query key constants/factories to keep invalidation and cache updates consistent.
-- Add `enabled` guards for required IDs/paths to prevent invalid requests.
-- Use `placeholderData: keepPreviousData` for paginated/filter-driven views to avoid UI flicker.
-- Set `staleTime` intentionally per resource; keep `refetchOnWindowFocus` off unless fresh-on-focus behavior is required.
-- On mutation success, update cache intentionally (`setQueryData`) and/or invalidate the narrowest matching keys.
-- Respect shared query client retry behavior and only override retries when endpoint-specific behavior is needed.
-
-### Query loading UI
-
-TanStack Query v5 flags (do not treat them as interchangeable):
-
-| Flag | Meaning |
-| --- | --- |
-| `isPending` | No cached data yet (`status === 'pending'`) |
-| `isFetching` | Any in-flight request, including background refetch |
-| `isLoading` | First fetch in flight (`isPending && isFetching`) |
-
-Rules:
-
-1. **Content-blocking / full-page spinner** — use `isLoading` (or combine several `isLoading*` flags). Prefer `isLoading` over bare `isPending` when the query can be `enabled: false` (lazy/disabled queries stay `isPending` without fetching).
-2. **Do not use bare `isFetching` for blocking UI** — it re-shows the full loader on every background refetch. Use `isFetching` only for subtle “refreshing” indicators while keeping content visible.
-3. **Paginated / `keepPreviousData` lists** — show a hard loader only when there is nothing useful to render:
-
-```ts
-const isLoading = computed(() => isPending.value || (isFetching.value && !data.value))
-```
-
-4. **Multiple queries for one screen** — combine with OR into one (or purpose-prefixed) computed:
-
-```ts
-const isLoading = computed(() => isLoadingDetails.value || isLoadingList.value)
-```
-
-5. **No passthrough aliases** — do not wrap a single flag (`const loading = computed(() => isFetching.value)`). Destructure and rename instead:
-
-```ts
-const { data, isLoading, error } = useGetDetails(id)
-// template: v-show="isLoading"
-```
-
-6. **Naming** — local query-derived booleans use the `is*` prefix: `isLoading`, `isLoadingUnits`, `isLoadingHistory`. Keep FDS/component prop names as-is (`:loading="isLoading"`). Mutations: rename `isPending` to intent (`isSaving`, `isSubmitting`, `isUploading`).
-
-- TanStack Query boolean flags (`isPending`, `isSuccess`, `isError`) are typed `Ref<false> | Ref<true>`. `vue-tsc` unwraps that union in templates to `boolean`; the Vue language plugin may not.
-- Narrow in script (`const isPending = mutation.isPending as Ref<boolean>`), then bind without `.value` (`:loading="isPending"`). Do not use `.value` in templates (fails `vue-tsc`) and do not add a wrapping `computed` only to satisfy the editor.
-
-## Mutation cache behavior
-
-- Every mutation should define post-success cache behavior.
-- Use `invalidateQueries` for stale collections and `setQueryData` for direct entity updates.
-- Invalidate the narrowest query keys that match changed resources.
-
-## Vue Router conventions
-
-- Organize route definitions in modules (for example `src/router/modules/*`) composed from a single router entry (for example `src/router/index.ts`), matching the repo layout.
-- Every user-facing route should define `meta.title`; provide breadcrumb metadata for detail/flow routes when needed.
-- Use shared route guards for auth/anonymous access control instead of duplicating checks in views.
-- Prefer `props: true` and typed route params in components instead of reading raw params everywhere.
-- Prefer named-route navigation for internal flows (`{ name, params, query }`) and reserve raw path pushes for simple/static redirects.
-- Preserve existing query params intentionally when updating filters, pagination, or tab state.
-- Returning to a view whose filters live in the URL: call `usePreviousLocation` from `fds-vue-core` in setup. `router.push('/path')` drops that query. Browser back keeps it.
-- Use `hrefFor` on `router-link` and `FdsTabsItem`, and `goTo` on back buttons, only when the target is that same view. Leave other navigations unchanged.
-- `hrefFor(path)` reuses the previous history entry, including `_search`, `_page`, and filters, when its pathname matches. Otherwise it returns the path only.
-- `goTo(fallback, matchPaths?)` calls `router.back()` when the previous entry matches, so scroll is kept. Otherwise it pushes the fallback path.
-- Pass `matchPaths` when several paths count as the same place. Without it, only the fallback path is compared.
-
-```ts
-import { usePreviousLocation } from 'fds-vue-core'
-
-const { hrefFor, goTo } = usePreviousLocation()
-
-const goBack = () => {
-  goTo('/services/J4', ['/services/J4', '/services'])
-}
-```
-
-```vue
-<router-link :to="hrefFor(breadcrumb.path)">
-  {{ breadcrumb.name }}
-</router-link>
-<FdsTabsItem :to="hrefFor(tab.path)" />
-<FdsButtonMinor :text="t('common.back')" icon="left" @click="goBack" />
-```
-
-- Lazy-load route components with dynamic imports to keep initial bundles smaller.
-- Name organisation route params by domain meaning, not generic `id`:
-  - top org: `:topClientNumber`
-  - unit/sub-org: `:unitClientNumber`
-  - Prefer `/organisations/:topClientNumber/units/:unitClientNumber` over `:id` / `:clino`.
-- Keep route param names aligned with component props when using `props: true`.
-
-## Vue and UI expectations
-
-- Prefer clear, readable templates over compact but hard-to-follow expressions.
-- Keep components focused; extract repeated UI blocks when duplication grows.
-- Keep localization text in language files instead of hardcoded UI strings.
-
-## FDS-first component usage
-
-- Use `fds-vue-core` components as the default choice for UI building blocks.
-- Multi-step wizards use `FdsWizard` from `fds-vue-core`. Follow the project’s wizard rule file when one exists (for example `.cursor/rules/fds-wizard.md`).
-- Before adding custom UI, check whether an FDS component already solves the use case.
-- Prefer extending composition around FDS components over re-implementing design-system behavior.
-- Keep visual consistency by matching FDS variants, spacing patterns, and interaction styles.
-
-## Asset creation policy
-
-- Do not create icons, images, illustrations, or placeholder content unless explicitly requested.
-- Assume `fds-vue-core` provides the required visual assets and use those first.
-- If a required asset appears missing, clearly point out the gap instead of inventing a replacement.
-
-## FDS typography (fds-vue-core)
-
-- For headings, use `FdsH1`, `FdsH2`, and `FdsH3` (not raw `h1/h2/h3`).
-- `FdsH1/FdsH2/FdsH3` use the `text` prop for content and support `size` (`sm|md|lg|xl|responsive`).
-- When layout spacing needs to be neutralized, reset heading spacing with `class="m-0"` (and add explicit margins as needed).
-- Use `FdsLead` for intro/lead paragraphs, `FdsMeta` for metadata/secondary text, and `FdsLabel` for short labels.
-- `FdsLead`, `FdsMeta`, and `FdsLabel` render slot content; prefer these over custom styled spans for text semantics.
-
-## Tailwind (v4+)
-
-- Use Tailwind v4 patterns and utilities (for example `tailwindcss@4` with `@tailwindcss/vite` where applicable).
-- Prefer utility classes in templates; only add custom CSS when utilities cannot express the design.
-- Follow existing FDS token/preset styling (`fds-vue-core` tokens and preset) instead of inventing parallel design tokens.
-- Always use Tailwind/FDS design tokens for colors, spacing, typography, radius, and shadows.
-- Never invent ad-hoc color values (for example hex/rgb/hsl literals) when a tokenized utility exists.
-- Keep spacing and typography explicit in class names; avoid hidden styling in deep selectors.
-- Use `!` utility overrides sparingly and only when a component default cannot be changed safely.
-- For Tailwind v4 important modifiers, use postfix-important utility syntax (for example `grid-cols-1!`) instead of prefix syntax (for example `!grid-cols-1`).
-- Stack repeated items with parent `flex flex-col gap-*` (or `space-y-*`). Do not use `mb-* last:mb-0` or `last-of-type:mb-*` — those variants often miss the last `v-for` item (extra Vue/FDS nodes) and trip Tailwind conflict lint.
-
-## Figma MCP implementation workflow
-
-- When using Figma MCP, implement the design as specified (layout, spacing, typography, states, and interactions).
-- Treat the Figma file as source of truth for UI behavior unless product/technical constraints are explicitly documented.
-- Primary choice for implementation is `fds-vue-core` components that best match the design intent.
-- Only create custom UI when no suitable FDS component exists; keep custom parts minimal and design-token based.
-- If any Figma detail cannot be implemented exactly, document the deviation and choose the closest FDS-aligned solution.
-
-## i18n and content
-
-- Do not hardcode user-facing copy in templates or script logic; use `t(...)` keys.
-- Add or update locale entries under the project’s language folder (for example `src/lang/*.json`) when introducing new text.
-- Keep translation keys descriptive and grouped by screen/feature.
-- Avoid storing i18n keys inside data/definition arrays (e.g. `i18nKey`) and translating later via dynamic keys or large switch statements. Prefer building definitions with already-translated `label: t('...')` (often as a `computed`) so types stay strict and templates stay simple.
-
-## Formatting and locale consistency
-
-- Prefer shared formatting utilities for date/number/currency output instead of ad-hoc inline formatting.
-- Use Swedish locale conventions (`sv-SE`) unless a feature explicitly requires another locale.
-
-## Accessibility baseline
-
-- Use semantic HTML and accessible FDS components first; avoid click-only `div`/`span` patterns.
-- Ensure form controls have proper labels and required ARIA attributes when needed.
-- All interactive elements must be keyboard reachable and show visible focus states.
-- Provide meaningful accessible names for icon-only actions and links.
-
-## Async UI states
-
-- For data-driven screens, always handle loading, empty, error, and success states explicitly.
-- Use consistent FDS-based feedback patterns for loaders, alerts, and empty-state messaging.
-
-## Error handling UX
-
-- Do not swallow errors silently; surface actionable feedback to users.
-- Use consistent FDS feedback patterns for API failures (alerts/toasts/inline messages).
-- Keep technical error details out of user-facing copy unless explicitly required.
-
-## Performance guardrails
-
-- Avoid unnecessary reactive churn (redundant watchers/computed chains in hot paths).
-- Memoize expensive derived values and keep render-time computations lightweight.
-- Keep route-level and heavy feature components lazy-loaded.
-
-## Security and data handling
-
-- Never commit or expose secrets, tokens, or sensitive identifiers in code, logs, or UI.
-- Validate and sanitize untrusted values from route/query params before use.
-- Type and validate outgoing payloads to prevent accidental over-posting.
-
-## Testing expectations
-
-- Do not add new automated tests unless the user explicitly asks for them.
-- Update existing tests when your change requires it (for example broken assertions, renamed APIs, or changed behavior covered by current tests).
-- When new tests are requested, add them close to the affected feature.
-- Keep tests behavior-focused and avoid brittle implementation-detail assertions.
-- When no new tests are requested, rely on lint, typecheck, and manual verification of critical flows where practical.
-
-## CI/CD
-
-- Treat the repository’s CI configuration as the source of truth (`Jenkinsfile`, GitHub Actions, or equivalent).
-- Prefer frozen lockfile installs in CI (for example `pnpm install --frozen-lockfile --prefer-offline`) so CI matches local installs.
-- Keep build, lint, typecheck, and test stages deterministic; document any project-specific stages (security scans, i18n download, Docker publish) in the repo README or a dedicated rule file.
-
-## Quality checks before finishing
-
-- Run relevant checks for touched code (lint and typecheck when practical).
-- Run and update existing tests when your change affects them; add new tests only when the user explicitly requests them.
-- Fix issues introduced by your change before handing off.
-- Call out anything you could not verify.
-
-## Definition of done
-
-- Lint and type checks pass for touched code.
-- UI matches Figma/FDS expectations and uses tokenized styling.
-- i18n keys, async states, and cache behavior are handled for changed features.
-- Note any constraints, deviations, or unverified parts in handoff.
-
-## Legacy/deprecation policy
-
-- For new work, follow the current preferred patterns in this document.
-- Do not expand usage of known legacy patterns when a supported modern pattern exists.
-- If migration is out of scope, isolate legacy touchpoints and avoid spreading them.
-
-## Example: API data safety
-
-```ts
-// Prefer typed fallbacks when API data may be missing.
-const total = response?.stats?.total ?? 0
-```

package/scripts/sync-core-coding-standards.mjs

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-/**
- * Syncs .cursor/rules/core-coding-standards.mdc into the consumer repo.
- * Rewrites frontmatter description to include the consumer package name.
- *
- * Usage:
- *   node node_modules/fg-devkit/scripts/sync-core-coding-standards.mjs
- *   pnpm exec fg-devkit sync-core-coding-standards
- */
-
-import fs from 'node:fs'
-import path from 'node:path'
-import { findFgDevkitPackageRoot } from './lib/common.mjs'
-
-const projectRoot = process.cwd()
-
-function getConsumerPackageName() {
-  const pkgPath = path.join(projectRoot, 'package.json')
-  if (!fs.existsSync(pkgPath)) {
-    return 'consumer-project'
-  }
-  try {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
-    if (typeof pkg.name === 'string' && pkg.name.trim() !== '') {
-      return pkg.name.trim()
-    }
-  } catch {
-    // fall through to default
-  }
-  return 'consumer-project'
-}
-
-const fgRoot = findFgDevkitPackageRoot(projectRoot)
-if (!fgRoot) {
-  console.error(
-    '[sync-core-coding-standards] Could not find fg-devkit (install fg-devkit or a package that bundles it, e.g. fds-vue-core).',
-  )
-  process.exit(1)
-}
-
-const sourcePath = path.join(fgRoot, '.cursor', 'rules', 'core-coding-standards.mdc')
-if (!fs.existsSync(sourcePath)) {
-  console.error('[sync-core-coding-standards] Missing source rule in fg-devkit package.')
-  process.exit(1)
-}
-
-const destinationPath = path.join(projectRoot, '.cursor', 'rules', 'core-coding-standards.mdc')
-const packageName = getConsumerPackageName()
-
-try {
-  const content = fs.readFileSync(sourcePath, 'utf8')
-  const updated = content.replace(
-    /^description:\s*.*$/m,
-    `description: Core coding standards for ${packageName}`,
-  )
-  fs.mkdirSync(path.dirname(destinationPath), { recursive: true })
-  fs.writeFileSync(destinationPath, updated, 'utf8')
-  console.log(`[sync-core-coding-standards] Updated ${destinationPath}`)
-} catch (err) {
-  console.error(`[sync-core-coding-standards] ${err.message}`)
-  process.exit(1)
-}