sauron-cli 1.1.3 → 1.3.0

package/OpenSpec-main/test/core/collections/initiatives/schema.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  INITIATIVE_COLLECTION_ID,
+  INITIATIVE_FILE_NAME,
+  INITIATIVE_FILE_NAMES,
+  INITIATIVE_MARKDOWN_FILE_NAMES,
+  INITIATIVE_STATUSES,
+  isValidInitiativeId,
+  parseInitiativeState,
+  serializeInitiativeState,
+  validateInitiativeId,
+  type InitiativeState,
+} from '../../../../src/core/collections/initiatives/index.js';
+
+describe('initiative schema', () => {
+  const state: InitiativeState = {
+    version: 1,
+    id: 'launch-billing-flow',
+    title: 'Launch Billing Flow',
+    summary: 'Coordinate billing launch across product, API, and client surfaces.',
+    status: 'exploring',
+    created: '2026-05-21',
+    owners: ['platform-team'],
+    metadata: {
+      priority: 'high',
+      nested: {
+        score: 3,
+        blocked: false,
+        notes: null,
+      },
+    },
+  };
+
+  it('defines the initiative MVP file contract without links.yaml', () => {
+    expect(INITIATIVE_COLLECTION_ID).toBe('initiatives');
+    expect(INITIATIVE_FILE_NAME).toBe('initiative.yaml');
+    expect(INITIATIVE_STATUSES).toEqual(['exploring', 'active', 'complete', 'archived']);
+    expect(INITIATIVE_MARKDOWN_FILE_NAMES).toEqual([
+      'requirements.md',
+      'design.md',
+      'decisions.md',
+      'questions.md',
+      'tasks.md',
+    ]);
+    expect(INITIATIVE_FILE_NAMES).toEqual([
+      'initiative.yaml',
+      'requirements.md',
+      'design.md',
+      'decisions.md',
+      'questions.md',
+      'tasks.md',
+    ]);
+    expect(INITIATIVE_FILE_NAMES).not.toContain('links.yaml');
+  });
+
+  it('validates portable initiative ids', () => {
+    for (const id of ['launch-billing-flow', 'initiative2', 'api-v2-contracts']) {
+      expect(validateInitiativeId(id)).toBe(id);
+      expect(isValidInitiativeId(id)).toBe(true);
+    }
+  });
+
+  it('rejects unsafe initiative ids', () => {
+    for (const id of [
+      '',
+      '.',
+      '..',
+      'bad/name',
+      'bad\\name',
+      'Launch',
+      'launch_flow',
+      'launch.flow',
+      'launch flow',
+      '-launch',
+      'launch-',
+      'launch--flow',
+      'a\0b',
+    ]) {
+      expect(() => validateInitiativeId(id)).toThrow();
+      expect(isValidInitiativeId(id)).toBe(false);
+    }
+  });
+
+  it('parses initiative.yaml and defaults optional collection metadata', () => {
+    expect(
+      parseInitiativeState(`
+version: 1
+id: launch-billing-flow
+title: Launch Billing Flow
+summary: Coordinate billing launch.
+status: active
+created: "2026-05-21"
+`)
+    ).toEqual({
+      version: 1,
+      id: 'launch-billing-flow',
+      title: 'Launch Billing Flow',
+      summary: 'Coordinate billing launch.',
+      status: 'active',
+      created: '2026-05-21',
+      owners: [],
+      metadata: {},
+    });
+  });
+
+  it('serializes initiative.yaml with deterministic fields', () => {
+    const serialized = serializeInitiativeState(state);
+
+    expect(parseInitiativeState(serialized)).toEqual(state);
+    expect(serialized).toContain('version: 1');
+    expect(serialized).toContain('id: launch-billing-flow');
+    expect(serialized).toContain('created: 2026-05-21');
+  });
+
+  it('rejects invalid initiative.yaml input', () => {
+    const invalidCases = [
+      'not-an-object',
+      `
+version: 2
+id: launch-billing-flow
+title: Launch Billing Flow
+summary: Coordinate billing launch.
+status: exploring
+created: "2026-05-21"
+`,
+      `
+version: 1
+id: Launch
+title: Launch Billing Flow
+summary: Coordinate billing launch.
+status: exploring
+created: "2026-05-21"
+`,
+      `
+version: 1
+id: launch-billing-flow
+title: Launch Billing Flow
+summary: Coordinate billing launch.
+status: paused
+created: "2026-05-21"
+`,
+      `
+version: 1
+id: launch-billing-flow
+title: Launch Billing Flow
+summary: Coordinate billing launch.
+status: exploring
+`,
+      `
+version: 1
+id: launch-billing-flow
+title: Launch Billing Flow
+summary: Coordinate billing launch.
+status: exploring
+created: "05/21/2026"
+`,
+      `
+version: 1
+id: launch-billing-flow
+title: ""
+summary: Coordinate billing launch.
+status: exploring
+created: "2026-05-21"
+`,
+      `
+version: 1
+id: launch-billing-flow
+title: Launch Billing Flow
+summary: Coordinate billing launch.
+status: exploring
+created: "2026-05-21"
+owners: [""]
+`,
+      `
+version: 1
+id: launch-billing-flow
+title: Launch Billing Flow
+summary: Coordinate billing launch.
+status: exploring
+created: "2026-05-21"
+extra: nope
+`,
+    ];
+
+    for (const content of invalidCases) {
+      expect(() => parseInitiativeState(content)).toThrow();
+    }
+  });
+
+  it('rejects non-json metadata values on serialize', () => {
+    expect(() =>
+      serializeInitiativeState({
+        ...state,
+        metadata: {
+          notFinite: Number.NaN,
+        },
+      })
+    ).toThrow(/metadata/u);
+  });
+});

package/OpenSpec-main/test/core/collections/initiatives/templates.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  INITIATIVE_MARKDOWN_FILE_NAMES,
+  buildDefaultInitiativeFiles,
+  buildInitiativeDecisionsTemplate,
+  buildInitiativeDesignTemplate,
+  buildInitiativeQuestionsTemplate,
+  buildInitiativeRequirementsTemplate,
+  buildInitiativeTasksTemplate,
+  type InitiativeState,
+} from '../../../../src/core/collections/initiatives/index.js';
+
+describe('initiative templates', () => {
+  const state: InitiativeState = {
+    version: 1,
+    id: 'launch-billing-flow',
+    title: 'Launch Billing Flow',
+    summary: 'Coordinate billing launch across product, API, and client surfaces.',
+    status: 'exploring',
+    created: '2026-05-21',
+    owners: [],
+    metadata: {},
+  };
+
+  it('builds the default markdown files in the initiative file order', () => {
+    const files = buildDefaultInitiativeFiles(state);
+
+    expect(files.map((file) => file.fileName)).toEqual(INITIATIVE_MARKDOWN_FILE_NAMES);
+    expect(files.map((file) => file.fileName)).not.toContain('links.yaml');
+    for (const file of files) {
+      expect(file.content.endsWith('\n')).toBe(true);
+      expect(file.content).toMatch(/^# /u);
+    }
+  });
+
+  it('builds requirements content from initiative intent', () => {
+    const content = buildInitiativeRequirementsTemplate(state);
+
+    expect(content).toContain('# Requirements');
+    expect(content).toContain('## Product Intent');
+    expect(content).toContain(state.summary);
+    expect(content).toContain('## Accepted Requirements');
+    expect(content).toContain('## Out Of Scope');
+  });
+
+  it('builds design content for coordination context', () => {
+    const content = buildInitiativeDesignTemplate(state);
+
+    expect(content).toContain('# Design');
+    expect(content).toContain('## Context');
+    expect(content).toContain('## Approach');
+    expect(content).toContain('## Affected Areas');
+    expect(content).toContain('## Dependencies');
+    expect(content).toContain('## Risks');
+  });
+
+  it('builds decisions content with date and title context', () => {
+    const content = buildInitiativeDecisionsTemplate(state);
+
+    expect(content).toContain('# Decisions');
+    expect(content).toContain(`### ${state.created}: ${state.title}`);
+    expect(content).toContain('- Decision: TBD');
+    expect(content).toContain('- Why: TBD');
+    expect(content).toContain('- Implications: TBD');
+  });
+
+  it('builds questions and coordination tasks content', () => {
+    expect(buildInitiativeQuestionsTemplate()).toContain('## Open Questions');
+    expect(buildInitiativeQuestionsTemplate()).toContain('## Resolved Questions');
+    expect(buildInitiativeTasksTemplate()).toContain('## Coordination Tasks');
+    expect(buildInitiativeTasksTemplate()).toContain('- [ ] TBD');
+  });
+});

package/OpenSpec-main/test/core/collections/runtime.test.ts

@@ -0,0 +1,214 @@
+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 {
+  createCollectionRegistry,
+  mountCollections,
+  parseCollectionPath,
+  validateCollectionId,
+  validateMount,
+  type MountedCollectionContext,
+} from '../../../src/core/collections/index.js';
+
+describe('collection runtime', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-context-store-collections-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('collection id and mount validation', () => {
+    it('accepts portable kebab-case ids and mounts', () => {
+      for (const value of ['initiatives', 'decisions', 'api-catalog', 'context2']) {
+        expect(validateCollectionId(value)).toBe(value);
+        expect(validateMount(value)).toBe(value);
+      }
+    });
+
+    it('rejects unsafe ids and mounts', () => {
+      for (const invalidValue of [
+        '',
+        '.',
+        '..',
+        'bad/name',
+        'bad\\name',
+        'Acme',
+        'acme_context',
+        'acme.context',
+        'acme context',
+        '-acme',
+        'acme-',
+        'acme--context',
+        'a\0b',
+      ]) {
+        expect(() => validateCollectionId(invalidValue)).toThrow();
+        expect(() => validateMount(invalidValue)).toThrow();
+      }
+
+      expect(() => validateMount('.openspec-store')).toThrow(/reserved/u);
+    });
+  });
+
+  describe('collection path parsing', () => {
+    it('parses logical paths inside a collection mount', () => {
+      expect(parseCollectionPath()).toBe('');
+      expect(parseCollectionPath('')).toBe('');
+      expect(parseCollectionPath('launch-billing-flow/initiative.yaml')).toBe(
+        'launch-billing-flow/initiative.yaml'
+      );
+      expect(parseCollectionPath('initiatives-old/file.md')).toBe('initiatives-old/file.md');
+    });
+
+    it('rejects paths that are absolute, ambiguous, or outside the mount', () => {
+      for (const invalidPath of [
+        '.',
+        './x',
+        'x/.',
+        '..',
+        '../x',
+        'x/..',
+        'x/../y',
+        'x//y',
+        'x/',
+        '/x',
+        '//server/share/file',
+        'C:/x',
+        'C:\\x',
+        '\\\\server\\share\\x',
+        'bad\\path',
+        'a\0b',
+      ]) {
+        expect(() => parseCollectionPath(invalidPath)).toThrow();
+      }
+    });
+  });
+
+  describe('collection registry', () => {
+    it('lists, gets, and requires collection definitions deterministically', () => {
+      const registry = createCollectionRegistry([
+        { id: 'decisions', mount: 'decisions' },
+        { id: 'initiatives', mount: 'initiatives' },
+      ]);
+
+      expect(registry.list().map((definition) => definition.id)).toEqual([
+        'decisions',
+        'initiatives',
+      ]);
+      expect(registry.get('initiatives')).toEqual({
+        id: 'initiatives',
+        mount: 'initiatives',
+      });
+      expect(registry.get('missing')).toBeUndefined();
+      expect(registry.require('decisions').mount).toBe('decisions');
+      expect(() => registry.require('missing')).toThrow(/Unknown collection/u);
+    });
+
+    it('rejects duplicate collection ids and mounts', () => {
+      expect(() =>
+        createCollectionRegistry([
+          { id: 'initiatives', mount: 'initiatives' },
+          { id: 'initiatives', mount: 'initiative-plans' },
+        ])
+      ).toThrow(/Duplicate collection id/u);
+
+      expect(() =>
+        createCollectionRegistry([
+          { id: 'initiatives', mount: 'shared-context' },
+          { id: 'decisions', mount: 'shared-context' },
+        ])
+      ).toThrow(/Duplicate collection mount/u);
+    });
+  });
+
+  describe('mounted collections', () => {
+    it('mounts initiatives as a generic collection without creating files', () => {
+      const storeRoot = path.join(tempDir, 'acme-context');
+      const registry = createCollectionRegistry([{ id: 'initiatives', mount: 'initiatives' }]);
+      const mounted = mountCollections({ storeRoot, collections: registry });
+      const initiatives = mounted.require('initiatives');
+
+      expect(initiatives.collectionId).toBe('initiatives');
+      expect(initiatives.mount).toBe('initiatives');
+      expect(initiatives.mountRoot).toBe(path.join(storeRoot, 'initiatives'));
+      expect(initiatives.resolvePath('launch-billing-flow/initiative.yaml')).toBe(
+        path.join(storeRoot, 'initiatives', 'launch-billing-flow', 'initiative.yaml')
+      );
+      expect(initiatives.resolvePath('..draft/notes.md')).toBe(
+        path.join(storeRoot, 'initiatives', '..draft', 'notes.md')
+      );
+      expect(initiatives.resolvePath()).toBe(path.join(storeRoot, 'initiatives'));
+      expect(initiatives.toStorePath('launch-billing-flow/initiative.yaml')).toBe(
+        'initiatives/launch-billing-flow/initiative.yaml'
+      );
+      expect(initiatives.toStorePath()).toBe('initiatives');
+      expect(fs.existsSync(path.join(storeRoot, 'initiatives'))).toBe(false);
+    });
+
+    it('preserves Windows-style store roots when resolving filesystem paths', () => {
+      const registry = createCollectionRegistry([{ id: 'initiatives', mount: 'initiatives' }]);
+      const mounted = mountCollections({
+        storeRoot: 'D:\\stores\\acme-context',
+        collections: registry,
+      });
+      const initiatives = mounted.require('initiatives');
+
+      expect(initiatives.mountRoot).toBe('D:\\stores\\acme-context\\initiatives');
+      expect(initiatives.resolvePath('launch/initiative.yaml')).toBe(
+        'D:\\stores\\acme-context\\initiatives\\launch\\initiative.yaml'
+      );
+      expect(initiatives.toStorePath('launch/initiative.yaml')).toBe(
+        'initiatives/launch/initiative.yaml'
+      );
+    });
+
+    it('passes mounted context into collection handles', () => {
+      const seenContexts: MountedCollectionContext[] = [];
+      const registry = createCollectionRegistry([
+        {
+          id: 'initiatives',
+          mount: 'initiatives',
+          createHandle(context) {
+            seenContexts.push(context);
+            return {
+              rootPath: context.resolvePath(),
+              storePath: context.toStorePath('launch/initiative.yaml'),
+            };
+          },
+        },
+        { id: 'decisions', mount: 'decisions' },
+      ]);
+
+      const storeRoot = path.join(tempDir, 'acme-context');
+      const mounted = mountCollections({ storeRoot, collections: registry });
+      const initiatives = mounted.require<{
+        rootPath: string;
+        storePath: string;
+      }>('initiatives');
+      const decisions = mounted.require('decisions');
+
+      expect(seenContexts).toHaveLength(1);
+      expect(seenContexts[0].collectionId).toBe('initiatives');
+      expect(initiatives.handle).toEqual({
+        rootPath: path.join(storeRoot, 'initiatives'),
+        storePath: 'initiatives/launch/initiative.yaml',
+      });
+      expect(decisions.handle).toBeUndefined();
+      expect(mounted.get('missing')).toBeUndefined();
+      expect(() => mounted.require('missing')).toThrow(/Unknown mounted collection/u);
+    });
+
+    it('rejects empty store roots', () => {
+      const registry = createCollectionRegistry([{ id: 'initiatives', mount: 'initiatives' }]);
+
+      expect(() => mountCollections({ storeRoot: '', collections: registry })).toThrow(
+        /must not be empty/u
+      );
+    });
+  });
+});