@specmarket/cli 0.0.4 → 0.0.6

package/src/commands/info.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Hoisted mocks ---
+
+const { mockQuery, mockAction, mockClient, mockSpinner } = vi.hoisted(() => {
+  const mockQuery = vi.fn();
+  const mockAction = vi.fn();
+  const mockClient = { query: mockQuery, action: mockAction };
+  const mockSpinner = {
+    start: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+  };
+  return { mockQuery, mockAction, mockClient, mockSpinner };
+});
+
+vi.mock('../lib/convex-client.js', () => ({
+  getConvexClient: vi.fn().mockResolvedValue(mockClient),
+}));
+
+vi.mock('ora', () => ({
+  default: vi.fn().mockReturnValue(mockSpinner),
+}));
+
+vi.mock('@specmarket/convex/api', () => ({
+  api: {
+    specs: {
+      get: 'specs.get',
+      getVersions: 'specs.getVersions',
+    },
+    runs: { getStats: 'runs.getStats' },
+    users: { getProfile: 'users.getProfile' },
+    issues: { list: 'issues.list' },
+    specMaintainers: { list: 'specMaintainers.list' },
+    comments: { list: 'comments.list' },
+  },
+}));
+
+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 { handleInfo } from './info.js';
+
+// --- Test data ---
+
+const MOCK_SPEC = {
+  _id: 'spec123',
+  scopedName: '@alice/todo-app',
+  displayName: 'Todo App',
+  description: 'A full-featured todo application',
+  slug: 'todo-app',
+  authorId: 'user1',
+  outputType: 'web-app',
+  primaryStack: 'nextjs-typescript',
+  currentVersion: '1.2.0',
+  runner: 'claude',
+  minModel: 'claude-opus-4-5',
+  status: 'published',
+  tags: ['productivity', 'todo'],
+  estimatedTokens: 50000,
+  estimatedCostUsd: 2.5,
+  estimatedTimeMinutes: 30,
+  totalRuns: 42,
+  successfulRuns: 36,
+  successRate: 0.857,
+  avgCostUsd: 2.1,
+  communityRating: 4.3,
+  ratingCount: 15,
+  forkCount: 3,
+  replacesSaas: 'Todoist',
+  replacesPricing: '$4/mo',
+  forkedFromId: null,
+  infrastructure: null,
+};
+
+// Return Promises from mockQuery since info.ts chains .catch() on query results
+function setupQueryMock(overrides: Record<string, unknown> = {}) {
+  const defaults: Record<string, unknown> = {
+    'specs.get': MOCK_SPEC,
+    'runs.getStats': { totalRuns: 0, modelBreakdown: [], costDistribution: { min: 0, max: 0, p50: 0 } },
+    'specs.getVersions': { page: [] },
+    'issues.list': { page: [], isDone: true },
+    'specMaintainers.list': [],
+    'comments.list': { page: [], isDone: true },
+    'users.getProfile': null,
+  };
+  const merged = { ...defaults, ...overrides };
+  mockQuery.mockImplementation((fn: string) => Promise.resolve(merged[fn] ?? null));
+}
+
+describe('handleInfo', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+  });
+
+  it('displays full spec information for a scoped name', async () => {
+    setupQueryMock({
+      'users.getProfile': { username: 'alice', displayName: 'Alice', bio: 'Developer' },
+    });
+
+    await handleInfo('@alice/todo-app');
+
+    expect(mockQuery).toHaveBeenCalledWith('specs.get', {
+      scopedName: '@alice/todo-app',
+    });
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Todo App')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('web-app')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('85.7%')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Todoist')
+    );
+  });
+
+  it('exits with error when spec not found', async () => {
+    setupQueryMock({ 'specs.get': null });
+
+    await expect(handleInfo('@alice/nonexistent')).rejects.toThrow(
+      'process.exit called'
+    );
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Spec not found')
+    );
+  });
+
+  it('shows version history when versions exist', async () => {
+    setupQueryMock({
+      'specs.getVersions': {
+        page: [
+          { version: '1.2.0', publishedAt: Date.now(), changelog: 'Added dark mode' },
+          { version: '1.1.0', publishedAt: Date.now() - 86400_000, changelog: 'Bug fixes' },
+        ],
+      },
+    });
+
+    await handleInfo('@alice/todo-app');
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Versions (2)')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('v1.2.0')
+    );
+  });
+
+  it('displays infrastructure details when present', async () => {
+    setupQueryMock({
+      'specs.get': {
+        ...MOCK_SPEC,
+        infrastructure: {
+          monthlyCost: { freeTierUsd: 0, productionUsd: 25 },
+          setupTimeMinutes: 15,
+          services: [
+            {
+              category: 'database',
+              name: 'PostgreSQL',
+              purpose: 'Data store',
+              required: true,
+              defaultProvider: 'Neon',
+              providers: [{ name: 'Neon', freeTier: true }],
+            },
+          ],
+          userProvided: [],
+          deploymentTargets: [{ name: 'Vercel', notes: 'Recommended' }],
+        },
+      },
+    });
+
+    await handleInfo('@alice/todo-app');
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Infrastructure')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('PostgreSQL')
+    );
+  });
+});

package/src/commands/info.ts

@@ -26,11 +26,56 @@ export async function handleInfo(specId: string): Promise<void> {
     // Determine if it's a scoped name or an ID
     const isScopedName = specId.startsWith('@') || specId.includes('/');
 
-    const [spec, stats, versions] = await Promise.all([
+    const [spec, stats, versionsResult] = await Promise.all([
       client.query(api.specs.get, isScopedName ? { scopedName: specId } : { specId }),
       client.query(api.runs.getStats, { specId: specId as any }).catch(() => null),
-      client.query(api.specs.getVersions, { specId: specId as any }).catch(() => []),
+      client.query(api.specs.getVersions, { specId: specId as any, paginationOpts: { numItems: 25, cursor: null } }).catch(() => ({ page: [] })),
     ]);
+    const versions = versionsResult.page;
+
+    // Fetch collaboration data (best-effort — don't fail if these aren't available)
+    let openIssueCount = 0;
+    let maintainers: Array<{ user: { username: string } | null }> = [];
+    let commentCount = 0;
+
+    if (spec) {
+      const [issuesResult, maintainersResult, commentsResult] = await Promise.all([
+        client
+          .query(api.issues.list, {
+            specId: spec._id,
+            status: 'open' as const,
+            paginationOpts: { numItems: 1, cursor: null },
+          })
+          .catch(() => null),
+        client
+          .query(api.specMaintainers.list, { specId: spec._id })
+          .catch(() => []),
+        client
+          .query(api.comments.list, {
+            targetType: 'spec' as const,
+            targetId: spec._id,
+            paginationOpts: { numItems: 1, cursor: null },
+          })
+          .catch(() => null),
+      ]);
+
+      // issues.list returns paginated results — use page length as approximation
+      // For accurate count we'd need a dedicated count query, but this shows "at least N"
+      if (issuesResult) {
+        openIssueCount = issuesResult.page.length;
+        if (!issuesResult.isDone && openIssueCount > 0) {
+          // There are more pages — indicate "N+"
+          openIssueCount = -1; // sentinel for "many"
+        }
+      }
+      maintainers = maintainersResult;
+      if (commentsResult) {
+        commentCount = commentsResult.page.length;
+        if (!commentsResult.isDone && commentCount > 0) {
+          commentCount = -1; // sentinel for "many"
+        }
+      }
+    }
 
     spinner.stop();
 
@@ -91,6 +136,25 @@ export async function handleInfo(specId: string): Promise<void> {
       console.log(chalk.gray(`  (Forked from v${spec.forkedFromVersion})`));
     }
 
+    // Collaboration info
+    const issueDisplay =
+      openIssueCount === -1 ? 'many' : String(openIssueCount);
+    const commentDisplay =
+      commentCount === -1 ? 'many' : String(commentCount);
+    console.log(
+      `  Open Issues: ${issueDisplay}`
+    );
+    console.log(
+      `  Comments: ${commentDisplay}`
+    );
+    if (maintainers.length > 0) {
+      const names = maintainers
+        .filter((m) => m.user)
+        .map((m) => `@${m.user!.username}`)
+        .join(', ');
+      console.log(`  Maintainers: ${names}`);
+    }
+
     if (author) {
       console.log('');
       console.log(chalk.bold('Creator:'));

package/src/commands/init.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFile, rm, access, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+
+// --- Hoisted mocks ---
+
+const { mockSpinner, mockPrompt } = vi.hoisted(() => {
+  const mockSpinner = {
+    start: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    warn: vi.fn().mockReturnThis(),
+  };
+  const mockPrompt = vi.fn();
+  return { mockSpinner, mockPrompt };
+});
+
+vi.mock('ora', () => ({
+  default: vi.fn().mockReturnValue(mockSpinner),
+}));
+
+vi.mock('inquirer', () => ({
+  default: { prompt: mockPrompt },
+}));
+
+const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+import { handleInit } from './init.js';
+import { SIDECAR_FILENAME } from '@specmarket/shared';
+
+describe('handleInit', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tmpDir = join(tmpdir(), `init-test-${randomUUID()}`);
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('creates spec directory with all required files', async () => {
+    // Path provided + empty dir: first prompt "Create from scratch?", then full spec answers
+    mockPrompt
+      .mockResolvedValueOnce({ createNew: true })
+      .mockResolvedValueOnce({
+        name: 'test-spec',
+        displayName: 'Test Spec',
+        replacesSaas: '',
+        outputType: 'web-app',
+        primaryStack: 'nextjs-typescript',
+      });
+
+    await handleInit({ path: tmpDir });
+
+    // Verify all required files were created (specmarket.yaml is required for validate/publish)
+    await expect(access(join(tmpDir, SIDECAR_FILENAME))).resolves.toBeUndefined();
+    await expect(access(join(tmpDir, 'spec.yaml'))).resolves.toBeUndefined();
+    await expect(access(join(tmpDir, 'PROMPT.md'))).resolves.toBeUndefined();
+    await expect(access(join(tmpDir, 'SPEC.md'))).resolves.toBeUndefined();
+    await expect(access(join(tmpDir, 'SUCCESS_CRITERIA.md'))).resolves.toBeUndefined();
+    await expect(access(join(tmpDir, 'stdlib', 'STACK.md'))).resolves.toBeUndefined();
+    await expect(access(join(tmpDir, 'TASKS.md'))).resolves.toBeUndefined();
+
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(
+      expect.stringContaining('Spec created')
+    );
+  });
+
+  it('writes correct spec.yaml content based on prompts', async () => {
+    mockPrompt
+      .mockResolvedValueOnce({ createNew: true })
+      .mockResolvedValueOnce({
+        name: 'my-project',
+        displayName: 'My Project',
+        replacesSaas: 'Notion',
+        outputType: 'web-app',
+        primaryStack: 'nextjs-typescript',
+      });
+
+    await handleInit({ path: tmpDir });
+
+    const specYaml = await readFile(join(tmpDir, 'spec.yaml'), 'utf-8');
+    expect(specYaml).toContain('name: my-project');
+    expect(specYaml).toContain('display_name: "My Project"');
+    expect(specYaml).toContain('replaces_saas: "Notion"');
+    expect(specYaml).toContain('output_type: web-app');
+    expect(specYaml).toContain('primary_stack: nextjs-typescript');
+  });
+
+  it('shows next-steps instructions after creation', async () => {
+    mockPrompt
+      .mockResolvedValueOnce({ createNew: true })
+      .mockResolvedValueOnce({
+        name: 'test-spec',
+        displayName: 'Test Spec',
+        replacesSaas: '',
+        outputType: 'cli-tool',
+        primaryStack: 'go',
+      });
+
+    await handleInit({ path: tmpDir });
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Next steps')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('specmarket validate')
+    );
+  });
+
+  it('adds only specmarket.yaml when -p points at existing Spec Kit dir (no overwrites)', async () => {
+    await mkdir(tmpDir, { recursive: true });
+    await writeFile(join(tmpDir, 'spec.md'), '# My Spec Kit spec\nDo not overwrite.');
+    await writeFile(join(tmpDir, 'tasks.md'), '# Tasks');
+
+    mockPrompt.mockResolvedValue({
+      displayName: 'Spec Kit Spec',
+      description: 'A spec kit spec for the marketplace.',
+      replacesSaas: '',
+      outputType: 'web-app',
+      primaryStack: 'nextjs-typescript',
+    });
+
+    await handleInit({ path: tmpDir });
+
+    await expect(access(join(tmpDir, SIDECAR_FILENAME))).resolves.toBeUndefined();
+    const sidecar = await readFile(join(tmpDir, SIDECAR_FILENAME), 'utf-8');
+    expect(sidecar).toContain('spec_format: speckit');
+    expect(sidecar).toContain('display_name: "Spec Kit Spec"');
+    const specMd = await readFile(join(tmpDir, 'spec.md'), 'utf-8');
+    expect(specMd).toBe('# My Spec Kit spec\nDo not overwrite.');
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Added specmarket.yaml'));
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('specmarket validate'));
+  });
+
+  it('exits without overwriting when specmarket.yaml already exists in -p dir', async () => {
+    await mkdir(tmpDir, { recursive: true });
+    await writeFile(
+      join(tmpDir, SIDECAR_FILENAME),
+      'spec_format: speckit\ndisplay_name: X\ndescription: Already have a sidecar here.\noutput_type: web-app\nprimary_stack: nextjs-typescript\n'
+    );
+
+    await handleInit({ path: tmpDir });
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('already exists')
+    );
+    const sidecar = await readFile(join(tmpDir, SIDECAR_FILENAME), 'utf-8');
+    expect(sidecar).toContain('Already have a sidecar here.');
+  });
+
+  // --from flag tests (import-only mode)
+
+  it('--from: adds specmarket.yaml sidecar to existing Spec Kit dir', async () => {
+    await mkdir(tmpDir, { recursive: true });
+    await writeFile(join(tmpDir, 'spec.md'), '# My Spec Kit spec');
+    await writeFile(join(tmpDir, 'tasks.md'), '# Tasks');
+
+    mockPrompt.mockResolvedValue({
+      displayName: 'Imported Spec',
+      description: 'An imported spec kit spec for testing.',
+      replacesSaas: '',
+      outputType: 'web-app',
+      primaryStack: 'nextjs-typescript',
+    });
+
+    await handleInit({ from: tmpDir });
+
+    await expect(access(join(tmpDir, SIDECAR_FILENAME))).resolves.toBeUndefined();
+    const sidecar = await readFile(join(tmpDir, SIDECAR_FILENAME), 'utf-8');
+    expect(sidecar).toContain('spec_format: speckit');
+    expect(sidecar).toContain('display_name: "Imported Spec"');
+    // Original files must not be modified
+    const specMd = await readFile(join(tmpDir, 'spec.md'), 'utf-8');
+    expect(specMd).toBe('# My Spec Kit spec');
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Added specmarket.yaml'));
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('specmarket validate'));
+  });
+
+  it('--from: adds specmarket.yaml sidecar to BMAD dir', async () => {
+    await mkdir(tmpDir, { recursive: true });
+    await writeFile(join(tmpDir, 'prd.md'), '# PRD');
+    await writeFile(join(tmpDir, 'architecture.md'), '# Architecture');
+
+    mockPrompt.mockResolvedValue({
+      displayName: 'BMAD App',
+      description: 'A bmad formatted spec for the marketplace.',
+      replacesSaas: 'Jira',
+      outputType: 'web-app',
+      primaryStack: 'nextjs-typescript',
+    });
+
+    await handleInit({ from: tmpDir });
+
+    const sidecar = await readFile(join(tmpDir, SIDECAR_FILENAME), 'utf-8');
+    expect(sidecar).toContain('spec_format: bmad');
+    expect(sidecar).toContain('display_name: "BMAD App"');
+  });
+
+  it('--from: errors when directory does not exist', async () => {
+    const nonExistentDir = join(tmpDir, 'does-not-exist');
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((_code?: number | string | null) => { throw new Error('process.exit called'); });
+
+    await expect(handleInit({ from: nonExistentDir })).rejects.toThrow('process.exit called');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Directory not found'));
+    exitSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('--from: errors when directory is empty', async () => {
+    await mkdir(tmpDir, { recursive: true });
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((_code?: number | string | null) => { throw new Error('process.exit called'); });
+
+    await expect(handleInit({ from: tmpDir })).rejects.toThrow('process.exit called');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Directory is empty'));
+    exitSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('--from: warns and exits without overwriting when specmarket.yaml already exists', async () => {
+    await mkdir(tmpDir, { recursive: true });
+    await writeFile(join(tmpDir, 'spec.md'), '# Spec');
+    await writeFile(
+      join(tmpDir, SIDECAR_FILENAME),
+      'spec_format: speckit\ndisplay_name: Existing\ndescription: Already have sidecar.\noutput_type: web-app\nprimary_stack: nextjs-typescript\n'
+    );
+
+    await handleInit({ from: tmpDir });
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('already exists'));
+    const sidecar = await readFile(join(tmpDir, SIDECAR_FILENAME), 'utf-8');
+    expect(sidecar).toContain('Already have sidecar.');
+    // mockPrompt should NOT have been called (no prompts for metadata)
+    expect(mockPrompt).not.toHaveBeenCalled();
+  });
+});