sauron-cli 1.3.0 → 1.4.0

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

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

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

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

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

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

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

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