create-quiver 0.15.3 → 0.16.0

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

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+
+function parseChangelog(content) {
+  const lines = String(content || '').split(/\r?\n/);
+  const entries = [];
+  let current = null;
+
+  for (const line of lines) {
+    const heading = line.match(/^##\s+\[?([^\]\n]+)\]?(?:\s+-\s+(.+))?$/);
+    if (heading) {
+      if (current) {
+        current.body = current.body.trim();
+        entries.push(current);
+      }
+      current = {
+        version: heading[1].trim(),
+        date: heading[2]?.trim() || null,
+        body: '',
+      };
+      continue;
+    }
+
+    if (current) {
+      current.body += `${line}\n`;
+    }
+  }
+
+  if (current) {
+    current.body = current.body.trim();
+    entries.push(current);
+  }
+
+  return entries;
+}
+
+function readChangelog(packageRoot) {
+  const changelogPath = path.join(packageRoot, 'CHANGELOG.md');
+  if (!fs.existsSync(changelogPath)) {
+    return { path: changelogPath, entries: [], missing: true };
+  }
+
+  const content = fs.readFileSync(changelogPath, 'utf8');
+  return { path: changelogPath, entries: parseChangelog(content), missing: false };
+}
+
+function formatHumanChangelog(report) {
+  if (report.missing) {
+    return 'Quiver changelog\n\nNo local CHANGELOG.md was found in the installed package.\n';
+  }
+
+  const entries = report.entries.slice(0, 3);
+  if (entries.length === 0) {
+    return 'Quiver changelog\n\nLocal CHANGELOG.md did not contain parseable release entries.\n';
+  }
+
+  const lines = ['Quiver changelog', ''];
+  for (const entry of entries) {
+    lines.push(`## ${entry.version}${entry.date ? ` - ${entry.date}` : ''}`);
+    if (entry.body) {
+      lines.push(entry.body);
+    }
+    lines.push('');
+  }
+
+  return `${lines.join('\n').trimEnd()}\n`;
+}
+
+function runChangelog(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, '../..', '..');
+  const report = readChangelog(packageRoot);
+  const payload = {
+    schema_version: 1,
+    source: report.path,
+    missing: report.missing,
+    entries: report.entries.slice(0, 10),
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return payload;
+  }
+
+  process.stdout.write(formatHumanChangelog(report));
+  return payload;
+}
+
+module.exports = {
+  formatHumanChangelog,
+  parseChangelog,
+  readChangelog,
+  runChangelog,
+};

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

@@ -0,0 +1,135 @@
+const path = require('path');
+
+const {
+  DEFAULT_LANGUAGE,
+  SUPPORTED_LANGUAGES,
+  formatLanguageWarning,
+  globalLanguageConfigPath,
+  normalizeLanguage,
+  projectLanguageConfigPath,
+  writeGlobalLanguageConfig,
+  writeProjectLanguageConfig,
+} = require('../lib/i18n/language');
+const { createTranslator } = require('../lib/i18n/catalog');
+
+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, translator = createTranslator()) {
+  const normalized = normalizeLanguage(language);
+  if (!normalized || normalized !== String(language || '').trim().toLowerCase()) {
+    throw new Error(formatError(translator.t('config.error.unsupported_language', {
+      fallback: DEFAULT_LANGUAGE,
+      language: language || '<missing>',
+      supported: SUPPORTED_LANGUAGES.join(', '),
+    })));
+  }
+  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 translator = createTranslator(options.language);
+  const language = validateLanguageForSet(options.value, translator);
+  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 = {}) {
+  const translator = createTranslator(options.language);
+  if (options.section !== 'language') {
+    throw new Error(formatError(translator.t('config.error.unsupported_section', {
+      section: options.section || '(missing)',
+    })));
+  }
+
+  if (options.command === 'show') {
+    runLanguageShow(repoRoot, options);
+    return;
+  }
+
+  if (options.command === 'set') {
+    runLanguageSet(repoRoot, options);
+    return;
+  }
+
+  throw new Error(formatError(translator.t('config.error.unsupported_language_command', {
+    command: options.command || '(missing)',
+  })));
+}
+
+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 { listEvidenceFiles, runEvidenceCommand, showEvidenceFile } = require('../lib/evidence');
+const { createTranslator } = require('../lib/i18n/catalog');
 
 function formatOutputPath(repoRoot, outputPath) {
   const relativeOutput = path.relative(repoRoot, outputPath).split(path.sep).join('/');
@@ -11,22 +12,54 @@ function formatOutputPath(repoRoot, outputPath) {
 }
 
 function runEvidence(repoRoot, options = {}) {
+  const translator = createTranslator(options.language);
   const command = options.command || '';
+  if (options.subcommand === 'list') {
+    const evidence = listEvidenceFiles(repoRoot);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify({ evidence }, null, 2)}\n`);
+      return { evidence, exitCode: 0 };
+    }
+
+    console.log(translator.t('evidence.list.title'));
+    if (evidence.length === 0) {
+      console.log(translator.t('evidence.list.empty'));
+      return { evidence, exitCode: 0 };
+    }
+
+    for (const item of evidence) {
+      console.log(`- ${item.path} (${translator.t('evidence.exit_code', { code: item.exit_code ?? '-' })})`);
+    }
+    return { evidence, exitCode: 0 };
+  }
+
+  if (options.subcommand === 'show') {
+    const evidence = showEvidenceFile(repoRoot, options.target);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(evidence, null, 2)}\n`);
+      return { evidence, exitCode: 0 };
+    }
+
+    process.stdout.write(evidence.content);
+    return { evidence, exitCode: 0 };
+  }
+
   if (options.subcommand !== 'run') {
-    throw new Error('create-quiver: missing evidence subcommand. Use: npx create-quiver evidence run -- <command>');
+    throw new Error(`create-quiver: ${translator.t('evidence.error.missing_subcommand')}`);
   }
 
   const result = runEvidenceCommand(repoRoot, command, {
+    missingCommandMessage: `create-quiver: ${translator.t('evidence.error.missing_command')}`,
     maxOutput: options.maxOutput,
     outputPath: options.output,
     spawnSync: options.spawnSync,
   });
   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');
@@ -257,6 +258,7 @@ function baseReport({ stage, label, blockers = [], nextCommand, suggestedCommand
     label,
     blockers,
     nextCommand,
+    next_command: nextCommand,
     suggestedCommands,
     facts,
   };
@@ -617,38 +619,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 +754,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

@@ -3,6 +3,7 @@ const { computeLevels, detectFileConflicts } = require('../lib/slice-graph');
 const { renderDotGraph } = require('../lib/renderers/dot');
 const { renderMermaidGraph } = require('../lib/renderers/mermaid');
 const { renderTreeGraph, isUnicodeEnabled } = require('../lib/renderers/tree');
+const { createTranslator } = require('../lib/i18n/catalog');
 
 function toGraphNode(node) {
   return {
@@ -69,9 +70,14 @@ function collectGraph(repoRoot, options = {}) {
 }
 
 function formatHumanGraph(report, options = {}) {
+  const translator = createTranslator(options.language);
   const format = options.format || 'tree';
+  if (format === 'tree' && typeof options.level === 'number' && (!Array.isArray(report.levels) || report.levels.length === 0)) {
+    return `${translator.t('graph.empty.level', { level: options.level })}\n`;
+  }
   const sharedOptions = {
     showConflicts: options.showConflicts === true,
+    language: options.language,
     unicode: options.unicode === true || isUnicodeEnabled(options),
   };
 
@@ -87,12 +93,13 @@ function formatHumanGraph(report, options = {}) {
     return renderDotGraph(report, sharedOptions);
   }
 
-  throw new Error(`create-quiver: unsupported graph format: ${format}`);
+  throw new Error(`create-quiver: ${translator.t('graph.error.unsupported_format', { format })}`);
 }
 
 function runGraph(repoRoot, options = {}) {
+  const translator = createTranslator(options.language);
   if (options.format && !['tree', 'mermaid', 'dot'].includes(options.format)) {
-    throw new Error(`create-quiver: unsupported graph format: ${options.format}`);
+    throw new Error(`create-quiver: ${translator.t('graph.error.unsupported_format', { format: options.format })}`);
   }
 
   const report = collectGraph(repoRoot, 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;
   }