@goodandready/dsh-image-gen 0.10.24 → 0.10.26

package/lib/responsive-helpers.js

@@ -0,0 +1,94 @@
+// Pure helpers for generate_responsive_mockups (#173) — no cordis imports.
+
+export const DEVICE_ORDER = ['mobile', 'tablet', 'desktop']
+
+export const DEVICE_PRESETS = {
+  mobile: {
+    id: 'mobile',
+    label: 'Mobile',
+    aspect: '9:16',
+    size: 'portrait_16_9',
+    fileStem: 'mockup-mobile',
+    viewport: 'iPhone-class mobile viewport 375×812, portrait 9:16',
+    layoutHint:
+      'Single-column mobile UI mockup: compact header, stacked content, thumb-reachable bottom actions. '
+      + 'Preserve the same product, brand colors, typography family and visual language as the desktop and tablet versions.',
+  },
+  tablet: {
+    id: 'tablet',
+    label: 'Tablet',
+    aspect: '3:4',
+    size: 'portrait_4_3',
+    fileStem: 'mockup-tablet',
+    viewport: 'iPad-class tablet viewport 768×1024, portrait 3:4',
+    layoutHint:
+      'Tablet UI mockup with two-column or wide single-column layout, roomier spacing than mobile, '
+      + 'same product screens, brand colors, and component language as mobile and desktop versions.',
+  },
+  desktop: {
+    id: 'desktop',
+    label: 'Desktop',
+    aspect: '16:9',
+    size: 'landscape_16_9',
+    fileStem: 'mockup-desktop',
+    viewport: 'desktop viewport 1440×900 / 1920×1080, landscape 16:10–16:9',
+    layoutHint:
+      'Desktop UI mockup with multi-column layout, full navigation chrome and wide content area. '
+      + 'Same product, brand palette and component language as mobile and tablet versions.',
+  },
+}
+
+export function normalizeDevices(input) {
+  if (input == null) return [...DEVICE_ORDER]
+  const list = Array.isArray(input) ? input : [input]
+  const cleaned = list
+    .map((d) => String(d || '').trim().toLowerCase())
+    .filter((d) => DEVICE_ORDER.includes(d))
+  const unique = []
+  for (const d of cleaned) {
+    if (!unique.includes(d)) unique.push(d)
+  }
+  return unique.length ? unique : [...DEVICE_ORDER]
+}
+
+export function resolveDevicePreset(device) {
+  return DEVICE_PRESETS[String(device || '').toLowerCase()] || DEVICE_PRESETS.mobile
+}
+
+/**
+ * Build a shared semantic base prompt so the three viewports stay visually coherent.
+ * Device-specific lines only restate composition constraints, not the product idea.
+ */
+export function buildResponsivePrompt(basePrompt, { device, stylePreset, paletteColors } = {}) {
+  const preset = resolveDevicePreset(device)
+  const core = String(basePrompt || '').trim()
+  const style = stylePreset ? ` Style preset: ${stylePreset}.` : ''
+  const palette = Array.isArray(paletteColors) && paletteColors.length
+    ? ` Dominant brand colors must remain consistent across all responsive mockups: ${paletteColors.join(', ')}.`
+    : ''
+  return `Responsive UI product mockup of: ${core}.${style}${palette} `
+    + `Render as a polished ${preset.viewport}. ${preset.layoutHint} `
+    + 'Keep the same information architecture, iconography language, spacing rhythm and color palette across mobile, tablet and desktop variants. '
+    + 'High-fidelity interface design, clean UI, realistic device framing only if needed, no lorem-ipsum walls of unreadable text, no watermark.'
+}
+
+export function mockupFileName(device, { outputName } = {}) {
+  const preset = resolveDevicePreset(device)
+  const stem = String(outputName || '').trim()
+    ? String(outputName).trim().replace(/\.(png|jpe?g|webp)$/i, '')
+    : preset.fileStem
+  // Issue requires mockup-mobile.png style names when default stem is used.
+  if (!outputName) return `${preset.fileStem}.png`
+  return `${stem}-${preset.id}.png`
+}
+
+export function deviceMeta(device) {
+  const preset = resolveDevicePreset(device)
+  return {
+    device: preset.id,
+    label: preset.label,
+    aspect: preset.aspect,
+    size: preset.size,
+    viewport: preset.viewport,
+  }
+}

package/lib/spritesheet-helpers.js

@@ -0,0 +1,65 @@
+// Pure helpers for generate_spritesheet (#177) — no cordis/dsh-tools imports.
+
+export const ANIMATION_PRESETS = {
+  idle: ['neutral standing pose', 'subtle breathing chest rise', 'slight weight shift', 'return to neutral'],
+  walk: ['contact pose left foot forward', 'down pose', 'passing pose', 'up pose', 'contact pose right foot forward', 'down pose', 'passing pose', 'up pose'],
+  attack: ['wind-up anticipation', 'strike extension', 'impact frame', 'recoil follow-through'],
+  pulse: ['scale 1.0 rest', 'scale 1.08 glow peak', 'scale 1.0 settle', 'scale 0.96 micro-bounce'],
+  hover: ['lift 0px', 'lift -6px', 'lift 0px', 'lift 2px press'],
+}
+
+export function clampFrames(n, animation = 'idle') {
+  const v = Number(n)
+  const anim = String(animation || 'idle').toLowerCase()
+  // walk preset has a natural 8-phase cycle; 12 would stutter at loop point
+  if (anim === 'walk') return v === 4 ? 4 : 8
+  if (v === 4 || v === 8 || v === 12) return v
+  return 8
+}
+
+export function buildSpritesheetCss({ frameCount, frameW, frameH, durationSec, name }) {
+  const anim = name || 'play'
+  const sheetW = frameW * frameCount
+  return `/* dsh-image-gen spritesheet */
+.${anim} {
+  width: ${frameW}px;
+  height: ${frameH}px;
+  background-image: url('./${anim}-sheet.svg');
+  background-repeat: no-repeat;
+  background-size: ${sheetW}px ${frameH}px;
+  animation: ${anim} ${durationSec}s steps(${frameCount}) infinite;
+}
+@keyframes ${anim} {
+  from { background-position: 0 0; }
+  to { background-position: -${sheetW}px 0; }
+}
+`
+}
+
+export function buildSpritesheetSvg(frames, { frameW, frameH }) {
+  const count = frames.length
+  const totalW = frameW * count
+  const totalH = frameH
+  let images = ''
+  frames.forEach((src, idx) => {
+    const b64 = Buffer.isBuffer(src.bytes) ? src.bytes.toString('base64') : Buffer.from(src.bytes).toString('base64')
+    const mime = src.mediaType || 'image/png'
+    const x = idx * frameW
+    images += `<image href="data:${mime};base64,${b64}" x="${x}" y="0" width="${frameW}" height="${frameH}" preserveAspectRatio="xMidYMid slice"/>`
+  })
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}">
+${images}
+</svg>`
+}
+
+export function buildFramePrompts(subject, animation, frameCount) {
+  const preset = ANIMATION_PRESETS[animation] || ANIMATION_PRESETS.idle
+  const phases = []
+  for (let i = 0; i < frameCount; i++) {
+    phases.push(preset[i % preset.length])
+  }
+  return phases.map((phase, i) =>
+    `2D game sprite frame ${i + 1} of ${frameCount}: ${subject}. Animation phase: ${phase}. `
+    + 'Transparent or solid flat background, consistent character scale and camera, same character design across frames, clean silhouette, even lighting.')
+}

package/lib/tools/editing.js

@@ -116,6 +116,7 @@ export function registerEditingTools(ctx, deps) {
         },
         async execute(args, exec) {
           try {
+            const cfg = live()
             trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
             const estimatedCostEdit = calculateGenerationCost({
               provider: cfg.provider || 'fal',
@@ -249,6 +250,7 @@ export function registerEditingTools(ctx, deps) {
         },
         async execute(args, exec) {
           try {
+            const cfg = live()
             trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
             const count = normalizeCount(args.count || 1)
             const estimatedCostVary = calculateGenerationCost({

package/lib/tools/generation-pack.js

@@ -0,0 +1,74 @@
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import { toLosslessJson } from '../providers.js'
+import { slugify } from '../index.js'
+
+export function registerGenerationPackTool(ctx, deps) {
+  const { live } = deps
+
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'generate_image_pack',
+        description: 'Generate a multi-aspect ratio pack of the same image (e.g. 1:1, 16:9, 9:16) for different platforms.',
+        parameters: {
+          prompt: { type: 'string', required: true, description: 'Text prompt for image generation.' },
+          aspect_ratios: { type: 'array', items: { type: 'string' }, description: 'Target ratios (default: ["1:1", "16:9", "9:16"]).' },
+          output_name: { type: 'string', description: 'Base file name for the pack.' },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              images: { type: 'array', items: { type: 'object', additionalProperties: true } },
+              count: { type: 'number' },
+              warnings: { type: 'array', items: { type: 'string' } },
+            },
+          },
+        },
+        async execute(args, exec) {
+          const ratios = Array.isArray(args.aspect_ratios) && args.aspect_ratios.length ? args.aspect_ratios : ['1:1', '16:9', '9:16']
+          const cfg = live()
+          const generateTool = ctx.tools.get('generate_image')
+          const results = []
+          const warnings = []
+          const seedBase = Math.floor(Math.random() * 100000)
+
+          const packTasks = ratios.map((ratio) => async () => {
+            const sizeName = ratio === '16:9' ? 'landscape_16_9' : ratio === '9:16' ? 'portrait_16_9' : ratio === '4:3' ? 'landscape_4_3' : ratio === '3:4' ? 'portrait_4_3' : 'square_hd'
+            const name = `${slugify(args.output_name || 'pack')}-${ratio.replace(':', 'x')}`
+            try {
+              const genResult = await generateTool.execute({
+                prompt: args.prompt,
+                image_size: sizeName,
+                seed: seedBase,
+                output_name: name,
+              }, exec)
+              return { success: true, ratio, genResult }
+            } catch (err) {
+              return { success: false, ratio, error: err?.message || String(err) }
+            }
+          })
+          const settledPack = await Promise.all(packTasks.map((t) => t()))
+          for (const item of settledPack) {
+            if (item.success) {
+              results.push({ ratio: item.ratio, ...item.genResult })
+            } else {
+              warnings.push(`Ratio ${item.ratio} failed: ${item.error}`)
+            }
+          }
+
+          if (results.length === 0 && warnings.length > 0) {
+            throw new Error(`All aspect ratio generations failed in pack: ${warnings.join('; ')}`)
+          }
+
+          return toLosslessJson({
+            images: results,
+            count: results.length,
+            ...(warnings.length ? { warnings } : {}),
+          })
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool generate_image_pack')
+}

package/lib/tools/generation.js

@@ -1,4 +1,5 @@
 import { polishPrompt } from '../prompt-polisher.js'
+import { registerGenerationPackTool } from './generation-pack.js'
 
 /** Run an array of async task functions with a concurrency cap */
 async function asyncPool(tasks, concurrency = 3) {
@@ -542,70 +543,5 @@ export function registerGenerationTools(ctx, deps) {
     }),
   )
   }, 'dsh-image-gen: tool generate_image')
-  ctx.effect(() => {
-    ctx.tools.register(
-      defineTool({
-        name: 'generate_image_pack',
-        description: 'Generate a multi-aspect ratio pack of the same image (e.g. 1:1, 16:9, 9:16) for different platforms.',
-        parameters: {
-          prompt: { type: 'string', required: true, description: 'Text prompt for image generation.' },
-          aspect_ratios: { type: 'array', items: { type: 'string' }, description: 'Target ratios (default: ["1:1", "16:9", "9:16"]).' },
-          output_name: { type: 'string', description: 'Base file name for the pack.' },
-        },
-        output: {
-          schema: {
-            type: 'object',
-            additionalProperties: true,
-            properties: {
-              images: { type: 'array', items: { type: 'object', additionalProperties: true } },
-              count: { type: 'number' },
-              warnings: { type: 'array', items: { type: 'string' } },
-            },
-          },
-        },
-        async execute(args, exec) {
-          const ratios = Array.isArray(args.aspect_ratios) && args.aspect_ratios.length ? args.aspect_ratios : ['1:1', '16:9', '9:16']
-          const cfg = live()
-          const generateTool = ctx.tools.get('generate_image')
-          const results = []
-          const warnings = []
-          const seedBase = Math.floor(Math.random() * 100000)
-
-          const packTasks = ratios.map((ratio) => async () => {
-            const sizeName = ratio === '16:9' ? 'landscape_16_9' : ratio === '9:16' ? 'portrait_16_9' : ratio === '4:3' ? 'landscape_4_3' : ratio === '3:4' ? 'portrait_4_3' : 'square_hd'
-            const name = `${slugify(args.output_name || 'pack')}-${ratio.replace(':', 'x')}`
-            try {
-              const genResult = await generateTool.execute({
-                prompt: args.prompt,
-                image_size: sizeName,
-                seed: seedBase,
-                output_name: name,
-              }, exec)
-              return { success: true, ratio, genResult }
-            } catch (err) {
-              return { success: false, ratio, error: err?.message || String(err) }
-            }
-          })
-          const settledPack = await Promise.all(packTasks.map((t) => t()))
-          for (const item of settledPack) {
-            if (item.success) {
-              results.push({ ratio: item.ratio, ...item.genResult })
-            } else {
-              warnings.push(`Ratio ${item.ratio} failed: ${item.error}`)
-            }
-          }
-
-          if (results.length === 0 && warnings.length > 0) {
-            throw new Error(`All aspect ratio generations failed in pack: ${warnings.join('; ')}`)
-          }
-
-          return toLosslessJson({
-            images: results,
-            count: results.length,
-            ...(warnings.length ? { warnings } : {}),
-          })
-        },
-      }),
-    )
-  }, 'dsh-image-gen: tool generate_image_pack')
+  registerGenerationPackTool(ctx, deps)
 }

package/lib/tools/pattern.js

@@ -0,0 +1,125 @@
+// pattern — generate_seamless_pattern tool (#178)
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import path from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { makeProviders, toLosslessJson, saveAttachmentSafe, sizeToPixels } from '../providers.js'
+import { trackAndAssertLoopGuard } from '../loop-guard.js'
+import { sanitizeErrorAndLogs } from '../security.js'
+import {
+  buildSeamlessPrompt,
+  buildPatternCss,
+  normalizeDensity,
+} from '../pattern-helpers.js'
+
+export function registerPatternTools(ctx, deps) {
+  const { live, slugify, resolveApiKey } = deps
+
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'generate_seamless_pattern',
+        description:
+          'Generate a seamless tileable repeating pattern for backgrounds (#178). '
+          + 'Describe the motif and optional style; returns a square pattern image plus CSS background-repeat snippet.',
+        parameters: {
+          motif: {
+            type: 'string',
+            required: true,
+            description: 'What to repeat (e.g. "terrazzo chips", "sakura blossoms", "circuit traces").',
+          },
+          style: {
+            type: 'string',
+            description: 'Visual style (e.g. "watercolor", "flat vector", "isometric").',
+          },
+          density: {
+            type: 'string',
+            description: 'Motif density: low, medium, or high (default medium).',
+          },
+          size: {
+            type: 'string',
+            description: 'Named image size (default square).',
+          },
+          output_name: {
+            type: 'string',
+            description: 'File name stem / CSS class (default seamless-pattern).',
+          },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              summary: { type: 'string' },
+              path: { type: 'string' },
+              url: { type: 'string' },
+              css: { type: 'string' },
+              cssPath: { type: 'string' },
+              format: { type: 'string' },
+              attachment: { type: 'object', additionalProperties: true },
+            },
+          },
+        },
+        async execute(args, exec) {
+          try {
+            const cfg = live()
+            trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
+            const density = normalizeDensity(args.density)
+            const prompt = buildSeamlessPrompt(args.motif, args.style, density)
+            const provider = cfg.provider || 'fal'
+            const format = cfg.defaultFormat || 'png'
+            const size = args.size || 'square'
+            const seed = Math.floor(Math.random() * 100000)
+
+            const pdeps = {
+              fetchImpl: fetch,
+              resolveKey: (ref) => resolveApiKey(ctx, ref),
+              cfg,
+            }
+            const job = { prompt, size, format, seed, provider }
+            const providers = makeProviders(pdeps, job)
+            const fn = providers[provider] || providers.fal || providers.custom
+            const gen = await fn(seed, prompt)
+
+            const stem = slugify(args.output_name || 'seamless-pattern')
+            const name = `${stem}.${format}`
+            const { attachment, localUrl } = await saveAttachmentSafe(ctx, {
+              bytes: gen.bytes,
+              mediaType: gen.mediaType || 'image/png',
+              name,
+            })
+
+            const sessionCwd = exec?.agent?.session?.header?.cwd
+            const outDir = path.resolve(sessionCwd || process.cwd(), cfg.outputDir || 'generated/images')
+            await mkdir(outDir, { recursive: true })
+            const filePath = path.join(outDir, name)
+            await writeFile(filePath, gen.bytes)
+
+            const [tilePx] = sizeToPixels(size)
+            const css = buildPatternCss({ className: stem, sizePx: tilePx, imagePath: `./${name}` })
+            const cssPath = path.join(outDir, `${stem}.css`)
+            await writeFile(cssPath, css, 'utf8')
+
+            const summary = `### Seamless pattern (${density})\n`
+              + `- **Motif**: ${args.motif}\n`
+              + `- **File**: \`${filePath}\`\n`
+              + `- **CSS**: \`${cssPath}\`\n\n`
+              + `![${stem}](${localUrl || filePath})`
+
+            return toLosslessJson({
+              summary,
+              path: filePath,
+              url: localUrl,
+              css,
+              cssPath,
+              format,
+              attachment,
+            })
+          } catch (err) {
+            throw new Error(sanitizeErrorAndLogs(err.message || err))
+          }
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool generate_seamless_pattern')
+}

package/lib/tools/processing-advanced.js

@@ -458,7 +458,13 @@ export function registerProcessingAdvancedTools(ctx, deps) {
                   const b64 = Buffer.isBuffer(src.bytes) ? src.bytes.toString('base64') : Buffer.from(src.bytes).toString('base64')
                   logoDataUri = `data:${src.mediaType || 'image/png'};base64,${b64}`
                 }
-              } catch (_) {}
+              } catch (err) {
+                // Optional logo embed: brand pack still exports without it.
+                const msg = err?.message || String(err)
+                if (typeof ctx?.logger?.debug === 'function') {
+                  ctx.logger.debug(`dsh-image-gen: brand logo embed skipped: ${msg}`)
+                }
+              }
             }
 
             const exportedFiles = []