create-quiver 0.15.1 → 0.15.3

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/init-docs.js

@@ -398,7 +398,9 @@ npm run quiver:ai:execute-plan -- --dry-run --commit --mode delegated
 The generated project includes \`quiver:*\` npm scripts that call the Node CLI:
 
 \`\`\`bash
+npm run quiver:version
 npm run quiver:analyze
+npm run quiver:dashboard
 npm run quiver:prepare -- --dry-run
 npm run quiver:plan
 npm run quiver:graph
@@ -504,7 +506,9 @@ Remove \`--dry-run\` only after the phase output is approved and the local provi
 The generated project includes \`quiver:*\` npm scripts that call the Node CLI and are the preferred repeatable workflow:
 
 \`\`\`bash
+npm run quiver:version
 npm run quiver:analyze
+npm run quiver:dashboard
 npm run quiver:prepare -- --dry-run
 npm run quiver:plan
 npm run quiver:graph
@@ -538,6 +542,8 @@ npm run quiver:refresh-active-slices
 \`\`\`
 
 The \`quiver:graph\` script prints the tree view by default; use \`npx create-quiver graph --format mermaid\` for PR-ready Markdown and \`--format dot\` when you want Graphviz source.
+The \`quiver:version\` script shows the Quiver-branded version report; add \`--json\` for automation while top-level \`--version\` stays semver-only.
+The \`quiver:dashboard\` script shows compact read-only project, spec, slice, run, approval, and agent status by default; use \`--details\` for the full report, \`--section <name>\` for focused inspection, and \`--json\` for automation.
 The \`quiver:next\` script points to the next ready slice and can auto-start it behind a confirmation prompt.
 The \`quiver:ai:*\` scripts standardize planner/executor AI flows. Use dry-run first: onboarding and planning dry-runs do not require provider auth, \`quiver:ai:execute-plan -- --dry-run --commit --mode manual\` prints manual prompts, \`--mode delegated\` prints safe waves, \`quiver:ai:inspect\` shows lifecycle state, \`quiver:ai:export -- --format json|markdown\` emits dashboard/agent-friendly state, and \`quiver:ai:pr -- --dry-run\` validates \`gh\`, GitFlow docs, branch/worktree state, SSH inputs, and \`pr.md\` without creating a PR. Add \`--create\` only after reviewing the plan.
 Use \`quiver:spec:create\`, \`quiver:spec:start\`, \`quiver:spec:status\`, and \`quiver:spec:close\` for one spec generation and worktree per spec.

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

@@ -181,8 +181,10 @@ function resolveInitVisibleDirectories(profile, projectSlug) {
 function resolveInitPackageScripts(profile, options = {}) {
   const baseScripts = {
     'quiver:migrate': 'npx create-quiver migrate',
+    'quiver:version': 'npx create-quiver version',
     'quiver:analyze': 'npx create-quiver analyze',
     'quiver:flow': 'npx create-quiver flow',
+    'quiver:dashboard': 'npx create-quiver dashboard',
     'quiver:prepare': 'npx create-quiver prepare',
     'quiver:plan': 'npx create-quiver plan',
     'quiver:graph': 'npx create-quiver graph',

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)}`));

package/src/create-quiver/lib/project-state-resolver.js

@@ -83,8 +83,28 @@ function safeBuildGraph(slices, allowGraphErrors) {
 function resolveProjectState(projectRoot, options = {}) {
   const specSlug = options.specSlug ? String(options.specSlug).trim() : '';
   const rawSlices = readResolverSlices(projectRoot, specSlug);
-  const graph = safeBuildGraph(rawSlices, options.allowGraphErrors === true);
-  const orderedSlices = graph.ok ? topoSort(graph).map(normalizeSliceRecord) : graph.nodes.slice().sort((left, right) => compareRefs(left.ref, right.ref));
+  let graph = safeBuildGraph(rawSlices, options.allowGraphErrors === true);
+  let orderedSlices;
+
+  try {
+    orderedSlices = graph.ok ? topoSort(graph).map(normalizeSliceRecord) : graph.nodes.slice().sort((left, right) => compareRefs(left.ref, right.ref));
+  } catch (error) {
+    if (!options.allowGraphErrors || !(error instanceof SliceGraphError)) {
+      throw error;
+    }
+
+    graph = {
+      ok: false,
+      nodes: inferDependencies(rawSlices).map(normalizeSliceRecord),
+      edges: [],
+      cycles: Array.isArray(graph.cycles) ? graph.cycles : [],
+      error: {
+        code: error.code,
+        message: error.message,
+      },
+    };
+    orderedSlices = graph.nodes.slice().sort((left, right) => compareRefs(left.ref, right.ref));
+  }
 
   return {
     graph,

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

@@ -0,0 +1,157 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { resolveTheme } = require('./cli/theme');
+
+const VERSION_SCHEMA_VERSION = 1;
+const PACKAGE_ROOT = path.resolve(__dirname, '../../..');
+const PACKAGE_JSON = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+
+function readJsonIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function parsePackageManagerField(value) {
+  const text = String(value || '').trim();
+  if (!text) return null;
+  const [name, version] = text.split('@');
+  return {
+    name: name || null,
+    version: version || null,
+    source: 'package.json',
+  };
+}
+
+function parseUserAgent(value) {
+  const text = String(value || '').trim();
+  if (!text) return null;
+  const first = text.split(/\s+/)[0] || '';
+  const [name, version] = first.split('/');
+  if (!name) return null;
+  return {
+    name,
+    version: version || null,
+    source: 'npm_config_user_agent',
+  };
+}
+
+function detectPackageManager(projectRoot, env = process.env) {
+  const packageJson = readJsonIfExists(path.join(projectRoot, 'package.json'));
+  const packageManagerField = parsePackageManagerField(packageJson?.packageManager);
+  if (packageManagerField) return packageManagerField;
+
+  const signals = [
+    ['bun', 'bun.lockb'],
+    ['bun', 'bun.lock'],
+    ['pnpm', 'pnpm-lock.yaml'],
+    ['yarn', 'yarn.lock'],
+    ['npm', 'package-lock.json'],
+  ];
+
+  for (const [name, filename] of signals) {
+    if (fs.existsSync(path.join(projectRoot, filename))) {
+      return { name, version: null, source: filename };
+    }
+  }
+
+  return parseUserAgent(env.npm_config_user_agent) || {
+    name: 'unknown',
+    version: null,
+    source: 'none',
+  };
+}
+
+function collectProjectInfo(projectRoot) {
+  const packageJson = readJsonIfExists(path.join(projectRoot, 'package.json'));
+  const state = readJsonIfExists(path.join(projectRoot, '.quiver', 'state.json'));
+  const hasProjectSignals = Boolean(packageJson || state);
+
+  if (!hasProjectSignals) {
+    return {
+      name: null,
+      path: null,
+      quiver_initialized: false,
+      quiver_version: null,
+    };
+  }
+
+  return {
+    name: packageJson?.name || state?.project_name || path.basename(projectRoot),
+    path: projectRoot,
+    quiver_initialized: Boolean(state?.initialized_version || state?.quiver_version),
+    quiver_version: state?.quiver_version || state?.initialized_version || null,
+  };
+}
+
+function collectVersionReport(projectRoot = process.cwd(), options = {}) {
+  return {
+    version_schema_version: VERSION_SCHEMA_VERSION,
+    cli: {
+      name: PACKAGE_JSON.name || 'create-quiver',
+      version: options.cliVersion || PACKAGE_JSON.version || '0.0.0',
+    },
+    runtime: {
+      node: process.version,
+      platform: process.platform,
+      arch: process.arch,
+    },
+    package_manager: detectPackageManager(projectRoot, options.env || process.env),
+    project: collectProjectInfo(projectRoot),
+  };
+}
+
+function formatPackageManager(packageManager) {
+  if (!packageManager?.name || packageManager.name === 'unknown') {
+    return 'unknown';
+  }
+  return packageManager.version ? `${packageManager.name}@${packageManager.version}` : packageManager.name;
+}
+
+function quiverBanner(theme) {
+  const lines = [
+    '  ___        _                ',
+    ' / _ \\ _   _(_)_   _____ _ __ ',
+    '| | | | | | | \\ \\ / / _ \\ \'__|',
+    '| |_| | |_| | |\\ V /  __/ |   ',
+    ' \\__\\_\\\\__,_|_| \\_/ \\___|_|   ',
+  ];
+  const colors = ['sky', 'blue', 'periwinkle', 'violet', 'magenta'];
+  return lines.map((line, index) => theme.colorize(line, colors[index])).join('\n');
+}
+
+function formatHumanVersionReport(report, options = {}) {
+  const theme = resolveTheme({ noColor: options.noColor }, options.env || process.env, {
+    stdout: options.stdoutIsTTY ?? Boolean(process.stdout.isTTY),
+  });
+  const project = report.project?.name
+    ? `${report.project.name}${report.project.quiver_initialized ? ' (Quiver project)' : ''}`
+    : 'none';
+  const lines = [
+    quiverBanner(theme),
+    '',
+    `Quiver CLI: ${report.cli.version}`,
+    `Node: ${report.runtime.node}`,
+    `Package manager: ${formatPackageManager(report.package_manager)}`,
+    `OS: ${report.runtime.platform} ${report.runtime.arch}`,
+    `Project: ${project}`,
+    '',
+  ];
+
+  return `${lines.join('\n')}`;
+}
+
+module.exports = {
+  VERSION_SCHEMA_VERSION,
+  collectVersionReport,
+  detectPackageManager,
+  formatHumanVersionReport,
+  quiverBanner,
+};