@goodandready/dsh-image-gen 0.10.4 → 0.10.6

package/lib/index.js

@@ -45,9 +45,113 @@ import {
   applyStylePreset,
   resolveStylePreset,
   blendImagesFal,
+  toLosslessJson,
 } from './providers.js'
 
-export { IMAGE_SIZES, OUTPUT_FORMATS, PROVIDER_KEYS, buildSidecar, normalizeMediaType }
+import { resolveConversationImage, analyzeImageWithVision, buildDualOutputMarkdown } from './resolve-image.js'
+import {
+  extractDesignTokens,
+  generateCssGradient,
+  checkWcagContrast,
+  optimizeSvgContent,
+  generatePwaIconSuite,
+  extractSampleColorsFromBuffer,
+} from './frontend-assets.js'
+
+
+export { IMAGE_SIZES, OUTPUT_FORMATS, PROVIDER_KEYS, buildSidecar, normalizeMediaType, resolveConversationImage, analyzeImageWithVision }
+
+
+/**
+ * Сохраняет сгенерированный ассет в воркспейс, регистрирует в attachments и возвращает Dual-Output (#150).
+ */
+export async function saveAndAttachResult(ctx, exec, cfg, {
+  bytes,
+  mediaType,
+  name,
+  stem,
+  prompt,
+  size,
+  format,
+  seed,
+  provider,
+  model,
+  cost,
+  sourceUrl,
+  deliverAs,
+  args = {},
+  action = 'generated',
+}) {
+  const attachment = await ctx.attachments.saveImage({
+    data: new Uint8Array(bytes),
+    mediaType,
+    name,
+  })
+
+  const sessionCwd = exec?.agent?.session?.header?.cwd
+  const targetDir = (args.output_dir && String(args.output_dir).trim()) || cfg.outputDir || 'generated/images'
+  const outDir = path.resolve(sessionCwd || process.cwd(), targetDir)
+  await mkdir(outDir, { recursive: true })
+  const filePath = path.join(outDir, name)
+  await writeFile(filePath, bytes)
+
+  const localUrl = '/dsh-image-gen/image?id=' + encodeURIComponent(attachment.attachmentId)
+    + '&mt=' + encodeURIComponent(attachment.mediaType)
+    + '&b=' + encodeURIComponent(String(attachment.bytes))
+    + '&w=' + encodeURIComponent(String(attachment.width))
+    + '&h=' + encodeURIComponent(String(attachment.height))
+
+  await writeFile(
+    path.join(outDir, `${stem}.json`),
+    JSON.stringify(buildSidecar({
+      prompt,
+      size,
+      format,
+      seed,
+      provider,
+      deliverAs,
+      width: attachment.width,
+      height: attachment.height,
+      mediaType,
+      attachmentId: attachment.attachmentId,
+      url: deliverAs === 'image' && sourceUrl ? sourceUrl : localUrl,
+      cost,
+    }), null, 2),
+  )
+
+  const summary = buildDualOutputMarkdown({
+    action,
+    filePath,
+    width: attachment.width,
+    height: attachment.height,
+    mediaType,
+    seed,
+    provider,
+    model: model || cfg.model || cfg.customModel || 'default',
+    cost,
+    attachmentId: attachment.attachmentId,
+  })
+
+  return toLosslessJson({
+    summary,
+    path: filePath,
+    url: deliverAs === 'image' && sourceUrl ? sourceUrl : localUrl,
+    width: attachment.width,
+    height: attachment.height,
+    seed,
+    prompt,
+    cost,
+    format: mediaType.replace('image/', ''),
+    attachment: {
+      attachmentId: attachment.attachmentId,
+      mediaType: attachment.mediaType,
+      bytes: attachment.bytes,
+      width: attachment.width,
+      height: attachment.height,
+      name: attachment.name,
+    },
+  })
+}
 
 export const name = 'dsh-image-gen'
 
@@ -813,7 +917,7 @@ export function apply(ctx, config) {
             height: gen.height || attachment.height,
             seed: gen.seed,
             prompt: promptArg,
-            originalPrompt: enhanced.enhanced ? args.prompt : undefined,
+            ...(enhanced.enhanced ? { originalPrompt: args.prompt } : {}),
             cost: gen.cost,
             format: mediaType.replace('image/', ''),
             attachment: {
@@ -873,7 +977,19 @@ export function apply(ctx, config) {
           }
         }
         const first = images[0]
-        return { channel: provider, provider, model: cfg.model || cfg.customModel, ...first, images }
+        const dualOutputSummary = buildDualOutputMarkdown({
+          action: 'generated',
+          filePath: first.path,
+          width: first.width,
+          height: first.height,
+          mediaType: first.mediaType || ('image/' + (first.format || 'png')),
+          seed: first.seed,
+          provider,
+          model: cfg.model || cfg.customModel || 'default',
+          cost: first.cost,
+          attachmentId: first.attachment?.attachmentId || 'N/A',
+        })
+        return toLosslessJson({ summary: dualOutputSummary, channel: provider, provider, model: cfg.model || cfg.customModel, ...first, images })
       },
     }),
   )
@@ -1173,11 +1289,257 @@ export function apply(ctx, config) {
           throw new Error(`All aspect ratio generations failed in pack: ${warnings.join('; ')}`)
         }
 
-        return {
+        return toLosslessJson({
           images: results,
           count: results.length,
-          warnings: warnings.length ? warnings : undefined,
+          ...(warnings.length ? { warnings } : {}),
+        })
+      },
+    }),
+  )
+
+  // Редактирование существующего изображения (Inpainting / Edits) (#142, #144, #145, #150).
+  ctx.tools.register(
+    defineTool({
+      name: 'edit_image',
+      description:
+        'Edit an existing image using inpainting, targeted modification, or object replacement. '
+        + 'Describe the desired changes in prompt. '
+        + 'If image is omitted or "latest", automatically resolves the most recent image from the conversation session (#144). '
+        + 'Leverages @goodandready/dsh-vision-bridge for pre-edit composition analysis (#145). '
+        + 'Optionally accepts mask (path or attachment id) and strength (0.1-1.0). Returns safe dual-output (#150).',
+      parameters: {
+        prompt: {
+          type: 'string',
+          required: true,
+          description: 'Detailed description of the modification or edit to perform on the image.',
+        },
+        image: {
+          type: 'string',
+          description: 'Path or attachment id of the source image. Defaults to "latest" to auto-resolve from session history.',
+        },
+        mask: {
+          type: 'string',
+          description: 'Optional path or attachment id of the inpaint mask image.',
+        },
+        strength: {
+          type: 'number',
+          description: 'Denoising / edit strength between 0.1 and 1.0 (default 0.75 for edits, 0.9 for mask inpainting).',
+        },
+        output_name: {
+          type: 'string',
+          description: 'Optional file name stem for the saved edited image.',
+        },
+        output_dir: {
+          type: 'string',
+          description: 'Optional custom directory to write edited image into.',
+        },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: true,
+          properties: {
+            summary: { type: 'string' },
+            path: { type: 'string' },
+            url: { type: 'string' },
+            width: { type: 'number' },
+            height: { type: 'number' },
+            seed: { type: 'number' },
+            provider: { type: 'string' },
+            cost: { type: 'number' },
+            format: { type: 'string' },
+            attachment: { type: 'object', additionalProperties: true },
+            visionAnalysis: { type: 'string' },
+          },
+        },
+      },
+      async execute(args, exec) {
+        const source = await resolveConversationImage(ctx, exec, args.image)
+        const mask = args.mask ? await resolveSource(ctx, exec, args.mask) : undefined
+        const vision = await analyzeImageWithVision(ctx, exec, source)
+
+        let effectivePrompt = args.prompt
+        if (vision.available && vision.summary) {
+          effectivePrompt = `${args.prompt} (Context: modifying ${vision.summary})`
+        }
+
+        const provider = cfg.provider || 'fal'
+        const deps = {
+          fetchImpl: ctx.http ? (url, opt) => ctx.http(url, opt) : fetch,
+          resolveKey: (ref) => resolveApiKey(ctx, ref),
+          cfg,
+        }
+
+        const seed = Math.floor(Math.random() * 100000)
+        const strength = args.strength ?? (mask ? 0.85 : 0.65)
+        const format = cfg.defaultFormat || 'png'
+        const size = cfg.defaultSize || 'square_hd'
+
+        const job = {
+          prompt: effectivePrompt,
+          size,
+          format,
+          seed,
+          source,
+          mask,
+          strength,
+          provider,
+        }
+
+        const providers = makeProviders(deps, job)
+        const fn = providers[provider] || providers.fal || providers.custom
+        const gen = await fn(seed, effectivePrompt)
+
+        const stem = args.output_name ? slugify(args.output_name) : `${source.name}-edit-${seed}`
+        const name = `${stem}.${format}`
+
+        const result = await saveAndAttachResult(ctx, exec, cfg, {
+          bytes: gen.bytes,
+          mediaType: gen.mediaType || 'image/png',
+          name,
+          stem,
+          prompt: args.prompt,
+          size,
+          format,
+          seed: gen.seed ?? seed,
+          provider,
+          model: cfg.model,
+          cost: gen.cost,
+          sourceUrl: gen.sourceUrl,
+          deliverAs: cfg.deliverAs || 'both',
+          args,
+          action: 'edited',
+        })
+
+        if (vision.summary) {
+          result.visionAnalysis = vision.summary
         }
+        return toLosslessJson(result)
+      },
+    }),
+  )
+
+  // Генерация вариаций существующего изображения (#143, #144, #145, #150).
+  ctx.tools.register(
+    defineTool({
+      name: 'vary_image',
+      description:
+        'Generate subtle or creative variations of an existing image while preserving overall composition and structure. '
+        + 'Pass variation_strength between 0.1 (subtle difference) and 0.9 (strong reinterpretation, default 0.35). '
+        + 'If image is omitted or "latest", automatically resolves the most recent image from the conversation session (#144). '
+        + 'Returns safe dual-output for text-only LLMs (#150).',
+      parameters: {
+        image: {
+          type: 'string',
+          description: 'Path or attachment id of the source image. Defaults to "latest" to auto-resolve from session history.',
+        },
+        prompt: {
+          type: 'string',
+          description: 'Optional prompt to steer the variation towards a specific mood, lighting, or style.',
+        },
+        variation_strength: {
+          type: 'number',
+          description: 'Strength of variation between 0.1 and 0.9. Default: 0.35.',
+        },
+        count: {
+          type: 'integer',
+          description: 'Number of variations to produce (1-4, default 1).',
+        },
+        output_name: {
+          type: 'string',
+          description: 'Optional file name stem for the saved variations.',
+        },
+        output_dir: {
+          type: 'string',
+          description: 'Optional custom directory to write variations into.',
+        },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: true,
+          properties: {
+            summary: { type: 'string' },
+            path: { type: 'string' },
+            url: { type: 'string' },
+            width: { type: 'number' },
+            height: { type: 'number' },
+            seed: { type: 'number' },
+            provider: { type: 'string' },
+            cost: { type: 'number' },
+            format: { type: 'string' },
+            attachment: { type: 'object', additionalProperties: true },
+            variations: { type: 'array', items: { type: 'object', additionalProperties: true } },
+          },
+        },
+      },
+      async execute(args, exec) {
+        const source = await resolveConversationImage(ctx, exec, args.image)
+        const vision = await analyzeImageWithVision(ctx, exec, source)
+
+        const provider = cfg.provider || 'fal'
+        const deps = {
+          fetchImpl: ctx.http ? (url, opt) => ctx.http(url, opt) : fetch,
+          resolveKey: (ref) => resolveApiKey(ctx, ref),
+          cfg,
+        }
+
+        const count = normalizeCount(args.count || 1)
+        const variationStrength = Math.max(0.05, Math.min(0.95, args.variation_strength ?? 0.35))
+        const baseSeed = Math.floor(Math.random() * 100000)
+        const format = cfg.defaultFormat || 'png'
+        const size = cfg.defaultSize || 'square_hd'
+
+        const promptText = args.prompt || (vision.available ? `variation of ${vision.summary}` : 'high fidelity variation preserving composition')
+
+        const results = []
+        for (let i = 0; i < count; i++) {
+          const currentSeed = baseSeed + i
+          const job = {
+            prompt: promptText,
+            size,
+            format,
+            seed: currentSeed,
+            source,
+            strength: variationStrength,
+            provider,
+          }
+
+          const providers = makeProviders(deps, job)
+          const fn = providers[provider] || providers.fal || providers.custom
+          const gen = await fn(currentSeed, promptText)
+
+          const stem = args.output_name
+            ? `${slugify(args.output_name)}-var-${i + 1}`
+            : `${source.name}-var-${currentSeed}`
+          const name = `${stem}.${format}`
+
+          const item = await saveAndAttachResult(ctx, exec, cfg, {
+            bytes: gen.bytes,
+            mediaType: gen.mediaType || 'image/png',
+            name,
+            stem,
+            prompt: promptText,
+            size,
+            format,
+            seed: gen.seed ?? currentSeed,
+            provider,
+            model: cfg.model,
+            cost: gen.cost,
+            sourceUrl: gen.sourceUrl,
+            deliverAs: cfg.deliverAs || 'both',
+            args,
+            action: `variation (${variationStrength})`,
+          })
+          results.push(item)
+        }
+
+        const first = results[0]
+        return toLosslessJson({
+          ...first,
+          variations: results.map((r) => ({ path: r.path, attachmentId: r.attachment?.attachmentId, seed: r.seed })),
+        })
       },
     }),
   )
@@ -1215,6 +1577,205 @@ export function apply(ctx, config) {
       },
     }),
     )
+
+  // #172: Генератор дизайн-токенов и CSS/Tailwind палитры по концепту
+  ctx.tools.register(
+    defineTool({
+      name: 'extract_design_tokens',
+      description: 'Extract design tokens (CSS variables, Tailwind colors config, W3C tokens JSON) from an image or palette.',
+      parameters: {
+        image: { type: 'string', description: 'Path or attachment ID of the image to extract colors from.' },
+        colors: { type: 'array', items: { type: 'string' }, description: 'Optional list of hex colors if already known.' },
+        prefix: { type: 'string', description: 'Token naming prefix (default: color).' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: true,
+          properties: {
+            tokens: { type: 'object', additionalProperties: true },
+            cssVariables: { type: 'string' },
+            tailwindSnippet: { type: 'string' },
+            w3cTokens: { type: 'object', additionalProperties: true },
+          },
+        },
+      },
+      async execute(args, exec) {
+        let colors = args.colors
+        if (!colors || colors.length === 0) {
+          if (args.image) {
+            const source = await resolveSource(ctx, exec, args.image)
+            if (source && source.bytes) {
+              colors = extractSampleColorsFromBuffer(source.bytes)
+            }
+          }
+        }
+        return extractDesignTokens(colors, { prefix: args.prefix })
+      },
+    }),
+  )
+
+  // #174: Конвертер фоновых изображений в легковесные CSS Mesh Gradients
+  ctx.tools.register(
+    defineTool({
+      name: 'image_to_css_gradient',
+      description: 'Convert an image background or color palette into a lightweight pure CSS gradient (< 1KB).',
+      parameters: {
+        image: { type: 'string', description: 'Path or attachment ID of the image.' },
+        colors: { type: 'array', items: { type: 'string' }, description: 'Optional explicit hex colors for the gradient.' },
+        type: { type: 'string', enum: ['mesh', 'linear', 'radial'], description: 'Gradient type: mesh, linear, or radial (default: mesh).' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: true,
+          properties: {
+            type: { type: 'string' },
+            fallbackColor: { type: 'string' },
+            gradientCss: { type: 'string' },
+            completeStyle: { type: 'string' },
+            byteSize: { type: 'number' },
+          },
+        },
+      },
+      async execute(args, exec) {
+        let colors = args.colors
+        if (!colors || colors.length === 0) {
+          if (args.image) {
+            const source = await resolveSource(ctx, exec, args.image)
+            if (source && source.bytes) {
+              colors = extractSampleColorsFromBuffer(source.bytes)
+            }
+          }
+        }
+        return generateCssGradient(colors, args.type || 'mesh')
+      },
+    }),
+  )
+
+  // #175: Проверка контрастности фона под текст по WCAG 2.1
+  ctx.tools.register(
+    defineTool({
+      name: 'check_image_contrast',
+      description: 'Check image background contrast ratio against text color according to WCAG 2.1 AA/AAA standards and suggest scrim.',
+      parameters: {
+        image: { type: 'string', description: 'Path or attachment ID of the image.' },
+        colors: { type: 'array', items: { type: 'string' }, description: 'Optional list of background hex colors.' },
+        text_color: { type: 'string', description: 'Text hex color to test against (default: #ffffff).' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: true,
+          properties: {
+            textHex: { type: 'string' },
+            minContrastRatio: { type: 'number' },
+            passedAA: { type: 'boolean' },
+            passedAALarge: { type: 'boolean' },
+            passedAAA: { type: 'boolean' },
+            recommendation: { type: 'string' },
+            suggestedScrimCss: { type: 'string' },
+            details: { type: 'array', items: { type: 'object', additionalProperties: true } },
+          },
+        },
+      },
+      async execute(args, exec) {
+        let colors = args.colors
+        if (!colors || colors.length === 0) {
+          if (args.image) {
+            const source = await resolveSource(ctx, exec, args.image)
+            if (source && source.bytes) {
+              colors = extractSampleColorsFromBuffer(source.bytes)
+            }
+          }
+        }
+        return checkWcagContrast(colors, args.text_color || '#ffffff')
+      },
+    }),
+  )
+
+  // #176: Интеллектуальная постобработка, очистка и оптимизация SVG
+  ctx.tools.register(
+    defineTool({
+      name: 'optimize_vector_svg',
+      description: 'Clean, sanitize, and minify SVG content, normalize viewBox, and export React TSX component.',
+      parameters: {
+        svg_content: { type: 'string', description: 'Raw SVG markup string to optimize.' },
+        image: { type: 'string', description: 'Path or attachment ID of an SVG file if not passing raw string.' },
+        component_name: { type: 'string', description: 'React component name for TSX export (default: VectorIcon).' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: true,
+          properties: {
+            svg: { type: 'string' },
+            viewBox: { type: 'string' },
+            originalSize: { type: 'number' },
+            optimizedSize: { type: 'number' },
+            savedBytes: { type: 'number' },
+            reductionPercent: { type: 'number' },
+            reactTsx: { type: 'string' },
+          },
+        },
+      },
+      async execute(args, exec) {
+        let svgStr = args.svg_content
+        if (!svgStr && args.image) {
+          const source = await resolveSource(ctx, exec, args.image)
+          if (source && source.bytes) {
+            svgStr = source.bytes.toString('utf8')
+          }
+        }
+        if (!svgStr) {
+          throw new Error('Either svg_content or image must be provided')
+        }
+        return optimizeSvgContent(svgStr, { componentName: args.component_name })
+      },
+    }),
+  )
+
+  // #190: Генератор полного комплекта фавиконок, иконок приложений и PWA-манифеста
+  ctx.tools.register(
+    defineTool({
+      name: 'generate_pwa_icon_suite',
+      description: 'Generate standard PWA icons specification, HTML meta tags, and web app manifest.json.',
+      parameters: {
+        image: { type: 'string', description: 'Source icon image path or attachment ID.' },
+        name: { type: 'string', description: 'App name (e.g. My Application).' },
+        short_name: { type: 'string', description: 'App short name (e.g. MyApp).' },
+        theme_color: { type: 'string', description: 'Theme color hex (e.g. #0f172a).' },
+        background_color: { type: 'string', description: 'Background color hex (e.g. #ffffff).' },
+        icons_dir: { type: 'string', description: 'Directory for icons relative to webroot (default: icons).' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: true,
+          properties: {
+            name: { type: 'string' },
+            shortName: { type: 'string' },
+            themeColor: { type: 'string' },
+            backgroundColor: { type: 'string' },
+            icons: { type: 'array', items: { type: 'object', additionalProperties: true } },
+            manifestJson: { type: 'string' },
+            htmlHeadSnippet: { type: 'string' },
+          },
+        },
+      },
+      async execute(args, exec) {
+        return generatePwaIconSuite({
+          name: args.name || 'App',
+          shortName: args.short_name || args.name || 'App',
+          themeColor: args.theme_color || '#0f172a',
+          backgroundColor: args.background_color || '#ffffff',
+          iconsDir: args.icons_dir || 'icons',
+          sourcePath: args.image || null,
+        })
+      },
+    }),
+  )
+
   })
 
 }