@dboio/cli 0.4.2 → 0.6.0

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);

package/src/lib/config.js

@@ -4,8 +4,11 @@ import { log } from './logger.js';
 
 const DBO_DIR = '.dbo';
 const CONFIG_FILE = 'config.json';
+const CONFIG_LOCAL_FILE = 'config.local.json';
 const CREDENTIALS_FILE = 'credentials.json';
 const COOKIES_FILE = 'cookies.txt';
+const SYNCHRONIZE_FILE = 'synchronize.json';
+const BASELINE_FILE = '.app.json';
 
 function dboDir() {
   return join(process.cwd(), DBO_DIR);
@@ -23,6 +26,10 @@ function cookiesPath() {
   return join(dboDir(), COOKIES_FILE);
 }
 
+function synchronizePath() {
+  return join(dboDir(), SYNCHRONIZE_FILE);
+}
+
 async function exists(path) {
   try {
     await access(path);
@@ -212,6 +219,73 @@ export async function loadClonePlacement() {
   }
 }
 
+/**
+ * Save entity-dir filename column preference to .dbo/config.json.
+ * Key format: "<EntityType>FilenameCol" (e.g., "ExtensionFilenameCol")
+ */
+export async function saveEntityDirPreference(entityKey, filenameCol) {
+  await mkdir(dboDir(), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(configPath(), 'utf8'));
+  } catch { /* no existing config */ }
+  // Capitalize first letter for config key: extension → ExtensionFilenameCol
+  const configKey = entityKey.charAt(0).toUpperCase() + entityKey.slice(1) + 'FilenameCol';
+  existing[configKey] = filenameCol;
+  await writeFile(configPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Load entity-dir filename column preference from .dbo/config.json.
+ */
+export async function loadEntityDirPreference(entityKey) {
+  try {
+    const raw = await readFile(configPath(), 'utf8');
+    const config = JSON.parse(raw);
+    const configKey = entityKey.charAt(0).toUpperCase() + entityKey.slice(1) + 'FilenameCol';
+    return config[configKey] || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save content extraction preferences for an entity type.
+ * Stores which base64 columns should be extracted as companion files and their extensions.
+ *
+ * @param {string} entityKey - Entity type (e.g., 'extension', 'site')
+ * @param {Object} extractions - Map of column names to extensions: { "String10": "css", "String7": false, ... }
+ *                                 false means user explicitly chose not to extract that column
+ */
+export async function saveEntityContentExtractions(entityKey, extractions) {
+  await mkdir(dboDir(), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(configPath(), 'utf8'));
+  } catch { /* no existing config */ }
+  // Capitalize first letter for config key: extension → ExtensionContentExtractions
+  const configKey = entityKey.charAt(0).toUpperCase() + entityKey.slice(1) + 'ContentExtractions';
+  existing[configKey] = extractions;
+  await writeFile(configPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Load content extraction preferences for an entity type from .dbo/config.json.
+ *
+ * @param {string} entityKey - Entity type (e.g., 'extension', 'site')
+ * @returns {Object|null} - Map of column names to extensions, or null if not saved
+ */
+export async function loadEntityContentExtractions(entityKey) {
+  try {
+    const raw = await readFile(configPath(), 'utf8');
+    const config = JSON.parse(raw);
+    const configKey = entityKey.charAt(0).toUpperCase() + entityKey.slice(1) + 'ContentExtractions';
+    return config[configKey] || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Save user profile fields (FirstName, LastName, Email) into credentials.json.
  */
@@ -244,6 +318,165 @@ export async function loadUserProfile() {
   }
 }
 
+/**
+ * Load synchronize.json (staging file for pending server operations).
+ */
+export async function loadSynchronize() {
+  try {
+    const raw = await readFile(synchronizePath(), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return { delete: [], edit: [], add: [] };
+  }
+}
+
+/**
+ * Save synchronize.json.
+ */
+export async function saveSynchronize(data) {
+  await mkdir(dboDir(), { recursive: true });
+  await writeFile(synchronizePath(), JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Stage a delete entry in synchronize.json. Deduplicates by UID.
+ */
+export async function addDeleteEntry(entry) {
+  const data = await loadSynchronize();
+  const idx = data.delete.findIndex(e => e.UID === entry.UID);
+  if (idx >= 0) {
+    data.delete[idx] = entry;
+  } else {
+    data.delete.push(entry);
+  }
+  await saveSynchronize(data);
+}
+
+/**
+ * Remove a delete entry from synchronize.json by UID.
+ */
+export async function removeDeleteEntry(uid) {
+  const data = await loadSynchronize();
+  data.delete = data.delete.filter(e => e.UID !== uid);
+  await saveSynchronize(data);
+}
+
+/**
+ * Remove a @metaPath reference from app.json children arrays.
+ */
+export async function removeAppJsonReference(metaPath) {
+  const appJsonPath = join(process.cwd(), 'app.json');
+  let appJson;
+  try {
+    appJson = JSON.parse(await readFile(appJsonPath, 'utf8'));
+  } catch {
+    return; // no app.json
+  }
+
+  if (!appJson.children) return;
+
+  const ref = `@${metaPath}`;
+  let changed = false;
+
+  for (const [key, arr] of Object.entries(appJson.children)) {
+    if (!Array.isArray(arr)) continue;
+    const filtered = arr.filter(entry => entry !== ref);
+    if (filtered.length !== arr.length) {
+      appJson.children[key] = filtered;
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    await writeFile(appJsonPath, JSON.stringify(appJson, null, 2) + '\n');
+  }
+}
+
+// ─── config.local.json (per-user, gitignored) ────────────────────────────
+
+function configLocalPath() {
+  return join(dboDir(), CONFIG_LOCAL_FILE);
+}
+
+/**
+ * Load config.local.json (per-user settings including plugin scopes).
+ * Returns empty structure if file doesn't exist.
+ */
+export async function loadLocalConfig() {
+  try {
+    const raw = await readFile(configLocalPath(), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return { plugins: {} };
+  }
+}
+
+/**
+ * Save config.local.json.
+ */
+export async function saveLocalConfig(data) {
+  await mkdir(dboDir(), { recursive: true });
+  await writeFile(configLocalPath(), JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Get the stored scope for a plugin by name (without extension).
+ * @param {string} pluginName - Plugin name without extension
+ * @param {string} [category='claudecommands'] - Plugin category
+ * @returns {Promise<'project' | 'global' | null>}
+ */
+export async function getPluginScope(pluginName, category = 'claudecommands') {
+  const config = await loadLocalConfig();
+  return config.plugins?.[category]?.[pluginName] || null;
+}
+
+/**
+ * Set the scope for a plugin by name.
+ * @param {string} pluginName - Plugin name without extension
+ * @param {'project' | 'global'} scope
+ * @param {string} [category='claudecommands'] - Plugin category
+ */
+export async function setPluginScope(pluginName, scope, category = 'claudecommands') {
+  const config = await loadLocalConfig();
+  if (!config.plugins) config.plugins = {};
+  if (!config.plugins[category]) config.plugins[category] = {};
+  config.plugins[category][pluginName] = scope;
+  await saveLocalConfig(config);
+}
+
+/**
+ * Get all stored plugin scopes for a category.
+ * Returns object mapping plugin names to their scope strings.
+ * @param {string} [category='claudecommands'] - Plugin category
+ */
+export async function getAllPluginScopes(category = 'claudecommands') {
+  const config = await loadLocalConfig();
+  return config.plugins?.[category] || {};
+}
+
+// ─── Gitignore ────────────────────────────────────────────────────────────
+
+/**
+ * Remove a specific pattern from .gitignore.
+ * Used when moving a plugin from project to global scope.
+ */
+export async function removeFromGitignore(pattern) {
+  const gitignorePath = join(process.cwd(), '.gitignore');
+  let content = '';
+  try {
+    content = await readFile(gitignorePath, 'utf8');
+  } catch {
+    return; // no .gitignore
+  }
+
+  if (!content.includes(pattern)) return;
+
+  const lines = content.split('\n');
+  const filtered = lines.filter(line => line.trim() !== pattern.trim());
+  await writeFile(gitignorePath, filtered.join('\n'));
+  log.dim(`  Removed ${pattern} from .gitignore`);
+}
+
 /**
  * Ensure patterns are in .gitignore. Creates .gitignore if it doesn't exist.
  */
@@ -267,3 +500,35 @@ export async function ensureGitignore(patterns) {
   await writeFile(gitignorePath, content + addition);
   for (const p of toAdd) log.dim(`  Added ${p} to .gitignore`);
 }
+
+// ─── Baseline (.app.json) ─────────────────────────────────────────────────
+
+function baselinePath() {
+  return join(process.cwd(), BASELINE_FILE);
+}
+
+/**
+ * Check if baseline file (.app.json) exists.
+ */
+export async function hasBaseline() {
+  return exists(baselinePath());
+}
+
+/**
+ * Load .app.json baseline file (tracks server state for delta detection).
+ */
+export async function loadAppJsonBaseline() {
+  try {
+    const raw = await readFile(baselinePath(), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save .app.json baseline file.
+ */
+export async function saveAppJsonBaseline(data) {
+  await writeFile(baselinePath(), JSON.stringify(data, null, 2) + '\n');
+}