sauron-cli 1.3.0 → 1.4.0

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

@@ -1,184 +0,0 @@
-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

@@ -1,371 +0,0 @@
-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);
-    });
-  });
-});