sauron-cli 1.3.0 → 1.4.1

package/OpenSpec-main/test/core/artifact-graph/schema.test.ts

@@ -1,207 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseSchema, SchemaValidationError } from '../../../src/core/artifact-graph/schema.js';
-
-describe('artifact-graph/schema', () => {
-  describe('parseSchema', () => {
-    it('should parse valid schema YAML', () => {
-      const yaml = `
-name: test-schema
-version: 1
-description: A test schema
-artifacts:
-  - id: proposal
-    generates: proposal.md
-    description: Initial proposal
-    template: templates/proposal.md
-    requires: []
-  - id: design
-    generates: design.md
-    description: Design document
-    template: templates/design.md
-    requires:
-      - proposal
-`;
-      const schema = parseSchema(yaml);
-
-      expect(schema.name).toBe('test-schema');
-      expect(schema.version).toBe(1);
-      expect(schema.description).toBe('A test schema');
-      expect(schema.artifacts).toHaveLength(2);
-      expect(schema.artifacts[0].id).toBe('proposal');
-      expect(schema.artifacts[1].requires).toEqual(['proposal']);
-    });
-
-    it('should throw on missing required fields', () => {
-      const yaml = `
-name: test-schema
-version: 1
-artifacts:
-  - id: proposal
-    description: Missing generates and template
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/generates/);
-    });
-
-    it('should throw on missing schema name', () => {
-      const yaml = `
-version: 1
-artifacts:
-  - id: proposal
-    generates: proposal.md
-    description: Test
-    template: templates/proposal.md
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/name/);
-    });
-
-    it('should throw on invalid version (non-positive)', () => {
-      const yaml = `
-name: test
-version: 0
-artifacts:
-  - id: proposal
-    generates: proposal.md
-    description: Test
-    template: templates/proposal.md
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/positive/);
-    });
-
-    it('should throw on empty artifacts array', () => {
-      const yaml = `
-name: test
-version: 1
-artifacts: []
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/artifact/i);
-    });
-
-    it('should throw on duplicate artifact IDs', () => {
-      const yaml = `
-name: test
-version: 1
-artifacts:
-  - id: proposal
-    generates: proposal.md
-    description: First
-    template: templates/proposal.md
-  - id: proposal
-    generates: other.md
-    description: Duplicate
-    template: templates/other.md
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/Duplicate artifact ID: proposal/);
-    });
-
-    it('should throw on invalid requires reference', () => {
-      const yaml = `
-name: test
-version: 1
-artifacts:
-  - id: design
-    generates: design.md
-    description: Design doc
-    template: templates/design.md
-    requires:
-      - nonexistent
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/Invalid dependency reference.*nonexistent/);
-    });
-
-    it('should detect self-referencing cycle', () => {
-      const yaml = `
-name: test
-version: 1
-artifacts:
-  - id: A
-    generates: a.md
-    description: Self reference
-    template: templates/a.md
-    requires:
-      - A
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/Cyclic dependency detected/);
-    });
-
-    it('should detect simple A → B → A cycle', () => {
-      const yaml = `
-name: test
-version: 1
-artifacts:
-  - id: A
-    generates: a.md
-    description: A
-    template: templates/a.md
-    requires:
-      - B
-  - id: B
-    generates: b.md
-    description: B
-    template: templates/b.md
-    requires:
-      - A
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/Cyclic dependency detected/);
-      expect(() => parseSchema(yaml)).toThrow(/→/);
-    });
-
-    it('should detect longer A → B → C → A cycle and list all IDs', () => {
-      const yaml = `
-name: test
-version: 1
-artifacts:
-  - id: A
-    generates: a.md
-    description: A
-    template: templates/a.md
-    requires:
-      - C
-  - id: B
-    generates: b.md
-    description: B
-    template: templates/b.md
-    requires:
-      - A
-  - id: C
-    generates: c.md
-    description: C
-    template: templates/c.md
-    requires:
-      - B
-`;
-      expect(() => parseSchema(yaml)).toThrow(SchemaValidationError);
-      expect(() => parseSchema(yaml)).toThrow(/Cyclic dependency detected/);
-      // Should contain all three in the cycle path
-      const error = (() => {
-        try {
-          parseSchema(yaml);
-        } catch (e) {
-          return e;
-        }
-      })() as Error;
-      expect(error.message).toMatch(/A.*→.*B|B.*→.*C|C.*→.*A/);
-    });
-
-    it('should allow default empty requires array', () => {
-      const yaml = `
-name: test
-version: 1
-artifacts:
-  - id: root
-    generates: root.md
-    description: Root artifact
-    template: templates/root.md
-`;
-      const schema = parseSchema(yaml);
-      expect(schema.artifacts[0].requires).toEqual([]);
-    });
-  });
-});

package/OpenSpec-main/test/core/artifact-graph/state.test.ts

@@ -1,174 +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 { detectCompleted } from '../../../src/core/artifact-graph/state.js';
-import { ArtifactGraph } from '../../../src/core/artifact-graph/graph.js';
-import type { SchemaYaml } from '../../../src/core/artifact-graph/types.js';
-
-describe('artifact-graph/state', () => {
-  let tempDir: string;
-
-  const createSchema = (artifacts: SchemaYaml['artifacts']): SchemaYaml => ({
-    name: 'test',
-    version: 1,
-    artifacts,
-  });
-
-  beforeEach(() => {
-    tempDir = path.join(os.tmpdir(), `openspec-state-test-${Date.now()}`);
-    fs.mkdirSync(tempDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('detectCompleted', () => {
-    it('should return empty set when changeDir does not exist', () => {
-      const schema = createSchema([
-        { id: 'A', generates: 'a.md', description: 'A', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      const completed = detectCompleted(graph, '/nonexistent/path');
-
-      expect(completed.size).toBe(0);
-    });
-
-    it('should return empty set when changeDir is empty', () => {
-      const schema = createSchema([
-        { id: 'A', generates: 'a.md', description: 'A', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.size).toBe(0);
-    });
-
-    it('should mark artifact complete when file exists', () => {
-      const schema = createSchema([
-        { id: 'proposal', generates: 'proposal.md', description: 'Proposal', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Create the file
-      fs.writeFileSync(path.join(tempDir, 'proposal.md'), 'content');
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.has('proposal')).toBe(true);
-    });
-
-    it('should not mark artifact complete when file does not exist', () => {
-      const schema = createSchema([
-        { id: 'proposal', generates: 'proposal.md', description: 'Proposal', template: 't.md', requires: [] },
-        { id: 'design', generates: 'design.md', description: 'Design', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Only create proposal.md
-      fs.writeFileSync(path.join(tempDir, 'proposal.md'), 'content');
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.has('proposal')).toBe(true);
-      expect(completed.has('design')).toBe(false);
-    });
-
-    it('should handle nested paths', () => {
-      const schema = createSchema([
-        { id: 'nested', generates: 'docs/design.md', description: 'Nested', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Create nested directory and file
-      fs.mkdirSync(path.join(tempDir, 'docs'), { recursive: true });
-      fs.writeFileSync(path.join(tempDir, 'docs', 'design.md'), 'content');
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.has('nested')).toBe(true);
-    });
-
-    it('should detect glob pattern as complete when files exist', () => {
-      const schema = createSchema([
-        { id: 'specs', generates: 'specs/*.md', description: 'Specs', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Create specs directory with files
-      fs.mkdirSync(path.join(tempDir, 'specs'), { recursive: true });
-      fs.writeFileSync(path.join(tempDir, 'specs', 'feature-a.md'), 'content');
-      fs.writeFileSync(path.join(tempDir, 'specs', 'feature-b.md'), 'content');
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.has('specs')).toBe(true);
-    });
-
-    it('should not mark glob pattern complete when directory is empty', () => {
-      const schema = createSchema([
-        { id: 'specs', generates: 'specs/*.md', description: 'Specs', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Create empty specs directory
-      fs.mkdirSync(path.join(tempDir, 'specs'), { recursive: true });
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.has('specs')).toBe(false);
-    });
-
-    it('should not mark glob pattern complete when directory does not exist', () => {
-      const schema = createSchema([
-        { id: 'specs', generates: 'specs/*.md', description: 'Specs', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.has('specs')).toBe(false);
-    });
-
-    it('should not mark glob pattern complete when only non-matching files exist', () => {
-      const schema = createSchema([
-        { id: 'specs', generates: 'specs/*.md', description: 'Specs', template: 't.md', requires: [] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Create specs directory with non-matching files
-      fs.mkdirSync(path.join(tempDir, 'specs'), { recursive: true });
-      fs.writeFileSync(path.join(tempDir, 'specs', 'readme.txt'), 'content');
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.has('specs')).toBe(false);
-    });
-
-    it('should handle multiple artifacts with mixed completion', () => {
-      const schema = createSchema([
-        { id: 'proposal', generates: 'proposal.md', description: 'Proposal', template: 't.md', requires: [] },
-        { id: 'specs', generates: 'specs/*.md', description: 'Specs', template: 't.md', requires: ['proposal'] },
-        { id: 'design', generates: 'design.md', description: 'Design', template: 't.md', requires: ['proposal'] },
-        { id: 'tasks', generates: 'tasks.md', description: 'Tasks', template: 't.md', requires: ['specs', 'design'] },
-      ]);
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Create some files
-      fs.writeFileSync(path.join(tempDir, 'proposal.md'), 'content');
-      fs.mkdirSync(path.join(tempDir, 'specs'), { recursive: true });
-      fs.writeFileSync(path.join(tempDir, 'specs', 'auth.md'), 'content');
-      // design.md and tasks.md do not exist
-
-      const completed = detectCompleted(graph, tempDir);
-
-      expect(completed.has('proposal')).toBe(true);
-      expect(completed.has('specs')).toBe(true);
-      expect(completed.has('design')).toBe(false);
-      expect(completed.has('tasks')).toBe(false);
-    });
-  });
-});

package/OpenSpec-main/test/core/artifact-graph/workflow.integration.test.ts

@@ -1,182 +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 { resolveSchema } from '../../../src/core/artifact-graph/resolver.js';
-import { ArtifactGraph } from '../../../src/core/artifact-graph/graph.js';
-import { detectCompleted } from '../../../src/core/artifact-graph/state.js';
-import type { BlockedArtifacts } from '../../../src/core/artifact-graph/types.js';
-
-/**
- * Normalize BlockedArtifacts for comparison by sorting dependency arrays.
- * The order of unmet dependencies is not guaranteed, so we sort for stable assertions.
- */
-function normalizeBlocked(blocked: BlockedArtifacts): BlockedArtifacts {
-  const normalized: BlockedArtifacts = {};
-  for (const [key, deps] of Object.entries(blocked)) {
-    normalized[key] = [...deps].sort();
-  }
-  return normalized;
-}
-
-describe('artifact-graph workflow integration', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    // Use a unique temp directory for each test
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-workflow-test-'));
-  });
-
-  afterEach(() => {
-    // Clean up temp directory after each test
-    if (tempDir && fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('spec-driven workflow', () => {
-    it('should progress through complete workflow', () => {
-      // 1. Resolve the real built-in schema
-      const schema = resolveSchema('spec-driven');
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Verify schema structure
-      expect(graph.getName()).toBe('spec-driven');
-      expect(graph.getAllArtifacts()).toHaveLength(4);
-
-      // 2. Initial state - nothing complete, only proposal is ready
-      let completed = detectCompleted(graph, tempDir);
-      expect(completed.size).toBe(0);
-      expect(graph.getNextArtifacts(completed)).toEqual(['proposal']);
-      expect(graph.isComplete(completed)).toBe(false);
-      expect(normalizeBlocked(graph.getBlocked(completed))).toEqual({
-        specs: ['proposal'],
-        design: ['proposal'],
-        tasks: ['design', 'specs'],
-      });
-
-      // 3. Create proposal.md - now specs and design become ready
-      fs.writeFileSync(path.join(tempDir, 'proposal.md'), '# Proposal\n\nInitial proposal content.');
-      completed = detectCompleted(graph, tempDir);
-      expect(completed).toEqual(new Set(['proposal']));
-      expect(graph.getNextArtifacts(completed).sort()).toEqual(['design', 'specs']);
-      expect(normalizeBlocked(graph.getBlocked(completed))).toEqual({
-        tasks: ['design', 'specs'],
-      });
-
-      // 4. Create design.md - specs still needed for tasks
-      fs.writeFileSync(path.join(tempDir, 'design.md'), '# Design\n\nTechnical design content.');
-      completed = detectCompleted(graph, tempDir);
-      expect(completed).toEqual(new Set(['proposal', 'design']));
-      expect(graph.getNextArtifacts(completed)).toEqual(['specs']);
-      expect(graph.getBlocked(completed)).toEqual({
-        tasks: ['specs'],
-      });
-
-      // 5. Create specs directory with a spec file - tasks becomes ready
-      const specsDir = path.join(tempDir, 'specs');
-      fs.mkdirSync(specsDir, { recursive: true });
-      fs.writeFileSync(path.join(specsDir, 'feature-auth.md'), '# Auth Spec\n\nAuthentication specification.');
-      completed = detectCompleted(graph, tempDir);
-      expect(completed).toEqual(new Set(['proposal', 'design', 'specs']));
-      expect(graph.getNextArtifacts(completed)).toEqual(['tasks']);
-      expect(graph.getBlocked(completed)).toEqual({});
-
-      // 6. Create tasks.md - workflow complete
-      fs.writeFileSync(path.join(tempDir, 'tasks.md'), '# Tasks\n\n- [ ] Implement feature');
-      completed = detectCompleted(graph, tempDir);
-      expect(completed).toEqual(new Set(['proposal', 'design', 'specs', 'tasks']));
-      expect(graph.getNextArtifacts(completed)).toEqual([]);
-      expect(graph.isComplete(completed)).toBe(true);
-      expect(graph.getBlocked(completed)).toEqual({});
-    });
-
-    it('should handle out-of-order file creation', () => {
-      const schema = resolveSchema('spec-driven');
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Create files in wrong order - design before proposal
-      fs.writeFileSync(path.join(tempDir, 'design.md'), '# Design');
-
-      let completed = detectCompleted(graph, tempDir);
-      // design file exists but it's still marked complete (filesystem-based)
-      expect(completed).toEqual(new Set(['design']));
-      // proposal is still the only "ready" artifact since it has no deps
-      expect(graph.getNextArtifacts(completed)).toEqual(['proposal']);
-
-      // Now create proposal
-      fs.writeFileSync(path.join(tempDir, 'proposal.md'), '# Proposal');
-      completed = detectCompleted(graph, tempDir);
-      expect(completed).toEqual(new Set(['proposal', 'design']));
-      // specs is the only thing ready now (design already done)
-      expect(graph.getNextArtifacts(completed)).toEqual(['specs']);
-    });
-
-    it('should handle multiple spec files in glob pattern', () => {
-      const schema = resolveSchema('spec-driven');
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Complete prerequisites
-      fs.writeFileSync(path.join(tempDir, 'proposal.md'), '# Proposal');
-
-      // Create specs directory with multiple files
-      const specsDir = path.join(tempDir, 'specs');
-      fs.mkdirSync(specsDir, { recursive: true });
-      fs.writeFileSync(path.join(specsDir, 'auth.md'), '# Auth');
-      fs.writeFileSync(path.join(specsDir, 'api.md'), '# API');
-      fs.writeFileSync(path.join(specsDir, 'database.md'), '# Database');
-
-      const completed = detectCompleted(graph, tempDir);
-      expect(completed.has('specs')).toBe(true);
-    });
-  });
-
-  describe('build order consistency', () => {
-    it('should return consistent build order across multiple calls', () => {
-      const schema = resolveSchema('spec-driven');
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      const order1 = graph.getBuildOrder();
-      const order2 = graph.getBuildOrder();
-      const order3 = graph.getBuildOrder();
-
-      expect(order1).toEqual(order2);
-      expect(order2).toEqual(order3);
-    });
-  });
-
-  describe('empty and edge cases', () => {
-    it('should handle empty change directory gracefully', () => {
-      const schema = resolveSchema('spec-driven');
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Directory exists but is empty
-      const completed = detectCompleted(graph, tempDir);
-      expect(completed.size).toBe(0);
-      expect(graph.getNextArtifacts(completed)).toEqual(['proposal']);
-    });
-
-    it('should handle non-existent change directory', () => {
-      const schema = resolveSchema('spec-driven');
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      const nonExistentDir = path.join(tempDir, 'does-not-exist');
-      const completed = detectCompleted(graph, nonExistentDir);
-      expect(completed.size).toBe(0);
-    });
-
-    it('should not count non-matching files in glob directories', () => {
-      const schema = resolveSchema('spec-driven');
-      const graph = ArtifactGraph.fromSchema(schema);
-
-      // Create specs directory with wrong file types
-      const specsDir = path.join(tempDir, 'specs');
-      fs.mkdirSync(specsDir, { recursive: true });
-      fs.writeFileSync(path.join(specsDir, 'notes.txt'), 'not a markdown file');
-      fs.writeFileSync(path.join(specsDir, 'data.json'), '{}');
-
-      const completed = detectCompleted(graph, tempDir);
-      expect(completed.has('specs')).toBe(false);
-    });
-  });
-});