@juangcarmona/lighthouse 0.4.0 → 0.6.0

package/src/lighthouse.mjs

@@ -6,6 +6,7 @@ import { createRequire } from 'node:module';
 import { basename, dirname, resolve } from 'node:path';
 import { execFileSync, spawnSync } from 'node:child_process';
 import { evaluateGuardrails, readGuardrailCatalog } from './guardrails.mjs';
+import { composeProfiles, normalizeApplication, profileCompositionResult, readProfileCatalog } from './profiles.mjs';
 let sdlcCapabilities;
 let sdlcReconcile;
 let sdlcGithub;
@@ -32,6 +33,7 @@ const upgradeStateRelative = '.lighthouse/upgrade.json';
 const upgradeStatePath = resolve(root, upgradeStateRelative);
 const layout = ['src', 'docs', 'infra', 'scripts'];
 const sdlcPackage = { name: '@juangcarmona/lighthouse-sdlc', version: installedPackageVersion('@juangcarmona/lighthouse-sdlc', 'contract.json') ?? '0.1.0' };
+const uiPackage = { name: '@juangcarmona/lighthouse-ui', version: installedPackageVersion('@juangcarmona/lighthouse-ui', 'DESIGN.md') ?? '0.1.0' };
 const managedPaths = [
   projection,
   'scripts/lighthouse-guard.mjs',
@@ -41,16 +43,17 @@ const managedPaths = [
   '.lighthouse/sdlc.json',
   upgradeStateRelative,
 ];
+const profileManagedPaths = Object.freeze({
+  'visual-theme': ['docs/design/DESIGN.md', '.agents/skills/lighthouse-ui/SKILL.md'],
+  'dotnet-backend': ['docs/profiles/dotnet/README.md', 'docs/profiles/dotnet/adoption.md', 'docs/profiles/dotnet/architecture.md', 'docs/profiles/dotnet/guardrails.md', 'docs/profiles/dotnet/practices.md', 'docs/profiles/dotnet/testing-and-development.md', 'docs/profiles/dotnet/use-cases.md', '.agents/skills/lighthouse-dotnet/SKILL.md'],
+});
 const previousManagedPaths = managedPaths.slice(0, -1);
 const legacyManagedPaths = [projection];
+const supportedProfiles = ['node-tooling', 'dotnet-backend', 'visual-theme'];
 const branchPattern = '^(feat|fix|docs|refactor|test|chore|build|ci|perf|revert)/[1-9]\\d*-[a-z0-9]+(?:-[a-z0-9]+)*$';
 const authorityVersions = { productShape: '0.22.0', arcShape: '0.1.3' };
-const upgradeScopes = {
-  harness: [projection, 'scripts/lighthouse-guard.mjs', '.husky/commit-msg', '.husky/pre-push', '.github/workflows/lighthouse.yml'],
-  sdlc: ['.lighthouse/sdlc.json'],
-};
 const upgradeSchema = './node_modules/@juangcarmona/lighthouse/assets/schemas/lighthouse-upgrade.schema.json';
-const usage = 'Usage: lighthouse <init|authorities|reconcile|upgrade|capabilities|verify> [--name <product>] [--scope <harness|sdlc|all>] [--format <text|json>] [--dry-run] [--apply]';
+const usage = 'Usage: lighthouse <init|create-dotnet|profiles|authorities|reconcile|upgrade|capabilities|verify> [--name <product>] [--profile <profile>] [--scope <harness|sdlc|all>] [--format <text|json>] [--dry-run] [--apply]';
 
 const defaultRepository = () => ({
   layout: [...layout],
@@ -58,16 +61,69 @@ const defaultRepository = () => ({
   conventions: { commits: 'conventional', branchPattern },
 });
 
-function defaultManifest(product) {
+function managedPathsFor(manifest) {
+  const profiles = manifest?.profiles ?? [];
+  return [...managedPaths, ...profiles.flatMap((profile) => profileManagedPaths[profile] ?? [])];
+}
+
+function upgradeScopesFor(manifest) {
+  return {
+    harness: [projection, 'scripts/lighthouse-guard.mjs', '.husky/commit-msg', '.husky/pre-push', '.github/workflows/lighthouse.yml', ...((manifest?.profiles ?? []).flatMap((profile) => profileManagedPaths[profile] ?? []))],
+    sdlc: ['.lighthouse/sdlc.json'],
+  };
+}
+
+function packageAsset(packageName, entry) {
+  const path = packageRequire.resolve(`${packageName}/${entry}`);
+  return readFileSync(path, 'utf8');
+}
+
+function profileAssets(manifest) {
+  const assets = {};
+  if ((manifest?.profiles ?? []).includes('visual-theme')) {
+    try {
+      assets['docs/design/DESIGN.md'] = packageAsset('@juangcarmona/lighthouse-ui', 'DESIGN.md');
+      assets['.agents/skills/lighthouse-ui/SKILL.md'] = packageAsset('@juangcarmona/lighthouse-ui', 'skills/ui-design/SKILL.md');
+    } catch (error) {
+      throw new Error(`Cannot read the installed Lighthouse UI profile: ${error.message}`);
+    }
+  }
+  if ((manifest?.profiles ?? []).includes('dotnet-backend')) {
+    const files = ['README.md', 'adoption.md', 'architecture.md', 'guardrails.md', 'practices.md', 'testing-and-development.md', 'use-cases.md', 'SKILL.md'];
+    for (const file of files) {
+      const target = file === 'SKILL.md' ? '.agents/skills/lighthouse-dotnet/SKILL.md' : `docs/profiles/dotnet/${file}`;
+      try { assets[target] = readFileSync(new URL(`../assets/profiles/dotnet/${file}`, import.meta.url), 'utf8'); }
+      catch (error) { throw new Error(`Cannot read the installed Lighthouse .NET profile: ${error.message}`); }
+    }
+  }
+  return assets;
+}
+
+function profileArguments(args) {
+  const selected = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== '--profile' && !args[index].startsWith('--profile=')) continue;
+    const value = args[index] === '--profile' ? args[++index] : args[index].slice('--profile='.length);
+    if (!value || !supportedProfiles.includes(value)) throw new Error(`Unknown profile ${value ?? ''}; use ${supportedProfiles.join(', ')}.`);
+    if (!selected.includes(value)) selected.push(value);
+  }
+  return selected;
+}
+
+function defaultManifest(product, profiles = []) {
+  const draft = { profiles: [...profiles] };
+  const packages = { sdlc: { ...sdlcPackage } };
+  if (profiles.includes('visual-theme')) packages.ui = { ...uiPackage };
   return {
     $schema: './node_modules/@juangcarmona/lighthouse/assets/schemas/lighthouse-manifest.schema.json',
     schemaVersion: 1,
     baseline: '0.1.0',
     product,
-    profiles: [],
+    application: { shape: 'unknown', stacks: [] },
+    profiles: [...profiles],
     integrations: { productShape: null, arcShape: null },
-    packages: { sdlc: { ...sdlcPackage } },
-    managed: [...managedPaths],
+    packages,
+    managed: managedPathsFor(draft),
     repository: defaultRepository(),
   };
 }
@@ -167,7 +223,9 @@ function render(manifest) {
   const publicSite = repository.publicSite.enabled ? 'enabled' : 'disabled';
   const selectedSdlc = normalizeSdlcPackage(manifest);
   const sdlcLine = selectedSdlc ? `- SDLC package: \`${selectedSdlc.name}@${selectedSdlc.version}\`\n` : '';
-  return `<!-- Generated by Lighthouse. Edit lighthouse.json and regenerate this file. -->\n\n# ${manifest.product} repository baseline\n\n- Baseline: \`${manifest.baseline}\`\n- Product: \`${manifest.product}\`\n- Profiles: ${manifest.profiles.length ? manifest.profiles.map((x) => `\`${x}\``).join(', ') : 'none'}\n${sdlcLine}- ProductShape: ${manifest.integrations.productShape ?? 'not adopted'}\n- ArcShape: ${manifest.integrations.arcShape ?? 'not adopted'}\n- Public site: \`${publicSite}\`\n- Repository roots: ${repository.layout.map((x) => `\`${x}/\``).join(', ')}\n- Commit convention: \`${repository.conventions.commits}\`\n\n## Delivery contract\n\nProductShape remains the source of product intent and Product Changes. ArcShape remains the source of architecture documentation and decisions. Lighthouse installs the repository baseline and verifies the selected integrations without replacing either authority.\n\nThe repository keeps source code in \`src/\`, documentation in \`docs/\`, infrastructure in \`infra/\` and repository automation in \`scripts/\`. A project may record a narrow, owned exception, but an initializer never overwrites an existing project file.\n\nThe selected SDLC package owns lifecycle skills, commands, meta-commands, routes and gates. The \`.lighthouse/\` control plane records the selected package and host adapters without storing agent runtime data.\n\nWhen the public site is enabled, its publication is allowed only after ProductShape and ArcShape validate successfully. A missing or invalid authority stops the build before deployment and reports the command that can repair the missing input.\n\nThis file is managed. Put repository-specific policy in its own documentation and keep this projection generated from \`lighthouse.json\`.\n`;
+  const selectedUi = manifest.packages?.ui;
+  const uiLine = selectedUi ? `- UI package: \`${selectedUi.name}@${selectedUi.version}\`\n` : '';
+  return `<!-- Generated by Lighthouse. Edit lighthouse.json and regenerate this file. -->\n\n# ${manifest.product} repository baseline\n\n- Baseline: \`${manifest.baseline}\`\n- Product: \`${manifest.product}\`\n- Profiles: ${manifest.profiles.length ? manifest.profiles.map((x) => `\`${x}\``).join(', ') : 'none'}\n${sdlcLine}${uiLine}- ProductShape: ${manifest.integrations.productShape ?? 'not adopted'}\n- ArcShape: ${manifest.integrations.arcShape ?? 'not adopted'}\n- Public site: \`${publicSite}\`\n- Repository roots: ${repository.layout.map((x) => `\`${x}/\``).join(', ')}\n- Commit convention: \`${repository.conventions.commits}\`\n\n## Delivery contract\n\nProductShape remains the source of product intent and Product Changes. ArcShape remains the source of architecture documentation and decisions. Lighthouse installs the repository baseline and verifies the selected integrations without replacing either authority.\n\nThe repository keeps source code in \`src/\`, documentation in \`docs/\`, infrastructure in \`infra/\` and repository automation in \`scripts/\`. A project may record a narrow, owned exception, but an initializer never overwrites an existing project file.\n\nThe selected SDLC package owns lifecycle skills, commands, meta-commands, routes and gates. The \`.lighthouse/\` control plane records the selected package and host adapters without storing agent runtime data.\n\nWhen the public site is enabled, its publication is allowed only after ProductShape and ArcShape validate successfully. A missing or invalid authority stops the build before deployment and reports the command that can repair the missing input.\n\nThis file is managed. Put repository-specific policy in its own documentation and keep this projection generated from \`lighthouse.json\`.\n`;
 }
 
 function guardrailScript(manifest) {
@@ -259,6 +317,7 @@ function managedFiles(manifest) {
     '.husky/pre-push': prePushHook(),
     '.github/workflows/lighthouse.yml': workflow(),
   };
+  Object.assign(files, profileAssets(manifest));
   const controlPlane = sdlcControlPlane(manifest);
   if (controlPlane) files['.lighthouse/sdlc.json'] = controlPlane;
   return files;
@@ -269,9 +328,10 @@ function contentHash(content) {
 }
 
 function upgradeState(manifest, files = managedFiles(manifest), previous = null) {
+  const scopes = upgradeScopesFor(manifest);
   const entries = Object.fromEntries(Object.entries(files).map(([path, content]) => [path, {
     hash: contentHash(content),
-    scope: Object.entries(upgradeScopes).find(([, paths]) => paths.includes(path))?.[0] ?? 'harness',
+    scope: Object.entries(scopes).find(([, paths]) => paths.includes(path))?.[0] ?? 'harness',
   }]));
   return {
     $schema: upgradeSchema,
@@ -309,7 +369,8 @@ function stateProblems(state) {
   return problems;
 }
 
-function scopesFromArgs(args) {
+function scopesFromArgs(args, manifest) {
+  const upgradeScopes = upgradeScopesFor(manifest);
   const selected = new Set();
   for (let index = 0; index < args.length; index += 1) {
     if (args[index] !== '--scope' && !args[index].startsWith('--scope=')) continue;
@@ -325,7 +386,8 @@ function scopesFromArgs(args) {
   return selected.size ? selected : new Set(Object.keys(upgradeScopes));
 }
 
-function selectedPaths(scopes) {
+function selectedPaths(scopes, manifest) {
+  const upgradeScopes = upgradeScopesFor(manifest);
   return new Set([...scopes].flatMap((scope) => upgradeScopes[scope]));
 }
 
@@ -343,7 +405,8 @@ async function planUpgrade(manifest, scopes) {
   const state = await readUpgradeState();
   const problems = stateProblems(state);
   const files = managedFiles(manifest);
-  const paths = selectedPaths(scopes);
+  const paths = selectedPaths(scopes, manifest);
+  const upgradeScopes = upgradeScopesFor(manifest);
   const changes = [];
   for (const path of Object.keys(files).filter((candidate) => paths.has(candidate))) {
     const target = resolve(root, path);
@@ -407,7 +470,7 @@ function printUpgradePlan(plan) {
 function validate(manifest) {
   const problems = [];
   if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) return ['manifest must be an object'];
-  const allowed = ['$schema', 'schemaVersion', 'baseline', 'product', 'profiles', 'integrations', 'packages', 'managed', 'repository'];
+  const allowed = ['$schema', 'schemaVersion', 'baseline', 'product', 'application', 'profiles', 'integrations', 'packages', 'managed', 'repository'];
   for (const key of Object.keys(manifest)) if (!allowed.includes(key)) problems.push(`unknown field ${key}`);
   for (const key of ['schemaVersion', 'baseline', 'product', 'profiles', 'integrations', 'managed']) {
     if (!(key in manifest)) problems.push(`missing ${key}`);
@@ -418,7 +481,16 @@ function validate(manifest) {
   if (typeof manifest.product !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9 ._-]{0,63}$/.test(manifest.product)) {
     problems.push('product must be a readable name of 1–64 characters');
   }
-  const profiles = ['node-tooling', 'dotnet-backend', 'visual-theme'];
+  if ('application' in manifest) {
+    const application = manifest.application;
+    if (!application || typeof application !== 'object' || Array.isArray(application)
+        || !['unknown', 'frontend', 'backend', 'full-stack', 'service', 'library', 'tooling', 'cli', 'worker', 'mobile'].includes(application.shape)
+        || !Array.isArray(application.stacks) || application.stacks.some((stack) => typeof stack !== 'string' || !stack)
+        || new Set(application.stacks).size !== application.stacks.length) {
+      problems.push('application must declare a supported shape and unique stack names');
+    }
+  }
+  const profiles = supportedProfiles;
   if (!Array.isArray(manifest.profiles) || manifest.profiles.some((p) => !profiles.includes(p))
       || new Set(manifest.profiles).size !== manifest.profiles.length) {
     problems.push('profiles must be unique supported profile names');
@@ -435,26 +507,42 @@ function validate(manifest) {
   if ('packages' in manifest) {
     const packages = manifest.packages;
     const selected = packages?.sdlc;
+    const selectedUi = packages?.ui;
+    const hasVisualProfile = manifest.profiles?.includes('visual-theme');
     if (!packages || typeof packages !== 'object' || Array.isArray(packages)
-        || Object.keys(packages).length !== 1
+        || !Object.keys(packages).every((key) => ['sdlc', 'ui'].includes(key))
+        || Object.keys(packages).length < 1 || Object.keys(packages).length > 2
         || !selected || typeof selected !== 'object' || Array.isArray(selected)
         || Object.keys(selected).length !== 2
         || selected.name !== sdlcPackage.name
         || typeof selected.version !== 'string' || !pin.test(selected.version)) {
       problems.push(`packages.sdlc must declare ${sdlcPackage.name} and an exact version or commit hash`);
     }
+    if (hasVisualProfile && (!selectedUi || typeof selectedUi !== 'object' || Array.isArray(selectedUi)
+        || Object.keys(selectedUi).length !== 2
+        || selectedUi.name !== uiPackage.name
+        || typeof selectedUi.version !== 'string' || !pin.test(selectedUi.version))) {
+      problems.push(`packages.ui must declare ${uiPackage.name} and an exact version or commit hash when visual-theme is selected`);
+    }
+    if (!hasVisualProfile && selectedUi) problems.push('packages.ui requires the visual-theme profile');
+  } else if (manifest.profiles?.includes('visual-theme')) {
+    problems.push(`packages must declare ${sdlcPackage.name} and ${uiPackage.name} when visual-theme is selected`);
   }
   const legacyManaged = Array.isArray(manifest.managed)
     && manifest.managed.length === legacyManagedPaths.length
     && manifest.managed.every((entry, index) => entry === legacyManagedPaths[index]);
+  const expectedManagedPaths = managedPathsFor(manifest);
   const completeManaged = Array.isArray(manifest.managed)
+    && manifest.managed.length === expectedManagedPaths.length
+    && manifest.managed.every((entry, index) => entry === expectedManagedPaths[index]);
+  const profilelessManaged = Array.isArray(manifest.managed)
     && manifest.managed.length === managedPaths.length
     && manifest.managed.every((entry, index) => entry === managedPaths[index]);
   const previousCompleteManaged = Array.isArray(manifest.managed)
     && manifest.managed.length === previousManagedPaths.length
     && manifest.managed.every((entry, index) => entry === previousManagedPaths[index]);
-  if (!legacyManaged && !previousCompleteManaged && !completeManaged) {
-    problems.push(`managed must be ${legacyManagedPaths.join(', ')}, the previous Lighthouse guardrail set or the current complete set`);
+  if (!legacyManaged && !profilelessManaged && !previousCompleteManaged && !completeManaged) {
+    problems.push(`managed must be ${legacyManagedPaths.join(', ')}, the previous Lighthouse guardrail set or the selected profile set`);
   }
   if ('repository' in manifest) {
     const repository = manifest.repository;
@@ -563,7 +651,12 @@ function printReconciliationPlan(plan) {
 async function initialize(args) {
   let manifest = await readManifest();
   const manifestMissing = !manifest;
-  if (!manifest) manifest = defaultManifest(productNameFromArgs(args));
+  const selectedProfiles = profileArguments(args);
+  if (!manifest) manifest = defaultManifest(productNameFromArgs(args), selectedProfiles);
+  else if (selectedProfiles.some((profile) => !(manifest.profiles ?? []).includes(profile))) {
+    const missing = selectedProfiles.filter((profile) => !(manifest.profiles ?? []).includes(profile));
+    throw new Error(`The existing lighthouse.json does not select ${missing.join(', ')}; edit its profiles and rerun lighthouse init.`);
+  }
   const problems = validate(manifest);
   if (problems.length) throw new Error(problems.map((problem) => `Invalid lighthouse.json: ${problem}`).join('\n'));
   const plan = await planInitialization(manifest, manifestMissing);
@@ -682,7 +775,7 @@ async function upgrade(args) {
   if (!manifest) throw new Error('Cannot read lighthouse.json: file does not exist; run lighthouse init --name <product>.');
   const problems = validate(manifest);
   if (problems.length) throw new Error(problems.map((problem) => `Invalid lighthouse.json: ${problem}`).join('\n'));
-  const plan = await planUpgrade(manifest, scopesFromArgs(args));
+  const plan = await planUpgrade(manifest, scopesFromArgs(args, manifest));
   const format = formatFromArgs(args);
   const apply = args.includes('--apply');
   const dryRun = args.includes('--dry-run') || !apply;
@@ -849,7 +942,13 @@ async function verify(manifest, format = 'text') {
     readFile,
     validateGitConventions,
     branch: gitBranch(),
+    uiTokens: manifest?.profiles?.includes('visual-theme') ? packageAsset('@juangcarmona/lighthouse-ui', 'tokens.css') : null,
   });
+  const profileComposition = composeProfiles(readProfileCatalog(), manifest);
+  report.profiles = profileComposition;
+  const profileResult = profileCompositionResult(profileComposition);
+  report.results.push(profileResult);
+  report.summary[profileResult.status] = (report.summary[profileResult.status] ?? 0) + 1;
   const adoption = Object.values(capabilityAdoption(await readUpgradeState()));
   for (const item of adoption) {
     if (item.status !== 'adopted' || !item.recordPath || await exists(resolve(root, item.recordPath))) continue;
@@ -883,6 +982,20 @@ async function verify(manifest, format = 'text') {
   console.log('Lighthouse manifest, repository boundaries and managed projection are valid.');
 }
 
+async function profiles(manifest, format = 'text') {
+  const composition = composeProfiles(readProfileCatalog(), manifest);
+  if (format === 'json') {
+    console.log(JSON.stringify(composition, null, 2));
+    if (composition.status === 'failed') process.exitCode = 1;
+    return;
+  }
+  console.log(`Lighthouse profile composition: ${composition.status}`);
+  console.log(`  application ${composition.application.shape}${composition.application.stacks.length ? ` (${composition.application.stacks.join(', ')})` : ''}`);
+  for (const profile of composition.selected) console.log(`  ${profile.id}: ${profile.status}${profile.nextAction ? `; next: ${profile.nextAction}` : ''}`);
+  if (!composition.selected.length) console.log('  no profiles selected');
+  if (composition.status === 'failed') process.exitCode = 1;
+}
+
 function planHash(plan) {
   const { authorization, ...payload } = plan;
   return contentHash(JSON.stringify(payload));
@@ -1044,6 +1157,11 @@ function formatFromArgs(args) {
 const args = process.argv.slice(2);
 const command = args[0];
 const commandArgs = args.slice(1);
+if (command === 'create-dotnet') {
+  process.argv.splice(2, 1);
+  await import('./create-dotnet.mjs');
+  process.exit(0);
+}
 let invalidArgument = false;
 for (let index = 0; index < commandArgs.length; index += 1) {
   const arg = commandArgs[index];
@@ -1052,13 +1170,22 @@ for (let index = 0; index < commandArgs.length; index += 1) {
   if (arg === '--apply') { if (!['authorities', 'reconcile', 'upgrade'].includes(command)) invalidArgument = true; continue; }
   if (arg === '--name') { if (!commandArgs[index + 1]) invalidArgument = true; else index += 1; continue; }
   if (arg.startsWith('--name=') && arg.length > '--name='.length) continue;
+  if (arg === '--profile') {
+    if (command !== 'init' || !commandArgs[index + 1]) invalidArgument = true;
+    else index += 1;
+    continue;
+  }
+  if (arg.startsWith('--profile=') && arg.length > '--profile='.length) {
+    if (command !== 'init') invalidArgument = true;
+    continue;
+  }
   if (arg === '--format') {
-    if (!['verify', 'upgrade', 'capabilities'].includes(command) || !['text', 'json'].includes(commandArgs[index + 1])) invalidArgument = true;
+    if (!['profiles', 'verify', 'upgrade', 'capabilities'].includes(command) || !['text', 'json'].includes(commandArgs[index + 1])) invalidArgument = true;
     else index += 1;
     continue;
   }
   if (arg.startsWith('--format=') && ['text', 'json'].includes(arg.slice('--format='.length))) {
-    if (!['verify', 'upgrade', 'capabilities'].includes(command)) invalidArgument = true;
+    if (!['profiles', 'verify', 'upgrade', 'capabilities'].includes(command)) invalidArgument = true;
     continue;
   }
   if (arg === '--scope') {
@@ -1078,7 +1205,7 @@ for (let index = 0; index < commandArgs.length; index += 1) {
   if (['--id=', '--provider=', '--repo=', '--input=', '--plan-file=', '--authorize='].some((prefix) => arg.startsWith(prefix) && arg.length > prefix.length)) continue;
   invalidArgument = true;
 }
-if (!['init', 'authorities', 'reconcile', 'upgrade', 'capabilities', 'verify'].includes(command) || invalidArgument) {
+if (!['init', 'profiles', 'authorities', 'reconcile', 'upgrade', 'capabilities', 'verify'].includes(command) || invalidArgument) {
   console.error(usage);
   process.exit(2);
 }
@@ -1088,6 +1215,11 @@ try {
   else if (command === 'reconcile') await reconcile(args.slice(1));
   else if (command === 'upgrade') await upgrade(args.slice(1));
   else if (command === 'capabilities') await capabilities(args.slice(1));
+  else if (command === 'profiles') {
+    const manifest = await readManifest();
+    if (!manifest) throw new Error('Cannot read lighthouse.json: file does not exist; run lighthouse init --name <product>.');
+    await profiles(manifest, formatFromArgs(commandArgs));
+  }
   else {
     const manifest = await readManifest();
     if (!manifest) throw new Error('Cannot read lighthouse.json: file does not exist; run lighthouse init --name <product>.');

package/src/profiles.mjs

@@ -0,0 +1,133 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const catalogPath = fileURLToPath(new URL('../assets/profiles/catalog.json', import.meta.url));
+const allowedShapes = new Set(['unknown', 'frontend', 'backend', 'full-stack', 'service', 'library', 'tooling', 'cli', 'worker', 'mobile']);
+const allowedLevels = new Set(['required', 'recommended', 'optional']);
+const allowedKinds = new Set(['hard', 'soft']);
+const allowedVerification = new Set(['deterministic', 'semantic', 'human']);
+const allowedLayers = new Set(['static', 'unit', 'architecture', 'integration', 'functional', 'browser-e2e', 'operational']);
+
+function profileProblems(profile) {
+  const problems = [];
+  if (!profile || typeof profile !== 'object' || Array.isArray(profile)) return ['profile must be an object'];
+  for (const key of ['id', 'owner', 'purpose', 'appliesTo', 'surfaces', 'verification']) if (!(key in profile)) problems.push(`missing ${key}`);
+  if (typeof profile.id !== 'string' || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(profile.id)) problems.push('id must use kebab-case');
+  if (typeof profile.owner !== 'string' || !profile.owner) problems.push('owner must be a non-empty string');
+  if (typeof profile.purpose !== 'string' || !profile.purpose) problems.push('purpose must be a non-empty string');
+  const applicability = profile.appliesTo;
+  if (!applicability || typeof applicability !== 'object' || Array.isArray(applicability)
+      || !Array.isArray(applicability.shapes) || !Array.isArray(applicability.stacks)
+      || applicability.shapes.length === 0 || applicability.shapes.some((shape) => typeof shape !== 'string' || !allowedShapes.has(shape))) {
+    problems.push('appliesTo must declare supported application shapes');
+  }
+  if (Array.isArray(applicability?.shapes) && new Set(applicability.shapes).size !== applicability.shapes.length) problems.push('appliesTo.shapes must be unique');
+  if (Array.isArray(applicability?.stacks) && (applicability.stacks.some((stack) => typeof stack !== 'string') || new Set(applicability.stacks).size !== applicability.stacks.length)) problems.push('appliesTo.stacks must contain unique strings');
+  if (!Array.isArray(profile.surfaces) || profile.surfaces.length === 0 || profile.surfaces.some((surface) => typeof surface !== 'string' || !surface)) problems.push('surfaces must contain non-empty strings');
+  const layers = profile.verification?.layers;
+  if (!Array.isArray(layers) || layers.length === 0) problems.push('verification.layers must contain at least one layer');
+  const ids = new Set();
+  for (const layer of layers ?? []) {
+    if (!layer || typeof layer !== 'object' || Array.isArray(layer)) { problems.push('verification layer must be an object'); continue; }
+    for (const key of ['id', 'level', 'kind', 'verification']) if (!(key in layer)) problems.push(`verification layer missing ${key}`);
+    if (!allowedLayers.has(layer.id)) problems.push(`unsupported verification layer ${layer.id}`);
+    if (!allowedLevels.has(layer.level)) problems.push(`verification layer ${layer.id} has an invalid level`);
+    if (!allowedKinds.has(layer.kind)) problems.push(`verification layer ${layer.id} has an invalid kind`);
+    if (!allowedVerification.has(layer.verification)) problems.push(`verification layer ${layer.id} has an invalid verification method`);
+    if (layer.command !== undefined && layer.command !== null && (typeof layer.command !== 'string' || !layer.command)) problems.push(`verification layer ${layer.id} command must be a string or null`);
+    if (ids.has(layer.id)) problems.push(`duplicate verification layer ${layer.id}`);
+    ids.add(layer.id);
+  }
+  return problems;
+}
+
+function catalogProblems(catalog) {
+  if (!catalog || typeof catalog !== 'object' || Array.isArray(catalog)) return ['catalog must be an object'];
+  const problems = [];
+  if (catalog.schemaVersion !== 1) problems.push('schemaVersion must be 1');
+  if (!Array.isArray(catalog.profiles)) problems.push('profiles must be an array');
+  const ids = new Set();
+  for (const profile of catalog.profiles ?? []) {
+    problems.push(...profileProblems(profile).map((problem) => `${profile?.id ?? '<unknown>'}: ${problem}`));
+    if (profile?.id && ids.has(profile.id)) problems.push(`${profile.id}: duplicate id`);
+    if (profile?.id) ids.add(profile.id);
+  }
+  return problems;
+}
+
+export function readProfileCatalog() {
+  const catalog = JSON.parse(readFileSync(catalogPath, 'utf8'));
+  const problems = catalogProblems(catalog);
+  if (problems.length) throw new Error(`Invalid profile catalog:\n${problems.join('\n')}`);
+  return catalog;
+}
+
+export function normalizeApplication(application) {
+  if (!application || typeof application !== 'object' || Array.isArray(application)) return { shape: 'unknown', stacks: [] };
+  return {
+    shape: typeof application.shape === 'string' ? application.shape : 'unknown',
+    stacks: Array.isArray(application.stacks) ? [...application.stacks] : [],
+  };
+}
+
+function profileStatus(profile, application) {
+  const shapeKnown = application.shape !== 'unknown';
+  const stacksKnown = application.stacks.length > 0;
+  const shapeMatches = !shapeKnown || profile.appliesTo.shapes.includes('any') || profile.appliesTo.shapes.includes(application.shape);
+  const stackMatches = !stacksKnown || profile.appliesTo.stacks.length === 0 || profile.appliesTo.stacks.includes('any') || application.stacks.some((stack) => profile.appliesTo.stacks.includes(stack));
+  if (!shapeMatches || !stackMatches) return 'failed';
+  if ((!shapeKnown && profile.appliesTo.shapes.length > 0) || (profile.appliesTo.stacks.length > 0 && !stacksKnown)) return 'unconfigured';
+  return 'passed';
+}
+
+export function composeProfiles(catalog, manifest) {
+  const application = normalizeApplication(manifest?.application);
+  const selected = (manifest?.profiles ?? []).map((id) => {
+    const profile = catalog.profiles.find((item) => item.id === id);
+    const status = profile ? profileStatus(profile, application) : 'failed';
+    const problems = profile
+      ? status === 'failed'
+        ? [`${id} does not apply to application shape '${application.shape}' and stacks '${application.stacks.join(', ') || 'none'}'.`]
+        : status === 'unconfigured'
+          ? [`${id} needs application.shape and${profile.appliesTo.stacks.length ? ' application.stacks' : ''} in lighthouse.json.`]
+          : []
+      : [`${id} is not declared by the installed profile catalog.`];
+    return {
+      id,
+      owner: profile?.owner ?? '@juangcarmona/lighthouse',
+      purpose: profile?.purpose ?? null,
+      status,
+      appliesTo: profile?.appliesTo ?? null,
+      surfaces: profile?.surfaces ?? [],
+      verification: profile?.verification ?? { layers: [] },
+      problems,
+      nextAction: problems.length
+        ? status === 'unconfigured'
+          ? 'Declare application.shape and application.stacks, then run lighthouse profiles --format json.'
+          : 'Choose a compatible profile or correct application.shape and application.stacks.'
+        : null,
+    };
+  });
+  const status = selected.length === 0
+    ? 'not-applicable'
+    : selected.some((profile) => profile.status === 'failed')
+      ? 'failed'
+      : selected.some((profile) => profile.status === 'unconfigured')
+        ? 'unconfigured'
+        : 'passed';
+  return { schemaVersion: 1, application, selected, available: catalog.profiles.map(({ id, owner, purpose, appliesTo, surfaces, verification }) => ({ id, owner, purpose, appliesTo, surfaces, verification })), status };
+}
+
+export function profileCompositionResult(composition) {
+  return {
+    id: 'foundation.profile-composition',
+    owner: '@juangcarmona/lighthouse',
+    level: 'recommended',
+    kind: 'hard',
+    verification: 'deterministic',
+    status: composition.status,
+    evidence: composition.selected.map((profile) => ({ id: profile.id, status: profile.status, layers: profile.verification.layers.map((layer) => layer.id) })),
+    problems: composition.selected.flatMap((profile) => profile.problems),
+    nextAction: composition.selected.find((profile) => profile.nextAction)?.nextAction ?? null,
+  };
+}

package/src/verify-dotnet.mjs

@@ -0,0 +1,85 @@
+import { spawnSync } from 'node:child_process';
+import { readdir, readFile, mkdir, mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+const root = process.cwd();
+const nestedSolution = resolve(root, 'src/dotnet/Lighthouse.slnx');
+const rootSolutions = (await readdir(root)).filter((name) => name.endsWith('.slnx'));
+const solutionPath = await readFile(nestedSolution).then(() => nestedSolution).catch(() => {
+  if (rootSolutions.length !== 1) throw new Error('Expected src/dotnet/Lighthouse.slnx or one generated root solution.');
+  return resolve(root, rootSolutions[0]);
+});
+const dotnetRoot = dirname(solutionPath);
+const lighthouseSourceRoot = solutionPath === nestedSolution ? dotnetRoot : resolve(root, 'src/dotnet');
+const solutionName = solutionPath.slice(dotnetRoot.length + 1);
+function run(args, options = {}) {
+  const result = spawnSync('dotnet', args, { cwd: dotnetRoot, encoding: 'utf8', ...options });
+  if (result.error) throw result.error;
+  return result;
+}
+for (const args of [
+  ['restore', solutionName, '--locked-mode'],
+  ['build', solutionName, '--no-restore', '-c', 'Release'],
+  ['test', solutionName, '--no-build', '--no-restore', '-c', 'Release']
+]) {
+  const result = run(args, { stdio: 'inherit' });
+  if (result.status !== 0) process.exit(result.status ?? 1);
+}
+
+const sourceFiles = [];
+async function collectSource(folder) {
+  for (const entry of await readdir(resolve(dotnetRoot, folder), { withFileTypes: true })) {
+    if (['bin', 'obj', 'node_modules'].includes(entry.name)) continue;
+    const path = folder === '.' ? entry.name : `${folder}/${entry.name}`;
+    if (entry.isDirectory()) await collectSource(path);
+    else if (entry.isFile() && entry.name.endsWith('.cs')) sourceFiles.push(path);
+  }
+}
+await collectSource('.');
+const formatted = run(['format', 'whitespace', '.', '--folder', '--verify-no-changes',
+  '--include', ...sourceFiles, '--verbosity', 'quiet'], { stdio: 'inherit' });
+if (formatted.status !== 0) process.exit(formatted.status ?? 1);
+
+const solution = await readFile(solutionPath, 'utf8');
+for (const match of solution.matchAll(/<Project Path="([^"]+\.csproj)"/g)) {
+  const result = run(['msbuild', resolve(dotnetRoot, match[1]), '-getProperty:AssemblyName,LighthouseModule', '-getItem:ProjectReference']);
+  if (result.status !== 0) throw new Error(`Cannot evaluate project policy: ${match[1]}`);
+  const evaluated = JSON.parse(result.stdout);
+  const assembly = evaluated.Properties.AssemblyName;
+  if (!assembly.includes('.Modules.') || assembly.endsWith('.Contracts') || assembly.endsWith('Tests')) continue;
+  const active = evaluated.Properties.LighthouseModule === 'true';
+  const attached = evaluated.Items.ProjectReference.some((item) => item.Identity.endsWith('Lighthouse.Analyzers.csproj')
+    && item.OutputItemType === 'Analyzer' && item.ReferenceOutputAssembly === 'false');
+  if (!active || !attached) throw new Error(`Module ${assembly} must activate and reference the Lighthouse analyzer.`);
+}
+process.stdout.write('Every implementation module in the solution activates the analyzer.\n');
+
+const probe = await mkdtemp(join(tmpdir(), 'lighthouse-rejection-'));
+const xml = (value) => value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;');
+try {
+  await mkdir(resolve(probe, 'Sibling'));
+  await mkdir(resolve(probe, 'Invalid'));
+  await writeFile(resolve(probe, 'Sibling/Sibling.csproj'), '<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><TargetFramework>net10.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><AssemblyName>JuanGCarmona.Probe.Modules.Sibling</AssemblyName></PropertyGroup></Project>');
+  await writeFile(resolve(probe, 'Sibling/Sibling.cs'), 'namespace JuanGCarmona.Probe.Modules.Sibling; public sealed class SiblingExport {}');
+  await writeFile(resolve(probe, 'Invalid/Invalid.csproj'), `<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup><TargetFramework>net10.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><AssemblyName>JuanGCarmona.Probe.Modules.Invalid</AssemblyName><LighthouseModule>true</LighthouseModule></PropertyGroup>
+    <ItemGroup>
+      <CompilerVisibleProperty Include="LighthouseModule" />
+      <ProjectReference Include="../Sibling/Sibling.csproj" />
+      <ProjectReference Include="${xml(resolve(lighthouseSourceRoot, 'Lighthouse.Cqrs/Lighthouse.Cqrs.csproj'))}" />
+      <ProjectReference Include="${xml(resolve(lighthouseSourceRoot, 'Lighthouse.Analyzers/Lighthouse.Analyzers.csproj'))}" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+    </ItemGroup></Project>`);
+  await writeFile(resolve(probe, 'Invalid/Invalid.cs'), `using JuanGCarmona.Lighthouse.Cqrs;
+    namespace JuanGCarmona.Probe.Modules.Invalid;
+    public class ExposedHandler : ICommandHandler<string, string> {
+      public Task<string> Handle(string request, CancellationToken token) => Task.FromResult(request);
+    }`);
+  const result = run(['build', resolve(probe, 'Invalid/Invalid.csproj'), '-c', 'Release']);
+  const output = result.stdout + result.stderr;
+  if (result.status === 0 || !/error LH1001\b/.test(output) || !/error LH1002\b/.test(output)) {
+    process.stderr.write(output);
+    throw new Error('The real build must reject both the exposed handler and sibling implementation reference.');
+  }
+  process.stdout.write('Build rejection rehearsal passed: LH1001 and LH1002 blocked the invalid module.\n');
+} finally { await rm(probe, { recursive: true, force: true }); }