@fragments-sdk/cli 0.15.0 → 0.15.2

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

@@ -0,0 +1,258 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('govern init', () => {
+  let tmpDir: string;
+  let originalCwd: string;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'fragments-govern-test-'));
+    originalCwd = process.cwd();
+  });
+
+  afterAll(async () => {
+    process.chdir(originalCwd);
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it(
+    'generates a fragments.config.ts with default output path',
+    { timeout: 15_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'default-init');
+      await mkdir(projectDir, { recursive: true });
+      process.chdir(projectDir);
+
+      const { governInit } = await import('../govern.js');
+      await governInit();
+
+      const configPath = join(projectDir, 'fragments.config.ts');
+      expect(existsSync(configPath)).toBe(true);
+
+      const content = await readFile(configPath, 'utf-8');
+      expect(content).toContain('rules');
+    },
+  );
+
+  it(
+    'generates config at custom output path',
+    { timeout: 15_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'custom-output');
+      await mkdir(projectDir, { recursive: true });
+      process.chdir(projectDir);
+
+      const customPath = join(projectDir, 'my-config.ts');
+      const { governInit } = await import('../govern.js');
+      await governInit({ output: customPath });
+
+      expect(existsSync(customPath)).toBe(true);
+      const content = await readFile(customPath, 'utf-8');
+      expect(content).toContain('rules');
+    },
+  );
+
+  it(
+    'auto-detects Tailwind config and includes it in token sources',
+    { timeout: 15_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'tailwind-detect');
+      await mkdir(projectDir, { recursive: true });
+      process.chdir(projectDir);
+
+      // Create a tailwind config file
+      await writeFile(
+        join(projectDir, 'tailwind.config.ts'),
+        'export default { content: ["./src/**/*.tsx"] };',
+      );
+
+      const { governInit } = await import('../govern.js');
+      await governInit();
+
+      const configPath = join(projectDir, 'fragments.config.ts');
+      const content = await readFile(configPath, 'utf-8');
+      expect(content).toContain('tailwind.config.ts');
+    },
+  );
+
+  it(
+    'auto-detects SCSS token files',
+    { timeout: 15_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'scss-detect');
+      await mkdir(join(projectDir, 'src', 'styles'), { recursive: true });
+      process.chdir(projectDir);
+
+      await writeFile(
+        join(projectDir, 'src', 'styles', 'tokens.scss'),
+        '$color-primary: #2563EB;',
+      );
+
+      const { governInit } = await import('../govern.js');
+      await governInit();
+
+      const configPath = join(projectDir, 'fragments.config.ts');
+      const content = await readFile(configPath, 'utf-8');
+      expect(content).toContain('src/styles/tokens.scss');
+    },
+  );
+
+  it(
+    'handles empty project gracefully (no token sources)',
+    { timeout: 15_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'empty-project');
+      await mkdir(projectDir, { recursive: true });
+      process.chdir(projectDir);
+
+      const { governInit } = await import('../govern.js');
+      await governInit();
+
+      const configPath = join(projectDir, 'fragments.config.ts');
+      expect(existsSync(configPath)).toBe(true);
+    },
+  );
+});
+
+describe('govern check', () => {
+  let tmpDir: string;
+  let originalCwd: string;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'fragments-govern-check-'));
+    originalCwd = process.cwd();
+  });
+
+  afterAll(async () => {
+    process.chdir(originalCwd);
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it(
+    'returns exitCode 0 for a passing spec',
+    { timeout: 15_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'check-pass');
+      await mkdir(projectDir, { recursive: true });
+      process.chdir(projectDir);
+
+      // Write a minimal UISpec that should pass basic checks
+      const spec = {
+        nodes: [
+          {
+            id: 'root',
+            type: 'div',
+            props: {},
+            children: ['btn'],
+          },
+          {
+            id: 'btn',
+            type: 'Button',
+            props: { variant: 'primary' },
+          },
+        ],
+        root: 'root',
+      };
+      await writeFile(
+        join(projectDir, 'spec.json'),
+        JSON.stringify(spec, null, 2),
+      );
+
+      const { governCheck } = await import('../govern.js');
+      const result = await governCheck({
+        input: join(projectDir, 'spec.json'),
+        quiet: true,
+      });
+
+      // With no config (empty rules), should pass
+      expect(typeof result.exitCode).toBe('number');
+      expect(result.exitCode === 0 || result.exitCode === 1).toBe(true);
+    },
+  );
+
+  it(
+    'returns a valid result structure',
+    { timeout: 15_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'check-structure');
+      await mkdir(projectDir, { recursive: true });
+      process.chdir(projectDir);
+
+      const spec = {
+        nodes: [{ id: 'root', type: 'div' }],
+        root: 'root',
+      };
+      await writeFile(
+        join(projectDir, 'spec.json'),
+        JSON.stringify(spec, null, 2),
+      );
+
+      const { governCheck } = await import('../govern.js');
+      const result = await governCheck({
+        input: join(projectDir, 'spec.json'),
+        quiet: true,
+      });
+
+      expect(result).toHaveProperty('exitCode');
+    },
+  );
+});
+
+describe('govern report', () => {
+  let tmpDir: string;
+  let originalCwd: string;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'fragments-govern-report-'));
+    originalCwd = process.cwd();
+  });
+
+  afterAll(async () => {
+    process.chdir(originalCwd);
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it(
+    'handles missing audit log gracefully',
+    { timeout: 10_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'no-log');
+      await mkdir(projectDir, { recursive: true });
+      process.chdir(projectDir);
+
+      const { governReport } = await import('../govern.js');
+      // Should not throw
+      await governReport();
+    },
+  );
+
+  it(
+    'parses and summarizes audit log',
+    { timeout: 10_000 },
+    async () => {
+      const projectDir = join(tmpDir, 'with-log');
+      await mkdir(projectDir, { recursive: true });
+      process.chdir(projectDir);
+
+      const entries = [
+        { score: 90, passed: true, violationCount: 1 },
+        { score: 70, passed: false, violationCount: 5 },
+        { score: 100, passed: true, violationCount: 0 },
+      ];
+      const logContent = entries
+        .map((e) => JSON.stringify(e))
+        .join('\n');
+      await writeFile(join(projectDir, '.govern-audit.jsonl'), logContent);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const { governReport } = await import('../govern.js');
+      await governReport();
+      consoleSpy.mockRestore();
+
+      // Verify it ran without error — the console output is tested implicitly
+    },
+  );
+});

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

@@ -13,7 +13,15 @@ describe("init", () => {
   });
 
   afterAll(async () => {
-    await rm(tmpDir, { recursive: true, force: true });
+    // Retry cleanup — CI runners can race with async handles
+    for (let i = 0; i < 3; i++) {
+      try {
+        await rm(tmpDir, { recursive: true, force: true });
+        break;
+      } catch {
+        await new Promise((r) => setTimeout(r, 200));
+      }
+    }
   });
 
   it("skips Fragments UI runtime injection for shadcn-style projects", async () => {

package/src/commands/__tests__/scan-generate.test.ts

@@ -15,7 +15,7 @@ import {
   buildEnrichedUsageBlock,
   type EnrichmentResult,
 } from "../scan-generate.js";
-import type { ComponentMeta } from "../../core/component-extractor.js";
+import type { ComponentMeta } from '@fragments-sdk/extract';
 
 // ---------------------------------------------------------------------------
 // Helper to build a minimal ComponentMeta for tests

package/src/commands/build.ts

@@ -5,7 +5,7 @@
 import pc from 'picocolors';
 import { BRAND } from '../core/index.js';
 import { loadConfig } from '../core/node.js';
-import { buildFragments, buildFragmentsDir } from '../build.js';
+import { buildFragments, buildFragmentsDir, getFragmentsJsonStatus } from '@fragments-sdk/compiler';
 import { scan } from './scan.js';
 
 /**
@@ -22,6 +22,10 @@ export interface BuildOptions {
   registryOnly?: boolean;
   /** Build from source code (zero-config, no fragment files needed) */
   fromSource?: boolean;
+  /** Skip work when fragments.json is already fresh */
+  ifNeeded?: boolean;
+  /** Check freshness and exit non-zero if fragments.json needs regeneration */
+  check?: boolean;
   /** Skip usage analysis when building from source */
   skipUsage?: boolean;
   /** Skip Storybook parsing when building from source */
@@ -88,6 +92,55 @@ export async function build(options: BuildOptions = {}): Promise<BuildResult> {
 
   // Build fragments.json unless --registry-only
   if (!options.registryOnly) {
+    const status = await getFragmentsJsonStatus(config, configDir, {
+      output: config.outFile,
+      configPath: options.config,
+    });
+
+    if (options.check) {
+      if (status.missing || status.stale) {
+        const message = status.missing
+          ? `${BRAND.outFile} is missing`
+          : `${BRAND.outFile} is stale${status.reason ? ` (${status.reason})` : ''}`;
+        console.log(pc.red(`✗ ${message}\n`));
+        errors.push({
+          file: status.outputPath,
+          error: message,
+        });
+        return {
+          success: false,
+          outputPath: status.outputPath,
+          errors,
+        };
+      }
+
+      console.log(pc.green(`✓ ${BRAND.outFile} is up to date`));
+      console.log(pc.dim(`  Output: ${status.outputPath}\n`));
+
+      if (!options.registry) {
+        return {
+          success: true,
+          fragmentCount: Object.keys(status.data?.fragments ?? {}).length,
+          outputPath: status.outputPath,
+          errors,
+        };
+      }
+    }
+
+    if (options.ifNeeded && !status.missing && !status.stale) {
+      console.log(pc.green(`✓ ${BRAND.outFile} is up to date`));
+      console.log(pc.dim(`  Output: ${status.outputPath}\n`));
+
+      if (!options.registry) {
+        return {
+          success: true,
+          fragmentCount: Object.keys(status.data?.fragments ?? {}).length,
+          outputPath: status.outputPath,
+          errors,
+        };
+      }
+    }
+
     console.log(pc.dim('Compiling fragments...\n'));
 
     const result = await buildFragments(config, configDir);

package/src/commands/context.ts

@@ -8,7 +8,7 @@ import pc from 'picocolors';
 import { generateContext } from '../core/index.js';
 import type { CompiledFragment, CompiledFragmentsFile } from '../core/index.js';
 import { loadConfig } from '../core/node.js';
-import { buildFragments } from '../build.js';
+import { buildFragments } from '@fragments-sdk/compiler';
 
 /**
  * Options for context command