linear-cli-agents 0.1.1 → 0.2.1

package/dist/commands/open.js

@@ -0,0 +1,100 @@
+import { Args, Command, Flags } from '@oclif/core';
+import open from 'open';
+import { getClient } from '../lib/client.js';
+import { success, print } from '../lib/output.js';
+import { handleError } from '../lib/errors.js';
+import { parseIdentifier, isUUID, resolveIssueId } from '../lib/issue-utils.js';
+export default class Open extends Command {
+    static description = 'Open Linear resources in browser';
+    static examples = [
+        '<%= config.bin %> open ENG-123',
+        '<%= config.bin %> open --team ENG',
+        '<%= config.bin %> open --inbox',
+        '<%= config.bin %> open --settings',
+        '<%= config.bin %> open --my-issues',
+    ];
+    static args = {
+        issue: Args.string({
+            description: 'Issue identifier (e.g., ENG-123) or ID to open',
+            required: false,
+        }),
+    };
+    static flags = {
+        team: Flags.string({
+            char: 't',
+            description: 'Open team page by key (e.g., ENG)',
+            exclusive: ['inbox', 'settings', 'my-issues'],
+        }),
+        inbox: Flags.boolean({
+            description: 'Open inbox',
+            exclusive: ['team', 'settings', 'my-issues'],
+        }),
+        settings: Flags.boolean({
+            description: 'Open workspace settings',
+            exclusive: ['team', 'inbox', 'my-issues'],
+        }),
+        'my-issues': Flags.boolean({
+            description: 'Open my issues view',
+            exclusive: ['team', 'inbox', 'settings'],
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(Open);
+            const client = getClient();
+            // Get organization for URL building
+            const viewer = await client.viewer;
+            const organization = await viewer.organization;
+            if (!organization) {
+                throw new Error('Could not determine organization');
+            }
+            const orgKey = organization.urlKey;
+            let url;
+            if (args.issue) {
+                // Open specific issue
+                const parsed = parseIdentifier(args.issue);
+                if (parsed) {
+                    url = `https://linear.app/${orgKey}/issue/${args.issue}`;
+                }
+                else if (isUUID(args.issue)) {
+                    // Need to fetch issue to get identifier for URL
+                    const issueId = await resolveIssueId(client, args.issue);
+                    const issue = await client.issue(issueId);
+                    url = issue.url;
+                }
+                else {
+                    throw new Error(`Invalid issue identifier: ${args.issue}`);
+                }
+            }
+            else if (flags.team) {
+                // Open team page
+                url = `https://linear.app/${orgKey}/team/${flags.team}`;
+            }
+            else if (flags.inbox) {
+                // Open inbox
+                url = `https://linear.app/${orgKey}/inbox`;
+            }
+            else if (flags.settings) {
+                // Open settings
+                url = `https://linear.app/${orgKey}/settings`;
+            }
+            else if (flags['my-issues']) {
+                // Open my issues
+                url = `https://linear.app/${orgKey}/my-issues`;
+            }
+            else {
+                // Default: open workspace home
+                url = `https://linear.app/${orgKey}`;
+            }
+            await open(url);
+            print(success({
+                opened: true,
+                url,
+            }));
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/teams/list.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class TeamsList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        first: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        after: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/teams/list.js

@@ -0,0 +1,99 @@
+import { Command, Flags } from '@oclif/core';
+import { getClient } from '../../lib/client.js';
+import { successList, print, printList } from '../../lib/output.js';
+import { handleError } from '../../lib/errors.js';
+import { colors, truncate } from '../../lib/formatter.js';
+const COLUMNS = [
+    {
+        key: 'key',
+        header: 'KEY',
+        format: (value) => colors.cyan(String(value)),
+    },
+    {
+        key: 'name',
+        header: 'NAME',
+        format: (value) => colors.bold(String(value)),
+    },
+    {
+        key: 'description',
+        header: 'DESCRIPTION',
+        format: (value) => truncate(String(value ?? ''), 40),
+    },
+    {
+        key: 'private',
+        header: 'PRIVATE',
+        format: (value) => (value ? colors.yellow('Yes') : colors.gray('No')),
+    },
+    {
+        key: 'issueCount',
+        header: 'ISSUES',
+        format: (value) => colors.dim(String(value)),
+    },
+];
+export default class TeamsList extends Command {
+    static description = 'List teams in the workspace';
+    static examples = [
+        '<%= config.bin %> teams list',
+        '<%= config.bin %> teams list --format table',
+        '<%= config.bin %> teams list --first 10',
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        first: Flags.integer({
+            description: 'Number of teams to fetch (default: 50)',
+            default: 50,
+        }),
+        after: Flags.string({
+            description: 'Cursor for pagination',
+        }),
+    };
+    async run() {
+        try {
+            const { flags } = await this.parse(TeamsList);
+            const format = flags.format;
+            const client = getClient();
+            const teams = await client.teams({
+                first: flags.first,
+                after: flags.after,
+            });
+            const data = await Promise.all(teams.nodes.map(async (team) => {
+                const issues = await team.issues({ first: 0 });
+                return {
+                    id: team.id,
+                    key: team.key,
+                    name: team.name,
+                    description: team.description ?? undefined,
+                    private: team.private,
+                    issueCount: issues.pageInfo.hasNextPage ? 50 : issues.nodes.length,
+                    createdAt: team.createdAt,
+                };
+            }));
+            const pageInfo = {
+                hasNextPage: teams.pageInfo.hasNextPage,
+                hasPreviousPage: teams.pageInfo.hasPreviousPage,
+                startCursor: teams.pageInfo.startCursor,
+                endCursor: teams.pageInfo.endCursor,
+            };
+            if (format === 'json') {
+                print(successList(data, pageInfo));
+            }
+            else {
+                printList(data, format, {
+                    columns: COLUMNS,
+                    primaryKey: 'key',
+                    secondaryKey: 'name',
+                    pageInfo,
+                });
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/lib/__tests__/errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/errors.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CliError, ErrorCodes, handleError } from '../errors.js';
+describe('errors utilities', () => {
+    describe('CliError', () => {
+        it('creates error with code and message', () => {
+            const err = new CliError(ErrorCodes.NOT_FOUND, 'Issue not found');
+            expect(err.code).toBe('NOT_FOUND');
+            expect(err.message).toBe('Issue not found');
+            expect(err.details).toBeUndefined();
+            expect(err.name).toBe('CliError');
+        });
+        it('creates error with details', () => {
+            const details = { issueId: 'ENG-123' };
+            const err = new CliError(ErrorCodes.NOT_FOUND, 'Issue not found', details);
+            expect(err.details).toEqual({ issueId: 'ENG-123' });
+        });
+        it('toResponse returns error response format', () => {
+            const err = new CliError(ErrorCodes.INVALID_INPUT, 'Bad input', {
+                field: 'title',
+            });
+            const response = err.toResponse();
+            expect(response).toEqual({
+                success: false,
+                error: {
+                    code: 'INVALID_INPUT',
+                    message: 'Bad input',
+                    details: { field: 'title' },
+                },
+            });
+        });
+    });
+    describe('handleError', () => {
+        let consoleSpy;
+        beforeEach(() => {
+            consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            consoleSpy.mockRestore();
+        });
+        it('handles CliError', () => {
+            const err = new CliError(ErrorCodes.NOT_FOUND, 'Not found');
+            handleError(err);
+            expect(consoleSpy).toHaveBeenCalled();
+            const output = JSON.parse(consoleSpy.mock.calls[0][0]);
+            expect(output.success).toBe(false);
+            expect(output.error.code).toBe('NOT_FOUND');
+        });
+        it('handles 401 unauthorized errors', () => {
+            const err = new Error('Request failed with status 401');
+            handleError(err);
+            expect(consoleSpy).toHaveBeenCalled();
+            const output = JSON.parse(consoleSpy.mock.calls[0][0]);
+            expect(output.error.code).toBe('INVALID_API_KEY');
+        });
+        it('handles 404 not found errors', () => {
+            const err = new Error('Resource not found');
+            handleError(err);
+            expect(consoleSpy).toHaveBeenCalled();
+            const output = JSON.parse(consoleSpy.mock.calls[0][0]);
+            expect(output.error.code).toBe('NOT_FOUND');
+        });
+        it('handles rate limit errors', () => {
+            const err = new Error('rate limit exceeded');
+            handleError(err);
+            expect(consoleSpy).toHaveBeenCalled();
+            const output = JSON.parse(consoleSpy.mock.calls[0][0]);
+            expect(output.error.code).toBe('RATE_LIMITED');
+        });
+        it('handles generic Error as API_ERROR', () => {
+            const err = new Error('Something went wrong');
+            handleError(err);
+            expect(consoleSpy).toHaveBeenCalled();
+            const output = JSON.parse(consoleSpy.mock.calls[0][0]);
+            expect(output.error.code).toBe('API_ERROR');
+            expect(output.error.message).toBe('Something went wrong');
+        });
+        it('handles unknown error types', () => {
+            handleError('string error');
+            expect(consoleSpy).toHaveBeenCalled();
+            const output = JSON.parse(consoleSpy.mock.calls[0][0]);
+            expect(output.error.code).toBe('UNKNOWN_ERROR');
+        });
+    });
+    describe('ErrorCodes', () => {
+        it('has all expected error codes', () => {
+            expect(ErrorCodes.NOT_AUTHENTICATED).toBe('NOT_AUTHENTICATED');
+            expect(ErrorCodes.INVALID_API_KEY).toBe('INVALID_API_KEY');
+            expect(ErrorCodes.NOT_FOUND).toBe('NOT_FOUND');
+            expect(ErrorCodes.ALREADY_EXISTS).toBe('ALREADY_EXISTS');
+            expect(ErrorCodes.INVALID_INPUT).toBe('INVALID_INPUT');
+            expect(ErrorCodes.MISSING_REQUIRED_FIELD).toBe('MISSING_REQUIRED_FIELD');
+            expect(ErrorCodes.API_ERROR).toBe('API_ERROR');
+            expect(ErrorCodes.RATE_LIMITED).toBe('RATE_LIMITED');
+            expect(ErrorCodes.CONFIG_ERROR).toBe('CONFIG_ERROR');
+            expect(ErrorCodes.UNKNOWN_ERROR).toBe('UNKNOWN_ERROR');
+        });
+    });
+});

package/dist/lib/__tests__/output.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/output.test.js

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { success, successList, error, print, printRaw } from '../output.js';
+describe('output utilities', () => {
+    describe('success', () => {
+        it('returns success response with data', () => {
+            const data = { id: '123', name: 'Test' };
+            const result = success(data);
+            expect(result).toEqual({
+                success: true,
+                data: { id: '123', name: 'Test' },
+            });
+        });
+        it('handles null data', () => {
+            const result = success(null);
+            expect(result).toEqual({
+                success: true,
+                data: null,
+            });
+        });
+        it('handles array data', () => {
+            const result = success([1, 2, 3]);
+            expect(result).toEqual({
+                success: true,
+                data: [1, 2, 3],
+            });
+        });
+    });
+    describe('successList', () => {
+        it('returns list response without pageInfo', () => {
+            const data = [{ id: '1' }, { id: '2' }];
+            const result = successList(data);
+            expect(result).toEqual({
+                success: true,
+                data: [{ id: '1' }, { id: '2' }],
+            });
+        });
+        it('returns list response with pageInfo', () => {
+            const data = [{ id: '1' }];
+            const pageInfo = { hasNextPage: true, hasPreviousPage: false, endCursor: 'cursor123' };
+            const result = successList(data, pageInfo);
+            expect(result).toEqual({
+                success: true,
+                data: [{ id: '1' }],
+                pageInfo: { hasNextPage: true, hasPreviousPage: false, endCursor: 'cursor123' },
+            });
+        });
+        it('handles empty array', () => {
+            const result = successList([]);
+            expect(result).toEqual({
+                success: true,
+                data: [],
+            });
+        });
+    });
+    describe('error', () => {
+        it('returns error response with code and message', () => {
+            const result = error('NOT_FOUND', 'Issue not found');
+            expect(result).toEqual({
+                success: false,
+                error: {
+                    code: 'NOT_FOUND',
+                    message: 'Issue not found',
+                },
+            });
+        });
+        it('returns error response with details', () => {
+            const details = { field: 'title', reason: 'required' };
+            const result = error('INVALID_INPUT', 'Validation failed', details);
+            expect(result).toEqual({
+                success: false,
+                error: {
+                    code: 'INVALID_INPUT',
+                    message: 'Validation failed',
+                    details: { field: 'title', reason: 'required' },
+                },
+            });
+        });
+    });
+    describe('print', () => {
+        let consoleSpy;
+        beforeEach(() => {
+            consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            consoleSpy.mockRestore();
+        });
+        it('prints success response as formatted JSON', () => {
+            const response = success({ id: '123' });
+            print(response);
+            expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify(response, null, 2));
+        });
+        it('prints error response as formatted JSON', () => {
+            const response = error('NOT_FOUND', 'Not found');
+            print(response);
+            expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify(response, null, 2));
+        });
+    });
+    describe('printRaw', () => {
+        let consoleSpy;
+        beforeEach(() => {
+            consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            consoleSpy.mockRestore();
+        });
+        it('prints raw data as formatted JSON', () => {
+            const data = { key: 'value', nested: { a: 1 } };
+            printRaw(data);
+            expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify(data, null, 2));
+        });
+    });
+});

package/dist/lib/formatter.d.ts

@@ -0,0 +1,59 @@
+import type { OutputFormat } from './types.js';
+/**
+ * Check if colors should be disabled.
+ * Respects NO_COLOR env var and --no-color flag.
+ */
+export declare const shouldDisableColors: () => boolean;
+/**
+ * Color utilities that respect NO_COLOR.
+ */
+declare const colors: {
+    dim: (str: string) => string;
+    bold: (str: string) => string;
+    cyan: (str: string) => string;
+    green: (str: string) => string;
+    yellow: (str: string) => string;
+    red: (str: string) => string;
+    blue: (str: string) => string;
+    magenta: (str: string) => string;
+    gray: (str: string) => string;
+};
+export { colors };
+/**
+ * Column definition for table formatting.
+ */
+export interface ColumnDef<T> {
+    key: keyof T | string;
+    header: string;
+    width?: number;
+    align?: 'left' | 'center' | 'right';
+    format?: (value: unknown, row: T) => string;
+}
+/**
+ * Format data as a colored table.
+ */
+export declare const formatTable: <T extends Record<string, unknown>>(data: T[], columns: ColumnDef<T>[]) => string;
+/**
+ * Format data as plain text (one item per line).
+ */
+export declare const formatPlain: <T extends Record<string, unknown>>(data: T[], primaryKey?: keyof T, secondaryKey?: keyof T) => string;
+/**
+ * Format a single item as a key-value table.
+ */
+export declare const formatKeyValue: (data: Record<string, unknown>) => string;
+/**
+ * Priority label formatter with colors.
+ */
+export declare const formatPriority: (priority: number) => string;
+/**
+ * Truncate string to max length with ellipsis.
+ */
+export declare const truncate: (str: string | undefined | null, maxLength: number) => string;
+/**
+ * Generic formatter that outputs data in the specified format.
+ */
+export declare const formatOutput: <T extends Record<string, unknown>>(format: OutputFormat, data: T | T[], options?: {
+    columns?: ColumnDef<T>[];
+    primaryKey?: keyof T;
+    secondaryKey?: keyof T;
+}) => string;

package/dist/lib/formatter.js

@@ -0,0 +1,192 @@
+import Table from 'cli-table3';
+import pc from 'picocolors';
+/**
+ * Check if colors should be disabled.
+ * Respects NO_COLOR env var and --no-color flag.
+ */
+export const shouldDisableColors = () => {
+    return Boolean(process.env.NO_COLOR) || process.argv.includes('--no-color');
+};
+/**
+ * Color utilities that respect NO_COLOR.
+ */
+const colors = {
+    dim: (str) => (shouldDisableColors() ? str : pc.dim(str)),
+    bold: (str) => (shouldDisableColors() ? str : pc.bold(str)),
+    cyan: (str) => (shouldDisableColors() ? str : pc.cyan(str)),
+    green: (str) => (shouldDisableColors() ? str : pc.green(str)),
+    yellow: (str) => (shouldDisableColors() ? str : pc.yellow(str)),
+    red: (str) => (shouldDisableColors() ? str : pc.red(str)),
+    blue: (str) => (shouldDisableColors() ? str : pc.blue(str)),
+    magenta: (str) => (shouldDisableColors() ? str : pc.magenta(str)),
+    gray: (str) => (shouldDisableColors() ? str : pc.gray(str)),
+};
+export { colors };
+/**
+ * Format data as a colored table.
+ */
+export const formatTable = (data, columns) => {
+    if (data.length === 0) {
+        return colors.dim('No results found.');
+    }
+    const colWidths = columns.map((col) => col.width ?? null);
+    const table = new Table({
+        head: columns.map((col) => colors.bold(col.header)),
+        colWidths,
+        colAligns: columns.map((col) => col.align ?? 'left'),
+        style: {
+            head: [],
+            border: [],
+        },
+        chars: {
+            top: '',
+            'top-mid': '',
+            'top-left': '',
+            'top-right': '',
+            bottom: '',
+            'bottom-mid': '',
+            'bottom-left': '',
+            'bottom-right': '',
+            left: '',
+            'left-mid': '',
+            mid: '',
+            'mid-mid': '',
+            right: '',
+            'right-mid': '',
+            middle: '  ',
+        },
+    });
+    for (const row of data) {
+        const cells = columns.map((col) => {
+            const value = getNestedValue(row, col.key);
+            if (col.format) {
+                return col.format(value, row);
+            }
+            return String(value ?? '');
+        });
+        table.push(cells);
+    }
+    return table.toString();
+};
+/**
+ * Format data as plain text (one item per line).
+ */
+export const formatPlain = (data, primaryKey = 'id', secondaryKey) => {
+    if (data.length === 0) {
+        return '';
+    }
+    return data
+        .map((item) => {
+        const primary = String(item[primaryKey] ?? '');
+        if (secondaryKey && item[secondaryKey]) {
+            return `${primary}\t${String(item[secondaryKey])}`;
+        }
+        return primary;
+    })
+        .join('\n');
+};
+/**
+ * Format a single item as a key-value table.
+ */
+export const formatKeyValue = (data) => {
+    const table = new Table({
+        style: {
+            head: [],
+            border: [],
+        },
+        chars: {
+            top: '',
+            'top-mid': '',
+            'top-left': '',
+            'top-right': '',
+            bottom: '',
+            'bottom-mid': '',
+            'bottom-left': '',
+            'bottom-right': '',
+            left: '',
+            'left-mid': '',
+            mid: '',
+            'mid-mid': '',
+            right: '',
+            'right-mid': '',
+            middle: '  ',
+        },
+    });
+    for (const [key, value] of Object.entries(data)) {
+        if (value === null || value === undefined)
+            continue;
+        let formattedValue;
+        if (typeof value === 'object') {
+            formattedValue = colors.dim(JSON.stringify(value));
+        }
+        else {
+            formattedValue = String(value);
+        }
+        table.push([colors.cyan(key), formattedValue]);
+    }
+    return table.toString();
+};
+/**
+ * Get nested value from object using dot notation.
+ */
+const getNestedValue = (obj, path) => {
+    return path.split('.').reduce((acc, part) => {
+        if (acc && typeof acc === 'object') {
+            return acc[part];
+        }
+        return undefined;
+    }, obj);
+};
+/**
+ * Priority label formatter with colors.
+ */
+export const formatPriority = (priority) => {
+    switch (priority) {
+        case 0:
+            return colors.gray('No priority');
+        case 1:
+            return colors.red('Urgent');
+        case 2:
+            return colors.yellow('High');
+        case 3:
+            return colors.blue('Medium');
+        case 4:
+            return colors.gray('Low');
+        default:
+            return String(priority);
+    }
+};
+/**
+ * Truncate string to max length with ellipsis.
+ */
+export const truncate = (str, maxLength) => {
+    if (!str)
+        return '';
+    if (str.length <= maxLength)
+        return str;
+    return str.slice(0, maxLength - 1) + '\u2026';
+};
+/**
+ * Generic formatter that outputs data in the specified format.
+ */
+export const formatOutput = (format, data, options = {}) => {
+    if (format === 'json') {
+        return JSON.stringify(Array.isArray(data) ? data : data, null, 2);
+    }
+    if (format === 'plain') {
+        if (Array.isArray(data)) {
+            return formatPlain(data, options.primaryKey, options.secondaryKey);
+        }
+        return String(data[options.primaryKey ?? 'id'] ?? '');
+    }
+    if (format === 'table') {
+        if (Array.isArray(data)) {
+            if (!options.columns) {
+                throw new Error('Columns are required for table format');
+            }
+            return formatTable(data, options.columns);
+        }
+        return formatKeyValue(data);
+    }
+    return JSON.stringify(data, null, 2);
+};