sauron-cli 1.3.0 → 1.4.0

package/OpenSpec-main/test/prompts/searchable-multi-select.test.ts

@@ -1,220 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-/**
- * Tests for searchable-multi-select keybinding behavior.
- *
- * We mock @inquirer/core to intercept the prompt's render function and
- * keypress handler, then simulate key events to verify:
- *   - Space toggles selection (add/remove)
- *   - Enter confirms and submits
- *   - Tab does NOT confirm (removed)
- *   - Hint text is updated
- */
-
-// State store for the mock hook system
-const state: Record<number, unknown> = {};
-let stateIndex = 0;
-let keypressHandler: ((key: Record<string, unknown>) => void) | null = null;
-let renderOutput = '';
-
-function resetState() {
-  for (const k of Object.keys(state)) delete state[k as unknown as number];
-  stateIndex = 0;
-  keypressHandler = null;
-  renderOutput = '';
-  currentRenderFn = null;
-  currentConfig = null;
-  currentDone = null;
-}
-
-// Re-render: reset hook index, re-invoke the render function
-let currentRenderFn: ((config: Record<string, unknown>, done: (v: string[]) => void) => string) | null = null;
-let currentConfig: Record<string, unknown> | null = null;
-let currentDone: ((v: string[]) => void) | null = null;
-
-function rerender() {
-  if (!currentRenderFn || !currentConfig || !currentDone) return;
-  stateIndex = 0;
-  renderOutput = currentRenderFn(currentConfig, currentDone);
-}
-
-vi.mock('@inquirer/core', () => {
-  return {
-    createPrompt: (fn: (config: Record<string, unknown>, done: (v: string[]) => void) => string) => {
-      currentRenderFn = fn;
-      return (config: Record<string, unknown>) => {
-        return new Promise<string[]>((resolve) => {
-          currentConfig = config;
-          currentDone = resolve;
-          stateIndex = 0;
-          renderOutput = fn(config, resolve);
-        });
-      };
-    },
-    useState: (initial: unknown) => {
-      const idx = stateIndex++;
-      if (!(idx in state)) {
-        state[idx] = typeof initial === 'function' ? (initial as () => unknown)() : initial;
-      }
-      const setter = (value: unknown) => {
-        state[idx] = value;
-        // Re-render after state change
-        rerender();
-      };
-      return [state[idx], setter];
-    },
-    useKeypress: (handler: (key: Record<string, unknown>) => void) => {
-      keypressHandler = handler;
-    },
-    useMemo: (fn: () => unknown, _deps: unknown[]) => fn(),
-    usePrefix: () => '?',
-    isEnterKey: (key: Record<string, unknown>) => key.name === 'return' || key.name === 'enter',
-    isBackspaceKey: (key: Record<string, unknown>) => key.name === 'backspace',
-    isUpKey: (key: Record<string, unknown>) => key.name === 'up',
-    isDownKey: (key: Record<string, unknown>) => key.name === 'down',
-  };
-});
-
-function pressKey(name: string) {
-  if (!keypressHandler) throw new Error('No keypress handler registered');
-  keypressHandler({ name, ctrl: false });
-}
-
-function getSelectedValues(): string[] {
-  return (state[1] as string[]) ?? [];
-}
-
-function getStatus(): string {
-  return (state[3] as string) ?? 'idle';
-}
-
-function getError(): string | null {
-  return (state[4] as string | null) ?? null;
-}
-
-const testChoices = [
-  { name: 'Tool A', value: 'tool-a' },
-  { name: 'Tool B', value: 'tool-b' },
-  { name: 'Tool C', value: 'tool-c' },
-];
-
-async function setup(choices = testChoices, validate?: (selected: string[]) => boolean | string) {
-  resetState();
-
-  const mod = await import('../../src/prompts/searchable-multi-select.js');
-
-  // Fire and forget - the promise resolves only when done() is called via Enter
-  // We just need the side effect of registering the keypress handler
-  mod.searchableMultiSelect({
-    message: 'Select tools',
-    choices,
-    validate,
-  });
-
-  // The async chain in searchableMultiSelect involves:
-  //   1. await createSearchableMultiSelect() -> await import('@inquirer/core')
-  //   2. prompt(config) which registers the keypress handler synchronously
-  // Flush enough microtask ticks for the full chain to settle.
-  await vi.waitFor(() => {
-    if (!keypressHandler) throw new Error('Keypress handler not yet registered');
-  }, { timeout: 500 });
-}
-
-describe('searchable-multi-select keybindings', () => {
-  beforeEach(() => {
-    resetState();
-    vi.resetModules();
-  });
-
-  describe('Space to toggle', () => {
-    it('should select highlighted item when Space is pressed', async () => {
-      await setup();
-      pressKey('space');
-      expect(getSelectedValues()).toContain('tool-a');
-    });
-
-    it('should deselect highlighted item when Space is pressed on already-selected item', async () => {
-      await setup();
-      pressKey('space');
-      expect(getSelectedValues()).toContain('tool-a');
-
-      pressKey('space');
-      expect(getSelectedValues()).not.toContain('tool-a');
-    });
-
-    it('should toggle multiple items independently', async () => {
-      await setup();
-
-      // Select Tool A
-      pressKey('space');
-      expect(getSelectedValues()).toEqual(['tool-a']);
-
-      // Move down to Tool B, select it
-      pressKey('down');
-      pressKey('space');
-      expect(getSelectedValues()).toContain('tool-a');
-      expect(getSelectedValues()).toContain('tool-b');
-
-      // Move back up to Tool A, deselect it
-      pressKey('up');
-      pressKey('space');
-      expect(getSelectedValues()).not.toContain('tool-a');
-      expect(getSelectedValues()).toContain('tool-b');
-    });
-  });
-
-  describe('Enter to confirm', () => {
-    it('should set status to done when Enter is pressed', async () => {
-      await setup();
-      pressKey('space');
-      pressKey('return');
-      expect(getStatus()).toBe('done');
-    });
-
-    it('should confirm with empty selection', async () => {
-      await setup();
-      pressKey('return');
-      expect(getStatus()).toBe('done');
-    });
-
-    it('should show validation error when validation fails', async () => {
-      const validate = (selected: string[]) =>
-        selected.length > 0 ? true : 'Select at least one';
-      await setup(testChoices, validate);
-
-      pressKey('return');
-      expect(getStatus()).toBe('idle');
-      expect(getError()).toBe('Select at least one');
-    });
-
-    it('should confirm when validation passes', async () => {
-      const validate = (selected: string[]) =>
-        selected.length > 0 ? true : 'Select at least one';
-      await setup(testChoices, validate);
-
-      pressKey('space');
-      pressKey('return');
-      expect(getStatus()).toBe('done');
-    });
-  });
-
-  describe('Tab does not confirm', () => {
-    it('should not change status when Tab is pressed', async () => {
-      await setup();
-      pressKey('space');
-      pressKey('tab');
-      expect(getStatus()).toBe('idle');
-    });
-  });
-
-  describe('hint text', () => {
-    it('should include Space toggle and Enter confirm in rendered output', async () => {
-      await setup();
-      expect(renderOutput).toContain('Space');
-      expect(renderOutput).toContain('toggle');
-      expect(renderOutput).toContain('Enter');
-      expect(renderOutput).toContain('confirm');
-      expect(renderOutput).not.toMatch(/Tab.*confirm/);
-    });
-  });
-});

package/OpenSpec-main/test/specs/source-specs-normalization.test.ts

@@ -1,63 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { describe, it, expect } from 'vitest';
-import { MarkdownParser } from '../../src/core/parsers/markdown-parser.js';
-import {
-  findMainSpecStructureIssues,
-  stripFencedCodeBlocksPreservingLines,
-} from '../../src/core/parsers/spec-structure.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const projectRoot = path.resolve(__dirname, '..', '..');
-const specsRoot = path.join(projectRoot, 'openspec', 'specs');
-
-const PURPOSE_PLACEHOLDER_PATTERN = /TBD - created by archiving change .*?\. Update Purpose after archive\./;
-const REQUIREMENT_HEADER_PATTERN = /^###\s+Requirement:/gm;
-
-async function getSpecFiles(): Promise<string[]> {
-  const entries = await fs.readdir(specsRoot, { withFileTypes: true });
-  const files: string[] = [];
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const specFile = path.join(specsRoot, entry.name, 'spec.md');
-    try {
-      await fs.access(specFile);
-      files.push(specFile);
-    } catch {
-      // Ignore directories without spec.md
-    }
-  }
-
-  return files.sort();
-}
-
-describe('source-of-truth specs normalization', () => {
-  it('enforces required sections and bans hidden requirements, placeholders, and delta headers', async () => {
-    const files = await getSpecFiles();
-    expect(files.length).toBeGreaterThan(0);
-
-    for (const file of files) {
-      const content = await fs.readFile(file, 'utf8');
-      const relativeFile = path.relative(projectRoot, file);
-      const structureIssues = findMainSpecStructureIssues(content);
-      const parser = new MarkdownParser(content);
-      const spec = parser.parseSpec(path.basename(path.dirname(file)));
-      const rawRequirementCount =
-        stripFencedCodeBlocksPreservingLines(content).match(REQUIREMENT_HEADER_PATTERN)?.length ?? 0;
-
-      expect(content, `${relativeFile} must include ## Purpose`).toMatch(/^## Purpose$/m);
-      expect(content, `${relativeFile} must include ## Requirements`).toMatch(/^## Requirements$/m);
-      expect(content, `${relativeFile} must not include archive placeholder purpose text`).not.toMatch(
-        PURPOSE_PLACEHOLDER_PATTERN
-      );
-      expect(structureIssues, `${relativeFile} must not contain hidden requirements or delta headers`).toHaveLength(0);
-      expect(
-        spec.requirements.length,
-        `${relativeFile} parsed requirement count must match visible requirement headers`
-      ).toBe(rawRequirementCount);
-    }
-  });
-});

package/OpenSpec-main/test/telemetry/config.test.ts

@@ -1,298 +0,0 @@
-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 { randomUUID } from 'node:crypto';
-
-import {
-  getConfigPath,
-  readConfig,
-  writeConfig,
-  getTelemetryConfig,
-  updateTelemetryConfig,
-} from '../../src/telemetry/config.js';
-
-describe('telemetry/config', () => {
-  let tempDir: string;
-  let originalEnv: NodeJS.ProcessEnv;
-
-  function restoreEnv(env: NodeJS.ProcessEnv): void {
-    for (const key of Object.keys(process.env)) {
-      delete process.env[key];
-    }
-    Object.assign(process.env, env);
-  }
-
-  function defaultConfigDir(): string {
-    return os.platform() === 'win32'
-      ? path.join(tempDir, 'appdata', 'openspec')
-      : path.join(tempDir, '.config', 'openspec');
-  }
-
-  function defaultConfigPath(): string {
-    return path.join(defaultConfigDir(), 'config.json');
-  }
-
-  beforeEach(() => {
-    // Create temp directory for tests
-    tempDir = path.join(os.tmpdir(), `openspec-telemetry-test-${randomUUID()}`);
-    fs.mkdirSync(tempDir, { recursive: true });
-
-    // Mock HOME/USERPROFILE to point to temp dir
-    // On POSIX, os.homedir() uses HOME; on Windows it uses USERPROFILE
-    originalEnv = { ...process.env };
-    delete process.env.XDG_CONFIG_HOME;
-    process.env.APPDATA = path.join(tempDir, 'appdata');
-    process.env.HOME = tempDir;
-    process.env.USERPROFILE = tempDir;
-  });
-
-  afterEach(() => {
-    // Restore environment
-    restoreEnv(originalEnv);
-
-    // Clean up temp directory
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('getConfigPath', () => {
-    it('should return path to config.json in the default config directory', () => {
-      const result = getConfigPath();
-      expect(result).toBe(defaultConfigPath());
-    });
-
-    it('should use XDG_CONFIG_HOME when set', () => {
-      const xdgConfigHome = path.join(tempDir, 'xdg-config');
-      process.env.XDG_CONFIG_HOME = xdgConfigHome;
-
-      const result = getConfigPath();
-
-      expect(result).toBe(path.join(xdgConfigHome, 'openspec', 'config.json'));
-    });
-  });
-
-  describe('readConfig', () => {
-    it('should return empty object when config file does not exist', async () => {
-      const config = await readConfig();
-      expect(config).toEqual({});
-    });
-
-    it('should load valid config from file', async () => {
-      const configDir = defaultConfigDir();
-      const configPath = defaultConfigPath();
-
-      fs.mkdirSync(configDir, { recursive: true });
-      fs.writeFileSync(configPath, JSON.stringify({
-        telemetry: { anonymousId: 'test-id', noticeSeen: true }
-      }));
-
-      const config = await readConfig();
-      expect(config.telemetry).toEqual({ anonymousId: 'test-id', noticeSeen: true });
-    });
-
-    it('should return empty object for invalid JSON', async () => {
-      const configDir = defaultConfigDir();
-      const configPath = defaultConfigPath();
-
-      fs.mkdirSync(configDir, { recursive: true });
-      fs.writeFileSync(configPath, '{ invalid json }');
-
-      const config = await readConfig();
-      expect(config).toEqual({});
-    });
-
-    it('should migrate telemetry from legacy path when XDG_CONFIG_HOME is set', async () => {
-      const xdgConfigHome = path.join(tempDir, 'xdg-config');
-      const legacyConfigDir = path.join(tempDir, '.config', 'openspec');
-      const legacyConfigPath = path.join(legacyConfigDir, 'config.json');
-      const newConfigPath = path.join(xdgConfigHome, 'openspec', 'config.json');
-      process.env.XDG_CONFIG_HOME = xdgConfigHome;
-
-      fs.mkdirSync(legacyConfigDir, { recursive: true });
-      fs.writeFileSync(legacyConfigPath, JSON.stringify({
-        telemetry: { anonymousId: 'legacy-id', noticeSeen: true },
-      }));
-
-      const config = await readConfig();
-
-      expect(config.telemetry).toEqual({ anonymousId: 'legacy-id', noticeSeen: true });
-      expect(JSON.parse(fs.readFileSync(newConfigPath, 'utf-8')).telemetry).toEqual({
-        anonymousId: 'legacy-id',
-        noticeSeen: true,
-      });
-    });
-
-    it('should not overwrite invalid new config during legacy migration', async () => {
-      const xdgConfigHome = path.join(tempDir, 'xdg-config');
-      const legacyConfigDir = path.join(tempDir, '.config', 'openspec');
-      const legacyConfigPath = path.join(legacyConfigDir, 'config.json');
-      const newConfigDir = path.join(xdgConfigHome, 'openspec');
-      const newConfigPath = path.join(newConfigDir, 'config.json');
-      const invalidJson = '{ invalid json }';
-      process.env.XDG_CONFIG_HOME = xdgConfigHome;
-
-      fs.mkdirSync(legacyConfigDir, { recursive: true });
-      fs.writeFileSync(legacyConfigPath, JSON.stringify({
-        telemetry: { anonymousId: 'legacy-id', noticeSeen: true },
-      }));
-
-      fs.mkdirSync(newConfigDir, { recursive: true });
-      fs.writeFileSync(newConfigPath, invalidJson);
-
-      const config = await readConfig();
-
-      expect(config.telemetry).toEqual({ anonymousId: 'legacy-id', noticeSeen: true });
-      expect(fs.readFileSync(newConfigPath, 'utf-8')).toBe(invalidJson);
-    });
-
-    it('should fill only missing telemetry fields from legacy config', async () => {
-      const xdgConfigHome = path.join(tempDir, 'xdg-config');
-      const legacyConfigDir = path.join(tempDir, '.config', 'openspec');
-      const legacyConfigPath = path.join(legacyConfigDir, 'config.json');
-      const newConfigDir = path.join(xdgConfigHome, 'openspec');
-      const newConfigPath = path.join(newConfigDir, 'config.json');
-      process.env.XDG_CONFIG_HOME = xdgConfigHome;
-
-      fs.mkdirSync(legacyConfigDir, { recursive: true });
-      fs.writeFileSync(legacyConfigPath, JSON.stringify({
-        telemetry: { anonymousId: 'legacy-id', noticeSeen: true },
-        legacyOnly: 'ignored',
-      }));
-
-      fs.mkdirSync(newConfigDir, { recursive: true });
-      fs.writeFileSync(newConfigPath, JSON.stringify({
-        featureFlags: { existing: true },
-        telemetry: { anonymousId: 'new-id' },
-      }));
-
-      const config = await readConfig();
-
-      expect(config.featureFlags).toEqual({ existing: true });
-      expect(config.telemetry).toEqual({ anonymousId: 'new-id', noticeSeen: true });
-      expect((config as Record<string, unknown>).legacyOnly).toBeUndefined();
-      expect(JSON.parse(fs.readFileSync(newConfigPath, 'utf-8')).telemetry).toEqual({
-        anonymousId: 'new-id',
-        noticeSeen: true,
-      });
-    });
-  });
-
-  describe('writeConfig', () => {
-    it('should create directory if it does not exist', async () => {
-      const configDir = defaultConfigDir();
-
-      await writeConfig({ telemetry: { noticeSeen: true } });
-
-      expect(fs.existsSync(configDir)).toBe(true);
-    });
-
-    it('should write config to file', async () => {
-      const configPath = defaultConfigPath();
-
-      await writeConfig({ telemetry: { anonymousId: 'test-123' } });
-
-      const content = fs.readFileSync(configPath, 'utf-8');
-      const parsed = JSON.parse(content);
-      expect(parsed.telemetry.anonymousId).toBe('test-123');
-    });
-
-    it('should write config to XDG_CONFIG_HOME when set', async () => {
-      const xdgConfigHome = path.join(tempDir, 'xdg-config');
-      const configPath = path.join(xdgConfigHome, 'openspec', 'config.json');
-      process.env.XDG_CONFIG_HOME = xdgConfigHome;
-
-      await writeConfig({ telemetry: { anonymousId: 'test-123' } });
-
-      const content = fs.readFileSync(configPath, 'utf-8');
-      const parsed = JSON.parse(content);
-      expect(parsed.telemetry.anonymousId).toBe('test-123');
-    });
-
-    it('should preserve existing fields when updating', async () => {
-      const configDir = defaultConfigDir();
-      const configPath = defaultConfigPath();
-
-      // Create initial config with other fields
-      fs.mkdirSync(configDir, { recursive: true });
-      fs.writeFileSync(configPath, JSON.stringify({
-        existingField: 'preserved',
-        telemetry: { anonymousId: 'old-id' }
-      }));
-
-      // Update telemetry
-      await writeConfig({ telemetry: { noticeSeen: true } });
-
-      const content = fs.readFileSync(configPath, 'utf-8');
-      const parsed = JSON.parse(content);
-      expect(parsed.existingField).toBe('preserved');
-      expect(parsed.telemetry.noticeSeen).toBe(true);
-    });
-
-    it('should deep merge telemetry fields', async () => {
-      const configDir = defaultConfigDir();
-      const configPath = defaultConfigPath();
-
-      // Create initial config
-      fs.mkdirSync(configDir, { recursive: true });
-      fs.writeFileSync(configPath, JSON.stringify({
-        telemetry: { anonymousId: 'existing-id' }
-      }));
-
-      // Update with noticeSeen only
-      await writeConfig({ telemetry: { noticeSeen: true } });
-
-      const content = fs.readFileSync(configPath, 'utf-8');
-      const parsed = JSON.parse(content);
-      expect(parsed.telemetry.anonymousId).toBe('existing-id');
-      expect(parsed.telemetry.noticeSeen).toBe(true);
-    });
-  });
-
-  describe('getTelemetryConfig', () => {
-    it('should return empty object when no config exists', async () => {
-      const config = await getTelemetryConfig();
-      expect(config).toEqual({});
-    });
-
-    it('should return telemetry section from config', async () => {
-      const configDir = defaultConfigDir();
-      const configPath = defaultConfigPath();
-
-      fs.mkdirSync(configDir, { recursive: true });
-      fs.writeFileSync(configPath, JSON.stringify({
-        telemetry: { anonymousId: 'my-id', noticeSeen: false }
-      }));
-
-      const config = await getTelemetryConfig();
-      expect(config).toEqual({ anonymousId: 'my-id', noticeSeen: false });
-    });
-  });
-
-  describe('updateTelemetryConfig', () => {
-    it('should create telemetry config when none exists', async () => {
-      await updateTelemetryConfig({ anonymousId: 'new-id' });
-
-      const configPath = defaultConfigPath();
-      const content = fs.readFileSync(configPath, 'utf-8');
-      const parsed = JSON.parse(content);
-      expect(parsed.telemetry.anonymousId).toBe('new-id');
-    });
-
-    it('should merge with existing telemetry config', async () => {
-      const configDir = defaultConfigDir();
-      const configPath = defaultConfigPath();
-
-      fs.mkdirSync(configDir, { recursive: true });
-      fs.writeFileSync(configPath, JSON.stringify({
-        telemetry: { anonymousId: 'existing-id' }
-      }));
-
-      await updateTelemetryConfig({ noticeSeen: true });
-
-      const content = fs.readFileSync(configPath, 'utf-8');
-      const parsed = JSON.parse(content);
-      expect(parsed.telemetry.anonymousId).toBe('existing-id');
-      expect(parsed.telemetry.noticeSeen).toBe(true);
-    });
-  });
-});