@specmarket/cli 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specmarket/cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "description": "SpecMarket CLI - discover, validate, execute, and publish AI specs",
   "bin": {

package/src/commands/comment.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Hoisted mocks ---
+
+const { mockQuery, mockMutation, mockClient, mockSpinner } = vi.hoisted(() => {
+  const mockQuery = vi.fn();
+  const mockMutation = vi.fn();
+  const mockClient = { query: mockQuery, mutation: mockMutation };
+  const mockSpinner = {
+    start: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+  };
+  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: { get: 'specs.get' },
+    issues: { get: 'issues.get' },
+    comments: { create: 'comments.create' },
+  },
+}));
+
+const mockExit = vi.spyOn(process, 'exit').mockImplementation((() => {
+  throw new Error('process.exit called');
+}) as any);
+
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+import { handleComment } from './comment.js';
+
+// --- Test data ---
+
+const MOCK_SPEC = {
+  _id: 'spec123',
+  scopedName: '@alice/my-spec',
+};
+
+const MOCK_ISSUE = {
+  _id: 'issue456',
+  specId: 'spec123',
+  number: 3,
+};
+
+describe('handleComment', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+  });
+
+  it('posts a comment on a spec using scoped name', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+    });
+    mockMutation.mockResolvedValue('comment789');
+
+    await handleComment('spec', '@alice/my-spec', 'Great spec!', {});
+
+    expect(mockQuery).toHaveBeenCalledWith('specs.get', {
+      scopedName: '@alice/my-spec',
+    });
+    expect(mockMutation).toHaveBeenCalledWith('comments.create', {
+      targetType: 'spec',
+      targetId: 'spec123',
+      body: 'Great spec!',
+    });
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(
+      expect.stringContaining('Comment posted')
+    );
+  });
+
+  it('posts a comment on an issue using @user/spec#N format', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.get') return MOCK_ISSUE;
+    });
+    mockMutation.mockResolvedValue('comment789');
+
+    await handleComment(
+      'issue',
+      '@alice/my-spec#3',
+      'I can reproduce this',
+      {}
+    );
+
+    expect(mockQuery).toHaveBeenCalledWith('specs.get', {
+      scopedName: '@alice/my-spec',
+    });
+    expect(mockQuery).toHaveBeenCalledWith('issues.get', {
+      specId: 'spec123',
+      number: 3,
+    });
+    expect(mockMutation).toHaveBeenCalledWith('comments.create', {
+      targetType: 'issue',
+      targetId: 'issue456',
+      body: 'I can reproduce this',
+    });
+  });
+
+  it('posts a comment on a bounty', async () => {
+    mockMutation.mockResolvedValue('comment789');
+
+    await handleComment(
+      'bounty',
+      'bounty999',
+      'I am working on this',
+      {}
+    );
+
+    expect(mockMutation).toHaveBeenCalledWith('comments.create', {
+      targetType: 'bounty',
+      targetId: 'bounty999',
+      body: 'I am working on this',
+    });
+  });
+
+  it('passes reply comment ID when --reply flag is set', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+    });
+    mockMutation.mockResolvedValue('comment790');
+
+    await handleComment('spec', '@alice/my-spec', 'Reply text', {
+      reply: 'parentComment123',
+    });
+
+    expect(mockMutation).toHaveBeenCalledWith('comments.create', {
+      targetType: 'spec',
+      targetId: 'spec123',
+      body: 'Reply text',
+      parentId: 'parentComment123',
+    });
+  });
+
+  it('exits with error for invalid target type', async () => {
+    await expect(
+      handleComment('invalid', 'ref', 'text', {})
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      expect.stringContaining('Invalid target type')
+    );
+  });
+
+  it('exits with error for missing # in issue reference', async () => {
+    await expect(
+      handleComment('issue', '@alice/my-spec', 'text', {})
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      expect.stringContaining('Invalid issue reference')
+    );
+  });
+
+  it('exits with error for non-numeric issue number', async () => {
+    await expect(
+      handleComment('issue', '@alice/my-spec#abc', 'text', {})
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      expect.stringContaining('Invalid issue number')
+    );
+  });
+
+  it('exits with error when spec not found', async () => {
+    mockQuery.mockResolvedValue(null);
+
+    await expect(
+      handleComment('spec', '@alice/nonexistent', 'text', {})
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      expect.stringContaining('Spec not found')
+    );
+  });
+
+  it('exits with error when issue not found', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.get') return null;
+    });
+
+    await expect(
+      handleComment('issue', '@alice/my-spec#99', 'text', {})
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      expect.stringContaining('Issue #99 not found')
+    );
+  });
+});

package/src/commands/comment.ts

@@ -0,0 +1,176 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getConvexClient } from '../lib/convex-client.js';
+import { requireAuth } from '../lib/auth.js';
+import { EXIT_CODES } from '@specmarket/shared';
+
+/**
+ * Posts a comment on a spec, issue, or bounty.
+ *
+ * Target reference formats:
+ * - spec: @user/spec or specId
+ * - issue: @user/spec#3 (scoped name + issue number)
+ * - bounty: bountyId
+ *
+ * Requires authentication.
+ */
+export async function handleComment(
+  targetType: string,
+  targetRef: string,
+  body: string,
+  opts: { reply?: string }
+): Promise<void> {
+  const creds = await requireAuth();
+
+  let api: any;
+  try {
+    api = (await import('@specmarket/convex/api')).api;
+  } catch {
+    console.error(
+      chalk.red('Error: Could not load Convex API bindings. Is CONVEX_URL configured?')
+    );
+    process.exit(EXIT_CODES.NETWORK_ERROR);
+  }
+
+  const client = await getConvexClient(creds.token);
+  const spinner = (await import('ora')).default('Posting comment...').start();
+
+  try {
+    let resolvedTargetType: 'spec' | 'bounty' | 'issue';
+    let resolvedTargetId: string;
+
+    if (targetType === 'spec') {
+      resolvedTargetType = 'spec';
+      const isScopedName = targetRef.startsWith('@') || targetRef.includes('/');
+      const spec = await client.query(
+        api.specs.get,
+        isScopedName ? { scopedName: targetRef } : { specId: targetRef }
+      );
+      if (!spec) {
+        spinner.fail(chalk.red(`Spec not found: ${targetRef}`));
+        process.exit(EXIT_CODES.VALIDATION_ERROR);
+      }
+      resolvedTargetId = spec._id;
+    } else if (targetType === 'issue') {
+      resolvedTargetType = 'issue';
+      // Parse @user/spec#3 format
+      const hashIndex = targetRef.lastIndexOf('#');
+      if (hashIndex === -1) {
+        spinner.fail(
+          chalk.red(
+            'Invalid issue reference. Use format: @user/spec#<number>'
+          )
+        );
+        process.exit(EXIT_CODES.VALIDATION_ERROR);
+      }
+
+      const specRef = targetRef.slice(0, hashIndex);
+      const issueNumber = parseInt(targetRef.slice(hashIndex + 1), 10);
+
+      if (isNaN(issueNumber) || issueNumber < 1) {
+        spinner.fail(
+          chalk.red(`Invalid issue number in "${targetRef}". Use format: @user/spec#<number>`)
+        );
+        process.exit(EXIT_CODES.VALIDATION_ERROR);
+      }
+
+      // Resolve spec
+      const isScopedName = specRef.startsWith('@') || specRef.includes('/');
+      const spec = await client.query(
+        api.specs.get,
+        isScopedName ? { scopedName: specRef } : { specId: specRef }
+      );
+      if (!spec) {
+        spinner.fail(chalk.red(`Spec not found: ${specRef}`));
+        process.exit(EXIT_CODES.VALIDATION_ERROR);
+      }
+
+      // Resolve issue
+      const issue = await client.query(api.issues.get, {
+        specId: spec._id,
+        number: issueNumber,
+      });
+      if (!issue) {
+        spinner.fail(
+          chalk.red(`Issue #${issueNumber} not found on ${spec.scopedName}`)
+        );
+        process.exit(EXIT_CODES.VALIDATION_ERROR);
+      }
+      resolvedTargetId = issue._id;
+    } else if (targetType === 'bounty') {
+      resolvedTargetType = 'bounty';
+      resolvedTargetId = targetRef;
+    } else {
+      spinner.fail(
+        chalk.red(
+          `Invalid target type: "${targetType}". Use "spec", "issue", or "bounty".`
+        )
+      );
+      process.exit(EXIT_CODES.VALIDATION_ERROR);
+    }
+
+    const args: Record<string, unknown> = {
+      targetType: resolvedTargetType,
+      targetId: resolvedTargetId,
+      body: body.trim(),
+    };
+
+    if (opts.reply) {
+      args.parentId = opts.reply;
+    }
+
+    await client.mutation(api.comments.create, args);
+
+    spinner.succeed(chalk.green(`Comment posted on ${targetType} ${targetRef}`));
+  } catch (err) {
+    spinner.fail(chalk.red(`Failed to post comment: ${(err as Error).message}`));
+    process.exit(EXIT_CODES.NETWORK_ERROR);
+  }
+}
+
+/**
+ * Creates the `specmarket comment` command.
+ *
+ * Usage:
+ *   specmarket comment spec @user/spec "Great spec!"
+ *   specmarket comment issue @user/spec#3 "I can reproduce this"
+ *   specmarket comment bounty <bounty-id> "I'm working on this"
+ *   --reply <comment-id>  Reply to a specific comment (threading)
+ */
+export function createCommentCommand(): Command {
+  return new Command('comment')
+    .description('Post a comment on a spec, issue, or bounty (requires login)')
+    .argument(
+      '<target-type>',
+      'Target type: spec, issue, or bounty'
+    )
+    .argument(
+      '<target-ref>',
+      'Target reference (e.g., @user/spec, @user/spec#3, bounty-id)'
+    )
+    .argument('<body>', 'Comment body text')
+    .option(
+      '--reply <comment-id>',
+      'Reply to a specific comment (threading)'
+    )
+    .action(
+      async (
+        targetType: string,
+        targetRef: string,
+        body: string,
+        opts: { reply?: string }
+      ) => {
+        try {
+          await handleComment(targetType, targetRef, body, opts);
+        } catch (err) {
+          const error = err as NodeJS.ErrnoException;
+          if (error.code === String(EXIT_CODES.AUTH_ERROR)) {
+            console.error(chalk.red(error.message));
+            process.exit(EXIT_CODES.AUTH_ERROR);
+          }
+          console.error(chalk.red(`Error: ${error.message}`));
+          process.exit(EXIT_CODES.NETWORK_ERROR);
+        }
+      }
+    );
+}

package/src/commands/fork.test.ts

@@ -0,0 +1,163 @@
+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 { 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(),
+    text: '',
+  };
+  return { mockQuery, mockAction, 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: {
+      get: 'specs.get',
+      download: 'specs.download',
+    },
+  },
+}));
+
+// Mock exec for unzip
+vi.mock('../lib/exec.js', () => ({
+  execAsync: vi.fn().mockResolvedValue({ stdout: '', stderr: '' }),
+}));
+
+// Mock fetch for download
+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 { handleFork } from './fork.js';
+
+// --- Test data ---
+
+const MOCK_SPEC = {
+  _id: 'spec123',
+  scopedName: '@alice/todo-app',
+  displayName: 'Todo App',
+  slug: 'todo-app',
+  currentVersion: '2.0.0',
+};
+
+describe('handleFork', () => {
+  let targetDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+    targetDir = join(tmpdir(), `fork-test-${randomUUID()}`);
+  });
+
+  afterEach(async () => {
+    await rm(targetDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('exits with error when spec not found', async () => {
+    mockQuery.mockResolvedValue(null);
+
+    await expect(
+      handleFork('@alice/nonexistent', targetDir)
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      expect.stringContaining('Spec not found')
+    );
+  });
+
+  it('downloads and extracts a spec fork successfully', async () => {
+    mockQuery.mockResolvedValue(MOCK_SPEC);
+    mockAction.mockResolvedValue({ url: 'https://storage.example.com/spec.zip' });
+
+    // Create a minimal zip-like response (the actual extraction is mocked via exec.js)
+    mockFetch.mockResolvedValue({
+      ok: true,
+      arrayBuffer: async () => new ArrayBuffer(100),
+    });
+
+    // We need to create the targetDir and a spec.yaml in it since the fork handler
+    // reads and rewrites spec.yaml after extracting. We'll mock readFile indirectly
+    // by having exec mock create the directory structure.
+    // Actually, the code does: downloadAndExtract → readFile(specYamlPath).
+    // Since exec is mocked, we need to pre-create the spec.yaml file.
+    const { mkdir, writeFile } = await import('fs/promises');
+    await mkdir(targetDir, { recursive: true });
+    await writeFile(
+      join(targetDir, 'spec.yaml'),
+      'name: todo-app\nversion: "2.0.0"\n'
+    );
+
+    await handleFork('@alice/todo-app', targetDir);
+
+    expect(mockAction).toHaveBeenCalledWith('specs.download', {
+      specId: 'spec123',
+    });
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(
+      expect.stringContaining('Forked')
+    );
+
+    // Verify spec.yaml was updated with fork info
+    const updatedYaml = await readFile(join(targetDir, 'spec.yaml'), 'utf-8');
+    expect(updatedYaml).toContain('forked_from_id');
+    expect(updatedYaml).toContain('spec123');
+  });
+
+  it('uses scopedName query for @-prefixed spec IDs', async () => {
+    mockQuery.mockResolvedValue(null);
+
+    await expect(
+      handleFork('@bob/crm', targetDir)
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockQuery).toHaveBeenCalledWith('specs.get', {
+      scopedName: '@bob/crm',
+    });
+  });
+
+  it('uses specId query for non-scoped spec IDs', async () => {
+    mockQuery.mockResolvedValue(null);
+
+    await expect(
+      handleFork('spec123', targetDir)
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockQuery).toHaveBeenCalledWith('specs.get', {
+      specId: 'spec123',
+    });
+  });
+});