@specmarket/cli 0.0.4 → 0.0.6

package/src/commands/publish.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+
+// --- Hoisted mocks ---
+
+const { mockQuery, mockMutation, mockClient, mockSpinner } = vi.hoisted(() => {
+  const mockQuery = vi.fn();
+  const mockMutation = vi.fn();
+  const mockClient = { query: mockQuery, mutation: mockMutation, action: vi.fn() };
+  const mockSpinner = {
+    start: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    warn: vi.fn().mockReturnThis(),
+    text: '',
+  };
+  return { mockQuery, mockMutation, mockClient, mockSpinner };
+});
+
+vi.mock('../lib/convex-client.js', () => ({
+  getConvexClient: vi.fn().mockResolvedValue(mockClient),
+}));
+
+vi.mock('../lib/auth.js', () => ({
+  requireAuth: vi.fn().mockResolvedValue({
+    token: 'test-token',
+    username: 'testuser',
+    expiresAt: Date.now() + 3600_000,
+  }),
+}));
+
+vi.mock('ora', () => ({
+  default: vi.fn().mockReturnValue(mockSpinner),
+}));
+
+vi.mock('@specmarket/convex/api', () => ({
+  api: {
+    specs: {
+      publish: 'specs.publish',
+      generateUploadUrl: 'specs.generateUploadUrl',
+    },
+  },
+}));
+
+// Mock fetch for upload
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+const mockExit = vi.spyOn(process, 'exit').mockImplementation((() => {
+  throw new Error('process.exit called');
+}) as any);
+
+const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+import { handlePublish } from './publish.js';
+import { SIDECAR_FILENAME } from '@specmarket/shared';
+
+// --- Helpers ---
+
+const VALID_SPECMARKET_YAML = `spec_format: specmarket
+display_name: "Test Spec"
+description: "A valid test spec with enough description length to pass."
+output_type: web-app
+primary_stack: nextjs-typescript
+tags: []
+estimated_tokens: 50000
+estimated_cost_usd: 2.50
+estimated_time_minutes: 30
+`;
+
+const VALID_SPEC_YAML = `name: test-spec
+display_name: "Test Spec"
+description: "A valid test spec with enough description length to pass."
+output_type: web-app
+primary_stack: nextjs-typescript
+version: "1.0.0"
+runner: claude
+min_model: "claude-opus-4-5"
+estimated_tokens: 50000
+estimated_cost_usd: 2.50
+estimated_time_minutes: 30
+tags: []
+`;
+
+const VALID_SUCCESS_CRITERIA = `# Success Criteria
+- [ ] Application builds
+- [ ] Tests pass
+`;
+
+describe('handlePublish', () => {
+  let specDir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+    specDir = join(tmpdir(), `publish-test-${randomUUID()}`);
+    await mkdir(specDir, { recursive: true });
+    await mkdir(join(specDir, 'stdlib'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(specDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('exits with validation error when spec is invalid', async () => {
+    // Create spec dir without required files
+    await writeFile(join(specDir, 'spec.yaml'), 'invalid');
+
+    await expect(handlePublish(specDir)).rejects.toThrow('process.exit called');
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      expect.stringContaining('validation failed')
+    );
+  });
+
+  it('publishes a valid spec successfully', async () => {
+    // Write a valid spec (specmarket.yaml required)
+    await Promise.all([
+      writeFile(join(specDir, SIDECAR_FILENAME), VALID_SPECMARKET_YAML),
+      writeFile(join(specDir, 'spec.yaml'), VALID_SPEC_YAML),
+      writeFile(join(specDir, 'PROMPT.md'), '# Prompt\nBuild something.'),
+      writeFile(join(specDir, 'SPEC.md'), '# Spec\nDetails here.'),
+      writeFile(join(specDir, 'SUCCESS_CRITERIA.md'), VALID_SUCCESS_CRITERIA),
+      writeFile(join(specDir, 'stdlib', 'STACK.md'), '# Stack\nNext.js'),
+    ]);
+
+    // Mock generateUploadUrl
+    mockMutation.mockImplementation((fn: string) => {
+      if (fn === 'specs.generateUploadUrl') return 'https://upload.example.com/url';
+      if (fn === 'specs.publish') return { specId: 'spec123', created: true };
+      return null;
+    });
+
+    // Mock upload fetch
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ storageId: 'storage-id-123' }),
+    });
+
+    await handlePublish(specDir, { changelog: 'Initial release' });
+
+    expect(mockMutation).toHaveBeenCalledWith('specs.publish', expect.objectContaining({
+      slug: 'test-spec',
+      displayName: 'Test Spec',
+      version: '1.0.0',
+      changelog: 'Initial release',
+    }));
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Spec ID')
+    );
+  });
+});

package/src/commands/publish.ts

@@ -102,6 +102,7 @@ export async function handlePublish(specPath: string, opts: { changelog?: string
       specStorageId: storageId,
       readme,
       runner: specYaml.runner,
+      specFormat: validation.format,
       minModel: specYaml.min_model,
       estimatedTokens: specYaml.estimated_tokens,
       estimatedCostUsd: specYaml.estimated_cost_usd,

package/src/commands/report.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+import { homedir } from 'os';
+
+// --- Hoisted mocks ---
+
+const { mockQuery, mockClient, mockLoadCreds } = vi.hoisted(() => {
+  const mockQuery = vi.fn();
+  const mockClient = { query: mockQuery };
+  const mockLoadCreds = vi.fn();
+  return { mockQuery, mockClient, mockLoadCreds };
+});
+
+vi.mock('../lib/convex-client.js', () => ({
+  getConvexClient: vi.fn().mockResolvedValue(mockClient),
+}));
+
+vi.mock('../lib/auth.js', () => ({
+  loadCredentials: mockLoadCreds,
+}));
+
+vi.mock('@specmarket/convex/api', () => ({
+  api: {
+    runs: { getById: 'runs.getById' },
+  },
+}));
+
+const mockExit = vi.spyOn(process, 'exit').mockImplementation((() => {
+  throw new Error('process.exit called');
+}) as any);
+
+const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+import { handleReport } from './report.js';
+
+// --- Test data ---
+
+const MOCK_RUN_REPORT = {
+  runId: 'run-abc-123',
+  specId: 'spec123',
+  specVersion: '1.0.0',
+  model: 'claude-opus-4-5',
+  runner: 'claude',
+  loopCount: 5,
+  totalTokens: 25000,
+  totalCostUsd: 1.2345,
+  totalTimeMinutes: 12.5,
+  status: 'success',
+  successCriteriaResults: [
+    { criterion: 'App builds', passed: true },
+    { criterion: 'Tests pass', passed: false, details: '2 failures' },
+  ],
+  os: 'darwin',
+  nodeVersion: 'v20.10.0',
+  cliVersion: '0.0.4',
+};
+
+describe('handleReport', () => {
+  let runsDir: string;
+  const runId = `test-run-${randomUUID()}`;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+    runsDir = join(homedir(), '.specmarket', 'runs', runId);
+  });
+
+  afterEach(async () => {
+    await rm(runsDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('displays a local run report when file exists', async () => {
+    await mkdir(runsDir, { recursive: true });
+    await writeFile(
+      join(runsDir, 'run-report.json'),
+      JSON.stringify({ ...MOCK_RUN_REPORT, runId })
+    );
+
+    await handleReport(runId);
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Run Report')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[local]')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('SUCCESS')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('25,000')
+    );
+  });
+
+  it('displays success criteria results', async () => {
+    await mkdir(runsDir, { recursive: true });
+    await writeFile(
+      join(runsDir, 'run-report.json'),
+      JSON.stringify({ ...MOCK_RUN_REPORT, runId })
+    );
+
+    await handleReport(runId);
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('1/2 criteria passed')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('App builds')
+    );
+  });
+
+  it('exits with auth error when not found locally and not logged in', async () => {
+    // Run ID that doesn't exist locally
+    const missingRunId = `missing-${randomUUID()}`;
+    mockLoadCreds.mockResolvedValue(null);
+
+    await expect(handleReport(missingRunId)).rejects.toThrow(
+      'process.exit called'
+    );
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('not found locally')
+    );
+  });
+
+  it('fetches from platform when not found locally but logged in', async () => {
+    const missingRunId = `missing-${randomUUID()}`;
+    mockLoadCreds.mockResolvedValue({
+      token: 'test-token',
+      username: 'alice',
+    });
+    mockQuery.mockResolvedValue({
+      _id: missingRunId,
+      specId: 'spec123',
+      specVersion: '1.0.0',
+      model: 'claude-opus-4-5',
+      runner: 'claude',
+      loopCount: 3,
+      totalTokens: 15000,
+      totalCostUsd: 0.75,
+      totalTimeMinutes: 8.2,
+      status: 'success',
+      successCriteriaResults: [],
+      os: 'linux',
+      nodeVersion: 'v20.10.0',
+      cliVersion: '0.0.4',
+    });
+
+    await handleReport(missingRunId);
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[platform]')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('SUCCESS')
+    );
+  });
+
+  it('exits with error when run not found on platform', async () => {
+    const missingRunId = `missing-${randomUUID()}`;
+    mockLoadCreds.mockResolvedValue({
+      token: 'test-token',
+      username: 'alice',
+    });
+    mockQuery.mockResolvedValue(null);
+
+    await expect(handleReport(missingRunId)).rejects.toThrow(
+      'process.exit called'
+    );
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Run not found')
+    );
+  });
+});