fimo 0.17.0 → 0.19.0

package/templates/sveltekit/src/routes/+layout.server.ts

@@ -1,7 +1,12 @@
 import { getLabels } from 'fimo/sveltekit';
 
+import { resolveLocale } from '../locales';
+
 export async function load(event) {
+  const locale = resolveLocale(event.params);
+
   return {
-    labels: await getLabels({ event }),
+    locale,
+    labels: await getLabels({ event, locale }),
   };
 }

package/templates/sveltekit/src/routes/+layout.svelte

@@ -1,10 +1,15 @@
 <script lang="ts">
+  import { afterNavigate } from '$app/navigation';
   import { FimoProvider } from 'fimo/sveltekit/components';
   import type { Snippet } from 'svelte';
 
   import type { LayoutData } from './$types';
 
   let { data, children }: { data: LayoutData; children: Snippet } = $props();
+
+  afterNavigate(() => {
+    document.documentElement.lang = data.locale;
+  });
 </script>
 
 <FimoProvider labels={data.labels}>

package/assets/skills/fimo-migration/references/inventory/coordinator.md

@@ -1,40 +0,0 @@
-# Deterministic inventory coordination
-
-Prepare before running lanes:
-
-```bash
-fimo migrate inventory <project-root> --prepare
-```
-
-Read `inventory-plan.json`, then run each listed area in an independent worker
-that treats application source as read-only:
-
-```bash
-fimo migrate inventory <project-root> --area runtime-config
-fimo migrate inventory <project-root> --area locales
-```
-
-Run only areas present in the plan. The `locales` area is currently planned
-only when the source package manifest declares `next-intl`.
-
-Workers must return the written deterministic fragment, not a prose summary.
-They must read only the source root and write only their planned fragment and
-execution receipt. A worker may report structured unresolved claims in its
-fragment; process outcome and timing belong in the run receipt.
-
-If independent workers are unavailable, run the same areas sequentially:
-
-```bash
-fimo migrate inventory <project-root> --sequential
-```
-
-After every fan-out, run deterministic fan-in:
-
-```bash
-fimo migrate inventory <project-root> --reconcile
-```
-
-Use a separate validator worker that did not produce fragments to compare the
-plan, source evidence, fragments, and unresolved claims. If it finds a gap,
-reopen only the affected area and reconcile again. The CLI never starts an
-LLM or chooses a harness.

package/assets/skills/fimo-migration/references/inventory/locales/next-intl.md

@@ -1,39 +0,0 @@
-# next-intl locale inventory
-
-Use the shipped analyzer after `package.json` proves a next-intl dependency:
-
-```bash
-node <this-skill>/scripts/inventory/locales/next-intl.mjs <source-root>
-```
-
-It detects conventional JSON dictionaries, JSON imports with one dynamic locale
-segment, and static `defineRouting` locale/default-locale values. It emits
-deterministic facts and file/line evidence without changing the source.
-
-If request configuration does not reveal a custom JSON dictionary layout, let
-the agent select one relative pattern containing `{locale}` exactly once:
-
-```bash
-node <this-skill>/scripts/inventory/locales/next-intl.mjs <source-root> \
-  --messages-pattern 'src/translations/{locale}/common.json'
-```
-
-The script rejects absolute paths, paths outside the source root, non-JSON
-patterns, and ambiguous placeholders.
-
-## Support boundary
-
-The analyzer intentionally leaves a claim unresolved when its static source
-shape is unknown. Current gaps include:
-
-- locales/default locale declared only through legacy middleware or navigation
-  helpers;
-- dynamic or remote locale configuration;
-- non-JSON dictionaries such as extracted PO catalogs;
-- public route reachability.
-
-Treat package version as evidence that helps prioritize likely source shapes,
-not as the primary switch. If the analyzer cannot prove a claim, follow the
-temporary read-only strategy in `references/inventory/locales.md`. A zero exit
-code means the analyzer ran successfully; read `unresolved[]` as the exact
-claims still requiring evidence.

package/assets/skills/fimo-migration/references/inventory/locales.md

@@ -1,41 +0,0 @@
-# Locale inventory
-
-Inventory locale evidence without deciding that every dictionary is configured
-or publicly routable.
-
-## Evidence contract
-
-Keep these facts distinct:
-
-- **dictionary candidates**: locale-like values derived from message files or
-  records;
-- **configured locales**: values proven by static application configuration;
-- **default locale**: one statically proven fallback when present;
-- **public locales**: values proven reachable through the application's routes;
-- **unresolved claims**: individual facts that no strategy proved.
-
-A successful script run means evidence collection executed correctly. It does
-not mean every locale claim is known. Preserve proven facts when another claim
-remains unresolved.
-
-## Bounded fallback
-
-1. Run the shipped strategy for the detected locale system.
-2. If the dictionary layout is the only unknown, pass a supported bounded path
-   pattern to that strategy.
-3. If a claim remains unresolved, inspect only the files likely to own it.
-4. When repeated manual reads would be slower or less reliable, let the agent
-   create one disposable script in the harness or operating-system temporary
-   directory, outside the application source tree. The script must:
-   - read only the selected source root;
-   - perform no network calls or source writes;
-   - have explicit file, byte, or time bounds;
-   - print deterministic facts, evidence paths, and unresolved claims;
-   - avoid claiming route reachability from dictionary files alone.
-5. Validate the output, copy its evidence into the canonical ledger, and remove
-   the temporary script. Do not commit it to the migrated application.
-6. At fan-in, compare configured, default, dictionary, and public locales. Keep
-   every mismatch or unproven claim unresolved until evidence settles it.
-
-If the same temporary strategy is needed repeatedly across migrations, turn it
-into a tested shipped script in a separate Fimo change.

package/assets/skills/fimo-migration/scripts/inventory/locales/next-intl.mjs

@@ -1,459 +0,0 @@
-#!/usr/bin/env node
-
-import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-
-const IGNORED_DIRECTORIES = new Set([
-  '.git',
-  '.next',
-  '.output',
-  '.turbo',
-  'build',
-  'coverage',
-  'dist',
-  'node_modules',
-  'public',
-]);
-const SOURCE_EXTENSIONS = new Set(['.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx']);
-const MAX_SOURCE_FILES = 5_000;
-const MAX_SOURCE_BYTES = 1_000_000;
-const MAX_DICTIONARY_FILES = 10_000;
-const CONVENTIONAL_PATTERN = 'messages/{locale}.json';
-
-function fail(message) {
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}
-
-function parseArguments(argv) {
-  if (argv.length === 0) {
-    fail('Usage: next-intl.mjs <source-root> [--messages-pattern <relative-pattern>]');
-  }
-
-  const sourceRoot = argv[0];
-  let messagesPattern;
-
-  for (let index = 1; index < argv.length; index += 1) {
-    if (argv[index] !== '--messages-pattern' || messagesPattern !== undefined || !argv[index + 1]) {
-      fail('Usage: next-intl.mjs <source-root> [--messages-pattern <relative-pattern>]');
-    }
-    messagesPattern = argv[index + 1];
-    index += 1;
-  }
-
-  return { sourceRoot, messagesPattern };
-}
-
-function toPosix(value) {
-  return value.split(path.sep).join('/');
-}
-
-function lineOf(source, offset) {
-  return source.slice(0, offset).split('\n').length;
-}
-
-function validatePattern(patternValue, root) {
-  if (path.isAbsolute(patternValue)) {
-    fail('The messages pattern must be relative to the source root.');
-  }
-  if ((patternValue.match(/\{locale\}/g) ?? []).length !== 1) {
-    fail('The messages pattern must contain {locale} exactly once.');
-  }
-  if (!patternValue.endsWith('.json')) {
-    fail('The messages pattern must point to JSON files.');
-  }
-
-  const normalized = path.normalize(patternValue);
-  if ((normalized.match(/\{locale\}/g) ?? []).length !== 1) {
-    fail('The normalized messages pattern must retain {locale} exactly once.');
-  }
-  const resolved = path.resolve(root, normalized.replace('{locale}', '__locale__'));
-  if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) {
-    fail('The messages pattern must stay inside the source root.');
-  }
-
-  return toPosix(normalized);
-}
-
-function listSourceFiles(root) {
-  const files = [];
-  let truncated = false;
-
-  function visit(directory) {
-    for (const entry of readdirSync(directory, { withFileTypes: true }).sort((left, right) =>
-      left.name.localeCompare(right.name)
-    )) {
-      if (files.length >= MAX_SOURCE_FILES) {
-        truncated = true;
-        return;
-      }
-      const absolute = path.join(directory, entry.name);
-      if (entry.isSymbolicLink()) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        if (!IGNORED_DIRECTORIES.has(entry.name)) {
-          visit(absolute);
-        }
-        continue;
-      }
-      if (
-        entry.isFile() &&
-        SOURCE_EXTENSIONS.has(path.extname(entry.name)) &&
-        lstatSync(absolute).size <= MAX_SOURCE_BYTES
-      ) {
-        files.push(absolute);
-      }
-    }
-  }
-
-  visit(root);
-  return { files, truncated };
-}
-
-function readPackageEvidence(root) {
-  const packagePath = path.join(root, 'package.json');
-  if (!existsSync(packagePath)) {
-    return { declared: false, evidence: [] };
-  }
-
-  let manifest;
-  try {
-    manifest = JSON.parse(readFileSync(packagePath, 'utf8'));
-  } catch {
-    return { declared: false, evidence: [] };
-  }
-
-  const sections = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
-  for (const section of sections) {
-    if (typeof manifest[section]?.['next-intl'] === 'string') {
-      const source = readFileSync(packagePath, 'utf8');
-      const offset = source.indexOf('"next-intl"');
-      return {
-        declared: true,
-        evidence: [
-          {
-            claim: 'next-intl.declared',
-            path: 'package.json',
-            line: lineOf(source, Math.max(offset, 0)),
-            value: manifest[section]['next-intl'],
-          },
-        ],
-      };
-    }
-  }
-
-  return { declared: false, evidence: [] };
-}
-
-function deriveMessagePatterns(files, root) {
-  const findings = [];
-  const importPattern = /import\s*\(\s*`([^`]*\$\{[^}]+\}[^`]*\.json)`\s*\)/g;
-
-  for (const absolute of files) {
-    const source = readFileSync(absolute, 'utf8');
-    for (const match of source.matchAll(importPattern)) {
-      const template = match[1];
-      if ((template.match(/\$\{[^}]+\}/g) ?? []).length !== 1) {
-        continue;
-      }
-      const relativeTemplate = template.replace(/\$\{[^}]+\}/, '{locale}');
-      const resolvedTemplate = path.resolve(path.dirname(absolute), relativeTemplate.replace('{locale}', '__locale__'));
-      if (resolvedTemplate !== root && !resolvedTemplate.startsWith(`${root}${path.sep}`)) {
-        continue;
-      }
-      const rootRelative = toPosix(path.relative(root, resolvedTemplate)).replace('__locale__', '{locale}');
-      findings.push({
-        pattern: rootRelative,
-        source: 'request-config',
-        path: toPosix(path.relative(root, absolute)),
-        line: lineOf(source, match.index ?? 0),
-      });
-    }
-  }
-
-  return findings;
-}
-
-function parseQuotedValues(value) {
-  return [...value.matchAll(/(['"])(.*?)\1/g)].map((match) => match[2]);
-}
-
-function readStaticBindings(source) {
-  const arrays = new Map();
-  const strings = new Map();
-
-  for (const match of source.matchAll(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*\[([^\]]*)\](?:\s+as\s+const)?/g)) {
-    const values = parseQuotedValues(match[2]);
-    if (values.length > 0) {
-      arrays.set(match[1], values);
-    }
-  }
-  for (const match of source.matchAll(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(['"])(.*?)\2/g)) {
-    strings.set(match[1], match[3]);
-  }
-
-  return { arrays, strings };
-}
-
-function readRoutingCandidates(files, root) {
-  const localeCandidates = [];
-  const defaultLocaleCandidates = [];
-
-  for (const absolute of files) {
-    const source = readFileSync(absolute, 'utf8');
-    if (!source.includes('defineRouting')) {
-      continue;
-    }
-    const bindings = readStaticBindings(source);
-
-    for (const match of source.matchAll(/\blocales\s*:\s*(\[[^\]]*\]|[A-Za-z_$][\w$]*)/g)) {
-      const expression = match[1];
-      const locales = expression.startsWith('[') ? parseQuotedValues(expression) : bindings.arrays.get(expression);
-      if (locales?.length) {
-        localeCandidates.push({
-          locales: [...new Set(locales)].sort(),
-          path: toPosix(path.relative(root, absolute)),
-          line: lineOf(source, match.index ?? 0),
-        });
-      }
-    }
-
-    for (const match of source.matchAll(/\bdefaultLocale\s*:\s*(?:(['"])(.*?)\1|([A-Za-z_$][\w$]*))/g)) {
-      const locale = match[2] ?? bindings.strings.get(match[3]);
-      if (locale) {
-        defaultLocaleCandidates.push({
-          locale,
-          path: toPosix(path.relative(root, absolute)),
-          line: lineOf(source, match.index ?? 0),
-        });
-      }
-    }
-  }
-
-  return { localeCandidates, defaultLocaleCandidates };
-}
-
-function uniqueBy(items, keyOf) {
-  const seen = new Set();
-  return items.filter((item) => {
-    const key = keyOf(item);
-    if (seen.has(key)) {
-      return false;
-    }
-    seen.add(key);
-    return true;
-  });
-}
-
-function selectConsistent(items, valueOf) {
-  const values = uniqueBy(items.map(valueOf), (value) => JSON.stringify(value));
-  return values.length === 1 ? values[0] : null;
-}
-
-function inspectDictionaries(root, patterns) {
-  const dictionaries = [];
-  let truncated = false;
-
-  for (const patternEntry of patterns) {
-    const escaped = patternEntry.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace('\\{locale\\}', '([^/]+)');
-    const matcher = new RegExp(`^${escaped}$`);
-    const prefix = patternEntry.pattern.slice(0, patternEntry.pattern.indexOf('{locale}'));
-    const scanRootRelative = prefix.includes('/') ? prefix.slice(0, prefix.lastIndexOf('/')) : '';
-    const scanRoot = path.resolve(root, scanRootRelative || '.');
-    if (!existsSync(scanRoot) || !lstatSync(scanRoot).isDirectory()) {
-      continue;
-    }
-
-    const candidates = [];
-    function visit(directory) {
-      for (const entry of readdirSync(directory, { withFileTypes: true }).sort((left, right) =>
-        left.name.localeCompare(right.name)
-      )) {
-        if (candidates.length >= MAX_DICTIONARY_FILES) {
-          truncated = true;
-          return;
-        }
-        const absolute = path.join(directory, entry.name);
-        if (entry.isSymbolicLink()) {
-          continue;
-        }
-        if (entry.isDirectory()) {
-          if (!IGNORED_DIRECTORIES.has(entry.name)) {
-            visit(absolute);
-          }
-        } else if (entry.isFile() && entry.name.endsWith('.json')) {
-          candidates.push(absolute);
-        }
-      }
-    }
-    visit(scanRoot);
-
-    for (const absolute of candidates) {
-      const relative = toPosix(path.relative(root, absolute));
-      const match = relative.match(matcher);
-      if (match) {
-        dictionaries.push({ locale: match[1], path: relative, pattern: patternEntry.pattern });
-      }
-    }
-  }
-
-  return {
-    dictionaries: uniqueBy(dictionaries, (item) => `${item.locale}\0${item.path}\0${item.pattern}`).sort(
-      (left, right) => left.locale.localeCompare(right.locale) || left.path.localeCompare(right.path)
-    ),
-    truncated,
-  };
-}
-
-const { sourceRoot: sourceRootArgument, messagesPattern: suppliedPattern } = parseArguments(process.argv.slice(2));
-const sourceRoot = path.resolve(sourceRootArgument);
-if (!existsSync(sourceRoot) || !lstatSync(sourceRoot).isDirectory()) {
-  fail(`Source root is not a directory: ${sourceRootArgument}`);
-}
-const canonicalRoot = realpathSync(sourceRoot);
-
-const sourceInspection = listSourceFiles(canonicalRoot);
-const sourceFiles = sourceInspection.files;
-const packageFinding = readPackageEvidence(canonicalRoot);
-const derivedPatterns = deriveMessagePatterns(sourceFiles, canonicalRoot);
-const patterns = [];
-
-if (suppliedPattern) {
-  patterns.push({ pattern: validatePattern(suppliedPattern, canonicalRoot), source: 'agent-supplied' });
-} else {
-  for (const finding of derivedPatterns) {
-    patterns.push({ pattern: validatePattern(finding.pattern, canonicalRoot), source: finding.source });
-  }
-  if (existsSync(path.join(canonicalRoot, 'messages'))) {
-    patterns.push({ pattern: CONVENTIONAL_PATTERN, source: 'conventional' });
-  }
-}
-
-const uniquePatterns = uniqueBy(patterns, (item) => item.pattern).sort((left, right) =>
-  left.pattern.localeCompare(right.pattern)
-);
-const dictionaryInspection = inspectDictionaries(canonicalRoot, uniquePatterns);
-const dictionaries = dictionaryInspection.dictionaries;
-const routing = readRoutingCandidates(sourceFiles, canonicalRoot);
-const configuredLocales = selectConsistent(routing.localeCandidates, (item) => item.locales);
-const defaultLocale = selectConsistent(routing.defaultLocaleCandidates, (item) => item.locale);
-const dictionaryLocales = [...new Set(dictionaries.map((item) => item.locale))].sort();
-const unresolved = [];
-
-if (sourceInspection.truncated) {
-  unresolved.push({ code: 'source-scan-truncated', claim: `Source scanning stopped after ${MAX_SOURCE_FILES} files.` });
-}
-if (!packageFinding.declared) {
-  unresolved.push({
-    code: 'next-intl-not-declared',
-    claim: 'Whether this project uses next-intl is not proven by package.json.',
-  });
-}
-if (uniquePatterns.length === 0) {
-  unresolved.push({
-    code: 'messages-pattern-not-found',
-    claim: 'The location of next-intl message dictionaries is not proven.',
-  });
-} else if (dictionaries.length === 0) {
-  unresolved.push({
-    code: 'message-dictionaries-not-found',
-    claim: 'No JSON message dictionaries matched the selected pattern.',
-  });
-}
-if (dictionaryInspection.truncated) {
-  unresolved.push({
-    code: 'dictionary-scan-truncated',
-    claim: `Dictionary scanning stopped after ${MAX_DICTIONARY_FILES} JSON files.`,
-  });
-}
-if (routing.localeCandidates.length === 0) {
-  unresolved.push({
-    code: 'configured-locales-not-found',
-    claim: 'The statically configured next-intl locales are not proven.',
-  });
-} else if (configuredLocales === null) {
-  unresolved.push({
-    code: 'configured-locales-conflict',
-    claim: 'Static routing files declare different locale lists.',
-  });
-}
-if (routing.defaultLocaleCandidates.length === 0) {
-  unresolved.push({
-    code: 'default-locale-not-found',
-    claim: 'The statically configured next-intl default locale is not proven.',
-  });
-} else if (defaultLocale === null) {
-  unresolved.push({
-    code: 'default-locale-conflict',
-    claim: 'Static routing files declare different default locales.',
-  });
-}
-if (configuredLocales) {
-  for (const locale of configuredLocales.filter((value) => !dictionaryLocales.includes(value))) {
-    unresolved.push({
-      code: 'configured-locale-without-dictionary',
-      claim: `Configured locale ${locale} has no matching message dictionary.`,
-      locale,
-    });
-  }
-  for (const locale of dictionaryLocales.filter((value) => !configuredLocales.includes(value))) {
-    unresolved.push({
-      code: 'dictionary-locale-not-configured',
-      claim: `Message dictionary locale ${locale} is not in the static routing configuration.`,
-      locale,
-    });
-  }
-}
-if (defaultLocale && configuredLocales && !configuredLocales.includes(defaultLocale)) {
-  unresolved.push({
-    code: 'default-locale-not-configured',
-    claim: `Default locale ${defaultLocale} is not in the static routing configuration.`,
-    locale: defaultLocale,
-  });
-}
-
-const evidence = [
-  ...packageFinding.evidence,
-  ...derivedPatterns
-    .filter((item) => uniquePatterns.some((patternEntry) => patternEntry.pattern === item.pattern))
-    .map((item) => ({ claim: 'messages.pattern', path: item.path, line: item.line, value: item.pattern })),
-  ...dictionaries.map((item) => ({ claim: 'messages.dictionary', path: item.path, line: 1, value: item.locale })),
-  ...routing.localeCandidates.map((item) => ({
-    claim: 'routing.locales',
-    path: item.path,
-    line: item.line,
-    value: item.locales,
-  })),
-  ...routing.defaultLocaleCandidates.map((item) => ({
-    claim: 'routing.defaultLocale',
-    path: item.path,
-    line: item.line,
-    value: item.locale,
-  })),
-].sort(
-  (left, right) =>
-    left.path.localeCompare(right.path) || left.line - right.line || left.claim.localeCompare(right.claim)
-);
-
-const result = {
-  version: 1,
-  area: 'locales',
-  facts: {
-    system: 'next-intl',
-    declared: packageFinding.declared,
-    messagesPatterns: uniquePatterns,
-    dictionaryCandidates: dictionaries,
-    configuredLocaleCandidates: routing.localeCandidates,
-    configuredLocales,
-    defaultLocaleCandidates: routing.defaultLocaleCandidates,
-    defaultLocale,
-  },
-  evidence,
-  unresolved: unresolved.sort(
-    (left, right) => left.code.localeCompare(right.code) || (left.locale ?? '').localeCompare(right.locale ?? '')
-  ),
-};
-
-process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/templates/nextjs/src/app/layout.tsx

@@ -1,17 +0,0 @@
-import { FimoProvider } from 'fimo/next/client';
-import type { ReactNode } from 'react';
-
-import './globals.css';
-
-export default function RootLayout({ children }: Readonly<{ children: ReactNode }>) {
-  const previewScriptUrl = process.env.NEXT_PUBLIC_FIMO_PREVIEW_SCRIPT_URL;
-
-  return (
-    <html lang="en">
-      <body>
-        <FimoProvider>{children}</FimoProvider>
-        {previewScriptUrl ? <script src={previewScriptUrl} defer /> : null}
-      </body>
-    </html>
-  );
-}