pagelathe 0.1.0

package/dist/chunk-LRG7WLGI.js

@@ -0,0 +1,1020 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/version.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+function getVersion() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const pkgPath = join(here, "..", "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  return pkg.version;
+}
+
+// src/config/store.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+
+// src/config/paths.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+function getConfigDir() {
+  const override = process.env.PAGELATHE_CONFIG_DIR;
+  if (override && override.trim() !== "") return override;
+  return join2(homedir(), ".pagelathe");
+}
+function getConfigFile() {
+  return join2(getConfigDir(), "config.json");
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var pagelatheConfigSchema = z.object({
+  version: z.literal(1).default(1),
+  provider: z.object({
+    /** OpenRouter API key (may instead come from env at read time). */
+    openrouterKey: z.string().min(1).optional(),
+    /** Default model id shown first in the picker. */
+    defaultModel: z.string().min(1).default("anthropic/claude-3.7-sonnet")
+  }).default({ defaultModel: "anthropic/claude-3.7-sonnet" })
+});
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+
+// src/config/store.ts
+function loadConfig() {
+  let raw;
+  try {
+    raw = readFileSync2(getConfigFile(), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return pagelatheConfigSchema.parse({});
+    }
+    throw new ConfigError(`Could not read config: ${err.message}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new ConfigError(`Config file is not valid JSON: ${getConfigFile()}`);
+  }
+  const result = pagelatheConfigSchema.safeParse(json);
+  if (!result.success) {
+    throw new ConfigError(`Config file failed validation: ${result.error.message}`);
+  }
+  return result.data;
+}
+function saveConfig(config) {
+  let validated;
+  try {
+    validated = pagelatheConfigSchema.parse(config);
+  } catch (err) {
+    throw new ConfigError(`Invalid config: ${err.message}`);
+  }
+  mkdirSync(getConfigDir(), { recursive: true, mode: 448 });
+  writeFileSync(getConfigFile(), `${JSON.stringify(validated, null, 2)}
+`, { mode: 384 });
+}
+
+// src/config/keys.ts
+var OPENROUTER_KEY_RE = /^sk-or-[A-Za-z0-9-_]{8,}$/;
+var KeyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KeyError";
+  }
+};
+function isValidOpenRouterKeyFormat(key) {
+  return OPENROUTER_KEY_RE.test(key);
+}
+function getApiKey() {
+  const fromEnv = process.env.OPENROUTER_API_KEY;
+  if (fromEnv && fromEnv.trim() !== "") return fromEnv;
+  return loadConfig().provider.openrouterKey;
+}
+function setApiKey(key) {
+  if (!isValidOpenRouterKeyFormat(key)) {
+    throw new KeyError(
+      "That does not look like an OpenRouter key (expected it to start with 'sk-or-')."
+    );
+  }
+  const config = loadConfig();
+  config.provider.openrouterKey = key;
+  saveConfig(config);
+}
+function maskKey(key) {
+  const tail = key.slice(-4);
+  return `sk-or-\u2026${tail}`;
+}
+
+// src/ui/prompts.ts
+import { isCancel, cancel, password, text } from "@clack/prompts";
+async function promptSecret(message) {
+  const value = await password({ message });
+  if (isCancel(value)) {
+    cancel("Aborted.");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptText(message) {
+  const value = await text({ message });
+  if (isCancel(value)) {
+    cancel("Aborted.");
+    process.exit(0);
+  }
+  return value;
+}
+
+// src/commands/config-cmd.ts
+function runSetKey(key) {
+  setApiKey(key);
+  return { ok: true, masked: maskKey(key) };
+}
+function runShow() {
+  const envKey = process.env.OPENROUTER_API_KEY;
+  const config = loadConfig();
+  const key = getApiKey();
+  const source = envKey && envKey.trim() !== "" ? "env" : key ? "config" : "none";
+  return {
+    keySet: Boolean(key),
+    maskedKey: key ? maskKey(key) : null,
+    defaultModel: config.provider.defaultModel,
+    source
+  };
+}
+function registerConfigCommand(program) {
+  const config = program.command("config").description("manage pagelathe config and keys");
+  config.command("set-key [key]").description("store your OpenRouter API key locally").action(async (key) => {
+    const value = key ?? await promptSecret("Paste your OpenRouter API key");
+    const { masked } = runSetKey(value);
+    console.log(`\u2713 Saved OpenRouter key (${masked}).`);
+  });
+  config.command("show").description("show current config (key is masked)").action(() => {
+    const out = runShow();
+    console.log(`Key set:       ${out.keySet ? "yes" : "no"}`);
+    console.log(`Source:        ${out.source}`);
+    console.log(`Key:           ${out.maskedKey ?? "\u2014"}`);
+    console.log(`Default model: ${out.defaultModel}`);
+  });
+}
+
+// src/commands/init-cmd.ts
+import { resolve as resolve2, join as join6 } from "path";
+
+// src/registry/read.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+
+// ../../registry/sections/src/page.ts
+import { z as z2 } from "zod";
+var primaryGoalSchema = z2.enum([
+  "signup",
+  "github_star",
+  "docs",
+  "contact",
+  "waitlist",
+  "purchase"
+]);
+var archetypeSchema = z2.enum(["sdk-infra", "technical-app", "general"]);
+var metaSchema = z2.object({
+  title: z2.string().min(1),
+  description: z2.string().min(1),
+  locales: z2.array(z2.string().min(2)).min(1).default(["en"]),
+  primaryGoal: primaryGoalSchema.default("signup")
+});
+var themeSchema = z2.object({
+  tokens: z2.object({
+    colorPrimary: z2.string().min(1).default("#3A6463"),
+    radius: z2.string().min(1).default("0.5rem"),
+    font: z2.string().min(1).default("Inter")
+  }).default({})
+});
+function buildPageDocumentSchema(entrySchemas2) {
+  const sectionUnion = entrySchemas2.length === 1 ? entrySchemas2[0] : (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    z2.discriminatedUnion("type", entrySchemas2)
+  );
+  return z2.object({
+    meta: metaSchema,
+    theme: themeSchema.default({ tokens: {} }),
+    archetype: archetypeSchema.default("general"),
+    sections: z2.array(sectionUnion).min(1)
+  });
+}
+
+// ../../registry/sections/hero/schema.ts
+import { z as z3 } from "zod";
+var ctaSchema = z3.object({
+  label: z3.string().min(1),
+  href: z3.string().min(1),
+  style: z3.enum(["primary", "secondary", "ghost"]).default("primary")
+});
+var propsSchema = z3.object({
+  variant: z3.enum(["code-snippet", "product-ui"]).default("code-snippet"),
+  eyebrow: z3.string().optional(),
+  headline: z3.string().min(1),
+  subhead: z3.string().min(1),
+  ctas: z3.array(ctaSchema).min(1).max(3),
+  /** Shown when variant === "code-snippet". */
+  code: z3.object({ lang: z3.string().min(1), source: z3.string().min(1) }).optional(),
+  /** Shown when variant === "product-ui". */
+  image: z3.object({ src: z3.string().min(1), alt: z3.string().min(1) }).optional()
+});
+var entrySchema = z3.object({
+  type: z3.literal("hero"),
+  id: z3.string().min(1),
+  props: propsSchema
+});
+var manifest = {
+  type: "hero",
+  title: "Hero",
+  description: "Above-the-fold value statement with CTAs; adaptive code or product-UI variant.",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  variants: ["code-snippet", "product-ui"],
+  componentFile: "section.astro",
+  defaultProps: {
+    variant: "code-snippet",
+    eyebrow: "Open source",
+    headline: "Postgres branching for teams",
+    subhead: "Spin up an isolated database branch per pull request in one command.",
+    ctas: [
+      { label: "Start free", href: "#get-started", style: "primary" },
+      { label: "View on GitHub", href: "https://github.com", style: "secondary" }
+    ],
+    code: {
+      lang: "bash",
+      source: "npx branchy create --from main\n# \u2192 branch ready in 1.2s"
+    }
+  }
+};
+
+// ../../registry/sections/header/schema.ts
+import { z as z4 } from "zod";
+var navLinkSchema = z4.object({ label: z4.string().min(1), href: z4.string().min(1) });
+var propsSchema2 = z4.object({
+  brand: z4.string().min(1),
+  links: z4.array(navLinkSchema).max(6).default([]),
+  github: z4.object({ href: z4.string().min(1), stars: z4.string().optional() }).optional(),
+  cta: z4.object({ label: z4.string().min(1), href: z4.string().min(1) }).optional()
+});
+var entrySchema2 = z4.object({
+  type: z4.literal("header"),
+  id: z4.string().min(1),
+  props: propsSchema2
+});
+var manifest2 = {
+  type: "header",
+  title: "Header / Navbar",
+  description: "Top navigation with brand, links, GitHub star badge, and a co-equal docs/CTA link.",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  componentFile: "section.astro",
+  defaultProps: {
+    brand: "Branchy",
+    links: [
+      { label: "Docs", href: "/docs" },
+      { label: "Pricing", href: "#pricing" }
+    ],
+    github: { href: "https://github.com", stars: "4.2k" },
+    cta: { label: "Start free", href: "#get-started" }
+  }
+};
+
+// ../../registry/sections/footer/schema.ts
+import { z as z5 } from "zod";
+var footerColumnSchema = z5.object({
+  heading: z5.string().min(1),
+  links: z5.array(z5.object({ label: z5.string().min(1), href: z5.string().min(1) })).min(1)
+});
+var propsSchema3 = z5.object({
+  brand: z5.string().min(1),
+  tagline: z5.string().optional(),
+  columns: z5.array(footerColumnSchema).max(4).default([]),
+  copyright: z5.string().min(1)
+});
+var entrySchema3 = z5.object({
+  type: z5.literal("footer"),
+  id: z5.string().min(1),
+  props: propsSchema3
+});
+var manifest3 = {
+  type: "footer",
+  title: "Footer",
+  description: "Site footer with link columns and copyright.",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  componentFile: "section.astro",
+  defaultProps: {
+    brand: "Branchy",
+    tagline: "Database branching for teams.",
+    columns: [
+      {
+        heading: "Product",
+        links: [
+          { label: "Docs", href: "/docs" },
+          { label: "Pricing", href: "#pricing" }
+        ]
+      },
+      { heading: "Community", links: [{ label: "GitHub", href: "https://github.com" }] }
+    ],
+    copyright: "\xA9 2026 Branchy. Apache-2.0."
+  }
+};
+
+// ../../registry/sections/features/schema.ts
+import { z as z6 } from "zod";
+var featureSchema = z6.object({
+  title: z6.string().min(1),
+  body: z6.string().min(1),
+  /** Larger tile = more important feature (first item is the lead). */
+  emphasis: z6.boolean().default(false),
+  icon: z6.string().optional()
+});
+var propsSchema4 = z6.object({
+  heading: z6.string().min(1),
+  subhead: z6.string().optional(),
+  items: z6.array(featureSchema).min(2).max(8)
+});
+var entrySchema4 = z6.object({
+  type: z6.literal("features"),
+  id: z6.string().min(1),
+  props: propsSchema4
+});
+var manifest4 = {
+  type: "features",
+  title: "Features / Bento",
+  description: "Feature grid; the emphasized tile is the most important capability.",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  componentFile: "section.astro",
+  defaultProps: {
+    heading: "Built for teams that ship",
+    subhead: "Isolated environments, instant reset, zero config.",
+    items: [
+      {
+        title: "Branch per PR",
+        body: "Every pull request gets an isolated database.",
+        emphasis: true
+      },
+      { title: "1-second reset", body: "Roll back to a clean state instantly." },
+      { title: "Self-host or cloud", body: "Run it your way; data stays yours." }
+    ]
+  }
+};
+
+// ../../registry/sections/codeDemo/schema.ts
+import { z as z7 } from "zod";
+var snippetSchema = z7.object({
+  lang: z7.string().min(1),
+  label: z7.string().min(1),
+  source: z7.string().min(1)
+});
+var propsSchema5 = z7.object({
+  heading: z7.string().min(1),
+  subhead: z7.string().optional(),
+  snippets: z7.array(snippetSchema).min(1).max(6)
+});
+var entrySchema5 = z7.object({
+  type: z7.literal("codeDemo"),
+  id: z7.string().min(1),
+  props: propsSchema5
+});
+var manifest5 = {
+  type: "codeDemo",
+  title: "Code / Integration demo",
+  description: "Multi-language code tabs with shiki highlighting and copy-to-clipboard.",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app"],
+  componentFile: "section.astro",
+  defaultProps: {
+    heading: "Drop it into your stack",
+    subhead: "Same API across languages.",
+    snippets: [
+      {
+        lang: "python",
+        label: "Python",
+        source: 'from branchy import Client\nc = Client()\nc.create("feat-x")'
+      },
+      {
+        lang: "javascript",
+        label: "Node",
+        source: "import { Client } from 'branchy'\nawait new Client().create('feat-x')"
+      },
+      { lang: "go", label: "Go", source: 'client := branchy.New()\nclient.Create("feat-x")' }
+    ]
+  }
+};
+
+// ../../registry/sections/pricing/schema.ts
+import { z as z8 } from "zod";
+var tierSchema = z8.object({
+  name: z8.string().min(1),
+  price: z8.string().min(1),
+  period: z8.string().optional(),
+  description: z8.string().min(1),
+  features: z8.array(z8.string().min(1)).min(1),
+  cta: z8.object({ label: z8.string().min(1), href: z8.string().min(1) }),
+  featured: z8.boolean().default(false)
+});
+var propsSchema6 = z8.object({
+  heading: z8.string().min(1),
+  subhead: z8.string().optional(),
+  tiers: z8.array(tierSchema).min(1).max(4)
+});
+var entrySchema6 = z8.object({
+  type: z8.literal("pricing"),
+  id: z8.string().min(1),
+  props: propsSchema6
+});
+var manifest6 = {
+  type: "pricing",
+  title: "Pricing",
+  description: "Transparent pricing tiers with honest constraints (rate limits, free tier).",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  componentFile: "section.astro",
+  defaultProps: {
+    heading: "Honest pricing",
+    subhead: "Start free. No credit card.",
+    tiers: [
+      {
+        name: "Open source",
+        price: "$0",
+        description: "Self-host, unlimited branches.",
+        features: ["Self-hosted", "Community support", "Apache-2.0"],
+        cta: { label: "Get started", href: "#get-started" }
+      },
+      {
+        name: "Team",
+        price: "$29",
+        period: "/mo",
+        description: "Managed cloud for small teams.",
+        features: ["10 projects", "Daily backups", "Email support"],
+        cta: { label: "Start trial", href: "#trial" },
+        featured: true
+      }
+    ]
+  }
+};
+
+// ../../registry/sections/finalCta/schema.ts
+import { z as z9 } from "zod";
+var propsSchema7 = z9.object({
+  headline: z9.string().min(1),
+  subhead: z9.string().optional(),
+  cta: z9.object({ label: z9.string().min(1), href: z9.string().min(1) }),
+  microcopy: z9.string().optional()
+});
+var entrySchema7 = z9.object({
+  type: z9.literal("finalCta"),
+  id: z9.string().min(1),
+  props: propsSchema7
+});
+var manifest7 = {
+  type: "finalCta",
+  title: "Final CTA",
+  description: "Closing call to action with action-specific label and honest microcopy.",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  componentFile: "section.astro",
+  defaultProps: {
+    headline: "Ship your first branch today",
+    subhead: "Free and open source. Self-host in minutes.",
+    cta: { label: "Start free", href: "#get-started" },
+    microcopy: "No credit card \xB7 Apache-2.0"
+  }
+};
+
+// ../../registry/sections/src/registry.ts
+var sectionModules = [
+  { manifest, propsSchema, entrySchema },
+  { manifest: manifest2, propsSchema: propsSchema2, entrySchema: entrySchema2 },
+  { manifest: manifest3, propsSchema: propsSchema3, entrySchema: entrySchema3 },
+  {
+    manifest: manifest4,
+    propsSchema: propsSchema4,
+    entrySchema: entrySchema4
+  },
+  {
+    manifest: manifest5,
+    propsSchema: propsSchema5,
+    entrySchema: entrySchema5
+  },
+  {
+    manifest: manifest6,
+    propsSchema: propsSchema6,
+    entrySchema: entrySchema6
+  },
+  {
+    manifest: manifest7,
+    propsSchema: propsSchema7,
+    entrySchema: entrySchema7
+  }
+];
+var registry = Object.fromEntries(
+  sectionModules.map((m) => [m.manifest.type, m])
+);
+function listSections() {
+  return [...sectionModules];
+}
+function getSection(type) {
+  return registry[type];
+}
+var entrySchemas = sectionModules.map((m) => m.entrySchema);
+var pageDocumentSchema = buildPageDocumentSchema(
+  entrySchemas
+);
+
+// src/registry/paths.ts
+import { existsSync } from "fs";
+import { dirname as dirname2, join as join3, resolve } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var RegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryError";
+  }
+};
+function getRegistryRoot() {
+  const override = process.env.PAGELATHE_REGISTRY_DIR;
+  if (override && override.trim() !== "") return resolve(override);
+  let dir = dirname2(fileURLToPath2(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    const candidate = join3(dir, "registry");
+    if (existsSync(join3(candidate, "sections")) && existsSync(join3(candidate, "app"))) {
+      return candidate;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new RegistryError(
+    "Could not locate the pagelathe registry. Set PAGELATHE_REGISTRY_DIR to the registry/ directory."
+  );
+}
+function getSectionsDir() {
+  return join3(getRegistryRoot(), "sections");
+}
+function getAppDir() {
+  return join3(getRegistryRoot(), "app");
+}
+
+// src/registry/read.ts
+function listAvailableSections() {
+  return listSections().map((s) => ({
+    type: s.manifest.type,
+    title: s.manifest.title,
+    required: s.manifest.required
+  }));
+}
+function sectionComponentPath(type) {
+  const known = listSections().some((s) => s.manifest.type === type);
+  if (!known) throw new RegistryError(`Unknown section: "${type}".`);
+  const path = join4(getSectionsDir(), type, "section.astro");
+  if (!existsSync2(path)) {
+    throw new RegistryError(`Section "${type}" has no section.astro at ${path}.`);
+  }
+  return path;
+}
+var DEFAULT_PAGE_SECTIONS = [
+  "header",
+  "hero",
+  "features",
+  "codeDemo",
+  "pricing",
+  "finalCta",
+  "footer"
+];
+
+// src/fs/scaffold.ts
+import {
+  cpSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  copyFileSync,
+  rmSync,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+var COPY_SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", ".astro"]);
+function copyAppTemplate(srcDir, destDir) {
+  const created = [];
+  cpSync(srcDir, destDir, {
+    recursive: true,
+    filter: (src) => {
+      const base = src.split(/[\\/]/).pop() ?? "";
+      if (COPY_SKIP.has(base)) return false;
+      if (/[\\/]src[\\/]components[\\/]sections[\\/].+\.astro$/.test(src)) return false;
+      return true;
+    }
+  });
+  created.push(destDir);
+  return created;
+}
+function isNonEmptyDir(dir) {
+  if (!existsSync3(dir)) return false;
+  return readdirSync(dir).filter((n) => n !== ".git").length > 0;
+}
+function copyInto(srcFile, destFile) {
+  mkdirSync2(dirname3(destFile), { recursive: true });
+  copyFileSync(srcFile, destFile);
+}
+function finalizeScaffold(destDir) {
+  rmSync(join5(destDir, "scripts"), { recursive: true, force: true });
+  const pkgPath = join5(destDir, "package.json");
+  if (!existsSync3(pkgPath)) return;
+  const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+  if (pkg.scripts) {
+    delete pkg.scripts.prebuild;
+    delete pkg.scripts["clean:sections"];
+  }
+  writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+
+// src/commands/init-cmd.ts
+async function runInit(targetDir, opts = {}) {
+  const dest = resolve2(targetDir);
+  if (isNonEmptyDir(dest) && !opts.force) {
+    throw new Error(`Directory ${dest} is not empty. Use --force to scaffold anyway.`);
+  }
+  const created = copyAppTemplate(getAppDir(), dest);
+  for (const type of DEFAULT_PAGE_SECTIONS) {
+    copyInto(
+      sectionComponentPath(type),
+      join6(dest, "src", "components", "sections", `${type}.astro`)
+    );
+  }
+  finalizeScaffold(dest);
+  return { created };
+}
+function registerInitCommand(program) {
+  program.command("init [dir]").description("scaffold a new pagelathe landing project").option("-f, --force", "scaffold into a non-empty directory").action(async (dir, options) => {
+    const target = dir ?? ".";
+    await runInit(target, options);
+    console.log(`\u2713 Scaffolded pagelathe project in ${resolve2(target)}.`);
+    console.log(`  Next: cd ${target} && pnpm install && pnpm dev`);
+  });
+}
+
+// src/commands/add-cmd.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join7, resolve as resolve3 } from "path";
+async function runAdd(type, opts = {}) {
+  const src = sectionComponentPath(type);
+  const cwd = resolve3(opts.cwd ?? process.cwd());
+  const dest = join7(cwd, "src", "components", "sections", `${type}.astro`);
+  if (existsSync4(dest) && !opts.force) {
+    throw new Error(`${dest} exists. Use --force to overwrite.`);
+  }
+  copyInto(src, dest);
+  return { written: dest };
+}
+function registerAddCommand(program) {
+  program.command("add <section>").description("vendor a section component from the registry into this project").option("-f, --force", "overwrite an existing section file").action(async (section, options) => {
+    try {
+      const { written } = await runAdd(section, options);
+      console.log(`\u2713 Added ${section} \u2192 ${written}`);
+    } catch (err) {
+      const available = listAvailableSections().map((s) => s.type).join(", ");
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`${msg}
+Available sections: ${available}`);
+    }
+  });
+}
+
+// src/gen/provider.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/gen/llm.ts
+var LlmError = class extends Error {
+  constructor(message, detail) {
+    super(message);
+    this.detail = detail;
+    this.name = "LlmError";
+  }
+  detail;
+};
+
+// src/gen/provider.ts
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+function createOpenRouterClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+  async function callOnce(messages, schemaName, jsonSchema) {
+    const res = await fetchImpl(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${opts.apiKey}`,
+        "Content-Type": "application/json",
+        ...opts.appUrl ? { "HTTP-Referer": opts.appUrl } : {},
+        ...opts.appName ? { "X-Title": opts.appName } : {}
+      },
+      body: JSON.stringify({
+        model: opts.model,
+        messages,
+        response_format: {
+          type: "json_schema",
+          json_schema: { name: schemaName, strict: true, schema: jsonSchema }
+        }
+      })
+    });
+    if (!res.ok) {
+      throw new LlmError(`OpenRouter request failed (HTTP ${res.status}).`, {
+        status: res.status
+      });
+    }
+    const data = await res.json();
+    const content = data.choices?.[0]?.message?.content;
+    if (typeof content !== "string") throw new LlmError("OpenRouter returned no content.");
+    return content;
+  }
+  return {
+    async generateObject(schema, options) {
+      const maxRetries = options.maxRetries ?? 2;
+      const schemaName = options.schemaName ?? "result";
+      const jsonSchema = zodToJsonSchema(schema, { $refStrategy: "none" });
+      const messages = [
+        { role: "system", content: options.system },
+        {
+          role: "user",
+          content: `${options.prompt}
+
+Return ONLY a JSON object that matches the schema. No prose, no markdown fences.`
+        }
+      ];
+      let lastErr = "";
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        let content;
+        try {
+          content = await callOnce(messages, schemaName, jsonSchema);
+        } catch (err) {
+          if (err instanceof LlmError && err.detail?.status !== void 0 && err.detail.status >= 500 && attempt < maxRetries) {
+            continue;
+          }
+          throw err instanceof LlmError ? err : new LlmError("OpenRouter request error.");
+        }
+        const parsed = safeJson(content);
+        const result = parsed === void 0 ? void 0 : schema.safeParse(parsed);
+        if (result?.success) return result.data;
+        lastErr = result && !result.success ? JSON.stringify(result.error.issues) : "Output was not valid JSON.";
+        messages.push({ role: "assistant", content });
+        messages.push({
+          role: "user",
+          content: `That output was invalid: ${lastErr}
+Return a corrected JSON object that matches the schema exactly.`
+        });
+      }
+      throw new LlmError(
+        `Model did not produce schema-valid output after ${maxRetries + 1} attempts.`,
+        { attempts: maxRetries + 1 }
+      );
+    }
+  };
+}
+function safeJson(text2) {
+  const trimmed = text2.trim().replace(/^```(?:json)?\s*/i, "").replace(/```$/i, "");
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/gen/generate.ts
+import { join as join9 } from "path";
+
+// src/gen/archetype.ts
+import { z as z10 } from "zod";
+
+// src/gen/prompts.ts
+var BANNED_WORDS = [
+  "scalable",
+  "powerful",
+  "easy",
+  "seamless",
+  "robust",
+  "cutting-edge",
+  "revolutionary",
+  "game-changing"
+];
+var BRAND_RULES = `You write landing-page copy for technical founders building developer tools.
+Rules (non-negotiable):
+- Anti-fluff: never use these words: ${BANNED_WORDS.join(", ")}. Be concrete and specific.
+- Dark-mode-first, terse, honest. No marketing hyperbole.
+- Keep terminology consistent across sections (same product nouns and verbs).
+- For sdk-infra/technical-app products, lead with real code and real numbers.
+- Pricing must be honest: name real constraints (rate limits, free tier, OSS).`;
+var archetypeSystem = `You classify developer-product landing pages into one archetype.
+${BRAND_RULES}`;
+var plannerSystem = `You plan the section order of a developer landing page.
+${BRAND_RULES}`;
+var metaSystem = `You write page metadata (title, description) for a developer landing page.
+${BRAND_RULES}`;
+function fillSystem(type, archetype) {
+  return `You write the content for the "${type}" section of a ${archetype} developer landing page.
+${BRAND_RULES}
+Fill every required field of the JSON schema with concrete, on-brand content.`;
+}
+
+// src/gen/archetype.ts
+var resultSchema = z10.object({
+  archetype: z10.enum(["sdk-infra", "technical-app", "general"]),
+  reason: z10.string().min(1)
+});
+async function classifyArchetype(description, llm) {
+  const { archetype } = await llm.generateObject(resultSchema, {
+    system: archetypeSystem,
+    schemaName: "archetype",
+    prompt: `Classify this product into one archetype.
+- sdk-infra: SDKs, APIs, databases, infra, CLIs, libraries (code-forward).
+- technical-app: technical SaaS / apps with a UI for technical users.
+- general: anything else technical.
+
+Product description:
+${description}`
+  });
+  return archetype;
+}
+
+// src/gen/planner.ts
+import { z as z11 } from "zod";
+var CANONICAL_ORDER = [
+  "header",
+  "hero",
+  "features",
+  "codeDemo",
+  "pricing",
+  "finalCta",
+  "footer"
+];
+var REQUIRED = ["header", "hero", "features", "pricing", "finalCta", "footer"];
+async function planSections(input, llm) {
+  const available = listSections().map((s) => s.manifest.type);
+  const schema = z11.object({
+    sections: z11.array(z11.enum(available)).min(1)
+  });
+  const { sections } = await llm.generateObject(schema, {
+    system: plannerSystem,
+    schemaName: "section_plan",
+    prompt: `Choose which sections this ${input.archetype} product page should include, from: ${available.join(", ")}.
+Always include: ${REQUIRED.join(", ")}.
+For sdk-infra/technical-app, include codeDemo.
+Return them in the order they should appear.
+
+Product description:
+${input.description}`
+  });
+  const chosen = new Set(sections);
+  for (const r of REQUIRED) chosen.add(r);
+  if (input.archetype !== "general") chosen.add("codeDemo");
+  return CANONICAL_ORDER.filter((t) => chosen.has(t));
+}
+
+// src/gen/fill.ts
+import { z as z12 } from "zod";
+async function fillSection(input, llm) {
+  const section = getSection(input.type);
+  if (!section) throw new Error(`Unknown section: ${input.type}`);
+  return llm.generateObject(section.propsSchema, {
+    system: fillSystem(input.type, input.archetype),
+    schemaName: `${input.type}_props`,
+    prompt: `Product "${input.brand}": ${input.description}
+
+Write the props for the "${input.type}" section. Use real, specific copy consistent with the product. Reuse the brand name "${input.brand}" where a brand is needed.`
+  });
+}
+var metaResultSchema = z12.object({
+  title: z12.string().min(1),
+  description: z12.string().min(1),
+  primaryGoal: z12.enum(["signup", "github_star", "docs", "contact", "waitlist", "purchase"]),
+  brand: z12.string().min(1)
+});
+async function deriveMeta(input, llm) {
+  return llm.generateObject(metaResultSchema, {
+    system: metaSystem,
+    schemaName: "page_meta",
+    prompt: `From this product description, produce: a short brand name, an SEO title ("<Brand> \u2014 <value>"), a one-sentence meta description, and the primary conversion goal.
+
+Description:
+${input.description}`
+  });
+}
+
+// src/gen/yaml-doc.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, renameSync } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
+import { stringify as yamlStringify } from "yaml";
+function writeDocumentYaml(doc, destFile) {
+  mkdirSync3(dirname4(destFile), { recursive: true });
+  const tmp = join8(dirname4(destFile), `.index.yaml.tmp-${process.pid}`);
+  writeFileSync3(tmp, yamlStringify(doc), "utf8");
+  renameSync(tmp, destFile);
+}
+
+// src/gen/generate.ts
+async function generate(input) {
+  const log = input.onProgress ?? (() => {
+  });
+  log("Classifying product\u2026");
+  const archetype = await classifyArchetype(input.description, input.llm);
+  log(`Archetype: ${archetype}`);
+  const meta = await deriveMeta({ description: input.description }, input.llm);
+  log(`Planning sections\u2026`);
+  const types = await planSections({ description: input.description, archetype }, input.llm);
+  const sections = [];
+  for (const type of types) {
+    log(`Writing ${type}\u2026`);
+    const props = await fillSection(
+      { type, description: input.description, archetype, brand: meta.brand },
+      input.llm
+    );
+    sections.push({ type, id: `${type}-1`, props });
+  }
+  const document = pageDocumentSchema.parse({
+    meta: {
+      title: meta.title,
+      description: meta.description,
+      locales: ["en"],
+      primaryGoal: meta.primaryGoal
+    },
+    theme: { tokens: {} },
+    archetype,
+    sections
+  });
+  for (const type of types) {
+    copyInto(
+      sectionComponentPath(type),
+      join9(input.cwd, "src", "components", "sections", `${type}.astro`)
+    );
+  }
+  const yamlPath = join9(input.cwd, "src", "content", "landing", "index.yaml");
+  writeDocumentYaml(document, yamlPath);
+  return { document, vendored: types, yamlPath };
+}
+
+// src/commands/generate-cmd.ts
+async function runGenerate(opts) {
+  const description = opts.description?.trim();
+  if (!description) throw new Error("A product description is required.");
+  let llm = opts.llm;
+  if (!llm) {
+    const key = getApiKey();
+    if (!key) {
+      throw new Error(
+        "No OpenRouter key found. Run `pagelathe config set-key` or set OPENROUTER_API_KEY."
+      );
+    }
+    const model = opts.model ?? loadConfig().provider.defaultModel;
+    llm = createOpenRouterClient({ apiKey: key, model, appName: "pagelathe" });
+  }
+  return generate({
+    description,
+    cwd: opts.cwd ?? process.cwd(),
+    llm,
+    onProgress: opts.onProgress
+  });
+}
+function registerGenerateCommand(program) {
+  program.command("generate").description("describe your product and generate an on-brand landing page").option("-d, --description <text>", "product description (skips the prompt)").option("-m, --model <id>", "OpenRouter model id (defaults to your config)").action(async (options) => {
+    const description = options.description ?? await promptText("Describe your product (what it does, who it's for):");
+    const res = await runGenerate({
+      description,
+      model: options.model,
+      onProgress: (m) => console.log(`  ${m}`)
+    });
+    console.log(`
+\u2713 Generated ${res.vendored.length} sections \u2192 ${res.yamlPath}`);
+    console.log(`  Next: pnpm dev`);
+  });
+}
+
+// src/index.ts
+function buildProgram() {
+  const program = new Command();
+  program.name("pagelathe").description("AI landing-page builder for technical founders").version(getVersion(), "-v, --version", "print the pagelathe version");
+  registerConfigCommand(program);
+  registerInitCommand(program);
+  registerAddCommand(program);
+  registerGenerateCommand(program);
+  return program;
+}
+async function cli(argv) {
+  const program = buildProgram();
+  await program.parseAsync(argv);
+}
+
+export {
+  buildProgram,
+  cli
+};