@hasna/skills 0.1.62 → 0.1.63

package/skills/split-pdf/src/index.ts

@@ -1,301 +0,0 @@
-#!/usr/bin/env bun
-
-import { PDFDocument } from "pdf-lib";
-import * as fs from "fs";
-import * as path from "path";
-import minimist from "minimist";
-
-// Types
-interface SplitOptions {
-  output: string;
-  pages: string;
-  chunkSize: number;
-  even: boolean;
-  odd: boolean;
-  first: number | null;
-  last: number | null;
-  reverse: boolean;
-  naming: string;
-  startNumber: number;
-  padDigits: number;
-}
-
-// Parse command line arguments
-const args = minimist(process.argv.slice(2), {
-  string: ["output", "pages", "naming"],
-  boolean: ["even", "odd", "reverse", "help"],
-  default: {
-    output: "./split/",
-    pages: "all",
-    "chunk-size": 1,
-    even: false,
-    odd: false,
-    reverse: false,
-    naming: "page-{n}",
-    "start-number": 1,
-    "pad-digits": 3,
-  },
-  alias: {
-    o: "output",
-    p: "pages",
-    h: "help",
-  },
-});
-
-// Show help
-if (args.help || args._.length === 0) {
-  console.log(`
-Split PDF - Split PDF files into pages or ranges
-
-Usage:
-  skills run split-pdf -- <file.pdf> [options]
-
-Options:
-  -o, --output <path>       Output directory or file (default: ./split/)
-  -p, --pages <range>       Pages to extract: "1-5", "1,3,5", "all" (default: all)
-  --chunk-size <n>          Pages per output file (default: 1)
-  --even                    Extract even pages only
-  --odd                     Extract odd pages only
-  --first <n>               Extract first N pages
-  --last <n>                Extract last N pages
-  --reverse                 Reverse page order
-  --naming <template>       Output naming: page-{n}, chunk-{n}, {original}-{n}
-  --start-number <n>        Starting number for output files (default: 1)
-  --pad-digits <n>          Zero-padding digits (default: 3)
-  -h, --help                Show this help message
-
-Examples:
-  skills run split-pdf -- document.pdf -o ./pages/
-  skills run split-pdf -- document.pdf --pages "1-10" -o extract.pdf
-  skills run split-pdf -- document.pdf --chunk-size 5 -o ./chunks/
-  skills run split-pdf -- document.pdf --even -o even-pages.pdf
-`);
-  process.exit(0);
-}
-
-// Get input file
-const inputFile = args._[0] as string;
-
-if (!inputFile) {
-  console.error("Error: No input PDF file specified");
-  process.exit(1);
-}
-
-if (!fs.existsSync(inputFile)) {
-  console.error(`Error: File not found: ${inputFile}`);
-  process.exit(1);
-}
-
-// Parse options
-const options: SplitOptions = {
-  output: args.output,
-  pages: args.pages,
-  chunkSize: parseInt(args["chunk-size"]) || 1,
-  even: args.even,
-  odd: args.odd,
-  first: args.first ? parseInt(args.first) : null,
-  last: args.last ? parseInt(args.last) : null,
-  reverse: args.reverse,
-  naming: args.naming,
-  startNumber: parseInt(args["start-number"]) || 1,
-  padDigits: parseInt(args["pad-digits"]) || 3,
-};
-
-// Parse page range into array of page indices (0-based)
-function parsePageRange(pageStr: string, totalPages: number): number[] {
-  if (pageStr === "all") {
-    return Array.from({ length: totalPages }, (_, i) => i);
-  }
-
-  const pages: Set<number> = new Set();
-  const parts = pageStr.split(",").map((p) => p.trim());
-
-  for (const part of parts) {
-    if (part.includes("-")) {
-      const [startStr, endStr] = part.split("-");
-      const start = startStr ? parseInt(startStr) : 1;
-      const end = endStr ? parseInt(endStr) : totalPages;
-      for (let i = start - 1; i < Math.min(end, totalPages); i++) {
-        if (i >= 0) pages.add(i);
-      }
-    } else {
-      const pageNum = parseInt(part) - 1;
-      if (pageNum >= 0 && pageNum < totalPages) {
-        pages.add(pageNum);
-      }
-    }
-  }
-
-  return Array.from(pages).sort((a, b) => a - b);
-}
-
-// Filter pages based on options
-function filterPages(
-  pages: number[],
-  totalPages: number,
-  options: SplitOptions
-): number[] {
-  let filtered = [...pages];
-
-  // Apply even/odd filter
-  if (options.even) {
-    filtered = filtered.filter((p) => (p + 1) % 2 === 0);
-  } else if (options.odd) {
-    filtered = filtered.filter((p) => (p + 1) % 2 === 1);
-  }
-
-  // Apply first/last
-  if (options.first !== null) {
-    filtered = filtered.slice(0, options.first);
-  } else if (options.last !== null) {
-    filtered = filtered.slice(-options.last);
-  }
-
-  // Apply reverse
-  if (options.reverse) {
-    filtered.reverse();
-  }
-
-  return filtered;
-}
-
-// Generate output filename
-function generateFilename(
-  template: string,
-  index: number,
-  totalPages: number,
-  originalName: string,
-  padDigits: number
-): string {
-  const paddedNum = String(index).padStart(padDigits, "0");
-  const date = new Date().toISOString().split("T")[0];
-
-  return (
-    template
-      .replace("{n}", paddedNum)
-      .replace("{original}", originalName)
-      .replace("{total}", String(totalPages))
-      .replace("{date}", date) + ".pdf"
-  );
-}
-
-// Split into chunks
-function chunkArray<T>(array: T[], size: number): T[][] {
-  const chunks: T[][] = [];
-  for (let i = 0; i < array.length; i += size) {
-    chunks.push(array.slice(i, i + size));
-  }
-  return chunks;
-}
-
-// Main split function
-async function splitPdf(): Promise<void> {
-  console.log(`\nLoading: ${inputFile}`);
-
-  // Load source PDF
-  const sourceBytes = fs.readFileSync(inputFile);
-  const sourcePdf = await PDFDocument.load(sourceBytes);
-  const totalPages = sourcePdf.getPageCount();
-
-  console.log(`Total pages: ${totalPages}`);
-
-  // Get and filter pages
-  let pageIndices = parsePageRange(options.pages, totalPages);
-  pageIndices = filterPages(pageIndices, totalPages, options);
-
-  if (pageIndices.length === 0) {
-    console.error("Error: No pages match the specified criteria");
-    process.exit(1);
-  }
-
-  console.log(`Selected pages: ${pageIndices.length}`);
-
-  // Determine output mode
-  const outputIsFile = options.output.toLowerCase().endsWith(".pdf");
-  const originalName = path.basename(inputFile, ".pdf");
-
-  // Create chunks
-  const chunks = chunkArray(pageIndices, options.chunkSize);
-  console.log(`Output files: ${chunks.length}\n`);
-
-  // Ensure output directory exists
-  if (!outputIsFile) {
-    if (!fs.existsSync(options.output)) {
-      fs.mkdirSync(options.output, { recursive: true });
-    }
-  } else if (chunks.length > 1) {
-    // Multiple chunks but output is a file - create directory instead
-    const outputDir = options.output.replace(".pdf", "");
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
-    options.output = outputDir;
-  }
-
-  const outputFiles: string[] = [];
-
-  // Process each chunk
-  for (let i = 0; i < chunks.length; i++) {
-    const chunk = chunks[i];
-    const fileNum = options.startNumber + i;
-
-    // Create new PDF for this chunk
-    const newPdf = await PDFDocument.create();
-    const copiedPages = await newPdf.copyPages(sourcePdf, chunk);
-
-    for (const page of copiedPages) {
-      newPdf.addPage(page);
-    }
-
-    // Set metadata
-    newPdf.setCreator("split-pdf skill");
-    newPdf.setProducer("pdf-lib");
-
-    // Generate output path
-    let outputPath: string;
-    if (outputIsFile && chunks.length === 1) {
-      outputPath = options.output;
-    } else {
-      const filename = generateFilename(
-        options.chunkSize > 1 ? options.naming.replace("page", "chunk") : options.naming,
-        fileNum,
-        totalPages,
-        originalName,
-        options.padDigits
-      );
-      outputPath = path.join(options.output, filename);
-    }
-
-    // Save
-    const outputBytes = await newPdf.save();
-    fs.writeFileSync(outputPath, outputBytes);
-    outputFiles.push(outputPath);
-
-    // Progress
-    const pageRange =
-      chunk.length === 1
-        ? `page ${chunk[0] + 1}`
-        : `pages ${chunk[0] + 1}-${chunk[chunk.length - 1] + 1}`;
-    console.log(`Created: ${path.basename(outputPath)} (${pageRange})`);
-  }
-
-  // Summary
-  console.log(`\n${"=".repeat(50)}`);
-  console.log(`Split complete!`);
-  console.log(`  - Input: ${inputFile} (${totalPages} pages)`);
-  console.log(`  - Output: ${outputFiles.length} file(s)`);
-  console.log(`  - Location: ${outputIsFile && chunks.length === 1 ? options.output : options.output + "/"}`);
-  console.log("=".repeat(50));
-}
-
-// Main execution
-async function main() {
-  try {
-    await splitPdf();
-  } catch (error: any) {
-    console.error(`Error: ${error.message}`);
-    process.exit(1);
-  }
-}
-
-main();

package/skills/split-pdf/tsconfig.json

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

package/skills/statistical-test-selector/CLAUDE.md

@@ -1,19 +0,0 @@
-# statistical-test-selector
-
-Statistical Test Selector skill.
-
-## Tech Stack
-
-- Runtime: Bun
-- Language: TypeScript
-- CLI: Commander.js
-
-## CLI
-
-```bash
-statistical-test-selector run
-```
-
-## Data Directory
-
-~/.skill/statistical-test-selector/

package/skills/statistical-test-selector/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "statistical-test-selector",
-  "version": "0.1.0",
-  "description": "Statistical Test Selector skill",
-  "type": "module",
-  "bin": {
-    "statistical-test-selector": "./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/statistical-test-selector/src/index.ts

@@ -1,75 +0,0 @@
-#!/usr/bin/env bun
-import { parseArgs } from "util";
-
-const { values } = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    independent: { type: "string" }, // categorical, continuous
-    dependent: { type: "string" },   // categorical, continuous
-    groups: { type: "string" },      // 1, 2, >2
-    paired: { type: "boolean" },     // true/false
-    parametric: { type: "boolean", default: true }, // true/false
-    help: { type: "boolean" },
-  },
-  allowPositionals: true,
-});
-
-if (values.help || !values.independent || !values.dependent) {
-  console.log(`
-Statistical Test Selector
-Usage: skills run statistical-test-selector --independent <type> --dependent <type> [options]
-
-Options:
-  --independent <type>   Type of independent variable (categorical, continuous)
-  --dependent <type>     Type of dependent variable (categorical, continuous)
-  --groups <n>           Number of groups/levels in independent variable (1, 2, >2)
-  --paired               Whether data is paired/matched (e.g., pre/post)
-  --parametric           Assume normal distribution (default: true)
-`);
-  process.exit(0);
-}
-
-const ind = values.independent;
-const dep = values.dependent;
-const groups = values.groups || "2";
-const paired = values.paired || false;
-const parametric = values.parametric;
-
-let recommendation = "Consult a statistician.";
-
-if (ind === "categorical" && dep === "continuous") {
-  if (groups === "2") {
-    if (paired) {
-      recommendation = parametric ? "Paired t-test" : "Wilcoxon signed-rank test";
-    } else {
-      recommendation = parametric ? "Independent samples t-test" : "Mann-Whitney U test";
-    }
-  } else if (groups === ">2") {
-    if (paired) {
-      recommendation = parametric ? "Repeated measures ANOVA" : "Friedman test";
-    } else {
-      recommendation = parametric ? "One-way ANOVA" : "Kruskal-Wallis H test";
-    }
-  }
-} else if (ind === "categorical" && dep === "categorical") {
-  if (paired) {
-    recommendation = "McNemar's test";
-  } else {
-    recommendation = "Chi-square test of independence (or Fisher's exact test for small samples)";
-  }
-} else if (ind === "continuous" && dep === "continuous") {
-  recommendation = parametric ? "Pearson correlation or Linear Regression" : "Spearman rank correlation";
-} else if (ind === "continuous" && dep === "categorical") {
-  recommendation = "Logistic Regression";
-}
-
-console.log(`
-Recommended Test: ${recommendation}
-
-Context:
-- Independent Variable: ${ind}
-- Dependent Variable: ${dep}
-- Groups: ${groups}
-- Paired: ${paired}
-- Parametric Assumption: ${parametric}
-`);

package/skills/statistical-test-selector/tsconfig.json

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

package/skills/test-suite-generator/SKILL.md

@@ -1,51 +0,0 @@
----
-name: test-suite-generator
-description: Generate API, unit, and browser test suite packages with runnable tests and coverage notes.
-kind: instruction
----
-
-# Test Suite Generator
-
-Generate a test package for SaaS apps from routes, specs, or user flows.
-
-## 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 |
-|--------|-------------|---------|
-| `spec` | Routes, specs, or user flows. Positional text also works. | required |
-| `framework` | Application framework. | generic SaaS app |
-| `runner` | Test runner style: `bun`, `vitest`, or `playwright`. | bun |
-| `include-browser` | Include browser flow tests. | false |
-
-## Deliverables
-
-- `tests/api.test.ts`
-- `tests/unit.test.ts`
-- `tests/browser.spec.ts`
-- `test-plan.md`
-- `coverage-notes.md`
-- `manifest.json`
-
-## Method
-
-1. Turn the natural-language spec into an explicit list of behaviours with their
-   expected outcomes before writing any test code.
-2. Cover the boundaries first — empty, maximum, malformed, unauthorized,
-   concurrent. Happy-path-only suites give false confidence.
-3. Write assertions against observable behaviour, not implementation detail, so
-   the suite survives refactoring.
-4. Keep tests independent and order-agnostic; shared mutable fixtures are the
-   most common source of flakiness.
-5. Match the project's existing framework and conventions — detect them from the
-   repo rather than imposing your own.
-6. Note explicitly what you did NOT cover and why, so the gaps are visible.

package/skills/test-suite-generator/package.json

@@ -1,10 +0,0 @@
-{
-  "name": "test-suite-generator",
-  "version": "0.1.0",
-  "private": true,
-  "description": "Generate runnable SaaS test suite artifacts",
-  "type": "module",
-  "skills": {
-    "kind": "instruction"
-  }
-}

package/skills/tmux-session/SKILL.md

@@ -1,109 +0,0 @@
----
-name: tmux-session
-description: Create and manage grouped tmux sessions where each session focuses on its own window and its own folder. Knows workspace layout, naming conventions, and both multi-project and multi-agent patterns.
-user_invocable: true
----
-
-# tmux-session
-
-Use this skill when you need to add a window and session to an existing group, or create a new group from scratch. These are grouped tmux sessions where every named session locks onto its own window so `tmux attach -t <name>` lands directly in the intended project or tool.
-
-## Workspace Layout
-
-```text
-~/workspace/          Linux hosts — always lowercase
-~/Workspace/          macOS hosts — always capital W
-
-[workspace]/
-└── [division]/
-    └── [area]/
-        └── [area][status]/
-            └── [prefix]-[name]/
-```
-
-Examples:
-
-```text
-workspace/hasna/opensource/opensourcedev/open-todos
-workspace/hasna/opensource/opensourcedev/open-conversations
-workspace/hasnaxyz/agent/agentdev/agent-claude
-workspace/hasnaxyz/service/servicedev/service-chat
-workspace/hasnastudio/hasnastudio-alumia/platform/platform-alumia
-workspace/hasnaxyz/internalapp/iapp-takumi
-```
-
-Local tools live under `~/local/local-[name]/`.
-
-## How grouped sessions work
-
-- A source session owns the windows.
-- Named sessions join that source session and lock onto one window index.
-- `tmux attach -t open-economy` should land in the `open-economy` window without manual switching.
-
-## When to open a session
-
-| Work type | Source session | Session/window naming |
-|-----------|----------------|-----------------------|
-| Multiple OSS repos | `opensourcemaintain` | `open-[name]` |
-| Multiple agent repos | `agentdev` | `agent-[name]` |
-| Multiple local tools | `local` | `local-[name]` |
-| Multiple workers on one project | project name | `[project]-01`, `[project]-02`, ... |
-
-Rule: tmux groups live at the area/team level, not the individual repo level.
-
-## Add a window to an existing group
-
-```bash
-SOURCE="opensourcemaintain"
-NAME="open-economy"
-DIR="$HOME/workspace/hasna/opensource/opensourcedev/open-economy"
-
-tmux new-window -t "$SOURCE" -n "$NAME" -c "$DIR"
-IDX=$(tmux list-windows -t "$SOURCE" -F "#{window_index}:#{window_name}" | grep ":${NAME}$" | cut -d: -f1)
-tmux new-session -d -s "$NAME" -t "$SOURCE"
-tmux select-window -t "${NAME}:${IDX}"
-```
-
-## Create a new group
-
-```bash
-SOURCE="opensourcemaintain"
-BASE="$HOME/workspace/hasna/opensource/opensourcedev"
-
-WINDOWS=(
-  "open-todos:$BASE/open-todos"
-  "open-conversations:$BASE/open-conversations"
-  "open-mementos:$BASE/open-mementos"
-)
-
-tmux new-session -d -s "$SOURCE" -n "open-todos" -c "$BASE/open-todos"
-
-for entry in "${WINDOWS[@]:1}"; do
-  tmux new-window -t "$SOURCE" -n "$(echo "$entry" | cut -d: -f1)" -c "$(echo "$entry" | cut -d: -f2)"
-done
-
-for entry in "${WINDOWS[@]}"; do
-  name=$(echo "$entry" | cut -d: -f1)
-  idx=$(tmux list-windows -t "$SOURCE" -F "#{window_index}:#{window_name}" | grep ":${name}$" | cut -d: -f1)
-  tmux new-session -d -s "$name" -t "$SOURCE"
-  tmux select-window -t "${name}:${idx}"
-done
-```
-
-## Naming rules
-
-- OSS project: `open-[name]`
-- Agent repo: `agent-[name]`
-- Service repo: `service-[name]`
-- Local tool: `local-[name]`
-- Multi-agent on one project: `[project]-01..N`
-
-Always use the full prefixed name for both the window name and the session name.
-
-## Verification
-
-```bash
-tmux display-message -t open-economy -p "#{window_index}:#{window_name} @ #{pane_current_path}"
-tmux list-sessions | grep "(group opensourcemaintain)"
-tmux list-panes -a -F "#{session_name}:#{window_name} dead=#{pane_dead}" | grep "dead=1"
-```

package/skills/tmux-session/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "tmux-session",
-  "version": "0.1.0",
-  "description": "Instruction-set skill for creating grouped tmux sessions with repo-aware naming",
-  "type": "module",
-  "main": "src/index.ts",
-  "bin": {
-    "tmux-session": "src/index.ts"
-  },
-  "files": [
-    "src",
-    "SKILL.md",
-    "tsconfig.json"
-  ],
-  "publishConfig": {
-    "access": "restricted"
-  },
-  "keywords": [
-    "tmux",
-    "sessions",
-    "workspace",
-    "automation",
-    "skill"
-  ],
-  "scripts": {
-    "start": "bun run src/index.ts",
-    "typecheck": "tsc --noEmit"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.7.0"
-  }
-}

package/skills/tmux-session/src/index.ts

@@ -1,34 +0,0 @@
-#!/usr/bin/env bun
-
-const VERSION = "0.1.0";
-
-function printHelp(): void {
-  console.log(`tmux-session - Instruction-set skill
-
-DESCRIPTION:
-  Guides an agent through grouped tmux session setup with workspace-aware naming:
-    - create source sessions
-    - add windows for repos or local tools
-    - attach named sessions to the correct window index
-    - verify pane focus and dead sessions
-
-USAGE:
-  skills docs tmux-session
-  skills install tmux-session --for claude
-`);
-}
-
-const args = process.argv.slice(2);
-
-if (args.includes("--version") || args.includes("-v")) {
-  console.log(VERSION);
-  process.exit(0);
-}
-
-if (args.includes("--help") || args.includes("-h") || args.length === 0) {
-  printHelp();
-  process.exit(0);
-}
-
-console.log("This is an instruction-set skill. Install it for an agent with:");
-console.log("  skills install tmux-session --for claude");