buddy-workbench 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "private": false,
   "type": "module",
   "bin": {

package/server/routes/file-organizer.js

@@ -0,0 +1,104 @@
+import express from 'express';
+import fs from 'node:fs';
+import path from 'node:path';
+import { expandPath, scanFolder, executeOrganize, getHistoryList, undoSession } from '../services/file-organizer.js';
+
+const router = express.Router();
+
+// POST /api/file-organizer/scan
+router.post('/scan', async (req, res, next) => {
+  try {
+    const { sourcePath, targetPath, includeSubfolders, skipOrganized } = req.body;
+    if (!sourcePath) {
+      return res.status(400).json({ error: '请指定需要整理的源文件夹路径' });
+    }
+
+    const result = await scanFolder({
+      sourcePath,
+      targetPath,
+      includeSubfolders: Boolean(includeSubfolders),
+      skipOrganized: skipOrganized !== false
+    });
+
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/file-organizer/execute
+router.post('/execute', async (req, res, next) => {
+  try {
+    const { sourcePath, targetPath, files, operation = 'move' } = req.body;
+    if (!sourcePath || !targetPath) {
+      return res.status(400).json({ error: '必须同时提供源文件夹和目标文件夹路径' });
+    }
+    if (!Array.isArray(files) || files.length === 0) {
+      return res.status(400).json({ error: '请勾选需要整理的文件' });
+    }
+
+    const session = await executeOrganize({
+      sourcePath,
+      targetPath,
+      files,
+      operation
+    });
+
+    res.json(session);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /api/file-organizer/history
+router.get('/history', (req, res) => {
+  try {
+    const list = getHistoryList();
+    res.json(list);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// POST /api/file-organizer/undo
+router.post('/undo', async (req, res, next) => {
+  try {
+    const { sessionId } = req.body;
+    if (!sessionId) {
+      return res.status(400).json({ error: '必须提供 sessionId' });
+    }
+
+    const session = await undoSession(sessionId);
+    res.json(session);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/file-organizer/browse
+router.post('/browse', async (req, res) => {
+  try {
+    const dirPath = expandPath(req.body.path || '~');
+    if (!fs.existsSync(dirPath)) {
+      return res.status(400).json({ error: '路径不存在' });
+    }
+
+    const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+    const subdirs = entries
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => ({
+        name: e.name,
+        fullPath: path.join(dirPath, e.name)
+      }));
+
+    res.json({
+      currentPath: dirPath,
+      parentPath: path.dirname(dirPath),
+      subdirectories: subdirs
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/routes/jira-filters.js

@@ -158,4 +158,76 @@ router.get('/:id/issues', async (req, res) => {
   }
 });
 
+// Clone an issue
+router.post('/issues/clone', async (req, res) => {
+  const { issueKey, summary } = req.body || {};
+  if (!summary || typeof summary !== 'string' || !summary.trim()) {
+    return res.status(400).json({ error: 'Summary is required for clone.' });
+  }
+
+  const jiraHost = getJiraHost();
+  if (!jiraHost) {
+    return res.status(400).json({ error: 'Jira domain is not configured. Please set Domain in Settings.' });
+  }
+
+  const settings = readSettings();
+  const token = settings.jiraAccessToken;
+  const headers = { 'Content-Type': 'application/json' };
+  if (token) {
+    headers.Authorization = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
+  }
+
+  try {
+    // Fetch current authenticated user's info from Jira
+    let assigneeField = null;
+    try {
+      const myselfUrl = `https://${jiraHost}/rest/api/2/myself`;
+      const myselfRes = await httpClient.get(myselfUrl, { headers });
+      if (myselfRes.status === 200 && myselfRes.data) {
+        if (myselfRes.data.accountId) {
+          assigneeField = { accountId: myselfRes.data.accountId };
+        } else if (myselfRes.data.name) {
+          assigneeField = { name: myselfRes.data.name };
+        }
+      }
+    } catch {
+      // Ignore if fetching current user fails
+    }
+
+    const projectKey = issueKey ? issueKey.split('-')[0] : '';
+    const url = `https://${jiraHost}/rest/api/2/issue`;
+    const payload = {
+      fields: {
+        summary: summary.trim(),
+        ...(projectKey ? { project: { key: projectKey } } : {}),
+        issuetype: { name: 'Task' },
+        ...(assigneeField ? { assignee: assigneeField } : {})
+      }
+    };
+
+    const response = await httpClient.post(url, payload, { headers });
+    if (response.status !== 201 && response.status !== 200) {
+      const errMsg = response.data?.errorMessages?.[0] || response.data?.message || `Jira API returned status ${response.status}`;
+      return res.status(response.status).json({ error: errMsg });
+    }
+
+    const created = response.data || {};
+    const createdKey = created.key || issueKey;
+
+    // Fallback: Assign explicitly if not assigned during creation
+    if (createdKey && assigneeField) {
+      try {
+        const assignUrl = `https://${jiraHost}/rest/api/2/issue/${createdKey}/assignee`;
+        await httpClient.put(assignUrl, assigneeField, { headers });
+      } catch {
+        // Ignore fallback assign error
+      }
+    }
+
+    res.status(201).json({ success: true, issue: { key: createdKey, id: created.id } });
+  } catch (error) {
+    res.status(500).json({ error: error.message || 'Failed to clone Jira issue.' });
+  }
+});
+
 export default router;

package/server/services/file-organizer.js

@@ -0,0 +1,426 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { paths } from '../config.js';
+
+const HISTORY_FILE = path.join(paths.launchers ? path.dirname(paths.launchers) : 'data', 'file-organizer-history.json');
+
+// Expand '~' to home directory
+export function expandPath(filePath) {
+  if (!filePath || typeof filePath !== 'string') return '';
+  const trimmed = filePath.trim();
+  if (trimmed === '~' || trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return path.join(os.homedir(), trimmed.slice(1));
+  }
+  return path.resolve(trimmed);
+}
+
+// Resolve target path: if relative, resolve against source directory
+export function resolveTargetPath(targetPath, sourcePath) {
+  if (!targetPath || typeof targetPath !== 'string') return '';
+  const trimmed = targetPath.trim();
+  if (!trimmed) return '';
+
+  let expanded = trimmed;
+  if (trimmed === '~' || trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    expanded = path.join(os.homedir(), trimmed.slice(1));
+  }
+
+  if (path.isAbsolute(expanded)) {
+    return path.normalize(expanded);
+  }
+
+  const resolvedSource = expandPath(sourcePath);
+  return path.resolve(resolvedSource, trimmed);
+}
+
+// Category definition maps
+const CATEGORY_CONFIG = {
+  screenshots: {
+    key: 'screenshots',
+    label: 'Screenshots',
+    subfolder: 'Screenshots',
+    extensions: ['png', 'jpg', 'jpeg', 'webp', 'gif'],
+    isMatch: (filename, ext) => {
+      if (!['png', 'jpg', 'jpeg', 'webp', 'gif'].includes(ext)) return false;
+      const lower = filename.toLowerCase();
+      const patterns = [
+        'screenshot', 'screen shot', '截图', '屏幕快照', '屏幕截图',
+        'cleanshot', 'snipaste', 'screen recording', '录屏', '截屏',
+        'shot_', 'scrn_'
+      ];
+      return patterns.some(p => lower.includes(p));
+    }
+  },
+  images: {
+    key: 'images',
+    label: 'Images',
+    subfolder: 'Images',
+    extensions: ['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'heic', 'heif', 'psd', 'ai', 'tiff', 'raw', 'tga'],
+    isMatch: () => true
+  },
+  videos: {
+    key: 'videos',
+    label: 'Videos',
+    subfolder: 'Videos',
+    extensions: ['mp4', 'mkv', 'mov', 'avi', 'wmv', 'flv', 'webm', 'm4v', '3gp', 'rmvb', 'ts', 'mpg', 'mpeg'],
+    isMatch: () => true
+  },
+  audio: {
+    key: 'audio',
+    label: 'Audio',
+    subfolder: 'Audio',
+    extensions: ['mp3', 'wav', 'flac', 'aac', 'm4a', 'ogg', 'wma', 'aiff', 'opus', 'mid', 'midi', 'amr'],
+    isMatch: () => true
+  },
+  documents: {
+    key: 'documents',
+    label: 'Documents',
+    subfolder: 'Documents',
+    extensions: ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt', 'md', 'pages', 'numbers', 'key', 'csv', 'epub', 'mobi', 'rtf', 'odt', 'ods', 'odp'],
+    isMatch: () => true
+  },
+  emails: {
+    key: 'emails',
+    label: 'Emails',
+    subfolder: 'Emails',
+    extensions: ['eml', 'msg', 'pst', 'mbox', 'emlx'],
+    isMatch: () => true
+  },
+  json: {
+    key: 'json',
+    label: 'JSON',
+    subfolder: 'JSON',
+    extensions: ['json', 'json5', 'jsonl', 'geojson'],
+    isMatch: () => true
+  },
+  code: {
+    key: 'code',
+    label: 'Code',
+    subfolder: 'Code',
+    extensions: [
+      'js', 'jsx', 'ts', 'tsx', 'py', 'java', 'c', 'cpp', 'cc', 'h', 'hpp',
+      'cs', 'go', 'rs', 'php', 'rb', 'html', 'htm', 'css', 'scss', 'less',
+      'sh', 'zsh', 'bash', 'sql', 'yaml', 'yml', 'xml', 'vue', 'svelte',
+      'swift', 'kt', 'kts', 'dart', 'lua', 'r', 'pl', 'm', 'mm', 'toml', 'ini', 'env'
+    ],
+    isMatch: () => true
+  },
+  archives: {
+    key: 'archives',
+    label: 'Archives',
+    subfolder: 'Archives',
+    extensions: ['zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz', 'tgz', 'z'],
+    isMatch: () => true
+  },
+  installers: {
+    key: 'installers',
+    label: 'Installers',
+    subfolder: 'Installers',
+    extensions: ['dmg', 'pkg', 'exe', 'msi', 'deb', 'rpm', 'apk', 'ipa', 'iso'],
+    isMatch: () => true
+  }
+};
+
+export function classifyFile(filename) {
+  const ext = path.extname(filename).slice(1).toLowerCase();
+
+  // First check screenshots specially
+  if (CATEGORY_CONFIG.screenshots.isMatch(filename, ext)) {
+    return {
+      key: CATEGORY_CONFIG.screenshots.key,
+      label: CATEGORY_CONFIG.screenshots.label,
+      subfolder: CATEGORY_CONFIG.screenshots.subfolder
+    };
+  }
+
+  // Check other categories by extension
+  for (const [key, cfg] of Object.entries(CATEGORY_CONFIG)) {
+    if (key === 'screenshots') continue;
+    if (cfg.extensions.includes(ext)) {
+      return {
+        key: cfg.key,
+        label: cfg.label,
+        subfolder: cfg.subfolder
+      };
+    }
+  }
+
+  return {
+    key: 'others',
+    label: 'Others',
+    subfolder: 'Others'
+  };
+}
+
+export async function scanFolder({
+  sourcePath,
+  targetPath = '',
+  includeSubfolders = false,
+  skipOrganized = true
+}) {
+  const resolvedSource = expandPath(sourcePath);
+  if (!resolvedSource || !fs.existsSync(resolvedSource)) {
+    throw new Error(`Source directory does not exist: ${sourcePath}`);
+  }
+
+  const stat = await fs.promises.stat(resolvedSource);
+  if (!stat.isDirectory()) {
+    throw new Error(`Input path is not a valid directory: ${sourcePath}`);
+  }
+
+  const resolvedTarget = targetPath ? resolveTargetPath(targetPath, resolvedSource) : '';
+  const fileItems = [];
+
+  async function walk(dirPath, relativeDir = '') {
+    const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const name = entry.name;
+      // Skip system hidden metadata
+      if (name === '.DS_Store' || name === '.git' || name === '.localized' || name === 'Thumbs.db') {
+        continue;
+      }
+
+      const fullPath = path.join(dirPath, name);
+      const relativePath = relativeDir ? path.join(relativeDir, name) : name;
+
+      if (entry.isDirectory()) {
+        // Skip rules for subdirectories
+        if (skipOrganized) {
+          const lowerName = name.toLowerCase();
+          if (lowerName.startsWith('organized') || lowerName.includes('_organized_')) {
+            continue;
+          }
+          if (resolvedTarget && fullPath.startsWith(resolvedTarget)) {
+            continue;
+          }
+        }
+
+        if (includeSubfolders) {
+          await walk(fullPath, relativePath);
+        }
+      } else if (entry.isFile()) {
+        const fileStat = await fs.promises.stat(fullPath);
+        const classification = classifyFile(name);
+
+        fileItems.push({
+          id: relativePath,
+          filename: name,
+          relativePath,
+          fullPath,
+          extension: path.extname(name).slice(1).toLowerCase(),
+          size: fileStat.size,
+          categoryKey: classification.key,
+          categoryLabel: classification.label,
+          subfolder: classification.subfolder,
+          selected: true
+        });
+      }
+    }
+  }
+
+  await walk(resolvedSource);
+
+  // Stats calculation
+  const stats = {
+    totalCount: fileItems.length,
+    totalSize: fileItems.reduce((acc, item) => acc + item.size, 0),
+    byCategory: {}
+  };
+
+  const categories = ['screenshots', 'images', 'videos', 'audio', 'documents', 'emails', 'json', 'code', 'archives', 'installers', 'others'];
+  for (const cat of categories) {
+    const items = fileItems.filter(f => f.categoryKey === cat);
+    const label = cat === 'others' ? 'Others' : CATEGORY_CONFIG[cat]?.label || cat;
+    const subfolder = cat === 'others' ? 'Others' : CATEGORY_CONFIG[cat]?.subfolder || cat;
+    stats.byCategory[cat] = {
+      key: cat,
+      label,
+      subfolder,
+      count: items.length,
+      size: items.reduce((acc, item) => acc + item.size, 0)
+    };
+  }
+
+  return {
+    sourcePath: resolvedSource,
+    files: fileItems,
+    stats
+  };
+}
+
+function getUniqueDestinationPath(targetDir, filename) {
+  let destPath = path.join(targetDir, filename);
+  if (!fs.existsSync(destPath)) {
+    return destPath;
+  }
+
+  const ext = path.extname(filename);
+  const baseName = path.basename(filename, ext);
+  let counter = 1;
+
+  while (fs.existsSync(destPath)) {
+    destPath = path.join(targetDir, `${baseName}_${counter}${ext}`);
+    counter++;
+  }
+  return destPath;
+}
+
+function loadHistory() {
+  try {
+    if (fs.existsSync(HISTORY_FILE)) {
+      const data = fs.readFileSync(HISTORY_FILE, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch (err) {
+    console.error('Failed to load history:', err);
+  }
+  return [];
+}
+
+function saveHistory(history) {
+  try {
+    const dir = path.dirname(HISTORY_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2), 'utf-8');
+  } catch (err) {
+    console.error('Failed to save history:', err);
+  }
+}
+
+export async function executeOrganize({
+  sourcePath,
+  targetPath,
+  files,
+  operation = 'move'
+}) {
+  const resolvedSource = expandPath(sourcePath);
+  const resolvedTarget = resolveTargetPath(targetPath, resolvedSource);
+
+  if (!resolvedSource || !fs.existsSync(resolvedSource)) {
+    throw new Error(`Source directory does not exist: ${sourcePath}`);
+  }
+  if (!resolvedTarget) {
+    throw new Error('Target directory not specified');
+  }
+
+  // Ensure target folder exists
+  await fs.promises.mkdir(resolvedTarget, { recursive: true });
+
+  const records = [];
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const item of files) {
+    try {
+      const categoryDir = path.join(resolvedTarget, item.subfolder || 'Others');
+      await fs.promises.mkdir(categoryDir, { recursive: true });
+
+      const destPath = getUniqueDestinationPath(categoryDir, item.filename);
+
+      if (operation === 'copy') {
+        await fs.promises.copyFile(item.fullPath, destPath);
+      } else {
+        await fs.promises.rename(item.fullPath, destPath);
+      }
+
+      records.push({
+        filename: item.filename,
+        originalPath: item.fullPath,
+        newPath: destPath,
+        categorySubfolder: item.subfolder,
+        operation,
+        status: 'success'
+      });
+      successCount++;
+    } catch (err) {
+      console.error(`Failed to ${operation} file ${item.fullPath}:`, err);
+      records.push({
+        filename: item.filename,
+        originalPath: item.fullPath,
+        categorySubfolder: item.subfolder,
+        operation,
+        status: 'failed',
+        error: err.message
+      });
+      failCount++;
+    }
+  }
+
+  // Save history session
+  const history = loadHistory();
+  const session = {
+    id: `organize_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+    timestamp: new Date().toISOString(),
+    sourcePath: resolvedSource,
+    targetPath: resolvedTarget,
+    operation,
+    totalFiles: files.length,
+    successCount,
+    failCount,
+    status: 'completed',
+    records
+  };
+
+  history.unshift(session);
+  if (history.length > 50) history.pop();
+  saveHistory(history);
+
+  return session;
+}
+
+export function getHistoryList() {
+  return loadHistory();
+}
+
+export async function undoSession(sessionId) {
+  const history = loadHistory();
+  const index = history.findIndex(s => s.id === sessionId);
+  if (index === -1) {
+    throw new Error('History session record not found');
+  }
+
+  const session = history[index];
+  if (session.status === 'reverted') {
+    throw new Error('This organization session has already been reverted.');
+  }
+
+  let revertSuccessCount = 0;
+  let revertFailCount = 0;
+
+  for (const record of session.records) {
+    if (record.status !== 'success' || !record.newPath) continue;
+
+    try {
+      if (session.operation === 'move') {
+        if (fs.existsSync(record.newPath)) {
+          const parentDir = path.dirname(record.originalPath);
+          await fs.promises.mkdir(parentDir, { recursive: true });
+          await fs.promises.rename(record.newPath, record.originalPath);
+          revertSuccessCount++;
+        }
+      } else if (session.operation === 'copy') {
+        if (fs.existsSync(record.newPath)) {
+          await fs.promises.unlink(record.newPath);
+          revertSuccessCount++;
+        }
+      }
+    } catch (err) {
+      console.error(`Failed to revert ${record.filename}:`, err);
+      revertFailCount++;
+    }
+  }
+
+  session.status = 'reverted';
+  session.revertedAt = new Date().toISOString();
+  session.revertSuccessCount = revertSuccessCount;
+  session.revertFailCount = revertFailCount;
+
+  history[index] = session;
+  saveHistory(history);
+
+  return session;
+}

package/server.js

@@ -19,6 +19,7 @@ import staticPagesRoutes from './server/routes/static-pages.js';
 import errorRoutes from './server/routes/errors.js';
 import postmanRoutes from './server/routes/postman.js';
 import bookmarkSyncRoutes from './server/routes/bookmark-sync.js';
+import fileOrganizerRoutes from './server/routes/file-organizer.js';
 import { addErrorRecord } from './server/repositories/errors.js';
 import { startClipboardCapture } from './server/services/clipboard-history.js';
 
@@ -73,6 +74,7 @@ app.use('/api/static-pages', staticPagesRoutes);
 app.use('/api/errors', errorRoutes);
 app.use('/api/postman', postmanRoutes);
 app.use('/api/bookmark-sync', bookmarkSyncRoutes);
+app.use('/api/file-organizer', fileOrganizerRoutes);
 
 app.use((err, req, res, _next) => {
   addErrorRecord({