@waron97/prbot 3.5.0 → 3.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@waron97/prbot",
-    "version": "3.5.0",
+    "version": "3.6.0",
     "description": "",
     "main": "index.js",
     "engines": {

package/src/commands/autopr.js

@@ -7,6 +7,7 @@ import { resolveAddonsPath } from '../lib/addons.js';
 import { fuzzyMatch } from '../lib/fuzzy.js';
 import { execGit } from '../lib/git.js';
 import { log } from '../lib/logger.js';
+import { tridentRpc } from '../lib/trident.js';
 import {
     appendPrToLine,
     appendRefsToLine,
@@ -27,42 +28,11 @@ function devopsHeaders() {
 }
 
 async function fetchTask(taskId) {
-    const url = `${process.env.TRIDENT_URL}/jsonrpc`;
-    const body = {
-        jsonrpc: '2.0',
-        method: 'call',
-        id: 1,
-        params: {
-            service: 'object',
-            method: 'execute_kw',
-            args: [
-                process.env.TRIDENT_DB,
-                parseInt(process.env.TRIDENT_UID, 10),
-                process.env.TRIDENT_TOKEN,
-                'project.task',
-                'read',
-                [[parseInt(taskId, 10)]],
-                {
-                    fields: [
-                        'name',
-                        'x_subpackage_id',
-                        'x_workflow',
-                        'x_cluster_id',
-                        'x_release_checklist',
-                    ],
-                },
-            ],
-        },
-    };
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
+    const result = await tridentRpc('project.task', 'read', [[parseInt(taskId, 10)]], {
+        fields: ['name', 'x_subpackage_id', 'x_workflow', 'x_cluster_id', 'x_release_checklist'],
     });
-    const data = await res.json();
-    if (data.error) throw new Error(`Trident error: ${JSON.stringify(data.error)}`);
-    if (!data.result || !data.result[0]) throw new Error(`Task ${taskId} not found`);
-    return data.result[0];
+    if (!result || !result[0]) throw new Error(`Task ${taskId} not found`);
+    return result[0];
 }
 
 function buildPrDescription(taskIds, jiras) {
@@ -124,30 +94,10 @@ async function createDevopsPR(branch, title, description) {
 async function appendChecklistPrLink(taskId, currentChecklist, prUrl) {
     const link = `<a href="${prUrl}">${prUrl}</a><br/>`;
     const updated = currentChecklist ? `${currentChecklist}\n${link}` : link;
-    const url = `${process.env.TRIDENT_URL}/jsonrpc`;
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            jsonrpc: '2.0',
-            method: 'call',
-            id: 2,
-            params: {
-                service: 'object',
-                method: 'execute_kw',
-                args: [
-                    process.env.TRIDENT_DB,
-                    parseInt(process.env.TRIDENT_UID, 10),
-                    process.env.TRIDENT_TOKEN,
-                    'project.task',
-                    'write',
-                    [[parseInt(taskId, 10)], { x_release_checklist: updated }],
-                ],
-            },
-        }),
-    });
-    const data = await res.json();
-    if (data.error) throw new Error(`Trident write error: ${JSON.stringify(data.error)}`);
+    await tridentRpc('project.task', 'write', [
+        [parseInt(taskId, 10)],
+        { x_release_checklist: updated },
+    ]);
 }
 
 function scoreSections(sections, candidates) {

package/src/commands/doc.js

@@ -0,0 +1,93 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { htmlToMarkdown } from '../lib/html.js';
+import { log, warn } from '../lib/logger.js';
+import { tridentRpc } from '../lib/trident.js';
+
+async function fetchTaskDoc(taskId) {
+    const id = parseInt(taskId, 10);
+    const [task] = await tridentRpc('project.task', 'read', [[id]], {
+        fields: ['name', 'description'],
+    });
+    if (!task) throw new Error(`Task ${taskId} not found`);
+
+    const attachments = await tridentRpc(
+        'ir.attachment',
+        'search_read',
+        [
+            [
+                ['res_model', '=', 'project.task'],
+                ['res_id', '=', id],
+            ],
+        ],
+        { fields: ['name', 'datas', 'mimetype'] }
+    );
+
+    return { task, attachments };
+}
+
+// Strips path separators from an Odoo attachment name and de-dupes against
+// names already written into the same folder.
+function safeFilename(name, usedNames) {
+    const cleaned = (name || 'attachment').replace(/[/\\]/g, '_').trim() || 'attachment';
+    if (!usedNames.has(cleaned)) {
+        usedNames.add(cleaned);
+        return cleaned;
+    }
+    const ext = path.extname(cleaned);
+    const base = cleaned.slice(0, cleaned.length - ext.length);
+    let i = 2;
+    let candidate = `${base} (${i})${ext}`;
+    while (usedNames.has(candidate)) {
+        i += 1;
+        candidate = `${base} (${i})${ext}`;
+    }
+    usedNames.add(candidate);
+    return candidate;
+}
+
+async function writeTaskDoc(taskId, { task, attachments }) {
+    const dirName = `trident_${taskId}`;
+    const dir = path.join(process.cwd(), dirName);
+    await fs.mkdir(dir, { recursive: true });
+
+    const usedNames = new Set();
+    const writtenFiles = [];
+    for (const att of attachments) {
+        if (!att.datas) {
+            warn(`Warning: skipping attachment "${att.name}" (no downloadable content)`);
+            continue;
+        }
+        const filename = safeFilename(att.name, usedNames);
+        await fs.writeFile(path.join(dir, filename), Buffer.from(att.datas, 'base64'));
+        writtenFiles.push(filename);
+    }
+
+    const taskUrl = `${process.env.TRIDENT_URL}/odoo/my-tasks/${taskId}`;
+    const lines = [`# ${task.name}`, '', taskUrl, ''];
+    const body = htmlToMarkdown(task.description);
+    if (body) lines.push(body, '');
+
+    lines.push('## Attachments');
+    if (writtenFiles.length === 0) {
+        lines.push('', '_None_');
+    } else {
+        lines.push('', ...writtenFiles.map((f) => `- [${f}](./${f})`));
+    }
+
+    await fs.writeFile(path.join(dir, `${dirName}.md`), lines.join('\n') + '\n');
+    return dir;
+}
+
+async function doc(opts) {
+    const ids = opts.trident ?? [];
+    if (ids.length === 0) throw new Error('No Trident id: provide -t <id>');
+
+    for (const id of ids) {
+        const data = await fetchTaskDoc(id);
+        const dir = await writeTaskDoc(id, data);
+        log(`Wrote ${dir}`);
+    }
+}
+
+export { doc };

package/src/index.js

@@ -5,6 +5,7 @@ import { configDotenv } from 'dotenv';
 import { autopr } from './commands/autopr.js';
 import { changelog } from './commands/changelog.js';
 import { commit } from './commands/commit.js';
+import { doc } from './commands/doc.js';
 import {
     exportEmailTemplates,
     exportImperex,
@@ -143,6 +144,13 @@ program.command('commit').action(async (opts) => {
     await commit(opts);
 });
 
+program
+    .command('doc')
+    .option('-t, --trident <id>', 'Trident task IDs (repeatable)', collect)
+    .action(async (opts) => {
+        await doc(opts);
+    });
+
 const exportCmd = program.command('export');
 
 withQuiet(

package/src/lib/html.js

@@ -0,0 +1,117 @@
+// Small, dependency-free HTML→markdown converter. Not a general-purpose HTML
+// parser — it's sized to the markup Odoo actually produces for `project.task`
+// description fields (paragraphs, line breaks, bold/italic, links, lists,
+// inline images), which is enough to render usefully in a .md file. Anything
+// outside that (tables, nested lists, styled spans, ...) is stripped down to
+// its plain text rather than mis-rendered.
+
+function decodeEntities(str) {
+    return str
+        .replace(/ /gi, ' ')
+        .replace(/&/gi, '&')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&apos;/gi, "'");
+}
+
+function htmlToMarkdown(html) {
+    if (!html) return '';
+
+    let out = '';
+    let lastIndex = 0;
+    let match;
+    const listStack = []; // { type: 'ul' | 'ol', index: number }
+    const linkStack = []; // pending href for the currently-open <a>
+
+    // Raw text between tags: collapse the source's own whitespace/indentation
+    // into single spaces. Paragraph/line breaks are produced by the tag
+    // handling below, not by whitespace in the source.
+    function appendText(text) {
+        const cleaned = text.replace(/\s+/g, ' ');
+        if (cleaned.trim() === '') return;
+        out += cleaned;
+    }
+
+    const tagRe = /<(\/?)([a-zA-Z0-9]+)([^>]*)>/g;
+    while ((match = tagRe.exec(html)) !== null) {
+        const [, closing, rawTag, attrs] = match;
+        const tag = rawTag.toLowerCase();
+        appendText(html.slice(lastIndex, match.index));
+        lastIndex = tagRe.lastIndex;
+        const isClosing = closing === '/';
+
+        switch (tag) {
+            case 'br':
+                out += '\n';
+                break;
+            case 'p':
+            case 'div':
+                // Odoo commonly wraps list-item text in a <p> (<li><p>...</p></li>);
+                // inside a list, let <li> alone own the line breaks.
+                if (listStack.length === 0) out += '\n\n';
+                break;
+            case 'h1':
+            case 'h2':
+            case 'h3':
+            case 'h4':
+            case 'h5':
+            case 'h6':
+                out += isClosing ? '\n\n' : `\n\n${'#'.repeat(Number(tag[1]))} `;
+                break;
+            case 'strong':
+            case 'b':
+                out += '**';
+                break;
+            case 'em':
+            case 'i':
+                out += '_';
+                break;
+            case 'a':
+                if (!isClosing) {
+                    const hrefMatch = attrs.match(/href=["']([^"']*)["']/i);
+                    linkStack.push(hrefMatch ? hrefMatch[1] : '');
+                    out += '[';
+                } else {
+                    const href = linkStack.pop() ?? '';
+                    out += `](${href})`;
+                }
+                break;
+            case 'img': {
+                const srcMatch = attrs.match(/src=["']([^"']*)["']/i);
+                out += `![](${srcMatch ? srcMatch[1] : ''})`;
+                break;
+            }
+            case 'ul':
+            case 'ol':
+                if (!isClosing) listStack.push({ type: tag, index: 0 });
+                else listStack.pop();
+                out += '\n';
+                break;
+            case 'li':
+                if (!isClosing) {
+                    const ctx = listStack[listStack.length - 1];
+                    if (ctx && ctx.type === 'ol') {
+                        ctx.index += 1;
+                        out += `\n${ctx.index}. `;
+                    } else {
+                        out += '\n- ';
+                    }
+                }
+                break;
+            default:
+                // Unknown/unsupported tag (span, table, etc.): drop the tag,
+                // keep its text content via the surrounding appendText calls.
+                break;
+        }
+    }
+    appendText(html.slice(lastIndex));
+
+    return decodeEntities(out)
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+
+export { htmlToMarkdown };

package/src/lib/trident.js

@@ -0,0 +1,34 @@
+import fetch from 'node-fetch';
+
+// Generic Odoo execute_kw call against Trident. Throws on transport or Odoo error.
+async function tridentRpc(model, method, args, kwargs = {}) {
+    const url = `${process.env.TRIDENT_URL}/jsonrpc`;
+    const body = {
+        jsonrpc: '2.0',
+        method: 'call',
+        id: 1,
+        params: {
+            service: 'object',
+            method: 'execute_kw',
+            args: [
+                process.env.TRIDENT_DB,
+                parseInt(process.env.TRIDENT_UID, 10),
+                process.env.TRIDENT_TOKEN,
+                model,
+                method,
+                args,
+                kwargs,
+            ],
+        },
+    };
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    if (data.error) throw new Error(`Trident error: ${JSON.stringify(data.error)}`);
+    return data.result;
+}
+
+export { tridentRpc };