@hasna/skills 0.1.19 → 0.1.21

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

@@ -0,0 +1,264 @@
+#!/usr/bin/env bun
+
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, extname, resolve } from "path";
+
+const VERSION = "0.1.0";
+const DEFAULT_MODEL = process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514";
+const DEFAULT_PROMPT =
+  "Describe this image in detail. Extract any visible text, call out objects, layout, branding, and anything notable.";
+const API_URL = process.env.ANTHROPIC_API_URL || "https://api.anthropic.com/v1/messages";
+
+interface CliOptions {
+  input?: string;
+  prompt: string;
+  model: string;
+  maxTokens: number;
+  output?: string;
+  text: boolean;
+}
+
+interface ImageAnalysisResult {
+  input: string;
+  sourceType: "file" | "url";
+  model: string;
+  prompt: string;
+  analysis: string;
+  stopReason: string | null;
+  usage: unknown;
+}
+
+function printHelp(): void {
+  console.log(`skill-read-image v${VERSION}
+
+USAGE:
+  skill-read-image --input <path-or-url> [options]
+
+OPTIONS:
+  -i, --input <path-or-url>  Local image path or remote URL
+  -p, --prompt <text>        Extraction or analysis prompt
+  -m, --model <name>         Anthropic model to call
+      --max-tokens <n>       Maximum response tokens
+  -o, --output <path>        Save result to a file
+      --text                 Print only Claude's text response
+      --help                 Show this help message
+      --version              Show the current version
+`);
+}
+
+function parseArgs(argv: string[]): CliOptions {
+  const options: CliOptions = {
+    prompt: DEFAULT_PROMPT,
+    model: DEFAULT_MODEL,
+    maxTokens: 1200,
+    text: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        printHelp();
+        process.exit(0);
+      case "--version":
+      case "-v":
+        console.log(VERSION);
+        process.exit(0);
+      case "--input":
+      case "-i":
+        options.input = argv[++i];
+        break;
+      case "--prompt":
+      case "-p":
+        options.prompt = argv[++i] ?? DEFAULT_PROMPT;
+        break;
+      case "--model":
+      case "-m":
+        options.model = argv[++i] ?? DEFAULT_MODEL;
+        break;
+      case "--max-tokens": {
+        const value = Number.parseInt(argv[++i] ?? "", 10);
+        if (!Number.isFinite(value) || value <= 0) {
+          throw new Error(`Invalid --max-tokens value: ${argv[i]}`);
+        }
+        options.maxTokens = value;
+        break;
+      }
+      case "--output":
+      case "-o":
+        options.output = argv[++i];
+        break;
+      case "--text":
+        options.text = true;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown option: ${arg}`);
+        }
+        if (!options.input) {
+          options.input = arg;
+          break;
+        }
+        throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  if (!options.input) {
+    throw new Error("Missing required --input <path-or-url> argument");
+  }
+
+  return options;
+}
+
+function isUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function getImageMediaType(value: string): string {
+  const extension = extname(value).toLowerCase();
+  switch (extension) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".png":
+      return "image/png";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    default:
+      throw new Error(`Unsupported image format: ${extension || value}`);
+  }
+}
+
+async function buildImageBlock(input: string): Promise<{ block: Record<string, unknown>; sourceType: "file" | "url"; resolvedInput: string }> {
+  if (isUrl(input)) {
+    return {
+      block: {
+        type: "image",
+        source: {
+          type: "url",
+          url: input,
+        },
+      },
+      sourceType: "url",
+      resolvedInput: input,
+    };
+  }
+
+  const resolvedInput = resolve(input);
+  const mediaType = getImageMediaType(resolvedInput);
+  const bytes = await readFile(resolvedInput);
+  return {
+    block: {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: mediaType,
+        data: Buffer.from(bytes).toString("base64"),
+      },
+    },
+    sourceType: "file",
+    resolvedInput,
+  };
+}
+
+async function callAnthropic(
+  model: string,
+  maxTokens: number,
+  prompt: string,
+  imageBlock: Record<string, unknown>,
+): Promise<{ analysis: string; usage: unknown; stopReason: string | null }> {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error("Missing ANTHROPIC_API_KEY");
+  }
+
+  const response = await fetch(API_URL, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      messages: [
+        {
+          role: "user",
+          content: [
+            imageBlock,
+            {
+              type: "text",
+              text: prompt,
+            },
+          ],
+        },
+      ],
+    }),
+  });
+
+  const payload = await response.json() as {
+    content?: Array<{ type: string; text?: string }>;
+    usage?: unknown;
+    stop_reason?: string | null;
+    error?: { message?: string };
+  };
+
+  if (!response.ok) {
+    throw new Error(payload.error?.message || `Anthropic request failed with status ${response.status}`);
+  }
+
+  const analysis = (payload.content ?? [])
+    .filter((entry) => entry.type === "text" && typeof entry.text === "string")
+    .map((entry) => entry.text)
+    .join("\n\n");
+
+  return {
+    analysis,
+    usage: payload.usage ?? null,
+    stopReason: payload.stop_reason ?? null,
+  };
+}
+
+async function writeOutput(path: string, value: string): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, value, "utf8");
+}
+
+async function main(): Promise<void> {
+  const options = parseArgs(process.argv.slice(2));
+  const { block, sourceType, resolvedInput } = await buildImageBlock(options.input!);
+  const response = await callAnthropic(options.model, options.maxTokens, options.prompt, block);
+
+  const result: ImageAnalysisResult = {
+    input: resolvedInput,
+    sourceType,
+    model: options.model,
+    prompt: options.prompt,
+    analysis: response.analysis,
+    stopReason: response.stopReason,
+    usage: response.usage,
+  };
+
+  const output = options.text ? `${response.analysis}\n` : `${JSON.stringify(result, null, 2)}\n`;
+
+  if (options.output) {
+    await writeOutput(resolve(options.output), output);
+  } else {
+    process.stdout.write(output);
+  }
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`skill-read-image: ${message}\n`);
+  process.exit(1);
+});

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

@@ -0,0 +1,17 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "resolveJsonModule": true,
+    "noEmit": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

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

@@ -0,0 +1,52 @@
+---
+name: skill-read-pdf
+description: Analyze PDF files with Claude document blocks. Supports page-range selection, 20-page chunking, and merged structured output.
+---
+
+# Read PDF
+
+Analyze a PDF with Claude's native document support and return structured output for the requested pages.
+
+## Features
+
+- Supports page range selection like `1-5,8,10-12`
+- Chunks large selections into windows of up to 20 pages per request
+- Emits merged JSON, markdown, or plain-text output
+- Preserves chunk/page metadata so downstream tools can trace the source pages
+
+## Requirements
+
+- `ANTHROPIC_API_KEY` must be available in the environment
+
+## Usage
+
+```bash
+# Read the whole PDF with markdown output
+skill-read-pdf --input ./deck.pdf
+
+# Restrict to a few pages
+skill-read-pdf --input ./contract.pdf --pages 1-3,8 --format text
+
+# Ask for specific structure and save it
+skill-read-pdf \
+  --input ./invoice.pdf \
+  --prompt "Extract invoice metadata, every line item, and the payment terms." \
+  --format json \
+  --output ./invoice.json
+```
+
+## Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-i, --input <path-or-url>` | PDF file path or URL | required |
+| `--pages <ranges>` | Page ranges like `1-5,8,10-12` | all pages |
+| `-p, --prompt <text>` | What Claude should extract | text + tables + structure |
+| `-f, --format <value>` | `json`, `markdown`, or `text` | `markdown` |
+| `-m, --model <name>` | Anthropic model to call | `ANTHROPIC_MODEL` or built-in default |
+| `--chunk-size <n>` | Pages per request (max 20) | 20 |
+| `--max-tokens <n>` | Maximum response tokens per chunk | 1600 |
+| `-o, --output <path>` | Save result to a file | stdout |
+| `--text` | Emit only the merged extracted text | false |
+| `--help` | Show usage | |
+| `--version` | Show version | |

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

@@ -0,0 +1,37 @@
+{
+  "name": "@hasnaxyz/skill-read-pdf",
+  "version": "0.1.0",
+  "description": "Analyze PDFs with Claude document blocks and merge chunked output",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "skill-read-pdf": "src/index.ts"
+  },
+  "files": [
+    "src",
+    "SKILL.md",
+    "tsconfig.json"
+  ],
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "keywords": [
+    "pdf",
+    "claude",
+    "document",
+    "ocr",
+    "skill"
+  ],
+  "license": "Apache-2.0",
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "pdf-lib": "^1.17.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  }
+}