@hasna/skills 0.0.2

package/skills/skill-destination-briefing/src/index.ts

@@ -0,0 +1,291 @@
+#!/usr/bin/env bun
+/**
+ * skill-destination-briefing
+ * Generates destination briefings using OpenAI.
+ */
+
+import { parseArgs } from "util";
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { randomUUID } from "crypto";
+
+type OutputFormat = "markdown" | "json";
+
+type BriefingTemplate = {
+  destination?: Record<string, unknown>;
+  travelers?: Array<Record<string, unknown>>;
+  itinerary?: Array<Record<string, unknown>>;
+  notes?: string;
+};
+
+interface SkillOptions {
+  brief: string;
+  audience?: string;
+  tone?: string;
+  format: OutputFormat;
+  model: string;
+  output?: string;
+  template?: BriefingTemplate;
+}
+
+interface OpenAIChatResponse {
+  choices?: Array<{
+    message?: {
+      content?: string | null;
+    };
+  }>;
+  error?: {
+    message?: string;
+  };
+}
+
+const SKILL_SLUG = "destination-briefing";
+const SESSION_ID = randomUUID().slice(0, 8);
+
+function ensureDir(path: string) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+
+function getPaths() {
+  const sessionStamp = new Date().toISOString().replace(/[:.]/g, "_").replace(/-/g, "_");
+  const exportsRoot = process.env.SKILLS_EXPORTS_DIR || join(process.cwd(), ".skills", "exports");
+  const logsRoot = process.env.SKILLS_LOGS_DIR || join(process.cwd(), ".skills", "logs");
+
+  const skillExportsDir = join(exportsRoot, SKILL_SLUG);
+  const skillLogsDir = join(logsRoot, SKILL_SLUG);
+
+  ensureDir(skillExportsDir);
+  ensureDir(skillLogsDir);
+
+  return {
+    sessionStamp,
+    skillExportsDir,
+    skillLogsDir,
+  };
+}
+
+function createLogger(logDir: string, sessionStamp: string) {
+  const logFile = join(logDir, `log_${sessionStamp}_${SESSION_ID}.log`);
+
+  function write(level: "info" | "success" | "error", message: string) {
+    const timestamp = new Date().toISOString();
+    const entry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+    appendFileSync(logFile, entry);
+    const prefix = level === "success" ? "✅" : level === "error" ? "❌" : "ℹ️";
+    if (level === "error") {
+      console.error(`${prefix} ${message}`);
+    } else {
+      console.log(`${prefix} ${message}`);
+    }
+  }
+
+  return {
+    info: (message: string) => write("info", message),
+    success: (message: string) => write("success", message),
+    error: (message: string) => write("error", message),
+    logFile,
+  };
+}
+
+function slugify(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40) || "destination-briefing";
+}
+
+function parseJsonTemplate(content: string): BriefingTemplate | undefined {
+  try {
+    const data = JSON.parse(content);
+    if (typeof data === "object" && data !== null) {
+      return data as BriefingTemplate;
+    }
+  } catch (_error) {
+    // treat as plain text when parsing fails
+  }
+  return undefined;
+}
+
+function parseOptions(): SkillOptions {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      text: { type: "string" },
+      audience: { type: "string" },
+      tone: { type: "string" },
+      format: { type: "string", default: "markdown" },
+      model: { type: "string", default: "gpt-4o-mini" },
+      output: { type: "string" },
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    console.log(`
+Destination Briefing - Generates destination briefings
+
+Usage:
+  skills run destination-briefing -- [options] <file-path>
+
+Options:
+  --text <string>      Destination data (or use positional arg)
+  --audience <string>  Target audience
+  --tone <string>      Tone of voice
+  --format <fmt>       Output format: markdown, json (default: markdown)
+  --model <model>      OpenAI model to use (default: gpt-4o-mini)
+  --output <path>      Save report to file
+  --help, -h           Show this help
+`);
+    process.exit(0);
+  }
+
+  let brief = values.text || "";
+  let template: BriefingTemplate | undefined;
+
+  if (!brief && positionals[0]) {
+    const filePath = resolve(positionals[0]);
+    if (existsSync(filePath)) {
+      const content = readFileSync(filePath, "utf-8");
+      template = parseJsonTemplate(content);
+      brief = template ? "" : content;
+    } else {
+      brief = positionals.join(" ");
+    }
+  }
+
+  if (!brief.trim() && !template) {
+    throw new Error("Provide destination data via positional text, file path, or --text.");
+  }
+
+  const format: OutputFormat =
+    values.format === "json" ? "json" : values.format === "markdown" ? "markdown" : "markdown";
+
+  return {
+    brief,
+    audience: values.audience as string,
+    tone: values.tone as string,
+    format,
+    model: values.model as string,
+    output: values.output as string,
+    template,
+  };
+}
+
+function buildPrompt(options: SkillOptions) {
+  const system = `You are a travel risk and logistics advisor creating destination briefings.
+Cover visas, customs, health, safety, money, transport, connectivity, cultural etiquette, and local contacts.
+Tailor tone and detail to the specified audience.`;
+
+  const instructions =
+    options.format === "json"
+      ? "Respond in JSON with keys: summary, entry_requirements, health, safety, logistics, etiquette, contacts, next_steps." 
+      : "Respond in polished Markdown. Start with an executive summary, provide sections for entry/visa, health & safety, logistics (transport, money, connectivity), cultural etiquette, and include recommended actions.";
+
+  const payload = {
+    audience: options.audience || "Traveler",
+    tone: options.tone || "friendly",
+    brief_text: options.brief.substring(0, 6000),
+    structured_template: options.template,
+  };
+
+  const user = `${instructions}\n\n${JSON.stringify(payload, null, 2)}`;
+
+  return { system, user };
+}
+
+async function callOpenAI(options: SkillOptions, system: string, user: string): Promise<string> {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY environment variable is required.");
+  }
+
+  const body = {
+    model: options.model,
+    messages: [
+      { role: "system", content: system },
+      { role: "user", content: user },
+    ],
+    temperature: 0.4,
+    max_tokens: options.format === "json" ? 2200 : 2000,
+  };
+
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  const data: OpenAIChatResponse = await response.json();
+
+  if (!response.ok) {
+    throw new Error(data.error?.message || `OpenAI API error (${response.status})`);
+  }
+
+  const content = data.choices?.[0]?.message?.content;
+  if (!content) {
+    throw new Error("OpenAI response did not include content.");
+  }
+
+  return content.trim();
+}
+
+async function writeExport(path: string, content: string) {
+  ensureDir(dirname(path));
+  await Bun.write(path, content);
+}
+
+function buildExportPath(skillExportsDir: string, sessionStamp: string, options: SkillOptions) {
+  if (options.output) {
+    return resolve(options.output);
+  }
+
+  const descriptorParts = [options.audience || "traveler", options.tone || "friendly"];
+  const base = slugify(descriptorParts.filter(Boolean).join("-"));
+  const extension = options.format === "json" ? "json" : "md";
+  return join(skillExportsDir, `${base}_${sessionStamp}.${extension}`);
+}
+
+function preview(content: string) {
+  const lines = content.split(/\r?\n/).slice(0, 8);
+  lines.forEach(line => console.log(`   ${line}`));
+  if (content.split(/\r?\n/).length > 8) {
+    console.log("   ...");
+  }
+}
+
+async function main() {
+  const { sessionStamp, skillExportsDir, skillLogsDir } = getPaths();
+  const logger = createLogger(skillLogsDir, sessionStamp);
+
+  try {
+    logger.info(`Starting ${SKILL_SLUG} session: ${SESSION_ID}`);
+    const options = parseOptions();
+    logger.info("Parsed destination inputs and options.");
+
+    const { system, user } = buildPrompt(options);
+    logger.info("Constructed destination briefing prompt.");
+
+    const content = await callOpenAI(options, system, user);
+    logger.success("Received destination briefing from OpenAI.");
+
+    const exportPath = buildExportPath(skillExportsDir, sessionStamp, options);
+    await writeExport(exportPath, content);
+    logger.success(`Saved destination briefing to ${exportPath}`);
+
+    console.log("\nPreview:");
+    preview(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(message);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/skills/skill-destination-briefing/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-diff-viewer/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-diff-viewer
+
+Diff Viewer skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+skill-diff-viewer run
+```
+
+## Data Directory
+
+~/.skill/skill-diff-viewer/

package/skills/skill-diff-viewer/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-diff-viewer",
+  "version": "0.1.0",
+  "description": "Diff Viewer skill",
+  "type": "module",
+  "bin": {
+    "skill-diff-viewer": "./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-diff-viewer.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}

package/skills/skill-diff-viewer/src/index.ts

@@ -0,0 +1,164 @@
+#!/usr/bin/env bun
+import { readFile } from "fs/promises";
+import { diffLines } from "diff";
+import chalk from "chalk";
+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
+// ============================================================================
+
+const args = process.argv.slice(2);
+
+if (args.includes("-h") || args.includes("--help")) {
+  console.log(`
+skill-diff-viewer - Compare two files and show differences
+
+Usage:
+  skills run diff-viewer -- file1=<path> file2=<path>
+
+Options:
+  -h, --help           Show this help message
+  file1=<path>         First file to compare (required)
+  file2=<path>         Second file to compare (required)
+
+Output:
+  Green text: Lines added in file2
+  Red text: Lines removed from file1
+  Grey text: Unchanged lines
+
+Examples:
+  skills run diff-viewer -- file1=old.txt file2=new.txt
+  skills run diff-viewer -- file1=src/v1.ts file2=src/v2.ts
+`);
+  process.exit(0);
+}
+
+const file1Arg = args.find(a => a.startsWith("file1="))?.split("=")[1];
+const file2Arg = args.find(a => a.startsWith("file2="))?.split("=")[1];
+
+async function main() {
+  if (!file1Arg || !file2Arg) {
+    console.log("Usage: skills run diff-viewer -- file1=... file2=...");
+    process.exit(1);
+  }
+
+  try {
+    // Validate file paths before reading
+    const validatedPath1 = validateFilePath(file1Arg, "file1");
+    const validatedPath2 = validateFilePath(file2Arg, "file2");
+
+    const content1 = await readFile(validatedPath1, "utf-8");
+    const content2 = await readFile(validatedPath2, "utf-8");
+
+    const diff = diffLines(content1, content2);
+
+    diff.forEach(part => {
+      const color = part.added ? chalk.green :
+                    part.removed ? chalk.red :
+                    chalk.grey;
+      process.stdout.write(color(part.value));
+    });
+    console.log(); // Newline at end
+
+  } catch (error: any) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/skills/skill-diff-viewer/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-dns-manager/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-dns-manager
+
+Dns Manager skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+skill-dns-manager run
+```
+
+## Data Directory
+
+~/.skill/skill-dns-manager/

package/skills/skill-dns-manager/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-dns-manager",
+  "version": "0.1.0",
+  "description": "Dns Manager skill",
+  "type": "module",
+  "bin": {
+    "skill-dns-manager": "./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-dns-manager.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}

package/skills/skill-dns-manager/src/index.ts

@@ -0,0 +1,92 @@
+#!/usr/bin/env bun
+/**
+ * skill-dns-manager
+ * Manages DNS records.
+ */
+
+import { parseArgs } from "util";
+import { existsSync, mkdirSync, appendFileSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+
+const SKILL_SLUG = "dns-manager";
+const SESSION_ID = randomUUID().slice(0, 8);
+
+function ensureDir(path: string) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+
+function getPaths() {
+  const sessionStamp = new Date().toISOString().replace(/[:.]/g, "_").replace(/-/g, "_");
+  const exportsRoot = process.env.SKILLS_EXPORTS_DIR || join(process.cwd(), ".skills", "exports");
+  const logsRoot = process.env.SKILLS_LOGS_DIR || join(process.cwd(), ".skills", "logs");
+
+  const skillExportsDir = join(exportsRoot, SKILL_SLUG);
+  const skillLogsDir = join(logsRoot, SKILL_SLUG);
+
+  ensureDir(skillExportsDir);
+  ensureDir(skillLogsDir);
+
+  return {
+    sessionStamp,
+    skillExportsDir,
+    skillLogsDir,
+  };
+}
+
+function createLogger(logDir: string, sessionStamp: string) {
+  const logFile = join(logDir, `log_${sessionStamp}_${SESSION_ID}.log`);
+
+  function write(level: "info" | "success" | "error", message: string) {
+    const timestamp = new Date().toISOString();
+    const entry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+    appendFileSync(logFile, entry);
+    const prefix = level === "success" ? "✅" : level === "error" ? "❌" : "ℹ️";
+    if (level === "error") {
+      console.error(`${prefix} ${message}`);
+    } else {
+      console.log(`${prefix} ${message}`);
+    }
+  }
+
+  return {
+    info: (message: string) => write("info", message),
+    success: (message: string) => write("success", message),
+    error: (message: string) => write("error", message),
+    logFile,
+  };
+}
+
+function main() {
+  const { values } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    console.log(`
+DNS Manager - Manage DNS records
+
+Usage:
+  skills run dns-manager [options]
+
+Options:
+  --help, -h           Show this help
+`);
+    process.exit(0);
+  }
+
+  const { sessionStamp, skillLogsDir } = getPaths();
+  const logger = createLogger(skillLogsDir, sessionStamp);
+
+  logger.info("DNS Manager skill started.");
+  // Placeholder for dns-manager skill implementation
+  logger.success("DNS Manager skill finished.");
+}
+
+main();

package/skills/skill-dns-manager/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/**/*"]
+}