dsh-artcraft-plugin-lightcraft 0.2.8 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-artcraft-plugin-lightcraft",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "private": false,
   "type": "module",
   "description": "DSH plugin: drive LightCraft (photo library and raw development) headlessly through its own CLI and MCP server.",

package/src/kit/preview.js

@@ -10,7 +10,8 @@
  * @module @dsh-artcraft/craft-kit/preview
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { basename, dirname, join } from 'node:path'
 import { runCraft } from './exec.js'
@@ -32,19 +33,19 @@ export function previewRoot(configured         )         {
  * picture (SoundCraft has no page, and the MCP-only crafts need their server).
  */
                          
-                                                        
-                                                                                
+                                                                                     
+                                                                                               
  
 
 /** Per-craft render recipes, verified against the 2026-11 CLI releases. */
 const RECIPES                                = {
   // `render FILE OUT [--page N] [--scale S]` draws a page as a PNG.
-  wordcraft: { argv: (file, out, scale) => ['render', file, out, '--page', '1', '--scale', String(scale)] },
+  wordcraft: { argv: (file, out, scale, index) => ['render', file, out, '--page', String(index + 1), '--scale', String(scale)] },
   // `convert` picks the format from the output extension.
   cadcraft: { argv: (file, out) => ['convert', file, out] },
   figcraft: { argv: (file, out) => ['convert', file, out] },
   // `render FILE [--slide N] [--scale S] OUT` draws one slide as a PNG.
-  deckcraft: { argv: (file, out, scale) => ['render', file, '--slide', '0', '--scale', String(scale), out] },
+  deckcraft: { argv: (file, out, scale, index) => ['render', file, '--slide', String(index), '--scale', String(scale), out] },
   // VectorCraft exports the active artboard through `run --export`.
   vectorcraft: { argv: (file, out) => ['run', file, '--export', out] },
   // TextureCraft renders the viewport (2D view; the 3D one needs a GPU).
@@ -73,6 +74,10 @@ export function canPreview(profile              )          {
                          
                          
                           
+                                                                                      
+                        
+                                                 
+                        
                               
                                                                                    
  
@@ -103,6 +108,35 @@ export function canPreview(profile              )          {
                                         
  
 
+/**
+ * How many pages or slides a document has, for the crafts that can report it.
+ * @param profile - the craft.
+ * @param binary - its binary.
+ * @param file - the document.
+ * @returns the count, or 1 when unknown (rendering the first page is always safe).
+ */
+export async function pageCount(profile              , binary             , file        , timeoutMs = 30_000)                  {
+  if (profile.id !== 'wordcraft' && profile.id !== 'deckcraft') return 1
+  try {
+    const result = await runCraft({ profile, binary, argv: ['info', file], cwd: process.cwd(), timeoutMs })
+    if (!result.ok) return 1
+    const parsed = JSON.parse(result.stdout)                                       
+    const count = profile.id === 'wordcraft' ? parsed.pages : parsed.slides
+    return typeof count === 'number' && count > 0 ? count : 1
+  } catch {
+    return 1
+  }
+}
+
+/** Content hash of a rendered image, so an unchanged page is not a new step. */
+export function imageHash(path        )                     {
+  try {
+    return createHash('sha256').update(readFileSync(path)).digest('hex')
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * Render one document to `<dir>/<craft>/step-NNN.png`.
  *
@@ -116,16 +150,18 @@ export function canPreview(profile              )          {
 export async function renderPreview(
   profile              ,
   binary             ,
-  options                                                                                                                             ,
-)                              {
+  options                                                                                                                                                     ,
+)                                                      {
   const recipe = RECIPES[profile.id]
   if (recipe === undefined) return undefined
   if (!existsSync(options.file)) return undefined
   try {
     mkdirSync(options.dir, { recursive: true })
-    const argv = recipe.argv(options.file, options.out, options.scale ?? 1.5)
+    const argv = recipe.argv(options.file, options.out, options.scale ?? 1.5, options.page ?? 0)
     const result = await runCraft({ profile, binary, argv, cwd: process.cwd(), timeoutMs: options.timeoutMs ?? 60_000 })
-    return result.ok && existsSync(options.out) ? options.out : undefined
+    if (!result.ok || !existsSync(options.out)) return undefined
+    const hash = imageHash(options.out)
+    return hash === undefined ? undefined : { path: options.out, hash }
   } catch {
     return undefined
   }
@@ -150,6 +186,37 @@ export function nextStepNumber(root        , craft        )         {
   }
 }
 
+/**
+ * Remove a render that matched the previous step's image.
+ * @param path - the rendered file.
+ * @returns nothing; a missing file is not an error.
+ */
+export function discardRender(path        )       {
+  try {
+    unlinkSync(path)
+  } catch {
+    // Already gone.
+  }
+}
+
+/**
+ * The hash of the last rendered step, for skipping a render that repeats it.
+ * @param root - preview root.
+ * @param craft - craft id.
+ * @returns the hash, or `undefined` when there is no earlier render.
+ */
+export function lastStepHash(root        , craft        )                     {
+  try {
+    const state = JSON.parse(readFileSync(join(root, craft, 'state.json'), 'utf8'))                
+    const last = state.steps[state.steps.length - 1]
+    if (last === undefined) return undefined
+    if (last.hash !== undefined) return last.hash
+    return last.image === undefined ? undefined : imageHash(join(root, craft, last.image))
+  } catch {
+    return undefined
+  }
+}
+
 /** Read-modify-write one craft's state and refresh the index. */
 export function recordPreview(
   root        ,

package/src/kit/suite.js

@@ -0,0 +1,80 @@
+/**
+ * The ArtCraft suite graph: which applications work together.
+ *
+ * A user who installs one craft has a working tool, not the best version of the
+ * workflow they are about to attempt: a report wants a spreadsheet and a word
+ * processor, a video wants slides and a mixer. This is the one place that
+ * knowledge lives, so the installer, the doctor and the plugins agree.
+ * @module @dsh-artcraft/craft-kit/suite
+ */
+
+/** A workflow that spans several crafts. */
+                                
+                     
+                           
+                                    
+ 
+
+/** A package that is not a craft but completes the experience. */
+                                 
+                     
+                          
+                      
+ 
+
+/** Workflows that need more than one craft. */
+export const SUITE_WORKFLOWS                           = [
+  { id: 'report', delivers: 'a data-backed report as DOCX and PDF', crafts: ['gridcraft', 'wordcraft', 'pdfcraft'] },
+  { id: 'deck', delivers: 'a presentation with native charts', crafts: ['gridcraft', 'deckcraft', 'pdfcraft'] },
+  { id: 'explainer-video', delivers: 'a narrated video from slides', crafts: ['deckcraft', 'filmcraft', 'soundcraft'] },
+  { id: 'motion', delivers: 'a motion-graphics piece cut with the video', crafts: ['effectcraft', 'filmcraft'] },
+  { id: 'brand-kit', delivers: 'a design system turned into a brand book', crafts: ['figcraft', 'vectorcraft', 'designcraft'] },
+  { id: 'photo-pipeline', delivers: 'raw files developed and retouched for web and print', crafts: ['lightcraft', 'photocraft'] },
+  { id: 'print-layout', delivers: 'a print-ready layout with images and graphics', crafts: ['photocraft', 'vectorcraft', 'designcraft'] },
+  { id: 'cad-set', delivers: 'a drawing set delivered as one PDF', crafts: ['cadcraft', 'pdfcraft'] },
+  { id: 'texture-kit', delivers: 'PBR maps baked and packed for a 3D asset', crafts: ['texturecraft', 'photocraft'] },
+]
+
+/** Packages that improve every craft. */
+export const SUITE_COMPANIONS                            = [
+  {
+    id: 'preview-panel',
+    package: 'dsh-artcraft-preview-panel',
+    why: 'shows each step of the document inside the DSH Web GUI, and starts the local preview server',
+  },
+  {
+    id: 'skills',
+    package: 'dsh-artcraft-skills',
+    why: 'the workflows themselves (report, brand kit, explainer video, drawing set, conversion) as agent skills',
+  },
+]
+
+/**
+ * Missing crafts of the workflows a user has already started.
+ * @param installed - craft ids currently installed.
+ * @returns one entry per missing craft, best-completing workflow first.
+ */
+export function suggestCrafts(installed                   )                                                                                         {
+  const have = new Set(installed)
+  const missing = new Map                                                                                              ()
+  for (const workflow of SUITE_WORKFLOWS) {
+    const present = workflow.crafts.filter(craft => have.has(craft))
+    if (present.length === 0 || present.length === workflow.crafts.length) continue
+    for (const craft of workflow.crafts) {
+      if (have.has(craft)) continue
+      const existing = missing.get(craft)
+      const candidate = { craft, forWorkflow: workflow.id, delivers: workflow.delivers, has: present.length, needs: workflow.crafts.length }
+      if (existing === undefined || candidate.has / candidate.needs > existing.has / existing.needs) missing.set(craft, candidate)
+    }
+  }
+  return [...missing.values()].sort((a, b) => b.has / b.needs - a.has / a.needs || a.craft.localeCompare(b.craft))
+}
+
+/**
+ * The workflows one craft takes part in.
+ * @param craft - craft id.
+ * @returns the workflows containing it.
+ */
+export function workflowsOf(craft        )                  {
+  return SUITE_WORKFLOWS.filter(workflow => workflow.crafts.includes(craft))
+}

package/src/kit/tools.js

@@ -9,7 +9,8 @@
  */
 
 import { craftCallView, craftResultView } from './present.js'
-import { canPreview, nextStepNumber, previewRoot, recordPreview, renderPreview, stepName } from './preview.js'
+import { canPreview, discardRender, lastStepHash, nextStepNumber, pageCount, previewRoot, recordPreview, renderPreview, stepName } from './preview.js'
+import { workflowsOf } from './suite.js'
 import { appendJournal } from './journal.js'
 import { CraftMcpClient, renderSchema } from './mcp.js'
                                        
@@ -178,18 +179,38 @@ export function createRuntime(profile              , packageRoot        , config
       const dir = join(previewDir, profile.id)
       const out = join(dir, stepName(n))
       const scale = options.scale ?? config.previewScale ?? 1.5
-      const rendered = await renderPreview(profile, binary, { file: options.file, dir, out, scale })
-      const relative = rendered === undefined ? undefined : stepName(n)
+      const previous = lastStepHash(previewDir, profile.id)
+
+      // Render the first page, and when it did not change look at the last page:
+      // appending a slide or typing on page 2 leaves page 1 identical, and a wall
+      // of identical thumbnails is worse than no step at all.
+      let rendered = await renderPreview(profile, binary, { file: options.file, dir, out, scale, page: 0 })
+      let pages = 1
+      if (rendered !== undefined && previous !== undefined && rendered.hash === previous) {
+        pages = await pageCount(profile, binary, options.file)
+        rendered = pages > 1
+          ? await renderPreview(profile, binary, { file: options.file, dir, out, scale, page: pages - 1 })
+          : undefined
+        if (rendered !== undefined && rendered.hash === previous) rendered = undefined
+      }
+      if (rendered === undefined) {
+        // Nothing visible changed; keep the step list meaningful by not adding one.
+        discardRender(out)
+        return undefined
+      }
       recordPreview(previewDir, profile, {
         n,
         at: new Date().toISOString(),
         tool: options.tool,
         title: options.title,
         summary: options.summary,
-        ...relative === undefined ? {} : { image: relative, thumb: relative },
+        image: stepName(n),
+        thumb: stepName(n),
+        hash: rendered.hash,
+        page: pages,
         ...options.durationMs === undefined ? {} : { durationMs: options.durationMs },
-      }, options.file, 1)
-      return rendered
+      }, options.file, pages)
+      return rendered.path
     },
     startJob(binary, argv) {
       jobCounter += 1
@@ -1157,7 +1178,14 @@ export function applyCraftPlugin(
       + (profile.mcpAttach === undefined
         ? ''
         : `When the user has ${profile.product} open, pass \`attach: <control port>\` to an mcp call to work in their window instead of a headless copy. `)
-      + `Images returned by a render or screenshot are saved and named by path; look at them with \`read_image\`.`,
+      + `Images returned by a render or screenshot are saved and named by path; look at them with \`read_image\`.`
+      + (() => {
+        const partners = [...new Set(workflowsOf(profile.id).flatMap(workflow => workflow.crafts).filter(craft => craft !== profile.id))]
+        if (partners.length === 0) return ''
+        // A half-installed workflow is the common gap: name the partners so the
+        // agent can offer the missing plugin instead of failing at the join.
+        return ` Workflows that start in ${profile.product} usually also need ${partners.join(', ')}: if one of those tools is unavailable, say which plugin provides it and offer to install it.`
+      })(),
     order: CRAFT_SECTION_ORDER,
   })
   return () => {