buddy-workbench 0.1.86 → 0.1.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.86",
+  "version": "0.1.87",
   "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.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);