create-quiver 0.15.0 → 0.15.2

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

@@ -1,6 +1,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
+const { redactSecrets, truncateText } = require('./evidence');
 const { quiverInternalPaths } = require('./init-layout');
 
 const PLANNER_APPROVAL_PHASES = Object.freeze(['acceptance', 'technical-plan']);
@@ -185,6 +186,107 @@ function renderApprovalStatus(report) {
   return `approved ${report.phase}`;
 }
 
+function safePreview(text, maxLength = 180) {
+  const firstLines = String(text || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .slice(0, 3)
+    .join(' ');
+  const truncated = truncateText(redactSecrets(firstLines), maxLength);
+  return {
+    text: truncated.text.replace(/\s+/g, ' ').trim(),
+    truncated: truncated.truncated,
+  };
+}
+
+function readCandidatePreview(projectRoot, draft) {
+  const draftPath = draft?.path || '';
+  if (!draftPath) {
+    return safePreview('');
+  }
+  const resolved = path.resolve(projectRoot, draftPath);
+  if (!fs.existsSync(resolved)) {
+    return {
+      text: '(missing draft artifact)',
+      truncated: false,
+    };
+  }
+  return safePreview(fs.readFileSync(resolved, 'utf8'));
+}
+
+function buildApprovalCandidate(projectRoot, phase, draft, latestVersion, report) {
+  const version = Number(draft.version || 0) || null;
+  const isLatest = Boolean(version && latestVersion && version === latestVersion);
+  const artifactExists = Boolean(draft.path && fs.existsSync(path.resolve(projectRoot, draft.path)));
+  const preview = readCandidatePreview(projectRoot, draft);
+  const approvable = isLatest && artifactExists && (report.status === 'draft' || report.status === 'stale' || report.status === 'approved');
+  const nextCommand = version
+    ? `npx create-quiver ai approve --phase ${phase} --version ${version}`
+    : `npx create-quiver ai approve --phase ${phase} --version <n>`;
+
+  return {
+    phase,
+    version,
+    label: version ? `v${version}` : 'unknown version',
+    path: draft.path || '',
+    source_file: draft.source_file || '',
+    created_at: draft.created_at || '',
+    raw_artifact_path: draft.raw_artifact_path || null,
+    output_source: draft.output_source || null,
+    input_compaction: draft.input_compaction || null,
+    current: isLatest,
+    latest: isLatest,
+    recommended: approvable,
+    approvable,
+    blocked: !approvable,
+    status: approvable ? 'approvable' : isLatest ? 'blocked' : 'history',
+    reason: approvable
+      ? 'latest draft is eligible for approval'
+      : isLatest
+        ? 'latest draft artifact is missing or not eligible'
+        : `not current; latest draft version is ${latestVersion || 'unknown'}`,
+    preview: preview.text,
+    preview_truncated: preview.truncated,
+    next_command: nextCommand,
+    recommended_action: approvable ? 'approve' : 'inspect',
+    review: null,
+  };
+}
+
+function buildPlannerApprovalCandidates(projectRoot, phase) {
+  const normalizedPhase = normalizePhase(phase);
+  if (!PLANNER_APPROVAL_PHASES.includes(normalizedPhase)) {
+    throw new Error(formatError(`approval candidates are only supported for planner phases: ${PLANNER_APPROVAL_PHASES.join(', ')}`));
+  }
+
+  const report = readPhaseApproval(projectRoot, normalizedPhase);
+  const drafts = normalizeDrafts(report.meta);
+  const latestVersion = latestDraftVersion(report.meta);
+  const candidates = drafts.map((draft) => buildApprovalCandidate(projectRoot, normalizedPhase, draft, latestVersion, report));
+  const current = candidates.find((candidate) => candidate.current) || null;
+  const recommended = candidates.find((candidate) => candidate.recommended) || null;
+
+  return {
+    phase: normalizedPhase,
+    approval_status: report.status,
+    latest_version: latestVersion,
+    current,
+    recommended,
+    candidates,
+    history: candidates.filter((candidate) => !candidate.current),
+    approved: report.approved
+      ? {
+          path: report.approved.path,
+          version: Number(report.meta?.approved?.version || 0) || null,
+          source_file: report.meta?.approved?.source_file || '',
+          approved_at: report.meta?.approved?.approved_at || '',
+        }
+      : null,
+    next_command: recommended?.next_command || `npx create-quiver ai plan --phase ${normalizedPhase}${normalizedPhase === 'acceptance' ? ' --input <requirements.md>' : ''} --dry-run`,
+  };
+}
+
 function writeApprovalArtifacts(projectRoot, phase, kind, sourceFile, contents, options = {}) {
   const normalizedPhase = normalizePhase(phase);
   const root = approvalRoot(projectRoot, normalizedPhase);
@@ -372,6 +474,7 @@ module.exports = {
   approvePlannerPhase,
   findDraftVersion,
   latestDraftVersion,
+  buildPlannerApprovalCandidates,
   normalizePhase,
   readPhaseApproval,
   renderApprovalStatus,

package/src/create-quiver/lib/cli/selectors.js

@@ -101,7 +101,60 @@ async function selectOption(message, rawOptions, options = {}) {
   ].join('\n')));
 }
 
+async function promptText(message, options = {}) {
+  const explicit = String(options.value || '').trim();
+  if (explicit) return explicit;
+
+  const mode = resolveUxMode({
+    interactive: options.interactive === true,
+    json: options.json,
+    noColor: options.noColor,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    stderrIsTTY: options.stderrIsTTY,
+  }, options.env || process.env, {
+    input: options.input || process.stdin,
+    output: options.output || process.stdout,
+    error: options.error || process.stderr,
+  });
+
+  if (mode.usePrompts) {
+    if (typeof options.promptText === 'function') {
+      const value = await options.promptText(message, options);
+      const normalized = String(value || '').trim();
+      if (!normalized && options.required !== false) {
+        throw new Error(formatError(`${options.name || 'input'} is required.`));
+      }
+      return normalized;
+    }
+    const clack = await loadClack(options.prompts);
+    const value = await clack.text({
+      message,
+      placeholder: options.placeholder,
+      initialValue: options.initialValue,
+      validate: options.required === false
+        ? undefined
+        : (input) => (String(input || '').trim() ? undefined : 'Required'),
+    });
+    if (clack.isCancel && clack.isCancel(value)) {
+      throw new Error(formatError(`${options.name || 'input'} was canceled.`));
+    }
+    return String(value || '').trim();
+  }
+
+  if (options.defaultValue !== undefined && options.defaultValue !== null) {
+    return String(options.defaultValue).trim();
+  }
+
+  const flag = options.flag || '--value';
+  throw new Error(formatError([
+    `${options.name || 'input'} requires an explicit value.`,
+    `Use ${flag} <value> or rerun with --interactive.`,
+  ].join('\n')));
+}
+
 module.exports = {
   normalizeSelectorOptions,
+  promptText,
   selectOption,
 };

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

@@ -19,6 +19,14 @@ function tryGit(args, cwd, options = {}) {
   }
 }
 
+function withWindowsLongPaths(args, options = {}) {
+  const platform = options.platform || process.platform;
+  if (platform !== 'win32') {
+    return args;
+  }
+  return ['-c', 'core.longpaths=true', ...args];
+}
+
 function hasRef(repoRoot, ref) {
   try {
     runGit(['show-ref', '--verify', '--quiet', ref], repoRoot);
@@ -45,11 +53,11 @@ function fetchRemote(repoRoot, remote = 'origin', args = ['--prune']) {
 }
 
 function worktreePrune(repoRoot) {
-  tryGit(['worktree', 'prune'], repoRoot);
+  tryGit(withWindowsLongPaths(['worktree', 'prune']), repoRoot);
 }
 
 function worktreeList(repoRoot) {
-  const text = tryGit(['worktree', 'list', '--porcelain'], repoRoot);
+  const text = tryGit(withWindowsLongPaths(['worktree', 'list', '--porcelain']), repoRoot);
   const entries = [];
   const chunks = text.trim().split('\n\n').filter(Boolean);
 
@@ -79,7 +87,7 @@ function worktreeAdd(repoRoot, worktreePath, ref, options = {}) {
     args.push('--force');
   }
   args.push(worktreePath, ref);
-  return runGit(args, repoRoot);
+  return runGit(withWindowsLongPaths(args, options), repoRoot);
 }
 
 function worktreeRemove(repoRoot, worktreePath, force = false) {
@@ -88,7 +96,7 @@ function worktreeRemove(repoRoot, worktreePath, force = false) {
     args.push('--force');
   }
   args.push(worktreePath);
-  return runGit(args, repoRoot);
+  return runGit(withWindowsLongPaths(args), repoRoot);
 }
 
 function branchDelete(repoRoot, branchName, force = false) {
@@ -207,6 +215,7 @@ module.exports = {
   runGit,
   statusPorcelain,
   tryGit,
+  withWindowsLongPaths,
   worktreeAdd,
   worktreeList,
   worktreePrune,

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

@@ -84,9 +84,42 @@ function realpathOrResolve(filePath, pathLib = path) {
   }
 }
 
-function isPathInsideRoot(root, target, pathLib = path) {
-  const rootPath = realpathOrResolve(root, pathLib);
-  const targetPath = realpathOrResolve(target, pathLib);
+function realpathCandidates(filePath, pathLib = path) {
+  const normalized = normalizeGitBashDrivePath(filePath, pathLib);
+  const candidates = [];
+
+  const add = (candidate) => {
+    if (!candidate) {
+      return;
+    }
+    const resolved = pathLib.resolve(normalizeGitBashDrivePath(candidate, pathLib));
+    if (!candidates.includes(resolved)) {
+      candidates.push(resolved);
+    }
+  };
+
+  try {
+    add(fs.realpathSync(normalized));
+  } catch {
+    // Fall back below for paths that do not exist yet.
+  }
+
+  if (typeof fs.realpathSync.native === 'function') {
+    try {
+      add(fs.realpathSync.native(normalized));
+    } catch {
+      // Fall back below for paths that do not exist yet.
+    }
+  }
+
+  if (candidates.length === 0) {
+    add(normalized);
+  }
+
+  return candidates;
+}
+
+function isCandidateInsideRoot(rootPath, targetPath, pathLib = path) {
   const windowsPath = pathLib === path.win32 || process.platform === 'win32';
   const comparableRoot = windowsPath ? rootPath.toLowerCase() : rootPath;
   const comparableTarget = windowsPath ? targetPath.toLowerCase() : targetPath;
@@ -99,6 +132,15 @@ function isPathInsideRoot(root, target, pathLib = path) {
   return Boolean(relative && !relative.startsWith('..') && !pathLib.isAbsolute(relative));
 }
 
+function isPathInsideRoot(root, target, pathLib = path) {
+  const rootCandidates = realpathCandidates(root, pathLib);
+  const targetCandidates = realpathCandidates(target, pathLib);
+
+  return rootCandidates.some((rootPath) => targetCandidates.some((targetPath) => (
+    isCandidateInsideRoot(rootPath, targetPath, pathLib)
+  )));
+}
+
 function assertPathInsideRoot(root, target, label = 'path', pathLib = path) {
   if (!isPathInsideRoot(root, target, pathLib)) {
     throw new Error(formatError(`${label} must stay inside the project root: ${toPosixPath(target, pathLib)}`));