@things-factory/figure-service 10.1.33 → 10.1.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.33",
+  "version": "10.1.35",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,15 +23,15 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.27",
+    "@hatiolab/figure-model": "^0.1.32",
     "@operato/typeorm-history": "^10.0.0",
     "@things-factory/ai-client-base": "^10.1.31",
-    "@things-factory/auth-base": "^10.1.33",
+    "@things-factory/auth-base": "^10.1.34",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/shell": "^10.1.33",
+    "@things-factory/shell": "^10.1.34",
     "graphql-scalars": "^1.22.4",
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "7fb7b6587846b5ff6ee7a4983652d9561b4d6b2c"
+  "gitHead": "396f43b648b704f1938a2d890ab2f6efa33fdb86"
 }

package/server/service/figure/figure-gate.test.ts

@@ -30,6 +30,26 @@ describe('release-gate repair candidates', () => {
     ]))
     expect(split?.fixes?.every(fix => fix.resolved > 0)).toBe(true)
   })
+
+  it('offers one coordinated draft repair only after the full sizing suite clears', () => {
+    const source = {
+      version: 2,
+      type: 'STACK',
+      base: { x: 100, y: 200, z: 100 },
+      detailLevel: 'M',
+      parts: [
+        { name: 'body', primitive: 'cube', transform: { position: { x: 0, y: 50, z: 0 }, size: { x: 100, y: 100, z: 100 } }, material: { token: 'palette.primary' }, anchor: { y: 'min' } },
+        { name: 'cap-a', primitive: 'cube', transform: { position: { x: -25, y: 110, z: 0 }, size: { x: 20, y: 20, z: 20 } }, material: { token: 'palette.accent' }, anchor: { y: 'max' } },
+        { name: 'cap-b', primitive: 'cube', transform: { position: { x: 25, y: 110, z: 0 }, size: { x: 20, y: 20, z: 20 } }, material: { token: 'palette.accent' }, anchor: { y: 'max' } }
+      ]
+    }
+
+    const split = inspectSource(JSON.stringify(source)).findings.find(finding => finding.code === 'sizing-splits')
+
+    expect(split?.fixPlan).toEqual(expect.objectContaining({ safe: true, resolved: expect.any(Number) }))
+    expect(split?.fixPlan?.fixes.length).toBeGreaterThan(0)
+    expect(split?.fixPlan?.fixes.every(fix => fix.safe)).toBe(true)
+  })
 })
 
 /*

package/server/service/figure/figure-gate.ts

@@ -13,6 +13,18 @@ export interface GateFix {
   safe: boolean
 }
 
+/**
+ * A coordinated repair, measured from the current source all the way through the sizing suite.
+ * A split often involves several independently anchored parts, so no single anchor edit can be
+ * called a solution. This remains a draft-only edit; it is never saved or released by the gate.
+ */
+export interface GateFixPlan {
+  fixes: GateFix[]
+  resolved: number
+  /** True only after the complete plan leaves no release-blocking sizing split. */
+  safe: boolean
+}
+
 /**
  * 발행해도 되나 — **서버가 판정한다.**
  *
@@ -65,6 +77,8 @@ export interface GateFinding {
    * 수락하기 전에는 정본을 바꾸지 않는다.
    */
   fixes?: GateFix[]
+  /** The one-click, fully remeasured repair when individual candidates are insufficient. */
+  fixPlan?: GateFixPlan
   blocking: boolean
 }
 
@@ -122,6 +136,134 @@ function measuredFixes(source: FigureSource, factor: number): GateFix[] {
   return fixes.sort((a, b) => b.resolved - a.resolved || a.part.localeCompare(b.part)).slice(0, 12)
 }
 
+function sourceWithFix(source: FigureSource, fix: Pick<GateFix, 'part' | 'axis' | 'to'>): FigureSource {
+  return {
+    ...source,
+    parts: source.parts.map(part => part.name === fix.part
+      ? { ...part, anchor: { ...(part.anchor ?? {}), [fix.axis]: fix.to } }
+      : part)
+  }
+}
+
+function splitCount(source: FigureSource, factor: number) {
+  return sizingReport(compile(source), factor).findings.filter(finding => finding.code === 'sizing-splits').length
+}
+
+/**
+ * Find a small coordinated repair by repeatedly choosing the measured anchor edit that removes
+ * the most remaining splits. Every step is evaluated against the real compiler; prose is never
+ * interpreted. If the complete suite is not clear, no "recommended" button is exposed.
+ */
+function measuredFixPlan(source: FigureSource, factor: number): GateFixPlan | undefined {
+  const originalCount = splitCount(source, factor)
+  if (originalCount === 0) return undefined
+
+  let working = source
+  let remaining = originalCount
+  const used = new Set<string>()
+  const fixes: GateFix[] = []
+
+  for (let step = 0; step < source.parts.length * 3 && remaining > 0; step++) {
+    const report = sizingReport(compile(working), factor)
+    let best: GateFix | undefined
+
+    for (const finding of report.findings) {
+      if (finding.code !== 'sizing-splits' || !finding.way) continue
+      const axes = finding.way.split('-').filter((axis): axis is Axis => ['x', 'y', 'z'].includes(axis))
+      const names = new Set(finding.clumps.flat())
+
+      for (const part of working.parts) {
+        if (!names.has(part.name)) continue
+        for (const axis of axes) {
+          const key = `${part.name}:${axis}`
+          if (used.has(key)) continue
+          for (const to of ['min', 'center', 'max', 'span'] as const) {
+            if (part.anchor?.[axis] === to) continue
+            const afterCount = splitCount(sourceWithFix(working, { part: part.name, axis, to }), factor)
+            const resolved = remaining - afterCount
+            if (resolved <= 0) continue
+            const candidate: GateFix = {
+              findingWay: finding.way,
+              part: part.name,
+              axis,
+              from: source.parts.find(one => one.name === part.name)?.anchor?.[axis],
+              to,
+              resolved,
+              safe: false
+            }
+            if (!best || candidate.resolved > best.resolved ||
+              (candidate.resolved === best.resolved && `${candidate.part}:${candidate.axis}:${candidate.to}` < `${best.part}:${best.axis}:${best.to}`)) {
+              best = candidate
+            }
+          }
+        }
+      }
+    }
+
+    if (!best) break
+    fixes.push(best)
+    used.add(`${best.part}:${best.axis}`)
+    working = sourceWithFix(working, best)
+    remaining = splitCount(working, factor)
+  }
+
+  if (remaining === 0 && fixes.length > 0) {
+    return { fixes: fixes.map(fix => ({ ...fix, safe: true })), resolved: originalCount, safe: true }
+  }
+
+  /*
+   * Some assemblies need two anchors to move together. Neither first move removes a whole split,
+   * so greedy improvement alone cannot see the repair. Search a small, deterministic beam of those
+   * coordinated moves, and still return only a plan that the compiler proves clear.
+   */
+  const firstReport = sizingReport(compile(source), factor)
+  const candidates = new Map<string, { part: string; axis: Axis }>()
+  for (const finding of firstReport.findings) {
+    if (finding.code !== 'sizing-splits' || !finding.way) continue
+    const axes = finding.way.split('-').filter((axis): axis is Axis => ['x', 'y', 'z'].includes(axis))
+    const names = new Set(finding.clumps.flat())
+    for (const part of source.parts) {
+      if (!names.has(part.name)) continue
+      for (const axis of axes) candidates.set(`${part.name}:${axis}`, { part: part.name, axis })
+    }
+  }
+
+  type SearchState = { source: FigureSource; fixes: GateFix[]; used: Set<string>; remaining: number }
+  let frontier: SearchState[] = [{ source, fixes: [], used: new Set(), remaining: originalCount }]
+  const visited = new Set<string>()
+  for (let depth = 0; depth < 8 && frontier.length; depth++) {
+    const next: SearchState[] = []
+    for (const state of frontier) {
+      for (const [key, target] of candidates) {
+        if (state.used.has(key)) continue
+        const current = state.source.parts.find(part => part.name === target.part)
+        if (!current) continue
+        for (const to of ['min', 'center', 'max', 'span'] as const) {
+          if (current.anchor?.[target.axis] === to) continue
+          const changed = sourceWithFix(state.source, { ...target, to })
+          const signature = JSON.stringify(changed.parts.map(part => [part.name, part.anchor]))
+          if (visited.has(signature)) continue
+          visited.add(signature)
+          const after = splitCount(changed, factor)
+          const fix: GateFix = {
+            findingWay: 'coordinated', part: target.part, axis: target.axis,
+            from: source.parts.find(part => part.name === target.part)?.anchor?.[target.axis], to,
+            resolved: state.remaining - after, safe: false
+          }
+          const fixes = [...state.fixes, fix]
+          if (after === 0) return { fixes: fixes.map(one => ({ ...one, safe: true })), resolved: originalCount, safe: true }
+          next.push({ source: changed, fixes, used: new Set([...state.used, key]), remaining: after })
+        }
+      }
+    }
+    /* Keep enough alternatives to discover a paired repair without making release inspection expensive. */
+    frontier = next.sort((a, b) => a.remaining - b.remaining || a.fixes.length - b.fixes.length ||
+      JSON.stringify(a.fixes).localeCompare(JSON.stringify(b.fixes))).slice(0, 24)
+  }
+
+  return undefined
+}
+
 /**
  * 정본 하나를 판정한다.
  *
@@ -190,6 +332,7 @@ export function inspectSource(sourceJson?: string | null, releasedJson?: string
     const source = parsed as FigureSource
     const report = sizingReport(compile(source))
     const fixes = measuredFixes(source, report.factor)
+    const fixPlan = measuredFixPlan(source, report.factor)
 
     for (const finding of report.findings) {
       findings.push({
@@ -201,6 +344,8 @@ export function inspectSource(sourceJson?: string | null, releasedJson?: string
         /* 숫자가 아니라 자리를 말한다 — 어느 부품들이 갈라져 나왔나. */
         at: finding.clumps.map(clump => [...clump].sort().join('+')).join(' | ') || undefined,
           fixes: finding.code === 'sizing-splits' ? fixes.filter(fix => fix.findingWay === finding.way) : undefined,
+          /* A plan is attached once: it clears the full suite, not merely this card's symptom. */
+          fixPlan: finding.code === 'sizing-splits' && finding === report.findings.find(one => one.code === 'sizing-splits') ? fixPlan : undefined,
         blocking: finding.code === 'sizing-splits'
       })
     }

package/server/service/figure/figure-propose.test.ts

@@ -82,17 +82,19 @@ function candidate(over: Record<string, unknown> = {}) {
  * 고치는 요청에서 「부품 이름을 바꾸지 말라」가 빠지면 AI 가 이름을 갈아 버리고, 그러면
  * 이미 배치된 도면의 바인딩이 끊긴다. 답만 보는 모형으로는 그것이 나갔는지 알 수 없다.
  */
-function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[][]; system?: string } {
+function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[][]; options: any[]; system?: string } {
   const client = {
     id: 'stub',
     calls: 0,
     sent: [] as any[][],
+    options: [] as any[],
     system: undefined as string | undefined,
     async chat() {
       return ''
     },
-    async generateJSON(messages: any[], options?: { systemPrompt?: string }) {
+    async generateJSON(messages: any[], options?: { systemPrompt?: string; maxTokens?: number }) {
       client.sent.push(JSON.parse(JSON.stringify(messages)))
+      client.options.push(options)
       client.system = options?.systemPrompt
       const answer = answers[client.calls]
       client.calls++
@@ -100,7 +102,7 @@ function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[]
       return answer
     }
   }
-  return client as unknown as AIClient & { calls: number; sent: any[][]; system?: string }
+  return client as unknown as AIClient & { calls: number; sent: any[][]; options: any[]; system?: string }
 }
 
 /** 첫 요청에 실려 나간 사람 쪽 말. 이어 붙인 것까지 한 덩어리로 본다. */
@@ -266,6 +268,24 @@ describe('joints (ADR-0066)', () => {
 })
 
 describe('고치라는 요청일 때', () => {
+  it('편집 후보에는 JSON 완결에 충분한 출력 한도를 준다', async () => {
+    const client = stubClient([candidate()])
+    setDefaultAIClient(client as any)
+
+    await proposeFigure({ prompt: '색을 바꿔 줘', base: candidate() as any, palette: PALETTE })
+
+    expect((client as any).options?.[0]?.maxTokens).toBe(16384)
+  })
+
+  it('새 Figure 후보에도 같은 출력 한도를 준다', async () => {
+    const client = stubClient([candidate()])
+    setDefaultAIClient(client as any)
+
+    await proposeFigure({ prompt: '교반기', type: 'MIXER', palette: PALETTE })
+
+    expect((client as any).options?.[0]?.maxTokens).toBe(16384)
+  })
+
   it('요청이 안 건드린 것을 그대로 실으라고 못 박는다', async () => {
     /*
       이 문장이 없으면 애니메이션이 있는 도형을 「색만 바꿔 줘」로 고쳤을 때 모델이 clip 을

package/server/service/figure/figure-propose.ts

@@ -75,6 +75,12 @@ import type { FigureQualityReview } from './figure-quality.js'
 /** 몇 번까지 다시 시키나. 이보다 늘려도 대개 같은 자리에서 막힌다. */
 const MAX_ATTEMPTS = 3
 
+/*
+ * Figure 후보는 새로 만들든 기존 것을 고치든 완결된 정본 하나를 JSON으로 낸다. 기본 4,096
+ * 토큰으로는 부품 수가 조금만 늘어도 JSON이 중간에서 끊겨 닫는 괄호를 잃는다.
+ */
+const FIGURE_GENERATE_MAX_TOKENS = 16384
+
 export interface ProposeInput {
   /** 사람이 시킨 말. */
   prompt: string
@@ -478,7 +484,10 @@ export async function proposeFigure(input: ProposeInput): Promise<ProposeResult>
     // 코드 울타리나 앞뒤 설명을 우리가 걷어내지 않아도 된다.
     let answer: unknown
     try {
-      answer = await client.generateJSON(messages, { systemPrompt: system })
+      answer = await client.generateJSON(messages, {
+        systemPrompt: system,
+        maxTokens: FIGURE_GENERATE_MAX_TOKENS
+      })
     } catch (e) {
       // 모델이 JSON 을 못 냈다. 그것도 사유이므로 돌려주고 다시 시킨다.
       reasons = [`The answer was not valid JSON: ${(e as Error).message}`]

package/server/service/figure/figure-tools.ts

@@ -408,15 +408,28 @@ function figureToolSpecs(): ToolSpec[] {
           hostImage = { data: buf, mediaType: rawImage.mediaType || 'image/png' }
         }
 
-        const result = await proposeFigure({
-          prompt,
-          palette,
-          base,
-          type: typeof args?.type === 'string' ? args.type : undefined,
-          feedback,
-          refine: !!feedback?.length,
-          image: hostImage
-        })
+        let result: any
+        try {
+          result = await proposeFigure({
+            prompt,
+            palette,
+            base,
+            type: typeof args?.type === 'string' ? args.type : undefined,
+            feedback,
+            refine: !!feedback?.length,
+            image: hostImage
+          })
+        } catch (error) {
+          /*
+           * 후보 생성은 세 번의 JSON·형식 검사 끝에 실패할 수 있다. 그 마지막 검사 사유를
+           * ProposeFailure.reasons 에만 두면 agentic-loop은 "만들지 못했습니다"만 받아
+           * 사용자 화면에는 "응답이 비어있습니다"가 된다. 재시도할 수 있는 말로 경계를
+           * 넘긴다. 다른 예외(권한·통신)는 원문을 보존한다.
+           */
+          const reasons = Array.isArray((error as any)?.reasons) ? (error as any).reasons : []
+          if (reasons.length > 0) throw new Error([(error as Error).message, ...reasons].join('\n'))
+          throw error
+        }
 
         /*
           **`proposed: true` 가 카드를 만든다.** 이 표시가 없으면 후보는 도구 추적 안에 묻히고,

package/server/service/figure/figure-type.ts

@@ -161,6 +161,18 @@ export class FigureGateFix {
   safe: boolean
 }
 
+@ObjectType({ description: 'A coordinated, fully remeasured set of anchor changes that clears release-blocking sizing splits.' })
+export class FigureGateFixPlan {
+  @Field(type => [FigureGateFix], { description: 'The draft-only anchor changes to apply together.' })
+  fixes: FigureGateFix[]
+
+  @Field(type => Int, { description: 'Number of blocking sizing checks cleared by the complete plan.' })
+  resolved: number
+
+  @Field({ description: 'True only when the full plan was remeasured with no sizing split left.' })
+  safe: boolean
+}
+
 @ObjectType({ description: 'One finding from the release gate.' })
 export class FigureGateFinding {
   @Field({ description: 'Stable code — figure-model validation codes, or sizing-splits / sizing-loose.' })
@@ -184,6 +196,12 @@ export class FigureGateFinding {
   })
   fixes?: FigureGateFix[]
 
+  @Field(type => FigureGateFixPlan, {
+    nullable: true,
+    description: 'A coordinated recommended repair, available only when the complete sizing suite clears.'
+  })
+  fixPlan?: FigureGateFixPlan
+
   @Field({ description: 'True when this finding blocks the release.' })
   blocking: boolean
 }