@hasna/skills 0.0.2

package/skills/skill-salescopy/CLAUDE.md

@@ -0,0 +1,23 @@
+# service-salescopygenerate
+
+Sales copy generator using OpenAI GPT.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+- AI: OpenAI GPT-4o
+
+## CLI
+
+```bash
+service-salescopygenerate generate -n "Product" -d "Description" -t sales-letter
+service-salescopygenerate generate -n "Product" -d "Description" --template aida --tone urgent
+service-salescopygenerate templates list
+service-salescopygenerate sessions list
+```
+
+## Environment
+
+- `OPENAI_API_KEY` - Required

package/skills/skill-salescopy/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 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-salescopy/README.md

@@ -0,0 +1,72 @@
+# service-salescopygenerate
+
+Sales copy generator using AI. Create high-converting sales letters, landing pages, email sequences, and more.
+
+## Features
+
+- Multiple copy types: sales letters, landing pages, email sequences, headlines, etc.
+- Built-in copywriting templates: AIDA, PAS, FAB, and more
+- Tone control: professional, casual, urgent, friendly, etc.
+- Session management for organizing copy variations
+- OpenAI GPT-4o powered generation
+
+## Installation
+
+```bash
+bun install -g @hasnaxyz/service-salescopygenerate
+```
+
+## CLI
+
+```bash
+# Generate a sales letter
+service-salescopygenerate generate -n "Product Name" -d "Product description" -t sales-letter
+
+# Use a template
+service-salescopygenerate generate -n "Product Name" -d "Description" --template aida
+
+# Generate with specific tone and length
+service-salescopygenerate generate -n "Product" -d "Description" --tone urgent -l long
+
+# Generate multiple variations
+service-salescopygenerate generate -n "Product" -d "Description" -v 3
+
+# List templates
+service-salescopygenerate templates list
+
+# Manage sessions
+service-salescopygenerate sessions list
+service-salescopygenerate sessions show <id>
+service-salescopygenerate sessions export <id> -o output.md
+
+# Configuration
+service-salescopygenerate config show
+service-salescopygenerate config set defaultModel gpt-4o
+```
+
+## Copy Types
+
+- `sales-letter` - Persuasive sales letters
+- `landing-page` - Landing page copy
+- `email-sequence` - Email marketing sequences
+- `headline` - Compelling headlines
+- `bullet-points` - Benefit-focused bullets
+- `call-to-action` - CTA buttons and phrases
+- `testimonial-request` - Testimonial requests
+- `product-description` - Product descriptions
+
+## Templates
+
+- `aida` - Attention, Interest, Desire, Action
+- `pas` - Problem, Agitate, Solution
+- `fab` - Features, Advantages, Benefits
+- `headline-power` - Power headline variations
+- `email-welcome` - Welcome email sequence
+
+## Environment
+
+- `OPENAI_API_KEY` - Required
+
+## License
+
+MIT License - Copyright (c) 2024 Hasna

package/skills/skill-salescopy/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@hasnaxyz/skill-salescopygenerate",
+  "version": "0.1.0",
+  "description": "Sales copy generator using AI",
+  "type": "module",
+  "bin": {
+    "skill-salescopygenerate": "./bin/cli.ts"
+  },
+  "scripts": {
+    "start": "bun run bin/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "build": "bun build bin/cli.ts --outdir dist --target node"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.0.0",
+    "openai": "^4.77.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "restricted"
+  }
+}

package/skills/skill-salescopy/src/commands/config.ts

@@ -0,0 +1,115 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { dirname } from "path";
+import { getConfigPath, ensureDir } from "../utils/paths.js";
+import { logger } from "../utils/logger.js";
+
+interface Config {
+  defaultModel: string;
+  defaultTone: string;
+  defaultLength: string;
+  defaultCopyType: string;
+}
+
+function loadConfig(): Config {
+  const configPath = getConfigPath();
+
+  if (!existsSync(configPath)) {
+    return {
+      defaultModel: "gpt-4o",
+      defaultTone: "professional",
+      defaultLength: "medium",
+      defaultCopyType: "sales-letter",
+    };
+  }
+
+  const content = readFileSync(configPath, "utf-8");
+  return JSON.parse(content) as Config;
+}
+
+function saveConfig(config: Config): void {
+  const configPath = getConfigPath();
+  ensureDir(dirname(configPath));
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+export function registerConfigCommand(program: Command): void {
+  const config = program
+    .command("config")
+    .description("View and edit configuration");
+
+  config
+    .command("show")
+    .description("Show current configuration")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const cfg = loadConfig();
+
+      if (options.json) {
+        console.log(JSON.stringify(cfg, null, 2));
+        return;
+      }
+
+      logger.header("Configuration");
+      logger.label("Config file", getConfigPath());
+      console.log();
+
+      logger.label("Default Model", cfg.defaultModel);
+      logger.label("Default Tone", cfg.defaultTone);
+      logger.label("Default Length", cfg.defaultLength);
+      logger.label("Default Copy Type", cfg.defaultCopyType);
+
+      console.log();
+      console.log(chalk.bold("Environment:"));
+      logger.label(
+        "OPENAI_API_KEY",
+        process.env.OPENAI_API_KEY ? chalk.green("Set") : chalk.red("Not set")
+      );
+    });
+
+  config
+    .command("set <key> <value>")
+    .description("Set a configuration value")
+    .action((key, value) => {
+      const cfg = loadConfig();
+      const validKeys = [
+        "defaultModel",
+        "defaultTone",
+        "defaultLength",
+        "defaultCopyType",
+      ];
+
+      if (!validKeys.includes(key)) {
+        logger.error(`Invalid config key: ${key}`);
+        logger.info(`Valid keys: ${validKeys.join(", ")}`);
+        process.exit(1);
+      }
+
+      (cfg as unknown as Record<string, string>)[key] = value;
+      saveConfig(cfg);
+      logger.success(`Set ${key} = ${value}`);
+    });
+
+  config
+    .command("reset")
+    .description("Reset configuration to defaults")
+    .action(() => {
+      const defaultConfig: Config = {
+        defaultModel: "gpt-4o",
+        defaultTone: "professional",
+        defaultLength: "medium",
+        defaultCopyType: "sales-letter",
+      };
+
+      saveConfig(defaultConfig);
+      logger.success("Configuration reset to defaults");
+    });
+
+  config
+    .command("path")
+    .description("Show configuration file path")
+    .action(() => {
+      console.log(getConfigPath());
+    });
+}

package/skills/skill-salescopy/src/commands/generate.ts

@@ -0,0 +1,179 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import {
+  generateCopy,
+  generateVariations,
+  listCopyTypes,
+  listTones,
+} from "../lib/generator.js";
+import {
+  createSession,
+  loadSession,
+  addResultToSession,
+} from "../lib/storage.js";
+import { logger } from "../utils/logger.js";
+import type { CopyType, Tone, Length } from "../types/index.js";
+
+export function registerGenerateCommand(program: Command): void {
+  program
+    .command("generate")
+    .description("Generate sales copy for a product")
+    .requiredOption("-n, --name <name>", "Product name")
+    .requiredOption("-d, --description <description>", "Product description")
+    .option(
+      "-t, --type <type>",
+      "Copy type (sales-letter, landing-page, email-sequence, headline, bullet-points, call-to-action, testimonial-request, product-description)",
+      "sales-letter"
+    )
+    .option(
+      "--tone <tone>",
+      "Tone (professional, casual, urgent, friendly, authoritative, empathetic, humorous)",
+      "professional"
+    )
+    .option(
+      "-l, --length <length>",
+      "Length (short, medium, long)",
+      "medium"
+    )
+    .option("--template <template>", "Template ID to use (e.g., aida, pas, fab)")
+    .option("-f, --features <features>", "Comma-separated product features")
+    .option("-b, --benefits <benefits>", "Comma-separated product benefits")
+    .option("-p, --price <price>", "Product price")
+    .option("-a, --audience <audience>", "Target audience description")
+    .option("-i, --instructions <instructions>", "Custom instructions for the AI")
+    .option("-s, --session <sessionId>", "Add result to existing session")
+    .option("-v, --variations <count>", "Generate multiple variations", "1")
+    .option("-o, --output <file>", "Save output to file")
+    .option("-m, --model <model>", "OpenAI model to use", "gpt-4o")
+    .option("--json", "Output result as JSON")
+    .action(async (options) => {
+      try {
+        const copyType = options.type as CopyType;
+        const tone = options.tone as Tone;
+        const length = options.length as Length;
+        const variationCount = parseInt(options.variations, 10);
+
+        // Validate options
+        if (!listCopyTypes().includes(copyType)) {
+          logger.error(`Invalid copy type: ${copyType}`);
+          logger.info(`Valid types: ${listCopyTypes().join(", ")}`);
+          process.exit(1);
+        }
+
+        if (!listTones().includes(tone)) {
+          logger.error(`Invalid tone: ${tone}`);
+          logger.info(`Valid tones: ${listTones().join(", ")}`);
+          process.exit(1);
+        }
+
+        const product = {
+          name: options.name,
+          description: options.description,
+          features: options.features?.split(",").map((f: string) => f.trim()),
+          benefits: options.benefits?.split(",").map((b: string) => b.trim()),
+          price: options.price,
+          targetAudience: options.audience,
+        };
+
+        const request = {
+          product,
+          copyType,
+          tone,
+          length,
+          template: options.template,
+          customInstructions: options.instructions,
+        };
+
+        logger.header("Sales Copy Generator");
+        logger.label("Product", product.name);
+        logger.label("Type", copyType);
+        logger.label("Tone", tone);
+        logger.label("Length", length);
+        if (options.template) {
+          logger.label("Template", options.template);
+        }
+        logger.divider();
+
+        const config = {
+          provider: "openai" as const,
+          model: options.model,
+        };
+
+        let results;
+        if (variationCount > 1) {
+          logger.info(`Generating ${variationCount} variations...`);
+          results = await generateVariations(request, variationCount, config);
+        } else {
+          logger.info("Generating copy...");
+          const result = await generateCopy(request, config);
+          results = [result];
+        }
+
+        // Handle session
+        if (options.session) {
+          const session = loadSession(options.session);
+          if (!session) {
+            logger.error(`Session not found: ${options.session}`);
+          } else {
+            for (const result of results) {
+              addResultToSession(options.session, result);
+            }
+            logger.success(`Added ${results.length} result(s) to session ${options.session}`);
+          }
+        }
+
+        // Output results
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else {
+          for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (results.length > 1) {
+              console.log();
+              console.log(chalk.bold.cyan(`═══ Variation ${i + 1} ═══`));
+            }
+            console.log();
+            console.log(result.content);
+            console.log();
+            logger.divider();
+            logger.label("ID", result.id);
+            logger.label("Model", result.model);
+            logger.label("Generated", new Date(result.timestamp).toLocaleString());
+          }
+        }
+
+        // Save to file if requested
+        if (options.output) {
+          const fs = require("fs");
+          const content = results.map((r) => r.content).join("\n\n---\n\n");
+          fs.writeFileSync(options.output, content);
+          logger.success(`Saved to ${options.output}`);
+        }
+
+        logger.success("Copy generated successfully");
+      } catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("types")
+    .description("List available copy types")
+    .action(() => {
+      logger.header("Available Copy Types");
+      for (const type of listCopyTypes()) {
+        console.log(chalk.cyan("•"), type);
+      }
+    });
+
+  program
+    .command("tones")
+    .description("List available tones")
+    .action(() => {
+      logger.header("Available Tones");
+      for (const tone of listTones()) {
+        console.log(chalk.cyan("•"), tone);
+      }
+    });
+}

package/skills/skill-salescopy/src/commands/sessions.ts

@@ -0,0 +1,169 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import {
+  listSessions,
+  loadSession,
+  createSession,
+  deleteSession,
+} from "../lib/storage.js";
+import { logger } from "../utils/logger.js";
+
+export function registerSessionsCommand(program: Command): void {
+  const sessions = program
+    .command("sessions")
+    .description("Manage generation sessions");
+
+  sessions
+    .command("list")
+    .alias("ls")
+    .description("List all sessions")
+    .option("-n, --limit <count>", "Limit number of sessions", "10")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const sessionList = listSessions().slice(0, parseInt(options.limit, 10));
+
+      if (options.json) {
+        console.log(JSON.stringify(sessionList, null, 2));
+        return;
+      }
+
+      logger.header("Sessions");
+
+      if (sessionList.length === 0) {
+        logger.warning("No sessions found");
+        return;
+      }
+
+      for (const session of sessionList) {
+        console.log();
+        console.log(
+          chalk.bold.cyan(session.product.name),
+          chalk.gray(`(${session.id})`)
+        );
+        console.log(chalk.gray(session.product.description.slice(0, 80) + "..."));
+        console.log(chalk.yellow("Results:"), session.results.length);
+        console.log(
+          chalk.yellow("Updated:"),
+          new Date(session.updatedAt).toLocaleString()
+        );
+      }
+    });
+
+  sessions
+    .command("show <id>")
+    .description("Show session details")
+    .option("--json", "Output as JSON")
+    .action((id, options) => {
+      const session = loadSession(id);
+
+      if (!session) {
+        logger.error(`Session not found: ${id}`);
+        process.exit(1);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify(session, null, 2));
+        return;
+      }
+
+      logger.header(`Session: ${session.product.name}`);
+      logger.label("ID", session.id);
+      logger.label("Product", session.product.name);
+      logger.label("Description", session.product.description);
+      logger.label("Results", String(session.results.length));
+      logger.label("Created", new Date(session.createdAt).toLocaleString());
+      logger.label("Updated", new Date(session.updatedAt).toLocaleString());
+
+      if (session.results.length > 0) {
+        console.log();
+        console.log(chalk.bold("Results:"));
+        for (const result of session.results) {
+          logger.divider();
+          console.log(chalk.cyan("ID:"), result.id);
+          console.log(chalk.cyan("Type:"), result.copyType);
+          console.log(chalk.cyan("Tone:"), result.tone || "default");
+          console.log(chalk.cyan("Model:"), result.model);
+          console.log(
+            chalk.cyan("Generated:"),
+            new Date(result.timestamp).toLocaleString()
+          );
+          console.log();
+          console.log(result.content.slice(0, 200) + "...");
+        }
+      }
+    });
+
+  sessions
+    .command("create")
+    .description("Create a new session")
+    .requiredOption("-n, --name <name>", "Product name")
+    .requiredOption("-d, --description <description>", "Product description")
+    .action((options) => {
+      const session = createSession({
+        name: options.name,
+        description: options.description,
+      });
+
+      logger.success(`Session created: ${session.id}`);
+      console.log();
+      console.log(chalk.gray("Use this session ID with --session flag:"));
+      console.log(
+        chalk.cyan(
+          `  service-salescopygenerate generate -n "${options.name}" -d "..." --session ${session.id}`
+        )
+      );
+    });
+
+  sessions
+    .command("delete <id>")
+    .description("Delete a session")
+    .action((id) => {
+      const deleted = deleteSession(id);
+
+      if (deleted) {
+        logger.success(`Session deleted: ${id}`);
+      } else {
+        logger.error(`Session not found: ${id}`);
+        process.exit(1);
+      }
+    });
+
+  sessions
+    .command("export <id>")
+    .description("Export session results to file")
+    .requiredOption("-o, --output <file>", "Output file path")
+    .option("--format <format>", "Output format (txt, json, md)", "md")
+    .action((id, options) => {
+      const session = loadSession(id);
+
+      if (!session) {
+        logger.error(`Session not found: ${id}`);
+        process.exit(1);
+      }
+
+      const fs = require("fs");
+      let content: string;
+
+      switch (options.format) {
+        case "json":
+          content = JSON.stringify(session, null, 2);
+          break;
+        case "txt":
+          content = session.results.map((r) => r.content).join("\n\n---\n\n");
+          break;
+        case "md":
+        default:
+          content = `# ${session.product.name}\n\n`;
+          content += `${session.product.description}\n\n`;
+          for (const result of session.results) {
+            content += `## ${result.copyType} (${result.tone || "default"})\n\n`;
+            content += `${result.content}\n\n`;
+            content += `---\n\n`;
+          }
+          break;
+      }
+
+      fs.writeFileSync(options.output, content);
+      logger.success(`Exported to ${options.output}`);
+    });
+}