@agent-spaces/server 0.1.0

package/dist/services/message.js

@@ -0,0 +1,70 @@
+import { v4 as uuid } from 'uuid';
+import { join } from 'node:path';
+import { readJsonFile, writeJsonFile, getDataDir } from '../storage/json-store.js';
+function messageFilePath(workspaceId, channelId) {
+    return join(getDataDir(), 'workspaces', workspaceId, 'channels', channelId, 'messages.json');
+}
+export function listMessages(workspaceId, channelId, opts = {}) {
+    const all = readJsonFile(messageFilePath(workspaceId, channelId)) || [];
+    const limit = opts.limit || 50;
+    if (opts.before) {
+        const idx = all.findIndex((m) => m.id === opts.before);
+        if (idx <= 0)
+            return [];
+        return all.slice(Math.max(0, idx - limit), idx);
+    }
+    return all.slice(-limit);
+}
+export function createMessage(workspaceId, channelId, data) {
+    const path = messageFilePath(workspaceId, channelId);
+    const messages = readJsonFile(path) || [];
+    const message = {
+        id: uuid(),
+        channelId,
+        senderId: data.senderId,
+        senderRole: data.senderRole,
+        content: data.content,
+        type: data.type || 'text',
+        status: data.status,
+        attachments: data.attachments,
+        parts: data.parts,
+        metadata: data.metadata,
+        createdAt: new Date().toISOString(),
+    };
+    messages.push(message);
+    writeJsonFile(path, messages);
+    return message;
+}
+export function updateMessage(workspaceId, channelId, messageId, data) {
+    const path = messageFilePath(workspaceId, channelId);
+    const messages = readJsonFile(path) || [];
+    const index = messages.findIndex((message) => message.id === messageId);
+    if (index === -1)
+        return null;
+    const updated = {
+        ...messages[index],
+        ...data,
+    };
+    messages[index] = updated;
+    writeJsonFile(path, messages);
+    return updated;
+}
+export function deleteMessage(workspaceId, channelId, messageId) {
+    const path = messageFilePath(workspaceId, channelId);
+    const messages = readJsonFile(path) || [];
+    const index = messages.findIndex((message) => message.id === messageId);
+    if (index === -1)
+        return false;
+    messages.splice(index, 1);
+    writeJsonFile(path, messages);
+    return true;
+}
+export function clearMessages(workspaceId, channelId) {
+    const path = messageFilePath(workspaceId, channelId);
+    const messages = readJsonFile(path) || [];
+    if (messages.length === 0)
+        return false;
+    writeJsonFile(path, []);
+    return true;
+}
+//# sourceMappingURL=message.js.map

package/dist/services/notification-hub/bot-agent.js

@@ -0,0 +1,87 @@
+import * as workspaceService from '../workspace.js';
+import * as agentService from '../agent.js';
+import { createAgentRuntime } from '../../adapters/agent-runtime.js';
+import { getThinkingRuntimeConfig } from '../llm-model-config.js';
+import { runIssueAutomation } from '../../agents/issue-agent-runner.js';
+import { publishWorkspaceEvent } from './events.js';
+export function getConfiguredBotAgent(workspaceId) {
+    const workspace = workspaceService.getById(workspaceId);
+    const botAgentId = workspace?.notificationSettings?.botAgentId;
+    if (!botAgentId)
+        return null;
+    return (agentService.listPresets(workspaceId) ?? [])
+        .find((agent) => agent.id === botAgentId && agent.role === 'bot' && agent.enabled !== false) ?? null;
+}
+export async function runBotAgent(workspaceId, preset, message) {
+    const session = agentService.getOrCreateSessionForConfig(workspaceId, preset);
+    agentService.updateStatus(workspaceId, session.id, 'active');
+    const startedAt = Date.now();
+    const runtime = createAgentRuntime({
+        kind: preset.runtimeKind,
+        provider: preset.modelProvider,
+        model: preset.modelId,
+        apiKey: preset.apiKey,
+        baseURL: preset.apiBase,
+        ...getThinkingRuntimeConfig(preset),
+    });
+    const workingDir = agentService.resolveWorkingDir(workspaceId, preset);
+    try {
+        const result = await runtime.execute(buildBotPrompt(message), workingDir, {
+            maxTurns: 20,
+            mcpServers: agentService.getMcpServers(preset.mcps),
+            skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, preset), preset.skills),
+            configDir: agentService.getAgentConfigDir(workspaceId, preset),
+            sandboxDirs: preset.sandboxDirs,
+            systemPrompt: preset.systemPrompt,
+        });
+        agentService.complete(workspaceId, session.id, result.success ? undefined : result.error || result.summary, {
+            runtime: preset.runtimeKind,
+            model: preset.modelId,
+            summary: result.summary,
+            output: result.output,
+            durationMs: Date.now() - startedAt,
+            usage: result.usage,
+            costUsd: result.costUsd,
+        });
+        return formatBotFinalMessage(result);
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        agentService.updateStatus(workspaceId, session.id, 'crashed', { error });
+        return `处理失败：${error}`;
+    }
+}
+export function startIssueAutomation(workspaceId, issueId) {
+    runIssueAutomation(workspaceId, issueId, createBotAgentContext(workspaceId)).catch((err) => {
+        console.error(`[bot-command] issue automation error workspaceId=${workspaceId} issueId=${issueId}:`, err);
+    });
+}
+export function createBotAgentContext(workspaceId) {
+    return {
+        workspaceId,
+        broadcast: (event, data) => publishWorkspaceEvent(workspaceId, event, data),
+        getSession: (sessionId) => agentService.getById(workspaceId, sessionId),
+        updateSessionStatus: (sessionId, status, extra) => agentService.updateStatus(workspaceId, sessionId, status, extra),
+    };
+}
+function buildBotPrompt(message) {
+    return [
+        'User message from external chat platform:',
+        message,
+        '',
+        'Reply to the user directly. Output only the final reply.',
+    ].join('\n');
+}
+function formatBotFinalMessage(result) {
+    if (!result.success)
+        return result.error || result.summary || '处理失败';
+    const finalOutput = result.output
+        .map((line) => line.trim())
+        .filter((line) => line && !isUsageLine(line))
+        .at(-1);
+    return finalOutput || result.summary || '处理完成';
+}
+function isUsageLine(line) {
+    return /^\[usage\]\s+tokens=/i.test(line);
+}
+//# sourceMappingURL=bot-agent.js.map

package/dist/services/notification-hub/bot-commands.js

@@ -0,0 +1,360 @@
+import * as workspaceService from '../workspace.js';
+import * as issueService from '../issue.js';
+import * as taskService from '../task.js';
+import * as agentService from '../agent.js';
+import * as issueCommentService from '../issue-comment.js';
+import { gitCommit, gitGenerateCommitMsg, gitPull, gitPush, gitStatus } from '../../adapters/git.js';
+import { botCommandContexts } from './types.js';
+import { truncateLine } from './format.js';
+import { startIssueAutomation, getConfiguredBotAgent } from './bot-agent.js';
+import { hasActiveIssueAutomation } from '../../agents/issue-agent-runner.js';
+export function isBuiltInCommand(text) {
+    const command = text.trim().split(/\s+/, 1)[0];
+    return command.startsWith('/');
+}
+export async function buildCommandResponse(input) {
+    try {
+        return await executeCommand(input);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return `Command failed: ${message}`;
+    }
+}
+async function executeCommand(input) {
+    const text = input.text.trim();
+    const tokens = parseCommandTokens(text);
+    const command = tokens[0] ?? '';
+    const args = tokens.slice(1);
+    const context = getBotCommandContext(input.conversationId, input.defaultWorkspaceId);
+    const workspaceId = context.workspaceId ?? input.defaultWorkspaceId;
+    if (command === '/workspace') {
+        const workspace = workspaceService.getById(workspaceId);
+        return workspace ? formatWorkspaceDetail(workspace, context.issueId) : 'Workspace not found.';
+    }
+    if (command === '/workspaces') {
+        const workspaces = workspaceService.getAll();
+        return workspaces.length
+            ? workspaces.map((workspace) => formatWorkspaceSummary(workspace, workspace.id === workspaceId)).join('\n')
+            : 'No workspaces.';
+    }
+    if (command === '/workspac') {
+        const nextWorkspaceId = args[0];
+        if (!nextWorkspaceId)
+            return 'Usage: /workspac [id]';
+        const workspace = workspaceService.getById(nextWorkspaceId);
+        if (!workspace)
+            return `Workspace not found: ${nextWorkspaceId}`;
+        const nextContext = { workspaceId: workspace.id };
+        botCommandContexts.set(input.conversationId, nextContext);
+        return `Switched workspace:\n${formatWorkspaceDetail(workspace)}`;
+    }
+    if (command === '/agents') {
+        return formatAgentList(workspaceId);
+    }
+    if (command === '/issues') {
+        return formatIssueList(workspaceId);
+    }
+    if (command === '/issue') {
+        if (args[0] === 'new') {
+            const title = args[1]?.trim();
+            const description = args.slice(2).join(' ').trim();
+            if (!title)
+                return 'Usage: /issue new [title] [desc]';
+            const issue = issueService.create(workspaceId, { title, description });
+            const issues = issueService.list(workspaceId);
+            const issueIndex = issues.findIndex((i) => i.id === issue.id);
+            botCommandContexts.set(input.conversationId, { ...context, workspaceId, issueId: issue.id });
+            return `Created issue #${issueIndex}:\n${formatIssueDetail(workspaceId, issue.id)}`;
+        }
+        if (args[0] === 'start') {
+            const issue = getCurrentIssue(workspaceId, context.issueId);
+            if (!issue)
+                return 'No current issue. Use /issue [id/index] first.';
+            const updated = issueService.updateStatus(workspaceId, issue.id, 'planned');
+            if (updated)
+                startIssueAutomation(workspaceId, issue.id);
+            return updated ? `Issue started:\n${formatIssueSummary(updated)}` : 'Issue not found.';
+        }
+        if (args[0] === 'close') {
+            const issue = getCurrentIssue(workspaceId, context.issueId);
+            if (!issue)
+                return 'No current issue. Use /issue [id/index] first.';
+            const updated = issueService.markError(workspaceId, issue.id, 'Closed from bot command.');
+            return updated ? `Issue closed as failed:\n${formatIssueSummary(updated)}` : 'Issue not found.';
+        }
+        if (args[0] && args[1] === 'agent') {
+            const issue = resolveIssue(workspaceId, args[0]);
+            if (!issue)
+                return `Issue not found: ${args[0]}`;
+            const agentIds = args[2]?.split(',').map((s) => s.trim()).filter(Boolean);
+            if (!agentIds?.length)
+                return 'Usage: /issue [id/index] agent agent_id,agent_id,...';
+            const presets = agentService.listPresets(workspaceId) ?? [];
+            const presetIds = new Set(presets.map((p) => p.id));
+            const invalid = agentIds.filter((id) => !presetIds.has(id));
+            if (invalid.length)
+                return `Agent not found: ${invalid.join(', ')}`;
+            issue.assignedAgents = agentIds;
+            issueService.save(workspaceId, issue);
+            botCommandContexts.set(input.conversationId, { ...context, workspaceId, issueId: issue.id });
+            return `Set agents for "${issue.title}": ${agentIds.join(', ')}`;
+        }
+        if (args[0]) {
+            const issue = resolveIssue(workspaceId, args[0]);
+            if (!issue)
+                return `Issue not found: ${args[0]}`;
+            botCommandContexts.set(input.conversationId, { ...context, workspaceId, issueId: issue.id });
+            return `Entered issue:\n${formatIssueDetail(workspaceId, issue.id)}`;
+        }
+        const issue = getCurrentIssue(workspaceId, context.issueId);
+        return issue ? formatIssueDetail(workspaceId, issue.id) : 'No current issue. Use /issue [id/index] first.';
+    }
+    if (command === '/task') {
+        return formatCurrentTask(workspaceId, context.issueId);
+    }
+    if (command === '/comment') {
+        const content = getRawCommandTail(text).trim();
+        if (!content)
+            return 'Usage: /comment [msg]';
+        const issue = getCurrentIssue(workspaceId, context.issueId);
+        if (!issue)
+            return 'No current issue. Use /issue [id] first.';
+        const comment = issueCommentService.createIssueComment(workspaceId, issue.id, {
+            senderId: 'user',
+            content,
+            source: 'user',
+        });
+        if (comment && !hasActiveIssueAutomation(workspaceId))
+            startIssueAutomation(workspaceId, issue.id);
+        return comment ? `Comment added to ${issue.title}.` : 'Issue not found.';
+    }
+    if (command === '/comments') {
+        const issue = getCurrentIssue(workspaceId, context.issueId);
+        if (!issue)
+            return 'No current issue. Use /issue [id] first.';
+        return formatComments(workspaceId, issue.id);
+    }
+    if (command === '/changes') {
+        const status = await gitStatus(workspaceId);
+        if (status.clean)
+            return `No changes on ${status.branch}.`;
+        return [
+            `Changes on ${status.branch}:`,
+            ...status.files.map((file) => `- ${file.path} [${file.status}]`),
+        ].join('\n');
+    }
+    if (command === '/commit') {
+        const rawMessage = getRawCommandTail(text).trim();
+        if (!rawMessage)
+            return 'Usage: /commit [desc/auto]';
+        const status = await gitStatus(workspaceId);
+        if (status.clean)
+            return `No changes to commit on ${status.branch}.`;
+        const message = rawMessage === 'auto' ? await gitGenerateCommitMsg(workspaceId) : rawMessage;
+        const result = await gitCommit(workspaceId, message);
+        return `Committed ${result.hash.slice(0, 7)}:\n${message}`;
+    }
+    if (command === '/push') {
+        await gitPush(workspaceId);
+        return 'Pushed to remote git.';
+    }
+    if (command === '/pull') {
+        await gitPull(workspaceId);
+        return 'Pulled from remote git.';
+    }
+    if (command === '/help')
+        return buildCommandHelp();
+    return buildCommandHelp();
+}
+function getBotCommandContext(conversationId, defaultWorkspaceId) {
+    const existing = botCommandContexts.get(conversationId) ?? {};
+    const workspaceId = existing.workspaceId && workspaceService.getById(existing.workspaceId)
+        ? existing.workspaceId
+        : defaultWorkspaceId;
+    const issueId = existing.issueId && issueService.getById(workspaceId, existing.issueId)
+        ? existing.issueId
+        : undefined;
+    const normalized = { workspaceId, issueId };
+    botCommandContexts.set(conversationId, normalized);
+    return normalized;
+}
+function parseCommandTokens(text) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    let escaping = false;
+    for (const char of text.trim()) {
+        if (escaping) {
+            current += char;
+            escaping = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaping = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            else
+                current += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+function getRawCommandTail(text) {
+    const trimmed = text.trim();
+    const firstSpace = trimmed.search(/\s/);
+    return firstSpace === -1 ? '' : trimmed.slice(firstSpace + 1);
+}
+function formatWorkspaceSummary(workspace, active) {
+    const issueCount = issueService.list(workspace.id).length;
+    const marker = active ? '*' : '-';
+    return `${marker} ${workspace.name} (${workspace.id}) issues=${issueCount}`;
+}
+function formatWorkspaceDetail(workspace, currentIssueId) {
+    const issues = issueService.list(workspace.id);
+    const agents = agentService.listPresets(workspace.id) ?? [];
+    return [
+        `${workspace.name} (${workspace.id})`,
+        `Root: ${workspace.boundDirs[0] ?? '-'}`,
+        `Issues: ${issues.length}`,
+        `Agents: ${agents.length}`,
+        currentIssueId ? `Current issue: ${currentIssueId}` : undefined,
+    ].filter(Boolean).join('\n');
+}
+function resolveIssue(workspaceId, idOrIndex) {
+    const byId = issueService.getById(workspaceId, idOrIndex);
+    if (byId)
+        return byId;
+    const index = Number(idOrIndex);
+    if (Number.isInteger(index) && index >= 0) {
+        const issues = issueService.list(workspaceId)
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        return issues[index] ?? null;
+    }
+    return null;
+}
+function formatAgentList(workspaceId) {
+    const agents = agentService.listPresets(workspaceId) ?? [];
+    if (!agents.length)
+        return 'No agents.';
+    return [
+        'Agents:',
+        ...agents.map((agent, i) => `#${i} ${agent.name} (${agent.id})${agent.role ? ` [${agent.role}]` : ''}`),
+    ].join('\n');
+}
+function formatIssueList(workspaceId) {
+    const issues = issueService.list(workspaceId);
+    if (!issues.length)
+        return 'No issues.';
+    return issues
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+        .map((issue, i) => `#${i} ${formatIssueSummary(issue)}`)
+        .join('\n');
+}
+function formatIssueSummary(issue) {
+    return `${issue.title} [${issue.status}] ${issue.id}`;
+}
+function formatIssueDetail(workspaceId, issueId) {
+    const issue = issueService.getById(workspaceId, issueId);
+    if (!issue)
+        return 'Issue not found.';
+    const tasks = taskService.list(workspaceId, issue.id);
+    const comments = issueCommentService.listIssueComments(workspaceId, issue.id);
+    const members = issue.members.length ? issue.members.join(', ') : '-';
+    const agents = issue.assignedAgents.length ? issue.assignedAgents.join(', ') : '-';
+    return [
+        `${issue.title} [${issue.status}]`,
+        `ID: ${issue.id}`,
+        issue.description ? `Desc: ${issue.description}` : undefined,
+        `Members: ${members}`,
+        `Agents: ${agents}`,
+        `Tasks: ${tasks.length}`,
+        ...tasks.map((task) => `- ${task.title} [${task.status}] ${task.id}`),
+        `Comments: ${comments.length}`,
+        ...comments.slice(-5).map((comment) => `- ${comment.senderId}: ${truncateLine(comment.content, 120)}`),
+    ].filter(Boolean).join('\n');
+}
+function getCurrentIssue(workspaceId, issueId) {
+    if (issueId) {
+        const issue = issueService.getById(workspaceId, issueId);
+        if (issue)
+            return issue;
+    }
+    return issueService.list(workspaceId)
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0] ?? null;
+}
+function formatCurrentTask(workspaceId, issueId) {
+    const botAgent = getConfiguredBotAgent(workspaceId);
+    const sessions = botAgent
+        ? agentService.list(workspaceId).filter((session) => session.agentConfigId === botAgent.id)
+        : [];
+    const currentTaskIds = new Set(sessions.map((session) => session.currentTaskId).filter((id) => Boolean(id)));
+    const currentTasks = [...currentTaskIds]
+        .map((taskId) => taskService.getById(workspaceId, taskId))
+        .filter((task) => Boolean(task));
+    if (currentTasks.length) {
+        return [
+            botAgent ? `Current tasks for ${botAgent.name}:` : 'Current tasks:',
+            ...currentTasks.map((task) => `- ${task.title} [${task.status}] ${task.id}`),
+        ].join('\n');
+    }
+    const issue = getCurrentIssue(workspaceId, issueId);
+    if (!issue)
+        return 'No current task.';
+    const tasks = taskService.list(workspaceId, issue.id).filter((task) => !botAgent || task.agentConfigId === botAgent.id || task.assignedAgentId === botAgent.id);
+    if (!tasks.length)
+        return botAgent ? `No task for ${botAgent.name}.` : 'No current task.';
+    return [
+        botAgent ? `Tasks for ${botAgent.name}:` : `Tasks for ${issue.title}:`,
+        ...tasks.map((task) => `- ${task.title} [${task.status}] ${task.id}`),
+    ].join('\n');
+}
+function formatComments(workspaceId, issueId) {
+    const comments = issueCommentService.listIssueComments(workspaceId, issueId);
+    if (!comments.length)
+        return 'No comments.';
+    return comments.map((comment) => `- ${comment.senderId} ${comment.createdAt}: ${truncateLine(comment.content, 180)}`).join('\n');
+}
+function buildCommandHelp() {
+    return [
+        'Supported commands:',
+        '/workspace',
+        '/workspaces',
+        '/workspac [id]',
+        '/agents',
+        '/issues',
+        '/issue',
+        '/issue [id/index]',
+        '/issue new [title] [desc]',
+        '/issue [id/index] agent agent_id,agent_id,...',
+        '/issue start',
+        '/issue close',
+        '/task',
+        '/comment [msg]',
+        '/comments',
+        '/help',
+        '/changes',
+        '/commit [desc/auto]',
+        '/push',
+        '/pull',
+    ].join('\n');
+}
+//# sourceMappingURL=bot-commands.js.map

package/dist/services/notification-hub/events.js

@@ -0,0 +1,96 @@
+import * as issueService from '../issue.js';
+import * as taskService from '../task.js';
+import { adapters } from './types.js';
+import { shouldNotify, isIssueStartStatus, isTaskDoneStatus } from './helpers.js';
+export function publishWorkspaceEvent(workspaceId, wsEvent, data) {
+    const envelope = buildNotificationEnvelope(workspaceId, wsEvent, data);
+    if (!envelope)
+        return;
+    const adapter = adapters.get(workspaceId);
+    if (!adapter)
+        return;
+    adapter.send(envelope).catch((err) => {
+        console.error(`[notification] failed to send ${envelope.event} workspaceId=${workspaceId}:`, err);
+    });
+}
+function buildNotificationEnvelope(workspaceId, wsEvent, data) {
+    if (wsEvent === 'issue.status_changed') {
+        const payload = data;
+        if (!payload.issueId)
+            return null;
+        const issue = issueService.getById(workspaceId, payload.issueId);
+        if (!issue || !shouldNotify(workspaceId, payload.to === 'completed' ? 'issue_completed' : 'issue_started')) {
+            return null;
+        }
+        if (!isIssueStartStatus(payload.to) && payload.to !== 'completed')
+            return null;
+        return {
+            event: 'issuse_status_change',
+            workspaceId,
+            timestamp: new Date().toISOString(),
+            data: {
+                issueId: issue.id,
+                channelId: issue.channelId,
+                title: issue.title,
+                description: issue.description,
+                from: payload.from,
+                to: payload.to,
+                status: issue.status,
+                tasks: taskService.list(workspaceId, issue.id),
+                issue,
+            },
+        };
+    }
+    if (wsEvent === 'task.status_changed') {
+        const payload = data;
+        if (!payload.taskId)
+            return null;
+        const task = taskService.getById(workspaceId, payload.taskId);
+        if (!task)
+            return null;
+        const issue = issueService.getById(workspaceId, task.issueId);
+        if (!issue)
+            return null;
+        if (payload.to === 'running' && shouldNotify(workspaceId, 'issue_started')) {
+            return {
+                event: 'issue_task_start',
+                workspaceId,
+                timestamp: new Date().toISOString(),
+                data: {
+                    issueId: issue.id,
+                    channelId: issue.channelId,
+                    taskId: task.id,
+                    title: task.title,
+                    description: task.description,
+                    assignedAgentId: task.assignedAgentId,
+                    from: payload.from,
+                    to: payload.to,
+                    task,
+                    issue,
+                },
+            };
+        }
+        if (isTaskDoneStatus(payload.to) && shouldNotify(workspaceId, 'issue_task_completed')) {
+            return {
+                event: 'issue_task_done',
+                workspaceId,
+                timestamp: new Date().toISOString(),
+                data: {
+                    issueId: issue.id,
+                    channelId: issue.channelId,
+                    taskId: task.id,
+                    title: task.title,
+                    description: task.description,
+                    assignedAgentId: task.assignedAgentId,
+                    from: payload.from,
+                    to: payload.to,
+                    result: task.result,
+                    task,
+                    issue,
+                },
+            };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=events.js.map

package/dist/services/notification-hub/format.js

@@ -0,0 +1,34 @@
+export function formatLarkTitle(envelope) {
+    const title = typeof envelope.data.title === 'string' ? String(envelope.data.title) : 'Issue update';
+    if (envelope.event === 'issue_task_start')
+        return `Task started: ${title}`;
+    if (envelope.event === 'issue_task_done')
+        return `Task done: ${title}`;
+    return `Issue status: ${title}`;
+}
+export function formatLarkContent(envelope) {
+    const lines = [
+        `Event: ${envelope.event}`,
+        `Workspace: ${envelope.workspaceId}`,
+        envelope.data.issueId ? `Issue: ${envelope.data.issueId}` : '',
+        envelope.data.taskId ? `Task: ${envelope.data.taskId}` : '',
+        envelope.data.to ? `Status: ${String(envelope.data.from ?? '')} -> ${String(envelope.data.to)}` : '',
+        envelope.data.message ? String(envelope.data.message) : '',
+        formatResult(envelope.data.result),
+    ];
+    return lines.filter(Boolean).join('\n');
+}
+export function formatResult(result) {
+    if (!result)
+        return '';
+    return [
+        `Success: ${result.success}`,
+        result.summary ? `Summary: ${result.summary}` : '',
+        result.error ? `Error: ${result.error}` : '',
+    ].filter(Boolean).join('\n');
+}
+export function truncateLine(value, maxLength) {
+    const compact = value.replace(/\s+/g, ' ').trim();
+    return compact.length > maxLength ? `${compact.slice(0, maxLength - 3)}...` : compact;
+}
+//# sourceMappingURL=format.js.map