@specmarket/cli 0.0.4 → 0.0.5

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,106 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFile, rm, access } 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';
+
+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 () => {
+    mockPrompt.mockResolvedValue({
+      name: 'test-spec',
+      displayName: 'Test Spec',
+      replacesSaas: '',
+      outputType: 'web-app',
+      primaryStack: 'nextjs-typescript',
+    });
+
+    await handleInit({ path: tmpDir });
+
+    // Verify all required files were created
+    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.mockResolvedValue({
+      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.mockResolvedValue({
+      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')
+    );
+  });
+});

package/src/commands/init.ts

@@ -26,7 +26,7 @@ ${data.replacesSaas ? `replaces_saas: "${data.replacesSaas}"` : '# replaces_saas
 output_type: ${data.outputType}
 primary_stack: ${data.primaryStack}
 version: "1.0.0"
-runner: claude-code
+runner: claude
 min_model: "claude-opus-4-5"
 
 estimated_tokens: 50000
@@ -71,9 +71,9 @@ Read the requirements in SPEC.md and implement the application step by step.
 ## Process
 
 1. Read SPEC.md completely before writing any code
-2. Check fix_plan.md for outstanding items
+2. Check TASKS.md for outstanding items
 3. Implement features, run tests, iterate
-4. Update fix_plan.md as you complete items
+4. Update TASKS.md as you complete items
 5. Verify SUCCESS_CRITERIA.md criteria are met
 
 ## Rules
@@ -81,7 +81,7 @@ Read the requirements in SPEC.md and implement the application step by step.
 - Follow stdlib/STACK.md for technology choices
 - Write tests for all business logic
 - Do not skip steps or take shortcuts
-- Update fix_plan.md after each significant change
+- Update TASKS.md after each significant change
 `;
 
 const SPEC_MD_TEMPLATE = (data: { displayName: string }) => `# ${data.displayName} — Specification
@@ -144,12 +144,12 @@ ${primaryStack}
 - Playwright for E2E (optional)
 `;
 
-const FIX_PLAN_TEMPLATE = (displayName: string) => `# Fix Plan
+const TASKS_MD_TEMPLATE = (displayName: string) => `# Tasks
 
 > This file tracks outstanding work. Update it after each change.
-> Empty = implementation complete.
+> All items checked = implementation complete.
 
-## ${displayName} — Initial Implementation
+## Phase 1: ${displayName} — Initial Implementation
 
 - [ ] Set up project structure and dependencies
 - [ ] Implement core data model
@@ -158,6 +158,8 @@ const FIX_PLAN_TEMPLATE = (displayName: string) => `# Fix Plan
 - [ ] Implement UI/interface
 - [ ] Write integration tests
 - [ ] Update README.md
+
+## Discovered Issues
 `;
 
 export async function handleInit(opts: {
@@ -247,7 +249,7 @@ export async function handleInit(opts: {
       writeFile(join(targetDir, 'SPEC.md'), SPEC_MD_TEMPLATE(data)),
       writeFile(join(targetDir, 'SUCCESS_CRITERIA.md'), SUCCESS_CRITERIA_TEMPLATE),
       writeFile(join(targetDir, 'stdlib', 'STACK.md'), STACK_MD_TEMPLATE(answers.primaryStack)),
-      writeFile(join(targetDir, 'fix_plan.md'), FIX_PLAN_TEMPLATE(answers.displayName)),
+      writeFile(join(targetDir, 'TASKS.md'), TASKS_MD_TEMPLATE(answers.displayName)),
     ]);
 
     spinner.succeed(chalk.green(`Spec created at ${targetDir}`));
@@ -257,8 +259,8 @@ export async function handleInit(opts: {
     console.log(`  1. ${chalk.cyan(`cd ${answers.name}`)}`);
     console.log(`  2. Edit ${chalk.cyan('SPEC.md')} with your application requirements`);
     console.log(`  3. Edit ${chalk.cyan('SUCCESS_CRITERIA.md')} with specific pass/fail criteria`);
-    console.log(`  4. Run ${chalk.cyan(`specmarket validate ${answers.name}`)} to check your spec`);
-    console.log(`  5. Run ${chalk.cyan(`specmarket run ${answers.name}`)} to execute the spec`);
+    console.log(`  4. Run ${chalk.cyan(`specmarket validate`)} to check your spec`);
+    console.log(`  5. Run ${chalk.cyan(`specmarket run`)} to execute the spec`);
   } catch (err) {
     spinner.fail(chalk.red(`Failed to create spec: ${(err as Error).message}`));
     throw err;