@hasna/skills 0.0.2

package/skills/skill-generate-resume/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*", "bin/**/*"]
+}

package/skills/skill-generate-sitemap/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-generate-sitemap
+
+Generate Sitemap skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+skill-generate-sitemap run
+```
+
+## Data Directory
+
+~/.skill/skill-generate-sitemap/

package/skills/skill-generate-sitemap/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-generate-sitemap",
+  "version": "0.1.0",
+  "description": "Generate Sitemap skill",
+  "type": "module",
+  "bin": {
+    "skill-generate-sitemap": "./bin/cli.ts"
+  },
+  "scripts": {
+    "dev": "bun run bin/cli.ts",
+    "build": "bun build bin/cli.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": ["bin", "src", "tsconfig.json"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/skill-generate-sitemap.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}

package/skills/skill-generate-sitemap/src/index.ts

@@ -0,0 +1,626 @@
+#!/usr/bin/env bun
+
+/**
+ * Generate Sitemap Skill
+ *
+ * Generates XML sitemaps for websites with support for:
+ * - Automated website crawling
+ * - Manual URL input from file or CLI
+ * - Priority and change frequency settings
+ * - Sitemap indexes for large sites (>50k URLs)
+ * - Last modified dates
+ */
+
+import { parseArgs } from "util";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname, basename } from "path";
+import { gzipSync } from "zlib";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface SitemapURL {
+  loc: string;
+  lastmod?: string;
+  changefreq?: ChangeFrequency;
+  priority?: number;
+}
+
+type ChangeFrequency =
+  | "always"
+  | "hourly"
+  | "daily"
+  | "weekly"
+  | "monthly"
+  | "yearly"
+  | "never";
+
+interface CrawlOptions {
+  maxDepth?: number;
+  maxUrls?: number;
+  excludePatterns?: string[];
+  includePatterns?: string[];
+  followExternal?: boolean;
+  timeout?: number;
+  userAgent?: string;
+}
+
+interface GenerateOptions {
+  file?: string;
+  crawl?: boolean;
+  depth?: number;
+  maxUrls?: number;
+  priority?: number;
+  changefreq?: ChangeFrequency;
+  lastmod?: string;
+  output?: string;
+  index?: boolean;
+  compress?: boolean;
+  pretty?: boolean;
+  exclude?: string[];
+  include?: string[];
+  followExternal?: boolean;
+  timeout?: number;
+  userAgent?: string;
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const SITEMAP_XMLNS = "http://www.sitemaps.org/schemas/sitemap/0.9";
+const MAX_URLS_PER_SITEMAP = 50000;
+const DEFAULT_TIMEOUT = 5000;
+const DEFAULT_USER_AGENT = "skills.md-sitemap-generator/1.0";
+const RATE_LIMIT_DELAY = 200; // 5 requests per second
+
+// ============================================================================
+// URL Parser & Validator
+// ============================================================================
+
+function isValidUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function normalizeUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    // Remove trailing slash except for root
+    if (parsed.pathname !== "/" && parsed.pathname.endsWith("/")) {
+      parsed.pathname = parsed.pathname.slice(0, -1);
+    }
+    // Remove hash
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+
+function matchesPattern(url: string, pattern: string): boolean {
+  const regex = new RegExp(
+    pattern
+      .replace(/\*/g, ".*")
+      .replace(/\?/g, ".")
+  );
+  return regex.test(url);
+}
+
+// ============================================================================
+// File Parser
+// ============================================================================
+
+function parseUrlsFile(filePath: string, defaultOptions: Partial<SitemapURL>): SitemapURL[] {
+  if (!existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter(line => {
+    const trimmed = line.trim();
+    return trimmed && !trimmed.startsWith("#");
+  });
+
+  const urls: SitemapURL[] = [];
+
+  for (const line of lines) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length === 0) continue;
+
+    const url = parts[0];
+    if (!isValidUrl(url)) {
+      console.warn(`⚠️  Skipping invalid URL: ${url}`);
+      continue;
+    }
+
+    const sitemapUrl: SitemapURL = {
+      loc: normalizeUrl(url),
+      priority: parts[1] ? parseFloat(parts[1]) : defaultOptions.priority,
+      changefreq: (parts[2] as ChangeFrequency) || defaultOptions.changefreq,
+      lastmod: parts[3] || defaultOptions.lastmod,
+    };
+
+    urls.push(sitemapUrl);
+  }
+
+  return urls;
+}
+
+// ============================================================================
+// Web Crawler
+// ============================================================================
+
+class WebCrawler {
+  private visited = new Set<string>();
+  private baseUrl: URL;
+  private options: CrawlOptions;
+
+  constructor(baseUrl: string, options: CrawlOptions = {}) {
+    this.baseUrl = new URL(baseUrl);
+    this.options = {
+      maxDepth: options.maxDepth,
+      maxUrls: options.maxUrls || MAX_URLS_PER_SITEMAP,
+      excludePatterns: options.excludePatterns || [],
+      includePatterns: options.includePatterns || [],
+      followExternal: options.followExternal || false,
+      timeout: options.timeout || DEFAULT_TIMEOUT,
+      userAgent: options.userAgent || DEFAULT_USER_AGENT,
+    };
+  }
+
+  async crawl(): Promise<SitemapURL[]> {
+    console.log(`🕷️  Starting crawl of ${this.baseUrl.toString()}`);
+    console.log(`   Max depth: ${this.options.maxDepth || "unlimited"}`);
+    console.log(`   Max URLs: ${this.options.maxUrls}`);
+
+    const urls: SitemapURL[] = [];
+    await this.crawlRecursive(this.baseUrl.toString(), 0, urls);
+
+    console.log(`✅ Crawl complete: ${urls.length} URLs discovered`);
+    return urls;
+  }
+
+  private async crawlRecursive(
+    url: string,
+    depth: number,
+    urls: SitemapURL[]
+  ): Promise<void> {
+    // Check limits
+    if (this.options.maxDepth && depth > this.options.maxDepth) return;
+    if (urls.length >= this.options.maxUrls!) return;
+
+    const normalizedUrl = normalizeUrl(url);
+
+    // Check if already visited
+    if (this.visited.has(normalizedUrl)) return;
+    this.visited.add(normalizedUrl);
+
+    // Check domain (unless followExternal is enabled)
+    const urlObj = new URL(url);
+    if (!this.options.followExternal && urlObj.hostname !== this.baseUrl.hostname) {
+      return;
+    }
+
+    // Apply filters
+    if (!this.shouldIncludeUrl(url)) return;
+
+    // Add to sitemap
+    urls.push({
+      loc: normalizedUrl,
+      lastmod: new Date().toISOString().split("T")[0],
+      changefreq: "weekly",
+      priority: depth === 0 ? 1.0 : Math.max(0.1, 1.0 - depth * 0.2),
+    });
+
+    console.log(`   [${depth}] ${normalizedUrl}`);
+
+    // Fetch and parse links
+    try {
+      const links = await this.fetchLinks(url);
+
+      // Rate limiting
+      await new Promise(resolve => setTimeout(resolve, RATE_LIMIT_DELAY));
+
+      // Crawl children
+      for (const link of links) {
+        if (urls.length >= this.options.maxUrls!) break;
+        await this.crawlRecursive(link, depth + 1, urls);
+      }
+    } catch (error) {
+      console.warn(`   ⚠️  Failed to crawl ${url}:`, (error as Error).message);
+    }
+  }
+
+  private async fetchLinks(url: string): Promise<string[]> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": this.options.userAgent!,
+        },
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      const contentType = response.headers.get("content-type") || "";
+      if (!contentType.includes("text/html")) {
+        return [];
+      }
+
+      const html = await response.text();
+      return this.extractLinks(html, url);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+
+  private extractLinks(html: string, baseUrl: string): string[] {
+    const links: string[] = [];
+    const linkRegex = /<a[^>]+href=["']([^"']+)["']/gi;
+    let match;
+
+    while ((match = linkRegex.exec(html)) !== null) {
+      try {
+        const href = match[1];
+        const absoluteUrl = new URL(href, baseUrl).toString();
+
+        if (isValidUrl(absoluteUrl)) {
+          links.push(absoluteUrl);
+        }
+      } catch {
+        // Skip invalid URLs
+      }
+    }
+
+    return [...new Set(links)]; // Remove duplicates
+  }
+
+  private shouldIncludeUrl(url: string): boolean {
+    // Check exclude patterns
+    for (const pattern of this.options.excludePatterns!) {
+      if (matchesPattern(url, pattern)) {
+        return false;
+      }
+    }
+
+    // Check include patterns (if any)
+    if (this.options.includePatterns!.length > 0) {
+      return this.options.includePatterns!.some(pattern =>
+        matchesPattern(url, pattern)
+      );
+    }
+
+    return true;
+  }
+}
+
+// ============================================================================
+// XML Generator
+// ============================================================================
+
+function generateSitemapXML(urls: SitemapURL[], pretty: boolean = false): string {
+  const indent = pretty ? "  " : "";
+  const newline = pretty ? "\n" : "";
+
+  let xml = `<?xml version="1.0" encoding="UTF-8"?>${newline}`;
+  xml += `<urlset xmlns="${SITEMAP_XMLNS}">${newline}`;
+
+  for (const url of urls) {
+    xml += `${indent}<url>${newline}`;
+    xml += `${indent}${indent}<loc>${escapeXml(url.loc)}</loc>${newline}`;
+
+    if (url.lastmod) {
+      xml += `${indent}${indent}<lastmod>${url.lastmod}</lastmod>${newline}`;
+    }
+
+    if (url.changefreq) {
+      xml += `${indent}${indent}<changefreq>${url.changefreq}</changefreq>${newline}`;
+    }
+
+    if (url.priority !== undefined) {
+      xml += `${indent}${indent}<priority>${url.priority.toFixed(1)}</priority>${newline}`;
+    }
+
+    xml += `${indent}</url>${newline}`;
+  }
+
+  xml += `</urlset>`;
+  return xml;
+}
+
+function generateSitemapIndexXML(
+  sitemaps: Array<{ loc: string; lastmod: string }>,
+  pretty: boolean = false
+): string {
+  const indent = pretty ? "  " : "";
+  const newline = pretty ? "\n" : "";
+
+  let xml = `<?xml version="1.0" encoding="UTF-8"?>${newline}`;
+  xml += `<sitemapindex xmlns="${SITEMAP_XMLNS}">${newline}`;
+
+  for (const sitemap of sitemaps) {
+    xml += `${indent}<sitemap>${newline}`;
+    xml += `${indent}${indent}<loc>${escapeXml(sitemap.loc)}</loc>${newline}`;
+    xml += `${indent}${indent}<lastmod>${sitemap.lastmod}</lastmod>${newline}`;
+    xml += `${indent}</sitemap>${newline}`;
+  }
+
+  xml += `</sitemapindex>`;
+  return xml;
+}
+
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+// ============================================================================
+// File Writer
+// ============================================================================
+
+function writeOutput(
+  content: string,
+  outputPath: string,
+  compress: boolean = false
+): void {
+  // Ensure directory exists
+  const dir = dirname(outputPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  if (compress) {
+    const compressed = gzipSync(Buffer.from(content));
+    const gzPath = outputPath.endsWith(".gz") ? outputPath : `${outputPath}.gz`;
+    writeFileSync(gzPath, compressed);
+    console.log(`💾 Saved compressed sitemap: ${gzPath}`);
+  } else {
+    writeFileSync(outputPath, content, "utf-8");
+    console.log(`💾 Saved sitemap: ${outputPath}`);
+  }
+}
+
+// ============================================================================
+// Main Generator
+// ============================================================================
+
+async function generateSitemap(
+  inputUrls: string[],
+  options: GenerateOptions
+): Promise<void> {
+  console.log("🗺️  Generate Sitemap v1.0.0\n");
+
+  let urls: SitemapURL[] = [];
+
+  // Parse input from file
+  if (options.file) {
+    console.log(`📂 Reading URLs from file: ${options.file}`);
+    urls = parseUrlsFile(options.file, {
+      priority: options.priority,
+      changefreq: options.changefreq,
+      lastmod: options.lastmod,
+    });
+  }
+  // Or from manual input
+  else if (inputUrls.length > 0) {
+    for (const url of inputUrls) {
+      if (isValidUrl(url)) {
+        urls.push({
+          loc: normalizeUrl(url),
+          priority: options.priority,
+          changefreq: options.changefreq,
+          lastmod: options.lastmod,
+        });
+      }
+    }
+  }
+
+  // If first URL and crawl enabled (or no file provided)
+  if (inputUrls.length > 0 && (options.crawl || !options.file)) {
+    const baseUrl = inputUrls[0];
+    if (isValidUrl(baseUrl)) {
+      const crawler = new WebCrawler(baseUrl, {
+        maxDepth: options.depth,
+        maxUrls: options.maxUrls,
+        excludePatterns: options.exclude,
+        includePatterns: options.include,
+        followExternal: options.followExternal,
+        timeout: options.timeout,
+        userAgent: options.userAgent,
+      });
+
+      const crawledUrls = await crawler.crawl();
+
+      // Merge with manual URLs (deduplicate)
+      const urlMap = new Map<string, SitemapURL>();
+
+      for (const url of urls) {
+        urlMap.set(url.loc, url);
+      }
+
+      for (const url of crawledUrls) {
+        if (!urlMap.has(url.loc)) {
+          urlMap.set(url.loc, url);
+        }
+      }
+
+      urls = Array.from(urlMap.values());
+    }
+  }
+
+  if (urls.length === 0) {
+    console.error("❌ No URLs to generate sitemap. Provide URLs via file, CLI, or enable crawling.");
+    process.exit(1);
+  }
+
+  console.log(`\n📊 Total URLs: ${urls.length}`);
+
+  // Determine output path
+  const outputPath = options.output || join(
+    process.env.SKILLS_OUTPUT_DIR || "./",
+    "sitemap.xml"
+  );
+
+  // Generate sitemap(s)
+  if (options.index && urls.length > options.maxUrls!) {
+    // Generate multiple sitemaps with index
+    console.log(`📑 Generating sitemap index (${Math.ceil(urls.length / options.maxUrls!)} sitemaps)`);
+
+    const baseDir = dirname(outputPath);
+    const baseName = basename(outputPath, ".xml");
+    const sitemapFiles: Array<{ loc: string; lastmod: string }> = [];
+
+    for (let i = 0; i < urls.length; i += options.maxUrls!) {
+      const chunk = urls.slice(i, i + options.maxUrls!);
+      const chunkIndex = Math.floor(i / options.maxUrls!) + 1;
+      const chunkPath = join(baseDir, `${baseName}_${chunkIndex}.xml`);
+
+      const xml = generateSitemapXML(chunk, options.pretty);
+      writeOutput(xml, chunkPath, options.compress);
+
+      // Get base URL for sitemap location
+      const firstUrl = new URL(chunk[0].loc);
+      const sitemapLoc = `${firstUrl.protocol}//${firstUrl.hostname}/${basename(chunkPath)}`;
+
+      sitemapFiles.push({
+        loc: sitemapLoc,
+        lastmod: new Date().toISOString().split("T")[0],
+      });
+    }
+
+    // Generate index
+    const indexXml = generateSitemapIndexXML(sitemapFiles, options.pretty);
+    const indexPath = join(baseDir, `${baseName}_index.xml`);
+    writeOutput(indexXml, indexPath, options.compress);
+
+    console.log(`\n✅ Generated sitemap index with ${sitemapFiles.length} sitemaps`);
+  } else {
+    // Generate single sitemap
+    const xml = generateSitemapXML(urls, options.pretty);
+    writeOutput(xml, outputPath, options.compress);
+
+    console.log(`\n✅ Generated sitemap with ${urls.length} URLs`);
+  }
+
+  console.log("\n📍 Next steps:");
+  console.log("   1. Upload sitemap to your website root");
+  console.log("   2. Submit to search engines (Google Search Console, Bing Webmaster)");
+  console.log("   3. Add sitemap location to robots.txt:");
+  console.log(`      Sitemap: https://your-domain.com/${basename(outputPath)}`);
+}
+
+// ============================================================================
+// CLI Entry Point
+// ============================================================================
+
+async function main() {
+  try {
+    const { values, positionals } = parseArgs({
+      args: process.argv.slice(2),
+      options: {
+        file: { type: "string" },
+        crawl: { type: "boolean", default: true },
+        depth: { type: "string" },
+        "max-urls": { type: "string", default: "50000" },
+        priority: { type: "string", default: "0.5" },
+        changefreq: { type: "string", default: "weekly" },
+        lastmod: { type: "string" },
+        output: { type: "string" },
+        index: { type: "boolean", default: false },
+        compress: { type: "boolean", default: false },
+        pretty: { type: "boolean", default: true },
+        exclude: { type: "string", multiple: true },
+        include: { type: "string", multiple: true },
+        "follow-external": { type: "boolean", default: false },
+        timeout: { type: "string", default: "5000" },
+        "user-agent": { type: "string" },
+        help: { type: "boolean", short: "h" },
+      },
+      allowPositionals: true,
+    });
+
+    if (values.help) {
+      console.log(`
+Generate Sitemap v1.0.0
+
+Usage:
+  bun run src/index.ts [urls...] [options]
+
+Examples:
+  bun run src/index.ts https://example.com
+  bun run src/index.ts --file urls.txt --output sitemap.xml
+  bun run src/index.ts https://example.com --depth 3 --index
+
+Options:
+  --file <path>           Path to file with URLs
+  --crawl                 Enable crawling (default: true)
+  --depth <number>        Max crawl depth
+  --max-urls <number>     Max URLs per sitemap (default: 50000)
+  --priority <number>     Default priority 0.0-1.0 (default: 0.5)
+  --changefreq <freq>     Change frequency (default: weekly)
+  --lastmod <date>        Last modified date (ISO 8601)
+  --output <path>         Output path (default: ./sitemap.xml)
+  --index                 Generate sitemap index
+  --compress              Compress to .xml.gz
+  --pretty                Pretty print XML (default: true)
+  --exclude <pattern>     Exclude URL pattern (can repeat)
+  --include <pattern>     Include URL pattern (can repeat)
+  --follow-external       Follow external links
+  --timeout <ms>          Request timeout (default: 5000)
+  --user-agent <string>   Custom User-Agent
+  -h, --help              Show this help
+      `);
+      process.exit(0);
+    }
+
+    const options: GenerateOptions = {
+      file: values.file as string | undefined,
+      crawl: values.crawl as boolean,
+      depth: values.depth ? parseInt(values.depth as string) : undefined,
+      maxUrls: parseInt(values["max-urls"] as string),
+      priority: parseFloat(values.priority as string),
+      changefreq: values.changefreq as ChangeFrequency,
+      lastmod: values.lastmod as string | undefined,
+      output: values.output as string | undefined,
+      index: values.index as boolean,
+      compress: values.compress as boolean,
+      pretty: values.pretty as boolean,
+      exclude: values.exclude as string[] | undefined,
+      include: values.include as string[] | undefined,
+      followExternal: values["follow-external"] as boolean,
+      timeout: parseInt(values.timeout as string),
+      userAgent: values["user-agent"] as string | undefined,
+    };
+
+    await generateSitemap(positionals, options);
+
+  } catch (error) {
+    console.error("\n❌ Error:", (error as Error).message);
+    process.exit(1);
+  }
+}
+
+// Run if executed directly
+if (import.meta.main) {
+  main();
+}
+
+export { generateSitemap, WebCrawler, generateSitemapXML, generateSitemapIndexXML };

package/skills/skill-generate-sitemap/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*", "bin/**/*"]
+}