create-we8 0.1.0

package/template/src/pages/blog/index.astro

@@ -0,0 +1,75 @@
+---
+/**
+ * The blog listing: editorial content, newest first.
+ *
+ * Resource types (whitepapers, case studies, research) are deliberately not
+ * here; they have their own page. Every card leads with the post's answer
+ * summary rather than the first paragraph of its body, so the listing itself
+ * is scannable and quotable.
+ */
+import JsonLd from '../../components/JsonLd.astro';
+import PostCard from '../../components/PostCard.astro';
+import BaseLayout from '../../layouts/BaseLayout.astro';
+import { getArticles, getIdentity, postUrl } from '../../lib/data.js';
+import { breadcrumbJsonLd } from '../../lib/seo.js';
+
+const identity = await getIdentity();
+const posts = await getArticles();
+
+const blogJsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'Blog',
+  name: `${identity.name} blog`,
+  url: `${identity.siteUrl}/blog`,
+  blogPost: posts.map((post) => ({
+    '@type': 'BlogPosting',
+    headline: post.title,
+    url: postUrl(post, identity),
+    datePublished: post.publishedAt,
+  })),
+};
+---
+
+<BaseLayout
+  identity={identity}
+  seo={{
+    title: 'Blog',
+    description:
+      'Practical writing on maintenance scheduling, work orders, and downtime measurement for workshops under fifty machines.',
+  }}
+>
+  <Fragment slot="jsonLd">
+    <JsonLd data={blogJsonLd} />
+    <JsonLd
+      data={breadcrumbJsonLd(
+        [
+          { name: 'Home', path: '/' },
+          { name: 'Blog', path: '/blog' },
+        ],
+        identity,
+      )}
+    />
+  </Fragment>
+
+  <div class="stack">
+    <section class="prose">
+      <h1>Blog</h1>
+      <p class="lede">
+        Each post opens with the question it answers and a summary short enough to quote. Read the
+        summary, and read the rest only if you need the reasoning.
+      </p>
+    </section>
+
+    {
+      posts.length === 0 ? (
+        <p class="notice">No posts published yet.</p>
+      ) : (
+        <ul class="grid">
+          {posts.map((post) => (
+            <PostCard post={post} />
+          ))}
+        </ul>
+      )
+    }
+  </div>
+</BaseLayout>

package/template/src/pages/contact.astro

@@ -0,0 +1,106 @@
+---
+/**
+ * Contact.
+ *
+ * The form is `<We8Form>` from `@we8/astro`: a real `<form>` element that a
+ * script upgrades to submit through the API. Without JS the markup is still a
+ * valid, labelled, accessible form, so the fallback below is a plain mailto
+ * rather than a promise the page cannot keep.
+ *
+ * With no backend configured the form is not rendered at all. A form that
+ * silently discards a message is worse than a page that says to email us.
+ */
+import We8Form from '@we8/astro/We8Form.astro';
+import JsonLd from '../components/JsonLd.astro';
+import BaseLayout from '../layouts/BaseLayout.astro';
+import { getIdentity, runtime } from '../lib/data.js';
+import { breadcrumbJsonLd } from '../lib/seo.js';
+
+const identity = await getIdentity();
+
+/**
+ * The form's key in the CMS. Create a form with this key in the admin, or
+ * change the value here to match one you already have.
+ */
+const FORM_KEY = 'contact';
+const live = runtime.enabled && runtime.key !== null;
+---
+
+<BaseLayout
+  identity={identity}
+  seo={{
+    title: 'Contact',
+    description: `Get in touch with ${identity.name}. We answer within two working days, and there is no sales sequence behind it.`,
+  }}
+>
+  <JsonLd
+    slot="jsonLd"
+    data={breadcrumbJsonLd(
+      [
+        { name: 'Home', path: '/' },
+        { name: 'Contact', path: '/contact' },
+      ],
+      identity,
+    )}
+  />
+
+  <div class="stack prose">
+    <h1>Contact</h1>
+    <p class="lede">
+      Tell us how many machines you run and what breaks most. That is enough for a useful first
+      reply.
+    </p>
+
+    {
+      live ? (
+        <We8Form
+          formKey={FORM_KEY}
+          key={runtime.key ?? undefined}
+          apiUrl={runtime.apiUrl ?? undefined}
+          successMessage="Thanks. We answer within two working days."
+        >
+          <div class="field">
+            <label for="name">Your name</label>
+            <input id="name" name="name" type="text" required autocomplete="name" />
+          </div>
+
+          <div class="field">
+            <label for="email">Email</label>
+            <input id="email" name="email" type="email" required autocomplete="email" />
+          </div>
+
+          <div class="field">
+            <label for="machines">How many machines?</label>
+            <input id="machines" name="machines" type="text" inputmode="numeric" />
+          </div>
+
+          <div class="field">
+            <label for="message">What would you like to know?</label>
+            <textarea id="message" name="message" required />
+          </div>
+
+          {/* A honeypot: bots fill it, people never see it. The API drops any
+              submission that carries a value here. */}
+          <div class="honeypot" aria-hidden="true">
+            <label for="website">Leave this empty</label>
+            <input id="website" name="website" type="text" tabindex="-1" autocomplete="off" />
+          </div>
+
+          <button type="submit">Send message</button>
+        </We8Form>
+      ) : (
+        <p class="notice">
+          This build has no backend configured, so the contact form is not rendered. Set
+          <code> WE8_API_URL</code> and <code> WE8_PUBLISHABLE_KEY</code>, create a form with the
+          key <code>{FORM_KEY}</code> in your admin, and it appears here.
+        </p>
+      )
+    }
+
+    <h2>Would you rather just email?</h2>
+    <p>
+      <a href="mailto:hello@northgatetools.example">hello@northgatetools.example</a> reaches the same
+      inbox. The form exists so you do not have to leave the page.
+    </p>
+  </div>
+</BaseLayout>

package/template/src/pages/index.astro

@@ -0,0 +1,106 @@
+---
+/**
+ * Home.
+ *
+ * Answer-first, like every page here: the hero states what this is in one
+ * sentence, the "What is this?" block answers the question a stranger actually
+ * has, and the recent writing follows. No carousel, no hero image, nothing
+ * that has to load before the point arrives.
+ */
+import AnswerBlock from '../components/AnswerBlock.astro';
+import JsonLd from '../components/JsonLd.astro';
+import PostCard from '../components/PostCard.astro';
+import BaseLayout from '../layouts/BaseLayout.astro';
+import { getArticles, getIdentity, getResources } from '../lib/data.js';
+import { faqJsonLd } from '../lib/seo.js';
+
+const identity = await getIdentity();
+const articles = (await getArticles()).slice(0, 3);
+const resources = (await getResources()).slice(0, 3);
+
+/**
+ * The home page's own answer blocks. On a content page these come from the
+ * CMS; here the site is answering questions about itself, so they are written
+ * in place and marked `authored`, which is what they are.
+ */
+const faqs = [
+  {
+    question: `What does ${identity.name} do?`,
+    summary:
+      'We make maintenance planning software for workshops with fewer than fifty machines. It schedules servicing on runtime hours, records work orders in six fields, and reports downtime from two timestamps. It does not require a consultant to set up.',
+    source: 'authored' as const,
+  },
+  {
+    question: 'Who is it for?',
+    summary:
+      'Shops where one or two people handle maintenance alongside other work, and where a full enterprise system would cost more in setup time than it saves in a year. If you have a dedicated reliability team, you have outgrown us.',
+    source: 'authored' as const,
+  },
+  {
+    question: 'What does it cost?',
+    summary:
+      'A flat monthly fee per site, with no per-user pricing and no setup charge. There is a sixty day trial with your own data, and you can export everything as CSV at any point, including after you leave.',
+    source: 'authored' as const,
+  },
+];
+---
+
+<BaseLayout
+  identity={identity}
+  seo={{
+    description: identity.seo.metaDescription ?? undefined,
+  }}
+>
+  <JsonLd slot="jsonLd" data={faqJsonLd(faqs)} />
+
+  <div class="stack">
+    <section class="prose">
+      <h1>Maintenance planning that fits on a clipboard</h1>
+      <p class="lede">
+        {identity.name} helps small workshops schedule servicing on runtime hours instead of the
+        calendar, and record enough to know which machines are actually costing them.
+      </p>
+      <p>
+        <a class="button" href="/resources">Get the starter kit</a>
+        <a class="button secondary" href="/contact">Talk to us</a>
+      </p>
+    </section>
+
+    <section aria-labelledby="faq-heading" class="stack">
+      <h2 id="faq-heading">Straight answers</h2>
+      {faqs.map((faq) => <AnswerBlock answer={faq} />)}
+    </section>
+
+    {
+      articles.length > 0 && (
+        <section aria-labelledby="recent-heading">
+          <h2 id="recent-heading">Recent writing</h2>
+          <ul class="grid">
+            {articles.map((post) => (
+              <PostCard post={post} />
+            ))}
+          </ul>
+          <p>
+            <a href="/blog">All posts</a>
+          </p>
+        </section>
+      )
+    }
+
+    {
+      resources.length > 0 && (
+        <section aria-labelledby="resources-heading">
+          <h2 id="resources-heading">Take something with you</h2>
+          <ul class="grid">
+            {resources.map((post) => (
+              <PostCard post={post} />
+            ))}
+          </ul>
+          <p>
+            <a href="/resources">All resources</a>
+          </p>
+        </section>
+      )
+    }
+  </div>
+</BaseLayout>

package/template/src/pages/llms.txt.ts

@@ -0,0 +1,64 @@
+/**
+ * llms.txt: a plain-text summary of the site, written for answer engines.
+ *
+ * The backend serves one as a site document; when it has none, this route
+ * builds one from what the site actually publishes. Generating it beats
+ * serving nothing, and a generated file listing real URLs and real answer
+ * summaries is more useful to a model than a hand-written one gone stale.
+ */
+import type { APIRoute } from 'astro';
+import {
+  answerFor,
+  getArticles,
+  getDocument,
+  getIdentity,
+  getResources,
+  postUrl,
+  type Post,
+  type SiteIdentity,
+} from '../lib/data.js';
+
+async function authoredDocument(): Promise<string> {
+  try {
+    return await getDocument('llms-txt');
+  } catch {
+    // A backend without documents is not an error here; fall through to the
+    // generated version.
+    return '';
+  }
+}
+
+function entry(post: Post, identity: SiteIdentity): string {
+  const answer = answerFor(post);
+  return `- [${post.title}](${postUrl(post, identity)})${answer ? `: ${answer.summary}` : ''}`;
+}
+
+async function generate(identity: SiteIdentity): Promise<string> {
+  const articles = await getArticles();
+  const resources = await getResources();
+  return [
+    `# ${identity.name}`,
+    '',
+    ...(identity.seo.metaDescription ? [`> ${identity.seo.metaDescription}`, ''] : []),
+    'Every page on this site opens with the question it answers and a short',
+    'summary that stands on its own when quoted.',
+    '',
+    '## Blog',
+    ...articles.map((post) => entry(post, identity)),
+    '',
+    '## Resources',
+    ...resources.map((post) => entry(post, identity)),
+    '',
+    '## Pages',
+    `- [About](${identity.siteUrl}/about)`,
+    `- [Contact](${identity.siteUrl}/contact)`,
+    '',
+  ].join('\n');
+}
+
+export const GET: APIRoute = async () => {
+  const identity = await getIdentity();
+  const authored = await authoredDocument();
+  const body = authored.trim().length > 0 ? authored : await generate(identity);
+  return new Response(body, { headers: { 'content-type': 'text/plain; charset=utf-8' } });
+};

package/template/src/pages/resources/[slug].astro

@@ -0,0 +1,25 @@
+---
+/** One resource: whitepaper, case study, or research note. */
+import type { GetStaticPaths } from 'astro';
+import PostLayout from '../../layouts/PostLayout.astro';
+import { bylineFor, getAuthors, getIdentity, getResources } from '../../lib/data.js';
+
+export const getStaticPaths = (async () => {
+  const posts = await getResources();
+  const authors = await getAuthors();
+  const identity = await getIdentity();
+  return posts.map((post) => ({
+    params: { slug: post.slug },
+    props: { post, byline: bylineFor(post, authors), identity },
+  }));
+}) satisfies GetStaticPaths;
+
+const { post, byline, identity } = Astro.props;
+---
+
+<PostLayout
+  post={post}
+  byline={byline}
+  identity={identity}
+  section={{ name: 'Resources', path: '/resources' }}
+/>

package/template/src/pages/resources.astro

@@ -0,0 +1,95 @@
+---
+/**
+ * Resources: the toolkits, case studies, and research the site gives away.
+ *
+ * These are posts whose content type is one of RESOURCE_TYPES, laid out as a
+ * shelf rather than a feed. The site's llms.txt is surfaced here too, because
+ * it is a document the site publishes and this is the page about documents the
+ * site publishes.
+ */
+import JsonLd from '../components/JsonLd.astro';
+import ResourceCard from '../components/ResourceCard.astro';
+import BaseLayout from '../layouts/BaseLayout.astro';
+import { answerFor, getIdentity, getResources, postUrl } from '../lib/data.js';
+import { faqJsonLd } from '../lib/seo.js';
+
+const identity = await getIdentity();
+const resources = await getResources();
+
+const groups = [
+  { type: 'whitepaper', heading: 'Toolkits and downloads' },
+  { type: 'case-study', heading: 'Case studies' },
+  { type: 'research', heading: 'Research' },
+] as const;
+
+const itemList = {
+  '@context': 'https://schema.org',
+  '@type': 'ItemList',
+  name: 'Resources',
+  itemListElement: resources.map((post, index) => ({
+    '@type': 'ListItem',
+    position: index + 1,
+    url: postUrl(post, identity),
+    name: post.title,
+  })),
+};
+---
+
+<BaseLayout
+  identity={identity}
+  seo={{
+    title: 'Resources',
+    description:
+      'Printable toolkits, case studies, and field research on maintenance planning for small workshops. Free, and most of it needs no email.',
+  }}
+>
+  <Fragment slot="jsonLd">
+    <JsonLd data={itemList} />
+    <JsonLd data={faqJsonLd(resources.map((post) => answerFor(post)))} />
+  </Fragment>
+
+  <div class="stack">
+    <section class="prose">
+      <h1>Resources</h1>
+      <p class="lede">
+        Everything here is free. Two items ask for an email because we send a printable pack; the
+        rest you can read on the page.
+      </p>
+    </section>
+
+    {
+      resources.length === 0 ? (
+        <p class="notice">
+          No resources published yet. Publish a post of type whitepaper, case study, or research and
+          it appears here.
+        </p>
+      ) : (
+        groups.map((group) => {
+          const items = resources.filter((post) => post.type === group.type);
+          return (
+            items.length > 0 && (
+              <section aria-label={group.heading}>
+                <h2>{group.heading}</h2>
+                <ul class="grid">
+                  {items.map((post) => (
+                    <ResourceCard post={post} />
+                  ))}
+                </ul>
+              </section>
+            )
+          );
+        })
+      )
+    }
+
+    <section class="prose">
+      <h2>What is llms.txt?</h2>
+      <p>
+        A plain text summary of this site written for answer engines, served at
+        <a href="/llms.txt">/llms.txt</a>. It lists what we publish and where, so a model
+        answering a question about maintenance planning can find the right page instead of guessing
+        from our navigation.
+      </p>
+    </section>
+  </div>
+</BaseLayout>

package/template/src/pages/robots.txt.ts

@@ -0,0 +1,18 @@
+/**
+ * robots.txt.
+ *
+ * Honors the site's own indexing preference: if the backend says discourage
+ * search engines, this disallows everything rather than quietly ignoring the
+ * setting. It also points at the sitemap and at llms.txt, which is how an
+ * answer engine finds the summary meant for it.
+ */
+import type { APIRoute } from 'astro';
+import { getIdentity } from '../lib/data.js';
+import { robotsTxt } from '../lib/seo.js';
+
+export const GET: APIRoute = async () => {
+  const identity = await getIdentity();
+  return new Response(robotsTxt(identity), {
+    headers: { 'content-type': 'text/plain; charset=utf-8' },
+  });
+};

package/template/src/pages/sitemap.xml.ts

@@ -0,0 +1,22 @@
+/**
+ * The sitemap.
+ *
+ * One document covering everything: the site's own pages, every post, every
+ * author page, and anything the backend publishes that this site does not
+ * render (the merge, in `getSitemapUrls`). Two partial sitemaps are worse than
+ * one complete one, which is why this route builds it rather than leaving the
+ * CMS sitemap and the site sitemap to disagree.
+ */
+import type { APIRoute } from 'astro';
+import { getSitemapUrls } from '../lib/data.js';
+import { sitemapXml } from '../lib/seo.js';
+
+/** The pages this template always renders. Add yours here when you add a page. */
+const STATIC_PATHS = ['/', '/about', '/blog', '/resources', '/contact'] as const;
+
+export const GET: APIRoute = async () => {
+  const urls = await getSitemapUrls(STATIC_PATHS);
+  return new Response(sitemapXml(urls), {
+    headers: { 'content-type': 'application/xml; charset=utf-8' },
+  });
+};