profclaw 0.0.1-beta.1

package/dist/chat/execution/tools/openai-image-gen.js

@@ -0,0 +1,212 @@
+/**
+ * OpenAI Image Generation Tool
+ *
+ * Generate images using OpenAI DALL-E models.
+ * Supports DALL-E 2 and DALL-E 3 with configurable size, quality, and style.
+ */
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// Schema
+const ImageGenParamsSchema = z.object({
+    prompt: z.string().min(1).max(4000).describe('Text description of the image to generate'),
+    size: z.enum(['1024x1024', '1792x1024', '1024x1792'])
+        .optional()
+        .default('1024x1024')
+        .describe('Image dimensions (1792x1024 and 1024x1792 are DALL-E 3 only)'),
+    quality: z.enum(['standard', 'hd'])
+        .optional()
+        .default('standard')
+        .describe('Image quality (hd is DALL-E 3 only, costs more)'),
+    style: z.enum(['vivid', 'natural'])
+        .optional()
+        .default('vivid')
+        .describe('Image style: vivid for dramatic, natural for realistic (DALL-E 3 only)'),
+    model: z.enum(['dall-e-3', 'dall-e-2'])
+        .optional()
+        .default('dall-e-3')
+        .describe('Model to use for generation'),
+});
+let currentConfig = {
+    apiKey: process.env.OPENAI_API_KEY ?? '',
+};
+/**
+ * Update the image generation configuration
+ */
+export function setImageGenConfig(config) {
+    currentConfig = { ...currentConfig, ...config };
+    logger.info('[ImageGen] Config updated');
+}
+/**
+ * Get the current image generation configuration
+ */
+export function getImageGenConfig() {
+    return { ...currentConfig };
+}
+// Tool Definition
+export const openaiImageGenTool = {
+    name: 'openai_image_gen',
+    description: `Generate images using OpenAI DALL-E models.
+
+Creates high-quality AI-generated images from text descriptions.
+Supports DALL-E 3 (recommended) and DALL-E 2.
+
+DALL-E 3 features:
+- High-definition quality mode
+- Vivid or natural style
+- Wider sizes (landscape/portrait)
+- Automatically revised prompts for better results
+
+Returns a URL to the generated image (valid for ~1 hour).`,
+    category: 'custom',
+    securityLevel: 'moderate',
+    requiresApproval: false,
+    parameters: ImageGenParamsSchema,
+    isAvailable() {
+        const key = process.env.OPENAI_API_KEY ?? currentConfig.apiKey;
+        if (!key) {
+            return {
+                available: false,
+                reason: 'OPENAI_API_KEY is not set. Configure it in Settings > AI Providers.',
+            };
+        }
+        return { available: true };
+    },
+    examples: [
+        {
+            description: 'Generate a simple image',
+            params: { prompt: 'A serene mountain lake at sunset with reflections' },
+        },
+        {
+            description: 'High-definition landscape',
+            params: {
+                prompt: 'A futuristic city skyline with flying vehicles and neon lights',
+                size: '1792x1024',
+                quality: 'hd',
+                style: 'vivid',
+                model: 'dall-e-3',
+            },
+        },
+        {
+            description: 'Natural-style portrait',
+            params: {
+                prompt: 'A professional headshot of a friendly software engineer in their home office',
+                style: 'natural',
+                quality: 'hd',
+            },
+        },
+    ],
+    async execute(context, params) {
+        const apiKey = process.env.OPENAI_API_KEY ?? currentConfig.apiKey;
+        if (!apiKey) {
+            return {
+                success: false,
+                error: {
+                    code: 'NOT_CONFIGURED',
+                    message: 'OPENAI_API_KEY is not set. Configure it in Settings > AI Providers.',
+                },
+            };
+        }
+        // DALL-E 2 does not support hd quality, natural/vivid style, or non-square sizes
+        const isDalle2 = params.model === 'dall-e-2';
+        const size = isDalle2 ? '1024x1024' : (params.size ?? '1024x1024');
+        const quality = isDalle2 ? 'standard' : (params.quality ?? 'standard');
+        const style = isDalle2 ? undefined : (params.style ?? 'vivid');
+        const requestBody = {
+            model: params.model ?? 'dall-e-3',
+            prompt: params.prompt,
+            n: 1,
+            size,
+            quality,
+            response_format: 'url',
+        };
+        if (style !== undefined) {
+            requestBody.style = style;
+        }
+        logger.info(`[ImageGen] Generating image with ${params.model ?? 'dall-e-3'}`, {
+            component: 'ImageGen',
+        });
+        try {
+            const baseUrl = currentConfig.baseUrl ?? 'https://api.openai.com';
+            const response = await fetch(`${baseUrl}/v1/images/generations`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(requestBody),
+                signal: context.signal,
+            });
+            if (!response.ok) {
+                const errText = await response.text();
+                let errMessage = `OpenAI API error ${response.status}`;
+                try {
+                    const errJson = JSON.parse(errText);
+                    if (errJson.error?.message) {
+                        errMessage = errJson.error.message;
+                    }
+                }
+                catch {
+                    // use raw text
+                    errMessage = `${errMessage}: ${errText.slice(0, 200)}`;
+                }
+                logger.error(`[ImageGen] API error: ${errMessage}`, { component: 'ImageGen' });
+                return {
+                    success: false,
+                    error: {
+                        code: 'API_ERROR',
+                        message: errMessage,
+                        retryable: response.status >= 500,
+                    },
+                };
+            }
+            const data = (await response.json());
+            const imageData = data.data[0];
+            if (!imageData?.url) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_IMAGE_URL',
+                        message: 'OpenAI returned no image URL',
+                    },
+                };
+            }
+            const result = {
+                url: imageData.url,
+                revised_prompt: imageData.revised_prompt,
+                model: params.model ?? 'dall-e-3',
+                size,
+                quality,
+                style: style ?? 'vivid',
+            };
+            const lines = [
+                '## Image Generated\n',
+                `**URL**: ${imageData.url}`,
+                `**Model**: ${result.model}`,
+                `**Size**: ${size} | **Quality**: ${quality}${style ? ` | **Style**: ${style}` : ''}`,
+            ];
+            if (imageData.revised_prompt) {
+                lines.push('', `**Revised Prompt**: ${imageData.revised_prompt}`);
+            }
+            lines.push('', '*Note: The image URL is valid for approximately 1 hour.*');
+            logger.info('[ImageGen] Image generated successfully', { component: 'ImageGen' });
+            return {
+                success: true,
+                data: result,
+                output: lines.join('\n'),
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`[ImageGen] Generation failed: ${message}`, { component: 'ImageGen' });
+            return {
+                success: false,
+                error: {
+                    code: 'GENERATION_FAILED',
+                    message: `Image generation failed: ${message}`,
+                    retryable: true,
+                },
+            };
+        }
+    },
+};
+//# sourceMappingURL=openai-image-gen.js.map

package/dist/chat/execution/tools/profclaw-ops.d.ts

@@ -0,0 +1,204 @@
+/**
+ * profClaw Operations Tools
+ *
+ * Ticket, project, and sprint management through AI chat.
+ * These tools allow the AI to create and manage profClaw's own data.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+/** Reset cache (for testing) */
+export declare function _resetDbAvailabilityCache(): void;
+declare const CreateTicketParamsSchema: z.ZodObject<{
+    projectKey: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<["task", "bug", "story", "epic", "subtask", "feature", "improvement"]>>;
+    priority: z.ZodDefault<z.ZodEnum<["critical", "high", "medium", "low", "none"]>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    storyPoints: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    priority: "critical" | "medium" | "none" | "high" | "low";
+    type: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement";
+    projectKey: string;
+    description?: string | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}, {
+    title: string;
+    projectKey: string;
+    description?: string | undefined;
+    priority?: "critical" | "medium" | "none" | "high" | "low" | undefined;
+    type?: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement" | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}>;
+declare const CreateProjectParamsSchema: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+}, {
+    name: string;
+    key: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+}>;
+declare const ListTicketsParamsSchema: z.ZodObject<{
+    projectKey: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    search?: string | undefined;
+    priority?: string | undefined;
+    type?: string | undefined;
+    status?: string | undefined;
+    projectKey?: string | undefined;
+}, {
+    search?: string | undefined;
+    priority?: string | undefined;
+    type?: string | undefined;
+    status?: string | undefined;
+    limit?: number | undefined;
+    projectKey?: string | undefined;
+}>;
+declare const ListProjectsParamsSchema: z.ZodObject<{
+    status: z.ZodDefault<z.ZodEnum<["active", "archived", "all"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "all" | "archived";
+}, {
+    status?: "active" | "all" | "archived" | undefined;
+}>;
+declare const UpdateTicketParamsSchema: z.ZodObject<{
+    ticketKey: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["backlog", "todo", "in_progress", "in_review", "done", "cancelled"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "none"]>>;
+    type: z.ZodOptional<z.ZodEnum<["task", "bug", "story", "epic", "subtask", "feature", "improvement"]>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    storyPoints: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    ticketKey: string;
+    title?: string | undefined;
+    description?: string | undefined;
+    priority?: "critical" | "medium" | "none" | "high" | "low" | undefined;
+    type?: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement" | undefined;
+    status?: "in_progress" | "cancelled" | "backlog" | "done" | "todo" | "in_review" | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}, {
+    ticketKey: string;
+    title?: string | undefined;
+    description?: string | undefined;
+    priority?: "critical" | "medium" | "none" | "high" | "low" | undefined;
+    type?: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement" | undefined;
+    status?: "in_progress" | "cancelled" | "backlog" | "done" | "todo" | "in_review" | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}>;
+declare const GetTicketParamsSchema: z.ZodObject<{
+    ticketKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ticketKey: string;
+}, {
+    ticketKey: string;
+}>;
+export type CreateTicketParams = z.infer<typeof CreateTicketParamsSchema>;
+export type CreateProjectParams = z.infer<typeof CreateProjectParamsSchema>;
+export type ListTicketsParams = z.infer<typeof ListTicketsParamsSchema>;
+export type ListProjectsParams = z.infer<typeof ListProjectsParamsSchema>;
+export type UpdateTicketParams = z.infer<typeof UpdateTicketParamsSchema>;
+export type GetTicketParams = z.infer<typeof GetTicketParamsSchema>;
+interface TicketResult {
+    id: string;
+    key: string;
+    title: string;
+    description?: string;
+    status: string;
+    type: string;
+    priority: string;
+    labels?: string[];
+    storyPoints?: number;
+    projectKey: string;
+    createdAt: string;
+    /** URL to view this ticket in the UI */
+    url: string;
+}
+interface ProjectResult {
+    id: string;
+    name: string;
+    key: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    status: string;
+    ticketCount?: number;
+}
+export declare const createTicketTool: ToolDefinition<CreateTicketParams, TicketResult>;
+export declare const createProjectTool: ToolDefinition<CreateProjectParams, ProjectResult>;
+export declare const listTicketsTool: ToolDefinition<ListTicketsParams, {
+    tickets: TicketResult[];
+    total: number;
+}>;
+export declare const listProjectsTool: ToolDefinition<ListProjectsParams, {
+    projects: ProjectResult[];
+    hint?: string;
+}>;
+export declare const updateTicketTool: ToolDefinition<UpdateTicketParams, TicketResult>;
+export declare const getTicketTool: ToolDefinition<GetTicketParams, TicketResult>;
+export declare const profclawTools: (ToolDefinition<{
+    title: string;
+    priority: "critical" | "medium" | "none" | "high" | "low";
+    type: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement";
+    projectKey: string;
+    description?: string | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}, TicketResult> | ToolDefinition<{
+    name: string;
+    key: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+}, ProjectResult> | ToolDefinition<{
+    limit: number;
+    search?: string | undefined;
+    priority?: string | undefined;
+    type?: string | undefined;
+    status?: string | undefined;
+    projectKey?: string | undefined;
+}, {
+    tickets: TicketResult[];
+    total: number;
+}> | ToolDefinition<{
+    status: "active" | "all" | "archived";
+}, {
+    projects: ProjectResult[];
+    hint?: string;
+}> | ToolDefinition<{
+    ticketKey: string;
+    title?: string | undefined;
+    description?: string | undefined;
+    priority?: "critical" | "medium" | "none" | "high" | "low" | undefined;
+    type?: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement" | undefined;
+    status?: "in_progress" | "cancelled" | "backlog" | "done" | "todo" | "in_review" | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}, TicketResult> | ToolDefinition<{
+    ticketKey: string;
+}, TicketResult>)[];
+export {};
+//# sourceMappingURL=profclaw-ops.d.ts.map