sauron-cli 1.3.0 → 1.4.0

package/OpenSpec-main/test/core/config-schema.test.ts

@@ -1,340 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import {
-  getNestedValue,
-  setNestedValue,
-  deleteNestedValue,
-  coerceValue,
-  formatValueYaml,
-  validateConfig,
-  GlobalConfigSchema,
-  DEFAULT_CONFIG,
-} from '../../src/core/config-schema.js';
-
-describe('config-schema', () => {
-  describe('getNestedValue', () => {
-    it('should get a top-level value', () => {
-      const obj = { foo: 'bar' };
-      expect(getNestedValue(obj, 'foo')).toBe('bar');
-    });
-
-    it('should get a nested value with dot notation', () => {
-      const obj = { a: { b: { c: 'deep' } } };
-      expect(getNestedValue(obj, 'a.b.c')).toBe('deep');
-    });
-
-    it('should return undefined for non-existent path', () => {
-      const obj = { foo: 'bar' };
-      expect(getNestedValue(obj, 'baz')).toBeUndefined();
-    });
-
-    it('should return undefined for non-existent nested path', () => {
-      const obj = { a: { b: 'value' } };
-      expect(getNestedValue(obj, 'a.b.c')).toBeUndefined();
-    });
-
-    it('should return undefined when traversing through null', () => {
-      const obj = { a: null };
-      expect(getNestedValue(obj as Record<string, unknown>, 'a.b')).toBeUndefined();
-    });
-
-    it('should return undefined when traversing through primitive', () => {
-      const obj = { a: 'string' };
-      expect(getNestedValue(obj, 'a.b')).toBeUndefined();
-    });
-
-    it('should get object values', () => {
-      const obj = { a: { b: 'value' } };
-      expect(getNestedValue(obj, 'a')).toEqual({ b: 'value' });
-    });
-
-    it('should handle array values', () => {
-      const obj = { arr: [1, 2, 3] };
-      expect(getNestedValue(obj, 'arr')).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('setNestedValue', () => {
-    it('should set a top-level value', () => {
-      const obj: Record<string, unknown> = {};
-      setNestedValue(obj, 'foo', 'bar');
-      expect(obj.foo).toBe('bar');
-    });
-
-    it('should set a nested value', () => {
-      const obj: Record<string, unknown> = {};
-      setNestedValue(obj, 'a.b.c', 'deep');
-      expect((obj.a as Record<string, unknown>).b).toEqual({ c: 'deep' });
-    });
-
-    it('should create intermediate objects', () => {
-      const obj: Record<string, unknown> = {};
-      setNestedValue(obj, 'x.y.z', 'value');
-      expect(obj).toEqual({ x: { y: { z: 'value' } } });
-    });
-
-    it('should overwrite existing values', () => {
-      const obj: Record<string, unknown> = { a: 'old' };
-      setNestedValue(obj, 'a', 'new');
-      expect(obj.a).toBe('new');
-    });
-
-    it('should overwrite primitive with object when setting nested path', () => {
-      const obj: Record<string, unknown> = { a: 'string' };
-      setNestedValue(obj, 'a.b', 'value');
-      expect(obj.a).toEqual({ b: 'value' });
-    });
-
-    it('should preserve other keys when setting nested value', () => {
-      const obj: Record<string, unknown> = { a: { existing: 'keep' } };
-      setNestedValue(obj, 'a.new', 'added');
-      expect(obj.a).toEqual({ existing: 'keep', new: 'added' });
-    });
-  });
-
-  describe('deleteNestedValue', () => {
-    it('should delete a top-level key', () => {
-      const obj: Record<string, unknown> = { foo: 'bar', baz: 'qux' };
-      const result = deleteNestedValue(obj, 'foo');
-      expect(result).toBe(true);
-      expect(obj).toEqual({ baz: 'qux' });
-    });
-
-    it('should delete a nested key', () => {
-      const obj: Record<string, unknown> = { a: { b: 'value', c: 'keep' } };
-      const result = deleteNestedValue(obj, 'a.b');
-      expect(result).toBe(true);
-      expect(obj.a).toEqual({ c: 'keep' });
-    });
-
-    it('should return false for non-existent key', () => {
-      const obj: Record<string, unknown> = { foo: 'bar' };
-      const result = deleteNestedValue(obj, 'baz');
-      expect(result).toBe(false);
-    });
-
-    it('should return false for non-existent nested path', () => {
-      const obj: Record<string, unknown> = { a: { b: 'value' } };
-      const result = deleteNestedValue(obj, 'a.c');
-      expect(result).toBe(false);
-    });
-
-    it('should return false when intermediate path does not exist', () => {
-      const obj: Record<string, unknown> = { a: 'string' };
-      const result = deleteNestedValue(obj, 'a.b.c');
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('coerceValue', () => {
-    it('should coerce "true" to boolean true', () => {
-      expect(coerceValue('true')).toBe(true);
-    });
-
-    it('should coerce "false" to boolean false', () => {
-      expect(coerceValue('false')).toBe(false);
-    });
-
-    it('should coerce integer string to number', () => {
-      expect(coerceValue('42')).toBe(42);
-    });
-
-    it('should coerce float string to number', () => {
-      expect(coerceValue('3.14')).toBe(3.14);
-    });
-
-    it('should coerce negative number string to number', () => {
-      expect(coerceValue('-10')).toBe(-10);
-    });
-
-    it('should keep regular strings as strings', () => {
-      expect(coerceValue('hello')).toBe('hello');
-    });
-
-    it('should keep strings that start with numbers but are not numbers', () => {
-      expect(coerceValue('123abc')).toBe('123abc');
-    });
-
-    it('should keep empty string as string', () => {
-      expect(coerceValue('')).toBe('');
-    });
-
-    it('should keep whitespace-only string as string', () => {
-      expect(coerceValue('   ')).toBe('   ');
-    });
-
-    it('should force string when forceString is true', () => {
-      expect(coerceValue('true', true)).toBe('true');
-      expect(coerceValue('42', true)).toBe('42');
-      expect(coerceValue('hello', true)).toBe('hello');
-    });
-
-    it('should not coerce Infinity to number (not finite)', () => {
-      // Infinity is not a useful config value, so we keep it as string
-      expect(coerceValue('Infinity')).toBe('Infinity');
-    });
-
-    it('should handle scientific notation', () => {
-      expect(coerceValue('1e10')).toBe(1e10);
-    });
-  });
-
-  describe('formatValueYaml', () => {
-    it('should format null as "null"', () => {
-      expect(formatValueYaml(null)).toBe('null');
-    });
-
-    it('should format undefined as "null"', () => {
-      expect(formatValueYaml(undefined)).toBe('null');
-    });
-
-    it('should format boolean as string', () => {
-      expect(formatValueYaml(true)).toBe('true');
-      expect(formatValueYaml(false)).toBe('false');
-    });
-
-    it('should format number as string', () => {
-      expect(formatValueYaml(42)).toBe('42');
-      expect(formatValueYaml(3.14)).toBe('3.14');
-    });
-
-    it('should format string as-is', () => {
-      expect(formatValueYaml('hello')).toBe('hello');
-    });
-
-    it('should format empty array as "[]"', () => {
-      expect(formatValueYaml([])).toBe('[]');
-    });
-
-    it('should format empty object as "{}"', () => {
-      expect(formatValueYaml({})).toBe('{}');
-    });
-
-    it('should format object with key-value pairs', () => {
-      const result = formatValueYaml({ foo: 'bar' });
-      expect(result).toBe('foo: bar');
-    });
-
-    it('should format nested objects with indentation', () => {
-      const result = formatValueYaml({ a: { b: 'value' } });
-      expect(result).toContain('a:');
-      expect(result).toContain('b: value');
-    });
-  });
-
-  describe('validateConfig', () => {
-    it('should accept valid config with featureFlags', () => {
-      const result = validateConfig({ featureFlags: { test: true } });
-      expect(result.success).toBe(true);
-    });
-
-    it('should accept empty featureFlags', () => {
-      const result = validateConfig({ featureFlags: {} });
-      expect(result.success).toBe(true);
-    });
-
-    it('should accept config without featureFlags (uses default)', () => {
-      const result = validateConfig({});
-      expect(result.success).toBe(true);
-    });
-
-    it('should accept unknown fields (passthrough)', () => {
-      const result = validateConfig({ featureFlags: {}, unknownField: 'value' });
-      expect(result.success).toBe(true);
-    });
-
-    it('should accept unknown fields with various types', () => {
-      const result = validateConfig({
-        featureFlags: {},
-        futureStringField: 'value',
-        futureNumberField: 123,
-        futureObjectField: { nested: 'data' },
-      });
-      expect(result.success).toBe(true);
-    });
-
-    it('should reject non-boolean values in featureFlags', () => {
-      const result = validateConfig({ featureFlags: { test: 'string' } });
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    it('should include path in error message for invalid featureFlags', () => {
-      const result = validateConfig({ featureFlags: { someFlag: 'notABoolean' } });
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('featureFlags');
-    });
-
-    it('should reject non-object featureFlags', () => {
-      const result = validateConfig({ featureFlags: 'string' });
-      expect(result.success).toBe(false);
-    });
-
-    it('should reject number values in featureFlags', () => {
-      const result = validateConfig({ featureFlags: { flag: 123 } });
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('config set simulation', () => {
-    // These tests simulate the full config set flow: coerce value → set nested → validate
-
-    it('should accept setting unknown top-level key (forward compatibility)', () => {
-      const config: Record<string, unknown> = { featureFlags: {} };
-      const value = coerceValue('123');
-      setNestedValue(config, 'someFutureKey', value);
-
-      const result = validateConfig(config);
-      expect(result.success).toBe(true);
-      expect(config.someFutureKey).toBe(123);
-    });
-
-    it('should reject setting non-boolean to featureFlags', () => {
-      const config: Record<string, unknown> = { featureFlags: {} };
-      const value = coerceValue('notABoolean'); // stays as string
-      setNestedValue(config, 'featureFlags.someFlag', value);
-
-      const result = validateConfig(config);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('featureFlags');
-    });
-
-    it('should accept setting boolean to featureFlags', () => {
-      const config: Record<string, unknown> = { featureFlags: {} };
-      const value = coerceValue('true'); // coerces to boolean
-      setNestedValue(config, 'featureFlags.newFlag', value);
-
-      const result = validateConfig(config);
-      expect(result.success).toBe(true);
-      expect((config.featureFlags as Record<string, unknown>).newFlag).toBe(true);
-    });
-
-    it('should create featureFlags object when setting nested flag', () => {
-      const config: Record<string, unknown> = {};
-      const value = coerceValue('false');
-      setNestedValue(config, 'featureFlags.experimental', value);
-
-      const result = validateConfig(config);
-      expect(result.success).toBe(true);
-      expect((config.featureFlags as Record<string, unknown>).experimental).toBe(false);
-    });
-  });
-
-  describe('GlobalConfigSchema', () => {
-    it('should parse valid config', () => {
-      const result = GlobalConfigSchema.safeParse({ featureFlags: { test: true } });
-      expect(result.success).toBe(true);
-    });
-
-    it('should provide defaults for missing featureFlags', () => {
-      const result = GlobalConfigSchema.parse({});
-      expect(result.featureFlags).toEqual({});
-    });
-  });
-
-  describe('DEFAULT_CONFIG', () => {
-    it('should have empty featureFlags', () => {
-      expect(DEFAULT_CONFIG.featureFlags).toEqual({});
-    });
-  });
-});

package/OpenSpec-main/test/core/context-store/foundation.test.ts

@@ -1,364 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-
-import { getGlobalDataDir } from '../../../src/core/global-config.js';
-import {
-  CONTEXT_STORE_METADATA_DIR_NAME,
-  CONTEXT_STORE_METADATA_FILE_NAME,
-  CONTEXT_STORE_REGISTRY_FILE_NAME,
-  CONTEXT_STORES_DIR_NAME,
-  getContextStoreMetadataDir,
-  getContextStoreMetadataPath,
-  getContextStoreRegistryPath,
-  getContextStoresDir,
-  getDefaultContextStoreRoot,
-  isContextStoreRoot,
-  isValidContextStoreId,
-  listContextStoreRegistryEntries,
-  parseContextStoreMetadataState,
-  parseContextStoreRegistryState,
-  readContextStoreMetadataState,
-  readContextStoreRegistryState,
-  readOptionalContextStoreMetadataState,
-  resolveGitContextStoreBackendConfig,
-  serializeContextStoreMetadataState,
-  serializeContextStoreRegistryState,
-  validateContextStoreId,
-  writeContextStoreMetadataState,
-  writeContextStoreRegistryState,
-} from '../../../src/core/context-store/index.js';
-
-describe('context store foundation', () => {
-  let tempDir: string;
-  let originalEnv: NodeJS.ProcessEnv;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-context-store-foundation-'));
-    originalEnv = { ...process.env };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  function expectedExistingPath(existingPath: string): string {
-    return fs.realpathSync.native(existingPath);
-  }
-
-  function expectSameExistingPath(actualPath: string, expectedPath: string): void {
-    expect(fs.realpathSync.native(actualPath)).toBe(expectedExistingPath(expectedPath));
-  }
-
-  describe('path helpers', () => {
-    it('exposes context store constants', () => {
-      expect(CONTEXT_STORE_METADATA_DIR_NAME).toBe('.openspec-store');
-      expect(CONTEXT_STORE_METADATA_FILE_NAME).toBe('store.yaml');
-      expect(CONTEXT_STORES_DIR_NAME).toBe('context-stores');
-      expect(CONTEXT_STORE_REGISTRY_FILE_NAME).toBe('registry.yaml');
-    });
-
-    it('returns registry and metadata paths', () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      const storeRoot = path.join(tempDir, 'acme-context');
-
-      expect(getContextStoresDir()).toBe(path.join(tempDir, 'openspec', 'context-stores'));
-      expect(getContextStoreRegistryPath()).toBe(
-        path.join(tempDir, 'openspec', 'context-stores', 'registry.yaml')
-      );
-      expect(getDefaultContextStoreRoot('acme-context')).toBe(
-        path.join(tempDir, 'openspec', 'context-stores', 'acme-context')
-      );
-      expect(getContextStoreMetadataDir(storeRoot)).toBe(
-        path.join(storeRoot, '.openspec-store')
-      );
-      expect(getContextStoreMetadataPath(storeRoot)).toBe(
-        path.join(storeRoot, '.openspec-store', 'store.yaml')
-      );
-    });
-
-    it('uses global data dir options for registry locations', () => {
-      const dataDir = getGlobalDataDir({
-        env: {},
-        platform: 'linux',
-        homedir: '/home/tabish',
-      });
-
-      expect(getContextStoresDir({ globalDataDir: dataDir })).toBe(
-        '/home/tabish/.local/share/openspec/context-stores'
-      );
-      expect(getContextStoreRegistryPath({ globalDataDir: dataDir })).toBe(
-        '/home/tabish/.local/share/openspec/context-stores/registry.yaml'
-      );
-      expect(getDefaultContextStoreRoot('team-context', { globalDataDir: dataDir })).toBe(
-        '/home/tabish/.local/share/openspec/context-stores/team-context'
-      );
-    });
-
-    it('preserves Windows-style store root strings when building metadata paths', () => {
-      expect(getContextStoreMetadataPath('D:\\repos\\acme-context')).toBe(
-        'D:\\repos\\acme-context\\.openspec-store\\store.yaml'
-      );
-    });
-  });
-
-  describe('id validation', () => {
-    it('accepts kebab-case context store ids', () => {
-      expect(validateContextStoreId('acme')).toBe('acme');
-      expect(isValidContextStoreId('acme-context')).toBe(true);
-      expect(isValidContextStoreId('context2')).toBe(true);
-    });
-
-    it('rejects ids that are not safe kebab-case folder names', () => {
-      for (const invalidId of [
-        '',
-        '.',
-        '..',
-        'bad/name',
-        'bad\\name',
-        'Acme',
-        'acme_context',
-        'acme.context',
-        'acme context',
-        '-acme',
-        'acme-',
-        'acme--context',
-      ]) {
-        expect(isValidContextStoreId(invalidId)).toBe(false);
-      }
-    });
-  });
-
-  describe('registry parsing and serialization', () => {
-    it('parses and serializes a strict Git/local context store registry', () => {
-      const registry = parseContextStoreRegistryState(`version: 1
-stores:
-  zeta-context:
-    backend:
-      type: git
-      local_path: /repos/zeta-context
-  acme-context:
-    backend:
-      type: git
-      local_path: /repos/acme-context
-      remote: git@github.com:acme/context.git
-      branch: main
-`);
-
-      expect(registry.stores['acme-context'].backend).toEqual({
-        type: 'git',
-        local_path: '/repos/acme-context',
-        remote: 'git@github.com:acme/context.git',
-        branch: 'main',
-      });
-      expect(listContextStoreRegistryEntries(registry).map((entry) => entry.id)).toEqual([
-        'acme-context',
-        'zeta-context',
-      ]);
-      expect(parseContextStoreRegistryState(serializeContextStoreRegistryState(registry))).toEqual(
-        registry
-      );
-    });
-
-    it('rejects invalid registry structure and ids', () => {
-      expect(() =>
-        parseContextStoreRegistryState(`version: 2
-stores: {}
-`)
-      ).toThrow(/Invalid context store registry state/u);
-
-      expect(() =>
-        parseContextStoreRegistryState(`version: 1
-stores:
-  Acme:
-    backend:
-      type: git
-      local_path: /repos/acme
-`)
-      ).toThrow(/Invalid context store id/u);
-
-      expect(() =>
-        parseContextStoreRegistryState(`version: 1
-stores:
-  acme:
-    backend:
-      type: memory
-      local_path: /repos/acme
-`)
-      ).toThrow(/Invalid context store registry state/u);
-
-      expect(() =>
-        parseContextStoreRegistryState(`version: 1
-stores:
-  acme:
-    backend:
-      type: git
-      local_path: ""
-`)
-      ).toThrow(/Invalid context store registry state/u);
-    });
-
-    it('rejects unknown registry fields', () => {
-      expect(() =>
-        parseContextStoreRegistryState(`version: 1
-stores: {}
-extra: true
-`)
-      ).toThrow(/Invalid context store registry state/u);
-
-      expect(() =>
-        parseContextStoreRegistryState(`version: 1
-stores:
-  acme:
-    backend:
-      type: git
-      local_path: /repos/acme
-      depth: 1
-`)
-      ).toThrow(/Invalid context store registry state/u);
-    });
-  });
-
-  describe('metadata parsing and serialization', () => {
-    it('parses and serializes portable store metadata', () => {
-      const metadata = parseContextStoreMetadataState(`version: 1
-id: acme-context
-`);
-
-      expect(metadata).toEqual({
-        version: 1,
-        id: 'acme-context',
-      });
-      expect(parseContextStoreMetadataState(serializeContextStoreMetadataState(metadata))).toEqual(
-        metadata
-      );
-    });
-
-    it('rejects invalid metadata state', () => {
-      expect(() =>
-        parseContextStoreMetadataState(`version: 1
-id: Acme
-`)
-      ).toThrow(/Context store id must be kebab-case/u);
-
-      expect(() =>
-        parseContextStoreMetadataState(`version: 1
-id: acme
-local_path: /repos/acme
-`)
-      ).toThrow(/Invalid context store metadata state/u);
-    });
-  });
-
-  describe('registry IO', () => {
-    it('returns null for a missing local registry', async () => {
-      await expect(readContextStoreRegistryState({ globalDataDir: tempDir })).resolves.toBeNull();
-    });
-
-    it('writes and reads the machine-local registry', async () => {
-      const registry = {
-        version: 1 as const,
-        stores: {
-          'acme-context': {
-            backend: {
-              type: 'git' as const,
-              local_path: path.join(tempDir, 'acme-context'),
-              remote: 'git@github.com:acme/context.git',
-            },
-          },
-        },
-      };
-
-      await writeContextStoreRegistryState(registry, { globalDataDir: tempDir });
-
-      expect(fs.existsSync(getContextStoreRegistryPath({ globalDataDir: tempDir }))).toBe(true);
-      await expect(readContextStoreRegistryState({ globalDataDir: tempDir })).resolves.toEqual(
-        registry
-      );
-    });
-  });
-
-  describe('store metadata IO', () => {
-    it('writes and reads portable metadata inside the store root', async () => {
-      const storeRoot = path.join(tempDir, 'acme-context');
-
-      await expect(isContextStoreRoot(storeRoot)).resolves.toBe(false);
-      await writeContextStoreMetadataState(storeRoot, {
-        version: 1,
-        id: 'acme-context',
-      });
-
-      await expect(isContextStoreRoot(storeRoot)).resolves.toBe(true);
-      await expect(readContextStoreMetadataState(storeRoot)).resolves.toEqual({
-        version: 1,
-        id: 'acme-context',
-      });
-      await expect(readOptionalContextStoreMetadataState(storeRoot)).resolves.toEqual({
-        version: 1,
-        id: 'acme-context',
-      });
-    });
-
-    it('returns null only when optional metadata is missing', async () => {
-      const storeRoot = path.join(tempDir, 'missing-store');
-
-      await expect(readOptionalContextStoreMetadataState(storeRoot)).resolves.toBeNull();
-
-      fs.mkdirSync(path.dirname(getContextStoreMetadataPath(storeRoot)), { recursive: true });
-      fs.writeFileSync(getContextStoreMetadataPath(storeRoot), 'version: nope\n');
-
-      await expect(readOptionalContextStoreMetadataState(storeRoot)).rejects.toThrow(
-        /Invalid context store metadata state/u
-      );
-    });
-  });
-
-  describe('Git/local backend config', () => {
-    it('resolves an existing local checkout path without creating or managing it', async () => {
-      const storesDir = path.join(tempDir, 'stores');
-      const localPath = path.join(storesDir, 'acme-context');
-      fs.mkdirSync(localPath, { recursive: true });
-
-      const backend = await resolveGitContextStoreBackendConfig(
-        {
-          localPath: 'acme-context',
-          remote: 'git@github.com:acme/context.git',
-          branch: 'main',
-        },
-        storesDir
-      );
-
-      expect(backend).toEqual({
-        type: 'git',
-        local_path: expect.any(String),
-        remote: 'git@github.com:acme/context.git',
-        branch: 'main',
-      });
-      expectSameExistingPath(backend.local_path, localPath);
-      expect(fs.readdirSync(localPath)).toEqual([]);
-    });
-
-    it('rejects missing paths and empty optional Git config values', async () => {
-      await expect(
-        resolveGitContextStoreBackendConfig({ localPath: '' }, tempDir)
-      ).rejects.toThrow(/must not be empty/u);
-
-      await expect(
-        resolveGitContextStoreBackendConfig({ localPath: 'missing' }, tempDir)
-      ).rejects.toThrow(/does not exist/u);
-
-      const localPath = path.join(tempDir, 'acme-context');
-      fs.mkdirSync(localPath, { recursive: true });
-
-      await expect(
-        resolveGitContextStoreBackendConfig({ localPath, remote: '' }, tempDir)
-      ).rejects.toThrow(/remote must not be empty/u);
-
-      await expect(
-        resolveGitContextStoreBackendConfig({ localPath, branch: '' }, tempDir)
-      ).rejects.toThrow(/branch must not be empty/u);
-    });
-  });
-});