linear-cli-agents 0.6.0 → 0.7.0

package/dist/commands/info.js

@@ -43,8 +43,9 @@ const COMMANDS = {
         args: { id: { description: 'Issue ID or identifier (e.g., ENG-123)', required: true } },
         flags: {
             format: { type: 'string', options: ['json', 'table', 'plain'], default: 'json' },
+            'with-attachments': { type: 'boolean', description: 'Include attachments (linked PRs, commits, etc.)' },
         },
-        examples: ['linear issues get ENG-123', 'linear issues get abc123-uuid'],
+        examples: ['linear issues get ENG-123', 'linear issues get ENG-123 --with-attachments'],
     },
     'issues create': {
         description: 'Create a new issue',
@@ -405,6 +406,122 @@ const COMMANDS = {
         },
         examples: ['linear templates update TEMPLATE_ID --name "New Name"'],
     },
+    // Documents
+    'documents list': {
+        description: 'List documents',
+        flags: {
+            format: { type: 'string', options: ['json', 'table', 'plain'], default: 'json' },
+            first: { type: 'number', description: 'Number of results' },
+        },
+        examples: ['linear documents list'],
+    },
+    'documents get': {
+        description: 'Get document details',
+        args: { id: { description: 'Document ID', required: true } },
+        flags: { format: { type: 'string', options: ['json', 'table', 'plain'], default: 'json' } },
+        examples: ['linear documents get DOCUMENT_ID'],
+    },
+    'documents create': {
+        description: 'Create a new document',
+        flags: {
+            title: { type: 'string', char: 't', description: 'Document title', required: true },
+            content: { type: 'string', char: 'c', description: 'Document content (markdown)' },
+            'project-id': { type: 'string', description: 'Project ID to associate with' },
+            icon: { type: 'string', description: 'Document icon (emoji)' },
+            color: { type: 'string', description: 'Document color (hex)' },
+        },
+        examples: [
+            'linear documents create --title "My Document"',
+            'linear documents create --title "Notes" --content "# Heading\\n\\nContent"',
+        ],
+    },
+    'documents update': {
+        description: 'Update a document',
+        args: { id: { description: 'Document ID', required: true } },
+        flags: {
+            title: { type: 'string', char: 't', description: 'New title' },
+            content: { type: 'string', char: 'c', description: 'New content (markdown)' },
+            'project-id': { type: 'string', description: 'New project ID (empty to remove)' },
+            icon: { type: 'string', description: 'New icon (emoji)' },
+            color: { type: 'string', description: 'New color (hex)' },
+        },
+        examples: ['linear documents update DOCUMENT_ID --title "New Title"'],
+    },
+    'documents delete': {
+        description: 'Delete a document (moves to trash)',
+        args: { id: { description: 'Document ID', required: true } },
+        flags: {},
+        examples: ['linear documents delete DOCUMENT_ID'],
+    },
+    // Initiatives
+    'initiatives list': {
+        description: 'List initiatives',
+        flags: {
+            format: { type: 'string', options: ['json', 'table', 'plain'], default: 'json' },
+            status: { type: 'string', options: ['Planned', 'Active', 'Completed'], description: 'Filter by status' },
+            first: { type: 'number', description: 'Number of results' },
+        },
+        examples: [
+            'linear initiatives list',
+            'linear initiatives list --status Active',
+        ],
+    },
+    'initiatives get': {
+        description: 'Get initiative details',
+        args: { id: { description: 'Initiative ID', required: true } },
+        flags: { format: { type: 'string', options: ['json', 'table', 'plain'], default: 'json' } },
+        examples: ['linear initiatives get INITIATIVE_ID'],
+    },
+    'initiatives create': {
+        description: 'Create a new initiative',
+        flags: {
+            name: { type: 'string', char: 'n', description: 'Initiative name', required: true },
+            description: { type: 'string', char: 'd', description: 'Initiative description' },
+            status: { type: 'string', options: ['Planned', 'Active', 'Completed'], description: 'Initial status' },
+            'target-date': { type: 'string', description: 'Target completion date (YYYY-MM-DD)' },
+            'owner-id': { type: 'string', description: 'Owner user ID' },
+            icon: { type: 'string', description: 'Initiative icon (emoji)' },
+            color: { type: 'string', description: 'Initiative color (hex)' },
+        },
+        examples: [
+            'linear initiatives create --name "Q1 Goals"',
+            'linear initiatives create --name "Launch" --status Active --target-date 2024-12-31',
+        ],
+    },
+    'initiatives update': {
+        description: 'Update an initiative',
+        args: { id: { description: 'Initiative ID', required: true } },
+        flags: {
+            name: { type: 'string', char: 'n', description: 'New name' },
+            description: { type: 'string', char: 'd', description: 'New description' },
+            status: { type: 'string', options: ['Planned', 'Active', 'Completed'], description: 'New status' },
+            'target-date': { type: 'string', description: 'New target date (YYYY-MM-DD)' },
+            'owner-id': { type: 'string', description: 'New owner user ID' },
+            icon: { type: 'string', description: 'New icon (emoji)' },
+            color: { type: 'string', description: 'New color (hex)' },
+        },
+        examples: [
+            'linear initiatives update INITIATIVE_ID --status Completed',
+            'linear initiatives update INITIATIVE_ID --name "New Name"',
+        ],
+    },
+    'initiatives delete': {
+        description: 'Delete an initiative (moves to trash)',
+        args: { id: { description: 'Initiative ID', required: true } },
+        flags: {},
+        examples: ['linear initiatives delete INITIATIVE_ID'],
+    },
+    'initiatives archive': {
+        description: 'Archive or unarchive an initiative',
+        args: { id: { description: 'Initiative ID', required: true } },
+        flags: {
+            unarchive: { type: 'boolean', char: 'u', description: 'Unarchive instead of archive' },
+        },
+        examples: [
+            'linear initiatives archive INITIATIVE_ID',
+            'linear initiatives archive INITIATIVE_ID --unarchive',
+        ],
+    },
     // Config
     'config set': {
         description: 'Set a configuration value',
@@ -501,6 +618,19 @@ const COMMANDS = {
         },
         examples: ['linear schema', 'linear schema issues', 'linear schema --full'],
     },
+    upload: {
+        description: 'Upload a file to Linear and get the asset URL',
+        args: { file: { description: 'Path to the file to upload', required: true } },
+        flags: {
+            'content-type': { type: 'string', description: 'Override the content type (MIME type)' },
+            markdown: { type: 'boolean', char: 'm', description: 'Output as markdown link/image' },
+        },
+        examples: [
+            'linear upload ./screenshot.png',
+            'linear upload ./document.pdf --content-type application/pdf',
+            'linear upload ./image.png --markdown',
+        ],
+    },
     info: {
         description: 'Show comprehensive CLI documentation (this command)',
         flags: {
@@ -616,6 +746,34 @@ const ENTITY_SCHEMAS = {
             createdAt: 'Creation timestamp',
         },
     },
+    documents: {
+        entity: 'documents',
+        operations: ['list', 'get', 'create', 'update', 'delete'],
+        description: 'Rich text documents in Linear',
+        fields: {
+            id: 'Unique identifier',
+            title: 'Document title',
+            content: 'Markdown content',
+            icon: 'Document icon (emoji)',
+            color: 'Document color (hex)',
+            project: 'Associated project',
+            creator: 'User who created it',
+        },
+    },
+    initiatives: {
+        entity: 'initiatives',
+        operations: ['list', 'get', 'create', 'update', 'delete', 'archive'],
+        description: 'Strategic initiatives grouping projects',
+        fields: {
+            id: 'Unique identifier',
+            name: 'Initiative name',
+            description: 'Initiative description',
+            status: 'Planned/Active/Completed',
+            targetDate: 'Target completion date',
+            owner: 'Initiative owner',
+            projects: 'Associated projects',
+        },
+    },
 };
 const WORKFLOWS = {
     createIssue: {
@@ -692,7 +850,7 @@ export default class Info extends Command {
                 return acc;
             }, {});
             print(success({
-                version: '0.6.0',
+                version: '0.7.0',
                 commands: compactCommands,
                 configKeys: CONFIG_KEYS,
                 note: 'Use "linear info" for full documentation with examples and workflows',
@@ -701,7 +859,7 @@ export default class Info extends Command {
         }
         // Full documentation
         print(success({
-            version: '0.6.0',
+            version: '0.7.0',
             overview: {
                 description: 'CLI for interacting with Linear, designed for LLMs and agents',
                 authentication: 'Run "linear auth login" or set LINEAR_API_KEY environment variable',

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

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

package/dist/commands/initiatives/archive.js

@@ -0,0 +1,44 @@
+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 InitiativesArchive extends Command {
+    static description = 'Archive or unarchive an initiative';
+    static examples = [
+        '<%= config.bin %> initiatives archive INITIATIVE_ID',
+        '<%= config.bin %> initiatives archive INITIATIVE_ID --unarchive',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Initiative ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        unarchive: Flags.boolean({
+            char: 'u',
+            description: 'Unarchive instead of archive',
+            default: false,
+        }),
+    };
+    async run() {
+        try {
+            const { args, flags } = await this.parse(InitiativesArchive);
+            const client = getClient();
+            const payload = flags.unarchive
+                ? await client.unarchiveInitiative(args.id)
+                : await client.archiveInitiative(args.id);
+            if (!payload.success) {
+                throw new CliError(ErrorCodes.API_ERROR, `Failed to ${flags.unarchive ? 'unarchive' : 'archive'} initiative`);
+            }
+            print(success({
+                id: args.id,
+                archived: !flags.unarchive,
+            }));
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class InitiativesCreate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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>;
+        status: 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>;
+        'owner-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        icon: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        color: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/initiatives/create.js

@@ -0,0 +1,84 @@
+import { 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';
+import { LinearDocument } from '@linear/sdk';
+const InitiativeStatus = LinearDocument.InitiativeStatus;
+export default class InitiativesCreate extends Command {
+    static description = 'Create a new initiative';
+    static examples = [
+        '<%= config.bin %> initiatives create --name "Q1 Goals"',
+        '<%= config.bin %> initiatives create --name "Product Launch" --status Active',
+        '<%= config.bin %> initiatives create --name "H2 Objectives" --target-date 2024-12-31',
+    ];
+    static flags = {
+        name: Flags.string({
+            char: 'n',
+            description: 'Initiative name',
+            required: true,
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Initiative description',
+        }),
+        status: Flags.string({
+            char: 's',
+            description: 'Initiative status',
+            options: ['Planned', 'Active', 'Completed'],
+        }),
+        'target-date': Flags.string({
+            description: 'Target completion date (YYYY-MM-DD)',
+        }),
+        'owner-id': Flags.string({
+            description: 'Owner user ID',
+        }),
+        icon: Flags.string({
+            description: 'Initiative icon (emoji)',
+        }),
+        color: Flags.string({
+            description: 'Initiative color (hex)',
+        }),
+    };
+    async run() {
+        try {
+            const { flags } = await this.parse(InitiativesCreate);
+            const client = getClient();
+            const input = {
+                name: flags.name,
+            };
+            if (flags.description)
+                input.description = flags.description;
+            if (flags.status) {
+                input.status = InitiativeStatus[flags.status];
+            }
+            if (flags['target-date'])
+                input.targetDate = flags['target-date'];
+            if (flags['owner-id'])
+                input.ownerId = flags['owner-id'];
+            if (flags.icon)
+                input.icon = flags.icon;
+            if (flags.color)
+                input.color = flags.color;
+            const payload = await client.createInitiative(input);
+            if (!payload.success) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to create initiative');
+            }
+            const initiative = await payload.initiative;
+            if (!initiative) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Initiative not returned');
+            }
+            const owner = await initiative.owner;
+            print(success({
+                id: initiative.id,
+                name: initiative.name,
+                status: initiative.status,
+                owner: owner ? { id: owner.id, name: owner.name } : null,
+                createdAt: initiative.createdAt,
+            }));
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

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

package/dist/commands/initiatives/delete.js

@@ -0,0 +1,32 @@
+import { Args, Command } 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 InitiativesDelete extends Command {
+    static description = 'Delete an initiative (moves to trash)';
+    static examples = ['<%= config.bin %> initiatives delete INITIATIVE_ID'];
+    static args = {
+        id: Args.string({
+            description: 'Initiative ID',
+            required: true,
+        }),
+    };
+    async run() {
+        try {
+            const { args } = await this.parse(InitiativesDelete);
+            const client = getClient();
+            const payload = await client.deleteInitiative(args.id);
+            if (!payload.success) {
+                throw new CliError(ErrorCodes.API_ERROR, 'Failed to delete initiative');
+            }
+            print(success({
+                id: args.id,
+                deleted: true,
+            }));
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

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

@@ -0,0 +1,90 @@
+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 InitiativesGet extends Command {
+    static description = 'Get initiative details';
+    static examples = [
+        '<%= config.bin %> initiatives get INITIATIVE_ID',
+        '<%= config.bin %> initiatives get INITIATIVE_ID --format table',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Initiative 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(InitiativesGet);
+            const format = flags.format;
+            const client = getClient();
+            const initiative = await client.initiative(args.id);
+            if (!initiative) {
+                throw new CliError(ErrorCodes.NOT_FOUND, `Initiative ${args.id} not found`);
+            }
+            const [owner, creator, projects] = await Promise.all([
+                initiative.owner,
+                initiative.creator,
+                initiative.projects(),
+            ]);
+            const data = {
+                id: initiative.id,
+                name: initiative.name,
+                description: initiative.description ?? null,
+                status: initiative.status,
+                icon: initiative.icon ?? null,
+                color: initiative.color ?? null,
+                owner: owner
+                    ? {
+                        id: owner.id,
+                        name: owner.name,
+                    }
+                    : null,
+                creator: creator
+                    ? {
+                        id: creator.id,
+                        name: creator.name,
+                    }
+                    : null,
+                targetDate: initiative.targetDate ?? null,
+                projects: projects.nodes.map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                })),
+                createdAt: initiative.createdAt,
+                updatedAt: initiative.updatedAt,
+            };
+            if (format === 'json') {
+                print(success(data));
+            }
+            else if (format === 'table') {
+                printItem({
+                    id: data.id,
+                    name: data.name,
+                    status: data.status,
+                    owner: data.owner?.name ?? 'Unassigned',
+                    targetDate: data.targetDate ?? 'None',
+                    projects: data.projects.length,
+                    description: data.description ? `${data.description.slice(0, 100)}...` : 'None',
+                    createdAt: data.createdAt,
+                }, format);
+            }
+            else {
+                console.log(data.id);
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}

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

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

package/dist/commands/initiatives/list.js

@@ -0,0 +1,135 @@
+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, formatProgress } from '../../lib/formatter.js';
+const COLUMNS = [
+    {
+        key: 'id',
+        header: 'ID',
+        format: (value) => colors.dim(truncate(String(value), 12)),
+    },
+    {
+        key: 'name',
+        header: 'NAME',
+        format: (value) => colors.bold(truncate(String(value), 30)),
+    },
+    {
+        key: 'status',
+        header: 'STATUS',
+        format: (value) => {
+            const status = String(value);
+            if (status === 'Active')
+                return colors.green(status);
+            if (status === 'Completed')
+                return colors.cyan(status);
+            return colors.gray(status);
+        },
+    },
+    {
+        key: 'owner',
+        header: 'OWNER',
+        format: (_value, row) => {
+            const owner = row.owner;
+            return owner ? truncate(owner.name, 15) : colors.gray('Unassigned');
+        },
+    },
+    {
+        key: 'targetDate',
+        header: 'TARGET',
+        format: (value) => (value ? colors.dim(String(value)) : colors.gray('None')),
+    },
+    {
+        key: 'projectCount',
+        header: 'PROJECTS',
+        format: (value) => String(value),
+    },
+    {
+        key: 'progress',
+        header: 'PROGRESS',
+        format: (value) => String(value),
+    },
+];
+export default class InitiativesList extends Command {
+    static description = 'List initiatives';
+    static examples = [
+        '<%= config.bin %> initiatives list',
+        '<%= config.bin %> initiatives list --status Active',
+        '<%= config.bin %> initiatives list --format table',
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'F',
+            description: 'Output format',
+            options: ['json', 'table', 'plain'],
+            default: 'json',
+        }),
+        status: Flags.string({
+            char: 's',
+            description: 'Filter by status (Planned, Active, Completed)',
+            options: ['Planned', 'Active', 'Completed'],
+        }),
+        first: Flags.integer({
+            description: 'Number of initiatives to fetch',
+            default: 50,
+        }),
+    };
+    async run() {
+        try {
+            const { flags } = await this.parse(InitiativesList);
+            const format = flags.format;
+            const client = getClient();
+            const initiatives = await client.initiatives({
+                first: flags.first,
+            });
+            // Client-side filtering since the API doesn't support filter
+            let filtered = initiatives.nodes;
+            if (flags.status) {
+                filtered = filtered.filter((i) => i.status === flags.status);
+            }
+            const data = await Promise.all(filtered.map(async (initiative) => {
+                const owner = await initiative.owner;
+                const projects = await initiative.projects();
+                // Calculate progress from projects
+                let totalProgress = 0;
+                if (projects.nodes.length > 0) {
+                    for (const project of projects.nodes) {
+                        totalProgress += project.progress;
+                    }
+                    totalProgress = totalProgress / projects.nodes.length;
+                }
+                return {
+                    id: initiative.id,
+                    name: initiative.name,
+                    status: initiative.status,
+                    owner: owner ? { id: owner.id, name: owner.name } : null,
+                    targetDate: initiative.targetDate ?? null,
+                    projectCount: projects.nodes.length,
+                    progress: formatProgress(totalProgress),
+                    createdAt: initiative.createdAt,
+                };
+            }));
+            const pageInfo = {
+                hasNextPage: initiatives.pageInfo.hasNextPage,
+                hasPreviousPage: initiatives.pageInfo.hasPreviousPage,
+                startCursor: initiatives.pageInfo.startCursor,
+                endCursor: initiatives.pageInfo.endCursor,
+            };
+            if (format === 'json') {
+                print(successList(data, pageInfo));
+            }
+            else {
+                printList(data, format, {
+                    columns: COLUMNS,
+                    primaryKey: 'name',
+                    secondaryKey: 'id',
+                    pageInfo,
+                });
+            }
+        }
+        catch (err) {
+            handleError(err);
+            this.exit(1);
+        }
+    }
+}