linear-cli-agents 0.2.0 → 0.4.0

package/dist/commands/project-updates/get.js

@@ -0,0 +1,80 @@
+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 ProjectUpdatesGet extends Command {
+    static description = 'Get a project update by ID';
+    static examples = [
+        '<%= config.bin %> project-updates get UPDATE_ID',
+        '<%= config.bin %> project-updates get UPDATE_ID --format table',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Project update 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(ProjectUpdatesGet);
+            const format = flags.format;
+            const client = getClient();
+            const update = await client.projectUpdate(args.id);
+            if (!update) {
+                throw new CliError(ErrorCodes.NOT_FOUND, `Project update ${args.id} not found`);
+            }
+            const [project, user] = await Promise.all([update.project, update.user]);
+            const data = {
+                id: update.id,
+                body: update.body,
+                health: update.health,
+                url: update.url,
+                project: project
+                    ? {
+                        id: project.id,
+                        name: project.name,
+                    }
+                    : null,
+                user: user
+                    ? {
+                        id: user.id,
+                        name: user.name,
+                        email: user.email,
+                    }
+                    : null,
+                createdAt: update.createdAt,
+                updatedAt: update.updatedAt,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                printItem({
+                    id: data.id,
+                    project: data.project?.name ?? 'N/A',
+                    health: data.health,
+                    body: data.body,
+                    user: data.user?.name ?? 'Unknown',
+                    url: data.url,
+                    createdAt: data.createdAt,
+                    updatedAt: data.updatedAt,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/project-updates/list.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class ProjectUpdatesList extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        projectId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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/project-updates/list.js

@@ -0,0 +1,120 @@
+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 { colors, truncate } from '../../lib/formatter.js';
+const formatHealth = (health) => {
+    switch (health) {
+        case 'onTrack':
+            return colors.green('On Track');
+        case 'atRisk':
+            return colors.yellow('At Risk');
+        case 'offTrack':
+            return colors.red('Off Track');
+        default:
+            return health;
+    }
+};
+const COLUMNS = [
+    {
+        key: 'projectName',
+        header: 'PROJECT',
+        format: (value) => colors.cyan(truncate(String(value), 20)),
+    },
+    {
+        key: 'health',
+        header: 'HEALTH',
+        format: (value) => formatHealth(String(value)),
+    },
+    {
+        key: 'userName',
+        header: 'BY',
+        format: (value) => colors.dim(String(value)),
+    },
+    {
+        key: 'createdAt',
+        header: 'DATE',
+        format: (value) => {
+            const date = new Date(value);
+            return colors.dim(date.toLocaleDateString());
+        },
+    },
+];
+export default class ProjectUpdatesList extends Command {
+    static description = 'List project updates';
+    static examples = [
+        '<%= config.bin %> project-updates list PROJECT_ID',
+        '<%= config.bin %> project-updates list PROJECT_ID --format table',
+    ];
+    static args = {
+        projectId: Args.string({
+            description: 'Project ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        first: Flags.integer({
+            description: 'Number of updates to fetch (default: 20)',
+            default: 20,
+        }),
+        after: Flags.string({
+            description: 'Cursor for pagination',
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(ProjectUpdatesList);
+            const format = flags.format;
+            const client = getClient();
+            const project = await client.project(args.projectId);
+            if (!project) {
+                throw new CliError(ErrorCodes.NOT_FOUND, `Project ${args.projectId} not found`);
+            }
+            const updates = await project.projectUpdates({
+                first: flags.first,
+                after: flags.after,
+            });
+            const data = await Promise.all(updates.nodes.map(async (update) => {
+                const user = await update.user;
+                return {
+                    id: update.id,
+                    body: update.body,
+                    health: update.health,
+                    projectId: project.id,
+                    projectName: project.name,
+                    userId: user?.id ?? '',
+                    userName: user?.name ?? 'Unknown',
+                    createdAt: update.createdAt,
+                    updatedAt: update.updatedAt,
+                };
+            }));
+            const pageInfo = {
+                hasNextPage: updates.pageInfo.hasNextPage,
+                hasPreviousPage: updates.pageInfo.hasPreviousPage,
+                startCursor: updates.pageInfo.startCursor,
+                endCursor: updates.pageInfo.endCursor,
+            };
+            if (format === 'json') {
+                print(successList(data, pageInfo));
+            }
+            else {
+                printList(data, format, {
+                    columns: COLUMNS,
+                    primaryKey: 'id',
+                    secondaryKey: 'body',
+                    pageInfo,
+                });
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/project-updates/update.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class ProjectUpdatesUpdate 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>;
+        body: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        health: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/project-updates/update.js

@@ -0,0 +1,96 @@
+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';
+const HEALTH_OPTIONS = ['onTrack', 'atRisk', 'offTrack'];
+export default class ProjectUpdatesUpdate extends Command {
+    static description = 'Update a project update';
+    static examples = [
+        '<%= config.bin %> project-updates update UPDATE_ID --body "Updated status"',
+        '<%= config.bin %> project-updates update UPDATE_ID --health offTrack',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Project update ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        body: Flags.string({
+            char: 'b',
+            description: 'Update body (supports markdown)',
+        }),
+        health: Flags.string({
+            char: 'h',
+            description: 'Project health status',
+            options: [...HEALTH_OPTIONS],
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(ProjectUpdatesUpdate);
+            const format = flags.format;
+            const client = getClient();
+            const input = {};
+            if (flags.body)
+                input.body = flags.body;
+            if (flags.health)
+                input.health = flags.health;
+            if (Object.keys(input).length === 0) {
+                throw new CliError(ErrorCodes.INVALID_INPUT, 'At least one field to update is required');
+            }
+            const payload = await client.updateProjectUpdate(args.id, input);
+            if (!payload.success || !payload.projectUpdate) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to update project update');
+            }
+            const update = await payload.projectUpdate;
+            const [project, user] = await Promise.all([update.project, update.user]);
+            const data = {
+                id: update.id,
+                body: update.body,
+                health: update.health,
+                url: update.url,
+                project: project
+                    ? {
+                        id: project.id,
+                        name: project.name,
+                    }
+                    : null,
+                user: user
+                    ? {
+                        id: user.id,
+                        name: user.name,
+                    }
+                    : null,
+                createdAt: update.createdAt,
+                updatedAt: update.updatedAt,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                printItem({
+                    id: data.id,
+                    project: data.project?.name ?? 'N/A',
+                    health: data.health,
+                    body: data.body,
+                    user: data.user?.name ?? 'Unknown',
+                    updatedAt: data.updatedAt,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class ProjectsArchive 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>;
+        unarchive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/projects/archive.js

@@ -0,0 +1,79 @@
+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 ProjectsArchive extends Command {
+    static description = 'Archive a project';
+    static examples = [
+        '<%= config.bin %> projects archive PROJECT_ID',
+        '<%= config.bin %> projects archive PROJECT_ID --unarchive',
+    ];
+    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',
+        }),
+        unarchive: Flags.boolean({
+            char: 'u',
+            description: 'Unarchive instead of archive',
+            default: false,
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(ProjectsArchive);
+            const format = flags.format;
+            const client = getClient();
+            let payload;
+            if (flags.unarchive) {
+                payload = await client.unarchiveProject(args.id);
+            }
+            else {
+                payload = await client.archiveProject(args.id);
+            }
+            if (!payload.success) {
+                const action = flags.unarchive ? 'unarchive' : 'archive';
+                throw new CliError(ErrorCodes.API_ERROR, `Failed to ${action} project`);
+            }
+            const project = await payload.project;
+            if (!project) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Project not found in response');
+            }
+            const action = flags.unarchive ? 'unarchived' : 'archived';
+            const data = {
+                id: project.id,
+                name: project.name,
+                action,
+                archivedAt: project.archivedAt,
+                url: project.url,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                printItem({
+                    id: data.id,
+                    name: data.name,
+                    action: data.action,
+                    archivedAt: data.archivedAt ?? 'N/A',
+                    url: data.url,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class ProjectsCreate 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>;
+        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>;
+        'team-ids': import("@oclif/core/interfaces").OptionFlag<string, 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/create.js

@@ -0,0 +1,115 @@
+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 ProjectsCreate extends Command {
+    static description = 'Create a project';
+    static examples = [
+        '<%= config.bin %> projects create --name "My Project" --team-ids TEAM_ID',
+        '<%= config.bin %> projects create --name "Q1 Goals" --description "First quarter objectives" --target-date 2024-03-31',
+        '<%= config.bin %> projects create --name "Feature X" --state started --lead-id USER_ID',
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Project name',
+            required: true,
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Project description',
+        }),
+        state: Flags.string({
+            char: 's',
+            description: 'Project state',
+            options: ['planned', 'started', 'paused', 'completed', 'canceled'],
+        }),
+        'team-ids': Flags.string({
+            description: 'Team IDs (comma-separated)',
+            required: true,
+        }),
+        '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 { flags } = await this.parse(ProjectsCreate);
+            const format = flags.format;
+            const client = getClient();
+            const teamIds = flags['team-ids'].split(',').map((id) => id.trim());
+            const payload = await client.createProject({
+                name: flags.name,
+                description: flags.description,
+                state: flags.state,
+                teamIds,
+                leadId: flags['lead-id'],
+                startDate: flags['start-date'],
+                targetDate: flags['target-date'],
+            });
+            if (!payload.success || !payload.project) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to create 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,
+            };
+            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,
+                    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,
+                    createdAt: data.createdAt,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

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

@@ -0,0 +1,50 @@
+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 ProjectsDelete extends Command {
+    static description = 'Delete a project';
+    static examples = ['<%= config.bin %> projects delete PROJECT_ID'];
+    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',
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(ProjectsDelete);
+            const format = flags.format;
+            const client = getClient();
+            const payload = await client.deleteProject(args.id);
+            if (!payload.success) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to delete project');
+            }
+            const data = {
+                id: args.id,
+                deleted: true,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                console.log(`Project ${args.id} deleted successfully`);
+            }
+            else {
+                console.log(args.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

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