@hasna/skills 0.1.62 → 0.1.64

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

@@ -1,356 +0,0 @@
-#!/usr/bin/env bun
-
-import { createReadStream } from "fs";
-import { mkdir, open, readFile, writeFile } from "fs/promises";
-import { dirname, resolve } from "path";
-
-const VERSION = "0.1.0";
-const SAMPLE_BYTES = 128 * 1024;
-
-type HeaderMode = "auto" | "true" | "false";
-
-interface CliOptions {
-  input?: string;
-  delimiter?: string;
-  encoding: string;
-  headers: HeaderMode;
-  limit?: number;
-  output?: string;
-}
-
-interface CsvResult {
-  input: string;
-  encoding: string;
-  delimiter: string;
-  hasHeader: boolean;
-  columns: string[];
-  rowCount: number;
-  truncated: boolean;
-  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(`read-csv v${VERSION}
-
-USAGE:
-  read-csv --input <path> [options]
-
-OPTIONS:
-  -i, --input <path>        CSV file to parse
-  -d, --delimiter <value>   comma | tab | semicolon | pipe | literal character
-  -e, --encoding <value>    auto | utf8 | utf16le | utf16be | latin1 | win1252
-      --headers <mode>      auto | true | false
-  -l, --limit <n>           Stop after parsing n rows
-  -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 = {
-    encoding: "auto",
-    headers: "auto",
-  };
-
-  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 "--delimiter":
-      case "-d":
-        options.delimiter = argv[++i];
-        break;
-      case "--encoding":
-      case "-e":
-        options.encoding = argv[++i] ?? "auto";
-        break;
-      case "--headers": {
-        const value = (argv[++i] ?? "auto").toLowerCase();
-        if (value !== "auto" && value !== "true" && value !== "false") {
-          throw new Error(`Invalid --headers value: ${value}`);
-        }
-        options.headers = value;
-        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 normalizeDelimiter(input?: string): string | undefined {
-  if (!input) return undefined;
-  const value = input.toLowerCase();
-  switch (value) {
-    case "comma":
-      return ",";
-    case "tab":
-      return "\t";
-    case "semicolon":
-      return ";";
-    case "pipe":
-      return "|";
-    default:
-      return input;
-  }
-}
-
-async function readSample(path: string, byteCount = SAMPLE_BYTES): Promise<Buffer> {
-  const handle = await open(path, "r");
-  try {
-    const buffer = Buffer.alloc(byteCount);
-    const { bytesRead } = await handle.read(buffer, 0, byteCount, 0);
-    return buffer.subarray(0, bytesRead);
-  } finally {
-    await handle.close();
-  }
-}
-
-function detectEncoding(sample: Buffer, requested: string): { encoding: string; bomBytes: number } {
-  if (requested !== "auto") {
-    return { encoding: requested, bomBytes: 0 };
-  }
-
-  if (sample.length >= 3 && sample[0] === 0xef && sample[1] === 0xbb && sample[2] === 0xbf) {
-    return { encoding: "utf8", bomBytes: 3 };
-  }
-  if (sample.length >= 2 && sample[0] === 0xff && sample[1] === 0xfe) {
-    return { encoding: "utf16le", bomBytes: 2 };
-  }
-  if (sample.length >= 2 && sample[0] === 0xfe && sample[1] === 0xff) {
-    return { encoding: "utf16be", bomBytes: 2 };
-  }
-
-  return { encoding: "utf8", bomBytes: 0 };
-}
-
-function detectDelimiter(sampleText: string): string {
-  const candidates = [",", "\t", ";", "|"];
-  const lines = sampleText
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .slice(0, 8);
-
-  if (lines.length === 0) {
-    return ",";
-  }
-
-  let bestDelimiter = ",";
-  let bestScore = Number.NEGATIVE_INFINITY;
-
-  for (const delimiter of candidates) {
-    const counts = lines.map((line) => line.split(delimiter).length - 1);
-    const total = counts.reduce((sum, count) => sum + count, 0);
-    const variance = counts.reduce((sum, count) => sum + Math.abs(count - counts[0]), 0);
-    const score = total * 10 - variance;
-    if (score > bestScore) {
-      bestScore = score;
-      bestDelimiter = delimiter;
-    }
-  }
-
-  return bestDelimiter;
-}
-
-async function parseSampleRows(sampleText: string, delimiter: string): Promise<string[][]> {
-  const parseCsvSync = await loadCsvParseSync();
-  const records = parseCsvSync(sampleText, {
-    delimiter,
-    relax_column_count: true,
-    skip_empty_lines: true,
-    to_line: 5,
-  }) as string[][];
-  return records;
-}
-
-function looksNumeric(value: string): boolean {
-  return value.trim() !== "" && !Number.isNaN(Number(value));
-}
-
-function normalizeColumnName(value: string, index: number, seen: Set<string>): string {
-  const base = value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "_")
-    .replace(/^_+|_+$/g, "") || `column_${index + 1}`;
-
-  let next = base;
-  let suffix = 2;
-  while (seen.has(next)) {
-    next = `${base}_${suffix}`;
-    suffix += 1;
-  }
-  seen.add(next);
-  return next;
-}
-
-function inferHeader(sampleRows: string[][]): boolean {
-  if (sampleRows.length < 2) {
-    return false;
-  }
-
-  const first = sampleRows[0];
-  const second = sampleRows[1];
-  const unique = new Set(first.map((value) => value.trim().toLowerCase()).filter(Boolean));
-  const mostlyText = first.filter((value) => !looksNumeric(value)).length >= Math.ceil(first.length / 2);
-  const secondHasNumeric = second.some((value) => looksNumeric(value));
-
-  return unique.size === first.length && mostlyText && secondHasNumeric;
-}
-
-function buildColumns(sampleRows: string[][], headerMode: HeaderMode): { hasHeader: boolean; columns: string[] } {
-  const firstRow = sampleRows[0] ?? [];
-  const seen = new Set<string>();
-
-  if (headerMode === "true" || (headerMode === "auto" && inferHeader(sampleRows))) {
-    return {
-      hasHeader: true,
-      columns: firstRow.map((value, index) => normalizeColumnName(String(value), index, seen)),
-    };
-  }
-
-  return {
-    hasHeader: false,
-    columns: firstRow.map((_, index) => normalizeColumnName(`column_${index + 1}`, index, seen)),
-  };
-}
-
-async function parseCsvFile(
-  path: string,
-  options: CliOptions,
-  encoding: string,
-  bomBytes: number,
-  delimiter: string,
-  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)
-    .pipe(iconv.decodeStream(encoding))
-    .pipe(createParser({
-      delimiter,
-      columns: hasHeader ? true : columns,
-      relax_column_count: true,
-      skip_empty_lines: true,
-      trim: false,
-    }));
-
-  for await (const record of stream) {
-    rows.push(record as Record<string, string | null>);
-    if (options.limit && rows.length >= options.limit) {
-      truncated = true;
-      break;
-    }
-  }
-
-  stream.destroy();
-  return { rows, truncated };
-}
-
-async function writeJson(path: string, payload: CsvResult): 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 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 = await parseSampleRows(sampleText, delimiter);
-  const { hasHeader, columns } = buildColumns(sampleRows, options.headers);
-  const { rows, truncated } = await parseCsvFile(inputPath, options, encoding, bomBytes, delimiter, columns, hasHeader);
-
-  const result: CsvResult = {
-    input: inputPath,
-    encoding,
-    delimiter,
-    hasHeader,
-    columns,
-    rowCount: rows.length,
-    truncated,
-    rows,
-  };
-
-  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(`read-csv: ${message}\n`);
-  process.exit(1);
-});

package/skills/read-csv/tsconfig.json

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

package/skills/read-excel/SKILL.md

@@ -1,64 +0,0 @@
----
-name: 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
-read-excel --input ./forecast.xlsx
-
-# Restrict to specific sheets
-read-excel --input ./ops.xls --sheets Summary,Costs
-
-# Limit output and save it
-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/read-excel/package.json

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