orbital-command 0.1.4 → 0.3.0

package/server/services/scope-cache.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ScopeCache } from './scope-cache.js';
+import type { ParsedScope } from '../parsers/scope-parser.js';
+
+function makeScope(overrides: Partial<ParsedScope> & { id: number }): ParsedScope {
+  return {
+    title: `Scope ${overrides.id}`,
+    slug: undefined,
+    status: 'backlog',
+    priority: null,
+    effort_estimate: null,
+    category: null,
+    tags: [],
+    blocked_by: [],
+    blocks: [],
+    file_path: `/scopes/backlog/${String(overrides.id).padStart(3, '0')}-test.md`,
+    created_at: null,
+    updated_at: null,
+    raw_content: '',
+    sessions: {},
+    is_ghost: false,
+    favourite: false,
+    ...overrides,
+  };
+}
+
+describe('ScopeCache', () => {
+  let cache: ScopeCache;
+
+  beforeEach(() => {
+    cache = new ScopeCache();
+  });
+
+  describe('loadAll()', () => {
+    it('populates both indexes', () => {
+      const scopes = [makeScope({ id: 1 }), makeScope({ id: 2 })];
+      cache.loadAll(scopes);
+      expect(cache.size).toBe(2);
+      expect(cache.getById(1)).toBeDefined();
+      expect(cache.getById(2)).toBeDefined();
+    });
+
+    it('clears previous data on re-load', () => {
+      cache.loadAll([makeScope({ id: 1 })]);
+      expect(cache.size).toBe(1);
+
+      cache.loadAll([makeScope({ id: 5 }), makeScope({ id: 6 })]);
+      expect(cache.size).toBe(2);
+      expect(cache.has(1)).toBe(false);
+      expect(cache.has(5)).toBe(true);
+    });
+  });
+
+  describe('set()', () => {
+    it('adds new scope', () => {
+      cache.set(makeScope({ id: 10 }));
+      expect(cache.has(10)).toBe(true);
+      expect(cache.size).toBe(1);
+    });
+
+    it('updates existing scope', () => {
+      cache.set(makeScope({ id: 10, title: 'Original' }));
+      cache.set(makeScope({ id: 10, title: 'Updated' }));
+      expect(cache.getById(10)?.title).toBe('Updated');
+      expect(cache.size).toBe(1);
+    });
+
+    it('cleans up old file_path index when scope moves', () => {
+      const oldPath = '/scopes/backlog/010-test.md';
+      const newPath = '/scopes/implementing/010-test.md';
+
+      cache.set(makeScope({ id: 10, file_path: oldPath }));
+      expect(cache.idByFilePath(oldPath)).toBe(10);
+
+      cache.set(makeScope({ id: 10, file_path: newPath }));
+      expect(cache.idByFilePath(oldPath)).toBeUndefined();
+      expect(cache.idByFilePath(newPath)).toBe(10);
+    });
+  });
+
+  describe('removeByFilePath()', () => {
+    it('removes from both indexes and returns removed ID', () => {
+      const scope = makeScope({ id: 10 });
+      cache.set(scope);
+
+      const removedId = cache.removeByFilePath(scope.file_path);
+      expect(removedId).toBe(10);
+      expect(cache.has(10)).toBe(false);
+      expect(cache.idByFilePath(scope.file_path)).toBeUndefined();
+    });
+
+    it('returns undefined for unknown path', () => {
+      expect(cache.removeByFilePath('/nonexistent')).toBeUndefined();
+    });
+  });
+
+  describe('read operations', () => {
+    beforeEach(() => {
+      cache.loadAll([
+        makeScope({ id: 3, title: 'Three' }),
+        makeScope({ id: 1, title: 'One' }),
+        makeScope({ id: 2, title: 'Two' }),
+      ]);
+    });
+
+    it('getById() returns scope or undefined', () => {
+      expect(cache.getById(1)?.title).toBe('One');
+      expect(cache.getById(999)).toBeUndefined();
+    });
+
+    it('getAll() returns sorted by ID', () => {
+      const all = cache.getAll();
+      expect(all.map(s => s.id)).toEqual([1, 2, 3]);
+    });
+
+    it('has() returns boolean', () => {
+      expect(cache.has(1)).toBe(true);
+      expect(cache.has(999)).toBe(false);
+    });
+
+    it('idByFilePath() returns ID or undefined', () => {
+      const scope = cache.getById(1)!;
+      expect(cache.idByFilePath(scope.file_path)).toBe(1);
+      expect(cache.idByFilePath('/nonexistent')).toBeUndefined();
+    });
+  });
+
+  describe('maxNonIceboxId()', () => {
+    it('returns 0 for empty cache', () => {
+      expect(cache.maxNonIceboxId()).toBe(0);
+    });
+
+    it('returns highest raw ID', () => {
+      cache.loadAll([
+        makeScope({ id: 10, status: 'backlog' }),
+        makeScope({ id: 20, status: 'implementing' }),
+        makeScope({ id: 5, status: 'review' }),
+      ]);
+      expect(cache.maxNonIceboxId()).toBe(20);
+    });
+
+    it('ignores icebox-status scopes', () => {
+      cache.loadAll([
+        makeScope({ id: 10, status: 'backlog' }),
+        makeScope({ id: 50, status: 'icebox' }),
+      ]);
+      expect(cache.maxNonIceboxId()).toBe(10);
+    });
+
+    it('decodes encoded IDs (>= 1000) to raw numbers', () => {
+      // 1047 → suffix-encoded → raw is 1047 % 1000 = 47
+      cache.loadAll([
+        makeScope({ id: 1047, status: 'backlog' }),
+        makeScope({ id: 10, status: 'implementing' }),
+      ]);
+      expect(cache.maxNonIceboxId()).toBe(47);
+    });
+
+    it('skips raw IDs >= 500 (legacy icebox-origin)', () => {
+      cache.loadAll([
+        makeScope({ id: 501, status: 'backlog' }),
+        makeScope({ id: 30, status: 'implementing' }),
+      ]);
+      expect(cache.maxNonIceboxId()).toBe(30);
+    });
+  });
+});

package/server/services/scope-cache.ts

@@ -62,13 +62,16 @@ export class ScopeCache {
 
   /** Get the maximum raw scope number excluding icebox scopes (for next-ID generation).
    *  Cache keys use encoded IDs (suffixed scopes like 047a → 1047, 075x → 9075),
-   *  but next-ID generation needs the raw scope number (047, 075, 087). */
+   *  but next-ID generation needs the raw scope number (047, 075, 087).
+   *  Skips IDs >= 500 to handle legacy icebox-origin files during migration. */
   maxNonIceboxId(): number {
     let max = 0;
     for (const [id, scope] of this.byId) {
       if (scope.status === 'icebox') continue;
       // Decode: encoded IDs ≥1000 have a suffix offset — raw number is id % 1000
       const raw = id >= 1000 ? id % 1000 : id;
+      // Skip legacy icebox-origin IDs (500+) to prevent namespace pollution
+      if (raw >= 500) continue;
       if (raw > max) max = raw;
     }
     return max;

package/server/services/scope-service.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { ScopeService } from './scope-service.js';
+import { ScopeCache } from './scope-cache.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { CONFIG_WITH_HOOKS } from '../../shared/__fixtures__/workflow-configs.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+import type { Emitter } from '../project-emitter.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+describe('ScopeService', () => {
+  let tmpDir: string;
+  let cache: ScopeCache;
+  let emitter: Emitter & { emit: ReturnType<typeof vi.fn> };
+  let engine: WorkflowEngine;
+  let service: ScopeService;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'scope-svc-test-'));
+    cache = new ScopeCache();
+    emitter = createMockEmitter();
+    engine = new WorkflowEngine(CONFIG_WITH_HOOKS);
+    service = new ScopeService(cache, emitter, tmpDir, engine);
+
+    // Create status directories
+    for (const status of ['icebox', 'backlog', 'active', 'review', 'shipped']) {
+      fs.mkdirSync(path.join(tmpDir, status), { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function writeScopeFile(status: string, filename: string, frontmatter: Record<string, unknown>, body: string = '') {
+    const filePath = path.join(tmpDir, status, filename);
+    const yamlLines = Object.entries(frontmatter).map(([k, v]) => {
+      if (Array.isArray(v)) return `${k}: [${v.join(', ')}]`;
+      return `${k}: ${v}`;
+    }).join('\n');
+    fs.writeFileSync(filePath, `---\n${yamlLines}\n---\n${body}\n`);
+    return filePath;
+  }
+
+  // ─── syncFromFilesystem() ─────────────────────────────────
+
+  describe('syncFromFilesystem()', () => {
+    it('loads all .md files into cache', () => {
+      writeScopeFile('backlog', '001-first.md', { title: 'First', status: 'backlog' });
+      writeScopeFile('active', '002-second.md', { title: 'Second', status: 'active' });
+
+      const count = service.syncFromFilesystem();
+      expect(count).toBe(2);
+      expect(cache.size).toBe(2);
+    });
+
+    it('returns 0 for empty directories', () => {
+      expect(service.syncFromFilesystem()).toBe(0);
+    });
+  });
+
+  // ─── getAll() / getById() ─────────────────────────────────
+
+  describe('getAll() / getById()', () => {
+    it('delegates to cache', () => {
+      writeScopeFile('backlog', '001-test.md', { title: 'Test', status: 'backlog' });
+      service.syncFromFilesystem();
+
+      expect(service.getAll()).toHaveLength(1);
+      expect(service.getById(1)?.title).toBe('Test');
+      expect(service.getById(999)).toBeUndefined();
+    });
+  });
+
+  // ─── updateStatus() ──────────────────────────────────────
+
+  describe('updateStatus()', () => {
+    beforeEach(() => {
+      writeScopeFile('backlog', '001-test.md', { title: 'Test', status: 'backlog' });
+      service.syncFromFilesystem();
+    });
+
+    it('validates transition via engine', () => {
+      // backlog → shipped is not a valid edge in CONFIG_WITH_HOOKS
+      const result = service.updateStatus(1, 'shipped', 'patch');
+      expect(result.ok).toBe(false);
+    });
+
+    it('bulk-sync bypasses validation', () => {
+      const result = service.updateStatus(1, 'shipped', 'bulk-sync');
+      expect(result.ok).toBe(true);
+    });
+
+    it('returns NOT_FOUND for unknown scope', () => {
+      const result = service.updateStatus(999, 'active', 'dispatch');
+      expect(result.ok).toBe(false);
+    });
+
+    it('fires onStatusChange callbacks on successful transition', () => {
+      const callback = vi.fn();
+      service.onStatusChange(callback);
+
+      // Use bulk-sync to bypass edge validation — focuses on the callback mechanism
+      const result = service.updateStatus(1, 'active', 'bulk-sync');
+      if (result.ok) {
+        expect(callback).toHaveBeenCalledWith(1, 'active');
+      }
+    });
+  });
+
+  // ─── createIdeaFile() ─────────────────────────────────────
+
+  describe('createIdeaFile()', () => {
+    it('creates file in icebox directory', () => {
+      const result = service.createIdeaFile('My New Idea', 'A description of the idea');
+      expect(result.slug).toBeDefined();
+      expect(result.title).toBe('My New Idea');
+
+      // Verify file exists
+      const files = fs.readdirSync(path.join(tmpDir, 'icebox'));
+      expect(files.length).toBe(1);
+      expect(files[0]).toMatch(/\.md$/);
+    });
+
+    it('slugifies the title', () => {
+      const result = service.createIdeaFile('Some Feature Idea!', '');
+      expect(result.slug).toMatch(/^[a-z0-9-]+$/);
+    });
+  });
+
+  // ─── deleteIdeaFile() ─────────────────────────────────────
+
+  describe('deleteIdeaFile()', () => {
+    it('removes the idea file', () => {
+      const { slug } = service.createIdeaFile('To Delete', '');
+      const result = service.deleteIdeaFile(slug);
+      expect(result).toBe(true);
+
+      const files = fs.readdirSync(path.join(tmpDir, 'icebox'));
+      expect(files).toHaveLength(0);
+    });
+
+    it('returns false for non-existent slug', () => {
+      expect(service.deleteIdeaFile('nonexistent-slug')).toBe(false);
+    });
+  });
+
+  // ─── reconcileDirectories() ───────────────────────────────
+
+  describe('reconcileDirectories()', () => {
+    it('moves files to correct directory based on frontmatter', () => {
+      // Put a file in backlog but with status: active in frontmatter
+      writeScopeFile('backlog', '001-misplaced.md', { title: 'Misplaced', status: 'active' });
+      service.syncFromFilesystem();
+
+      const moved = service.reconcileDirectories();
+      expect(moved).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  // ─── isSuppressed() ──────────────────────────────────────
+
+  describe('isSuppressed()', () => {
+    it('returns false by default', () => {
+      expect(service.isSuppressed('/some/path.md')).toBe(false);
+    });
+  });
+});