@hasna/skills 0.1.21 → 0.1.23

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

@@ -0,0 +1,29 @@
+{
+  "name": "@hasnaxyz/skill-pdf-read",
+  "version": "0.1.0",
+  "description": "Read and extract text from PDF files with page-range selection and parallel processing",
+  "type": "module",
+  "bin": {
+    "skill-pdf-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": {
+    "pdf-parse": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src",
+    "tsconfig.json"
+  ]
+}

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

@@ -0,0 +1,320 @@
+#!/usr/bin/env bun
+
+import { readFile, writeFile, stat, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { basename, extname, dirname, join, resolve } from 'path';
+import { parseArgs } from 'util';
+
+interface PageResult {
+  pageNumber: number;
+  text: string;
+}
+
+interface PdfResult {
+  file: string;
+  pageCount: number;
+  pages: PageResult[];
+  metadata?: {
+    title?: string;
+    author?: string;
+    creator?: string;
+    producer?: string;
+  };
+}
+
+interface ChunkResult {
+  chunkIndex: number;
+  startPage: number;
+  endPage: number;
+  text: string;
+}
+
+function parsePageRange(spec: string, totalPages: number): number[] {
+  const pages = new Set<number>();
+  for (const part of spec.split(',')) {
+    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);
+}
+
+async function loadPdfParse() {
+  try {
+    return (await import('pdf-parse')).default;
+  } catch {
+    console.error('pdf-parse not available. Install with: bun add pdf-parse');
+    process.exit(1);
+  }
+}
+
+async function getPdfPageCount(buffer: Buffer): Promise<number> {
+  const pdfParse = await loadPdfParse();
+  const data = await pdfParse(buffer, { max: 0 });
+  return data.numpages;
+}
+
+async function extractPdfText(buffer: Buffer, maxPages?: number): Promise<string> {
+  const pdfParse = await loadPdfParse();
+  const data = await pdfParse(buffer, maxPages ? { max: maxPages } : undefined);
+  return data.text;
+}
+
+async function extractPdfMetadata(buffer: Buffer): Promise<PdfResult['metadata']> {
+  const pdfParse = await loadPdfParse();
+  const data = await pdfParse(buffer, { max: 0 });
+  return {
+    title: data.info?.Title,
+    author: data.info?.Author,
+    creator: data.info?.Creator,
+    producer: data.info?.Producer,
+  };
+}
+
+async function readPdfChunked(
+  filePath: string,
+  chunkSize: number,
+  pageRange?: number[]
+): Promise<ChunkResult[]> {
+  const buffer = await readFile(filePath);
+  const totalPages = await getPdfPageCount(buffer);
+  const pages = pageRange || Array.from({ length: totalPages }, (_, i) => i + 1);
+
+  const chunks: ChunkResult[] = [];
+  for (let i = 0; i < pages.length; i += chunkSize) {
+    const chunkPages = pages.slice(i, i + chunkSize);
+    const startPage = chunkPages[0];
+    const endPage = chunkPages[chunkPages.length - 1];
+
+    const pdfParse = await loadPdfParse();
+    const data = await pdfParse(buffer, { max: endPage });
+    const text = data.text;
+
+    chunks.push({
+      chunkIndex: Math.floor(i / chunkSize),
+      startPage,
+      endPage,
+      text,
+    });
+  }
+
+  return chunks;
+}
+
+async function readSinglePdf(
+  filePath: string,
+  pageSpec?: string,
+  chunkSize?: number
+): Promise<PdfResult> {
+  const buffer = await readFile(filePath);
+  const totalPages = await getPdfPageCount(buffer);
+  const metadata = await extractPdfMetadata(buffer);
+
+  let pageRange: number[] | undefined;
+  if (pageSpec) {
+    pageRange = parsePageRange(pageSpec, totalPages);
+  }
+
+  if (chunkSize) {
+    const chunks = await readPdfChunked(filePath, chunkSize, pageRange);
+    const pages: PageResult[] = chunks.map(c => ({
+      pageNumber: c.startPage,
+      text: c.text,
+    }));
+    return { file: filePath, pageCount: totalPages, pages, metadata };
+  }
+
+  const maxPage = pageRange ? Math.max(...pageRange) : undefined;
+  const text = await extractPdfText(buffer, maxPage);
+
+  return {
+    file: filePath,
+    pageCount: totalPages,
+    pages: [{ pageNumber: 1, text }],
+    metadata,
+  };
+}
+
+async function readMultiplePdfs(
+  files: string[],
+  pageSpec?: string,
+  chunkSize?: number,
+  concurrency = 4
+): Promise<PdfResult[]> {
+  const results: PdfResult[] = [];
+  const queue = [...files];
+
+  async function processNext(): Promise<void> {
+    while (queue.length > 0) {
+      const file = queue.shift()!;
+      console.log(`Reading: ${basename(file)}`);
+      const result = await readSinglePdf(file, pageSpec, chunkSize);
+      results.push(result);
+      console.log(`  ${result.pageCount} pages, ${result.pages.reduce((s, p) => s + p.text.length, 0)} chars extracted`);
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(concurrency, files.length) }, () => processNext());
+  await Promise.all(workers);
+
+  return results;
+}
+
+function formatText(results: PdfResult[]): string {
+  return results.map(r => {
+    const header = `=== ${basename(r.file)} (${r.pageCount} pages) ===\n`;
+    const text = r.pages.map(p => p.text).join('\n\n---\n\n');
+    return header + text;
+  }).join('\n\n');
+}
+
+function formatJson(results: PdfResult[]): string {
+  return JSON.stringify(results, null, 2);
+}
+
+function formatMarkdown(results: PdfResult[]): 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(`**Pages:** ${r.pageCount}`);
+    lines.push('');
+    for (const page of r.pages) {
+      lines.push(`## Page ${page.pageNumber}`);
+      lines.push('');
+      lines.push(page.text);
+      lines.push('');
+    }
+    return lines.join('\n');
+  }).join('\n---\n\n');
+}
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      pages: { type: 'string' },
+      'chunk-size': { type: 'string' },
+      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(`
+PDF Read - Extract text from PDF files
+
+Usage:
+  skill-pdf-read read <files...> [options]
+  skill-pdf-read info <files...>
+
+Commands:
+  read          Extract text from PDFs
+  info          Show PDF metadata and page counts
+
+Read Options:
+  --pages <spec>       Page range (e.g., "1-5", "3,7,10-15")
+  --chunk-size <n>     Read in chunks of N pages (for large files)
+  --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-pdf-read read document.pdf
+  skill-pdf-read read report.pdf --pages 1-5 --format json
+  skill-pdf-read read *.pdf --chunk-size 10 --output extracted.txt
+  skill-pdf-read info document.pdf
+`);
+    process.exit(0);
+  }
+
+  if (files.length === 0) {
+    console.error('Error: At least one PDF file is required');
+    process.exit(1);
+  }
+
+  for (const file of files) {
+    if (!existsSync(file)) {
+      console.error(`File not found: ${file}`);
+      process.exit(1);
+    }
+    if (extname(file).toLowerCase() !== '.pdf') {
+      console.error(`Not a PDF file: ${file}`);
+      process.exit(1);
+    }
+  }
+
+  switch (command) {
+    case 'read': {
+      const chunkSize = values['chunk-size'] ? parseInt(values['chunk-size'] as string) : undefined;
+      const concurrency = parseInt(values.concurrency as string) || 4;
+
+      console.log(`\nReading ${files.length} PDF file(s)...\n`);
+
+      const results = await readMultiplePdfs(files, values.pages as string, chunkSize, 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 totalChars = results.reduce((s, r) => s + r.pages.reduce((ps, p) => ps + p.text.length, 0), 0);
+      const totalPages = results.reduce((s, r) => s + r.pageCount, 0);
+      console.log(`\nProcessed: ${files.length} files, ${totalPages} pages, ${totalChars.toLocaleString()} characters`);
+      break;
+    }
+
+    case 'info': {
+      for (const file of files) {
+        const buffer = await readFile(file);
+        const pageCount = await getPdfPageCount(buffer);
+        const metadata = await extractPdfMetadata(buffer);
+        const fileStats = await stat(file);
+
+        console.log(`\n${basename(file)}:`);
+        console.log(`  Pages: ${pageCount}`);
+        console.log(`  Size: ${(fileStats.size / 1024).toFixed(1)} KB`);
+        if (metadata?.title) console.log(`  Title: ${metadata.title}`);
+        if (metadata?.author) console.log(`  Author: ${metadata.author}`);
+        if (metadata?.creator) console.log(`  Creator: ${metadata.creator}`);
+        if (metadata?.producer) console.log(`  Producer: ${metadata.producer}`);
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

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

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

package/skills/skill-persona-based-adwriter/package.json

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

package/skills/skill-persona-generator/package.json

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

package/skills/skill-personal-daily-ops/package.json

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

package/skills/skill-pet-care-scheduler/package.json

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

package/skills/skill-podcast-show-notes/package.json

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

package/skills/skill-presentation-theme-maker/package.json

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

package/skills/skill-press-release-drafter/package.json

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

package/skills/skill-print-collateral-designer/package.json

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

package/skills/skill-procurement-scorecard/package.json

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

package/skills/skill-product-demo-script/package.json

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

package/skills/skill-product-mockup/package.json

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

package/skills/skill-project-retro-companion/package.json

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

package/skills/skill-proposal-redline-advisor/package.json

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

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

@@ -1,5 +1,5 @@
 ---
-name: skill-read-csv
+name: read-csv
 description: Parse CSV files into structured JSON with delimiter auto-detection, header handling, common encoding support, and streaming reads for large files.
 ---
 

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

@@ -22,7 +22,6 @@
     "cli",
     "skill"
   ],
-  "license": "Apache-2.0",
   "scripts": {
     "start": "bun run src/index.ts",
     "typecheck": "tsc --noEmit"

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

@@ -3,9 +3,6 @@
 import { createReadStream } from "fs";
 import { mkdir, open, readFile, writeFile } from "fs/promises";
 import { dirname, resolve } from "path";
-import { parse as createParser } from "csv-parse";
-import { parse as parseCsvSync } from "csv-parse/sync";
-import iconv from "iconv-lite";
 
 const VERSION = "0.1.0";
 const SAMPLE_BYTES = 128 * 1024;
@@ -32,6 +29,30 @@ interface CsvResult {
   rows: Array<Record<string, string | null>>;
 }
 
+async function loadCsvParse() {
+  try {
+    return (await import("csv-parse")).parse;
+  } catch {
+    throw new Error("Missing dependency 'csv-parse'. Run bun install in this skill directory.");
+  }
+}
+
+async function loadCsvParseSync() {
+  try {
+    return (await import("csv-parse/sync")).parse;
+  } catch {
+    throw new Error("Missing dependency 'csv-parse'. Run bun install in this skill directory.");
+  }
+}
+
+async function loadIconv() {
+  try {
+    return (await import("iconv-lite")).default;
+  } catch {
+    throw new Error("Missing dependency 'iconv-lite'. Run bun install in this skill directory.");
+  }
+}
+
 function printHelp(): void {
   console.log(`skill-read-csv v${VERSION}
 
@@ -195,7 +216,8 @@ function detectDelimiter(sampleText: string): string {
   return bestDelimiter;
 }
 
-function parseSampleRows(sampleText: string, delimiter: string): string[][] {
+async function parseSampleRows(sampleText: string, delimiter: string): Promise<string[][]> {
+  const parseCsvSync = await loadCsvParseSync();
   const records = parseCsvSync(sampleText, {
     delimiter,
     relax_column_count: true,
@@ -266,6 +288,8 @@ async function parseCsvFile(
   columns: string[],
   hasHeader: boolean,
 ): Promise<{ rows: Array<Record<string, string | null>>; truncated: boolean }> {
+  const iconv = await loadIconv();
+  const createParser = await loadCsvParse();
   const rows: Array<Record<string, string | null>> = [];
   let truncated = false;
   const stream = createReadStream(path, bomBytes > 0 ? { start: bomBytes } : undefined)
@@ -299,10 +323,11 @@ async function main(): Promise<void> {
   const options = parseArgs(process.argv.slice(2));
   const inputPath = resolve(options.input!);
   const sample = await readSample(inputPath);
+  const iconv = await loadIconv();
   const { encoding, bomBytes } = detectEncoding(sample, options.encoding.toLowerCase());
   const sampleText = iconv.decode(sample.subarray(bomBytes), encoding);
   const delimiter = normalizeDelimiter(options.delimiter) ?? detectDelimiter(sampleText);
-  const sampleRows = parseSampleRows(sampleText, delimiter);
+  const sampleRows = await parseSampleRows(sampleText, delimiter);
   const { hasHeader, columns } = buildColumns(sampleRows, options.headers);
   const { rows, truncated } = await parseCsvFile(inputPath, options, encoding, bomBytes, delimiter, columns, hasHeader);
 

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

@@ -1,5 +1,5 @@
 ---
-name: skill-read-excel
+name: read-excel
 description: Parse XLS and XLSX workbooks into structured JSON with sheet metadata, named ranges, and formatted cell snapshots.
 ---
 

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

@@ -22,7 +22,6 @@
     "spreadsheet",
     "skill"
   ],
-  "license": "Apache-2.0",
   "scripts": {
     "start": "bun run src/index.ts",
     "typecheck": "tsc --noEmit"