sauron-cli 1.1.3 → 1.3.0

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

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

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