linear-cli-agents 0.2.1 → 0.4.1

package/dist/commands/projects/list.js

@@ -0,0 +1,141 @@
+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 formatProgress = (progress) => {
+    const percentage = Math.round(progress * 100);
+    if (percentage === 100) {
+        return colors.green(`${percentage}%`);
+    }
+    if (percentage >= 75) {
+        return colors.cyan(`${percentage}%`);
+    }
+    if (percentage >= 50) {
+        return colors.yellow(`${percentage}%`);
+    }
+    return colors.dim(`${percentage}%`);
+};
+const formatState = (state) => {
+    switch (state) {
+        case 'planned':
+            return colors.blue('planned');
+        case 'started':
+            return colors.yellow('started');
+        case 'paused':
+            return colors.gray('paused');
+        case 'completed':
+            return colors.green('completed');
+        case 'canceled':
+            return colors.red('canceled');
+        default:
+            return state;
+    }
+};
+const COLUMNS = [
+    {
+        key: 'name',
+        header: 'NAME',
+        format: (value) => colors.bold(truncate(String(value), 30)),
+    },
+    {
+        key: 'state',
+        header: 'STATE',
+        format: (value) => formatState(String(value)),
+    },
+    {
+        key: 'progress',
+        header: 'PROGRESS',
+        format: (value) => formatProgress(Number(value)),
+    },
+    {
+        key: 'targetDate',
+        header: 'TARGET',
+        format: (value) => (value ? colors.dim(String(value)) : colors.gray('No date')),
+    },
+];
+export default class ProjectsList extends Command {
+    static description = 'List projects in the workspace';
+    static examples = [
+        '<%= config.bin %> projects list',
+        '<%= config.bin %> projects list --format table',
+        '<%= config.bin %> projects list --team ENG',
+        '<%= config.bin %> projects list --state started',
+    ];
+    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)',
+        }),
+        state: Flags.string({
+            char: 's',
+            description: 'Filter by state (planned, started, paused, completed, canceled)',
+        }),
+        first: Flags.integer({
+            description: 'Number of projects to fetch (default: 50)',
+            default: 50,
+        }),
+        after: Flags.string({
+            description: 'Cursor for pagination',
+        }),
+    };
+    async run() {
+        try {
+            const { flags } = await this.parse(ProjectsList);
+            const format = flags.format;
+            const client = getClient();
+            // Build filter
+            const filter = {};
+            if (flags.state) {
+                filter.state = { eq: flags.state };
+            }
+            if (flags.team) {
+                // Filter projects by team
+                filter.accessibleTeams = { key: { eq: flags.team } };
+            }
+            const projects = await client.projects({
+                filter: Object.keys(filter).length > 0 ? filter : undefined,
+                first: flags.first,
+                after: flags.after,
+            });
+            const data = projects.nodes.map((project) => ({
+                id: project.id,
+                name: project.name,
+                description: project.description ?? undefined,
+                state: project.state,
+                progress: project.progress,
+                targetDate: project.targetDate ?? undefined,
+                url: project.url,
+                createdAt: project.createdAt,
+                updatedAt: project.updatedAt,
+            }));
+            const pageInfo = {
+                hasNextPage: projects.pageInfo.hasNextPage,
+                hasPreviousPage: projects.pageInfo.hasPreviousPage,
+                startCursor: projects.pageInfo.startCursor,
+                endCursor: projects.pageInfo.endCursor,
+            };
+            if (format === 'json') {
+                print(successList(data, pageInfo));
+            }
+            else {
+                printList(data, format, {
+                    columns: COLUMNS,
+                    primaryKey: 'name',
+                    secondaryKey: 'state',
+                    pageInfo,
+                });
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/projects/update.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class ProjectsUpdate 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>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        state: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'lead-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'start-date': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'target-date': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/projects/update.js

@@ -0,0 +1,125 @@
+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 ProjectsUpdate extends Command {
+    static description = 'Update a project';
+    static examples = [
+        '<%= config.bin %> projects update PROJECT_ID --name "Updated Name"',
+        '<%= config.bin %> projects update PROJECT_ID --state completed',
+        '<%= config.bin %> projects update PROJECT_ID --target-date 2024-06-30',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Project ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Project name',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Project description',
+        }),
+        state: Flags.string({
+            char: 's',
+            description: 'Project state',
+            options: ['planned', 'started', 'paused', 'completed', 'canceled'],
+        }),
+        'lead-id': Flags.string({
+            description: 'Lead user ID',
+        }),
+        'start-date': Flags.string({
+            description: 'Start date (YYYY-MM-DD)',
+        }),
+        'target-date': Flags.string({
+            description: 'Target date (YYYY-MM-DD)',
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(ProjectsUpdate);
+            const format = flags.format;
+            const client = getClient();
+            const input = {};
+            if (flags.name)
+                input.name = flags.name;
+            if (flags.description)
+                input.description = flags.description;
+            if (flags.state)
+                input.state = flags.state;
+            if (flags['lead-id'])
+                input.leadId = flags['lead-id'];
+            if (flags['start-date'])
+                input.startDate = flags['start-date'];
+            if (flags['target-date'])
+                input.targetDate = flags['target-date'];
+            if (Object.keys(input).length === 0) {
+                throw new CliError(ErrorCodes.INVALID_INPUT, 'At least one field to update is required');
+            }
+            const payload = await client.updateProject(args.id, input);
+            if (!payload.success || !payload.project) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to update project');
+            }
+            const project = await payload.project;
+            const [lead, teams] = await Promise.all([project.lead, project.teams()]);
+            const data = {
+                id: project.id,
+                name: project.name,
+                description: project.description,
+                state: project.state,
+                progress: project.progress,
+                startDate: project.startDate,
+                targetDate: project.targetDate,
+                url: project.url,
+                lead: lead
+                    ? {
+                        id: lead.id,
+                        name: lead.name,
+                    }
+                    : null,
+                teams: teams.nodes.map((team) => ({
+                    id: team.id,
+                    key: team.key,
+                    name: team.name,
+                })),
+                createdAt: project.createdAt,
+                updatedAt: project.updatedAt,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                printItem({
+                    id: data.id,
+                    name: data.name,
+                    description: data.description ?? 'N/A',
+                    state: data.state,
+                    progress: `${Math.round(data.progress * 100)}%`,
+                    startDate: data.startDate ?? 'N/A',
+                    targetDate: data.targetDate ?? 'N/A',
+                    lead: data.lead?.name ?? 'None',
+                    teams: data.teams.map((t) => t.key).join(', '),
+                    url: data.url,
+                    updatedAt: data.updatedAt,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

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

package/dist/commands/relations/create.js

@@ -0,0 +1,98 @@
+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';
+import { resolveIssueId } from '../../lib/issue-utils.js';
+const RELATION_TYPES = ['blocks', 'duplicate', 'related'];
+export default class RelationsCreate extends Command {
+    static description = 'Create a relation between two issues';
+    static examples = [
+        '<%= config.bin %> relations create ENG-123 ENG-456 --type blocks',
+        '<%= config.bin %> relations create ENG-123 ENG-456 --type duplicate',
+        '<%= config.bin %> relations create ENG-123 ENG-456 --type related',
+    ];
+    static args = {
+        issue: Args.string({
+            description: 'Source issue ID or identifier (e.g., ENG-123)',
+            required: true,
+        }),
+        relatedIssue: Args.string({
+            description: 'Related issue ID or identifier (e.g., ENG-456)',
+            required: true,
+        }),
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Relation type (blocks, duplicate, related)',
+            required: true,
+            options: [...RELATION_TYPES],
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(RelationsCreate);
+            const format = flags.format;
+            const relationType = flags.type;
+            const client = getClient();
+            const [issueId, relatedIssueId] = await Promise.all([
+                resolveIssueId(client, args.issue),
+                resolveIssueId(client, args.relatedIssue),
+            ]);
+            const payload = await client.createIssueRelation({
+                issueId,
+                relatedIssueId,
+                type: relationType,
+            });
+            if (!payload.success || !payload.issueRelation) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to create relation');
+            }
+            const relation = await payload.issueRelation;
+            const [issue, relatedIssue] = await Promise.all([relation.issue, relation.relatedIssue]);
+            const data = {
+                id: relation.id,
+                type: relation.type,
+                issue: issue
+                    ? {
+                        id: issue.id,
+                        identifier: issue.identifier,
+                        title: issue.title,
+                    }
+                    : null,
+                relatedIssue: relatedIssue
+                    ? {
+                        id: relatedIssue.id,
+                        identifier: relatedIssue.identifier,
+                        title: relatedIssue.title,
+                    }
+                    : null,
+                createdAt: relation.createdAt,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                printItem({
+                    id: data.id,
+                    type: data.type,
+                    issue: data.issue?.identifier ?? 'N/A',
+                    relatedIssue: data.relatedIssue?.identifier ?? 'N/A',
+                    createdAt: data.createdAt,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/relations/delete.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class RelationsDelete 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/relations/delete.js

@@ -0,0 +1,47 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getClient } from '../../lib/client.js';
+import { success, print } from '../../lib/output.js';
+import { handleError, CliError, ErrorCodes } from '../../lib/errors.js';
+export default class RelationsDelete extends Command {
+    static description = 'Delete an issue relation';
+    static examples = ['<%= config.bin %> relations delete RELATION_ID'];
+    static args = {
+        id: Args.string({
+            description: 'Relation 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(RelationsDelete);
+            const format = flags.format;
+            const client = getClient();
+            const payload = await client.deleteIssueRelation(args.id);
+            if (!payload.success) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to delete relation');
+            }
+            const data = {
+                id: args.id,
+                deleted: true,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else {
+                console.log(`Relation ${args.id} deleted`);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class RelationsList extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        issue: 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/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>;
+}