@setzkasten-cms/astro-admin 0.6.0

package/src/api-routes/init-scan-page.ts

@@ -0,0 +1,336 @@
+import type { APIRoute } from 'astro'
+import type { SetzKastenConfig } from '@setzkasten-cms/core'
+import { resolveStorageConfig, prefixPath } from './_storage-config'
+import { extractSectionImports, extractLayoutImport } from '../init/astro-detector'
+import { analyzeAstroSection } from '../init/astro-section-analyzer-v2'
+import type { RepoFile } from '@setzkasten-cms/core/init'
+
+/**
+ * POST /api/setzkasten/init/scan-page
+ *
+ * Scans a single page's Astro template for section imports and identifies:
+ * 1. Unmanaged sections — not yet in the Setzkasten schema
+ * 2. Missing fields on managed sections — template fields not in the schema
+ *
+ * Body: { owner, repo, branch?, pagePath, projectRoot? }
+ * Returns: { unmanagedSections: InferredSection[], managedUpdates: ManagedUpdate[] }
+ */
+export const POST: APIRoute = async ({ request, cookies }) => {
+  const session = cookies.get('setzkasten_session')?.value
+  if (!session) {
+    return new Response('Unauthorized', { status: 401 })
+  }
+
+  const githubToken = import.meta.env.GITHUB_TOKEN ?? process.env.GITHUB_TOKEN
+  if (!githubToken) {
+    return new Response('GitHub token not configured', { status: 500 })
+  }
+
+  try {
+    const body = await request.json() as {
+      owner?: string
+      repo?: string
+      branch?: string
+      pagePath: string
+      projectRoot?: string
+    }
+
+    const storage = resolveStorageConfig(body)
+    if (!storage) {
+      return Response.json({ error: 'Could not resolve owner/repo. Set SETZKASTEN_OWNER and SETZKASTEN_REPO env vars.' }, { status: 400 })
+    }
+    const { owner, repo, branch, projectPrefix } = storage
+    const { pagePath } = body
+
+    if (!pagePath) {
+      return Response.json({ error: 'pagePath is required' }, { status: 400 })
+    }
+
+    // Get current schema to know which sections are already managed + their fields
+    const config = (globalThis as any).__SETZKASTEN_FULL_CONFIG__ as SetzKastenConfig | undefined
+    const managedSections = new Map<string, Set<string>>() // key → field keys
+    if (config) {
+      for (const product of Object.values(config.products)) {
+        for (const [key, section] of Object.entries(product.sections)) {
+          managedSections.set(key, new Set(Object.keys(section.fields)))
+        }
+      }
+    }
+
+    // Fetch repo tree to resolve imports
+    const treeResponse = await githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`,
+      githubToken,
+    )
+    if (!treeResponse.ok) {
+      return Response.json(
+        { error: `Failed to fetch repo tree: ${treeResponse.status}` },
+        { status: treeResponse.status },
+      )
+    }
+
+    const treeData = await treeResponse.json() as {
+      tree: Array<{ path: string; type: string }>
+    }
+    const files: RepoFile[] = treeData.tree.map((item) => ({
+      path: item.path,
+      type: item.type as 'blob' | 'tree',
+    }))
+
+    // Fetch page source (prefix with monorepo path)
+    // Try both pagePath.astro and pagePath/index.astro for directory-based routes
+    let fullPagePath = prefixPath(pagePath, projectPrefix)
+    let pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken)
+    if (!pageSource && pagePath.endsWith('.astro')) {
+      // Try directory index: src/pages/docs.astro → src/pages/docs/index.astro
+      const indexPath = pagePath.replace(/\.astro$/, '/index.astro')
+      fullPagePath = prefixPath(indexPath, projectPrefix)
+      pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken)
+    }
+    if (!pageSource) {
+      return Response.json({ error: `Could not read page source: ${fullPagePath}` }, { status: 404 })
+    }
+
+    // Extract section imports
+    const imports = extractSectionImports(pageSource, fullPagePath, files, projectPrefix)
+
+    const serverConfig = (globalThis as any).__SETZKASTEN_CONFIG__
+    const contentPath = serverConfig?.storage?.contentPath || 'content'
+
+    const unmanagedSections: Array<Awaited<ReturnType<typeof analyzeAstroSection>>> = []
+    const managedUpdates: Array<{
+      key: string
+      componentName: string
+      componentPath: string
+      missingFields: Array<Awaited<ReturnType<typeof analyzeAstroSection>>['fields'][number]>
+      allFields: Array<Awaited<ReturnType<typeof analyzeAstroSection>>['fields'][number]>
+    }> = []
+
+    for (const imp of imports) {
+      if (!imp.resolvedPath) continue
+
+      if (!managedSections.has(imp.sectionKey)) {
+        // Unmanaged section — full analysis
+        const sectionSource = await fetchFileContent(owner, repo, branch, imp.resolvedPath, githubToken)
+        if (!sectionSource) continue
+
+        const section = await analyzeAstroSection(
+          sectionSource,
+          imp.sectionKey,
+          imp.componentName,
+          imp.resolvedPath,
+        )
+        unmanagedSections.push(section)
+      } else {
+        // Managed section — check for missing fields
+        const existingFieldKeys = managedSections.get(imp.sectionKey)!
+        const sectionSource = await fetchFileContent(owner, repo, branch, imp.resolvedPath, githubToken)
+        if (!sectionSource) continue
+
+        const inferred = await analyzeAstroSection(
+          sectionSource,
+          imp.sectionKey,
+          imp.componentName,
+          imp.resolvedPath,
+        )
+
+        // Load existing content to filter out fields whose value already exists
+        // (e.g. template has ctaText="GitHub öffnen" but schema has buttonText with same value)
+        const sectionJsonPath = `${contentPath}/_sections/${imp.sectionKey}.json`
+        const sectionJson = await fetchFileContent(owner, repo, branch, sectionJsonPath, githubToken)
+        const existingValues = new Set<string>()
+        if (sectionJson) {
+          try {
+            const data = JSON.parse(sectionJson) as Record<string, unknown>
+            for (const val of Object.values(data)) {
+              if (typeof val === 'string' && val.length >= 2) existingValues.add(val)
+            }
+          } catch { /* ignore parse errors */ }
+        }
+
+        // Find fields that aren't in the schema AND whose value isn't already stored
+        const missingFields = inferred.fields.filter(f => {
+          if (existingFieldKeys.has(f.key)) return false
+          if (typeof f.defaultValue === 'string' && existingValues.has(f.defaultValue)) return false
+          return true
+        })
+        if (missingFields.length > 0) {
+          managedUpdates.push({
+            key: imp.sectionKey,
+            componentName: imp.componentName,
+            componentPath: imp.resolvedPath,
+            missingFields,
+            allFields: inferred.fields,
+          })
+        }
+      }
+    }
+
+    // Always analyze page-level inline content (in addition to imported sections).
+    // A page can have imported sections AND inline content (headings, text, arrays).
+    {
+      const pageKeyNorm = pagePath
+        .replace(/^src\/pages\//, '')
+        .replace(/\/(index)?\.astro$/, '')
+        .replace(/\.astro$/, '') || 'index'
+      const sectionKey = '_page_' + pageKeyNorm.replace(/\//g, '_')
+
+      const pageSection = await analyzeAstroSection(
+        pageSource,
+        sectionKey,
+        pageKeyNorm.replace(/\//g, '_') + 'Page',
+        fullPagePath,
+        { mode: 'page' },
+      )
+      ;(pageSection as any).isPageLevel = true
+
+      if (!managedSections.has(sectionKey)) {
+        // Not yet in config — offer adoption (even if getSection already present)
+        if (pageSection.fields.length > 0) {
+          unmanagedSections.push(pageSection)
+        }
+      } else {
+        // Already in config — check for new unbound fields
+        const existingFieldKeys = managedSections.get(sectionKey)!
+        const sectionJsonPath = `${contentPath}/_sections/${sectionKey}.json`
+        const sectionJson = await fetchFileContent(owner, repo, branch, sectionJsonPath, githubToken)
+        const existingValues = new Set<string>()
+        if (sectionJson) {
+          try {
+            const data = JSON.parse(sectionJson) as Record<string, unknown>
+            for (const val of Object.values(data)) {
+              if (typeof val === 'string' && val.length >= 2) existingValues.add(val)
+            }
+          } catch { /* ignore */ }
+        }
+        const missingFields = pageSection.fields.filter(f => {
+          if (existingFieldKeys.has(f.key)) return false
+          if (typeof f.defaultValue === 'string' && existingValues.has(f.defaultValue)) return false
+          return true
+        })
+        if (missingFields.length > 0) {
+          managedUpdates.push({
+            key: sectionKey,
+            componentName: pageKeyNorm.replace(/\//g, '_') + 'Page',
+            componentPath: fullPagePath,
+            missingFields,
+            allFields: pageSection.fields,
+          })
+        }
+      }
+    }
+
+    // Analyze layout file for header/footer content (global sections).
+    // Only done once per layout — if _layout_header or _layout_footer are
+    // already managed, they are skipped.
+    {
+      const layoutImport = extractLayoutImport(pageSource, fullPagePath, files, projectPrefix)
+      if (layoutImport?.resolvedPath) {
+        const layoutSource = await fetchFileContent(owner, repo, branch, layoutImport.resolvedPath, githubToken)
+        if (layoutSource) {
+          for (const region of extractLayoutRegions(layoutSource)) {
+            const sectionKey = `_layout_${region.name}`
+            if (managedSections.has(sectionKey)) continue
+
+            // Wrap the region in a minimal Astro file for the analyzer
+            const regionSource = `---\n---\n\n${region.html}`
+            const section = await analyzeAstroSection(
+              regionSource, sectionKey,
+              region.name, layoutImport.resolvedPath,
+              { mode: 'page' },
+            )
+            ;(section as any).isPageLevel = true
+            ;(section as any).isLayoutRegion = true
+            ;(section as any).layoutPath = layoutImport.resolvedPath
+            ;(section as any).regionTag = region.tag
+            if (section.fields.length > 0) {
+              unmanagedSections.push(section)
+            }
+          }
+        }
+      }
+    }
+
+    return Response.json({ unmanagedSections, managedUpdates })
+  } catch (error) {
+    console.error('[setzkasten] scan-page error:', error)
+    return Response.json(
+      { error: error instanceof Error ? error.message : 'Scan failed' },
+      { status: 500 },
+    )
+  }
+}
+
+async function githubFetch(url: string, token: string): Promise<Response> {
+  return fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+  })
+}
+
+interface LayoutRegion {
+  /** Region name: 'header' or 'footer' */
+  name: string
+  /** HTML tag used to identify this region */
+  tag: string
+  /** Extracted HTML content */
+  html: string
+}
+
+/**
+ * Extract header and footer regions from a layout file's template.
+ * Looks for top-level <header>...</header> and <footer>...</footer> blocks.
+ */
+export function extractLayoutRegions(layoutSource: string): LayoutRegion[] {
+  // Strip frontmatter to get template only
+  let template = layoutSource
+  if (layoutSource.startsWith('---')) {
+    const endIdx = layoutSource.indexOf('\n---', 3)
+    if (endIdx !== -1) {
+      template = layoutSource.slice(endIdx + 4)
+    }
+  }
+
+  const regions: LayoutRegion[] = []
+
+  for (const tag of ['header', 'footer']) {
+    const openTag = new RegExp(`<${tag}(\\s[^>]*)?>`, 'i')
+    const openMatch = openTag.exec(template)
+    if (!openMatch) continue
+
+    // Find matching closing tag (simple approach — works for non-nested same-tag)
+    const closeTag = `</${tag}>`
+    const closeIdx = template.indexOf(closeTag, openMatch.index)
+    if (closeIdx === -1) continue
+
+    const html = template.slice(openMatch.index, closeIdx + closeTag.length)
+    regions.push({ name: tag, tag, html })
+  }
+
+  return regions
+}
+
+async function fetchFileContent(
+  owner: string,
+  repo: string,
+  branch: string,
+  path: string,
+  token: string,
+): Promise<string | null> {
+  try {
+    const response = await githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+      token,
+    )
+    if (!response.ok) return null
+    const data = await response.json() as { content: string; encoding: string }
+    return data.encoding === 'base64'
+      ? Buffer.from(data.content, 'base64').toString('utf-8')
+      : data.content
+  } catch {
+    return null
+  }
+}

package/src/api-routes/init-scan.ts

@@ -0,0 +1,162 @@
+import type { APIRoute } from 'astro'
+import { analyzeProject, type RepoFile } from '@setzkasten-cms/core/init'
+import { findAstroPages, extractSectionImports } from '../init/astro-detector'
+import { analyzeAstroSection } from '../init/astro-section-analyzer-v2'
+
+/**
+ * POST /api/setzkasten/init/scan
+ *
+ * Scans a GitHub repo and returns project analysis + detected sections.
+ * Body: { owner: string, repo: string, branch?: string }
+ */
+export const POST: APIRoute = async ({ request, cookies }) => {
+  // Verify session
+  const session = cookies.get('setzkasten_session')?.value
+  if (!session) {
+    return new Response('Unauthorized', { status: 401 })
+  }
+
+  const githubToken = import.meta.env.GITHUB_TOKEN ?? process.env.GITHUB_TOKEN
+  if (!githubToken) {
+    return new Response('GitHub token not configured', { status: 500 })
+  }
+
+  try {
+    const body = await request.json() as { owner: string; repo: string; branch?: string }
+    const { owner, repo, branch = 'main' } = body
+
+    if (!owner || !repo) {
+      return Response.json({ error: 'owner and repo are required' }, { status: 400 })
+    }
+
+    // 1. Fetch repo tree (recursive)
+    const treeResponse = await githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`,
+      githubToken,
+    )
+
+    if (!treeResponse.ok) {
+      return Response.json(
+        { error: `Failed to fetch repo tree: ${treeResponse.status}` },
+        { status: treeResponse.status },
+      )
+    }
+
+    const treeData = await treeResponse.json() as {
+      tree: Array<{ path: string; type: string; sha: string }>
+    }
+
+    const files: RepoFile[] = treeData.tree.map((item) => ({
+      path: item.path,
+      type: item.type as 'blob' | 'tree',
+    }))
+
+    // 2. Analyze project structure
+    const analysis = analyzeProject(files)
+
+    // 3. Find Astro project root
+    const astroRoot = analysis.projectRoots.find((r) => r.framework === 'astro')
+    if (!astroRoot) {
+      return Response.json({
+        analysis,
+        pages: [],
+        sections: [],
+        astroConfigPath: null,
+        message: 'Kein Astro-Projekt gefunden',
+      })
+    }
+
+    // 4. Find pages
+    const pages = findAstroPages(files, astroRoot.path)
+
+    // 5. For each page, extract section imports and analyze sections
+    const allSections = new Map<string, Awaited<ReturnType<typeof analyzeAstroSection>>>()
+    const pageSections: Record<string, string[]> = {}
+
+    for (const page of pages) {
+      // Fetch page source
+      const pageSource = await fetchFileContent(owner, repo, branch, page.filePath, githubToken)
+      if (!pageSource) continue
+
+      const imports = extractSectionImports(pageSource, page.filePath, files, astroRoot.path)
+      pageSections[page.pageKey] = imports.map((i) => i.sectionKey)
+
+      // Analyze each section (skip duplicates)
+      for (const imp of imports) {
+        if (allSections.has(imp.sectionKey)) continue
+        if (!imp.resolvedPath) continue
+
+        const sectionSource = await fetchFileContent(owner, repo, branch, imp.resolvedPath, githubToken)
+        if (!sectionSource) continue
+
+        const section = await analyzeAstroSection(
+          sectionSource,
+          imp.sectionKey,
+          imp.componentName,
+          imp.resolvedPath,
+        )
+        allSections.set(imp.sectionKey, section)
+      }
+    }
+
+    // 6. Find astro.config path
+    const astroConfigCandidates = ['astro.config.mjs', 'astro.config.ts', 'astro.config.js']
+    let astroConfigPath: string | null = null
+    for (const candidate of astroConfigCandidates) {
+      const path = astroRoot.path ? `${astroRoot.path}/${candidate}` : candidate
+      if (files.some((f) => f.path === path)) {
+        astroConfigPath = path
+        break
+      }
+    }
+
+    return Response.json({
+      analysis,
+      projectRoot: astroRoot.path,
+      pages,
+      pageSections,
+      sections: Object.fromEntries(allSections),
+      astroConfigPath,
+    })
+  } catch (error) {
+    console.error('[setzkasten] Init scan error:', error)
+    return Response.json(
+      { error: error instanceof Error ? error.message : 'Scan failed' },
+      { status: 500 },
+    )
+  }
+}
+
+async function githubFetch(url: string, token: string): Promise<Response> {
+  return fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+  })
+}
+
+async function fetchFileContent(
+  owner: string,
+  repo: string,
+  branch: string,
+  path: string,
+  token: string,
+): Promise<string | null> {
+  try {
+    const response = await githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+      token,
+    )
+    if (!response.ok) return null
+
+    const data = await response.json() as { content: string; encoding: string }
+    if (data.encoding === 'base64') {
+      return Buffer.from(data.content, 'base64').toString('utf-8')
+    }
+    return data.content
+  } catch {
+    return null
+  }
+}

package/src/api-routes/pages.ts

@@ -0,0 +1,17 @@
+import type { APIRoute } from 'astro'
+
+/**
+ * Returns the list of pages detected at build time.
+ * The pages are scanned from src/pages/ by the integration hook
+ * and injected into globalThis.__SETZKASTEN_PAGES__.
+ *
+ * GET /api/setzkasten/pages
+ */
+export const GET: APIRoute = async () => {
+  const pages = (globalThis as Record<string, unknown>).__SETZKASTEN_PAGES__ ?? []
+
+  return new Response(JSON.stringify({ pages }), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  })
+}