@fugood/bricks-ctor 2.25.0-beta.60 → 2.25.0-beta.61

package/tools/mcp-tools/data-calc-editing.ts

@@ -1,1311 +0,0 @@
-import generateModule from '@babel/generator'
-import { parse, parseExpression } from '@babel/parser'
-import * as t from '@babel/types'
-import { parse as parseSandboxModule } from 'acorn'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { format as formatWithOxfmt } from 'oxfmt'
-import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import { z } from 'zod'
-
-import { verifyProject } from './_verify'
-import {
-  ensureBricksCtorImport,
-  getObjectProperty,
-  getStringProperty,
-  insertImport,
-  isRecord,
-  makeObjectKey,
-  oxfmtOptions,
-  projectRelativePath,
-  removeObjectProperty,
-  setObjectProperty,
-} from './_editing-helpers'
-import { appendEditRecord, editProvenance } from '../_edits-log'
-
-const generate = (generateModule as any).default || generateModule
-
-type ParsedFile = {
-  ast: t.File
-  source: string
-  absPath: string
-  relPath: string
-}
-
-type ExportEntry = {
-  name: string
-  object?: t.ObjectExpression
-  id?: string
-  alias?: string
-  typeName?: string
-}
-
-type ReferenceResolution = {
-  input: string
-  id?: string
-  alias?: string
-  varName: string
-  sameFile: boolean
-  importSource?: string
-}
-
-type EditContext = {
-  projectDir: string
-  parsed: ParsedFile
-  references: ReferenceResolution[]
-  typeImports: Set<string>
-  valueImports: Set<string>
-}
-
-type CalcTarget = {
-  parsed: ParsedFile
-  object: t.ObjectExpression
-  slug: string
-  sandboxFile: string
-}
-
-class DataCalcEditingError extends Error {
-  code: string
-  details?: Record<string, unknown>
-  isMcpError: boolean
-
-  constructor(
-    code: string,
-    message: string,
-    details?: Record<string, unknown>,
-    isMcpError = false,
-  ) {
-    super(message)
-    this.name = 'DataCalcEditingError'
-    this.code = code
-    this.details = details
-    this.isMcpError = isMcpError
-  }
-}
-
-const resolveProjectPath = (projectDir: string, file: string) => {
-  if (path.isAbsolute(file)) {
-    throw new DataCalcEditingError('invalid_file', 'File must be project-relative', { file })
-  }
-
-  const absPath = path.resolve(projectDir, file)
-  const relative = path.relative(projectDir, absPath)
-  if (relative.startsWith('..') || path.isAbsolute(relative)) {
-    throw new DataCalcEditingError('invalid_file', 'File must stay inside the project directory', {
-      file,
-    })
-  }
-  return absPath
-}
-
-const parseFileSource = (source: string, relPath: string) => {
-  try {
-    return parse(source, {
-      sourceType: 'module',
-      plugins: ['typescript', 'topLevelAwait'],
-      errorRecovery: false,
-    })
-  } catch (err: any) {
-    throw new DataCalcEditingError(
-      'parse_failed',
-      `Cannot parse ${relPath} as TypeScript: ${err.message}. Edit this file directly.`,
-      { file: relPath },
-      true,
-    )
-  }
-}
-
-const readParsedFile = async (projectDir: string, absPath: string): Promise<ParsedFile> => {
-  const source = await readFile(absPath, 'utf8')
-  const relPath = projectRelativePath(projectDir, absPath)
-  return {
-    source,
-    ast: parseFileSource(source, relPath),
-    absPath,
-    relPath,
-  }
-}
-
-const getExportEntries = (ast: t.File): ExportEntry[] =>
-  ast.program.body.flatMap((statement) => {
-    if (!t.isExportNamedDeclaration(statement)) return []
-    if (!t.isVariableDeclaration(statement.declaration)) return []
-    return statement.declaration.declarations.flatMap((declarator) => {
-      if (!t.isIdentifier(declarator.id)) return []
-
-      const typeAnnotation = declarator.id.typeAnnotation
-      let typeName: string | undefined
-      if (
-        t.isTSTypeAnnotation(typeAnnotation) &&
-        t.isTSTypeReference(typeAnnotation.typeAnnotation) &&
-        t.isIdentifier(typeAnnotation.typeAnnotation.typeName)
-      ) {
-        typeName = typeAnnotation.typeAnnotation.typeName.name
-      }
-
-      const object = t.isObjectExpression(declarator.init) ? declarator.init : undefined
-      return [
-        {
-          name: declarator.id.name,
-          object,
-          id: object ? getStringProperty(object, 'id') : undefined,
-          alias: object ? getStringProperty(object, 'alias') : undefined,
-          typeName,
-        },
-      ]
-    })
-  })
-
-const getCalcDirFromSubspaceDir = (subspaceDir: string) => path.join(subspaceDir, 'data-calc')
-
-const getSubspaceDirFromCalcFile = (absPath: string) => {
-  const parts = absPath.split(path.sep)
-  const index = parts.findIndex((part) => /^subspace-\d+$/.test(part))
-  if (index < 0) {
-    throw new DataCalcEditingError(
-      'invalid_file',
-      'Data-calc file must be inside subspaces/subspace-N/data-calc',
-      { file: absPath },
-    )
-  }
-  return parts.slice(0, index + 1).join(path.sep)
-}
-
-const resolveSubspaceDir = (projectDir: string, subspace?: string | number) => {
-  if (subspace == null || subspace === '') return path.join(projectDir, 'subspaces/subspace-0')
-  if (typeof subspace === 'number') {
-    return path.join(projectDir, 'subspaces', `subspace-${subspace}`)
-  }
-
-  const normalized = String(subspace)
-  if (/^\d+$/.test(normalized)) return path.join(projectDir, 'subspaces', `subspace-${normalized}`)
-  if (/^subspace-\d+$/.test(normalized)) return path.join(projectDir, 'subspaces', normalized)
-  if (normalized.includes('/')) return resolveProjectPath(projectDir, normalized)
-
-  throw new DataCalcEditingError(
-    'unsupported_subspace',
-    `Unsupported subspace locator: ${normalized}`,
-    {
-      subspace: normalized,
-    },
-  )
-}
-
-const calcSlugFromFile = (absPath: string) => {
-  const basename = path.basename(absPath)
-  const match = /^data-calculation-(.+)\.ts$/.exec(basename)
-  if (!match) {
-    throw new DataCalcEditingError('invalid_file', 'Expected data-calculation-{slug}.ts file', {
-      file: absPath,
-    })
-  }
-  return match[1]
-}
-
-const getDataCalcFiles = async (dataCalcDir: string) => {
-  const entries = await readdir(dataCalcDir, { withFileTypes: true }).catch(() => [])
-  return entries
-    .filter(
-      (entry) =>
-        entry.isFile() &&
-        /^data-calculation-.+\.ts$/.test(entry.name) &&
-        !entry.name.endsWith('.sandbox.ts'),
-    )
-    .map((entry) => path.join(dataCalcDir, entry.name))
-    .sort()
-}
-
-const extractCalcObject = (parsed: ParsedFile) => {
-  const entries = getExportEntries(parsed.ast)
-  const calcEntry = entries.find((entry) => entry.name === 'dataCalculation')
-  if (!calcEntry || !calcEntry.object) {
-    throw new DataCalcEditingError(
-      'fallback_recommended',
-      `Data calc ${parsed.relPath} is not a single exported object literal. Edit this file directly for this one.`,
-      { file: parsed.relPath, check: 'export const dataCalculation object literal' },
-    )
-  }
-
-  const typename = getStringProperty(calcEntry.object, '__typename')
-  if (typename !== 'DataCalculationScript') {
-    throw new DataCalcEditingError(
-      'fallback_recommended',
-      `Data calc ${parsed.relPath} is ${typename || 'not DataCalculationScript'}. DataCalculationMap is out of scope; edit this file directly.`,
-      { file: parsed.relPath, typename },
-    )
-  }
-
-  return calcEntry.object
-}
-
-const getCodeExpression = (object: t.ObjectExpression): t.Expression | null => {
-  const value = getObjectProperty(object, 'code')?.value
-  return value && t.isExpression(value) ? value : null
-}
-
-// Sibling sandbox files only: a plain `./name.sandbox.js` basename. Anything else
-// (nested paths, ../ traversal, non-sandbox files) is not ours to rewrite or delete.
-const isSandboxFilename = (value: string) => /^(\.\/)?[^/\\]+\.sandbox\.js$/.test(value)
-
-const readCodeUrlFilename = (code: t.Expression | null | undefined) => {
-  const expression = t.isAwaitExpression(code) ? code.argument : code
-  if (!t.isCallExpression(expression)) return null
-  const firstArg = expression.arguments[0]
-  if (!t.isNewExpression(firstArg)) return null
-  if (!t.isIdentifier(firstArg.callee) || firstArg.callee.name !== 'URL') return null
-  const filenameArg = firstArg.arguments[0]
-  if (!t.isStringLiteral(filenameArg)) return null
-  return filenameArg.value
-}
-
-const sandboxFilenameFromCodeExpression = (
-  code: t.Expression | null | undefined,
-  fallbackSlug: string,
-) => {
-  const filename = readCodeUrlFilename(code)
-  if (!filename || !isSandboxFilename(filename)) {
-    return `data-calculation-${fallbackSlug}.sandbox.js`
-  }
-  return filename.replace(/^\.\//, '')
-}
-
-const isRecognizedCodeExpression = (code: t.Expression | null | undefined) => {
-  if (!code) return false
-  if (t.isStringLiteral(code) || t.isTemplateLiteral(code)) return true
-  const filename = readCodeUrlFilename(code)
-  return filename != null && isSandboxFilename(filename)
-}
-
-const resolveCalcTarget = async (projectDir: string, input: any): Promise<CalcTarget> => {
-  let absPath: string | undefined
-
-  if (input.file) {
-    absPath = resolveProjectPath(projectDir, input.file)
-  } else {
-    const subspaceDir = resolveSubspaceDir(projectDir, input.subspace)
-    const calcDir = getCalcDirFromSubspaceDir(subspaceDir)
-    const files = await getDataCalcFiles(calcDir)
-    const calc = input.calc
-    if (!calc) {
-      throw new DataCalcEditingError('missing_calc', 'Provide file or subspace+calc')
-    }
-
-    for (const file of files) {
-      if (calc === calcSlugFromFile(file)) {
-        absPath = file
-        break
-      }
-      // Tolerate unparseable / non-Script siblings while scanning: they only opt out
-      // of alias/id matching here; standard-style checks run on the resolved target.
-      try {
-        const parsed = await readParsedFile(projectDir, file)
-        const entry = getExportEntries(parsed.ast).find((item) => item.name === 'dataCalculation')
-        if (entry && (calc === entry.alias || calc === entry.id)) {
-          absPath = file
-          break
-        }
-      } catch {
-        continue
-      }
-    }
-  }
-
-  if (!absPath) {
-    throw new DataCalcEditingError('calc_not_found', `Data calc not found: ${input.calc}`, {
-      calc: input.calc,
-      subspace: input.subspace ?? 'subspace-0',
-    })
-  }
-
-  const parsed = await readParsedFile(projectDir, absPath)
-  const object = extractCalcObject(parsed)
-  const slug = calcSlugFromFile(absPath)
-  const sandboxFile = sandboxFilenameFromCodeExpression(getCodeExpression(object), slug)
-  return { parsed, object, slug, sandboxFile }
-}
-
-const relativeImportSource = (fromFile: string, toFile: string) => {
-  let rel = path.relative(path.dirname(fromFile), toFile).replace(/\\/g, '/')
-  if (!rel.startsWith('.')) rel = `./${rel}`
-  return rel.replace(/\.(ts|tsx|js|jsx)$/, '')
-}
-
-const ensureNamespaceImport = (parsed: ParsedFile, source: string, preferredLocal: string) => {
-  for (const statement of parsed.ast.program.body) {
-    if (!t.isImportDeclaration(statement) || statement.source.value !== source) continue
-    const namespace = statement.specifiers.find(
-      (specifier): specifier is t.ImportNamespaceSpecifier =>
-        t.isImportNamespaceSpecifier(specifier),
-    )
-    if (namespace) return namespace.local.name
-  }
-
-  const declaration = t.importDeclaration(
-    [t.importNamespaceSpecifier(t.identifier(preferredLocal))],
-    t.stringLiteral(source),
-  )
-  insertImport(parsed.ast, declaration)
-  return preferredLocal
-}
-
-const ensureReadFileImport = (ast: t.File) => {
-  for (const statement of ast.program.body) {
-    if (!t.isImportDeclaration(statement) || statement.source.value !== 'node:fs/promises') {
-      continue
-    }
-    const hasReadFile = statement.specifiers.some(
-      (specifier) =>
-        t.isImportSpecifier(specifier) &&
-        t.isIdentifier(specifier.imported) &&
-        specifier.imported.name === 'readFile',
-    )
-    if (!hasReadFile) {
-      statement.specifiers.push(
-        t.importSpecifier(t.identifier('readFile'), t.identifier('readFile')),
-      )
-    }
-    return
-  }
-
-  insertImport(
-    ast,
-    t.importDeclaration(
-      [t.importSpecifier(t.identifier('readFile'), t.identifier('readFile'))],
-      t.stringLiteral('node:fs/promises'),
-    ),
-  )
-}
-
-const applyPendingImports = (ctx: EditContext) => {
-  ensureBricksCtorImport(ctx.parsed.ast, 'type', ctx.typeImports)
-  ensureBricksCtorImport(ctx.parsed.ast, 'value', ctx.valueImports)
-}
-
-const resolveDataReference = async (
-  projectDir: string,
-  currentFile: string,
-  ref: string,
-  subspace?: string | number,
-): Promise<ReferenceResolution> => {
-  const currentSubspaceDir = getSubspaceDirFromCalcFile(currentFile)
-  const targetSubspaceDir =
-    subspace == null ? currentSubspaceDir : resolveSubspaceDir(projectDir, subspace)
-  const dataFile = path.join(targetSubspaceDir, 'data.ts')
-  const parsed = await readParsedFile(projectDir, dataFile)
-  const matches = getExportEntries(parsed.ast).filter(
-    (entry) => entry.name === ref || entry.id === ref || entry.alias === ref,
-  )
-
-  if (matches.length === 0) {
-    throw new DataCalcEditingError('reference_not_found', `Data reference not found: ${ref}`, {
-      ref,
-      subspace: path.basename(targetSubspaceDir),
-    })
-  }
-  if (matches.length > 1) {
-    throw new DataCalcEditingError('ambiguous_reference', `Data reference is ambiguous: ${ref}`, {
-      ref,
-      matches: matches.map((match) => ({
-        file: projectRelativePath(projectDir, dataFile),
-        entry: match.name,
-        id: match.id,
-        alias: match.alias,
-      })),
-    })
-  }
-
-  const sameFile = path.resolve(dataFile) === path.resolve(currentFile)
-  return {
-    input: ref,
-    id: matches[0].id,
-    alias: matches[0].alias,
-    varName: matches[0].name,
-    sameFile,
-    importSource: sameFile ? undefined : relativeImportSource(currentFile, dataFile),
-  }
-}
-
-const dataGetterExpression = async (input: any, ctx: EditContext): Promise<t.Expression> => {
-  if (isRecord(input) && typeof input.expr === 'string') {
-    return parseExpression(input.expr, { plugins: ['typescript'] }) as t.Expression
-  }
-
-  const ref = typeof input === 'string' ? input : isRecord(input) ? input.ref : undefined
-  if (typeof ref !== 'string' || !ref) {
-    throw new DataCalcEditingError('invalid_ref', 'Data getter requires a data ref string')
-  }
-
-  const resolved = await resolveDataReference(
-    ctx.projectDir,
-    ctx.parsed.absPath,
-    ref,
-    isRecord(input) ? (input.subspace as any) : undefined,
-  )
-  const local = resolved.sameFile
-    ? 'data'
-    : ensureNamespaceImport(ctx.parsed, resolved.importSource || '../data', 'data')
-  ctx.references.push(resolved)
-  return t.arrowFunctionExpression(
-    [],
-    t.memberExpression(t.identifier(local), t.identifier(resolved.varName)),
-  )
-}
-
-const nullableDataGetterExpression = async (value: any, ctx: EditContext) => {
-  if (value == null) return t.nullLiteral()
-  return dataGetterExpression(value, ctx)
-}
-
-// Alias-keyed makeId calls hash to the same uuid regardless of declaration order, so
-// recompiles stay stable when sibling entries are added or removed.
-const makeIdCallExpression = (idType: string, alias?: string) =>
-  t.callExpression(
-    t.identifier('makeId'),
-    alias ? [t.stringLiteral(idType), t.stringLiteral(alias)] : [t.stringLiteral(idType)],
-  )
-
-// True when another calc anywhere in the project already uses the alias — the aliased
-// makeId form would collide at compile time.
-const aliasUsedInCalcs = async (projectDir: string, alias: string) => {
-  const subspacesDir = path.join(projectDir, 'subspaces')
-  const entries = await readdir(subspacesDir, { withFileTypes: true }).catch(() => [])
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !/^subspace-\d+$/.test(entry.name)) continue
-    const files = await getDataCalcFiles(path.join(subspacesDir, entry.name, 'data-calc'))
-    for (const file of files) {
-      try {
-        const parsed = await readParsedFile(projectDir, file)
-        const calcEntry = getExportEntries(parsed.ast).find(
-          (item) => item.name === 'dataCalculation',
-        )
-        if (calcEntry?.alias === alias) return true
-      } catch {
-        continue
-      }
-    }
-  }
-  return false
-}
-
-// Required by the DataCalculationScript type; unsetting them yields a calc that
-// crashes compile with an unrelated-looking error instead of a clear refusal here.
-const requiredCalcFields = new Set([
-  '__typename',
-  'id',
-  'code',
-  'enableAsync',
-  'inputs',
-  'output',
-  'outputs',
-  'error',
-])
-
-const makeCodeReadFileExpression = (sandboxFile: string) =>
-  t.awaitExpression(
-    t.callExpression(t.identifier('readFile'), [
-      t.newExpression(t.identifier('URL'), [
-        t.stringLiteral(`./${sandboxFile}`),
-        t.memberExpression(
-          t.metaProperty(t.identifier('import'), t.identifier('meta')),
-          t.identifier('url'),
-        ),
-      ]),
-      t.stringLiteral('utf8'),
-    ]),
-  )
-
-const expressionFromInput = async (input: any, ctx: EditContext): Promise<t.Expression> => {
-  if (isRecord(input)) {
-    if (typeof input.expr === 'string') {
-      return parseExpression(input.expr, { plugins: ['typescript'] }) as t.Expression
-    }
-    if (typeof input.ref === 'string') return dataGetterExpression(input, ctx)
-  }
-  if (input === null) return t.nullLiteral()
-  if (input === undefined) return t.identifier('undefined')
-  if (typeof input === 'string') return t.stringLiteral(input)
-  if (typeof input === 'number') return t.numericLiteral(input)
-  if (typeof input === 'boolean') return t.booleanLiteral(input)
-  if (Array.isArray(input)) {
-    return t.arrayExpression(
-      await Promise.all(input.map((value) => expressionFromInput(value, ctx))),
-    )
-  }
-  if (isRecord(input)) {
-    const properties = await Promise.all(
-      Object.entries(input).map(async ([key, value]) =>
-        t.objectProperty(makeObjectKey(key), await expressionFromInput(value, ctx)),
-      ),
-    )
-    return t.objectExpression(properties)
-  }
-  throw new DataCalcEditingError('invalid_value', `Unsupported value: ${String(input)}`)
-}
-
-const printAndFormat = async (parsed: ParsedFile) => {
-  const generated = generate(parsed.ast, { comments: true }, parsed.source).code
-  const formatted = await formatWithOxfmt(parsed.absPath, generated, oxfmtOptions)
-  if (formatted.errors.length > 0) {
-    throw new DataCalcEditingError('format_failed', `oxfmt failed for ${parsed.relPath}`, {
-      file: parsed.relPath,
-      errors: formatted.errors,
-    })
-  }
-  return formatted.code
-}
-
-const writeParsedFile = async (parsed: ParsedFile) => {
-  const code = await printAndFormat(parsed)
-  parseFileSource(code, parsed.relPath)
-  await writeFile(parsed.absPath, code)
-  return code
-}
-
-const responseFor = (result: any): any => ({
-  content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }],
-  isError: result.isError || undefined,
-})
-
-const referenceInputDetails = (references: ReferenceResolution[]) =>
-  references.map((reference) => ({
-    input: reference.input,
-    id: reference.id,
-    alias: reference.alias,
-    entry: reference.varName,
-  }))
-
-const runOperation = async (
-  projectDir: string,
-  tool: string,
-  input: any,
-  operation: () => Promise<any>,
-) => {
-  const startedAt = new Date().toISOString()
-  const provenance = editProvenance()
-  try {
-    const result = await operation()
-    await appendEditRecord(projectDir, {
-      ts: startedAt,
-      tool,
-      input,
-      provenance,
-      outcome: result.outcome,
-      summary: result.summary,
-      result,
-    })
-    return result
-  } catch (err: any) {
-    const isMcpError = err instanceof DataCalcEditingError
-    const outcome =
-      isMcpError && err.code === 'fallback_recommended' ? 'fallback_recommended' : 'error'
-    const result = {
-      outcome,
-      // Fallback recommendations are guidance, not MCP errors (mirrors entry-editing).
-      isError: outcome === 'error',
-      error: {
-        code: isMcpError ? err.code : 'unexpected_error',
-        message: err.message,
-        details: isMcpError ? err.details : undefined,
-      },
-      summary: `${tool} failed: ${err.message}`,
-    }
-    await appendEditRecord(projectDir, {
-      ts: startedAt,
-      tool,
-      input,
-      provenance,
-      outcome: result.outcome,
-      summary: result.summary,
-      error: result.error,
-    }).catch(() => undefined)
-    return result
-  }
-}
-
-const slugify = (value: string) => {
-  const slug = value
-    .trim()
-    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-  return slug || 'calc'
-}
-
-const nextFreeSlug = async (dataCalcDir: string, preferred?: string) => {
-  const existing = new Set((await getDataCalcFiles(dataCalcDir)).map(calcSlugFromFile))
-  if (preferred) {
-    let slug = slugify(preferred)
-    if (!existing.has(slug)) return slug
-    let index = 1
-    while (existing.has(`${slug}-${index}`)) index += 1
-    return `${slug}-${index}`
-  }
-
-  let index = 0
-  while (existing.has(String(index))) index += 1
-  return String(index)
-}
-
-// Compile unwraps the sandbox with the same acorn parse (compile/index.ts
-// compileScriptCalculationCode, ecmaVersion 2020) and silently falls back to the raw
-// wrapped string when it fails, so an unparseable sandbox must be rejected here.
-const sandboxParses = (source: string) => {
-  try {
-    parseSandboxModule(source, { sourceType: 'module', ecmaVersion: 2020 })
-    return true
-  } catch {
-    return false
-  }
-}
-
-const wrapSandboxCode = (code?: string) => {
-  const body = code ?? ''
-  if (/export\s+(async\s+)?function\s+main\s*\(/.test(body)) {
-    const wrapped = body.endsWith('\n') ? body : `${body}\n`
-    if (!sandboxParses(wrapped)) {
-      throw new DataCalcEditingError(
-        'invalid_code',
-        'Sandbox code does not parse as a module (note: top-level await requires export async function main)',
-      )
-    }
-    return wrapped
-  }
-  const trimmed = body.trim()
-  if (!trimmed) return 'export function main() {\n}\n'
-  // Bodies using top-level await (enableAsync mode) only parse inside an async main;
-  // compile unwraps either wrapper form to the same script body.
-  for (const asyncPrefix of ['', 'async ']) {
-    const wrapped = `export ${asyncPrefix}function main() {\n${trimmed}\n}\n`
-    if (sandboxParses(wrapped)) return wrapped
-  }
-  throw new DataCalcEditingError(
-    'invalid_code',
-    'Sandbox code does not parse as a script body (statements with top-level return)',
-  )
-}
-
-const regenerateDataCalcIndex = async (projectDir: string, dataCalcDir: string) => {
-  await mkdir(dataCalcDir, { recursive: true })
-  const files = await getDataCalcFiles(dataCalcDir)
-  const imports = files
-    .map((file, index) => {
-      const slug = calcSlugFromFile(file)
-      return `import { dataCalculation as dataCalculation${index} } from './data-calculation-${slug}'`
-    })
-    .join('\n')
-  const list = files.map((_, index) => `dataCalculation${index}`).join(',\n  ')
-  const source = `${imports}
-
-export const dataCalculation = [
-  ${list}
-]
-`
-  const indexPath = path.join(dataCalcDir, 'index.ts')
-  const parsed: ParsedFile = {
-    absPath: indexPath,
-    relPath: projectRelativePath(projectDir, indexPath),
-    source,
-    ast: parseFileSource(source, projectRelativePath(projectDir, indexPath)),
-  }
-  await writeParsedFile(parsed)
-  return projectRelativePath(projectDir, indexPath)
-}
-
-const getDefaultExportObject = (ast: t.File) => {
-  for (const statement of ast.program.body) {
-    if (!t.isExportDefaultDeclaration(statement)) continue
-    const declaration = statement.declaration
-    if (t.isObjectExpression(declaration)) return declaration
-    if (t.isTSAsExpression(declaration) && t.isObjectExpression(declaration.expression)) {
-      return declaration.expression
-    }
-  }
-  return null
-}
-
-const ensureSubspaceRootDataCalcImport = async (
-  projectDir: string,
-  subspaceDir: string,
-): Promise<{ touched?: string; warning?: string } | null> => {
-  const indexPath = path.join(subspaceDir, 'index.ts')
-  const relPath = projectRelativePath(projectDir, indexPath)
-  const source = await readFile(indexPath, 'utf8').catch((err: any) => {
-    if (err?.code === 'ENOENT') return null
-    throw err
-  })
-  if (source == null) {
-    return { warning: `${relPath} not found; wire the data-calc import manually` }
-  }
-
-  const parsed = await readParsedFile(projectDir, indexPath)
-  const object = getDefaultExportObject(parsed.ast)
-  if (!object) {
-    return {
-      warning: `${relPath} has no default-export object; wire the data-calc import manually`,
-    }
-  }
-
-  const property = getObjectProperty(object, 'dataCalculation')
-  if (property && t.isIdentifier(property.value)) return null
-  if (property && !(t.isArrayExpression(property.value) && property.value.elements.length === 0)) {
-    // Only the codegen minimal-subspace shape (dataCalculation: []) is safe to rewire;
-    // replacing any other value (inline calcs, spreads) would silently drop config.
-    return {
-      warning: `${relPath} has a non-empty dataCalculation value; wire the data-calc import manually`,
-    }
-  }
-
-  const alreadyImported = parsed.ast.program.body.some(
-    (statement) =>
-      t.isImportDeclaration(statement) &&
-      (statement.source.value === './data-calc' || statement.source.value === './data-calc/index'),
-  )
-  if (!alreadyImported) {
-    insertImport(
-      parsed.ast,
-      t.importDeclaration(
-        [t.importSpecifier(t.identifier('dataCalculation'), t.identifier('dataCalculation'))],
-        t.stringLiteral('./data-calc'),
-      ),
-    )
-  }
-
-  if (!property) {
-    const dataCalculationProperty = t.objectProperty(
-      t.identifier('dataCalculation'),
-      t.identifier('dataCalculation'),
-    )
-    dataCalculationProperty.shorthand = true
-    object.properties.push(dataCalculationProperty)
-  } else {
-    property.value = t.identifier('dataCalculation')
-    if (t.isIdentifier(property.key)) property.shorthand = true
-  }
-
-  await writeParsedFile(parsed)
-  return { touched: parsed.relPath }
-}
-
-const buildIoObject = async (field: 'inputs' | 'outputs', input: any, ctx: EditContext) => {
-  if (!input.key) {
-    throw new DataCalcEditingError('missing_key', `${field} item requires key`)
-  }
-  if (input.data == null) {
-    throw new DataCalcEditingError('missing_data', `${field} item requires data`)
-  }
-  const properties: t.ObjectProperty[] = [
-    t.objectProperty(t.identifier('key'), t.stringLiteral(input.key)),
-    t.objectProperty(t.identifier('data'), await dataGetterExpression(input.data, ctx)),
-  ]
-  if (field === 'inputs') {
-    properties.push(
-      t.objectProperty(t.identifier('trigger'), t.booleanLiteral(input.trigger !== false)),
-    )
-  }
-  return t.objectExpression(properties)
-}
-
-const buildIoArrayExpression = async (
-  field: 'inputs' | 'outputs',
-  items: any[],
-  ctx: EditContext,
-) => {
-  if (field === 'inputs') {
-    const keys = new Set<string>()
-    for (const item of items) {
-      if (keys.has(item?.key)) {
-        throw new DataCalcEditingError('duplicate_key', `Input key already exists: ${item.key}`, {
-          key: item.key,
-        })
-      }
-      keys.add(item?.key)
-    }
-  }
-  return t.arrayExpression(await Promise.all(items.map((item) => buildIoObject(field, item, ctx))))
-}
-
-const getOrCreateArrayProperty = (object: t.ObjectExpression, key: string) => {
-  const existing = getObjectProperty(object, key)
-  if (existing) {
-    if (!t.isArrayExpression(existing.value)) {
-      throw new DataCalcEditingError(
-        'fallback_recommended',
-        `${key} is not an array. Edit this file directly.`,
-      )
-    }
-    return existing.value
-  }
-  const array = t.arrayExpression([])
-  object.properties.push(t.objectProperty(t.identifier(key), array))
-  return array
-}
-
-const findIoIndex = (array: t.ArrayExpression, target: { key?: string; index?: number }) => {
-  if (typeof target.index === 'number') return target.index
-  if (!target.key) return -1
-  const matches = array.elements
-    .map((element, index) => ({ element, index }))
-    .filter(
-      ({ element }) =>
-        t.isObjectExpression(element) && getStringProperty(element, 'key') === target.key,
-    )
-  if (matches.length > 1) {
-    throw new DataCalcEditingError('ambiguous_key', `IO key is ambiguous: ${target.key}`, {
-      key: target.key,
-      count: matches.length,
-    })
-  }
-  return matches[0]?.index ?? -1
-}
-
-const assertInputKeyUnique = (array: t.ArrayExpression, key: string, ignoreIndex?: number) => {
-  const duplicate = array.elements.some(
-    (element, index) =>
-      index !== ignoreIndex &&
-      t.isObjectExpression(element) &&
-      getStringProperty(element, 'key') === key,
-  )
-  if (duplicate) {
-    throw new DataCalcEditingError('duplicate_key', `Input key already exists: ${key}`, { key })
-  }
-}
-
-const buildCalcObject = async (
-  input: any,
-  sandboxFile: string,
-  ctx: EditContext,
-  stableIdAlias?: string,
-) => {
-  ctx.typeImports.add('DataCalculationScript')
-  ctx.valueImports.add('makeId')
-  ensureReadFileImport(ctx.parsed.ast)
-
-  const properties: t.ObjectProperty[] = [
-    t.objectProperty(t.identifier('__typename'), t.stringLiteral('DataCalculationScript')),
-    t.objectProperty(
-      t.identifier('id'),
-      input.id
-        ? t.stringLiteral(input.id)
-        : makeIdCallExpression('property_bank_calc', stableIdAlias),
-    ),
-  ]
-  if (input.alias)
-    properties.push(t.objectProperty(t.identifier('alias'), t.stringLiteral(input.alias)))
-  if (input.title != null)
-    properties.push(t.objectProperty(t.identifier('title'), t.stringLiteral(input.title)))
-  if (input.description != null) {
-    properties.push(
-      t.objectProperty(t.identifier('description'), t.stringLiteral(input.description)),
-    )
-  }
-  if (input.note != null)
-    properties.push(t.objectProperty(t.identifier('note'), t.stringLiteral(input.note)))
-
-  properties.push(t.objectProperty(t.identifier('code'), makeCodeReadFileExpression(sandboxFile)))
-  properties.push(
-    t.objectProperty(t.identifier('enableAsync'), t.booleanLiteral(!!input.enableAsync)),
-  )
-  if (input.triggerMode != null) {
-    properties.push(
-      t.objectProperty(t.identifier('triggerMode'), t.stringLiteral(input.triggerMode)),
-    )
-  }
-
-  properties.push(
-    t.objectProperty(
-      t.identifier('inputs'),
-      await buildIoArrayExpression('inputs', input.inputs || [], ctx),
-    ),
-  )
-  properties.push(
-    t.objectProperty(t.identifier('output'), await nullableDataGetterExpression(input.output, ctx)),
-  )
-  properties.push(
-    t.objectProperty(
-      t.identifier('outputs'),
-      await buildIoArrayExpression('outputs', input.outputs || [], ctx),
-    ),
-  )
-  properties.push(
-    t.objectProperty(t.identifier('error'), await nullableDataGetterExpression(input.error, ctx)),
-  )
-
-  return t.objectExpression(properties)
-}
-
-const createCalcParsedFile = (projectDir: string, absPath: string): ParsedFile => {
-  const relPath = projectRelativePath(projectDir, absPath)
-  const source = 'export const dataCalculation = {}\n'
-  const ast = parseFileSource(source, relPath)
-  ast.program.body = []
-  return { ast, source, absPath, relPath }
-}
-
-const newDataCalc = async (projectDir: string, input: any) =>
-  runOperation(projectDir, 'new_data_calc', input, async () => {
-    const subspaceDir = resolveSubspaceDir(projectDir, input.subspace)
-    const dataCalcDir = getCalcDirFromSubspaceDir(subspaceDir)
-    await mkdir(dataCalcDir, { recursive: true })
-    const slug = await nextFreeSlug(dataCalcDir, input.alias)
-    const sandboxFile = `data-calculation-${slug}.sandbox.js`
-    const calcPath = path.join(dataCalcDir, `data-calculation-${slug}.ts`)
-    const sandboxPath = path.join(dataCalcDir, sandboxFile)
-    const parsed = createCalcParsedFile(projectDir, calcPath)
-    const ctx: EditContext = {
-      projectDir,
-      parsed,
-      references: [],
-      typeImports: new Set(),
-      valueImports: new Set(),
-    }
-    const stableIdAlias =
-      !input.id &&
-      typeof input.alias === 'string' &&
-      input.alias &&
-      !(await aliasUsedInCalcs(projectDir, input.alias))
-        ? input.alias
-        : undefined
-    const object = await buildCalcObject(input, sandboxFile, ctx, stableIdAlias)
-    const declarator = t.variableDeclarator(t.identifier('dataCalculation'), object)
-    ;(declarator.id as t.Identifier).typeAnnotation = t.tsTypeAnnotation(
-      t.tsTypeReference(t.identifier('DataCalculationScript')),
-    )
-    parsed.ast.program.body.push(
-      t.exportNamedDeclaration(t.variableDeclaration('const', [declarator])),
-    )
-    applyPendingImports(ctx)
-
-    await writeFile(sandboxPath, wrapSandboxCode(input.code))
-    await writeParsedFile(parsed)
-    const touchedSites = [
-      { file: projectRelativePath(projectDir, calcPath), action: 'create_calc' },
-      { file: projectRelativePath(projectDir, sandboxPath), action: 'write_sandbox' },
-    ]
-    touchedSites.push({
-      file: await regenerateDataCalcIndex(projectDir, dataCalcDir),
-      action: 'regenerate_index',
-    })
-    const rootWiring = await ensureSubspaceRootDataCalcImport(projectDir, subspaceDir)
-    if (rootWiring?.touched) {
-      touchedSites.push({ file: rootWiring.touched, action: 'wire_subspace_index' })
-    }
-
-    const verify = await verifyProject(projectDir, input.verify)
-    return {
-      file: projectRelativePath(projectDir, calcPath),
-      subspace: path.basename(subspaceDir),
-      calc: slug,
-      idExpression:
-        input.id ??
-        (stableIdAlias
-          ? `makeId('property_bank_calc', '${stableIdAlias}')`
-          : "makeId('property_bank_calc')"),
-      outcome: verify.status === 'compile:failed' ? 'verify_failed' : 'ok',
-      touchedSites,
-      ...(rootWiring?.warning ? { warnings: [rootWiring.warning] } : {}),
-      verify,
-      references: referenceInputDetails(ctx.references),
-      summary: `created data calc ${slug} in ${path.basename(subspaceDir)} -> ${verify.status}`,
-    }
-  })
-
-const editDataCalc = async (projectDir: string, input: any) =>
-  runOperation(projectDir, 'edit_data_calc', input, async () => {
-    const target = await resolveCalcTarget(projectDir, input)
-    const ctx: EditContext = {
-      projectDir,
-      parsed: target.parsed,
-      references: [],
-      typeImports: new Set(),
-      valueImports: new Set(),
-    }
-    const touchedSites: Array<Record<string, unknown>> = []
-
-    for (const [key, value] of Object.entries(input.set || {})) {
-      if (key === 'output' || key === 'error') {
-        setObjectProperty(target.object, key, await nullableDataGetterExpression(value, ctx))
-      } else if (key === 'inputs' || key === 'outputs') {
-        if (!Array.isArray(value)) {
-          throw new DataCalcEditingError('invalid_value', `${key} must be an array of IO items`)
-        }
-        setObjectProperty(target.object, key, await buildIoArrayExpression(key, value, ctx))
-      } else if (key === 'code') {
-        throw new DataCalcEditingError(
-          'invalid_field',
-          'Set code via the dedicated code parameter so it stays normalized to the sandbox file',
-        )
-      } else {
-        setObjectProperty(target.object, key, await expressionFromInput(value, ctx))
-      }
-    }
-    for (const key of input.unset || []) {
-      if (requiredCalcFields.has(key)) {
-        throw new DataCalcEditingError('invalid_field', `Cannot unset required field: ${key}`, {
-          field: key,
-        })
-      }
-      removeObjectProperty(target.object, key)
-    }
-
-    if (input.code != null) {
-      const codeExpression = getCodeExpression(target.object)
-      if (!isRecognizedCodeExpression(codeExpression)) {
-        throw new DataCalcEditingError(
-          'fallback_recommended',
-          `Data calc ${target.parsed.relPath} has an unsupported code expression. Edit this file directly for this one.`,
-          { file: target.parsed.relPath, field: 'code' },
-        )
-      }
-      const sandboxFile = target.sandboxFile
-      const sandboxPath = path.join(path.dirname(target.parsed.absPath), sandboxFile)
-      await writeFile(sandboxPath, wrapSandboxCode(input.code))
-      ensureReadFileImport(target.parsed.ast)
-      setObjectProperty(target.object, 'code', makeCodeReadFileExpression(sandboxFile))
-      touchedSites.push({
-        file: projectRelativePath(projectDir, sandboxPath),
-        action: 'write_sandbox',
-      })
-    }
-
-    applyPendingImports(ctx)
-    await writeParsedFile(target.parsed)
-    touchedSites.unshift({ file: target.parsed.relPath, action: 'edit_calc' })
-    const verify = await verifyProject(projectDir, input.verify)
-    return {
-      file: target.parsed.relPath,
-      calc: target.slug,
-      outcome: verify.status === 'compile:failed' ? 'verify_failed' : 'ok',
-      touchedSites,
-      verify,
-      references: referenceInputDetails(ctx.references),
-      summary: `edited data calc ${target.slug} -> ${verify.status}`,
-    }
-  })
-
-const editDataCalcIo = async (projectDir: string, input: any) =>
-  runOperation(projectDir, 'edit_data_calc_io', input, async () => {
-    const target = await resolveCalcTarget(projectDir, input)
-    const ctx: EditContext = {
-      projectDir,
-      parsed: target.parsed,
-      references: [],
-      typeImports: new Set(),
-      valueImports: new Set(),
-    }
-    const field = input.field as 'inputs' | 'outputs'
-    const array = getOrCreateArrayProperty(target.object, field)
-    const op = input.op
-
-    if (op === 'clear') {
-      array.elements = []
-    } else if (op === 'remove') {
-      const index = findIoIndex(array, input)
-      if (index < 0 || index >= array.elements.length) {
-        throw new DataCalcEditingError('invalid_index', 'remove requires a valid key or index')
-      }
-      array.elements.splice(index, 1)
-    } else if (op === 'add' || op === 'replace') {
-      const index = op === 'replace' ? findIoIndex(array, input) : input.index
-      if (op === 'replace' && (index < 0 || index >= array.elements.length)) {
-        throw new DataCalcEditingError('invalid_index', 'replace requires a valid key or index')
-      }
-      if (
-        op === 'add' &&
-        typeof index === 'number' &&
-        (index < 0 || index > array.elements.length)
-      ) {
-        throw new DataCalcEditingError('invalid_index', 'add index out of range', { index })
-      }
-      if (field === 'inputs')
-        assertInputKeyUnique(array, input.key, op === 'replace' ? index : undefined)
-      const item = await buildIoObject(field, input, ctx)
-      if (op === 'replace') array.elements[index] = item
-      else array.elements.splice(typeof index === 'number' ? index : array.elements.length, 0, item)
-    } else {
-      throw new DataCalcEditingError('invalid_op', `Unsupported edit_data_calc_io op: ${op}`)
-    }
-
-    applyPendingImports(ctx)
-    await writeParsedFile(target.parsed)
-    const verify = await verifyProject(projectDir, input.verify)
-    return {
-      file: target.parsed.relPath,
-      calc: target.slug,
-      outcome: verify.status === 'compile:failed' ? 'verify_failed' : 'ok',
-      change: { field, op, key: input.key, index: input.index },
-      verify,
-      references: referenceInputDetails(ctx.references),
-      summary: `${op} ${field} on data calc ${target.slug} -> ${verify.status}`,
-    }
-  })
-
-const removeDataCalc = async (projectDir: string, input: any) =>
-  runOperation(projectDir, 'remove_data_calc', input, async () => {
-    const target = await resolveCalcTarget(projectDir, input)
-    const dataCalcDir = path.dirname(target.parsed.absPath)
-    const sandboxPath = path.join(dataCalcDir, target.sandboxFile)
-    await rm(target.parsed.absPath, { force: true })
-    await rm(sandboxPath, { force: true })
-    const indexRelPath = await regenerateDataCalcIndex(projectDir, dataCalcDir)
-    const verify = await verifyProject(projectDir, input.verify)
-    return {
-      file: target.parsed.relPath,
-      calc: target.slug,
-      outcome: verify.status === 'compile:failed' ? 'verify_failed' : 'ok',
-      touchedSites: [
-        { file: target.parsed.relPath, action: 'delete_calc' },
-        { file: projectRelativePath(projectDir, sandboxPath), action: 'delete_sandbox' },
-        { file: indexRelPath, action: 'regenerate_index' },
-      ],
-      verify,
-      summary: `removed data calc ${target.slug} -> ${verify.status}`,
-    }
-  })
-
-const valueSchema = z
-  .any()
-  .describe(
-    'Value grammar: JSON literals, bare data ref strings for output/error/IO data, { ref, subspace }, or { expr: "raw TypeScript expression" }.',
-  )
-const fileSchema = z
-  .string()
-  .describe(
-    'Project-relative data-calc file path, for example subspaces/subspace-0/data-calc/data-calculation-total.ts.',
-  )
-const subspaceSchema = z
-  .union([z.string(), z.number()])
-  .describe(
-    'Subspace locator. Defaults to subspace-0; accepts 0, "0", "subspace-0", or a project-relative subspace path.',
-  )
-const calcSchema = z
-  .string()
-  .describe('Data calc locator inside the subspace: alias, explicit string id, or filename slug.')
-const verifySchema = z
-  .boolean()
-  .describe(
-    'Override compile verification. Defaults to BRICKS_CTOR_MCP_EDIT_VERIFY, otherwise true.',
-  )
-const targetSchema = {
-  file: fileSchema.optional(),
-  subspace: subspaceSchema.optional(),
-  calc: calcSchema.optional(),
-  verify: verifySchema.optional(),
-}
-const ioItemSchema = z
-  .object({
-    key: z.string().describe('Sandbox input/output key, for example "price" or "total".'),
-    data: valueSchema.describe('Data ref as alias/id/varName, { ref, subspace }, or { expr }.'),
-    trigger: z.boolean().describe('Inputs only; defaults true.').optional(),
-  })
-  .describe('DataCalculationScript IO item.')
-
-export function register(server: McpServer, projectDir: string) {
-  server.tool(
-    'new_data_calc',
-    'Create a standard DataCalculationScript in data-calc/{calc}.ts plus its sandbox JS file, regenerate data-calc/index.ts, and wire minimal subspace indexes.',
-    {
-      subspace: subspaceSchema.optional(),
-      alias: z.string().describe('Optional alias; also drives the filename slug.').optional(),
-      title: z.string().describe('Optional title.').optional(),
-      description: z.string().describe('Optional description.').optional(),
-      note: z.string().describe('Optional script note.').optional(),
-      triggerMode: z
-        .enum(['auto', 'manual'])
-        .describe('Optional trigger mode; omitted by default.')
-        .optional(),
-      enableAsync: z
-        .boolean()
-        .describe('Whether the sandbox main may be async. Defaults false.')
-        .optional(),
-      code: z
-        .string()
-        .describe(
-          'Sandbox body. The tool wraps it as export function main() { ... } unless already wrapped.',
-        )
-        .optional(),
-      inputs: z
-        .array(ioItemSchema)
-        .describe('Initial script inputs. Input keys must be unique.')
-        .optional(),
-      outputs: z
-        .array(ioItemSchema)
-        .describe('Initial fan-out outputs. Output keys may repeat.')
-        .optional(),
-      output: valueSchema.describe('Single output data ref or null.').optional(),
-      error: valueSchema.describe('Error output data ref or null.').optional(),
-      id: z
-        .string()
-        .describe(
-          "Optional explicit id. Defaults to source expression makeId('property_bank_calc').",
-        )
-        .optional(),
-      verify: verifySchema.optional(),
-    },
-    async (input: any) => responseFor(await newDataCalc(projectDir, input)),
-  )
-
-  server.tool(
-    'edit_data_calc',
-    'Edit DataCalculationScript scalar fields, output/error refs, or sandbox code. Code edits normalize inline code to sandbox file-form.',
-    {
-      ...targetSchema,
-      set: z
-        .record(
-          z
-            .string()
-            .describe(
-              'Top-level field path such as title, description, note, alias, triggerMode, enableAsync, output, or error.',
-            ),
-          valueSchema,
-        )
-        .describe(
-          'Fields to set. output/error accept bare data ref strings, { ref, subspace }, { expr }, or null; inputs/outputs accept whole replacement arrays of { key, data, trigger? }. Use the code parameter for code.',
-        )
-        .optional(),
-      unset: z.array(z.string()).describe('Top-level fields to remove.').optional(),
-      code: z
-        .string()
-        .describe(
-          'Replacement sandbox body. The tool wraps it as export function main() { ... } unless already wrapped.',
-        )
-        .optional(),
-    },
-    async (input: any) => responseFor(await editDataCalc(projectDir, input)),
-  )
-
-  server.tool(
-    'edit_data_calc_io',
-    'Edit DataCalculationScript inputs or outputs arrays. Inputs require unique keys; outputs may repeat keys for fan-out.',
-    {
-      ...targetSchema,
-      field: z.enum(['inputs', 'outputs']).describe('Which IO array to edit.'),
-      op: z.enum(['add', 'remove', 'replace', 'clear']).describe('Array operation.'),
-      key: z
-        .string()
-        .describe('IO key target. Ambiguous repeated output keys must use index.')
-        .optional(),
-      index: z.number().describe('Zero-based IO index target or add insertion index.').optional(),
-      data: valueSchema
-        .describe('For add/replace: data ref as string, { ref, subspace }, or { expr }.')
-        .optional(),
-      trigger: z.boolean().describe('Inputs only; defaults true.').optional(),
-    },
-    async (input: any) => responseFor(await editDataCalcIo(projectDir, input)),
-  )
-
-  server.tool(
-    'remove_data_calc',
-    'Remove a standard DataCalculationScript .ts file plus its sandbox file and regenerate data-calc/index.ts. No reverse cascade is needed.',
-    targetSchema,
-    async (input: any) => responseFor(await removeDataCalc(projectDir, input)),
-  )
-}
-
-export const __test__ = {
-  newDataCalc,
-  editDataCalc,
-  editDataCalcIo,
-  removeDataCalc,
-  resolveCalcTarget,
-}