Implement issue list command

Add ability to list all issues for the current repository.

Features:
- Lists issues with rkey (issue number) and title
- Shows creation date with human-readable formatting
- Supports --limit option (1-100, default 50)
- Displays "No issues found" message when list is empty

New utilities:
- Add formatDate() in src/utils/formatting.ts
- Converts dates to human-readable format (today, yesterday, X days/weeks/months ago, or locale date)
- Comprehensive test coverage with 9 tests

Implementation:
- Add createListCommand() with limit validation
- Import formatDate from utils/formatting.ts
- Add 9 comprehensive command tests

Tests:
- List issues successfully
- Custom limit handling
- Empty list handling
- Authentication required
- Context required
- Invalid limit validation (too low/high/non-numeric)
- API error handling
- Date formatting tests (9 tests covering all ranges)

All 232 tests passing ✅

Co-Authored-By: Claude Sonnet 4.5 <[e-mail]>

src/commands/issue.ts

···
 import { Command } from 'commander';
 import { createApiClient } from '../lib/api-client.js';
 import { getCurrentRepoContext } from '../lib/context.js';
-import { createIssue } from '../lib/issues-api.js';
+import { createIssue, listIssues } from '../lib/issues-api.js';
 import { buildRepoAtUri } from '../utils/at-uri.js';
 import { readBodyInput } from '../utils/body-input.js';
+import { formatDate } from '../utils/formatting.js';
 import { validateIssueBody, validateIssueTitle } from '../utils/validation.js';
 
 /**
···
   issue.description('Manage issues in Tangled repositories');
 
   issue.addCommand(createCreateCommand());
+  issue.addCommand(createListCommand());
 
   return issue;
 }
···
       }
     });
 }
+
+/**
+ * Issue list subcommand
+ */
+function createListCommand(): Command {
+  return new Command('list')
+    .description('List issues for the current repository')
+    .option('-l, --limit <number>', 'Maximum number of issues to fetch', '50')
+    .action(async (options: { limit: string }) => {
+      try {
+        // 1. Validate auth
+        const client = createApiClient();
+        if (!(await client.resumeSession())) {
+          console.error('✗ Not authenticated. Run "tangled auth login" first.');
+          process.exit(1);
+        }
+
+        // 2. Get repo context
+        const context = await getCurrentRepoContext();
+        if (!context) {
+          console.error('✗ Not in a Tangled repository');
+          console.error('\nTo use this repository with Tangled, add a remote:');
+          console.error('  git remote add origin [e-mail]:<did>/<repo>.git');
+          process.exit(1);
+        }
+
+        // 3. Build repo AT-URI
+        const repoAtUri = await buildRepoAtUri(context.owner, context.name, client);
+
+        // 4. Fetch issues
+        const limit = Number.parseInt(options.limit, 10);
+        if (Number.isNaN(limit) || limit < 1 || limit > 100) {
+          console.error('✗ Invalid limit. Must be between 1 and 100.');
+          process.exit(1);
+        }
+
+        const { issues } = await listIssues({
+          client,
+          repoAtUri,
+          limit,
+        });
+
+        // 5. Display results
+        if (issues.length === 0) {
+          console.log('No issues found for this repository.');
+          return;
+        }
+
+        console.log(`\nFound ${issues.length} issue${issues.length === 1 ? '' : 's'}:\n`);
+
+        for (const issue of issues) {
+          const rkey = extractRkey(issue.uri);
+          const date = formatDate(issue.createdAt);
+          console.log(`  #${rkey}  ${issue.title}`);
+          console.log(`         Created ${date}`);
+          console.log();
+        }
+      } catch (error) {
+        console.error(
+          `✗ Failed to list issues: ${error instanceof Error ? error.message : 'Unknown error'}`
+        );
+        process.exit(1);
+      }
+    });
+}

src/utils/formatting.ts

···
+/**
+ * Format a date for display with human-readable relative time
+ * @param dateString - ISO date string
+ * @returns Human-readable date string
+ */
+export function formatDate(dateString: string): string {
+  const date = new Date(dateString);
+  const now = new Date();
+  const diff = now.getTime() - date.getTime();
+  const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+
+  if (days === 0) return 'today';
+  if (days === 1) return 'yesterday';
+  if (days < 7) return `${days} days ago`;
+  if (days < 30) return `${Math.floor(days / 7)} weeks ago`;
+  if (days < 365) return `${Math.floor(days / 30)} months ago`;
+  return date.toLocaleDateString();
+}

tests/commands/issue.test.ts

···
     });
   });
 });
+
+describe('issue list command', () => {
+  let mockClient: TangledApiClient;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+  let processExitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    // Mock console methods
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {}) as never;
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}) as never;
+    processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => {
+      throw new Error(`process.exit(${code})`);
+    }) as never;
+
+    // Mock API client
+    mockClient = {
+      resumeSession: vi.fn(async () => true),
+    } as unknown as TangledApiClient;
+    vi.mocked(apiClient.createApiClient).mockReturnValue(mockClient);
+
+    // Mock context
+    vi.mocked(context.getCurrentRepoContext).mockResolvedValue({
+      owner: 'test.bsky.social',
+      ownerType: 'handle',
+      name: 'test-repo',
+      remoteName: 'origin',
+      remoteUrl: '[e-mail]:test.bsky.social/test-repo.git',
+      protocol: 'ssh',
+    });
+
+    // Mock AT-URI builder
+    vi.mocked(atUri.buildRepoAtUri).mockResolvedValue(
+      'at://did:plc:abc123/sh.tangled.repo/xyz789'
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('list issues', () => {
+    it('should list issues successfully', async () => {
+      const mockIssues: IssueWithMetadata[] = [
+        {
+          $type: 'sh.tangled.repo.issue',
+          repo: 'at://did:plc:abc123/sh.tangled.repo/xyz789',
+          title: 'First Issue',
+          createdAt: new Date('2024-01-01').toISOString(),
+          uri: 'at://did:plc:abc123/sh.tangled.repo.issue/issue1',
+          cid: 'bafyrei1',
+          author: 'did:plc:abc123',
+        },
+        {
+          $type: 'sh.tangled.repo.issue',
+          repo: 'at://did:plc:abc123/sh.tangled.repo/xyz789',
+          title: 'Second Issue',
+          createdAt: new Date('2024-01-02').toISOString(),
+          uri: 'at://did:plc:abc123/sh.tangled.repo.issue/issue2',
+          cid: 'bafyrei2',
+          author: 'did:plc:abc123',
+        },
+      ];
+
+      vi.mocked(issuesApi.listIssues).mockResolvedValue({
+        issues: mockIssues,
+        cursor: undefined,
+      });
+
+      const command = createIssueCommand();
+      await command.parseAsync(['node', 'test', 'list']);
+
+      expect(issuesApi.listIssues).toHaveBeenCalledWith({
+        client: mockClient,
+        repoAtUri: 'at://did:plc:abc123/sh.tangled.repo/xyz789',
+        limit: 50,
+      });
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('\nFound 2 issues:\n');
+      expect(consoleLogSpy).toHaveBeenCalledWith('  #issue1  First Issue');
+      expect(consoleLogSpy).toHaveBeenCalledWith('  #issue2  Second Issue');
+    });
+
+    it('should handle custom limit', async () => {
+      vi.mocked(issuesApi.listIssues).mockResolvedValue({
+        issues: [],
+        cursor: undefined,
+      });
+
+      const command = createIssueCommand();
+      await command.parseAsync(['node', 'test', 'list', '--limit', '25']);
+
+      expect(issuesApi.listIssues).toHaveBeenCalledWith({
+        client: mockClient,
+        repoAtUri: 'at://did:plc:abc123/sh.tangled.repo/xyz789',
+        limit: 25,
+      });
+    });
+
+    it('should handle empty issue list', async () => {
+      vi.mocked(issuesApi.listIssues).mockResolvedValue({
+        issues: [],
+        cursor: undefined,
+      });
+
+      const command = createIssueCommand();
+      await command.parseAsync(['node', 'test', 'list']);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('No issues found for this repository.');
+    });
+  });
+
+  describe('authentication required', () => {
+    it('should fail when not authenticated', async () => {
+      vi.mocked(mockClient.resumeSession).mockResolvedValue(false);
+
+      const command = createIssueCommand();
+
+      await expect(command.parseAsync(['node', 'test', 'list'])).rejects.toThrow(
+        'process.exit(1)'
+      );
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '✗ Not authenticated. Run "tangled auth login" first.'
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('context required', () => {
+    it('should fail when not in a Tangled repository', async () => {
+      vi.mocked(context.getCurrentRepoContext).mockResolvedValue(null);
+
+      const command = createIssueCommand();
+
+      await expect(command.parseAsync(['node', 'test', 'list'])).rejects.toThrow(
+        'process.exit(1)'
+      );
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('✗ Not in a Tangled repository');
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('validation errors', () => {
+    it('should fail with invalid limit (too low)', async () => {
+      const command = createIssueCommand();
+
+      await expect(command.parseAsync(['node', 'test', 'list', '--limit', '0'])).rejects.toThrow(
+        'process.exit(1)'
+      );
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '✗ Invalid limit. Must be between 1 and 100.'
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail with invalid limit (too high)', async () => {
+      const command = createIssueCommand();
+
+      await expect(
+        command.parseAsync(['node', 'test', 'list', '--limit', '101'])
+      ).rejects.toThrow('process.exit(1)');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '✗ Invalid limit. Must be between 1 and 100.'
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail with non-numeric limit', async () => {
+      const command = createIssueCommand();
+
+      await expect(
+        command.parseAsync(['node', 'test', 'list', '--limit', 'abc'])
+      ).rejects.toThrow('process.exit(1)');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '✗ Invalid limit. Must be between 1 and 100.'
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('API errors', () => {
+    it('should handle API errors gracefully', async () => {
+      vi.mocked(issuesApi.listIssues).mockRejectedValue(new Error('Network error'));
+
+      const command = createIssueCommand();
+
+      await expect(command.parseAsync(['node', 'test', 'list'])).rejects.toThrow(
+        'process.exit(1)'
+      );
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('✗ Failed to list issues: Network error');
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+});

tests/utils/formatting.test.ts

···
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { formatDate } from '../../src/utils/formatting.js';
+
+describe('formatDate', () => {
+  beforeEach(() => {
+    // Mock current date to 2024-06-15 12:00:00 UTC for consistent testing
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2024-06-15T12:00:00.000Z'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('should return "today" for current day', () => {
+    const today = new Date('2024-06-15T10:00:00.000Z').toISOString();
+    expect(formatDate(today)).toBe('today');
+  });
+
+  it('should return "yesterday" for previous day', () => {
+    const yesterday = new Date('2024-06-14T10:00:00.000Z').toISOString();
+    expect(formatDate(yesterday)).toBe('yesterday');
+  });
+
+  it('should return days ago for 2-6 days', () => {
+    const twoDaysAgo = new Date('2024-06-13T10:00:00.000Z').toISOString();
+    expect(formatDate(twoDaysAgo)).toBe('2 days ago');
+
+    const threeDaysAgo = new Date('2024-06-12T10:00:00.000Z').toISOString();
+    expect(formatDate(threeDaysAgo)).toBe('3 days ago');
+
+    const sixDaysAgo = new Date('2024-06-09T10:00:00.000Z').toISOString();
+    expect(formatDate(sixDaysAgo)).toBe('6 days ago');
+  });
+
+  it('should return weeks ago for 7-29 days', () => {
+    const oneWeekAgo = new Date('2024-06-08T10:00:00.000Z').toISOString();
+    expect(formatDate(oneWeekAgo)).toBe('1 weeks ago');
+
+    const twoWeeksAgo = new Date('2024-06-01T10:00:00.000Z').toISOString();
+    expect(formatDate(twoWeeksAgo)).toBe('2 weeks ago');
+
+    const threeWeeksAgo = new Date('2024-05-25T10:00:00.000Z').toISOString();
+    expect(formatDate(threeWeeksAgo)).toBe('3 weeks ago');
+  });
+
+  it('should return months ago for 30-364 days', () => {
+    const oneMonthAgo = new Date('2024-05-16T10:00:00.000Z').toISOString();
+    expect(formatDate(oneMonthAgo)).toBe('1 months ago');
+
+    const threeMonthsAgo = new Date('2024-03-16T10:00:00.000Z').toISOString();
+    expect(formatDate(threeMonthsAgo)).toBe('3 months ago');
+
+    const sixMonthsAgo = new Date('2023-12-16T10:00:00.000Z').toISOString();
+    expect(formatDate(sixMonthsAgo)).toBe('6 months ago');
+  });
+
+  it('should return locale date string for 365+ days', () => {
+    const oneYearAgo = new Date('2023-06-15T10:00:00.000Z').toISOString();
+    const formatted = formatDate(oneYearAgo);
+
+    // The exact format depends on locale, but it should be a date string
+    expect(formatted).toMatch(/\d{1,2}\/\d{1,2}\/\d{4}/);
+  });
+
+  it('should handle edge case at exactly 7 days', () => {
+    const sevenDaysAgo = new Date('2024-06-08T12:00:00.000Z').toISOString();
+    expect(formatDate(sevenDaysAgo)).toBe('1 weeks ago');
+  });
+
+  it('should handle edge case at exactly 30 days', () => {
+    const thirtyDaysAgo = new Date('2024-05-16T12:00:00.000Z').toISOString();
+    expect(formatDate(thirtyDaysAgo)).toBe('1 months ago');
+  });
+
+  it('should handle edge case at exactly 365 days', () => {
+    const oneYearAgo = new Date('2023-06-15T12:00:00.000Z').toISOString();
+    const formatted = formatDate(oneYearAgo);
+
+    // Should use locale date string
+    expect(formatted).toMatch(/\d{1,2}\/\d{1,2}\/\d{4}/);
+  });
+});