@fugood/bricks-ctor 2.25.0-beta.55 → 2.25.0-beta.56

package/compile/__tests__/util.test.js

@@ -335,3 +335,116 @@ describe('generateCalulationMap', () => {
     expect(result.map[refs[1].id].properties.command).toBe('OBJECT_GET')
   })
 })
+
+// Direction A: generateCalulationMap also emits a single-node `script_map` the new runtime
+// prefers. These assert that derived graph, independent of the legacy `map` above.
+const scriptNode = (scriptMap) =>
+  Object.entries(scriptMap).find(([, node]) => node.type === 'command-node-script')
+
+describe('generateScriptMap (script_map)', () => {
+  test('empty config produces a single command-node-script node', () => {
+    const { script_map } = genMap(baseConfig())
+    expect(Object.values(script_map)).toHaveLength(1)
+    const [, node] = scriptNode(script_map)
+    expect(node.properties.command).toBe('SCRIPT_RUN')
+    expect(node.properties.args.code).toBe('return inputs')
+    expect(node.properties.args.inputs).toEqual({})
+    expect(node.properties.args.outputs).toEqual({})
+    expect(node.in).toEqual({})
+    expect(node.out).toEqual({})
+  })
+
+  test('wires keyed input ports and input data nodes, preserving order', () => {
+    const { script_map } = genMap(baseConfig({ inputs: { a: 'foo.bar', b: 'baz' } }))
+    const [scriptId, node] = scriptNode(script_map)
+    expect(script_map.a.out.value).toEqual([{ id: scriptId, port: 'a' }])
+    expect(script_map.b.out.value).toEqual([{ id: scriptId, port: 'b' }])
+    expect(script_map.a.in.change).toBeNull()
+    expect(node.in.a).toEqual([{ id: 'a', port: 'value' }])
+    expect(node.in.b).toEqual([{ id: 'b', port: 'value' }])
+    // args.inputs maps each input port (data-node id) to its inputs-object path, in order.
+    expect(node.properties.args.inputs).toEqual({ a: 'foo.bar', b: 'baz' })
+    expect(Object.keys(node.properties.args.inputs)).toEqual(['a', 'b'])
+  })
+
+  test('fans out output / error / outputs to distinct ports and target data nodes', () => {
+    const { script_map } = genMap(
+      baseConfig({ output: 'outNode', error: 'errNode', outputs: { sum: ['pb1', 'pb2'] } }),
+    )
+    const [scriptId, node] = scriptNode(script_map)
+    expect(node.out.output).toEqual([{ id: 'outNode', port: 'change' }])
+    expect(node.out.error).toEqual([{ id: 'errNode', port: 'change' }])
+    expect(node.out['out:sum']).toEqual([
+      { id: 'pb1', port: 'change' },
+      { id: 'pb2', port: 'change' },
+    ])
+    expect(node.properties.args.outputs).toEqual({ 'out:sum': 'sum' })
+    expect(script_map.outNode.in.change).toEqual([{ id: scriptId, port: 'output' }])
+    expect(script_map.errNode.in.change).toEqual([{ id: scriptId, port: 'error' }])
+    expect(script_map.pb1.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
+    expect(script_map.pb2.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
+  })
+
+  test('manual mode disables every input edge', () => {
+    const { script_map } = genMap(
+      baseConfig({ trigger_mode: 'manual', inputs: { a: 'foo', b: 'bar' } }),
+    )
+    const [, node] = scriptNode(script_map)
+    expect(node.in.a[0].disable_trigger_command).toBe(true)
+    expect(node.in.b[0].disable_trigger_command).toBe(true)
+  })
+
+  test('auto mode honours per-key disabled_triggers', () => {
+    const { script_map } = genMap(
+      baseConfig({ inputs: { a: 'foo', b: 'bar' }, disabled_triggers: { a: true, b: false } }),
+    )
+    const [, node] = scriptNode(script_map)
+    expect(node.in.a[0].disable_trigger_command).toBe(true)
+    expect(node.in.b[0].disable_trigger_command).toBeUndefined()
+  })
+
+  test('a node reused as input and output keeps both edges (manual mode)', () => {
+    const { script_map } = genMap(
+      baseConfig({
+        trigger_mode: 'manual',
+        inputs: { shared: 'foo' },
+        outputs: { sum: ['shared'] },
+      }),
+    )
+    const [scriptId] = scriptNode(script_map)
+    // Input side (out.value) is preserved alongside the output side (in.change).
+    expect(script_map.shared.out.value).toEqual([{ id: scriptId, port: 'shared' }])
+    expect(script_map.shared.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
+  })
+
+  test('outputs port names never collide with the reserved output port', () => {
+    const { script_map } = genMap(baseConfig({ output: 'outNode', outputs: { output: ['pb1'] } }))
+    const [, node] = scriptNode(script_map)
+    // The whole-return-value port stays `output`; an outputs path literally named "output"
+    // is namespaced to `out:output`.
+    expect(node.out.output).toEqual([{ id: 'outNode', port: 'change' }])
+    expect(node.out['out:output']).toEqual([{ id: 'pb1', port: 'change' }])
+    expect(node.properties.args.outputs).toEqual({ 'out:output': 'output' })
+  })
+
+  test('script node id is byte-stable across recompiles and unique per calc', () => {
+    const config = baseConfig({ inputs: { a: 'foo' }, outputs: { out: ['pb1'] } })
+    const first = generateCalulationMap(config, CALC_ID)
+    const second = generateCalulationMap(config, CALC_ID)
+    expect(Object.keys(second.script_map)).toEqual(Object.keys(first.script_map))
+    const [idA] = scriptNode(first.script_map)
+    const [idB] = scriptNode(
+      generateCalulationMap(
+        config,
+        'PROPERTY_BANK_COMMAND_MAP_bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+      ).script_map,
+    )
+    expect(idA).not.toBe(idB)
+    const uuid = '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
+    expect(idA).toMatch(new RegExp(`^PROPERTY_BANK_COMMAND_NODE_${uuid}$`))
+  })
+
+  test('validateConfig still guards the script_map path (auto mode overlap)', () => {
+    expect(() => genMap(baseConfig({ inputs: { a: 'foo' }, error: 'a' }))).toThrow(/key: error/)
+  })
+})

package/compile/util.ts

@@ -54,6 +54,104 @@ const padding = 15
 const layerXInterval = 300
 const layerYInterval = 150
 
+// Direction A — first-class script node (see local-plan/PLAN-data-calculation-refactor.md).
+//
+// `generateCalulationMap` keeps emitting the legacy OBJECT_SET → SANDBOX_RUN_JAVASCRIPT →
+// SANDBOX_GET_*/OBJECT_GET expansion in `map` (consumed by older runtimes). In parallel,
+// `generateScriptMap` derives an equivalent single-node graph in `script_map` that a newer
+// runtime prefers: one `command-node-script` node that assembles `inputs` from keyed input
+// ports and fans out `error` / `output` / each `outputs` path directly to the target data
+// nodes. Both are byte-stable functions of `script_config`, so codegen (which only reads
+// `script_config`) round-trips losslessly and recompiling unchanged source re-derives an
+// identical `script_map`.
+//
+// Trigger semantics stay edge-level (`disable_trigger_command` on the script node's input
+// edges, same as the legacy OBJECT_SET inputs) so the circular-reference check and the
+// manual-trigger overlay keep working unchanged — only the node count collapses N+3 → 1.
+const generateScriptMap = (config: ScriptConfig, calcId: string) => {
+  const scriptId = makeSeededId('property_bank_command', `${calcId}:script`)
+  const map: Record<string, any> = {}
+
+  // Compiled run-time config for the script node. `inputs` maps each input port name (the
+  // source data-node id) to its OBJECT_SET path; `outputs` maps each fan-out port name to the
+  // OBJECT_GET path it extracts from the return value. The runtime reads these from
+  // properties.args, keeping the node `value` reserved purely for incoming input-port values.
+  const inputArgs: Record<string, string> = {}
+  const outputArgs: Record<string, string> = {}
+
+  const scriptIn: Record<string, any> = {}
+  const scriptOut: Record<string, any> = {}
+
+  // One in-port per input, keyed by the source data-node id (unique per input, so each input
+  // keeps its own `disable_trigger_command` flag — a shared path could not). Manual mode
+  // disables every input edge; auto mode honours per-key `disabled_triggers`.
+  Object.entries(config.inputs).forEach(([dataNodeId, path]) => {
+    inputArgs[dataNodeId] = path
+    scriptIn[dataNodeId] = [
+      {
+        id: dataNodeId,
+        port: 'value',
+        disable_trigger_command:
+          config.trigger_mode === 'manual' || config.disabled_triggers?.[dataNodeId] || undefined,
+      },
+    ]
+    map[dataNodeId] = {
+      type: 'data-node',
+      properties: {},
+      in: { change: null },
+      out: { value: [{ id: scriptId, port: dataNodeId }] },
+    }
+  })
+
+  // Wire an output target data-node's `change` port back from a script out-port, preserving
+  // any `out.value` it already has (a node reused as both input and output — allowed in manual
+  // mode). Mirrors the last-wins reuse handling in generateCalulationMap's outputs section.
+  const wireOutputTarget = (dataNodeId: string, scriptPort: string) => {
+    const existing = map[dataNodeId]
+    map[dataNodeId] = {
+      type: 'data-node',
+      properties: {},
+      in: { change: [{ id: scriptId, port: scriptPort }] },
+      out: { value: existing?.out?.value ?? null },
+    }
+  }
+
+  if (config.error) {
+    scriptOut.error = [{ id: config.error, port: 'change' }]
+    wireOutputTarget(config.error, 'error')
+  }
+  if (config.output) {
+    scriptOut.output = [{ id: config.output, port: 'change' }]
+    wireOutputTarget(config.output, 'output')
+  }
+  // `out:`-prefixed port names keep `outputs` paths from colliding with the reserved
+  // `error` / `output` ports (a path could legitimately be the string "output").
+  Object.entries(config.outputs).forEach(([path, pbList]) => {
+    const portName = `out:${path}`
+    outputArgs[portName] = path
+    scriptOut[portName] = pbList.map((pb) => ({ id: pb, port: 'change' }))
+    pbList.forEach((pb) => wireOutputTarget(pb, portName))
+  })
+
+  map[scriptId] = {
+    type: 'command-node-script',
+    title: 'Command: SCRIPT_RUN',
+    properties: {
+      command: 'SCRIPT_RUN',
+      args: {
+        code: config.code,
+        enable_async: config.enable_async,
+        inputs: inputArgs,
+        outputs: outputArgs,
+      },
+    },
+    in: scriptIn,
+    out: scriptOut,
+  }
+
+  return map
+}
+
 // `calcId` (the owning script calc's stable id) seeds every derived command-node id, so an
 // unchanged calc recompiles to identical ids and editing one calc never shifts another's —
 // keeping the compiled config byte-stable for change detection. See makeSeededId in utils/id.
@@ -219,6 +317,8 @@ export const generateCalulationMap = (config: ScriptConfig, calcId: string) => {
   )
 
   return {
+    // Newer runtimes prefer this single-node graph; older runtimes fall back to `map` below.
+    script_map: generateScriptMap(config, calcId),
     map: {
       ...inputs.map,
       [sandboxId]: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.55",
+  "version": "2.25.0-beta.56",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
@@ -29,5 +29,5 @@
   "peerDependencies": {
     "oxfmt": "^0.36.0"
   },
-  "gitHead": "08f3ae4a88db84f682384ecfa94e9d4583371bda"
+  "gitHead": "5d3de40404adc334a9a64046c5514e1cd86132db"
 }

package/tools/__tests__/pull.test.ts

@@ -0,0 +1,108 @@
+import { execFile as execFileCallback } from 'node:child_process'
+import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { promisify } from 'node:util'
+
+// bricks-project's tsconfig has no @types/jest, so declare the globals this test uses
+// (mirrors tools/__tests__/_mcp-config.test.ts).
+declare const describe: (name: string, fn: () => void) => void
+declare const it: (name: string, fn: () => void | Promise<void>, timeout?: number) => void
+declare const expect: (actual: unknown) => {
+  toBe: (expected: unknown) => void
+}
+
+const execFile = promisify(execFileCallback)
+
+async function run(cmd: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv) {
+  return execFile(cmd, args, {
+    cwd,
+    env: { ...process.env, ...env },
+    maxBuffer: 1024 * 1024,
+  })
+}
+
+async function initGitProject(projectDir: string) {
+  await run('git', ['init', '--initial-branch=master'], projectDir)
+  await run('git', ['config', 'user.email', 'test@example.com'], projectDir)
+  await run('git', ['config', 'user.name', 'Test User'], projectDir)
+  await writeFile(join(projectDir, 'application.json'), JSON.stringify({ id: 'app-1' }))
+  await run('git', ['add', '.'], projectDir)
+  await run('git', ['commit', '-m', 'init'], projectDir)
+}
+
+async function writeFakeBricks(binDir: string) {
+  const payload = {
+    files: [
+      {
+        name: 'subspaces/subspace-13/data-calc/data-calculation-0.sandbox.js',
+        input: 'export const value = 1\n',
+        formatable: false,
+      },
+    ],
+    lastCommitId: 'server-commit',
+  }
+  const bricksPath = join(binDir, 'bricks')
+  await writeFile(
+    bricksPath,
+    `#!/usr/bin/env node\nprocess.stdout.write(${JSON.stringify(JSON.stringify(payload))})\n`,
+  )
+  await chmod(bricksPath, 0o755)
+}
+
+describe('pull.ts', () => {
+  it('creates parent directories before writing pulled project files', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'bricks-project-pull-'))
+    const projectDir = join(root, 'project')
+    const binDir = join(root, 'bin')
+
+    try {
+      await mkdir(projectDir)
+      await mkdir(binDir)
+      await initGitProject(projectDir)
+      await writeFakeBricks(binDir)
+
+      const pullScript = resolve(__dirname, '../pull.ts')
+      await run('bun', [pullScript, '--force'], projectDir, {
+        PATH: `${binDir}:${process.env.PATH || ''}`,
+      })
+
+      const pulledFile = join(
+        projectDir,
+        'subspaces/subspace-13/data-calc/data-calculation-0.sandbox.js',
+      )
+      expect(await readFile(pulledFile, 'utf8')).toBe('export const value = 1\n')
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  }, 30000)
+
+  it('merges pulled project files back into the starting branch', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'bricks-project-pull-'))
+    const projectDir = join(root, 'project')
+    const binDir = join(root, 'bin')
+
+    try {
+      await mkdir(projectDir)
+      await mkdir(binDir)
+      await initGitProject(projectDir)
+      await writeFakeBricks(binDir)
+
+      const pullScript = resolve(__dirname, '../pull.ts')
+      await run('bun', [pullScript], projectDir, {
+        PATH: `${binDir}:${process.env.PATH || ''}`,
+      })
+
+      const { stdout: branch } = await run('git', ['branch', '--show-current'], projectDir)
+      const pulledFile = join(
+        projectDir,
+        'subspaces/subspace-13/data-calc/data-calculation-0.sandbox.js',
+      )
+
+      expect(branch.trim()).toBe('master')
+      expect(await readFile(pulledFile, 'utf8')).toBe('export const value = 1\n')
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  }, 30000)
+})

package/tools/pull.ts

@@ -1,6 +1,6 @@
-import { readdir, readFile, unlink, writeFile } from 'node:fs/promises'
+import { mkdir, readdir, readFile, unlink, writeFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { join, relative } from 'node:path'
+import { dirname, join, relative } from 'node:path'
 import { format } from 'oxfmt'
 import { sh } from './_shell'
 import { extractCliErrorMessage } from './_cli-error'
@@ -86,7 +86,11 @@ const branchName = isModule
   ? 'BRICKS_PROJECT_try-pull-module'
   : 'BRICKS_PROJECT_try-pull-application'
 
+let landingBranch = ''
 if (isGitRepo && !force) {
+  landingBranch = (await sh`cd ${cwd} && git branch --show-current`.text()).trim()
+  if (!landingBranch) throw new Error('Cannot pull from a detached HEAD')
+
   console.log(`Checking commit ${baseCommitId}...`)
   const found = (await sh`cd ${cwd} && git rev-list -1 ${baseCommitId}`.nothrow().text())
     .trim()
@@ -100,8 +104,8 @@ if (isGitRepo && !force) {
 
   // When the base commit isn't reachable in this clone (server stored a
   // nanoid, or the commit was pruned), fall back to forking from current
-  // HEAD. The downstream merge into main collapses both paths into the
-  // same result, just with different merge bases.
+  // HEAD. The downstream merge into the starting branch collapses both paths
+  // into the same result, just with different merge bases.
   if (found) {
     await sh`cd ${cwd} && git checkout -b ${branchName} ${baseCommitId}`.nothrow()
   } else {
@@ -143,7 +147,9 @@ await Promise.all(
       const result = await format(file.name, file.input, oxfmtConfig)
       content = result.code
     }
-    return writeFile(`${cwd}/${file.name}`, content)
+    const target = join(cwd, file.name)
+    await mkdir(dirname(target), { recursive: true })
+    return writeFile(target, content)
   }),
 )
 
@@ -160,11 +166,11 @@ if (isGitRepo) {
     await sh`cd ${cwd} && git ${commitArgs}`
   }
   if (!force) {
-    // Land the pulled commits on main with a single 3-way merge using
+    // Land the pulled commits on the starting branch with a single 3-way merge using
     // baseCommit as the merge base. The user doesn't have to manage a side
-    // branch, and conflicts (if any) land in the working tree on main where
+    // branch, and conflicts (if any) land in the working tree on the starting branch where
     // auto-compile surfaces them as typecheck errors to resolve in-place.
-    await sh`cd ${cwd} && git checkout main`
+    await sh`cd ${cwd} && git checkout ${landingBranch}`
     const mergeResult = await sh`cd ${cwd} && git merge ${branchName} --no-edit`.nothrow()
     if (mergeResult.exitCode !== 0) {
       // Conflict markers are in the working tree — commit them so the tree
@@ -174,7 +180,7 @@ if (isGitRepo) {
       await sh`cd ${cwd} && git add .`
       const conflictArgs = await buildCommitArgs(
         cwd,
-        ['chore(project): merge with conflicts (resolve in main)'],
+        [`chore(project): merge with conflicts (resolve in ${landingBranch})`],
         ['--no-verify'],
       )
       await sh`cd ${cwd} && git ${conflictArgs}`