@specmarket/cli 0.0.4 → 0.0.6

package/src/commands/issues.ts

@@ -0,0 +1,436 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { getConvexClient } from '../lib/convex-client.js';
+import { requireAuth } from '../lib/auth.js';
+import { EXIT_CODES } from '@specmarket/shared';
+
+/**
+ * Loads the Convex API module. Exits on failure.
+ */
+async function loadApi(): Promise<any> {
+  try {
+    return (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);
+  }
+}
+
+/**
+ * Resolves a spec identifier (scoped name or ID) to a spec document.
+ * Exits with VALIDATION_ERROR if not found.
+ */
+async function resolveSpec(client: any, api: any, specRef: string): Promise<any> {
+  const isScopedName = specRef.startsWith('@') || specRef.includes('/');
+  const spec = await client.query(
+    api.specs.get,
+    isScopedName ? { scopedName: specRef } : { specId: specRef }
+  );
+  if (!spec) {
+    console.error(chalk.red(`Spec not found: ${specRef}`));
+    process.exit(EXIT_CODES.VALIDATION_ERROR);
+  }
+  return spec;
+}
+
+/**
+ * Formats a relative time string from a timestamp (e.g., "3 days ago").
+ */
+function relativeTime(timestamp: number): string {
+  const diff = Date.now() - timestamp;
+  const seconds = Math.floor(diff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return 'just now';
+}
+
+/**
+ * Lists open issues for a spec in table format.
+ * Public endpoint — no auth required.
+ *
+ * Flags: --status open|closed|all, --label <label>
+ */
+export async function handleIssuesList(
+  specRef: string,
+  opts: { status?: string; label?: string }
+): Promise<void> {
+  const api = await loadApi();
+  const client = await getConvexClient();
+  const spinner = (await import('ora')).default('Loading issues...').start();
+
+  try {
+    const spec = await resolveSpec(client, api, specRef);
+
+    const statusFilter =
+      opts.status === 'all' ? undefined : (opts.status as 'open' | 'closed') ?? 'open';
+
+    const result = await client.query(api.issues.list, {
+      specId: spec._id,
+      status: statusFilter,
+      labels: opts.label ? [opts.label] : undefined,
+      paginationOpts: { numItems: 50, cursor: null },
+    });
+
+    spinner.stop();
+
+    const issues = result.page;
+
+    if (issues.length === 0) {
+      const statusLabel = statusFilter ?? 'any';
+      console.log(chalk.gray(`No ${statusLabel} issues for ${spec.scopedName}`));
+      return;
+    }
+
+    console.log(
+      chalk.bold(`\n${issues.length} issue(s) for ${spec.scopedName}:\n`)
+    );
+
+    const table = new Table({
+      head: [
+        chalk.cyan('#'),
+        chalk.cyan('Title'),
+        chalk.cyan('Author'),
+        chalk.cyan('Age'),
+        chalk.cyan('Labels'),
+      ],
+      style: { compact: true },
+      colWidths: [6, 40, 16, 10, 20],
+      wordWrap: true,
+    });
+
+    for (const issue of issues) {
+      const statusIcon = issue.status === 'open' ? chalk.green('●') : chalk.gray('○');
+      table.push([
+        `${statusIcon} ${issue.number}`,
+        issue.title.slice(0, 60),
+        issue.author ? `@${issue.author.username}` : chalk.gray('unknown'),
+        relativeTime(issue.createdAt),
+        issue.labels.length > 0 ? issue.labels.join(', ') : chalk.gray('—'),
+      ]);
+    }
+
+    console.log(table.toString());
+    console.log(
+      chalk.gray(
+        `\nView: ${chalk.cyan(`specmarket issues ${specRef} <number>`)}`
+      )
+    );
+  } catch (err) {
+    spinner.fail(chalk.red(`Failed to load issues: ${(err as Error).message}`));
+    process.exit(EXIT_CODES.NETWORK_ERROR);
+  }
+}
+
+/**
+ * Creates a new issue interactively (prompts for title and body).
+ * Requires authentication.
+ */
+export async function handleIssuesCreate(specRef: string): Promise<void> {
+  const creds = await requireAuth();
+  const api = await loadApi();
+  const client = await getConvexClient(creds.token);
+
+  const spec = await resolveSpec(client, api, specRef);
+
+  const { default: inquirer } = await import('inquirer');
+
+  const answers = await inquirer.prompt<{ title: string; body: string }>([
+    {
+      type: 'input',
+      name: 'title',
+      message: 'Issue title:',
+      validate: (v: string) => v.trim().length > 0 || 'Title cannot be empty',
+    },
+    {
+      type: 'editor',
+      name: 'body',
+      message: 'Issue body (markdown):',
+      validate: (v: string) => v.trim().length > 0 || 'Body cannot be empty',
+    },
+  ]);
+
+  const spinner = (await import('ora')).default('Creating issue...').start();
+
+  try {
+    const result = await client.mutation(api.issues.create, {
+      specId: spec._id,
+      title: answers.title.trim(),
+      body: answers.body.trim(),
+      labels: [],
+    });
+
+    spinner.succeed(
+      chalk.green(`Issue #${result.number} created on ${spec.scopedName}`)
+    );
+  } catch (err) {
+    spinner.fail(chalk.red(`Failed to create issue: ${(err as Error).message}`));
+    process.exit(EXIT_CODES.NETWORK_ERROR);
+  }
+}
+
+/**
+ * Displays a single issue with detail and recent comments.
+ * Public endpoint — no auth required.
+ */
+export async function handleIssuesView(
+  specRef: string,
+  issueNumber: number
+): Promise<void> {
+  const api = await loadApi();
+  const client = await getConvexClient();
+  const spinner = (await import('ora')).default(`Loading issue #${issueNumber}...`).start();
+
+  try {
+    const spec = await resolveSpec(client, api, specRef);
+
+    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);
+    }
+
+    // Fetch recent comments
+    const commentsResult = await client.query(api.comments.list, {
+      targetType: 'issue',
+      targetId: issue._id,
+      paginationOpts: { numItems: 10, cursor: null },
+    });
+
+    spinner.stop();
+
+    const statusBadge =
+      issue.status === 'open'
+        ? chalk.green.bold(' OPEN ')
+        : chalk.gray.bold(' CLOSED ');
+
+    console.log('');
+    console.log(
+      `${statusBadge}  ${chalk.bold(`#${issue.number}: ${issue.title}`)}`
+    );
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(
+      `${chalk.bold('Author:')} ${issue.author ? `@${issue.author.username}` : 'unknown'}  ${chalk.bold('Created:')} ${new Date(issue.createdAt).toLocaleDateString()}`
+    );
+    if (issue.labels.length > 0) {
+      console.log(`${chalk.bold('Labels:')} ${issue.labels.join(', ')}`);
+    }
+    if (issue.closedAt) {
+      console.log(
+        `${chalk.bold('Closed:')} ${new Date(issue.closedAt).toLocaleDateString()}`
+      );
+    }
+    console.log('');
+    console.log(issue.body);
+    console.log('');
+
+    // Comments
+    if (commentsResult.page.length > 0) {
+      console.log(
+        chalk.bold(`Comments (${issue.commentCount}):`)
+      );
+      console.log(chalk.gray('─'.repeat(40)));
+
+      for (const comment of commentsResult.page) {
+        const author = comment.author
+          ? `@${comment.author.username}`
+          : 'unknown';
+        const edited = comment.editedAt ? chalk.gray(' (edited)') : '';
+        console.log(
+          `  ${chalk.bold(author)} — ${relativeTime(comment.createdAt)}${edited}`
+        );
+        console.log(`  ${comment.body}`);
+
+        if (comment.replies && comment.replies.length > 0) {
+          for (const reply of comment.replies) {
+            const replyAuthor = reply.author
+              ? `@${reply.author.username}`
+              : 'unknown';
+            const replyEdited = reply.editedAt ? chalk.gray(' (edited)') : '';
+            console.log(
+              `    ${chalk.bold(replyAuthor)} — ${relativeTime(reply.createdAt)}${replyEdited}`
+            );
+            console.log(`    ${reply.body}`);
+          }
+        }
+        console.log('');
+      }
+    } else {
+      console.log(chalk.gray('No comments yet.'));
+    }
+  } catch (err) {
+    spinner.fail(
+      chalk.red(`Failed to load issue: ${(err as Error).message}`)
+    );
+    process.exit(EXIT_CODES.NETWORK_ERROR);
+  }
+}
+
+/**
+ * Closes an issue. Requires authentication.
+ * Authorized: issue author, spec author, or spec maintainer.
+ */
+export async function handleIssuesClose(
+  specRef: string,
+  issueNumber: number
+): Promise<void> {
+  const creds = await requireAuth();
+  const api = await loadApi();
+  const client = await getConvexClient(creds.token);
+  const spinner = (await import('ora')).default(`Closing issue #${issueNumber}...`).start();
+
+  try {
+    const spec = await resolveSpec(client, api, specRef);
+
+    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);
+    }
+
+    await client.mutation(api.issues.close, {
+      issueId: issue._id,
+    });
+
+    spinner.succeed(
+      chalk.green(`Issue #${issueNumber} closed on ${spec.scopedName}`)
+    );
+  } catch (err) {
+    spinner.fail(chalk.red(`Failed to close issue: ${(err as Error).message}`));
+    process.exit(EXIT_CODES.NETWORK_ERROR);
+  }
+}
+
+/**
+ * Reopens a closed issue. Requires authentication.
+ * Authorized: issue author, spec author, or spec maintainer.
+ */
+export async function handleIssuesReopen(
+  specRef: string,
+  issueNumber: number
+): Promise<void> {
+  const creds = await requireAuth();
+  const api = await loadApi();
+  const client = await getConvexClient(creds.token);
+  const spinner = (await import('ora')).default(`Reopening issue #${issueNumber}...`).start();
+
+  try {
+    const spec = await resolveSpec(client, api, specRef);
+
+    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);
+    }
+
+    await client.mutation(api.issues.reopen, {
+      issueId: issue._id,
+    });
+
+    spinner.succeed(
+      chalk.green(`Issue #${issueNumber} reopened on ${spec.scopedName}`)
+    );
+  } catch (err) {
+    spinner.fail(
+      chalk.red(`Failed to reopen issue: ${(err as Error).message}`)
+    );
+    process.exit(EXIT_CODES.NETWORK_ERROR);
+  }
+}
+
+/**
+ * Creates the `specmarket issues` command with subcommands.
+ *
+ * Usage:
+ *   specmarket issues @user/spec                 — list open issues
+ *   specmarket issues @user/spec create           — create issue
+ *   specmarket issues @user/spec <number>         — view issue
+ *   specmarket issues @user/spec <number> close   — close issue
+ *   specmarket issues @user/spec <number> reopen  — reopen issue
+ */
+export function createIssuesCommand(): Command {
+  return new Command('issues')
+    .description('Manage issues on a spec')
+    .argument('<spec-id>', 'Spec scoped name (@user/name) or document ID')
+    .argument('[action-or-number]', 'Issue number or "create"')
+    .argument('[action]', '"close" or "reopen" (with issue number)')
+    .option(
+      '-s, --status <status>',
+      'Filter by status: open, closed, all (default: open)'
+    )
+    .option('--label <label>', 'Filter by label')
+    .action(
+      async (
+        specId: string,
+        actionOrNumber: string | undefined,
+        action: string | undefined,
+        opts: { status?: string; label?: string }
+      ) => {
+        try {
+          if (!actionOrNumber) {
+            // specmarket issues @user/spec → list
+            await handleIssuesList(specId, opts);
+          } else if (actionOrNumber === 'create') {
+            // specmarket issues @user/spec create → create
+            await handleIssuesCreate(specId);
+          } else {
+            const issueNumber = parseInt(actionOrNumber, 10);
+            if (isNaN(issueNumber) || issueNumber < 1) {
+              console.error(
+                chalk.red(
+                  `Invalid issue number or action: "${actionOrNumber}". ` +
+                  'Use a number or "create".'
+                )
+              );
+              process.exit(EXIT_CODES.VALIDATION_ERROR);
+            }
+
+            if (!action) {
+              // specmarket issues @user/spec 3 → view
+              await handleIssuesView(specId, issueNumber);
+            } else if (action === 'close') {
+              // specmarket issues @user/spec 3 close → close
+              await handleIssuesClose(specId, issueNumber);
+            } else if (action === 'reopen') {
+              // specmarket issues @user/spec 3 reopen → reopen
+              await handleIssuesReopen(specId, issueNumber);
+            } else {
+              console.error(
+                chalk.red(
+                  `Unknown action: "${action}". Use "close" or "reopen".`
+                )
+              );
+              process.exit(EXIT_CODES.VALIDATION_ERROR);
+            }
+          }
+        } 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/login.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Hoisted mocks ---
+
+const { mockQuery, mockClient, mockSpinner, mockLoadCreds, mockSaveCreds } =
+  vi.hoisted(() => {
+    const mockQuery = vi.fn();
+    const mockClient = { query: mockQuery, mutation: vi.fn() };
+    const mockSpinner = {
+      start: vi.fn().mockReturnThis(),
+      stop: vi.fn().mockReturnThis(),
+      succeed: vi.fn().mockReturnThis(),
+      fail: vi.fn().mockReturnThis(),
+    };
+    const mockLoadCreds = vi.fn();
+    const mockSaveCreds = vi.fn();
+    return { mockQuery, mockClient, mockSpinner, mockLoadCreds, mockSaveCreds };
+  });
+
+vi.mock('../lib/convex-client.js', () => ({
+  getConvexClient: vi.fn().mockResolvedValue(mockClient),
+}));
+
+vi.mock('../lib/auth.js', () => ({
+  loadCredentials: mockLoadCreds,
+  saveCredentials: mockSaveCreds,
+}));
+
+vi.mock('ora', () => ({
+  default: vi.fn().mockReturnValue(mockSpinner),
+}));
+
+vi.mock('@specmarket/convex/api', () => ({
+  api: {
+    users: { getMe: 'users.getMe' },
+    auth: { createDeviceCode: 'auth.createDeviceCode', checkDeviceCode: 'auth.checkDeviceCode' },
+  },
+}));
+
+const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+import { handleLogin } from './login.js';
+
+describe('handleLogin', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('shows already-logged-in message when credentials exist', async () => {
+    mockLoadCreds.mockResolvedValue({
+      token: 'existing-token',
+      username: 'alice',
+      expiresAt: Date.now() + 3600_000,
+    });
+
+    await handleLogin({});
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Already logged in')
+    );
+    expect(mockSaveCreds).not.toHaveBeenCalled();
+  });
+
+  it('validates and saves token with --token flag', async () => {
+    mockLoadCreds.mockResolvedValue(null);
+    mockQuery.mockResolvedValue({ _id: 'user1', username: 'bob' });
+    mockSaveCreds.mockResolvedValue(undefined);
+
+    await handleLogin({ token: 'my-jwt-token' });
+
+    expect(mockSaveCreds).toHaveBeenCalledWith(
+      expect.objectContaining({
+        token: 'my-jwt-token',
+        username: 'bob',
+        userId: 'user1',
+      })
+    );
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(
+      expect.stringContaining('Logged in')
+    );
+  });
+
+  it('saves token even if getMe query fails', async () => {
+    mockLoadCreds.mockResolvedValue(null);
+    mockQuery.mockRejectedValue(new Error('Convex unreachable'));
+    mockSaveCreds.mockResolvedValue(undefined);
+
+    await handleLogin({ token: 'fallback-token' });
+
+    expect(mockSaveCreds).toHaveBeenCalledWith(
+      expect.objectContaining({
+        token: 'fallback-token',
+        username: undefined,
+      })
+    );
+    expect(mockSpinner.succeed).toHaveBeenCalled();
+  });
+});

package/src/commands/login.ts

@@ -1,10 +1,9 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
-import { EXIT_CODES } from '@specmarket/shared';
+import { EXIT_CODES, TOKEN_EXPIRY_MS, DEFAULT_WEB_URL } from '@specmarket/shared';
 import { saveCredentials, loadCredentials } from '../lib/auth.js';
 import { getConvexClient } from '../lib/convex-client.js';
-import { TOKEN_EXPIRY_MS } from '@specmarket/shared';
 import type { Credentials } from '@specmarket/shared';
 import createDebug from 'debug';
 
@@ -101,10 +100,7 @@ async function handleTokenLogin(token: string): Promise<void> {
  * 6. On expiry/timeout: show error
  */
 async function handleDeviceCodeLogin(): Promise<void> {
-  const config = await import('../lib/config.js').then((m) => m.loadConfig());
-  const baseUrl = config.convexUrl ?? process.env['CONVEX_URL'] ?? 'https://your-deployment.convex.cloud';
-  const webUrl = baseUrl.replace('convex.cloud', 'specmarket.dev');
-
+  const webUrl = DEFAULT_WEB_URL;
   const client = await getConvexClient();
 
   let api: any;

package/src/commands/logout.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Hoisted mocks ---
+
+const { mockLoadCreds, mockClearCreds } = vi.hoisted(() => {
+  const mockLoadCreds = vi.fn();
+  const mockClearCreds = vi.fn();
+  return { mockLoadCreds, mockClearCreds };
+});
+
+vi.mock('../lib/auth.js', () => ({
+  loadCredentials: mockLoadCreds,
+  clearCredentials: mockClearCreds,
+}));
+
+const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+import { handleLogout } from './logout.js';
+
+describe('handleLogout', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('clears credentials and shows success message when logged in', async () => {
+    mockLoadCreds.mockResolvedValue({
+      token: 'test-token',
+      username: 'alice',
+      expiresAt: Date.now() + 3600_000,
+    });
+    mockClearCreds.mockResolvedValue(undefined);
+
+    await handleLogout();
+
+    expect(mockClearCreds).toHaveBeenCalled();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Logged out')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('alice')
+    );
+  });
+
+  it('shows not-logged-in message when no credentials exist', async () => {
+    mockLoadCreds.mockResolvedValue(null);
+
+    await handleLogout();
+
+    expect(mockClearCreds).not.toHaveBeenCalled();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('not currently logged in')
+    );
+  });
+});