sauron-cli 1.2.0 → 1.3.0

package/OpenSpec-main/test/core/workspace/legacy-state.test.ts

@@ -0,0 +1,221 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import {
+  getWorkspaceMetadataDir,
+  getWorkspaceViewStatePath,
+  parseWorkspacePreferredOpenerValue,
+  parseWorkspaceViewState,
+  readWorkspaceViewState,
+  serializeWorkspaceViewState,
+  writeWorkspaceViewState,
+} from '../../../src/core/workspace/index.js';
+import {
+  WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME,
+  WORKSPACE_LEGACY_LOCAL_STATE_IGNORE_PATTERN,
+  WORKSPACE_LEGACY_SHARED_STATE_FILE_NAME,
+  getWorkspaceLegacyLocalStatePath,
+  getWorkspaceLegacySharedStatePath,
+  parseWorkspaceLocalState,
+  parseWorkspaceSharedState,
+  serializeWorkspaceLocalState,
+  workspaceStatePartsToViewState,
+  workspaceViewToLocalState,
+  workspaceViewToSharedState,
+} from '../../../src/core/workspace/legacy-state.js';
+
+describe('workspace legacy state compatibility', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-workspace-legacy-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  function createWorkspaceRoot(name = 'platform'): string {
+    const workspaceRoot = path.join(tempDir, name);
+    fs.mkdirSync(path.dirname(getWorkspaceViewStatePath(workspaceRoot)), { recursive: true });
+    fs.writeFileSync(
+      getWorkspaceViewStatePath(workspaceRoot),
+      `version: 1
+name: ${name}
+context: null
+links: {}
+`
+    );
+
+    return workspaceRoot;
+  }
+
+  it('keeps legacy file helpers isolated from canonical workspace helpers', () => {
+    const workspaceRoot = path.join(tempDir, 'platform');
+
+    expect(WORKSPACE_LEGACY_SHARED_STATE_FILE_NAME).toBe('workspace.yaml');
+    expect(WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME).toBe('local.yaml');
+    expect(WORKSPACE_LEGACY_LOCAL_STATE_IGNORE_PATTERN).toBe('.openspec-workspace/local.yaml');
+    expect(getWorkspaceLegacySharedStatePath(workspaceRoot)).toBe(
+      path.join(workspaceRoot, '.openspec-workspace', 'workspace.yaml')
+    );
+    expect(getWorkspaceLegacyLocalStatePath(workspaceRoot)).toBe(
+      path.join(workspaceRoot, '.openspec-workspace', 'local.yaml')
+    );
+    expect(getWorkspaceViewStatePath(workspaceRoot)).toBe(
+      path.join(workspaceRoot, '.openspec-workspace', 'view.yaml')
+    );
+    expect(getWorkspaceLegacyLocalStatePath('D:\\repos\\platform-workspace')).toBe(
+      'D:\\repos\\platform-workspace\\.openspec-workspace\\local.yaml'
+    );
+  });
+
+  it('parses and validates legacy shared state', () => {
+    const state = parseWorkspaceSharedState(`version: 1
+name: platform
+links:
+  api: {}
+  web:
+    note: planning only
+`);
+
+    expect(state).toEqual({
+      version: 1,
+      name: 'platform',
+      context: null,
+      links: {
+        api: {},
+        web: { note: 'planning only' },
+      },
+    });
+    expect(() => parseWorkspaceSharedState('version: 2\nname: platform\nlinks: {}\n')).toThrow(
+      /Invalid workspace shared state/
+    );
+    expect(() => parseWorkspaceSharedState('version: 1\nname: bad/name\nlinks: {}\n')).toThrow(
+      /Workspace name/
+    );
+    expect(() =>
+      parseWorkspaceSharedState('version: 1\nname: platform\nlinks:\n  bad/name: {}\n')
+    ).toThrow(/workspace link name/);
+    expect(() =>
+      parseWorkspaceSharedState('version: 1\nname: platform\nlinks:\n  api: nope\n')
+    ).toThrow(/Invalid workspace shared state/);
+  });
+
+  it('parses, serializes, and validates legacy local state', () => {
+    const state = parseWorkspaceLocalState(String.raw`version: 1
+paths:
+  windows: D:\repos\api
+  wsl: /mnt/d/repos/api
+  linux: /home/tabish/repos/api
+`);
+
+    expect(state.paths.windows).toBe('D:\\repos\\api');
+    expect(state.paths.wsl).toBe('/mnt/d/repos/api');
+    expect(state.paths.linux).toBe('/home/tabish/repos/api');
+
+    const codexState = parseWorkspaceLocalState(`version: 1
+paths:
+  api: /repo/api
+preferred_opener:
+  kind: agent
+  id: codex
+`);
+    expect(codexState.preferred_opener).toEqual({
+      kind: 'agent',
+      id: 'codex-cli',
+    });
+    expect(parseWorkspaceLocalState(serializeWorkspaceLocalState(codexState))).toEqual(
+      codexState
+    );
+    expect(parseWorkspacePreferredOpenerValue('editor')).toEqual({
+      kind: 'editor',
+      id: 'vscode',
+    });
+
+    expect(() => parseWorkspaceLocalState('version: 2\npaths: {}\n')).toThrow(
+      /Invalid workspace local state/
+    );
+    expect(() => parseWorkspaceLocalState('version: 1\npaths:\n  ../api: /repo\n')).toThrow(
+      /workspace local path name/
+    );
+    expect(() => parseWorkspaceLocalState('version: 1\npaths:\n  api: 42\n')).toThrow(
+      /Invalid workspace local state/
+    );
+    expect(() =>
+      parseWorkspaceLocalState(
+        'version: 1\npaths: {}\npreferred_opener:\n  kind: agent\n  id: editor\n'
+      )
+    ).toThrow(/Unsupported workspace opener/);
+  });
+
+  it('converts legacy state parts to and from canonical view state', async () => {
+    const workspaceRoot = path.join(tempDir, 'roundtrip');
+    const viewState = workspaceStatePartsToViewState(
+      {
+        version: 1,
+        name: 'roundtrip',
+        context: null,
+        links: {
+          api: {},
+          web: {},
+        },
+      },
+      {
+        version: 1,
+        paths: {
+          api: '/repos/api',
+        },
+      }
+    );
+
+    expect(viewState.links).toEqual({
+      api: '/repos/api',
+      web: null,
+    });
+    expect(parseWorkspaceViewState(serializeWorkspaceViewState(viewState))).toEqual(viewState);
+    expect(workspaceViewToSharedState(viewState).links).toEqual({
+      api: {},
+      web: {},
+    });
+    expect(workspaceViewToLocalState(viewState).paths).toEqual({
+      api: '/repos/api',
+    });
+
+    await writeWorkspaceViewState(workspaceRoot, viewState);
+    await expect(readWorkspaceViewState(workspaceRoot)).resolves.toEqual(viewState);
+  });
+
+  it('reads legacy split state through the canonical view-state reader', async () => {
+    const workspaceRoot = createWorkspaceRoot();
+    fs.rmSync(getWorkspaceViewStatePath(workspaceRoot));
+    fs.mkdirSync(getWorkspaceMetadataDir(workspaceRoot), { recursive: true });
+    fs.writeFileSync(
+      getWorkspaceLegacySharedStatePath(workspaceRoot),
+      `version: 1
+name: platform
+context: null
+links:
+  api: {}
+`
+    );
+    fs.writeFileSync(
+      getWorkspaceLegacyLocalStatePath(workspaceRoot),
+      `version: 1
+paths:
+  api: /repos/api
+`
+    );
+
+    await expect(readWorkspaceViewState(workspaceRoot)).resolves.toEqual({
+      version: 1,
+      name: 'platform',
+      context: null,
+      links: {
+        api: '/repos/api',
+      },
+    });
+  });
+});

package/OpenSpec-main/test/core/workspace/skills.test.ts

@@ -0,0 +1,69 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { describe, expect, it } from 'vitest';
+
+import {
+  getWorkspaceSkillDirectory,
+  getWorkspaceSkillToolIds,
+  hasWorkspaceSkillProfileDrift,
+  parseWorkspaceSkillToolsValue,
+} from '../../../src/core/workspace/skills.js';
+import { CORE_WORKFLOWS } from '../../../src/core/profiles.js';
+
+function withDefaultGlobalConfig<T>(callback: () => T): T {
+  const previousConfigHome = process.env.XDG_CONFIG_HOME;
+  const configHome = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-workspace-skills-'));
+
+  process.env.XDG_CONFIG_HOME = configHome;
+
+  try {
+    return callback();
+  } finally {
+    if (previousConfigHome === undefined) {
+      delete process.env.XDG_CONFIG_HOME;
+    } else {
+      process.env.XDG_CONFIG_HOME = previousConfigHome;
+    }
+    fs.rmSync(configHome, { recursive: true, force: true });
+  }
+}
+
+describe('workspace skill helpers', () => {
+  it('parses workspace --tools values using the skill-capable tool set', () => {
+    expect(parseWorkspaceSkillToolsValue('all')).toEqual(getWorkspaceSkillToolIds());
+    expect(parseWorkspaceSkillToolsValue('none')).toEqual([]);
+    expect(parseWorkspaceSkillToolsValue('Codex, claude,codex')).toEqual(['codex', 'claude']);
+  });
+
+  it('rejects invalid or mixed workspace --tools values', () => {
+    expect(() => parseWorkspaceSkillToolsValue('')).toThrow(/requires a value/);
+    expect(() => parseWorkspaceSkillToolsValue('all,codex')).toThrow(/Cannot combine/);
+    expect(() => parseWorkspaceSkillToolsValue('codex,missing')).toThrow(/missing/);
+  });
+
+  it('builds workspace-root skill paths with the workspace path style', () => {
+    expect(getWorkspaceSkillDirectory('/repos/platform-workspace', 'codex')).toBe(
+      '/repos/platform-workspace/.codex/skills'
+    );
+    expect(getWorkspaceSkillDirectory('D:\\repos\\platform-workspace', 'codex')).toBe(
+      'D:\\repos\\platform-workspace\\.codex\\skills'
+    );
+  });
+
+  it('does not report profile drift when workflow IDs match in a different order', () => {
+    withDefaultGlobalConfig(() => {
+      expect(
+        hasWorkspaceSkillProfileDrift({
+          workspace_skills: {
+            selected_agents: ['codex'],
+            last_applied_profile: 'core',
+            last_applied_delivery: 'both',
+            last_applied_workflow_ids: [...CORE_WORKFLOWS].reverse(),
+          },
+        })
+      ).toBe(false);
+    });
+  });
+});

package/OpenSpec-main/test/fixtures/tmp-init/openspec/changes/c1/proposal.md

@@ -0,0 +1,7 @@
+# Test Change
+
+## Why
+Because reasons that are sufficiently long for validation.
+
+## What Changes
+- **alpha:** Add something

package/OpenSpec-main/test/fixtures/tmp-init/openspec/changes/c1/specs/alpha/spec.md

@@ -0,0 +1,8 @@
+## ADDED Requirements
+### Requirement: Parser SHALL accept CRLF change proposals
+The parser SHALL accept CRLF change proposals without manual edits.
+
+#### Scenario: Validate CRLF change
+- **GIVEN** a change proposal saved with CRLF line endings
+- **WHEN** a developer runs openspec validate on the proposal
+- **THEN** validation succeeds without section errors

package/OpenSpec-main/test/fixtures/tmp-init/openspec/specs/alpha/spec.md

@@ -0,0 +1,12 @@
+## Purpose
+This spec ensures the validation harness exercises a deterministic alpha module for automated tests.
+
+## Requirements
+
+### Requirement: Alpha module SHALL produce deterministic output
+The alpha module SHALL produce a deterministic response for validation.
+
+#### Scenario: Deterministic alpha run
+- **GIVEN** a configured alpha module
+- **WHEN** the module runs the default flow
+- **THEN** the output matches the expected fixture result

package/OpenSpec-main/test/helpers/path-env.ts

@@ -0,0 +1,26 @@
+import * as path from 'node:path';
+
+export function pathEnvKey(env: NodeJS.ProcessEnv = process.env): string {
+  return Object.keys(env).find((key) => key.toLowerCase() === 'path') ?? 'PATH';
+}
+
+export function setProcessPathEnv(value: string): void {
+  process.env[pathEnvKey()] = value;
+}
+
+export function prependProcessPathEnv(dir: string): void {
+  const key = pathEnvKey();
+  process.env[key] = prependPathValue(dir, process.env[key]);
+}
+
+export function withPrependedPathEnv(baseEnv: NodeJS.ProcessEnv, dir: string): NodeJS.ProcessEnv {
+  const key = pathEnvKey({ ...process.env, ...baseEnv });
+  return {
+    ...baseEnv,
+    [key]: prependPathValue(dir, baseEnv[key] ?? process.env[key]),
+  };
+}
+
+function prependPathValue(dir: string, currentPath: string | undefined): string {
+  return currentPath ? `${dir}${path.delimiter}${currentPath}` : dir;
+}

package/OpenSpec-main/test/helpers/run-cli.ts

@@ -0,0 +1,150 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const projectRoot = path.resolve(__dirname, '..', '..');
+const cliEntry = path.join(projectRoot, 'dist', 'cli', 'index.js');
+
+let buildPromise: Promise<void> | undefined;
+
+interface RunCommandOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+interface RunCLIOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  input?: string;
+  timeoutMs?: number;
+}
+
+export interface RunCLIResult {
+  exitCode: number | null;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+  timedOut: boolean;
+  command: string;
+}
+
+function runCommand(command: string, args: string[], options: RunCommandOptions = {}) {
+  return new Promise<void>((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd ?? projectRoot,
+      env: { ...process.env, ...options.env },
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+    });
+
+    child.on('error', (error) => reject(error));
+    child.on('close', (code, signal) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        const reason = signal ? `signal ${signal}` : `exit code ${code}`;
+        reject(new Error(`Command failed (${reason}): ${command} ${args.join(' ')}`));
+      }
+    });
+  });
+}
+
+export async function ensureCliBuilt() {
+  if (existsSync(cliEntry)) {
+    return;
+  }
+
+  if (!buildPromise) {
+    buildPromise = runCommand('pnpm', ['run', 'build']).catch((error) => {
+      buildPromise = undefined;
+      throw error;
+    });
+  }
+
+  await buildPromise;
+
+  if (!existsSync(cliEntry)) {
+    throw new Error('CLI entry point missing after build. Expected dist/cli/index.js');
+  }
+}
+
+export async function runCLI(args: string[] = [], options: RunCLIOptions = {}): Promise<RunCLIResult> {
+  await ensureCliBuilt();
+
+  const finalArgs = Array.isArray(args) ? args : [args];
+  const invocation = [cliEntry, ...finalArgs].join(' ');
+
+  return new Promise<RunCLIResult>((resolve, reject) => {
+    const child = spawn(process.execPath, [cliEntry, ...finalArgs], {
+      cwd: options.cwd ?? projectRoot,
+      env: {
+        ...process.env,
+        OPEN_SPEC_INTERACTIVE: '0',
+        ...options.env,
+      },
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+
+    // Prevent child process from keeping the event loop alive
+    child.unref();
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+
+    const timeout = options.timeoutMs
+      ? setTimeout(() => {
+          timedOut = true;
+          child.kill('SIGKILL');
+        }, options.timeoutMs)
+      : undefined;
+
+    child.stdout?.setEncoding('utf-8');
+    child.stdout?.on('data', (chunk) => {
+      stdout += chunk;
+    });
+
+    child.stderr?.setEncoding('utf-8');
+    child.stderr?.on('data', (chunk) => {
+      stderr += chunk;
+    });
+
+    child.on('error', (error) => {
+      if (timeout) clearTimeout(timeout);
+      // Explicitly destroy streams to prevent hanging handles
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      child.stdin?.destroy();
+      reject(error);
+    });
+
+    child.on('close', (code, signal) => {
+      if (timeout) clearTimeout(timeout);
+      // Explicitly destroy streams to prevent hanging handles
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      child.stdin?.destroy();
+      resolve({
+        exitCode: code,
+        signal,
+        stdout,
+        stderr,
+        timedOut,
+        command: `node ${invocation}`,
+      });
+    });
+
+    if (options.input && child.stdin) {
+      child.stdin.end(options.input);
+    } else if (child.stdin) {
+      child.stdin.end();
+    }
+  });
+}
+
+export const cliProjectRoot = projectRoot;