linear-cli-agents 0.2.0 → 0.4.0

package/dist/commands/relations/list.js

@@ -0,0 +1,128 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getClient } from '../../lib/client.js';
+import { successList, print, printList } from '../../lib/output.js';
+import { handleError, CliError, ErrorCodes } from '../../lib/errors.js';
+import { resolveIssueId } from '../../lib/issue-utils.js';
+import { colors } from '../../lib/formatter.js';
+const formatRelationType = (type) => {
+    switch (type) {
+        case 'blocks':
+            return colors.red('blocks');
+        case 'blocked':
+            return colors.yellow('blocked by');
+        case 'duplicate':
+            return colors.magenta('duplicate of');
+        case 'related':
+            return colors.blue('related to');
+        default:
+            return type;
+    }
+};
+const COLUMNS = [
+    {
+        key: 'issueIdentifier',
+        header: 'ISSUE',
+        format: (value) => colors.cyan(String(value)),
+    },
+    {
+        key: 'type',
+        header: 'RELATION',
+        format: (value) => formatRelationType(String(value)),
+    },
+    {
+        key: 'relatedIssueIdentifier',
+        header: 'RELATED ISSUE',
+        format: (value) => colors.cyan(String(value)),
+    },
+    {
+        key: 'relatedIssueTitle',
+        header: 'TITLE',
+        format: (value) => colors.dim(String(value).slice(0, 30)),
+    },
+];
+export default class RelationsList extends Command {
+    static description = 'List relations for an issue';
+    static examples = [
+        '<%= config.bin %> relations list ENG-123',
+        '<%= config.bin %> relations list ENG-123 --format table',
+    ];
+    static args = {
+        issue: Args.string({
+            description: 'Issue ID or identifier (e.g., ENG-123)',
+            required: true,
+        }),
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(RelationsList);
+            const format = flags.format;
+            const client = getClient();
+            const issueId = await resolveIssueId(client, args.issue);
+            const issue = await client.issue(issueId);
+            if (!issue) {
+                throw new CliError(ErrorCodes.NOT_FOUND, `Issue ${args.issue} not found`);
+            }
+            // Get both relations and inverse relations
+            const [relations, inverseRelations] = await Promise.all([issue.relations(), issue.inverseRelations()]);
+            const data = [];
+            // Process outgoing relations
+            for (const relation of relations.nodes) {
+                const relatedIssue = await relation.relatedIssue;
+                if (relatedIssue) {
+                    data.push({
+                        id: relation.id,
+                        type: relation.type,
+                        issueId: issue.id,
+                        issueIdentifier: issue.identifier,
+                        issueTitle: issue.title,
+                        relatedIssueId: relatedIssue.id,
+                        relatedIssueIdentifier: relatedIssue.identifier,
+                        relatedIssueTitle: relatedIssue.title,
+                        createdAt: relation.createdAt,
+                    });
+                }
+            }
+            // Process incoming relations (inverse)
+            for (const relation of inverseRelations.nodes) {
+                const sourceIssue = await relation.issue;
+                if (sourceIssue) {
+                    // Flip the type for inverse relations
+                    const inverseType = relation.type === 'blocks' ? 'blocked' : relation.type === 'blocked' ? 'blocks' : relation.type;
+                    data.push({
+                        id: relation.id,
+                        type: inverseType,
+                        issueId: issue.id,
+                        issueIdentifier: issue.identifier,
+                        issueTitle: issue.title,
+                        relatedIssueId: sourceIssue.id,
+                        relatedIssueIdentifier: sourceIssue.identifier,
+                        relatedIssueTitle: sourceIssue.title,
+                        createdAt: relation.createdAt,
+                    });
+                }
+            }
+            if (format === 'json') {
+                print(successList(data));
+            }
+            else {
+                printList(data, format, {
+                    columns: COLUMNS,
+                    primaryKey: 'issueIdentifier',
+                    secondaryKey: 'relatedIssueIdentifier',
+                });
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Search extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        query: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        team: import("@oclif/core/interfaces").OptionFlag<string | undefined, 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/search.js

@@ -0,0 +1,102 @@
+import { Args, 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, formatPriority } from '../lib/formatter.js';
+const COLUMNS = [
+    {
+        key: 'identifier',
+        header: 'ID',
+        format: (value) => colors.cyan(String(value)),
+    },
+    {
+        key: 'priority',
+        header: 'PRI',
+        format: (value) => formatPriority(Number(value)),
+    },
+    {
+        key: 'title',
+        header: 'TITLE',
+        format: (value) => truncate(String(value), 50),
+    },
+];
+export default class Search extends Command {
+    static description = 'Search issues by text query';
+    static examples = [
+        '<%= config.bin %> search "bug login"',
+        '<%= config.bin %> search "SSO" --team ENG',
+        '<%= config.bin %> search "authentication" --format table',
+    ];
+    static args = {
+        query: Args.string({
+            description: 'Search query',
+            required: true,
+        }),
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        team: Flags.string({
+            char: 't',
+            description: 'Filter by team key (e.g., ENG)',
+        }),
+        first: Flags.integer({
+            description: 'Number of results to fetch (default: 20)',
+            default: 20,
+        }),
+        after: Flags.string({
+            description: 'Cursor for pagination',
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(Search);
+            const format = flags.format;
+            const client = getClient();
+            // Build filter for team if specified
+            const filter = flags.team ? { team: { key: { eq: flags.team } } } : undefined;
+            // Use the searchIssues method for text search
+            const searchResults = await client.searchIssues(args.query, {
+                filter,
+                first: flags.first,
+                after: flags.after,
+            });
+            const data = searchResults.nodes.map((issue) => ({
+                id: issue.id,
+                identifier: issue.identifier,
+                title: issue.title,
+                description: issue.description ?? undefined,
+                priority: issue.priority,
+                priorityLabel: issue.priorityLabel,
+                url: issue.url,
+                createdAt: issue.createdAt,
+                updatedAt: issue.updatedAt,
+            }));
+            const pageInfo = {
+                hasNextPage: searchResults.pageInfo.hasNextPage,
+                hasPreviousPage: searchResults.pageInfo.hasPreviousPage,
+                startCursor: searchResults.pageInfo.startCursor,
+                endCursor: searchResults.pageInfo.endCursor,
+            };
+            if (format === 'json') {
+                print(successList(data, pageInfo));
+            }
+            else {
+                printList(data, format, {
+                    columns: COLUMNS,
+                    primaryKey: 'identifier',
+                    secondaryKey: 'title',
+                    pageInfo,
+                });
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class StatesList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        team: import("@oclif/core/interfaces").OptionFlag<string | undefined, 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/states/list.js

@@ -0,0 +1,151 @@
+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 } from '../../lib/formatter.js';
+const STATE_TYPE_ORDER = {
+    backlog: 1,
+    unstarted: 2,
+    started: 3,
+    completed: 4,
+    canceled: 5,
+};
+const formatStateType = (type) => {
+    switch (type) {
+        case 'backlog':
+            return colors.gray('backlog');
+        case 'unstarted':
+            return colors.blue('unstarted');
+        case 'started':
+            return colors.yellow('started');
+        case 'completed':
+            return colors.green('completed');
+        case 'canceled':
+            return colors.red('canceled');
+        default:
+            return type;
+    }
+};
+const COLUMNS = [
+    {
+        key: 'teamKey',
+        header: 'TEAM',
+        format: (value) => colors.cyan(String(value)),
+    },
+    {
+        key: 'name',
+        header: 'NAME',
+        format: (value) => colors.bold(String(value)),
+    },
+    {
+        key: 'type',
+        header: 'TYPE',
+        format: (value) => formatStateType(String(value)),
+    },
+    {
+        key: 'color',
+        header: 'COLOR',
+        format: (value) => colors.dim(String(value)),
+    },
+];
+export default class StatesList extends Command {
+    static description = 'List workflow states in the workspace';
+    static examples = [
+        '<%= config.bin %> states list',
+        '<%= config.bin %> states list --format table',
+        '<%= config.bin %> states list --team ENG',
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        team: Flags.string({
+            char: 't',
+            description: 'Filter by team key (e.g., ENG)',
+        }),
+        first: Flags.integer({
+            description: 'Number of states to fetch (default: 100)',
+            default: 100,
+        }),
+        after: Flags.string({
+            description: 'Cursor for pagination',
+        }),
+    };
+    async run() {
+        try {
+            const { flags } = await this.parse(StatesList);
+            const format = flags.format;
+            const client = getClient();
+            let states;
+            if (flags.team) {
+                // Fetch states for a specific team
+                const teams = await client.teams({
+                    filter: { key: { eq: flags.team } },
+                });
+                const team = teams.nodes[0];
+                if (!team) {
+                    throw new Error(`Team ${flags.team} not found`);
+                }
+                states = await team.states({
+                    first: flags.first,
+                    after: flags.after,
+                });
+            }
+            else {
+                // Fetch all workflow states
+                states = await client.workflowStates({
+                    first: flags.first,
+                    after: flags.after,
+                });
+            }
+            const data = await Promise.all(states.nodes.map(async (state) => {
+                const team = await state.team;
+                return {
+                    id: state.id,
+                    name: state.name,
+                    color: state.color,
+                    type: state.type,
+                    position: state.position,
+                    teamId: team?.id ?? '',
+                    teamKey: team?.key ?? '',
+                };
+            }));
+            // Sort by team, then by type order, then by position
+            data.sort((a, b) => {
+                if (a.teamKey !== b.teamKey) {
+                    return a.teamKey.localeCompare(b.teamKey);
+                }
+                const typeOrderA = STATE_TYPE_ORDER[a.type] ?? 99;
+                const typeOrderB = STATE_TYPE_ORDER[b.type] ?? 99;
+                if (typeOrderA !== typeOrderB) {
+                    return typeOrderA - typeOrderB;
+                }
+                return a.position - b.position;
+            });
+            const pageInfo = {
+                hasNextPage: states.pageInfo.hasNextPage,
+                hasPreviousPage: states.pageInfo.hasPreviousPage,
+                startCursor: states.pageInfo.startCursor,
+                endCursor: states.pageInfo.endCursor,
+            };
+            if (format === 'json') {
+                print(successList(data, pageInfo));
+            }
+            else {
+                printList(data, format, {
+                    columns: COLUMNS,
+                    primaryKey: 'name',
+                    secondaryKey: 'type',
+                    pageInfo,
+                });
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/templates/create.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class TemplatesCreate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'team-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'template-data': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/templates/create.js

@@ -0,0 +1,102 @@
+import { Command, Flags } from '@oclif/core';
+import { getClient } from '../../lib/client.js';
+import { success, print, printItem } from '../../lib/output.js';
+import { handleError, CliError, ErrorCodes } from '../../lib/errors.js';
+export default class TemplatesCreate extends Command {
+    static description = 'Create a template';
+    static examples = [
+        '<%= config.bin %> templates create --name "Bug Report" --type issue --team-id TEAM_ID --template-data \'{"title":"Bug: ","priority":2}\'',
+        '<%= config.bin %> templates create --name "Feature Request" --type issue --template-data \'{"title":"Feature: "}\'',
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Template name',
+            required: true,
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Template type',
+            required: true,
+            options: ['issue', 'project'],
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+        'team-id': Flags.string({
+            description: 'Team ID (optional, for team-specific templates)',
+        }),
+        'template-data': Flags.string({
+            description: 'Template data as JSON (e.g., {"title":"Bug: ","priority":2})',
+            required: true,
+        }),
+    };
+    async run() {
+        try {
+            const { flags } = await this.parse(TemplatesCreate);
+            const format = flags.format;
+            const client = getClient();
+            let templateData;
+            try {
+                templateData = JSON.parse(flags['template-data']);
+            }
+            catch {
+                throw new CliError(ErrorCodes.INVALID_INPUT, 'Invalid JSON in --template-data');
+            }
+            const payload = await client.createTemplate({
+                name: flags.name,
+                type: flags.type,
+                description: flags.description,
+                teamId: flags['team-id'],
+                templateData,
+            });
+            if (!payload.success || !payload.template) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to create template');
+            }
+            const template = await payload.template;
+            const team = await template.team;
+            const data = {
+                id: template.id,
+                name: template.name,
+                type: template.type,
+                description: template.description,
+                templateData: template.templateData,
+                team: team
+                    ? {
+                        id: team.id,
+                        key: team.key,
+                        name: team.name,
+                    }
+                    : null,
+                createdAt: template.createdAt,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                printItem({
+                    id: data.id,
+                    name: data.name,
+                    type: data.type,
+                    description: data.description ?? 'N/A',
+                    team: data.team?.key ?? 'Organization',
+                    createdAt: data.createdAt,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/templates/get.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class TemplatesGet extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/templates/get.js

@@ -0,0 +1,84 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getClient } from '../../lib/client.js';
+import { success, print, printItem } from '../../lib/output.js';
+import { handleError, CliError, ErrorCodes } from '../../lib/errors.js';
+export default class TemplatesGet extends Command {
+    static description = 'Get a template by ID';
+    static examples = [
+        '<%= config.bin %> templates get TEMPLATE_ID',
+        '<%= config.bin %> templates get TEMPLATE_ID --format table',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Template ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(TemplatesGet);
+            const format = flags.format;
+            const client = getClient();
+            // Templates need to be fetched via organization
+            const org = await client.organization;
+            const templates = await org.templates();
+            const template = templates.nodes.find((t) => t.id === args.id);
+            if (!template) {
+                throw new CliError(ErrorCodes.NOT_FOUND, `Template ${args.id} not found`);
+            }
+            const [team, creator] = await Promise.all([template.team, template.creator]);
+            const data = {
+                id: template.id,
+                name: template.name,
+                type: template.type,
+                description: template.description,
+                templateData: template.templateData,
+                team: team
+                    ? {
+                        id: team.id,
+                        key: team.key,
+                        name: team.name,
+                    }
+                    : null,
+                creator: creator
+                    ? {
+                        id: creator.id,
+                        name: creator.name,
+                    }
+                    : null,
+                createdAt: template.createdAt,
+                updatedAt: template.updatedAt,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                printItem({
+                    id: data.id,
+                    name: data.name,
+                    type: data.type,
+                    description: data.description ?? 'N/A',
+                    team: data.team?.key ?? 'Organization',
+                    creator: data.creator?.name ?? 'Unknown',
+                    createdAt: data.createdAt,
+                    updatedAt: data.updatedAt,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class TemplatesList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        team: import("@oclif/core/interfaces").OptionFlag<string | undefined, 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>;
+}