@specmarket/cli 0.0.4 → 0.0.5

package/src/commands/publish.test.ts

@@ -0,0 +1,146 @@
+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';
+
+// --- Helpers ---
+
+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
+    await Promise.all([
+      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/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')
+    );
+  });
+});

package/src/commands/run.test.ts

@@ -0,0 +1,213 @@
+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 { mockSpinner, mockRunSpec, mockSubmitTelemetry, mockPromptTelemetry, mockCheckClaude } =
+  vi.hoisted(() => {
+    const mockSpinner = {
+      start: vi.fn().mockReturnThis(),
+      stop: vi.fn().mockReturnThis(),
+      succeed: vi.fn().mockReturnThis(),
+      fail: vi.fn().mockReturnThis(),
+      text: '',
+    };
+    const mockRunSpec = vi.fn();
+    const mockSubmitTelemetry = vi.fn();
+    const mockPromptTelemetry = vi.fn();
+    const mockCheckClaude = vi.fn().mockResolvedValue(undefined);
+    return { mockSpinner, mockRunSpec, mockSubmitTelemetry, mockPromptTelemetry, mockCheckClaude };
+  });
+
+vi.mock('ora', () => ({
+  default: vi.fn().mockReturnValue(mockSpinner),
+}));
+
+vi.mock('../lib/ralph-loop.js', () => ({
+  runSpec: mockRunSpec,
+  checkClaudeCliInstalled: mockCheckClaude,
+}));
+
+vi.mock('../lib/telemetry.js', () => ({
+  submitTelemetry: mockSubmitTelemetry,
+  promptTelemetryOptIn: mockPromptTelemetry,
+}));
+
+vi.mock('../lib/auth.js', () => ({
+  loadCredentials: vi.fn().mockResolvedValue(null),
+  isAuthenticated: vi.fn().mockResolvedValue(false),
+}));
+
+vi.mock('../lib/convex-client.js', () => ({
+  getConvexClient: vi.fn().mockResolvedValue({ query: vi.fn(), action: vi.fn() }),
+}));
+
+// Mock the module builtin so createRequire can find package.json during tests
+vi.mock('module', () => ({
+  createRequire: vi.fn().mockReturnValue(
+    vi.fn().mockReturnValue({ version: '0.0.4' })
+  ),
+}));
+
+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 { handleRun } from './run.js';
+
+// --- Helpers ---
+
+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('handleRun', () => {
+  let specDir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+    specDir = join(tmpdir(), `run-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 a spec directory missing required files
+    await writeFile(join(specDir, 'spec.yaml'), 'invalid yaml content');
+
+    await expect(handleRun(specDir, {})).rejects.toThrow(
+      'process.exit called'
+    );
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('validation failed')
+    );
+  });
+
+  it('runs a valid spec and prints summary', async () => {
+    await Promise.all([
+      writeFile(join(specDir, 'spec.yaml'), VALID_SPEC_YAML),
+      writeFile(join(specDir, 'PROMPT.md'), '# Prompt\nBuild it.'),
+      writeFile(join(specDir, 'SPEC.md'), '# Spec\nDetails.'),
+      writeFile(join(specDir, 'SUCCESS_CRITERIA.md'), VALID_SUCCESS_CRITERIA),
+      writeFile(join(specDir, 'stdlib', 'STACK.md'), '# Stack\nNext.js'),
+    ]);
+
+    mockRunSpec.mockResolvedValue({
+      report: {
+        runId: 'run-123',
+        status: 'success',
+        loopCount: 3,
+        totalTokens: 15000,
+        totalCostUsd: 1.5,
+        totalTimeMinutes: 5.2,
+        successCriteriaResults: [
+          { criterion: 'Application builds', passed: true },
+        ],
+      },
+      outputDir: '/tmp/output',
+    });
+    mockSubmitTelemetry.mockResolvedValue(false);
+
+    await handleRun(specDir, {});
+
+    expect(mockRunSpec).toHaveBeenCalledWith(
+      specDir,
+      expect.objectContaining({ name: 'test-spec', version: '1.0.0' }),
+      expect.any(Object),
+      expect.any(Function)
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Run Complete')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('SUCCESS')
+    );
+  });
+
+  it('prints security warning before running', async () => {
+    await Promise.all([
+      writeFile(join(specDir, 'spec.yaml'), VALID_SPEC_YAML),
+      writeFile(join(specDir, 'PROMPT.md'), '# Prompt\nBuild it.'),
+      writeFile(join(specDir, 'SPEC.md'), '# Spec\nDetails.'),
+      writeFile(join(specDir, 'SUCCESS_CRITERIA.md'), VALID_SUCCESS_CRITERIA),
+      writeFile(join(specDir, 'stdlib', 'STACK.md'), '# Stack\nNext.js'),
+    ]);
+
+    mockRunSpec.mockResolvedValue({
+      report: {
+        runId: 'run-123',
+        status: 'success',
+        loopCount: 1,
+        totalTokens: 1000,
+        totalCostUsd: 0.1,
+        totalTimeMinutes: 1,
+        successCriteriaResults: [],
+      },
+      outputDir: '/tmp/output',
+    });
+    mockSubmitTelemetry.mockResolvedValue(false);
+
+    await handleRun(specDir, {});
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('SECURITY WARNING')
+    );
+  });
+
+  it('exits with budget_exceeded code on budget runs', async () => {
+    await Promise.all([
+      writeFile(join(specDir, 'spec.yaml'), VALID_SPEC_YAML),
+      writeFile(join(specDir, 'PROMPT.md'), '# Prompt\nBuild it.'),
+      writeFile(join(specDir, 'SPEC.md'), '# Spec\nDetails.'),
+      writeFile(join(specDir, 'SUCCESS_CRITERIA.md'), VALID_SUCCESS_CRITERIA),
+      writeFile(join(specDir, 'stdlib', 'STACK.md'), '# Stack\nNext.js'),
+    ]);
+
+    mockRunSpec.mockResolvedValue({
+      report: {
+        runId: 'run-123',
+        status: 'budget_exceeded',
+        loopCount: 50,
+        totalTokens: 500000,
+        totalCostUsd: 10.0,
+        totalTimeMinutes: 60,
+        successCriteriaResults: [],
+      },
+      outputDir: '/tmp/output',
+    });
+    mockSubmitTelemetry.mockResolvedValue(false);
+
+    await expect(handleRun(specDir, {})).rejects.toThrow(
+      'process.exit called'
+    );
+  });
+});

package/src/commands/run.ts

@@ -9,7 +9,7 @@ import { validateSpec } from './validate.js';
 import { loadCredentials, isAuthenticated } from '../lib/auth.js';
 import { getConvexClient } from '../lib/convex-client.js';
 import { submitTelemetry, promptTelemetryOptIn } from '../lib/telemetry.js';
-import { runSpec } from '../lib/ralph-loop.js';
+import { runSpec, checkClaudeCliInstalled } from '../lib/ralph-loop.js';
 import type { LoopIteration } from '@specmarket/shared';
 import createDebug from 'debug';
 import { createRequire } from 'module';
@@ -94,6 +94,14 @@ export async function handleRun(
     await promptTelemetryOptIn();
   }
 
+  // Pre-flight check: Ensure Claude CLI is installed
+  try {
+    await checkClaudeCliInstalled();
+  } catch (err) {
+    console.log(chalk.red(`\n✗ ${(err as Error).message}`));
+    process.exit(EXIT_CODES.VALIDATION_ERROR);
+  }
+
   const maxLoops = opts.maxLoops ? parseInt(opts.maxLoops, 10) : undefined;
   const maxBudget = opts.maxBudget ? parseFloat(opts.maxBudget) : undefined;
 
@@ -362,7 +370,7 @@ async function resolveSpecPath(pathOrId: string): Promise<ResolvedSpec> {
 export function createRunCommand(): Command {
   return new Command('run')
     .description('Execute a spec locally using the Ralph Loop')
-    .argument('<path-or-id>', 'Local path to spec directory or registry ID (@user/name[@version])')
+    .argument('[path-or-id]', 'Local path to spec directory or registry ID (@user/name[@version])', '.')
     .option('--max-loops <n>', 'Maximum loop iterations (default: 50)')
     .option('--max-budget <usd>', 'Maximum budget in USD (default: 2x estimated)')
     .option('--no-telemetry', 'Disable telemetry submission for this run')