@hasna/skills 0.1.19 → 0.1.21

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

@@ -0,0 +1,64 @@
+---
+name: skill-read-excel
+description: Parse XLS and XLSX workbooks into structured JSON with sheet metadata, named ranges, and formatted cell snapshots.
+---
+
+# Read Excel
+
+Parse Excel workbooks from disk and return structured JSON for one or more sheets.
+
+## Features
+
+- Supports `.xls` and `.xlsx`
+- Reads multiple sheets in one run
+- Returns workbook metadata, named ranges, and per-sheet rows
+- Preserves sheet order and includes formatted cell snapshots
+- Allows limiting rows for large workbooks
+
+## Usage
+
+```bash
+# Parse all sheets
+skill-read-excel --input ./forecast.xlsx
+
+# Restrict to specific sheets
+skill-read-excel --input ./ops.xls --sheets Summary,Costs
+
+# Limit output and save it
+skill-read-excel --input ./audit.xlsx --limit 100 --output ./audit.json
+```
+
+## Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-i, --input <path>` | Excel workbook to parse | required |
+| `-s, --sheets <list>` | Comma-separated sheet names to include | all sheets |
+| `-l, --limit <n>` | Limit rows returned per sheet | unlimited |
+| `-o, --output <path>` | Save JSON result to a file | stdout |
+| `--help` | Show usage | |
+| `--version` | Show version | |
+
+## Output Shape
+
+```json
+{
+  "input": "/absolute/path/to/workbook.xlsx",
+  "workbook": {
+    "sheetNames": ["Summary", "Data"],
+    "namedRanges": []
+  },
+  "sheets": [
+    {
+      "name": "Summary",
+      "index": 0,
+      "rowCount": 12,
+      "columnCount": 4,
+      "columns": ["month", "revenue", "cost"],
+      "rows": [
+        { "month": "Jan", "revenue": 1000, "cost": 600 }
+      ]
+    }
+  ]
+}
+```

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

@@ -0,0 +1,37 @@
+{
+  "name": "@hasnaxyz/skill-read-excel",
+  "version": "0.1.0",
+  "description": "Parse XLS and XLSX workbooks into structured JSON",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "skill-read-excel": "src/index.ts"
+  },
+  "files": [
+    "src",
+    "SKILL.md",
+    "tsconfig.json"
+  ],
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "keywords": [
+    "excel",
+    "xlsx",
+    "xls",
+    "spreadsheet",
+    "skill"
+  ],
+  "license": "Apache-2.0",
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "xlsx": "^0.18.5"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  }
+}

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

@@ -0,0 +1,253 @@
+#!/usr/bin/env bun
+
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
+import * as XLSX from "xlsx";
+
+const VERSION = "0.1.0";
+
+interface CliOptions {
+  input?: string;
+  sheets?: string[];
+  limit?: number;
+  output?: string;
+}
+
+interface NamedRange {
+  name: string;
+  ref: string;
+  sheet?: string;
+}
+
+interface SheetResult {
+  name: string;
+  index: number;
+  range: string | null;
+  rowCount: number;
+  columnCount: number;
+  columns: string[];
+  rows: Array<Record<string, unknown>>;
+  formattedCells: Array<{ cell: string; raw?: unknown; formatted?: string; format?: string }>;
+}
+
+interface WorkbookResult {
+  input: string;
+  workbook: {
+    sheetNames: string[];
+    namedRanges: NamedRange[];
+  };
+  sheets: SheetResult[];
+}
+
+function printHelp(): void {
+  console.log(`skill-read-excel v${VERSION}
+
+USAGE:
+  skill-read-excel --input <path> [options]
+
+OPTIONS:
+  -i, --input <path>      Excel workbook to parse (.xls or .xlsx)
+  -s, --sheets <list>     Comma-separated sheet names to include
+  -l, --limit <n>         Limit rows returned per sheet
+  -o, --output <path>     Save JSON result to a file
+      --help              Show this help message
+      --version           Show the current version
+`);
+}
+
+function parseArgs(argv: string[]): CliOptions {
+  const options: CliOptions = {};
+
+  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 "--sheets":
+      case "-s":
+        options.sheets = (argv[++i] ?? "")
+          .split(",")
+          .map((value) => value.trim())
+          .filter(Boolean);
+        break;
+      case "--limit":
+      case "-l": {
+        const value = Number.parseInt(argv[++i] ?? "", 10);
+        if (!Number.isFinite(value) || value <= 0) {
+          throw new Error(`Invalid --limit value: ${argv[i]}`);
+        }
+        options.limit = value;
+        break;
+      }
+      case "--output":
+      case "-o":
+        options.output = argv[++i];
+        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> argument");
+  }
+
+  return options;
+}
+
+function normalizeColumnName(value: unknown, index: number, seen: Set<string>): string {
+  const text = String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "") || `column_${index + 1}`;
+
+  let next = text;
+  let suffix = 2;
+  while (seen.has(next)) {
+    next = `${text}_${suffix}`;
+    suffix += 1;
+  }
+  seen.add(next);
+  return next;
+}
+
+function inferHeader(rows: unknown[][]): boolean {
+  if (rows.length < 2) {
+    return false;
+  }
+  const first = rows[0];
+  const second = rows[1];
+  const unique = new Set(first.map((value) => String(value ?? "").trim().toLowerCase()).filter(Boolean));
+  const mostlyText = first.filter((value) => String(value ?? "").trim() !== "" && Number.isNaN(Number(value))).length >= Math.ceil(first.length / 2);
+  const secondHasNumeric = second.some((value) => String(value ?? "").trim() !== "" && !Number.isNaN(Number(value)));
+  return unique.size === first.length && mostlyText && secondHasNumeric;
+}
+
+function collectFormattedCells(sheet: XLSX.WorkSheet, maxCells = 50): Array<{ cell: string; raw?: unknown; formatted?: string; format?: string }> {
+  const result: Array<{ cell: string; raw?: unknown; formatted?: string; format?: string }> = [];
+  const entries = Object.entries(sheet).filter(([key]) => !key.startsWith("!"));
+
+  for (const [cell, value] of entries) {
+    if (result.length >= maxCells) {
+      break;
+    }
+    const cellValue = value as XLSX.CellObject;
+    if (cellValue.z || cellValue.w) {
+      result.push({
+        cell,
+        raw: cellValue.v,
+        formatted: cellValue.w,
+        format: typeof cellValue.z === "string" ? cellValue.z : undefined,
+      });
+    }
+  }
+
+  return result;
+}
+
+function parseSheet(name: string, index: number, sheet: XLSX.WorkSheet, limit?: number): SheetResult {
+  const rows = XLSX.utils.sheet_to_json(sheet, {
+    header: 1,
+    defval: null,
+    raw: false,
+    blankrows: false,
+  }) as unknown[][];
+
+  const trimmedRows = limit ? rows.slice(0, limit + 1) : rows;
+  const hasHeader = inferHeader(trimmedRows);
+  const headerRow = trimmedRows[0] ?? [];
+  const seen = new Set<string>();
+  const columns = (hasHeader ? headerRow : headerRow.map((_, colIndex) => `column_${colIndex + 1}`))
+    .map((value, colIndex) => normalizeColumnName(value, colIndex, seen));
+
+  const dataRows = hasHeader ? trimmedRows.slice(1) : trimmedRows;
+  const normalizedRows = dataRows.map((row) =>
+    columns.reduce<Record<string, unknown>>((record, column, colIndex) => {
+      record[column] = row[colIndex] ?? null;
+      return record;
+    }, {})
+  );
+
+  return {
+    name,
+    index,
+    range: sheet["!ref"] ?? null,
+    rowCount: normalizedRows.length,
+    columnCount: columns.length,
+    columns,
+    rows: normalizedRows,
+    formattedCells: collectFormattedCells(sheet),
+  };
+}
+
+function collectNamedRanges(workbook: XLSX.WorkBook): NamedRange[] {
+  const names = workbook.Workbook?.Names ?? [];
+  return names.map((entry) => ({
+    name: entry.Name ?? "",
+    ref: entry.Ref ?? "",
+    sheet: entry.Sheet != null ? workbook.SheetNames[entry.Sheet] : undefined,
+  }));
+}
+
+async function writeJson(path: string, payload: WorkbookResult): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+async function main(): Promise<void> {
+  const options = parseArgs(process.argv.slice(2));
+  const inputPath = resolve(options.input!);
+  const workbook = XLSX.readFile(inputPath, {
+    cellDates: true,
+    cellNF: true,
+    cellStyles: true,
+    dense: false,
+  });
+
+  const selectedSheetNames = options.sheets?.length
+    ? workbook.SheetNames.filter((name) => options.sheets!.includes(name))
+    : workbook.SheetNames;
+
+  if (selectedSheetNames.length === 0) {
+    throw new Error("No matching sheets found");
+  }
+
+  const result: WorkbookResult = {
+    input: inputPath,
+    workbook: {
+      sheetNames: workbook.SheetNames,
+      namedRanges: collectNamedRanges(workbook),
+    },
+    sheets: selectedSheetNames.map((name) => parseSheet(name, workbook.SheetNames.indexOf(name), workbook.Sheets[name], options.limit)),
+  };
+
+  if (options.output) {
+    await writeJson(resolve(options.output), result);
+  } else {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  }
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`skill-read-excel: ${message}\n`);
+  process.exit(1);
+});

package/skills/skill-read-excel/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-image/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: skill-read-image
+description: Analyze an image from a local path or URL with Claude vision. Supports prompt-controlled description, OCR, object counting, and brand/visual extraction.
+---
+
+# Read Image
+
+Analyze an image with Claude vision and return structured JSON containing the prompt, model, and extracted analysis.
+
+## Features
+
+- Supports local files and remote URLs
+- Accepts PNG, JPG, JPEG, GIF, and WEBP
+- Prompt-controlled output for OCR, object counting, branding, layout analysis, and more
+- Emits plain text or JSON
+
+## Requirements
+
+- `ANTHROPIC_API_KEY` must be available in the environment
+
+## Usage
+
+```bash
+# Describe a local image
+skill-read-image --input ./product-shot.jpg
+
+# OCR a receipt from a URL
+skill-read-image \
+  --input https://example.com/receipt.png \
+  --prompt "Extract every line item, subtotal, tax, and total."
+
+# Return plain text only
+skill-read-image --input ./wireframe.webp --text
+```
+
+## Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-i, --input <path-or-url>` | Local image path or image URL | required |
+| `-p, --prompt <text>` | What Claude should extract or describe | detailed description + OCR |
+| `-m, --model <name>` | Anthropic model to call | `ANTHROPIC_MODEL` or built-in default |
+| `--max-tokens <n>` | Maximum response tokens | 1200 |
+| `-o, --output <path>` | Save result to a file | stdout |
+| `--text` | Emit only Claude's text response | false |
+| `--help` | Show usage | |
+| `--version` | Show version | |

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

@@ -0,0 +1,34 @@
+{
+  "name": "@hasnaxyz/skill-read-image",
+  "version": "0.1.0",
+  "description": "Analyze local or remote images with Claude vision",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "skill-read-image": "src/index.ts"
+  },
+  "files": [
+    "src",
+    "SKILL.md",
+    "tsconfig.json"
+  ],
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "keywords": [
+    "image",
+    "vision",
+    "ocr",
+    "claude",
+    "skill"
+  ],
+  "license": "Apache-2.0",
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  }
+}