@setzkasten-cms/astro-admin 0.6.0

package/src/init/analyzer-types.ts

@@ -0,0 +1,92 @@
+/**
+ * Shared types between section analyzer, label enricher, and template patcher.
+ * This is the contract that ensures clean separation of concerns:
+ *   Analyzer (structure) → Enricher (labels) → Patcher (template edits)
+ */
+
+// ---------------------------------------------------------------------------
+// Inner field info (fields inside repeated element groups)
+// ---------------------------------------------------------------------------
+
+export interface FieldPosition {
+  /** Char offset in the template source where the field value starts */
+  offset: number
+  /** Length of the field value to replace */
+  length: number
+  /** For .map() arrays: name of the frontmatter variable (e.g. 'starterFeatures') */
+  source?: string
+}
+
+export interface InnerFieldInfo {
+  /** Generic structural key: heading, text1, text2, list1, link1, linkText1 */
+  key: string
+  /** Field type */
+  type: 'text' | 'array' | 'link'
+  /** HTML tag this field was extracted from */
+  tag: string
+  /** Present in ALL instances? (false = optional, only in some) */
+  required: boolean
+  /** Cosmetic label (set by enricher, not analyzer) */
+  label?: string
+  /** Position of this field's value in EACH instance (null = absent in that instance) */
+  positions: Array<FieldPosition | null>
+  /** Default value per instance (null if field absent in that instance) */
+  defaultValues: unknown[]
+}
+
+// ---------------------------------------------------------------------------
+// Repeated element group (e.g. 3× <article>)
+// ---------------------------------------------------------------------------
+
+export interface RepeatedGroupInstance {
+  /** Source offset of opening tag */
+  start: number
+  /** Source offset of closing tag end */
+  end: number
+}
+
+/** A class attribute on an element within a repeated group instance */
+export interface ClassAttrInfo {
+  /** Child-index path within the instance element (e.g. "0/1/3") for matching across instances */
+  path: string
+  /** The full class attribute value */
+  value: string
+  /** Source offset of `class="` start in the full source */
+  sourceOffset: number
+  /** Length of the full `class="..."` attribute string in source */
+  sourceLength: number
+}
+
+export interface RepeatedGroup {
+  /** HTML tag name (e.g. 'article') */
+  tag: string
+  /** Field key for the array (e.g. 'items') */
+  fieldKey: string
+  /** Source bounds of each instance */
+  instances: RepeatedGroupInstance[]
+  /** Which instance to use as .map() template (usually 0) */
+  templateIndex: number
+  /** All detected inner fields */
+  fields: InnerFieldInfo[]
+  /** Class attributes per instance, matched by structural path. classAttrs[i] = attrs for instance i */
+  classAttrs?: ClassAttrInfo[][]
+}
+
+// ---------------------------------------------------------------------------
+// Analyzer result (consumed by enricher + patcher)
+// ---------------------------------------------------------------------------
+
+export interface AnalyzerResult {
+  sectionKey: string
+  componentName: string
+  componentPath: string
+  alreadyIntegrated: boolean
+  /** All top-level fields (text, arrays, etc.) */
+  fields: import('@setzkasten-cms/core/init').InferredField[]
+  /** Repeated element groups with positions for the patcher */
+  repeatedGroups: RepeatedGroup[]
+  /** Raw frontmatter block */
+  frontmatter: string
+  /** Raw template block */
+  template: string
+}

package/src/init/astro-config-patcher.ts

@@ -0,0 +1,98 @@
+/**
+ * Patches an existing astro.config.* file to add the Setzkasten integration.
+ * Uses string manipulation — no AST parser.
+ */
+
+/**
+ * Add the Setzkasten integration import and usage to an Astro config file.
+ * Returns the patched content, or null if already integrated.
+ */
+export function patchAstroConfig(source: string): string | null {
+  // Check if already integrated
+  if (source.includes('@setzkasten-cms/astro') || source.includes('setzkasten(')) {
+    return null
+  }
+
+  let result = source
+
+  // Add import at the top (after existing imports)
+  const importLine = "import setzkasten from '@setzkasten-cms/astro'\n"
+
+  // Find the last import statement
+  const lastImportIndex = findLastImportEnd(result)
+  if (lastImportIndex >= 0) {
+    result =
+      result.slice(0, lastImportIndex) +
+      '\n' +
+      importLine +
+      result.slice(lastImportIndex)
+  } else {
+    // No imports found — add at the very top
+    result = importLine + '\n' + result
+  }
+
+  // Add setzkasten() to the integrations array
+  result = addToIntegrations(result)
+
+  return result
+}
+
+/**
+ * Find the end position of the last import statement.
+ */
+function findLastImportEnd(source: string): number {
+  const lines = source.split('\n')
+  let lastImportLineEnd = -1
+  let pos = 0
+
+  for (const line of lines) {
+    pos += line.length + 1 // +1 for newline
+    if (line.trimStart().startsWith('import ')) {
+      lastImportLineEnd = pos
+    }
+  }
+
+  return lastImportLineEnd
+}
+
+/**
+ * Add setzkasten() to the integrations array in defineConfig.
+ */
+function addToIntegrations(source: string): string {
+  // Case 1: integrations array exists — add setzkasten() to it
+  const integrationsMatch = source.match(/integrations\s*:\s*\[/)
+  if (integrationsMatch && integrationsMatch.index !== undefined) {
+    const insertPos = integrationsMatch.index + integrationsMatch[0].length
+    const after = source.slice(insertPos).trimStart()
+
+    // Check if array is empty
+    if (after.startsWith(']')) {
+      return (
+        source.slice(0, insertPos) +
+        'setzkasten()' +
+        source.slice(insertPos)
+      )
+    }
+
+    // Array has items — prepend
+    return (
+      source.slice(0, insertPos) +
+      '\n    setzkasten(),\n    ' +
+      source.slice(insertPos)
+    )
+  }
+
+  // Case 2: No integrations array — add it to defineConfig
+  const defineConfigMatch = source.match(/defineConfig\s*\(\s*\{/)
+  if (defineConfigMatch && defineConfigMatch.index !== undefined) {
+    const insertPos = defineConfigMatch.index + defineConfigMatch[0].length
+    return (
+      source.slice(0, insertPos) +
+      '\n  integrations: [setzkasten()],\n' +
+      source.slice(insertPos)
+    )
+  }
+
+  // Case 3: No defineConfig — can't patch automatically
+  return source
+}

package/src/init/astro-detector.ts

@@ -0,0 +1,207 @@
+/**
+ * Astro-specific project detection.
+ * Finds pages, section imports, and component files in a repo's file tree.
+ */
+
+import type { RepoFile } from '@setzkasten-cms/core/init'
+
+export interface AstroPage {
+  /** File path relative to repo root, e.g. 'apps/website/src/pages/index.astro' */
+  filePath: string
+  /** Page key, e.g. 'index' or 'about' */
+  pageKey: string
+  /** Human-readable label */
+  label: string
+}
+
+export interface AstroSectionImport {
+  /** Component name, e.g. 'HeroSection' */
+  componentName: string
+  /** Import path as written in the source, e.g. '../components/sections/HeroSection.astro' */
+  importPath: string
+  /** Resolved file path relative to repo root */
+  resolvedPath: string | null
+  /** Derived section key, e.g. 'hero' */
+  sectionKey: string
+}
+
+/**
+ * Find all Astro page files in a project root.
+ */
+export function findAstroPages(files: RepoFile[], projectRoot: string): AstroPage[] {
+  const pagesDir = projectRoot ? `${projectRoot}/src/pages/` : 'src/pages/'
+  const pages: AstroPage[] = []
+
+  for (const file of files) {
+    if (file.type !== 'blob') continue
+    if (!file.path.startsWith(pagesDir)) continue
+    if (!file.path.endsWith('.astro')) continue
+
+    const relativePath = file.path.slice(pagesDir.length)
+
+    // Skip API routes, layouts, catch-all routes, admin pages
+    if (relativePath.startsWith('api/')) continue
+    if (relativePath.includes('[')) continue
+    if (relativePath.includes('admin')) continue
+    if (relativePath === 'preview.astro') continue
+
+    const name = relativePath.replace(/\.astro$/, '')
+    const isIndex = name === 'index' || name.endsWith('/index')
+    const pageKey = isIndex
+      ? name === 'index' ? 'index' : name.replace(/\/index$/, '')
+      : name
+
+    pages.push({
+      filePath: file.path,
+      pageKey,
+      label: pageKey === 'index' ? 'Startseite' : pageKey,
+    })
+  }
+
+  // Sort: index first, then alphabetically
+  pages.sort((a, b) => {
+    if (a.pageKey === 'index') return -1
+    if (b.pageKey === 'index') return 1
+    return a.pageKey.localeCompare(b.pageKey)
+  })
+
+  return pages
+}
+
+/**
+ * Extract section imports from an Astro page's source code.
+ */
+export function extractSectionImports(
+  pageSource: string,
+  pagePath: string,
+  allFiles: RepoFile[],
+  projectRoot: string,
+): AstroSectionImport[] {
+  const imports: AstroSectionImport[] = []
+
+  // Match: import ComponentName from '...' or import ComponentName from "..."
+  const importRegex = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g
+  let match: RegExpExecArray | null
+
+  while ((match = importRegex.exec(pageSource)) !== null) {
+    const componentName = match[1]!
+    const importPath = match[2]!
+
+    // Only consider explicit CMS section components:
+    //   - imported from a path containing 'section', OR
+    //   - component name ends with 'Section'
+    // This excludes generic UI components like CodeBlock, Nav, Button, etc.
+    const isSectionPath = importPath.includes('section')
+    const isSectionName = componentName.endsWith('Section')
+    if (!isSectionPath && !isSectionName) continue
+    // Skip non-component imports
+    if (!importPath.endsWith('.astro') && !importPath.match(/\/[A-Z]/)) continue
+
+    const sectionKey = deriveSectionKey(componentName)
+    const resolvedPath = resolveImportPath(importPath, pagePath, allFiles, projectRoot)
+
+    imports.push({
+      componentName,
+      importPath,
+      resolvedPath,
+      sectionKey,
+    })
+  }
+
+  return imports
+}
+
+export interface AstroLayoutImport {
+  /** Component name, e.g. 'BaseLayout' */
+  componentName: string
+  /** Import path as written in the source */
+  importPath: string
+  /** Resolved file path relative to repo root */
+  resolvedPath: string | null
+}
+
+/**
+ * Extract the layout import from an Astro page's source code.
+ * Returns the first import whose path contains 'layout' or whose name contains 'Layout'.
+ */
+export function extractLayoutImport(
+  pageSource: string,
+  pagePath: string,
+  allFiles: RepoFile[],
+  projectRoot: string,
+): AstroLayoutImport | null {
+  const importRegex = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g
+  let match: RegExpExecArray | null
+
+  while ((match = importRegex.exec(pageSource)) !== null) {
+    const componentName = match[1]!
+    const importPath = match[2]!
+
+    if (!importPath.includes('layout') && !componentName.includes('Layout')) continue
+    if (!importPath.endsWith('.astro') && !importPath.match(/\/[A-Z]/)) continue
+
+    const resolvedPath = resolveImportPath(importPath, pagePath, allFiles, projectRoot)
+    return { componentName, importPath, resolvedPath }
+  }
+
+  return null
+}
+
+/**
+ * Derive a section key from a component name.
+ * HeroSection → hero, HowItWorksSection → howItWorks, CtaSection → cta,
+ * SchemaShowcaseSection → schemaShowcase
+ * Uses camelCase (valid JS identifier) to avoid quoted keys in config.
+ */
+export function deriveSectionKey(componentName: string): string {
+  const stripped = componentName.replace(/Section$/, '')
+  return stripped.charAt(0).toLowerCase() + stripped.slice(1)
+}
+
+/**
+ * Resolve a relative import path to an absolute repo path.
+ */
+function resolveImportPath(
+  importPath: string,
+  fromFile: string,
+  allFiles: RepoFile[],
+  projectRoot: string,
+): string | null {
+  // Handle alias imports like @/components/... or ~/components/...
+  if (importPath.startsWith('@/') || importPath.startsWith('~/')) {
+    const aliasPath = importPath.replace(/^[@~]\//, '')
+    const candidates = [
+      `${projectRoot}/src/${aliasPath}`,
+      `${projectRoot}/src/${aliasPath}.astro`,
+    ]
+    for (const candidate of candidates) {
+      if (allFiles.some((f) => f.path === candidate)) return candidate
+    }
+    return null
+  }
+
+  // Handle relative imports
+  if (importPath.startsWith('.')) {
+    const fromDir = fromFile.substring(0, fromFile.lastIndexOf('/'))
+    const parts = importPath.split('/')
+    let currentDir = fromDir
+
+    for (const part of parts) {
+      if (part === '.') continue
+      if (part === '..') {
+        currentDir = currentDir.substring(0, currentDir.lastIndexOf('/'))
+      } else {
+        currentDir = `${currentDir}/${part}`
+      }
+    }
+
+    const resolved = currentDir
+    // Try with and without .astro extension
+    const candidates = [resolved, `${resolved}.astro`]
+    for (const candidate of candidates) {
+      if (allFiles.some((f) => f.path === candidate)) return candidate
+    }
+  }
+
+  return null
+}