@opnpress/opnpress-cli 0.1.0

package/dist/config.js

@@ -0,0 +1,210 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import matter from 'gray-matter';
+import YAML from 'yaml';
+import { z } from 'zod';
+const NavLinkSchema = z.object({
+    title: z.string().min(1),
+    url: z.string().min(1)
+});
+const NavigationSchema = z.object({
+    main: z.array(NavLinkSchema).default([]),
+    footer: z.array(NavLinkSchema).default([])
+});
+const ThemeSchema = z.object({
+    colors: z
+        .object({
+        primary: z.string().default('#1c3557'),
+        accent: z.string().default('#c86b3c'),
+        background: z.string().default('#f5efe6'),
+        surface: z.string().default('#fffaf3'),
+        text: z.string().default('#14212f'),
+        muted: z.string().default('#5e6b76'),
+        border: z.string().default('rgba(20, 33, 47, 0.12)')
+    })
+        .default({}),
+    backgrounds: z
+        .object({
+        page: z.string().default('radial-gradient(circle at top, rgba(200, 107, 60, 0.12), transparent 34%), linear-gradient(180deg, #f5efe6 0%, #fffaf3 100%)')
+    })
+        .default({}),
+    fonts: z
+        .object({
+        heading: z.string().default('Georgia, serif'),
+        body: z.string().default('Inter, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif'),
+        mono: z.string().default('ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace')
+    })
+        .default({}),
+    sizing: z
+        .object({
+        contentWidth: z.string().default('72rem'),
+        radius: z.string().default('24px'),
+        spacing: z.string().default('1rem')
+    })
+        .default({})
+});
+const ContactFormIntegrationSchema = z.object({
+    provider: z.enum(['formspree', 'basin', 'custom']).default('formspree'),
+    action: z.string().url().optional(),
+    buttonLabel: z.string().min(1).default('Send message')
+});
+const ShareableLinksIntegrationSchema = z.object({
+    enabled: z.boolean().default(true)
+});
+const ContactLinksIntegrationSchema = z.object({
+    email: z.string().optional(),
+    phone: z.string().optional(),
+    website: z.string().optional(),
+    mapUrl: z.string().url().optional(),
+    address: z.string().optional(),
+    hours: z.string().optional(),
+    showIcons: z.boolean().default(true),
+    showLabels: z.boolean().default(true),
+    showInHeader: z.boolean().default(false),
+    showInFooter: z.boolean().default(false)
+});
+const CompanyInfoIntegrationSchema = z.object({
+    name: z.string().optional(),
+    tagline: z.string().optional(),
+    logo: z.string().optional(),
+    address: z.string().optional(),
+    mapUrl: z.string().url().optional(),
+    phone: z.string().optional(),
+    email: z.string().optional(),
+    hours: z.string().optional(),
+    website: z.string().optional(),
+    showInHeader: z.boolean().default(false),
+    showInFooter: z.boolean().default(false)
+});
+const BookingCalendarIntegrationSchema = z.object({
+    provider: z.enum(['calendly', 'calcom']).default('calendly'),
+    embedUrl: z.string().url().optional(),
+    buttonLabel: z.string().min(1).default('Book a call')
+});
+const AnalyticsIntegrationSchema = z.object({
+    provider: z.enum(['google-analytics']).default('google-analytics'),
+    measurementId: z.string().min(1).optional()
+});
+const MapsIntegrationSchema = z.object({
+    provider: z.enum(['google-maps']).default('google-maps'),
+    embedUrl: z.string().url().optional()
+});
+const IntegrationsSchema = z.object({
+    contactForm: ContactFormIntegrationSchema.default({
+        provider: 'formspree',
+        buttonLabel: 'Send message'
+    }),
+    shareableLinks: ShareableLinksIntegrationSchema.default({
+        enabled: true
+    }),
+    contactLinks: ContactLinksIntegrationSchema.default({}),
+    companyInfo: CompanyInfoIntegrationSchema.default({}),
+    bookingCalendar: BookingCalendarIntegrationSchema.default({
+        provider: 'calendly',
+        buttonLabel: 'Book a call'
+    }),
+    analytics: AnalyticsIntegrationSchema.default({
+        provider: 'google-analytics'
+    }),
+    maps: MapsIntegrationSchema.default({
+        provider: 'google-maps'
+    })
+});
+const DeploymentSchema = z
+    .object({
+    provider: z.enum(['github-pages', 'cloudflare-pages']).default('cloudflare-pages'),
+    cloudflare: z
+        .object({
+        projectName: z.string().min(1).optional(),
+        productionBranch: z.string().min(1).default('master')
+    })
+        .default({
+        productionBranch: 'master'
+    })
+})
+    .default({
+    provider: 'cloudflare-pages',
+    cloudflare: {
+        productionBranch: 'master'
+    }
+});
+const FrontmatterSchema = z.object({
+    title: z.string().min(1).optional(),
+    description: z.string().optional(),
+    slug: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    categories: z.array(z.string()).optional(),
+    published: z.boolean().optional(),
+    draft: z.boolean().optional(),
+    image: z.string().optional(),
+    canonical: z.string().optional(),
+    date: z.union([z.string(), z.date()]).optional(),
+    updated: z.union([z.string(), z.date()]).optional(),
+    author: z.string().optional(),
+    schema: z.any().optional(),
+    aiVisibility: z.boolean().optional(),
+    llmVisibility: z.boolean().optional(),
+    customMetadata: z.record(z.any()).optional()
+});
+const SiteSchema = z.object({
+    site: z.object({
+        name: z.string().min(1),
+        domain: z.string().min(1),
+        description: z.string().optional().default(''),
+        language: z.string().min(1).default('en'),
+        theme: z.string().min(1).default('default'),
+        logo: z.string().optional(),
+        favicon: z.string().optional()
+    }),
+    seo: z
+        .object({
+        defaultImage: z.string().optional()
+    })
+        .default({}),
+    socials: z
+        .object({
+        twitter: z.string().optional(),
+        x: z.string().optional(),
+        github: z.string().optional(),
+        facebook: z.string().optional(),
+        instagram: z.string().optional(),
+        linkedin: z.string().optional(),
+        youtube: z.string().optional(),
+        tiktok: z.string().optional(),
+        threads: z.string().optional(),
+        mastodon: z.string().optional(),
+        bluesky: z.string().optional(),
+        website: z.string().optional(),
+        email: z.string().optional()
+    })
+        .default({}),
+    branding: z
+        .object({
+        poweredByOpnPress: z.boolean().default(true)
+    })
+        .default({}),
+    deployment: DeploymentSchema,
+    integrations: IntegrationsSchema.default({})
+});
+export async function readYamlFile(filePath, schema) {
+    const raw = await fs.readFile(filePath, 'utf8');
+    const parsed = YAML.parse(raw);
+    return schema.parse(parsed);
+}
+export async function loadSiteConfig(rootDir) {
+    return (await readYamlFile(path.join(rootDir, 'site.config.yaml'), SiteSchema));
+}
+export async function loadThemeConfig(rootDir) {
+    return (await readYamlFile(path.join(rootDir, 'theme.config.yaml'), ThemeSchema));
+}
+export async function loadNavigationConfig(rootDir) {
+    return (await readYamlFile(path.join(rootDir, 'navigation.yaml'), NavigationSchema));
+}
+export async function parseFrontmatter(filePath) {
+    const raw = await fs.readFile(filePath, 'utf8');
+    const parsed = matter(raw);
+    return {
+        data: FrontmatterSchema.parse(parsed.data),
+        content: parsed.content.trim()
+    };
+}

package/dist/content.js

@@ -0,0 +1,109 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { parseFrontmatter } from './config.js';
+import { slugify, toPosix, walkFiles } from './utils.js';
+const SECTION_PREFIX = {
+    pages: '',
+    services: 'services',
+    locations: 'locations'
+};
+function normalizeSegments(relativePath) {
+    const withoutExt = relativePath.replace(/\.(md|html)$/i, '');
+    const segments = withoutExt.split('/').filter(Boolean);
+    if (segments.at(-1) === 'index') {
+        segments.pop();
+    }
+    return segments;
+}
+function resolveRoutePath(section, relativePath, frontmatterSlug) {
+    const prefix = SECTION_PREFIX[section];
+    const segments = normalizeSegments(relativePath);
+    if (frontmatterSlug) {
+        if (segments.length === 0) {
+            segments.push(frontmatterSlug);
+        }
+        else {
+            segments[segments.length - 1] = frontmatterSlug;
+        }
+    }
+    const routeSegments = prefix ? [prefix, ...segments] : segments;
+    const joined = routeSegments.join('/');
+    if (!joined) {
+        return '/';
+    }
+    return `/${joined}/`;
+}
+function resolveOutputPath(routePath) {
+    if (routePath === '/') {
+        return 'dist/index.html';
+    }
+    return path.join('dist', routePath.replace(/^\//, ''), 'index.html');
+}
+function inferSection(filePath) {
+    const normalized = toPosix(filePath);
+    if (normalized.includes('/content/pages/'))
+        return 'pages';
+    if (normalized.includes('/content/services/'))
+        return 'services';
+    if (normalized.includes('/content/locations/'))
+        return 'locations';
+    return null;
+}
+export async function loadContentSources(rootDir) {
+    const contentRoot = path.join(rootDir, 'content');
+    const files = await walkFiles(contentRoot);
+    const sources = [];
+    for (const sourcePath of files) {
+        const section = inferSection(sourcePath);
+        if (!section) {
+            continue;
+        }
+        if (!/\.(md|html)$/i.test(sourcePath)) {
+            continue;
+        }
+        const relativePath = toPosix(path.relative(path.join(contentRoot, section), sourcePath));
+        if (relativePath.startsWith('..')) {
+            continue;
+        }
+        let frontmatter = {};
+        let body = '';
+        if (sourcePath.endsWith('.md')) {
+            const parsed = await parseFrontmatter(sourcePath);
+            frontmatter = parsed.data;
+            body = parsed.content;
+        }
+        else {
+            const raw = await fs.readFile(sourcePath, 'utf8');
+            body = raw.trim();
+        }
+        const routePath = resolveRoutePath(section, relativePath, frontmatter.slug ?? undefined);
+        const outputPath = resolveOutputPath(routePath);
+        sources.push({
+            section,
+            sourcePath,
+            relativePath,
+            routePath,
+            outputPath,
+            kind: sourcePath.endsWith('.md') ? 'markdown' : 'html',
+            frontmatter,
+            body
+        });
+    }
+    return sources;
+}
+export function buildPageTitle(source, siteName) {
+    const title = source.frontmatter.title ?? slugify(path.basename(source.sourcePath, path.extname(source.sourcePath))).replace(/-/g, ' ');
+    if (source.routePath === '/') {
+        return title || siteName;
+    }
+    return title;
+}
+export function isPublished(source) {
+    if (source.frontmatter.draft === true) {
+        return false;
+    }
+    if (source.frontmatter.published === false) {
+        return false;
+    }
+    return true;
+}

package/dist/init.js

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { ensureDir, walkFiles, writeFileEnsured } from './utils.js';
+const INIT_MARKER_PATH = '.opnpress/initialized.json';
+const TEMPLATE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'templates');
+export async function isInitialized(rootDir) {
+    try {
+        await fs.access(path.join(rootDir, INIT_MARKER_PATH));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function copyTemplateTree(rootDir) {
+    try {
+        await fs.access(TEMPLATE_ROOT);
+    }
+    catch {
+        throw new Error(`Template directory not found: ${TEMPLATE_ROOT}`);
+    }
+    const entries = await walkFiles(TEMPLATE_ROOT);
+    if (!entries.length) {
+        throw new Error(`Template directory is empty: ${TEMPLATE_ROOT}`);
+    }
+    for (const templatePath of entries) {
+        const relativePath = path.relative(TEMPLATE_ROOT, templatePath);
+        const destination = path.join(rootDir, relativePath);
+        const content = await fs.readFile(templatePath, 'utf8');
+        await writeFileEnsured(destination, content);
+    }
+}
+export async function initProject(rootDir) {
+    if (await isInitialized(rootDir)) {
+        return false;
+    }
+    await ensureDir(rootDir);
+    await copyTemplateTree(rootDir);
+    await writeFileEnsured(path.join(rootDir, INIT_MARKER_PATH), JSON.stringify({
+        name: 'OpnPress',
+        initializedAt: new Date().toISOString()
+    }, null, 2) + '\n');
+    return true;
+}