@hasna/skills 0.0.2

package/skills/skill-newsletter-campaign-planner/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-newsletter-campaign-planner",
+  "version": "0.1.0",
+  "description": "Newsletter Campaign Planner skill",
+  "type": "module",
+  "bin": {
+    "skill-newsletter-campaign-planner": "./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-newsletter-campaign-planner.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}

package/skills/skill-newsletter-campaign-planner/src/index.ts

@@ -0,0 +1,252 @@
+#!/usr/bin/env bun
+/**
+ * skill-newsletter-campaign-planner
+ * Generates multi-send newsletter campaign plans using OpenAI.
+ */
+
+import { parseArgs } from "util";
+import { existsSync, mkdirSync, appendFileSync } from "fs";
+import { join, dirname } from "path";
+
+type OutputFormat = "markdown" | "json";
+
+interface SkillOptions {
+  brief: string;
+  audience?: string;
+  goals?: string;
+  duration: number;
+  format: OutputFormat;
+  model: string;
+  output?: string;
+}
+
+interface OpenAIChatResponse {
+  choices?: Array<{
+    message?: {
+      content?: string | null;
+    };
+  }>;
+  error?: {
+    message?: string;
+  };
+}
+
+const SKILL_SLUG = "newsletter-campaign-planner";
+
+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}.txt`);
+
+  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" ? "❌" : "ℹ️";
+    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) || "newsletter-campaign";
+}
+
+function parseOptions(): SkillOptions {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      brief: { type: "string" },
+      audience: { type: "string" },
+      goals: { type: "string" },
+      duration: { type: "string" },
+      format: { type: "string", default: "markdown" },
+      model: { type: "string", default: "gpt-4o-mini" },
+      output: { type: "string" },
+    },
+    allowPositionals: true,
+  });
+
+  const brief = values.brief || positionals.join(" ").trim();
+  if (!brief) {
+    throw new Error("Provide a campaign brief via positional text or --brief.");
+  }
+
+  const duration = values.duration ? parseInt(values.duration, 10) : 2;
+  if (Number.isNaN(duration) || duration < 1) {
+    throw new Error("--duration must be an integer >= 1 week.");
+  }
+
+  const format: OutputFormat =
+    values.format === "json" ? "json" : values.format === "markdown" ? "markdown" : "markdown";
+
+  return {
+    brief,
+    audience: values.audience,
+    goals: values.goals,
+    duration,
+    format,
+    model: values.model,
+    output: values.output,
+  };
+}
+
+function buildPrompt(options: SkillOptions) {
+  const system = `You are a lifecycle marketing strategist and newsletter copy director.
+Create a ${options.duration}-week campaign plan for: ${options.brief}
+- Audience segments: ${options.audience || "broad subscriber base"}
+- Goals: ${options.goals || "increase engagement, drive conversions"}
+
+Include:
+- Campaign overview summarizing arc and messaging pillars.
+- Calendar: send dates (Week 1-Week ${options.duration}), subject line concepts, preview text, primary CTA.
+- Segmentation notes (which segments receive each send, personalization ideas).
+- Email-by-email outline: body sections, value props, social proof, visuals, dynamic content suggestions.
+- Testing ideas (A/B subject lines, CTA variations).
+- Automation logic or trigger recommendations (if applicable).
+- Metrics dashboard suggestions for evaluating success.
+- Compliance checklist (CAN-SPAM/GDPR, unsubscribe handling).`;
+
+  const instructions =
+    options.format === "json"
+      ? "Respond in JSON with keys: overview, calendar, segmentation, emails, tests, automation, metrics, compliance. Calendar array should include week, send_name, subject, preview, cta."
+      : "Respond in polished Markdown. Start with an executive summary blockquote, include tables for calendar and segmentation, bullet lists for each email outline, and sections for testing, automation, metrics, compliance.";
+
+  const userPayload = {
+    brief: options.brief,
+    audience: options.audience,
+    goals: options.goals,
+    duration_weeks: options.duration,
+    format: options.format,
+  };
+
+  const user = `${instructions}\n\n${JSON.stringify(userPayload, 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.55,
+    max_tokens: options.format === "json" ? 2400 : 2100,
+  };
+
+  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);
+}
+
+async function run() {
+  const options = parseOptions();
+  const { sessionStamp, skillExportsDir, skillLogsDir } = getPaths();
+  const logger = createLogger(skillLogsDir, sessionStamp);
+
+  try {
+    logger.info("Planning newsletter campaign.");
+    logger.info(`Format: ${options.format.toUpperCase()}, Model: ${options.model}`);
+
+    const { system, user } = buildPrompt(options);
+    const content = await callOpenAI(options, system, user);
+
+    const slugBase = options.brief.split(/\s+/).slice(0, 4).join("-");
+    const planSlug = slugify(slugBase);
+    const extension = options.format === "json" ? "json" : "md";
+    const defaultPath = join(skillExportsDir, `newsletter-plan-${planSlug}-${sessionStamp}.${extension}`);
+    const targetPath = options.output ? options.output : defaultPath;
+
+    let finalContent = content;
+
+    if (options.format === "json") {
+      try {
+        finalContent = JSON.stringify(JSON.parse(content), null, 2);
+      } catch {
+        logger.error("Model response was not valid JSON. Wrapping raw response.");
+        finalContent = JSON.stringify({ raw: content }, null, 2);
+      }
+    }
+
+    await writeExport(targetPath, finalContent);
+
+    logger.success("Newsletter campaign plan generated successfully.");
+    console.log("\n=== Campaign Plan Preview ===\n");
+    console.log(finalContent.slice(0, 1500));
+    if (finalContent.length > 1500) {
+      console.log("\n… (truncated)");
+    }
+    console.log(`\nExport saved to: ${targetPath}`);
+    console.log(`Logs written to: ${skillLogsDir}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(message);
+    process.exit(1);
+  }
+}
+
+run();

package/skills/skill-newsletter-campaign-planner/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-notify/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hasna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/skill-notify/README.md

@@ -0,0 +1,17 @@
+# skill-notify
+
+
+
+## Overview
+
+This skill provides capabilities for .
+
+## Usage
+
+```bash
+# Coming soon
+```
+
+## Development
+
+See `.implementation/` for development notes and todos.

package/skills/skill-notify/install.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+
+# Install script for skills
+# Installs the skill either globally for Claude Code or locally in a project
+
+set -e
+
+SKILL_NAME="$(basename "$(pwd)")"
+SKILL_PATH="$(pwd)"
+
+echo "📦 Installing $SKILL_NAME..."
+echo ""
+
+# Check if Claude Code is installed
+if ! command -v claude &> /dev/null; then
+    echo "⚠️  Claude Code not found in PATH"
+    echo "   Please install Claude Code first: https://claude.com/claude-code"
+    exit 1
+fi
+
+# Check if we're in a git repository
+if git rev-parse --git-dir > /dev/null 2>&1; then
+    IN_REPO=true
+    REPO_ROOT="$(git rev-parse --show-toplevel)"
+    echo "📁 Detected git repository: $REPO_ROOT"
+else
+    IN_REPO=false
+    echo "📁 Not in a git repository"
+fi
+
+# Ask installation type
+echo ""
+echo "Where would you like to install this skill?"
+if [ "$IN_REPO" = true ]; then
+    echo "  1) Locally (this repository only)"
+    echo "  2) Globally (all Claude Code sessions)"
+    read -p "Choose [1/2]: " choice
+else
+    echo "  Installing globally (not in a git repository)"
+    choice=2
+fi
+
+# Install function
+install_skill() {
+    local config_dir=$1
+    local config_file="$config_dir/claude_mcp_config.json"
+
+    # Create config directory if it doesn't exist
+    mkdir -p "$config_dir"
+
+    # Create or update config file
+    if [ ! -f "$config_file" ]; then
+        echo "{" > "$config_file"
+        echo '  "mcpServers": {}' >> "$config_file"
+        echo "}" >> "$config_file"
+    fi
+
+    # Add skill to config using bun
+    bun -e "
+    const fs = require('fs');
+    const config = JSON.parse(fs.readFileSync('$config_file', 'utf8'));
+
+    if (!config.mcpServers) config.mcpServers = {};
+
+    config.mcpServers['$SKILL_NAME'] = {
+      command: 'bun',
+      args: ['run', '$SKILL_PATH/src/index.ts'],
+      env: {
+        SKILL_API_KEY: process.env.SKILL_API_KEY || '',
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || '',
+        OPENAI_API_KEY: process.env.OPENAI_API_KEY || '',
+        ELEVENLABS_API_KEY: process.env.ELEVENLABS_API_KEY || '',
+        GEMINI_API_KEY: process.env.GEMINI_API_KEY || '',
+        XAI_API_KEY: process.env.XAI_API_KEY || '',
+        GOOGLE_API_KEY: process.env.GOOGLE_API_KEY || '',
+        GOOGLE_PROJECT_ID: process.env.GOOGLE_PROJECT_ID || '',
+        BROWSER_USE_API_KEY: process.env.BROWSER_USE_API_KEY || '',
+        RUNWAY_API_KEY: process.env.RUNWAY_API_KEY || ''
+      }
+    };
+
+    fs.writeFileSync('$config_file', JSON.stringify(config, null, 2));
+    "
+
+    echo "✅ Installed $SKILL_NAME to $config_file"
+}
+
+# Install based on choice
+if [ "$choice" = "1" ]; then
+    # Local installation
+    install_skill "$REPO_ROOT/.claude"
+    echo ""
+    echo "🎉 $SKILL_NAME installed locally!"
+    echo "   Config: $REPO_ROOT/.claude/claude_mcp_config.json"
+elif [ "$choice" = "2" ]; then
+    # Global installation
+    install_skill "$HOME/.config/claude-code"
+    echo ""
+    echo "🎉 $SKILL_NAME installed globally!"
+    echo "   Config: $HOME/.config/claude-code/claude_mcp_config.json"
+else
+    echo "❌ Invalid choice"
+    exit 1
+fi
+
+echo ""
+echo "📝 Next steps:"
+echo "   1. Restart Claude Code"
+echo "   2. The skill will be available as: $SKILL_NAME"
+echo ""
+echo "   Usage: Claude Code will automatically detect and use this skill"
+echo "          based on your prompts and task context."

package/skills/skill-notify/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "skill-notify",
+  "version": "1.0.0",
+  "description": "Claude Code skill",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "skill-notify": "src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun run --watch src/index.ts"
+  },
+  "keywords": [
+    "claude",
+    "ai",
+    "skill"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasnaxyz/skill-notify.git"
+  }
+}

package/skills/skill-notify/src/auth.ts

@@ -0,0 +1,49 @@
+/**
+ * Skill Authentication Check
+ * Add this to the top of any skill's main function
+ */
+
+export function checkSkillAuth(): void {
+  const SKILL_API_KEY = process.env.SKILL_API_KEY;
+  
+  // Check if SKILL_API_KEY is set
+  if (!SKILL_API_KEY) {
+    console.error('❌ Error: SKILL_API_KEY environment variable not set');
+    console.error('');
+    console.error('To use this skill, you must set your SKILL_API_KEY:');
+    console.error('');
+    console.error('  export SKILL_API_KEY=your-api-key-here');
+    console.error('');
+    console.error('Contact your administrator to get your API key.');
+    process.exit(1);
+  }
+
+  // Validate key format
+  if (!SKILL_API_KEY.startsWith('sk-skill-')) {
+    console.error('❌ Error: Invalid SKILL_API_KEY format');
+    console.error('Expected format: sk-skill-xxxxxxxxxxxx');
+    process.exit(1);
+  }
+
+  // Key is valid - skill can proceed
+}
+
+/**
+ * Check if running remotely (via SSH or network)
+ */
+export function isRemoteExecution(): boolean {
+  return !!(
+    process.env.SSH_CONNECTION ||
+    process.env.SSH_CLIENT ||
+    process.env.SSH_TTY
+  );
+}
+
+/**
+ * Require auth only if remote execution
+ */
+export function requireAuthIfRemote(): void {
+  if (isRemoteExecution()) {
+    checkSkillAuth();
+  }
+}