sauron-cli 1.1.3 → 1.3.0

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

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

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

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