@tpmjs/pricing-page-copy 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 TPMJS
+
+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/dist/index.d.ts

@@ -0,0 +1,67 @@
+import * as ai from 'ai';
+
+/**
+ * Pricing Page Copy Tool for TPMJS
+ * Generates pricing page copy with tier names, feature lists, and CTAs
+ *
+ * This is a proper AI SDK v6 tool that can be used with streamText()
+ * Uses jsonSchema() to avoid Zod 4 JSON Schema conversion issues with OpenAI
+ */
+interface PricingTier {
+    name: string;
+    headline: string;
+    price: string;
+    billingPeriod: string;
+    features: Array<{
+        text: string;
+        benefit: string;
+        included: boolean;
+    }>;
+    cta: string;
+    recommended?: boolean;
+    badge?: string;
+    valueProposition: string;
+}
+interface PricingPageCopy {
+    pageHeadline: string;
+    pageSubheadline: string;
+    tiers: PricingTier[];
+    faq: Array<{
+        question: string;
+        answer: string;
+    }>;
+    trustSignals: string[];
+    guarantee?: string;
+}
+/**
+ * Input type for Pricing Page Copy Tool
+ */
+type PricingPageCopyInput = {
+    tiers: Array<{
+        name?: string;
+        price: number | string;
+        billingPeriod?: string;
+        features: string[];
+        recommended?: boolean;
+    }>;
+    targetAudience: string;
+};
+/**
+ * Pricing Page Copy Tool
+ * Generates pricing page copy with tier names, feature lists, and CTAs
+ *
+ * This is a proper AI SDK v6 tool that can be used with streamText()
+ */
+declare const pricingPageCopyTool: ai.Tool<PricingPageCopyInput, {
+    pageHeadline: string;
+    pageSubheadline: string;
+    tiers: PricingTier[];
+    faq: {
+        question: string;
+        answer: string;
+    }[];
+    trustSignals: string[];
+    guarantee: string;
+}>;
+
+export { type PricingPageCopy, type PricingTier, pricingPageCopyTool as default, pricingPageCopyTool };

package/dist/index.js

@@ -0,0 +1,287 @@
+import { tool, jsonSchema } from 'ai';
+
+// src/index.ts
+function generateTierName(index, totalTiers, providedName) {
+  if (providedName) return providedName;
+  const tierNames = [
+    ["Free", "Pro", "Enterprise"],
+    ["Basic", "Professional", "Business", "Enterprise"],
+    ["Starter", "Growth", "Scale", "Enterprise"],
+    ["Essential", "Advanced", "Premium", "Ultimate"]
+  ];
+  const nameSet = tierNames.find((set) => set.length === totalTiers) || tierNames[1];
+  return nameSet?.[index] || `Tier ${index + 1}`;
+}
+function generateHeadline(tierName, index, totalTiers) {
+  const headlines = {
+    free: "Get started for free",
+    starter: "Perfect for individuals",
+    basic: "Essential features for getting started",
+    pro: "For growing teams",
+    professional: "Advanced features for professionals",
+    growth: "Scale your business",
+    business: "Built for businesses",
+    scale: "Enterprise-grade features",
+    premium: "Premium features and support",
+    enterprise: "Custom solutions for large teams",
+    ultimate: "Everything you need and more"
+  };
+  const nameLower = tierName.toLowerCase();
+  for (const [key, headline] of Object.entries(headlines)) {
+    if (nameLower.includes(key)) {
+      return headline;
+    }
+  }
+  if (index === 0) return "Perfect for getting started";
+  if (index === totalTiers - 1) return "Maximum power and flexibility";
+  return "Best for growing teams";
+}
+function featureToBenefit(feature) {
+  const featureLower = feature.toLowerCase();
+  if (featureLower.includes("unlimited")) {
+    return "Never worry about limits";
+  }
+  if (featureLower.includes("24/7") || featureLower.includes("support")) {
+    return "Get help whenever you need it";
+  }
+  if (featureLower.includes("analytics") || featureLower.includes("reporting")) {
+    return "Make data-driven decisions";
+  }
+  if (featureLower.includes("integration")) {
+    return "Work seamlessly with your tools";
+  }
+  if (featureLower.includes("storage")) {
+    return "Store all your important data";
+  }
+  if (featureLower.includes("user") || featureLower.includes("seat")) {
+    return "Collaborate with your team";
+  }
+  if (featureLower.includes("custom")) {
+    return "Tailored to your needs";
+  }
+  if (featureLower.includes("priority")) {
+    return "Get faster service";
+  }
+  if (featureLower.includes("backup")) {
+    return "Keep your data safe";
+  }
+  if (featureLower.includes("security")) {
+    return "Protect your information";
+  }
+  return "Enhance your workflow";
+}
+function generateCTA(tierName, price, index) {
+  const isFree = price === 0 || price === "0" || String(price).toLowerCase().includes("free");
+  if (isFree) {
+    return "Start for free";
+  }
+  const nameLower = tierName.toLowerCase();
+  if (nameLower.includes("enterprise") || nameLower.includes("custom")) {
+    return "Contact sales";
+  }
+  if (index === 0) {
+    return "Get started";
+  }
+  return "Start free trial";
+}
+function generateBadge(tierName, recommended) {
+  if (recommended) {
+    return "Most Popular";
+  }
+  const nameLower = tierName.toLowerCase();
+  if (nameLower.includes("pro") || nameLower.includes("professional")) {
+    return "Best Value";
+  }
+  return void 0;
+}
+function generateValueProposition(tierName, features, targetAudience) {
+  const nameLower = tierName.toLowerCase();
+  if (nameLower.includes("free") || nameLower.includes("starter")) {
+    return `Perfect for ${targetAudience} just getting started`;
+  }
+  if (nameLower.includes("enterprise")) {
+    return `Comprehensive solution for large-scale ${targetAudience}`;
+  }
+  const featureCount = features.length;
+  return `Everything ${targetAudience} need${targetAudience.endsWith("s") ? "" : "s"} with ${featureCount}+ features`;
+}
+function formatPrice(price, billingPeriod) {
+  const priceNum = typeof price === "string" ? Number.parseFloat(price) : price;
+  if (isNaN(priceNum)) {
+    return String(price);
+  }
+  if (priceNum === 0) {
+    return "Free";
+  }
+  const formatted = `$${priceNum.toFixed(0)}`;
+  return billingPeriod ? `${formatted}/${billingPeriod}` : formatted;
+}
+function determineBillingPeriod(providedPeriod) {
+  if (providedPeriod) return providedPeriod;
+  return "month";
+}
+function processFeaturesWithBenefits(features, _tierIndex, _allTierFeatures) {
+  return features.map((feature) => ({
+    text: feature,
+    benefit: featureToBenefit(feature),
+    included: true
+  }));
+}
+function generatePageHeadline(targetAudience) {
+  return `Simple, transparent pricing for ${targetAudience}`;
+}
+function generatePageSubheadline(tierCount) {
+  if (tierCount === 1) {
+    return "One simple plan with everything you need";
+  }
+  if (tierCount === 2) {
+    return "Choose the plan that fits your needs";
+  }
+  return "Choose the plan that's right for you. All plans include a 14-day free trial.";
+}
+function generateFAQ(tiers, _targetAudience) {
+  const faq = [];
+  faq.push({
+    question: "Can I change plans later?",
+    answer: "Yes! You can upgrade or downgrade your plan at any time. Changes take effect immediately."
+  });
+  const hasTrial = tiers.some((tier) => tier.cta.toLowerCase().includes("trial"));
+  if (hasTrial) {
+    faq.push({
+      question: "What happens after the free trial?",
+      answer: "After your 14-day free trial, you'll be charged for your selected plan. Cancel anytime during the trial at no cost."
+    });
+  }
+  const hasEnterprise = tiers.some((tier) => tier.name.toLowerCase().includes("enterprise"));
+  if (hasEnterprise) {
+    faq.push({
+      question: "What's included in the Enterprise plan?",
+      answer: "Enterprise plans include custom features, dedicated support, advanced security, and volume pricing. Contact our sales team for details."
+    });
+  }
+  faq.push({
+    question: "Do you offer discounts?",
+    answer: "Yes! We offer discounts for annual billing, nonprofits, and educational institutions. Contact us for details."
+  });
+  faq.push({
+    question: "Is my data secure?",
+    answer: "Absolutely. We use industry-standard encryption and security practices to protect your data. All plans include secure data storage."
+  });
+  return faq;
+}
+function generateTrustSignals(tiers) {
+  const signals = [
+    "14-day free trial, no credit card required",
+    "Cancel anytime",
+    "Secure payment processing"
+  ];
+  const hasEnterprise = tiers.some((tier) => tier.name.toLowerCase().includes("enterprise"));
+  if (hasEnterprise) {
+    signals.push("Dedicated account manager for Enterprise");
+  }
+  signals.push("99.9% uptime SLA");
+  signals.push("24/7 customer support");
+  return signals;
+}
+function generateGuarantee() {
+  return "30-day money-back guarantee. If you're not satisfied, we'll refund your purchase, no questions asked.";
+}
+var pricingPageCopyTool = tool({
+  description: "Generates comprehensive pricing page copy with tier names, headlines, benefit-oriented feature lists, CTAs, FAQs, and trust signals. Frames features as benefits and clearly differentiates tiers.",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      tiers: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Tier name (optional, will be generated if not provided)"
+            },
+            price: {
+              oneOf: [{ type: "number" }, { type: "string" }],
+              description: 'Price amount (number or "custom", "free", etc.)'
+            },
+            billingPeriod: {
+              type: "string",
+              description: "Billing period (month, year, etc.)"
+            },
+            features: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of features included in this tier"
+            },
+            recommended: {
+              type: "boolean",
+              description: "Whether this tier is recommended/most popular"
+            }
+          },
+          required: ["price", "features"]
+        },
+        minItems: 1,
+        description: "Pricing tiers with features and prices"
+      },
+      targetAudience: {
+        type: "string",
+        description: 'Primary target audience (e.g., "small businesses", "developers", "teams")'
+      }
+    },
+    required: ["tiers", "targetAudience"],
+    additionalProperties: false
+  }),
+  async execute({ tiers, targetAudience }) {
+    if (!tiers || tiers.length === 0) {
+      throw new Error("At least one pricing tier is required");
+    }
+    if (!targetAudience || targetAudience.trim().length === 0) {
+      throw new Error("Target audience is required");
+    }
+    for (const tier of tiers) {
+      if (!tier.features || tier.features.length === 0) {
+        throw new Error("Each tier must have at least one feature");
+      }
+    }
+    tiers.map((t) => t.features);
+    const processedTiers = tiers.map(
+      (tier, index) => {
+        const name = generateTierName(index, tiers.length, tier.name);
+        const headline = generateHeadline(name, index, tiers.length);
+        const billingPeriod = determineBillingPeriod(tier.billingPeriod);
+        const price = formatPrice(tier.price, billingPeriod);
+        const features = processFeaturesWithBenefits(tier.features);
+        const cta = generateCTA(name, tier.price, index);
+        const badge = generateBadge(name, tier.recommended);
+        const valueProposition = generateValueProposition(name, tier.features, targetAudience);
+        return {
+          name,
+          headline,
+          price,
+          billingPeriod,
+          features,
+          cta,
+          recommended: tier.recommended,
+          badge,
+          valueProposition
+        };
+      }
+    );
+    const pageHeadline = generatePageHeadline(targetAudience);
+    const pageSubheadline = generatePageSubheadline(tiers.length);
+    const faq = generateFAQ(processedTiers);
+    const trustSignals = generateTrustSignals(processedTiers);
+    const guarantee = generateGuarantee();
+    return {
+      pageHeadline,
+      pageSubheadline,
+      tiers: processedTiers,
+      faq,
+      trustSignals,
+      guarantee
+    };
+  }
+});
+var index_default = pricingPageCopyTool;
+
+export { index_default as default, pricingPageCopyTool };

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@tpmjs/pricing-page-copy",
+  "version": "0.1.0",
+  "description": "Generate pricing page copy with tier names, feature lists, and CTAs",
+  "type": "module",
+  "keywords": [
+    "tpmjs",
+    "pricing",
+    "marketing",
+    "copywriting",
+    "ai"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.9.3",
+    "@tpmjs/tsconfig": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ajaxdavis/tpmjs.git",
+    "directory": "packages/tools/official/pricing-page-copy"
+  },
+  "homepage": "https://tpmjs.com",
+  "license": "MIT",
+  "tpmjs": {
+    "category": "marketing",
+    "frameworks": [
+      "vercel-ai"
+    ],
+    "tools": [
+      {
+        "exportName": "pricingPageCopyTool",
+        "description": "Generates comprehensive pricing page copy with tier names, headlines, benefit-oriented feature lists, CTAs, FAQs, and trust signals. Frames features as benefits and clearly differentiates tiers.",
+        "parameters": [
+          {
+            "name": "tiers",
+            "type": "object[]",
+            "description": "Pricing tiers with features and prices. Each tier should have: name (optional), price (number or string), billingPeriod (optional), features (string[]), recommended (optional boolean)",
+            "required": true
+          },
+          {
+            "name": "targetAudience",
+            "type": "string",
+            "description": "Primary target audience (e.g., 'small businesses', 'developers', 'teams')",
+            "required": true
+          }
+        ],
+        "returns": {
+          "type": "PricingPageCopy",
+          "description": "Complete pricing page copy with page headline/subheadline, processed tiers (with names, headlines, benefit-oriented features, CTAs, badges), FAQs, trust signals, and guarantee"
+        },
+        "aiAgent": {
+          "useCase": "Use this tool when users need to create pricing page copy for their products or services. Automatically generates benefit-oriented copy, tier differentiation, and conversion-focused CTAs.",
+          "limitations": "Generates copy structure and suggestions, not actual product pricing strategy. Copy should be reviewed and customized based on brand voice and specific product details.",
+          "examples": [
+            "Generate pricing page copy for our SaaS product with 3 tiers",
+            "Create pricing copy for small business audience with Free, Pro, and Enterprise plans",
+            "Build a pricing page for our API product targeting developers"
+          ]
+        }
+      }
+    ]
+  },
+  "dependencies": {
+    "ai": "6.0.0-beta.124"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  }
+}