@flocon-ai/init 0.0.0-stage → 0.0.2

package/src/sitemap.mjs

@@ -0,0 +1,180 @@
+// Sitemap + llms.txt files written by the CLI (`--no-sitemap` skips them).
+// Copy of the `get_setup` snippets in back/functions/mcp/setup.ts (a package never imports from back/).
+// test/init.test.mjs fails if they drift.
+import fs from "node:fs"
+import path from "node:path"
+import { applyUrlRule } from "./url.mjs"
+
+const nextSitemap = `import type { MetadataRoute } from "next"
+import { floconSitemap } from "@flocon-ai/next"
+import { connection } from "next/server"
+
+// Built on getAllPages(): published pages only, never drafts.
+// connection(): rendered on each request, so new pages show up without a deploy and the build never needs FLOCON_TOKEN.
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  await connection()
+  return floconSitemap({ url: ({ locale, path }) => \`https://example.com\${path}\` })
+}
+`
+
+const nextLlms = `import { floconLlmsTxt } from "@flocon-ai/next"
+import { connection } from "next/server"
+
+// connection(): rendered on each request (also with cacheComponents).
+export async function GET() {
+  await connection()
+  return new Response(await floconLlmsTxt({ url: ({ locale, path }) => \`https://example.com\${path}\` }), {
+    headers: { "content-type": "text/plain; charset=utf-8" }
+  })
+}
+`
+
+const astroSitemap = `import { getAllPages } from "@flocon-ai/astro"
+
+// Published pages only, never drafts.
+export async function GET() {
+  const pages = await getAllPages()
+  const urls = pages
+    .map((p) => \`<url><loc>https://example.com\${p.path}</loc><lastmod>\${p.updatedAt}</lastmod></url>\`)
+    .join("")
+  return new Response(
+    \`<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\${urls}</urlset>\`,
+    { headers: { "content-type": "application/xml" } }
+  )
+}
+`
+
+const astroLlms = `import { floconLlmsTxt } from "@flocon-ai/astro"
+
+export async function GET() {
+  const text = await floconLlmsTxt({ url: ({ locale, path }) => \`https://example.com\${path}\` })
+  return new Response(text, { headers: { "content-type": "text/plain; charset=utf-8" } })
+}
+`
+
+const reactSitemap = `import { floconSitemap } from "@flocon-ai/react"
+
+export async function loader() {
+  const xml = await floconSitemap({ url: ({ locale, path }) => \`https://example.com\${path}\` })
+  return new Response(xml, { headers: { "content-type": "application/xml; charset=utf-8" } })
+}
+`
+
+const reactLlms = `import { floconLlmsTxt } from "@flocon-ai/react"
+
+export async function loader() {
+  const text = await floconLlmsTxt({ url: ({ locale, path }) => \`https://example.com\${path}\` })
+  return new Response(text, { headers: { "content-type": "text/plain; charset=utf-8" } })
+}
+`
+
+const exts = (base, list) => list.map((e) => base + e)
+
+// `existing` = files that mean the website already has one.
+function spec(framework, appDir, rrApp = "app", rrDir = "routes") {
+  if (framework === "nextjs") {
+    return {
+      sitemap: {
+        file: `${appDir}/sitemap.ts`,
+        code: nextSitemap,
+        existing: [...exts(`${appDir}/sitemap`, [".js", ".ts", ".xml"]), ...exts(`${appDir}/sitemap.xml/route`, [".js", ".ts"]), "public/sitemap.xml"]
+      },
+      llms: {
+        file: `${appDir}/llms.txt/route.ts`,
+        code: nextLlms,
+        existing: [...exts(`${appDir}/llms.txt/route`, [".js", ".ts"]), `${appDir}/llms.txt`, "public/llms.txt"]
+      }
+    }
+  }
+  if (framework === "astro") {
+    return {
+      sitemap: {
+        file: "src/pages/sitemap.xml.ts",
+        code: astroSitemap,
+        existing: [...exts("src/pages/sitemap.xml", [".ts", ".js", ".astro"]), "src/pages/sitemap-index.xml.ts", "public/sitemap.xml", "public/sitemap-index.xml"]
+      },
+      llms: {
+        file: "src/pages/llms.txt.ts",
+        code: astroLlms,
+        existing: [...exts("src/pages/llms.txt", [".ts", ".js", ".astro"]), "public/llms.txt"]
+      }
+    }
+  }
+  const routes = `${rrApp}/${rrDir}`
+  return {
+    sitemap: {
+      file: `${routes}/sitemap[.]xml.ts`,
+      code: reactSitemap,
+      existing: [...exts(`${routes}/sitemap[.]xml`, [".ts", ".tsx"]), ...exts(`${routes}/sitemap.xml`, [".ts", ".tsx"]), "public/sitemap.xml"]
+    },
+    llms: {
+      file: `${routes}/llms[.]txt.ts`,
+      code: reactLlms,
+      existing: [...exts(`${routes}/llms[.]txt`, [".ts", ".tsx"]), ...exts(`${routes}/llms.txt`, [".ts", ".tsx"]), "public/llms.txt"]
+    }
+  }
+}
+
+// Astro: @astrojs/sitemap builds the sitemap from the config, there is no file to detect.
+function astroConfigHasSitemap(cwd) {
+  for (const f of ["astro.config.mjs", "astro.config.ts", "astro.config.js", "astro.config.mts"]) {
+    try {
+      if (/@astrojs\/sitemap/.test(fs.readFileSync(path.join(cwd, f), "utf8"))) return true
+    } catch {}
+  }
+  return false
+}
+
+// Never overwrites. Returns { manual, files }: manual = something has to be done by hand,
+// files = the files (written or printed) that still have https://example.com (or the domain the CLI found).
+// A file that is already ours (imports @flocon-ai/) is skipped: the command ran here before.
+export function addSitemapAndLlms({ cwd, framework, appDir, rrApp, rrDir, routesFile, urlPath, hasLocale, flat, domain, log }) {
+  const files = spec(framework, appDir, rrApp, rrDir)
+  const exists = (f) => fs.existsSync(path.join(cwd, f))
+  const ours = (f) => fs.statSync(path.join(cwd, f)).isFile() && fs.readFileSync(path.join(cwd, f), "utf8").includes("@flocon-ai/")
+  let manual = false
+  const created = []
+  const urlFiles = []
+  log()
+  for (const [kind, name] of [
+    ["sitemap", "sitemap"],
+    ["llms", "llms.txt"]
+  ]) {
+    const { file, existing } = files[kind]
+    const code = applyUrlRule(files[kind].code, urlPath, hasLocale, domain)
+    const found = existing.filter(exists)
+    if (found.some(ours)) continue
+    urlFiles.push(file)
+    if (found.length || (kind === "sitemap" && framework === "astro" && astroConfigHasSitemap(cwd))) {
+      manual = true
+      log(`The website already has a ${name}. I did not touch it. Add this yourself: merge the Flocon URLs (published pages, under ${urlPath}) into it.`)
+      log(`Example (${file}):\n`)
+      log(code)
+    } else {
+      const full = path.join(cwd, file)
+      fs.mkdirSync(path.dirname(full), { recursive: true })
+      fs.writeFileSync(full, code, { flag: "wx" })
+      log(`Created ${file}`)
+      created.push(file)
+    }
+  }
+  // flatRoutes(): the file names are the URLs, nothing to register.
+  if (framework === "react" && !flat && created.length) {
+    const r = `${files.sitemap.file.split("/").slice(-2).join("/")}`
+    const l = `${files.llms.file.split("/").slice(-2).join("/")}`
+    log(`Register both routes before the catch-all in ${routesFile}:\n  route("sitemap.xml", "${r}")\n  route("llms.txt", "${l}")`)
+  }
+  return { manual, files: urlFiles, created }
+}
+
+// The sitemap and llms.txt files that are Flocon's own (they import @flocon-ai/): a second run may fix their domain.
+export function ownSitemapFiles({ cwd, framework, appDir, rrApp, rrDir }) {
+  const files = spec(framework, appDir, rrApp, rrDir)
+  return [files.sitemap.file, files.llms.file].filter((f) => {
+    try {
+      return fs.readFileSync(path.join(cwd, f), "utf8").includes("@flocon-ai/")
+    } catch {
+      return false
+    }
+  })
+}

package/src/templates.mjs

@@ -0,0 +1,140 @@
+// Route files written by the CLI.
+// Copy of the `get_setup` snippets in back/functions/mcp/setup.ts (a package never imports from back/).
+// test/init.test.mjs fails if they drift.
+
+const nextjs = `import { FloconPage, getFloconMetadata } from "@flocon-ai/next"
+
+// One catch-all route serves every Flocon page. Rendered on each request.
+export const dynamic = "force-dynamic"
+
+// Your URL rule. Flocon AI adds no prefix of its own.
+const url = ({ locale, path }: { locale: string; path: string }) => \`https://example.com\${path}\`
+
+type Props = { params: Promise<{ slug: string[] }> }
+
+// Title, description, canonical URL and hreflang.
+export async function generateMetadata({ params }: Props) {
+  const { slug } = await params
+  return getFloconMetadata({ path: "/" + slug.join("/"), url })
+}
+
+export default async function Page({ params }: Props) {
+  const { slug } = await params
+  return <FloconPage path={"/" + slug.join("/")} url={url} />
+}
+`
+
+// Same as `nextjs`, for a route under `[locale]`: the locale goes to the lib.
+const nextjsLocale = `import { FloconPage, getFloconMetadata } from "@flocon-ai/next"
+
+// One catch-all route serves every Flocon page, under the [locale] segment. Rendered on each request.
+export const dynamic = "force-dynamic"
+
+// Your URL rule. Flocon AI adds no prefix of its own.
+const url = ({ locale, path }: { locale: string; path: string }) => \`https://example.com/\${locale}\${path}\`
+
+type Props = { params: Promise<{ locale: string; slug: string[] }> }
+
+// Title, description, canonical URL and hreflang.
+export async function generateMetadata({ params }: Props) {
+  const { locale, slug } = await params
+  return getFloconMetadata({ locale, path: "/" + slug.join("/"), url })
+}
+
+export default async function Page({ params }: Props) {
+  const { locale, slug } = await params
+  return <FloconPage locale={locale} path={"/" + slug.join("/")} url={url} />
+}
+`
+
+const astro = `---
+import FloconPage from "@flocon-ai/astro/FloconPage.astro"
+import { getFloconPage, getFloconMetadata } from "@flocon-ai/astro"
+
+// Your URL rule. Flocon AI adds no prefix of its own.
+const url = ({ locale, path }: { locale: string; path: string }) => \`https://example.com\${path}\`
+
+const data = await getFloconPage({ path: "/" + (Astro.params.slug ?? "") })
+if (!data) return new Response(null, { status: 404 })
+const meta = getFloconMetadata({ data, url })
+---
+
+<html lang={data.page.locale}>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+    <title>{meta.title}</title>
+    {meta.meta.map((m) => <meta {...m} />)}
+    {meta.links.map((l) => <link {...l} />)}
+  </head>
+  <body>
+    <FloconPage data={data} url={url} />
+  </body>
+</html>
+`
+
+// Same as `astro`, for a route under `src/pages/[locale]`.
+const astroLocale = `---
+import FloconPage from "@flocon-ai/astro/FloconPage.astro"
+import { getFloconPage, getFloconMetadata } from "@flocon-ai/astro"
+
+// Your URL rule. Flocon AI adds no prefix of its own.
+const url = ({ locale, path }: { locale: string; path: string }) => \`https://example.com/\${locale}\${path}\`
+
+// Always set: this file is under [locale].
+const data = await getFloconPage({ path: "/" + (Astro.params.slug ?? ""), locale: Astro.params.locale as string })
+if (!data) return new Response(null, { status: 404 })
+const meta = getFloconMetadata({ data, url })
+---
+
+<html lang={data.page.locale}>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+    <title>{meta.title}</title>
+    {meta.meta.map((m) => <meta {...m} />)}
+    {meta.links.map((l) => <link {...l} />)}
+  </head>
+  <body>
+    <FloconPage data={data} url={url} />
+  </body>
+</html>
+`
+
+const react = `// Register it as a splat route in app/routes.ts: route("*", "routes/flocon.tsx") (or route("blog/*", ...) for a prefix)
+import { FloconPage, getFloconMetadata, getPage } from "@flocon-ai/react"
+import type { Route } from "./+types/flocon"
+
+const url = ({ locale, path }: { locale: string; path: string }) => \`https://example.com\${path}\`
+
+export async function loader({ params }: Route.LoaderArgs) {
+  const page = await getPage({ path: "/" + params["*"] })
+  if (!page) throw new Response("Not found", { status: 404 })
+  return page
+}
+
+export function meta({ loaderData }: Route.MetaArgs) {
+  if (!loaderData) return [{ title: "Not found" }]
+  const m = getFloconMetadata({ page: loaderData, url })
+  return [
+    { title: m.title },
+    { name: "description", content: m.description },
+    { property: "og:type", content: m.openGraph.type },
+    { property: "og:title", content: m.openGraph.title },
+    { property: "og:description", content: m.openGraph.description },
+    { property: "og:url", content: m.openGraph.url },
+    { property: "og:locale", content: m.openGraph.locale },
+    { name: "twitter:card", content: m.twitter.card },
+    { name: "twitter:title", content: m.twitter.title },
+    { name: "twitter:description", content: m.twitter.description },
+    { tagName: "link", rel: "canonical", href: m.canonical },
+    ...Object.entries(m.languages).map(([hrefLang, href]) => ({ tagName: "link", rel: "alternate", hrefLang, href }))
+  ]
+}
+
+export default function Page({ loaderData }: Route.ComponentProps) {
+  return <FloconPage page={loaderData} url={url} />
+}
+`
+
+export const TEMPLATES = { nextjs, nextjsLocale, astro, astroLocale, react }

package/src/url.mjs

@@ -0,0 +1,17 @@
+// Fills the URL rule of a get_setup snippet for this website.
+// get_setup snippets use https://example.com${path} (no locale, no folder).
+// The CLI knows the folder (e.g. /blog) and if the website has a [locale] segment,
+// so it writes the real rule. A website without a locale in its URLs never gets one.
+// `domain`: the website's domain when the CLI found it (e.g. https://acme.com), else example.com stays.
+export function applyUrlRule(code, urlPath, hasLocale, domain) {
+  const folder = urlPath === "/" ? "" : urlPath
+  const rule = (locale, p) => `https://example.com${hasLocale ? "/${" + locale + "}" : ""}${folder}\${${p}}`
+  let out = code
+    .replaceAll("https://example.com/${locale}${path}", rule("locale", "path"))
+    .replaceAll("https://example.com${path}", rule("locale", "path"))
+    .replaceAll("https://example.com${p.path}", rule("p.locale", "p.path"))
+  // No locale in the URLs: drop the unused `locale` param (strict TypeScript, noUnusedParameters, fails the build on it).
+  if (!hasLocale) out = out.replaceAll("({ locale, path })", "({ path })").replaceAll("({ locale, path }:", "({ path }:")
+  if (domain) out = out.replaceAll("https://example.com", domain)
+  return out
+}