sauron-cli 1.2.0 → 1.3.0

package/OpenSpec-main/test/core/converters/json-converter.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { JsonConverter } from '../../../src/core/converters/json-converter.js';
+
+describe('JsonConverter', () => {
+  const testDir = path.join(process.cwd(), 'test-json-converter-tmp');
+  const converter = new JsonConverter();
+  
+  beforeEach(async () => {
+    await fs.mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  describe('convertSpecToJson', () => {
+    it('should convert a spec to JSON format', async () => {
+      const specContent = `# User Authentication Spec
+
+## Purpose
+This specification defines the requirements for user authentication.
+
+## Requirements
+
+### The system SHALL provide secure user authentication
+Users need to be able to log in securely.
+
+#### Scenario: Successful login
+Given a user with valid credentials
+When they submit the login form
+Then they are authenticated`;
+
+      const specPath = path.join(testDir, 'spec.md');
+      await fs.writeFile(specPath, specContent);
+      
+      const json = converter.convertSpecToJson(specPath);
+      const parsed = JSON.parse(json);
+      
+      expect(parsed.name).toBe('spec');
+      expect(parsed.overview).toContain('user authentication');
+      expect(parsed.requirements).toHaveLength(1);
+      expect(parsed.requirements[0].scenarios).toHaveLength(1);
+      expect(parsed.metadata).toBeDefined();
+      expect(parsed.metadata.format).toBe('openspec');
+      expect(parsed.metadata.sourcePath).toBe(specPath);
+    });
+
+    it('should extract spec name from directory structure', async () => {
+      const specsDir = path.join(testDir, 'specs', 'user-auth');
+      await fs.mkdir(specsDir, { recursive: true });
+      
+      const specContent = `# User Auth
+
+## Purpose
+Auth spec overview
+
+## Requirements
+
+### The system SHALL authenticate users
+
+#### Scenario: Login
+Given a user
+When they login
+Then authenticated`;
+
+      const specPath = path.join(specsDir, 'spec.md');
+      await fs.writeFile(specPath, specContent);
+      
+      const json = converter.convertSpecToJson(specPath);
+      const parsed = JSON.parse(json);
+      
+      expect(parsed.name).toBe('user-auth');
+    });
+  });
+
+  describe('convertChangeToJson', () => {
+    it('should convert a change to JSON format', async () => {
+      const changeContent = `# Add User Authentication
+
+## Why
+We need to implement user authentication to secure the application and protect user data from unauthorized access.
+
+## What Changes
+- **user-auth:** Add new user authentication specification
+- **api-endpoints:** Modify to include authentication endpoints`;
+
+      const changePath = path.join(testDir, 'change.md');
+      await fs.writeFile(changePath, changeContent);
+      
+      const json = await converter.convertChangeToJson(changePath);
+      const parsed = JSON.parse(json);
+      
+      expect(parsed.name).toBe('change');
+      expect(parsed.why).toContain('secure the application');
+      expect(parsed.deltas).toHaveLength(2);
+      expect(parsed.deltas[0].spec).toBe('user-auth');
+      expect(parsed.deltas[0].operation).toBe('ADDED');
+      expect(parsed.metadata).toBeDefined();
+      expect(parsed.metadata.format).toBe('openspec-change');
+      expect(parsed.metadata.sourcePath).toBe(changePath);
+    });
+
+    it('should extract change name from directory structure', async () => {
+      const changesDir = path.join(testDir, 'changes', 'add-auth');
+      await fs.mkdir(changesDir, { recursive: true });
+      
+      const changeContent = `# Add Auth
+
+## Why
+We need authentication for security reasons and to protect user data properly.
+
+## What Changes
+- **auth:** Add authentication`;
+
+      const changePath = path.join(changesDir, 'proposal.md');
+      await fs.writeFile(changePath, changeContent);
+      
+      const json = await converter.convertChangeToJson(changePath);
+      const parsed = JSON.parse(json);
+      
+      expect(parsed.name).toBe('add-auth');
+    });
+  });
+
+  describe('JSON formatting', () => {
+    it('should produce properly formatted JSON with indentation', async () => {
+      const specContent = `# Test
+
+## Purpose
+Test overview
+
+## Requirements
+
+### The system SHALL test
+
+#### Scenario: Test
+Given test
+When action
+Then result`;
+
+      const specPath = path.join(testDir, 'spec.md');
+      await fs.writeFile(specPath, specContent);
+      
+      const json = converter.convertSpecToJson(specPath);
+      
+      // Check for proper indentation (2 spaces)
+      expect(json).toContain('  "name"');
+      expect(json).toContain('  "overview"');
+      expect(json).toContain('  "requirements"');
+      
+      // Check it's valid JSON
+      expect(() => JSON.parse(json)).not.toThrow();
+    });
+
+    it('should handle special characters in content', async () => {
+      const specContent = `# Test
+
+## Purpose
+This has "quotes" and \\ backslashes and
+newlines
+
+## Requirements
+
+### The system SHALL handle "special" characters
+
+#### Scenario: Special chars
+Given a string with "quotes"
+When processing \\ backslash
+Then handle correctly`;
+
+      const specPath = path.join(testDir, 'spec.md');
+      await fs.writeFile(specPath, specContent);
+      
+      const json = converter.convertSpecToJson(specPath);
+      const parsed = JSON.parse(json);
+      
+      expect(parsed.overview).toContain('"quotes"');
+      expect(parsed.overview).toContain('\\');
+      expect(parsed.requirements[0].text).toContain('"special"');
+    });
+  });
+});

package/OpenSpec-main/test/core/global-config.test.ts

@@ -0,0 +1,371 @@
+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 {
+  getGlobalConfigDir,
+  getGlobalConfigPath,
+  getGlobalDataDir,
+  getGlobalConfig,
+  saveGlobalConfig,
+  GLOBAL_CONFIG_DIR_NAME,
+  GLOBAL_CONFIG_FILE_NAME
+} from '../../src/core/global-config.js';
+import type { Profile, Delivery } from '../../src/core/global-config.js';
+
+describe('global-config', () => {
+  let tempDir: string;
+  let originalEnv: NodeJS.ProcessEnv;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    // Create temp directory for tests
+    tempDir = path.join(os.tmpdir(), `openspec-global-config-test-${Date.now()}`);
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    // Save original env
+    originalEnv = { ...process.env };
+
+    // Spy on console.error for warning tests
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restore original env
+    process.env = originalEnv;
+
+    // Clean up temp directory
+    fs.rmSync(tempDir, { recursive: true, force: true });
+
+    // Restore console.error
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe('constants', () => {
+    it('should export correct directory name', () => {
+      expect(GLOBAL_CONFIG_DIR_NAME).toBe('openspec');
+    });
+
+    it('should export correct file name', () => {
+      expect(GLOBAL_CONFIG_FILE_NAME).toBe('config.json');
+    });
+  });
+
+  describe('getGlobalConfigDir', () => {
+    it('should use XDG_CONFIG_HOME when set', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+
+      const result = getGlobalConfigDir();
+
+      expect(result).toBe(path.join(tempDir, 'openspec'));
+    });
+
+    it('should fall back to ~/.config on Unix/macOS without XDG_CONFIG_HOME', () => {
+      delete process.env.XDG_CONFIG_HOME;
+
+      const result = getGlobalConfigDir();
+
+      // On non-Windows, should use ~/.config/openspec
+      if (os.platform() !== 'win32') {
+        expect(result).toBe(path.join(os.homedir(), '.config', 'openspec'));
+      }
+    });
+
+    it('should use APPDATA on Windows when XDG_CONFIG_HOME is not set', () => {
+      // This test only makes sense conceptually - we can't change os.platform()
+      // But we can verify the APPDATA logic by checking the code path
+      if (os.platform() === 'win32') {
+        delete process.env.XDG_CONFIG_HOME;
+        const appData = process.env.APPDATA;
+        if (appData) {
+          const result = getGlobalConfigDir();
+          expect(result).toBe(path.join(appData, 'openspec'));
+        }
+      }
+    });
+  });
+
+  describe('getGlobalConfigPath', () => {
+    it('should return path to config.json in config directory', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+
+      const result = getGlobalConfigPath();
+
+      expect(result).toBe(path.join(tempDir, 'openspec', 'config.json'));
+    });
+  });
+
+  describe('getGlobalDataDir', () => {
+    it('should use POSIX separators for Unix-like platform overrides', () => {
+      expect(
+        getGlobalDataDir({
+          env: {},
+          platform: 'linux',
+          homedir: '/home/tabish',
+        })
+      ).toBe('/home/tabish/.local/share/openspec');
+
+      expect(
+        getGlobalDataDir({
+          env: { XDG_DATA_HOME: '/var/data' },
+          platform: 'darwin',
+          homedir: '/Users/tabish',
+        })
+      ).toBe('/var/data/openspec');
+    });
+
+    it('should use Windows separators for native Windows platform overrides', () => {
+      expect(
+        getGlobalDataDir({
+          env: {},
+          platform: 'win32',
+          homedir: 'C:\\Users\\Tabish',
+        })
+      ).toBe('C:\\Users\\Tabish\\AppData\\Local\\openspec');
+
+      expect(
+        getGlobalDataDir({
+          env: { LOCALAPPDATA: 'D:\\Users\\Tabish\\AppData\\Local' },
+          platform: 'win32',
+          homedir: 'C:\\Users\\Tabish',
+        })
+      ).toBe('D:\\Users\\Tabish\\AppData\\Local\\openspec');
+    });
+  });
+
+  describe('getGlobalConfig', () => {
+    it('should return defaults when config file does not exist', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+
+      const config = getGlobalConfig();
+
+      expect(config).toEqual({ featureFlags: {}, profile: 'core', delivery: 'both' });
+    });
+
+    it('should not create directory when reading non-existent config', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configDir = path.join(tempDir, 'openspec');
+
+      getGlobalConfig();
+
+      expect(fs.existsSync(configDir)).toBe(false);
+    });
+
+    it('should load valid config from file', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configDir = path.join(tempDir, 'openspec');
+      const configPath = path.join(configDir, 'config.json');
+
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(configPath, JSON.stringify({
+        featureFlags: { testFlag: true, anotherFlag: false }
+      }));
+
+      const config = getGlobalConfig();
+
+      expect(config.featureFlags).toEqual({ testFlag: true, anotherFlag: false });
+    });
+
+    it('should return defaults for invalid JSON', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configDir = path.join(tempDir, 'openspec');
+      const configPath = path.join(configDir, 'config.json');
+
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(configPath, '{ invalid json }');
+
+      const config = getGlobalConfig();
+
+      expect(config).toEqual({ featureFlags: {}, profile: 'core', delivery: 'both' });
+    });
+
+    it('should log warning for invalid JSON', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configDir = path.join(tempDir, 'openspec');
+      const configPath = path.join(configDir, 'config.json');
+
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(configPath, '{ invalid json }');
+
+      getGlobalConfig();
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Invalid JSON')
+      );
+    });
+
+    it('should preserve unknown fields from config file', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configDir = path.join(tempDir, 'openspec');
+      const configPath = path.join(configDir, 'config.json');
+
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(configPath, JSON.stringify({
+        featureFlags: { x: true },
+        unknownField: 'preserved',
+        futureOption: 123
+      }));
+
+      const config = getGlobalConfig();
+
+      expect((config as any).unknownField).toBe('preserved');
+      expect((config as any).futureOption).toBe(123);
+    });
+
+    it('should merge loaded config with defaults', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configDir = path.join(tempDir, 'openspec');
+      const configPath = path.join(configDir, 'config.json');
+
+      // Config with only some fields
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(configPath, JSON.stringify({
+        featureFlags: { customFlag: true }
+      }));
+
+      const config = getGlobalConfig();
+
+      // Should have the custom flag
+      expect(config.featureFlags?.customFlag).toBe(true);
+    });
+
+    describe('schema evolution', () => {
+      it('should add default profile and delivery when loading old config without them', () => {
+        process.env.XDG_CONFIG_HOME = tempDir;
+        const configDir = path.join(tempDir, 'openspec');
+        const configPath = path.join(configDir, 'config.json');
+
+        // Simulate a pre-existing config that only has featureFlags
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify({
+          featureFlags: { existingFlag: true }
+        }));
+
+        const config = getGlobalConfig();
+
+        expect(config.profile).toBe('core');
+        expect(config.delivery).toBe('both');
+        expect(config.workflows).toBeUndefined();
+        expect(config.featureFlags?.existingFlag).toBe(true);
+      });
+
+      it('should preserve explicit profile and delivery values from config', () => {
+        process.env.XDG_CONFIG_HOME = tempDir;
+        const configDir = path.join(tempDir, 'openspec');
+        const configPath = path.join(configDir, 'config.json');
+
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify({
+          featureFlags: {},
+          profile: 'custom',
+          delivery: 'skills',
+          workflows: ['propose', 'review']
+        }));
+
+        const config = getGlobalConfig();
+
+        expect(config.profile).toBe('custom');
+        expect(config.delivery).toBe('skills');
+        expect(config.workflows).toEqual(['propose', 'review']);
+      });
+
+      it('should round-trip new fields correctly', () => {
+        process.env.XDG_CONFIG_HOME = tempDir;
+        const originalConfig = {
+          featureFlags: { flag1: true },
+          profile: 'custom' as Profile,
+          delivery: 'commands' as Delivery,
+          workflows: ['propose']
+        };
+
+        saveGlobalConfig(originalConfig);
+        const loadedConfig = getGlobalConfig();
+
+        expect(loadedConfig.profile).toBe('custom');
+        expect(loadedConfig.delivery).toBe('commands');
+        expect(loadedConfig.workflows).toEqual(['propose']);
+      });
+
+      it('should default workflows to undefined when not in config', () => {
+        process.env.XDG_CONFIG_HOME = tempDir;
+        const configDir = path.join(tempDir, 'openspec');
+        const configPath = path.join(configDir, 'config.json');
+
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify({
+          featureFlags: {},
+          profile: 'core',
+          delivery: 'both'
+        }));
+
+        const config = getGlobalConfig();
+
+        expect(config.workflows).toBeUndefined();
+      });
+    });
+  });
+
+  describe('saveGlobalConfig', () => {
+    it('should create directory if it does not exist', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configDir = path.join(tempDir, 'openspec');
+
+      saveGlobalConfig({ featureFlags: { test: true } });
+
+      expect(fs.existsSync(configDir)).toBe(true);
+    });
+
+    it('should write config to file', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configPath = path.join(tempDir, 'openspec', 'config.json');
+
+      saveGlobalConfig({ featureFlags: { myFlag: true } });
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const parsed = JSON.parse(content);
+      expect(parsed.featureFlags.myFlag).toBe(true);
+    });
+
+    it('should overwrite existing config file', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configDir = path.join(tempDir, 'openspec');
+      const configPath = path.join(configDir, 'config.json');
+
+      // Create initial config
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(configPath, JSON.stringify({ featureFlags: { old: true } }));
+
+      // Overwrite
+      saveGlobalConfig({ featureFlags: { new: true } });
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const parsed = JSON.parse(content);
+      expect(parsed.featureFlags.new).toBe(true);
+      expect(parsed.featureFlags.old).toBeUndefined();
+    });
+
+    it('should write formatted JSON with trailing newline', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const configPath = path.join(tempDir, 'openspec', 'config.json');
+
+      saveGlobalConfig({ featureFlags: {} });
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('\n');
+      expect(content.endsWith('\n')).toBe(true);
+    });
+
+    it('should round-trip config correctly', () => {
+      process.env.XDG_CONFIG_HOME = tempDir;
+      const originalConfig = {
+        featureFlags: { flag1: true, flag2: false }
+      };
+
+      saveGlobalConfig(originalConfig);
+      const loadedConfig = getGlobalConfig();
+
+      expect(loadedConfig.featureFlags).toEqual(originalConfig.featureFlags);
+    });
+  });
+});