sauron-cli 1.2.0 → 1.3.0

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

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

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

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