@mettlecast/domain-cli 0.2.61 → 0.2.63

package/src/commands/regenerate-modules-hashes.ts

@@ -0,0 +1,89 @@
+import { readFile, readdir, writeFile, mkdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { createHash } from 'node:crypto';
+import { cliLogger } from '../utils/logger.js';
+
+/**
+ * Options for the regenerate-modules-hashes command.
+ */
+export interface RegenerateModulesHashesOptions {
+  /** Root directory of the project (defaults to cwd). */
+  projectRoot?: string;
+}
+
+/**
+ * Manifest of infra/modules/ files with their SHA256 hashes.
+ */
+export interface ModulesHashesManifest {
+  /** Schema version. */
+  version: '1';
+  /** ISO timestamp when the manifest was generated. */
+  generatedAt: string;
+  /** Map of relative file path to SHA256 hex digest. */
+  files: Record<string, string>;
+}
+
+/**
+ * Walk infra/modules/, compute a SHA256 for every file, and write the result
+ * to .mc/modules-hashes.json. Used to refresh the scaffold drift baseline.
+ * @param opts Options including project root directory.
+ * @returns Absolute path to the written manifest file.
+ */
+export async function runRegenerateModulesHashes(
+  opts: RegenerateModulesHashesOptions = {},
+): Promise<string> {
+  const root = opts.projectRoot ?? process.cwd();
+  const mcDir = join(root, '.mc');
+  const manifestPath = join(mcDir, 'modules-hashes.json');
+  const modulesDir = join(root, 'infra', 'modules');
+
+  // Files/directories to skip when walking infra/modules/
+  const SKIP_NAMES = new Set(['node_modules', 'dist', 'cdk.out', 'package-lock.json', '.npmrc']);
+
+  /** Normalize CRLF → LF so hashes match across platforms (Windows vs Linux). */
+  function normalizeLineEndings(buf: Buffer): Buffer {
+    const str = buf.toString('utf8');
+    if (!str.includes('\r\n')) return buf;
+    return Buffer.from(str.replace(/\r\n/g, '\n'), 'utf8');
+  }
+
+  // Walk infra/modules/ and collect every file path
+  async function walk(dir: string): Promise<string[]> {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    const files: string[] = [];
+    for (const entry of entries) {
+      if (SKIP_NAMES.has(entry.name)) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) files.push(...await walk(full));
+      else if (entry.isFile()) files.push(full);
+    }
+    return files;
+  }
+
+  const onDiskFiles = await walk(modulesDir);
+
+  // Compute SHA256 for each file (line-ending-normalised)
+  const files: Record<string, string> = {};
+  for (const absPath of onDiskFiles) {
+    const relPath = relative(root, absPath).replace(/\\/g, '/');
+    const content = await readFile(absPath);
+    const normalized = normalizeLineEndings(content);
+    files[relPath] = createHash('sha256').update(normalized).digest('hex');
+  }
+
+  const manifest: ModulesHashesManifest = {
+    version: '1',
+    generatedAt: new Date().toISOString(),
+    files,
+  };
+
+  await mkdir(mcDir, { recursive: true });
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+
+  cliLogger.info(
+    { path: manifestPath, fileCount: Object.keys(files).length },
+    'modules-hashes manifest regenerated',
+  );
+
+  return manifestPath;
+}

package/src/commands/update-all.ts

@@ -0,0 +1,79 @@
+import { join } from 'node:path';
+import { cliLogger } from '../utils/logger.js';
+import { readScaffoldConfig } from '../utils/scaffold-config.js';
+import { runBuild } from './build.js';
+import { runBuildCatalog } from './build-catalog.js';
+import { runBuildFlows } from './build-flows.js';
+import { runBuildUi } from './build-ui.js';
+import { runRegenerateModulesHashes } from './regenerate-modules-hashes.js';
+import { runDoctor } from './doctor.js';
+
+/**
+ * Run the full scaffold update pipeline:
+ *   1. Build each domain registry from `.mc/scaffold-config.json`
+ *   2. Build the combined domain catalog
+ *   3. Build flows registry
+ *   4. Build UI manifests
+ *   5. Regenerate module hashes
+ *   6. Run doctor
+ *
+ * Per-domain build failures are logged and skipped so that one bad domain does
+ * not abort the whole pipeline. The remaining steps still run.
+ *
+ * @param opts - Optional projectRoot override. Defaults to cwd.
+ * @returns success derived from doctor pass/fail and a human-readable summary.
+ */
+export async function runUpdateAll(opts?: { projectRoot?: string }): Promise<{ success: boolean; summary: string }> {
+  const projectRoot = opts?.projectRoot ?? process.cwd();
+
+  cliLogger.info({ projectRoot }, 'update-all: starting');
+
+  // 1. Read scaffold-config to discover domains
+  const scaffoldConfig = await readScaffoldConfig(projectRoot);
+  const domainIds = scaffoldConfig.domainIds ?? [];
+
+  cliLogger.info({ domainCount: domainIds.length }, 'update-all: building domain registries');
+
+  // 2. Build each domain. Per-domain failures are logged and skipped.
+  for (const domainId of domainIds) {
+    const domainRoot = join(projectRoot, 'domains', domainId);
+    try {
+      cliLogger.info({ domainId, domainRoot }, 'update-all: building domain');
+      await runBuild({ domainRoot });
+    } catch (err) {
+      cliLogger.error(
+        { domainId, err: err instanceof Error ? err.message : String(err) },
+        'update-all: domain build failed — continuing',
+      );
+    }
+  }
+
+  // 3. Build catalog from .mc
+  const mcDir = join(projectRoot, '.mc');
+  cliLogger.info({ mcDir }, 'update-all: building domain catalog');
+  await runBuildCatalog(mcDir);
+
+  // 4. Build flows
+  cliLogger.info({ projectRoot }, 'update-all: building flows registry');
+  await runBuildFlows({ projectRoot });
+
+  // 5. Build UI manifests
+  cliLogger.info({ projectRoot }, 'update-all: building UI manifests');
+  await runBuildUi({ projectRoot });
+
+  // 6. Regenerate module hashes
+  cliLogger.info({ projectRoot }, 'update-all: regenerating module hashes');
+  await runRegenerateModulesHashes({ projectRoot });
+
+  // 7. Run doctor — final gate
+  cliLogger.info({ projectRoot }, 'update-all: running doctor');
+  const report = await runDoctor({ projectRoot });
+
+  cliLogger.info(
+    { pass: report.pass, exitCode: report.exitCode, checkCount: report.checks.length },
+    'update-all: doctor complete',
+  );
+
+  const summary = `Updated ${domainIds.length} domains; doctor ${report.pass ? 'PASS' : 'FAIL'}`;
+  return { success: report.pass, summary };
+}

package/src/utils/manifest.ts

@@ -1,4 +1,4 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
+import { readFile, writeFile, mkdir, access } from 'fs/promises';
 import path from 'path';
 import { cliLogger } from './logger.js';
 
@@ -179,3 +179,18 @@ export function isScaffoldManaged(manifest: TibManifest, filePath: string): bool
   // Returns true only when the file is in the manifest with policy 'managed'
   return entry != null && entry.policy === 'managed';
 }
+
+export async function pruneManifest(projectRoot: string, manifest: TibManifest): Promise<number> {
+  let pruned = 0;
+  const survivors: ManifestFileEntry[] = [];
+  for (const entry of manifest.files) {
+    try {
+      await access(path.join(projectRoot, entry.path));
+      survivors.push(entry);
+    } catch {
+      pruned++;
+    }
+  }
+  manifest.files = survivors;
+  return pruned;
+}