@agent-spaces/server 0.3.63 → 0.3.65

package/dist/services/builtin-tools/issue-tools.js

@@ -0,0 +1,209 @@
+import { BUILT_IN_AGENT_TOOLS } from '@agent-spaces/shared';
+import * as issueService from '../issue.js';
+import * as issueCommentService from '../issue-comment.js';
+import * as channelService from '../channel.js';
+import * as taskService from '../task.js';
+import * as agentService from '../agent.js';
+const issueStatuses = [
+    'draft',
+    'planned',
+    'in_progress',
+    'review_pending',
+    'changes_requested',
+    'approved',
+    'completed',
+    'archived',
+    'error',
+];
+const currentChannelInputSchema = {
+    type: 'object',
+    properties: {
+        channelId: {
+            type: 'string',
+            description: 'Must match the current channel id.',
+        },
+    },
+    required: ['channelId'],
+    additionalProperties: false,
+};
+const createIssueInputSchema = {
+    type: 'object',
+    properties: {
+        channelId: {
+            type: 'string',
+            description: 'Must match the current channel id.',
+        },
+        title: {
+            type: 'string',
+            description: 'Issue title to create for the current channel.',
+        },
+        description: {
+            type: 'string',
+            description: 'Issue description to create for the current channel.',
+        },
+        status: {
+            type: 'string',
+            enum: issueStatuses,
+            description: 'Issue status to create. Use completed when creating a finished issue report. Defaults to draft.',
+        },
+    },
+    required: ['channelId', 'title'],
+    additionalProperties: false,
+};
+const addCommentInputSchema = {
+    type: 'object',
+    properties: {
+        channelId: {
+            type: 'string',
+            description: 'Must match the current channel id.',
+        },
+        content: {
+            type: 'string',
+            description: 'Comment content to add to the issue bound to the current channel.',
+        },
+    },
+    required: ['channelId', 'content'],
+    additionalProperties: false,
+};
+export function createIssueFunctionTools(workspaceId, channel, actor, allowedTools) {
+    if (!channel)
+        return [];
+    const allowedToolNames = new Set(allowedTools ?? BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
+    const tools = [
+        {
+            name: 'CreateCurrentChannelIssue',
+            description: 'Create an issue for the current channel and bind it to this channel. The channelId must be the current channel id.',
+            inputSchema: createIssueInputSchema,
+            annotations: { destructive: false, openWorld: false },
+            execute: async (input) => createCurrentChannelIssue(workspaceId, channel, input),
+        },
+    ];
+    tools.push({
+        name: 'ViewCurrentChannelIssue',
+        description: 'View the issue and comments bound to the current channel. The channelId must be the current channel id.',
+        inputSchema: currentChannelInputSchema,
+        annotations: { readOnly: true, openWorld: false },
+        execute: async (input) => viewCurrentChannelIssue(workspaceId, channel, input),
+    }, {
+        name: 'AddCurrentChannelComment',
+        description: 'Add a comment to the issue bound to the current channel. The channelId must be the current channel id.',
+        inputSchema: addCommentInputSchema,
+        annotations: { destructive: false, openWorld: false },
+        execute: async (input) => addCurrentChannelComment(workspaceId, channel, actor, input),
+    });
+    return tools.filter((tool) => allowedToolNames.has(tool.name));
+}
+export function isBuiltInIssueToolName(name) {
+    return name === 'CreateCurrentChannelIssue'
+        || name === 'ViewCurrentChannelIssue'
+        || name === 'AddCurrentChannelComment'
+        || name === 'agent-spaces.CreateCurrentChannelIssue'
+        || name === 'agent-spaces.ViewCurrentChannelIssue'
+        || name === 'agent-spaces.AddCurrentChannelComment';
+}
+function createCurrentChannelIssue(workspaceId, channel, input) {
+    const data = assertCurrentChannelId(channel, input);
+    const currentChannel = getCurrentChannel(workspaceId, channel);
+    if (currentChannel.issueId)
+        throw new Error(`Current channel already has a bound issue: ${currentChannel.issueId}`);
+    const title = typeof data.title === 'string' ? data.title.trim() : '';
+    const description = typeof data.description === 'string' ? data.description.trim() : '';
+    const status = parseIssueStatus(data.status);
+    if (!title)
+        throw new Error('title is required.');
+    const issue = issueService.createForChannel(workspaceId, currentChannel.id, { title, description, status });
+    if (!issue)
+        throw new Error(`Current channel not found: ${currentChannel.id}`);
+    channel.issueId = issue.id;
+    channel.type = 'issue';
+    channel.name = title;
+    return issue;
+}
+function parseIssueStatus(status) {
+    if (status === undefined)
+        return undefined;
+    if (typeof status !== 'string' || !issueStatuses.includes(status)) {
+        throw new Error(`status must be one of: ${issueStatuses.join(', ')}.`);
+    }
+    return status;
+}
+function viewCurrentChannelIssue(workspaceId, channel, input) {
+    assertCurrentChannelId(channel, input);
+    const issue = getBoundIssue(workspaceId, channel);
+    const currentChannel = getCurrentChannel(workspaceId, channel);
+    const assignableAgents = getAssignableAgents(workspaceId, currentChannel);
+    return {
+        issue,
+        comments: issueCommentService.listIssueComments(workspaceId, issue.id),
+        tasks: taskService.list(workspaceId, issue.id),
+        channel: {
+            id: currentChannel.id,
+            name: currentChannel.name,
+            type: currentChannel.type,
+            issueId: currentChannel.issueId,
+            members: currentChannel.members,
+            pinnedMentionId: currentChannel.pinnedMentionId,
+            todos: currentChannel.todos,
+        },
+        assignableAgents,
+        validAgentConfigIds: assignableAgents.map((agent) => agent.id),
+    };
+}
+function addCurrentChannelComment(workspaceId, channel, actor, input) {
+    const data = assertCurrentChannelId(channel, input);
+    const issue = getBoundIssue(workspaceId, channel);
+    const content = typeof data.content === 'string' ? data.content.trim() : '';
+    if (!content)
+        throw new Error('content is required.');
+    const comment = issueCommentService.createIssueComment(workspaceId, issue.id, {
+        senderId: actor.senderId,
+        senderRole: actor.senderRole,
+        content,
+        source: actor.senderId === 'user' ? 'user' : 'agent_progress',
+        metadata: {
+            channelId: channel.id,
+        },
+    });
+    if (!comment)
+        throw new Error(`Bound issue not found: ${issue.id}`);
+    return comment;
+}
+function getBoundIssue(workspaceId, channel) {
+    const currentChannel = getCurrentChannel(workspaceId, channel);
+    if (!currentChannel.issueId)
+        throw new Error('Current channel is not bound to an issue.');
+    const issue = issueService.getById(workspaceId, currentChannel.issueId);
+    if (!issue)
+        throw new Error(`Bound issue not found: ${currentChannel.issueId}`);
+    return issue;
+}
+function getCurrentChannel(workspaceId, channel) {
+    const currentChannel = channelService.getChannel(workspaceId, channel.id);
+    if (!currentChannel)
+        throw new Error(`Current channel not found: ${channel.id}`);
+    return currentChannel;
+}
+function getAssignableAgents(workspaceId, channel) {
+    const members = new Set(channel.members);
+    return (agentService.listPresets(workspaceId) ?? [])
+        .filter((agent) => members.has(agent.id) && agent.enabled !== false)
+        .map((agent) => ({
+        id: agent.id,
+        name: agent.name,
+        role: agent.role,
+        description: agent.description,
+        enabled: agent.enabled,
+        sandboxDirs: agent.sandboxDirs,
+    }));
+}
+function assertCurrentChannelId(channel, input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('Tool input must be an object.');
+    }
+    const data = input;
+    if (data.channelId !== channel.id) {
+        throw new Error(`channelId must match the current channel id: ${channel.id}`);
+    }
+    return data;
+}
+//# sourceMappingURL=issue-tools.js.map

package/dist/services/builtin-tools/kanban-tools.js

@@ -0,0 +1,281 @@
+import { BUILT_IN_AGENT_TOOLS } from '@agent-spaces/shared';
+import * as kanbanStore from '../../storage/kanban-store.js';
+import { broadcastToWorkspace } from '../../ws/connection-manager.js';
+import { assertRecord, readOptionalString, readRequiredString, readString } from './input-helpers.js';
+const kanbanLayoutModes = ['horizontal', 'vertical'];
+const kanbanPriorities = ['low', 'medium', 'high'];
+const listKanbanBoardsInputSchema = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+};
+const viewKanbanBoardInputSchema = {
+    type: 'object',
+    properties: {
+        boardId: {
+            type: 'string',
+            description: 'Optional Kanban board ID. Omit to view the current workspace board.',
+        },
+    },
+    additionalProperties: false,
+};
+const createKanbanBoardInputSchema = {
+    type: 'object',
+    properties: {
+        title: {
+            type: 'string',
+            description: 'Board title. Defaults to Kanban Board.',
+        },
+        layoutMode: {
+            type: 'string',
+            enum: kanbanLayoutModes,
+            description: 'Board layout mode. Defaults to horizontal.',
+        },
+        columns: {
+            type: 'array',
+            description: 'Optional complete column list. Defaults to To Do, In Progress, Done, Archive.',
+            items: { type: 'object' },
+        },
+        tasks: {
+            type: 'array',
+            description: 'Optional complete task list. Defaults to empty.',
+            items: { type: 'object' },
+        },
+    },
+    additionalProperties: false,
+};
+const updateKanbanBoardInputSchema = {
+    type: 'object',
+    properties: {
+        boardId: {
+            type: 'string',
+            description: 'Optional Kanban board ID. Omit to update the current workspace board.',
+        },
+        title: {
+            type: 'string',
+            description: 'New board title.',
+        },
+        layoutMode: {
+            type: 'string',
+            enum: kanbanLayoutModes,
+            description: 'New board layout mode.',
+        },
+        columns: {
+            type: 'array',
+            description: 'Complete replacement column list. Existing columns are replaced.',
+            items: { type: 'object' },
+        },
+        tasks: {
+            type: 'array',
+            description: 'Complete replacement task list. Existing tasks are replaced.',
+            items: { type: 'object' },
+        },
+    },
+    additionalProperties: false,
+};
+const deleteKanbanBoardInputSchema = {
+    type: 'object',
+    properties: {
+        boardId: {
+            type: 'string',
+            description: 'Optional Kanban board ID. Omit to delete the current workspace board.',
+        },
+    },
+    additionalProperties: false,
+};
+export function createKanbanFunctionTools(workspaceId, allowedTools) {
+    const allowedToolNames = getAllowedKanbanToolNames(allowedTools);
+    const tools = [
+        {
+            name: 'ListKanbanBoards',
+            description: 'List Kanban boards in the current workspace. Agent Spaces currently uses one board per workspace.',
+            inputSchema: listKanbanBoardsInputSchema,
+            annotations: { readOnly: true, openWorld: false },
+            execute: async () => listKanbanBoards(workspaceId),
+        },
+        {
+            name: 'ViewKanbanBoard',
+            description: 'View the current workspace Kanban board, including board metadata, columns, and tasks.',
+            inputSchema: viewKanbanBoardInputSchema,
+            annotations: { readOnly: true, openWorld: false },
+            execute: async (input) => viewKanbanBoard(workspaceId, input),
+        },
+        {
+            name: 'CreateKanbanBoard',
+            description: 'Create the current workspace Kanban board. Use this only when ListKanbanBoards returns no board.',
+            inputSchema: createKanbanBoardInputSchema,
+            annotations: { destructive: false, openWorld: false },
+            execute: async (input) => createKanbanBoard(workspaceId, input),
+        },
+        {
+            name: 'UpdateKanbanBoard',
+            description: 'Update the current workspace Kanban board metadata and optionally replace its complete columns or tasks arrays.',
+            inputSchema: updateKanbanBoardInputSchema,
+            annotations: { destructive: false, openWorld: false },
+            execute: async (input) => updateKanbanBoard(workspaceId, input),
+        },
+        {
+            name: 'DeleteKanbanBoard',
+            description: 'Delete the current workspace Kanban board, including all columns and tasks.',
+            inputSchema: deleteKanbanBoardInputSchema,
+            annotations: { destructive: true, openWorld: false },
+            execute: async (input) => deleteKanbanBoard(workspaceId, input),
+        },
+    ];
+    return tools.filter((tool) => allowedToolNames.has(tool.name));
+}
+function getAllowedKanbanToolNames(allowedTools) {
+    const names = new Set(allowedTools ?? BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
+    const hasKanbanTools = Array.from(names).some((name) => isKanbanToolName(name));
+    if (hasKanbanTools) {
+        names.add('ListKanbanBoards');
+        names.add('ViewKanbanBoard');
+        names.add('CreateKanbanBoard');
+    }
+    return names;
+}
+function listKanbanBoards(workspaceId) {
+    return kanbanStore.listBoards(workspaceId);
+}
+function viewKanbanBoard(workspaceId, input) {
+    const data = assertRecord(input);
+    const board = resolveKanbanBoard(workspaceId, readOptionalString(data.boardId));
+    return board;
+}
+function createKanbanBoard(workspaceId, input) {
+    const data = assertRecord(input);
+    const existing = kanbanStore.getBoard(workspaceId);
+    if (existing)
+        throw new Error(`Kanban board already exists for this workspace: ${existing.id}. Use UpdateKanbanBoard instead.`);
+    const title = readOptionalString(data.title) ?? 'Kanban Board';
+    const layoutMode = parseLayoutMode(data.layoutMode);
+    const board = kanbanStore.createBoard(workspaceId, title);
+    if (layoutMode !== 'horizontal')
+        kanbanStore.updateBoard(workspaceId, { layoutMode }, board.id);
+    const columns = Object.hasOwn(data, 'columns') ? parseColumns(data.columns) : createDefaultColumns();
+    kanbanStore.saveColumns(board.id, columns);
+    if (Object.hasOwn(data, 'tasks'))
+        kanbanStore.saveTasks(board.id, parseTasks(data.tasks, columns));
+    const created = kanbanStore.getBoard(workspaceId);
+    if (!created)
+        throw new Error('Failed to create Kanban board.');
+    broadcastToWorkspace(workspaceId, 'kanban.updated', created);
+    return created;
+}
+function updateKanbanBoard(workspaceId, input) {
+    const data = assertRecord(input);
+    const board = resolveKanbanBoard(workspaceId, readOptionalString(data.boardId));
+    const updates = {};
+    if (Object.hasOwn(data, 'title'))
+        updates.title = readRequiredString(data.title, 'title');
+    if (Object.hasOwn(data, 'layoutMode'))
+        updates.layoutMode = parseLayoutMode(data.layoutMode);
+    if (!updates.title && !updates.layoutMode && !Object.hasOwn(data, 'columns') && !Object.hasOwn(data, 'tasks')) {
+        throw new Error('At least one field is required: title, layoutMode, columns, or tasks.');
+    }
+    const nextColumns = Object.hasOwn(data, 'columns') ? parseColumns(data.columns) : board.columns;
+    const nextTasks = Object.hasOwn(data, 'tasks') ? parseTasks(data.tasks, nextColumns) : parseTasks(board.tasks, nextColumns);
+    if (updates.title || updates.layoutMode) {
+        const updated = kanbanStore.updateBoard(workspaceId, updates, board.id);
+        if (!updated)
+            throw new Error(`Kanban board not found: ${board.id}`);
+    }
+    if (Object.hasOwn(data, 'columns'))
+        kanbanStore.saveColumns(board.id, nextColumns);
+    if (Object.hasOwn(data, 'tasks'))
+        kanbanStore.saveTasks(board.id, nextTasks);
+    const updated = kanbanStore.listBoards(workspaceId).find((item) => item.id === board.id);
+    if (!updated)
+        throw new Error(`Kanban board not found: ${board.id}`);
+    broadcastToWorkspace(workspaceId, 'kanban.updated', updated);
+    return updated;
+}
+function deleteKanbanBoard(workspaceId, input) {
+    const data = assertRecord(input);
+    const board = resolveKanbanBoard(workspaceId, readOptionalString(data.boardId));
+    const ok = kanbanStore.deleteBoard(workspaceId, board.id);
+    if (!ok)
+        throw new Error(`Kanban board not found: ${board.id}`);
+    broadcastToWorkspace(workspaceId, 'kanban.deleted', { boardId: board.id });
+    return { ok: true, deletedBoardId: board.id };
+}
+function resolveKanbanBoard(workspaceId, boardId) {
+    const boards = kanbanStore.listBoards(workspaceId);
+    const board = boardId ? boards.find((item) => item.id === boardId) : boards[0];
+    if (!board)
+        throw new Error('Kanban board not found. Use CreateKanbanBoard to create one.');
+    return board;
+}
+function createDefaultColumns() {
+    return [
+        { id: 'todo', title: 'To Do', color: 'sky', order: 0 },
+        { id: 'progress', title: 'In Progress', color: 'amber', order: 1 },
+        { id: 'done', title: 'Done', color: 'emerald', order: 2 },
+        { id: 'archive', title: 'Archive', color: 'slate', order: 3 },
+    ];
+}
+function parseColumns(value) {
+    if (!Array.isArray(value))
+        throw new Error('columns must be an array.');
+    return value.map((item, index) => {
+        const data = assertRecord(item);
+        return {
+            id: readRequiredString(data.id, `columns[${index}].id`),
+            title: readRequiredString(data.title, `columns[${index}].title`),
+            color: readOptionalString(data.color) ?? 'sky',
+            order: readInteger(data.order, `columns[${index}].order`, index),
+        };
+    });
+}
+function parseTasks(value, columns) {
+    if (!Array.isArray(value))
+        throw new Error('tasks must be an array.');
+    const columnIds = new Set(columns.map((column) => column.id));
+    return value.map((item, index) => {
+        const data = assertRecord(item);
+        const columnId = readRequiredString(data.columnId, `tasks[${index}].columnId`);
+        if (!columnIds.has(columnId))
+            throw new Error(`tasks[${index}].columnId does not match any column: ${columnId}`);
+        return {
+            id: readRequiredString(data.id, `tasks[${index}].id`),
+            title: readRequiredString(data.title, `tasks[${index}].title`),
+            description: readString(data.description ?? '', `tasks[${index}].description`),
+            priority: parsePriority(data.priority, `tasks[${index}].priority`),
+            columnId,
+            order: readInteger(data.order, `tasks[${index}].order`, index),
+            createdAt: readInteger(data.createdAt, `tasks[${index}].createdAt`, Date.now()),
+            dueDate: readOptionalString(data.dueDate),
+        };
+    });
+}
+function parseLayoutMode(value) {
+    if (value === undefined)
+        return 'horizontal';
+    if (typeof value !== 'string' || !kanbanLayoutModes.includes(value)) {
+        throw new Error(`layoutMode must be one of: ${kanbanLayoutModes.join(', ')}.`);
+    }
+    return value;
+}
+function parsePriority(value, field) {
+    if (value === undefined)
+        return 'medium';
+    if (typeof value !== 'string' || !kanbanPriorities.includes(value)) {
+        throw new Error(`${field} must be one of: ${kanbanPriorities.join(', ')}.`);
+    }
+    return value;
+}
+function readInteger(value, field, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'number' || !Number.isInteger(value))
+        throw new Error(`${field} must be an integer.`);
+    return value;
+}
+function isKanbanToolName(name) {
+    return name === 'ListKanbanBoards'
+        || name === 'ViewKanbanBoard'
+        || name === 'CreateKanbanBoard'
+        || name === 'UpdateKanbanBoard'
+        || name === 'DeleteKanbanBoard';
+}
+//# sourceMappingURL=kanban-tools.js.map