@hasna/skills 0.1.62 → 0.1.64

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

@@ -1,266 +0,0 @@
-#!/usr/bin/env bun
-
-import { mkdir, writeFile } from "fs/promises";
-import { dirname, resolve } from "path";
-
-type XlsxModule = typeof import("xlsx");
-type WorkBook = import("xlsx").WorkBook;
-type WorkSheet = import("xlsx").WorkSheet;
-type CellObject = import("xlsx").CellObject;
-
-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[];
-}
-
-async function loadXlsx(): Promise<XlsxModule> {
-  try {
-    return await import("xlsx");
-  } catch {
-    throw new Error("Missing dependency 'xlsx'. Run bun install in this skill directory.");
-  }
-}
-
-function printHelp(): void {
-  console.log(`read-excel v${VERSION}
-
-USAGE:
-  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: 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 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(xlsx: XlsxModule, name: string, index: number, sheet: 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: 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 xlsx = await loadXlsx();
-  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(xlsx, 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(`read-excel: ${message}\n`);
-  process.exit(1);
-});

package/skills/read-excel/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/regex-tester/CLAUDE.md

@@ -1,19 +0,0 @@
-# regex-tester
-
-Regex Tester skill.
-
-## Tech Stack
-
-- Runtime: Bun
-- Language: TypeScript
-- CLI: Commander.js
-
-## CLI
-
-```bash
-regex-tester run
-```
-
-## Data Directory
-
-~/.skill/regex-tester/

package/skills/regex-tester/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "regex-tester",
-  "version": "0.1.0",
-  "description": "Regex Tester skill",
-  "type": "module",
-  "bin": {
-    "regex-tester": "./src/index.ts"
-  },
-  "scripts": {
-    "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.7.0"
-  },
-  "publishConfig": {
-    "access": "restricted",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "src",
-    "tsconfig.json"
-  ]
-}

package/skills/regex-tester/src/index.ts

@@ -1,183 +0,0 @@
-#!/usr/bin/env bun
-import { readFile } from "fs/promises";
-import { resolve, normalize, isAbsolute } from "path";
-
-// ============================================================================
-// Path Security
-// ============================================================================
-
-// Sensitive paths that should never be read
-const BLOCKED_PATHS = [
-  '/etc/passwd',
-  '/etc/shadow',
-  '/etc/hosts',
-  '/etc/sudoers',
-  '/etc/ssh',
-  '/root',
-  '/.ssh',
-  '/.aws',
-  '/.config',
-  '/.env',
-  '/proc',
-  '/sys',
-  '/dev',
-  '/var/log',
-  '/var/run',
-  '/tmp',
-  '/private/etc',
-  '/private/var',
-];
-
-// File patterns that should be blocked
-const BLOCKED_PATTERNS = [
-  /\.env($|\.)/i,               // .env, .env.local, .env.production
-  /\.pem$/i,                    // Private keys
-  /\.key$/i,                    // Private keys
-  /\.crt$/i,                    // Certificates
-  /id_rsa/i,                    // SSH keys
-  /id_ed25519/i,                // SSH keys
-  /\.secrets?/i,                // Secrets directories/files
-  /credentials/i,               // Credential files
-  /password/i,                  // Password files
-  /\.git\/config$/i,            // Git config with potential tokens
-  /\.npmrc$/i,                  // npm config with tokens
-  /\.pypirc$/i,                 // PyPI config with tokens
-  /kubeconfig/i,                // Kubernetes configs
-  /\.docker\/config\.json$/i,   // Docker configs with auth
-];
-
-function isPathBlocked(filePath: string): { blocked: boolean; reason?: string } {
-  const normalizedPath = normalize(filePath).toLowerCase();
-  const resolvedPath = isAbsolute(filePath) ? resolve(filePath) : resolve(process.cwd(), filePath);
-  const resolvedLower = resolvedPath.toLowerCase();
-
-  // Check for path traversal attempts
-  if (filePath.includes('..')) {
-    // Allow .. only if it doesn't escape the current working directory
-    const cwd = process.cwd();
-    if (!resolvedPath.startsWith(cwd)) {
-      return { blocked: true, reason: 'Path traversal outside working directory is not allowed' };
-    }
-  }
-
-  // Check against blocked paths
-  for (const blockedPath of BLOCKED_PATHS) {
-    if (resolvedLower.startsWith(blockedPath.toLowerCase()) ||
-        resolvedLower.includes(blockedPath.toLowerCase())) {
-      return { blocked: true, reason: `Access to ${blockedPath} is restricted for security reasons` };
-    }
-  }
-
-  // Check against blocked patterns
-  for (const pattern of BLOCKED_PATTERNS) {
-    if (pattern.test(normalizedPath) || pattern.test(resolvedPath)) {
-      return { blocked: true, reason: `Access to files matching ${pattern} is restricted for security reasons` };
-    }
-  }
-
-  return { blocked: false };
-}
-
-function validateFilePath(filePath: string, argName: string): string {
-  if (!filePath || filePath.trim() === '') {
-    throw new Error(`${argName} cannot be empty`);
-  }
-
-  // Check for null bytes (path traversal attack vector)
-  if (filePath.includes('\0')) {
-    throw new Error(`${argName} contains invalid characters`);
-  }
-
-  const blockCheck = isPathBlocked(filePath);
-  if (blockCheck.blocked) {
-    throw new Error(`Security: ${blockCheck.reason}`);
-  }
-
-  return filePath;
-}
-
-// ============================================================================
-// Main
-// ============================================================================
-
-function showHelp(): void {
-  console.log(`
-regex-tester - Test regular expressions against text
-
-Usage:
-  skills run regex-tester -- pattern=<regex> [text=<text>|file=<path>] [flags=<flags>]
-
-Options:
-  -h, --help               Show this help message
-  pattern=<regex>          Regular expression pattern to test
-  text=<text>              Text to test against (inline)
-  file=<path>              File containing text to test against
-  flags=<flags>            Regex flags (default: g for global)
-
-Output includes:
-  - Pattern and flags used
-  - Number of matches found
-  - Each match with captured groups and index
-
-Examples:
-  skills run regex-tester -- pattern="\\d+" text="There are 42 apples and 7 oranges"
-  skills run regex-tester -- pattern="(\\w+)@(\\w+\\.\\w+)" file=./emails.txt
-  skills run regex-tester -- pattern="hello" text="Hello World" flags=gi
-`);
-}
-
-const args = process.argv.slice(2);
-
-// Check for help flag
-if (args.includes("-h") || args.includes("--help")) {
-  showHelp();
-  process.exit(0);
-}
-const patternArg = args.find(a => a.startsWith("pattern="))?.split("=")[1];
-const textArg = args.find(a => a.startsWith("text="))?.split("=")[1];
-const fileArg = args.find(a => a.startsWith("file="))?.split("=")[1];
-const flagsArg = args.find(a => a.startsWith("flags="))?.split("=")[1] || "g";
-
-async function main() {
-  if (!patternArg || (!textArg && !fileArg)) {
-    console.log("Usage: skills run regex-tester -- pattern=... [text=...|file=...] [flags=...]");
-    process.exit(1);
-  }
-
-  try {
-    let content = "";
-    if (fileArg) {
-      // Validate file path before reading
-      const validatedPath = validateFilePath(fileArg, "file");
-      content = await readFile(validatedPath, "utf-8");
-    } else if (textArg) {
-      content = textArg;
-    }
-
-    const regex = new RegExp(patternArg, flagsArg);
-    const matches = [...content.matchAll(regex)];
-
-    console.log(`Pattern: /${patternArg}/${flagsArg}`);
-    console.log(`Matches found: ${matches.length}\n`);
-
-    matches.forEach((m, i) => {
-      console.log(`Match ${i + 1}: "${m[0]}"`);
-      if (m.length > 1) {
-        console.log(`  Groups: ${JSON.stringify(m.slice(1))}`);
-      }
-      console.log(`  Index: ${m.index}`);
-    });
-
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error);
-    // Check if it's a security error or regex error
-    if (message.startsWith("Security:") || message.includes("cannot be empty") || message.includes("invalid characters")) {
-      console.error(`Error: ${message}`);
-    } else {
-      console.error("Invalid Regex:", message);
-    }
-    process.exit(1);
-  }
-}
-
-main();

package/skills/regex-tester/tsconfig.json

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

package/skills/repo-onboarding-report/SKILL.md

@@ -1,52 +0,0 @@
----
-name: repo-onboarding-report
-description: Generate repository onboarding reports with architecture maps, setup guides, first-week plans, code inventory, risk register, and manifest metadata.
-kind: instruction
----
-
-# Repo Onboarding Report
-
-Generate a practical onboarding package for a software repository so a new engineer or agent can understand the codebase, setup path, architecture, risks, and first useful tasks quickly.
-
-## Requirements
-
-None. This is an instruction skill: it is prose an agent follows, so it needs no
-credentials, no network access, and no local runtime.
-
-## Usage
-
-Ask an agent for the deliverables below and give it the inputs. Reading this file
-IS the invocation; `skills run` refuses instruction skills on purpose.
-
-## Inputs
-
-| Input | Description | Default |
-|--------|-------------|---------|
-| `target` | Repository directory to inspect. | current directory |
-| `name` | Project name used in report titles. | package name or folder name |
-| `stack` | Stack or product context. | inferred from repository files |
-| `focus` | Comma-separated focus areas. | architecture,setup,testing,risks,first-week |
-
-## Deliverables
-
-- `repo-onboarding-report.md`
-- `architecture-map.md`
-- `setup-quickstart.md`
-- `first-week-plan.md`
-- `code-inventory.json`
-- `risk-register.json`
-- `manifest.json`
-
-## Method
-
-1. Explore before you explain. Read the entry points, the build config, the test
-   setup, and the largest modules; do not summarize the README back to the user.
-2. Draw the architecture as the flow of a real request or command through the
-   system, naming the files it passes through.
-3. Write setup as a verified sequence — every command you list must be one you
-   found evidence for in the repo.
-4. Build the code inventory around responsibility ("where auth lives"), not
-   directory listing.
-5. Record risks concretely: untested paths, stale dependencies, undocumented
-   env vars, single points of knowledge.
-6. Make the first-week plan a series of increasingly non-trivial real tasks.

package/skills/repo-onboarding-report/package.json

@@ -1,10 +0,0 @@
-{
-  "name": "repo-onboarding-report",
-  "version": "0.1.0",
-  "private": true,
-  "description": "Hosted premium repository onboarding report generator",
-  "type": "module",
-  "skills": {
-    "kind": "instruction"
-  }
-}