Social Card Gen

{
  "version": 1,
  "registry": "https://clawhub.ai",
  "slug": "social-card-gen",
  "installedVersion": "1.0.2",
  "installedAt": 1769882955927
}

Product update: onboarding improvements

Product update: onboarding improvements This week we shipped a guided onboarding checklist for new users. In testing, setup time dropped from 45 minutes to 28 minutes, and week-1 activation improved by 19%. The biggest win came from replacing long setup docs with short in-app prompts at the exact moment users needed each step.

#onboarding #setup #week #users

What are you seeing in your team?

I just read this and wanted to sanity-check my take: Product update: onboarding improvements This week we shipped a guided onboarding checklist for new users.

In testing, setup time dropped from 45 minutes to 28 minutes, and week-1 activation improved by 19%. The biggest win came from replacing long setup docs with short in-app prompts at the exact moment users needed each step.

Curious how others here handle this.

Quick take: Product update: onboarding improvements This week we shipped a guided onboarding checklist for new users. In testing, setup time dropped from 45 minutes to 28 minutes, and week-1 activation improved by 19%. The biggest win came...

#onboarding #setup #week
Thoughts?

#!/usr/bin/env node
'use strict';

const fs = require('node:fs');
const path = require('node:path');
const { extractKeywords, renderTemplate, PLATFORM_CONFIGS } = require('./templates');

function printHelp() {
  console.log(`social-card-gen\n\nUsage:\n  node generate.js [options]\n\nInput options (use one):\n  --text "..."           Raw text input\n  --file ./path.md        Read content from local file\n  --url https://...       Read content from URL\n\nOutput options:\n  --platforms list        Comma-separated: twitter,linkedin,reddit (default: all)\n  --outdir ./dir          Write files to directory (default: current directory)\n  --stdout                Print generated cards to stdout instead of files\n  --prefix output-        Output filename prefix (default: output-)\n  --title "Custom title" Override title extraction\n\nExamples:\n  node generate.js --text "We reduced deploy time by 42%" --stdout\n  node generate.js --file examples/input-example.md --outdir examples\n  node generate.js --url https://example.com/post --platforms twitter,linkedin --stdout\n`);
}

function parseArgs(argv) {
  const options = {
    platforms: ['twitter', 'linkedin', 'reddit'],
    outdir: process.cwd(),
    stdout: false,
    prefix: 'output-'
  };

  for (let i = 0; i < argv.length; i += 1) {
    const arg = argv[i];

    if (arg === '--help' || arg === '-h') {
      options.help = true;
      continue;
    }

    if (arg === '--text') {
      options.text = argv[++i];
      continue;
    }

    if (arg === '--file') {
      options.file = argv[++i];
      continue;
    }

    if (arg === '--url') {
      options.url = argv[++i];
      continue;
    }

    if (arg === '--platforms') {
      options.platforms = (argv[++i] || '')
        .split(',')
        .map((s) => s.trim().toLowerCase())
        .filter(Boolean);
      continue;
    }

    if (arg === '--outdir') {
      options.outdir = argv[++i];
      continue;
    }

    if (arg === '--stdout') {
      options.stdout = true;
      continue;
    }

    if (arg === '--prefix') {
      options.prefix = argv[++i] || 'output-';
      continue;
    }

    if (arg === '--title') {
      options.title = argv[++i];
      continue;
    }

    if (!arg.startsWith('--') && !options.text && !options.file && !options.url) {
      options.text = arg;
      continue;
    }

    throw new Error(`Unknown or incomplete argument: ${arg}`);
  }

  return options;
}

function stripMarkdownAndHtml(input) {
  return (input || '')
    .replace(/```[\s\S]*?```/g, ' ')
    .replace(/`([^`]+)`/g, '$1')
    .replace(/!\[[^\]]*\]\([^)]*\)/g, ' ')
    .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
    .replace(/<[^>]+>/g, ' ')
    .replace(/^#{1,6}\s+/gm, '')
    .replace(/^>\s?/gm, '')
    .replace(/\*\*([^*]+)\*\*/g, '$1')
    .replace(/\*([^*]+)\*/g, '$1')
    .replace(/\s+/g, ' ')
    .trim();
}

function toSentences(text) {
  return text
    .split(/(?<=[.!?])\s+/)
    .map((s) => s.trim())
    .filter((s) => s.length > 20);
}

function firstNonEmptyLine(raw) {
  const line = (raw || '')
    .split(/\r?\n/)
    .map((l) => l.trim())
    .find(Boolean);
  if (!line) return 'Content update';
  return line.replace(/^#{1,6}\s+/, '').trim();
}

function composeContext(rawInput, cleanedText, options) {
  const sentences = toSentences(cleanedText);
  const s1 = sentences[0] || cleanedText;
  const s2 = sentences[1] || '';
  const s3 = sentences[2] || '';
  const title = options.title || firstNonEmptyLine(rawInput).slice(0, 90);
  const keywords = extractKeywords(cleanedText, 8);

  return {
    title,
    hook: `Quick take: ${s1}`,
    corePoint: [s2, s3].filter(Boolean).join(' '),
    professionalSummary: [s1, s2, s3].filter(Boolean).join(' '),
    redditIntro: `I just read this and wanted to sanity-check my take: ${s1}`,
    redditBody: [s2, s3].filter(Boolean).join(' '),
    sourceUrl: options.url || '',
    keywords
  };
}

async function readFromStdinIfAvailable() {
  if (process.stdin.isTTY) return '';

  return new Promise((resolve, reject) => {
    let data = '';
    process.stdin.setEncoding('utf8');
    process.stdin.on('data', (chunk) => {
      data += chunk;
    });
    process.stdin.on('end', () => resolve(data));
    process.stdin.on('error', reject);
  });
}

async function loadInput(options) {
  if (options.text) {
    return options.text;
  }

  if (options.file) {
    return fs.readFileSync(path.resolve(options.file), 'utf8');
  }

  if (options.url) {
    const response = await fetch(options.url);
    if (!response.ok) {
      throw new Error(`Failed to fetch URL (${response.status}): ${options.url}`);
    }
    return response.text();
  }

  const stdinValue = await readFromStdinIfAvailable();
  if (stdinValue.trim()) {
    return stdinValue;
  }

  throw new Error('No input provided. Use --text, --file, --url, or pipe data via stdin.');
}

function validatePlatforms(platforms) {
  const supported = new Set(Object.keys(PLATFORM_CONFIGS));
  const invalid = platforms.filter((p) => !supported.has(p));

  if (invalid.length > 0) {
    throw new Error(`Unsupported platforms: ${invalid.join(', ')}`);
  }

  if (platforms.length === 0) {
    throw new Error('No platforms selected. Use --platforms twitter,linkedin,reddit');
  }
}

function writeOutputs(results, options) {
  if (options.stdout) {
    for (const { platform, text } of results) {
      process.stdout.write(`\n=== ${platform.toUpperCase()} ===\n${text}\n`);
    }
    return;
  }

  fs.mkdirSync(path.resolve(options.outdir), { recursive: true });
  for (const { platform, text } of results) {
    const fileName = `${options.prefix}${platform}.txt`;
    const filePath = path.join(path.resolve(options.outdir), fileName);
    fs.writeFileSync(filePath, `${text}\n`, 'utf8');
  }
}

async function main() {
  const options = parseArgs(process.argv.slice(2));
  if (options.help) {
    printHelp();
    return;
  }

  validatePlatforms(options.platforms);

  const rawInput = await loadInput(options);
  const cleanedText = stripMarkdownAndHtml(rawInput);
  if (!cleanedText) {
    throw new Error('Input resolved to empty text after cleaning.');
  }

  const context = composeContext(rawInput, cleanedText, options);
  const results = options.platforms.map((platform) => ({
    platform,
    text: renderTemplate(platform, context)
  }));

  writeOutputs(results, options);
}

main().catch((err) => {
  console.error(`Error: ${err.message}`);
  process.exit(1);
});

{
  "name": "social-card-gen",
  "version": "1.0.0",
  "description": "Offline social post generator for Twitter, LinkedIn, and Reddit",
  "main": "generate.js",
  "bin": {
    "social-card-gen": "generate.js"
  },
  "scripts": {
    "generate:examples": "node generate.js --file examples/input-example.md --outdir examples"
  },
  "keywords": [
    "social",
    "content",
    "twitter",
    "linkedin",
    "reddit",
    "generator"
  ],
  "license": "MIT",
  "dependencies": {}
}

'use strict';

const PLATFORM_CONFIGS = {
  twitter: {
    name: 'Twitter',
    characterLimit: 280,
    tone: 'punchy',
    toneGuideline: 'Lead with the hook, keep it tight, and make every sentence earn space.',
    hashtagStrategy: 'Use 1-3 topical hashtags. Keep them short and specific.',
    ctaFormat: 'Short imperative CTA (e.g., Read more:, Try this:, What do you think?)'
  },
  linkedin: {
    name: 'LinkedIn',
    characterLimit: 3000,
    tone: 'professional',
    toneGuideline: 'Use a clear business outcome, practical framing, and credible language.',
    hashtagStrategy: 'Use 2-5 industry hashtags at the end. Prefer category tags over memes.',
    ctaFormat: 'Professional prompt CTA (e.g., What are you seeing in your team?)'
  },
  reddit: {
    name: 'Reddit',
    characterLimit: null,
    tone: 'authentic',
    toneGuideline: 'Write like a real person: direct, candid, and discussion-friendly.',
    hashtagStrategy: 'Avoid hashtag spam. Usually 0 hashtags; optionally one if it adds context.',
    ctaFormat: 'Open-ended discussion question (e.g., Curious how others approach this.)'
  }
};

const STOPWORDS = new Set([
  'a', 'an', 'the', 'and', 'or', 'but', 'if', 'then', 'than', 'that', 'this', 'those', 'these',
  'to', 'for', 'of', 'on', 'in', 'at', 'with', 'by', 'from', 'as', 'is', 'are', 'was', 'were',
  'be', 'been', 'being', 'it', 'its', 'into', 'about', 'over', 'under', 'after', 'before',
  'we', 'you', 'they', 'our', 'your', 'their', 'i', 'he', 'she', 'them', 'us', 'can', 'could',
  'should', 'would', 'will', 'just', 'very', 'more', 'most', 'much', 'many', 'also'
]);

function extractKeywords(text, maxKeywords = 6) {
  const words = (text || '')
    .toLowerCase()
    .replace(/[^a-z0-9\s]/g, ' ')
    .split(/\s+/)
    .filter((word) => word.length > 2 && !STOPWORDS.has(word));

  const counts = new Map();
  for (const word of words) {
    counts.set(word, (counts.get(word) || 0) + 1);
  }

  return [...counts.entries()]
    .sort((a, b) => b[1] - a[1])
    .slice(0, maxKeywords)
    .map(([word]) => word);
}

function toHashtag(term) {
  const cleaned = term.replace(/[^a-z0-9]/gi, ' ').trim();
  if (!cleaned) return '';

  const parts = cleaned.split(/\s+/);
  const formatted = parts
    .map((part, index) => {
      if (index === 0) return part.toLowerCase();
      return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
    })
    .join('');

  return `#${formatted}`;
}

function enforceCharacterLimit(text, limit) {
  if (!limit || text.length <= limit) return text;

  const suffix = '...';
  const hardLimit = Math.max(0, limit - suffix.length);
  const trimmed = text.slice(0, hardLimit);
  const safeTrimmed = trimmed.slice(0, Math.max(0, trimmed.lastIndexOf(' ')));
  const output = (safeTrimmed || trimmed).trimEnd();
  return `${output}${suffix}`;
}

function buildHashtags(platform, keywords) {
  if (!keywords.length) return '';

  if (platform === 'twitter') {
    return keywords.slice(0, 3).map(toHashtag).filter(Boolean).join(' ');
  }

  if (platform === 'linkedin') {
    return keywords.slice(0, 4).map(toHashtag).filter(Boolean).join(' ');
  }

  if (platform === 'reddit') {
    return ''; // Reddit style avoids hashtag clutter by default.
  }

  return '';
}

function buildCTA(platform, sourceUrl) {
  if (platform === 'twitter') {
    return sourceUrl ? `Read more: ${sourceUrl}` : 'Thoughts?';
  }

  if (platform === 'linkedin') {
    return sourceUrl
      ? `Full details: ${sourceUrl}\n\nWhat are you seeing in your team?`
      : 'What are you seeing in your team?';
  }

  if (platform === 'reddit') {
    return sourceUrl
      ? `If you want the full context: ${sourceUrl}\n\nCurious how others here handle this.`
      : 'Curious how others here handle this.';
  }

  return '';
}

function renderTemplate(platform, context) {
  const config = PLATFORM_CONFIGS[platform];
  if (!config) {
    throw new Error(`Unsupported platform: ${platform}`);
  }

  const hashtags = buildHashtags(platform, context.keywords || []);
  const cta = buildCTA(platform, context.sourceUrl);

  let text;
  if (platform === 'twitter') {
    const tailLines = [hashtags, cta].filter(Boolean);
    const tail = tailLines.join('\n');
    const reserved = tail ? tail.length + 2 : 0; // account for separating newlines
    const maxBodyLength = Math.max(0, (config.characterLimit || 280) - reserved);
    const body = enforceCharacterLimit(
      [context.hook, context.corePoint].filter(Boolean).join(' ').trim(),
      maxBodyLength
    );
    text = tail ? `${body}\n\n${tail}` : body;
  } else if (platform === 'linkedin') {
    text = `${context.title}\n\n${context.professionalSummary}\n\n${hashtags}`.trim();
    text = `${text}\n\n${cta}`.trim();
  } else {
    text = `${context.redditIntro}\n\n${context.redditBody}\n\n${cta}`.trim();
  }

  return enforceCharacterLimit(text, config.characterLimit);
}

module.exports = {
  PLATFORM_CONFIGS,
  extractKeywords,
  enforceCharacterLimit,
  renderTemplate
};