@hasna/skills 0.1.60 → 0.1.62

package/skills/convert/src/converters/document.ts

@@ -1,189 +0,0 @@
-/**
- * Document conversion utilities (DOCX, HTML, Markdown)
- */
-
-import mammoth from 'mammoth';
-import TurndownService from 'turndown';
-import { marked } from 'marked';
-import { htmlToText } from 'html-to-text';
-import { readFile, writeFile, stat } from 'fs/promises';
-import { extname, basename, dirname, join } from 'path';
-import type { ConvertOptions, ConvertResult } from '../types';
-
-const turndownService = new TurndownService({
-  headingStyle: 'atx',
-  codeBlockStyle: 'fenced',
-  bulletListMarker: '-',
-});
-
-/**
- * Convert DOCX to HTML
- */
-export async function docxToHtml(docxPath: string): Promise<string> {
-  const buffer = await readFile(docxPath);
-  const result = await mammoth.convertToHtml({ buffer });
-  return result.value;
-}
-
-/**
- * Convert DOCX to plain text
- */
-export async function docxToText(docxPath: string): Promise<string> {
-  const buffer = await readFile(docxPath);
-  const result = await mammoth.extractRawText({ buffer });
-  return result.value;
-}
-
-/**
- * Convert DOCX to Markdown
- */
-export async function docxToMarkdown(docxPath: string): Promise<string> {
-  const html = await docxToHtml(docxPath);
-  return turndownService.turndown(html);
-}
-
-/**
- * Convert HTML to Markdown
- */
-export function htmlToMarkdown(html: string): string {
-  return turndownService.turndown(html);
-}
-
-/**
- * Convert Markdown to HTML
- */
-export async function markdownToHtml(markdown: string): Promise<string> {
-  return await marked(markdown);
-}
-
-/**
- * Convert HTML to plain text
- */
-export function htmlToPlainText(html: string): string {
-  return htmlToText(html, {
-    wordwrap: 80,
-    selectors: [
-      { selector: 'a', options: { ignoreHref: true } },
-      { selector: 'img', format: 'skip' },
-    ],
-  });
-}
-
-/**
- * Convert document to another format
- */
-export async function convertDocument(options: ConvertOptions): Promise<ConvertResult> {
-  const startTime = Date.now();
-  const inputStat = await stat(options.input);
-  const inputExt = extname(options.input).slice(1).toLowerCase();
-
-  const outputPath = options.output || join(
-    dirname(options.input),
-    `${basename(options.input, extname(options.input))}.${options.format}`
-  );
-
-  try {
-    let content: string;
-
-    // Convert based on input format
-    if (inputExt === 'docx' || inputExt === 'doc') {
-      switch (options.format) {
-        case 'html':
-        case 'htm':
-          content = await docxToHtml(options.input);
-          break;
-        case 'md':
-        case 'markdown':
-          content = await docxToMarkdown(options.input);
-          break;
-        case 'txt':
-          content = await docxToText(options.input);
-          break;
-        default:
-          throw new Error(`Cannot convert DOCX to ${options.format}`);
-      }
-    } else if (inputExt === 'html' || inputExt === 'htm') {
-      const html = await readFile(options.input, 'utf-8');
-      switch (options.format) {
-        case 'md':
-        case 'markdown':
-          content = htmlToMarkdown(html);
-          break;
-        case 'txt':
-          content = htmlToPlainText(html);
-          break;
-        default:
-          throw new Error(`Cannot convert HTML to ${options.format}`);
-      }
-    } else if (inputExt === 'md' || inputExt === 'markdown') {
-      const markdown = await readFile(options.input, 'utf-8');
-      switch (options.format) {
-        case 'html':
-        case 'htm':
-          content = await markdownToHtml(markdown);
-          break;
-        case 'txt':
-          // Strip markdown formatting
-          content = markdown
-            .replace(/#{1,6}\s/g, '')
-            .replace(/\*\*/g, '')
-            .replace(/\*/g, '')
-            .replace(/`/g, '')
-            .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
-          break;
-        default:
-          throw new Error(`Cannot convert Markdown to ${options.format}`);
-      }
-    } else if (inputExt === 'txt') {
-      const text = await readFile(options.input, 'utf-8');
-      switch (options.format) {
-        case 'md':
-        case 'markdown':
-          // Wrap plain text in markdown (basic formatting)
-          content = text;
-          break;
-        case 'html':
-        case 'htm':
-          // Wrap in basic HTML
-          content = `<!DOCTYPE html>
-<html>
-<head><meta charset="utf-8"></head>
-<body>
-<pre>${text.replace(/</g, '&lt;').replace(/>/g, '&gt;')}</pre>
-</body>
-</html>`;
-          break;
-        default:
-          throw new Error(`Cannot convert TXT to ${options.format}`);
-      }
-    } else {
-      throw new Error(`Unsupported input format: ${inputExt}`);
-    }
-
-    await writeFile(outputPath, content);
-    const outputStat = await stat(outputPath);
-
-    return {
-      success: true,
-      input: options.input,
-      output: outputPath,
-      inputFormat: inputExt,
-      outputFormat: options.format,
-      inputSize: inputStat.size,
-      outputSize: outputStat.size,
-      duration: Date.now() - startTime,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      input: options.input,
-      output: outputPath,
-      inputFormat: inputExt,
-      outputFormat: options.format,
-      inputSize: inputStat.size,
-      outputSize: 0,
-      error: error instanceof Error ? error.message : String(error),
-      duration: Date.now() - startTime,
-    };
-  }
-}

package/skills/convert/src/converters/image.ts

@@ -1,227 +0,0 @@
-/**
- * Image conversion utilities using Sharp
- */
-
-import sharp from 'sharp';
-import { readFile, stat } from 'fs/promises';
-import { extname, basename, dirname, join } from 'path';
-import type { ImageFormat, ImageQuality, ConvertOptions, ConvertResult } from '../types';
-import { QUALITY_SETTINGS } from '../types';
-
-/**
- * Convert image to another format
- */
-export async function convertImage(options: ConvertOptions): Promise<ConvertResult> {
-  const startTime = Date.now();
-  const inputStat = await stat(options.input);
-  const inputFormat = extname(options.input).slice(1).toLowerCase() as ImageFormat;
-  const outputFormat = options.format as ImageFormat;
-
-  // Determine output path
-  const outputPath = options.output || join(
-    dirname(options.input),
-    `${basename(options.input, extname(options.input))}.${outputFormat}`
-  );
-
-  try {
-    let pipeline = sharp(options.input);
-
-    // Apply resize if specified
-    if (options.resize) {
-      pipeline = pipeline.resize({
-        width: options.resize.width,
-        height: options.resize.height,
-        fit: options.resize.fit || 'contain',
-        withoutEnlargement: true,
-      });
-    }
-
-    // Get quality settings
-    const qualityPreset = options.quality || 'high';
-    const qualitySetting = options.qualityValue ?? QUALITY_SETTINGS[qualityPreset].quality;
-
-    // Convert to target format with appropriate options
-    switch (outputFormat) {
-      case 'png':
-        pipeline = pipeline.png({
-          quality: qualitySetting,
-          compressionLevel: qualityPreset === 'lossless' ? 0 : 9,
-        });
-        break;
-
-      case 'jpg':
-      case 'jpeg':
-        pipeline = pipeline.jpeg({
-          quality: qualitySetting,
-          mozjpeg: qualityPreset !== 'lossless',
-        });
-        break;
-
-      case 'webp':
-        pipeline = pipeline.webp({
-          quality: qualitySetting,
-          lossless: qualityPreset === 'lossless',
-          effort: QUALITY_SETTINGS[qualityPreset].effort || 4,
-        });
-        break;
-
-      case 'avif':
-        pipeline = pipeline.avif({
-          quality: qualitySetting,
-          lossless: qualityPreset === 'lossless',
-          effort: QUALITY_SETTINGS[qualityPreset].effort || 4,
-        });
-        break;
-
-      case 'gif':
-        pipeline = pipeline.gif();
-        break;
-
-      case 'tiff':
-        pipeline = pipeline.tiff({
-          quality: qualitySetting,
-          compression: qualityPreset === 'lossless' ? 'none' : 'lzw',
-        });
-        break;
-
-      case 'bmp':
-        // Sharp doesn't support BMP output directly, convert via raw buffer
-        pipeline = pipeline.raw();
-        break;
-
-      default:
-        throw new Error(`Unsupported output format: ${outputFormat}`);
-    }
-
-    // Write output
-    await pipeline.toFile(outputPath);
-
-    // Get output file size
-    const outputStat = await stat(outputPath);
-
-    return {
-      success: true,
-      input: options.input,
-      output: outputPath,
-      inputFormat,
-      outputFormat,
-      inputSize: inputStat.size,
-      outputSize: outputStat.size,
-      compressionRatio: inputStat.size / outputStat.size,
-      duration: Date.now() - startTime,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      input: options.input,
-      output: outputPath,
-      inputFormat,
-      outputFormat,
-      inputSize: inputStat.size,
-      outputSize: 0,
-      error: error instanceof Error ? error.message : String(error),
-      duration: Date.now() - startTime,
-    };
-  }
-}
-
-/**
- * Get image metadata
- */
-export async function getImageMetadata(filePath: string): Promise<{
-  width: number;
-  height: number;
-  format: string;
-  channels: number;
-  size: number;
-}> {
-  const metadata = await sharp(filePath).metadata();
-  const fileStat = await stat(filePath);
-
-  return {
-    width: metadata.width || 0,
-    height: metadata.height || 0,
-    format: metadata.format || 'unknown',
-    channels: metadata.channels || 0,
-    size: fileStat.size,
-  };
-}
-
-/**
- * Create image from buffer (for PDF to image conversion)
- */
-export async function imageFromBuffer(
-  buffer: Buffer,
-  outputPath: string,
-  format: ImageFormat,
-  quality: ImageQuality = 'high'
-): Promise<void> {
-  const qualitySetting = QUALITY_SETTINGS[quality].quality;
-
-  let pipeline = sharp(buffer);
-
-  switch (format) {
-    case 'png':
-      pipeline = pipeline.png({ quality: qualitySetting });
-      break;
-    case 'jpg':
-    case 'jpeg':
-      pipeline = pipeline.jpeg({ quality: qualitySetting });
-      break;
-    case 'webp':
-      pipeline = pipeline.webp({ quality: qualitySetting });
-      break;
-    default:
-      pipeline = pipeline.png({ quality: qualitySetting });
-  }
-
-  await pipeline.toFile(outputPath);
-}
-
-/**
- * Extract first frame from GIF (for GIF to PNG/JPG)
- */
-export async function extractGifFrame(
-  inputPath: string,
-  outputPath: string,
-  format: ImageFormat = 'png',
-  quality: ImageQuality = 'high'
-): Promise<void> {
-  const qualitySetting = QUALITY_SETTINGS[quality].quality;
-
-  let pipeline = sharp(inputPath, { pages: 1 }); // Extract first page/frame
-
-  switch (format) {
-    case 'png':
-      pipeline = pipeline.png({ quality: qualitySetting });
-      break;
-    case 'jpg':
-    case 'jpeg':
-      pipeline = pipeline.jpeg({ quality: qualitySetting });
-      break;
-    case 'webp':
-      pipeline = pipeline.webp({ quality: qualitySetting });
-      break;
-    default:
-      pipeline = pipeline.png({ quality: qualitySetting });
-  }
-
-  await pipeline.toFile(outputPath);
-}
-
-/**
- * Optimize image without changing format
- */
-export async function optimizeImage(
-  inputPath: string,
-  outputPath: string,
-  quality: ImageQuality = 'web'
-): Promise<ConvertResult> {
-  const format = extname(inputPath).slice(1).toLowerCase() as ImageFormat;
-  return convertImage({
-    input: inputPath,
-    output: outputPath,
-    format,
-    quality,
-  });
-}

package/skills/convert/src/converters/index.ts

@@ -1,9 +0,0 @@
-/**
- * Converters module - export all conversion utilities
- */
-
-export { convertImage, getImageMetadata, optimizeImage, extractGifFrame, imageFromBuffer } from './image';
-export { extractPdfText, pdfToText, getPdfPageCount, getPdfMetadata, imagesToPdf, mergePdfs, splitPdfIntoChunks, extractPdfPages, parsePageRange } from './pdf';
-export { convertDocument, docxToHtml, docxToMarkdown, docxToText, htmlToMarkdown, markdownToHtml, htmlToPlainText } from './document';
-export { convertData, csvToJson, jsonToCsv, csvToExcel, excelToCsv, excelToJson, jsonToYaml, yamlToJson, parseCsv, parseTsv } from './data';
-export { convertWithAI, imageToMarkdownAI, imageToJsonAI, pdfToMarkdownAI, cleanTextAI } from './ai';

package/skills/convert/src/converters/pdf.ts

@@ -1,255 +0,0 @@
-/**
- * PDF conversion utilities
- */
-
-import { PDFDocument } from 'pdf-lib';
-import pdfParse from 'pdf-parse';
-import { readFile, writeFile, stat, mkdir } from 'fs/promises';
-import { extname, basename, dirname, join } from 'path';
-import type { ImageFormat, ImageQuality, ConvertOptions, ConvertResult } from '../types';
-import { QUALITY_SETTINGS, MAX_SINGLE_PASS_SIZE, DEFAULT_CHUNK_SIZE } from '../types';
-
-/**
- * Extract text from PDF
- */
-export async function extractPdfText(pdfPath: string): Promise<string> {
-  const buffer = await readFile(pdfPath);
-  const data = await pdfParse(buffer);
-  return data.text;
-}
-
-/**
- * Get PDF page count
- */
-export async function getPdfPageCount(pdfPath: string): Promise<number> {
-  const buffer = await readFile(pdfPath);
-  const pdfDoc = await PDFDocument.load(buffer);
-  return pdfDoc.getPageCount();
-}
-
-/**
- * Extract specific pages from PDF
- */
-export async function extractPdfPages(
-  pdfPath: string,
-  pages: number[]
-): Promise<Buffer> {
-  const buffer = await readFile(pdfPath);
-  const sourcePdf = await PDFDocument.load(buffer);
-  const newPdf = await PDFDocument.create();
-
-  for (const pageNum of pages) {
-    if (pageNum > 0 && pageNum <= sourcePdf.getPageCount()) {
-      const [copiedPage] = await newPdf.copyPages(sourcePdf, [pageNum - 1]);
-      newPdf.addPage(copiedPage);
-    }
-  }
-
-  return Buffer.from(await newPdf.save());
-}
-
-/**
- * Split PDF into chunks for processing
- */
-export async function splitPdfIntoChunks(
-  pdfPath: string,
-  pagesPerChunk: number = 10
-): Promise<Buffer[]> {
-  const buffer = await readFile(pdfPath);
-  const sourcePdf = await PDFDocument.load(buffer);
-  const totalPages = sourcePdf.getPageCount();
-  const chunks: Buffer[] = [];
-
-  for (let i = 0; i < totalPages; i += pagesPerChunk) {
-    const endPage = Math.min(i + pagesPerChunk, totalPages);
-    const chunkPdf = await PDFDocument.create();
-
-    for (let j = i; j < endPage; j++) {
-      const [copiedPage] = await chunkPdf.copyPages(sourcePdf, [j]);
-      chunkPdf.addPage(copiedPage);
-    }
-
-    chunks.push(Buffer.from(await chunkPdf.save()));
-  }
-
-  return chunks;
-}
-
-/**
- * Convert PDF to text
- */
-export async function pdfToText(options: ConvertOptions): Promise<ConvertResult> {
-  const startTime = Date.now();
-  const inputStat = await stat(options.input);
-
-  const outputPath = options.output || join(
-    dirname(options.input),
-    `${basename(options.input, extname(options.input))}.txt`
-  );
-
-  try {
-    const text = await extractPdfText(options.input);
-    await writeFile(outputPath, text);
-    const outputStat = await stat(outputPath);
-
-    return {
-      success: true,
-      input: options.input,
-      output: outputPath,
-      inputFormat: 'pdf',
-      outputFormat: 'txt',
-      inputSize: inputStat.size,
-      outputSize: outputStat.size,
-      duration: Date.now() - startTime,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      input: options.input,
-      output: outputPath,
-      inputFormat: 'pdf',
-      outputFormat: 'txt',
-      inputSize: inputStat.size,
-      outputSize: 0,
-      error: error instanceof Error ? error.message : String(error),
-      duration: Date.now() - startTime,
-    };
-  }
-}
-
-/**
- * Parse page range string (e.g., "1-5" or "1,3,5" or "1-3,5,7-10")
- */
-export function parsePageRange(pageSpec: string, totalPages: number): number[] {
-  const pages: Set<number> = new Set();
-  const parts = pageSpec.split(',');
-
-  for (const part of parts) {
-    const trimmed = part.trim();
-    if (trimmed.includes('-')) {
-      const [start, end] = trimmed.split('-').map((n) => parseInt(n.trim(), 10));
-      for (let i = start; i <= Math.min(end, totalPages); i++) {
-        if (i > 0) pages.add(i);
-      }
-    } else {
-      const num = parseInt(trimmed, 10);
-      if (num > 0 && num <= totalPages) pages.add(num);
-    }
-  }
-
-  return Array.from(pages).sort((a, b) => a - b);
-}
-
-/**
- * Merge multiple PDFs into one
- */
-export async function mergePdfs(pdfPaths: string[], outputPath: string): Promise<void> {
-  const mergedPdf = await PDFDocument.create();
-
-  for (const pdfPath of pdfPaths) {
-    const buffer = await readFile(pdfPath);
-    const sourcePdf = await PDFDocument.load(buffer);
-    const pages = await mergedPdf.copyPages(sourcePdf, sourcePdf.getPageIndices());
-    pages.forEach((page) => mergedPdf.addPage(page));
-  }
-
-  await writeFile(outputPath, await mergedPdf.save());
-}
-
-/**
- * Create PDF from images
- */
-export async function imagesToPdf(
-  imagePaths: string[],
-  outputPath: string
-): Promise<ConvertResult> {
-  const startTime = Date.now();
-  let totalInputSize = 0;
-
-  try {
-    const pdfDoc = await PDFDocument.create();
-
-    for (const imagePath of imagePaths) {
-      const imageBuffer = await readFile(imagePath);
-      const imgStat = await stat(imagePath);
-      totalInputSize += imgStat.size;
-
-      const ext = extname(imagePath).toLowerCase();
-      let image;
-
-      if (ext === '.jpg' || ext === '.jpeg') {
-        image = await pdfDoc.embedJpg(imageBuffer);
-      } else if (ext === '.png') {
-        image = await pdfDoc.embedPng(imageBuffer);
-      } else {
-        // For other formats, we'd need to convert first
-        // Skip unsupported formats
-        console.warn(`Skipping unsupported image format: ${ext}`);
-        continue;
-      }
-
-      // Create page with image dimensions
-      const page = pdfDoc.addPage([image.width, image.height]);
-      page.drawImage(image, {
-        x: 0,
-        y: 0,
-        width: image.width,
-        height: image.height,
-      });
-    }
-
-    const pdfBytes = await pdfDoc.save();
-    await writeFile(outputPath, pdfBytes);
-    const outputStat = await stat(outputPath);
-
-    return {
-      success: true,
-      input: imagePaths.join(', '),
-      output: outputPath,
-      inputFormat: 'image',
-      outputFormat: 'pdf',
-      inputSize: totalInputSize,
-      outputSize: outputStat.size,
-      pagesProcessed: imagePaths.length,
-      duration: Date.now() - startTime,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      input: imagePaths.join(', '),
-      output: outputPath,
-      inputFormat: 'image',
-      outputFormat: 'pdf',
-      inputSize: totalInputSize,
-      outputSize: 0,
-      error: error instanceof Error ? error.message : String(error),
-      duration: Date.now() - startTime,
-    };
-  }
-}
-
-/**
- * Get PDF metadata
- */
-export async function getPdfMetadata(pdfPath: string): Promise<{
-  pageCount: number;
-  author?: string;
-  title?: string;
-  creator?: string;
-  producer?: string;
-  creationDate?: Date;
-  modificationDate?: Date;
-}> {
-  const buffer = await readFile(pdfPath);
-  const pdfDoc = await PDFDocument.load(buffer);
-
-  return {
-    pageCount: pdfDoc.getPageCount(),
-    author: pdfDoc.getAuthor(),
-    title: pdfDoc.getTitle(),
-    creator: pdfDoc.getCreator(),
-    producer: pdfDoc.getProducer(),
-    creationDate: pdfDoc.getCreationDate(),
-    modificationDate: pdfDoc.getModificationDate(),
-  };
-}