create-quiver 0.15.2 → 0.15.3

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/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,
+};