foundrycms 0.1.0

package/dist/plugins/growth.js

@@ -0,0 +1,668 @@
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Scout — Prospect Discovery
+// ---------------------------------------------------------------------------
+export const scoutPlugin = {
+    id: '@foundry/scout',
+    name: 'Scout',
+    version: '1.0.0',
+    description: 'Prospect discovery engine with lead scoring, company lookup, and outreach automation',
+    requires: ['@foundry/compass'],
+    adminPages: [
+        {
+            path: 'scout',
+            label: 'Prospects',
+            icon: 'search',
+            component: 'ScoutDashboardPage',
+            order: 20,
+            permission: 'scout:view',
+            children: [
+                {
+                    path: 'search',
+                    label: 'Search',
+                    component: 'ScoutSearchPage',
+                    permission: 'scout:search',
+                },
+                {
+                    path: 'lists',
+                    label: 'Lists',
+                    component: 'ScoutListsPage',
+                    permission: 'scout:view',
+                },
+                {
+                    path: 'enrichment',
+                    label: 'Enrichment',
+                    component: 'ScoutEnrichmentPage',
+                    permission: 'scout:enrich',
+                },
+                {
+                    path: 'outreach',
+                    label: 'Outreach',
+                    component: 'ScoutOutreachPage',
+                    permission: 'scout:outreach',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'POST',
+            path: '/api/scout/search',
+            handler: 'scout.searchProspects',
+            middleware: ['auth', 'permission:scout:search'],
+            description: 'Search for prospects by industry, location, size',
+        },
+        {
+            method: 'POST',
+            path: '/api/scout/enrich',
+            handler: 'scout.enrichProspect',
+            middleware: ['auth', 'permission:scout:enrich'],
+            description: 'Enrich a prospect with additional data',
+        },
+        {
+            method: 'POST',
+            path: '/api/scout/score',
+            handler: 'scout.scoreProspect',
+            middleware: ['auth'],
+            description: 'Calculate lead score for a prospect',
+        },
+        {
+            method: 'GET',
+            path: '/api/scout/lists',
+            handler: 'scout.getLists',
+            middleware: ['auth'],
+            description: 'Get all prospect lists',
+        },
+        {
+            method: 'POST',
+            path: '/api/scout/lists/:id/export',
+            handler: 'scout.exportList',
+            middleware: ['auth', 'permission:scout:export'],
+            description: 'Export a prospect list to CSV',
+        },
+    ],
+    widgets: [
+        {
+            id: 'scout-hot-leads',
+            name: 'Hot Leads',
+            component: 'ScoutHotLeadsWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 3, height: 4 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:after_save',
+            handler: (payload) => {
+                // Auto-score new prospects when added
+                if (payload.content?.type === 'prospect' && !payload.content.leadScore) {
+                    const score = calculateLeadScore(payload.content);
+                    payload.content.leadScore = score;
+                    payload.content.leadGrade = score >= 80 ? 'A' : score >= 60 ? 'B' : score >= 40 ? 'C' : 'D';
+                }
+            },
+            priority: 10,
+        },
+    ],
+    settingsSchema: z.object({
+        scoringWeights: z.object({
+            companySize: z.number().default(0.2),
+            industry: z.number().default(0.25),
+            engagement: z.number().default(0.3),
+            recency: z.number().default(0.25),
+        }).default({}),
+        autoEnrich: z.boolean().default(false),
+        enrichmentProvider: z.enum(['clearbit', 'apollo', 'manual']).default('manual'),
+        enrichmentApiKey: z.string().optional(),
+    }),
+    async onActivate(core) {
+        // Sync new CRM contacts to prospect pool
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'contact' && payload.content?.source === 'inbound') {
+                core.hooks.emit('content:before_save', {
+                    content: {
+                        type: 'prospect',
+                        fromContactId: payload.content.id,
+                        email: payload.content.email,
+                        name: payload.content.name,
+                    },
+                });
+            }
+        });
+    },
+    async onDeactivate(_core) { },
+};
+function calculateLeadScore(prospect) {
+    let score = 50; // base score
+    if (prospect.email?.includes('.com'))
+        score += 5;
+    if (prospect.company)
+        score += 10;
+    if (prospect.phone)
+        score += 10;
+    if (prospect.industry)
+        score += 10;
+    if (prospect.lastEngagement) {
+        const daysSince = (Date.now() - new Date(prospect.lastEngagement).getTime()) / 86400000;
+        if (daysSince < 7)
+            score += 15;
+        else if (daysSince < 30)
+            score += 5;
+    }
+    return Math.min(100, Math.max(0, score));
+}
+// ---------------------------------------------------------------------------
+// Beacon — SEO Toolkit
+// ---------------------------------------------------------------------------
+export const beaconPlugin = {
+    id: '@foundry/beacon',
+    name: 'Beacon',
+    version: '1.0.0',
+    description: 'SEO toolkit with meta tag management, sitemap generation, Open Graph, and structured data',
+    adminPages: [
+        {
+            path: 'beacon',
+            label: 'SEO',
+            icon: 'globe',
+            component: 'BeaconDashboardPage',
+            order: 25,
+            permission: 'beacon:view',
+            children: [
+                {
+                    path: 'audit',
+                    label: 'SEO Audit',
+                    component: 'BeaconAuditPage',
+                    permission: 'beacon:audit',
+                },
+                {
+                    path: 'meta',
+                    label: 'Meta Manager',
+                    component: 'BeaconMetaPage',
+                    permission: 'beacon:edit',
+                },
+                {
+                    path: 'sitemap',
+                    label: 'Sitemap',
+                    component: 'BeaconSitemapPage',
+                    permission: 'beacon:edit',
+                },
+                {
+                    path: 'redirects',
+                    label: 'Redirects',
+                    component: 'BeaconRedirectsPage',
+                    permission: 'beacon:edit',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/sitemap.xml',
+            handler: 'beacon.serveSitemap',
+            description: 'Serve XML sitemap',
+        },
+        {
+            method: 'GET',
+            path: '/robots.txt',
+            handler: 'beacon.serveRobots',
+            description: 'Serve robots.txt',
+        },
+        {
+            method: 'POST',
+            path: '/api/beacon/audit',
+            handler: 'beacon.runAudit',
+            middleware: ['auth', 'permission:beacon:audit'],
+            description: 'Run SEO audit on specified pages',
+        },
+        {
+            method: 'GET',
+            path: '/api/beacon/redirects',
+            handler: 'beacon.listRedirects',
+            middleware: ['auth'],
+            description: 'List all URL redirects',
+        },
+        {
+            method: 'POST',
+            path: '/api/beacon/redirects',
+            handler: 'beacon.createRedirect',
+            middleware: ['auth', 'permission:beacon:edit'],
+            description: 'Create a URL redirect',
+        },
+    ],
+    hooks: [
+        {
+            hook: 'page:before_render',
+            handler: (payload) => {
+                if (!payload.page)
+                    return payload;
+                // Inject SEO meta tags
+                const meta = payload.page.meta ?? {};
+                const seoHead = [];
+                if (meta.title) {
+                    seoHead.push(`<title>${escapeForHtml(meta.title)}</title>`);
+                    seoHead.push(`<meta property="og:title" content="${escapeForAttr(meta.title)}" />`);
+                }
+                if (meta.description) {
+                    seoHead.push(`<meta name="description" content="${escapeForAttr(meta.description)}" />`);
+                    seoHead.push(`<meta property="og:description" content="${escapeForAttr(meta.description)}" />`);
+                }
+                if (meta.canonicalUrl) {
+                    seoHead.push(`<link rel="canonical" href="${escapeForAttr(meta.canonicalUrl)}" />`);
+                    seoHead.push(`<meta property="og:url" content="${escapeForAttr(meta.canonicalUrl)}" />`);
+                }
+                if (meta.ogImage) {
+                    seoHead.push(`<meta property="og:image" content="${escapeForAttr(meta.ogImage)}" />`);
+                }
+                if (meta.noIndex) {
+                    seoHead.push('<meta name="robots" content="noindex, nofollow" />');
+                }
+                // Add JSON-LD structured data
+                if (meta.structuredData) {
+                    seoHead.push(`<script type="application/ld+json">${JSON.stringify(meta.structuredData)}</script>`);
+                }
+                payload.page._seoHead = seoHead;
+                return payload;
+            },
+            priority: 5,
+        },
+        {
+            hook: 'page:after_save',
+            handler: (payload) => {
+                // Mark sitemap as stale when pages change
+                if (payload.page?.status === 'published') {
+                    _sitemapStale = true;
+                }
+            },
+            priority: 10,
+        },
+    ],
+    settingsSchema: z.object({
+        siteUrl: z.string().url().optional(),
+        siteName: z.string().default(''),
+        defaultOgImage: z.string().url().optional(),
+        robotsTxt: z.string().default('User-agent: *\nAllow: /\nSitemap: /sitemap.xml'),
+        autoGenerateSitemap: z.boolean().default(true),
+        sitemapChangeFreq: z.enum(['always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'never']).default('weekly'),
+        enableStructuredData: z.boolean().default(true),
+        twitterCard: z.enum(['summary', 'summary_large_image']).default('summary_large_image'),
+        twitterHandle: z.string().optional(),
+    }),
+    async onActivate(core) {
+        // Rebuild sitemap on activation
+        core.hooks.on('content:after_save', () => {
+            _sitemapStale = true;
+        });
+    },
+    async onDeactivate(_core) { },
+};
+let _sitemapStale = true;
+function escapeForHtml(str) {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function escapeForAttr(str) {
+    return str.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+// ---------------------------------------------------------------------------
+// Chronicle — Blog Engine
+// ---------------------------------------------------------------------------
+export const chroniclePlugin = {
+    id: '@foundry/chronicle',
+    name: 'Chronicle',
+    version: '1.0.0',
+    description: 'Full-featured blog engine with categories, tags, RSS feed, author pages, and markdown support',
+    adminPages: [
+        {
+            path: 'chronicle',
+            label: 'Blog',
+            icon: 'book-open',
+            component: 'ChronicleDashboardPage',
+            order: 8,
+            permission: 'chronicle:view',
+            children: [
+                {
+                    path: 'posts',
+                    label: 'Posts',
+                    component: 'ChroniclePostsPage',
+                    permission: 'chronicle:view',
+                },
+                {
+                    path: 'posts/new',
+                    label: 'New Post',
+                    component: 'ChronicleEditorPage',
+                    permission: 'chronicle:create',
+                },
+                {
+                    path: 'categories',
+                    label: 'Categories',
+                    component: 'ChronicleCategoriesPage',
+                    permission: 'chronicle:manage',
+                },
+                {
+                    path: 'tags',
+                    label: 'Tags',
+                    component: 'ChronicleTagsPage',
+                    permission: 'chronicle:manage',
+                },
+                {
+                    path: 'comments',
+                    label: 'Comments',
+                    component: 'ChronicleCommentsPage',
+                    permission: 'chronicle:moderate',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/chronicle/posts',
+            handler: 'chronicle.listPosts',
+            description: 'List blog posts with pagination and filters',
+        },
+        {
+            method: 'POST',
+            path: '/api/chronicle/posts',
+            handler: 'chronicle.createPost',
+            middleware: ['auth', 'permission:chronicle:create'],
+            description: 'Create a new blog post',
+        },
+        {
+            method: 'GET',
+            path: '/api/chronicle/posts/:slug',
+            handler: 'chronicle.getPostBySlug',
+            description: 'Get a blog post by its slug',
+        },
+        {
+            method: 'PUT',
+            path: '/api/chronicle/posts/:id',
+            handler: 'chronicle.updatePost',
+            middleware: ['auth', 'permission:chronicle:edit'],
+            description: 'Update a blog post',
+        },
+        {
+            method: 'GET',
+            path: '/api/chronicle/categories',
+            handler: 'chronicle.listCategories',
+            description: 'List all blog categories',
+        },
+        {
+            method: 'GET',
+            path: '/feed.xml',
+            handler: 'chronicle.serveFeed',
+            description: 'Serve RSS feed',
+        },
+        {
+            method: 'GET',
+            path: '/feed.json',
+            handler: 'chronicle.serveJsonFeed',
+            description: 'Serve JSON feed',
+        },
+    ],
+    pageElements: [
+        {
+            type: 'blog-post-card',
+            name: 'Blog Post Card',
+            category: 'content',
+            component: 'ChronicleBlogPostCard',
+            settingsSchema: z.object({
+                postId: z.string().optional(),
+                showExcerpt: z.boolean().default(true),
+                showImage: z.boolean().default(true),
+                showDate: z.boolean().default(true),
+                showAuthor: z.boolean().default(true),
+                showCategory: z.boolean().default(true),
+                excerptLength: z.number().min(50).max(500).default(160),
+            }),
+        },
+        {
+            type: 'blog-post-list',
+            name: 'Blog Post List',
+            category: 'content',
+            component: 'ChronicleBlogPostList',
+            settingsSchema: z.object({
+                category: z.string().optional(),
+                tag: z.string().optional(),
+                limit: z.number().min(1).max(50).default(10),
+                layout: z.enum(['grid', 'list', 'masonry']).default('grid'),
+                columns: z.number().min(1).max(4).default(3),
+                showPagination: z.boolean().default(true),
+            }),
+        },
+        {
+            type: 'blog-recent-posts',
+            name: 'Recent Posts',
+            category: 'content',
+            component: 'ChronicleRecentPosts',
+            settingsSchema: z.object({
+                count: z.number().min(1).max(10).default(5),
+                showThumbnail: z.boolean().default(true),
+            }),
+        },
+    ],
+    widgets: [
+        {
+            id: 'chronicle-recent-posts',
+            name: 'Recent Posts',
+            component: 'ChronicleRecentPostsWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 4, height: 3 },
+        },
+        {
+            id: 'chronicle-stats',
+            name: 'Blog Stats',
+            component: 'ChronicleStatsWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 2, height: 2 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'blog_post') {
+                    // Auto-generate slug from title if missing
+                    if (payload.content.title && !payload.content.slug) {
+                        payload.content.slug = generateSlug(payload.content.title);
+                    }
+                    // Calculate reading time
+                    if (payload.content.body) {
+                        const wordCount = payload.content.body.split(/\s+/).length;
+                        payload.content.readingTime = Math.max(1, Math.ceil(wordCount / 200));
+                    }
+                    // Auto-generate excerpt from body if missing
+                    if (payload.content.body && !payload.content.excerpt) {
+                        const plainText = payload.content.body.replace(/<[^>]*>/g, '').replace(/[#*_~`]/g, '');
+                        payload.content.excerpt = plainText.substring(0, 160).trim() + '...';
+                    }
+                    // Set publication date
+                    if (payload.content.status === 'published' && !payload.content.publishedAt) {
+                        payload.content.publishedAt = new Date().toISOString();
+                    }
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+    ],
+    settingsSchema: z.object({
+        postsPerPage: z.number().min(1).max(50).default(12),
+        excerptLength: z.number().min(50).max(500).default(160),
+        enableComments: z.boolean().default(true),
+        moderateComments: z.boolean().default(true),
+        enableRss: z.boolean().default(true),
+        feedTitle: z.string().default('Blog'),
+        feedDescription: z.string().default(''),
+        defaultCategory: z.string().default('uncategorized'),
+        dateFormat: z.string().default('MMMM d, yyyy'),
+        showReadingTime: z.boolean().default(true),
+        enableMarkdown: z.boolean().default(true),
+    }),
+    async onActivate(core) {
+        // Auto-update RSS feed when posts change
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'blog_post' && payload.content?.status === 'published') {
+                // Mark RSS feed as needing regeneration
+            }
+        });
+    },
+    async onDeactivate(_core) { },
+};
+function generateSlug(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 80);
+}
+// ---------------------------------------------------------------------------
+// Atlas — Analytics
+// ---------------------------------------------------------------------------
+export const atlasPlugin = {
+    id: '@foundry/atlas',
+    name: 'Atlas',
+    version: '1.0.0',
+    description: 'Privacy-first analytics with page views, events, funnels, and real-time dashboard',
+    adminPages: [
+        {
+            path: 'atlas',
+            label: 'Analytics',
+            icon: 'bar-chart-2',
+            component: 'AtlasDashboardPage',
+            order: 6,
+            permission: 'atlas:view',
+            children: [
+                {
+                    path: 'realtime',
+                    label: 'Real-time',
+                    component: 'AtlasRealtimePage',
+                    permission: 'atlas:view',
+                },
+                {
+                    path: 'pages',
+                    label: 'Pages',
+                    component: 'AtlasPagesPage',
+                    permission: 'atlas:view',
+                },
+                {
+                    path: 'events',
+                    label: 'Events',
+                    component: 'AtlasEventsPage',
+                    permission: 'atlas:view',
+                },
+                {
+                    path: 'funnels',
+                    label: 'Funnels',
+                    component: 'AtlasFunnelsPage',
+                    permission: 'atlas:manage',
+                },
+                {
+                    path: 'reports',
+                    label: 'Reports',
+                    component: 'AtlasReportsPage',
+                    permission: 'atlas:view',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'POST',
+            path: '/api/atlas/event',
+            handler: 'atlas.trackEvent',
+            description: 'Track an analytics event (public endpoint)',
+        },
+        {
+            method: 'POST',
+            path: '/api/atlas/pageview',
+            handler: 'atlas.trackPageview',
+            description: 'Track a pageview (public endpoint)',
+        },
+        {
+            method: 'GET',
+            path: '/api/atlas/stats',
+            handler: 'atlas.getStats',
+            middleware: ['auth', 'permission:atlas:view'],
+            description: 'Get aggregated stats for a date range',
+        },
+        {
+            method: 'GET',
+            path: '/api/atlas/realtime',
+            handler: 'atlas.getRealtime',
+            middleware: ['auth', 'permission:atlas:view'],
+            description: 'Get real-time visitor data',
+        },
+        {
+            method: 'GET',
+            path: '/api/atlas/top-pages',
+            handler: 'atlas.getTopPages',
+            middleware: ['auth'],
+            description: 'Get top pages by views',
+        },
+    ],
+    widgets: [
+        {
+            id: 'atlas-visitors',
+            name: 'Visitors Overview',
+            component: 'AtlasVisitorsWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 6, height: 3 },
+        },
+        {
+            id: 'atlas-top-pages',
+            name: 'Top Pages',
+            component: 'AtlasTopPagesWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 3, height: 4 },
+        },
+        {
+            id: 'atlas-live-count',
+            name: 'Live Visitors',
+            component: 'AtlasLiveCountWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 2, height: 1 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'page:after_render',
+            handler: (payload) => {
+                // Inject analytics tracking script before </body>
+                if (payload.html && payload.page?.status === 'published') {
+                    const trackingScript = `
+<script>
+(function(){
+  var d={url:location.pathname,ref:document.referrer,w:window.innerWidth,t:Date.now()};
+  navigator.sendBeacon&&navigator.sendBeacon('/api/atlas/pageview',JSON.stringify(d));
+})();
+</script>`;
+                    payload.html = payload.html.replace('</body>', trackingScript + '\n</body>');
+                }
+                return payload;
+            },
+            priority: 100, // run last so other plugins have already modified the HTML
+        },
+    ],
+    settingsSchema: z.object({
+        enabled: z.boolean().default(true),
+        respectDnt: z.boolean().default(true),
+        excludePaths: z.array(z.string()).default(['/admin', '/api']),
+        retentionDays: z.number().min(7).max(730).default(365),
+        sampleRate: z.number().min(0).max(1).default(1),
+        enableFunnels: z.boolean().default(false),
+        enableHeatmaps: z.boolean().default(false),
+    }),
+    async onActivate(core) {
+        // Start real-time tracking session cleanup interval
+        core.hooks.on('page:after_render', (payload) => {
+            // Tracking is handled by the injected script, this is for server-side tracking
+            if (payload.page?._serverRendered) {
+                // Log server-side pageview
+            }
+        });
+    },
+    async onDeactivate(_core) {
+        // Stop real-time tracking
+    },
+};
+//# sourceMappingURL=growth.js.map