@uzooai/anime-ai-cli 0.0.0-stage → 0.6.0

package/src/group-membership.js

@@ -0,0 +1,125 @@
+// Frontend membership semantics; no runtime frontend dependency.
+const DEFAULT_NODE_WIDTH = 200
+const DEFAULT_NODE_HEIGHT = 100
+
+function readNodeSize(node) {
+  const width = Number(node?.computedWidth) || Number(node?.width)
+  const height = Number(node?.computedHeight) || Number(node?.height)
+  return {
+    width: Number.isFinite(width) && width > 0 ? width : DEFAULT_NODE_WIDTH,
+    height: Number.isFinite(height) && height > 0 ? height : DEFAULT_NODE_HEIGHT,
+  }
+}
+
+export function getNodeGroupBox(node) {
+  const position = node?.position || { x: 0, y: 0 }
+  const size = readNodeSize(node)
+  return {
+    x: Number(position.x) || 0,
+    y: Number(position.y) || 0,
+    width: size.width,
+    height: size.height,
+  }
+}
+
+export function normalizeGroupBox(group) {
+  const position = group?.position || {}
+  const size = group?.size || {}
+  return {
+    x: Number(position.x) || 0,
+    y: Number(position.y) || 0,
+    width: Math.max(Number(size.width) || 0, 0),
+    height: Math.max(Number(size.height) || 0, 0),
+  }
+}
+
+/**
+ * 节点中心点是否落在组框内。
+ */
+export function isNodeInsideGroup(node, group) {
+  const box = normalizeGroupBox(group)
+  if (box.width <= 0 || box.height <= 0) return false
+
+  const nodeBox = getNodeGroupBox(node)
+  const centerX = nodeBox.x + nodeBox.width / 2
+  const centerY = nodeBox.y + nodeBox.height / 2
+  return (
+    centerX >= box.x &&
+    centerX <= box.x + box.width &&
+    centerY >= box.y &&
+    centerY <= box.y + box.height
+  )
+}
+
+export function syncGroupMemberships(state) {
+  if (!state || !Array.isArray(state.groups) || !Array.isArray(state.nodes)) return false
+
+  const existingNodeIds = new Set(state.nodes.map((node) => String(node?.id || '')).filter(Boolean))
+  const claimedNodeIds = new Set()
+  let changed = false
+
+  for (const group of state.groups) {
+    const activeIds = (Array.isArray(group.nodeIds) ? group.nodeIds : [])
+      .map((id) => String(id || ''))
+      .filter(Boolean)
+    const exitedIds = (Array.isArray(group.exitedNodeIds) ? group.exitedNodeIds : [])
+      .map((id) => String(id || ''))
+      .filter(Boolean)
+    const aliveIds = new Set([...activeIds, ...exitedIds].filter((id) => existingNodeIds.has(id)))
+
+    const nextActive = []
+    const nextExited = []
+
+    for (const id of activeIds) {
+      if (!aliveIds.has(id) || claimedNodeIds.has(id)) {
+        changed = true
+        continue
+      }
+      const node = state.nodes.find((item) => String(item?.id || '') === id)
+      if (isNodeInsideGroup(node, group)) {
+        nextActive.push(id)
+        claimedNodeIds.add(id)
+      } else {
+        nextExited.push(id)
+        changed = true
+      }
+    }
+
+    for (const id of exitedIds) {
+      if (!aliveIds.has(id) || claimedNodeIds.has(id)) {
+        changed = true
+        continue
+      }
+      const node = state.nodes.find((item) => String(item?.id || '') === id)
+      if (isNodeInsideGroup(node, group)) {
+        nextActive.push(id)
+        claimedNodeIds.add(id)
+        changed = true
+      } else {
+        nextExited.push(id)
+      }
+    }
+
+    const finalActive = [...new Set(nextActive)]
+    const finalExited = [...new Set(nextExited)]
+    const currentActive = [...new Set(activeIds)]
+    const currentExited = [...new Set(exitedIds)]
+    const activeChanged =
+      currentActive.length !== finalActive.length ||
+      currentActive.some((id, index) => id !== finalActive[index])
+    const exitedChanged =
+      currentExited.length !== finalExited.length ||
+      currentExited.some((id, index) => id !== finalExited[index])
+
+    if (activeChanged) {
+      group.nodeIds = finalActive
+      changed = true
+    }
+    if (exitedChanged) {
+      group.exitedNodeIds = finalExited
+      changed = true
+    }
+  }
+
+  return changed
+}

package/src/history-add.js

@@ -0,0 +1,119 @@
+import path from 'node:path'
+import { isDeepStrictEqual as same } from 'node:util'
+import { atomic, json, root, safeName } from './store.js'
+import { nodeHistoryInput, historyContext, selectedHistory } from './node-history.js'
+import { requireServiceReady } from './service.js'
+import { captureMediaHistory } from './media-copy.js'
+import { sameImageReferences, sameVideoReferences } from './media.js'
+
+const plain = v => JSON.parse(JSON.stringify(v))
+export const historyAddPath = (profile, operation) => path.join(root(), 'history-add', safeName(profile), safeName(operation) + '.json')
+const persist = r => atomic(historyAddPath(r.profile, r.operation), r)
+export function historyAddInput(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(k =>
+    !['doc_id','node_id','space','team_uid','task_id','new_node_id','position','title','expected_version'].includes(k))) throw Error('历史添加输入无效')
+  const { new_node_id, position, title, expected_version, ...selection } = value
+  const input = nodeHistoryInput(selection)
+  if (typeof new_node_id !== 'string' || !new_node_id.trim() || new_node_id === input.node_id ||
+      !position || Object.keys(position).some(k => !['x','y'].includes(k)) || !Number.isFinite(position.x) || !Number.isFinite(position.y)) throw Error('历史添加需要不同的new_node_id及有效position')
+  if (title !== undefined && (typeof title !== 'string' || !title.trim())) throw Error('title无效')
+  if (expected_version !== undefined && (!Number.isSafeInteger(expected_version) || expected_version < 1)) throw Error('expected_version无效')
+  return {...input,new_node_id,position:{x:Math.round(position.x),y:Math.round(position.y)},...(title === undefined ? {} : {title}),...(expected_version === undefined ? {} : {expected_version})}
+}
+function promptOnly(item) {
+  const prompt = String(item.prompt || '').trim(), names = new Map()
+  const block = prompt.match(/<!-- flow:auto-material-preparation:start -->\r?\n([\s\S]*?)\r?\n<!-- flow:auto-material-preparation:end -->/)?.[1] || ''
+  for (const match of block.matchAll(/(@(?:图片|视频|音频)\d+)是([^；;\r\n]+?)(?=[；;。]|$)/g)) names.set(match[1],match[2])
+  const allowed = new Set(['image','video','audio'].flatMap(type => (item[`reference_${type}_urls`] || []).map((_,i) => '@'+({image:'图片',video:'视频',audio:'音频'}[type])+(i+1))))
+  return prompt.replace(/<!-- flow:auto-material-preparation:start -->\r?\n[\s\S]*?\r?\n<!-- flow:auto-material-preparation:end -->(?:\r?\n){0,2}/g,'')
+    .replace(/@(?:图片|视频|音频)\d+/g, marker => allowed.has(marker) ? names.get(marker) || marker : marker)
+}
+// Counterpart of buildCompletedHistoryNodeData: new ordinary generation node,
+// output only, no inherited inputs, review authorization, draft or running task.
+// Store provenance in copied history so web serialization retains sourceTaskId.
+export function buildHistoryAddedNode(source, item, input) {
+  const type = source.type, result = structuredClone(item.result)
+  for (const key of ['task_id','taskId','task_no','taskNo']) delete result[key]
+  const data = {title:input.title || `${type === 'image' ? '图片历史' : '视频历史'}${item.task_id}`,
+    prompt:promptOnly(item),model_name:String(item.model_name || ''),status:'completed',last_task_id:null,
+    duration:Number(item.duration ?? result.duration) || null,result:{...result,status:result.status || 'completed'},error_message:'',
+    extra:{node_kind:'generation',file_ref:result.file_ref,source_task_id:String(item.task_id),
+      source_doc_id:item.doc_id,source_node_id:item.node_id,
+      ...(item.aspect_ratio || item.extra?.aspect_ratio ? {aspect_ratio:item.aspect_ratio || item.extra.aspect_ratio} : {}),
+      ...(item.resolution || item.extra?.resolution ? {resolution:item.resolution || item.extra.resolution} : {}),
+      image_count:Number(item.extra?.image_count) || 1,
+      ...(type === 'image' ? {image_to_image_enabled:true,asset_type:'character'} : {})}}
+  const node = {id:input.new_node_id,type,position:input.position,width:486,height:420,data}
+  data.extra.copied_generation_history = captureMediaHistory({...node,id:item.node_id})
+  const history = data.extra.copied_generation_history[0]
+  Object.assign(history,{docId:item.doc_id,nodeId:item.node_id,segmentType:type,contentType:type,taskNo:String(item.task_no || ''),
+    mode:String(item.generation_mode || item.extra?.generation_mode || ''),prompt:String(item.prompt || ''),
+    createdAt:item.created_at || '',completedAt:item.completed_at || '',generatedAt:item.completed_at || item.created_at || '',
+    raw:{...structuredClone(item),id:String(item.task_id),source:'copied'}})
+  return plain(node)
+}
+function identity(item) {
+  const copy = plain(item)
+  for (const key of ['url','file_ref','preview_url','preview_file_ref']) delete copy.result[key]
+  return copy
+}
+const summary = r => ({operation:r.operation,state:r.state,doc_id:r.input.doc_id,source_node_id:r.input.node_id,
+  source_task_id:r.input.task_id,new_node_id:r.input.new_node_id,canvas_written:false,generation_submitted:false,library_saved:false,
+  add_verified:r.state === 'applied'})
+async function bound(client, profile, operation) {
+  const r = await json(historyAddPath(profile,operation),null)
+  if (!r || r.schema !== 1 || r.profile !== profile || r.operation !== operation || r.baseUrl !== client.baseUrl ||
+      !r.before || !r.pendingNode || r.pendingNode.id !== r.input?.new_node_id) throw Error('历史添加operation不存在、不完整或服务不匹配')
+  historyAddInput(r.input)
+  const ctx = await historyContext(client,r.input)
+  if (ctx.owner !== r.owner) throw Error('历史添加账号不匹配')
+  return {r,ctx}
+}
+export async function addNodeHistory(client, profile, value, operation, confirmed = false) {
+  const input = historyAddInput(value)
+  await requireServiceReady(client)
+  const old = await json(historyAddPath(profile,operation),null)
+  if (old && (!same(old.input,input) || old.baseUrl !== client.baseUrl || old.profile !== profile)) throw Error('原历史添加operation绑定不可更改')
+  if (old?.attempted) return recoverHistoryAdd(client,profile,operation)
+  const ctx = await historyContext(client,input)
+  if (old && ctx.owner !== old.owner) throw Error('历史添加账号不匹配')
+  if (ctx.doc.nodes.some(n => n.id === input.new_node_id)) throw Error('新节点ID已存在；不覆盖')
+  if (input.expected_version !== undefined && input.expected_version !== ctx.doc.version) throw Error('画布版本已变化，重新预览')
+  const item = await selectedHistory(client,input,ctx)
+  if (!confirmed) {
+    const r = {schema:1,profile,operation,baseUrl:client.baseUrl,owner:ctx.owner,input,before:ctx.doc,
+      identity:identity(item),media:{url:item.result.url,file_ref:item.result.file_ref},pendingNode:buildHistoryAddedNode(ctx.node,item,input),state:'prepared'}
+    await persist(r)
+    return {...summary(r),expected_version:ctx.doc.version,node:r.pendingNode,source_unchanged:true,references_restored:false}
+  }
+  const {r,ctx:checked} = await bound(client,profile,operation)
+  if (!same(checked.doc,r.before) || !same(identity(item),r.identity)) throw Error('预览后画布或历史已变化；不覆盖')
+  if (!same(r.media,{url:item.result.url,file_ref:item.result.file_ref}) &&
+      !await (ctx.node.type === 'image' ? sameImageReferences : sameVideoReferences)(client,r.media.file_ref,item.result.file_ref)) throw Error('历史更新引用不能确认是原媒体')
+  r.pendingNode = buildHistoryAddedNode(ctx.node,item,input)
+  r.attempted = true; r.state = 'saving'; await persist(r)
+  const doc = checked.doc
+  try {
+    const saved = await client.raw('/canvas/docs/'+encodeURIComponent(input.doc_id),{method:'PUT',body:{version:doc.version,name:doc.name,
+      viewport:doc.viewport,nodes:[...doc.nodes,r.pendingNode],edges:doc.edges,meta:doc.meta}},{retry:false})
+    if (saved?.version !== doc.version+1) throw Error('保存响应版本不完整')
+    const result = await recoverHistoryAdd(client,profile,operation)
+    if (!result.add_verified || !result.canvas_preserved) throw Error('历史添加保存后读回不一致')
+    return {...result,canvas_written:true}
+  } catch (cause) {
+    r.state = cause.status === 409 || cause.apiCode === 3002 ? 'conflict' : 'save_unknown'; await persist(r)
+    throw Object.assign(Error('历史添加保存未确认；仅用原history-add-recover核对，不重发保存',{cause}),{code:'NODE_HISTORY_SAVE_PENDING'})
+  }
+}
+export async function recoverHistoryAdd(client,profile,operation) {
+  await requireServiceReady(client)
+  const {r,ctx} = await bound(client,profile,operation)
+  if (!r.attempted) return summary(r)
+  const matches = same(ctx.doc.nodes.find(n => n.id === r.input.new_node_id),r.pendingNode)
+  const preserved = same(ctx.doc.nodes.filter(n => n.id !== r.input.new_node_id),r.before.nodes) &&
+    ['edges','viewport','meta','name'].every(k => same(ctx.doc[k],r.before[k]))
+  if (matches) {r.state='applied';await persist(r)}
+  return {...summary(r),state:!matches && r.state === 'applied' ? 'canvas_changed' : r.state,
+    add_verified:matches,canvas_preserved:preserved,source_unchanged:same(ctx.node,r.before.nodes.find(n => n.id === r.input.node_id)),
+    version:ctx.doc.version,next:matches ? '原历史结果新增已核验；其他内容后续变化分别报告' : '保留当前画布；不自动覆盖、重建或重发保存'}
+}

package/src/image-annotation.js

@@ -0,0 +1,246 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { atomic, json, root, safeName } from './store.js'
+import { downloadImage, hashFile } from './media.js'
+import { readImageSource } from './image-crop.js'
+import {
+  annotationCommands,
+  annotationGeometry,
+  annotationTools,
+  annotateImage
+} from './annotation-media.js'
+import { imageOutputWorkflow } from './image-output.js'
+
+const mediaDefault = { annotationTools, annotateImage, downloadImage }
+const digest = (value) => crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex')
+export const annotationPath = (profile, operation) =>
+  path.join(root(), 'image-annotations', safeName(profile), safeName(operation) + '.json')
+export function annotationInput(value) {
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    Array.isArray(value) ||
+    Object.keys(value).some(
+      (k) => !['doc_id', 'node_id', 'space', 'team_uid', 'commands', 'font_file'].includes(k)
+    )
+  )
+    throw new Error('标注输入无效或包含未接入字段')
+  if (
+    typeof value.doc_id !== 'string' ||
+    !value.doc_id.trim() ||
+    typeof value.node_id !== 'string' ||
+    !value.node_id.trim()
+  )
+    throw new Error('标注缺少doc_id/node_id')
+  if (
+    value.font_file !== undefined &&
+    (typeof value.font_file !== 'string' || !value.font_file.trim())
+  )
+    throw new Error('font_file须为已有本机字体路径')
+  return { ...value, commands: annotationCommands(value.commands) }
+}
+async function identity(client) {
+  const me = await client.raw('/auth/me'),
+    uid = String(me.uid ?? me.id ?? '')
+  if (!uid) throw new Error('标注账号缺少UID')
+  return uid
+}
+async function context(client, input) {
+  const current = await readImageSource(client, input)
+  return {
+    ...current,
+    geometry: annotationGeometry(current.source, input.commands),
+    binding: { ...current.binding, source_type: current.node.type }
+  }
+}
+const summary = (record) => ({
+  operation: record.operation,
+  state: record.state,
+  generation_submitted: false,
+  library_saved: false,
+  doc_id: record.input.doc_id,
+  source_node_id: record.input.node_id,
+  ...record.geometry,
+  output_type: record.outputType,
+  command_count: record.input.commands.length,
+  command_types: [...new Set(record.input.commands.map((c) => c.type))],
+  items: record.items.map((item) => ({
+    node_id: item.nodeId,
+    state: item.state,
+    canvas_bound: item.bound === true,
+    task_id: item.response?.task_id || null,
+    width: item.local?.width || null,
+    height: item.local?.height || null
+  })),
+  next:
+    record.state === 'completed'
+      ? '读取画布/PNG核验；不自动入库或生成'
+      : '先查后端和原任务；annotate-recover原operation --yes恢复已知阶段，不重发未知complete'
+})
+const { persistNodes, runUploads } = imageOutputWorkflow({
+  recordPath: annotationPath,
+  readContext: context,
+  nodeTitle: (item) => item.title,
+  nodePosition: (_nodes, source) => ({
+    x: Number(source.position?.x || 0) + Number(source.width || 320) + 80,
+    y: Number(source.position?.y || 0)
+  }),
+  nodeType: (record) => record.outputType,
+  edgeRole: 'image-edit-link',
+  edgePrefix: 'annotation-link-',
+  codePrefix: 'ANNOTATION',
+  mime: 'image/png',
+  summarize: summary
+})
+async function bound(client, profile, operation) {
+  const record = await json(annotationPath(profile, operation), null)
+  if (!record) throw new Error('未找到标注operation')
+  if (record.baseUrl !== client.baseUrl || record.owner !== (await identity(client)))
+    throw new Error('标注operation账号或服务不匹配')
+  const current = await context(client, record.input)
+  if (
+    digest(current.binding) !== digest(record.binding) ||
+    digest(current.geometry) !== digest(record.geometry)
+  )
+    throw new Error('标注原图/节点类型/任务已变化，停止恢复')
+  return { record, current }
+}
+async function prepareLocal(client, profile, record, current, options, media) {
+  const item = record.items[0]
+  if (item.local) return
+  const tools = await media.annotationTools(record.input.commands, {
+    ...options,
+    fontFile: record.rendering?.fontFile || record.input.font_file
+  })
+  if (record.rendering?.fontHash && digest(record.rendering.fontHash) !== digest(tools.fontHash))
+    throw new Error('原标注字体文件已变化，停止恢复')
+  await fs.mkdir(record.directory, { recursive: true })
+  const source = path.join(record.directory, 'source.img')
+  if (!record.download) {
+    await fs.rm(source, { force: true })
+    record.download = await media.downloadImage(client, current.url, source)
+    await atomic(annotationPath(profile, record.operation), record)
+  } else if (digest(await hashFile(source)) !== digest(record.download))
+    throw new Error('本地标注原图缓存已变化')
+  const target = path.join(record.directory, item.fileName)
+  await fs.rm(target, { force: true })
+  item.local = await media.annotateImage(
+    source,
+    target,
+    record.geometry,
+    record.input.commands,
+    tools
+  )
+  record.state = 'local_ready'
+  await atomic(annotationPath(profile, record.operation), record)
+}
+export async function startAnnotation(
+  client,
+  profile,
+  value,
+  operation,
+  confirmed = false,
+  options = {},
+  media = mediaDefault
+) {
+  const input = annotationInput(value),
+    file = annotationPath(profile, operation),
+    old = await json(file, null)
+  if (old) {
+    if (digest(old.input) !== digest(input)) throw new Error('原标注operation不可改变输入')
+    return getAnnotation(client, profile, operation)
+  }
+  const tools = await media.annotationTools(input.commands, {
+      ...options,
+      fontFile: input.font_file
+    }),
+    current = await context(client, input),
+    owner = await identity(client)
+  const outputType = current.node.type === 'image' ? 'image' : 'image_upload'
+  if (!confirmed)
+    return {
+      operation,
+      submitted: false,
+      generation_submitted: false,
+      library_saved: false,
+      source_task_id: current.binding.task_id,
+      ...current.geometry,
+      output_format: 'image/png',
+      output_type: outputType,
+      commands: input.commands,
+      media_tools: 'available',
+      next: '核对标注位置和源图，暂停同画布编辑后加--yes；本地合成、真实上传并新增下游节点，不生成/入库'
+    }
+  const title = current.node.data?.title || '图片'
+  const record = {
+    operation,
+    input,
+    owner,
+    baseUrl: client.baseUrl,
+    binding: current.binding,
+    geometry: current.geometry,
+    outputType,
+    rendering: {
+      engine: 'ffmpeg-drawvg/drawtext',
+      ...(tools.fontFile ? { fontFile: tools.fontFile, fontHash: tools.fontHash } : {})
+    },
+    directory: path.join(path.dirname(file), safeName(operation) + '-files'),
+    createdAt: new Date().toISOString(),
+    state: 'preparing',
+    items: [
+      {
+        nodeId: 'annotate-' + crypto.randomUUID(),
+        title: title + '（标注）',
+        fileName:
+          (title.replace(/[\\/:*?"<>|\u0000-\u001f]+/g, '_').slice(0, 80) || 'edited-image') +
+          '.png',
+        state: 'prepared'
+      }
+    ]
+  }
+  await atomic(file, record)
+  await prepareLocal(client, profile, record, current, tools, media)
+  await persistNodes(client, profile, record, (await bound(client, profile, operation)).current)
+  return runUploads(client, profile, record)
+}
+export async function getAnnotation(client, profile, operation) {
+  const { record, current } = await bound(client, profile, operation),
+    result = summary(record)
+  for (let i = 0; i < record.items.length; i++) {
+    const item = record.items[i],
+      node = current.doc.nodes.find((n) => n.id === item.nodeId)
+    if (
+      item.bound &&
+      (node?.type !== record.outputType ||
+        node.data?.extra?.node_kind !== (record.outputType === 'image' ? 'generation' : 'asset') ||
+        node.data?.extra?.file_ref !== item.response.result.file_ref ||
+        !current.doc.edges.some(
+          (e) =>
+            e.source === record.input.node_id &&
+            e.target === item.nodeId &&
+            e.data?.role === 'image-edit-link'
+        ))
+    ) {
+      result.state = 'canvas_changed'
+      result.items[i].state = 'canvas_changed'
+      result.items[i].canvas_bound = false
+    }
+  }
+  return result
+}
+export async function recoverAnnotation(
+  client,
+  profile,
+  operation,
+  confirmed = false,
+  options = {},
+  media = mediaDefault
+) {
+  if (!confirmed) return getAnnotation(client, profile, operation)
+  const { record, current } = await bound(client, profile, operation)
+  if (record.state === 'completed') return getAnnotation(client, profile, operation)
+  await prepareLocal(client, profile, record, current, options, media)
+  await persistNodes(client, profile, record, (await bound(client, profile, operation)).current)
+  return runUploads(client, profile, record)
+}