@mettlecast/domain-cli 0.2.67 → 0.2.68

package/dist/commands/doctor.js

@@ -726,6 +726,12 @@ async function checkAllHttpClientsUseKy(projectRoot) {
             { dir: join(projectRoot, 'domains'), label: 'domains' },
             { dir: join(projectRoot, 'packages', 'domain-cli', 'src', 'commands'), label: 'CLI commands' },
         ];
+        // Files to skip — these contain raw fetch() in comments, docs, or template
+        // literals that generate output code, not actual HTTP calls.
+        const skipFiles = new Set([
+            'generate-sdk.ts', // template literal generating SDK client code
+            'doctor.ts', // JSDoc block comments and fix-message strings self-flag
+        ]);
         const violations = [];
         let totalFiles = 0;
         for (const { dir, label } of scanDirs) {
@@ -734,6 +740,9 @@ async function checkAllHttpClientsUseKy(projectRoot) {
             const files = findFiles(dir, /\.ts$/);
             totalFiles += files.length;
             for (const file of files) {
+                const baseName = file.split(/[/\\]/).pop() ?? '';
+                if (skipFiles.has(baseName))
+                    continue;
                 const content = await readFile(file, 'utf8');
                 const lines = content.split('\n');
                 for (let i = 0; i < lines.length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mettlecast/domain-cli",
-  "version": "0.2.67",
+  "version": "0.2.68",
   "type": "module",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/__tests__/doctor.test.ts

@@ -694,4 +694,173 @@ describe('runDoctor', () => {
       expect(check?.status).toBe('PASS');
     });
   });
+
+  describe('checkConventionEvidence (W1)', () => {
+    async function buildConventionProject(): Promise<string> {
+      const dir = tempDir;
+      await mkdir(join(dir, 'domains', 'test-domain'), { recursive: true });
+      await mkdir(join(dir, '.mc'), { recursive: true });
+      await mkdir(join(dir, '.husky'), { recursive: true });
+      await writeFile(
+        join(dir, '.mc', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: ['test-domain'] })
+      );
+      await writeFile(join(dir, '.husky', 'pre-commit'), '#!/bin/sh');
+      return dir;
+    }
+
+    it('PASS when K-node IDs are present in domain CLAUDE.md', async () => {
+      await buildConventionProject();
+      await writeFile(
+        join(tempDir, 'domains', 'test-domain', 'CLAUDE.md'),
+        [
+          '# Test Domain',
+          '',
+          'Conventions:',
+          '- `K:exit-gate:domain-complete` — exit gate',
+          '- `K:convention:tenancy-trio` — tenancy trio',
+          '- `K:convention:no-cross-domain-import` — no cross-domain imports',
+          '- `K:convention:rls-per-domain-role` — RLS test',
+          '- `K:convention:tier-1-foundations` — tier-1 foundations',
+          '- `K:convention:flow-vs-subscriber-rule` — flow vs subscriber',
+          '',
+        ].join('\n')
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Conventions have evidence');
+      expect(check).toBeDefined();
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('WARN when 1-2 K-node IDs are missing from domain files', async () => {
+      await buildConventionProject();
+      // Only add some K-node IDs
+      await writeFile(
+        join(tempDir, 'domains', 'test-domain', 'CLAUDE.md'),
+        [
+          '# Test Domain',
+          '`K:exit-gate:domain-complete`',
+          '`K:convention:tenancy-trio`',
+          '`K:convention:no-cross-domain-import`',
+          '`K:convention:rls-per-domain-role`',
+          // Missing: tier-1-foundations, flow-vs-subscriber-rule
+        ].join('\n')
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Conventions have evidence');
+      expect(check).toBeDefined();
+      expect(check?.status).toBe('WARN');
+      expect(check?.message).toMatch(/tier-1-foundations/);
+    });
+
+    it('FAIL when more than 2 K-node IDs are missing', async () => {
+      await buildConventionProject();
+      await writeFile(
+        join(tempDir, 'domains', 'test-domain', 'CLAUDE.md'),
+        '# Test Domain\nNo convention references here.\n'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Conventions have evidence');
+      expect(check).toBeDefined();
+      expect(check?.status).toBe('FAIL');
+      expect(check?.message).toMatch(/6\/6 convention/);
+    });
+
+    it('PASS when K-node IDs are found in root CLAUDE.md', async () => {
+      await buildConventionProject();
+      await writeFile(
+        join(tempDir, 'CLAUDE.md'),
+        [
+          '# Project',
+          '`K:exit-gate:domain-complete`',
+          '`K:convention:tenancy-trio`',
+          '`K:convention:no-cross-domain-import`',
+          '`K:convention:rls-per-domain-role`',
+          '`K:convention:tier-1-foundations`',
+          '`K:convention:flow-vs-subscriber-rule`',
+        ].join('\n')
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Conventions have evidence');
+      expect(check).toBeDefined();
+      expect(check?.status).toBe('PASS');
+    });
+  });
+
+  describe('checkAllHttpClientsUseKy skipfiles', () => {
+    async function buildBaseForCliCheck(): Promise<string> {
+      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, '.mc', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: [] })
+      );
+      await writeFile(join(tempDir, '.husky', 'pre-commit'), '#!/bin/sh');
+      return tempDir;
+    }
+
+    it('does not flag fetch() inside generate-sdk.ts template literal', async () => {
+      await buildBaseForCliCheck();
+      const cliDir = join(tempDir, 'packages', 'domain-cli', 'src', 'commands');
+      await mkdir(cliDir, { recursive: true });
+      await writeFile(
+        join(cliDir, 'generate-sdk.ts'),
+        `export function genTemplate() {
+  return \`
+    const res = await fetch('/api/endpoint', { method: 'GET' });
+    if (!res.ok) throw new Error();
+    return res.json();
+  \`;
+}`
+      );
+
+      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('does not flag fetch() in doctor.ts JSDoc comments and message strings', async () => {
+      await buildBaseForCliCheck();
+      const cliDir = join(tempDir, 'packages', 'domain-cli', 'src', 'commands');
+      await mkdir(cliDir, { recursive: true });
+      await writeFile(
+        join(cliDir, 'doctor.ts'),
+        [
+          '/**',
+          ' * Check W5-1: All HTTP clients use ky (no raw fetch()).',
+          ' * Detects raw `fetch(` calls and FAILs.',
+          ' * Allows `ctx.fetch(` and `ky.fetch(`.',
+          ' */',
+          'export function check() {',
+          '  return { message: "No raw fetch() calls found" };',
+          '}',
+          '',
+        ].join('\n')
+      );
+
+      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('still flags raw fetch() in non-skipped CLI files', async () => {
+      await buildBaseForCliCheck();
+      const cliDir = join(tempDir, 'packages', 'domain-cli', 'src', 'commands');
+      await mkdir(cliDir, { recursive: true });
+      await writeFile(
+        join(cliDir, 'some-command.ts'),
+        'export const cmd = () => 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(/some-command\.ts/);
+    });
+  });
 });

package/src/commands/doctor.ts

@@ -822,6 +822,13 @@ async function checkAllHttpClientsUseKy(projectRoot: string): Promise<DoctorChec
       { dir: join(projectRoot, 'packages', 'domain-cli', 'src', 'commands'), label: 'CLI commands' },
     ];
 
+    // Files to skip — these contain raw fetch() in comments, docs, or template
+    // literals that generate output code, not actual HTTP calls.
+    const skipFiles = new Set([
+      'generate-sdk.ts',   // template literal generating SDK client code
+      'doctor.ts',         // JSDoc block comments and fix-message strings self-flag
+    ]);
+
     const violations: string[] = [];
     let totalFiles = 0;
 
@@ -831,6 +838,8 @@ async function checkAllHttpClientsUseKy(projectRoot: string): Promise<DoctorChec
       totalFiles += files.length;
 
       for (const file of files) {
+        const baseName = file.split(/[/\\]/).pop() ?? '';
+        if (skipFiles.has(baseName)) continue;
         const content = await readFile(file, 'utf8');
         const lines = content.split('\n');
         for (let i = 0; i < lines.length; i++) {