sauron-cli 1.3.0 → 1.4.1

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

@@ -1,201 +0,0 @@
-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 { validateChangeName, createChange } from '../../src/utils/change-utils.js';
-
-describe('validateChangeName', () => {
-  describe('valid names', () => {
-    it('should accept simple kebab-case name', () => {
-      const result = validateChangeName('add-auth');
-      expect(result).toEqual({ valid: true });
-    });
-
-    it('should accept name with multiple segments', () => {
-      const result = validateChangeName('add-user-auth');
-      expect(result).toEqual({ valid: true });
-    });
-
-    it('should accept name with numeric suffix', () => {
-      const result = validateChangeName('add-feature-2');
-      expect(result).toEqual({ valid: true });
-    });
-
-    it('should accept single word name', () => {
-      const result = validateChangeName('refactor');
-      expect(result).toEqual({ valid: true });
-    });
-
-    it('should accept name with numbers in segments', () => {
-      const result = validateChangeName('upgrade-to-v2');
-      expect(result).toEqual({ valid: true });
-    });
-  });
-
-  describe('invalid names - uppercase rejected', () => {
-    it('should reject name with uppercase letters', () => {
-      const result = validateChangeName('Add-Auth');
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain('lowercase');
-    });
-
-    it('should reject fully uppercase name', () => {
-      const result = validateChangeName('ADD-AUTH');
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain('lowercase');
-    });
-  });
-
-  describe('invalid names - spaces rejected', () => {
-    it('should reject name with spaces', () => {
-      const result = validateChangeName('add auth');
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain('spaces');
-    });
-  });
-
-  describe('invalid names - underscores rejected', () => {
-    it('should reject name with underscores', () => {
-      const result = validateChangeName('add_auth');
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain('underscores');
-    });
-  });
-
-  describe('invalid names - special characters rejected', () => {
-    it('should reject name with exclamation mark', () => {
-      const result = validateChangeName('add-auth!');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    it('should reject name with @ symbol', () => {
-      const result = validateChangeName('add@auth');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-  });
-
-  describe('invalid names - leading/trailing hyphens rejected', () => {
-    it('should reject name with leading hyphen', () => {
-      const result = validateChangeName('-add-auth');
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain('start with a hyphen');
-    });
-
-    it('should reject name with trailing hyphen', () => {
-      const result = validateChangeName('add-auth-');
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain('end with a hyphen');
-    });
-  });
-
-  describe('invalid names - consecutive hyphens rejected', () => {
-    it('should reject name with double hyphens', () => {
-      const result = validateChangeName('add--auth');
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain('consecutive hyphens');
-    });
-  });
-
-  describe('invalid names - empty name rejected', () => {
-    it('should reject empty string', () => {
-      const result = validateChangeName('');
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain('empty');
-    });
-  });
-});
-
-describe('createChange', () => {
-  let testDir: string;
-
-  beforeEach(async () => {
-    testDir = path.join(os.tmpdir(), `openspec-test-${randomUUID()}`);
-    await fs.mkdir(testDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await fs.rm(testDir, { recursive: true, force: true });
-  });
-
-  describe('creates directory', () => {
-    it('should create change directory', async () => {
-      await createChange(testDir, 'add-auth');
-
-      const changeDir = path.join(testDir, 'openspec', 'changes', 'add-auth');
-      const stats = await fs.stat(changeDir);
-      expect(stats.isDirectory()).toBe(true);
-    });
-
-    it('should create .openspec.yaml metadata file with default schema', async () => {
-      await createChange(testDir, 'add-auth');
-
-      const metaPath = path.join(testDir, 'openspec', 'changes', 'add-auth', '.openspec.yaml');
-      const content = await fs.readFile(metaPath, 'utf-8');
-      expect(content).toContain('schema: spec-driven');
-      expect(content).toMatch(/created: \d{4}-\d{2}-\d{2}/);
-    });
-
-    it('should create .openspec.yaml with custom schema', async () => {
-      await createChange(testDir, 'add-auth', { schema: 'spec-driven' });
-
-      const metaPath = path.join(testDir, 'openspec', 'changes', 'add-auth', '.openspec.yaml');
-      const content = await fs.readFile(metaPath, 'utf-8');
-      expect(content).toContain('schema: spec-driven');
-    });
-  });
-
-  describe('schema validation', () => {
-    it('should throw error for unknown schema', async () => {
-      await expect(createChange(testDir, 'add-auth', { schema: 'unknown-schema' })).rejects.toThrow(
-        /Unknown schema/
-      );
-    });
-  });
-
-  describe('duplicate change throws error', () => {
-    it('should throw error if change already exists', async () => {
-      await createChange(testDir, 'add-auth');
-
-      await expect(createChange(testDir, 'add-auth')).rejects.toThrow(
-        /already exists/
-      );
-    });
-  });
-
-  describe('invalid name throws validation error', () => {
-    it('should throw error for uppercase name', async () => {
-      await expect(createChange(testDir, 'Add-Auth')).rejects.toThrow(
-        /lowercase/
-      );
-    });
-
-    it('should throw error for name with spaces', async () => {
-      await expect(createChange(testDir, 'add auth')).rejects.toThrow(
-        /spaces/
-      );
-    });
-
-    it('should throw error for empty name', async () => {
-      await expect(createChange(testDir, '')).rejects.toThrow(
-        /empty/
-      );
-    });
-  });
-
-  describe('creates parent directories if needed', () => {
-    it('should create openspec/changes/ directories if they do not exist', async () => {
-      const newProjectDir = path.join(testDir, 'new-project');
-      await fs.mkdir(newProjectDir);
-
-      // openspec/changes/ does not exist yet
-      await createChange(newProjectDir, 'add-auth');
-
-      const changeDir = path.join(newProjectDir, 'openspec', 'changes', 'add-auth');
-      const stats = await fs.stat(changeDir);
-      expect(stats.isDirectory()).toBe(true);
-    });
-  });
-});

package/OpenSpec-main/test/utils/command-references.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { transformToHyphenCommands } from '../../src/utils/command-references.js';
-
-describe('transformToHyphenCommands', () => {
-  describe('basic transformations', () => {
-    it('should transform single command reference', () => {
-      expect(transformToHyphenCommands('/opsx:new')).toBe('/opsx-new');
-    });
-
-    it('should transform multiple command references', () => {
-      const input = '/opsx:new and /opsx:apply';
-      const expected = '/opsx-new and /opsx-apply';
-      expect(transformToHyphenCommands(input)).toBe(expected);
-    });
-
-    it('should transform command reference in context', () => {
-      const input = 'Use /opsx:apply to implement tasks';
-      const expected = 'Use /opsx-apply to implement tasks';
-      expect(transformToHyphenCommands(input)).toBe(expected);
-    });
-
-    it('should handle backtick-quoted commands', () => {
-      const input = 'Run `/opsx:continue` to proceed';
-      const expected = 'Run `/opsx-continue` to proceed';
-      expect(transformToHyphenCommands(input)).toBe(expected);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should return unchanged text with no command references', () => {
-      const input = 'This is plain text without commands';
-      expect(transformToHyphenCommands(input)).toBe(input);
-    });
-
-    it('should return empty string unchanged', () => {
-      expect(transformToHyphenCommands('')).toBe('');
-    });
-
-    it('should not transform similar but non-matching patterns', () => {
-      const input = '/ops:new opsx: /other:command';
-      expect(transformToHyphenCommands(input)).toBe(input);
-    });
-
-    it('should handle multiple occurrences on same line', () => {
-      const input = '/opsx:new /opsx:continue /opsx:apply';
-      const expected = '/opsx-new /opsx-continue /opsx-apply';
-      expect(transformToHyphenCommands(input)).toBe(expected);
-    });
-  });
-
-  describe('multiline content', () => {
-    it('should transform references across multiple lines', () => {
-      const input = `Use /opsx:new to start
-Then /opsx:continue to proceed
-Finally /opsx:apply to implement`;
-      const expected = `Use /opsx-new to start
-Then /opsx-continue to proceed
-Finally /opsx-apply to implement`;
-      expect(transformToHyphenCommands(input)).toBe(expected);
-    });
-  });
-
-  describe('all known commands', () => {
-    const commands = [
-      'new',
-      'continue',
-      'apply',
-      'ff',
-      'sync',
-      'archive',
-      'bulk-archive',
-      'verify',
-      'explore',
-      'onboard',
-    ];
-
-    for (const cmd of commands) {
-      it(`should transform /opsx:${cmd}`, () => {
-        expect(transformToHyphenCommands(`/opsx:${cmd}`)).toBe(`/opsx-${cmd}`);
-      });
-    }
-  });
-});

package/OpenSpec-main/test/utils/file-system.test.ts

@@ -1,322 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import * as nodeFs from 'fs';
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
-import { randomUUID } from 'crypto';
-import { FileSystemUtils } from '../../src/utils/file-system.js';
-
-describe('FileSystemUtils', () => {
-  let testDir: string;
-
-  beforeEach(async () => {
-    testDir = path.join(os.tmpdir(), `openspec-test-${randomUUID()}`);
-    await fs.mkdir(testDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await fs.rm(testDir, { recursive: true, force: true });
-  });
-
-  describe('createDirectory', () => {
-    it('should create a directory', async () => {
-      const dirPath = path.join(testDir, 'new-dir');
-      await FileSystemUtils.createDirectory(dirPath);
-      
-      const stats = await fs.stat(dirPath);
-      expect(stats.isDirectory()).toBe(true);
-    });
-
-    it('should create nested directories', async () => {
-      const dirPath = path.join(testDir, 'nested', 'deep', 'dir');
-      await FileSystemUtils.createDirectory(dirPath);
-      
-      const stats = await fs.stat(dirPath);
-      expect(stats.isDirectory()).toBe(true);
-    });
-
-    it('should not throw if directory already exists', async () => {
-      const dirPath = path.join(testDir, 'existing-dir');
-      await fs.mkdir(dirPath);
-      
-      await expect(FileSystemUtils.createDirectory(dirPath)).resolves.not.toThrow();
-    });
-  });
-
-  describe('fileExists', () => {
-    it('should return true for existing file', async () => {
-      const filePath = path.join(testDir, 'test.txt');
-      await fs.writeFile(filePath, 'test content');
-      
-      const exists = await FileSystemUtils.fileExists(filePath);
-      expect(exists).toBe(true);
-    });
-
-    it('should return false for non-existing file', async () => {
-      const filePath = path.join(testDir, 'non-existent.txt');
-      
-      const exists = await FileSystemUtils.fileExists(filePath);
-      expect(exists).toBe(false);
-    });
-
-    it('should return false for directory path', async () => {
-      const dirPath = path.join(testDir, 'dir');
-      await fs.mkdir(dirPath);
-      
-      const exists = await FileSystemUtils.fileExists(dirPath);
-      expect(exists).toBe(true); // fs.access doesn't distinguish between files and directories
-    });
-  });
-
-  describe('directoryExists', () => {
-    it('should return true for existing directory', async () => {
-      const dirPath = path.join(testDir, 'test-dir');
-      await fs.mkdir(dirPath);
-      
-      const exists = await FileSystemUtils.directoryExists(dirPath);
-      expect(exists).toBe(true);
-    });
-
-    it('should return false for non-existing directory', async () => {
-      const dirPath = path.join(testDir, 'non-existent-dir');
-      
-      const exists = await FileSystemUtils.directoryExists(dirPath);
-      expect(exists).toBe(false);
-    });
-
-    it('should return false for file path', async () => {
-      const filePath = path.join(testDir, 'file.txt');
-      await fs.writeFile(filePath, 'content');
-      
-      const exists = await FileSystemUtils.directoryExists(filePath);
-      expect(exists).toBe(false);
-    });
-  });
-
-  describe('canonicalizeExistingPath', () => {
-    it('should prefer the native realpath resolver when available', async () => {
-      const filePath = path.join(testDir, 'canonical.txt');
-      await fs.writeFile(filePath, 'content');
-
-      const nativeSpy = vi.spyOn(nodeFs.realpathSync, 'native');
-
-      const resolved = FileSystemUtils.canonicalizeExistingPath(filePath);
-
-      expect(nativeSpy).toHaveBeenCalledWith(filePath);
-      expect(resolved).toBe(nodeFs.realpathSync.native(filePath));
-
-      nativeSpy.mockRestore();
-    });
-  });
-
-  describe('writeFile', () => {
-    it('should write content to file', async () => {
-      const filePath = path.join(testDir, 'output.txt');
-      const content = 'Hello, World!';
-      
-      await FileSystemUtils.writeFile(filePath, content);
-      
-      const readContent = await fs.readFile(filePath, 'utf-8');
-      expect(readContent).toBe(content);
-    });
-
-    it('should create directory if it does not exist', async () => {
-      const filePath = path.join(testDir, 'nested', 'dir', 'output.txt');
-      const content = 'Nested content';
-      
-      await FileSystemUtils.writeFile(filePath, content);
-      
-      const readContent = await fs.readFile(filePath, 'utf-8');
-      expect(readContent).toBe(content);
-    });
-
-    it('should overwrite existing file', async () => {
-      const filePath = path.join(testDir, 'existing.txt');
-      await fs.writeFile(filePath, 'old content');
-      
-      const newContent = 'new content';
-      await FileSystemUtils.writeFile(filePath, newContent);
-      
-      const readContent = await fs.readFile(filePath, 'utf-8');
-      expect(readContent).toBe(newContent);
-    });
-  });
-
-  describe('readFile', () => {
-    it('should read file content', async () => {
-      const filePath = path.join(testDir, 'input.txt');
-      const content = 'Test content';
-      await fs.writeFile(filePath, content);
-      
-      const readContent = await FileSystemUtils.readFile(filePath);
-      expect(readContent).toBe(content);
-    });
-
-    it('should throw for non-existing file', async () => {
-      const filePath = path.join(testDir, 'non-existent.txt');
-      
-      await expect(FileSystemUtils.readFile(filePath)).rejects.toThrow();
-    });
-  });
-
-  describe('ensureWritePermissions', () => {
-    it('should return true for writable directory', async () => {
-      const hasPermission = await FileSystemUtils.ensureWritePermissions(testDir);
-      expect(hasPermission).toBe(true);
-    });
-
-    it('should return true for non-existing directory with writable parent', async () => {
-      const dirPath = path.join(testDir, 'new-dir');
-      const hasPermission = await FileSystemUtils.ensureWritePermissions(dirPath);
-      expect(hasPermission).toBe(true);
-    });
-
-    it('should handle deeply nested non-existing directories', async () => {
-      const dirPath = path.join(testDir, 'a', 'b', 'c', 'd');
-      const hasPermission = await FileSystemUtils.ensureWritePermissions(dirPath);
-      expect(hasPermission).toBe(true);
-    });
-  });
-
-  describe('canWriteFile', () => {
-    it('should return true for existing writable file', async () => {
-      const filePath = path.join(testDir, 'writable.txt');
-      await fs.writeFile(filePath, 'content');
-
-      const canWrite = await FileSystemUtils.canWriteFile(filePath);
-      expect(canWrite).toBe(true);
-    });
-
-    it('should return false for existing read-only file', async () => {
-      const filePath = path.join(testDir, 'readonly.txt');
-      await fs.writeFile(filePath, 'content');
-      await fs.chmod(filePath, 0o444); // Read-only
-
-      const canWrite = await FileSystemUtils.canWriteFile(filePath);
-      expect(canWrite).toBe(false);
-
-      // Cleanup: restore permissions so afterEach can delete
-      await fs.chmod(filePath, 0o644);
-    });
-
-    it('should return true for non-existent file in writable directory', async () => {
-      const filePath = path.join(testDir, 'new-file.txt');
-
-      const canWrite = await FileSystemUtils.canWriteFile(filePath);
-      expect(canWrite).toBe(true);
-    });
-
-    it('should return true for non-existent file in non-existent nested directories', async () => {
-      const filePath = path.join(testDir, 'deep', 'nested', 'path', 'file.txt');
-
-      const canWrite = await FileSystemUtils.canWriteFile(filePath);
-      expect(canWrite).toBe(true);
-    });
-
-    // Skip on Windows: fs.chmod() on directories doesn't restrict write access on Windows
-    // Windows uses ACLs which Node.js chmod doesn't control
-    it.skipIf(process.platform === 'win32')('should return false for non-existent file in read-only directory', async () => {
-      const readOnlyDir = path.join(testDir, 'readonly-dir');
-      await fs.mkdir(readOnlyDir);
-      await fs.chmod(readOnlyDir, 0o555); // Read-only + execute
-
-      const filePath = path.join(readOnlyDir, 'file.txt');
-      const canWrite = await FileSystemUtils.canWriteFile(filePath);
-      expect(canWrite).toBe(false);
-
-      // Cleanup
-      await fs.chmod(readOnlyDir, 0o755);
-    });
-
-    it('should return true when path points to existing directory', async () => {
-      const dirPath = path.join(testDir, 'some-dir');
-      await fs.mkdir(dirPath);
-
-      const canWrite = await FileSystemUtils.canWriteFile(dirPath);
-      expect(canWrite).toBe(true);
-    });
-
-    it('should traverse multiple non-existent parent directories', async () => {
-      const filePath = path.join(testDir, 'a', 'b', 'c', 'd', 'e', 'file.txt');
-
-      const canWrite = await FileSystemUtils.canWriteFile(filePath);
-      expect(canWrite).toBe(true);
-    });
-
-    it('should return false when intermediate path component is a file', async () => {
-      // Create a file where a directory should be
-      const fileInPath = path.join(testDir, 'blocking-file.txt');
-      await fs.writeFile(fileInPath, 'content');
-
-      // Try to check a path that goes "through" this file
-      const filePath = path.join(fileInPath, 'nested', 'file.txt');
-      const canWrite = await FileSystemUtils.canWriteFile(filePath);
-      expect(canWrite).toBe(false);
-    });
-
-    // Skip on Windows: creating symlinks requires elevated privileges or Developer Mode
-    it.skipIf(process.platform === 'win32')('should follow symbolic links to files', async () => {
-      const realFile = path.join(testDir, 'real-file.txt');
-      const linkFile = path.join(testDir, 'link-file.txt');
-      await fs.writeFile(realFile, 'content');
-      await fs.symlink(realFile, linkFile);
-
-      const canWrite = await FileSystemUtils.canWriteFile(linkFile);
-      expect(canWrite).toBe(true);
-    });
-
-    it('should handle platform-specific path separators', async () => {
-      const filePath = FileSystemUtils.joinPath(testDir, 'subdir', 'file.txt');
-      const canWrite = await FileSystemUtils.canWriteFile(filePath);
-      expect(canWrite).toBe(true);
-    });
-  });
-
-  describe('joinPath', () => {
-    it('should join POSIX-style paths', () => {
-      const result = FileSystemUtils.joinPath(
-        '/tmp/project',
-        '.claude/commands/openspec/proposal.md'
-      );
-      expect(result).toBe('/tmp/project/.claude/commands/openspec/proposal.md');
-    });
-
-    it('should join Linux home directory paths', () => {
-      const result = FileSystemUtils.joinPath(
-        '/home/dev/workspace/openspec',
-        '.cursor/commands/install.md'
-      );
-      expect(result).toBe('/home/dev/workspace/openspec/.cursor/commands/install.md');
-    });
-
-    it('should join Windows drive-letter paths with backslashes', () => {
-      const result = FileSystemUtils.joinPath(
-        'C:\\Users\\dev\\project',
-        '.claude/commands/openspec/proposal.md'
-      );
-      expect(result).toBe(
-        'C:\\Users\\dev\\project\\.claude\\commands\\openspec\\proposal.md'
-      );
-    });
-
-    it('should join Windows paths that use forward slashes', () => {
-      const result = FileSystemUtils.joinPath(
-        'D:/workspace/app',
-        '.cursor/commands/openspec-apply.md'
-      );
-      expect(result).toBe(
-        'D:\\workspace\\app\\.cursor\\commands\\openspec-apply.md'
-      );
-    });
-
-    it('should join UNC-style Windows paths', () => {
-      const result = FileSystemUtils.joinPath(
-        '\\server\\share\\repo',
-        '.windsurf/workflows/openspec-archive.md'
-      );
-      expect(result).toBe(
-        '\\server\\share\\repo\\.windsurf\\workflows\\openspec-archive.md'
-      );
-    });
-  });
-});