@proletariat/cli 0.3.23 → 0.3.24

package/dist/commands/{agent/themes → theme}/index.js

@@ -1,11 +1,11 @@
 import { Command, Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { getWorkspaceInfo } from '../../../lib/agents/commands.js';
-import { ensureBuiltinThemes } from '../../../lib/themes.js';
-import { getThemes, getAvailableThemeNames } from '../../../lib/database/index.js';
-import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
-export default class Themes extends Command {
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ensureBuiltinThemes } from '../../lib/themes.js';
+import { getThemes, getAvailableThemeNames } from '../../lib/database/index.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Theme extends Command {
     static description = 'Manage agent naming themes';
     static examples = [
         '<%= config.bin %> <%= command.id %> list',
@@ -21,15 +21,15 @@ export default class Themes extends Command {
         }),
     };
     async run() {
-        const { flags } = await this.parse(Themes);
+        const { flags } = await this.parse(Theme);
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
         // Define choices once, use for both JSON and interactive modes
         // Each choice includes the full command for AI agents to execute
         const menuChoices = [
-            { id: 'list', name: 'List themes', command: 'prlt agent themes list --format json' },
-            { id: 'create', name: 'Create a new theme', command: 'prlt agent themes create --machine' },
-            { id: 'add-names', name: 'Add names to a theme', command: 'prlt agent themes add-names --machine' },
+            { id: 'list', name: 'List themes', command: 'prlt theme list --format json' },
+            { id: 'create', name: 'Create a new theme', command: 'prlt theme create --machine' },
+            { id: 'add-names', name: 'Add names to a theme', command: 'prlt theme add-names --machine' },
             { id: 'cancel', name: 'Cancel', command: '' },
         ];
         const message = 'What would you like to do?';
@@ -39,7 +39,7 @@ export default class Themes extends Command {
                 name: c.name,
                 value: c.id,
                 command: c.command,
-            }))), createMetadata('agent themes', flags));
+            }))), createMetadata('theme', flags));
             return;
         }
         this.log(chalk.bold('\nAgent Themes'));

package/dist/commands/{agent/themes → theme}/list.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class ThemesList extends Command {
+export default class ThemeList extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;

package/dist/commands/{agent/themes → theme}/list.js

@@ -1,9 +1,9 @@
 import { Command } from '@oclif/core';
 import chalk from 'chalk';
-import { getWorkspaceInfo } from '../../../lib/agents/commands.js';
-import { ensureBuiltinThemes } from '../../../lib/themes.js';
-import { getThemes, getThemeNames, getAvailableThemeNames } from '../../../lib/database/index.js';
-export default class ThemesList extends Command {
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ensureBuiltinThemes } from '../../lib/themes.js';
+import { getThemes, getThemeNames, getAvailableThemeNames } from '../../lib/database/index.js';
+export default class ThemeList extends Command {
     static description = 'List available agent themes';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
@@ -32,7 +32,7 @@ export default class ThemesList extends Command {
                 this.log(chalk.gray(`    Names: ${chalk.green(availableNames.length + ' available')}, ${chalk.yellow(inUse + ' in use')}`));
                 this.log('');
             }
-            this.log(chalk.blue('Use: prlt agent add --theme <theme-id>'));
+            this.log(chalk.blue('Use: prlt staff add --theme <theme-id>'));
         }
         catch (error) {
             this.error(error instanceof Error ? error.message : String(error));

package/dist/commands/{agent/themes → theme}/set.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class ThemesSet extends Command {
+export default class ThemeSet extends Command {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{agent/themes → theme}/set.js

@@ -1,11 +1,11 @@
 import { Command, Args, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import { getWorkspaceInfo } from '../../../lib/agents/commands.js';
-import { ensureBuiltinThemes } from '../../../lib/themes.js';
-import { getThemes, getAvailableThemeNames, setActiveTheme, getActiveTheme } from '../../../lib/database/index.js';
-import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
-export default class ThemesSet extends Command {
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ensureBuiltinThemes } from '../../lib/themes.js';
+import { getThemes, getAvailableThemeNames, setActiveTheme, getActiveTheme } from '../../lib/database/index.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class ThemeSet extends Command {
     static description = 'Set the active theme for this workspace';
     static examples = [
         '<%= config.bin %> <%= command.id %> billionaires',
@@ -26,7 +26,7 @@ export default class ThemesSet extends Command {
         }),
     };
     async run() {
-        const { args, flags } = await this.parse(ThemesSet);
+        const { args, flags } = await this.parse(ThemeSet);
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
         try {
@@ -47,7 +47,7 @@ export default class ThemesSet extends Command {
                             value: t.id
                         };
                     });
-                    outputPromptAsJson(buildPromptConfig('list', 'theme', 'Select theme for this workspace:', themeChoices), createMetadata('agent themes set', flags));
+                    outputPromptAsJson(buildPromptConfig('list', 'theme', 'Select theme for this workspace:', themeChoices), createMetadata('theme set', flags));
                     return;
                 }
                 const choices = themes.map(t => {

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

@@ -14,6 +14,7 @@ export default class TicketCreate extends PMOCommand {
         epic: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         template: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         labels: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     execute(): Promise<void>;

package/dist/commands/ticket/create.js

@@ -4,7 +4,7 @@ import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index
 import { styles } from '../../lib/styles.js';
 import { updateEpicTicketsSection } from '../../lib/pmo/epic-files.js';
 import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
-import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, outputDryRunSuccessAsJson, outputDryRunErrorsAsJson, createMetadata, } from '../../lib/prompt-json.js';
 import { FlagResolver } from '../../lib/flags/index.js';
 export default class TicketCreate extends PMOCommand {
     static description = 'Create a new ticket on the PMO board';
@@ -15,6 +15,7 @@ export default class TicketCreate extends PMOCommand {
         '<%= config.bin %> <%= command.id %> --project mobile-app -t "New feature"',
         '<%= config.bin %> <%= command.id %> --epic EPIC-001 -t "Implement auth flow"',
         '<%= config.bin %> <%= command.id %> --json  # Output column choices as JSON',
+        '<%= config.bin %> <%= command.id %> --title "Test" -P PROJ-001 --dry-run --json  # Validate without creating',
     ];
     static flags = {
         ...pmoBaseFlags,
@@ -26,7 +27,7 @@ export default class TicketCreate extends PMOCommand {
         }),
         title: Flags.string({
             char: 't',
-            description: 'Ticket title',
+            description: 'Ticket title [required for non-interactive]',
         }),
         column: Flags.string({
             char: 'c',
@@ -64,6 +65,10 @@ export default class TicketCreate extends PMOCommand {
             char: 'l',
             description: 'Labels (comma-separated)',
         }),
+        'dry-run': Flags.boolean({
+            description: 'Validate inputs without creating ticket (use with --json for structured output)',
+            default: false,
+        }),
     };
     async execute() {
         const { flags } = await this.parse(TicketCreate);
@@ -171,8 +176,55 @@ export default class TicketCreate extends PMOCommand {
         }
         // Validate status/column
         if (!columns.includes(ticketData.statusName)) {
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputDryRunErrorsAsJson([{ field: 'column', error: `Invalid column "${ticketData.statusName}". Available: ${columns.join(', ')}` }], createMetadata('ticket create', flags));
+                }
+                this.error(`Invalid column "${ticketData.statusName}". Available columns: ${columns.join(', ')}`);
+            }
             this.error(`Invalid column "${ticketData.statusName}". Available columns: ${columns.join(', ')}`);
         }
+        // Handle dry-run: show what would be created without actually creating
+        if (flags['dry-run']) {
+            const wouldCreate = {
+                title: ticketData.title,
+                project: projectId,
+                column: ticketData.statusName,
+                ...(ticketData.priority && { priority: ticketData.priority }),
+                ...(ticketData.category && { category: ticketData.category }),
+                ...(ticketData.description && { description: ticketData.description }),
+                ...(ticketData.epicId && { epic: ticketData.epicId }),
+                ...(ticketData.labels && ticketData.labels.length > 0 && { labels: ticketData.labels }),
+            };
+            if (jsonMode) {
+                outputDryRunSuccessAsJson('ticket', wouldCreate, createMetadata('ticket create', flags));
+            }
+            // Human-readable dry-run output
+            this.log(styles.warning('\n[DRY RUN] Would create ticket:'));
+            this.log(styles.muted(`   Title: ${ticketData.title}`));
+            this.log(styles.muted(`   Project: ${projectName}`));
+            this.log(styles.muted(`   Column: ${ticketData.statusName}`));
+            if (ticketData.priority) {
+                this.log(styles.muted(`   Priority: ${ticketData.priority}`));
+            }
+            if (ticketData.category) {
+                this.log(styles.muted(`   Category: ${ticketData.category}`));
+            }
+            if (ticketData.epicId) {
+                this.log(styles.muted(`   Epic: ${ticketData.epicId}`));
+            }
+            if (ticketData.labels && ticketData.labels.length > 0) {
+                this.log(styles.muted(`   Labels: ${ticketData.labels.join(', ')}`));
+            }
+            if (template) {
+                this.log(styles.muted(`   Template: ${template.name}`));
+                if (template.suggestedSubtasks.length > 0) {
+                    this.log(styles.muted(`   Subtasks: ${template.suggestedSubtasks.length} would be created`));
+                }
+            }
+            this.log(styles.muted('\n(No ticket was created)'));
+            return;
+        }
         const ticket = await this.storage.createTicket(projectId, {
             id: ticketData.id,
             title: ticketData.title,

package/dist/commands/ticket/index.js

@@ -27,7 +27,7 @@ export default class Ticket extends PMOCommand {
         // Each choice includes the full command for AI agents to execute
         const menuChoices = [
             { name: 'Create new ticket', value: 'create', command: 'prlt ticket create --json' },
-            { name: 'Create from template', value: 'template', command: 'prlt ticket template apply --json' },
+            { name: 'Create from template', value: 'template', command: 'prlt template apply --type ticket --json' },
             { name: 'List all tickets', value: 'list', command: 'prlt ticket list --format json' },
             { name: 'View ticket details', value: 'view', command: 'prlt ticket view --json' },
             { name: 'Edit ticket', value: 'edit', command: 'prlt ticket edit --json' },
@@ -35,8 +35,8 @@ export default class Ticket extends PMOCommand {
             { name: 'Move to different project', value: 'project', command: 'prlt ticket project --json' },
             { name: 'Assign to epic', value: 'epic', command: 'prlt ticket epic --json' },
             { name: 'Assign to spec', value: 'spec', command: 'prlt ticket spec --json' },
-            { name: 'Manage dependencies', value: 'link', command: 'prlt ticket link --json' },
-            { name: 'Manage templates', value: 'templates', command: 'prlt ticket template --json' },
+            { name: 'Manage dependencies', value: 'link', command: 'prlt link list --json' },
+            { name: 'Manage templates', value: 'templates', command: 'prlt template --json' },
             { name: 'Delete ticket', value: 'delete', command: 'prlt ticket delete --json' },
             { name: 'Cancel', value: 'cancel' },
         ];
@@ -68,7 +68,7 @@ export default class Ticket extends PMOCommand {
                 await this.config.runCommand('ticket:create', []);
                 break;
             case 'template':
-                await this.config.runCommand('ticket:template:apply', []);
+                await this.config.runCommand('template:apply', ['--type', 'ticket']);
                 break;
             case 'list':
                 await this.config.runCommand('ticket:list', []);
@@ -92,10 +92,10 @@ export default class Ticket extends PMOCommand {
                 await this.config.runCommand('ticket:spec', []);
                 break;
             case 'link':
-                await this.config.runCommand('ticket:link', []);
+                await this.config.runCommand('link', []);
                 break;
             case 'templates':
-                await this.config.runCommand('ticket:template', []);
+                await this.config.runCommand('template', []);
                 break;
             case 'delete':
                 await this.config.runCommand('ticket:delete', []);

package/dist/commands/work/spawn.js

@@ -39,7 +39,7 @@ export default class WorkSpawn extends PMOCommand {
         }),
         column: Flags.string({
             char: 'c',
-            description: 'Column name to spawn tickets from (used with --all)',
+            description: 'Column name to spawn tickets from [required for non-interactive with --all]',
         }),
         strategy: Flags.string({
             char: 's',

package/dist/lib/mcp/helpers.d.ts

@@ -0,0 +1,43 @@
+/**
+ * MCP Helper Functions
+ */
+import type { Ticket } from '../pmo/types.js';
+import type { McpToolResult } from './types.js';
+export declare function formatTicket(t: Ticket): {
+    id: string;
+    title: string;
+    priority: string | undefined;
+    category: string | undefined;
+    statusName: string | undefined;
+    statusCategory: import("../pmo/types.js").StateCategory | undefined;
+    projectId: string | undefined;
+    assignee: string | undefined;
+    owner: string | undefined;
+    branch: string | undefined;
+    epicId: string | undefined;
+};
+export declare function formatTicketFull(t: Ticket): {
+    description: string | undefined;
+    subtasks: import("../pmo/types.js").Subtask[];
+    labels: string[];
+    metadata: Record<string, string>;
+    blockedBy: string[] | undefined;
+    acceptanceCriteria: import("../pmo/types.js").AcceptanceCriterion[] | undefined;
+    specId: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+    id: string;
+    title: string;
+    priority: string | undefined;
+    category: string | undefined;
+    statusName: string | undefined;
+    statusCategory: import("../pmo/types.js").StateCategory | undefined;
+    projectId: string | undefined;
+    assignee: string | undefined;
+    owner: string | undefined;
+    branch: string | undefined;
+    epicId: string | undefined;
+};
+export declare function successResponse(data: Record<string, unknown>): McpToolResult;
+export declare function errorResponse(error: unknown): McpToolResult;
+export declare function textResponse(text: string): McpToolResult;

package/dist/lib/mcp/helpers.js

@@ -0,0 +1,57 @@
+/**
+ * MCP Helper Functions
+ */
+export function formatTicket(t) {
+    return {
+        id: t.id,
+        title: t.title,
+        priority: t.priority,
+        category: t.category,
+        statusName: t.statusName,
+        statusCategory: t.statusCategory,
+        projectId: t.projectId,
+        assignee: t.assignee,
+        owner: t.owner,
+        branch: t.branch,
+        epicId: t.epicId,
+    };
+}
+export function formatTicketFull(t) {
+    return {
+        ...formatTicket(t),
+        description: t.description,
+        subtasks: t.subtasks,
+        labels: t.labels,
+        metadata: t.metadata,
+        blockedBy: t.blockedBy,
+        acceptanceCriteria: t.acceptanceCriteria,
+        specId: t.specId,
+        createdAt: t.createdAt.toISOString(),
+        updatedAt: t.updatedAt.toISOString(),
+    };
+}
+export function successResponse(data) {
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({ success: true, ...data }, null, 2),
+            }],
+    };
+}
+export function errorResponse(error) {
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                }),
+            }],
+        isError: true,
+    };
+}
+export function textResponse(text) {
+    return {
+        content: [{ type: 'text', text }],
+    };
+}

package/dist/lib/mcp/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Library - Main exports
+ */
+export * from './types.js';
+export * from './helpers.js';
+export * from './tools/index.js';

package/dist/lib/mcp/index.js

@@ -0,0 +1,6 @@
+/**
+ * MCP Library - Main exports
+ */
+export * from './types.js';
+export * from './helpers.js';
+export * from './tools/index.js';

package/dist/lib/mcp/tools/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Action Tools
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerActionTools(server: McpServer, ctx: McpToolContext): void;

package/dist/lib/mcp/tools/action.js

@@ -0,0 +1,88 @@
+/**
+ * MCP Action Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerActionTools(server, ctx) {
+    server.tool('action_list', 'List work actions', { include_builtin: z.boolean().optional() }, async (params) => {
+        try {
+            const actions = await ctx.storage.listActions({
+                isBuiltin: params.include_builtin ? undefined : false,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            actions: actions.map((a) => ({
+                                id: a.id,
+                                name: a.name,
+                                description: a.description,
+                                modifiesCode: a.modifiesCode,
+                                isBuiltin: a.isBuiltin,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('action_show', 'Get action details', { id: z.string().describe('Action ID') }, async (params) => {
+        try {
+            const action = await ctx.storage.getAction(params.id);
+            if (!action)
+                throw new Error(`Action not found: ${params.id}`);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, action }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('action_create', 'Create a work action', {
+        name: z.string().describe('Action name'),
+        prompt: z.string().describe('Start prompt'),
+        description: z.string().optional(),
+        end_prompt: z.string().optional(),
+        modifies_code: z.boolean().optional(),
+    }, async (params) => {
+        try {
+            const action = await ctx.storage.createAction({
+                name: params.name,
+                prompt: params.prompt,
+                description: params.description,
+                endPrompt: params.end_prompt,
+                modifiesCode: params.modifies_code ?? true,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, action: { id: action.id, name: action.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('action_delete', 'Delete an action', { id: z.string().describe('Action ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteAction(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Action deleted' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

package/dist/lib/mcp/tools/board.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Board Tools
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerBoardTools(server: McpServer, ctx: McpToolContext): void;

package/dist/lib/mcp/tools/board.js

@@ -0,0 +1,139 @@
+/**
+ * MCP Board Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerBoardTools(server, ctx) {
+    server.tool('board_show', 'Show the kanban board', { project: z.string().optional().describe('Project ID') }, async (params) => {
+        try {
+            let projectId = params.project;
+            if (!projectId) {
+                const projects = await ctx.storage.listProjects();
+                if (projects.length === 0)
+                    throw new Error('No projects found');
+                projectId = projects[0].id;
+            }
+            const board = await ctx.storage.getBoard(projectId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            board: {
+                                id: board.id,
+                                name: board.name,
+                                columns: board.columns.map((col) => ({
+                                    name: col.name,
+                                    position: col.position,
+                                    ticketCount: col.tickets.length,
+                                    tickets: col.tickets.map((t) => ({
+                                        id: t.id,
+                                        title: t.title,
+                                        priority: t.priority,
+                                        assignee: t.assignee,
+                                    })),
+                                })),
+                                updatedAt: board.updatedAt.toISOString(),
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_columns', 'Get column names for a project', { project: z.string().optional().describe('Project ID') }, async (params) => {
+        try {
+            let projectId = params.project;
+            if (!projectId) {
+                const projects = await ctx.storage.listProjects();
+                if (projects.length === 0)
+                    throw new Error('No projects found');
+                projectId = projects[0].id;
+            }
+            const columns = ctx.storage.getColumnNames(projectId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, projectId, columns }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_create_column', 'Add a new column to the board', {
+        project: z.string().describe('Project ID'),
+        name: z.string().describe('Column name'),
+        position: z.number().optional().describe('Position'),
+    }, async (params) => {
+        try {
+            const column = await ctx.storage.createColumn(params.project, params.name, params.position);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, column: { id: column.id, name: column.name, position: column.position } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_rename_column', 'Rename a column', {
+        project: z.string().describe('Project ID'),
+        column_id: z.string().describe('Column ID'),
+        name: z.string().describe('New name'),
+    }, async (params) => {
+        try {
+            const column = await ctx.storage.renameColumn(params.project, params.column_id, params.name);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, column: { id: column.id, name: column.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_move_column', 'Reorder a column', {
+        project: z.string().describe('Project ID'),
+        column_id: z.string().describe('Column ID'),
+        position: z.number().describe('New position'),
+    }, async (params) => {
+        try {
+            const column = await ctx.storage.moveColumn(params.project, params.column_id, params.position);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, column: { id: column.id, name: column.name, position: column.position } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_delete_column', 'Delete a column', {
+        project: z.string().describe('Project ID'),
+        column_id: z.string().describe('Column ID'),
+        cascade: z.boolean().optional().describe('Delete tickets in column'),
+    }, async (params) => {
+        try {
+            await ctx.storage.deleteColumn(params.project, params.column_id, params.cascade);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Column deleted' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

package/dist/lib/mcp/tools/category.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Category Tools
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerCategoryTools(server: McpServer, ctx: McpToolContext): void;