@bike4mind/cli 0.2.6-fix-cli-mcp-type-mismatch.17119 → 0.2.7-ja-fix-confluence-table-data-5752.17142

package/dist/ImageStore-RQZ7OF7P.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/storage/ImageStore.ts
+import { createHash } from "crypto";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync } from "fs";
+import { join, extname, resolve } from "path";
+import { homedir } from "os";
+import Database from "better-sqlite3";
+import sharp from "sharp";
+var ImageStore = class _ImageStore {
+  static {
+    this.BASE_DIR = join(homedir(), ".bike4mind", "cli");
+  }
+  static {
+    this.IMAGES_DIR = join(_ImageStore.BASE_DIR, "images");
+  }
+  static {
+    this.DB_PATH = join(_ImageStore.BASE_DIR, "images.db");
+  }
+  static {
+    this.RETENTION_DAYS = 7;
+  }
+  static {
+    // Target max size before base64 encoding. Base64 adds ~33% overhead.
+    // To stay under 1MB after base64, we need images < 750KB
+    this.MAX_RAW_SIZE = 750 * 1024;
+  }
+  static {
+    // 750KB
+    // Maximum size before compression to prevent OOM with very large images
+    this.MAX_PRECOMPRESS_SIZE = 50 * 1024 * 1024;
+  }
+  constructor() {
+    this.ensureDirectories();
+    this.db = new Database(_ImageStore.DB_PATH);
+    this.initDatabase();
+    try {
+      this.cleanupOldImages();
+    } catch (err) {
+      console.warn("Failed to cleanup old images:", err);
+    }
+  }
+  ensureDirectories() {
+    mkdirSync(_ImageStore.BASE_DIR, { recursive: true });
+    mkdirSync(_ImageStore.IMAGES_DIR, { recursive: true });
+  }
+  initDatabase() {
+    this.db.exec(`
+			CREATE TABLE IF NOT EXISTS images (
+				hash TEXT PRIMARY KEY,
+				format TEXT NOT NULL,
+				size INTEGER NOT NULL,
+				timestamp INTEGER NOT NULL,
+				uploaded INTEGER NOT NULL DEFAULT 0,
+				s3_url TEXT,
+				original_filename TEXT
+			)
+		`);
+  }
+  /**
+   * Store an image locally with content-based hashing for deduplication
+   */
+  async store(imageData, originalFilename) {
+    const { buffer: processedData, format: processedFormat } = await this.processImage(imageData, originalFilename);
+    const hash = this.generateHash(processedData);
+    const format = processedFormat;
+    const ext = format.toLowerCase();
+    const localPath = join(_ImageStore.IMAGES_DIR, `${hash}.${ext}`);
+    const existing = this.getMetadata(hash);
+    if (existing) {
+      return {
+        hash,
+        placeholder: "",
+        // Will be set by caller
+        localPath,
+        metadata: existing
+      };
+    }
+    writeFileSync(localPath, processedData);
+    const metadata = {
+      hash,
+      format,
+      size: processedData.length,
+      timestamp: Date.now(),
+      uploaded: false,
+      originalFilename
+    };
+    this.db.prepare(
+      `INSERT INTO images (hash, format, size, timestamp, uploaded, original_filename)
+				 VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(hash, format, metadata.size, metadata.timestamp, 0, originalFilename || null);
+    return {
+      hash,
+      placeholder: "",
+      localPath,
+      metadata
+    };
+  }
+  /**
+   * Get image metadata by hash
+   */
+  getMetadata(hash) {
+    const row = this.db.prepare("SELECT * FROM images WHERE hash = ?").get(hash);
+    if (!row) return null;
+    return {
+      hash: row.hash,
+      format: row.format,
+      size: row.size,
+      timestamp: row.timestamp,
+      uploaded: Boolean(row.uploaded),
+      s3Url: row.s3_url,
+      originalFilename: row.original_filename
+    };
+  }
+  /**
+   * Read image data from local cache
+   */
+  readImage(hash) {
+    const metadata = this.getMetadata(hash);
+    if (!metadata) return null;
+    const localPath = join(_ImageStore.IMAGES_DIR, `${hash}.${metadata.format.toLowerCase()}`);
+    const normalizedPath = resolve(localPath);
+    if (!normalizedPath.startsWith(resolve(_ImageStore.IMAGES_DIR))) {
+      throw new Error("Invalid image path");
+    }
+    if (!existsSync(localPath)) return null;
+    return readFileSync(localPath);
+  }
+  /**
+   * Generate content hash for deduplication
+   */
+  generateHash(data) {
+    return createHash("sha256").update(data).digest("hex").substring(0, 16);
+  }
+  /**
+   * Process image: compress if needed to stay under size limit
+   */
+  async processImage(data, originalFilename) {
+    if (data.length > _ImageStore.MAX_PRECOMPRESS_SIZE) {
+      throw new Error(
+        `Image too large to process (${Math.round(data.length / 1024 / 1024)}MB). Maximum size is ${_ImageStore.MAX_PRECOMPRESS_SIZE / 1024 / 1024}MB.`
+      );
+    }
+    const originalFormat = this.detectFormat(data, originalFilename);
+    if (data.length <= _ImageStore.MAX_RAW_SIZE) {
+      return { buffer: data, format: originalFormat };
+    }
+    let image = sharp(data);
+    const metadata = await image.metadata();
+    if (!metadata.width || !metadata.height) {
+      throw new Error("Unable to read image dimensions");
+    }
+    const maxDimension = 2048;
+    let width = metadata.width;
+    let height = metadata.height;
+    if (width > maxDimension || height > maxDimension) {
+      if (width > height) {
+        height = Math.round(height * maxDimension / width);
+        width = maxDimension;
+      } else {
+        width = Math.round(width * maxDimension / height);
+        height = maxDimension;
+      }
+    }
+    image = image.resize(width, height);
+    let quality = 85;
+    let buffer = await image.jpeg({ quality }).toBuffer();
+    while (buffer.length > _ImageStore.MAX_RAW_SIZE && quality > 30) {
+      quality -= 10;
+      buffer = await image.jpeg({ quality }).toBuffer();
+    }
+    if (buffer.length > _ImageStore.MAX_RAW_SIZE) {
+      throw new Error(`Unable to compress image below ${_ImageStore.MAX_RAW_SIZE / 1024}KB limit`);
+    }
+    return { buffer, format: "jpg" };
+  }
+  /**
+   * Detect image format from buffer or filename
+   */
+  detectFormat(data, filename) {
+    if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) {
+      return "png";
+    }
+    if (data[0] === 255 && data[1] === 216 && data[2] === 255) {
+      return "jpg";
+    }
+    if (data[0] === 71 && data[1] === 73 && data[2] === 70) {
+      return "gif";
+    }
+    if (data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70) {
+      return "webp";
+    }
+    if (filename) {
+      const ext = extname(filename).substring(1).toLowerCase();
+      if (["png", "jpg", "jpeg", "gif", "webp"].includes(ext)) {
+        return ext === "jpeg" ? "jpg" : ext;
+      }
+    }
+    return "png";
+  }
+  /**
+   * Clean up images older than retention period
+   */
+  cleanupOldImages() {
+    const cutoffTime = Date.now() - _ImageStore.RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+    const oldImages = this.db.prepare("SELECT hash, format FROM images WHERE timestamp < ?").all(cutoffTime);
+    for (const { hash, format } of oldImages) {
+      const localPath = join(_ImageStore.IMAGES_DIR, `${hash}.${format.toLowerCase()}`);
+      if (existsSync(localPath)) {
+        unlinkSync(localPath);
+      }
+    }
+    this.db.prepare("DELETE FROM images WHERE timestamp < ?").run(cutoffTime);
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+};
+export {
+  ImageStore
+};

package/dist/{artifactExtractor-DNE5C6DY.js → artifactExtractor-6IAPZV52.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-H6SHASMZ.js";
+} from "./chunk-F2LBB4TN.js";
 import "./chunk-PDX44BCA.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/artifactExtractor.js

package/dist/{chunk-LIRY24M5.js → chunk-6ATNPERY.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-DNSBC3LO.js";
+} from "./chunk-KPBWTYME.js";
 import {
   GenericCreditDeductTransaction,
   ImageEditUsageTransaction,
@@ -10,7 +10,7 @@ import {
   RealtimeVoiceUsageTransaction,
   TextGenerationUsageTransaction,
   TransferCreditTransaction
-} from "./chunk-H6SHASMZ.js";
+} from "./chunk-F2LBB4TN.js";
 
 // ../../b4m-core/packages/services/dist/src/creditService/subtractCredits.js
 import { z } from "zod";

package/dist/{chunk-H6SHASMZ.js → chunk-F2LBB4TN.js}

@@ -5041,6 +5041,74 @@ function formatUserList(users) {
 }
 
 // ../../b4m-core/packages/common/dist/src/jira/api.js
+function wikiMarkupToAdf(text) {
+  const lines = text.split("\n");
+  const content = [];
+  let currentTableRows = [];
+  let inTable = false;
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith("||") && trimmedLine.endsWith("||")) {
+      inTable = true;
+      const cells = trimmedLine.slice(2, -2).split("||").map((cell) => cell.trim());
+      const headerRow = {
+        type: "tableRow",
+        content: cells.map((cell) => ({
+          type: "tableHeader",
+          attrs: {},
+          content: [{ type: "paragraph", content: [{ type: "text", text: cell || " " }] }]
+        }))
+      };
+      currentTableRows.push(headerRow);
+      continue;
+    }
+    if (trimmedLine.startsWith("|") && trimmedLine.endsWith("|") && !trimmedLine.startsWith("||")) {
+      inTable = true;
+      const cells = trimmedLine.slice(1, -1).split("|").map((cell) => cell.trim());
+      const dataRow = {
+        type: "tableRow",
+        content: cells.map((cell) => ({
+          type: "tableCell",
+          attrs: {},
+          content: [{ type: "paragraph", content: [{ type: "text", text: cell || " " }] }]
+        }))
+      };
+      currentTableRows.push(dataRow);
+      continue;
+    }
+    if (inTable && currentTableRows.length > 0) {
+      const table = {
+        type: "table",
+        attrs: { isNumberColumnEnabled: false, layout: "default" },
+        content: currentTableRows
+      };
+      content.push(table);
+      currentTableRows = [];
+      inTable = false;
+    }
+    if (trimmedLine) {
+      content.push({
+        type: "paragraph",
+        content: [{ type: "text", text: trimmedLine }]
+      });
+    }
+  }
+  if (currentTableRows.length > 0) {
+    const table = {
+      type: "table",
+      attrs: { isNumberColumnEnabled: false, layout: "default" },
+      content: currentTableRows
+    };
+    content.push(table);
+  }
+  if (content.length === 0) {
+    content.push({ type: "paragraph", content: [{ type: "text", text: " " }] });
+  }
+  return { type: "doc", version: 1, content };
+}
+function containsWikiTable(text) {
+  return /^\|\|.+\|\|$/m.test(text) || /^\|(?!\|).+\|$/m.test(text);
+}
 var JiraApi = class {
   config;
   constructor(config) {
@@ -5120,16 +5188,21 @@ var JiraApi = class {
       ...customFields
     };
     if (description) {
-      fields.description = {
-        type: "doc",
-        version: 1,
-        content: [
-          {
-            type: "paragraph",
-            content: [{ type: "text", text: description }]
-          }
-        ]
-      };
+      if (containsWikiTable(description)) {
+        console.log("[JIRA-ADF] Converting wiki table to ADF", { length: description.length });
+        fields.description = wikiMarkupToAdf(description);
+      } else {
+        fields.description = {
+          type: "doc",
+          version: 1,
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: description }]
+            }
+          ]
+        };
+      }
     }
     if (assignee) {
       fields.assignee = { id: assignee };
@@ -5155,16 +5228,21 @@ var JiraApi = class {
       fields.summary = summary;
     }
     if (description) {
-      fields.description = {
-        type: "doc",
-        version: 1,
-        content: [
-          {
-            type: "paragraph",
-            content: [{ type: "text", text: description }]
-          }
-        ]
-      };
+      if (containsWikiTable(description)) {
+        console.log("[JIRA-ADF] Converting wiki table to ADF (update)", { length: description.length });
+        fields.description = wikiMarkupToAdf(description);
+      } else {
+        fields.description = {
+          type: "doc",
+          version: 1,
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: description }]
+            }
+          ]
+        };
+      }
     }
     if (labels) {
       fields.labels = labels;
@@ -5324,16 +5402,21 @@ var JiraApi = class {
         issuetype: { name: issueTypeName }
       };
       if (description) {
-        fields.description = {
-          type: "doc",
-          version: 1,
-          content: [
-            {
-              type: "paragraph",
-              content: [{ type: "text", text: description }]
-            }
-          ]
-        };
+        if (containsWikiTable(description)) {
+          console.log("[JIRA-ADF] Converting wiki table to ADF (bulk)", { length: description.length });
+          fields.description = wikiMarkupToAdf(description);
+        } else {
+          fields.description = {
+            type: "doc",
+            version: 1,
+            content: [
+              {
+                type: "paragraph",
+                content: [{ type: "text", text: description }]
+              }
+            ]
+          };
+        }
       }
       if (assignee) {
         fields.assignee = { id: assignee };
@@ -6149,6 +6232,8 @@ export {
   formatUser,
   formatTransitionResult,
   formatUserList,
+  wikiMarkupToAdf,
+  containsWikiTable,
   JiraApi,
   getErrorMessage,
   getAtlassianConfig,

package/dist/{chunk-3CCBDIFR.js → chunk-GPTQ7T7Y.js}

@@ -6,12 +6,12 @@ import {
   getSettingsByNames,
   obfuscateApiKey,
   secureParameters
-} from "./chunk-DNSBC3LO.js";
+} from "./chunk-KPBWTYME.js";
 import {
   ApiKeyType,
   MementoTier,
   isSupportedEmbeddingModel
-} from "./chunk-H6SHASMZ.js";
+} from "./chunk-F2LBB4TN.js";
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/get.js
 import { z } from "zod";

package/dist/{chunk-DNSBC3LO.js → chunk-KPBWTYME.js}

@@ -16,7 +16,7 @@ import {
   dayjsConfig_default,
   extractSnippetMeta,
   settingsMap
-} from "./chunk-H6SHASMZ.js";
+} from "./chunk-F2LBB4TN.js";
 
 // ../../b4m-core/packages/utils/dist/src/storage/S3Storage.js
 import { S3Client, PutObjectCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand } from "@aws-sdk/client-s3";

package/dist/{chunk-YXHQN7SK.js → chunk-OK3T7VKG.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-DNSBC3LO.js";
+} from "./chunk-KPBWTYME.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-H6SHASMZ.js";
+} from "./chunk-F2LBB4TN.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";

package/dist/{create-PNU64QSF.js → create-OF43XXQD.js}

@@ -2,10 +2,10 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-YXHQN7SK.js";
-import "./chunk-DNSBC3LO.js";
+} from "./chunk-OK3T7VKG.js";
+import "./chunk-KPBWTYME.js";
 import "./chunk-AMDXHL6S.js";
-import "./chunk-H6SHASMZ.js";
+import "./chunk-F2LBB4TN.js";
 import "./chunk-PDX44BCA.js";
 export {
   createFabFile,