marketing-selling-point-generator

const { SellingPointFinder } = require('./src/finder');
 
const finder = new SellingPointFinder();
 
// Analyze product attributes
const productData = {
  name: "Smart Wireless Earbuds Pro",
  features: [
    "Active Noise Cancellation",
    "40-hour battery life",
    "IPX7 waterproof",
    "Bluetooth 5.3"
  ],
  price: 99.99,
  category: "Audio"
};
 
const attributePoints = await finder.analyzeAttributes(productData);
// Returns structured selling points based on features

# Python equivalent
from src.finder import SellingPointFinder
 
finder = SellingPointFinder()
 
product_data = {
    "name": "Smart Wireless Earbuds Pro",
    "features": [
        "Active Noise Cancellation",
        "40-hour battery life",
        "IPX7 waterproof",
        "Bluetooth 5.3"
    ],
    "price": 99.99,
    "category": "Audio"
}
 
attribute_points = finder.analyze_attributes(product_data)

// Compare with competitors
const competitorData = [
  { name: "Brand X Earbuds", price: 129.99, battery: "30 hours" },
  { name: "Brand Y Pods", price: 89.99, battery: "24 hours" }
];
 
const competitivePoints = await finder.compareCompetitors(
  productData,
  competitorData
);
// Returns: differentiation advantages like "33% longer battery vs competitors"

const reviews = [
  "Amazing battery life, lasts all week!",
  "Sound quality is incredible for the price",
  "Finally earbuds that survive my workouts"
];
 
const userInsights = await finder.analyzeReviews(reviews);
// Extracts: key value points users actually care about

const targetAudience = {
  segment: "fitness enthusiasts",
  painPoints: [
    "Earbuds fall out during exercise",
    "Battery dies mid-workout",
    "Not sweat-resistant"
  ]
};
 
const painPointMap = await finder.mapPainPoints(productData, targetAudience);
// Maps product features to solved pain points

const { SellingPointRanker } = require('./src/ranker');
 
const ranker = new SellingPointRanker();
 
const allPoints = [
  ...attributePoints,
  ...competitivePoints,
  ...userInsights,
  ...painPointMap
];
 
// Score by differentiation
const scoredPoints = await ranker.scoreDifferentiation(allPoints);
// Returns points sorted by competitive advantage strength
 
// Match to target audience
const audienceConfig = {
  demographic: "25-35, fitness-focused professionals",
  values: ["performance", "durability", "convenience"],
  channels: ["Instagram", "fitness forums"]
};
 
const audienceMatched = await ranker.matchAudience(scoredPoints, audienceConfig);
 
// Evaluate by scenario
const scenarios = ["gym workout", "daily commute", "work calls"];
const scenarioScores = await ranker.evaluateScenarios(audienceMatched, scenarios);
 
// Predict viral potential
const viralityScores = await ranker.predictVirality(scenarioScores);

# Python equivalent
from src.ranker import SellingPointRanker
 
ranker = SellingPointRanker()
 
scored_points = ranker.score_differentiation(all_points)
audience_matched = ranker.match_audience(scored_points, audience_config)
scenario_scores = ranker.evaluate_scenarios(audience_matched, scenarios)
virality_scores = ranker.predict_virality(scenario_scores)

const { CopyWriter } = require('./src/writer');
 
const writer = new CopyWriter();
 
const topPoints = viralityScores.slice(0, 5);
 
// FAB (Features-Advantages-Benefits) transformation
const fabCopy = await writer.transformFAB(topPoints[0]);
// Input: "40-hour battery life"
// Output: {
//   feature: "40-hour battery life",
//   advantage: "5x longer than typical earbuds",
//   benefit: "Charge once a week, not every day"
// }
 
// Emotion hook design
const emotionHooks = await writer.createEmotionHooks(topPoints, {
  emotions: ["relief", "excitement", "confidence"]
});
// Returns: "Never ask 'Are my earbuds charged?' again"
 
// Platform-specific copy
const platformCopy = await writer.adaptToPlatform(topPoints, {
  platform: "ecommerce",
  maxLength: 150,
  includeCTA: true
});
 
// E-commerce example
console.log(platformCopy.ecommerce);
// "40-hour battery. IPX7 waterproof. Premium sound at half the price. 
//  Your all-day, every-workout companion. Shop Now →"
 
// Social media version
const socialCopy = await writer.adaptToPlatform(topPoints, {
  platform: "instagram",
  style: "casual",
  includeEmoji: true
});
 
console.log(socialCopy.instagram);
// "Charge once. Play all week. 🔋💪 
//  40 hours of battery = zero anxiety. #NeverDie"

const abVariants = await writer.generateABVariants(topPoints[0], {
  count: 3,
  variables: ["headline", "cta", "emotional_angle"]
});
 
console.log(abVariants);
// [
//   { headline: "Battery that lasts as long as you do", cta: "Shop Now" },
//   { headline: "40 hours of pure freedom", cta: "Get Yours" },
//   { headline: "Never cut your workout short again", cta: "Try It" }
// ]

{
  "platform": "ecommerce",
  "style": "professional",
  "max_points": 5,
  "include_emotion_hook": true,
  "include_cta": true,
  "target_audience": {
    "age_range": "25-45",
    "interests": ["fitness", "technology"],
    "pain_points": ["battery anxiety", "durability concerns"]
  },
  "brand_voice": {
    "tone": "confident but approachable",
    "avoid": ["technical jargon", "hype"],
    "emphasize": ["reliability", "value"]
  },
  "output_formats": ["short_bullet", "long_description", "social_caption"]
}

const { loadConfig } = require('./src/config');
 
const config = loadConfig('./config.json');
const writer = new CopyWriter(config);

const { 
  SellingPointFinder, 
  SellingPointRanker, 
  CopyWriter 
} = require('./src');
 
async function generateMarketingCopy(productData, competitorData, reviews) {
  // Phase 1: Find
  const finder = new SellingPointFinder();
  const attributePoints = await finder.analyzeAttributes(productData);
  const competitivePoints = await finder.compareCompetitors(
    productData, 
    competitorData
  );
  const userPoints = await finder.analyzeReviews(reviews);
  
  // Phase 2: Define
  const ranker = new SellingPointRanker();
  const allPoints = [...attributePoints, ...competitivePoints, ...userPoints];
  const scoredPoints = await ranker.scoreDifferentiation(allPoints);
  const topPoints = scoredPoints.slice(0, 5);
  
  // Phase 3: Write
  const writer = new CopyWriter({
    platform: 'ecommerce',
    style: 'professional',
    include_cta: true
  });
  
  const marketingCopy = {
    mainHeadline: await writer.createEmotionHooks([topPoints[0]]),
    bulletPoints: await Promise.all(
      topPoints.map(p => writer.transformFAB(p))
    ),
    platformCopy: await writer.adaptToPlatform(topPoints, {
      platform: 'ecommerce',
      maxLength: 200
    }),
    abVariants: await writer.generateABVariants(topPoints[0], { count: 3 })
  };
  
  return marketingCopy;
}
 
// Usage
const result = await generateMarketingCopy(
  productData,
  competitorData,
  reviews
);
 
console.log(result);

const { quickGenerate } = require('./src/quick');
 
const description = await quickGenerate({
  productName: "Smart Wireless Earbuds Pro",
  keyFeatures: ["40h battery", "ANC", "IPX7"],
  targetPlatform: "amazon"
});
 
// Returns optimized Amazon listing copy

const platforms = ['ecommerce', 'instagram', 'facebook_ad', 'google_ad'];
 
const campaign = await Promise.all(
  platforms.map(platform => 
    writer.adaptToPlatform(topPoints, { 
      platform, 
      style: 'casual' 
    })
  )
);
 
const campaignPack = Object.fromEntries(
  platforms.map((p, i) => [p, campaign[i]])
);

const positioning = await finder.generatePositioningStatement({
  product: productData,
  competitors: competitorData,
  targetAudience: "fitness enthusiasts",
  keyDifferentiator: "battery life"
});
 
// Returns: "For fitness enthusiasts who need reliable audio, 
//  Smart Earbuds Pro offers 40-hour battery life—33% longer 
//  than leading competitors—so you never miss a beat."

# .env file
OPENAI_API_KEY=your_openai_key_here
ANALYSIS_MODEL=gpt-4
COPY_MODEL=gpt-3.5-turbo
MAX_TOKENS=500
TEMPERATURE=0.7

require('dotenv').config();
 
const writer = new CopyWriter({
  apiKey: process.env.OPENAI_API_KEY,
  model: process.env.COPY_MODEL,
  temperature: parseFloat(process.env.TEMPERATURE)
});

// ❌ Too generic
const productData = { name: "Earbuds", features: ["wireless"] };
 
// ✅ Specific
const productData = {
  name: "Smart Wireless Earbuds Pro",
  features: [
    { name: "ANC", spec: "35dB reduction", userBenefit: "blocks gym noise" },
    { name: "Battery", spec: "40 hours", userBenefit: "weekly charging" }
  ],
  targetScenarios: ["gym", "commute", "work calls"]
};

const audienceConfig = {
  demographic: "25-35, urban professionals",
  psychographic: "values efficiency and quality",
  painPoints: ["battery anxiety", "poor call quality"],
  desiredOutcomes: ["all-day reliability", "professional sound"],
  influencers: ["tech reviewers", "fitness influencers"]
};
 
const matched = await ranker.matchAudience(points, audienceConfig);

const twitterCopy = await writer.adaptToPlatform(points, {
  platform: 'twitter',
  maxLength: 280,
  enforceStrict: true, // Cuts off at limit
  priorityPoints: [points[0], points[1]] // Focus on top 2
});

const chineseCopy = await writer.adaptToPlatform(points, {
  platform: 'ecommerce',
  language: 'zh-CN',
  culturalContext: 'China market preferences'
});

const ranker = new SellingPointRanker({
  weights: {
    differentiation: 0.4,
    audienceMatch: 0.3,
    virality: 0.2,
    feasibility: 0.1
  }
});

const products = [product1, product2, product3];
 
const batchResults = await Promise.all(
  products.map(p => generateMarketingCopy(p, competitors, reviews))
);

const { exportToCSV, exportToJSON } = require('./src/export');
 
await exportToCSV(marketingCopy, './output/copy.csv');
await exportToJSON(campaignPack, './output/campaign.json');