buddy-workbench 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "private": false,
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "version": "node -e \"const v=process.env.npm_package_version; const fs=require('fs'); ['ui/package.json', 'ui/package-lock.json'].forEach(p=>{if(fs.existsSync(p)){const j=JSON.parse(fs.readFileSync(p)); j.version=v; if(j.packages&&j.packages['']){j.packages[''].version=v;} fs.writeFileSync(p, JSON.stringify(j,null,2)+'\\n');}});\" && git add ui/package.json ui/package-lock.json"
   },
   "dependencies": {
+    "@jsquash/jpeg": "^1.6.0",
     "axios": "^1.7.9",
     "express": "^5.1.0"
   }

package/server/config.js

@@ -12,6 +12,7 @@ export const paths = {
   staticPages: join(root, 'data', 'static-pages.json'),
   errors: join(root, 'data', 'errors.json'),
   postman: join(root, 'data', 'postman.json'),
+  branchSync: join(root, 'data', 'branch-sync.json'),
   shutdownLog: join(root, 'data', 'shutdown.log'),
   clipboardDir: join(root, 'data', 'clipboard'),
   plugins: join(root, 'plugins'),

package/server/repositories/branch-sync.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { paths } from '../config.js';
+
+export function listBranchSyncApps() {
+  try {
+    return existsSync(paths.branchSync) ? JSON.parse(readFileSync(paths.branchSync, 'utf8')) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveBranchSyncApps(apps) {
+  mkdirSync(dirname(paths.branchSync), { recursive: true });
+  writeFileSync(paths.branchSync, JSON.stringify(apps, null, 2));
+}
+
+export function createBranchSyncApp(data) {
+  const apps = listBranchSyncApps();
+  const newApp = {
+    id: `app-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    name: data.name || '',
+    repo: data.repo || '',
+    activeBranch: data.activeBranch || '',
+    lastReleaseBranch: data.lastReleaseBranch || '',
+    subApps: Array.isArray(data.subApps) ? data.subApps : [],
+    createdAt: new Date().toISOString()
+  };
+  apps.push(newApp);
+  saveBranchSyncApps(apps);
+  return newApp;
+}
+
+export function updateBranchSyncApp(id, data) {
+  const apps = listBranchSyncApps();
+  const index = apps.findIndex((a) => a.id === id);
+  if (index === -1) return null;
+  apps[index] = {
+    ...apps[index],
+    name: data.name !== undefined ? data.name : apps[index].name,
+    repo: data.repo !== undefined ? data.repo : apps[index].repo,
+    activeBranch: data.activeBranch !== undefined ? data.activeBranch : apps[index].activeBranch,
+    lastReleaseBranch: data.lastReleaseBranch !== undefined ? data.lastReleaseBranch : apps[index].lastReleaseBranch,
+    subApps: Array.isArray(data.subApps) ? data.subApps : apps[index].subApps,
+    updatedAt: new Date().toISOString()
+  };
+  saveBranchSyncApps(apps);
+  return apps[index];
+}
+
+export function removeBranchSyncApp(id) {
+  const apps = listBranchSyncApps();
+  const filtered = apps.filter((a) => a.id !== id);
+  saveBranchSyncApps(filtered);
+  return true;
+}

package/server/routes/branch-sync.js

@@ -0,0 +1,464 @@
+import https from 'node:https';
+import axios from 'axios';
+import { Router } from 'express';
+import { readSettings } from '../repositories/settings.js';
+import {
+  createBranchSyncApp,
+  listBranchSyncApps,
+  removeBranchSyncApp,
+  updateBranchSyncApp
+} from '../repositories/branch-sync.js';
+
+const router = Router();
+
+const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+const httpClient = axios.create({
+  httpsAgent,
+  validateStatus: () => true
+});
+
+function parseRepo(repoStr) {
+  if (!repoStr || typeof repoStr !== 'string') return null;
+  const settings = readSettings();
+  let raw = repoStr.trim().replace(/\.git$/i, '');
+
+  let protocol = 'https';
+  if (raw.startsWith('http://')) {
+    protocol = 'http';
+  }
+
+  let host = '';
+  let projectKey = '';
+  let repositorySlug = '';
+
+  // 1. Handle HTTP / HTTPS / SSH URLs
+  if (raw.startsWith('http://') || raw.startsWith('https://') || raw.startsWith('ssh://')) {
+    try {
+      let urlStr = raw;
+      if (urlStr.startsWith('ssh://')) {
+        urlStr = urlStr.replace(/^ssh:\/\//i, 'https://');
+      }
+      // Strip basic auth (e.g. http://username@host/...)
+      urlStr = urlStr.replace(/^(https?:\/\/)(([^/@]+)@)/i, '$1');
+
+      const urlObj = new URL(urlStr);
+      host = urlObj.host; // Includes hostname and port
+      let pathname = urlObj.pathname.replace(/^\/+/, '');
+
+      // Case A: /projects/PROJ/repos/REPO or /users/USER/repos/REPO
+      const webMatch = pathname.match(/^(?:projects\/([^/]+)|users\/([^/]+))\/repos\/([^/]+)/i);
+      if (webMatch) {
+        projectKey = webMatch[1] ? webMatch[1] : `~${webMatch[2]}`;
+        repositorySlug = webMatch[3];
+        return { protocol, host, projectKey, repositorySlug };
+      }
+
+      // Case B: /scm/PROJ/REPO or /scm/~USER/REPO
+      const scmMatch = pathname.match(/^scm\/([^/]+)\/([^/]+)/i);
+      if (scmMatch) {
+        projectKey = scmMatch[1];
+        repositorySlug = scmMatch[2];
+        return { protocol, host, projectKey, repositorySlug };
+      }
+
+      // Case C: /PROJ/REPO
+      const parts = pathname.split('/').filter(Boolean);
+      if (parts.length >= 2) {
+        projectKey = parts[parts.length - 2];
+        repositorySlug = parts[parts.length - 1];
+        return { protocol, host, projectKey, repositorySlug };
+      }
+    } catch {}
+  }
+
+  // 2. SSH / SCP pattern: bitbucket@host/PROJECT/REPO or git@host:PROJECT/REPO
+  const scpMatch = raw.match(/^(?:[a-zA-Z0-9_.-]+@)?([^:/]+)[:/](.+)$/);
+  if (scpMatch) {
+    host = scpMatch[1];
+    let path = scpMatch[2].replace(/^\/+/, '').replace(/^scm\//i, '');
+    const pathParts = path.split('/').filter(Boolean);
+    if (pathParts.length >= 2) {
+      projectKey = pathParts[pathParts.length - 2];
+      repositorySlug = pathParts[pathParts.length - 1];
+      return { protocol, host, projectKey, repositorySlug };
+    }
+  }
+
+  // 3. Fallback: PROJ/REPO
+  const parts = raw.split('/').filter(Boolean);
+  if (parts.length === 2) {
+    projectKey = parts[0];
+    repositorySlug = parts[1];
+    const domain = settings.domain || '';
+    host = domain ? (domain.includes('bitbucket') ? domain : `bitbucket.${domain}`) : '';
+    return { protocol, host, projectKey, repositorySlug };
+  }
+
+  return null;
+}
+
+// Check branch merge status & existing PR for a single repo and branch pair
+async function checkBranchPair(parsedRepo, sourceBranch, targetBranch, headers) {
+  if (!sourceBranch || !targetBranch) {
+    return { error: 'Source and target branches must be specified.' };
+  }
+  const { protocol = 'https', host, projectKey, repositorySlug } = parsedRepo;
+  if (!host) {
+    return { error: 'Could not determine Bitbucket host for repository.' };
+  }
+
+  const result = {
+    sourceBranch,
+    targetBranch,
+    merged: false,
+    unmergedCommitCount: 0,
+    openPr: null,
+    error: null
+  };
+
+  try {
+    // 1. Check commits in sourceBranch not in targetBranch
+    const commitsUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/commits?until=${encodeURIComponent(targetBranch)}&since=${encodeURIComponent(sourceBranch)}&limit=1`;
+    const commitsRes = await httpClient.get(commitsUrl, { headers });
+
+    if (commitsRes.status === 401) {
+      result.error = 'Unauthorized. Please check your Bitbucket Access Token in Settings.';
+      return result;
+    }
+
+    if (commitsRes.status < 200 || commitsRes.status >= 300) {
+      const errDetail = commitsRes.data?.errors?.[0]?.message || commitsRes.data?.message || commitsRes.statusText;
+      result.error = `Failed to check commits (${commitsRes.status}): ${errDetail}`;
+      return result;
+    }
+
+    const commits = commitsRes.data?.values || [];
+    if (commits.length === 0) {
+      result.merged = true;
+      result.unmergedCommitCount = 0;
+    } else {
+      result.merged = false;
+      result.unmergedCommitCount = commitsRes.data?.size || commits.length;
+
+      // 2. Check if an open PR already exists
+      try {
+        const prUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests?at=refs/heads/${encodeURIComponent(sourceBranch)}&direction=OUTGOING&state=OPEN`;
+        const prRes = await httpClient.get(prUrl, { headers });
+        if (prRes.status >= 200 && prRes.status < 300) {
+          const prs = prRes.data?.values || [];
+          const existingPr = prs.find((pr) => {
+            const toId = pr.toRef?.id || '';
+            const toDisplay = pr.toRef?.displayId || '';
+            return toId === `refs/heads/${targetBranch}` || toDisplay === targetBranch;
+          });
+          if (existingPr) {
+            result.openPr = {
+              id: existingPr.id,
+              title: existingPr.title,
+              url: existingPr.links?.self?.[0]?.href || `${protocol}://${host}/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${existingPr.id}`
+            };
+          }
+        }
+      } catch {}
+    }
+  } catch (err) {
+    result.error = err.message || 'Network error checking branch status.';
+  }
+
+  return result;
+}
+
+// App CRUD Routes
+router.get('/apps', (_req, res) => {
+  res.json(listBranchSyncApps());
+});
+
+// Fetch Remote Branches List for a Repository from Bitbucket
+router.get('/branches', async (req, res) => {
+  const repoStr = req.query.repo;
+  if (!repoStr) {
+    return res.status(400).json({ error: 'Repository URL parameter "repo" is required.', branches: [] });
+  }
+
+  const parsed = parseRepo(String(repoStr));
+  if (!parsed) {
+    return res.status(400).json({ error: `Invalid repository URL format: ${repoStr}`, branches: [] });
+  }
+
+  const settings = readSettings();
+  const token = settings.bitbucketAccessToken;
+  const headers = { Accept: 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  const { protocol = 'https', host, projectKey, repositorySlug } = parsed;
+  if (!host) {
+    return res.status(400).json({ error: 'Could not determine Bitbucket host for repository.', branches: [] });
+  }
+
+  try {
+    const branchesUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/branches?limit=200`;
+    const response = await httpClient.get(branchesUrl, { headers });
+
+    if (response.status >= 200 && response.status < 300) {
+      const values = response.data?.values || [];
+      const branchNames = values
+        .map((b) => b.displayId || b.id?.replace(/^refs\/heads\//, ''))
+        .filter(Boolean);
+      return res.json({ branches: branchNames });
+    }
+
+    const errDetail = response.data?.errors?.[0]?.message || response.data?.message || response.statusText;
+    return res.status(response.status).json({ error: `Bitbucket error: ${errDetail}`, branches: [] });
+  } catch (err) {
+    return res.status(500).json({ error: err.message || 'Failed to fetch remote branches.', branches: [] });
+  }
+});
+
+router.post('/apps', (req, res) => {
+  const { name, repo, activeBranch, lastReleaseBranch, subApps } = req.body || {};
+  if (!name || !repo) {
+    return res.status(400).json({ error: 'App name and repository URL are required.' });
+  }
+  const app = createBranchSyncApp({ name, repo, activeBranch, lastReleaseBranch, subApps });
+  res.status(201).json(app);
+});
+
+router.put('/apps/:id', (req, res) => {
+  const updated = updateBranchSyncApp(req.params.id, req.body || {});
+  if (!updated) {
+    return res.status(404).json({ error: 'App not found.' });
+  }
+  res.json(updated);
+});
+
+router.delete('/apps/:id', (req, res) => {
+  removeBranchSyncApp(req.params.id);
+  res.status(204).end();
+});
+
+// Check Branch Sync Status for an App (and all its nested subApps)
+router.post('/check', async (req, res) => {
+  const { app } = req.body || {};
+  if (!app || !app.repo) {
+    return res.status(400).json({ error: 'Valid App configuration is required.' });
+  }
+
+  const settings = readSettings();
+  const token = settings.bitbucketAccessToken;
+  const headers = { Accept: 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  const activeBranch = app.activeBranch || 'active';
+  const lastReleaseBranch = app.lastReleaseBranch || 'release';
+  const targetMasterBranch = 'master';
+
+  // 1. Check parent app
+  const parentParsed = parseRepo(app.repo);
+  let parentCheck = null;
+  if (!parentParsed) {
+    parentCheck = {
+      error: `Invalid repository URL format: ${app.repo}`
+    };
+  } else {
+    const releaseToMaster = await checkBranchPair(parentParsed, lastReleaseBranch, targetMasterBranch, headers);
+    const masterToActive = await checkBranchPair(parentParsed, targetMasterBranch, activeBranch, headers);
+    parentCheck = {
+      releaseToMaster,
+      masterToActive
+    };
+  }
+
+  // 2. Check sub-apps (using sub.branch if configured, otherwise parent's activeBranch)
+  const subAppResults = [];
+  for (const sub of app.subApps || []) {
+    const subParsed = parseRepo(sub.repo);
+    const subActiveBranch = (sub.branch && typeof sub.branch === 'string' && sub.branch.trim()) ? sub.branch.trim() : activeBranch;
+
+    if (!subParsed) {
+      subAppResults.push({
+        name: sub.name,
+        repo: sub.repo,
+        activeBranch: subActiveBranch,
+        error: `Invalid sub-app repository URL format: ${sub.repo}`
+      });
+    } else {
+      const releaseToMaster = await checkBranchPair(subParsed, lastReleaseBranch, targetMasterBranch, headers);
+      const masterToActive = await checkBranchPair(subParsed, targetMasterBranch, subActiveBranch, headers);
+      subAppResults.push({
+        name: sub.name,
+        repo: sub.repo,
+        activeBranch: subActiveBranch,
+        releaseToMaster,
+        masterToActive
+      });
+    }
+  }
+
+  res.json({
+    appId: app.id,
+    appName: app.name,
+    parentCheck,
+    subAppResults,
+    checkedAt: new Date().toISOString()
+  });
+});
+
+// Create Pull Request
+router.post('/create-pr', async (req, res) => {
+  const { repo, sourceBranch, targetBranch, title } = req.body || {};
+  if (!repo || !sourceBranch || !targetBranch) {
+    return res.status(400).json({ error: 'Repository, sourceBranch, and targetBranch are required.' });
+  }
+
+  const parsed = parseRepo(repo);
+  if (!parsed) {
+    return res.status(400).json({ error: `Invalid repository URL format: ${repo}` });
+  }
+
+  const settings = readSettings();
+  const token = settings.bitbucketAccessToken;
+  if (!token) {
+    return res.status(400).json({ error: 'Bitbucket Access Token is not configured. Please set your token in Settings.' });
+  }
+
+  const { protocol = 'https', host, projectKey, repositorySlug } = parsed;
+  const headers = {
+    Accept: 'application/json',
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${token}`
+  };
+
+  const prPayload = {
+    title: title || `Merge ${sourceBranch} to ${targetBranch}`,
+    description: `Automated Pull Request created via DevBuddy Branch Sync Status Check.\n\nMerging \`${sourceBranch}\` into \`${targetBranch}\`.`,
+    fromRef: {
+      id: `refs/heads/${sourceBranch}`,
+      repository: {
+        slug: repositorySlug,
+        project: { key: projectKey }
+      }
+    },
+    toRef: {
+      id: `refs/heads/${targetBranch}`,
+      repository: {
+        slug: repositorySlug,
+        project: { key: projectKey }
+      }
+    }
+  };
+
+  try {
+    const prUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests`;
+    const prRes = await httpClient.post(prUrl, prPayload, { headers });
+
+    if (prRes.status >= 200 && prRes.status < 300) {
+      const data = prRes.data;
+      const webUrl = data?.links?.self?.[0]?.href || `${protocol}://${host}/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${data?.id}`;
+      return res.json({
+        success: true,
+        prId: data?.id,
+        prUrl: webUrl,
+        title: data?.title
+      });
+    }
+
+    // Handle error response from Bitbucket
+    const errMessage =
+      prRes.data?.errors?.[0]?.message ||
+      prRes.data?.message ||
+      `Bitbucket returned status ${prRes.status}: ${prRes.statusText || 'Failed to create PR'}`;
+
+    return res.status(400).json({ error: errMessage });
+  } catch (err) {
+    return res.status(500).json({ error: err.message || 'Failed to create pull request.' });
+  }
+});
+
+// Helper to create a single branch on Bitbucket
+async function createBranchForRepo(repoStr, sourceBranch, targetBranch, headers) {
+  const parsed = parseRepo(repoStr);
+  if (!parsed) {
+    return { success: false, error: `Invalid repository URL format: ${repoStr}` };
+  }
+  const { protocol = 'https', host, projectKey, repositorySlug } = parsed;
+  if (!host) {
+    return { success: false, error: 'Could not determine Bitbucket host for repository.' };
+  }
+
+  const startPoint = sourceBranch.startsWith('refs/') ? sourceBranch : `refs/heads/${sourceBranch}`;
+  const branchUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/branches`;
+  const payload = {
+    name: targetBranch,
+    startPoint
+  };
+
+  try {
+    const res = await httpClient.post(branchUrl, payload, { headers });
+    if (res.status >= 200 && res.status < 300) {
+      return { success: true, branch: targetBranch, id: res.data?.id };
+    }
+    const errDetail = res.data?.errors?.[0]?.message || res.data?.message || `Bitbucket returned status ${res.status}: ${res.statusText}`;
+    return { success: false, error: errDetail };
+  } catch (err) {
+    return { success: false, error: err.message || 'Network error creating branch.' };
+  }
+}
+
+// Create Branch endpoint
+router.post('/create-branch', async (req, res) => {
+  const { app, repo, sourceBranch, targetBranch } = req.body || {};
+  if (!sourceBranch || !targetBranch) {
+    return res.status(400).json({ error: 'Source branch and target branch are required.' });
+  }
+
+  const settings = readSettings();
+  const token = settings.bitbucketAccessToken;
+  if (!token) {
+    return res.status(400).json({ error: 'Bitbucket Access Token is not configured. Please set your token in Settings.' });
+  }
+
+  const headers = {
+    Accept: 'application/json',
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${token}`
+  };
+
+  if (app && app.repo) {
+    const results = [];
+    // 1. Parent App
+    const parentRes = await createBranchForRepo(app.repo, sourceBranch, targetBranch, headers);
+    results.push({
+      name: app.name,
+      repo: app.repo,
+      isParent: true,
+      ...parentRes
+    });
+
+    // 2. Sub Apps
+    for (const sub of app.subApps || []) {
+      const subSourceBranch = (sourceBranch === app.activeBranch && sub.branch && typeof sub.branch === 'string' && sub.branch.trim())
+        ? sub.branch.trim()
+        : sourceBranch;
+      const subRes = await createBranchForRepo(sub.repo, subSourceBranch, targetBranch, headers);
+      results.push({
+        name: sub.name,
+        repo: sub.repo,
+        isParent: false,
+        sourceBranch: subSourceBranch,
+        ...subRes
+      });
+    }
+
+    return res.json({ results });
+  } else if (repo) {
+    const singleRes = await createBranchForRepo(repo, sourceBranch, targetBranch, headers);
+    if (!singleRes.success) {
+      return res.status(400).json({ error: singleRes.error });
+    }
+    return res.json(singleRes);
+  }
+
+  return res.status(400).json({ error: 'Repository or App object is required.' });
+});
+
+export default router;

package/server/routes/file-organizer.js

@@ -29,7 +29,7 @@ router.post('/scan', async (req, res, next) => {
 // POST /api/file-organizer/execute
 router.post('/execute', async (req, res, next) => {
   try {
-    const { sourcePath, targetPath, files, operation = 'move' } = req.body;
+    const { sourcePath, targetPath, files, operation = 'move', deleteEmptyFolders = false } = req.body;
     if (!sourcePath || !targetPath) {
       return res.status(400).json({ error: '必须同时提供源文件夹和目标文件夹路径' });
     }
@@ -41,7 +41,8 @@ router.post('/execute', async (req, res, next) => {
       sourcePath,
       targetPath,
       files,
-      operation
+      operation,
+      deleteEmptyFolders: Boolean(deleteEmptyFolders)
     });
 
     res.json(session);

package/server/services/clipboard-history.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFile
 import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
-import encodeMozjpeg, { init as initMozjpeg } from '../../ui/node_modules/@jsquash/jpeg/encode.js';
+import encodeMozjpeg, { init as initMozjpeg } from '@jsquash/jpeg/encode.js';
 import { paths } from '../config.js';
 import { readSettings } from '../repositories/settings.js';
 
@@ -16,7 +16,7 @@ let mozjpegWasmModule = null;
 
 async function compressMozjpeg(rgbaBuf, width, height, quality = 75) {
   if (!mozjpegWasmModule) {
-    const wasmPath = fileURLToPath(import.meta.resolve('../../ui/node_modules/@jsquash/jpeg/codec/enc/mozjpeg_enc.wasm'));
+    const wasmPath = fileURLToPath(import.meta.resolve('../../ui/dist/assets/mozjpeg_enc-DO-zoExo.wasm'));
     mozjpegWasmModule = await WebAssembly.compile(readFileSync(wasmPath));
     await initMozjpeg(mozjpegWasmModule);
   }

package/server/services/file-organizer.js

@@ -291,11 +291,58 @@ function saveHistory(history) {
   }
 }
 
+async function cleanEmptyDirectories(dirPath, excludeTargetDir, deletedDirs = []) {
+  if (!dirPath || !fs.existsSync(dirPath)) return deletedDirs;
+
+  try {
+    const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const fullPath = path.join(dirPath, entry.name);
+
+        // Do NOT delete or traverse into the target directory!
+        if (excludeTargetDir && (fullPath === excludeTargetDir || fullPath.startsWith(excludeTargetDir + path.sep))) {
+          continue;
+        }
+
+        // Recursively clean child directories first
+        await cleanEmptyDirectories(fullPath, excludeTargetDir, deletedDirs);
+
+        // Check if current subdirectory is empty
+        try {
+          const subEntries = await fs.promises.readdir(fullPath);
+          const remaining = subEntries.filter(n => !['.DS_Store', '.git', '.localized', 'Thumbs.db'].includes(n));
+
+          if (remaining.length === 0) {
+            // Remove OS metadata files inside if any
+            for (const metaFile of subEntries) {
+              try {
+                await fs.promises.unlink(path.join(fullPath, metaFile));
+              } catch {}
+            }
+
+            await fs.promises.rmdir(fullPath);
+            deletedDirs.push(fullPath);
+          }
+        } catch (err) {
+          console.error(`Failed to clean empty directory ${fullPath}:`, err);
+        }
+      }
+    }
+  } catch (err) {
+    console.error(`Failed to read directory ${dirPath} for empty cleanup:`, err);
+  }
+
+  return deletedDirs;
+}
+
 export async function executeOrganize({
   sourcePath,
   targetPath,
   files,
-  operation = 'move'
+  operation = 'move',
+  deleteEmptyFolders = false
 }) {
   const resolvedSource = expandPath(sourcePath);
   const resolvedTarget = resolveTargetPath(targetPath, resolvedSource);
@@ -350,6 +397,11 @@ export async function executeOrganize({
     }
   }
 
+  let deletedDirs = [];
+  if (deleteEmptyFolders) {
+    deletedDirs = await cleanEmptyDirectories(resolvedSource, resolvedTarget);
+  }
+
   // Save history session
   const history = loadHistory();
   const session = {
@@ -358,6 +410,9 @@ export async function executeOrganize({
     sourcePath: resolvedSource,
     targetPath: resolvedTarget,
     operation,
+    deleteEmptyFolders: Boolean(deleteEmptyFolders),
+    deletedDirsCount: deletedDirs.length,
+    deletedDirs,
     totalFiles: files.length,
     successCount,
     failCount,
@@ -414,6 +469,17 @@ export async function undoSession(sessionId) {
     }
   }
 
+  // Re-create deleted empty directories if any
+  if (Array.isArray(session.deletedDirs)) {
+    for (const dir of session.deletedDirs) {
+      try {
+        await fs.promises.mkdir(dir, { recursive: true });
+      } catch (err) {
+        console.error(`Failed to recreate directory ${dir}:`, err);
+      }
+    }
+  }
+
   session.status = 'reverted';
   session.revertedAt = new Date().toISOString();
   session.revertSuccessCount = revertSuccessCount;