@mettlecast/domain-cli 0.2.22 → 0.2.23

package/src/__tests__/commands/why.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { runWhy, formatWhyReport, runWhyCli } from '../../commands/why.js';
+import * as s3Fetch from '../../utils/s3-fetch.js';
+
+describe('why command', () => {
+  let tmpDir: string;
+  let fetchVersionsJsonSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'tib-why-'));
+    await mkdir(join(tmpDir, '.mc'), { recursive: true });
+    fetchVersionsJsonSpy = vi.spyOn(s3Fetch, 'fetchVersionsJson');
+  });
+
+  afterEach(async () => {
+    fetchVersionsJsonSpy.mockRestore();
+    try {
+      await rm(tmpDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+  });
+
+  it('returns current + latest versions and reports no upgrade when on latest', async () => {
+    await writeFile(
+      join(tmpDir, '.mc', 'manifest.json'),
+      JSON.stringify({
+        scaffoldVersion: '2.5.0',
+        enabledModules: ['core', 'backend-lambda', 'frontend'],
+      })
+    );
+    fetchVersionsJsonSpy.mockResolvedValue({
+      latest: '2.5.0',
+      versions: ['2.5.0', '2.4.0', '2.3.0'],
+    });
+
+    const report = await runWhy({ projectRoot: tmpDir });
+
+    expect(report.currentVersion).toBe('2.5.0');
+    expect(report.latestVersion).toBe('2.5.0');
+    expect(report.upgradeAvailable).toBe(false);
+    expect(report.versionsBehind).toBe(0);
+    expect(report.enabledModules).toEqual(['core', 'backend-lambda', 'frontend']);
+  });
+
+  it('reports upgrade available when current is behind latest', async () => {
+    await writeFile(
+      join(tmpDir, '.mc', 'manifest.json'),
+      JSON.stringify({
+        scaffoldVersion: '2.3.0',
+        enabledModules: ['core'],
+      })
+    );
+    fetchVersionsJsonSpy.mockResolvedValue({
+      latest: '2.5.0',
+      versions: ['2.5.0', '2.4.0', '2.3.0', '2.2.0'],
+    });
+
+    const report = await runWhy({ projectRoot: tmpDir });
+
+    expect(report.currentVersion).toBe('2.3.0');
+    expect(report.latestVersion).toBe('2.5.0');
+    expect(report.upgradeAvailable).toBe(true);
+    expect(report.versionsBehind).toBe(2);
+  });
+
+  it('handles missing manifest gracefully with currentVersion=unknown', async () => {
+    // No .mc/manifest.json written
+    fetchVersionsJsonSpy.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    const report = await runWhy({ projectRoot: tmpDir });
+
+    expect(report.currentVersion).toBe('unknown');
+    expect(report.latestVersion).toBe('1.0.0');
+    expect(report.upgradeAvailable).toBe(true);
+    expect(report.versionsBehind).toBe(-1);
+    expect(report.enabledModules).toEqual([]);
+  });
+
+  it('passes scaffoldBucket through to the S3 fetch', async () => {
+    await writeFile(
+      join(tmpDir, '.mc', 'manifest.json'),
+      JSON.stringify({ scaffoldVersion: '1.0.0', enabledModules: [] })
+    );
+    fetchVersionsJsonSpy.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    await runWhy({ projectRoot: tmpDir, scaffoldBucket: 'my-bucket' });
+
+    expect(fetchVersionsJsonSpy).toHaveBeenCalledWith('my-bucket');
+  });
+
+  it('uses ky under the hood (S3 fetch is wired through the ky-backed s3-fetch utility)', async () => {
+    await writeFile(
+      join(tmpDir, '.mc', 'manifest.json'),
+      JSON.stringify({ scaffoldVersion: '1.0.0', enabledModules: [] })
+    );
+    fetchVersionsJsonSpy.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    await runWhy({ projectRoot: tmpDir });
+
+    // The spy is on the s3-fetch module function — s3-fetch.ts itself
+    // is now ky-backed, so a single call here proves the ky path is exercised.
+    expect(fetchVersionsJsonSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('formats a human-readable report including enabled modules and pending diff', () => {
+    const report = {
+      currentVersion: '2.3.0',
+      enabledModules: ['core', 'frontend'],
+      latestVersion: '2.5.0',
+      upgradeAvailable: true,
+      versionsBehind: 2,
+      allVersions: ['2.5.0', '2.4.0', '2.3.0', '2.2.0'],
+    };
+
+    const out = formatWhyReport(report);
+
+    expect(out).toContain('Current version : 2.3.0');
+    expect(out).toContain('Latest version  : 2.5.0');
+    expect(out).toContain('Upgrade available: yes (2 release(s) behind)');
+    expect(out).toContain('- core');
+    expect(out).toContain('- frontend');
+    expect(out).toContain('2.5.0');
+    expect(out).toContain('2.4.0');
+  });
+
+  it('prints "(none)" for pending diff when on latest', () => {
+    const report = {
+      currentVersion: '1.0.0',
+      enabledModules: [],
+      latestVersion: '1.0.0',
+      upgradeAvailable: false,
+      versionsBehind: 0,
+      allVersions: ['1.0.0'],
+    };
+
+    const out = formatWhyReport(report);
+
+    expect(out).toContain('Upgrade available: no');
+    expect(out).toContain('(none)');
+  });
+
+  it('runWhyCli prints human-readable report by default', async () => {
+    await writeFile(
+      join(tmpDir, '.mc', 'manifest.json'),
+      JSON.stringify({ scaffoldVersion: '1.0.0', enabledModules: ['core'] })
+    );
+    fetchVersionsJsonSpy.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    const stdoutWriteSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+
+    const report = await runWhyCli({ projectRoot: tmpDir });
+
+    expect(stdoutWriteSpy).toHaveBeenCalled();
+    const written = stdoutWriteSpy.mock.calls.map(call => String(call[0])).join('');
+    expect(written).toContain('Current version : 1.0.0');
+    expect(report.upgradeAvailable).toBe(false);
+
+    stdoutWriteSpy.mockRestore();
+  });
+
+  it('runWhyCli prints JSON when --json is set', async () => {
+    await writeFile(
+      join(tmpDir, '.mc', 'manifest.json'),
+      JSON.stringify({ scaffoldVersion: '1.0.0', enabledModules: [] })
+    );
+    fetchVersionsJsonSpy.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    await runWhyCli({ projectRoot: tmpDir, json: true });
+
+    expect(logSpy).toHaveBeenCalled();
+    const logged = String(logSpy.mock.calls[0]?.[0] ?? '');
+    const parsed = JSON.parse(logged) as { currentVersion: string; latestVersion: string };
+    expect(parsed.currentVersion).toBe('1.0.0');
+    expect(parsed.latestVersion).toBe('1.0.0');
+
+    logSpy.mockRestore();
+  });
+});

package/src/__tests__/doctor.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { runDoctor } from '../commands/doctor.js';
+import { runDoctor, DOCTOR_FIX_FLAG } from '../commands/doctor.js';
 
 describe('runDoctor', () => {
   let tempDir: string;
@@ -293,4 +293,339 @@ describe('runDoctor', () => {
       expect(check?.status).toBe('FAIL');
     });
   });
+
+  describe('--fix flag', () => {
+    it('exports DOCTOR_FIX_FLAG constant for cli-integration to consume', () => {
+      expect(DOCTOR_FIX_FLAG).toBe('--fix');
+    });
+
+    it('moves scaffold-owned files from old layout to .mc/ and updates manifest', async () => {
+      await mkdir(join(tempDir, '.tib'), { recursive: true });
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'infra', 'modules'), { recursive: true });
+      await mkdir(join(tempDir, 'domains'), { recursive: true });
+      await mkdir(join(tempDir, '.husky'), { recursive: true });
+
+      const appContent = '// @mc-scaffold: backend-lambda@1.0.0\nimport * as cdk from "aws-cdk-lib";\n';
+      await writeFile(join(tempDir, 'infra', 'modules', 'app.ts'), appContent);
+      await writeFile(join(tempDir, '.husky', 'pre-commit'), '#!/bin/sh');
+      await writeFile(join(tempDir, '.tib', 'scaffold-config.json'), JSON.stringify({ domainIds: [] }));
+
+      const { computeChecksumString } = await import('../utils/checksum.js');
+      const sha256 = computeChecksumString(appContent);
+
+      const manifest = {
+        $schema: 'https://mc-scaffold.s3.amazonaws.com/schema/manifest.v2.json',
+        scaffoldVersion: '1.0.0',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T00:00:00Z',
+        projectName: 'test',
+        awsRegion: 'eu-north-1',
+        enabledModules: ['backend-lambda'],
+        files: [
+          { path: 'infra/modules/app.ts', module: 'backend-lambda', moduleVersion: '1.0.0',
+            sha256, wasTemplate: true, installedAt: '2026-01-01T00:00:00Z', policy: 'managed' as const }
+        ]
+      };
+      await writeFile(join(tempDir, '.mc', 'manifest.json'), JSON.stringify(manifest));
+
+      const report = await runDoctor({ projectRoot: tempDir, fix: true });
+
+      // File moved from old layout to .mc/
+      const { existsSync } = await import('node:fs');
+      expect(existsSync(join(tempDir, '.mc', 'infra', 'modules', 'app.ts'))).toBe(true);
+      expect(existsSync(join(tempDir, 'infra', 'modules', 'app.ts'))).toBe(false);
+
+      // Manifest updated: old path removed, new path added
+      const manifestOnDisk = JSON.parse(
+        await (await import('node:fs/promises')).readFile(join(tempDir, '.mc', 'manifest.json'), 'utf-8')
+      );
+      const paths = manifestOnDisk.files.map((f: { path: string }) => f.path);
+      expect(paths).toContain('.mc/infra/modules/app.ts');
+      expect(paths).not.toContain('infra/modules/app.ts');
+
+      // Report includes the relocation summary
+      const summary = report.checks.find(c => c.name === 'Relocate: summary');
+      expect(summary).toBeDefined();
+      expect(summary?.message).toMatch(/1 file\(s\) moved/);
+
+      // Per-file move check
+      const moveCheck = report.checks.find(
+        c => c.name === 'Relocate: infra/modules/app.ts'
+      );
+      expect(moveCheck?.status).toBe('PASS');
+
+      // Doctor's full report still ran (superset of --relocate)
+      expect(report.checks.some(c => c.name === 'Domain configs valid')).toBe(true);
+    });
+
+    it('is a no-op on a clean project (exit 0, 0 files moved)', async () => {
+      await mkdir(join(tempDir, '.tib'), { recursive: true });
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'domains'), { recursive: true });
+      await mkdir(join(tempDir, '.husky'), { recursive: true });
+
+      await writeFile(join(tempDir, '.tib', 'scaffold-config.json'), JSON.stringify({ domainIds: [] }));
+      await writeFile(join(tempDir, '.husky', 'pre-commit'), '#!/bin/sh');
+
+      const manifest = {
+        $schema: 'https://mc-scaffold.s3.amazonaws.com/schema/manifest.v2.json',
+        scaffoldVersion: '1.0.0',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T00:00:00Z',
+        projectName: 'test',
+        awsRegion: 'eu-north-1',
+        enabledModules: ['backend-lambda'],
+        files: []
+      };
+      await writeFile(join(tempDir, '.mc', 'manifest.json'), JSON.stringify(manifest));
+
+      const report = await runDoctor({ projectRoot: tempDir, fix: true });
+
+      // No files moved
+      const summary = report.checks.find(c => c.name === 'Relocate: summary');
+      expect(summary).toBeDefined();
+      expect(summary?.message).toMatch(/0 file\(s\) moved/);
+      expect(summary?.status).toBe('PASS');
+
+      // Clean exit (no FAIL anywhere in the report)
+      expect(report.exitCode).toBe(0);
+    });
+  });
+
+  describe('W5 new checks (scaffolder modernize)', () => {
+    /** Build a minimal temp project that passes the W1/W2 baseline checks
+     *  so the new W5 checks can be evaluated in isolation. */
+    async function buildBaseProject(): Promise<void> {
+      await mkdir(join(tempDir, '.tib'), { recursive: true });
+      await mkdir(join(tempDir, 'domains'), { recursive: true });
+      await mkdir(join(tempDir, '.husky'), { recursive: true });
+      await writeFile(
+        join(tempDir, '.tib', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: [] })
+      );
+      await writeFile(join(tempDir, '.husky', 'pre-commit'), '#!/bin/sh');
+    }
+
+    it('all 5 W5 checks are present in the report', async () => {
+      await buildBaseProject();
+
+      const report = await runDoctor({ projectRoot: tempDir });
+
+      const expectedW5 = [
+        'Every API has a fixture', // checkEveryApiHasFixture (reuses checkApiFixtures)
+        'All HTTP clients use ky',
+        'Routes use TanStack Router',
+        'OTel init in Lambdas',
+        'Frontend uses strict TypeScript',
+      ];
+      for (const name of expectedW5) {
+        expect(report.checks.some(c => c.name === name)).toBe(true);
+      }
+    });
+
+    it('checkEveryApiHasFixture reuses checkApiFixtures (alias yields identical result)', async () => {
+      await buildBaseProject();
+      // No APIs → both should PASS with the same message
+      const report = await runDoctor({ projectRoot: tempDir });
+
+      const fixtureCheck = report.checks.find(c => c.name === 'Every API has a fixture');
+      expect(fixtureCheck).toBeDefined();
+      expect(fixtureCheck?.status).toBe('PASS');
+      // No duplicate entry — the wrapper replaces the original, not adds alongside
+      const matches = report.checks.filter(c => c.name === 'Every API has a fixture');
+      expect(matches.length).toBe(1);
+    });
+
+    it('checkAllHttpClientsUseKy: PASS when no raw fetch in domains/', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'domains', 'sample'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'domains', 'sample', 'client.ts'),
+        'import ky from "ky";\nexport const get = () => ky.get("/foo");'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'All HTTP clients use ky');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('checkAllHttpClientsUseKy: PASS when only ctx.fetch is used in domains/', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'domains', 'sample'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'domains', 'sample', 'client.ts'),
+        'export const get = (ctx: any) => ctx.fetch.fetch("https://api.example.com");'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'All HTTP clients use ky');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('checkAllHttpClientsUseKy: FAIL when raw fetch( is used in domains/', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'domains', 'sample'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'domains', 'sample', 'client.ts'),
+        'export const get = () => fetch("https://api.example.com");'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'All HTTP clients use ky');
+      expect(check?.status).toBe('FAIL');
+      expect(check?.message).toMatch(/raw fetch/i);
+      expect(check?.message).toMatch(/client\.ts/);
+    });
+
+    it('checkAllRoutesUseTanStackRouter: PASS when no react-router-dom in frontend/', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'frontend', 'src'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'frontend', 'src', 'router.tsx'),
+        'import { createRouter } from "@tanstack/react-router";'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Routes use TanStack Router');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('checkAllRoutesUseTanStackRouter: FAIL when react-router-dom is imported in frontend/', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'frontend', 'src'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'frontend', 'src', 'App.tsx'),
+        "import { useNavigate } from 'react-router-dom';\nexport const App = () => null;"
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Routes use TanStack Router');
+      expect(check?.status).toBe('FAIL');
+      expect(check?.message).toMatch(/react-router-dom/);
+      expect(check?.message).toMatch(/App\.tsx/);
+    });
+
+    it('checkAllRoutesUseTanStackRouter: PASS when no frontend/ directory exists', async () => {
+      await buildBaseProject();
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Routes use TanStack Router');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('checkOtelInitInLambdas: PASS when every handler file contains initOtel()', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'domains', 'sample', 'api'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'domains', 'sample', 'api', 'get.ts'),
+        'import { initOtel } from "@mettlecast/domain-runtime";\ninitOtel();\nexport const get = async () => ({});'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'OTel init in Lambdas');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('checkOtelInitInLambdas: FAIL when a handler file is missing initOtel()', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'domains', 'sample', 'api'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'domains', 'sample', 'api', 'noOtel.ts'),
+        'export const get = async () => ({});'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'OTel init in Lambdas');
+      expect(check?.status).toBe('FAIL');
+      expect(check?.message).toMatch(/noOtel\.ts/);
+      expect(check?.fixHint).toMatch(/initOtel/);
+    });
+
+    it('checkOtelInitInLambdas: PASS when no domains/ directory exists', async () => {
+      await buildBaseProject();
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'OTel init in Lambdas');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('checkFrontendUsesStrictTypescript: PASS when frontend/tsconfig.json has strict: true', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'frontend'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'frontend', 'tsconfig.json'),
+        JSON.stringify({ compilerOptions: { strict: true, target: 'ES2022' } })
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Frontend uses strict TypeScript');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('checkFrontendUsesStrictTypescript: FAIL when strict is missing', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'frontend'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'frontend', 'tsconfig.json'),
+        JSON.stringify({ compilerOptions: { target: 'ES2022' } })
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Frontend uses strict TypeScript');
+      expect(check?.status).toBe('FAIL');
+    });
+
+    it('checkFrontendUsesStrictTypescript: FAIL when strict is false', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'frontend'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'frontend', 'tsconfig.json'),
+        JSON.stringify({ compilerOptions: { strict: false } })
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Frontend uses strict TypeScript');
+      expect(check?.status).toBe('FAIL');
+    });
+
+    it('checkFrontendUsesStrictTypescript: PASS when no frontend/tsconfig.json', async () => {
+      await buildBaseProject();
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Frontend uses strict TypeScript');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('checkFrontendUsesStrictTypescript: FAIL when tsconfig.json is invalid JSON', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'frontend'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'frontend', 'tsconfig.json'),
+        '{ not valid json }'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Frontend uses strict TypeScript');
+      expect(check?.status).toBe('FAIL');
+      expect(check?.message).toMatch(/not valid JSON/);
+    });
+
+    it('doctor always exits non-zero on any FAIL (--strict is no-op confirmation)', async () => {
+      await buildBaseProject();
+      await mkdir(join(tempDir, 'frontend', 'src'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'frontend', 'src', 'App.tsx'),
+        "import { Link } from 'react-router-dom';\nexport const App = () => null;"
+      );
+
+      // Run with and without --strict — both should exit non-zero (doctor is
+      // always strict, the flag is a self-documenting no-op).
+      const reportStrict = await runDoctor({ projectRoot: tempDir, strict: true });
+      const reportPlain = await runDoctor({ projectRoot: tempDir });
+
+      expect(reportStrict.exitCode).toBe(1);
+      expect(reportPlain.exitCode).toBe(1);
+    });
+  });
 });