@i18nprune/core 0.1.0

package/dist/init.js

@@ -0,0 +1,848 @@
+// src/shared/translator/utils/orchestration.ts
+var DEFAULT_PROVIDER_RATE_LIMITS = {
+  // Google can sustain higher throughput; default to safe-high (32) while allowing user/config up to 64.
+  google: { maxConcurrency: 32, rpm: 1920, rps: 32, intervalMs: 32 },
+  mymemory: { maxConcurrency: 2, rpm: 60, rps: 1, intervalMs: 1e3 },
+  libre: { maxConcurrency: 6, rpm: 120, rps: 2, intervalMs: 500 },
+  deepl: { maxConcurrency: 4, rpm: 90, rps: 1.5, intervalMs: 600 },
+  llm: { maxConcurrency: 2, rpm: 30, rps: 0.5, intervalMs: 1500 }
+};
+var DOCS_SITE_BASE = "https://docs.i18nprune.dev";
+
+// src/shared/docs/urls.ts
+function parseDocsLinkInput(input) {
+  const hashIdx = input.indexOf("#");
+  const hash = hashIdx >= 0 ? input.slice(hashIdx) : "";
+  let p = (hashIdx >= 0 ? input.slice(0, hashIdx) : input).trim().replace(/^\/+/, "");
+  p = p.replace(/\/+$/g, "");
+  if (p.endsWith(".md")) p = p.slice(0, -3);
+  if (p.endsWith(".mdx")) p = p.slice(0, -4);
+  if (p === "README" || p.endsWith("/README")) {
+    p = p === "README" ? "" : p.slice(0, -"/README".length);
+  }
+  p = p.replace(/\/+$/g, "");
+  p = p.replace(/\/+/g, "/");
+  return { core: p, hash };
+}
+function getDocsUrl(path = "") {
+  const { core, hash } = parseDocsLinkInput(path);
+  if (!core) {
+    return `${DOCS_SITE_BASE}${hash}`;
+  }
+  return `${DOCS_SITE_BASE}/${core}${hash}`;
+}
+
+// src/init/presets/fields.ts
+var INIT_PRESET_IDS = [
+  "generic",
+  "i18next",
+  "lingui",
+  "next-i18next",
+  "next-intl",
+  "react-intl"
+];
+function isInitPresetId(value) {
+  return INIT_PRESET_IDS.includes(value);
+}
+function formatInitPresetIdList() {
+  return INIT_PRESET_IDS.join(", ");
+}
+var PRESET_FIELDS = {
+  generic: {
+    locales: { source: "en", directory: "locales" },
+    src: "src",
+    functions: ["t"]
+  },
+  "next-intl": {
+    locales: { source: "en", directory: "messages" },
+    src: "src",
+    functions: ["useTranslations", "t"]
+  },
+  "next-i18next": {
+    locales: { source: "en", directory: "public/locales" },
+    src: "src",
+    functions: ["useTranslation", "t"]
+  },
+  i18next: {
+    locales: { source: "en", directory: "locales" },
+    src: "src",
+    functions: ["t", "i18n.t"]
+  },
+  lingui: {
+    locales: { source: "en", directory: "locales" },
+    src: "src",
+    functions: ["t", "Trans"]
+  },
+  "react-intl": {
+    locales: { source: "en", directory: "locales" },
+    src: "src",
+    functions: ["useIntl", "FormattedMessage"]
+  }
+};
+function getInitPresetConfigFields(preset) {
+  return PRESET_FIELDS[preset];
+}
+
+// src/init/template.ts
+var CACHE_PROFILE_DOCS_URL = getDocsUrl("cli/cache");
+var REFERENCE_DOCS_URL = getDocsUrl("reference");
+var DEFAULT_INIT_CONFIG_IMPORT_SPECIFIER = "i18nprune/core/config";
+function rateLimitLiteral(providerId) {
+  const d = DEFAULT_PROVIDER_RATE_LIMITS[providerId];
+  return `{ maxConcurrency: ${String(d.maxConcurrency)}, rpm: ${String(d.rpm)}, rps: ${String(d.rps)}, intervalMs: ${String(d.intervalMs)} }`;
+}
+var GOOGLE_RATE_LIMIT_LITERAL = rateLimitLiteral("google");
+var MYMEMORY_RATE_LIMIT_LITERAL = rateLimitLiteral("mymemory");
+var LIBRE_RATE_LIMIT_LITERAL = rateLimitLiteral("libre");
+var DEEPL_RATE_LIMIT_LITERAL = rateLimitLiteral("deepl");
+var LLM_RATE_LIMIT_LITERAL = rateLimitLiteral("llm");
+var TRANSLATE_PROVIDER_COMMENT_ROWS = `
+      // The order of \`providers[]\` IS the auto-routing chain (\`policy.routing: 'auto'\` walks
+      // top-to-bottom on retryable failures). \`--provider\` / \`I18NPRUNE_TRANSLATE_PROVIDER\`
+      // pins an id to the FRONT of the chain without disabling fallback. Set \`enabled: false\`
+      // (or comment the row) to skip a provider.
+      // Uncomment one row at a time \xB7 set \`translate.primary\` \xB7 use env vars where noted (run \`i18nprune providers\`).
+      // { id: 'mymemory', enabled: true, contactEmail: 'you@example.com', rateLimit: ${MYMEMORY_RATE_LIMIT_LITERAL} },
+      // { id: 'libre', enabled: true, baseUrl: 'https://libretranslate.com', rateLimit: ${LIBRE_RATE_LIMIT_LITERAL} },
+      // { id: 'deepl', enabled: true, apiKey: process.env.I18NPRUNE_TRANSLATE_DEEPL_API_KEY, rateLimit: ${DEEPL_RATE_LIMIT_LITERAL} },
+      // {
+      //   id: 'llm',
+      //   enabled: true,
+      //   apiKey: process.env.I18NPRUNE_TRANSLATE_LLM_API_KEY,
+      //   baseUrl: process.env.I18NPRUNE_TRANSLATE_LLM_BASE_URL ?? 'https://api.openai.com/v1',
+      //   model: process.env.I18NPRUNE_TRANSLATE_LLM_MODEL ?? 'gpt-4o-mini',
+      //   rateLimit: ${LLM_RATE_LIMIT_LITERAL},
+      // },`;
+var TRANSLATE_POLICY_BLOCK = `
+    // Per-outcome verbs consumed by the translate-policy resolver. All keys optional \u2014 these are the safe defaults.
+    policy: {
+      routing: 'single',
+      onRateLimit: 'backoff',
+      onTransientFailure: 'retry',
+      onQuotaExceeded: 'fallback',
+      onAuthFailure: 'abort',
+      onProviderUnavailable: 'fallback',
+      onIdentityOutput: 'flag',
+      onIncompleteRun: 'confirm',
+      handoff: 'auto',
+      // maxAttempts: providers.length, // omit to use one shot per provider in chain
+    },`;
+function formatFunctionsArray(functions) {
+  return JSON.stringify(functions);
+}
+function formatLocaleLayoutLines(layout) {
+  if (!layout) return "";
+  return `
+    mode: '${layout.mode}',
+    structure: '${layout.structure}',`;
+}
+function formatPresetBody(preset, localeLayout) {
+  const p = getInitPresetConfigFields(preset);
+  const sf = p.locales.source.replace(/'/g, "\\'");
+  const dir = p.locales.directory.replace(/'/g, "\\'");
+  const layoutLines = formatLocaleLayoutLines(localeLayout);
+  return `  locales: {
+    source: '${sf}',
+    directory: '${dir}',${layoutLines}
+  },
+  src: '${p.src.replace(/'/g, "\\'")}',
+  functions: ${formatFunctionsArray(p.functions)},`;
+}
+function buildMinimalInitConfigTemplate(importSpecifier, preset, localeLayout) {
+  const body = formatPresetBody(preset, localeLayout);
+  return `import { defineConfig, type I18nPruneConfig } from '${importSpecifier}';
+
+export default defineConfig({
+${body}
+  translate: {
+    primary: 'google',
+    workers: ${String(DEFAULT_PROVIDER_RATE_LIMITS.google.maxConcurrency)},
+    providers: [{ id: 'google', rateLimit: ${GOOGLE_RATE_LIMIT_LITERAL} },${TRANSLATE_PROVIDER_COMMENT_ROWS}
+    ],${TRANSLATE_POLICY_BLOCK}
+  },
+  policies: {
+    preserve: {
+      // copyKeys: ['brand.tagline'],
+      // copyPrefixes: ['legal.'],
+    },
+    parity: {
+      // excludeKeys: ['debug.flag'],
+      // excludePrefixes: ['experimental.'],
+      // excludeValues: ['TODO'],
+    },
+  },
+  exclude: {
+    preset: 'production',
+    useDefaultSkip: true,
+    // dirs: ['fixtures'],
+    // extensions: ['d.ts'],
+    // patterns: [/^src\\/generated\\//],
+  },
+} satisfies Partial<I18nPruneConfig>);
+`;
+}
+function buildRichInitConfigTemplate(importSpecifier, preset, localeLayout) {
+  const body = formatPresetBody(preset, localeLayout);
+  return `import { defineConfig, type I18nPruneConfig } from '${importSpecifier}';
+
+export default defineConfig({
+${body}
+  translate: {
+    primary: 'google',
+    workers: ${String(DEFAULT_PROVIDER_RATE_LIMITS.google.maxConcurrency)},
+    providers: [
+      { id: 'google', rateLimit: ${GOOGLE_RATE_LIMIT_LITERAL} },${TRANSLATE_PROVIDER_COMMENT_ROWS}
+    ],
+    // Per-outcome verbs consumed by the translate-policy resolver. All keys optional.
+    policy: {
+      routing: 'single',
+      onRateLimit: 'backoff',
+      onTransientFailure: 'retry',
+      onQuotaExceeded: 'fallback',
+      onAuthFailure: 'abort',
+      onProviderUnavailable: 'fallback',
+      onIdentityOutput: 'flag',
+      onIncompleteRun: 'confirm',
+      handoff: 'auto',
+      // maxAttempts: providers.length, // omit to use one shot per provider in chain
+    },
+  },
+
+  policies: {
+    preserve: {
+      // copyKeys: ['brand.tagline'],
+      // copyPrefixes: ['legal.'],
+    },
+    parity: {
+      // excludeKeys: ['debug.flag'],
+      // excludePrefixes: ['experimental.'],
+      // excludeValues: ['TODO'],
+    },
+  },
+
+  exclude: {
+    preset: 'production',
+    useDefaultSkip: true,
+    // dirs: ['fixtures', 'vendor'],
+    // files: ['ignored-keys.ts'],
+    // extensions: ['d.ts'],
+    // patterns: [/^src\\/generated\\//],
+  },
+
+  reference: {
+    defaults: {
+      treatCommentedCallSitesAsRuntime: false,
+      treatNonSourceFileSitesAsRuntime: false,
+      uncertainKeyPolicy: 'protect',
+      stringPresence: 'guard',
+      stringPresenceMaxHitsPerKey: 5,
+      respectPreserve: true,
+    },
+    // Per-command overrides: add \`commands: { cleanup?: {\u2026}, sync?: {\u2026}, generate?: {\u2026} }\` with the same keys as \`defaults\`.
+    // Each block shallow-merges over \`defaults\` when that command runs. Docs: ${REFERENCE_DOCS_URL}
+  },
+
+  localeLeaves: {
+    // \`mode\`: **\`legacy_string\`** (plain string leaves) or **\`structured\`** (\`{ value, \u2026 }\` terminals) \u2014 only these two values are valid.
+    mode: 'legacy_string',
+    sync: {
+      // When **\`true\`**, sync can strip structured metadata back to plain strings (see \`sync --strip-metadata\`).
+      stripMetadata: false,
+    },
+  },
+
+  missing: {
+    // Omit \`placeholder\` to use the SDK default sentinel; set any string merged at new paths (grep-friendly recommended).
+    placeholder: '__I18NPRUNE_MISSING__',
+  },
+  output: {
+    list: {
+      top: 10,
+      full: false,
+      // maxCap: 100000,
+    },
+  },
+
+  scanner: {
+    // \`auto\` picks serial vs concurrent; tune for huge repos.
+    mode: 'auto',
+    // concurrency: 8,
+    // hardCap: 256,
+  },
+
+  cache: {
+    // Preset: safe | balanced | fast (default when omitted: balanced). ${CACHE_PROFILE_DOCS_URL}
+    profile: 'balanced',
+    // On-disk scan cache for faster repeat runs. Omit \`dir\` for the CLI default (~/.i18nprune/cache).
+    enabled: true,
+    // --- Optional overrides (uncomment to replace the profile value for that field only) ---
+    // dir: '.i18nprune/cache',
+    // mode: 'readWrite', // or 'readOnly' (CI: read cache, never write)
+    // rebuild: 'partial', // or 'full' \u2014 always full scan on analysis miss
+    // fullRescanThresholdPercent: 40, // partial only: full scan when this % of src files change
+  },
+
+  patching: {
+    // Opt-in: may create/refresh loader wiring under \`src\` \u2014 keep \`enabled: false\` until you deliberately adopt the patching recipe.
+    enabled: false,
+    recipe: 'loader_generated',
+    mode: 'warn_skip',
+    // loaderPath: 'src/i18n/loaders.generated.ts',
+    // configPath: 'src/i18n/config.json',
+    // localeJsonImportBase: 'locales',
+    // sizeLimitBytes: 524288,
+  },
+
+} satisfies Partial<I18nPruneConfig>);
+`;
+}
+function buildInitConfigTemplate(importSpecifierOrOpts) {
+  if (typeof importSpecifierOrOpts === "string") {
+    return buildMinimalInitConfigTemplate(importSpecifierOrOpts, "generic");
+  }
+  const opts = importSpecifierOrOpts ?? {};
+  const importSpecifier = opts.importSpecifier ?? DEFAULT_INIT_CONFIG_IMPORT_SPECIFIER;
+  const preset = opts.preset ?? "generic";
+  const layout = opts.localeLayout;
+  return opts.rich ? buildRichInitConfigTemplate(importSpecifier, preset, layout) : buildMinimalInitConfigTemplate(importSpecifier, preset, layout);
+}
+function configFileNameForFormat(baseName, format) {
+  return `${baseName}.${format}`;
+}
+function defaultInitConfigFileName(baseName) {
+  return configFileNameForFormat(baseName, "ts");
+}
+
+// src/shared/errors/internal.ts
+var I18nPruneError = class extends Error {
+  code;
+  issueCode;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "I18nPruneError";
+    this.code = code;
+    this.issueCode = options?.issueCode;
+  }
+};
+
+// src/runtime/helpers/sync/assert.ts
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function assertSyncPortResult(value, label, at) {
+  if (isThenable(value)) {
+    throw new I18nPruneError(
+      `Synchronous ${label} requires a plain value (got a Promise at ${at})`,
+      "USAGE"
+    );
+  }
+  return value;
+}
+
+// src/runtime/helpers/sync/fs.ts
+function readRuntimeFsTextSync(filePath, fs) {
+  return assertSyncPortResult(fs.readText(filePath), "fs.readText", filePath);
+}
+function existsRuntimeFsSync(filePath, fs) {
+  return assertSyncPortResult(fs.exists(filePath), "fs.exists", filePath);
+}
+function listRuntimeFsDirSync(dirPath, fs) {
+  return assertSyncPortResult(fs.listDir(dirPath), "fs.listDir", dirPath);
+}
+
+// src/init/detect/packageJson.ts
+function readInitPackageJson(host, projectRoot) {
+  const pkgPath = host.path.join(projectRoot, "package.json");
+  if (!existsRuntimeFsSync(pkgPath, host.fs)) return null;
+  try {
+    const raw = readRuntimeFsTextSync(pkgPath, host.fs);
+    const parsed = JSON.parse(raw);
+    const dependencies = parsed.dependencies && typeof parsed.dependencies === "object" && parsed.dependencies !== null ? parsed.dependencies : {};
+    const devDependencies = parsed.devDependencies && typeof parsed.devDependencies === "object" && parsed.devDependencies !== null ? parsed.devDependencies : {};
+    return { dependencies, devDependencies };
+  } catch {
+    return null;
+  }
+}
+function hasDep(pkg, name) {
+  if (!pkg) return false;
+  return Object.hasOwn(pkg.dependencies, name) || Object.hasOwn(pkg.devDependencies, name);
+}
+function initPackageDeclares(pkg, name) {
+  return hasDep(pkg, name);
+}
+
+// src/init/detect/localeTopology.ts
+var NEXT_CONFIG_NAMES = ["next.config.js", "next.config.mjs", "next.config.ts"];
+var LOCALE_ROOT_CANDIDATES = [
+  "messages",
+  "locales",
+  "translations",
+  "i18n",
+  "lang",
+  "public/locales"
+];
+function readInitTopologySignals(host, projectRoot) {
+  const localeRoots = [];
+  for (const rel of LOCALE_ROOT_CANDIDATES) {
+    const abs = host.path.join(projectRoot, rel);
+    if (!existsRuntimeFsSync(abs, host.fs)) continue;
+    const kind = assertSyncPortResult(host.fs.statKind(abs), "fs.statKind", abs);
+    if (kind === "directory" || kind === "file") {
+      localeRoots.push(rel);
+    }
+  }
+  let nextConfigPresent = false;
+  for (const name of NEXT_CONFIG_NAMES) {
+    const p = host.path.join(projectRoot, name);
+    if (existsRuntimeFsSync(p, host.fs)) {
+      nextConfigPresent = true;
+      break;
+    }
+  }
+  return { localeRoots, nextConfigPresent };
+}
+
+// src/shared/locales/enumerate/parseSegmentLocale.ts
+function localeCodeForSegment(structure, path, segment) {
+  if (structure === "locale_file") {
+    if (segment.relativePath.includes("/")) return null;
+    return path.basename(segment.absolutePath, ".json");
+  }
+  if (structure === "locale_per_dir") {
+    const slash = segment.relativePath.indexOf("/");
+    if (slash < 0) return null;
+    const locale = segment.relativePath.slice(0, slash);
+    return locale.length > 0 ? locale : null;
+  }
+  if (structure === "feature_bundle") {
+    return path.basename(segment.absolutePath, ".json");
+  }
+  return null;
+}
+
+// src/shared/constants/locales.ts
+var MAX_LOCALE_SEGMENT_TREE_DEPTH = 16;
+
+// src/shared/locales/enumerate/walkJsonTree.ts
+function posixRelative(pathApi, root, absolute) {
+  let rel = pathApi.relative(root, absolute);
+  if (rel.startsWith("..") || pathApi.isAbsolute(rel)) {
+    rel = pathApi.basename(absolute);
+  }
+  return rel.replace(/\\/g, "/");
+}
+function walkLocaleJsonSegments(input) {
+  const { fs, path, rootAbsolute} = input;
+  const maxDepth = input.maxDepth ?? MAX_LOCALE_SEGMENT_TREE_DEPTH;
+  const out = [];
+  function visit(dirAbsolute, depth) {
+    if (!existsRuntimeFsSync(dirAbsolute, fs)) return;
+    const entries = listRuntimeFsDirSync(dirAbsolute, fs);
+    for (const entry of entries) {
+      const childAbsolute = path.join(dirAbsolute, entry.name);
+      if (entry.kind === "file" && entry.name.endsWith(".json")) {
+        out.push({
+          absolutePath: childAbsolute,
+          relativePath: posixRelative(path, rootAbsolute, childAbsolute)
+        });
+      } else if (entry.kind === "directory" && depth < maxDepth) {
+        visit(childAbsolute, depth + 1);
+      }
+    }
+  }
+  visit(rootAbsolute, 0);
+  return out;
+}
+
+// src/init/detect/localeFilesystemLayout.ts
+var STRUCTURES = ["locale_file", "locale_per_dir", "feature_bundle"];
+var LIKELY_LOCALE_CODE = /^[a-z]{2}(-[A-Z]{2})?$/i;
+function isLikelyLocaleCode(code) {
+  return LIKELY_LOCALE_CODE.test(code);
+}
+function classifySegment(path, segment) {
+  if (!segment.relativePath.includes("/")) {
+    return localeCodeForSegment("locale_file", path, segment) !== null ? "locale_file" : "unknown";
+  }
+  const slash = segment.relativePath.indexOf("/");
+  const firstSegment = segment.relativePath.slice(0, slash);
+  const basenameLocale = path.basename(segment.absolutePath, ".json");
+  const perDir = localeCodeForSegment("locale_per_dir", path, segment);
+  const bundle = localeCodeForSegment("feature_bundle", path, segment);
+  if (perDir !== null && bundle !== null) {
+    const firstLooksLocale = isLikelyLocaleCode(firstSegment);
+    const baseLooksLocale = isLikelyLocaleCode(basenameLocale);
+    if (baseLooksLocale && !firstLooksLocale) return "feature_bundle";
+    if (firstLooksLocale && !baseLooksLocale) return "locale_per_dir";
+    return "unknown";
+  }
+  if (perDir !== null) return "locale_per_dir";
+  if (bundle !== null) return "feature_bundle";
+  return "unknown";
+}
+function detectLocaleFilesystemLayout(host, projectRoot, localesDirectory) {
+  const rootAbsolute = host.path.join(projectRoot, localesDirectory);
+  if (!existsRuntimeFsSync(rootAbsolute, host.fs)) {
+    return null;
+  }
+  const segments = walkLocaleJsonSegments({
+    fs: host.fs,
+    path: host.path,
+    rootAbsolute});
+  if (segments.length === 0) {
+    return null;
+  }
+  const counts = {
+    locale_file: 0,
+    locale_per_dir: 0,
+    feature_bundle: 0,
+    unknown: 0
+  };
+  for (const segment of segments) {
+    const kind = classifySegment(host.path, segment);
+    counts[kind] += 1;
+  }
+  if (counts.unknown > 0) {
+    return null;
+  }
+  let winner = null;
+  let winnerCount = 0;
+  for (const structure of STRUCTURES) {
+    const n = counts[structure];
+    if (n > winnerCount) {
+      winner = structure;
+      winnerCount = n;
+    }
+  }
+  if (winner === null || winnerCount !== segments.length) {
+    return null;
+  }
+  const mode = winner === "locale_file" ? "flat_file" : "locale_directory";
+  return {
+    mode,
+    structure: winner,
+    confidence: 1,
+    segmentCount: segments.length
+  };
+}
+
+// src/config/locales/sourceValidate.ts
+var LANGUAGE_CODE_SHAPE = /^[a-z]{2}(-[a-z0-9]{2,8})*$/i;
+function classifyLocalesSourceInput(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return "invalid_shape";
+  if (trimmed.includes("/") || trimmed.includes("\\")) return "path";
+  if (trimmed.toLowerCase().endsWith(".json")) return "json_filename";
+  if (!LANGUAGE_CODE_SHAPE.test(trimmed)) return "invalid_shape";
+  return "language_code";
+}
+
+// src/init/detect/inferLayoutFromConfigPaths.ts
+var LIKELY_LOCALE_CODE2 = /^[a-z]{2}(-[A-Z]{2})?$/i;
+function isLikelyLocaleCode2(code) {
+  return LIKELY_LOCALE_CODE2.test(code);
+}
+function relativeSourcePath(directory, source) {
+  const dir = directory.replace(/\\/g, "/").replace(/\/$/, "");
+  const src = source.replace(/\\/g, "/");
+  if (src.startsWith(`${dir}/`)) {
+    return src.slice(dir.length + 1);
+  }
+  return src;
+}
+function inferLocaleLayoutFromConfigPaths(directory, source) {
+  if (classifyLocalesSourceInput(source) === "language_code") {
+    return null;
+  }
+  const rel = relativeSourcePath(directory, source);
+  if (!rel.endsWith(".json")) {
+    return null;
+  }
+  if (!rel.includes("/")) {
+    return {
+      mode: "flat_file",
+      structure: "locale_file",
+      confidence: 0.85,
+      segmentCount: 1
+    };
+  }
+  const slash = rel.indexOf("/");
+  const first = rel.slice(0, slash);
+  const basenameLocale = rel.slice(slash + 1).replace(/\.json$/, "");
+  if (isLikelyLocaleCode2(basenameLocale) && !isLikelyLocaleCode2(first)) {
+    return {
+      mode: "locale_directory",
+      structure: "feature_bundle",
+      confidence: 0.85,
+      segmentCount: 1
+    };
+  }
+  if (isLikelyLocaleCode2(first) && !isLikelyLocaleCode2(basenameLocale)) {
+    return {
+      mode: "locale_directory",
+      structure: "locale_per_dir",
+      confidence: 0.85,
+      segmentCount: 1
+    };
+  }
+  return null;
+}
+
+// src/init/detect/scorePresets.ts
+function sumContributions(factors) {
+  let s = 0;
+  for (const f of factors) s += f.contribution;
+  return s;
+}
+function normalizeConfidence(score) {
+  if (!Number.isFinite(score) || score <= 0) return 0;
+  return Math.min(1, score);
+}
+function buildFactors(preset, signals) {
+  const pkg = signals.packageJson;
+  const { topology } = signals;
+  const factors = [];
+  if (preset === "generic") {
+    factors.push({
+      id: "baseline.generic",
+      contribution: 0.12,
+      detail: "Always-available neutral starter"
+    });
+  }
+  if (preset === "next-intl") {
+    if (initPackageDeclares(pkg, "next-intl")) {
+      factors.push({
+        id: "npm.next-intl",
+        contribution: 0.48,
+        detail: "`next-intl` declared in package.json"
+      });
+    }
+    if (topology.localeRoots.includes("messages")) {
+      factors.push({
+        id: "dir.messages",
+        contribution: 0.28,
+        detail: "`messages/` directory present"
+      });
+    }
+    if (topology.nextConfigPresent && initPackageDeclares(pkg, "next")) {
+      factors.push({
+        id: "conv.next_app",
+        contribution: 0.12,
+        detail: "`next` dependency and Next config file present"
+      });
+    }
+  }
+  if (preset === "next-i18next") {
+    if (initPackageDeclares(pkg, "next-i18next")) {
+      factors.push({
+        id: "npm.next-i18next",
+        contribution: 0.46,
+        detail: "`next-i18next` declared in package.json"
+      });
+    }
+    if (topology.localeRoots.includes("public/locales")) {
+      factors.push({
+        id: "dir.public_locales",
+        contribution: 0.26,
+        detail: "`public/locales/` directory present"
+      });
+    }
+    if (topology.nextConfigPresent && initPackageDeclares(pkg, "next")) {
+      factors.push({
+        id: "conv.next_app",
+        contribution: 0.1,
+        detail: "`next` dependency and Next config file present"
+      });
+    }
+  }
+  if (preset === "i18next") {
+    if (initPackageDeclares(pkg, "i18next")) {
+      factors.push({
+        id: "npm.i18next",
+        contribution: 0.42,
+        detail: "`i18next` declared in package.json"
+      });
+    }
+    if (initPackageDeclares(pkg, "react-i18next")) {
+      factors.push({
+        id: "npm.react-i18next",
+        contribution: 0.22,
+        detail: "`react-i18next` declared in package.json"
+      });
+    }
+    if (topology.localeRoots.includes("locales") || topology.localeRoots.includes("public/locales")) {
+      factors.push({
+        id: "dir.locales_family",
+        contribution: 0.2,
+        detail: "`locales/` or `public/locales/` directory present"
+      });
+    }
+  }
+  if (preset === "react-intl") {
+    if (initPackageDeclares(pkg, "react-intl")) {
+      factors.push({
+        id: "npm.react-intl",
+        contribution: 0.44,
+        detail: "`react-intl` declared in package.json"
+      });
+    }
+    if (initPackageDeclares(pkg, "@formatjs/intl")) {
+      factors.push({
+        id: "npm.formatjs_intl",
+        contribution: 0.18,
+        detail: "`@formatjs/intl` declared in package.json"
+      });
+    }
+    if (topology.localeRoots.includes("lang") || topology.localeRoots.includes("locales")) {
+      factors.push({
+        id: "dir.lang_or_locales",
+        contribution: 0.12,
+        detail: "`lang/` or `locales/` directory present"
+      });
+    }
+  }
+  if (preset === "lingui") {
+    if (initPackageDeclares(pkg, "@lingui/core") || initPackageDeclares(pkg, "@lingui/react")) {
+      factors.push({
+        id: "npm.lingui",
+        contribution: 0.46,
+        detail: "`@lingui/core` or `@lingui/react` declared in package.json"
+      });
+    }
+    if (topology.localeRoots.includes("locales")) {
+      factors.push({
+        id: "dir.locales",
+        contribution: 0.14,
+        detail: "`locales/` directory present"
+      });
+    }
+  }
+  return factors;
+}
+var FRAMEWORK_PRESETS = ["next-intl", "next-i18next", "i18next"];
+function applyConflictDampingInPlace(rows) {
+  for (const r of rows) {
+    r.score = r.rawScore;
+  }
+  const strong = FRAMEWORK_PRESETS.map((id) => rows.find((x) => x.preset === id)).filter(
+    (x) => Boolean(x && x.rawScore >= 0.32)
+  );
+  if (strong.length >= 2) {
+    const factor = 0.72;
+    for (const r of strong) {
+      r.score = r.rawScore * factor;
+    }
+  }
+}
+function scoreInitPresets(signals) {
+  const rows = INIT_PRESET_IDS.map((preset) => {
+    const factors = buildFactors(preset, signals);
+    const rawScore = sumContributions(factors);
+    return { preset, rawScore, score: 0, confidence: 0, factors };
+  });
+  applyConflictDampingInPlace(rows);
+  for (const r of rows) {
+    r.confidence = normalizeConfidence(r.score);
+  }
+  rows.sort((a, b) => b.score - a.score);
+  return rows;
+}
+function pickTopInitPreset(scores) {
+  return scores[0]?.preset ?? "generic";
+}
+function isInitAutoAmbiguous(scores) {
+  if (scores.length < 2) return false;
+  const [a, b] = scores;
+  if (a.preset === "generic" && a.score <= 0.2 && b.score < 0.08) {
+    return false;
+  }
+  if (a.score < 0.28) return true;
+  if (a.score - b.score < 0.1) return true;
+  return false;
+}
+
+// src/init/detect/project.ts
+function detectInitProject(host, projectRoot) {
+  const packageJson = readInitPackageJson(host, projectRoot);
+  const topology = readInitTopologySignals(host, projectRoot);
+  const signals = { packageJson, topology };
+  const scores = scoreInitPresets(signals);
+  return { signals, scores };
+}
+
+// src/init/run.ts
+function runInit(host, opts = {}) {
+  if (host.skippedExistingConfig) {
+    const payload2 = {
+      kind: "init",
+      schemaVersion: 1,
+      skippedExistingConfig: true,
+      preset: "generic",
+      proposedConfigSource: "",
+      proposedConfigFileName: defaultInitConfigFileName("i18nprune.config")
+    };
+    return { payload: payload2, issues: [], exitCode: 0 };
+  }
+  const presetArg = opts.preset;
+  if (presetArg !== void 0 && !isInitPresetId(presetArg)) {
+    const issue = {
+      severity: "error",
+      code: "i18nprune.init.unknown_preset",
+      message: `Unknown init preset "${String(presetArg)}" (expected one of: ${formatInitPresetIdList()}).`
+    };
+    const payload2 = {
+      kind: "init",
+      schemaVersion: 1,
+      skippedExistingConfig: false,
+      preset: "generic",
+      proposedConfigSource: "",
+      proposedConfigFileName: defaultInitConfigFileName("i18nprune.config")
+    };
+    return { payload: payload2, issues: [issue], exitCode: 1 };
+  }
+  const { signals, scores } = detectInitProject(host, host.projectRoot);
+  const ambiguous = Boolean(opts.auto) && presetArg === void 0 && isInitAutoAmbiguous(scores);
+  let preset = "generic";
+  if (presetArg !== void 0) {
+    preset = presetArg;
+  } else if (opts.auto) {
+    preset = pickTopInitPreset(scores);
+  }
+  const presetFields = getInitPresetConfigFields(preset);
+  const localeLayout = detectLocaleFilesystemLayout(host, host.projectRoot, presetFields.locales.directory) ?? inferLocaleLayoutFromConfigPaths(presetFields.locales.directory, presetFields.locales.source);
+  const detection = {
+    signals,
+    scores,
+    ambiguous,
+    localeLayout
+  };
+  const issues = [];
+  let exitCode = 0;
+  if (ambiguous) {
+    issues.push({
+      severity: "error",
+      code: "i18nprune.init.ambiguous_auto",
+      message: `Could not pick a unique preset from project signals \u2014 pass \`--preset <${formatInitPresetIdList()}>\` or retry without \`--auto\`.`
+    });
+    exitCode = 1;
+  }
+  const proposedConfigSource = exitCode === 1 ? "" : buildInitConfigTemplate({
+    importSpecifier: opts.importSpecifier,
+    rich: opts.rich,
+    preset,
+    localeLayout
+  });
+  const payload = {
+    kind: "init",
+    schemaVersion: 1,
+    skippedExistingConfig: false,
+    preset,
+    proposedConfigSource,
+    proposedConfigFileName: defaultInitConfigFileName("i18nprune.config"),
+    detection
+  };
+  return { payload, issues, exitCode };
+}
+
+export { DEFAULT_INIT_CONFIG_IMPORT_SPECIFIER, INIT_PRESET_IDS, buildInitConfigTemplate, configFileNameForFormat, defaultInitConfigFileName, detectInitProject, detectLocaleFilesystemLayout, formatInitPresetIdList, getInitPresetConfigFields, initPackageDeclares, isInitAutoAmbiguous, isInitPresetId, pickTopInitPreset, readInitPackageJson, readInitTopologySignals, runInit, scoreInitPresets };