create-quiver 0.15.3 → 0.15.4

package/src/create-quiver/commands/config.js

@@ -0,0 +1,124 @@
+const path = require('path');
+
+const {
+  DEFAULT_LANGUAGE,
+  SUPPORTED_LANGUAGES,
+  formatLanguageWarning,
+  globalLanguageConfigPath,
+  normalizeLanguage,
+  projectLanguageConfigPath,
+  writeGlobalLanguageConfig,
+  writeProjectLanguageConfig,
+} = require('../lib/i18n/language');
+
+function formatError(message) {
+  return `create-quiver: ${message}`;
+}
+
+function toJsonWarning(warning) {
+  return {
+    code: warning.code,
+    source: warning.source,
+    requested_language: warning.requestedLanguage,
+    fallback_language: warning.fallbackLanguage,
+    supported_languages: warning.supportedLanguages,
+  };
+}
+
+function formatProjectRelativePath(repoRoot, filePath) {
+  return path.relative(repoRoot, filePath).split(path.sep).join('/') || '.';
+}
+
+function validateLanguageForSet(language) {
+  const normalized = normalizeLanguage(language);
+  if (!normalized || normalized !== String(language || '').trim().toLowerCase()) {
+    throw new Error(formatError(`unsupported language: ${language || '<missing>'}. Supported languages: ${SUPPORTED_LANGUAGES.join(', ')}. Run: npx create-quiver config language set ${DEFAULT_LANGUAGE}`));
+  }
+  return normalized;
+}
+
+function runLanguageShow(repoRoot, options = {}) {
+  const resolution = options.languageResolution || {
+    language: DEFAULT_LANGUAGE,
+    source: 'default',
+    warnings: [],
+  };
+  const warnings = resolution.warnings || [];
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({
+      schema_version: 1,
+      language: resolution.language,
+      source: resolution.source,
+      requested_source: resolution.requestedSource || null,
+      requested_language: resolution.requestedLanguage || null,
+      warnings: warnings.map(toJsonWarning),
+    }, null, 2)}\n`);
+    return;
+  }
+
+  const lines = [
+    'Quiver config language',
+    `Language: ${resolution.language}`,
+    `Source: ${resolution.source}`,
+  ];
+  for (const warning of warnings) {
+    lines.push(formatLanguageWarning(warning));
+  }
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function runLanguageSet(repoRoot, options = {}) {
+  const language = validateLanguageForSet(options.value);
+  const global = options.global === true;
+  const configPath = global ? globalLanguageConfigPath() : projectLanguageConfigPath(repoRoot);
+
+  if (global) {
+    writeGlobalLanguageConfig(language);
+  } else {
+    writeProjectLanguageConfig(repoRoot, language);
+  }
+
+  const displayPath = global ? '~/.quiver/config.json' : formatProjectRelativePath(repoRoot, configPath);
+  const scope = global ? 'global' : 'project';
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({
+      schema_version: 1,
+      action: 'set',
+      scope,
+      language,
+      path: displayPath,
+    }, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write([
+    'Quiver config language updated',
+    `Scope: ${scope}`,
+    `Path: ${displayPath}`,
+    `Language: ${language}`,
+  ].join('\n') + '\n');
+}
+
+function runConfig(repoRoot, options = {}) {
+  if (options.section !== 'language') {
+    throw new Error(formatError(`unsupported config section: ${options.section || '(missing)'}. Supported sections: language`));
+  }
+
+  if (options.command === 'show') {
+    runLanguageShow(repoRoot, options);
+    return;
+  }
+
+  if (options.command === 'set') {
+    runLanguageSet(repoRoot, options);
+    return;
+  }
+
+  throw new Error(formatError(`unsupported config language command: ${options.command || '(missing)'}. Supported commands: show, set`));
+}
+
+module.exports = {
+  runConfig,
+};

package/src/create-quiver/commands/demo.js

@@ -8,12 +8,12 @@ function runDemo(options = {}) {
   const plan = buildDemoPlan(options.targetRoot, { demo: options.demo });
 
   if (options.dryRun) {
-    console.log(formatDemoPlan(plan, { dryRun: true }));
+    console.log(formatDemoPlan(plan, { dryRun: true, language: options.language }));
     return plan;
   }
 
   writeDemoPlan(plan);
-  console.log(formatDemoPlan(plan));
+  console.log(formatDemoPlan(plan, { language: options.language }));
   return plan;
 }
 

package/src/create-quiver/commands/evidence.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const { runEvidenceCommand } = require('../lib/evidence');
+const { createTranslator } = require('../lib/i18n/catalog');
 
 function formatOutputPath(repoRoot, outputPath) {
   const relativeOutput = path.relative(repoRoot, outputPath).split(path.sep).join('/');
@@ -11,6 +12,7 @@ function formatOutputPath(repoRoot, outputPath) {
 }
 
 function runEvidence(repoRoot, options = {}) {
+  const translator = createTranslator(options.language);
   const command = options.command || '';
   if (options.subcommand !== 'run') {
     throw new Error('create-quiver: missing evidence subcommand. Use: npx create-quiver evidence run -- <command>');
@@ -23,10 +25,10 @@ function runEvidence(repoRoot, options = {}) {
   });
   const displayOutput = formatOutputPath(repoRoot, result.outputPath);
 
-  console.log('Quiver evidence recorded');
-  console.log(`- Command: ${result.record.command}`);
-  console.log(`- Exit code: ${result.exitCode}`);
-  console.log(`- Output: ${displayOutput}`);
+  console.log(translator.t('evidence.recorded'));
+  console.log(`- ${translator.t('evidence.command', { command: result.record.command })}`);
+  console.log(`- ${translator.t('evidence.exit_code', { code: result.exitCode })}`);
+  console.log(`- ${translator.t('evidence.output', { path: displayOutput })}`);
 
   return result;
 }

package/src/create-quiver/commands/flow.js

@@ -5,6 +5,7 @@ const { readPhaseApproval } = require('../lib/approvals');
 const { approvalCandidateCommand, buildApprovalCandidateReport, formatCandidateSummary } = require('../lib/ai/approval-candidates');
 const { readPlanReview } = require('../lib/ai/plan-review');
 const { listAgentProfiles } = require('../lib/agent-profiles');
+const { translatorForHuman } = require('../lib/i18n/read-only-format');
 const { readProjectScanStatus } = require('../lib/project-scan');
 const { buildGraph, naturalNumberFromSliceId, readAllSlices } = require('../lib/slice-graph');
 const { hasQuiverInitializationEvidence, readState } = require('../lib/state');
@@ -617,38 +618,129 @@ function detectFlowState(projectRoot) {
   });
 }
 
-function formatFlowReport(report) {
+function formatFlowBlocker(blocker, translator) {
+  const text = String(blocker || '');
+  if (text === 'Quiver has not been initialized in this project.') {
+    return translator.t('flow.blocker.not_initialized');
+  }
+  if (text === 'Acceptance criteria draft exists but is not approved.') {
+    return translator.t('flow.blocker.acceptance_draft');
+  }
+  if (text === 'Acceptance criteria changed after approval.') {
+    return translator.t('flow.blocker.acceptance_stale');
+  }
+  if (text === 'Technical plan draft exists but has not been reviewed for production readiness.') {
+    return translator.t('flow.blocker.technical_plan_review_needed');
+  }
+  if (text === 'Technical plan review blocks approval.') {
+    return translator.t('flow.blocker.technical_plan_review_blocked');
+  }
+  if (text === 'Technical plan draft was reviewed but is not approved.') {
+    return translator.t('flow.blocker.technical_plan_draft');
+  }
+  if (text === 'Technical plan changed after approval and needs a fresh production review.') {
+    return translator.t('flow.blocker.technical_plan_changed_review_needed');
+  }
+  if (text === 'Technical plan changed after approval and latest review blocks approval.') {
+    return translator.t('flow.blocker.technical_plan_changed_review_blocked');
+  }
+  if (text === 'Technical plan changed after approval and the latest draft was reviewed.') {
+    return translator.t('flow.blocker.technical_plan_changed_reviewed');
+  }
+  if (text === 'Later slices are blocked until slice-00 is completed and committed.') {
+    return translator.t('flow.blocker.slice_00_required');
+  }
+  if (text === 'No ready slice was found. Review dependencies and statuses.') {
+    return translator.t('flow.blocker.no_ready_slice');
+  }
+  const missingDoc = text.match(/^Missing (docs\/[^.]+\.md)\.$/);
+  if (missingDoc) {
+    return translator.t('flow.blocker.missing_doc', { file: missingDoc[1] });
+  }
+  const missingProfiles = text.match(/^Missing (.+) agent profile(s?)\.$/);
+  if (missingProfiles) {
+    return translator.t('flow.blocker.missing_agent_profiles', { roles: missingProfiles[1] });
+  }
+  const planReviewStatus = text.match(/^Plan review status is (.+)\.$/);
+  if (planReviewStatus) {
+    return translator.t('flow.blocker.plan_review_status', { status: planReviewStatus[1] });
+  }
+  const couldNotReadSlices = text.match(/^Could not read slices: (.+)$/);
+  if (couldNotReadSlices) {
+    return translator.t('flow.blocker.could_not_read_slices', { error: couldNotReadSlices[1] });
+  }
+  if (text === 'No slice.json files found for the detected specs.') {
+    return translator.t('flow.blocker.no_slice_json');
+  }
+  const graphNotReady = text.match(/^Slice graph is not ready: (.+)$/);
+  if (graphNotReady) {
+    return translator.t('flow.blocker.slice_graph_not_ready', { error: graphNotReady[1] });
+  }
+  return text;
+}
+
+function formatFlowContextSource(contextSource, translator) {
+  const source = contextSource || {};
+  if (source.status === 'fresh') {
+    return translator.t('flow.context_source.fresh', {
+      path: source.artifactPath,
+      updatedAt: source.scanUpdatedAt,
+    });
+  }
+  if (source.status === 'legacy') {
+    return translator.t('flow.context_source.legacy', {
+      path: source.artifactPath,
+      updatedAt: source.scanUpdatedAt,
+    });
+  }
+  if (source.status === 'stale') {
+    return translator.t('flow.context_source.stale', { path: source.artifactPath });
+  }
+  if (source.status === 'partial' && source.artifactPath && !source.projectMapPath) {
+    return translator.t('flow.context_source.partial_scan_only', { path: source.artifactPath });
+  }
+  if (source.status === 'partial' && !source.artifactPath && source.projectMapPath) {
+    return translator.t('flow.context_source.partial_map_only');
+  }
+  if (source.status === 'invalid') {
+    return translator.t('flow.context_source.invalid', { error: source.error });
+  }
+  return translator.t('flow.context_source.missing');
+}
+
+function formatFlowReport(report, options = {}) {
+  const translator = translatorForHuman(options);
   const lines = [
-    'Quiver guided flow',
+    translator.t('flow.title'),
     '',
-    'Command path:',
-    '- Bootstrap and remote use: npx create-quiver <command>',
-    '- Short alias after local install: quiver <command>',
-    `- Generated project script: ${report.facts.flowScriptCommand}`,
+    `${translator.t('flow.command_path')}:`,
+    `- ${translator.t('flow.bootstrap_remote')}: npx create-quiver <command>`,
+    `- ${translator.t('flow.short_alias')}: quiver <command>`,
+    `- ${translator.t('flow.generated_script')}: ${report.facts.flowScriptCommand}`,
     '',
-    `Package manager: ${report.facts.packageManager}`,
-    `Stage: ${report.label}`,
-    `Next safe command: ${report.nextCommand}`,
-    `Context source: ${report.facts.contextSource.summary}`,
+    `${translator.t('flow.package_manager')}: ${report.facts.packageManager}`,
+    `${translator.t('flow.stage')}: ${translator.t(`flow.stage.${report.stage}`)}`,
+    `${translator.t('flow.next_safe_command')}: ${report.nextCommand}`,
+    `${translator.t('flow.context_source')}: ${formatFlowContextSource(report.facts.contextSource, translator)}`,
   ];
 
   if (report.blockers.length > 0) {
-    lines.push('', 'Blockers:');
+    lines.push('', `${translator.t('flow.blockers')}:`);
     for (const blocker of report.blockers) {
-      lines.push(`- ${blocker}`);
+      lines.push(`- ${formatFlowBlocker(blocker, translator)}`);
     }
   }
 
-  lines.push('', 'Suggested sequence:');
+  lines.push('', `${translator.t('flow.suggested_sequence')}:`);
   for (const command of report.suggestedCommands) {
     lines.push(`- ${command}`);
   }
 
   if (report.facts.specSlugs.length > 0) {
-    lines.push('', `Specs found: ${report.facts.specSlugs.join(', ')}`);
+    lines.push('', `${translator.t('flow.specs_found')}: ${report.facts.specSlugs.join(', ')}`);
   }
 
-  lines.push('', 'Safety: this command is read-only and does not call AI providers.');
+  lines.push('', translator.t('flow.safety_read_only'));
 
   return `${lines.join('\n')}\n`;
 }
@@ -661,7 +753,7 @@ async function runFlow(repoRoot, options = {}) {
     return report;
   }
 
-  process.stdout.write(formatFlowReport(report));
+  process.stdout.write(formatFlowReport(report, options));
   return report;
 }
 

package/src/create-quiver/commands/graph.js

@@ -72,6 +72,7 @@ function formatHumanGraph(report, options = {}) {
   const format = options.format || 'tree';
   const sharedOptions = {
     showConflicts: options.showConflicts === true,
+    language: options.language,
     unicode: options.unicode === true || isUnicodeEnabled(options),
   };
 

package/src/create-quiver/commands/next.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const readline = require('readline');
 const { collectPlan } = require('./plan');
+const { formatStatus, translatorForHuman } = require('../lib/i18n/read-only-format');
 const { startSlice } = require('../lib/lifecycle');
 
 function toStartSliceCommand(slicePath) {
@@ -34,15 +35,16 @@ function collectNext(repoRoot, options = {}) {
 }
 
 function formatHumanNext(report, options = {}) {
-  const lines = [options.allReady ? 'Ready slices' : 'Next ready slice'];
+  const translator = translatorForHuman(options);
+  const lines = [options.allReady ? translator.t('next.title.ready') : translator.t('next.title.next')];
 
   if (!report.next) {
-    lines.push('No ready slices found.');
+    lines.push(translator.t('next.empty.ready'));
     if (report.include_completed && report.history.length > 0) {
       lines.push('');
-      lines.push('Historical slices included by --include-completed:');
+      lines.push(`${translator.t('next.history_title')}:`);
       for (const item of report.history) {
-        lines.push(`- ${item.ref} (${item.status})`);
+        lines.push(`- ${item.ref} (${formatStatus(item.status, translator)})`);
       }
     }
     return `${lines.join('\n')}\n`;
@@ -55,25 +57,25 @@ function formatHumanNext(report, options = {}) {
     if (options.allReady) {
       lines.push('');
       lines.push(`[${index + 1}] ${item.ref}`);
-      lines.push(`Title: ${item.title}`);
-      lines.push(`Status: ${item.status}`);
-      lines.push(`Start: ${command}`);
+      lines.push(`${translator.t('next.label.title')}: ${item.title}`);
+      lines.push(`${translator.t('next.label.status')}: ${formatStatus(item.status, translator)}`);
+      lines.push(`${translator.t('next.label.start')}: ${command}`);
     } else {
-      lines.push(`Slice: ${item.ref}`);
-      lines.push(`Title: ${item.title}`);
-      lines.push(`Status: ${item.status}`);
-      lines.push(`Start: ${command}`);
+      lines.push(`${translator.t('next.label.slice')}: ${item.ref}`);
+      lines.push(`${translator.t('next.label.title')}: ${item.title}`);
+      lines.push(`${translator.t('next.label.status')}: ${formatStatus(item.status, translator)}`);
+      lines.push(`${translator.t('next.label.start')}: ${command}`);
       if (report.all_ready.length > 1) {
-        lines.push(`Also ready: ${report.all_ready.slice(1).map((candidate) => candidate.ref).join(', ')}`);
+        lines.push(`${translator.t('next.label.also_ready')}: ${report.all_ready.slice(1).map((candidate) => candidate.ref).join(', ')}`);
       }
     }
   }
 
   if (report.include_completed && report.history.length > 0) {
     lines.push('');
-    lines.push('Historical slices included by --include-completed:');
+    lines.push(`${translator.t('next.history_title')}:`);
     for (const item of report.history) {
-      lines.push(`- ${item.ref} (${item.status})`);
+      lines.push(`- ${item.ref} (${formatStatus(item.status, translator)})`);
     }
   }
 
@@ -104,6 +106,7 @@ function promptConfirm(message, io = {}) {
 
 async function runNext(repoRoot, options = {}) {
   const report = collectNext(repoRoot, options);
+  const translator = translatorForHuman(options);
   const isTTY = options.isTTY || {
     stdin: Boolean(process.stdin.isTTY),
     stdout: Boolean(process.stdout.isTTY),
@@ -115,17 +118,17 @@ async function runNext(repoRoot, options = {}) {
     }
 
     if (!report.next) {
-      process.stdout.write('No ready slices found.\n');
+      process.stdout.write(`${translator.t('next.empty.ready')}\n`);
       return report;
     }
 
-    const confirmed = await (options.promptConfirm || promptConfirm)(`Start slice ${report.next.ref}?`);
+    const confirmed = await (options.promptConfirm || promptConfirm)(translator.t('next.prompt.start', { ref: report.next.ref }));
     if (confirmed) {
       const slicePath = path.resolve(repoRoot, report.next.slice_path);
       await Promise.resolve((options.startSliceFn || startSlice)(slicePath, { allowDraft: true }));
-      process.stdout.write(`Started: ${report.next.ref}\n`);
+      process.stdout.write(`${translator.t('next.started', { ref: report.next.ref })}\n`);
     } else {
-      process.stdout.write('Aborted.\n');
+      process.stdout.write(`${translator.t('next.aborted')}\n`);
     }
     return report;
   }

package/src/create-quiver/commands/plan.js

@@ -1,4 +1,5 @@
 const { relativePosixPath } = require('../lib/paths');
+const { formatStatus, translatorForHuman } = require('../lib/i18n/read-only-format');
 const { filterSlicesForExecution, resolveProjectState } = require('../lib/project-state-resolver');
 const { topoSort } = require('../lib/slice-graph');
 
@@ -147,13 +148,21 @@ function collectPlan(repoRoot, options = {}) {
 }
 
 function formatHumanPlan(report, options = {}) {
+  const translator = translatorForHuman(options);
   const unicode = Boolean(options.unicode) || /UTF-8/i.test(process.env.LANG || '');
-  const title = options.onlyReady ? 'Ready slices' : (report.include_completed ? 'Quiver plan (including completed)' : 'Quiver plan');
+  const title = options.onlyReady
+    ? translator.t('plan.title.ready')
+    : (report.include_completed ? translator.t('plan.title.including_completed') : translator.t('plan.title'));
   const pathSeparator = unicode ? ' → ' : ' -> ';
-  const lines = [title, `Total hours: ${report.total_hours}`, `Critical path: ${report.critical_path.length > 0 ? report.critical_path.join(pathSeparator) : '-'}`, ''];
+  const lines = [
+    title,
+    `${translator.t('plan.total_hours')}: ${report.total_hours}`,
+    `${translator.t('plan.critical_path')}: ${report.critical_path.length > 0 ? report.critical_path.join(pathSeparator) : '-'}`,
+    '',
+  ];
 
   if (report.plan.length === 0) {
-    lines.push(report.include_completed ? 'No slices found for the selected filters.' : 'No pending slices found.');
+    lines.push(report.include_completed ? translator.t('plan.empty.filtered') : translator.t('plan.empty.pending'));
     return `${lines.join('\n')}\n`;
   }
 
@@ -163,15 +172,23 @@ function formatHumanPlan(report, options = {}) {
     item.ref,
     item.title,
     `${item.hours}`,
-    item.status,
+    formatStatus(item.status, translator),
   ]);
 
+  const headers = [
+    translator.t('plan.header.index'),
+    translator.t('plan.header.ticket'),
+    translator.t('plan.header.spec_slice'),
+    translator.t('plan.header.title'),
+    translator.t('plan.header.hours'),
+    translator.t('plan.header.status'),
+  ];
   const widths = rows[0].map((_, colIndex) => Math.max(
     rows.reduce((max, row) => Math.max(max, row[colIndex].length), 0),
-    ['[N]', 'TICKET', 'SPEC/SLICE', 'TITLE', 'HOURS', 'STATUS'][colIndex].length,
+    headers[colIndex].length,
   ));
 
-  lines.push(['[N]', 'TICKET', 'SPEC/SLICE', 'TITLE', 'HOURS', 'STATUS'].map((label, index) => label.padEnd(widths[index])).join('  '));
+  lines.push(headers.map((label, index) => label.padEnd(widths[index])).join('  '));
   lines.push(widths.map((width) => '-'.repeat(width)).join('  '));
 
   for (const row of rows) {