@symbo.ls/cli 2.33.11 → 2.33.13

package/helpers/changesUtils.js

@@ -0,0 +1,474 @@
+import { normalizeKeys } from './compareUtils.js'
+
+// Keys managed by the CLI filesystem representation (exclude settings/schema/key/thumbnail/etc.)
+export const DATA_KEYS = [
+  'designSystem','components','state','pages','snippets',
+  'methods','functions','dependencies','files'
+]
+
+function stripMetaDeep(val) {
+  if (Array.isArray(val)) {
+    return val.map(stripMetaDeep)
+  }
+  if (val && typeof val === 'object') {
+    const out = {}
+    for (const [k, v] of Object.entries(val)) {
+      if (k === '__order') continue
+      out[k] = stripMetaDeep(v)
+    }
+    return out
+  }
+  return val
+}
+
+function asPlain(obj) {
+  // Ensure consistent comparison and strip meta keys (like __order)
+  return stripMetaDeep(normalizeKeys(obj || {}))
+}
+
+function equal(a, b) {
+  // Coarse compare; sufficient for top-level merges
+  try {
+    return JSON.stringify(a) === JSON.stringify(b)
+  } catch (_) {
+    return a === b
+  }
+}
+
+export function computeChangedKeys(base, local, keys = DATA_KEYS) {
+  const changed = []
+  const a = asPlain(base)
+  const b = asPlain(local)
+  // Only consider top-level data keys; ignore 'schema' entirely
+  for (const key of [...keys]) {
+    const ak = a?.[key]
+    const bk = b?.[key]
+    if (bk === undefined && ak !== undefined) {
+      changed.push(key)
+      continue
+    }
+    if (!equal(ak, bk)) {
+      changed.push(key)
+    }
+  }
+  return changed
+}
+
+export function computeCoarseChanges(base, local, keys = DATA_KEYS) {
+  const changes = []
+  const a = asPlain(base)
+  const b = asPlain(local)
+
+  // Generate per-item granular changes one level deeper for each data type.
+  // Ignore 'schema' comparisons; manage schema side-effects below.
+  for (const typeKey of [...keys]) {
+    const aSection = a?.[typeKey] || {}
+    const bSection = b?.[typeKey] || {}
+
+    // If sections are not plain objects (or are arrays), fallback to coarse replacement on the section itself
+    const aIsObject = aSection && typeof aSection === 'object' && !Array.isArray(aSection)
+    const bIsObject = bSection && typeof bSection === 'object' && !Array.isArray(bSection)
+    if (!aIsObject || !bIsObject) {
+      if (b?.hasOwnProperty(typeKey) === false && a?.hasOwnProperty(typeKey) === true) {
+        changes.push(['delete', [typeKey]])
+      } else if (!equal(aSection, bSection)) {
+        changes.push(['update', [typeKey], bSection])
+      }
+      continue
+    }
+
+    // Handle deletions (items present in base but not in local)
+    for (const itemKey of Object.keys(aSection)) {
+      if (!(itemKey in bSection)) {
+        changes.push(['delete', [typeKey, itemKey]])
+        // When an item is deleted, also delete its schema entry
+        changes.push(['delete', ['schema', typeKey, itemKey]])
+      }
+    }
+
+    // Handle additions and updates (items present in local)
+    for (const itemKey of Object.keys(bSection)) {
+      const aVal = aSection[itemKey]
+      const bVal = bSection[itemKey]
+      if (aVal === undefined) {
+        // New item
+        changes.push(['update', [typeKey, itemKey], bVal])
+        // Ensure any stale schema code is removed (safety)
+        changes.push(['delete', ['schema', typeKey, itemKey, 'code']])
+      } else if (!equal(aVal, bVal)) {
+        // Updated item
+        changes.push(['update', [typeKey, itemKey], bVal])
+        // When an item changes, drop its schema.code to be regenerated
+        changes.push(['delete', ['schema', typeKey, itemKey, 'code']])
+      }
+    }
+  }
+
+  return changes
+}
+
+export function threeWayRebase(base, local, remote, keys = DATA_KEYS) {
+  const oursKeys = computeChangedKeys(base, local, keys)
+  const theirsKeys = computeChangedKeys(base, remote, keys)
+  const conflicts = oursKeys.filter(k => theirsKeys.includes(k))
+
+  const ours = computeCoarseChanges(base, local, keys).filter(([_, [k]]) => oursKeys.includes(k))
+  const theirs = computeCoarseChanges(base, remote, keys).filter(([_, [k]]) => theirsKeys.includes(k))
+
+  let finalChanges = []
+  if (conflicts.length === 0) {
+    // Safe to apply our edited keys onto remote
+    finalChanges = ours
+  }
+
+  return {
+    ours,
+    theirs,
+    conflicts,
+    finalChanges
+  }
+}
+
+// -------------------- Orders computation (adapted for CLI plain objects) --------------------
+function isObjectLike(val) {
+  return val && typeof val === 'object' && !Array.isArray(val)
+}
+
+function normalizePath(path) {
+  if (Array.isArray(path)) return path
+  if (typeof path === 'string') return [path]
+  return []
+}
+
+function getByPathPlain(root, path = []) {
+  if (!root) return null
+  try {
+    let cur = root
+    for (let i = 0; i < path.length; i++) {
+      const seg = path[i]
+      if (cur == null || typeof cur !== 'object') return null
+      cur = cur[seg]
+    }
+    return cur
+  } catch (_) {
+    return null
+  }
+}
+
+function getParentPathsFromTuples(tuples = []) {
+  const seen = new Set()
+  const parents = []
+  const META_KEYS = new Set([
+    'style', 'class', 'text', 'html', 'content', 'data', 'attr', 'state', 'scope',
+    'define', 'on', 'extend', 'extends', 'childExtend', 'childExtends',
+    'children', 'component', 'context', 'tag', 'key', '__order', 'if'
+  ])
+  for (let i = 0; i < tuples.length; i++) {
+    const tuple = tuples[i]
+    if (!Array.isArray(tuple) || tuple.length < 2) continue
+    const path = normalizePath(tuple[1])
+    if (!path.length) continue
+    if (path[0] === 'schema') continue
+    const immediateParent = path.slice(0, -1)
+    if (immediateParent.length) {
+      const key = JSON.stringify(immediateParent)
+      if (!seen.has(key)) {
+        seen.add(key)
+        parents.push(immediateParent)
+      }
+    }
+    const last = path[path.length - 1]
+    if (META_KEYS.has(last) && path.length >= 2) {
+      const containerParent = path.slice(0, -2)
+      if (containerParent.length) {
+        const key2 = JSON.stringify(containerParent)
+        if (!seen.has(key2)) {
+          seen.add(key2)
+          parents.push(containerParent)
+        }
+      }
+    }
+    for (let j = 0; j < path.length; j++) {
+      const seg = path[j]
+      if (!META_KEYS.has(seg)) continue
+      const containerParent2 = path.slice(0, j)
+      if (!containerParent2.length) continue
+      const key3 = JSON.stringify(containerParent2)
+      if (!seen.has(key3)) {
+        seen.add(key3)
+        parents.push(containerParent2)
+      }
+    }
+  }
+  return parents
+}
+
+function computeOrdersFromStatePlain(root, parentPaths = []) {
+  const orders = []
+  const EXCLUDE_KEYS = new Set(['__order'])
+  for (let i = 0; i < parentPaths.length; i++) {
+    const parentPath = parentPaths[i]
+    const obj = getByPathPlain(root, parentPath)
+    if (!isObjectLike(obj)) continue
+    const keys = Object.keys(obj).filter(k => !EXCLUDE_KEYS.has(k))
+    orders.push({ path: parentPath, keys })
+  }
+  return orders
+}
+
+// --- Schema `code` parsing helpers (adapted) ---
+function normaliseSchemaCode(code) {
+  if (typeof code !== 'string' || !code.length) return ''
+  return code
+    .replaceAll('/////n', '\n')
+    .replaceAll('/////tilde', '`')
+}
+
+function parseExportedObject(code) {
+  const src = normaliseSchemaCode(code)
+  if (!src) return null
+  const body = src.replace(/^\s*export\s+default\s*/u, 'return ')
+  try {
+    // eslint-disable-next-line no-new-func
+    return new Function(body)()
+  } catch {
+    return null
+  }
+}
+
+function extractTopLevelKeysFromCode(code) {
+  const obj = parseExportedObject(code)
+  if (!obj || typeof obj !== 'object') return []
+  return Object.keys(obj)
+}
+
+/**
+ * Compute ordered key arrays for each parent path using a plain root object and granular tuples.
+ */
+export function computeOrdersForTuples(root, tuples = []) {
+  const pendingChildrenByContainer = new Map()
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i]
+    if (!Array.isArray(t)) continue
+    const [action, path] = t
+    const p = normalizePath(path)
+    if (!Array.isArray(p) || p.length < 3) continue
+    if (p[0] === 'schema') continue
+    const [typeName, containerKey, childKey] = p
+    const containerPath = [typeName, containerKey]
+    const key = JSON.stringify(containerPath)
+    if (!pendingChildrenByContainer.has(key)) {
+      pendingChildrenByContainer.set(key, new Set())
+    }
+    if (action === 'update' || action === 'set') {
+      pendingChildrenByContainer.get(key).add(childKey)
+    }
+  }
+
+  const preferredOrderMap = new Map()
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i]
+    if (!Array.isArray(t)) continue
+    const [action, path, value] = t
+    const p = normalizePath(path)
+    if (action !== 'update' || !Array.isArray(p) || p.length < 3) continue
+    if (p[0] !== 'schema') continue
+    const [, type, key] = p
+    const containerPath = [type, key]
+
+    const obj = getByPathPlain(root, containerPath)
+    if (!obj) continue
+
+    const present = new Set(Object.keys(obj))
+    const EXCLUDE_KEYS = new Set(['__order'])
+    const uses = value && Array.isArray(value.uses) ? value.uses : null
+    const code = value && value.code
+    const codeKeys = extractTopLevelKeysFromCode(code)
+    let resolved = []
+
+    const pendingKey = JSON.stringify(containerPath)
+    const pendingChildren = pendingChildrenByContainer.get(pendingKey) || new Set()
+    const eligible = new Set([...present, ...pendingChildren])
+
+    if (Array.isArray(codeKeys) && codeKeys.length) {
+      resolved = codeKeys.filter(k => eligible.has(k) && !EXCLUDE_KEYS.has(k))
+    }
+    if (Array.isArray(uses) && uses.length) {
+      for (let u = 0; u < uses.length; u++) {
+        const keyName = uses[u]
+        if (eligible.has(keyName) && !EXCLUDE_KEYS.has(keyName) && !resolved.includes(keyName)) {
+          resolved.push(keyName)
+        }
+      }
+    }
+    if (pendingChildren.size) {
+      for (const child of pendingChildren) {
+        if (!EXCLUDE_KEYS.has(child) && !resolved.includes(child)) {
+          resolved.push(child)
+        }
+      }
+    }
+    if (resolved.length) {
+      preferredOrderMap.set(JSON.stringify(containerPath), { path: containerPath, keys: resolved })
+    }
+  }
+
+  const parents = getParentPathsFromTuples(tuples)
+  const orders = []
+  const seen = new Set()
+  preferredOrderMap.forEach(v => {
+    const k = JSON.stringify(v.path)
+    if (!seen.has(k)) { seen.add(k); orders.push(v) }
+  })
+  const fallbackOrders = computeOrdersFromStatePlain(root, parents)
+  for (let i = 0; i < fallbackOrders.length; i++) {
+    const v = fallbackOrders[i]
+    const k = JSON.stringify(v.path)
+    if (seen.has(k)) continue
+    const pending = pendingChildrenByContainer.get(k)
+    if (pending && pending.size) {
+      const existing = new Set(v.keys)
+      for (const child of pending) {
+        if (existing.has(child)) continue
+        v.keys.push(child)
+      }
+    }
+    seen.add(k)
+    orders.push(v)
+  }
+  return orders
+}
+
+// -------------------- Granular expansion (preprocess) --------------------
+function isPlainObject(val) {
+  return val && typeof val === 'object' && !Array.isArray(val)
+}
+
+function diffJsonPlain(prev, next, basePath = []) {
+  const ops = []
+  const prevIsObj = isPlainObject(prev)
+  const nextIsObj = isPlainObject(next)
+  if (!prevIsObj || !nextIsObj) {
+    if (!equal(prev, next)) {
+      ops.push({ action: 'set', path: [], value: next })
+    }
+    return ops
+  }
+  const prevKeys = new Set(Object.keys(prev || {}))
+  const nextKeys = new Set(Object.keys(next || {}))
+  // deletions
+  prevKeys.forEach((k) => {
+    if (!nextKeys.has(k)) {
+      ops.push({ action: 'del', path: [k] })
+    }
+  })
+  // additions/updates
+  nextKeys.forEach((k) => {
+    const pv = prev[k]
+    const nv = next[k]
+    if (!prevKeys.has(k)) {
+      ops.push({ action: 'set', path: [k], value: nv })
+    } else if (!equal(pv, nv)) {
+      if (isPlainObject(pv) && isPlainObject(nv)) {
+        const child = diffJsonPlain(pv, nv, [...basePath, k])
+        if (child.length === 0) {
+          ops.push({ action: 'set', path: [k], value: nv })
+        } else {
+          for (let i = 0; i < child.length; i++) {
+            const c = child[i]
+            ops.push({ action: c.action, path: [k, ...c.path], value: c.value })
+          }
+        }
+      } else {
+        ops.push({ action: 'set', path: [k], value: nv })
+      }
+    }
+  })
+  return ops
+}
+
+export function preprocessChanges(root, tuples = [], options = {}) {
+  const META_FILES = 'files'
+
+  const getByPath = (path) => getByPathPlain(root, path)
+
+  const expandTuple = (t) => {
+    const [action, path, value] = t || []
+    const isSchemaPath = Array.isArray(path) && path[0] === 'schema'
+    const isFilesPath = Array.isArray(path) && path[0] === META_FILES
+    if (action === 'delete') return [t]
+    const canConsiderExpansion = (
+      action === 'update' &&
+      Array.isArray(path) &&
+      (
+        path.length === 1 ||
+        path.length === 2 ||
+        (isSchemaPath && path.length === 3)
+      ) &&
+      isPlainObject(value)
+    )
+    if (!canConsiderExpansion || isFilesPath || (value && value.type === META_FILES)) return [t]
+
+    const prevRaw = getByPath(path)
+    const isCreatePath = (
+      Array.isArray(path) &&
+      action === 'update' &&
+      ((!isSchemaPath && path.length === 2) || (isSchemaPath && path.length === 3)) &&
+      (prevRaw === null || typeof prevRaw === 'undefined')
+    )
+    if (isCreatePath) return [t]
+
+    const prev = prevRaw || {}
+    const next = value || {}
+    if (!isPlainObject(prev) || !isPlainObject(next)) return [t]
+
+    const ops = diffJsonPlain(prev, next, [])
+    if (!ops.length) return [t]
+
+    const out = []
+    for (let i = 0; i < ops.length; i++) {
+      const op = ops[i]
+      const fullPath = [...path, ...op.path]
+      const last = fullPath[fullPath.length - 1]
+      if (op.action === 'set') {
+        out.push(['update', fullPath, op.value])
+      } else if (op.action === 'del') {
+        if (last !== '__order') out.push(['delete', fullPath])
+      }
+    }
+    return out
+  }
+
+  const minimizeTuples = (input) => {
+    const out = []
+    const seen = new Set()
+    for (let i = 0; i < input.length; i++) {
+      const expanded = expandTuple(input[i])
+      for (let k = 0; k < expanded.length; k++) {
+        const tuple = expanded[k]
+        const isDelete = Array.isArray(tuple) && tuple[0] === 'delete'
+        const isOrderKey = isDelete && Array.isArray(tuple[1]) && tuple[1][tuple[1].length - 1] === '__order'
+        if (!isOrderKey) {
+          const key = JSON.stringify(tuple)
+          if (!seen.has(key)) { seen.add(key); out.push(tuple) }
+        }
+      }
+    }
+    return out
+  }
+
+  const granularChanges = (() => {
+    try {
+      const res = minimizeTuples(tuples || [])
+      if (options.append && options.append.length) res.push(...options.append)
+      return res
+    } catch {
+      return Array.isArray(tuples) ? tuples.slice() : []
+    }
+  })()
+
+  const orders = computeOrdersForTuples(root || {}, granularChanges)
+  return { granularChanges, orders }
+}
+
+

package/helpers/compareUtils.js

@@ -24,6 +24,95 @@ export function normalizeKeys (obj) {
   }, {})
 }
 
+export function generateDefaultSchema(key, type) {
+  // Base schema for components and pages
+  const baseSchema = {
+    key,
+    title: toTitleCase(key),
+    description: '',
+    type: type.slice(0, -1), // Convert plural to singular
+    code: '',
+    state: {},
+    props: {},
+    settings: {
+      gridOptions: {
+        x: 0,
+        y: 0,
+        w: 1,
+        h: 1
+      }
+    }
+  }
+
+  // Type-specific schema generation
+  switch (type.toLowerCase()) {
+    case 'components':
+      return {
+        ...baseSchema,
+        category: ['comp'],
+        draft: false,
+        highlighted: false,
+        tags: [],
+        dataTypes: [],
+        interactivity: [],
+        error: null,
+        thumbnail: null,
+        pdf: null,
+        uses: {
+          components: [],
+          icons: [],
+          themes: [],
+          colors: [],
+          dependencies: []
+        }
+      }
+
+    case 'pages':
+      return {
+        ...baseSchema,
+        key: key.startsWith('/') ? key : `/${key}`,
+        type: 'page'
+      }
+
+    case 'functions':
+    case 'snippets':
+    case 'methods':
+      return {
+        key,
+        title: toTitleCase(key),
+        description: '',
+        type: type.slice(0, -1),
+        code: ''
+      }
+
+    case 'dependencies':
+      return {
+        key,
+        type: 'dependency'
+      }
+
+    case 'secrets':
+      return {
+        key,
+        type: 'secret'
+      }
+
+    case 'files':
+      return {
+        key,
+        format: key.split('.').pop() || '',
+        type: 'file'
+      }
+
+    case 'designsystem':
+      // Design system items (colors, typography, etc) don't need schema entries
+      return null
+
+    default:
+      return baseSchema
+  }
+}
+
 export function generateChanges (oldData, newData) {
   const changes = []
   const diffs = []
@@ -32,7 +121,7 @@ export function generateChanges (oldData, newData) {
     throw new Error('Both oldData and newData must be provided')
   }
 
-  // Filter out non-allowed top-level fields before comparison
+  // Filter allowed fields
   const filteredOldData = Object.keys(oldData)
     .filter(key => ALLOWED_FIELDS.includes(key.toLowerCase()))
     .reduce((obj, key) => {
@@ -47,7 +136,27 @@ export function generateChanges (oldData, newData) {
       return obj
     }, {})
 
-  compareObjects(filteredOldData, filteredNewData, [], changes, diffs)
+  // Compare and generate changes
+  for (const type of ALLOWED_FIELDS) {
+    const oldSection = filteredOldData[type] || {}
+    const newSection = filteredNewData[type] || {}
+
+    // Check for new items
+    for (const key of Object.keys(newSection)) {
+      if (!oldSection[key]) {
+        // New item added - generate schema
+        const defaultSchema = generateDefaultSchema(key, type)
+        changes.push(
+          ['update', [type, key], newSection[key]],
+          ['update', ['schema', type, key], defaultSchema]
+        )
+        diffs.push(generateDiffDisplay('add', [type, key], null, newSection[key]))
+      }
+    }
+
+    // Handle other changes
+    compareObjects(oldSection, newSection, [type], changes, diffs)
+  }
 
   return { changes, diffs }
 }
@@ -133,3 +242,28 @@ function handleAdditionsAndUpdates (oldObj, newObj, currentPath, changes, diffs)
     }
   }
 }
+
+/**
+ * Converts a string to title case format
+ * Examples:
+ * - "myComponent" -> "My Component"
+ * - "my-component" -> "My Component"
+ * - "my_component" -> "My Component"
+ * - "MyComponent" -> "My Component"
+ */
+export function toTitleCase(str) {
+  if (!str) return ''
+
+  // Handle kebab-case and snake_case
+  str = str.replace(/[-_]/g, ' ')
+
+  // Handle camelCase and PascalCase
+  str = str.replace(/([a-z])([A-Z])/g, '$1 $2')
+
+  // Capitalize first letter of each word
+  return str
+    .split(' ')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(' ')
+    .trim()
+}