atl-fetch 1.0.0 → 1.2.0

package/dist/services/text-converter/text-converter.js

@@ -135,6 +135,236 @@ export const convertAdfToPlainText = (adf) => {
     }
     return '';
 };
+// ============================================================
+// ADF → Markdown 変換（Confluence と同じ TurndownService を使用）
+// ============================================================
+/**
+ * HTML 特殊文字をエスケープする
+ *
+ * @param text エスケープ対象の文字列
+ * @returns エスケープ済み文字列
+ */
+const escapeHtml = (text) => {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+};
+/**
+ * ADF マークを HTML タグで囲む
+ *
+ * @param text 対象のテキスト
+ * @param marks 適用するマーク配列
+ * @returns マークを適用した HTML
+ */
+const applyMarksToHtml = (text, marks) => {
+    let result = text;
+    for (const mark of marks) {
+        switch (mark.type) {
+            case 'strong':
+                result = `<strong>${result}</strong>`;
+                break;
+            case 'em':
+                result = `<em>${result}</em>`;
+                break;
+            case 'code':
+                result = `<code>${result}</code>`;
+                break;
+            case 'strike':
+                result = `<s>${result}</s>`;
+                break;
+            case 'underline':
+                result = `<u>${result}</u>`;
+                break;
+            case 'link': {
+                const href = mark.attrs?.['href'];
+                if (typeof href === 'string') {
+                    result = `<a href="${escapeHtml(href)}">${result}</a>`;
+                }
+                break;
+            }
+            case 'textColor': {
+                const color = mark.attrs?.['color'];
+                if (typeof color === 'string') {
+                    result = `<span style="color: ${escapeHtml(color)}">${result}</span>`;
+                }
+                break;
+            }
+            case 'subsup': {
+                const subType = mark.attrs?.['type'];
+                if (subType === 'sub') {
+                    result = `<sub>${result}</sub>`;
+                }
+                else if (subType === 'sup') {
+                    result = `<sup>${result}</sup>`;
+                }
+                break;
+            }
+            // 未知のマークタイプは無視
+            default:
+                break;
+        }
+    }
+    return result;
+};
+/**
+ * ADF ノードを HTML に変換する
+ *
+ * @param node ADF ノード
+ * @param attachmentPaths 添付ファイル ID → ローカルパスのマッピング
+ * @returns HTML 文字列
+ */
+const convertAdfNodeToHtml = (node, attachmentPaths) => {
+    // テキストノードの場合
+    if (node.type === 'text' && node.text !== undefined) {
+        const escapedText = escapeHtml(node.text);
+        if (node.marks !== undefined && node.marks.length > 0) {
+            return applyMarksToHtml(escapedText, node.marks);
+        }
+        return escapedText;
+    }
+    // hardBreak の場合
+    if (node.type === 'hardBreak') {
+        return '<br>';
+    }
+    // rule（水平線）の場合
+    if (node.type === 'rule') {
+        return '<hr>';
+    }
+    // メンションの場合
+    if (node.type === 'mention' && node.attrs !== undefined) {
+        const text = node.attrs['text'];
+        if (typeof text === 'string') {
+            return escapeHtml(text);
+        }
+        return '@ユーザー';
+    }
+    // 絵文字の場合
+    if (node.type === 'emoji' && node.attrs !== undefined) {
+        const text = node.attrs['text'];
+        const shortName = node.attrs['shortName'];
+        if (typeof text === 'string') {
+            return text;
+        }
+        if (typeof shortName === 'string') {
+            return shortName;
+        }
+        return '';
+    }
+    // media ノードの場合（添付ファイル）
+    if (node.type === 'media' && node.attrs !== undefined) {
+        const mediaId = node.attrs['id'];
+        const mediaType = node.attrs['type'];
+        if (typeof mediaId === 'string' && attachmentPaths?.[mediaId] !== undefined) {
+            const localPath = attachmentPaths[mediaId];
+            const alt = typeof node.attrs['alt'] === 'string' ? node.attrs['alt'] : mediaId;
+            return `<img src="${escapeHtml(localPath)}" alt="${escapeHtml(alt)}">`;
+        }
+        // 外部リンクの場合
+        if (mediaType === 'external' || mediaType === 'link') {
+            const url = node.attrs['url'];
+            if (typeof url === 'string') {
+                return `<img src="${escapeHtml(url)}" alt="">`;
+            }
+        }
+        // マッピングがない場合はプレースホルダー
+        return '[添付ファイル]';
+    }
+    // mediaSingle（メディアコンテナ）の場合
+    if (node.type === 'mediaSingle' && node.content !== undefined) {
+        return node.content.map((child) => convertAdfNodeToHtml(child, attachmentPaths)).join('');
+    }
+    // mediaGroup の場合
+    if (node.type === 'mediaGroup' && node.content !== undefined) {
+        return node.content.map((child) => convertAdfNodeToHtml(child, attachmentPaths)).join('');
+    }
+    // inlineCard（インラインリンク）の場合
+    if (node.type === 'inlineCard' && node.attrs !== undefined) {
+        const url = node.attrs['url'];
+        if (typeof url === 'string') {
+            return `<a href="${escapeHtml(url)}">${escapeHtml(url)}</a>`;
+        }
+        return '';
+    }
+    // blockCard（ブロックリンク）の場合
+    if (node.type === 'blockCard' && node.attrs !== undefined) {
+        const url = node.attrs['url'];
+        if (typeof url === 'string') {
+            return `<p><a href="${escapeHtml(url)}">${escapeHtml(url)}</a></p>`;
+        }
+        return '';
+    }
+    // 子ノードがある場合
+    if (node.content !== undefined && Array.isArray(node.content)) {
+        const childrenHtml = node.content.map((child) => convertAdfNodeToHtml(child, attachmentPaths)).join('');
+        switch (node.type) {
+            case 'doc':
+                return childrenHtml;
+            case 'paragraph':
+                return `<p>${childrenHtml}</p>`;
+            case 'heading': {
+                const level = typeof node.attrs?.['level'] === 'number' ? node.attrs['level'] : 1;
+                const safeLevel = Math.max(1, Math.min(6, level));
+                return `<h${safeLevel}>${childrenHtml}</h${safeLevel}>`;
+            }
+            case 'bulletList':
+                return `<ul>${childrenHtml}</ul>`;
+            case 'orderedList':
+                return `<ol>${childrenHtml}</ol>`;
+            case 'listItem':
+                return `<li>${childrenHtml}</li>`;
+            case 'blockquote':
+                return `<blockquote>${childrenHtml}</blockquote>`;
+            case 'codeBlock': {
+                const language = typeof node.attrs?.['language'] === 'string' ? node.attrs['language'] : '';
+                const langClass = language ? ` class="language-${escapeHtml(language)}"` : '';
+                // コードブロック内のテキストは子ノードから取得
+                const codeText = node.content
+                    .map((child) => (child.type === 'text' && child.text !== undefined ? child.text : ''))
+                    .join('');
+                return `<pre><code${langClass}>${escapeHtml(codeText)}</code></pre>`;
+            }
+            case 'table':
+                return `<table>${childrenHtml}</table>`;
+            case 'tableRow':
+                return `<tr>${childrenHtml}</tr>`;
+            case 'tableHeader':
+                return `<th>${childrenHtml}</th>`;
+            case 'tableCell':
+                return `<td>${childrenHtml}</td>`;
+            case 'panel': {
+                // panel タイプを GitHub Alerts 形式に変換
+                const panelType = typeof node.attrs?.['panelType'] === 'string' ? node.attrs['panelType'] : 'info';
+                const alertTypeMap = {
+                    error: 'WARNING',
+                    info: 'NOTE',
+                    note: 'NOTE',
+                    success: 'TIP',
+                    warning: 'WARNING',
+                };
+                const alertType = alertTypeMap[panelType] || 'NOTE';
+                return `<blockquote data-github-alert="${alertType}">${childrenHtml}</blockquote>`;
+            }
+            // 未知のノードタイプは子ノードの内容を返す
+            default:
+                return childrenHtml;
+        }
+    }
+    // 子ノードもテキストもない場合は空文字列
+    return '';
+};
+/**
+ * ADF ドキュメントを HTML に変換する
+ *
+ * @param content ADF ドキュメントのコンテンツ配列
+ * @param attachmentPaths 添付ファイル ID → ローカルパスのマッピング
+ * @returns HTML 文字列
+ */
+const convertAdfContentToHtml = (content, attachmentPaths) => {
+    return content.map((node) => convertAdfNodeToHtml(node, attachmentPaths)).join('');
+};
 /**
  * HTML エンティティをデコードする
  *
@@ -348,20 +578,12 @@ const preprocessHtmlForMarkdown = (html, attachmentPaths) => {
     return result;
 };
 /**
- * Confluence Storage Format（XHTML）を Markdown に変換する
+ * TurndownService インスタンスを作成する（共通設定）
+ * Jira ADF と Confluence Storage Format の両方で使用する
  *
- * @param storageFormat Storage Format 文字列（HTML/XHTML）
- * @param attachmentPaths 添付ファイル名 → ローカルパスのマッピング
- * @returns Markdown 文字列
+ * @returns 設定済みの TurndownService インスタンス
  */
-export const convertStorageFormatToMarkdown = (storageFormat, attachmentPaths) => {
-    // null または undefined の場合は空文字列を返す
-    if (storageFormat === null || storageFormat === undefined || storageFormat === '') {
-        return '';
-    }
-    // 前処理
-    const preprocessedHtml = preprocessHtmlForMarkdown(storageFormat, attachmentPaths);
-    // Turndown インスタンス作成
+const createTurndownService = () => {
     const turndownService = new TurndownService({
         bulletListMarker: '-',
         codeBlockStyle: 'fenced',
@@ -371,9 +593,7 @@ export const convertStorageFormatToMarkdown = (storageFormat, attachmentPaths) =
     });
     // GFM プラグイン（テーブル、取り消し線など）を使用
     turndownService.use(gfm);
-    // --------------------------------------------------
     // カスタムルール: キャプション付き画像（<figure>）
-    // --------------------------------------------------
     turndownService.addRule('figureWithCaption', {
         filter: (node) => {
             return node.nodeName === 'FIGURE';
@@ -397,9 +617,7 @@ export const convertStorageFormatToMarkdown = (storageFormat, attachmentPaths) =
             return '';
         },
     });
-    // --------------------------------------------------
     // カスタムルール: GitHub Alerts（<blockquote data-github-alert="...">）
-    // --------------------------------------------------
     turndownService.addRule('githubAlerts', {
         filter: (node) => {
             if (node.nodeName !== 'BLOCKQUOTE')
@@ -417,9 +635,7 @@ export const convertStorageFormatToMarkdown = (storageFormat, attachmentPaths) =
             return `\n> [!${alertType}]\n${quotedContent}\n`;
         },
     });
-    // --------------------------------------------------
     // カスタムルール: 色変更テキスト（HTML のまま出力）
-    // --------------------------------------------------
     turndownService.addRule('coloredText', {
         filter: (node) => {
             if (node.nodeName !== 'SPAN')
@@ -432,9 +648,7 @@ export const convertStorageFormatToMarkdown = (storageFormat, attachmentPaths) =
             return node.outerHTML;
         },
     });
-    // --------------------------------------------------
     // カスタムルール: セル結合/セル内改行のあるテーブル（HTML のまま出力）
-    // --------------------------------------------------
     turndownService.addRule('complexTable', {
         filter: (node) => {
             if (node.nodeName !== 'TABLE')
@@ -447,6 +661,65 @@ export const convertStorageFormatToMarkdown = (storageFormat, attachmentPaths) =
             return node.outerHTML;
         },
     });
+    return turndownService;
+};
+/**
+ * ADF（Atlassian Document Format）を Markdown に変換する
+ *
+ * @param adf ADF ドキュメント（オブジェクトまたは JSON 文字列）
+ * @param attachmentPaths 添付ファイル ID → ローカルパスのマッピング
+ * @returns Markdown 文字列
+ */
+export const convertAdfToMarkdown = (adf, attachmentPaths) => {
+    // null または undefined の場合は空文字列を返す
+    if (adf === null || adf === undefined) {
+        return '';
+    }
+    // 文字列の場合は JSON としてパースを試みる
+    if (typeof adf === 'string') {
+        // 空文字列の場合
+        if (adf === '') {
+            return '';
+        }
+        try {
+            const parsed = JSON.parse(adf);
+            if (isAdfDocument(parsed)) {
+                const html = convertAdfContentToHtml(parsed.content, attachmentPaths);
+                const turndownService = createTurndownService();
+                return turndownService.turndown(html).trim();
+            }
+        }
+        catch {
+            // JSON パースに失敗した場合は元の文字列を返す
+            return adf;
+        }
+        // パースできたが ADF 形式でない場合は元の文字列を返す
+        return adf;
+    }
+    // オブジェクトの場合は ADF ドキュメントとして処理
+    if (isAdfDocument(adf)) {
+        const html = convertAdfContentToHtml(adf.content, attachmentPaths);
+        const turndownService = createTurndownService();
+        return turndownService.turndown(html).trim();
+    }
+    return '';
+};
+/**
+ * Confluence Storage Format（XHTML）を Markdown に変換する
+ *
+ * @param storageFormat Storage Format 文字列（HTML/XHTML）
+ * @param attachmentPaths 添付ファイル名 → ローカルパスのマッピング
+ * @returns Markdown 文字列
+ */
+export const convertStorageFormatToMarkdown = (storageFormat, attachmentPaths) => {
+    // null または undefined の場合は空文字列を返す
+    if (storageFormat === null || storageFormat === undefined || storageFormat === '') {
+        return '';
+    }
+    // 前処理
+    const preprocessedHtml = preprocessHtmlForMarkdown(storageFormat, attachmentPaths);
+    // 共通の TurndownService を使用
+    const turndownService = createTurndownService();
     // Markdown に変換
     const markdown = turndownService.turndown(preprocessedHtml);
     // 末尾の空白を除去

package/dist/types/jira.d.ts

@@ -6,8 +6,10 @@ export interface JiraComment {
     readonly id: string;
     /** 作成者の表示名 */
     readonly author: string;
-    /** コメント本文 */
+    /** コメント本文（プレーンテキスト） */
     readonly body: string;
+    /** コメント本文（ADF 形式、Markdown 変換用） */
+    readonly bodyAdf: unknown;
     /** 作成日時（ISO 8601 形式） */
     readonly created: string;
     /** 更新日時（ISO 8601 形式） */
@@ -62,6 +64,8 @@ export interface JiraIssue {
     readonly summary: string;
     /** Issue 説明（null の場合は説明なし） */
     readonly description: string | null;
+    /** Issue 説明（ADF 形式、Markdown 変換用） */
+    readonly descriptionAdf: unknown;
     /** コメント一覧 */
     readonly comments: readonly JiraComment[];
     /** 変更履歴一覧 */

package/dist/types/storage.d.ts

@@ -93,9 +93,9 @@ export interface JiraSaveData {
     readonly key: string;
     /** Issue タイトル（要約） */
     readonly summary: string;
-    /** Issue 説明（null の場合は説明なし） */
-    readonly description: string | null;
-    /** 説明のプレーンテキスト（null の場合は説明なし） */
+    /** Issue 説明（ADF 形式、null の場合は説明なし） */
+    readonly description: unknown;
+    /** 説明のプレーンテキスト（null の場合は説明なし、後方互換性のため維持） */
     readonly descriptionPlainText: string | null;
     /** コメント一覧 */
     readonly comments: readonly JiraComment[];

package/package.json

@@ -12,6 +12,8 @@
     "got": "14.6.6",
     "jsdom": "27.4.0",
     "neverthrow": "8.2.0",
+    "ora": "^9.0.0",
+    "picocolors": "^1.1.1",
     "turndown": "7.2.2",
     "turndown-plugin-gfm": "1.0.2",
     "yaml": "2.8.2",
@@ -80,7 +82,7 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",

package/dist/types/result.d.ts

@@ -1,104 +0,0 @@
-/**
- * Result 型 - 成功または失敗を表現する discriminated union
- *
- * @example
- * ```typescript
- * function divide(a: number, b: number): Result<number, DivisionError> {
- *   if (b === 0) {
- *     return err({ kind: 'DIVISION_BY_ZERO', message: 'Cannot divide by zero' });
- *   }
- *   return ok(a / b);
- * }
- * ```
- */
-/**
- * 成功を表す型
- */
-export interface Ok<T> {
-    readonly success: true;
-    readonly value: T;
-}
-/**
- * 失敗を表す型
- */
-export interface Err<E> {
-    readonly success: false;
-    readonly error: E;
-}
-/**
- * Result 型 - 成功（Ok）または失敗（Err）のどちらかを表す
- */
-export type Result<T, E> = Ok<T> | Err<E>;
-/**
- * 成功 Result を作成する
- *
- * @param value - 成功値
- * @returns 成功 Result
- */
-export declare function ok<T>(value: T): Ok<T>;
-/**
- * 失敗 Result を作成する
- *
- * @param error - エラー値
- * @returns 失敗 Result
- */
-export declare function err<E>(error: E): Err<E>;
-/**
- * Result が成功かどうかを判定する型ガード
- *
- * @param result - 判定対象の Result
- * @returns 成功の場合 true
- */
-export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
-/**
- * Result が失敗かどうかを判定する型ガード
- *
- * @param result - 判定対象の Result
- * @returns 失敗の場合 true
- */
-export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
-/**
- * 成功 Result から値を取り出す
- * 失敗 Result の場合はエラーをスローする
- *
- * @param result - 対象の Result
- * @returns 成功値
- * @throws 失敗 Result の場合
- */
-export declare function unwrap<T, E>(result: Result<T, E>): T;
-/**
- * 失敗 Result からエラー値を取り出す
- * 成功 Result の場合はエラーをスローする
- *
- * @param result - 対象の Result
- * @returns エラー値
- * @throws 成功 Result の場合
- */
-export declare function unwrapErr<T, E>(result: Result<T, E>): E;
-/**
- * 成功 Result から値を取り出す
- * 失敗 Result の場合はデフォルト値を返す
- *
- * @param result - 対象の Result
- * @param defaultValue - 失敗時のデフォルト値
- * @returns 成功値またはデフォルト値
- */
-export declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
-/**
- * 成功 Result の値を変換する
- * 失敗 Result の場合はそのまま返す
- *
- * @param result - 対象の Result
- * @param fn - 変換関数
- * @returns 変換された Result
- */
-export declare function mapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
-/**
- * 失敗 Result のエラー値を変換する
- * 成功 Result の場合はそのまま返す
- *
- * @param result - 対象の Result
- * @param fn - 変換関数
- * @returns 変換された Result
- */
-export declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;

package/dist/types/result.js

@@ -1,119 +0,0 @@
-/**
- * Result 型 - 成功または失敗を表現する discriminated union
- *
- * @example
- * ```typescript
- * function divide(a: number, b: number): Result<number, DivisionError> {
- *   if (b === 0) {
- *     return err({ kind: 'DIVISION_BY_ZERO', message: 'Cannot divide by zero' });
- *   }
- *   return ok(a / b);
- * }
- * ```
- */
-/**
- * 成功 Result を作成する
- *
- * @param value - 成功値
- * @returns 成功 Result
- */
-export function ok(value) {
-    return { success: true, value };
-}
-/**
- * 失敗 Result を作成する
- *
- * @param error - エラー値
- * @returns 失敗 Result
- */
-export function err(error) {
-    return { error, success: false };
-}
-/**
- * Result が成功かどうかを判定する型ガード
- *
- * @param result - 判定対象の Result
- * @returns 成功の場合 true
- */
-export function isOk(result) {
-    return result.success;
-}
-/**
- * Result が失敗かどうかを判定する型ガード
- *
- * @param result - 判定対象の Result
- * @returns 失敗の場合 true
- */
-export function isErr(result) {
-    return !result.success;
-}
-/**
- * 成功 Result から値を取り出す
- * 失敗 Result の場合はエラーをスローする
- *
- * @param result - 対象の Result
- * @returns 成功値
- * @throws 失敗 Result の場合
- */
-export function unwrap(result) {
-    if (isOk(result)) {
-        return result.value;
-    }
-    throw new Error(`Attempted to unwrap an Err value: ${String(result.error)}`);
-}
-/**
- * 失敗 Result からエラー値を取り出す
- * 成功 Result の場合はエラーをスローする
- *
- * @param result - 対象の Result
- * @returns エラー値
- * @throws 成功 Result の場合
- */
-export function unwrapErr(result) {
-    if (isErr(result)) {
-        return result.error;
-    }
-    throw new Error('Attempted to unwrapErr an Ok value');
-}
-/**
- * 成功 Result から値を取り出す
- * 失敗 Result の場合はデフォルト値を返す
- *
- * @param result - 対象の Result
- * @param defaultValue - 失敗時のデフォルト値
- * @returns 成功値またはデフォルト値
- */
-export function unwrapOr(result, defaultValue) {
-    if (isOk(result)) {
-        return result.value;
-    }
-    return defaultValue;
-}
-/**
- * 成功 Result の値を変換する
- * 失敗 Result の場合はそのまま返す
- *
- * @param result - 対象の Result
- * @param fn - 変換関数
- * @returns 変換された Result
- */
-export function mapResult(result, fn) {
-    if (isOk(result)) {
-        return ok(fn(result.value));
-    }
-    return result;
-}
-/**
- * 失敗 Result のエラー値を変換する
- * 成功 Result の場合はそのまま返す
- *
- * @param result - 対象の Result
- * @param fn - 変換関数
- * @returns 変換された Result
- */
-export function mapErr(result, fn) {
-    if (isErr(result)) {
-        return err(fn(result.error));
-    }
-    return result;
-}