create-quiver 0.9.0 → 0.10.0

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

@@ -1,5 +1,130 @@
+const { statusPorcelain } = require('./git');
+const { normalizeContextPath } = require('./ai/safety');
 const { checkScope } = require('./readiness');
 
+class ScopeValidationError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = 'ScopeValidationError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function formatError(message) {
+  return `create-quiver: ${message}`;
+}
+
+function normalizeScopePath(filePath) {
+  return normalizeContextPath(filePath);
+}
+
+function parseStatusPorcelain(text) {
+  if (!text) {
+    return [];
+  }
+
+  return String(text)
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .map((line) => {
+      if (line.startsWith('?? ')) {
+        return normalizeScopePath(line.slice(3));
+      }
+
+      const entry = (line[2] === ' ' ? line.slice(3) : line[1] === ' ' ? line.slice(2) : line.slice(3)).trim();
+      if (!entry) {
+        return '';
+      }
+
+      const renamedTarget = entry.includes(' -> ') ? entry.split(' -> ').pop() : entry;
+      return normalizeScopePath(renamedTarget);
+    })
+    .filter(Boolean);
+}
+
+function captureWorktreeSnapshot(repoRoot, options = {}) {
+  const raw = typeof options.rawStatus === 'string' ? options.rawStatus : statusPorcelain(repoRoot);
+  const files = parseStatusPorcelain(raw);
+
+  return {
+    repoRoot,
+    raw,
+    files,
+  };
+}
+
+function diffWorktreeSnapshots(beforeSnapshot, afterSnapshot) {
+  const beforeFiles = new Set((beforeSnapshot && Array.isArray(beforeSnapshot.files) ? beforeSnapshot.files : []).map(normalizeScopePath));
+  const seen = new Set();
+  const changedFiles = [];
+
+  for (const file of afterSnapshot && Array.isArray(afterSnapshot.files) ? afterSnapshot.files : []) {
+    const normalized = normalizeScopePath(file);
+    if (!normalized || beforeFiles.has(normalized) || seen.has(normalized)) {
+      continue;
+    }
+
+    seen.add(normalized);
+    changedFiles.push(normalized);
+  }
+
+  return changedFiles;
+}
+
+function validateScopeSnapshot({ allowedFiles = [], beforeSnapshot, afterSnapshot, strict = true } = {}) {
+  const normalizedAllowedFiles = new Set(
+    Array.isArray(allowedFiles)
+      ? allowedFiles.map(normalizeScopePath).filter(Boolean)
+      : [],
+  );
+  const changedFiles = diffWorktreeSnapshots(beforeSnapshot, afterSnapshot);
+  const outOfScopeFiles = changedFiles.filter((file) => !normalizedAllowedFiles.has(file));
+
+  if (outOfScopeFiles.length === 0) {
+    return {
+      ok: true,
+      changedFiles,
+      outOfScopeFiles,
+      allowedFiles: Array.from(normalizedAllowedFiles),
+      beforeSnapshot,
+      afterSnapshot,
+    };
+  }
+
+  const message = formatError(
+    `scope violation detected: changed files outside slice.json.files: ${outOfScopeFiles.join(', ')}`,
+  );
+  const error = new ScopeValidationError('SCOPE_VIOLATION', message, {
+    allowedFiles: Array.from(normalizedAllowedFiles),
+    beforeSnapshot,
+    afterSnapshot,
+    changedFiles,
+    outOfScopeFiles,
+  });
+
+  if (strict) {
+    throw error;
+  }
+
+  return {
+    ok: false,
+    changedFiles,
+    outOfScopeFiles,
+    allowedFiles: Array.from(normalizedAllowedFiles),
+    beforeSnapshot,
+    afterSnapshot,
+    error,
+  };
+}
+
 module.exports = {
+  ScopeValidationError,
+  captureWorktreeSnapshot,
+  diffWorktreeSnapshots,
   checkScope,
+  normalizeScopePath,
+  parseStatusPorcelain,
+  validateScopeSnapshot,
 };

package/src/create-quiver/lib/slice-graph.js

@@ -34,6 +34,10 @@ function naturalNumberFromSliceId(sliceId) {
   return match ? Number.parseInt(match[1], 10) : Number.POSITIVE_INFINITY;
 }
 
+function isFoundationSliceId(sliceId) {
+  return naturalNumberFromSliceId(sliceId) === 0;
+}
+
 function compareSliceRefs(a, b) {
   const left = String(a || '');
   const right = String(b || '');
@@ -448,6 +452,8 @@ module.exports = {
   computeLevels,
   detectFileConflicts,
   inferDependencies,
+  isFoundationSliceId,
   readAllSlices,
+  naturalNumberFromSliceId,
   topoSort,
 };

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

@@ -1,17 +1,18 @@
 const fs = require('fs');
 const path = require('path');
 const { parseJsonWithComments } = require('./json');
-const { resolveTargetRoot, toPosixPath } = require('./paths');
+const { normalizeGitBashDrivePath, relativePosixPath, resolveTargetRoot, specRelativePathFromPath, toPosixPath } = require('./paths');
 
 function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));
 }
 
 function canonicalizePath(dirPath) {
+  const normalizedPath = normalizeGitBashDrivePath(dirPath);
   try {
-    return fs.realpathSync(dirPath);
+    return normalizeGitBashDrivePath(fs.realpathSync(normalizedPath));
   } catch {
-    return path.resolve(dirPath);
+    return path.resolve(normalizedPath);
   }
 }
 
@@ -94,19 +95,61 @@ function validateSliceMetaForStart(slice) {
   }
 }
 
+function isSpecRelativePath(parts) {
+  return parts[0] === 'specs' || parts[0] === 'specs-fix';
+}
+
+function resolveRepoSlicePath(repoRoot, relSlicePath) {
+  const candidate = path.join(repoRoot, relSlicePath);
+  if (!fs.existsSync(candidate)) {
+    return '';
+  }
+
+  return canonicalizePath(candidate);
+}
+
 function resolveSliceContext(repoRoot, slicePath) {
-  const absSlicePath = resolveSlicePath(slicePath);
-  const relSlicePath = toPosixPath(path.relative(repoRoot, absSlicePath));
-  const parts = relSlicePath.split('/');
+  const canonicalRepoRoot = canonicalizePath(repoRoot);
+  let absSlicePath = resolveSlicePath(slicePath);
+  let relSlicePath = relativePosixPath(canonicalRepoRoot, absSlicePath);
+  let parts = relSlicePath.split('/');
+
+  if (!isSpecRelativePath(parts)) {
+    const cwdRelSlicePath = relativePosixPath(canonicalizePath(process.cwd()), absSlicePath);
+    const cwdParts = cwdRelSlicePath.split('/');
+    if (isSpecRelativePath(cwdParts)) {
+      relSlicePath = cwdRelSlicePath;
+      parts = cwdParts;
+    }
+  }
+
+  if (!isSpecRelativePath(parts) && !path.isAbsolute(slicePath)) {
+    const inputRelSlicePath = toPosixPath(slicePath).replace(/^\.\/+/, '');
+    const inputParts = inputRelSlicePath.split('/');
+    if (isSpecRelativePath(inputParts)) {
+      relSlicePath = inputRelSlicePath;
+      parts = inputParts;
+    }
+  }
+
+  if (!isSpecRelativePath(parts)) {
+    const candidateRelSlicePath = specRelativePathFromPath(absSlicePath) || specRelativePathFromPath(slicePath);
+    const candidateAbsSlicePath = candidateRelSlicePath ? resolveRepoSlicePath(canonicalRepoRoot, candidateRelSlicePath) : '';
+    if (candidateAbsSlicePath) {
+      relSlicePath = candidateRelSlicePath;
+      parts = relSlicePath.split('/');
+      absSlicePath = candidateAbsSlicePath;
+    }
+  }
 
-  if (parts[0] !== 'specs' && parts[0] !== 'specs-fix') {
+  if (!isSpecRelativePath(parts)) {
     throw new Error('create-quiver: el slice debe vivir dentro de specs/ o specs-fix/.');
   }
 
   const specFamily = parts[0];
   const specSlug = parts[1];
   const specDirRel = `${specFamily}/${specSlug}`;
-  const specDirAbs = path.join(repoRoot, specDirRel);
+  const specDirAbs = path.join(canonicalRepoRoot, specDirRel);
   const slice = readSliceMeta(absSlicePath);
   slice.specFamily = specFamily;
   slice.specSlug = specSlug;

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

@@ -1,8 +1,9 @@
 const fs = require('fs');
 const path = require('path');
+const { quiverInternalPaths } = require('./init-layout');
 
 function statePath(projectRoot) {
-  return path.join(projectRoot, '.quiver', 'state.json');
+  return quiverInternalPaths(projectRoot).statePath;
 }
 
 function ensureDir(dirPath) {
@@ -60,6 +61,21 @@ function hasLegacyQuiverInitializationEvidence(projectRoot) {
     && hasGeneratedProjectSpec(projectRoot);
 }
 
+function inspectLegacyMigrationLayout(projectRoot) {
+  const candidates = [
+    'docs-template/',
+    'tools/scripts/',
+    'docs/PROJECT_SCAN.json',
+  ];
+
+  const detected = candidates.filter((relativePath) => fs.existsSync(path.join(projectRoot, relativePath)));
+
+  return {
+    hasLegacyLayout: detected.length > 0,
+    legacyPaths: detected,
+  };
+}
+
 function hasQuiverInitializationEvidence(projectRoot) {
   const state = readState(projectRoot);
   return hasInitializedStateMetadata(state) || hasLegacyQuiverInitializationEvidence(projectRoot);
@@ -129,6 +145,7 @@ module.exports = {
   hasGeneratedProjectSpec,
   hasInitializedStateMetadata,
   hasLegacyQuiverInitializationEvidence,
+  inspectLegacyMigrationLayout,
   hasQuiverInitializationEvidence,
   readState,
   statePath,

package/src/create-quiver/lib/template-resolver.js

@@ -0,0 +1,74 @@
+const fs = require('fs');
+const path = require('path');
+
+function resolvePackagedTemplateRoot(packageRoot = path.resolve(__dirname, '../../..')) {
+  return packageRoot;
+}
+
+function resolveExportedTemplateRoot(projectRoot) {
+  return path.join(projectRoot, '.quiver', 'templates');
+}
+
+function resolveLegacyTemplateRoot(projectRoot) {
+  return path.join(projectRoot, 'docs-template');
+}
+
+function templateRootExists(templateRoot) {
+  return fs.existsSync(path.join(templateRoot, 'docs'))
+    && fs.existsSync(path.join(templateRoot, 'specs'))
+    && fs.existsSync(path.join(templateRoot, 'package.template.json'));
+}
+
+function resolveTemplateRoot(projectRoot, options = {}) {
+  const packageRoot = options.packageRoot || resolvePackagedTemplateRoot();
+  const candidates = [];
+
+  if (options.preferExported === true) {
+    candidates.push({
+      kind: 'exported',
+      path: resolveExportedTemplateRoot(projectRoot),
+    });
+  }
+
+  candidates.push({
+    kind: 'packaged',
+    path: resolvePackagedTemplateRoot(packageRoot),
+  });
+
+  candidates.push({
+    kind: 'legacy',
+    path: resolveLegacyTemplateRoot(projectRoot),
+  });
+
+  for (const candidate of candidates) {
+    if (templateRootExists(candidate.path)) {
+      return candidate;
+    }
+  }
+
+  const searched = candidates.map((candidate) => `${candidate.kind}: ${candidate.path}`).join(', ');
+  throw new Error(`create-quiver: missing Quiver templates. Searched ${searched}`);
+}
+
+function resolveTemplatePath(projectRoot, relativePath, options = {}) {
+  const root = resolveTemplateRoot(projectRoot, options);
+  const templatePath = path.join(root.path, relativePath);
+
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`create-quiver: missing template ${relativePath} in ${root.path}`);
+  }
+
+  return {
+    ...root,
+    templatePath,
+  };
+}
+
+module.exports = {
+  resolveExportedTemplateRoot,
+  resolveLegacyTemplateRoot,
+  resolvePackagedTemplateRoot,
+  resolveTemplatePath,
+  resolveTemplateRoot,
+  templateRootExists,
+};

package/.claude/settings.local.json

@@ -1,52 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git fetch *)",
-      "Bash(git checkout *)",
-      "Bash(git add *)",
-      "Bash(git commit -m ' *)",
-      "Bash(git cherry-pick *)",
-      "Bash(git reset *)",
-      "Bash(gh pr create --title 'docs: register v17-v22 orchestration plan and park web console idea' --base main --head docs/register-orchestration-plan-park-web-console --body ' *)",
-      "Bash(gh auth *)",
-      "Bash(gh pr *)",
-      "Bash(node -e \"const g=require\\('./src/create-quiver/lib/slice-graph'\\); const slices=g.readAllSlices\\('.'\\); console.log\\('Total slices:', slices.length\\); const graph=g.buildGraph\\(slices\\); const levels=g.computeLevels\\(graph\\); console.log\\('Levels:', levels.length\\);\")",
-      "Bash(npx . plan)",
-      "Bash(git pull *)",
-      "Read(//Users/fabrijk/Documents/Work/Proyectos Personales/nika/frameworks/.worktrees/quiver/bugfix-QUIVER-01-fix-legacy-dependency-resolution/**)",
-      "Bash(node --test tests/)",
-      "Bash(node --test tests/**/*.test.js)",
-      "Bash(node bin/create-quiver.js plan)",
-      "Bash(echo \"EXIT_$?\")",
-      "Bash(node bin/create-quiver.js plan --json)",
-      "Bash(node -e \"const d=JSON.parse\\(require\\('fs'\\).readFileSync\\('/dev/stdin','utf8'\\)\\); console.log\\('plan items:', Array.isArray\\(d.plan\\) ? d.plan.length : 'NOT ARRAY'\\); console.log\\('critical_path:', Array.isArray\\(d.critical_path\\)\\); console.log\\('total_hours:', typeof d.total_hours\\); process.exit\\(Array.isArray\\(d.plan\\) && Array.isArray\\(d.critical_path\\) && typeof d.total_hours === 'number' ? 0 : 1\\)\")",
-      "Bash(grep -v \"^\\\\-\\\\-$\")",
-      "Bash(echo \"EXIT:$?\")",
-      "Bash(node -e \"const d=JSON.parse\\(require\\('fs'\\).readFileSync\\('/tmp/plan_json.txt','utf8'\\)\\); console.log\\('plan:', Array.isArray\\(d.plan\\) ? d.plan.length + ' items' : 'INVALID'\\); console.log\\('critical_path:', Array.isArray\\(d.critical_path\\)\\); console.log\\('total_hours:', typeof d.total_hours\\)\")",
-      "Bash(xargs git branch -d)",
-      "Bash(git branch *)",
-      "Read(//private/tmp/**)",
-      "Read(//Users/fabrijk/Documents/Work/Proyectos Personales/nika/frameworks/quiver-v18-slice02/**)",
-      "Bash(git worktree *)",
-      "Bash(git ls-remote *)",
-      "Bash(node *)",
-      "Bash(npm view *)",
-      "Bash(bash scripts/release-quiver.sh)",
-      "Bash(git stash *)",
-      "Bash(npm whoami *)",
-      "Bash(bash scripts/release-quiver.sh --publish-current)",
-      "Bash(npm pkg *)",
-      "Bash(NPM_TOKEN=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 npm publish --access public)",
-      "Bash(NPM_TOKEN=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 npm publish --access public)",
-      "Bash(npm info *)",
-      "Bash(npm publish *)",
-      "Bash(rm -rf /tmp/quiver-skip-test)",
-      "Bash(mkdir -p /tmp/quiver-skip-test)",
-      "Bash(echo '{\"name\":\"test\",\"scripts\":{}}')",
-      "Bash(ls /tmp/quiver-skip-test/node_modules/create-quiver)",
-      "Bash(rm -rf /tmp/quiver-install-test)",
-      "Bash(mkdir -p /tmp/quiver-install-test)",
-      "Bash(npm config *)"
-    ]
-  }
-}