@flocon-ai/init 0.0.1 → 0.0.2

package/src/sitemap.mjs

@@ -3,20 +3,27 @@
 // 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> {
-  return floconSitemap({ url: ({ locale, path }) => \`https://example.com/\${locale}\${path}\` })
+  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() {
-  return new Response(await floconLlmsTxt({ url: ({ locale, path }) => \`https://example.com/\${locale}\${path}\` }), {
+  await connection()
+  return new Response(await floconLlmsTxt({ url: ({ locale, path }) => \`https://example.com\${path}\` }), {
     headers: { "content-type": "text/plain; charset=utf-8" }
   })
 }
@@ -28,7 +35,7 @@ const astroSitemap = `import { getAllPages } from "@flocon-ai/astro"
 export async function GET() {
   const pages = await getAllPages()
   const urls = pages
-    .map((p) => \`<url><loc>https://example.com/\${p.locale}\${p.path}</loc><lastmod>\${p.updatedAt}</lastmod></url>\`)
+    .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>\`,
@@ -40,7 +47,7 @@ export async function GET() {
 const astroLlms = `import { floconLlmsTxt } from "@flocon-ai/astro"
 
 export async function GET() {
-  const text = await floconLlmsTxt({ url: ({ locale, path }) => \`https://example.com/\${locale}\${path}\` })
+  const text = await floconLlmsTxt({ url: ({ locale, path }) => \`https://example.com\${path}\` })
   return new Response(text, { headers: { "content-type": "text/plain; charset=utf-8" } })
 }
 `
@@ -64,7 +71,7 @@ export async function loader() {
 const exts = (base, list) => list.map((e) => base + e)
 
 // `existing` = files that mean the website already has one.
-function spec(framework, appDir) {
+function spec(framework, appDir, rrApp = "app", rrDir = "routes") {
   if (framework === "nextjs") {
     return {
       sitemap: {
@@ -93,16 +100,17 @@ function spec(framework, appDir) {
       }
     }
   }
+  const routes = `${rrApp}/${rrDir}`
   return {
     sitemap: {
-      file: "app/routes/sitemap[.]xml.ts",
+      file: `${routes}/sitemap[.]xml.ts`,
       code: reactSitemap,
-      existing: [...exts("app/routes/sitemap[.]xml", [".ts", ".tsx"]), ...exts("app/routes/sitemap.xml", [".ts", ".tsx"]), "public/sitemap.xml"]
+      existing: [...exts(`${routes}/sitemap[.]xml`, [".ts", ".tsx"]), ...exts(`${routes}/sitemap.xml`, [".ts", ".tsx"]), "public/sitemap.xml"]
     },
     llms: {
-      file: "app/routes/llms[.]txt.ts",
+      file: `${routes}/llms[.]txt.ts`,
       code: reactLlms,
-      existing: [...exts("app/routes/llms[.]txt", [".ts", ".tsx"]), ...exts("app/routes/llms.txt", [".ts", ".tsx"]), "public/llms.txt"]
+      existing: [...exts(`${routes}/llms[.]txt`, [".ts", ".tsx"]), ...exts(`${routes}/llms.txt`, [".ts", ".tsx"]), "public/llms.txt"]
     }
   }
 }
@@ -117,19 +125,27 @@ function astroConfigHasSitemap(cwd) {
   return false
 }
 
-// Never overwrites. Returns true when something has to be done by hand.
-export function addSitemapAndLlms({ cwd, framework, appDir, urlPath, log }) {
-  const files = spec(framework, appDir)
+// 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, code, existing } = files[kind]
-    const taken = existing.some(exists) || (kind === "sitemap" && framework === "astro" && astroConfigHasSitemap(cwd))
-    if (taken) {
+    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`)
@@ -139,11 +155,26 @@ export function addSitemapAndLlms({ cwd, framework, appDir, urlPath, log }) {
       fs.mkdirSync(path.dirname(full), { recursive: true })
       fs.writeFileSync(full, code, { flag: "wx" })
       log(`Created ${file}`)
+      created.push(file)
     }
   }
-  log(`In the sitemap and llms.txt files, replace https://example.com with your website URL (Flocon pages live under ${urlPath}).`)
-  if (framework === "react") {
-    log('Register both routes before the catch-all in app/routes.ts:\n  route("sitemap.xml", "routes/sitemap[.]xml.ts")\n  route("llms.txt", "routes/llms[.]txt.ts")')
+  // 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
+  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

@@ -2,22 +2,48 @@
 // 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 } from "@flocon-ai/next"
+const nextjs = `import { FloconPage, getFloconMetadata } from "@flocon-ai/next"
 
 // One catch-all route serves every Flocon page. Rendered on each request.
-export default async function Page({ params }: { params: Promise<{ slug: string[] }> }) {
+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 <FloconPage path={"/" + slug.join("/")} />
+  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 } from "@flocon-ai/next"
+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 default async function Page({ params }: { params: Promise<{ locale: string; slug: string[] }> }) {
+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 <FloconPage locale={locale} path={"/" + slug.join("/")} />
+  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} />
 }
 `
 
@@ -26,7 +52,7 @@ 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}\`
+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 })
@@ -55,7 +81,8 @@ 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}\`
 
-const data = await getFloconPage({ path: "/" + (Astro.params.slug ?? ""), locale: Astro.params.locale })
+// 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 })
 ---
@@ -86,9 +113,9 @@ export async function loader({ params }: Route.LoaderArgs) {
   return page
 }
 
-export function meta({ data }: Route.MetaArgs) {
-  if (!data) return [{ title: "Not found" }]
-  const m = getFloconMetadata({ page: data, url })
+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 },

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
+}