@dboio/cli 0.4.1 → 0.5.1

package/src/commands/pull.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { DboClient } from '../lib/client.js';
+import { loadConfig } from '../lib/config.js';
 import { formatError } from '../lib/formatter.js';
 import { saveToDisk } from '../lib/save-to-disk.js';
 import { log } from '../lib/logger.js';
@@ -82,6 +83,7 @@ export const pullCommand = new Command('pull')
 
       // Content entity has well-known defaults — skip prompts
       const isContent = entity === 'content';
+      const config = await loadConfig();
 
       if (isContent) {
         await saveToDisk(rows, columns, {
@@ -94,12 +96,16 @@ export const pullCommand = new Command('pull')
           contentFileMap: columns.includes('Content') ? {
             Content: { suffix: '', extensionSource: columns.includes('Extension') ? 'Extension' : null, extension: 'txt' },
           } : null,
+          changeDetection: true,
+          config,
         });
       } else {
         // Other entities: interactive prompts for column selection
         await saveToDisk(rows, columns, {
           entity,
           nonInteractive: false,
+          changeDetection: true,
+          config,
         });
       }
     } catch (err) {

package/src/commands/push.js

@@ -1,13 +1,14 @@
 import { Command } from 'commander';
-import { readFile, readdir, stat, writeFile } from 'fs/promises';
+import { readFile, stat, writeFile } from 'fs/promises';
 import { join, dirname, basename, extname, relative } from 'path';
 import { DboClient } from '../lib/client.js';
 import { buildInputBody, checkSubmitErrors } from '../lib/input-parser.js';
 import { formatResponse, formatError } from '../lib/formatter.js';
 import { log } from '../lib/logger.js';
 import { shouldSkipColumn } from '../lib/columns.js';
-import { loadConfig } from '../lib/config.js';
+import { loadConfig, loadSynchronize, saveSynchronize } from '../lib/config.js';
 import { setFileTimestamps } from '../lib/timestamps.js';
+import { findMetadataFiles } from '../lib/diff.js';
 
 export const pushCommand = new Command('push')
   .description('Push local files back to DBO.io using metadata from pull')
@@ -24,6 +25,10 @@ export const pushCommand = new Command('push')
   .action(async (targetPath, options) => {
     try {
       const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+
+      // Process pending deletions from synchronize.json
+      await processPendingDeletes(client, options);
+
       const pathStat = await stat(targetPath);
 
       if (pathStat.isDirectory()) {
@@ -37,6 +42,62 @@ export const pushCommand = new Command('push')
     }
   });
 
+/**
+ * Process pending delete entries from .dbo/synchronize.json
+ */
+async function processPendingDeletes(client, options) {
+  const sync = await loadSynchronize();
+  if (!sync.delete || sync.delete.length === 0) return;
+
+  log.info(`Processing ${sync.delete.length} pending deletion(s)...`);
+
+  const remaining = [];
+  for (const entry of sync.delete) {
+    log.info(`Deleting "${entry.name}" (${entry.entity}:${entry.RowID})`);
+
+    const extraParams = { '_confirm': options.confirm || 'true' };
+    if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
+
+    const body = await buildInputBody([entry.expression], extraParams);
+
+    try {
+      const result = await client.postUrlEncoded('/api/input/submit', body);
+
+      // Retry with prompted params if needed
+      const retryParams = await checkSubmitErrors(result);
+      if (retryParams) {
+        Object.assign(extraParams, retryParams);
+        const retryBody = await buildInputBody([entry.expression], extraParams);
+        const retryResult = await client.postUrlEncoded('/api/input/submit', retryBody);
+        if (retryResult.successful) {
+          log.success(`  Deleted "${entry.name}" from server`);
+        } else {
+          log.error(`  Failed to delete "${entry.name}"`);
+          formatResponse(retryResult, { json: options.json, jq: options.jq });
+          remaining.push(entry);
+        }
+      } else if (result.successful) {
+        log.success(`  Deleted "${entry.name}" from server`);
+      } else {
+        log.error(`  Failed to delete "${entry.name}"`);
+        formatResponse(result, { json: options.json, jq: options.jq });
+        remaining.push(entry);
+      }
+    } catch (err) {
+      log.error(`  Failed to delete "${entry.name}": ${err.message}`);
+      remaining.push(entry);
+    }
+  }
+
+  // Update synchronize.json with any remaining entries
+  sync.delete = remaining;
+  await saveSynchronize(sync);
+
+  if (remaining.length > 0) {
+    log.warn(`${remaining.length} deletion(s) failed and remain staged.`);
+  }
+}
+
 /**
  * Push a single file using its companion .metadata.json
  */
@@ -288,22 +349,3 @@ async function checkPathMismatch(meta, metaPath, options) {
     log.success(`  Path updated to "${currentPath}"`);
   }
 }
-
-/**
- * Recursively find all .metadata.json files in a directory
- */
-async function findMetadataFiles(dir) {
-  const results = [];
-  const entries = await readdir(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...await findMetadataFiles(fullPath));
-    } else if (entry.name.endsWith('.metadata.json')) {
-      results.push(fullPath);
-    }
-  }
-
-  return results;
-}

package/src/commands/rm.js

@@ -0,0 +1,337 @@
+import { Command } from 'commander';
+import { readFile, unlink, stat, rm as fsRm } from 'fs/promises';
+import { join, dirname, basename, extname } from 'path';
+import { log } from '../lib/logger.js';
+import { formatError } from '../lib/formatter.js';
+import { addDeleteEntry, removeAppJsonReference } from '../lib/config.js';
+import { findMetadataFiles } from '../lib/diff.js';
+import { loadStructureFile, findBinByPath, findChildBins, BINS_DIR } from '../lib/structure.js';
+
+export const rmCommand = new Command('rm')
+  .description('Remove a file or directory locally and stage server deletions for the next dbo push')
+  .argument('<path>', 'File, metadata.json, or directory to remove')
+  .option('-f, --force', 'Skip confirmation prompts')
+  .option('--keep-local', 'Only stage server deletion, do not delete local files')
+  .action(async (targetPath, options) => {
+    try {
+      const pathStat = await stat(targetPath).catch(() => null);
+      if (!pathStat) {
+        log.error(`Path not found: "${targetPath}"`);
+        process.exit(1);
+      }
+
+      if (pathStat.isDirectory()) {
+        await rmDirectory(targetPath, options);
+      } else {
+        await rmFile(targetPath, options);
+      }
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });
+
+// ── File removal (existing logic) ──────────────────────────────────────────
+
+/**
+ * Resolve a file path to its metadata.json path.
+ */
+function resolveMetaPath(filePath) {
+  if (filePath.endsWith('.metadata.json')) {
+    return filePath;
+  }
+  const dir = dirname(filePath);
+  const ext = extname(filePath);
+  const base = basename(filePath, ext);
+  return join(dir, `${base}.metadata.json`);
+}
+
+/**
+ * Get the entity-specific row ID from metadata.
+ * Checks _id first (shorthand), then derives from entity name.
+ */
+function getRowId(meta) {
+  if (meta._id) return meta._id;
+  if (meta._entity) {
+    const entityIdKey = meta._entity.charAt(0).toUpperCase() + meta._entity.slice(1) + 'ID';
+    if (meta[entityIdKey]) return meta[entityIdKey];
+  }
+  return null;
+}
+
+/**
+ * Remove a single file record: stage deletion, remove from app.json, delete local files.
+ * Returns true if removed, false if skipped.
+ */
+async function rmFileRecord(metaPath, options, { skipPrompt = false } = {}) {
+  let meta;
+  try {
+    meta = JSON.parse(await readFile(metaPath, 'utf8'));
+  } catch {
+    log.warn(`  Could not read metadata: ${metaPath}`);
+    return false;
+  }
+
+  const entity = meta._entity;
+  const uid = meta.UID;
+  const rowId = getRowId(meta);
+
+  if (!entity || !rowId) {
+    log.warn(`  Skipping "${metaPath}": missing _entity or row ID`);
+    return false;
+  }
+
+  // Collect local files
+  const metaDir = dirname(metaPath);
+  const localFiles = [metaPath];
+
+  for (const col of (meta._contentColumns || [])) {
+    const ref = meta[col];
+    if (ref && String(ref).startsWith('@')) {
+      localFiles.push(join(metaDir, String(ref).substring(1)));
+    }
+  }
+
+  if (meta._mediaFile && String(meta._mediaFile).startsWith('@')) {
+    localFiles.push(join(metaDir, String(meta._mediaFile).substring(1)));
+  }
+
+  const displayName = basename(metaPath, '.metadata.json');
+
+  // Prompt if needed
+  if (!skipPrompt && !options.force) {
+    const inquirer = (await import('inquirer')).default;
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Remove "${displayName}" (${entity}:${uid || rowId})?`,
+      default: true,
+    }]);
+    if (!confirm) {
+      log.dim(`  Skipped ${displayName}`);
+      return false;
+    }
+  }
+
+  // Stage deletion
+  const expression = `RowID:del${rowId};entity:${entity}=true`;
+  await addDeleteEntry({ UID: uid, RowID: rowId, entity, name: displayName, expression });
+  log.success(`  Staged: ${displayName} → ${expression}`);
+
+  // Remove from app.json
+  await removeAppJsonReference(metaPath);
+
+  // Delete local files
+  if (!options.keepLocal) {
+    for (const f of localFiles) {
+      try {
+        await unlink(f);
+        log.dim(`  Deleted ${f}`);
+      } catch { /* file may not exist */ }
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Remove a single file (entry point for non-directory rm).
+ */
+async function rmFile(filePath, options) {
+  const metaPath = resolveMetaPath(filePath);
+
+  let meta;
+  try {
+    meta = JSON.parse(await readFile(metaPath, 'utf8'));
+  } catch {
+    log.error(`No metadata found at "${metaPath}". Cannot determine record to delete.`);
+    process.exit(1);
+  }
+
+  const entity = meta._entity;
+  const uid = meta.UID;
+  const rowId = getRowId(meta);
+
+  if (!entity) {
+    log.error(`No _entity found in "${metaPath}".`);
+    process.exit(1);
+  }
+  if (!rowId) {
+    log.error(`No row ID found in "${metaPath}". Cannot build delete expression.`);
+    process.exit(1);
+  }
+
+  // Collect local files for display
+  const metaDir = dirname(metaPath);
+  const localFiles = [metaPath];
+  for (const col of (meta._contentColumns || [])) {
+    const ref = meta[col];
+    if (ref && String(ref).startsWith('@')) {
+      localFiles.push(join(metaDir, String(ref).substring(1)));
+    }
+  }
+  if (meta._mediaFile && String(meta._mediaFile).startsWith('@')) {
+    localFiles.push(join(metaDir, String(meta._mediaFile).substring(1)));
+  }
+
+  const displayName = basename(metaPath, '.metadata.json');
+  log.info(`Removing "${displayName}" (${entity}:${uid || rowId})`);
+  for (const f of localFiles) {
+    log.dim(`  ${f}`);
+  }
+
+  // Confirmation
+  if (!options.force) {
+    const inquirer = (await import('inquirer')).default;
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Do you really want to remove this file and all of its nodes?\n  The next `dbo push` will also remove the record from the server.',
+      default: false,
+    }]);
+    if (!confirm) {
+      log.dim('Cancelled.');
+      return;
+    }
+  }
+
+  const expression = `RowID:del${rowId};entity:${entity}=true`;
+  await addDeleteEntry({ UID: uid, RowID: rowId, entity, name: displayName, expression });
+  log.success(`Staged deletion: ${expression}`);
+
+  await removeAppJsonReference(metaPath);
+
+  if (!options.keepLocal) {
+    for (const f of localFiles) {
+      try {
+        await unlink(f);
+        log.dim(`  Deleted ${f}`);
+      } catch {
+        log.warn(`  Could not delete ${f} (may not exist)`);
+      }
+    }
+  }
+
+  log.info('Run `dbo push` to apply the deletion on the server.');
+}
+
+// ── Directory removal ──────────────────────────────────────────────────────
+
+/**
+ * Collect bins in depth-first order (leaves first) for safe deletion.
+ */
+function collectBinsDepthFirst(binId, structure) {
+  const result = [];
+  const children = findChildBins(binId, structure);
+  for (const child of children) {
+    result.push(...collectBinsDepthFirst(child.binId, structure));
+  }
+  result.push(structure[binId]);
+  return result;
+}
+
+/**
+ * Remove a directory: all files inside, sub-bins recursively, then the bin itself.
+ */
+async function rmDirectory(dirPath, options) {
+  const structure = await loadStructureFile();
+  const bin = findBinByPath(dirPath, structure);
+
+  if (!bin) {
+    log.error(`Directory "${dirPath}" is not a known bin in structure.json.`);
+    process.exit(1);
+  }
+
+  // Collect all bins depth-first (leaves first)
+  const binsToRemove = collectBinsDepthFirst(bin.binId, structure);
+
+  // Count total files across all directories
+  let totalFiles = 0;
+  const binFilesMap = new Map(); // binId → [metaFiles]
+  for (const b of binsToRemove) {
+    const binDir = `${BINS_DIR}/${b.fullPath}`;
+    try {
+      const metaFiles = await findMetadataFiles(binDir);
+      binFilesMap.set(b.binId, metaFiles);
+      totalFiles += metaFiles.length;
+    } catch {
+      binFilesMap.set(b.binId, []);
+    }
+  }
+
+  // Summary
+  log.info(`Directory "${dirPath}" contains ${totalFiles} file(s) across ${binsToRemove.length} directory(ies)`);
+  for (const b of binsToRemove) {
+    const files = binFilesMap.get(b.binId) || [];
+    log.dim(`  ${BINS_DIR}/${b.fullPath}/ (${files.length} files, bin:${b.binId})`);
+  }
+
+  // Prompt for approach
+  let bulkRemove = options.force;
+  if (!options.force && totalFiles > 0) {
+    const inquirer = (await import('inquirer')).default;
+    const { action } = await inquirer.prompt([{
+      type: 'list',
+      name: 'action',
+      message: `How do you want to proceed?`,
+      choices: [
+        { name: 'Remove all files and directories', value: 'all' },
+        { name: 'Prompt for each file', value: 'each' },
+        { name: 'Cancel', value: 'cancel' },
+      ],
+    }]);
+
+    if (action === 'cancel') {
+      log.dim('Cancelled.');
+      return;
+    }
+    bulkRemove = action === 'all';
+  } else if (!options.force && totalFiles === 0) {
+    // Empty directory — just confirm bin deletion
+    const inquirer = (await import('inquirer')).default;
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Remove empty directory "${dirPath}" (bin:${bin.binId})?\n  The next \`dbo push\` will also remove it from the server.`,
+      default: true,
+    }]);
+    if (!confirm) {
+      log.dim('Cancelled.');
+      return;
+    }
+    bulkRemove = true;
+  }
+
+  // Process each bin (depth-first: leaves first)
+  for (const b of binsToRemove) {
+    const metaFiles = binFilesMap.get(b.binId) || [];
+
+    // Remove files in this bin
+    for (const metaPath of metaFiles) {
+      await rmFileRecord(metaPath, options, { skipPrompt: bulkRemove });
+    }
+
+    // Stage the bin itself for deletion
+    const binExpression = `RowID:del${b.binId};entity:bin=true`;
+    await addDeleteEntry({
+      UID: b.uid,
+      RowID: b.binId,
+      entity: 'bin',
+      name: b.name,
+      expression: binExpression,
+    });
+    log.success(`  Staged bin: ${b.name} (${b.binId}) → ${binExpression}`);
+  }
+
+  // Remove local directories
+  if (!options.keepLocal) {
+    try {
+      await fsRm(dirPath, { recursive: true });
+      log.dim(`  Removed directory: ${dirPath}`);
+    } catch {
+      log.warn(`  Could not remove directory: ${dirPath}`);
+    }
+  }
+
+  log.info('Run `dbo push` to apply the deletions on the server.');
+}

package/src/commands/status.js

@@ -1,6 +1,9 @@
 import { Command } from 'commander';
-import { loadConfig, isInitialized, getActiveCookiesPath, loadUserInfo } from '../lib/config.js';
+import { loadConfig, isInitialized, getActiveCookiesPath, loadUserInfo, getAllPluginScopes } from '../lib/config.js';
 import { loadCookies } from '../lib/cookie-jar.js';
+import { access } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
 import { log } from '../lib/logger.js';
 
 export const statusCommand = new Command('status')
@@ -34,6 +37,30 @@ export const statusCommand = new Command('status')
       } else {
         log.label('Session', 'No active session. Run "dbo login".');
       }
+
+      // Display plugin status
+      const scopes = await getAllPluginScopes();
+      const pluginNames = Object.keys(scopes);
+
+      if (pluginNames.length > 0) {
+        log.plain('');
+        log.info('Claude Code Plugins:');
+        for (const [name, scope] of Object.entries(scopes)) {
+          const resolvedScope = scope || 'project';
+          const fileName = `${name}.md`;
+          let location;
+          if (resolvedScope === 'global') {
+            location = join(homedir(), '.claude', 'commands', fileName);
+          } else {
+            location = join(process.cwd(), '.claude', 'commands', fileName);
+          }
+          let installed = false;
+          try { await access(location); installed = true; } catch {}
+          const icon = installed ? '\u2713' : '\u2717';
+          const scopeLabel = resolvedScope === 'global' ? 'global' : 'project';
+          log.label(`  ${name}`, `${icon} ${scopeLabel} (${installed ? location : 'not found'})`);
+        }
+      }
     } catch (err) {
       log.error(err.message);
       process.exit(1);