genesis-compiler 1.2.27 → 1.2.29

package/src/index/stack.js

@@ -10,18 +10,21 @@ import {
 import { composeStackCityPresentation } from './stack-city-presentation.js';
 import { resolveStackPieces } from './stack-composition.js';
 import {
-  composeStackEnvironmentDefaults,
   parseStackEnvironmentDefaultLines,
 } from './stack-environment-defaults.js';
 import {
-  composeStackEnvironmentFiles,
   parseStackEnvironmentFileLines,
 } from './stack-environment-files.js';
 import {
-  composeStackSections,
   opaqueStackSections,
   trimStackSectionLines,
 } from './stack-section.js';
+import {
+  materializeStackProjectContracts,
+  renderStackPreparationPrompt,
+  requireMaterializedStackProjectContracts,
+  stackPieceContractNames,
+} from './stack-project-contracts.js';
 import { parseStackVerificationLines } from './stack-verification.js';
 import {
   applyStackPieceCustomization,
@@ -129,7 +132,7 @@ function renderStack({
   resourceLines = null,
   extensionSections = [],
   stackPackages = [],
-  verificationLines = [],
+  verificationLines = null,
 }) {
   return [
     '# Stack',
@@ -148,7 +151,9 @@ function renderStack({
     ...(environmentFileLines === null
       ? []
       : ['', '## Environment files', '', ...trimStackSectionLines(environmentFileLines)]),
-    ...(verificationLines.length > 0 ? ['', '## Verification', ...verificationLines] : []),
+    ...(verificationLines === null
+      ? []
+      : ['', '## Verification', '', ...trimStackSectionLines(verificationLines)]),
     ...extensionSections.flatMap(({ name, lines }) => (
       ['', `## ${name}`, '', ...trimStackSectionLines(lines)]
     )),
@@ -185,46 +190,48 @@ export async function addStackPieces({ pieces, projectRoot, stackPackages = [] }
       .map((piece) => customizePiece(projectRoot, piece)),
   );
   const selected = selectedPieces.map(({ id }) => id);
+  const newlySelectedPieces = selectedPieces.filter(({ id }) => !existing.includes(id));
   const selectedPackages = [...new Set([
     ...declaredPackages,
     ...selectedPieces.map(({ stackPackage }) => stackPackage).filter(Boolean),
   ])].sort();
-  const verificationLines = parseStackVerificationLines(
-    sections.get('Verification') || [],
+  const projectContracts = materializeStackProjectContracts({
+    components: selectedPieces,
+    knownSectionNames: STACK_SECTIONS,
+    sections,
+  });
+  const verificationLines = projectContracts.verificationLines === null ? null : parseStackVerificationLines(
+    projectContracts.verificationLines,
     { path: STACK_PATH },
   )
     .map(({ label, argv }) => `- Verify \`${label}\`: ${argv.map((value) => `\`${value}\``).join(' ')}`);
-  const resourceLines = sections.has('Resources') ? sections.get('Resources') : null;
+  const resourceLines = projectContracts.resourceLines;
   parseStackResourceLines(resourceLines === null ? undefined : resourceLines, { path: STACK_PATH });
-  const environmentDefaultLines = sections.has('Environment defaults')
-    ? sections.get('Environment defaults')
-    : null;
+  const environmentDefaultLines = projectContracts.environmentDefaultLines;
   parseStackEnvironmentDefaultLines(
     environmentDefaultLines === null ? undefined : environmentDefaultLines,
     { path: STACK_PATH },
   );
-  const environmentFileLines = sections.has('Environment files')
-    ? sections.get('Environment files')
-    : null;
+  const environmentFileLines = projectContracts.environmentFileLines;
   parseStackEnvironmentFileLines(
     environmentFileLines === null ? undefined : environmentFileLines,
     { path: STACK_PATH },
   );
-  const extensionSections = opaqueStackSections(sections, STACK_SECTIONS);
   const rendered = renderStack({
     componentIds: selected,
     environmentDefaultLines,
     environmentFileLines,
     resourceLines,
-    extensionSections,
+    extensionSections: projectContracts.extensionSections,
     stackPackages: selectedPackages,
     verificationLines,
   });
   const stackChanged = rendered !== source;
   if (stackChanged) await writeFileAtomic(location, rendered);
+  const stack = await readStack(projectRoot, { stackPackages: availablePackages });
   const skills = await syncProjectSkills({
     projectRoot,
-    stack: await readStack(projectRoot, { stackPackages: availablePackages }),
+    stack,
   });
   const changedFiles = [
     ...(stackChanged ? [STACK_PATH] : []),
@@ -238,30 +245,34 @@ export async function addStackPieces({ pieces, projectRoot, stackPackages = [] }
     components: selected,
     changedFiles,
     diagnostics: skills.diagnostics,
+    prompt: renderStackPreparationPrompt({
+      components: stack.components,
+      materializedSections: projectContracts.materializedSections,
+      newlySelected: newlySelectedPieces.map(({ id }) => id),
+      projectContracts: stack.projectContracts,
+      reviewSections: [...new Set(newlySelectedPieces.flatMap(stackPieceContractNames))]
+        .filter((name) => sections.has(name)),
+    }),
   };
 }
 
-function distinctVerificationCommands(commands) {
-  const seen = new Set();
-  return commands.filter((command) => {
-    const key = JSON.stringify([command.label, command.argv]);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-function resourceDeclarations(components) {
-  return components.flatMap((piece) => piece.resources.map((resource) => ({
-    component: piece.id,
-    resource,
-  })));
+export async function materializeProjectStackContracts({ projectRoot, stackPackages = [] }) {
+  const source = await readFile(path.join(projectRoot, STACK_PATH), 'utf8');
+  const selected = componentIds(parseSections(source));
+  if (selected.length === 0) {
+    return { changedFiles: [], diagnostics: [], materializedSections: [] };
+  }
+  const result = await addStackPieces({ pieces: selected, projectRoot, stackPackages });
+  return {
+    changedFiles: result.changedFiles,
+    diagnostics: result.diagnostics,
+  };
 }
 
 function composedProse(components, field) {
   return components
-    .map((piece) => piece[field] || '')
-    .filter(Boolean)
+    .filter((piece) => piece[field])
+    .map((piece) => `### \`${piece.id}\`\n\n${piece[field]}`)
     .join('\n\n');
 }
 
@@ -280,7 +291,10 @@ async function customizePiece(projectRoot, piece) {
   }));
 }
 
-export async function readStack(projectRoot, { stackPackages = [] } = {}) {
+async function readStackWithContractMode(projectRoot, {
+  allowComponentContracts,
+  stackPackages = [],
+}) {
   const location = path.join(projectRoot, STACK_PATH);
   let source;
   try {
@@ -305,39 +319,45 @@ export async function readStack(projectRoot, { stackPackages = [] } = {}) {
     catalog,
     requested: componentIds(sections),
   })).map((piece) => customizePiece(projectRoot, piece)));
+  const projectContracts = (allowComponentContracts
+    ? materializeStackProjectContracts
+    : requireMaterializedStackProjectContracts)({
+    components,
+    knownSectionNames: STACK_SECTIONS,
+    sections,
+  });
   const projectVerificationCommands = parseStackVerificationLines(
-    sections.get('Verification') || [],
+    projectContracts.verificationLines || [],
     { path: STACK_PATH },
   ).map(({ line: _line, ...command }) => command);
-  const componentVerificationCommands = components.flatMap((piece) => piece.verificationCommands);
-  const verificationCommands = distinctVerificationCommands(
-    projectVerificationCommands.length > 0
-      ? projectVerificationCommands
-      : componentVerificationCommands,
-  );
+  const verificationCommands = projectVerificationCommands;
   const cityPresentation = composeStackCityPresentation(components);
-  const projectResources = sections.has('Resources')
-    ? parseStackResourceLines(sections.get('Resources'), { path: STACK_PATH })
-    : null;
-  const resources = projectResources === null
-    ? resourceDeclarations(components)
-    : projectResources.map((resource) => ({ component: 'project', resource }));
+  const resources = parseStackResourceLines(
+    projectContracts.resourceLines === null ? undefined : projectContracts.resourceLines,
+    { path: STACK_PATH },
+  ).map((resource) => ({ component: 'project', resource }));
   const projectEnvironmentDefaults = parseStackEnvironmentDefaultLines(
-    sections.has('Environment defaults') ? sections.get('Environment defaults') : undefined,
+    projectContracts.environmentDefaultLines === null
+      ? undefined
+      : projectContracts.environmentDefaultLines,
     { path: STACK_PATH },
   );
-  const environmentDefaults = sections.has('Environment defaults')
-    ? projectEnvironmentDefaults.map((entry) => ({ ...entry, sources: ['project'] }))
-    : composeStackEnvironmentDefaults(components);
+  const environmentDefaults = projectEnvironmentDefaults
+    .map((entry) => ({ ...entry, sources: ['project'] }));
   const projectEnvironmentFiles = parseStackEnvironmentFileLines(
-    sections.has('Environment files') ? sections.get('Environment files') : undefined,
+    projectContracts.environmentFileLines === null
+      ? undefined
+      : projectContracts.environmentFileLines,
     { path: STACK_PATH },
   );
-  const environmentFiles = composeStackEnvironmentFiles(components, projectEnvironmentFiles);
-  const extensions = composeStackSections(
-    components,
-    opaqueStackSections(sections, STACK_SECTIONS),
-  );
+  const environmentFiles = (projectEnvironmentFiles || [])
+    .map((file) => ({ ...file, source: 'project' }));
+  const extensions = projectContracts.extensionSections.map(({ name, lines }) => ({
+    name,
+    lines,
+    source: 'project',
+    diagnostics: [],
+  }));
   return {
     path: STACK_PATH,
     identityHash: sha256(stableJson({
@@ -359,6 +379,7 @@ export async function readStack(projectRoot, { stackPackages = [] } = {}) {
     environmentDefaults,
     environmentFiles,
     extensions,
+    projectContracts: projectContracts.projectContracts,
     resources,
     guidance: composedProse(components, 'guidance'),
     adoption: composedProse(components, 'adoption'),
@@ -367,9 +388,22 @@ export async function readStack(projectRoot, { stackPackages = [] } = {}) {
   };
 }
 
+export function readStack(projectRoot, { stackPackages = [] } = {}) {
+  return readStackWithContractMode(projectRoot, {
+    allowComponentContracts: false,
+    stackPackages,
+  });
+}
+
+export function readLegacyStack(projectRoot, { stackPackages = [] } = {}) {
+  return readStackWithContractMode(projectRoot, {
+    allowComponentContracts: true,
+    stackPackages,
+  });
+}
+
 export function stackPromptContext(stack) {
   return {
-    stackPackages: stack.stackPackages,
     components: stack.components.map((piece) => ({
       id: piece.id,
       description: piece.description,