@hasna/skills 0.1.21 → 0.1.23

package/skills/{skill-generate-docx → skill-doc-generate}/src/index.ts

@@ -1,31 +1,92 @@
 #!/usr/bin/env bun
 
-import {
-  Document,
-  Packer,
-  Paragraph,
-  TextRun,
-  HeadingLevel,
-  Table,
-  TableRow,
-  TableCell,
-  WidthType,
-  AlignmentType,
-  BorderStyle,
-  PageNumber,
-  NumberFormat,
-  Header,
-  Footer,
-  TableOfContents,
-  ImageRun,
-  ExternalHyperlink,
-  PageBreak,
-} from "docx";
 import * as fs from "fs";
 import * as path from "path";
-import minimist from "minimist";
-import { marked } from "marked";
-import OpenAI from "openai";
+
+let Document: any;
+let Packer: any;
+let Paragraph: any;
+let TextRun: any;
+let HeadingLevel: any;
+let Table: any;
+let TableRow: any;
+let TableCell: any;
+let WidthType: any;
+let AlignmentType: any;
+let BorderStyle: any;
+let PageNumber: any;
+let NumberFormat: any;
+let Header: any;
+let Footer: any;
+let TableOfContents: any;
+let PageBreak: any;
+let marked: any;
+
+function printHelpAndExit(): never {
+  console.log(`
+Generate DOCX - Create Word documents from markdown or AI
+
+Usage:
+  skill-doc-generate <markdown-file> [options]
+  skill-doc-generate --topic "Topic" [options]
+  skill-doc-generate --prompt "Prompt" [options]
+
+Input Options:
+  <file>              Input markdown file
+  --topic <text>      Topic for AI to write about
+  --prompt <text>     Direct prompt for AI generation
+  --text <text>       Plain text content
+
+Output Options:
+  -o, --output <path> Output file path
+  --dir <path>        Output directory (default: .skills/exports)
+  --template <name>   Template: default, report, letter, memo, resume, article
+  --help, -h          Show this help
+`);
+  process.exit(0);
+}
+
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+  printHelpAndExit();
+}
+
+async function loadDocumentDeps(): Promise<void> {
+  if (Document && marked) return;
+  try {
+    const docx = await import("docx");
+    Document = docx.Document;
+    Packer = docx.Packer;
+    Paragraph = docx.Paragraph;
+    TextRun = docx.TextRun;
+    HeadingLevel = docx.HeadingLevel;
+    Table = docx.Table;
+    TableRow = docx.TableRow;
+    TableCell = docx.TableCell;
+    WidthType = docx.WidthType;
+    AlignmentType = docx.AlignmentType;
+    BorderStyle = docx.BorderStyle;
+    PageNumber = docx.PageNumber;
+    NumberFormat = docx.NumberFormat;
+    Header = docx.Header;
+    Footer = docx.Footer;
+    TableOfContents = docx.TableOfContents;
+    PageBreak = docx.PageBreak;
+    ({ marked } = await import("marked"));
+  } catch {
+    throw new Error("Missing document generation dependencies. Run bun install in this skill directory.");
+  }
+}
+
+async function createOpenAIClient(apiKey: string) {
+  try {
+    const { default: OpenAI } = await import("openai");
+    return new OpenAI({ apiKey });
+  } catch {
+    throw new Error("Missing dependency 'openai'. Run bun install in this skill directory.");
+  }
+}
+
+const minimist = (await import("minimist")).default;
 
 // Types
 interface DocOptions {
@@ -190,7 +251,7 @@ async function generateWithAI(topic: string, isPrompt: boolean = false): Promise
     throw new Error("OPENAI_API_KEY environment variable is required for AI generation");
   }
 
-  const openai = new OpenAI({ apiKey });
+  const openai = await createOpenAIClient(apiKey);
 
   const lengthGuide = {
     short: "Keep it concise, around 500 words total.",
@@ -377,8 +438,8 @@ function parseMarkdown(markdown: string): ParsedContent {
 }
 
 // Parse inline formatting
-function parseInlineFormatting(text: string): TextRun[] {
-  const runs: TextRun[] = [];
+function parseInlineFormatting(text: string): any[] {
+  const runs: any[] = [];
   let remaining = text;
 
   // Simple regex-based parsing for bold, italic, code
@@ -429,7 +490,7 @@ function getPageSize(size: string): { width: number; height: number } {
 }
 
 // Build document from parsed content
-function buildDocument(content: ParsedContent): Document {
+function buildDocument(content: ParsedContent): any {
   const pageSize = getPageSize(options.pageSize);
   const marginTwips = options.margins * 1440; // Convert inches to twips
 
@@ -698,6 +759,8 @@ async function main(): Promise<void> {
       process.exit(1);
     }
 
+    await loadDocumentDeps();
+
     // Parse content
     console.log("Parsing content...");
     const content = parseMarkdown(markdown);

package/skills/skill-doc-read/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: doc-read
+version: 0.1.0
+description: Read and extract text from DOCX files with section parsing, metadata extraction, and multiple file support
+category: Data & Analysis
+tags:
+  - docx
+  - documents
+  - extraction
+  - reader
+  - word
+---
+
+# Doc Read
+
+Read and extract content from DOCX files. Supports multiple files at once, preserves document structure (headings, paragraphs, lists, tables), and extracts metadata. Outputs plain text, JSON with structure, or markdown.
+
+## Features
+
+- **Multiple Files**: Process many DOCX files in a single command
+- **Structure Preservation**: Extracts headings, paragraphs, lists, and tables
+- **Metadata Extraction**: Get title, author, creation date, word count
+- **Parallel Processing**: Process multiple files concurrently
+- **Output Formats**: Plain text, JSON with document structure, or markdown
+
+## Usage
+
+```bash
+# Read a single DOCX file
+skill-doc-read read document.docx
+
+# Read multiple files
+skill-doc-read read file1.docx file2.docx file3.docx
+
+# Output as JSON with structure
+skill-doc-read read document.docx --format json --output result.json
+
+# Get metadata only
+skill-doc-read info document.docx
+```
+
+## Requirements
+
+- Bun runtime
+- mammoth (auto-installed)

package/skills/skill-doc-read/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@hasnaxyz/skill-doc-read",
+  "version": "0.1.0",
+  "description": "Read and extract text from DOCX files with section parsing and metadata extraction",
+  "type": "module",
+  "bin": {
+    "skill-doc-read": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "jszip": "^3.10.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src",
+    "tsconfig.json"
+  ]
+}

package/skills/skill-doc-read/src/index.ts

@@ -0,0 +1,324 @@
+#!/usr/bin/env bun
+
+import { readFile, writeFile, stat, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { basename, extname, dirname, resolve } from 'path';
+import { parseArgs } from 'util';
+
+async function loadJSZip() {
+  try {
+    return (await import('jszip')).default;
+  } catch {
+    throw new Error("Missing dependency 'jszip'. Run bun install in this skill directory.");
+  }
+}
+
+interface DocResult {
+  file: string;
+  text: string;
+  sections: DocSection[];
+  metadata: DocMetadata;
+  wordCount: number;
+}
+
+interface DocSection {
+  type: 'heading' | 'paragraph' | 'list' | 'table';
+  level?: number;
+  text: string;
+  items?: string[];
+  rows?: string[][];
+}
+
+interface DocMetadata {
+  title?: string;
+  author?: string;
+  lastModifiedBy?: string;
+  created?: string;
+  modified?: string;
+  description?: string;
+}
+
+async function extractDocxText(buffer: Buffer): Promise<{ text: string; sections: DocSection[] }> {
+  const JSZip = await loadJSZip();
+  const zip = await JSZip.loadAsync(buffer);
+
+  const documentXml = await zip.file('word/document.xml')?.async('string');
+  if (!documentXml) throw new Error('Invalid DOCX: missing word/document.xml');
+
+  const sections: DocSection[] = [];
+  let fullText = '';
+
+  const paragraphs = documentXml.match(/<w:p[\s>][\s\S]*?<\/w:p>/g) || [];
+
+  for (const para of paragraphs) {
+    const textParts = para.match(/<w:t[^>]*>([\s\S]*?)<\/w:t>/g) || [];
+    const text = textParts
+      .map(t => t.replace(/<w:t[^>]*>/, '').replace(/<\/w:t>/, ''))
+      .join('');
+
+    if (!text.trim()) continue;
+
+    const headingMatch = para.match(/<w:pStyle w:val="Heading(\d)"/);
+    if (headingMatch) {
+      const level = parseInt(headingMatch[1]);
+      sections.push({ type: 'heading', level, text: text.trim() });
+    } else if (para.includes('<w:numPr>')) {
+      const lastSection = sections[sections.length - 1];
+      if (lastSection?.type === 'list') {
+        lastSection.items!.push(text.trim());
+      } else {
+        sections.push({ type: 'list', text: text.trim(), items: [text.trim()] });
+      }
+    } else {
+      sections.push({ type: 'paragraph', text: text.trim() });
+    }
+
+    fullText += text.trim() + '\n';
+  }
+
+  const tables = documentXml.match(/<w:tbl>[\s\S]*?<\/w:tbl>/g) || [];
+  for (const table of tables) {
+    const rows: string[][] = [];
+    const tableRows = table.match(/<w:tr[\s>][\s\S]*?<\/w:tr>/g) || [];
+    for (const row of tableRows) {
+      const cells = row.match(/<w:tc[\s>][\s\S]*?<\/w:tc>/g) || [];
+      const rowData = cells.map(cell => {
+        const cellTexts = cell.match(/<w:t[^>]*>([\s\S]*?)<\/w:t>/g) || [];
+        return cellTexts.map(t => t.replace(/<w:t[^>]*>/, '').replace(/<\/w:t>/, '')).join(' ');
+      });
+      rows.push(rowData);
+    }
+    if (rows.length > 0) {
+      sections.push({ type: 'table', text: '', rows });
+    }
+  }
+
+  return { text: fullText, sections };
+}
+
+async function extractDocxMetadata(buffer: Buffer): Promise<DocMetadata> {
+  const JSZip = await loadJSZip();
+  const zip = await JSZip.loadAsync(buffer);
+
+  const coreXml = await zip.file('docProps/core.xml')?.async('string');
+  if (!coreXml) return {};
+
+  const getTag = (xml: string, tag: string): string | undefined => {
+    const match = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+    return match?.[1]?.trim() || undefined;
+  };
+
+  return {
+    title: getTag(coreXml, 'dc:title'),
+    author: getTag(coreXml, 'dc:creator'),
+    lastModifiedBy: getTag(coreXml, 'cp:lastModifiedBy'),
+    created: getTag(coreXml, 'dcterms:created'),
+    modified: getTag(coreXml, 'dcterms:modified'),
+    description: getTag(coreXml, 'dc:description'),
+  };
+}
+
+async function readSingleDocx(filePath: string): Promise<DocResult> {
+  const buffer = await readFile(filePath);
+  const { text, sections } = await extractDocxText(buffer);
+  const metadata = await extractDocxMetadata(buffer);
+  const wordCount = text.split(/\s+/).filter(w => w.length > 0).length;
+
+  return { file: filePath, text, sections, metadata, wordCount };
+}
+
+async function readMultipleDocx(files: string[], concurrency = 4): Promise<DocResult[]> {
+  const results: DocResult[] = [];
+  const queue = [...files];
+
+  async function processNext(): Promise<void> {
+    while (queue.length > 0) {
+      const file = queue.shift()!;
+      console.log(`Reading: ${basename(file)}`);
+      const result = await readSingleDocx(file);
+      results.push(result);
+      console.log(`  ${result.sections.length} sections, ${result.wordCount} words`);
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(concurrency, files.length) }, () => processNext());
+  await Promise.all(workers);
+
+  return results;
+}
+
+function formatText(results: DocResult[]): string {
+  return results.map(r => {
+    const header = `=== ${basename(r.file)} (${r.wordCount} words) ===\n`;
+    return header + r.text;
+  }).join('\n\n');
+}
+
+function formatJson(results: DocResult[]): string {
+  return JSON.stringify(results.map(r => ({
+    file: basename(r.file),
+    wordCount: r.wordCount,
+    metadata: r.metadata,
+    sections: r.sections,
+  })), null, 2);
+}
+
+function formatMarkdown(results: DocResult[]): string {
+  return results.map(r => {
+    const lines: string[] = [];
+    lines.push(`# ${basename(r.file)}`);
+    lines.push('');
+    if (r.metadata.title) lines.push(`**Title:** ${r.metadata.title}`);
+    if (r.metadata.author) lines.push(`**Author:** ${r.metadata.author}`);
+    lines.push(`**Words:** ${r.wordCount}`);
+    lines.push('');
+
+    for (const section of r.sections) {
+      switch (section.type) {
+        case 'heading':
+          lines.push(`${'#'.repeat((section.level || 1) + 1)} ${section.text}`);
+          lines.push('');
+          break;
+        case 'paragraph':
+          lines.push(section.text);
+          lines.push('');
+          break;
+        case 'list':
+          for (const item of section.items || []) {
+            lines.push(`- ${item}`);
+          }
+          lines.push('');
+          break;
+        case 'table':
+          if (section.rows && section.rows.length > 0) {
+            lines.push('| ' + section.rows[0].join(' | ') + ' |');
+            lines.push('| ' + section.rows[0].map(() => '---').join(' | ') + ' |');
+            for (const row of section.rows.slice(1)) {
+              lines.push('| ' + row.join(' | ') + ' |');
+            }
+            lines.push('');
+          }
+          break;
+      }
+    }
+    return lines.join('\n');
+  }).join('\n---\n\n');
+}
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      format: { type: 'string', default: 'text' },
+      output: { type: 'string', short: 'o' },
+      concurrency: { type: 'string', default: '4' },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+  });
+
+  const command = positionals[0];
+  const files = positionals.slice(1);
+
+  if (values.help || !command) {
+    console.log(`
+Doc Read - Extract text from DOCX files
+
+Usage:
+  skill-doc-read read <files...> [options]
+  skill-doc-read info <files...>
+
+Commands:
+  read          Extract text and structure from DOCX files
+  info          Show document metadata
+
+Read Options:
+  --format <fmt>       Output format: text, json, markdown (default: text)
+  --output, -o <path>  Write output to file
+  --concurrency <n>    Parallel file processing (default: 4)
+
+Examples:
+  skill-doc-read read document.docx
+  skill-doc-read read *.docx --format json --output extracted.json
+  skill-doc-read read report.docx --format markdown
+  skill-doc-read info document.docx
+`);
+    process.exit(0);
+  }
+
+  if (files.length === 0) {
+    console.error('Error: At least one DOCX file is required');
+    process.exit(1);
+  }
+
+  for (const file of files) {
+    if (!existsSync(file)) {
+      console.error(`File not found: ${file}`);
+      process.exit(1);
+    }
+    const ext = extname(file).toLowerCase();
+    if (ext !== '.docx' && ext !== '.doc') {
+      console.error(`Not a DOCX file: ${file}`);
+      process.exit(1);
+    }
+  }
+
+  switch (command) {
+    case 'read': {
+      const concurrency = parseInt(values.concurrency as string) || 4;
+
+      console.log(`\nReading ${files.length} DOCX file(s)...\n`);
+
+      const results = await readMultipleDocx(files, concurrency);
+
+      let output: string;
+      switch (values.format) {
+        case 'json': output = formatJson(results); break;
+        case 'markdown': case 'md': output = formatMarkdown(results); break;
+        default: output = formatText(results); break;
+      }
+
+      if (values.output) {
+        const outputPath = resolve(values.output as string);
+        await mkdir(dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, output);
+        console.log(`\nOutput saved to: ${outputPath}`);
+      } else {
+        console.log('\n' + output);
+      }
+
+      const totalWords = results.reduce((s, r) => s + r.wordCount, 0);
+      console.log(`\nProcessed: ${files.length} files, ${totalWords.toLocaleString()} words`);
+      break;
+    }
+
+    case 'info': {
+      for (const file of files) {
+        const buffer = await readFile(file);
+        const metadata = await extractDocxMetadata(buffer);
+        const { text } = await extractDocxText(buffer);
+        const wordCount = text.split(/\s+/).filter(w => w.length > 0).length;
+        const fileStats = await stat(file);
+
+        console.log(`\n${basename(file)}:`);
+        console.log(`  Size: ${(fileStats.size / 1024).toFixed(1)} KB`);
+        console.log(`  Words: ${wordCount.toLocaleString()}`);
+        if (metadata.title) console.log(`  Title: ${metadata.title}`);
+        if (metadata.author) console.log(`  Author: ${metadata.author}`);
+        if (metadata.lastModifiedBy) console.log(`  Last Modified By: ${metadata.lastModifiedBy}`);
+        if (metadata.created) console.log(`  Created: ${metadata.created}`);
+        if (metadata.modified) console.log(`  Modified: ${metadata.modified}`);
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/skills/skill-doc-read/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/skills/skill-domainpurchase/package.json

@@ -16,10 +16,6 @@
     "src",
     "tsconfig.json"
   ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/hasnaxyz/skill-domainpurchase.git"
-  },
   "homepage": "https://github.com/hasnaxyz/skill-domainpurchase#readme",
   "bugs": {
     "url": "https://github.com/hasnaxyz/skill-domainpurchase/issues"
@@ -35,7 +31,5 @@
   "devDependencies": {
     "@types/bun": "^1.1.14",
     "typescript": "^5.7.2"
-  },
-  "author": "Hasna <dev@hasna.com>",
-  "license": "Apache-2.0"
+  }
 }

package/skills/skill-domainsearch/package.json

@@ -16,10 +16,6 @@
     "src",
     "tsconfig.json"
   ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/hasnaxyz/skill-domainsearch.git"
-  },
   "homepage": "https://github.com/hasnaxyz/skill-domainsearch#readme",
   "bugs": {
     "url": "https://github.com/hasnaxyz/skill-domainsearch/issues"
@@ -33,7 +29,5 @@
   "devDependencies": {
     "@types/bun": "^1.1.14",
     "typescript": "^5.7.2"
-  },
-  "author": "Hasna <dev@hasna.com>",
-  "license": "Apache-2.0"
+  }
 }

package/skills/skill-e2bswarm/package.json

@@ -45,12 +45,6 @@
     "ai-agent",
     "swarm"
   ],
-  "author": "hasnaxyz",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-e2bswarm.git"
-  },
   "homepage": "https://github.com/hasnaxyz/skill-e2bswarm#readme",
   "bugs": {
     "url": "https://github.com/hasnaxyz/skill-e2bswarm/issues"

package/skills/skill-educational-resource-finder/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-educational-resource-finder.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-email-campaign/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-email-campaign.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-emoji/package.json

@@ -22,7 +22,6 @@
     "emoji-pack"
   ],
   "author": "",
-  "license": "Apache-2.0",
   "devDependencies": {
     "@types/bun": "latest"
   },

package/skills/skill-exam-readiness-check/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-exam-readiness-check.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }