cowork-os 0.3.21

package/dist/electron/electron/agent/tools/image-tools.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageTools = void 0;
+const image_generator_1 = require("../skills/image-generator");
+/**
+ * ImageTools - Tools for AI image generation using Nano Banana models
+ *
+ * Provides two image generation models:
+ * - Nano Banana: Fast generation using Gemini 2.5 Flash Image
+ * - Nano Banana Pro: High-quality generation using Gemini 3 Pro
+ */
+class ImageTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+        this.imageGenerator = new image_generator_1.ImageGenerator(workspace);
+    }
+    /**
+     * Update the workspace for this tool
+     * Recreates the image generator with the new workspace
+     */
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+        this.imageGenerator = new image_generator_1.ImageGenerator(workspace);
+    }
+    /**
+     * Generate an image from a text prompt
+     */
+    async generateImage(input) {
+        if (!this.workspace.permissions.write) {
+            throw new Error('Write permission not granted for image generation');
+        }
+        const result = await this.imageGenerator.generate({
+            prompt: input.prompt,
+            model: input.model || 'nano-banana-pro',
+            filename: input.filename,
+            imageSize: input.imageSize || '1K',
+            numberOfImages: input.numberOfImages || 1,
+        });
+        // Log events for generated images
+        if (result.success) {
+            for (const image of result.images) {
+                this.daemon.logEvent(this.taskId, 'file_created', {
+                    path: image.filename,
+                    type: 'image',
+                    mimeType: image.mimeType,
+                    size: image.size,
+                    model: result.model,
+                });
+            }
+        }
+        else {
+            this.daemon.logEvent(this.taskId, 'error', {
+                action: 'generate_image',
+                error: result.error,
+            });
+        }
+        return result;
+    }
+    /**
+     * Check if image generation is available
+     */
+    static isAvailable() {
+        return image_generator_1.ImageGenerator.isAvailable();
+    }
+    /**
+     * Get tool definitions for image generation
+     */
+    static getToolDefinitions() {
+        return [
+            {
+                name: 'generate_image',
+                description: `Generate an image from a text description using AI. Two models are available:
+- nano-banana: Fast generation using Gemini 2.5 Flash
+- nano-banana-pro: High-quality generation using Gemini 3 Pro (default)
+
+The generated images are saved to the workspace folder.`,
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        prompt: {
+                            type: 'string',
+                            description: 'Detailed text description of the image to generate. Be specific about subject, style, colors, composition, lighting, etc.',
+                        },
+                        model: {
+                            type: 'string',
+                            enum: ['nano-banana', 'nano-banana-pro'],
+                            description: 'The model to use. "nano-banana" for fast generation, "nano-banana-pro" for high quality (default: nano-banana-pro)',
+                        },
+                        filename: {
+                            type: 'string',
+                            description: 'Output filename without extension (optional, defaults to generated_<timestamp>)',
+                        },
+                        imageSize: {
+                            type: 'string',
+                            enum: ['1K', '2K'],
+                            description: 'Size of the generated image. "1K" for 1024px, "2K" for 2048px (default: 1K)',
+                        },
+                        numberOfImages: {
+                            type: 'number',
+                            description: 'Number of images to generate (1-4, default: 1)',
+                        },
+                    },
+                    required: ['prompt'],
+                },
+            },
+        ];
+    }
+}
+exports.ImageTools = ImageTools;

package/dist/electron/electron/agent/tools/mention-tools.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MentionTools = void 0;
+const MentionRepository_1 = require("../../agents/MentionRepository");
+const AgentRoleRepository_1 = require("../../agents/AgentRoleRepository");
+const schema_1 = require("../../database/schema");
+/**
+ * MentionTools provides tools for agents to @mention and communicate with other specialized agents
+ * This enables multi-agent collaboration and task delegation
+ */
+class MentionTools {
+    constructor(workspaceId, taskId, daemon, currentAgentRoleId) {
+        this.workspaceId = workspaceId;
+        this.taskId = taskId;
+        this.daemon = daemon;
+        this.currentAgentRoleId = currentAgentRoleId;
+        // Get repositories from the database manager
+        const dbManager = schema_1.DatabaseManager.getInstance();
+        const db = dbManager.getDatabase();
+        this.mentionRepo = new MentionRepository_1.MentionRepository(db);
+        this.agentRoleRepo = new AgentRoleRepository_1.AgentRoleRepository(db);
+    }
+    /**
+     * Update workspace and task for this tool instance
+     */
+    setContext(workspaceId, taskId, agentRoleId) {
+        this.workspaceId = workspaceId;
+        this.taskId = taskId;
+        this.currentAgentRoleId = agentRoleId;
+    }
+    /**
+     * List available agent roles that can be mentioned
+     */
+    async listAgentRoles() {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'list_agent_roles',
+        });
+        const roles = this.agentRoleRepo.findAll(false); // false = only active roles
+        const result = {
+            agents: roles.map((role) => ({
+                id: role.id,
+                name: role.name,
+                displayName: role.displayName,
+                description: role.description,
+                capabilities: role.capabilities,
+            })),
+        };
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'list_agent_roles',
+            success: true,
+            count: result.agents.length,
+        });
+        return result;
+    }
+    /**
+     * @mention another agent to request help or delegate work
+     */
+    async mentionAgent(params) {
+        const { agentRole, mentionType, context } = params;
+        if (!agentRole || typeof agentRole !== 'string') {
+            throw new Error('Invalid agentRole: must be a non-empty string');
+        }
+        if (!['request', 'handoff', 'review', 'fyi'].includes(mentionType)) {
+            throw new Error('Invalid mentionType: must be one of request, handoff, review, fyi');
+        }
+        if (!context || typeof context !== 'string') {
+            throw new Error('Invalid context: must be a non-empty string');
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'mention_agent',
+            agentRole,
+            mentionType,
+        });
+        // Find the agent role by name or displayName
+        const allRoles = this.agentRoleRepo.findAll(false); // false = only active roles
+        const targetRole = allRoles.find((r) => r.name.toLowerCase() === agentRole.toLowerCase() ||
+            r.displayName.toLowerCase() === agentRole.toLowerCase());
+        if (!targetRole) {
+            const availableRoles = allRoles.map((r) => r.name).join(', ');
+            throw new Error(`Agent role "${agentRole}" not found. Available roles: ${availableRoles}`);
+        }
+        // Don't allow self-mentions
+        if (this.currentAgentRoleId && targetRole.id === this.currentAgentRoleId) {
+            throw new Error('Cannot mention yourself. Please choose a different agent.');
+        }
+        // Create the mention
+        const mention = this.mentionRepo.create({
+            workspaceId: this.workspaceId,
+            taskId: this.taskId,
+            fromAgentRoleId: this.currentAgentRoleId,
+            toAgentRoleId: targetRole.id,
+            mentionType,
+            context,
+        });
+        const typeDescriptions = {
+            request: 'requested help from',
+            handoff: 'handed off work to',
+            review: 'requested a review from',
+            fyi: 'shared information with',
+        };
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'mention_agent',
+            success: true,
+            mentionId: mention.id,
+            toAgentRoleId: targetRole.id,
+        });
+        return {
+            success: true,
+            mentionId: mention.id,
+            toAgent: targetRole.displayName,
+            message: `Successfully ${typeDescriptions[mentionType]} @${targetRole.displayName}. They will be notified about this task.`,
+        };
+    }
+    /**
+     * Get pending mentions for this agent
+     */
+    async getPendingMentions() {
+        if (!this.currentAgentRoleId) {
+            return { mentions: [] };
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'get_pending_mentions',
+        });
+        const pending = this.mentionRepo.getPendingForAgent(this.currentAgentRoleId, this.workspaceId);
+        const mentions = pending.map((m) => {
+            let fromAgent = null;
+            if (m.fromAgentRoleId) {
+                const role = this.agentRoleRepo.findById(m.fromAgentRoleId);
+                fromAgent = role?.displayName || null;
+            }
+            return {
+                id: m.id,
+                fromAgent,
+                mentionType: m.mentionType,
+                context: m.context,
+                createdAt: m.createdAt,
+            };
+        });
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'get_pending_mentions',
+            success: true,
+            count: mentions.length,
+        });
+        return { mentions };
+    }
+    /**
+     * Acknowledge a mention directed to this agent
+     */
+    async acknowledgeMention(mentionId) {
+        if (!mentionId || typeof mentionId !== 'string') {
+            throw new Error('Invalid mentionId: must be a non-empty string');
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'acknowledge_mention',
+            mentionId,
+        });
+        const mention = this.mentionRepo.acknowledge(mentionId);
+        if (!mention) {
+            throw new Error(`Mention "${mentionId}" not found or already processed`);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'acknowledge_mention',
+            success: true,
+        });
+        return {
+            success: true,
+            message: 'Mention acknowledged. You can now work on the requested task.',
+        };
+    }
+    /**
+     * Mark a mention as completed
+     */
+    async completeMention(mentionId) {
+        if (!mentionId || typeof mentionId !== 'string') {
+            throw new Error('Invalid mentionId: must be a non-empty string');
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'complete_mention',
+            mentionId,
+        });
+        const mention = this.mentionRepo.complete(mentionId);
+        if (!mention) {
+            throw new Error(`Mention "${mentionId}" not found`);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'complete_mention',
+            success: true,
+        });
+        return {
+            success: true,
+            message: 'Mention completed successfully.',
+        };
+    }
+    /**
+     * Static method to get tool definitions
+     */
+    static getToolDefinitions() {
+        return [
+            {
+                name: 'list_agent_roles',
+                description: 'List all available specialized agent roles that can be mentioned. ' +
+                    'Use this to see what experts are available for collaboration.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'mention_agent',
+                description: 'Mention another specialized agent to request help, delegate work, request a review, or share information. ' +
+                    'This sends a notification to the specified agent role. ' +
+                    'Example uses: ask the Reviewer to check your code, ask the Researcher to find information, ' +
+                    'hand off a task to the Tester, or notify the Architect about a design decision.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        agentRole: {
+                            type: 'string',
+                            description: 'The name of the agent role to mention (e.g., "Reviewer", "Researcher", "Tester", "Architect"). ' +
+                                'Use list_agent_roles to see available options.',
+                        },
+                        mentionType: {
+                            type: 'string',
+                            enum: ['request', 'handoff', 'review', 'fyi'],
+                            description: 'Type of mention: ' +
+                                '"request" - ask for help with a specific task, ' +
+                                '"handoff" - fully delegate the task to another agent, ' +
+                                '"review" - request a review of completed work, ' +
+                                '"fyi" - informational, no action needed.',
+                        },
+                        context: {
+                            type: 'string',
+                            description: 'Detailed context for the mention. Explain what you need, what you have done so far, ' +
+                                'and any relevant information the other agent needs to help.',
+                        },
+                    },
+                    required: ['agentRole', 'mentionType', 'context'],
+                },
+            },
+            {
+                name: 'get_pending_mentions',
+                description: 'Get any pending mentions directed to this agent. ' +
+                    'Use this to check if other agents have requested your help.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'acknowledge_mention',
+                description: 'Acknowledge a mention, indicating you have seen it and will work on it.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        mentionId: {
+                            type: 'string',
+                            description: 'The ID of the mention to acknowledge',
+                        },
+                    },
+                    required: ['mentionId'],
+                },
+            },
+            {
+                name: 'complete_mention',
+                description: 'Mark a mention as completed after finishing the requested work.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        mentionId: {
+                            type: 'string',
+                            description: 'The ID of the mention to mark as completed',
+                        },
+                    },
+                    required: ['mentionId'],
+                },
+            },
+        ];
+    }
+}
+exports.MentionTools = MentionTools;