@applica-software-guru/sdd-core 1.3.3 → 1.4.0

package/tests/api-client.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+  resolveApiKey,
+  buildApiConfig,
+  pullDocs,
+  pushDocs,
+  fetchPendingCRs,
+  fetchOpenBugs,
+  markCRAppliedRemote,
+  markBugResolvedRemote,
+} from '../src/remote/api-client.js';
+import { RemoteError, RemoteNotConfiguredError } from '../src/errors.js';
+import type { SDDConfig } from '../src/types.js';
+
+function mockFetch(response: unknown, ok = true, status = 200) {
+  return vi.fn().mockResolvedValue({
+    ok,
+    status,
+    statusText: ok ? 'OK' : 'Error',
+    json: async () => response,
+  });
+}
+
+const BASE_CONFIG: SDDConfig = {
+  description: 'test',
+  remote: {
+    url: 'http://test.local/api/v1',
+    'api-key': 'config-key-123',
+  },
+};
+
+const API = { baseUrl: 'http://test.local/api/v1', apiKey: 'key123' };
+
+describe('resolveApiKey', () => {
+  const originalEnv = process.env.SDD_API_KEY;
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.SDD_API_KEY = originalEnv;
+    } else {
+      delete process.env.SDD_API_KEY;
+    }
+  });
+
+  it('returns env var when set', () => {
+    process.env.SDD_API_KEY = 'env-key-456';
+    expect(resolveApiKey(BASE_CONFIG)).toBe('env-key-456');
+  });
+
+  it('falls back to config api-key when env var is unset', () => {
+    delete process.env.SDD_API_KEY;
+    expect(resolveApiKey(BASE_CONFIG)).toBe('config-key-123');
+  });
+
+  it('returns null when neither is available', () => {
+    delete process.env.SDD_API_KEY;
+    expect(resolveApiKey({ description: 'test' })).toBeNull();
+  });
+});
+
+describe('buildApiConfig', () => {
+  afterEach(() => {
+    delete process.env.SDD_API_KEY;
+  });
+
+  it('builds config from SDDConfig', () => {
+    delete process.env.SDD_API_KEY;
+    const result = buildApiConfig(BASE_CONFIG);
+    expect(result.baseUrl).toBe('http://test.local/api/v1');
+    expect(result.apiKey).toBe('config-key-123');
+  });
+
+  it('strips trailing slashes from URL', () => {
+    delete process.env.SDD_API_KEY;
+    const config: SDDConfig = {
+      description: 'test',
+      remote: { url: 'http://test.local/api/v1/', 'api-key': 'k' },
+    };
+    expect(buildApiConfig(config).baseUrl).toBe('http://test.local/api/v1');
+  });
+
+  it('throws when remote not configured', () => {
+    expect(() => buildApiConfig({ description: 'test' })).toThrow(RemoteNotConfiguredError);
+  });
+
+  it('throws when no API key available', () => {
+    delete process.env.SDD_API_KEY;
+    const config: SDDConfig = { description: 'test', remote: { url: 'http://test.local' } };
+    expect(() => buildApiConfig(config)).toThrow(RemoteNotConfiguredError);
+  });
+});
+
+describe('API client functions', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it('pullDocs sends GET with auth header', async () => {
+    const mock = mockFetch([]);
+    globalThis.fetch = mock;
+
+    const result = await pullDocs(API);
+    expect(result).toEqual([]);
+    expect(mock).toHaveBeenCalledWith(
+      'http://test.local/api/v1/cli/pull-docs',
+      expect.objectContaining({
+        method: 'GET',
+        headers: expect.objectContaining({
+          Authorization: 'Bearer key123',
+        }),
+      }),
+    );
+  });
+
+  it('pushDocs sends POST with body', async () => {
+    const mock = mockFetch({ created: 1, updated: 0, documents: [] });
+    globalThis.fetch = mock;
+
+    const docs = [{ path: 'product/vision.md', title: 'Vision', content: 'body' }];
+    await pushDocs(API, docs);
+
+    expect(mock).toHaveBeenCalledWith(
+      'http://test.local/api/v1/cli/push-docs',
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({ documents: docs }),
+      }),
+    );
+  });
+
+  it('fetchPendingCRs sends GET to correct endpoint', async () => {
+    const mock = mockFetch([]);
+    globalThis.fetch = mock;
+
+    await fetchPendingCRs(API);
+    expect(mock).toHaveBeenCalledWith(
+      'http://test.local/api/v1/cli/pending-crs',
+      expect.objectContaining({ method: 'GET' }),
+    );
+  });
+
+  it('fetchOpenBugs sends GET to correct endpoint', async () => {
+    const mock = mockFetch([]);
+    globalThis.fetch = mock;
+
+    await fetchOpenBugs(API);
+    expect(mock).toHaveBeenCalledWith(
+      'http://test.local/api/v1/cli/open-bugs',
+      expect.objectContaining({ method: 'GET' }),
+    );
+  });
+
+  it('markCRAppliedRemote sends POST with cr ID', async () => {
+    const mock = mockFetch({ id: 'abc', status: 'applied' });
+    globalThis.fetch = mock;
+
+    await markCRAppliedRemote(API, 'abc-123');
+    expect(mock).toHaveBeenCalledWith(
+      'http://test.local/api/v1/cli/crs/abc-123/applied',
+      expect.objectContaining({ method: 'POST' }),
+    );
+  });
+
+  it('markBugResolvedRemote sends POST with bug ID', async () => {
+    const mock = mockFetch({ id: 'xyz', status: 'resolved' });
+    globalThis.fetch = mock;
+
+    await markBugResolvedRemote(API, 'xyz-456');
+    expect(mock).toHaveBeenCalledWith(
+      'http://test.local/api/v1/cli/bugs/xyz-456/resolved',
+      expect.objectContaining({ method: 'POST' }),
+    );
+  });
+
+  it('throws RemoteError on non-OK response', async () => {
+    globalThis.fetch = mockFetch({ detail: 'Invalid API key' }, false, 401);
+
+    await expect(pullDocs(API)).rejects.toThrow(RemoteError);
+    await expect(pullDocs(API)).rejects.toThrow('Remote error (401)');
+  });
+
+  it('handles non-JSON error responses', async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+      json: async () => { throw new Error('not json'); },
+    });
+
+    await expect(pullDocs(API)).rejects.toThrow('Internal Server Error');
+  });
+});

package/tests/cr.test.ts

@@ -23,6 +23,23 @@ Add JWT-based authentication to the API.
 - Update \`system/entities.md\` to add User entity
 `;
 
+const CR_PENDING = `---
+title: "Add authentication"
+status: pending
+author: "user"
+created-at: "2025-01-01T00:00:00.000Z"
+---
+
+## Description
+
+Add JWT-based authentication to the API.
+
+## Changes
+
+- Create \`product/features/auth.md\` with login/logout flows
+- Update \`system/entities.md\` to add User entity
+`;
+
 const CR_APPLIED = `---
 title: "Fix navigation"
 status: applied
@@ -110,18 +127,18 @@ describe('SDD CR methods', () => {
     expect(crs[1].frontmatter.title).toBe('Fix navigation');
   });
 
-  it('pendingChangeRequests() returns only draft CRs', async () => {
-    await writeFile(join(tempDir, 'change-requests/CR-001.md'), CR_DRAFT, 'utf-8');
+  it('pendingChangeRequests() returns only pending CRs', async () => {
+    await writeFile(join(tempDir, 'change-requests/CR-001.md'), CR_PENDING, 'utf-8');
     await writeFile(join(tempDir, 'change-requests/CR-002.md'), CR_APPLIED, 'utf-8');
 
     const pending = await sdd.pendingChangeRequests();
     expect(pending).toHaveLength(1);
-    expect(pending[0].frontmatter.status).toBe('draft');
+    expect(pending[0].frontmatter.status).toBe('pending');
     expect(pending[0].frontmatter.title).toBe('Add authentication');
   });
 
-  it('markCRApplied() changes draft to applied', async () => {
-    await writeFile(join(tempDir, 'change-requests/CR-001.md'), CR_DRAFT, 'utf-8');
+  it('markCRApplied() changes pending to applied', async () => {
+    await writeFile(join(tempDir, 'change-requests/CR-001.md'), CR_PENDING, 'utf-8');
 
     const marked = await sdd.markCRApplied(['change-requests/CR-001.md']);
     expect(marked).toEqual(['change-requests/CR-001.md']);
@@ -130,10 +147,10 @@ describe('SDD CR methods', () => {
     expect(content).toContain('status: applied');
   });
 
-  it('markCRApplied() without args marks all draft CRs', async () => {
-    await writeFile(join(tempDir, 'change-requests/CR-001.md'), CR_DRAFT, 'utf-8');
-    const draft2 = CR_DRAFT.replace('Add authentication', 'Second CR');
-    await writeFile(join(tempDir, 'change-requests/CR-002.md'), draft2, 'utf-8');
+  it('markCRApplied() without args marks all pending CRs', async () => {
+    await writeFile(join(tempDir, 'change-requests/CR-001.md'), CR_PENDING, 'utf-8');
+    const pending2 = CR_PENDING.replace('Add authentication', 'Second CR');
+    await writeFile(join(tempDir, 'change-requests/CR-002.md'), pending2, 'utf-8');
 
     const marked = await sdd.markCRApplied();
     expect(marked).toHaveLength(2);
@@ -147,7 +164,7 @@ describe('SDD CR methods', () => {
   });
 
   it('integration: create CR → pending → mark applied → no longer pending', async () => {
-    await writeFile(join(tempDir, 'change-requests/CR-001.md'), CR_DRAFT, 'utf-8');
+    await writeFile(join(tempDir, 'change-requests/CR-001.md'), CR_PENDING, 'utf-8');
 
     // Should be pending
     let pending = await sdd.pendingChangeRequests();

package/tests/remote-state.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, mkdir, readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { readRemoteState, writeRemoteState } from '../src/remote/state.js';
+import type { RemoteState } from '../src/remote/types.js';
+
+describe('Remote state manager', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'sdd-remote-state-'));
+    await mkdir(join(tempDir, '.sdd'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true });
+  });
+
+  it('returns empty state when file does not exist', async () => {
+    const state = await readRemoteState(tempDir);
+    expect(state).toEqual({ documents: {} });
+  });
+
+  it('round-trips state correctly', async () => {
+    const state: RemoteState = {
+      lastPull: '2026-01-01T00:00:00.000Z',
+      lastPush: '2026-01-01T00:00:00.000Z',
+      documents: {
+        'product/vision.md': {
+          remoteId: 'abc-123',
+          remoteVersion: 3,
+          localHash: 'deadbeef',
+          lastSynced: '2026-01-01T00:00:00.000Z',
+        },
+      },
+    };
+
+    await writeRemoteState(tempDir, state);
+    const result = await readRemoteState(tempDir);
+    expect(result).toEqual(state);
+  });
+
+  it('creates .sdd directory if missing', async () => {
+    const freshDir = await mkdtemp(join(tmpdir(), 'sdd-fresh-'));
+    const state: RemoteState = { documents: {} };
+
+    await writeRemoteState(freshDir, state);
+    expect(existsSync(join(freshDir, '.sdd', 'remote-state.json'))).toBe(true);
+
+    await rm(freshDir, { recursive: true });
+  });
+
+  it('handles corrupt JSON gracefully', async () => {
+    const { writeFile } = await import('node:fs/promises');
+    await writeFile(join(tempDir, '.sdd', 'remote-state.json'), 'not valid json', 'utf-8');
+
+    const state = await readRemoteState(tempDir);
+    expect(state).toEqual({ documents: {} });
+  });
+
+  it('updates individual document entries', async () => {
+    const state: RemoteState = {
+      documents: {
+        'product/vision.md': {
+          remoteId: 'a',
+          remoteVersion: 1,
+          localHash: 'hash1',
+          lastSynced: '2026-01-01T00:00:00.000Z',
+        },
+      },
+    };
+
+    await writeRemoteState(tempDir, state);
+
+    // Add a new document
+    state.documents['system/entities.md'] = {
+      remoteId: 'b',
+      remoteVersion: 2,
+      localHash: 'hash2',
+      lastSynced: '2026-01-02T00:00:00.000Z',
+    };
+
+    await writeRemoteState(tempDir, state);
+    const result = await readRemoteState(tempDir);
+    expect(Object.keys(result.documents)).toHaveLength(2);
+    expect(result.documents['system/entities.md'].remoteVersion).toBe(2);
+  });
+});

package/tests/sync-engine.test.ts

@@ -0,0 +1,341 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtemp, rm, writeFile, readFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { SDD } from '../src/sdd.js';
+import { readRemoteState } from '../src/remote/state.js';
+import type { RemoteDocResponse, RemoteDocBulkResponse, RemoteCRResponse, RemoteBugResponse } from '../src/remote/types.js';
+
+function git(cmd: string, cwd: string): string {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+}
+
+const VISION_MD = `---
+title: "Product Vision"
+status: new
+author: "user"
+last-modified: "2024-01-01T00:00:00.000Z"
+version: "1.0"
+---
+
+# Product Vision
+
+A test project.
+`;
+
+const VISION_SYNCED = VISION_MD.replace('status: new', 'status: synced');
+
+function makeDocResponse(overrides: Partial<RemoteDocResponse> = {}): RemoteDocResponse {
+  return {
+    id: 'doc-001',
+    project_id: 'proj-001',
+    path: 'product/vision.md',
+    title: 'Product Vision',
+    status: 'synced',
+    version: 1,
+    content: '# Product Vision\n\nA test project.\n',
+    last_modified_by: null,
+    created_at: '2026-01-01T00:00:00.000Z',
+    updated_at: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+describe('Sync engine - push', () => {
+  let tempDir: string;
+  let sdd: SDD;
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(async () => {
+    originalFetch = globalThis.fetch;
+    tempDir = await mkdtemp(join(tmpdir(), 'sdd-sync-push-'));
+    sdd = new SDD({ root: tempDir });
+    await sdd.init({ description: 'test' });
+    git('config user.email "test@test.com"', tempDir);
+    git('config user.name "Test"', tempDir);
+    // Write remote config
+    const { writeConfig, readConfig } = await import('../src/config/config-manager.js');
+    const config = await readConfig(tempDir);
+    config.remote = { url: 'http://test.local/api/v1', 'api-key': 'test-key' };
+    await writeConfig(tempDir, config);
+  });
+
+  afterEach(async () => {
+    globalThis.fetch = originalFetch;
+    await rm(tempDir, { recursive: true });
+  });
+
+  it('pushes pending files and marks them synced', async () => {
+    await writeFile(join(tempDir, 'product/vision.md'), VISION_MD, 'utf-8');
+
+    const pushResponse: RemoteDocBulkResponse = {
+      created: 1,
+      updated: 0,
+      documents: [makeDocResponse()],
+    };
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => pushResponse,
+    });
+
+    const result = await sdd.push();
+
+    expect(result.created).toBe(1);
+    expect(result.updated).toBe(0);
+    expect(result.pushed).toContain('product/vision.md');
+
+    // Local file should now be synced
+    const content = await readFile(join(tempDir, 'product/vision.md'), 'utf-8');
+    expect(content).toContain('status: synced');
+
+    // Remote state should be updated
+    const state = await readRemoteState(tempDir);
+    expect(state.documents['product/vision.md']).toBeDefined();
+    expect(state.documents['product/vision.md'].remoteId).toBe('doc-001');
+    expect(state.lastPush).toBeDefined();
+  });
+
+  it('skips synced files when no paths specified', async () => {
+    await writeFile(join(tempDir, 'product/vision.md'), VISION_SYNCED, 'utf-8');
+
+    const result = await sdd.push();
+    expect(result.pushed).toHaveLength(0);
+  });
+
+  it('pushes specific paths when provided', async () => {
+    await writeFile(join(tempDir, 'product/vision.md'), VISION_SYNCED, 'utf-8');
+
+    const pushResponse: RemoteDocBulkResponse = {
+      created: 0,
+      updated: 1,
+      documents: [makeDocResponse({ version: 2 })],
+    };
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => pushResponse,
+    });
+
+    const result = await sdd.push(['product/vision.md']);
+    expect(result.pushed).toContain('product/vision.md');
+    expect(result.updated).toBe(1);
+  });
+});
+
+describe('Sync engine - pull', () => {
+  let tempDir: string;
+  let sdd: SDD;
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(async () => {
+    originalFetch = globalThis.fetch;
+    tempDir = await mkdtemp(join(tmpdir(), 'sdd-sync-pull-'));
+    sdd = new SDD({ root: tempDir });
+    await sdd.init({ description: 'test' });
+    git('config user.email "test@test.com"', tempDir);
+    git('config user.name "Test"', tempDir);
+    const { writeConfig, readConfig } = await import('../src/config/config-manager.js');
+    const config = await readConfig(tempDir);
+    config.remote = { url: 'http://test.local/api/v1', 'api-key': 'test-key' };
+    await writeConfig(tempDir, config);
+  });
+
+  afterEach(async () => {
+    globalThis.fetch = originalFetch;
+    await rm(tempDir, { recursive: true });
+  });
+
+  it('creates new local files from remote docs', async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => [makeDocResponse({ path: 'product/new-feature.md', title: 'New Feature' })],
+    });
+
+    const result = await sdd.pull();
+
+    expect(result.created).toContain('product/new-feature.md');
+    expect(existsSync(join(tempDir, 'product/new-feature.md'))).toBe(true);
+
+    const content = await readFile(join(tempDir, 'product/new-feature.md'), 'utf-8');
+    expect(content).toContain('title: New Feature');
+    expect(content).toContain('status: synced');
+  });
+
+  it('detects conflicts when local and remote both changed', async () => {
+    // Write a file and set up remote state
+    await writeFile(join(tempDir, 'product/vision.md'), VISION_MD, 'utf-8');
+    const { writeRemoteState } = await import('../src/remote/state.js');
+    await writeRemoteState(tempDir, {
+      documents: {
+        'product/vision.md': {
+          remoteId: 'doc-001',
+          remoteVersion: 1,
+          localHash: 'different-hash-from-current',
+          lastSynced: '2026-01-01T00:00:00.000Z',
+        },
+      },
+    });
+
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => [makeDocResponse({ version: 2 })],
+    });
+
+    const result = await sdd.pull();
+
+    expect(result.conflicts).toHaveLength(1);
+    expect(result.conflicts[0].path).toBe('product/vision.md');
+    expect(result.conflicts[0].remoteVersion).toBe(2);
+    // File should NOT be overwritten
+    const content = await readFile(join(tempDir, 'product/vision.md'), 'utf-8');
+    expect(content).toContain('status: new');
+  });
+
+  it('updates local files when no local changes detected', async () => {
+    await writeFile(join(tempDir, 'product/vision.md'), VISION_SYNCED, 'utf-8');
+
+    // Compute correct hash for the current content
+    const { createHash } = await import('node:crypto');
+    const currentContent = await readFile(join(tempDir, 'product/vision.md'), 'utf-8');
+    const hash = createHash('sha256').update(currentContent, 'utf-8').digest('hex');
+
+    const { writeRemoteState } = await import('../src/remote/state.js');
+    await writeRemoteState(tempDir, {
+      documents: {
+        'product/vision.md': {
+          remoteId: 'doc-001',
+          remoteVersion: 1,
+          localHash: hash,
+          lastSynced: '2026-01-01T00:00:00.000Z',
+        },
+      },
+    });
+
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => [makeDocResponse({ version: 2, content: '# Updated Vision\n\nNew content.\n' })],
+    });
+
+    const result = await sdd.pull();
+
+    expect(result.updated).toContain('product/vision.md');
+    const content = await readFile(join(tempDir, 'product/vision.md'), 'utf-8');
+    expect(content).toContain('Updated Vision');
+  });
+});
+
+describe('Sync engine - pull CRs', () => {
+  let tempDir: string;
+  let sdd: SDD;
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(async () => {
+    originalFetch = globalThis.fetch;
+    tempDir = await mkdtemp(join(tmpdir(), 'sdd-sync-crs-'));
+    sdd = new SDD({ root: tempDir });
+    await sdd.init({ description: 'test' });
+    const { writeConfig, readConfig } = await import('../src/config/config-manager.js');
+    const config = await readConfig(tempDir);
+    config.remote = { url: 'http://test.local/api/v1', 'api-key': 'test-key' };
+    await writeConfig(tempDir, config);
+  });
+
+  afterEach(async () => {
+    globalThis.fetch = originalFetch;
+    await rm(tempDir, { recursive: true });
+  });
+
+  it('creates local CR files from remote', async () => {
+    const cr: RemoteCRResponse = {
+      id: 'abcdef01-1234-5678-abcd-ef0123456789',
+      project_id: 'proj-001',
+      title: 'Add auth flow',
+      body: '## Description\n\nAdd JWT authentication.',
+      status: 'draft',
+      author_id: 'user-1',
+      assignee_id: null,
+      target_files: null,
+      closed_at: null,
+      created_at: '2026-01-01T00:00:00.000Z',
+      updated_at: '2026-01-01T00:00:00.000Z',
+    };
+
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => [cr],
+    });
+
+    const result = await sdd.pullCRs();
+    expect(result.created).toBe(1);
+
+    const filePath = join(tempDir, 'change-requests', 'CR-abcdef01.md');
+    expect(existsSync(filePath)).toBe(true);
+
+    const content = await readFile(filePath, 'utf-8');
+    expect(content).toContain('title: Add auth flow');
+    expect(content).toContain('status: draft');
+    expect(content).toContain('JWT authentication');
+  });
+});
+
+describe('Sync engine - pull bugs', () => {
+  let tempDir: string;
+  let sdd: SDD;
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(async () => {
+    originalFetch = globalThis.fetch;
+    tempDir = await mkdtemp(join(tmpdir(), 'sdd-sync-bugs-'));
+    sdd = new SDD({ root: tempDir });
+    await sdd.init({ description: 'test' });
+    const { writeConfig, readConfig } = await import('../src/config/config-manager.js');
+    const config = await readConfig(tempDir);
+    config.remote = { url: 'http://test.local/api/v1', 'api-key': 'test-key' };
+    await writeConfig(tempDir, config);
+  });
+
+  afterEach(async () => {
+    globalThis.fetch = originalFetch;
+    await rm(tempDir, { recursive: true });
+  });
+
+  it('creates local bug files from remote', async () => {
+    const bug: RemoteBugResponse = {
+      id: '12345678-abcd-ef01-2345-678901234567',
+      project_id: 'proj-001',
+      title: 'Search returns stale results',
+      body: '## Steps\n\n1. Search for a term\n2. Results are outdated',
+      status: 'open',
+      severity: 'major',
+      author_id: 'user-1',
+      assignee_id: null,
+      closed_at: null,
+      created_at: '2026-02-01T00:00:00.000Z',
+      updated_at: '2026-02-01T00:00:00.000Z',
+    };
+
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => [bug],
+    });
+
+    const result = await sdd.pullBugs();
+    expect(result.created).toBe(1);
+
+    const filePath = join(tempDir, 'bugs', 'BUG-12345678.md');
+    expect(existsSync(filePath)).toBe(true);
+
+    const content = await readFile(filePath, 'utf-8');
+    expect(content).toContain('title: Search returns stale results');
+    expect(content).toContain('status: open');
+    expect(content).toContain('Results are outdated');
+  });
+});