sauron-cli 1.1.3 → 1.3.0

package/OpenSpec-main/test/telemetry/index.test.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+// Mock posthog-node before importing the module
+vi.mock('posthog-node', () => {
+  return {
+    PostHog: vi.fn().mockImplementation(() => ({
+      capture: vi.fn(),
+      shutdown: vi.fn().mockResolvedValue(undefined),
+    })),
+  };
+});
+
+// Import after mocking
+import { isTelemetryEnabled, maybeShowTelemetryNotice, shutdown, trackCommand } from '../../src/telemetry/index.js';
+import { PostHog } from 'posthog-node';
+
+describe('telemetry/index', () => {
+  let tempDir: string;
+  let originalEnv: NodeJS.ProcessEnv;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let fetchSpy: ReturnType<typeof vi.spyOn<typeof globalThis, 'fetch'>>;
+
+  beforeEach(() => {
+    // Create unique temp directory for each test using UUID
+    tempDir = path.join(os.tmpdir(), `openspec-telemetry-test-${randomUUID()}`);
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    // Save original env
+    originalEnv = { ...process.env };
+
+    // Mock HOME to point to temp dir
+    process.env.HOME = tempDir;
+
+    // Clear all mocks
+    vi.clearAllMocks();
+
+    // Spy on console.log for notice tests
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    fetchSpy = vi.spyOn(globalThis, 'fetch');
+  });
+
+  afterEach(async () => {
+    // Restore original env
+    process.env = originalEnv;
+
+    // Clean up temp directory
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+
+    await shutdown();
+
+    // Restore all mocks
+    vi.restoreAllMocks();
+  });
+
+  describe('isTelemetryEnabled', () => {
+    it('should return false when OPENSPEC_TELEMETRY=0', () => {
+      process.env.OPENSPEC_TELEMETRY = '0';
+      expect(isTelemetryEnabled()).toBe(false);
+    });
+
+    it('should return false when DO_NOT_TRACK=1', () => {
+      process.env.DO_NOT_TRACK = '1';
+      expect(isTelemetryEnabled()).toBe(false);
+    });
+
+    it('should return false when CI=true', () => {
+      process.env.CI = 'true';
+      expect(isTelemetryEnabled()).toBe(false);
+    });
+
+    it('should return true when no opt-out is set', () => {
+      delete process.env.OPENSPEC_TELEMETRY;
+      delete process.env.DO_NOT_TRACK;
+      delete process.env.CI;
+      expect(isTelemetryEnabled()).toBe(true);
+    });
+
+    it('should prioritize OPENSPEC_TELEMETRY=0 over other settings', () => {
+      process.env.OPENSPEC_TELEMETRY = '0';
+      delete process.env.DO_NOT_TRACK;
+      delete process.env.CI;
+      expect(isTelemetryEnabled()).toBe(false);
+    });
+  });
+
+  describe('maybeShowTelemetryNotice', () => {
+    it('should not show notice when telemetry is disabled', async () => {
+      process.env.OPENSPEC_TELEMETRY = '0';
+
+      await maybeShowTelemetryNotice();
+
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('trackCommand', () => {
+    it('should not track when telemetry is disabled', async () => {
+      process.env.OPENSPEC_TELEMETRY = '0';
+
+      await trackCommand('test', '1.0.0');
+
+      expect(PostHog).not.toHaveBeenCalled();
+    });
+
+    it('should track when telemetry is enabled', async () => {
+      delete process.env.OPENSPEC_TELEMETRY;
+      delete process.env.DO_NOT_TRACK;
+      delete process.env.CI;
+
+      await trackCommand('test', '1.0.0');
+
+      expect(PostHog).toHaveBeenCalled();
+    });
+
+    it('should construct PostHog with bounded silent-failure settings', async () => {
+      delete process.env.OPENSPEC_TELEMETRY;
+      delete process.env.DO_NOT_TRACK;
+      delete process.env.CI;
+
+      await trackCommand('test', '1.0.0');
+
+      expect(PostHog).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          host: 'https://edge.openspec.dev',
+          flushAt: 1,
+          flushInterval: 0,
+          fetchRetryCount: 0,
+          requestTimeout: 1000,
+          preloadFeatureFlags: false,
+          disableRemoteConfig: true,
+          disableSurveys: true,
+          fetch: expect.any(Function),
+        })
+      );
+    });
+
+    it('should return a synthetic success response when fetch throws a network error', async () => {
+      delete process.env.OPENSPEC_TELEMETRY;
+      delete process.env.DO_NOT_TRACK;
+      delete process.env.CI;
+      await trackCommand('test', '1.0.0');
+
+      const fetchFn = (PostHog as any).mock.calls[0][1].fetch as typeof fetch;
+      fetchSpy.mockRejectedValueOnce(new Error('network down'));
+
+      const response = await fetchFn('https://edge.openspec.dev/batch/', { method: 'POST' });
+
+      expect(response.status).toBe(204);
+    });
+
+    it('should return a synthetic success response when fetch aborts', async () => {
+      delete process.env.OPENSPEC_TELEMETRY;
+      delete process.env.DO_NOT_TRACK;
+      delete process.env.CI;
+      await trackCommand('test', '1.0.0');
+
+      const fetchFn = (PostHog as any).mock.calls[0][1].fetch as typeof fetch;
+      fetchSpy.mockRejectedValueOnce(new DOMException('This operation was aborted', 'AbortError'));
+
+      const response = await fetchFn('https://edge.openspec.dev/batch/', { method: 'POST' });
+
+      expect(response.status).toBe(204);
+    });
+
+    it('should return a synthetic success response for non-2xx responses', async () => {
+      delete process.env.OPENSPEC_TELEMETRY;
+      delete process.env.DO_NOT_TRACK;
+      delete process.env.CI;
+      await trackCommand('test', '1.0.0');
+
+      const fetchFn = (PostHog as any).mock.calls[0][1].fetch as typeof fetch;
+      fetchSpy.mockResolvedValueOnce(new Response('forbidden', { status: 403 }));
+
+      const response = await fetchFn('https://edge.openspec.dev/batch/', { method: 'POST' });
+
+      expect(response.status).toBe(204);
+    });
+
+    it('should pass through successful responses from fetch', async () => {
+      delete process.env.OPENSPEC_TELEMETRY;
+      delete process.env.DO_NOT_TRACK;
+      delete process.env.CI;
+      await trackCommand('test', '1.0.0');
+
+      const fetchFn = (PostHog as any).mock.calls[0][1].fetch as typeof fetch;
+      const expectedResponse = new Response(null, { status: 200 });
+      fetchSpy.mockResolvedValueOnce(expectedResponse);
+
+      const response = await fetchFn('https://edge.openspec.dev/batch/', { method: 'POST' });
+
+      expect(response).toBe(expectedResponse);
+    });
+  });
+
+  describe('shutdown', () => {
+    it('should not throw when no client exists', async () => {
+      await expect(shutdown()).resolves.not.toThrow();
+    });
+
+    it('should handle shutdown errors silently', async () => {
+      const mockPostHog = {
+        capture: vi.fn(),
+        shutdown: vi.fn().mockRejectedValue(new Error('Network error')),
+      };
+      (PostHog as any).mockImplementation(() => mockPostHog);
+
+      await expect(shutdown()).resolves.not.toThrow();
+    });
+  });
+});

package/OpenSpec-main/test/utils/change-metadata.test.ts

@@ -0,0 +1,368 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+import {
+  writeChangeMetadata,
+  readChangeMetadata,
+  resolveSchemaForChange,
+  validateSchemaName,
+  ChangeMetadataError,
+} from '../../src/utils/change-metadata.js';
+import { ChangeMetadataSchema } from '../../src/core/change-metadata/index.js';
+
+describe('ChangeMetadataSchema', () => {
+  describe('valid metadata', () => {
+    it('should accept valid schema with created date', () => {
+      const result = ChangeMetadataSchema.safeParse({
+        schema: 'spec-driven',
+        created: '2025-01-05',
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.schema).toBe('spec-driven');
+        expect(result.data.created).toBe('2025-01-05');
+      }
+    });
+
+    it('should accept valid schema without created date', () => {
+      const result = ChangeMetadataSchema.safeParse({
+        schema: 'custom-schema',
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.schema).toBe('custom-schema');
+        expect(result.data.created).toBeUndefined();
+      }
+    });
+
+    it('should accept a portable initiative link', () => {
+      const result = ChangeMetadataSchema.safeParse({
+        schema: 'spec-driven',
+        initiative: {
+          store: 'platform',
+          id: 'billing-launch',
+        },
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.initiative).toEqual({
+          store: 'platform',
+          id: 'billing-launch',
+        });
+      }
+    });
+  });
+
+  describe('invalid metadata', () => {
+    it('should reject empty schema', () => {
+      const result = ChangeMetadataSchema.safeParse({
+        schema: '',
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject missing schema', () => {
+      const result = ChangeMetadataSchema.safeParse({
+        created: '2025-01-05',
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject invalid date format', () => {
+      const result = ChangeMetadataSchema.safeParse({
+        schema: 'spec-driven',
+        created: '01/05/2025', // Wrong format
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject non-ISO date format', () => {
+      const result = ChangeMetadataSchema.safeParse({
+        schema: 'spec-driven',
+        created: '2025-1-5', // Missing leading zeros
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject initiative links with local paths or copied content', () => {
+      const result = ChangeMetadataSchema.safeParse({
+        schema: 'spec-driven',
+        initiative: {
+          store: 'platform',
+          id: 'billing-launch',
+          path: '/tmp/context-store/initiatives/billing-launch',
+          summary: 'Copied initiative prose',
+        },
+      });
+
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject unsafe initiative link identifiers', () => {
+      for (const initiative of [
+        { store: '/tmp/platform', id: 'billing-launch' },
+        { store: 'platform', id: 'billing/launch' },
+        { store: 'Platform', id: 'billing-launch' },
+        { store: 'platform', id: 'billing launch' },
+      ]) {
+        const result = ChangeMetadataSchema.safeParse({
+          schema: 'spec-driven',
+          initiative,
+        });
+
+        expect(result.success).toBe(false);
+      }
+    });
+  });
+});
+
+describe('writeChangeMetadata', () => {
+  let testDir: string;
+  let changeDir: string;
+
+  beforeEach(async () => {
+    testDir = path.join(os.tmpdir(), `openspec-test-${randomUUID()}`);
+    changeDir = path.join(testDir, 'openspec', 'changes', 'test-change');
+    await fs.mkdir(changeDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('should write valid YAML metadata file', async () => {
+    writeChangeMetadata(changeDir, {
+      schema: 'spec-driven',
+      created: '2025-01-05',
+    });
+
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    const content = await fs.readFile(metaPath, 'utf-8');
+
+    expect(content).toContain('schema: spec-driven');
+    expect(content).toContain('created: 2025-01-05');
+  });
+
+  it('should throw error for unknown schema', () => {
+    expect(() =>
+      writeChangeMetadata(changeDir, {
+        schema: 'unknown-schema',
+        created: '2025-01-05',
+      })
+    ).toThrow(/Unknown schema 'unknown-schema'/);
+  });
+});
+
+describe('readChangeMetadata', () => {
+  let testDir: string;
+  let changeDir: string;
+
+  beforeEach(async () => {
+    testDir = path.join(os.tmpdir(), `openspec-test-${randomUUID()}`);
+    changeDir = path.join(testDir, 'openspec', 'changes', 'test-change');
+    await fs.mkdir(changeDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('should return null when no metadata file exists', () => {
+    const result = readChangeMetadata(changeDir);
+    expect(result).toBeNull();
+  });
+
+  it('should read valid metadata', async () => {
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(
+      metaPath,
+      'schema: spec-driven\ncreated: "2025-01-05"\n',
+      'utf-8'
+    );
+
+    const result = readChangeMetadata(changeDir);
+    expect(result).toEqual({
+      schema: 'spec-driven',
+      created: '2025-01-05',
+    });
+  });
+
+  it('should read portable initiative metadata', async () => {
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(
+      metaPath,
+      [
+        'schema: spec-driven',
+        'initiative:',
+        '  store: platform',
+        '  id: billing-launch',
+        '',
+      ].join('\n'),
+      'utf-8'
+    );
+
+    const result = readChangeMetadata(changeDir);
+    expect(result?.initiative).toEqual({
+      store: 'platform',
+      id: 'billing-launch',
+    });
+  });
+
+  it('should throw ChangeMetadataError for invalid YAML', async () => {
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, '{ invalid yaml', 'utf-8');
+
+    expect(() => readChangeMetadata(changeDir)).toThrow(ChangeMetadataError);
+  });
+
+  it('should throw ChangeMetadataError for missing schema field', async () => {
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, 'created: "2025-01-05"\n', 'utf-8');
+
+    expect(() => readChangeMetadata(changeDir)).toThrow(ChangeMetadataError);
+  });
+
+  it('should throw ChangeMetadataError for unknown schema', async () => {
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, 'schema: unknown-schema\n', 'utf-8');
+
+    expect(() => readChangeMetadata(changeDir)).toThrow(/Unknown schema/);
+  });
+});
+
+describe('resolveSchemaForChange', () => {
+  let testDir: string;
+  let changeDir: string;
+
+  beforeEach(async () => {
+    testDir = path.join(os.tmpdir(), `openspec-test-${randomUUID()}`);
+    changeDir = path.join(testDir, 'openspec', 'changes', 'test-change');
+    await fs.mkdir(changeDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('should return explicit schema when provided', async () => {
+    // Even with metadata file, explicit schema wins
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, 'schema: spec-driven\n', 'utf-8');
+
+    const result = resolveSchemaForChange(changeDir, 'custom-schema');
+    expect(result).toBe('custom-schema');
+  });
+
+  it('should return schema from metadata when no explicit schema', async () => {
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, 'schema: spec-driven\n', 'utf-8');
+
+    const result = resolveSchemaForChange(changeDir);
+    expect(result).toBe('spec-driven');
+  });
+
+  it('should return default when no metadata and no explicit schema', () => {
+    const result = resolveSchemaForChange(changeDir);
+    expect(result).toBe('spec-driven');
+  });
+
+  it('should fail when metadata exists but cannot be read', async () => {
+    // Create an invalid metadata file
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, '{ invalid yaml', 'utf-8');
+
+    expect(() => resolveSchemaForChange(changeDir)).toThrow(ChangeMetadataError);
+  });
+
+  it('should use project config schema when no metadata exists', async () => {
+    // Create project config
+    const configDir = path.join(testDir, 'openspec');
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(
+      path.join(configDir, 'config.yaml'),
+      'schema: custom-schema\n',
+      'utf-8'
+    );
+
+    const result = resolveSchemaForChange(changeDir);
+    expect(result).toBe('custom-schema');
+  });
+
+  it('should prefer change metadata over project config', async () => {
+    // Create project config
+    const configDir = path.join(testDir, 'openspec');
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(
+      path.join(configDir, 'config.yaml'),
+      'schema: custom-schema\n',
+      'utf-8'
+    );
+
+    // Create change metadata with different schema
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, 'schema: spec-driven\n', 'utf-8');
+
+    const result = resolveSchemaForChange(changeDir);
+    expect(result).toBe('spec-driven'); // Change metadata wins
+  });
+
+  it('should prefer explicit schema over all config sources', async () => {
+    // Create project config
+    const configDir = path.join(testDir, 'openspec');
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(
+      path.join(configDir, 'config.yaml'),
+      'schema: custom-schema\n',
+      'utf-8'
+    );
+
+    // Create change metadata
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, 'schema: spec-driven\n', 'utf-8');
+
+    // Explicit schema should win
+    const result = resolveSchemaForChange(changeDir, 'custom-schema');
+    expect(result).toBe('custom-schema');
+  });
+
+  it('should test full precedence order: CLI > metadata > config > default', async () => {
+    // Setup all levels
+    const configDir = path.join(testDir, 'openspec');
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(
+      path.join(configDir, 'config.yaml'),
+      'schema: custom-schema\n',
+      'utf-8'
+    );
+
+    const metaPath = path.join(changeDir, '.openspec.yaml');
+    await fs.writeFile(metaPath, 'schema: spec-driven\n', 'utf-8');
+
+    // Test each level
+    expect(resolveSchemaForChange(changeDir, 'custom-schema')).toBe('custom-schema'); // CLI wins
+    expect(resolveSchemaForChange(changeDir)).toBe('spec-driven'); // Metadata wins when no CLI
+
+    // Remove metadata, config should win
+    await fs.unlink(metaPath);
+    expect(resolveSchemaForChange(changeDir)).toBe('custom-schema'); // Config wins
+
+    // Remove config, default should win
+    await fs.unlink(path.join(configDir, 'config.yaml'));
+    expect(resolveSchemaForChange(changeDir)).toBe('spec-driven'); // Default wins
+  });
+});
+
+describe('validateSchemaName', () => {
+  it('should accept valid schema name', () => {
+    expect(() => validateSchemaName('spec-driven')).not.toThrow();
+  });
+
+  it('should throw for unknown schema', () => {
+    expect(() => validateSchemaName('unknown-schema')).toThrow(
+      /Unknown schema 'unknown-schema'/
+    );
+  });
+});