dsh-artcraft-plugin-soundcraft 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-artcraft-plugin-soundcraft",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "description": "DSH plugin: drive SoundCraft (audio production) headlessly through its own CLI and MCP server.",
@@ -43,4 +43,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/kit/catalog.js

@@ -92,9 +92,44 @@ export function parseCatalog(stdout        , json         )                 {
       // Fall through to the table parser: a CLI may ignore an unknown --json.
     }
   }
+  const emDash = parseEmDash(text)
+  if (emDash.length > 0) return emDash
   return parseTable(text)
 }
 
+/**
+ * Parse an `id — Label: {params}` catalogue (DeckCraft 0.14+).
+ *
+ * One command per line, single-spaced, with an em dash between the id and its
+ * label. `: {…}` introduces the parameter grammar and ` → …` describes what the
+ * command answers, which is not part of the grammar.
+ * @param text - raw `commands` output.
+ * @returns every command whose line has the `id — label` shape.
+ */
+export function parseEmDash(text        )                 {
+  const out                 = []
+  for (const raw of text.split('\n')) {
+    const line = raw.trimEnd()
+    if (line.length === 0 || line.startsWith('#')) continue
+    const match = /^([\w.-]+)\s+—\s+(.*)$/.exec(line)
+    if (match === null) continue
+    const id = match[1]
+    const rest = match[2]
+    const returnIndex = rest.indexOf(' → ')
+    const beforeReturn = returnIndex === -1 ? rest : rest.slice(0, returnIndex)
+    const brace = beforeReturn.indexOf(': {')
+    const label = brace === -1 ? beforeReturn.trim() : beforeReturn.slice(0, brace).trim()
+    const params = brace === -1 ? undefined : beforeReturn.slice(brace + 2).trim()
+    out.push({
+      id,
+      ...label.length > 0 ? { label } : {},
+      ...params !== undefined && params.length > 0 ? { params } : {},
+      group: groupOf(id),
+    })
+  }
+  return out
+}
+
 /**
  * Parse a craft's fixed-column `commands` table.
  *
@@ -111,7 +146,14 @@ export function parseTable(text        )                 {
   const flush = ()       => {
     if (current === undefined) return
     const { id, columns } = current
-    const rest = columns.join(' ').trim()
+    let rest = columns.join(' ').trim()
+    // Some tables end with the grammar as its own column (`{name?, color?}`),
+    // with no `params:` label; take the last column when it is only an object.
+    let columnParams
+    if (columns.length > 1 && /^\{.*\}$/.test(columns[columns.length - 1].trim())) {
+      columnParams = columns[columns.length - 1].trim()
+      rest = columns.slice(0, -1).join(' ').trim()
+    }
     const paramsMatch = /\bparams:\s*(\{.*)$/.exec(rest)
     const labelPart = paramsMatch === null ? rest : rest.slice(0, paramsMatch.index).trim()
     // Trailing `label  [Shortcut]` and an interleaved menu column.
@@ -120,7 +162,9 @@ export function parseTable(text        )                 {
     out.push({
       id,
       ...label.length > 0 ? { label } : {},
-      ...paramsMatch !== null ? { params: paramsMatch[1].replace(/\s+/g, ' ').trim() } : {},
+      ...columnParams !== undefined
+        ? { params: columnParams.replace(/\s+/g, ' ') }
+        : paramsMatch !== null ? { params: paramsMatch[1].replace(/\s+/g, ' ').trim() } : {},
       ...shortcutMatch !== null ? { shortcut: shortcutMatch[1] } : {},
       group: groupOf(id),
     })
@@ -136,7 +180,8 @@ export function parseTable(text        )                 {
     }
     flush()
     const columns = raw.trimEnd().split(/\s{2,}/).map(part => part.trim()).filter(part => part.length > 0)
-    const id = columns[0] ?? ''
+    // Rust CLIs mark undoable commands with a trailing `*`; it is not the id.
+    const id = (columns[0] ?? '').replace(/\*$/, '')
     if (id.length === 0 || /\s/.test(id) || !/^[\w.-]+$/.test(id)) continue
     current = { id, columns: columns.slice(1) }
   }

package/src/kit/profiles.mjs

@@ -359,6 +359,63 @@ export const CRAFT_PROFILES = [
     catalogArgs: ['commands'],
     mcpArgs: ['mcp'],
   },
+  {
+    id: 'figcraft',
+    product: 'FigCraft',
+    bin: 'figcraft-cli',
+    envVar: 'FIGCRAFT_CLI',
+    searchDirs: [CRAFTS_BIN_DIR],
+    extensions: ['.figcraft', '.penpot', '.fig', '.sketch', '.svg'],
+    blurb: 'Interface design and prototyping (Figma-style): frames, components, auto layout, variables, prototyping and code export.',
+    run: {
+      verb: 'run',
+      inputMode: 'flag',
+      inFlag: '--in',
+      sampleFlag: '',
+      cmdFlag: '',
+      cmdSeparator: ' ',
+      // `run script.json` takes a generated script, one step per command.
+      scriptFile: { encoding: 'json-array', commandKey: 'command', paramsKey: 'params', inputFlag: '--in', saveFlag: '--out' },
+      saveFlag: '--out',
+    },
+    reads: [
+      { name: 'inspect', verb: 'info', summary: 'Summarize a design file: pages, node counts, top-level frames, style and variable counts.' },
+      { name: 'convert', verb: 'convert', summary: 'Convert a design file between .figcraft, .json, .svg, .png, .pdf and more.' },
+    ],
+    catalogJson: true,
+    catalogArgs: ['commands', '--json'],
+    mcpArgs: ['mcp'],
+  },
+  {
+    id: 'texturecraft',
+    product: 'TextureCraft',
+    bin: 'texturecraft-cli',
+    envVar: 'TEXTURECRAFT_CLI',
+    searchDirs: [CRAFTS_BIN_DIR],
+    extensions: ['.tcraft'],
+    blurb: '3D texture painting: texture sets and layers over a mesh, baking, material channels and PBR export.',
+    run: {
+      verb: 'batch',
+      inputMode: 'flag',
+      inFlag: '',
+      sampleFlag: '',
+      cmdFlag: '',
+      cmdSeparator: ' ',
+      // `batch script.json` carries `{ open, steps, save }` in one file.
+      scriptFile: { encoding: 'json-array', commandKey: 'id', paramsKey: 'params', batch: { openKey: 'open', stepsKey: 'steps', saveKey: 'save' } },
+      saveMode: 'script',
+      saveFlag: '',
+      // A project is required before any command, so a bare run makes one.
+      sampleCreate: { verb: 'new', args: ['builtin:crate'], extension: '.tcraft' },
+    },
+    reads: [
+      { name: 'inspect', verb: 'info', summary: 'Summarize a texture project: texture sets, layers, triangles, materials and the UV report.' },
+      { name: 'convert', verb: 'export', summary: 'Export textures from a project: presets, formats, padding and size.' },
+    ],
+    catalogJson: false,
+    catalogArgs: ['commands'],
+    mcpArgs: ['mcp'],
+  },
 ]
 
 /** Profile lookup by craft id. */

package/src/kit/tools.js

@@ -39,6 +39,9 @@ function resolveSample(profile              , args                         )
   const requested = args.sample
   if (typeof requested === 'string' && requested.length > 0) return requested
   if (requested === true) {
+    // A craft that starts a new document by default, or creates one itself,
+    // has nothing to select; asking for the sample is a harmless no-op.
+    if (profile.run.sampleFlag.length === 0 && (profile.run.sampleCreate !== undefined || profile.run.scriptFile !== undefined)) return undefined
     if (profile.run.sampleFlag.length === 0) {
       throw new Error(
         `${profile.product} has no "new document" flag: pass \`input\` to open an existing document, `
@@ -361,7 +364,7 @@ export function createToolSet(runtime              )               {
         description: 'Ordered commands to apply. Each is { "id": "cell.set", "json": { "cell": "A1", "input": "x" } }. An entry may also be a raw CLI string.',
         items: { type: 'json' },
       },
-      ...(profile.run.saveMode ?? 'flag') === 'flag'
+      ...(profile.run.saveMode ?? 'flag') !== 'none'
         ? { save: { type: 'string', description: `Path to write the edited document to (${profile.extensions.join('/')}).` } }
         : {},
       // `export` is always advertised when the craft can render one. Where the
@@ -410,6 +413,48 @@ export function createToolSet(runtime              )               {
       // Crafts whose headless entry point only accepts a script file get one
       // written for this call; the file names the same commands the inline
       // style would have carried.
+      // Crafts whose headless verb takes a generated script file instead of
+      // inline command flags: FigCraft's `run script.json` and TextureCraft's
+      // `batch script.json`. The kernel writes it, so the model still supplies
+      // an ordered list and never has to know the file format.
+      if (profile.run.scriptFile !== undefined) {
+        const spec = profile.run.scriptFile
+        const savePath = typeof args.save === 'string' ? args.save : undefined
+        let effectiveInput = input
+        if (effectiveInput === undefined && profile.run.sampleCreate !== undefined) {
+          const created = join(craftWorkDir(profile), `sample-${Date.now()}${profile.run.sampleCreate.extension}`)
+          mkdirSync(dirname(created), { recursive: true })
+          const createdResult = await runCraft({
+            profile, binary,
+            argv: [profile.run.sampleCreate.verb, ...profile.run.sampleCreate.args, created],
+            cwd: process.cwd(), timeoutMs,
+          })
+          if (!createdResult.ok) return renderRun(createdResult, profile)
+          effectiveInput = created
+        }
+        const steps = commands.map(command => ({ [spec.commandKey]: command.id, [spec.paramsKey]: command.json ?? {} }))
+        const scriptPath = join(craftWorkDir(profile), `run-${Date.now()}.${spec.encoding === 'jsonl' ? 'jsonl' : 'json'}`)
+        mkdirSync(dirname(scriptPath), { recursive: true })
+        const argv = [profile.run.verb]
+        let body
+        if (spec.batch !== undefined) {
+          body = {
+            ...effectiveInput !== undefined ? { [spec.batch.openKey]: effectiveInput } : {},
+            [spec.batch.stepsKey]: steps,
+            ...savePath !== undefined ? { [spec.batch.saveKey]: savePath } : {},
+          }
+          argv.push(scriptPath)
+        } else {
+          body = spec.encoding === 'jsonl' ? steps.map(step => JSON.stringify(step)).join('\n') + '\n' : steps
+          argv.push(scriptPath)
+          if (effectiveInput !== undefined && spec.inputFlag !== undefined) argv.push(spec.inputFlag, effectiveInput)
+          if (savePath !== undefined && spec.saveFlag !== undefined) argv.push(spec.saveFlag, savePath)
+        }
+        writeFileSync(scriptPath, typeof body === 'string' ? body : JSON.stringify(body, null, 2) + '\n')
+        const extra = Array.isArray(args.extraArgs) ? args.extraArgs.filter((a)              => typeof a === 'string') : []
+        const scriptResult = await runCraft({ profile, binary, argv: [...argv, ...extra], cwd: process.cwd(), timeoutMs })
+        return renderRun(scriptResult, profile)
+      }
       if (profile.run.scriptFlag !== undefined) {
         const scriptPath = join(craftWorkDir(profile), `steps-${Date.now()}.json`)
         mkdirSync(dirname(scriptPath), { recursive: true })

package/src/kit/types.js

@@ -69,7 +69,7 @@
                                                                                  
                                                                            
      
-                                     
+