sauron-cli 1.2.0 → 1.3.0

package/OpenSpec-main/test/core/parsers/markdown-parser.test.ts

@@ -0,0 +1,355 @@
+import { describe, it, expect } from 'vitest';
+import { MarkdownParser } from '../../../src/core/parsers/markdown-parser.js';
+
+describe('MarkdownParser', () => {
+  describe('parseSpec', () => {
+    it('should parse a valid spec', () => {
+      const content = `# 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
+
+### The system SHALL handle invalid login attempts
+The system must handle incorrect credentials.
+
+#### Scenario: Invalid credentials
+Given a user with invalid credentials
+When they submit the login form
+Then they see an error message`;
+
+      const parser = new MarkdownParser(content);
+      const spec = parser.parseSpec('user-auth');
+      
+      expect(spec.name).toBe('user-auth');
+      expect(spec.overview).toContain('requirements for user authentication');
+      expect(spec.requirements).toHaveLength(2);
+      
+      const firstReq = spec.requirements[0];
+      expect(firstReq.text).toBe('Users need to be able to log in securely.');
+      expect(firstReq.scenarios).toHaveLength(1);
+      
+      const scenario = firstReq.scenarios[0];
+      expect(scenario.rawText).toContain('Given a user with valid credentials');
+      expect(scenario.rawText).toContain('When they submit the login form');
+      expect(scenario.rawText).toContain('Then they are authenticated');
+    });
+
+    it('should handle multi-line scenarios', () => {
+      const content = `# Test Spec
+
+## Purpose
+Test overview
+
+## Requirements
+
+### The system SHALL handle complex scenarios
+This requirement has content.
+
+#### Scenario: Multi-line scenario
+Given a user with valid credentials
+  and the user has admin privileges
+  and the system is in maintenance mode
+When they attempt to login
+  and provide their MFA token
+Then they are authenticated
+  and redirected to admin dashboard
+  and see a maintenance warning`;
+
+      const parser = new MarkdownParser(content);
+      const spec = parser.parseSpec('test');
+      
+      const scenario = spec.requirements[0].scenarios[0];
+      expect(scenario.rawText).toContain('Given a user with valid credentials');
+      expect(scenario.rawText).toContain('and the user has admin privileges');
+      expect(scenario.rawText).toContain('When they attempt to login');
+      expect(scenario.rawText).toContain('and provide their MFA token');
+      expect(scenario.rawText).toContain('Then they are authenticated');
+      expect(scenario.rawText).toContain('and see a maintenance warning');
+    });
+
+    it('should throw error for missing overview', () => {
+      const content = `# Test Spec
+
+## Requirements
+
+### The system SHALL do something
+
+#### Scenario: Test
+Given test
+When action
+Then result`;
+
+      const parser = new MarkdownParser(content);
+      expect(() => parser.parseSpec('test')).toThrow('must have a Purpose section');
+    });
+
+    it('should throw error for missing requirements', () => {
+      const content = `# Test Spec
+
+## Purpose
+This is a test spec`;
+
+      const parser = new MarkdownParser(content);
+      expect(() => parser.parseSpec('test')).toThrow('must have a Requirements section');
+    });
+
+    it('should ignore headings that appear inside fenced code blocks', () => {
+      const content = `# Test Spec
+
+## Purpose
+This spec documents delta syntax with a fenced example.
+
+## Requirements
+
+### Requirement: Explain delta syntax
+The system SHALL allow quoted markdown examples without changing parsed structure.
+
+\`\`\`markdown
+## ADDED Requirements
+
+### Requirement: Example
+The system SHALL ...
+\`\`\`
+
+#### Scenario: reader follows the example
+- **WHEN** a reader reviews the documentation
+- **THEN** the fenced heading stays part of the example`;
+
+      const parser = new MarkdownParser(content);
+      const spec = parser.parseSpec('test');
+
+      expect(spec.requirements).toHaveLength(1);
+      expect(spec.requirements[0].text).toBe(
+        'The system SHALL allow quoted markdown examples without changing parsed structure.'
+      );
+      expect(spec.requirements[0].scenarios).toHaveLength(1);
+      expect(spec.requirements[0].scenarios[0].rawText).toContain('- **WHEN** a reader reviews the documentation');
+    });
+
+    it('should not treat fence-like lines with trailing content as closing fences', () => {
+      const content = `# Test Spec
+
+## Purpose
+This spec includes a fence-like line with trailing content inside a fenced block.
+
+## Requirements
+
+### Requirement: Explain fence parsing
+The system SHALL keep fenced examples isolated until a real closing fence appears.
+
+\`\`\`markdown
+\`\`\` still inside the example
+## ADDED Requirements
+
+### Requirement: Example
+The system SHALL remain part of the example.
+\`\`\`
+
+#### Scenario: reader follows the example
+- **WHEN** a reader reviews the documentation
+- **THEN** the parser ignores headings until the real closing fence`;
+
+      const parser = new MarkdownParser(content);
+      const spec = parser.parseSpec('test');
+
+      expect(spec.requirements).toHaveLength(1);
+      expect(spec.requirements[0].scenarios).toHaveLength(1);
+      expect(spec.requirements[0].scenarios[0].rawText).toContain('parser ignores headings until the real closing fence');
+    });
+  });
+
+  describe('parseChange', () => {
+    it('should parse a valid change', () => {
+      const content = `# 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
+- **database:** Remove old session management tables`;
+
+      const parser = new MarkdownParser(content);
+      const change = parser.parseChange('add-user-auth');
+      
+      expect(change.name).toBe('add-user-auth');
+      expect(change.why).toContain('secure the application');
+      expect(change.whatChanges).toContain('user-auth');
+      expect(change.deltas).toHaveLength(3);
+      
+      expect(change.deltas[0].spec).toBe('user-auth');
+      expect(change.deltas[0].operation).toBe('ADDED');
+      expect(change.deltas[0].description).toContain('Add new user authentication');
+      
+      expect(change.deltas[1].spec).toBe('api-endpoints');
+      expect(change.deltas[1].operation).toBe('MODIFIED');
+      
+      expect(change.deltas[2].spec).toBe('database');
+      expect(change.deltas[2].operation).toBe('REMOVED');
+    });
+
+    it('should throw error for missing why section', () => {
+      const content = `# Test Change
+
+## What Changes
+- **test:** Add test`;
+
+      const parser = new MarkdownParser(content);
+      expect(() => parser.parseChange('test')).toThrow('must have a Why section');
+    });
+
+    it('should throw error for missing what changes section', () => {
+      const content = `# Test Change
+
+## Why
+Because we need it`;
+
+      const parser = new MarkdownParser(content);
+      expect(() => parser.parseChange('test')).toThrow('must have a What Changes section');
+    });
+
+    it('should handle changes without deltas', () => {
+      const content = `# Test Change
+
+## Why
+We need to make some changes for important reasons that justify this work.
+
+## What Changes
+Some general description of changes without specific deltas`;
+
+      const parser = new MarkdownParser(content);
+      const change = parser.parseChange('test');
+      
+      expect(change.deltas).toHaveLength(0);
+    });
+
+    it('parses change documents saved with CRLF line endings', () => {
+      const crlfContent = [
+        '# CRLF Change',
+        '',
+        '## Why',
+        'Reasons on Windows editors should parse like POSIX environments.',
+        '',
+        '## What Changes',
+        '- **alpha:** Add cross-platform parsing coverage',
+      ].join('\r\n');
+
+      const parser = new MarkdownParser(crlfContent);
+      const change = parser.parseChange('crlf-change');
+
+      expect(change.why).toContain('Windows editors should parse');
+      expect(change.deltas).toHaveLength(1);
+      expect(change.deltas[0].spec).toBe('alpha');
+    });
+  });
+
+  describe('section parsing', () => {
+    it('should handle nested sections correctly', () => {
+      const content = `# Test Spec
+
+## Purpose
+This is the overview section for testing nested sections.
+
+## Requirements
+
+### The system SHALL handle nested sections
+
+#### Scenario: Test nested
+Given a nested structure
+When parsing sections
+Then handle correctly
+
+### Another requirement SHALL work
+
+#### Scenario: Another test
+Given another test
+When running
+Then success`;
+
+      const parser = new MarkdownParser(content);
+      const spec = parser.parseSpec('test');
+      
+      // Should find the correct sections at different levels
+      expect(spec).toBeDefined();
+      expect(spec.overview).toContain('testing nested sections');
+      expect(spec.requirements).toHaveLength(2);
+    });
+
+    it('should preserve content between headers', () => {
+      const content = `# Test
+
+## Purpose
+This is the overview.
+It has multiple lines.
+
+Some more content here.
+
+## Requirements
+
+### Requirement 1
+Content for requirement 1`;
+
+      const parser = new MarkdownParser(content);
+      const spec = parser.parseSpec('test');
+      
+      expect(spec.overview).toContain('multiple lines');
+      expect(spec.overview).toContain('more content');
+    });
+
+    it('should use requirement heading as fallback when no content is provided', () => {
+      const content = `# Test Spec
+
+## Purpose
+Test overview
+
+## Requirements
+
+### The system SHALL use heading text when no content
+
+#### Scenario: Test
+Given test
+When action
+Then result`;
+
+      const parser = new MarkdownParser(content);
+      const spec = parser.parseSpec('test');
+      
+      expect(spec.requirements[0].text).toBe('The system SHALL use heading text when no content');
+    });
+
+    it('should extract requirement text from first non-empty content line', () => {
+      const content = `# Test Spec
+
+## Purpose
+Test overview
+
+## Requirements
+
+### Requirement heading
+
+This is the actual requirement text.
+This is additional description.
+
+#### Scenario: Test
+Given test
+When action
+Then result`;
+
+      const parser = new MarkdownParser(content);
+      const spec = parser.parseSpec('test');
+      
+      expect(spec.requirements[0].text).toBe('This is the actual requirement text.');
+    });
+  });
+});

package/OpenSpec-main/test/core/parsers/requirement-blocks.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { extractRequirementsSection, parseDeltaSpec } from '../../../src/core/parsers/requirement-blocks.js';
+
+describe('extractRequirementsSection', () => {
+  it('parses canonical ### Requirement: headers', () => {
+    const result = extractRequirementsSection(`## Requirements\n### Requirement: Foo\nThe system SHALL foo.\n`);
+    expect(result.bodyBlocks.length).toBe(1);
+    expect(result.bodyBlocks[0].name).toBe('Foo');
+  });
+
+  it('regression: parses mixed-case ### requirement: headers without silently dropping them', () => {
+    const variants = [
+      '### requirement: Lowercase',
+      '### REQUIREMENT: Uppercase',
+      '### Requirement: Canonical',
+    ];
+    for (const header of variants) {
+      const result = extractRequirementsSection(`## Requirements\n${header}\nThe system SHALL foo.\n`);
+      expect(result.bodyBlocks.length).toBeGreaterThan(0);
+      expect(result.bodyBlocks[0].name).toBe(header.replace(/^###\s*requirement:\s*/i, ''));
+    }
+  });
+
+  it('regression: parses ###Requirement: header with no space after ### without silently dropping it', () => {
+    const result = extractRequirementsSection(`## Requirements\n###Requirement: NoSpace\nThe system SHALL foo.\n`);
+    expect(result.bodyBlocks.length).toBe(1);
+    expect(result.bodyBlocks[0].name).toBe('NoSpace');
+  });
+
+  it('regression: multiple blocks where first uses no-space header are all parsed', () => {
+    const content = `## Requirements\n###Requirement: First\nThe system SHALL first.\n\n### Requirement: Second\nThe system SHALL second.\n`;
+    const result = extractRequirementsSection(content);
+    expect(result.bodyBlocks.length).toBe(2);
+    expect(result.bodyBlocks[0].name).toBe('First');
+    expect(result.bodyBlocks[1].name).toBe('Second');
+  });
+});
+
+describe('parseDeltaSpec', () => {
+  it('regression: parses ###Requirement: header with no space in delta ADDED section', () => {
+    const content = `## ADDED Requirements\n###Requirement: NoSpace\nThe system SHALL foo.\n`;
+    const result = parseDeltaSpec(content);
+    expect(result.added.length).toBe(1);
+    expect(result.added[0].name).toBe('NoSpace');
+  });
+});

package/OpenSpec-main/test/core/planning-home.test.ts

@@ -0,0 +1,120 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import {
+  type PlanningHome,
+  formatChangeLocation,
+  getChangeDir,
+  resolveCurrentPlanningHomeSync,
+} from '../../src/core/planning-home.js';
+
+describe('planning home paths', () => {
+  const tempDirs: string[] = [];
+
+  afterEach(() => {
+    for (const tempDir of tempDirs.splice(0)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('builds workspace change paths with the planning home path style', () => {
+    const workspacePlanningHome: PlanningHome = {
+      kind: 'workspace',
+      root: 'D:\\repos\\platform-workspace',
+      changesDir: 'D:\\repos\\platform-workspace\\changes',
+      defaultSchema: 'workspace-planning',
+      workspace: {
+        name: 'platform',
+        links: ['api', 'web'],
+      },
+    };
+
+    expect(getChangeDir(workspacePlanningHome, 'cross-repo-login')).toBe(
+      'D:\\repos\\platform-workspace\\changes\\cross-repo-login'
+    );
+    expect(formatChangeLocation(workspacePlanningHome, 'cross-repo-login')).toBe(
+      'changes\\cross-repo-login'
+    );
+  });
+
+  it('keeps a canonical workspace root comparable with an aliased start path', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-planning-home-'));
+    tempDirs.push(tempDir);
+    const realWorkspaceRoot = path.join(tempDir, 'real-workspace');
+    const aliasWorkspaceRoot = path.join(tempDir, 'alias-workspace');
+
+    fs.mkdirSync(path.join(realWorkspaceRoot, '.openspec-workspace'), { recursive: true });
+    fs.writeFileSync(
+      path.join(realWorkspaceRoot, '.openspec-workspace', 'view.yaml'),
+      'version: 1\nname: platform\ncontext: null\nlinks: {}\n',
+      'utf-8'
+    );
+    fs.symlinkSync(
+      realWorkspaceRoot,
+      aliasWorkspaceRoot,
+      process.platform === 'win32' ? 'junction' : 'dir'
+    );
+
+    const planningHome = resolveCurrentPlanningHomeSync({
+      startPath: aliasWorkspaceRoot,
+      allowImplicitRepoRoot: false,
+    });
+
+    expect(planningHome.kind).toBe('workspace');
+    expect(planningHome.root).toBe(fs.realpathSync.native(realWorkspaceRoot));
+  });
+
+  it('surfaces invalid current workspace state instead of falling back to legacy state', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-planning-home-'));
+    tempDirs.push(tempDir);
+    const workspaceRoot = path.join(tempDir, 'workspace');
+
+    fs.mkdirSync(path.join(workspaceRoot, '.openspec-workspace'), { recursive: true });
+    fs.writeFileSync(
+      path.join(workspaceRoot, '.openspec-workspace', 'view.yaml'),
+      'version: 1\nname: bad/name\ncontext: null\nlinks: {}\n',
+      'utf-8'
+    );
+    fs.writeFileSync(
+      path.join(workspaceRoot, '.openspec-workspace', 'workspace.yaml'),
+      'version: 1\nname: legacy-platform\nlinks: {}\n',
+      'utf-8'
+    );
+
+    expect(() =>
+      resolveCurrentPlanningHomeSync({
+        startPath: workspaceRoot,
+        allowImplicitRepoRoot: false,
+      })
+    ).toThrow(/Workspace name/u);
+  });
+
+  it('resolves repo-local projects with foreign workspace.yaml as repo planning homes', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-planning-home-'));
+    tempDirs.push(tempDir);
+    const repoRoot = path.join(tempDir, 'foreign-tool-repo');
+    const changesDir = path.join(repoRoot, 'openspec', 'changes');
+
+    fs.mkdirSync(changesDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(repoRoot, 'workspace.yaml'),
+      `tool_workspace:
+  projects:
+    - name: example
+      path: ./service
+`,
+      'utf-8'
+    );
+
+    const planningHome = resolveCurrentPlanningHomeSync({
+      startPath: changesDir,
+      allowImplicitRepoRoot: false,
+    });
+
+    expect(planningHome.kind).toBe('repo');
+    expect(planningHome.root).toBe(fs.realpathSync.native(repoRoot));
+  });
+});

package/OpenSpec-main/test/core/profile-sync-drift.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  hasProjectConfigDrift,
+  WORKFLOW_TO_SKILL_DIR,
+} from '../../src/core/profile-sync-drift.js';
+import { CORE_WORKFLOWS } from '../../src/core/profiles.js';
+import { CommandAdapterRegistry } from '../../src/core/command-generation/index.js';
+
+function writeSkill(projectDir: string, workflowId: string): void {
+  const skillDirName = WORKFLOW_TO_SKILL_DIR[workflowId as keyof typeof WORKFLOW_TO_SKILL_DIR];
+  const skillPath = path.join(projectDir, '.claude', 'skills', skillDirName, 'SKILL.md');
+  fs.mkdirSync(path.dirname(skillPath), { recursive: true });
+  fs.writeFileSync(skillPath, `name: ${skillDirName}\n`);
+}
+
+function writeCommand(projectDir: string, workflowId: string): void {
+  const adapter = CommandAdapterRegistry.get('claude');
+  if (!adapter) throw new Error('Claude adapter unavailable in test environment');
+  const cmdPath = adapter.getFilePath(workflowId);
+  const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectDir, cmdPath);
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, `# ${workflowId}\n`);
+}
+
+function setupCoreSkills(projectDir: string): void {
+  for (const workflow of CORE_WORKFLOWS) {
+    writeSkill(projectDir, workflow);
+  }
+}
+
+function setupCoreCommands(projectDir: string): void {
+  for (const workflow of CORE_WORKFLOWS) {
+    writeCommand(projectDir, workflow);
+  }
+}
+
+describe('profile sync drift detection', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = path.join(os.tmpdir(), `openspec-profile-sync-drift-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    fs.mkdirSync(path.join(tempDir, 'openspec'), { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('detects drift for skills-only delivery when commands still exist', () => {
+    setupCoreSkills(tempDir);
+    setupCoreCommands(tempDir);
+
+    const hasDrift = hasProjectConfigDrift(tempDir, CORE_WORKFLOWS, 'skills');
+    expect(hasDrift).toBe(true);
+  });
+
+  it('detects drift for commands-only delivery when skills still exist', () => {
+    setupCoreCommands(tempDir);
+    setupCoreSkills(tempDir);
+
+    const hasDrift = hasProjectConfigDrift(tempDir, CORE_WORKFLOWS, 'commands');
+    expect(hasDrift).toBe(true);
+  });
+
+  it('detects drift when required profile workflow files are missing', () => {
+    writeSkill(tempDir, 'explore');
+
+    const hasDrift = hasProjectConfigDrift(tempDir, CORE_WORKFLOWS, 'both');
+    expect(hasDrift).toBe(true);
+  });
+
+  it('returns false when project files match core profile and delivery', () => {
+    setupCoreSkills(tempDir);
+    setupCoreCommands(tempDir);
+
+    const hasDrift = hasProjectConfigDrift(tempDir, CORE_WORKFLOWS, 'both');
+    expect(hasDrift).toBe(false);
+  });
+
+  it('detects drift when extra workflows are installed for both delivery', () => {
+    setupCoreSkills(tempDir);
+    setupCoreCommands(tempDir);
+    writeSkill(tempDir, 'new');
+    writeCommand(tempDir, 'new');
+
+    const hasDrift = hasProjectConfigDrift(tempDir, CORE_WORKFLOWS, 'both');
+    expect(hasDrift).toBe(true);
+  });
+});

package/OpenSpec-main/test/core/profiles.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+
+import {
+  CORE_WORKFLOWS,
+  ALL_WORKFLOWS,
+  getProfileWorkflows,
+} from '../../src/core/profiles.js';
+
+describe('profiles', () => {
+  describe('CORE_WORKFLOWS', () => {
+    it('should contain the default core workflows', () => {
+      expect(CORE_WORKFLOWS).toEqual(['propose', 'explore', 'apply', 'sync', 'archive']);
+    });
+
+    it('should be a subset of ALL_WORKFLOWS', () => {
+      for (const workflow of CORE_WORKFLOWS) {
+        expect(ALL_WORKFLOWS).toContain(workflow);
+      }
+    });
+  });
+
+  describe('ALL_WORKFLOWS', () => {
+    it('should contain all 11 workflows', () => {
+      expect(ALL_WORKFLOWS).toHaveLength(11);
+    });
+
+    it('should contain expected workflow IDs', () => {
+      const expected = [
+        'propose', 'explore', 'new', 'continue', 'apply',
+        'ff', 'sync', 'archive', 'bulk-archive', 'verify', 'onboard',
+      ];
+      expect([...ALL_WORKFLOWS]).toEqual(expected);
+    });
+  });
+
+  describe('getProfileWorkflows', () => {
+    it('should return core workflows for core profile', () => {
+      const result = getProfileWorkflows('core');
+      expect(result).toEqual(CORE_WORKFLOWS);
+    });
+
+    it('should return core workflows for core profile even if customWorkflows provided', () => {
+      const result = getProfileWorkflows('core', ['new', 'apply']);
+      expect(result).toEqual(CORE_WORKFLOWS);
+    });
+
+    it('should return custom workflows for custom profile', () => {
+      const customWorkflows = ['explore', 'new', 'apply', 'ff'];
+      const result = getProfileWorkflows('custom', customWorkflows);
+      expect(result).toEqual(customWorkflows);
+    });
+
+    it('should return empty array for custom profile with no customWorkflows', () => {
+      const result = getProfileWorkflows('custom');
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty array for custom profile with empty customWorkflows', () => {
+      const result = getProfileWorkflows('custom', []);
+      expect(result).toEqual([]);
+    });
+  });
+});