@hasna/skills 0.1.62 → 0.1.64

package/skills/folder-tree/src/index.ts

@@ -1,568 +0,0 @@
-#!/usr/bin/env bun
-
-import * as fs from "fs";
-import * as path from "path";
-import { parseArgs } from "util";
-import ignore from "ignore";
-import { randomUUID } from "crypto";
-
-// Constants
-const SKILL_NAME = "folder-tree";
-const SESSION_ID = randomUUID().slice(0, 8);
-const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || path.join(process.cwd(), ".skills");
-const LOGS_DIR = path.join(SKILLS_OUTPUT_DIR, "logs", SKILL_NAME);
-const SESSION_TIMESTAMP = new Date().toISOString().replace(/[:.]/g, "_").slice(0, 19);
-
-// Ensure directories exist
-function ensureDir(dir: string) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-// Logger
-function log(message: string, level: "info" | "error" | "success" | "debug" = "info") {
-  ensureDir(LOGS_DIR);
-  const timestamp = new Date().toISOString();
-  const logFile = path.join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`);
-  const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-  fs.appendFileSync(logFile, logEntry);
-
-  const prefix = level === "error" ? "❌" : level === "success" ? "✅" : level === "debug" ? "🔍" : "ℹ️";
-  if (level === "error") {
-    console.error(`${prefix} ${message}`);
-  } else if (level !== "debug") {
-    console.log(`${prefix} ${message}`);
-  }
-}
-
-// Types
-interface TreeNode {
-  name: string;
-  path: string;
-  type: "file" | "directory";
-  size?: number;
-  modified?: string;
-  permissions?: string;
-  children?: TreeNode[];
-}
-
-interface TreeOptions {
-  format: "tree" | "json" | "markdown" | "csv";
-  output: string;
-  flat: boolean;
-  include: string[];
-  exclude: string[];
-  useGitignore: boolean;
-  hidden: boolean;
-  dirsOnly: boolean;
-  filesOnly: boolean;
-  depth: number;
-  maxFiles: number;
-  showSize: boolean;
-  showDate: boolean;
-  showPermissions: boolean;
-  showStats: boolean;
-  fullPath: boolean;
-  sort: "name" | "size" | "date" | "type";
-  reverse: boolean;
-  dirsFirst: boolean;
-}
-
-interface Stats {
-  directories: number;
-  files: number;
-  totalSize: number;
-  extensions: Record<string, number>;
-}
-
-// Parse command line arguments
-const { values, positionals } = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    format: { type: "string", default: "tree" },
-    output: { type: "string", short: "o" },
-    flat: { type: "boolean", default: false },
-    include: { type: "string" },
-    exclude: { type: "string" },
-    gitignore: { type: "boolean", default: true },
-    hidden: { type: "boolean", default: false },
-    "dirs-only": { type: "boolean", default: false },
-    "files-only": { type: "boolean", default: false },
-    depth: { type: "string" },
-    "max-files": { type: "string", default: "1000" },
-    size: { type: "boolean", default: false },
-    date: { type: "boolean", default: false },
-    permissions: { type: "boolean", default: false },
-    stats: { type: "boolean", default: false },
-    "full-path": { type: "boolean", default: false },
-    sort: { type: "string", default: "name" },
-    reverse: { type: "boolean", default: false },
-    "dirs-first": { type: "boolean", default: true },
-    help: { type: "boolean", short: "h" },
-  },
-  allowPositionals: true,
-});
-
-// Show help
-if (values.help) {
-  console.log(`
-Folder Tree - Generate directory structure visualization
-
-Usage:
-  skills run folder-tree -- <directory> [options]
-
-Format Options:
-  --format <type>       Output: tree, json, markdown, csv (default: tree)
-  -o, --output <path>   Output file path (default: stdout)
-  --flat                Flat list instead of tree (JSON/CSV)
-
-Filter Options:
-  --include <pattern>   Include glob pattern (comma-separated)
-  --exclude <pattern>   Exclude glob pattern (comma-separated)
-  --gitignore           Respect .gitignore (default: true)
-  --hidden              Include hidden files
-  --dirs-only           Show directories only
-  --files-only          Show files only
-
-Depth Options:
-  --depth <n>           Maximum depth (default: unlimited)
-  --max-files <n>       Maximum files to show (default: 1000)
-
-Display Options:
-  --size                Show file sizes
-  --date                Show modification dates
-  --permissions         Show file permissions
-  --stats               Show summary statistics
-  --full-path           Show full paths
-
-Sorting Options:
-  --sort <by>           Sort: name, size, date, type (default: name)
-  --reverse             Reverse sort order
-  --dirs-first          Directories before files (default: true)
-
-Examples:
-  skills run folder-tree -- ./my-project
-  skills run folder-tree -- ./src --format json -o structure.json
-  skills run folder-tree -- . --format markdown --depth 3
-  skills run folder-tree -- . --format csv --size --date
-`);
-  process.exit(0);
-}
-
-// Get input directory
-const inputDir = positionals[0] || ".";
-
-if (!fs.existsSync(inputDir)) {
-  log(`Error: Directory not found: ${inputDir}`, "error");
-  process.exit(1);
-}
-
-if (!fs.statSync(inputDir).isDirectory()) {
-  log(`Error: Not a directory: ${inputDir}`, "error");
-  process.exit(1);
-}
-
-// Build options
-const options: TreeOptions = {
-  format: values.format as TreeOptions["format"],
-  output: (values.output as string) || "",
-  flat: values.flat as boolean,
-  include: values.include ? (values.include as string).split(",").map((p: string) => p.trim()) : [],
-  exclude: values.exclude ? (values.exclude as string).split(",").map((p: string) => p.trim()) : [],
-  useGitignore: values.gitignore as boolean,
-  hidden: values.hidden as boolean,
-  dirsOnly: values["dirs-only"] as boolean,
-  filesOnly: values["files-only"] as boolean,
-  depth: values.depth ? parseInt(values.depth as string) : Infinity,
-  maxFiles: parseInt(values["max-files"] as string) || 1000,
-  showSize: values.size as boolean,
-  showDate: values.date as boolean,
-  showPermissions: values.permissions as boolean,
-  showStats: values.stats as boolean,
-  fullPath: values["full-path"] as boolean,
-  sort: values.sort as TreeOptions["sort"],
-  reverse: values.reverse as boolean,
-  dirsFirst: values["dirs-first"] as boolean,
-};
-
-// Load gitignore
-let gitignoreFilter: ReturnType<typeof ignore> | null = null;
-if (options.useGitignore) {
-  const gitignorePath = path.join(inputDir, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
-    gitignoreFilter = ignore().add(gitignoreContent);
-  }
-}
-
-// Statistics
-const stats: Stats = {
-  directories: 0,
-  files: 0,
-  totalSize: 0,
-  extensions: {},
-};
-
-let fileCount = 0;
-
-// Check if file matches patterns
-function matchesPattern(name: string, patterns: string[]): boolean {
-  if (patterns.length === 0) return true;
-  return patterns.some((pattern) => {
-    if (pattern.includes("*")) {
-      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
-      return regex.test(name);
-    }
-    return name === pattern || name.endsWith(pattern);
-  });
-}
-
-// Check if path should be excluded
-function shouldExclude(relativePath: string, name: string): boolean {
-  // Hidden files
-  if (!options.hidden && name.startsWith(".")) {
-    return true;
-  }
-
-  // Gitignore
-  if (gitignoreFilter && gitignoreFilter.ignores(relativePath)) {
-    return true;
-  }
-
-  // Exclude patterns
-  if (options.exclude.length > 0 && matchesPattern(name, options.exclude)) {
-    return true;
-  }
-
-  return false;
-}
-
-// Check if file should be included
-function shouldInclude(name: string, isDir: boolean): boolean {
-  if (options.dirsOnly && !isDir) return false;
-  if (options.filesOnly && isDir) return false;
-  if (options.include.length > 0 && !isDir && !matchesPattern(name, options.include)) {
-    return false;
-  }
-  return true;
-}
-
-// Get file info
-function getFileInfo(filePath: string): { size: number; modified: string; permissions: string } {
-  const stat = fs.statSync(filePath);
-  return {
-    size: stat.size,
-    modified: stat.mtime.toISOString().split("T")[0],
-    permissions: (stat.mode & 0o777).toString(8),
-  };
-}
-
-// Format file size
-function formatSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-
-// Sort nodes
-function sortNodes(nodes: TreeNode[]): TreeNode[] {
-  const sorted = [...nodes].sort((a, b) => {
-    // Dirs first
-    if (options.dirsFirst) {
-      if (a.type === "directory" && b.type === "file") return -1;
-      if (a.type === "file" && b.type === "directory") return 1;
-    }
-
-    // Sort by criteria
-    let comparison = 0;
-    switch (options.sort) {
-      case "size":
-        comparison = (a.size || 0) - (b.size || 0);
-        break;
-      case "date":
-        comparison = (a.modified || "").localeCompare(b.modified || "");
-        break;
-      case "type":
-        const extA = path.extname(a.name);
-        const extB = path.extname(b.name);
-        comparison = extA.localeCompare(extB);
-        break;
-      case "name":
-      default:
-        comparison = a.name.localeCompare(b.name);
-    }
-
-    return options.reverse ? -comparison : comparison;
-  });
-
-  return sorted;
-}
-
-// Build tree
-function buildTree(dirPath: string, relativePath: string = "", currentDepth: number = 0): TreeNode | null {
-  if (currentDepth > options.depth) return null;
-  if (fileCount >= options.maxFiles) return null;
-
-  const name = path.basename(dirPath) || dirPath;
-  const stat = fs.statSync(dirPath);
-  const isDir = stat.isDirectory();
-
-  // Check exclusions
-  if (relativePath && shouldExclude(relativePath, name)) {
-    return null;
-  }
-
-  // Check inclusions
-  if (!shouldInclude(name, isDir)) {
-    return null;
-  }
-
-  const node: TreeNode = {
-    name,
-    path: options.fullPath ? dirPath : relativePath || name,
-    type: isDir ? "directory" : "file",
-  };
-
-  if (options.showSize || options.sort === "size" || options.showStats) {
-    node.size = stat.size;
-  }
-  if (options.showDate || options.sort === "date") {
-    node.modified = stat.mtime.toISOString().split("T")[0];
-  }
-  if (options.showPermissions) {
-    node.permissions = (stat.mode & 0o777).toString(8);
-  }
-
-  if (isDir) {
-    stats.directories++;
-    const children: TreeNode[] = [];
-
-    try {
-      const entries = fs.readdirSync(dirPath);
-      for (const entry of entries) {
-        const entryPath = path.join(dirPath, entry);
-        const entryRelative = relativePath ? `${relativePath}/${entry}` : entry;
-        const childNode = buildTree(entryPath, entryRelative, currentDepth + 1);
-        if (childNode) {
-          children.push(childNode);
-        }
-      }
-    } catch (error) {
-      // Permission denied or other error
-    }
-
-    node.children = sortNodes(children);
-
-    // Calculate directory size
-    if (options.showSize || options.showStats) {
-      node.size = children.reduce((sum, child) => sum + (child.size || 0), 0);
-    }
-  } else {
-    stats.files++;
-    fileCount++;
-    stats.totalSize += stat.size;
-
-    const ext = path.extname(name) || "(no extension)";
-    stats.extensions[ext] = (stats.extensions[ext] || 0) + 1;
-  }
-
-  return node;
-}
-
-// Flatten tree
-function flattenTree(node: TreeNode, result: TreeNode[] = []): TreeNode[] {
-  if (node.type === "file" || !node.children) {
-    result.push({ ...node, children: undefined });
-  } else {
-    if (!options.filesOnly) {
-      result.push({ ...node, children: undefined });
-    }
-    for (const child of node.children) {
-      flattenTree(child, result);
-    }
-  }
-  return result;
-}
-
-// Format as ASCII tree
-function formatTree(node: TreeNode, prefix: string = "", isLast: boolean = true, isRoot: boolean = true): string {
-  let output = "";
-
-  if (isRoot) {
-    output += node.name + "/\n";
-  } else {
-    const connector = isLast ? "└── " : "├── ";
-    let line = prefix + connector + node.name;
-
-    if (node.type === "directory") {
-      line += "/";
-    }
-
-    // Add metadata
-    const meta: string[] = [];
-    if (options.showSize && node.size !== undefined) {
-      meta.push(formatSize(node.size));
-    }
-    if (options.showDate && node.modified) {
-      meta.push(node.modified);
-    }
-    if (options.showPermissions && node.permissions) {
-      meta.push(node.permissions);
-    }
-    if (meta.length > 0) {
-      line += "  (" + meta.join(", ") + ")";
-    }
-
-    output += line + "\n";
-  }
-
-  if (node.children) {
-    const newPrefix = isRoot ? "" : prefix + (isLast ? "    " : "│   ");
-    for (let i = 0; i < node.children.length; i++) {
-      const child = node.children[i];
-      const childIsLast = i === node.children.length - 1;
-      output += formatTree(child, newPrefix, childIsLast, false);
-    }
-  }
-
-  return output;
-}
-
-// Format as JSON
-function formatJson(node: TreeNode): string {
-  if (options.flat) {
-    const flattened = flattenTree(node);
-    return JSON.stringify(flattened, null, 2);
-  }
-  return JSON.stringify(node, null, 2);
-}
-
-// Format as Markdown
-function formatMarkdown(node: TreeNode, depth: number = 0): string {
-  let output = "";
-
-  if (depth === 0) {
-    output += `# Directory Structure\n\n`;
-    output += `## ${node.name}/\n\n`;
-  }
-
-  if (node.children) {
-    for (const child of node.children) {
-      const indent = "  ".repeat(depth);
-      if (child.type === "directory") {
-        output += `${indent}- **${child.name}/**\n`;
-        output += formatMarkdown(child, depth + 1);
-      } else {
-        let line = `${indent}- \`${child.name}\``;
-        if (options.showSize && child.size !== undefined) {
-          line += ` (${formatSize(child.size)})`;
-        }
-        output += line + "\n";
-      }
-    }
-  }
-
-  return output;
-}
-
-// Format as CSV
-function formatCsv(node: TreeNode): string {
-  const headers = ["path", "type"];
-  if (options.showSize) headers.push("size");
-  if (options.showDate) headers.push("modified");
-  if (options.showPermissions) headers.push("permissions");
-
-  const flattened = flattenTree(node);
-  const rows = flattened.map((n) => {
-    const row = [n.path, n.type];
-    if (options.showSize) row.push(String(n.size || 0));
-    if (options.showDate) row.push(n.modified || "");
-    if (options.showPermissions) row.push(n.permissions || "");
-    return row.map((v) => `"${v}"`).join(",");
-  });
-
-  return [headers.join(","), ...rows].join("\n");
-}
-
-// Format statistics
-function formatStats(): string {
-  const sortedExts = Object.entries(stats.extensions)
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 10)
-    .map(([ext, count]) => `${ext} (${count})`)
-    .join(", ");
-
-  return `
-Statistics:
-  Directories: ${stats.directories}
-  Files: ${stats.files}
-  Total Size: ${formatSize(stats.totalSize)}
-  Extensions: ${sortedExts}
-`;
-}
-
-// Main execution
-async function main(): Promise<void> {
-  log(`Starting ${SKILL_NAME} session: ${SESSION_ID}`, "debug");
-  log(`Scanning: ${path.resolve(inputDir)}`, "debug");
-  log(`Format: ${options.format}`, "debug");
-
-  // Build tree
-  const tree = buildTree(path.resolve(inputDir));
-
-  if (!tree) {
-    log("Error: Could not build tree", "error");
-    process.exit(1);
-  }
-
-  // Format output
-  let output: string;
-  switch (options.format) {
-    case "json":
-      output = formatJson(tree);
-      break;
-    case "markdown":
-      output = formatMarkdown(tree);
-      break;
-    case "csv":
-      output = formatCsv(tree);
-      break;
-    case "tree":
-    default:
-      output = formatTree(tree);
-  }
-
-  // Add statistics
-  if (options.showStats && options.format === "tree") {
-    output += formatStats();
-  }
-
-  // Write output
-  if (options.output) {
-    const outputDir = path.dirname(options.output);
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
-    fs.writeFileSync(options.output, output);
-    log(`Output written to: ${options.output}`, "success");
-  } else {
-    console.log(output);
-  }
-
-  // Summary
-  if (options.output || options.showStats) {
-    log(`Directories: ${stats.directories}`, "info");
-    log(`Files: ${stats.files}`, "info");
-    log(`Total Size: ${formatSize(stats.totalSize)}`, "info");
-    if (fileCount >= options.maxFiles) {
-      log(`Note: Output truncated at ${options.maxFiles} files`, "warn");
-    }
-  }
-}
-
-main().catch((error) => {
-  log(`Error: ${error.message}`, "error");
-  process.exit(1);
-});

package/skills/folder-tree/tsconfig.json

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

package/skills/form-filler/CLAUDE.md

@@ -1,19 +0,0 @@
-# form-filler
-
-Form Filler skill.
-
-## Tech Stack
-
-- Runtime: Bun
-- Language: TypeScript
-- CLI: Commander.js
-
-## CLI
-
-```bash
-form-filler run
-```
-
-## Data Directory
-
-~/.skill/form-filler/

package/skills/form-filler/package.json

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

package/skills/form-filler/src/index.ts

@@ -1,81 +0,0 @@
-#!/usr/bin/env bun
-import puppeteer from "puppeteer";
-import { join } from "path";
-
-const args = process.argv.slice(2);
-
-if (args.includes("-h") || args.includes("--help")) {
-  console.log(`
-form-filler - Automate web form filling with Puppeteer
-
-Usage:
-  skills run form-filler -- url=<url> data=<json> [options]
-
-Options:
-  -h, --help                 Show this help message
-  url=<url>                  URL of the page containing the form (required)
-  data=<json>                JSON mapping CSS selectors to values (required)
-  submitSelector=<selector>  CSS selector for submit button
-
-Data Format:
-  Provide a JSON object where keys are CSS selectors and values are text to type.
-  Example: '{"#email": "user@example.com", "#password": "secret123"}'
-
-Examples:
-  skills run form-filler -- url="https://example.com/login" data='{"#username": "john", "#password": "pass123"}'
-  skills run form-filler -- url="https://example.com/contact" data='{"#name": "John", "#message": "Hello"}' submitSelector="button[type=submit]"
-`);
-  process.exit(0);
-}
-
-const urlArg = args.find(a => a.startsWith("url="))?.split("=")[1];
-const dataArg = args.find(a => a.startsWith("data="))?.split("=")[1];
-const submitSelectorArg = args.find(a => a.startsWith("submitSelector="))?.split("=")[1];
-
-async function main() {
-  if (!urlArg || !dataArg) {
-    console.log("Usage: skills run form-filler -- url=... data='{\"selector\": \"value\"}' [submitSelector=...]");
-    process.exit(1);
-  }
-
-  let formData: Record<string, string>;
-  try {
-    formData = JSON.parse(dataArg);
-  } catch {
-    console.error("Error: data must be valid JSON");
-    process.exit(1);
-  }
-
-  console.log(`Navigating to ${urlArg}...`);
-  const browser = await puppeteer.launch({ headless: "new" });
-  const page = await browser.newPage();
-
-  try {
-    await page.goto(urlArg, { waitUntil: "networkidle0" });
-
-    for (const [selector, value] of Object.entries(formData)) {
-      console.log(`Filling ${selector} with "${value}"`);
-      await page.type(selector, value);
-    }
-
-    if (submitSelectorArg) {
-      console.log(`Clicking ${submitSelectorArg}...`);
-      await Promise.all([
-        page.waitForNavigation({ waitUntil: "networkidle0" }).catch(() => {}), // Wait for nav if it happens
-        page.click(submitSelectorArg),
-      ]);
-    }
-
-    const outputDir = process.env.SKILLS_EXPORTS_DIR || ".";
-    const screenshotPath = join(outputDir, "form-submission.png");
-    await page.screenshot({ path: screenshotPath, fullPage: true });
-    console.log(`Screenshot saved to ${screenshotPath}`);
-
-  } catch (error: any) {
-    console.error("Browser Error:", error.message);
-  } finally {
-    await browser.close();
-  }
-}
-
-main();