@dboio/cli 0.4.2 → 0.5.1

package/src/lib/config.js

@@ -4,8 +4,10 @@ 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';
 
 function dboDir() {
   return join(process.cwd(), DBO_DIR);
@@ -23,6 +25,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 +218,36 @@ 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 user profile fields (FirstName, LastName, Email) into credentials.json.
  */
@@ -244,6 +280,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.
  */