@hasna/skills 0.1.26 → 0.1.29

package/skills/doc-generate/src/markdown-parser.ts

@@ -0,0 +1,125 @@
+import type { ContentSection, DocOptions, ParsedContent } from "./types";
+
+export function parseMarkdown(markdown: string, options: DocOptions): ParsedContent {
+  const sections: ContentSection[] = [];
+  let title = options.title || "Document";
+
+  const lines = markdown.split("\n");
+  let i = 0;
+  let currentList: { items: string[]; ordered: boolean } | null = null;
+  let currentTable: string[][] | null = null;
+  let inCodeBlock = false;
+  let codeContent = "";
+  let codeLanguage = "";
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    if (line.startsWith("```")) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeLanguage = line.slice(3).trim();
+        codeContent = "";
+      } else {
+        inCodeBlock = false;
+        sections.push({ type: "code", text: codeContent.trim(), language: codeLanguage });
+      }
+      i++;
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeContent += line + "\n";
+      i++;
+      continue;
+    }
+
+    if (currentList && !line.match(/^[\s]*[-*+]\s/) && !line.match(/^[\s]*\d+\.\s/) && line.trim() !== "") {
+      sections.push({ type: "list", items: currentList.items, ordered: currentList.ordered });
+      currentList = null;
+    }
+
+    if (currentTable && !line.startsWith("|") && line.trim() !== "") {
+      sections.push({ type: "table", rows: currentTable });
+      currentTable = null;
+    }
+
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const text = headingMatch[2];
+      if (level === 1 && !options.title) {
+        title = text;
+      }
+      sections.push({ type: "heading", level, text });
+      i++;
+      continue;
+    }
+
+    if (line.match(/^[-*_]{3,}$/)) {
+      sections.push({ type: "hr" });
+      i++;
+      continue;
+    }
+
+    if (line.startsWith(">")) {
+      const quoteText = line.replace(/^>\s*/, "");
+      sections.push({ type: "quote", text: quoteText });
+      i++;
+      continue;
+    }
+
+    const ulMatch = line.match(/^[\s]*[-*+]\s+(.+)$/);
+    if (ulMatch) {
+      if (!currentList || currentList.ordered) {
+        if (currentList) {
+          sections.push({ type: "list", items: currentList.items, ordered: currentList.ordered });
+        }
+        currentList = { items: [], ordered: false };
+      }
+      currentList.items.push(ulMatch[1]);
+      i++;
+      continue;
+    }
+
+    const olMatch = line.match(/^[\s]*\d+\.\s+(.+)$/);
+    if (olMatch) {
+      if (!currentList || !currentList.ordered) {
+        if (currentList) {
+          sections.push({ type: "list", items: currentList.items, ordered: currentList.ordered });
+        }
+        currentList = { items: [], ordered: true };
+      }
+      currentList.items.push(olMatch[1]);
+      i++;
+      continue;
+    }
+
+    if (line.startsWith("|")) {
+      const cells = line.split("|").slice(1, -1).map((cell) => cell.trim());
+      if (!currentTable) {
+        currentTable = [];
+      }
+      if (!cells.every((cell) => cell.match(/^[-:]+$/))) {
+        currentTable.push(cells);
+      }
+      i++;
+      continue;
+    }
+
+    if (line.trim()) {
+      sections.push({ type: "paragraph", text: line });
+    }
+
+    i++;
+  }
+
+  if (currentList) {
+    sections.push({ type: "list", items: currentList.items, ordered: currentList.ordered });
+  }
+  if (currentTable) {
+    sections.push({ type: "table", rows: currentTable });
+  }
+
+  return { title, sections };
+}

package/skills/doc-generate/src/types.ts

@@ -0,0 +1,68 @@
+export interface DocOptions {
+  output: string;
+  dir: string;
+  template: "default" | "report" | "letter" | "memo" | "resume" | "article";
+  title: string;
+  author: string;
+  company: string;
+  date: string;
+  font: string;
+  fontSize: number;
+  headingFont: string;
+  lineSpacing: number;
+  margins: number;
+  pageSize: "letter" | "a4" | "legal";
+  toc: boolean;
+  pageNumbers: boolean;
+  header: string;
+  footer: string;
+  topic: string | null;
+  prompt: string | null;
+  text: string | null;
+  sections: number;
+  style: "professional" | "casual" | "formal" | "academic";
+  tone: "neutral" | "friendly" | "authoritative";
+  length: "short" | "medium" | "long" | "comprehensive";
+}
+
+export interface ParsedContent {
+  title: string;
+  sections: ContentSection[];
+}
+
+export interface ContentSection {
+  type: "heading" | "paragraph" | "list" | "table" | "quote" | "code" | "image" | "hr";
+  level?: number;
+  text?: string;
+  items?: string[];
+  rows?: string[][];
+  language?: string;
+  src?: string;
+  ordered?: boolean;
+}
+
+export interface CliResult {
+  options: DocOptions;
+  inputFile?: string;
+}
+
+export interface DocumentDeps {
+  Document: any;
+  Packer: any;
+  Paragraph: any;
+  TextRun: any;
+  HeadingLevel: any;
+  Table: any;
+  TableRow: any;
+  TableCell: any;
+  WidthType: any;
+  AlignmentType: any;
+  BorderStyle: any;
+  PageNumber: any;
+  NumberFormat: any;
+  Header: any;
+  Footer: any;
+  TableOfContents: any;
+  PageBreak: any;
+  marked: any;
+}

package/skills/domainpurchase/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: Domain Purchase
+name: domainpurchase
 description: Purchase and manage domains via GoDaddy API with CLI and HTTP server
 ---
 

package/skills/domainpurchase/package.json

@@ -9,7 +9,7 @@
     "access": "restricted"
   },
   "bin": {
-    "domainpurchase": "./bin/cli.ts"
+    "domainpurchase": "src/index.ts"
   },
   "files": [
     "bin",

package/skills/domainpurchase/src/index.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+
+console.log("Usage: skills run domainpurchase -- <command> [options]");

package/skills/domainsearch/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: Domain Search
+name: domainsearch
 description: Search domain availability and suggestions via GoDaddy API
 ---
 

package/skills/domainsearch/package.json

@@ -9,7 +9,7 @@
     "access": "restricted"
   },
   "bin": {
-    "domainsearch": "./bin/cli.ts"
+    "domainsearch": "src/index.ts"
   },
   "files": [
     "bin",

package/skills/domainsearch/src/index.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+
+console.log("Usage: skills run domainsearch -- <command> [options]");

package/skills/email-sequence/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: email-sequence
+description: Generate premium email campaigns with subject lines, preview text, body copy, segmentation notes, CTA variants, and HTML exports.
+---
+
+# Email Sequence
+
+Generate a 5 to 10 email campaign package for launch, nurture, onboarding, or reactivation.
+
+## Requirements
+
+- Authenticate with `skills auth login`.
+- This premium skill runs through the hosted Skills runtime; local installs expose only skill metadata and instructions.
+
+## Usage
+
+```bash
+skills run email-sequence "Usage-based billing for AI SaaS" --audience "founders" --goal "book demos"
+skills run email-sequence --campaign "API monitoring launch" --emails 7 --tone technical
+```
+
+## Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--campaign <text>` | Campaign, product, or offer brief. Positional text also works. | required |
+| `--audience <text>` | Target segment. | software teams |
+| `--goal <text>` | Conversion goal. | book demos |
+| `--emails <n>` | Number of emails, 5-10. | 5 |
+| `--tone <tone>` | `direct`, `premium`, `friendly`, or `technical`. | direct |
+| `--output <dir>` | Output directory for direct local execution. Hosted runs use the run export directory. | run export dir |
+
+## Outputs
+
+- `sequence.md`
+- `emails/email-XX.md`
+- `emails/email-XX.html`
+- `subject-lines.csv`
+- `segmentation-notes.md`
+- `cta-variants.csv`
+- `send-plan.csv`
+- `manifest.json`
+
+After submitting a hosted run, poll with `skills runs status <run-id>` and download outputs with `skills exports download <run-id>`.

package/skills/email-sequence/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "email-sequence",
+  "version": "0.1.0",
+  "description": "Hosted premium email sequence artifact generator",
+  "type": "module",
+  "bin": {
+    "email-sequence": "./src/index.ts"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  }
+}

package/skills/excel/CLAUDE.md

@@ -11,9 +11,9 @@ Generate Excel skill.
 ## CLI
 
 ```bash
-excel run
+skills run excel
 ```
 
 ## Data Directory
 
-~/.skill/excel/
+~/.hasna/skills/excel/

package/skills/experiment-power-calculator/package.json

@@ -11,7 +11,9 @@
     "build": "bun build src/index.ts --outdir dist --target node",
     "typecheck": "tsc --noEmit"
   },
-  "dependencies": {},
+  "dependencies": {
+    "mathjs": "^15.1.0"
+  },
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^5.7.0"

package/skills/extract-invoice/src/cli.ts

@@ -0,0 +1,97 @@
+import { existsSync, readdirSync } from "fs";
+import { extname, join, resolve } from "path";
+import { parseArgs } from "util";
+import { SUPPORTED_EXTENSIONS } from "./file-utils";
+import type { Options } from "./types";
+
+export function parseArguments(): Options {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      format: { type: "string", default: "json" },
+      confidence: { type: "boolean", default: false },
+      currency: { type: "string" },
+      language: { type: "string" },
+      pages: { type: "string" },
+      batch: { type: "boolean", default: false },
+      output: { type: "string" },
+      verbose: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const files: string[] = [];
+  for (const arg of positionals) {
+    if (arg.includes("*")) {
+      files.push(...expandGlob(arg));
+    } else {
+      files.push(resolve(process.cwd(), arg));
+    }
+  }
+
+  return {
+    files,
+    format: values.format as Options["format"],
+    confidence: values.confidence as boolean,
+    currency: values.currency as string,
+    language: values.language as string,
+    pages: values.pages as string,
+    batch: values.batch as boolean,
+    output: values.output as string,
+    verbose: values.verbose as boolean,
+  };
+}
+
+function expandGlob(pattern: string): string[] {
+  const dir = pattern.includes("/") ? pattern.substring(0, pattern.lastIndexOf("/")) : ".";
+  const filePattern = pattern.includes("/") ? pattern.substring(pattern.lastIndexOf("/") + 1) : pattern;
+  const regex = new RegExp("^" + filePattern.replace(/\*/g, ".*") + "$");
+
+  const resolvedDir = resolve(process.cwd(), dir);
+  if (!existsSync(resolvedDir)) {
+    return [];
+  }
+
+  return readdirSync(resolvedDir)
+    .filter((file) => regex.test(file))
+    .map((file) => join(resolvedDir, file))
+    .filter((file) => SUPPORTED_EXTENSIONS.includes(extname(file).toLowerCase()));
+}
+
+function printHelp(): void {
+  console.log(`
+Extract Invoice - AI-powered invoice data extraction
+
+Usage:
+  skills run extract-invoice -- <file(s)> [options]
+
+Arguments:
+  file(s)               Invoice file(s) to process (PDF, PNG, JPG, etc.)
+
+Options:
+  --format <format>     Output format: json, csv, excel, markdown (default: json)
+  --confidence          Include confidence scores for extracted fields
+  --currency <code>     Convert totals to specified currency (e.g., USD, EUR)
+  --language <lang>     Document language hint (e.g., en, es, fr)
+  --pages <range>       Pages to process (e.g., "1-3,5")
+  --batch               Process multiple files and combine output
+  --output <file>       Output file path
+  --verbose             Show detailed progress
+  --help, -h            Show this help
+
+Examples:
+  skills run extract-invoice -- invoice.pdf
+  skills run extract-invoice -- receipt.jpg --format csv
+  skills run extract-invoice -- ./invoices/*.pdf --batch
+  skills run extract-invoice -- invoice.pdf --confidence --verbose
+
+Supported file types:
+  PDF, PNG, JPG, JPEG, TIFF, HEIC, WebP
+`);
+}

package/skills/extract-invoice/src/extractor.ts

@@ -0,0 +1,170 @@
+import { basename } from "path";
+import { fileToBase64, getMimeType } from "./file-utils";
+import { OPENAI_API_URL, getOpenAIApiKey, log } from "./runtime";
+import type { InvoiceData, Options } from "./types";
+
+export async function extractInvoiceData(filePath: string, options: Options): Promise<InvoiceData> {
+  const openAIApiKey = getOpenAIApiKey();
+  if (!openAIApiKey) {
+    throw new Error("OPENAI_API_KEY environment variable is not set");
+  }
+
+  const base64Content = fileToBase64(filePath);
+  const mimeType = getMimeType(filePath);
+
+  if (options.verbose) {
+    log(`Processing ${basename(filePath)} (${mimeType})...`);
+  }
+
+  const response = await fetch(OPENAI_API_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${openAIApiKey}`,
+    },
+    body: JSON.stringify(buildRequestBody(base64Content, mimeType, options)),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI API error (${response.status}): ${error}`);
+  }
+
+  const result = await response.json();
+  const content = result.choices[0]?.message?.content;
+
+  if (!content) {
+    throw new Error("No response from OpenAI API");
+  }
+
+  try {
+    return JSON.parse(stripJsonFence(content));
+  } catch {
+    log(`Failed to parse API response: ${content}`, "error");
+    throw new Error("Failed to parse invoice data from API response");
+  }
+}
+
+function buildRequestBody(base64Content: string, mimeType: string, options: Options): Record<string, unknown> {
+  const systemPrompt = `You are an expert invoice data extraction system. Extract all relevant information from the provided invoice image/document and return it as structured JSON.
+
+Be thorough and extract:
+- Invoice details (number, dates, PO number, payment terms)
+- Vendor information (name, address, contact, tax ID)
+- Customer/Bill-to information
+- All line items with quantities, prices, and totals
+- Tax calculations
+- Discounts if any
+- Grand total and currency
+- Payment information (bank details, references)
+- Any notes or special instructions
+
+For amounts, extract numeric values without currency symbols.
+For dates, use ISO format (YYYY-MM-DD) when possible.
+Estimate your confidence in the extraction (0-100).
+
+${options.language ? `The document is in ${options.language}.` : "Detect the document language automatically."}
+${options.currency ? `Convert all amounts to ${options.currency} if possible.` : "Detect and preserve the original currency."}`;
+
+  const userPrompt = `Extract all invoice data from this document and return it as JSON matching this structure:
+{
+  "invoice_number": "string or null",
+  "invoice_date": "YYYY-MM-DD or null",
+  "due_date": "YYYY-MM-DD or null",
+  "po_number": "string or null",
+  "payment_terms": "string or null",
+  "vendor": {
+    "name": "string or null",
+    "address": "string or null",
+    "phone": "string or null",
+    "email": "string or null",
+    "tax_id": "string or null",
+    "website": "string or null"
+  },
+  "customer": {
+    "name": "string or null",
+    "address": "string or null",
+    "phone": "string or null",
+    "email": "string or null"
+  },
+  "line_items": [
+    {
+      "description": "string",
+      "quantity": number or null,
+      "unit": "string or null",
+      "unit_price": number or null,
+      "tax_rate": number or null,
+      "subtotal": number or null,
+      "discount": number or null
+    }
+  ],
+  "subtotal": number or null,
+  "tax": {
+    "rate": number or null,
+    "amount": number,
+    "type": "string or null"
+  },
+  "discount": {
+    "type": "percentage or fixed or null",
+    "value": number or null,
+    "amount": number
+  },
+  "shipping": number or null,
+  "total": number or null,
+  "currency": "USD, EUR, etc.",
+  "payment_info": {
+    "method": "string or null",
+    "bank_name": "string or null",
+    "account_number": "string or null (masked if sensitive)",
+    "routing_number": "string or null",
+    "iban": "string or null (masked)",
+    "swift": "string or null",
+    "reference": "string or null"
+  },
+  "notes": "string or null",
+  "confidence": number (0-100)
+}
+
+Return ONLY the JSON object, no markdown formatting or explanation.`;
+
+  return {
+    model: "gpt-4o",
+    messages: [
+      {
+        role: "system",
+        content: systemPrompt,
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: userPrompt,
+          },
+          {
+            type: "image_url",
+            image_url: {
+              url: `data:${mimeType};base64,${base64Content}`,
+              detail: "high",
+            },
+          },
+        ],
+      },
+    ],
+    max_tokens: 4096,
+    temperature: 0.1,
+  };
+}
+
+function stripJsonFence(content: string): string {
+  let jsonString = content.trim();
+  if (jsonString.startsWith("```json")) {
+    jsonString = jsonString.slice(7);
+  } else if (jsonString.startsWith("```")) {
+    jsonString = jsonString.slice(3);
+  }
+  if (jsonString.endsWith("```")) {
+    jsonString = jsonString.slice(0, -3);
+  }
+  return jsonString.trim();
+}

package/skills/extract-invoice/src/file-utils.ts

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from "fs";
+import { extname } from "path";
+import { log } from "./runtime";
+
+export const SUPPORTED_EXTENSIONS = [".pdf", ".png", ".jpg", ".jpeg", ".tiff", ".tif", ".heic", ".webp"];
+
+export function validateFiles(files: string[]): string[] {
+  const validFiles: string[] = [];
+
+  for (const file of files) {
+    if (!existsSync(file)) {
+      log(`File not found: ${file}`, "warn");
+      continue;
+    }
+
+    const ext = extname(file).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.includes(ext)) {
+      log(`Unsupported file type: ${file}`, "warn");
+      continue;
+    }
+
+    validFiles.push(file);
+  }
+
+  return validFiles;
+}
+
+export function fileToBase64(filePath: string): string {
+  const buffer = readFileSync(filePath);
+  return buffer.toString("base64");
+}
+
+export function getMimeType(filePath: string): string {
+  const ext = extname(filePath).toLowerCase();
+  const mimeTypes: Record<string, string> = {
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".tiff": "image/tiff",
+    ".tif": "image/tiff",
+    ".heic": "image/heic",
+    ".webp": "image/webp",
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+}