buddy-workbench 0.1.86 → 0.1.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.86",
+  "version": "0.1.88",
   "private": false,
   "type": "module",
   "bin": {
@@ -24,6 +24,17 @@
     "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"
   },
   "devbuddyChangelog": [
+    {
+      "version": "0.1.87",
+      "name": "Mind maps and test case workflow",
+      "notes": [
+        "Added editable Mind maps list and detail routes with XMind, JSON, and Markdown import/export, plus one JSON data file per map.",
+        "Added a left-to-right canvas with centered map positioning, expanded pan space, stable zoom controls, canvas panning, and expand-all/collapse-all actions.",
+        "Added Jira issue settings with key or link import, summary lookup, key/summary search, clickable issue cards, node tagging and untagging, and tagged-state styling.",
+        "Added node workflow controls for tested status cascading, moving a node subtree with an Ant Design Cascader, and confirmation before deleting maps or ideas.",
+        "Refined Mind maps headers, inspector controls, node spacing, Jira presentation, and canvas layout to support test case planning more clearly."
+      ]
+    },
     {
       "version": "0.1.42",
       "name": "Jira Workspace and navigation improvements",

package/server/config.js

@@ -36,6 +36,8 @@ export const paths = {
   branchSync: join(userDataDir, 'branch-sync.json'),
   packageUpgrade: join(userDataDir, 'package-upgrade.json'),
   presentations: join(userDataDir, 'presentations.json'),
+  mindMaps: join(userDataDir, 'mind-maps'),
+  legacyMindMaps: join(userDataDir, 'mind-maps.json'),
   shutdownLog: join(userDataDir, 'shutdown.log'),
   clipboardDir: join(userDataDir, 'clipboard'),
   plugins: join(root, 'plugins'),

package/server/repositories/mind-maps.js

@@ -0,0 +1,87 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from 'node:fs';
+import { join } from 'node:path';
+import { paths } from '../config.js';
+
+const getMapFilename = (id) => `${encodeURIComponent(String(id))}.json`;
+
+function ensureMindMapsDir() {
+  mkdirSync(paths.mindMaps, { recursive: true });
+}
+
+function mapFiles() {
+  if (!existsSync(paths.mindMaps)) return [];
+
+  return readdirSync(paths.mindMaps, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function writeMindMapFile(map) {
+  if (!map?.id) return;
+  writeFileSync(
+    join(paths.mindMaps, getMapFilename(map.id)),
+    JSON.stringify(map, null, 2),
+    'utf8'
+  );
+}
+
+function migrateLegacyMindMaps() {
+  if (!existsSync(paths.legacyMindMaps)) return;
+
+  ensureMindMapsDir();
+  const existingFiles = mapFiles();
+
+  try {
+    const parsed = JSON.parse(readFileSync(paths.legacyMindMaps, 'utf8'));
+    if (!existingFiles.length && Array.isArray(parsed)) {
+      parsed.forEach(writeMindMapFile);
+    }
+  } catch {
+    // Remove an invalid legacy file so it cannot block the new storage format.
+  }
+
+  unlinkSync(paths.legacyMindMaps);
+}
+
+export function listMindMaps() {
+  try {
+    migrateLegacyMindMaps();
+    return mapFiles().flatMap((filename) => {
+      try {
+        const parsed = JSON.parse(readFileSync(join(paths.mindMaps, filename), 'utf8'));
+        return parsed && typeof parsed === 'object' ? [parsed] : [];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+export function saveMindMaps(mindMaps) {
+  migrateLegacyMindMaps();
+  ensureMindMapsDir();
+
+  const expectedFiles = new Set();
+  for (const map of Array.isArray(mindMaps) ? mindMaps : []) {
+    if (!map?.id) continue;
+    const filename = getMapFilename(map.id);
+    expectedFiles.add(filename);
+    writeMindMapFile(map);
+  }
+
+  for (const filename of mapFiles()) {
+    if (!expectedFiles.has(filename)) {
+      unlinkSync(join(paths.mindMaps, filename));
+    }
+  }
+}

package/server/routes/mind-maps.js

@@ -0,0 +1,158 @@
+import crypto from 'node:crypto';
+import https from 'node:https';
+import axios from 'axios';
+import { Router } from 'express';
+import { readSettings } from '../repositories/settings.js';
+import { listMindMaps, saveMindMaps } from '../repositories/mind-maps.js';
+
+const router = Router();
+const httpClient = axios.create({
+  httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+  validateStatus: () => true,
+  timeout: 15000
+});
+
+const makeId = () => crypto.randomUUID();
+
+function getJiraHost(domain) {
+  const clean = String(domain || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+  if (!clean) return '';
+  return clean.includes('jira') || clean.includes('.atlassian.net') ? clean : `jira.${clean}`;
+}
+
+function extractJiraKey(value) {
+  const match = String(value || '').match(/(?:\/browse\/|\b)([A-Z][A-Z0-9_]*-\d+)\b/i);
+  return match?.[1]?.toUpperCase() || '';
+}
+
+async function resolveJiraIssue(value) {
+  const input = String(value || '').trim();
+  const key = extractJiraKey(input);
+  if (!key) throw new Error('Enter a valid Jira No or Jira issue link.');
+
+  const settings = readSettings();
+  const host = getJiraHost(settings.domain);
+  if (!host) throw new Error('Jira domain is not configured. Please set Domain in Settings.');
+
+  const headers = { Accept: 'application/json' };
+  if (settings.jiraAccessToken) {
+    headers.Authorization = settings.jiraAccessToken.startsWith('Bearer ')
+      ? settings.jiraAccessToken
+      : `Bearer ${settings.jiraAccessToken}`;
+  }
+  const response = await httpClient.get(
+    `https://${host}/rest/api/2/issue/${encodeURIComponent(key)}?fields=summary`,
+    { headers }
+  );
+  if (response.status < 200 || response.status >= 300) {
+    const detail = response.data?.errorMessages?.[0] || response.data?.message || response.statusText;
+    throw new Error(detail || `Jira returned status ${response.status}.`);
+  }
+
+  const summary = String(response.data?.fields?.summary || '').trim();
+  if (!summary) throw new Error(`Jira issue ${key} has no summary.`);
+  return {
+    id: String(response.data?.id || key),
+    key: String(response.data?.key || key).toUpperCase(),
+    summary,
+    url: /^https?:\/\//i.test(input) ? input : `https://${host}/browse/${encodeURIComponent(key)}`
+  };
+}
+
+function normalizeNode(node, fallbackText = 'Untitled idea') {
+  const text = String(node?.text ?? node?.label ?? fallbackText).trim() || fallbackText;
+  const x = Number(node?.position?.x);
+  const y = Number(node?.position?.y);
+  return {
+    id: String(node?.id || makeId()),
+    text,
+    ...(typeof node?.color === 'string' && node.color.trim() ? { color: node.color.trim() } : {}),
+    collapsed: Boolean(node?.collapsed),
+    tested: Boolean(node?.tested),
+    ...(typeof node?.notes === 'string' && node.notes ? { notes: node.notes } : {}),
+    ...(Array.isArray(node?.jiraKeys)
+      ? { jiraKeys: [...new Set(node.jiraKeys.map((key) => String(key).trim().toUpperCase()).filter(Boolean))] }
+      : {}),
+    ...(Number.isFinite(x) && Number.isFinite(y) ? { position: { x, y } } : {}),
+    children: Array.isArray(node?.children)
+      ? node.children.map((child) => normalizeNode(child))
+      : []
+  };
+}
+
+function normalizeMindMap(input, { id = makeId(), createdAt = new Date().toISOString() } = {}) {
+  const rootInput = input?.root || input?.data?.root;
+  if (!rootInput || typeof rootInput !== 'object') return null;
+  const title = String(input?.title || rootInput.text || 'Untitled mind map').trim() || 'Untitled mind map';
+  const root = normalizeNode(rootInput, title);
+  return {
+    id: String(id),
+    title,
+    layout: 'left-to-right',
+    createdAt,
+    updatedAt: new Date().toISOString(),
+    jiraIssues: Array.isArray(input?.jiraIssues)
+      ? input.jiraIssues
+        .map((issue) => ({
+          id: String(issue?.id || issue?.key || '').trim(),
+          key: String(issue?.key || '').trim().toUpperCase(),
+          summary: String(issue?.summary || '').trim(),
+          url: typeof issue?.url === 'string' ? issue.url.trim() : ''
+        }))
+        .filter((issue) => issue.id && issue.key)
+      : [],
+    root: { ...root, text: root.text || title }
+  };
+}
+
+router.get('/', (_req, res) => {
+  res.json(listMindMaps());
+});
+
+router.get('/:id', (req, res) => {
+  const mindMap = listMindMaps().find((item) => String(item.id) === String(req.params.id));
+  if (!mindMap) return res.status(404).json({ error: 'Mind map not found.' });
+  res.json(mindMap);
+});
+
+router.post('/jira-issues/resolve', async (req, res) => {
+  try {
+    res.json(await resolveJiraIssue(req.body?.input));
+  } catch (error) {
+    res.status(400).json({ error: error.message || 'Unable to load Jira issue summary.' });
+  }
+});
+
+router.post('/', (req, res) => {
+  const mindMap = normalizeMindMap(req.body);
+  if (!mindMap) return res.status(400).json({ error: 'A root node is required.' });
+  const mindMaps = listMindMaps();
+  mindMaps.unshift(mindMap);
+  saveMindMaps(mindMaps);
+  res.status(201).json(mindMap);
+});
+
+router.put('/:id', (req, res) => {
+  const mindMaps = listMindMaps();
+  const index = mindMaps.findIndex((item) => String(item.id) === String(req.params.id));
+  if (index < 0) return res.status(404).json({ error: 'Mind map not found.' });
+
+  const updated = normalizeMindMap(req.body, {
+    id: mindMaps[index].id,
+    createdAt: mindMaps[index].createdAt || new Date().toISOString()
+  });
+  if (!updated) return res.status(400).json({ error: 'A root node is required.' });
+  mindMaps[index] = updated;
+  saveMindMaps(mindMaps);
+  res.json(updated);
+});
+
+router.delete('/:id', (req, res) => {
+  const mindMaps = listMindMaps();
+  const next = mindMaps.filter((item) => String(item.id) !== String(req.params.id));
+  if (next.length === mindMaps.length) return res.status(404).json({ error: 'Mind map not found.' });
+  saveMindMaps(next);
+  res.status(204).end();
+});
+
+export default router;

package/server/routes/updates.js

@@ -139,13 +139,17 @@ async function readNpmPackageMetadata() {
 
 async function checkForUpdates() {
   const metadata = await readNpmPackageMetadata();
-  const latestVersion = String(metadata.version).replace(/^v/i, '');
+  const releases = buildReleaseList(metadata);
+  // A release is only visible after the 48-hour safety window. Keep the
+  // summary and the release list on the same source of truth so an update
+  // can never target a newer, still-hidden npm release.
+  const latestVersion = releases[0]?.version || CURRENT_VERSION;
   return {
     currentVersion: CURRENT_VERSION,
     latestVersion,
     updateAvailable: compareVersions(latestVersion, CURRENT_VERSION) > 0,
     checkedAt: new Date().toISOString(),
-    releases: buildReleaseList(metadata),
+    releases,
     sourceUnavailable: false
   };
 }
@@ -215,7 +219,18 @@ router.post('/self-update', async (req, res) => {
 
   selfUpdateRunning = true;
   try {
-    const version = normalizeUpdateVersion(req.body?.version);
+    let version = normalizeUpdateVersion(req.body?.version);
+    if (version === 'latest') {
+      const status = cachedResult && !cachedResult.sourceUnavailable && Date.now() - cachedAt < CACHE_TTL_MS
+        ? cachedResult
+        : await checkForUpdates();
+      version = status.latestVersion;
+    }
+
+    if (compareVersions(version, CURRENT_VERSION) <= 0) {
+      return res.json({ success: true, message: `DevBuddy is already up to date (${CURRENT_VERSION}).` });
+    }
+
     if (process.platform === 'win32') {
       scheduleWindowsSelfUpdate(`${PACKAGE_NAME}@${version}`);
       cachedResult = null;

package/server/services/clipboard-history.js

@@ -6,6 +6,7 @@ import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import encodeMozjpeg, { init as initMozjpeg } from '@jsquash/jpeg/encode.js';
 import { paths } from '../config.js';
+import { addErrorRecord } from '../repositories/errors.js';
 import { readSettings } from '../repositories/settings.js';
 import { readWindowsClipboard } from './windows.js';
 
@@ -15,6 +16,22 @@ let lastValue = '';
 let lastImageHash = '';
 let suppressImageCaptureUntil = 0;
 let mozjpegWasmModule = null;
+const clipboardErrorLogTimes = new Map();
+
+function logClipboardError(stage, error) {
+  // Clipboard polling runs continuously. Avoid filling Error Log with the
+  // same native-tool failure every two seconds while retaining diagnostics.
+  const now = Date.now();
+  const lastLoggedAt = clipboardErrorLogTimes.get(stage) || 0;
+  if (now - lastLoggedAt < 60 * 1000) return;
+  clipboardErrorLogTimes.set(stage, now);
+  const details = String(error?.stderr || error?.stdout || error?.stack || error?.message || error || '').trim();
+  addErrorRecord({
+    source: 'Clipboard Monitor',
+    message: `Failed during ${stage}.`,
+    details: details || 'The native clipboard operation returned an unknown error.'
+  });
+}
 
 async function compressMozjpeg(rgbaBuf, width, height, quality = 75) {
   if (!mozjpegWasmModule) {
@@ -72,7 +89,8 @@ async function getMacClipboardImageData() {
     const base64 = str.slice(secondColon + 1);
     if (!width || !height || !base64) return null;
     return { width, height, rgbaBuf: Buffer.from(base64, 'base64') };
-  } catch {
+  } catch (error) {
+    logClipboardError('macOS image clipboard read (osascript)', error);
     return null;
   }
 }
@@ -95,7 +113,8 @@ if let data = pb.data(forType: .png) {
   try {
     const { stdout } = await execFileAsync('swift', ['-e', swiftCode], { encoding: 'buffer', timeout: 3000 });
     if (stdout && stdout.length > 0) return stdout;
-  } catch {
+  } catch (error) {
+    logClipboardError('macOS image clipboard read (Swift)', error);
     try {
       const jsaScript = `
         ObjC.import("AppKit");
@@ -118,7 +137,9 @@ if let data = pb.data(forType: .png) {
       const { stdout } = await execFileAsync('osascript', ['-l', 'JavaScript', '-e', jsaScript], { timeout: 3000 });
       const str = stdout.trim();
       if (str) return Buffer.from(str, 'base64');
-    } catch {}
+    } catch (fallbackError) {
+      logClipboardError('macOS image clipboard fallback read (osascript)', fallbackError);
+    }
   }
   return null;
 }
@@ -330,9 +351,16 @@ export async function captureClipboard() {
             try {
               const mozjpegBuf = await compressMozjpeg(imageData.rgbaBuf, imageData.width, imageData.height, 75);
               saveClipboardImage(mozjpegBuf, 'jpg', hash);
-            } catch {
+            } catch (error) {
+              logClipboardError('image compression or save (WASM/JPEG)', error);
               const rawBuf = await getMacClipboardImageBuffer();
-              if (rawBuf) saveClipboardImage(rawBuf, 'png', hash);
+              if (rawBuf) {
+                try {
+                  saveClipboardImage(rawBuf, 'png', hash);
+                } catch (fallbackError) {
+                  logClipboardError('raw image save after compression fallback', fallbackError);
+                }
+              }
             }
           }
         }
@@ -357,7 +385,11 @@ export async function captureClipboard() {
 
             lastImageHash = hash;
             if (!isDuplicate) {
-              saveClipboardImage(imageBuffer, 'png', hash);
+              try {
+                saveClipboardImage(imageBuffer, 'png', hash);
+              } catch (error) {
+                logClipboardError('image save', error);
+              }
             }
           }
         }

package/server.js

@@ -26,6 +26,7 @@ import branchSyncRoutes from './server/routes/branch-sync.js';
 import updateRoutes from './server/routes/updates.js';
 import dataBackupRoutes from './server/routes/data-backup.js';
 import presentationsRoutes from './server/routes/presentations.js';
+import mindMapsRoutes from './server/routes/mind-maps.js';
 import packageUpgradeRoutes from './server/routes/package-upgrade.js';
 import overviewRoutes from './server/routes/overview.js';
 import { addErrorRecord } from './server/repositories/errors.js';
@@ -103,6 +104,7 @@ app.use('/api/branch-sync', branchSyncRoutes);
 app.use('/api/updates', updateRoutes);
 app.use('/api/data-backup', dataBackupRoutes);
 app.use('/api/presentations', presentationsRoutes);
+app.use('/api/mind-maps', mindMapsRoutes);
 app.use('/api/package-upgrade', packageUpgradeRoutes);
 app.use('/api/overview', overviewRoutes);