buddy-workbench 0.1.85 → 0.1.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.85",
+  "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/routes/pr-conflicts.js

@@ -39,6 +39,10 @@ function webPullRequestUrl(host, pr) {
   return `https://${host}/${projectPath}/repos/${repository}/pull-requests/${pr.id}`;
 }
 
+function pullRequestKey(project, repository, id) {
+  return `${project}/${repository}/${id}`;
+}
+
 async function git(folder, args, options = {}) {
   const result = await execFileAsync('git', args, {
     cwd: folder,
@@ -49,6 +53,31 @@ async function git(folder, args, options = {}) {
   return result.stdout;
 }
 
+async function detectConflictedPaths(folder, sourceRef, targetRef) {
+  try {
+    const output = await git(folder, [
+      'merge-tree',
+      '--write-tree',
+      '--name-only',
+      '-z',
+      '--no-messages',
+      targetRef,
+      sourceRef
+    ]);
+    return String(output)
+      .split('\0')
+      .map((path) => path.trim())
+      .filter((path) => path && !/^[0-9a-f]{40}$/i.test(path));
+  } catch (error) {
+    const output = String(error.stdout || '');
+    if (!output) throw error;
+    return output
+      .split('\0')
+      .map((path) => path.trim())
+      .filter((path) => path && !/^[0-9a-f]{40}$/i.test(path));
+  }
+}
+
 function remoteIdentity(remoteUrl) {
   const raw = String(remoteUrl || '').replace(/\.git$/i, '');
   let pathname = '';
@@ -226,6 +255,12 @@ export function UserProfile({ userId }: { userId: string }) {
           sourceContent: `{\n  "name": "enterprise-workbench",\n  "version": "2.4.0",\n  "endpoints": {\n    "auth": "https://auth.internal.company.com/oauth2/token",\n    "storage": "https://storage.internal.company.com/data"\n  }\n}`,
           targetContent: `{\n  "name": "enterprise-workbench",\n  "version": "2.3.1",\n  "endpoints": {\n    "auth": "https://auth-legacy.internal.company.com/token",\n    "storage": "https://storage.internal.company.com/data"\n  }\n}`,
           defaultChoice: 'target'
+        },
+        {
+          path: 'README.md',
+          sourceContent: '# Enterprise Workbench\n\nUpdated setup instructions for the new release.\n',
+          targetContent: '# Enterprise Workbench\n\nSetup instructions for the current release.\n',
+          conflicted: false
         }
       ]
     });
@@ -247,15 +282,26 @@ export function UserProfile({ userId }: { userId: string }) {
     const changes = changesResponse.data?.values || [];
     const sourceCommit = pr.fromRef?.latestCommit || pr.fromRef?.id;
     const targetCommit = pr.toRef?.latestCommit || pr.toRef?.id;
+    let conflictedPaths = null;
+    if (mergeResponse.data?.conflicted) {
+      try {
+        const folder = await findWorkspaceRepository(parsed);
+        await git(folder, ['fetch', 'origin', '--prune']);
+        const sourceRef = `origin/${pr.fromRef?.displayId}`;
+        const targetRef = `origin/${pr.toRef?.displayId}`;
+        conflictedPaths = new Set(await detectConflictedPaths(folder, sourceRef, targetRef));
+      } catch {}
+    }
     const files = await Promise.all(changes.map(async (change) => {
       const path = pathOf(change);
+      if (conflictedPaths && !conflictedPaths.has(path)) return null;
       const [sourceContent, targetContent] = await Promise.all([
         readFile({ ...parsed, commit: sourceCommit, path }),
         readFile({ ...parsed, commit: targetCommit, path })
       ]);
       return { path, sourceContent, targetContent, defaultChoice: 'source' };
     }));
-    res.json({ conflicted: Boolean(mergeResponse.data.conflicted), pr: { title: pr.title, sourceBranch: pr.fromRef?.displayId, targetBranch: pr.toRef?.displayId }, files: files.filter((file) => file.path) });
+    res.json({ conflicted: Boolean(mergeResponse.data.conflicted), pr: { title: pr.title, sourceBranch: pr.fromRef?.displayId, targetBranch: pr.toRef?.displayId }, files: files.filter((file) => file?.path).map((file) => ({ ...file, conflicted: conflictedPaths ? conflictedPaths.has(file.path) : true })) });
   } catch (error) {
     res.status(500).json({ error: `Unable to load conflict data: ${error.message}` });
   }
@@ -264,28 +310,54 @@ export function UserProfile({ userId }: { userId: string }) {
 router.get('/my-conflicts', async (_req, res) => {
   const host = configuredBitbucketHost();
   if (!host) return res.json({ values: [] });
-  const dashboardUrl = `https://${host}/rest/api/latest/dashboard/pull-requests?role=author&state=OPEN&limit=100`;
+  const dashboardUrl = `https://${host}/rest/api/latest/dashboard/pull-requests?role=author&state=ALL&limit=1000`;
   try {
     const response = await client.get(dashboardUrl, { headers: authHeaders() });
     if (response.status < 200 || response.status >= 300) return res.status(response.status).json({ error: `Unable to load authored Pull Requests (${response.status}).` });
     const values = Array.isArray(response.data?.values) ? response.data.values : [];
+    const resolutionPrs = new Map();
+    values.forEach((pr) => {
+      const project = pr.toRef?.repository?.project?.key;
+      const repository = pr.toRef?.repository?.slug;
+      const originalId = String(pr.description || '').match(/This branch resolves conflicts for Pull Request #(\d+)/i)?.[1];
+      if (project && repository && originalId && pr.id) {
+        resolutionPrs.set(pullRequestKey(project, repository, originalId), pr);
+      }
+    });
+
     const conflicts = await Promise.all(values.map(async (pr) => {
       const project = pr.toRef?.repository?.project?.key;
       const repository = pr.toRef?.repository?.slug;
       if (!project || !repository || !pr.id) return null;
-      const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
-      const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
-      if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
-      return {
+      if (String(pr.description || '').match(/This branch resolves conflicts for Pull Request #\d+/i)) return null;
+
+      const resolutionPr = resolutionPrs.get(pullRequestKey(project, repository, pr.id));
+      const baseConflict = {
         id: pr.id,
         title: pr.title || `Pull Request #${pr.id}`,
+        repositoryName: pr.toRef?.repository?.name || repository,
         sourceBranch: pr.fromRef?.displayId || pr.fromRef?.id,
         targetBranch: pr.toRef?.displayId || pr.toRef?.id,
         updatedDate: pr.updatedDate,
         url: webPullRequestUrl(host, pr)
       };
+      if (resolutionPr) {
+        return {
+          ...baseConflict,
+          resolutionPrUrl: webPullRequestUrl(host, resolutionPr),
+          resolutionPrId: resolutionPr.id
+        };
+      }
+
+      const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
+      const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
+      if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
+      return baseConflict;
     }));
-    res.json({ values: conflicts.filter(Boolean).sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0)) });
+    const sorted = conflicts.filter(Boolean).sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0));
+    const unresolved = sorted.filter((pr) => !pr.resolutionPrUrl);
+    const resolved = sorted.filter((pr) => pr.resolutionPrUrl);
+    res.json({ values: unresolved, unresolved, resolved });
   } catch (error) {
     res.status(500).json({ error: `Unable to load authored Pull Requests: ${error.message}` });
   }

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);