datagrok-tools 6.1.12 → 6.1.14

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Datagrok-tools changelog
 
+## 6.1.14 (2026-05-01)
+
+* Reports: `grok report comment` now converts Markdown body to JIRA wiki markup before POSTing, fixing rendered headings/list/HTML-entity mismatches in JIRA UI.
+
+## 6.1.13 (2026-04-30)
+
+* Reports: `grok report ticket` now uses direct JIRA REST honoring `$JIRA_PROJECT`, replacing the Datlas-mediated path that hardcoded GROK.
+
 ## 6.1.11 (2026-04-27)
 
 * `grok report read <path | instance number>` — normalize a report zip/json into one JSON object on stdout (envelope unwrap, `_meta.json` merge, optional `--extract-screenshot` / `--extract-d42` / `--extract-actions`)

package/bin/__tests__/jira-wiki-converter.test.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _report = require("../commands/report");
+(0, _vitest.describe)('markdownToJiraWiki — basic rules', () => {
+  (0, _vitest.it)('converts H1', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('# Title')).toBe('h1. Title');
+  });
+  (0, _vitest.it)('converts H2 / H3 / H6', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('## Sub')).toBe('h2. Sub');
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('### Sub-sub')).toBe('h3. Sub-sub');
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('###### Deep')).toBe('h6. Deep');
+  });
+  (0, _vitest.it)('converts bold', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('hello **world** foo')).toBe('hello *world* foo');
+  });
+  (0, _vitest.it)('converts italic with single asterisks', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('hello *world* foo')).toBe('hello _world_ foo');
+  });
+  (0, _vitest.it)('converts strikethrough', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('~~gone~~')).toBe('-gone-');
+  });
+  (0, _vitest.it)('converts links', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('see [docs](https://x.example/y)')).toBe('see [docs|https://x.example/y]');
+  });
+  (0, _vitest.it)('converts blockquote', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('> quoted line')).toBe('bq. quoted line');
+  });
+  (0, _vitest.it)('converts unordered list', () => {
+    const md = '- one\n- two\n- three';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('* one\n* two\n* three');
+  });
+  (0, _vitest.it)('converts one level of nested unordered list', () => {
+    const md = '- top\n  - sub\n- back';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('* top\n** sub\n* back');
+  });
+  (0, _vitest.it)('converts ordered list', () => {
+    const md = '1. one\n2. two\n3. three';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('# one\n# two\n# three');
+  });
+  (0, _vitest.it)('converts inline code', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('use `foo()` here')).toBe('use {{foo()}} here');
+  });
+  (0, _vitest.it)('converts plain code fence to noformat', () => {
+    const md = '```\nraw code\nmore\n```';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('{noformat}\nraw code\nmore\n{noformat}');
+  });
+  (0, _vitest.it)('converts code fence with language tag to {code:lang}', () => {
+    const md = '```js\nconst x = 1;\n```';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('{code:js}\nconst x = 1;\n{code}');
+  });
+  (0, _vitest.it)('converts HTML entities   / & / < / >', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('a b')).toBe('a b');
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('a&b')).toBe('a&b');
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('a&lt;b&gt;c')).toBe('a<b>c');
+  });
+});
+(0, _vitest.describe)('markdownToJiraWiki — content-protection inside code fences', () => {
+  (0, _vitest.it)('does not transform `{{plates}}` inside a fenced block (run-#4 false-positive case)', () => {
+    const md = ['Before', '```', 'context: {{plates}} should stay literal', '# not a heading', '- not a list', '```', 'After'].join('\n');
+    const out = (0, _report.markdownToJiraWiki)(md);
+    (0, _vitest.expect)(out).toContain('{noformat}\ncontext: {{plates}} should stay literal');
+    (0, _vitest.expect)(out).toContain('# not a heading');
+    (0, _vitest.expect)(out).toContain('- not a list');
+    (0, _vitest.expect)(out).not.toContain('h1.');
+  });
+  (0, _vitest.it)('does not transform headings/links/lists inside an inline code span', () => {
+    const md = 'use `# not a heading` and `[ref](u)` here';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('use {{# not a heading}} and {{[ref](u)}} here');
+  });
+});
+(0, _vitest.describe)('markdownToJiraWiki — edge cases', () => {
+  (0, _vitest.it)('handles bold containing italic: **bold *inside* bold**', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('**bold *inside* bold**')).toBe('*bold _inside_ bold*');
+  });
+  (0, _vitest.it)('preserves bold and italic on the same line', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('**a** and *b*')).toBe('*a* and _b_');
+  });
+  (0, _vitest.it)('handles a heading whose text contains backticks', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('## use `foo()` for x')).toBe('h2. use {{foo()}} for x');
+  });
+  (0, _vitest.it)('passes plain text through unchanged', () => {
+    const plain = 'Just a normal sentence with no markdown.';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(plain)).toBe(plain);
+  });
+  (0, _vitest.it)('returns empty string unchanged', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('')).toBe('');
+  });
+  (0, _vitest.it)('handles a multi-block document end-to-end', () => {
+    const md = ['# Handoff', '', 'Some **bold** intro and a [link](https://x.example).', '', '## Findings', '', '- first', '- second', '', '> note: this matters', '', '```js', 'const x = 1;', '```', '', 'Done&nbsp;here.'].join('\n');
+    const out = (0, _report.markdownToJiraWiki)(md);
+    (0, _vitest.expect)(out).toContain('h1. Handoff');
+    (0, _vitest.expect)(out).toContain('h2. Findings');
+    (0, _vitest.expect)(out).toContain('Some *bold* intro and a [link|https://x.example].');
+    (0, _vitest.expect)(out).toContain('* first\n* second');
+    (0, _vitest.expect)(out).toContain('bq. note: this matters');
+    (0, _vitest.expect)(out).toContain('{code:js}\nconst x = 1;\n{code}');
+    (0, _vitest.expect)(out).toContain('Done here.');
+    (0, _vitest.expect)(out).not.toContain('&nbsp;');
+  });
+});

package/bin/__tests__/jira-wiki-converter.test.ts

@@ -0,0 +1,150 @@
+import {describe, it, expect} from 'vitest';
+import {markdownToJiraWiki} from '../commands/report';
+
+describe('markdownToJiraWiki — basic rules', () => {
+  it('converts H1', () => {
+    expect(markdownToJiraWiki('# Title')).toBe('h1. Title');
+  });
+
+  it('converts H2 / H3 / H6', () => {
+    expect(markdownToJiraWiki('## Sub')).toBe('h2. Sub');
+    expect(markdownToJiraWiki('### Sub-sub')).toBe('h3. Sub-sub');
+    expect(markdownToJiraWiki('###### Deep')).toBe('h6. Deep');
+  });
+
+  it('converts bold', () => {
+    expect(markdownToJiraWiki('hello **world** foo')).toBe('hello *world* foo');
+  });
+
+  it('converts italic with single asterisks', () => {
+    expect(markdownToJiraWiki('hello *world* foo')).toBe('hello _world_ foo');
+  });
+
+  it('converts strikethrough', () => {
+    expect(markdownToJiraWiki('~~gone~~')).toBe('-gone-');
+  });
+
+  it('converts links', () => {
+    expect(markdownToJiraWiki('see [docs](https://x.example/y)'))
+      .toBe('see [docs|https://x.example/y]');
+  });
+
+  it('converts blockquote', () => {
+    expect(markdownToJiraWiki('> quoted line')).toBe('bq. quoted line');
+  });
+
+  it('converts unordered list', () => {
+    const md = '- one\n- two\n- three';
+    expect(markdownToJiraWiki(md)).toBe('* one\n* two\n* three');
+  });
+
+  it('converts one level of nested unordered list', () => {
+    const md = '- top\n  - sub\n- back';
+    expect(markdownToJiraWiki(md)).toBe('* top\n** sub\n* back');
+  });
+
+  it('converts ordered list', () => {
+    const md = '1. one\n2. two\n3. three';
+    expect(markdownToJiraWiki(md)).toBe('# one\n# two\n# three');
+  });
+
+  it('converts inline code', () => {
+    expect(markdownToJiraWiki('use `foo()` here')).toBe('use {{foo()}} here');
+  });
+
+  it('converts plain code fence to noformat', () => {
+    const md = '```\nraw code\nmore\n```';
+    expect(markdownToJiraWiki(md)).toBe('{noformat}\nraw code\nmore\n{noformat}');
+  });
+
+  it('converts code fence with language tag to {code:lang}', () => {
+    const md = '```js\nconst x = 1;\n```';
+    expect(markdownToJiraWiki(md)).toBe('{code:js}\nconst x = 1;\n{code}');
+  });
+
+  it('converts HTML entities   / & / < / >', () => {
+    expect(markdownToJiraWiki('a b')).toBe('a b');
+    expect(markdownToJiraWiki('a&b')).toBe('a&b');
+    expect(markdownToJiraWiki('a&lt;b&gt;c')).toBe('a<b>c');
+  });
+});
+
+describe('markdownToJiraWiki — content-protection inside code fences', () => {
+  it('does not transform `{{plates}}` inside a fenced block (run-#4 false-positive case)', () => {
+    const md = [
+      'Before',
+      '```',
+      'context: {{plates}} should stay literal',
+      '# not a heading',
+      '- not a list',
+      '```',
+      'After',
+    ].join('\n');
+    const out = markdownToJiraWiki(md);
+    expect(out).toContain('{noformat}\ncontext: {{plates}} should stay literal');
+    expect(out).toContain('# not a heading');
+    expect(out).toContain('- not a list');
+    expect(out).not.toContain('h1.');
+  });
+
+  it('does not transform headings/links/lists inside an inline code span', () => {
+    const md = 'use `# not a heading` and `[ref](u)` here';
+    expect(markdownToJiraWiki(md))
+      .toBe('use {{# not a heading}} and {{[ref](u)}} here');
+  });
+});
+
+describe('markdownToJiraWiki — edge cases', () => {
+  it('handles bold containing italic: **bold *inside* bold**', () => {
+    expect(markdownToJiraWiki('**bold *inside* bold**'))
+      .toBe('*bold _inside_ bold*');
+  });
+
+  it('preserves bold and italic on the same line', () => {
+    expect(markdownToJiraWiki('**a** and *b*')).toBe('*a* and _b_');
+  });
+
+  it('handles a heading whose text contains backticks', () => {
+    expect(markdownToJiraWiki('## use `foo()` for x'))
+      .toBe('h2. use {{foo()}} for x');
+  });
+
+  it('passes plain text through unchanged', () => {
+    const plain = 'Just a normal sentence with no markdown.';
+    expect(markdownToJiraWiki(plain)).toBe(plain);
+  });
+
+  it('returns empty string unchanged', () => {
+    expect(markdownToJiraWiki('')).toBe('');
+  });
+
+  it('handles a multi-block document end-to-end', () => {
+    const md = [
+      '# Handoff',
+      '',
+      'Some **bold** intro and a [link](https://x.example).',
+      '',
+      '## Findings',
+      '',
+      '- first',
+      '- second',
+      '',
+      '> note: this matters',
+      '',
+      '```js',
+      'const x = 1;',
+      '```',
+      '',
+      'Done&nbsp;here.',
+    ].join('\n');
+    const out = markdownToJiraWiki(md);
+    expect(out).toContain('h1. Handoff');
+    expect(out).toContain('h2. Findings');
+    expect(out).toContain('Some *bold* intro and a [link|https://x.example].');
+    expect(out).toContain('* first\n* second');
+    expect(out).toContain('bq. note: this matters');
+    expect(out).toContain('{code:js}\nconst x = 1;\n{code}');
+    expect(out).toContain('Done here.');
+    expect(out).not.toContain('&nbsp;');
+  });
+});

package/bin/commands/report.js

@@ -4,6 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.markdownToJiraWiki = markdownToJiraWiki;
 exports.report = report;
 var _fs = _interopRequireDefault(require("fs"));
 var _os = _interopRequireDefault(require("os"));
@@ -342,46 +343,79 @@ async function handleTicket(args) {
   const instance = args._[2];
   const reportId = args._[3];
   if (!instance || !reportId) {
-    color.error('Usage: grok report ticket <instance> <report-id>');
+    color.error('Usage: grok report ticket <instance> <report-id> [--project <KEY>] [--type <Bug>] [--jira-url <url>]');
     return false;
   }
+  const projectKey = args['project'] || process.env.JIRA_PROJECT || '';
+  if (!projectKey) {
+    color.error('--project or $JIRA_PROJECT is required (no GROK default)');
+    return false;
+  }
+  const issueType = args['type'] || 'Bug';
+  const auth = jiraAuthHeader();
+  if (auth == null) {
+    color.error('JIRA_USER and JIRA_TOKEN env vars are required for `grok report ticket`.');
+    return false;
+  }
+  const jiraBase = resolveJiraBase(args);
   try {
     const {
       url,
       key
     } = (0, _testUtils.getDevKey)(instance);
     const token = await (0, _testUtils.getToken)(url, key);
-    console.log('Getting current user...');
-    const userResp = await fetch(`${url}/users/current`, {
+    console.log(`Fetching report ${reportId}...`);
+    const reportResp = await fetch(`${url}/reports/${encodeURIComponent(reportId)}`, {
       headers: {
         Authorization: token
       }
     });
-    if (!userResp.ok) {
-      color.error(`Failed to get current user (HTTP ${userResp.status})`);
-      return false;
-    }
-    const user = await userResp.json();
-    const userId = user.id || user.Id;
-    if (!userId) {
-      color.error('No user id in response');
+    if (!reportResp.ok) {
+      const body = await reportResp.text();
+      color.error(`Failed to fetch report (HTTP ${reportResp.status}): ${body.slice(0, 400)}`);
       return false;
     }
-    console.log(`Creating JIRA ticket for report ${reportId}...`);
-    const ticketResp = await fetch(`${url}/reports/${reportId}/jira?assigneeId=${userId}`, {
+    const body = await reportResp.json();
+    // The REST endpoint returns a flat UserReport: top-level `#type`,
+    // `number`, `errorMessage`, etc. The `data` field is a ref to the
+    // related data-table entity, not a body wrapper — do not unwrap.
+    const number = body && (body.number != null ? body.number : body.Number);
+    const errorMessage = (body && (body.errorMessage || body.ErrorMessage) || '').toString().trim();
+    let summary = number != null ? errorMessage ? `Report #${number}: ${errorMessage}` : `Report #${number}` : errorMessage || `Report ${reportId}`;
+    if (summary.length > 200) summary = summary.slice(0, 200);
+    // JIRA rejects newlines in summary.
+    summary = summary.replace(/[\r\n]+/g, ' ').trim();
+    const webRoot = url.replace(/\/api\/?$/, '');
+    const reportLink = number != null ? `${webRoot}/apps/usage/reports/${number}` : `${webRoot}/apps/usage/reports/`;
+    const description = `Auto-created from ${reportLink}`;
+    console.log(`Creating JIRA ticket in ${projectKey} (${issueType})...`);
+    const createResp = await fetch(`${jiraBase}/rest/api/2/issue/`, {
       method: 'POST',
       headers: {
-        Authorization: token,
-        'Content-Type': 'application/json'
-      }
+        Authorization: auth,
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      body: JSON.stringify({
+        fields: {
+          project: {
+            key: projectKey
+          },
+          summary,
+          issuetype: {
+            name: issueType
+          },
+          description
+        }
+      })
     });
-    if (ticketResp.status !== 200 && ticketResp.status !== 201) {
-      const body = await ticketResp.text();
-      color.error(`JIRA ticket creation failed (HTTP ${ticketResp.status}): ${body}`);
+    if (createResp.status !== 200 && createResp.status !== 201) {
+      const errBody = await createResp.text();
+      color.error(`JIRA issue creation failed (HTTP ${createResp.status}): ${errBody}`);
       return false;
     }
-    const result = await ticketResp.json();
-    const ticketKey = result.key;
+    const result = await createResp.json();
+    const ticketKey = result && result.key;
     if (!ticketKey) {
       color.error(`No ticket key in response: ${JSON.stringify(result).slice(0, 200)}`);
       return false;
@@ -403,8 +437,10 @@ async function handleTicket(args) {
 // the Datagrok org instance; override via --jira-url or $JIRA_URL.
 //
 // Why v2 and not v3: v3 requires comment bodies in ADF (Atlassian Document
-// Format) JSON; v2 accepts plain text / wiki-markup. The handoff prompt emits
-// markdown, which JIRA's plain-text path renders acceptably.
+// Format) JSON, which is much heavier to construct. v2 accepts a plain string
+// body, which JIRA renders as wiki markup — NOT Markdown. So a `# heading`
+// becomes a top-level ordered-list item, `&nbsp;` shows up literally, etc.
+// `markdownToJiraWiki` below bridges the gap for Markdown-emitting callers.
 
 function resolveJiraBase(args) {
   const cli = args['jira-url'] || '';
@@ -417,6 +453,76 @@ function jiraAuthHeader() {
   if (!user || !token) return null;
   return 'Basic ' + Buffer.from(`${user}:${token}`).toString('base64');
 }
+
+// Convert a Markdown string to JIRA wiki markup so that REST v2 renders it the
+// way the author intended. Handles the common cases that diverge between the
+// two dialects; for anything not listed, the input is passed through unchanged.
+//
+// Deferred for v1 (left as-is, may render imperfectly):
+//   - tables (Markdown and JIRA wiki use very similar pipe syntax)
+//   - nested lists deeper than two levels
+//   - footnotes, definition lists, raw HTML
+function markdownToJiraWiki(md) {
+  if (!md) return md;
+
+  // 1. Code fences first: extract their content into placeholders so that
+  //    later rules cannot rewrite anything inside `{noformat}` / `{code}`.
+  const placeholders = [];
+  const protect = s => {
+    placeholders.push(s);
+    return `\x00P${placeholders.length - 1}\x00`;
+  };
+  let out = md;
+  out = out.replace(/```([A-Za-z0-9_+\-]*)\r?\n([\s\S]*?)```/g, (_m, lang, code) => {
+    const wiki = lang ? `{code:${lang}}\n${code}{code}` : `{noformat}\n${code}{noformat}`;
+    return protect(wiki);
+  });
+
+  // 2. Inline code spans (after fences, before anything else).
+  out = out.replace(/`([^`\n]+)`/g, (_m, code) => protect(`{{${code}}}`));
+
+  // 3. Headings — h6 → h1 so that the `###` prefix doesn't get matched as `##`.
+  //    Must run before list rules (where `#` would otherwise be ambiguous).
+  out = out.replace(/^###### (.+)$/gm, 'h6. $1');
+  out = out.replace(/^##### (.+)$/gm, 'h5. $1');
+  out = out.replace(/^#### (.+)$/gm, 'h4. $1');
+  out = out.replace(/^### (.+)$/gm, 'h3. $1');
+  out = out.replace(/^## (.+)$/gm, 'h2. $1');
+  out = out.replace(/^# (.+)$/gm, 'h1. $1');
+
+  // 4. Bold then italic. We stash bold runs behind a sentinel first so that
+  //    the inner italic pass can't mistake the leftover single `*` markers for
+  //    italic (and vice-versa for `**bold *italic* bold**`).
+  out = out.replace(/\*\*([\s\S]+?)\*\*/g, '\x01$1\x01');
+  out = out.replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, '_$1_');
+  out = out.replace(/\x01/g, '*');
+
+  // 5. Strikethrough.
+  out = out.replace(/~~([^~\n]+)~~/g, '-$1-');
+
+  // 6. Links: [text](url) → [text|url].
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '[$1|$2]');
+
+  // 7. Blockquote.
+  out = out.replace(/^> (.+)$/gm, 'bq. $1');
+
+  // 8. Unordered lists (one level of nesting). Two-space indent → second level.
+  out = out.replace(/^  - /gm, '** ');
+  out = out.replace(/^- /gm, '* ');
+
+  // 9. Ordered lists. After the heading pass so we don't clobber `# Title`.
+  out = out.replace(/^\d+\. /gm, '# ');
+
+  // 10. HTML entities that JIRA wiki shows literally.
+  out = out.replace(/&nbsp;/g, ' ');
+  out = out.replace(/&amp;/g, '&');
+  out = out.replace(/&lt;/g, '<');
+  out = out.replace(/&gt;/g, '>');
+
+  // Restore protected fences / inline code last.
+  out = out.replace(/\x00P(\d+)\x00/g, (_m, idx) => placeholders[Number(idx)]);
+  return out;
+}
 async function handleComment(args) {
   const ticket = args._[2];
   if (!ticket) {
@@ -449,6 +555,10 @@ async function handleComment(args) {
   }
   const base = resolveJiraBase(args);
   const url = `${base}/rest/api/2/issue/${encodeURIComponent(ticket)}/comment`;
+  // Callers (especially the dg-fix-reports M2 handoff) emit Markdown, but JIRA
+  // REST v2 renders the body as wiki markup. Convert before posting so headings,
+  // lists, and HTML entities don't render as garbage in the JIRA UI.
+  const wikiBody = markdownToJiraWiki(body);
   try {
     const resp = await fetch(url, {
       method: 'POST',
@@ -458,7 +568,7 @@ async function handleComment(args) {
         Accept: 'application/json'
       },
       body: JSON.stringify({
-        body
+        body: wikiBody
       })
     });
     if (resp.status !== 200 && resp.status !== 201) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "6.1.12",
+  "version": "6.1.14",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {
@@ -14,13 +14,12 @@
     "archiver-promise": "^1.0.0",
     "datagrok-api": "^1.26.0",
     "estraverse": "^5.3.0",
-    "glob": "^11.0.2",
+    "glob": "^13.0.6",
     "ignore-walk": "^3.0.4",
     "inquirer": "^7.3.3",
     "js-yaml": "^4.1.0",
     "minimist": "^1.2.8",
     "node-fetch": "^2.7.0",
-    "node-recursive-directory": "^1.2.0",
     "os": "^0.1.2",
     "papaparse": "^5.4.1",
     "path": "^0.12.7",