@hasna/skills 0.1.26 → 0.1.29

package/skills/generate-resume/src/types.ts

@@ -0,0 +1,86 @@
+export interface Experience {
+  title: string;
+  company: string;
+  dates: string;
+  description: string;
+}
+
+export interface Education {
+  degree: string;
+  school: string;
+  dates: string;
+  details?: string;
+}
+
+export interface Skill {
+  name: string;
+  level: number;
+}
+
+export interface Project {
+  name: string;
+  description: string;
+  url?: string;
+}
+
+export interface Certification {
+  name: string;
+  year: string;
+  issuer?: string;
+}
+
+export interface Language {
+  name: string;
+  proficiency: string;
+}
+
+export interface ResumeData {
+  // Contact
+  name: string;
+  email?: string;
+  phone?: string;
+  location?: string;
+  website?: string;
+  linkedin?: string;
+  github?: string;
+  portfolio?: string;
+  twitter?: string;
+  photo?: string;
+
+  // Professional
+  title?: string;
+  summary?: string;
+
+  // Sections
+  experience: Experience[];
+  education: Education[];
+  skills: Skill[];
+  projects: Project[];
+  certifications: Certification[];
+  languages: Language[];
+
+  // Design
+  template: string;
+  layout: string;
+  color: string;
+  font: string;
+  fontSize: string;
+  spacing: string;
+  atsFriendly: boolean;
+  includePhoto: boolean;
+  pageNumbers: boolean;
+}
+
+export interface CoverLetterData {
+  name: string;
+  email?: string;
+  phone?: string;
+  location?: string;
+  company: string;
+  position: string;
+  content: string;
+  template: string;
+  date: string;
+}
+
+// Parse command line arguments

package/skills/generate-social-posts/src/ai.ts

@@ -0,0 +1,88 @@
+import { log } from "./runtime";
+import type { AnthropicResponse, OpenAIChatResponse } from "./types";
+
+// Call AI API
+export async function callAI(prompt: string, systemPrompt: string): Promise<string> {
+  // Try OpenAI first
+  const openaiKey = process.env.OPENAI_API_KEY;
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+
+  if (openaiKey) {
+    return await callOpenAI(prompt, systemPrompt, openaiKey);
+  } else if (anthropicKey) {
+    return await callAnthropic(prompt, systemPrompt, anthropicKey);
+  } else {
+    throw new Error("No AI API key found. Please set OPENAI_API_KEY or ANTHROPIC_API_KEY environment variable");
+  }
+}
+
+// Call OpenAI API
+async function callOpenAI(prompt: string, systemPrompt: string, apiKey: string): Promise<string> {
+  log("Using OpenAI API...");
+
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: "gpt-4o-mini",
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: prompt },
+      ],
+      temperature: 0.8,
+      max_tokens: 4000,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+  }
+
+  const data: OpenAIChatResponse = await response.json();
+
+  if (!data.choices?.[0]?.message?.content) {
+    throw new Error("No content returned from OpenAI");
+  }
+
+  return data.choices[0].message.content;
+}
+
+// Call Anthropic API
+async function callAnthropic(prompt: string, systemPrompt: string, apiKey: string): Promise<string> {
+  log("Using Anthropic Claude API...");
+
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+    },
+    body: JSON.stringify({
+      model: "claude-3-5-sonnet-20241022",
+      max_tokens: 4000,
+      system: systemPrompt,
+      messages: [
+        { role: "user", content: prompt },
+      ],
+      temperature: 0.8,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);
+  }
+
+  const data: AnthropicResponse = await response.json();
+
+  if (!data.content?.[0]?.text) {
+    throw new Error("No content returned from Anthropic");
+  }
+
+  return data.content[0].text;
+}

package/skills/generate-social-posts/src/cli.ts

@@ -0,0 +1,118 @@
+import { parseArgs } from "util";
+import { log } from "./runtime";
+import { detectSourceType } from "./source";
+import type { GenerateOptions, OutputFormat, Platform, Tone } from "./types";
+
+export function parseGenerateOptions(): GenerateOptions {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      input: { type: "string" },
+      platforms: { type: "string", default: "all" },
+      count: { type: "string", default: "3" },
+      tone: { type: "string", default: "professional" },
+      "include-hashtags": { type: "boolean", default: true },
+      threads: { type: "boolean", default: false },
+      "max-length": { type: "string", default: "10000" },
+      output: { type: "string", short: "o" },
+      format: { type: "string", default: "json" },
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    console.log(`
+Generate Social Posts - Transform content into platform-optimized social media posts
+
+Usage:
+  bun run src/index.ts <url|file> [options]
+  bun run src/index.ts --input "text" [options]
+
+Options:
+  --input <text>          Direct text input (alternative to URL/file)
+  --platforms <list>      Comma-separated platforms (twitter,linkedin,facebook,instagram,threads,all) [default: all]
+  --count <number>        Number of post variants per platform [default: 3]
+  --tone <tone>           Writing tone (professional,casual,witty,inspiring,educational) [default: professional]
+  --include-hashtags      Include hashtag suggestions [default: true]
+  --threads               Generate thread/carousel versions [default: false]
+  --max-length <chars>    Maximum content length to process [default: 10000]
+  --output, -o <path>     Custom output path
+  --format <format>       Output format (json,markdown,text) [default: json]
+  --help, -h              Show this help
+`);
+    process.exit(0);
+  }
+
+  const { source, sourceType } = resolveSource(values.input as string | undefined, positionals);
+  const platforms = parsePlatforms(values.platforms as string);
+  const count = parseInt(values.count as string);
+  const maxLength = parseInt(values["max-length"] as string);
+  const tone = values.tone as Tone;
+  const format = values.format as OutputFormat;
+
+  const validTones: Tone[] = ["professional", "casual", "witty", "inspiring", "educational"];
+  const validFormats: OutputFormat[] = ["json", "markdown", "text"];
+
+  if (!validTones.includes(tone)) {
+    log(`Invalid tone: ${tone}. Must be one of: ${validTones.join(", ")}`, "error");
+    process.exit(1);
+  }
+
+  if (!validFormats.includes(format)) {
+    log(`Invalid format: ${format}. Must be one of: ${validFormats.join(", ")}`, "error");
+    process.exit(1);
+  }
+
+  if (count < 1 || count > 20) {
+    log("Count must be between 1 and 20", "error");
+    process.exit(1);
+  }
+
+  return {
+    source,
+    sourceType,
+    platforms,
+    count,
+    tone,
+    includeHashtags: values["include-hashtags"] as boolean,
+    threads: values.threads as boolean,
+    maxLength,
+    output: values.output as string | undefined,
+    format,
+  };
+}
+
+function resolveSource(input: string | undefined, positionals: string[]) {
+  if (input) {
+    return { source: input, sourceType: "text" as const };
+  }
+
+  if (positionals.length > 0) {
+    const source = positionals.join(" ");
+    return { source, sourceType: detectSourceType(source) };
+  }
+
+  log("Please provide a URL, file path, or use --input for direct text", "error");
+  process.exit(1);
+}
+
+function parsePlatforms(value: string): Platform[] {
+  const platformsInput = value.toLowerCase();
+  if (platformsInput === "all") {
+    return ["twitter", "linkedin", "facebook", "instagram", "threads"];
+  }
+
+  const validPlatforms: Platform[] = ["twitter", "linkedin", "facebook", "instagram", "threads"];
+  const platforms = platformsInput
+    .split(",")
+    .map((platform) => platform.trim())
+    .filter((platform) => validPlatforms.includes(platform as Platform)) as Platform[];
+
+  if (platforms.length === 0) {
+    log("No valid platforms specified. Use: twitter, linkedin, facebook, instagram, threads, or all", "error");
+    process.exit(1);
+  }
+
+  return platforms;
+}

package/skills/generate-social-posts/src/exporters.ts

@@ -0,0 +1,126 @@
+import { writeFileSync } from "fs";
+import { join } from "path";
+import { PLATFORM_CONFIGS } from "./platforms";
+import { log } from "./runtime";
+import type { GeneratedContent, Platform, SocialPost } from "./types";
+
+// Export as JSON
+export function exportJSON(content: GeneratedContent, outputPath: string): void {
+  const json = JSON.stringify(content, null, 2);
+  writeFileSync(outputPath, json);
+  log(`JSON exported to: ${outputPath}`);
+}
+
+// Export as Markdown
+export function exportMarkdown(content: GeneratedContent, outputPath: string): void {
+  let markdown = `# Social Media Posts\n\n`;
+  markdown += `**Source:** ${content.sourceTitle}\n\n`;
+  markdown += `**Summary:** ${content.sourceSummary}\n\n`;
+  markdown += `**Generated:** ${new Date(content.generatedAt).toLocaleString()}\n\n`;
+  markdown += `**Platforms:** ${content.platforms.join(", ")}\n\n`;
+  markdown += `---\n\n`;
+
+  // Group posts by platform
+  const postsByPlatform: Record<Platform, SocialPost[]> = {
+    twitter: [],
+    linkedin: [],
+    facebook: [],
+    instagram: [],
+    threads: [],
+  };
+
+  content.posts.forEach(post => {
+    postsByPlatform[post.platform].push(post);
+  });
+
+  // Write posts for each platform
+  for (const platform of content.platforms) {
+    const posts = postsByPlatform[platform];
+    if (posts.length === 0) continue;
+
+    const config = PLATFORM_CONFIGS[platform];
+    markdown += `## ${config.name}\n\n`;
+
+    posts.forEach((post, index) => {
+      markdown += `### Variant ${index + 1}\n\n`;
+      markdown += `${post.content}\n\n`;
+
+      if (post.hashtags.length > 0) {
+        markdown += `**Hashtags:** ${post.hashtags.join(" ")}\n\n`;
+      }
+
+      if (post.hooks.length > 0) {
+        markdown += `**Hook:** ${post.hooks[0]}\n\n`;
+      }
+
+      if (post.cta) {
+        markdown += `**CTA:** ${post.cta}\n\n`;
+      }
+
+      if (post.threadPosts && post.threadPosts.length > 0) {
+        markdown += `**Thread Version:**\n\n`;
+        post.threadPosts.forEach((threadPost, i) => {
+          markdown += `${i + 1}. ${threadPost}\n\n`;
+        });
+      }
+
+      if (post.bestTime) {
+        markdown += `**Best Time:** ${post.bestTime}\n\n`;
+      }
+
+      markdown += `**Character Count:** ${post.characterCount}\n\n`;
+      markdown += `---\n\n`;
+    });
+  }
+
+  writeFileSync(outputPath, markdown);
+  log(`Markdown exported to: ${outputPath}`);
+}
+
+// Export as text files per platform
+export function exportText(content: GeneratedContent, outputDir: string): void {
+  const postsByPlatform: Record<Platform, SocialPost[]> = {
+    twitter: [],
+    linkedin: [],
+    facebook: [],
+    instagram: [],
+    threads: [],
+  };
+
+  content.posts.forEach(post => {
+    postsByPlatform[post.platform].push(post);
+  });
+
+  for (const platform of content.platforms) {
+    const posts = postsByPlatform[platform];
+    if (posts.length === 0) continue;
+
+    let text = `${PLATFORM_CONFIGS[platform].name} Posts\n`;
+    text += `${"=".repeat(50)}\n\n`;
+
+    posts.forEach((post, index) => {
+      text += `--- Variant ${index + 1} ---\n\n`;
+      text += `${post.content}\n\n`;
+
+      if (post.hashtags.length > 0) {
+        text += `Hashtags: ${post.hashtags.join(" ")}\n\n`;
+      }
+
+      if (post.threadPosts && post.threadPosts.length > 0) {
+        text += `Thread Version:\n`;
+        post.threadPosts.forEach((threadPost, i) => {
+          text += `${i + 1}. ${threadPost}\n`;
+        });
+        text += `\n`;
+      }
+
+      text += `Character Count: ${post.characterCount}\n`;
+      text += `Best Time: ${post.bestTime || "N/A"}\n\n`;
+      text += `${"=".repeat(50)}\n\n`;
+    });
+
+    const outputPath = join(outputDir, `${platform}.txt`);
+    writeFileSync(outputPath, text);
+    log(`${PLATFORM_CONFIGS[platform].name} posts exported to: ${outputPath}`);
+  }
+}

package/skills/generate-social-posts/src/generator.ts

@@ -0,0 +1,130 @@
+import { callAI } from "./ai";
+import { PLATFORM_CONFIGS } from "./platforms";
+import { log } from "./runtime";
+import type { GeneratedContent, GenerateOptions, Platform, SocialPost } from "./types";
+
+// Generate posts for a specific platform
+export async function generatePlatformPosts(
+  content: string,
+  platform: Platform,
+  options: GenerateOptions
+): Promise<SocialPost[]> {
+  const config = PLATFORM_CONFIGS[platform];
+
+  log(`Generating ${options.count} post(s) for ${config.name}...`);
+
+  const systemPrompt = `You are an expert social media content creator specializing in ${config.name}. Create engaging, platform-optimized posts that drive engagement and conversions.`;
+
+  const toneDescriptions = {
+    professional: "formal, authoritative, business-appropriate",
+    casual: "friendly, approachable, conversational",
+    witty: "clever, humorous, attention-grabbing",
+    inspiring: "motivational, uplifting, aspirational",
+    educational: "informative, clear, teaching-focused",
+  };
+
+  const userPrompt = `Transform the following content into ${options.count} engaging ${config.name} post(s).
+
+CONTENT:
+${content.slice(0, 3000)}...
+
+REQUIREMENTS:
+- Platform: ${config.name}
+- Character limit: ${config.charLimit}
+- Tone: ${toneDescriptions[options.tone]}
+- Style: ${config.style}
+- Emoji usage: ${config.emojiUsage}
+${options.includeHashtags ? `- Include ${config.hashtagLimit} relevant hashtags` : "- No hashtags"}
+${options.threads ? "- Create thread version if content is long" : ""}
+
+Return a JSON array with ${options.count} post objects in this format:
+[
+  {
+    "content": "The post content (respecting character limit)",
+    "hashtags": ["hashtag1", "hashtag2"],
+    "hook": "Attention-grabbing opening line",
+    "cta": "Call to action",
+    ${options.threads ? '"threadPosts": ["post 1/5", "post 2/5", ...],' : ""}
+    "bestTime": "Optimal posting time (e.g., 'Weekday mornings 9-11am')"
+  }
+]
+
+Make each post variant unique and engaging. Ensure character counts are within limits.`;
+
+  const response = await callAI(userPrompt, systemPrompt);
+
+  // Parse JSON response
+  const jsonMatch = response.match(/\[[\s\S]*\]/);
+  if (!jsonMatch) {
+    throw new Error(`Could not parse ${platform} posts JSON from response`);
+  }
+
+  const postsData = JSON.parse(jsonMatch[0]);
+
+  const posts: SocialPost[] = postsData.map((post: any) => ({
+    platform,
+    content: post.content,
+    hashtags: post.hashtags || [],
+    hooks: [post.hook].filter(Boolean),
+    cta: post.cta,
+    threadPosts: post.threadPosts,
+    bestTime: post.bestTime,
+    characterCount: post.content.length,
+  }));
+
+  log(`Generated ${posts.length} ${config.name} post(s)`, "success");
+
+  return posts;
+}
+
+// Generate all posts
+export async function generateAllPosts(
+  content: string,
+  options: GenerateOptions
+): Promise<GeneratedContent> {
+  log(`Generating posts for ${options.platforms.length} platform(s)...`);
+
+  // First, get a summary and title from the content
+  const summaryPrompt = `Analyze this content and provide a title and brief summary.
+
+CONTENT:
+${content.slice(0, 2000)}...
+
+Return JSON:
+{
+  "title": "Content title or main topic",
+  "summary": "2-3 sentence summary"
+}`;
+
+  const summaryResponse = await callAI(
+    summaryPrompt,
+    "You are a content analyst. Provide concise, accurate summaries."
+  );
+
+  const summaryMatch = summaryResponse.match(/\{[\s\S]*\}/);
+  const summaryData = summaryMatch ? JSON.parse(summaryMatch[0]) : {
+    title: "Generated Content",
+    summary: "Social media posts generated from content",
+  };
+
+  // Generate posts for each platform
+  const allPosts: SocialPost[] = [];
+
+  for (const platform of options.platforms) {
+    const posts = await generatePlatformPosts(content, platform, options);
+    allPosts.push(...posts);
+  }
+
+  const result: GeneratedContent = {
+    sourceTitle: summaryData.title,
+    sourceSummary: summaryData.summary,
+    platforms: options.platforms,
+    posts: allPosts,
+    generatedAt: new Date().toISOString(),
+    options,
+  };
+
+  log(`Generated ${allPosts.length} total posts across all platforms`, "success");
+
+  return result;
+}