create-quiver 0.15.3 → 0.15.4

package/src/create-quiver/lib/i18n/read-only-format.js

@@ -0,0 +1,26 @@
+const { createTranslator } = require('./catalog');
+
+function translatorForHuman(options = {}) {
+  return createTranslator(options.language);
+}
+
+function formatStatus(status, translator = createTranslator()) {
+  const key = `status.${String(status || '').replace(/-/g, '_')}`;
+  const translated = translator.t(key);
+  return translated.startsWith('[missing:') ? String(status || '') : translated;
+}
+
+function formatWarningPrefix(message, translator = createTranslator()) {
+  const text = String(message || '');
+  const match = text.match(/^Warning: (.+)$/);
+  if (!match) {
+    return text;
+  }
+  return translator.t('common.warning', { message: match[1] });
+}
+
+module.exports = {
+  formatStatus,
+  formatWarningPrefix,
+  translatorForHuman,
+};

package/src/create-quiver/lib/i18n/templates.js

@@ -0,0 +1,172 @@
+const fs = require('fs');
+const path = require('path');
+
+const {
+  DEFAULT_LANGUAGE,
+  SUPPORTED_LANGUAGES,
+  normalizeLanguage,
+  resolveLanguage,
+} = require('./language');
+
+const MACHINE_TEMPLATE_PATHS = new Set([
+  'package.template.json',
+  'specs/[project-name]/slices/slice-template/slice.json',
+]);
+
+function toTemplatePath(relativePath) {
+  const normalized = String(relativePath || '').replace(/\\/g, '/').replace(/^\.\//, '');
+  if (!normalized || path.isAbsolute(normalized) || normalized.split('/').includes('..')) {
+    throw new Error(`invalid template path: ${relativePath}`);
+  }
+  return normalized;
+}
+
+function isHumanTemplatePath(relativePath) {
+  const normalized = toTemplatePath(relativePath);
+  if (MACHINE_TEMPLATE_PATHS.has(normalized)) {
+    return false;
+  }
+  return normalized.endsWith('.md.template') || normalized.endsWith('.md');
+}
+
+function localizedTemplateRelativePath(relativePath, language) {
+  const normalized = toTemplatePath(relativePath);
+  const resolvedLanguage = normalizeLanguage(language) || DEFAULT_LANGUAGE;
+  if (resolvedLanguage === DEFAULT_LANGUAGE || !isHumanTemplatePath(normalized)) {
+    return normalized;
+  }
+
+  if (normalized.endsWith('.template')) {
+    const withoutTemplateSuffix = normalized.slice(0, -'.template'.length);
+    return `${withoutTemplateSuffix}.${resolvedLanguage}.template`;
+  }
+
+  const extension = path.posix.extname(normalized);
+  if (!extension) {
+    return `${normalized}.${resolvedLanguage}`;
+  }
+
+  return `${normalized.slice(0, -extension.length)}.${resolvedLanguage}${extension}`;
+}
+
+function resolveTemplateLanguage(options = {}) {
+  return resolveLanguage({
+    cliLanguage: options.language || options.cliLanguage,
+    env: options.env,
+    homeDir: options.homeDir,
+    intlLocale: options.intlLocale,
+    projectRoot: options.projectRoot,
+  });
+}
+
+function resolveLocalizedTemplatePath(templateRoot, relativePath, options = {}) {
+  const normalized = toTemplatePath(relativePath);
+  const templateLanguage = resolveTemplateLanguage(options);
+  const requestedLanguage = templateLanguage.language || DEFAULT_LANGUAGE;
+  const basePath = path.join(templateRoot, normalized);
+  const human = isHumanTemplatePath(normalized);
+
+  if (!human) {
+    return {
+      human: false,
+      language: '',
+      requestedLanguage,
+      relativePath: normalized,
+      templatePath: basePath,
+      localizedRelativePath: normalized,
+      fallback: false,
+      reason: 'machine-artifact',
+      languageSource: templateLanguage.source,
+      warnings: templateLanguage.warnings || [],
+    };
+  }
+
+  const localizedRelativePath = localizedTemplateRelativePath(normalized, requestedLanguage);
+  const localizedPath = path.join(templateRoot, localizedRelativePath);
+  if (localizedRelativePath !== normalized && fs.existsSync(localizedPath)) {
+    return {
+      human: true,
+      language: requestedLanguage,
+      requestedLanguage,
+      relativePath: normalized,
+      templatePath: localizedPath,
+      localizedRelativePath,
+      fallback: false,
+      reason: 'localized-template',
+      languageSource: templateLanguage.source,
+      warnings: templateLanguage.warnings || [],
+    };
+  }
+
+  if (fs.existsSync(basePath)) {
+    return {
+      human: true,
+      language: DEFAULT_LANGUAGE,
+      requestedLanguage,
+      relativePath: normalized,
+      templatePath: basePath,
+      localizedRelativePath: normalized,
+      fallback: requestedLanguage !== DEFAULT_LANGUAGE,
+      reason: requestedLanguage === DEFAULT_LANGUAGE ? 'default-template' : 'missing-localized-template',
+      languageSource: templateLanguage.source,
+      warnings: templateLanguage.warnings || [],
+    };
+  }
+
+  throw new Error(`create-quiver: missing template ${normalized} in ${templateRoot}`);
+}
+
+function collectLocalizedTemplateCoverage(templateRoot, relativePaths, options = {}) {
+  const languages = Array.isArray(options.languages) && options.languages.length > 0
+    ? options.languages.map((language) => normalizeLanguage(language)).filter(Boolean)
+    : SUPPORTED_LANGUAGES;
+  const missing = [];
+  const checked = [];
+  const skipped = [];
+
+  for (const relativePath of relativePaths) {
+    const normalized = toTemplatePath(relativePath);
+    if (!isHumanTemplatePath(normalized)) {
+      skipped.push({
+        relativePath: normalized,
+        reason: 'machine-artifact',
+      });
+      continue;
+    }
+
+    for (const language of languages) {
+      if (language === DEFAULT_LANGUAGE) {
+        continue;
+      }
+      const localizedRelativePath = localizedTemplateRelativePath(normalized, language);
+      checked.push({
+        language,
+        relativePath: normalized,
+        localizedRelativePath,
+      });
+      if (!fs.existsSync(path.join(templateRoot, localizedRelativePath))) {
+        missing.push({
+          language,
+          relativePath: normalized,
+          localizedRelativePath,
+        });
+      }
+    }
+  }
+
+  return {
+    ok: missing.length === 0,
+    checked,
+    missing,
+    skipped,
+  };
+}
+
+module.exports = {
+  collectLocalizedTemplateCoverage,
+  isHumanTemplatePath,
+  localizedTemplateRelativePath,
+  resolveLocalizedTemplatePath,
+  resolveTemplateLanguage,
+  toTemplatePath,
+};

package/src/create-quiver/lib/init-docs.js

@@ -7,6 +7,7 @@ const {
   quiverInternalPaths,
   resolveInitPackageScripts,
 } = require('./init-layout');
+const { resolveLocalizedTemplatePath } = require('./i18n/templates');
 const { writeState } = require('./state');
 
 function ensureDir(dirPath) {
@@ -118,6 +119,17 @@ function copyRenderedFile(sourcePath, destinationPath, replacements, skipIfExist
   return 'created';
 }
 
+function resolveGeneratedTemplatePath(templateRoot, relativePath, options = {}) {
+  const basePath = path.join(templateRoot, relativePath);
+  if (!fs.existsSync(basePath)) {
+    return '';
+  }
+  return resolveLocalizedTemplatePath(templateRoot, relativePath, {
+    language: options.language,
+    projectRoot: options.projectRoot,
+  }).templatePath;
+}
+
 function copyBinaryFile(sourcePath, destinationPath, skipIfExists) {
   if (skipIfExists && fs.existsSync(destinationPath)) {
     return 'skipped';
@@ -686,6 +698,7 @@ function initializeProjectDocs(options) {
     migrateMode = false,
     profile = 'default',
     templateRoot: providedTemplateRoot = '',
+    language = '',
   } = options;
 
   const templateRoot = providedTemplateRoot || path.join(projectRoot, 'docs-template');
@@ -747,8 +760,9 @@ function initializeProjectDocs(options) {
     operations.push({ source: 'packaged templates', destination: '.quiver/templates', result: 'merged' });
   }
 
-  const agentsSourcePath = path.join(templateRoot, 'AGENTS.md.template');
-  if (fs.existsSync(agentsSourcePath)) {
+  const templateLanguageOptions = { language, projectRoot };
+  const agentsSourcePath = resolveGeneratedTemplatePath(templateRoot, 'AGENTS.md.template', templateLanguageOptions);
+  if (agentsSourcePath) {
     const agentsDestinationPath = path.join(projectRoot, 'AGENTS.md');
     const result = copyRenderedFile(agentsSourcePath, agentsDestinationPath, replacements, true);
     operations.push({ source: 'AGENTS.md.template', destination: 'AGENTS.md', result });
@@ -814,8 +828,8 @@ function initializeProjectDocs(options) {
       continue;
     }
 
-    const sourcePath = path.join(templateRoot, source);
-    if (!fs.existsSync(sourcePath)) {
+    const sourcePath = resolveGeneratedTemplatePath(templateRoot, source, templateLanguageOptions);
+    if (!sourcePath) {
       continue;
     }
 

package/src/create-quiver/lib/init-layout.js

@@ -125,6 +125,7 @@ function normalizeInitLayoutOptions(options = {}) {
     dryRun: options.dryRun === true,
     full,
     includeTemplates: options.includeTemplates === true,
+    language: typeof options.language === 'string' ? options.language : '',
     legacyScripts: options.legacyScripts === true,
     minimal,
     skipInstall: options.skipInstall === true,
@@ -353,6 +354,7 @@ function buildInitLayout(projectRoot, options = {}) {
     projectSlug,
     targetRoot: path.resolve(projectRoot),
     flags: normalized,
+    language: normalized.language,
     operations,
     ignoredPaths: [...new Set(ignoredPaths)],
     risks,
@@ -374,6 +376,10 @@ function formatInitLayoutPlan(plan) {
   lines.push(`- Slug: ${plan.projectSlug}`);
   lines.push(`- Target: ${plan.targetRoot}`);
   lines.push(`- Profile: ${plan.profile}`);
+  if (plan.language) {
+    lines.push(`- Language: ${plan.language}`);
+    lines.push('- Language config: write .quiver/config.json');
+  }
   lines.push(`- Entry point: ${entryPoint}`);
   lines.push(`- Planned create: ${plan.summary.create}`);
   lines.push(`- Planned update: ${plan.summary.update}`);

package/src/create-quiver/lib/lifecycle.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { branchDelete, catFileExists, currentBranch, fetchBranch, fetchRemote, hasLocalBranch, hasRemoteBranch, isGitWorktree, isLinkedWorktree, lsRemoteHeads, mergeBaseIsAncestor, revListCount, runGit, statusPorcelain, worktreeAdd, worktreeList, worktreePrune, worktreeRemove } = require('./git');
 const { parseJsonWithComments } = require('./json');
+const { createTranslator } = require('./i18n/catalog');
 const { writeFrontMatter } = require('./init-docs');
 const { withLockSync } = require('./locks');
 const { relativePosixPath, resolveTargetRoot } = require('./paths');
@@ -12,6 +13,10 @@ function ensureDir(dirPath) {
   fs.mkdirSync(dirPath, { recursive: true });
 }
 
+function lifecycleTranslator(options = {}) {
+  return createTranslator(options.language);
+}
+
 function estimateTokenCost(text) {
   return Math.max(1, Math.ceil(Buffer.byteLength(text, 'utf8') / 4));
 }
@@ -267,7 +272,7 @@ function refreshActiveSlicesBoard(repoRoot) {
   return outputPath;
 }
 
-function resolveBaseRef(repoRoot, baseBranch) {
+function resolveBaseRef(repoRoot, baseBranch, translator = lifecycleTranslator()) {
   if (hasLocalBranch(repoRoot, baseBranch)) {
     return baseBranch;
   }
@@ -279,10 +284,10 @@ function resolveBaseRef(repoRoot, baseBranch) {
       fetchBranch(repoRoot, baseBranch);
       return `origin/${baseBranch}`;
     } catch {
-      throw new Error(`create-quiver: origin existe pero no se pudo actualizar '${baseBranch}'. Revisa conectividad o crea la rama local '${baseBranch}' antes de correr start-slice.`);
+      throw new Error(`create-quiver: ${translator.t('lifecycle.base_ref.fetch_failed', { base: baseBranch })}`);
     }
   }
-  throw new Error(`create-quiver: no se encontró '${baseBranch}' como rama local ni como ref remota 'origin/${baseBranch}'. Crea la rama base localmente o configura origin antes de correr start-slice.`);
+  throw new Error(`create-quiver: ${translator.t('lifecycle.base_ref.missing', { base: baseBranch, remoteRef: `origin/${baseBranch}` })}`);
 }
 
 function findExistingWorktreeForBranch(repoRoot, branchName) {
@@ -326,6 +331,7 @@ function formatNestedSliceWorktree(branchName, existingWorktreePath = '') {
 }
 
 function startSlice(sliceInput, options = {}) {
+  const translator = lifecycleTranslator(options);
   const allowDraft = options.allowDraft === true || process.env.ALLOW_DRAFT_SLICE === '1';
   const repoRoot = runGit(['rev-parse', '--show-toplevel'], process.cwd());
   const slice = resolveSliceContext(repoRoot, sliceInput);
@@ -338,19 +344,19 @@ function startSlice(sliceInput, options = {}) {
   validateSliceMetaForStart(slice);
 
   if (slice.status === 'blocked') {
-    throw new Error('create-quiver: el slice esta bloqueado (status=blocked). Resolve el bloqueante antes de iniciar.');
+    throw new Error(`create-quiver: ${translator.t('lifecycle.start.error.blocked')}`);
   }
   if (slice.status === 'cancelled') {
-    throw new Error('create-quiver: el slice esta cancelado (status=cancelled).');
+    throw new Error(`create-quiver: ${translator.t('lifecycle.start.error.cancelled')}`);
   }
   if (slice.status === 'completed') {
-    console.log('WARN: el slice ya figura como completed. Si realmente corresponde reejecutarlo, cambia el status a in_progress.');
+    console.log(translator.t('lifecycle.start.warn.completed'));
   }
   if (slice.status === 'draft' && !allowDraft) {
-    throw new Error("create-quiver: el slice esta en estado 'draft'. Marca el slice como 'ready' o usa --allow-draft para un bootstrap intencional.");
+    throw new Error(`create-quiver: ${translator.t('lifecycle.start.error.draft')}`);
   }
   if (slice.status === 'draft') {
-    console.log('WARN: bootstrap intencional para un slice en draft.');
+    console.log(translator.t('lifecycle.start.warn.draft'));
   }
 
   return withLockSync(repoRoot, `slice-worktree-${slice.branchName}`, {
@@ -375,19 +381,19 @@ function startSlice(sliceInput, options = {}) {
     writeWorktreeContext(existingWorktreePath, slice, slice.branchName);
     const activeSlice = writeActiveSlice(repoRoot, slice);
     if (activeSlice.replaced) {
-      console.log('WARN: Reemplazando docs/ai/ACTIVE_SLICE.md existente.');
+      console.log(translator.t('lifecycle.active_slice.replaced'));
     } else {
-      console.log('Wrote docs/ai/ACTIVE_SLICE.md');
+      console.log(translator.t('lifecycle.active_slice.wrote'));
     }
     refreshActiveSlicesBoard(repoRoot);
-    console.log('La rama ya tiene un worktree asociado.');
-    console.log(`Alias: ${toAlias(slice.ticket)}`);
-    console.log(`Spec: ${slice.specSlug}`);
-    console.log(`Slice: ${slice.sliceId}`);
-    console.log(`Ticket: ${slice.ticket}`);
-    console.log(`Rama: ${slice.branchName}`);
-    console.log(`Base: ${slice.baseBranch}`);
-    console.log(`Worktree: ${existingWorktreePath}`);
+    console.log(translator.t('lifecycle.start.existing_worktree'));
+    console.log(translator.t('lifecycle.label.alias', { value: toAlias(slice.ticket) }));
+    console.log(translator.t('lifecycle.label.spec', { value: slice.specSlug }));
+    console.log(translator.t('lifecycle.label.slice', { value: slice.sliceId }));
+    console.log(translator.t('lifecycle.label.ticket', { value: slice.ticket }));
+    console.log(translator.t('lifecycle.label.branch', { value: slice.branchName }));
+    console.log(translator.t('lifecycle.label.base', { value: slice.baseBranch }));
+    console.log(translator.t('lifecycle.label.worktree', { value: existingWorktreePath }));
     return { worktreePath: existingWorktreePath, reused: true };
   }
 
@@ -418,35 +424,36 @@ function startSlice(sliceInput, options = {}) {
     }
     worktreeAdd(repoRoot, worktreePath, slice.branchName);
   } else {
-    const baseRef = resolveBaseRef(repoRoot, slice.baseBranch);
+    const baseRef = resolveBaseRef(repoRoot, slice.baseBranch, translator);
     worktreeAdd(repoRoot, worktreePath, baseRef, { branch: slice.branchName });
   }
 
   writeWorktreeContext(worktreePath, slice, slice.branchName);
   const activeSlice = writeActiveSlice(repoRoot, slice);
   if (activeSlice.replaced) {
-    console.log('WARN: Reemplazando docs/ai/ACTIVE_SLICE.md existente.');
+    console.log(translator.t('lifecycle.active_slice.replaced'));
   } else {
-    console.log('Wrote docs/ai/ACTIVE_SLICE.md');
+    console.log(translator.t('lifecycle.active_slice.wrote'));
   }
   refreshActiveSlicesBoard(repoRoot);
 
-  console.log('Slice listo para trabajar.');
-  console.log(`Alias: ${toAlias(slice.ticket)}`);
-  console.log(`Spec: ${slice.specSlug}`);
-  console.log(`Slice: ${slice.sliceId}`);
-  console.log(`Ticket: ${slice.ticket}`);
-  console.log(`Tipo de rama: ${slice.branchType}`);
-  console.log(`Base: ${slice.baseBranch}`);
-  console.log(`Slug: ${slice.branchSlug}`);
-  console.log(`Rama: ${slice.branchName}`);
-  console.log(`Worktree: ${worktreePath}`);
-  console.log(`Contexto: ${worktreePath}/WORKTREE_CONTEXT.md`);
+  console.log(translator.t('lifecycle.start.ready'));
+  console.log(translator.t('lifecycle.label.alias', { value: toAlias(slice.ticket) }));
+  console.log(translator.t('lifecycle.label.spec', { value: slice.specSlug }));
+  console.log(translator.t('lifecycle.label.slice', { value: slice.sliceId }));
+  console.log(translator.t('lifecycle.label.ticket', { value: slice.ticket }));
+  console.log(translator.t('lifecycle.label.branch_type', { value: slice.branchType }));
+  console.log(translator.t('lifecycle.label.base', { value: slice.baseBranch }));
+  console.log(translator.t('lifecycle.label.slug', { value: slice.branchSlug }));
+  console.log(translator.t('lifecycle.label.branch', { value: slice.branchName }));
+  console.log(translator.t('lifecycle.label.worktree', { value: worktreePath }));
+  console.log(translator.t('lifecycle.label.context', { value: `${worktreePath}/WORKTREE_CONTEXT.md` }));
   return { worktreePath, reused: false };
   });
 }
 
 function cleanupSlice(sliceInput, options = {}) {
+  const translator = lifecycleTranslator(options);
   const closeBaseline = options.closeBaseline === true;
   const discard = options.discard === true;
   const forceDelete = options.force === true;
@@ -457,18 +464,18 @@ function cleanupSlice(sliceInput, options = {}) {
   const worktreePath = path.join(worktreesRoot, safeBranchName(slice.branchName));
 
   if (slice.isBaseline && !closeBaseline) {
-    console.log(`INFO: '${slice.sliceId}' es baseline. El worktree queda congelado por default.`);
-    console.log('INFO: Usa --close-baseline solo cuando la primera ola del spec ya este estable o mergeada.');
+    console.log(translator.t('lifecycle.cleanup.baseline.info', { slice: slice.sliceId }));
+    console.log(translator.t('lifecycle.cleanup.baseline.close_hint'));
     return;
   }
 
   if (!discard) {
     const branch = currentBranch(repoRoot);
     if (branch !== 'develop') {
-      throw new Error(`create-quiver: el cleanup normal debe correrse desde develop. Rama actual: ${branch}`);
+      throw new Error(`create-quiver: ${translator.t('lifecycle.cleanup.error.branch', { branch })}`);
     }
     if (statusPorcelain(repoRoot) !== '') {
-      throw new Error('create-quiver: el checkout actual no esta limpio. Limpialo antes del cleanup.');
+      throw new Error(`create-quiver: ${translator.t('lifecycle.cleanup.error.dirty')}`);
     }
 
     try {
@@ -480,12 +487,12 @@ function cleanupSlice(sliceInput, options = {}) {
     const localDevelopSha = runGit(['rev-parse', 'HEAD'], repoRoot);
     const remoteDevelopSha = runGit(['rev-parse', 'origin/develop'], repoRoot);
     if (localDevelopSha !== remoteDevelopSha) {
-      throw new Error('create-quiver: develop local no esta actualizado. Ejecuta git pull --ff-only antes del cleanup.');
+      throw new Error(`create-quiver: ${translator.t('lifecycle.cleanup.error.develop_stale')}`);
     }
 
     if (hasLocalBranch(repoRoot, slice.branchName)) {
       if (!mergeBaseIsAncestor(repoRoot, slice.branchName, 'origin/develop')) {
-        throw new Error(`create-quiver: la rama '${slice.branchName}' no esta mergeada en origin/develop. Usa --discard si el slice se descarta.`);
+        throw new Error(`create-quiver: ${translator.t('lifecycle.cleanup.error.unmerged', { branch: slice.branchName })}`);
       }
     }
   }
@@ -493,38 +500,38 @@ function cleanupSlice(sliceInput, options = {}) {
   const worktreeExists = fs.existsSync(worktreePath);
   const branchExists = hasLocalBranch(repoRoot, slice.branchName);
   if (!worktreeExists && !branchExists) {
-    throw new Error(`create-quiver: no existe worktree ni rama local para '${slice.sliceId}'.`);
+    throw new Error(`create-quiver: ${translator.t('lifecycle.cleanup.error.missing', { slice: slice.sliceId })}`);
   }
 
   const removeWorktree = () => worktreeRemove(repoRoot, worktreePath, forceDelete || discard);
   const removeBranch = () => branchDelete(repoRoot, slice.branchName, forceDelete || discard);
 
   if (dryRun) {
-    console.log(`DRY RUN: slice=${slice.sliceId} branch=${slice.branchName}`);
+    console.log(translator.t('lifecycle.cleanup.dry_run.slice', { slice: slice.sliceId, branch: slice.branchName }));
     if (worktreeExists) {
-      console.log(`DRY RUN: git worktree remove ${forceDelete || discard ? '--force ' : ''}${worktreePath}`);
+      console.log(translator.t('lifecycle.cleanup.dry_run.worktree', { force: forceDelete || discard ? '--force ' : '', path: worktreePath }));
     }
     if (branchExists) {
-      console.log(`DRY RUN: git branch ${forceDelete || discard ? '-D' : '-d'} ${slice.branchName}`);
+      console.log(translator.t('lifecycle.cleanup.dry_run.branch', { flag: forceDelete || discard ? '-D' : '-d', branch: slice.branchName }));
     }
     return;
   }
 
   if (worktreeExists) {
     removeWorktree();
-    console.log(`PASS: Worktree eliminado: ${worktreePath}`);
+    console.log(translator.t('lifecycle.cleanup.removed_worktree', { path: worktreePath }));
   }
   if (branchExists) {
     removeBranch();
-    console.log(`PASS: Rama local eliminada: ${slice.branchName}`);
+    console.log(translator.t('lifecycle.cleanup.removed_branch', { branch: slice.branchName }));
   }
 
   if (removeActiveSlice(repoRoot)) {
-    console.log('PASS: ACTIVE_SLICE.md eliminado');
+    console.log(translator.t('lifecycle.cleanup.removed_active_slice'));
   }
 
   refreshActiveSlicesBoard(repoRoot);
-  console.log(`PASS: Cleanup finalizado para '${slice.sliceId}'.`);
+  console.log(translator.t('lifecycle.cleanup.finished', { slice: slice.sliceId }));
 }
 
 module.exports = {