foundrycms 0.1.0

package/dist/plugins/core.js

@@ -0,0 +1,675 @@
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Forge — Visual Site Builder
+// ---------------------------------------------------------------------------
+export const forgePlugin = {
+    id: '@foundry/forge',
+    name: 'Forge',
+    version: '1.0.0',
+    description: 'Visual drag-and-drop site builder with live preview and responsive editing',
+    adminPages: [
+        {
+            path: 'forge',
+            label: 'Site Builder',
+            icon: 'hammer',
+            component: 'ForgeEditorPage',
+            order: 1,
+            permission: 'forge:edit',
+            children: [
+                {
+                    path: 'pages',
+                    label: 'Pages',
+                    component: 'ForgePagesListPage',
+                    permission: 'forge:edit',
+                },
+                {
+                    path: 'templates',
+                    label: 'Templates',
+                    component: 'ForgeTemplatesPage',
+                    permission: 'forge:templates',
+                },
+                {
+                    path: 'global-styles',
+                    label: 'Global Styles',
+                    component: 'ForgeGlobalStylesPage',
+                    permission: 'forge:styles',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/forge/pages',
+            handler: 'forge.listPages',
+            middleware: ['auth'],
+            description: 'List all site pages',
+        },
+        {
+            method: 'POST',
+            path: '/api/forge/pages',
+            handler: 'forge.createPage',
+            middleware: ['auth', 'permission:forge:edit'],
+            description: 'Create a new page',
+        },
+        {
+            method: 'PUT',
+            path: '/api/forge/pages/:id',
+            handler: 'forge.updatePage',
+            middleware: ['auth', 'permission:forge:edit'],
+            description: 'Update a page by ID',
+        },
+        {
+            method: 'POST',
+            path: '/api/forge/pages/:id/publish',
+            handler: 'forge.publishPage',
+            middleware: ['auth', 'permission:forge:publish'],
+            description: 'Publish a page',
+        },
+        {
+            method: 'DELETE',
+            path: '/api/forge/pages/:id',
+            handler: 'forge.deletePage',
+            middleware: ['auth', 'permission:forge:delete'],
+            description: 'Delete a page',
+        },
+    ],
+    pageElements: [
+        {
+            type: 'forge-section',
+            name: 'Section',
+            category: 'layout',
+            component: 'ForgeSectionElement',
+            settingsSchema: z.object({
+                backgroundColor: z.string().optional(),
+                padding: z.enum(['none', 'sm', 'md', 'lg', 'xl']).default('md'),
+                fullWidth: z.boolean().default(false),
+                backgroundImage: z.string().url().optional(),
+                parallax: z.boolean().default(false),
+            }),
+        },
+        {
+            type: 'forge-container',
+            name: 'Container',
+            category: 'layout',
+            component: 'ForgeContainerElement',
+            settingsSchema: z.object({
+                maxWidth: z.enum(['sm', 'md', 'lg', 'xl', 'full']).default('lg'),
+                alignment: z.enum(['left', 'center', 'right']).default('center'),
+            }),
+        },
+    ],
+    widgets: [
+        {
+            id: 'forge-recent-pages',
+            name: 'Recent Pages',
+            component: 'ForgeRecentPagesWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 4, height: 3 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'page:before_render',
+            handler: (payload) => {
+                // Inject Forge builder data attributes for live editing
+                if (payload.page && payload.page._forgeEditing) {
+                    payload.page._renderMode = 'builder';
+                    payload.page._builderScripts = ['/forge/builder.js'];
+                    payload.page._builderStyles = ['/forge/builder.css'];
+                }
+                return payload;
+            },
+            priority: 1,
+        },
+        {
+            hook: 'page:before_save',
+            handler: (payload) => {
+                // Validate page structure before saving
+                if (payload.page?.rows) {
+                    for (const row of payload.page.rows) {
+                        if (!row.columns || row.columns.length === 0) {
+                            throw new Error(`Forge: Row "${row.id}" must have at least one column`);
+                        }
+                    }
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+    ],
+    settingsSchema: z.object({
+        defaultTemplate: z.string().default('blank'),
+        autosaveInterval: z.number().min(5000).max(120000).default(30000),
+        enableVersionHistory: z.boolean().default(true),
+        maxVersions: z.number().min(1).max(100).default(25),
+        livePreview: z.boolean().default(true),
+    }),
+    async onActivate(core) {
+        core.hooks.on('page:after_save', (payload) => {
+            // Trigger rebuild of static pages if needed
+            if (payload.page?.status === 'published') {
+                core.hooks.emit('content:after_save', {
+                    content: { type: 'page', id: payload.page.id, action: 'publish' },
+                });
+            }
+        });
+    },
+    async onDeactivate(_core) {
+        // Clean up any live-preview websocket connections
+    },
+};
+// ---------------------------------------------------------------------------
+// Ledger — Invoicing (ChronoCraft)
+// ---------------------------------------------------------------------------
+export const ledgerPlugin = {
+    id: '@foundry/ledger',
+    name: 'Ledger',
+    version: '1.0.0',
+    description: 'Professional invoicing system with Stripe integration, recurring billing, and payment tracking',
+    adminPages: [
+        {
+            path: 'ledger',
+            label: 'Invoicing',
+            icon: 'file-text',
+            component: 'LedgerDashboardPage',
+            order: 10,
+            permission: 'ledger:view',
+            children: [
+                {
+                    path: 'invoices',
+                    label: 'Invoices',
+                    component: 'LedgerInvoicesPage',
+                    permission: 'ledger:view',
+                },
+                {
+                    path: 'invoices/new',
+                    label: 'New Invoice',
+                    component: 'LedgerInvoiceEditorPage',
+                    permission: 'ledger:create',
+                },
+                {
+                    path: 'clients',
+                    label: 'Clients',
+                    component: 'LedgerClientsPage',
+                    permission: 'ledger:view',
+                },
+                {
+                    path: 'recurring',
+                    label: 'Recurring',
+                    component: 'LedgerRecurringPage',
+                    permission: 'ledger:manage',
+                },
+                {
+                    path: 'settings',
+                    label: 'Settings',
+                    component: 'LedgerSettingsPage',
+                    permission: 'ledger:settings',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/ledger/invoices',
+            handler: 'ledger.listInvoices',
+            middleware: ['auth'],
+            description: 'List all invoices with optional filters',
+        },
+        {
+            method: 'POST',
+            path: '/api/ledger/invoices',
+            handler: 'ledger.createInvoice',
+            middleware: ['auth', 'permission:ledger:create'],
+            description: 'Create a new invoice',
+        },
+        {
+            method: 'GET',
+            path: '/api/ledger/invoices/:id',
+            handler: 'ledger.getInvoice',
+            middleware: ['auth'],
+            description: 'Get invoice by ID',
+        },
+        {
+            method: 'PUT',
+            path: '/api/ledger/invoices/:id',
+            handler: 'ledger.updateInvoice',
+            middleware: ['auth', 'permission:ledger:edit'],
+            description: 'Update an invoice',
+        },
+        {
+            method: 'POST',
+            path: '/api/ledger/invoices/:id/send',
+            handler: 'ledger.sendInvoice',
+            middleware: ['auth', 'permission:ledger:send'],
+            description: 'Email an invoice to the client',
+        },
+        {
+            method: 'POST',
+            path: '/api/ledger/webhooks/stripe',
+            handler: 'ledger.stripeWebhook',
+            description: 'Stripe webhook endpoint for payment events',
+        },
+        {
+            method: 'GET',
+            path: '/api/ledger/invoices/:id/pdf',
+            handler: 'ledger.generatePdf',
+            middleware: ['auth'],
+            description: 'Generate PDF for an invoice',
+        },
+    ],
+    widgets: [
+        {
+            id: 'ledger-revenue-summary',
+            name: 'Revenue Summary',
+            component: 'LedgerRevenueSummaryWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 4, height: 2 },
+        },
+        {
+            id: 'ledger-outstanding',
+            name: 'Outstanding Invoices',
+            component: 'LedgerOutstandingWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 4, height: 3 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                // Validate invoice data before saving
+                if (payload.content?.type === 'invoice') {
+                    const invoice = payload.content;
+                    if (!invoice.lineItems || invoice.lineItems.length === 0) {
+                        throw new Error('Ledger: Invoice must have at least one line item');
+                    }
+                    // Recalculate totals
+                    let subtotal = 0;
+                    for (const item of invoice.lineItems) {
+                        item.amount = (item.quantity ?? 1) * (item.rate ?? 0);
+                        subtotal += item.amount;
+                    }
+                    invoice.subtotal = subtotal;
+                    invoice.tax = subtotal * (invoice.taxRate ?? 0);
+                    invoice.total = invoice.subtotal + invoice.tax;
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+    ],
+    settingsSchema: z.object({
+        companyName: z.string().default(''),
+        companyAddress: z.string().default(''),
+        companyEmail: z.string().email().optional(),
+        companyLogo: z.string().url().optional(),
+        currency: z.string().default('GBP'),
+        defaultPaymentTerms: z.number().min(0).max(90).default(30),
+        defaultTaxRate: z.number().min(0).max(1).default(0.2),
+        stripeSecretKey: z.string().optional(),
+        stripeWebhookSecret: z.string().optional(),
+        invoicePrefix: z.string().default('INV'),
+        nextInvoiceNumber: z.number().default(1001),
+    }),
+    async onActivate(core) {
+        // Register recurring invoice cron-like check
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'invoice' && payload.content?.status === 'paid') {
+                // Check if this invoice has a recurring schedule
+                if (payload.content.recurringSchedule) {
+                    core.hooks.emit('content:before_save', {
+                        content: {
+                            type: 'invoice',
+                            action: 'schedule_next',
+                            sourceInvoiceId: payload.content.id,
+                            schedule: payload.content.recurringSchedule,
+                        },
+                    });
+                }
+            }
+        });
+    },
+    async onDeactivate(_core) {
+        // Clean up Stripe webhook listeners
+    },
+};
+// ---------------------------------------------------------------------------
+// Compass — CRM
+// ---------------------------------------------------------------------------
+export const compassPlugin = {
+    id: '@foundry/compass',
+    name: 'Compass',
+    version: '1.0.0',
+    description: 'Customer relationship management with contact lifecycle tracking, deal pipeline, and activity logs',
+    adminPages: [
+        {
+            path: 'compass',
+            label: 'CRM',
+            icon: 'users',
+            component: 'CompassDashboardPage',
+            order: 15,
+            permission: 'compass:view',
+            children: [
+                {
+                    path: 'contacts',
+                    label: 'Contacts',
+                    component: 'CompassContactsPage',
+                    permission: 'compass:view',
+                },
+                {
+                    path: 'contacts/:id',
+                    label: 'Contact Detail',
+                    component: 'CompassContactDetailPage',
+                    permission: 'compass:view',
+                },
+                {
+                    path: 'deals',
+                    label: 'Deals',
+                    component: 'CompassDealsPage',
+                    permission: 'compass:deals',
+                },
+                {
+                    path: 'pipeline',
+                    label: 'Pipeline',
+                    component: 'CompassPipelinePage',
+                    permission: 'compass:deals',
+                },
+                {
+                    path: 'activities',
+                    label: 'Activities',
+                    component: 'CompassActivitiesPage',
+                    permission: 'compass:view',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/compass/contacts',
+            handler: 'compass.listContacts',
+            middleware: ['auth'],
+            description: 'List contacts with search and filters',
+        },
+        {
+            method: 'POST',
+            path: '/api/compass/contacts',
+            handler: 'compass.createContact',
+            middleware: ['auth', 'permission:compass:create'],
+            description: 'Create a new contact',
+        },
+        {
+            method: 'GET',
+            path: '/api/compass/contacts/:id',
+            handler: 'compass.getContact',
+            middleware: ['auth'],
+            description: 'Get contact details',
+        },
+        {
+            method: 'PUT',
+            path: '/api/compass/contacts/:id',
+            handler: 'compass.updateContact',
+            middleware: ['auth', 'permission:compass:edit'],
+            description: 'Update a contact',
+        },
+        {
+            method: 'GET',
+            path: '/api/compass/deals',
+            handler: 'compass.listDeals',
+            middleware: ['auth'],
+            description: 'List all deals',
+        },
+        {
+            method: 'POST',
+            path: '/api/compass/deals',
+            handler: 'compass.createDeal',
+            middleware: ['auth', 'permission:compass:deals'],
+            description: 'Create a new deal',
+        },
+        {
+            method: 'PATCH',
+            path: '/api/compass/deals/:id/stage',
+            handler: 'compass.updateDealStage',
+            middleware: ['auth', 'permission:compass:deals'],
+            description: 'Move a deal to a new pipeline stage',
+        },
+    ],
+    widgets: [
+        {
+            id: 'compass-pipeline-summary',
+            name: 'Pipeline Summary',
+            component: 'CompassPipelineSummaryWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 6, height: 3 },
+        },
+        {
+            id: 'compass-recent-contacts',
+            name: 'Recent Contacts',
+            component: 'CompassRecentContactsWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 3, height: 4 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'contact') {
+                    // Normalize email
+                    if (payload.content.email) {
+                        payload.content.email = payload.content.email.toLowerCase().trim();
+                    }
+                    // Auto-assign lifecycle stage if missing
+                    if (!payload.content.lifecycleStage) {
+                        payload.content.lifecycleStage = 'lead';
+                    }
+                    // Set timestamps
+                    if (!payload.content.createdAt) {
+                        payload.content.createdAt = new Date().toISOString();
+                    }
+                    payload.content.updatedAt = new Date().toISOString();
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+        {
+            hook: 'content:after_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'deal' && payload.content?.stage === 'won') {
+                    // When a deal is won, update the contact's lifecycle stage
+                    // This would trigger another save with the updated contact
+                }
+            },
+            priority: 10,
+        },
+    ],
+    settingsSchema: z.object({
+        pipelineStages: z.array(z.object({
+            id: z.string(),
+            label: z.string(),
+            color: z.string(),
+            order: z.number(),
+        })).default([
+            { id: 'lead', label: 'Lead', color: '#6366f1', order: 0 },
+            { id: 'qualified', label: 'Qualified', color: '#8b5cf6', order: 1 },
+            { id: 'proposal', label: 'Proposal', color: '#a855f7', order: 2 },
+            { id: 'negotiation', label: 'Negotiation', color: '#d946ef', order: 3 },
+            { id: 'won', label: 'Won', color: '#22c55e', order: 4 },
+            { id: 'lost', label: 'Lost', color: '#ef4444', order: 5 },
+        ]),
+        lifecycleStages: z.array(z.string()).default([
+            'subscriber', 'lead', 'qualified', 'opportunity', 'customer', 'evangelist',
+        ]),
+        defaultCurrency: z.string().default('GBP'),
+    }),
+    async onActivate(core) {
+        // Wire up CRM activity logging
+        core.hooks.on('content:after_save', (payload) => {
+            if (['contact', 'deal'].includes(payload.content?.type)) {
+                // Log activity entry
+                core.hooks.emit('content:after_save', {
+                    content: {
+                        type: 'activity',
+                        action: 'updated',
+                        entityType: payload.content.type,
+                        entityId: payload.content.id,
+                        timestamp: new Date().toISOString(),
+                    },
+                });
+            }
+        });
+    },
+    async onDeactivate(_core) {
+        // Cleanup CRM hooks
+    },
+};
+// ---------------------------------------------------------------------------
+// Oracle — AI Integration
+// ---------------------------------------------------------------------------
+export const oraclePlugin = {
+    id: '@foundry/oracle',
+    name: 'Oracle',
+    version: '1.0.0',
+    description: 'AI-powered content generation, data analysis, SEO suggestions, and intelligent automation',
+    adminPages: [
+        {
+            path: 'oracle',
+            label: 'AI Assistant',
+            icon: 'sparkles',
+            component: 'OracleDashboardPage',
+            order: 5,
+            permission: 'oracle:view',
+            children: [
+                {
+                    path: 'generate',
+                    label: 'Content Generator',
+                    component: 'OracleGeneratorPage',
+                    permission: 'oracle:generate',
+                },
+                {
+                    path: 'analyze',
+                    label: 'Data Analysis',
+                    component: 'OracleAnalysisPage',
+                    permission: 'oracle:analyze',
+                },
+                {
+                    path: 'suggestions',
+                    label: 'Suggestions',
+                    component: 'OracleSuggestionsPage',
+                    permission: 'oracle:view',
+                },
+                {
+                    path: 'usage',
+                    label: 'AI Usage',
+                    component: 'OracleUsagePage',
+                    permission: 'oracle:settings',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'POST',
+            path: '/api/oracle/generate',
+            handler: 'oracle.generateContent',
+            middleware: ['auth', 'permission:oracle:generate', 'rateLimit:oracle'],
+            description: 'Generate content using AI',
+        },
+        {
+            method: 'POST',
+            path: '/api/oracle/analyze',
+            handler: 'oracle.analyzeData',
+            middleware: ['auth', 'permission:oracle:analyze'],
+            description: 'Run AI analysis on provided data',
+        },
+        {
+            method: 'POST',
+            path: '/api/oracle/suggest/seo',
+            handler: 'oracle.suggestSeo',
+            middleware: ['auth'],
+            description: 'Get AI-powered SEO suggestions for content',
+        },
+        {
+            method: 'POST',
+            path: '/api/oracle/rewrite',
+            handler: 'oracle.rewriteContent',
+            middleware: ['auth', 'permission:oracle:generate'],
+            description: 'Rewrite or improve existing content',
+        },
+        {
+            method: 'GET',
+            path: '/api/oracle/usage',
+            handler: 'oracle.getUsage',
+            middleware: ['auth'],
+            description: 'Get AI token usage stats',
+        },
+    ],
+    widgets: [
+        {
+            id: 'oracle-suggestions',
+            name: 'AI Suggestions',
+            component: 'OracleSuggestionsWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 3, height: 4 },
+        },
+        {
+            id: 'oracle-usage',
+            name: 'AI Usage',
+            component: 'OracleUsageWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 2, height: 2 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                // Auto-generate meta description if missing and AI is enabled
+                if (payload.content?.type === 'page' && !payload.content.metaDescription) {
+                    payload.content._oracleTask = 'generate_meta_description';
+                }
+                return payload;
+            },
+            priority: 20,
+        },
+        {
+            hook: 'page:before_render',
+            handler: (payload) => {
+                // Inject AI-powered content personalization markers
+                if (payload.page?._personalize) {
+                    payload.page._oraclePersonalization = {
+                        enabled: true,
+                        segments: payload.page._personalizeSegments ?? ['default'],
+                    };
+                }
+                return payload;
+            },
+            priority: 15,
+        },
+    ],
+    settingsSchema: z.object({
+        provider: z.enum(['anthropic', 'openai', 'local']).default('anthropic'),
+        apiKey: z.string().optional(),
+        model: z.string().default('claude-sonnet-4-20250514'),
+        maxTokensPerRequest: z.number().min(100).max(8000).default(2000),
+        monthlyTokenBudget: z.number().default(1000000),
+        autoSeoSuggestions: z.boolean().default(true),
+        autoMetaGeneration: z.boolean().default(false),
+        contentTone: z.enum(['professional', 'casual', 'formal', 'friendly']).default('professional'),
+    }),
+    async onActivate(core) {
+        // Register AI content generation pipeline
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?._oracleTask === 'generate_meta_description') {
+                // Queue meta description generation
+            }
+        });
+    },
+    async onDeactivate(_core) {
+        // Clean up AI processing queue
+    },
+};
+//# sourceMappingURL=core.js.map