@dboio/cli 0.11.4 → 0.15.0

package/src/commands/run.js

@@ -0,0 +1,81 @@
+// src/commands/run.js
+import { Command } from 'commander';
+import { loadScripts, loadScriptsLocal, loadConfig, loadAppConfig } from '../lib/config.js';
+import { mergeScriptsConfig, buildHookEnv, runHook } from '../lib/scripts.js';
+import { log } from '../lib/logger.js';
+
+export const runCommand = new Command('run')
+  .description('Run a named script from .dbo/scripts.json (like npm run)')
+  .argument('[script-name]', 'Name of the script to run (omit to list all scripts)')
+  .action(async (scriptName, options) => {
+    try {
+      const base = await loadScripts();
+      const local = await loadScriptsLocal();
+
+      if (!base && !local) {
+        log.error('No .dbo/scripts.json found');
+        process.exit(1);
+      }
+
+      const config = mergeScriptsConfig(base, local);
+      const scripts = config.scripts || {};
+
+      if (!scriptName) {
+        // List all script names
+        const allNames = Object.keys(scripts);
+        if (allNames.length === 0) {
+          log.info('No scripts defined in .dbo/scripts.json');
+          return;
+        }
+        log.info('Available scripts:');
+        for (const name of allNames) {
+          const value = scripts[name];
+          const preview = Array.isArray(value) ? value[0] : (value === false ? '(skip)' : String(value));
+          log.plain(`  ${name}: ${preview}`);
+        }
+        return;
+      }
+
+      if (!(scriptName in scripts)) {
+        log.error(`Script "${scriptName}" not found in .dbo/scripts.json`);
+        process.exit(1);
+      }
+
+      const cfg = await loadConfig();
+      const app = await loadAppConfig();
+      const appConfig = { ...app, domain: cfg.domain };
+      const env = buildHookEnv('', scriptName, appConfig);
+
+      // Pre/post auto-resolution
+      const preKey = `pre${scriptName}`;
+      const postKey = `post${scriptName}`;
+
+      if (preKey in scripts) {
+        log.dim(`  Running ${preKey}...`);
+        const result = await runHook(scripts[preKey], env, { cwd: process.cwd() });
+        if (!result.skipped && result.exitCode !== 0 && result.exitCode !== null) {
+          log.error(`Script "${preKey}" failed with exit code ${result.exitCode}`);
+          process.exit(result.exitCode);
+        }
+      }
+
+      log.dim(`  Running ${scriptName}...`);
+      const result = await runHook(scripts[scriptName], env, { cwd: process.cwd() });
+      if (!result.skipped && result.exitCode !== 0 && result.exitCode !== null) {
+        log.error(`Script "${scriptName}" failed with exit code ${result.exitCode}`);
+        process.exit(result.exitCode);
+      }
+
+      if (postKey in scripts) {
+        log.dim(`  Running ${postKey}...`);
+        const postResult = await runHook(scripts[postKey], env, { cwd: process.cwd() });
+        if (!postResult.skipped && postResult.exitCode !== 0 && postResult.exitCode !== null) {
+          log.error(`Script "${postKey}" failed with exit code ${postResult.exitCode}`);
+          process.exit(postResult.exitCode);
+        }
+      }
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });

package/src/commands/tag.js

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { tagProjectFiles } from '../lib/tagging.js';
+import { loadTagConfig, saveTagConfig } from '../lib/config.js';
+import { loadIgnore } from '../lib/ignore.js';
+import { join } from 'path';
+
+export const tagCommand = new Command('tag')
+  .description('Apply sync-status tags (Finder color tags / gio emblems) to project files')
+  .argument('[path]', 'File or directory to tag (defaults to entire project)')
+  .option('--clear', 'Remove all dbo:* tags from companion files')
+  .option('--status', 'Show counts of synced / modified / untracked / trashed files')
+  .option('--enable', 'Enable automatic tagging after clone/pull/push')
+  .option('--disable', 'Disable automatic tagging after clone/pull/push')
+  .option('--verbose', 'Log each file with its status')
+  .action(async (pathArg, options) => {
+    if (options.enable) {
+      await saveTagConfig(true);
+      console.log(chalk.green('✔ Automatic file tagging enabled'));
+      return;
+    }
+    if (options.disable) {
+      await saveTagConfig(false);
+      console.log(chalk.yellow('Automatic file tagging disabled'));
+      return;
+    }
+
+    // Verify project is initialized
+    const ig = await loadIgnore().catch(() => null);
+    if (!ig) {
+      console.error(chalk.red('Not a dbo project'));
+      process.exit(1);
+    }
+
+    const dir = pathArg ? join(process.cwd(), pathArg) : process.cwd();
+
+    if (options.clear) {
+      await tagProjectFiles({ clearAll: true, dir, verbose: options.verbose });
+      console.log(chalk.green('✔ All dbo:* tags cleared'));
+      return;
+    }
+
+    const counts = await tagProjectFiles({ verbose: options.verbose, dir });
+
+    if (counts === null) {
+      const { tagFiles } = await loadTagConfig();
+      if (!tagFiles) {
+        console.log(chalk.yellow('File tagging is disabled. Run `dbo tag --enable` to enable.'));
+      } else {
+        console.log(chalk.dim('File tagging is not supported on this platform.'));
+      }
+      return;
+    }
+
+    if (options.status || options.verbose) {
+      console.log(
+        `${chalk.green(counts.synced)} synced, ` +
+        `${chalk.blue(counts.modified)} modified, ` +
+        `${chalk.yellow(counts.untracked)} untracked, ` +
+        `${chalk.red(counts.trashed)} trashed`
+      );
+    } else {
+      console.log(chalk.green(`✔ Tags applied (${counts.synced} synced, ${counts.modified} modified, ${counts.untracked} untracked)`));
+    }
+  });

package/src/lib/config.js

@@ -9,6 +9,8 @@ const CREDENTIALS_FILE = 'credentials.json';
 const COOKIES_FILE = 'cookies.txt';
 const SYNCHRONIZE_FILE = 'synchronize.json';
 const BASELINE_FILE = '.app_baseline.json';
+const SCRIPTS_FILE = 'scripts.json';
+const SCRIPTS_LOCAL_FILE = 'scripts.local.json';
 
 function dboDir() {
   return join(process.cwd(), DBO_DIR);
@@ -897,3 +899,68 @@ export async function loadExtensionDocumentationMDPlacement() {
     return cfg.ExtensionDocumentationMDPlacement || null;
   } catch { return null; }
 }
+
+// ─── Script Hooks (.dbo/scripts.json, .dbo/scripts.local.json) ────────────
+
+function scriptsPath() {
+  return join(dboDir(), SCRIPTS_FILE);
+}
+
+function scriptsLocalPath() {
+  return join(dboDir(), SCRIPTS_LOCAL_FILE);
+}
+
+/**
+ * Load .dbo/scripts.json. Returns parsed object or null if missing.
+ * Throws SyntaxError with clear message if JSON is malformed.
+ */
+export async function loadScripts() {
+  const path = scriptsPath();
+  let raw;
+  try { raw = await readFile(path, 'utf8'); } catch { return null; }
+  try { return JSON.parse(raw); } catch (err) {
+    throw new SyntaxError(`Invalid JSON in .dbo/scripts.json: ${err.message}`);
+  }
+}
+
+/**
+ * Load .dbo/scripts.local.json (gitignored per-user overrides).
+ * Returns parsed object or null if missing.
+ * Throws SyntaxError with clear message if JSON is malformed.
+ */
+export async function loadScriptsLocal() {
+  const path = scriptsLocalPath();
+  let raw;
+  try { raw = await readFile(path, 'utf8'); } catch { return null; }
+  try { return JSON.parse(raw); } catch (err) {
+    throw new SyntaxError(`Invalid JSON in .dbo/scripts.local.json: ${err.message}`);
+  }
+}
+
+// ─── Tag Config ───────────────────────────────────────────────────────────────
+
+/**
+ * Load the tagFiles setting from config.json.
+ * @returns {Promise<{tagFiles: boolean}>} defaults to true
+ */
+export async function loadTagConfig() {
+  try {
+    const raw = await readFile(join(process.cwd(), DBO_DIR, CONFIG_FILE), 'utf8');
+    const config = JSON.parse(raw);
+    return { tagFiles: config.tagFiles !== false };
+  } catch {
+    return { tagFiles: true };
+  }
+}
+
+/**
+ * Enable or disable automatic file tagging by writing to config.json.
+ * @param {boolean} enabled
+ */
+export async function saveTagConfig(enabled) {
+  const configPath = join(process.cwd(), DBO_DIR, CONFIG_FILE);
+  let config = {};
+  try { config = JSON.parse(await readFile(configPath, 'utf8')); } catch {}
+  config.tagFiles = enabled;
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+}

package/src/lib/delta.js

@@ -81,7 +81,13 @@ export async function compareFileContent(filePath, baselineValue) {
 
     return normalizedCurrent !== normalizedBaseline;
   } catch (err) {
-    // If file doesn't exist or can't be read, consider it changed
+    if (err.code === 'ENOENT') {
+      // File doesn't exist on disk — nothing to push regardless of baseline.
+      // This commonly happens with CustomSQL companion files that clone
+      // didn't extract (e.g. non-CustomSQL type with server-side content).
+      return false;
+    }
+    // Other read errors — treat as changed to be safe
     log.warn(`Failed to read ${filePath}: ${err.message}`);
     return true;
   }

package/src/lib/deploy-config.js

@@ -0,0 +1,137 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join, relative, extname, basename } from 'path';
+import { log } from './logger.js';
+
+const DEPLOY_CONFIG_FILE = '.dbo/deploy_config.json';
+
+function deployConfigPath() {
+  return join(process.cwd(), DEPLOY_CONFIG_FILE);
+}
+
+function sortedKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+}
+
+/**
+ * Load .dbo/deploy_config.json. Returns { deployments: {} } if missing.
+ * Throws on malformed JSON (do not silently recreate — would lose existing entries).
+ */
+export async function loadDeployConfig() {
+  try {
+    const raw = await readFile(deployConfigPath(), 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === 'ENOENT') return { deployments: {} };
+    throw new Error(`Failed to parse ${DEPLOY_CONFIG_FILE}: ${err.message}`);
+  }
+}
+
+/**
+ * Write .dbo/deploy_config.json with alphabetically sorted deployment keys.
+ */
+export async function saveDeployConfig(config) {
+  await mkdir(join(process.cwd(), '.dbo'), { recursive: true });
+  const sorted = { ...config, deployments: sortedKeys(config.deployments || {}) };
+  await writeFile(deployConfigPath(), JSON.stringify(sorted, null, 2) + '\n');
+}
+
+/**
+ * Derive the <ext>:<basename> deploy key from a relative file path.
+ * Finds the shortest key not already occupied in existingDeployments.
+ *
+ * @param {string} relPath             - e.g. "lib/bins/app/assets/css/colors.css"
+ * @param {Object} existingDeployments - current deployments object (to avoid collisions)
+ * @returns {string}                   - e.g. "css:colors"
+ */
+export function buildDeployKey(relPath, existingDeployments = {}) {
+  const normalized = relPath.replace(/\\/g, '/');
+  const parts = normalized.split('/');
+  const filename = parts[parts.length - 1];
+  const ext = extname(filename).slice(1).toLowerCase();   // '' if no dot
+  const base = ext ? basename(filename, `.${ext}`) : filename;
+  const prefix = ext || 'file';
+
+  // Try simplest key first, then progressively add parent segments for disambiguation
+  const dirParts = parts.slice(0, -1);
+  const candidates = [`${prefix}:${base}`];
+  for (let depth = 1; depth <= dirParts.length; depth++) {
+    const suffix = dirParts.slice(-depth).join('/');
+    candidates.push(`${prefix}:${suffix}/${base}`);
+  }
+  candidates.push(`${prefix}:${normalized}`);   // absolute fallback
+
+  for (const key of candidates) {
+    if (!existingDeployments[key]) return key;
+  }
+  return `${prefix}:${normalized}`;  // always unique
+}
+
+/**
+ * Insert or update a deploy config entry for a companion file.
+ *
+ * Behaviour:
+ *  - If an entry with the same UID already exists → update file, entity, column in place
+ *    (keeps the existing key, avoids duplicate keys on re-clone)
+ *  - If a new key collision exists with a DIFFERENT UID → log a warning, skip
+ *  - Otherwise → create new entry with the shortest unique key
+ *
+ * @param {string} companionPath - Absolute path to the companion file
+ * @param {string} uid           - Record UID (from metadata)
+ * @param {string} entity        - Entity type (e.g. 'content', 'extension', 'media')
+ * @param {string} [column]      - Column name (e.g. 'Content', 'CSS')
+ */
+export async function upsertDeployEntry(companionPath, uid, entity, column) {
+  if (!uid || !companionPath) return;
+  const config = await loadDeployConfig();
+  const { deployments } = config;
+
+  const relPath = relative(process.cwd(), companionPath).replace(/\\/g, '/');
+
+  // Find if this UID is already tracked under any key
+  const existingKey = Object.keys(deployments).find(k => deployments[k].uid === uid);
+
+  if (existingKey) {
+    // Update path + metadata in place — keeps existing key, avoids duplicates on re-clone
+    deployments[existingKey] = {
+      ...deployments[existingKey],
+      file: relPath,
+      entity,
+      ...(column ? { column } : {}),
+    };
+    config.deployments = sortedKeys(deployments);
+    await saveDeployConfig(config);
+    return;
+  }
+
+  // New entry — build unique key avoiding all occupied keys
+  const key = buildDeployKey(relPath, deployments);
+
+  if (deployments[key]) {
+    // buildDeployKey returned an occupied key (should not happen — means all path segments collide)
+    log.warn(`Deploy config: skipping auto-registration of "${relPath}" — key "${key}" already exists for a different record. Add manually to ${DEPLOY_CONFIG_FILE}.`);
+    return;
+  }
+
+  const entry = { uid, file: relPath, entity };
+  if (column) entry.column = column;
+  deployments[key] = entry;
+  config.deployments = sortedKeys(deployments);
+  await saveDeployConfig(config);
+}
+
+/**
+ * Remove the deploy config entry matching a given UID.
+ * No-op if no entry with that UID exists.
+ *
+ * @param {string} uid - Record UID to remove
+ */
+export async function removeDeployEntry(uid) {
+  if (!uid) return;
+  const config = await loadDeployConfig();
+  const { deployments } = config;
+  const key = Object.keys(deployments).find(k => deployments[k].uid === uid);
+  if (!key) return;
+  delete deployments[key];
+  config.deployments = sortedKeys(deployments);
+  await saveDeployConfig(config);
+}

package/src/lib/diff.js

@@ -5,6 +5,7 @@ import { loadIgnore } from './ignore.js';
 import { parseServerDate, setFileTimestamps } from './timestamps.js';
 import { loadConfig, loadUserInfo, loadAppJsonBaseline } from './config.js';
 import { findBaselineEntry } from './delta.js';
+import { isMetadataFile, parseMetaFilename } from './filenames.js';
 import { log } from './logger.js';
 
 // ─── Baseline Cache ─────────────────────────────────────────────────────────
@@ -155,10 +156,10 @@ export async function findMetadataFiles(dir, ig) {
       const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
       if (ig.ignores(relPath + '/') || ig.ignores(relPath)) continue;
       results.push(...await findMetadataFiles(fullPath, ig));
-    } else if (entry.name.endsWith('.metadata.json')) {
+    } else if (isMetadataFile(entry.name) && !entry.name.startsWith('__WILL_DELETE__')) {
       const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
       if (!ig.ignores(relPath)) results.push(fullPath);
-    } else if (entry.name.endsWith('.json') && !entry.name.endsWith('.metadata.json') && !entry.name.includes('.CustomSQL.') && entry.name.includes('~')) {
+    } else if (entry.name.endsWith('.json') && !isMetadataFile(entry.name) && !entry.name.includes('.CustomSQL.') && entry.name.includes('~')) {
       // Output hierarchy root files: Name~UID.json (or legacy _output~Name~UID.json)
       // Exclude old-format child output files — they contain a dot-prefixed
       // child-type segment (.column~, .join~, .filter~) before .json.
@@ -217,6 +218,14 @@ export async function hasLocalModifications(metaPath, config = {}) {
     const metaDir = dirname(metaPath);
     const contentCols = meta._contentColumns || [];
 
+    // Load baseline for content comparison fallback (build tools can
+    // rewrite files with identical content, bumping mtime without any
+    // real change — e.g. sass recompile producing the same CSS).
+    const baseline = _cachedBaseline || await loadAppJsonBaseline();
+    const baselineEntry = baseline
+      ? findBaselineEntry(baseline, meta._entity, meta.UID)
+      : null;
+
     for (const col of contentCols) {
       const ref = meta[col];
       if (ref && String(ref).startsWith('@')) {
@@ -224,6 +233,20 @@ export async function hasLocalModifications(metaPath, config = {}) {
         try {
           const contentStat = await stat(contentPath);
           if (contentStat.mtime.getTime() > syncTime + 2000) {
+            // mtime says modified — verify with content comparison against
+            // baseline to rule out false positives from build tools.
+            if (baselineEntry && baselineEntry[col] != null) {
+              try {
+                const localContent = await readFile(contentPath, 'utf8');
+                const normalizedLocal = localContent.replace(/\r\n/g, '\n').trimEnd();
+                const normalizedBaseline = String(baselineEntry[col]).replace(/\r\n/g, '\n').trimEnd();
+                if (normalizedLocal === normalizedBaseline) {
+                  // Content identical — false positive mtime bump, fix timestamp
+                  await setFileTimestamps(contentPath, meta._CreatedOn, meta._LastUpdated, serverTz);
+                  continue;
+                }
+              } catch { /* read failed — treat as modified */ }
+            }
             return true;
           }
         } catch { /* missing file */ }
@@ -473,7 +496,7 @@ export async function compareRecord(metaPath, config, serverRecordsMap) {
   }
 
   const metaDir = dirname(metaPath);
-  const metaBase = basename(metaPath, '.metadata.json');
+  const metaBase = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
   const contentCols = localMeta._contentColumns || [];
   const fieldDiffs = [];
 
@@ -687,7 +710,7 @@ function buildChangeMessage(recordName, serverRecord, config, options = {}) {
  */
 function formatDateHint(serverDate, localDate) {
   const fmt = (d) => d instanceof Date && !isNaN(d)
-    ? d.toLocaleString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })
+    ? d.toLocaleString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit', second: '2-digit' })
     : null;
   const s = fmt(serverDate);
   const l = fmt(localDate);
@@ -777,7 +800,7 @@ export async function inlineDiffAndMerge(serverRow, metaPath, config, options =
   }
 
   const metaDir = dirname(metaPath);
-  const metaBase = basename(metaPath, '.metadata.json');
+  const metaBase = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
   const contentCols = localMeta._contentColumns || [];
   const fieldDiffs = [];