@fugood/bricks-ctor 2.25.0-beta.46 → 2.25.0-beta.47

package/compile/__tests__/util.test.js

@@ -64,6 +64,28 @@ describe('validateConfig', () => {
   test('does not throw when error/output are falsy and inputs are empty', () => {
     expect(() => validateConfig(baseConfig())).not.toThrow()
   })
+
+  test('throws when error and output target the same id', () => {
+    const config = baseConfig({ output: 'shared', error: 'shared' })
+    expect(() => validateConfig(config)).toThrow(/key: error\/output/)
+  })
+
+  test('throws when output collides with an outputs target id', () => {
+    const config = baseConfig({ output: 'shared', outputs: { x: ['shared'] } })
+    expect(() => validateConfig(config)).toThrow(/key: output\/outputs/)
+  })
+
+  test('throws when error collides with an outputs target id', () => {
+    const config = baseConfig({ error: 'shared', outputs: { x: ['shared'] } })
+    expect(() => validateConfig(config)).toThrow(/key: error\/outputs/)
+  })
+
+  // The same id reused across *different* outputs entries is a supported last-wins case
+  // (see generateCalulationMap test below) and must stay allowed.
+  test('allows the same id across multiple outputs entries', () => {
+    const config = baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } })
+    expect(() => validateConfig(config)).not.toThrow()
+  })
 })
 
 // generateCalulationMap now seeds command ids from the owning calc id; tests that don't

package/compile/util.ts

@@ -27,6 +27,22 @@ export const validateConfig = (config: ScriptConfig) => {
   if (Object.values(config.outputs).some((value) => value.some((id) => config.inputs[id]))) {
     throw new Error(`${errorMsg}. key: outputs`)
   }
+  // The same data-node id reused across the output-side targets (output / error / outputs)
+  // also collides: generateCalulationMap spreads their node objects last-wins, so the later
+  // one silently overwrites the earlier wiring (e.g. error == output drops the error change
+  // link). The checks above only compare against `inputs`, so guard the output-side pairs
+  // too. (The same id appearing in multiple `outputs` entries is a supported last-wins case
+  // and stays allowed.)
+  if (config.error && config.output && config.error === config.output) {
+    throw new Error(`${errorMsg}. key: error/output`)
+  }
+  const outputsIds = Object.values(config.outputs).flat()
+  if (config.output && outputsIds.includes(config.output)) {
+    throw new Error(`${errorMsg}. key: output/outputs`)
+  }
+  if (config.error && outputsIds.includes(config.error)) {
+    throw new Error(`${errorMsg}. key: error/outputs`)
+  }
 }
 
 const padding = 15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.46",
+  "version": "2.25.0-beta.47",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
@@ -29,5 +29,5 @@
   "peerDependencies": {
     "oxfmt": "^0.36.0"
   },
-  "gitHead": "877bdee4953bcdc09b2dd04f28c8d7edc37824ab"
+  "gitHead": "95f194a3fb6331c0f25a879e55675e3ff331a412"
 }

package/tools/mcp-tools/__tests__/huggingface.test.ts

@@ -0,0 +1,49 @@
+import { buildGGUFSplitFiles } from '../huggingface'
+
+declare const describe: (name: string, fn: () => void) => void
+declare const it: (name: string, fn: () => void) => void
+declare const expect: (actual: unknown) => { toEqual: (expected: unknown) => void }
+
+describe('buildGGUFSplitFiles', () => {
+  it('builds split GGUF files with indexed sibling metadata lookup', () => {
+    const siblings = [
+      {
+        rfilename: 'other-file.txt',
+        size: 999,
+      },
+      {
+        rfilename: 'model-00001-of-00003.gguf',
+        size: 1,
+        lfs: { sha256: 'one' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 2,
+        lfs: { sha256: 'two' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 22,
+        lfs: { sha256: 'two-late' },
+      },
+    ]
+
+    expect(buildGGUFSplitFiles('model-00001-of-00003.gguf', '00003', siblings)).toEqual([
+      {
+        rfilename: 'model-00001-of-00003.gguf',
+        size: 1,
+        lfs: { sha256: 'one' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 2,
+        lfs: { sha256: 'two' },
+      },
+      {
+        rfilename: 'model-00003-of-00003.gguf',
+        size: undefined,
+        lfs: undefined,
+      },
+    ])
+  })
+})

package/tools/mcp-tools/__tests__/icons.test.ts

@@ -0,0 +1,21 @@
+import { searchIcons } from '../icons'
+
+declare const describe: (name: string, fn: () => void) => void
+declare const test: (name: string, fn: () => void) => void
+declare const expect: (actual: unknown) => {
+  toBe: (expected: unknown) => void
+  toHaveLength: (expected: number) => void
+}
+
+describe('icon_search helpers', () => {
+  test('searches the selected style corpus directly', () => {
+    const results = searchIcons('x', 10, 'brands')
+
+    expect(results).toHaveLength(10)
+    expect(results.every((result) => result.item.styles.includes('brands'))).toBe(true)
+  })
+
+  test('keeps unstyled searches capped by limit', () => {
+    expect(searchIcons('arrow', 5)).toHaveLength(5)
+  })
+})

package/tools/mcp-tools/huggingface.ts

@@ -269,6 +269,28 @@ const fetchHFModelDetails = async (modelId: string): Promise<HFModel> => {
 // Example: Mixtral-8x22B-v0.1.IQ3_XS-00001-of-00005.gguf
 const ggufSplitPattern = /-(\d{5})-of-(\d{5})\.gguf$/
 
+export const buildGGUFSplitFiles = (
+  filename: string,
+  splitTotal: string,
+  siblings: HFSibling[],
+): HFSibling[] => {
+  const siblingByFilename = new Map<string, HFSibling>()
+  for (const sibling of siblings) {
+    if (!siblingByFilename.has(sibling.rfilename)) siblingByFilename.set(sibling.rfilename, sibling)
+  }
+
+  return Array.from({ length: Number(splitTotal) }, (_, i) => {
+    const split = String(i + 1).padStart(5, '0')
+    const splitRFilename = filename.replace(ggufSplitPattern, `-${split}-of-${splitTotal}.gguf`)
+    const sibling = siblingByFilename.get(splitRFilename)
+    return {
+      rfilename: splitRFilename,
+      size: sibling?.size,
+      lfs: sibling?.lfs,
+    }
+  })
+}
+
 export function register(server: McpServer) {
   server.tool(
     'huggingface_search',
@@ -657,19 +679,7 @@ export function register(server: McpServer) {
 
         if (isSplit) {
           const [, , splitTotal] = matched!
-          const splitFiles = Array.from({ length: Number(splitTotal) }, (_, i) => {
-            const split = String(i + 1).padStart(5, '0')
-            const splitRFilename = filename.replace(
-              ggufSplitPattern,
-              `-${split}-of-${splitTotal}.gguf`,
-            )
-            const sibling = siblings.find((sb) => sb.rfilename === splitRFilename)
-            return {
-              rfilename: splitRFilename,
-              size: sibling?.size,
-              lfs: sibling?.lfs,
-            }
-          })
+          const splitFiles = buildGGUFSplitFiles(filename, splitTotal, siblings)
 
           const first = splitFiles[0]
           const rest = splitFiles.slice(1)

package/tools/mcp-tools/icons.ts

@@ -36,11 +36,31 @@ const iconList = Object.entries(glyphmap as Record<string, number>).map(([name,
   return { name, code, styles }
 })
 
-const iconFuse = new Fuse(iconList, {
+const fuseOptions = {
   keys: ['name'],
   threshold: 0.3,
   includeScore: true,
-})
+}
+
+const iconFuse = new Fuse(iconList, fuseOptions)
+const iconFuseByStyle = new Map<IconStyle, Fuse<(typeof iconList)[number]>>()
+
+function getStyleFuse(style: IconStyle) {
+  let fuse = iconFuseByStyle.get(style)
+  if (!fuse) {
+    fuse = new Fuse(
+      iconList.filter((icon) => icon.styles.includes(style)),
+      fuseOptions,
+    )
+    iconFuseByStyle.set(style, fuse)
+  }
+  return fuse
+}
+
+export function searchIcons(query: string, limit: number, style?: IconStyle) {
+  if (style) return getStyleFuse(style).search(query, { limit })
+  return iconFuse.search(query, { limit })
+}
 
 export function register(server: McpServer) {
   server.tool(
@@ -54,11 +74,7 @@ export function register(server: McpServer) {
         .describe('Filter by icon style'),
     },
     async ({ query, limit, style }) => {
-      let results = iconFuse.search(query, { limit: style ? limit * 3 : limit })
-
-      if (style) {
-        results = results.filter((r) => r.item.styles.includes(style)).slice(0, limit)
-      }
+      const results = searchIcons(query, limit, style)
 
       const icons = results.map((r) => ({
         name: r.item.name,