@dboio/cli 0.7.2 → 0.8.2

package/src/commands/init.js

@@ -4,8 +4,10 @@ import { join } from 'path';
 import { isInitialized, hasLegacyConfig, readLegacyConfig, initConfig, saveCredentials, ensureGitignore, saveTransactionKeyPreset, saveTicketSuggestionOutput } from '../lib/config.js';
 import { installOrUpdateClaudeCommands } from './install.js';
 import { scaffoldProjectDirs, logScaffoldResult } from '../lib/scaffold.js';
+import { createDboignore, loadIgnore } from '../lib/ignore.js';
 import { log } from '../lib/logger.js';
 import { checkDomainChange, writeAppJsonDomain } from '../lib/domain-guard.js';
+import { performLogin } from './login.js';
 
 export const initCommand = new Command('init')
   .description('Initialize DBO CLI configuration for the current directory')
@@ -19,10 +21,22 @@ export const initCommand = new Command('init')
   .option('-g, --global', 'Install Claude commands to user home directory (~/.claude/commands/)')
   .option('--local', 'Install Claude commands to project directory (.claude/commands/)')
   .option('--scaffold', 'Create standard project directories (App Versions, Automations, Bins, …)')
+  .option('--dboignore', 'Create or reset .dboignore to defaults (use with --force to overwrite)')
   .action(async (options) => {
     // Merge --yes into nonInteractive
     if (options.yes) options.nonInteractive = true;
     try {
+      // --dboignore: standalone operation, works regardless of init state
+      if (options.dboignore) {
+        const created = await createDboignore(process.cwd(), { force: options.force });
+        if (created) {
+          log.success(options.force ? 'Reset .dboignore to default patterns' : 'Created .dboignore with default patterns');
+        } else {
+          log.warn('.dboignore already exists. Use --force to overwrite with defaults.');
+        }
+        return;
+      }
+
       if (await isInitialized() && !options.force) {
         if (options.scaffold) {
           const result = await scaffoldProjectDirs();
@@ -86,6 +100,9 @@ export const initCommand = new Command('init')
       // Ensure sensitive files are gitignored
       await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt', '.dbo/config.local.json', '.dbo/ticketing.local.json']);
 
+      const createdIgnore = await createDboignore();
+      if (createdIgnore) log.dim('  Created .dboignore');
+
       log.success(`Initialized .dbo/ for ${domain}`);
       log.dim('  Run "dbo login" to authenticate.');
 
@@ -130,9 +147,9 @@ export const initCommand = new Command('init')
       let shouldScaffold = options.scaffold;
 
       if (!shouldScaffold && !options.nonInteractive) {
-        const entries = await readdir(process.cwd());
-        const IGNORED = new Set(['.dbo', '.claude', '.idea', '.vscode']);
-        const isEmpty = entries.every(e => IGNORED.has(e));
+        const entries = await readdir(process.cwd(), { withFileTypes: true });
+        const ig = await loadIgnore();
+        const isEmpty = entries.every(e => ig.ignores(e.isDirectory() ? e.name + '/' : e.name));
 
         const inquirer = (await import('inquirer')).default;
         const { doScaffold } = await inquirer.prompt([{
@@ -149,7 +166,7 @@ export const initCommand = new Command('init')
         logScaffoldResult(result);
       }
 
-      // Clone if requested
+      // Clone if requested — requires authentication first
       if (options.clone || options.app) {
         let appShortName = options.app;
         if (!appShortName) {
@@ -161,6 +178,13 @@ export const initCommand = new Command('init')
           }]);
           appShortName = appName;
         }
+
+        // Authenticate before fetching app data from the server
+        if (!options.nonInteractive) {
+          log.info('Login required to fetch app data from the server.');
+          await performLogin(domain, username);
+        }
+
         const { performClone } = await import('./clone.js');
         await performClone(null, { app: appShortName, domain });
       }

package/src/commands/install.js

@@ -235,7 +235,7 @@ async function promptForScope(pluginName) {
 
 /**
  * Resolve the scope for a plugin based on flags and stored preferences.
- * Priority: explicit flag > stored preference > prompt.
+ * Priority: explicit flag > stored preference > existing installation > prompt.
  * @param {string} pluginName - Plugin name without .md
  * @param {object} options - Command options with global/local flags
  * @returns {Promise<'project' | 'global'>}
@@ -247,6 +247,15 @@ async function resolvePluginScope(pluginName, options) {
   const storedScope = await getPluginScope(pluginName);
   if (storedScope) return storedScope;
 
+  // Infer from existing installation — avoids re-prompting on re-installs
+  // (e.g. postinstall after npm install when .dbo/ isn't in cwd)
+  const registry = await readPluginRegistry();
+  const key = `${pluginName}@${PLUGIN_MARKETPLACE}`;
+  if (registry.plugins[key]) return 'global';
+
+  const projectPluginDir = join(process.cwd(), '.claude', 'plugins', pluginName);
+  if (existsSync(projectPluginDir)) return 'project';
+
   return await promptForScope(pluginName);
 }
 

package/src/commands/login.js

@@ -3,6 +3,75 @@ import { loadConfig, saveUserInfo, saveUserProfile, ensureGitignore } from '../l
 import { DboClient } from '../lib/client.js';
 import { log } from '../lib/logger.js';
 
+/**
+ * Perform authentication against a DBO instance.
+ * Prompts for missing credentials interactively.
+ * Returns true on success, throws on failure.
+ *
+ * @param {string|null} domain - Override domain (null = use config)
+ * @param {string|null} knownUsername - Pre-filled username (will prompt if null)
+ */
+export async function performLogin(domain, knownUsername) {
+  const config = await loadConfig();
+  const client = new DboClient({ domain });
+
+  let username = knownUsername || config.username;
+  let password;
+
+  // Interactive prompt for missing credentials
+  const inquirer = (await import('inquirer')).default;
+  const answers = await inquirer.prompt([
+    { type: 'input', name: 'username', message: 'Username (email):', default: username || undefined, when: !username },
+    { type: 'password', name: 'password', message: 'Password:', mask: '*' },
+  ]);
+  username = username || answers.username;
+  password = answers.password;
+
+  const params = new URLSearchParams();
+  params.append('_username', username);
+  params.append('_password', password);
+
+  const result = await client.postUrlEncoded('/api/authenticate', params.toString());
+
+  if (!result.successful) {
+    throw new Error('Authentication failed');
+  }
+
+  log.success(`Authenticated as ${username} on ${await client.getDomain()}`);
+  await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt', '.dbo/ticketing.local.json']);
+
+  // Fetch and store user info (non-critical)
+  try {
+    const userResult = await client.get('/api/output/31799e38f0854956a47f10', { '_format': 'json_raw' });
+    const userData = userResult.payload || userResult.data;
+    const rows = Array.isArray(userData) ? userData : (userData?.Rows || userData?.rows || []);
+    if (rows.length > 0) {
+      const row = rows[0];
+      const userId = row.ID || row.id || row.UserID || row.userId;
+      if (userId) {
+        await saveUserInfo({ userId: String(userId) });
+        log.dim(`  User ID: ${userId}`);
+      }
+      const firstName = row.FirstName || row.firstname || row.first_name;
+      const lastName = row.LastName || row.lastname || row.last_name;
+      const email = row.Email || row.email;
+      const profile = {};
+      if (firstName) profile.FirstName = firstName;
+      if (lastName) profile.LastName = lastName;
+      if (email) profile.Email = email;
+      if (Object.keys(profile).length > 0) {
+        await saveUserProfile(profile);
+        if (firstName || lastName) log.dim(`  Name:     ${[firstName, lastName].filter(Boolean).join(' ')}`);
+        if (email) log.dim(`  Email:    ${email}`);
+      }
+    }
+  } catch {
+    log.dim('  Could not retrieve user info (non-critical)');
+  }
+
+  return true;
+}
+
 export const loginCommand = new Command('login')
   .description('Authenticate with a DBO.io instance')
   .option('-u, --username <value>', 'Username')

package/src/commands/push.js

@@ -12,7 +12,20 @@ import { checkModifyKey, isModifyKeyError, handleModifyKeyError } from '../lib/m
 import { resolveTransactionKey } from '../lib/transaction-key.js';
 import { setFileTimestamps } from '../lib/timestamps.js';
 import { findMetadataFiles } from '../lib/diff.js';
+import { loadIgnore } from '../lib/ignore.js';
 import { detectChangedColumns, findBaselineEntry } from '../lib/delta.js';
+
+/**
+ * Resolve an @reference file path to an absolute filesystem path.
+ * "@filename.ext"         → relative to the metadata file's directory (existing behaviour)
+ * "@/Documentation/..."  → relative to project root (process.cwd())
+ */
+function resolveAtReference(refFile, metaDir) {
+  if (refFile.startsWith('/')) {
+    return join(process.cwd(), refFile);
+  }
+  return join(metaDir, refFile);
+}
 import { ENTITY_DEPENDENCIES } from '../lib/dependencies.js';
 
 export const pushCommand = new Command('push')
@@ -166,7 +179,8 @@ async function pushSingleFile(filePath, client, options, modifyKey = null, trans
  * Push all records found in a directory (recursive)
  */
 async function pushDirectory(dirPath, client, options, modifyKey = null, transactionKey = 'RowUID') {
-  const metaFiles = await findMetadataFiles(dirPath);
+  const ig = await loadIgnore();
+  const metaFiles = await findMetadataFiles(dirPath, ig);
 
   if (metaFiles.length === 0) {
     log.warn(`No .metadata.json files found in "${dirPath}".`);
@@ -214,7 +228,7 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
     for (const col of contentCols) {
       const ref = meta[col];
       if (ref && ref.startsWith('@')) {
-        const refPath = join(dirname(metaPath), ref.substring(1));
+        const refPath = resolveAtReference(ref.substring(1), dirname(metaPath));
         try {
           await stat(refPath);
         } catch {
@@ -226,6 +240,26 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
     }
     if (missingFiles) { skipped++; continue; }
 
+    // Check if any companion content file is ignored by .dboignore
+    {
+      const metaDir = dirname(metaPath);
+      let contentIgnored = false;
+      for (const col of contentCols) {
+        const ref = meta[col];
+        if (ref && String(ref).startsWith('@')) {
+          const refFile = String(ref).substring(1);
+          const contentPath = resolveAtReference(refFile, metaDir);
+          const relContent = relative(process.cwd(), contentPath).replace(/\\/g, '/');
+          if (ig.ignores(relContent)) {
+            log.dim(`  Skipped (dboignored): ${basename(metaPath)}`);
+            contentIgnored = true;
+            break;
+          }
+        }
+      }
+      if (contentIgnored) { skipped++; continue; }
+    }
+
     // Detect changed columns (delta detection)
     let changedColumns = null;
     if (baseline) {
@@ -251,7 +285,8 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
 
   // Pre-flight ticket validation (only if no --ticket flag)
   if (!options.ticket && toPush.length > 0) {
-    const ticketCheck = await checkStoredTicket(options);
+    const recordSummary = toPush.map(r => basename(r.metaPath, '.metadata.json')).join(', ');
+    const ticketCheck = await checkStoredTicket(options, `${toPush.length} record(s): ${recordSummary}`);
     if (ticketCheck.cancel) {
       log.info('Submission cancelled');
       return;
@@ -378,38 +413,68 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
     if (strValue.startsWith('@')) {
       // @filename reference — resolve to actual file path
       const refFile = strValue.substring(1);
-      const refPath = join(metaDir, refFile);
+      const refPath = resolveAtReference(refFile, metaDir);
       dataExprs.push(`${rowKeyPrefix}:${rowKeyValue};column:${entity}.${key}@${refPath}`);
     } else {
       dataExprs.push(`${rowKeyPrefix}:${rowKeyValue};column:${entity}.${key}=${strValue}`);
     }
   }
 
-  if (dataExprs.length === 0) {
+  // Detect media file upload (binary file changed for media entity)
+  const isMediaUpload = entity === 'media' && meta._mediaFile
+    && String(meta._mediaFile).startsWith('@')
+    && changedColumns?.includes('_mediaFile');
+
+  if (dataExprs.length === 0 && !isMediaUpload) {
     log.warn(`Nothing to push for ${basename(metaPath)}`);
     return false;
   }
 
-  const fieldLabel = changedColumns ? `${dataExprs.length} changed field(s)` : `${dataExprs.length} field(s)`;
+  const fieldLabel = changedColumns ? `${dataExprs.length} changed field(s)${isMediaUpload ? ' + media file' : ''}` : `${dataExprs.length} field(s)`;
   log.info(`Pushing ${basename(metaPath, '.metadata.json')} (${entity}:${rowKeyValue}) — ${fieldLabel}`);
 
   // Apply stored ticket if no --ticket flag
-  await applyStoredTicketToSubmission(dataExprs, entity, uid || id, uid || id, options);
+  const storedTicket = await applyStoredTicketToSubmission(dataExprs, entity, uid || id, uid || id, options);
 
   const extraParams = { '_confirm': options.confirm };
   if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
+  else if (storedTicket) extraParams['_OverrideTicketID'] = storedTicket;
   if (modifyKey) extraParams['_modify_key'] = modifyKey;
 
-  let body = await buildInputBody(dataExprs, extraParams);
-  let result = await client.postUrlEncoded('/api/input/submit', body);
+  let result;
+
+  if (isMediaUpload) {
+    // Media file upload: use multipart/form-data
+    const mediaFileName = String(meta._mediaFile).substring(1);
+    const mediaFilePath = resolveAtReference(mediaFileName, metaDir);
+
+    // Ensure at least one data expression to identify the row for the server
+    if (dataExprs.length === 0 && meta.Filename) {
+      dataExprs.push(`${rowKeyPrefix}:${rowKeyValue};column:${entity}.Filename=${meta.Filename}`);
+    }
+
+    const fields = { ...extraParams };
+    for (const expr of dataExprs) {
+      const eqIdx = expr.indexOf('=');
+      if (eqIdx !== -1) {
+        fields[expr.substring(0, eqIdx)] = expr.substring(eqIdx + 1);
+      }
+    }
 
-  // Reactive ModifyKey retry — server rejected because key wasn't set locally
-  if (!result.successful && result.messages?.some(m => isModifyKeyError(m))) {
-    const retryMK = await handleModifyKeyError();
-    if (retryMK.cancel) { log.info('Submission cancelled'); return false; }
-    extraParams['_modify_key'] = retryMK.modifyKey;
-    body = await buildInputBody(dataExprs, extraParams);
+    const files = [{ fieldName: 'file', filePath: mediaFilePath, fileName: mediaFileName }];
+    result = await client.postMultipart('/api/input/submit', fields, files);
+  } else {
+    let body = await buildInputBody(dataExprs, extraParams);
     result = await client.postUrlEncoded('/api/input/submit', body);
+
+    // Reactive ModifyKey retry — server rejected because key wasn't set locally
+    if (!result.successful && result.messages?.some(m => isModifyKeyError(m))) {
+      const retryMK = await handleModifyKeyError();
+      if (retryMK.cancel) { log.info('Submission cancelled'); return false; }
+      extraParams['_modify_key'] = retryMK.modifyKey;
+      body = await buildInputBody(dataExprs, extraParams);
+      result = await client.postUrlEncoded('/api/input/submit', body);
+    }
   }
 
   // Retry with prompted params if needed (ticket, user, repo mismatch)
@@ -433,8 +498,22 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
     const params = retryResult.retryParams || retryResult;
     Object.assign(extraParams, params);
 
-    body = await buildInputBody(dataExprs, extraParams);
-    result = await client.postUrlEncoded('/api/input/submit', body);
+    if (isMediaUpload) {
+      const mediaFileName = String(meta._mediaFile).substring(1);
+      const mediaFilePath = resolveAtReference(mediaFileName, metaDir);
+      const fields = { ...extraParams };
+      for (const expr of dataExprs) {
+        const eqIdx = expr.indexOf('=');
+        if (eqIdx !== -1) {
+          fields[expr.substring(0, eqIdx)] = expr.substring(eqIdx + 1);
+        }
+      }
+      const files = [{ fieldName: 'file', filePath: mediaFilePath, fileName: mediaFileName }];
+      result = await client.postMultipart('/api/input/submit', fields, files);
+    } else {
+      const body = await buildInputBody(dataExprs, extraParams);
+      result = await client.postUrlEncoded('/api/input/submit', body);
+    }
   }
 
   formatResponse(result, { json: options.json, jq: options.jq });
@@ -474,6 +553,11 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
               await setFileTimestamps(contentPath, meta._CreatedOn, updated, serverTz);
             }
           }
+          // Update media file mtime too
+          if (meta._mediaFile && String(meta._mediaFile).startsWith('@')) {
+            const mediaPath = join(dirname(metaPath), String(meta._mediaFile).substring(1));
+            await setFileTimestamps(mediaPath, meta._CreatedOn, updated, serverTz);
+          }
         }
       }
     }
@@ -647,7 +731,7 @@ async function updateBaselineAfterPush(baseline, successfulPushes) {
       if (strValue.startsWith('@')) {
         try {
           const refFile = strValue.substring(1);
-          const refPath = join(dirname(metaPath), refFile);
+          const refPath = resolveAtReference(refFile, dirname(metaPath));
           const fileContent = await readFile(refPath, 'utf8');
           baselineEntry[col] = fileContent;
           modified = true;

package/src/lib/config.js

@@ -724,3 +724,104 @@ export async function loadAppJsonBaseline() {
 export async function saveAppJsonBaseline(data) {
   await writeFile(baselinePath(), JSON.stringify(data, null, 2) + '\n');
 }
+
+/**
+ * Save the clone source to .dbo/config.json.
+ * "default" = fetched from server via AppShortName.
+ * Any other value = explicit local file path or URL provided by the user.
+ */
+export async function saveCloneSource(source) {
+  await mkdir(dboDir(), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(configPath(), 'utf8'));
+  } catch { /* no existing config */ }
+  existing.cloneSource = source;
+  await writeFile(configPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Load the stored clone source from .dbo/config.json.
+ * Returns null if not set.
+ */
+export async function loadCloneSource() {
+  try {
+    const raw = await readFile(configPath(), 'utf8');
+    const config = JSON.parse(raw);
+    return config.cloneSource || null;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Descriptor-level Extension Preferences ───────────────────────────────
+
+/** Save filename column preference for a specific Descriptor value.
+ *  Config key: "Extension_<descriptor>_FilenameCol"
+ */
+export async function saveDescriptorFilenamePreference(descriptor, columnName) {
+  await mkdir(dboDir(), { recursive: true });
+  let cfg = {};
+  try { cfg = JSON.parse(await readFile(configPath(), 'utf8')); } catch {}
+  if (columnName === null) {
+    delete cfg[`Extension_${descriptor}_FilenameCol`];
+  } else {
+    cfg[`Extension_${descriptor}_FilenameCol`] = columnName;
+  }
+  await writeFile(configPath(), JSON.stringify(cfg, null, 2) + '\n');
+}
+
+/** Load filename column preference for a specific Descriptor value. Returns null if not set. */
+export async function loadDescriptorFilenamePreference(descriptor) {
+  try {
+    const cfg = JSON.parse(await readFile(configPath(), 'utf8'));
+    return cfg[`Extension_${descriptor}_FilenameCol`] || null;
+  } catch { return null; }
+}
+
+/** Save content extraction preferences for a specific Descriptor value.
+ *  Config key: "Extension_<descriptor>_ContentExtractions"
+ *  Value: { "ColName": "css", "Other": false, ... }
+ */
+export async function saveDescriptorContentExtractions(descriptor, extractions) {
+  await mkdir(dboDir(), { recursive: true });
+  let cfg = {};
+  try { cfg = JSON.parse(await readFile(configPath(), 'utf8')); } catch {}
+  if (extractions === null) {
+    delete cfg[`Extension_${descriptor}_ContentExtractions`];
+  } else {
+    cfg[`Extension_${descriptor}_ContentExtractions`] = extractions;
+  }
+  await writeFile(configPath(), JSON.stringify(cfg, null, 2) + '\n');
+}
+
+/** Load content extraction preferences for a specific Descriptor value. Returns null if not saved. */
+export async function loadDescriptorContentExtractions(descriptor) {
+  try {
+    const cfg = JSON.parse(await readFile(configPath(), 'utf8'));
+    return cfg[`Extension_${descriptor}_ContentExtractions`] || null;
+  } catch { return null; }
+}
+
+/** Save ExtensionDocumentationMDPlacement preference.
+ *  @param {'inline'|'root'|null} placement  — null clears the key
+ */
+export async function saveExtensionDocumentationMDPlacement(placement) {
+  await mkdir(dboDir(), { recursive: true });
+  let cfg = {};
+  try { cfg = JSON.parse(await readFile(configPath(), 'utf8')); } catch {}
+  if (placement === null) {
+    delete cfg.ExtensionDocumentationMDPlacement;
+  } else {
+    cfg.ExtensionDocumentationMDPlacement = placement;
+  }
+  await writeFile(configPath(), JSON.stringify(cfg, null, 2) + '\n');
+}
+
+/** Load ExtensionDocumentationMDPlacement preference. Returns 'inline', 'root', or null. */
+export async function loadExtensionDocumentationMDPlacement() {
+  try {
+    const cfg = JSON.parse(await readFile(configPath(), 'utf8'));
+    return cfg.ExtensionDocumentationMDPlacement || null;
+  } catch { return null; }
+}

package/src/lib/delta.js

@@ -1,4 +1,4 @@
-import { readFile } from 'fs/promises';
+import { readFile, stat } from 'fs/promises';
 import { join, dirname } from 'path';
 import { log } from './logger.js';
 
@@ -132,6 +132,19 @@ export async function detectChangedColumns(metaPath, baseline) {
     }
   }
 
+  // Check _mediaFile for binary file changes (media entities)
+  if (metadata._mediaFile && isReference(metadata._mediaFile)) {
+    const mediaPath = resolveReferencePath(metadata._mediaFile, metaDir);
+    try {
+      const mediaStat = await stat(mediaPath);
+      const metaStat = await stat(metaPath);
+      // Media file modified more recently than metadata = local change
+      if (mediaStat.mtimeMs > metaStat.mtimeMs + 2000) {
+        changedColumns.push('_mediaFile');
+      }
+    } catch { /* missing file, skip */ }
+  }
+
   return changedColumns;
 }
 

package/src/lib/diff.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { readFile, writeFile, readdir, access, stat } from 'fs/promises';
-import { join, dirname, basename, extname } from 'path';
+import { join, dirname, basename, extname, relative } from 'path';
+import { loadIgnore } from './ignore.js';
 import { parseServerDate, setFileTimestamps } from './timestamps.js';
 import { loadConfig, loadUserInfo } from './config.js';
 import { log } from './logger.js';
@@ -31,21 +32,25 @@ async function fileExists(path) {
  * Recursively find all metadata files in a directory.
  * Includes .metadata.json files and output hierarchy files (_output~*.json).
  */
-export async function findMetadataFiles(dir) {
+export async function findMetadataFiles(dir, ig) {
+  if (!ig) ig = await loadIgnore();
+
   const results = [];
   const entries = await readdir(dir, { withFileTypes: true });
 
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     if (entry.isDirectory()) {
-      // Skip hidden dirs, node_modules, .dbo
-      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
-      results.push(...await findMetadataFiles(fullPath));
+      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')) {
-      results.push(fullPath);
+      const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
+      if (!ig.ignores(relPath)) results.push(fullPath);
     } else if (entry.name.startsWith('_output~') && entry.name.endsWith('.json') && !entry.name.includes('.CustomSQL.')) {
       // Output hierarchy files: _output~<name>~<uid>.json and nested entity files
-      results.push(fullPath);
+      const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
+      if (!ig.ignores(relPath)) results.push(fullPath);
     }
   }
 
@@ -498,21 +503,67 @@ export async function applyServerChanges(diffResult, acceptedFields, config) {
   }
 }
 
+// ─── Diffability ─────────────────────────────────────────────────────────────
+
+// Extensions that can be meaningfully text-diffed
+const DIFFABLE_EXTENSIONS = new Set([
+  'js', 'mjs', 'cjs', 'ts', 'tsx', 'jsx',
+  'css', 'scss', 'less', 'sass',
+  'html', 'htm', 'xhtml',
+  'sql', 'xml', 'json', 'yaml', 'yml', 'toml', 'ini', 'env',
+  'md', 'txt', 'csv', 'tsv',
+  'sh', 'bash', 'zsh', 'ps1', 'bat', 'cmd',
+  'py', 'rb', 'php', 'java', 'c', 'cpp', 'h', 'cs', 'go', 'rs', 'swift', 'kt',
+  'vue', 'svelte', 'astro',
+  'graphql', 'gql', 'proto',
+  'htaccess', 'gitignore', 'dockerignore', 'editorconfig',
+]);
+
+/**
+ * Returns true if the file extension suggests it can be meaningfully text-diffed.
+ * Images, videos, audio, fonts, archives, and other binary formats return false.
+ */
+export function isDiffable(ext) {
+  if (!ext) return false;
+  return DIFFABLE_EXTENSIONS.has(String(ext).toLowerCase().replace(/^\./, ''));
+}
+
 // ─── Change Detection Prompt ────────────────────────────────────────────────
 
 /**
  * Build the change detection message describing who changed the file.
  */
-function buildChangeMessage(recordName, serverRecord, config) {
+function buildChangeMessage(recordName, serverRecord, config, options = {}) {
   const userInfo = loadUserInfoSync();
   const updatedBy = serverRecord._LastUpdatedUserID;
 
+  let who;
   if (updatedBy && userInfo && String(updatedBy) === String(userInfo.userId)) {
-    return `"${recordName}" was updated on server by you (from another session)`;
+    who = 'you (from another session)';
   } else if (updatedBy) {
-    return `"${recordName}" was updated on server by user ${updatedBy}`;
+    who = `user ${updatedBy}`;
+  }
+
+  const datePart = formatDateHint(options.serverDate, options.localDate);
+
+  if (who) {
+    return `"${recordName}" was updated on server by ${who}${datePart}`;
   }
-  return `"${recordName}" has updates newer than your local version`;
+  return `"${recordName}" has updates newer than your local version${datePart}`;
+}
+
+/**
+ * Format a "(server: X, local: Y)" hint when date info is available.
+ */
+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' })
+    : null;
+  const s = fmt(serverDate);
+  const l = fmt(localDate);
+  if (s && l) return `\n  server: ${s}  |  local: ${l}`;
+  if (s) return `\n  server: ${s}`;
+  return '';
 }
 
 // Sync version for message building (cached)
@@ -524,31 +575,36 @@ function loadUserInfoSync() {
 /**
  * Prompt the user when a record has changed.
  * options.localIsNewer: when true, the local file has modifications not on server.
+ * options.diffable: when false, omit the "Compare differences" choice.
+ * options.serverDate / options.localDate: Date objects shown as hints.
  * Returns: 'overwrite' | 'compare' | 'skip' | 'overwrite_all' | 'skip_all'
  */
 export async function promptChangeDetection(recordName, serverRecord, config, options = {}) {
   const localIsNewer = options.localIsNewer || false;
+  const diffable = options.diffable !== false; // default true for text records
 
   // Cache user info for message building
   _cachedUserInfo = await loadUserInfo();
 
+  const datePart = formatDateHint(options.serverDate, options.localDate);
+
   const message = localIsNewer
-    ? `"${recordName}" has local changes not on the server`
-    : buildChangeMessage(recordName, serverRecord, config);
+    ? `"${recordName}" has local changes not on the server${datePart}`
+    : buildChangeMessage(recordName, serverRecord, config, options);
 
   const inquirer = (await import('inquirer')).default;
 
   const choices = localIsNewer
     ? [
         { name: 'Restore server version (discard local changes)', value: 'overwrite' },
-        { name: 'Compare differences (dbo diff)', value: 'compare' },
+        ...(diffable ? [{ name: 'Compare differences (dbo diff)', value: 'compare' }] : []),
         { name: 'Keep local changes', value: 'skip' },
         { name: 'Restore all to server version', value: 'overwrite_all' },
         { name: 'Keep all local changes', value: 'skip_all' },
       ]
     : [
         { name: 'Overwrite local file with server version', value: 'overwrite' },
-        { name: 'Compare differences (dbo diff)', value: 'compare' },
+        ...(diffable ? [{ name: 'Compare differences (dbo diff)', value: 'compare' }] : []),
         { name: 'Skip this file', value: 'skip' },
         { name: 'Overwrite this and all remaining changed files', value: 'overwrite_all' },
         { name: 'Skip all remaining changed files', value: 'skip_all' },