@symbo.ls/cli 2.33.26 → 2.33.28

package/bin/collab.js

@@ -5,7 +5,7 @@ import path from 'path'
 import chalk from 'chalk'
 import { program } from './program.js'
 import { CredentialManager } from '../helpers/credentialManager.js'
-import { loadSymbolsConfig } from '../helpers/symbolsConfig.js'
+import { loadSymbolsConfig, resolveDistDir } from '../helpers/symbolsConfig.js'
 import { loadCliConfig, readLock, writeLock, getConfigPaths } from '../helpers/config.js'
 import { stringifyFunctionsForTransport } from '../helpers/transportUtils.js'
 import { getCurrentProjectData } from '../helpers/apiUtils.js'
@@ -48,6 +48,10 @@ export async function startCollab(options) {
   const branch = options.branch || cliConfig.branch || symbolsConfig.branch || 'main'
   const appKey = cliConfig.projectKey || symbolsConfig.key
 
+  const distDir =
+    resolveDistDir(symbolsConfig) ||
+    path.join(process.cwd(), 'smbls')
+
   if (!appKey) {
     console.log(chalk.red('Missing project key. Add it to symbols.json or .symbols/config.json'))
     process.exit(1)
@@ -148,7 +152,7 @@ export async function startCollab(options) {
       sendLocalChanges.cancel()
     }
     try {
-      await createFs(fullObj, path.join(process.cwd(), 'smbls'), { update: true, metadata: false })
+      await createFs(fullObj, distDir, { update: true, metadata: false })
     } finally {
       // Extend suppression window to allow file events to settle fully
       suppressUntil = Date.now() + suppressionWindowMs
@@ -253,7 +257,6 @@ export async function startCollab(options) {
   })
 
   // Watch local dist output and push coarse per-key changes
-  const distDir = path.join(process.cwd(), 'smbls')
   const outputDir = path.join(distDir, 'dist')
   const outputFile = path.join(outputDir, 'index.js')
 
@@ -272,10 +275,77 @@ export async function startCollab(options) {
     }
   }
 
+  /**
+   * Augment the loaded project object with any new items that exist as
+   * filesystem files (e.g. newly created component/page/method/function/snippet
+   * files) but are not yet present in the in‑memory data object.
+   *
+   * This bridges the gap between the one‑way createFs → files mapping so that
+   * adding a new file like components/MainFooter.js is seen as a new
+   * `components.MainFooter` data item and can be sent to the server.
+   */
+  async function augmentLocalWithNewFsItems(local) {
+    if (!local || typeof local !== 'object') return
+
+    const TYPES = ['components', 'pages', 'snippets', 'methods', 'functions']
+
+    for (let i = 0; i < TYPES.length; i++) {
+      const type = TYPES[i]
+      const srcDir = path.join(distDir, type)
+
+      let entries
+      try {
+        entries = await fs.promises.readdir(srcDir)
+      } catch {
+        continue
+      }
+      if (!Array.isArray(entries) || !entries.length) continue
+
+      const container = local[type] && typeof local[type] === 'object' && !Array.isArray(local[type])
+        ? local[type]
+        : (local[type] = {})
+      const baseSection = currentBase && currentBase[type] && typeof currentBase[type] === 'object'
+        ? currentBase[type]
+        : {}
+
+      for (let j = 0; j < entries.length; j++) {
+        const filename = entries[j]
+        if (!filename.endsWith('.js') || filename === 'index.js') continue
+
+        const key = filename.slice(0, -3)
+        if (Object.prototype.hasOwnProperty.call(container, key)) continue
+        if (Object.prototype.hasOwnProperty.call(baseSection, key)) continue
+
+        const compiledPath = path.join(outputDir, type, filename)
+        let mod
+        try {
+          const { loadModule } = await import('./require.js')
+          mod = await loadModule(compiledPath, { silent: true })
+        } catch {
+          if (options.verbose) {
+            console.error(`Failed to load new ${type} item from`, compiledPath)
+          }
+          continue
+        }
+
+        if (!mod) continue
+
+        let value = null
+        if (mod && typeof mod === 'object') {
+          value = mod.default || mod[key] || null
+        }
+        if (!value || typeof value !== 'object') continue
+
+        container[key] = value
+      }
+    }
+  }
+
   const sendLocalChanges = debounce(async () => {
     if (suppressLocalChanges) return
     const local = await loadLocalProject()
     if (!local) return
+    await augmentLocalWithNewFsItems(local)
     // Prepare safe, JSON-serialisable snapshots for diffing & transport
     const base = currentBase || {}
     const safeBase = stringifyFunctionsForTransport(base)
@@ -291,6 +361,25 @@ export async function startCollab(options) {
     const { granularChanges } = preprocessChanges(safeBase, changes)
     const orders = computeOrdersForTuples(safeLocal, granularChanges)
     console.log(chalk.gray(`Emitting local ops: ${JSON.stringify({ changes, granularChanges, orders, branch })}`))
+
+    // Optimistically apply our own ops to the in-memory base so that
+    // subsequent diffs are computed against the latest local state.
+    // This avoids repeatedly re-emitting the same changes when the
+    // server does not immediately send back a fresh snapshot.
+    try {
+      const tuplesToApply = Array.isArray(granularChanges) && granularChanges.length
+        ? granularChanges
+        : changes
+      applyTuples(currentBase, tuplesToApply)
+      if (Array.isArray(orders) && orders.length) {
+        applyOrders(currentBase, orders)
+      }
+    } catch (e) {
+      if (options.verbose) {
+        console.error('Failed to apply local ops to in-memory base', e)
+      }
+    }
+
     socket.emit('ops', {
       changes,
       granularChanges,

package/bin/config.js

@@ -0,0 +1,85 @@
+'use strict'
+
+import fs from 'fs'
+import path from 'path'
+import inquirer from 'inquirer'
+import chalk from 'chalk'
+import { program } from './program.js'
+import { loadSymbolsConfig } from '../helpers/symbolsConfig.js'
+import { loadCliConfig, saveCliConfig, updateLegacySymbolsJson } from '../helpers/config.js'
+
+program
+  .command('config')
+  .description('Interactively configure Symbols project settings')
+  .option('--dist-dir <dir>', 'Set distDir non-interactively')
+  .action(async (options) => {
+    // Load existing configs (do not fail if missing/malformed)
+    const symbolsConfig =
+      (await loadSymbolsConfig({ required: false, validateKey: false, silent: true })) || {}
+    const cliConfig = loadCliConfig()
+
+    // Fast path: only update distDir when provided explicitly
+    if (options.distDir) {
+      const next = { ...symbolsConfig, distDir: options.distDir }
+      updateLegacySymbolsJson(next)
+      console.log(chalk.green(`Updated symbols.json distDir to "${options.distDir}"`))
+      return
+    }
+
+    const questions = [
+      {
+        type: 'input',
+        name: 'key',
+        message: 'App key (symbols.json.key):',
+        default: symbolsConfig.key || '',
+        filter: (v) => v.trim()
+      },
+      {
+        type: 'input',
+        name: 'branch',
+        message: 'Default branch:',
+        default: cliConfig.branch || symbolsConfig.branch || 'main',
+        filter: (v) => v.trim() || 'main'
+      },
+      {
+        type: 'input',
+        name: 'distDir',
+        message: 'Directory for generated files (distDir):',
+        default: symbolsConfig.distDir || './smbls',
+        filter: (v) => v.trim() || './smbls'
+      },
+      {
+        type: 'input',
+        name: 'apiBaseUrl',
+        message: 'API base URL:',
+        default: cliConfig.apiBaseUrl || 'https://api.symbols.app',
+        filter: (v) => v.trim() || 'https://api.symbols.app'
+      }
+    ]
+
+    const answers = await inquirer.prompt(questions)
+
+    // Update symbols.json (legacy project config)
+    const nextSymbols = updateLegacySymbolsJson({
+      ...symbolsConfig,
+      key: answers.key || undefined,
+      branch: answers.branch,
+      distDir: answers.distDir
+    })
+
+    // Update .symbols/config.json (runtime CLI config)
+    const _nextCli = saveCliConfig({
+      apiBaseUrl: answers.apiBaseUrl,
+      projectKey: answers.key || cliConfig.projectKey || nextSymbols.key,
+      branch: answers.branch
+    })
+
+    console.log(`\n`)
+    console.log(chalk.green('Configuration updated successfully.'))
+    const symbolsPath = path.join(process.cwd(), 'symbols.json')
+    const cliConfigPath = path.join(process.cwd(), '.symbols', 'config.json')
+    console.log(chalk.gray(`symbols.json: ${chalk.cyan(symbolsPath)}`))
+    console.log(chalk.gray(`.symbols/config.json: ${chalk.cyan(cliConfigPath)}`))
+  })
+
+

package/bin/fetch.js

@@ -10,15 +10,10 @@ import { createFs } from './fs.js'
 import { CredentialManager } from '../helpers/credentialManager.js'
 import { getCurrentProjectData } from '../helpers/apiUtils.js'
 import { showAuthRequiredMessages } from '../helpers/buildMessages.js'
-import { loadSymbolsConfig } from '../helpers/symbolsConfig.js'
+import { loadSymbolsConfig, resolveDistDir } from '../helpers/symbolsConfig.js'
 import { loadCliConfig, readLock, writeLock, updateLegacySymbolsJson, getConfigPaths } from '../helpers/config.js'
 const { isObjectLike } = (utils.default || utils)
 
-const RC_PATH = process.cwd() + '/symbols.json'
-const LOCAL_CONFIG_PATH =
-  process.cwd() + '/node_modules/@symbo.ls/init/dynamic.json'
-const DEFAULT_REMOTE_REPOSITORY = 'https://github.com/symbo-ls/default-config/'
-
 const debugMsg = chalk.dim(
   'Use --verbose to debug the error or open the issue at https://github.com/symbo-ls/smbls'
 )
@@ -38,7 +33,7 @@ export const fetchFromCli = async (opts) => {
 
   const projectKey = cliConfig.projectKey || symbolsConfig.key
   const branch = cliConfig.branch || symbolsConfig.branch || 'main'
-  const { framework, distDir, metadata } = symbolsConfig
+  const { framework } = symbolsConfig
 
     console.log('\nFetching project data...\n')
 
@@ -79,7 +74,7 @@ export const fetchFromCli = async (opts) => {
       console.log(chalk.red('Failed to fetch:'), projectKey)
       if (verbose) console.error(e)
       else console.log(debugMsg)
-      return
+      process.exit(1)
     }
 
     // Persist base snapshot for future rebases
@@ -87,24 +82,11 @@ export const fetchFromCli = async (opts) => {
       const { projectPath } = getConfigPaths()
       await fs.promises.mkdir(path.dirname(projectPath), { recursive: true })
       await fs.promises.writeFile(projectPath, JSON.stringify(payload, null, 2))
-    } catch (_) {}
-
-    if (verbose) {
-      if (projectKey) {
-        console.log(
-          chalk.bold('Symbols'),
-          'data fetched for',
-          chalk.green(payload.name)
-        )
-      } else {
-        console.log(
-          chalk.bold('Symbols'),
-          'config fetched from',
-          chalk.bold('default-config from:'),
-          chalk.dim.underline(DEFAULT_REMOTE_REPOSITORY)
-        )
-      }
-      console.log()
+    } catch (e) {
+      console.error(chalk.bold.red('\nError writing file'))
+      if (verbose) console.error(e)
+      else console.log(debugMsg)
+      process.exit(1)
     }
 
     const { version: fetchedVersion, ...config } = payload
@@ -123,30 +105,12 @@ export const fetchFromCli = async (opts) => {
       } else console.log(chalk.dim(t + ':'), chalk.bold(type))
     }
 
-    if (!distDir) {
-      const bodyString = JSON.stringify(payload, null, prettify ?? 2)
-
-      try {
-        await fs.writeFileSync(LOCAL_CONFIG_PATH, bodyString)
-
-        if (verbose) {
-          console.log(chalk.dim('\ndynamic.json has been updated:'))
-          console.log(chalk.dim.underline(LOCAL_CONFIG_PATH))
-        }
-
-        console.log(chalk.bold.green('\nSuccessfully wrote file'))
-      } catch (e) {
-        console.log(chalk.bold.red('\nError writing file'))
-        if (verbose) console.error(e)
-        else console.log(debugMsg)
-      }
-
-      console.log()
-      console.warn(
-        'No --dist-dir option or "distDir" in symbols.json provided. Saving in ./node_modules/@symbo.ls/init/dynamic.json.'
-      )
-      return {}
-    }
+    // Resolve effective distDir from CLI flag or symbols.json, with a sane default
+    const distDir =
+      resolveDistDir(symbolsConfig, {
+        distDirOverride: opts.distDir
+      }) ||
+      path.join(process.cwd(), 'smbls')
 
     if (payload.components && convertOpt && framework) {
       convertFromCli(payload.components, { ...opts, framework })
@@ -169,5 +133,5 @@ program
   .option('--force', 'Force overriding changes from platform')
   .option('--update', 'Overriding changes from platform')
   .option('--verbose-code', 'Verbose errors and warnings')
-  .option('--dist-dir', 'Directory to import files to.')
+  .option('--dist-dir <dir>', 'Directory to import files to.')
   .action(fetchFromCli)

package/bin/index.js

@@ -5,6 +5,7 @@ import 'v8-compile-cache'
 import { program } from './program.js'
 import './install.js'
 import './init.js'
+import './config.js'
 import './fetch.js'
 import './sync.js'
 import './clean.js'

package/bin/push.js

@@ -12,13 +12,12 @@ import { generateDiffDisplay, showDiffPager } from '../helpers/diffUtils.js'
 import { getCurrentProjectData, postProjectChanges } from '../helpers/apiUtils.js'
 import { computeCoarseChanges, computeOrdersForTuples, preprocessChanges } from '../helpers/changesUtils.js'
 import { showAuthRequiredMessages, showProjectNotFoundMessages, showBuildErrorMessages } from '../helpers/buildMessages.js'
-import { loadSymbolsConfig } from '../helpers/symbolsConfig.js'
+import { loadSymbolsConfig, resolveDistDir } from '../helpers/symbolsConfig.js'
 import { loadCliConfig, readLock, writeLock, updateLegacySymbolsJson } from '../helpers/config.js'
 
 
-async function buildLocalProject () {
+async function buildLocalProject (distDir) {
   try {
-    const distDir = path.join(process.cwd(), 'smbls')
     const outputDirectory = path.join(distDir, 'dist')
 
     await buildDirectory(distDir, outputDirectory)
@@ -114,11 +113,15 @@ export async function pushProjectChanges(options) {
     const appKey = cliConfig.projectKey || symbolsConfig.key
     const branch = cliConfig.branch || symbolsConfig.branch || 'main'
 
+    const distDir =
+      resolveDistDir(symbolsConfig) ||
+      path.join(process.cwd(), 'smbls')
+
     // Build and load local project
     console.log(chalk.dim('Building local project...'))
     let localProject
     try {
-      localProject = await buildLocalProject()
+      localProject = await buildLocalProject(distDir)
       console.log(chalk.gray('Local project built successfully'))
     } catch (buildError) {
       showBuildErrorMessages(buildError)

package/bin/sync.js

@@ -11,15 +11,13 @@ import { buildDirectory } from '../helpers/fileUtils.js'
 import { generateDiffDisplay, showDiffPager } from '../helpers/diffUtils.js'
 import { normalizeKeys } from '../helpers/compareUtils.js'
 import { getCurrentProjectData, postProjectChanges } from '../helpers/apiUtils.js'
-import { computeCoarseChanges, threeWayRebase, computeOrdersForTuples, preprocessChanges } from '../helpers/changesUtils.js'
+import { threeWayRebase, computeOrdersForTuples, preprocessChanges } from '../helpers/changesUtils.js'
 import { createFs } from './fs.js'
 import { showAuthRequiredMessages, showBuildErrorMessages } from '../helpers/buildMessages.js'
-import { loadSymbolsConfig } from '../helpers/symbolsConfig.js'
+import { loadSymbolsConfig, resolveDistDir } from '../helpers/symbolsConfig.js'
 import { loadCliConfig, readLock, writeLock, getConfigPaths, updateLegacySymbolsJson } from '../helpers/config.js'
-const RC_PATH = process.cwd() + '/symbols.json'
-const distDir = path.join(process.cwd(), 'smbls')
 
-async function buildLocalProject() {
+async function buildLocalProject(distDir) {
   try {
     const outputDirectory = path.join(distDir, 'dist')
     await buildDirectory(distDir, outputDirectory)
@@ -165,6 +163,10 @@ export async function syncProjectChanges(options) {
     const appKey = cliConfig.projectKey || legacyKey
     const localBranch = cliConfig.branch || symbolsConfig.branch || 'main'
 
+    const distDir =
+      resolveDistDir(symbolsConfig) ||
+      path.join(process.cwd(), 'smbls')
+
     if (options.verbose) {
       console.log(chalk.dim('\nSync configuration:'))
       console.log(chalk.gray(`App Key: ${chalk.cyan(appKey)}`))
@@ -179,7 +181,7 @@ export async function syncProjectChanges(options) {
     console.log(chalk.dim('Building local project...'))
     let localProject
     try {
-      localProject = await buildLocalProject()
+      localProject = await buildLocalProject(distDir)
       console.log(chalk.gray('Local project built successfully'))
     } catch (buildError) {
       showBuildErrorMessages(buildError)

package/helpers/changesUtils.js

@@ -1,11 +1,16 @@
+import * as utils from '@domql/utils'
 import { normalizeKeys } from './compareUtils.js'
 
+const { objectToString } = utils.default || utils
+
 // 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'
 ]
 
+const SCHEMA_CODE_TYPES = new Set(['pages', 'components', 'functions', 'methods', 'snippets'])
+
 function stripMetaDeep(val) {
   if (Array.isArray(val)) {
     return val.map(stripMetaDeep)
@@ -61,9 +66,12 @@ export function computeCoarseChanges(base, local, keys = DATA_KEYS) {
 
   // Generate per-item granular changes one level deeper for each data type.
   // Ignore 'schema' comparisons; manage schema side-effects below.
+  const baseSchema = a?.schema || {}
+
   for (const typeKey of [...keys]) {
     const aSection = a?.[typeKey] || {}
     const bSection = b?.[typeKey] || {}
+    const aSchemaSection = baseSchema?.[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)
@@ -90,11 +98,17 @@ export function computeCoarseChanges(base, local, keys = DATA_KEYS) {
     for (const itemKey of Object.keys(bSection)) {
       const aVal = aSection[itemKey]
       const bVal = bSection[itemKey]
-      if (aVal === undefined) {
+      const hadPrev = typeof aVal !== 'undefined'
+      if (!hadPrev) {
         // New item
         changes.push(['update', [typeKey, itemKey], bVal])
-        // Ensure any stale schema code is removed (safety)
-        changes.push(['delete', ['schema', typeKey, itemKey, 'code']])
+        const hadSchema = aSchemaSection && Object.prototype.hasOwnProperty.call(aSchemaSection, itemKey)
+        if (SCHEMA_CODE_TYPES.has(typeKey) && !hadSchema) {
+          const schemaItem = buildSchemaItemFromData(typeKey, itemKey, bVal)
+          if (schemaItem) {
+            changes.push(['update', ['schema', typeKey, itemKey], schemaItem])
+          }
+        }
       } else if (!equal(aVal, bVal)) {
         // Updated item
         changes.push(['update', [typeKey, itemKey], bVal])
@@ -112,8 +126,18 @@ export function threeWayRebase(base, local, remote, keys = DATA_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))
+  const allOurs = computeCoarseChanges(base, local, keys)
+  const allTheirs = computeCoarseChanges(base, remote, keys)
+
+  const ownsKey = (path, set) => {
+    if (!Array.isArray(path) || !path.length) return false
+    const [rootKey, typeKey] = path
+    const primary = rootKey === 'schema' ? typeKey : rootKey
+    return set.includes(primary)
+  }
+
+  const ours = allOurs.filter(([, path]) => ownsKey(path, oursKeys))
+  const theirs = allTheirs.filter(([, path]) => ownsKey(path, theirsKeys))
 
   let finalChanges = []
   if (conflicts.length === 0) {
@@ -224,6 +248,13 @@ function normaliseSchemaCode(code) {
     .replaceAll('/////tilde', '`')
 }
 
+function encodeSchemaCode(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
@@ -236,6 +267,46 @@ function parseExportedObject(code) {
   }
 }
 
+export function buildSchemaCodeFromObject(obj) {
+  if (!obj || typeof obj !== 'object') return ''
+  const body = objectToString(obj, 2)
+  const src = `export default ${body}`
+  return encodeSchemaCode(src)
+}
+
+function buildSchemaItemFromData(type, key, value) {
+  const schemaType = type
+
+  const base = {
+    title: key,
+    key,
+    type: schemaType
+  }
+
+  if (['pages', 'components'].includes(schemaType)) {
+    base.settings = {
+      gridOptions: {}
+    }
+    base.props = {}
+    base.interactivity = []
+    base.dataTypes = []
+    base.error = null
+  }
+
+  if (SCHEMA_CODE_TYPES.has(schemaType)) {
+    try {
+      const code = buildSchemaCodeFromObject(value)
+      if (code) {
+        base.code = code
+      }
+    } catch (_) {
+      // Fallback: omit code field if serialisation fails
+    }
+  }
+
+  return base
+}
+
 function extractTopLevelKeysFromCode(code) {
   const obj = parseExportedObject(code)
   if (!obj || typeof obj !== 'object') return []

package/helpers/symbolsConfig.js

@@ -32,4 +32,35 @@ export const loadSymbolsConfig = async (options = {}) => {
     if (required) process.exit(1)
     return null
   }
-}
+}
+
+/**
+ * Resolve the effective dist directory for the current workspace.
+ *
+ * Precedence:
+ *  - explicit override (e.g. CLI flag)
+ *  - symbols.json.distDir
+ *
+ * Returns an absolute path when possible; null when no distDir
+ * configuration is available so callers can decide on a default.
+ */
+export function resolveDistDir (symbolsConfig, options = {}) {
+  const cfg = symbolsConfig || {}
+  const {
+    // Prefer explicit override from callers (e.g. CLI flag)
+    distDirOverride,
+    distDir: overrideDistDir,
+    cwd = process.cwd()
+  } = options
+
+  const raw =
+    distDirOverride ||
+    overrideDistDir ||
+    cfg.distDir
+
+  if (!raw) return null
+
+  // If already absolute, return as-is; otherwise resolve against cwd
+  if (path.isAbsolute(raw)) return raw
+  return path.resolve(cwd, raw)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/cli",
-  "version": "2.33.26",
+  "version": "2.33.28",
   "description": "Fetch your Symbols configuration",
   "main": "bin/fetch.js",
   "author": "Symbols",
@@ -15,9 +15,9 @@
     "vpatch": "npm version patch && npm publish"
   },
   "dependencies": {
-    "@symbo.ls/fetch": "^2.33.26",
-    "@symbo.ls/init": "^2.33.26",
-    "@symbo.ls/socket": "^2.33.26",
+    "@symbo.ls/fetch": "^2.33.28",
+    "@symbo.ls/init": "^2.33.28",
+    "@symbo.ls/socket": "^2.33.28",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
@@ -28,5 +28,5 @@
     "socket.io-client": "^4.8.1",
     "v8-compile-cache": "^2.4.0"
   },
-  "gitHead": "60d701cca225200ddb1e15d6a3a31da25dfc3bc0"
+  "gitHead": "58b2f9f34b228712ccc4352e15913c52d6007afb"
 }