uniweb 1.0.0 → 1.0.2

package/src/commands/inspect.js

@@ -0,0 +1,375 @@
+/**
+ * uniweb inspect — Show parsed content shape of markdown files.
+ *
+ * Usage:
+ *   uniweb inspect pages/home/hero.md          Single section
+ *   uniweb inspect pages/home/                 All sections in a page folder
+ *   uniweb inspect pages/home/hero.md --raw    ProseMirror AST instead of flat shape
+ *   uniweb inspect pages/home/ --full          Include empty fields (matches runtime)
+ *   uniweb inspect pages/home/ --sequence      Include sequence array
+ */
+
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { resolve, extname, basename } from 'node:path'
+import yaml from 'js-yaml'
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  dim: '\x1b[2m'
+}
+
+/**
+ * Parse CLI arguments for inspect command
+ */
+function parseArgs(args) {
+  const flags = {
+    target: null,
+    raw: false,
+    full: false,
+    sequence: false,
+    help: false
+  }
+
+  for (const arg of args) {
+    if (arg === '--raw') flags.raw = true
+    else if (arg === '--full') flags.full = true
+    else if (arg === '--sequence') flags.sequence = true
+    else if (arg === '--help' || arg === '-h') flags.help = true
+    else if (!arg.startsWith('-')) flags.target = arg
+  }
+
+  return flags
+}
+
+/**
+ * Dynamically import content-reader and semantic-parser.
+ * These are transitive deps of @uniweb/build, available in any project workspace.
+ */
+async function loadDependencies() {
+  try {
+    const [contentReader, semanticParser] = await Promise.all([
+      import('@uniweb/content-reader'),
+      import('@uniweb/semantic-parser')
+    ])
+    // Optional: the inset lift a Block runs (`@uniweb/core/insets`). An older
+    // install without it shows the insets unlifted, as `inset_ref` nodes.
+    const coreInsets = await import('@uniweb/core/insets').catch(() => null)
+    return {
+      markdownToProseMirror: contentReader.markdownToProseMirror,
+      parseContent: semanticParser.parseContent,
+      liftInsets: coreInsets?.liftInsets,
+      // Optional: present from @uniweb/semantic-parser >= the staircase
+      // release; older installs simply show no findings.
+      lintContent: semanticParser.lintContent
+    }
+  } catch {
+    console.error(
+      `${colors.red}✗${colors.reset} Could not load @uniweb/content-reader or @uniweb/semantic-parser.`
+    )
+    console.error(
+      `  These packages must be installed in the workspace (they come with @uniweb/build).`
+    )
+    process.exit(1)
+  }
+}
+
+/**
+ * Extract frontmatter and markdown body from a section file.
+ * Exact match of content-collector lines 634-639.
+ */
+function extractFrontmatter(content) {
+  let frontMatter = {}
+  let markdown = content
+
+  if (content.trim().startsWith('---')) {
+    const parts = content.split('---\n')
+    if (parts.length >= 3) {
+      try {
+        frontMatter = yaml.load(parts[1]) || {}
+      } catch (err) {
+        console.warn(
+          `${colors.yellow}Warning: YAML parse error: ${err.message}${colors.reset}`
+        )
+        frontMatter = {}
+      }
+      markdown = parts.slice(2).join('---\n')
+    }
+  }
+
+  return { frontMatter, markdown }
+}
+
+/**
+ * Split frontmatter into reserved keys and custom params.
+ * Exact match of content-collector line 642.
+ */
+function splitParams(frontMatter) {
+  const {
+    type,
+    component,
+    preset,
+    input,
+    props,
+    fetch,
+    data,
+    id,
+    background,
+    theme,
+    ...params
+  } = frontMatter
+  return {
+    type: type || component || null,
+    preset: preset || null,
+    reserved: { data, id, background, theme, input },
+    params
+  }
+}
+
+/**
+ * Guarantee item has flat content structure.
+ * Keep in sync with @uniweb/runtime/src/prepare-props.js
+ */
+function guaranteeItemStructure(item) {
+  return {
+    title: item.title || '',
+    pretitle: item.pretitle || '',
+    subtitle: item.subtitle || '',
+    paragraphs: item.paragraphs || [],
+    links: item.links || [],
+    images: item.images || [],
+    lists: item.lists || [],
+    icons: item.icons || [],
+    videos: item.videos || [],
+    buttons: item.buttons || [],
+    data: item.data || {},
+    cards: item.cards || [],
+    documents: item.documents || [],
+    forms: item.forms || [],
+    quotes: item.quotes || [],
+    headings: item.headings || []
+  }
+}
+
+/**
+ * Guarantee content structure exists.
+ * Keep in sync with @uniweb/runtime/src/prepare-props.js
+ */
+function guaranteeContentStructure(parsedContent) {
+  const content = parsedContent || {}
+
+  return {
+    title: content.title || '',
+    pretitle: content.pretitle || '',
+    subtitle: content.subtitle || '',
+    alignment: content.alignment || null,
+    paragraphs: content.paragraphs || [],
+    links: content.links || [],
+    images: content.images || [],
+    lists: content.lists || [],
+    icons: content.icons || [],
+    videos: content.videos || [],
+    insets: content.insets || [],
+    buttons: content.buttons || [],
+    data: content.data || {},
+    cards: content.cards || [],
+    documents: content.documents || [],
+    forms: content.forms || [],
+    quotes: content.quotes || [],
+    headings: content.headings || [],
+    items: (content.items || []).map(guaranteeItemStructure),
+    sequence: content.sequence || [],
+    raw: content.raw
+  }
+}
+
+/**
+ * Remove empty fields from content for clean output.
+ */
+function removeEmptyFields(obj) {
+  const result = {}
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === 'raw') continue // Always skip raw ProseMirror in clean output
+    if (value === null || value === undefined) continue
+    if (value === '') continue
+    if (Array.isArray(value) && value.length === 0) continue
+    if (
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      Object.keys(value).length === 0
+    )
+      continue
+
+    // Recursively clean items
+    if (key === 'items' && Array.isArray(value)) {
+      result[key] = value.map((item) => removeEmptyFields(item))
+    } else {
+      result[key] = value
+    }
+  }
+  return result
+}
+
+/**
+ * Process a single markdown file and return its parsed shape.
+ */
+function processFile(fileContent, fileName, deps, options) {
+  const { raw, full, sequence } = options
+  const { markdownToProseMirror, parseContent } = deps
+
+  const { frontMatter, markdown } = extractFrontmatter(fileContent)
+  const { type, preset, reserved, params } = splitParams(frontMatter)
+
+  // Parse markdown to ProseMirror — the document as stored, insets as written.
+  const stored = markdownToProseMirror(markdown)
+
+  // What the component receives: the insets lifted the way a Block lifts them —
+  // a placeholder in the content, the inset itself listed beside it. ⛔ This
+  // file carried its own copy of the site build's extractor until 2026-09-27,
+  // and it had drifted (top-level only, no inline insets, `description` for
+  // `title`); insets are lifted by core now, so this asks core.
+  const lifted = deps.liftInsets
+    ? deps.liftInsets(stored)
+    : { content: stored, leaves: [], containers: [] }
+  const doc = lifted.content
+  const insets = [
+    ...lifted.leaves,
+    ...lifted.containers.map(({ refId, type, params }) => ({ refId, type, params, container: true }))
+  ]
+
+  // Build result
+  const result = {}
+
+  if (type) result.type = type
+  if (preset) result.preset = preset
+
+  // Include non-empty reserved fields
+  for (const [key, value] of Object.entries(reserved)) {
+    if (value !== undefined && value !== null) result[key] = value
+  }
+
+  // Include params if any
+  if (Object.keys(params).length > 0) result.params = params
+
+  // Check if file is a child section
+  if (basename(fileName).startsWith('@')) {
+    result.child = true
+  }
+
+  if (raw) {
+    // Raw mode: the ProseMirror AST as stored — insets in it as the author wrote them.
+    result.prosemirror = stored
+    return result
+  }
+
+  // Parse to flat content shape
+  const parsed = parseContent(doc)
+
+  // Apply guarantees
+  let content = guaranteeContentStructure(parsed)
+
+  if (!full) {
+    content = removeEmptyFields(content)
+  } else {
+    // In full mode, still remove raw
+    delete content.raw
+  }
+
+  if (!sequence) {
+    delete content.sequence
+  }
+
+  result.content = content
+
+  if (insets.length > 0) result.insets = insets
+
+  // Grouping near-miss findings — shapes that usually mean the author got a
+  // different structure than they wanted (an entry absorbed into the
+  // headline, a hand-written eyebrow demoting the title). Observation only:
+  // the parse above is untouched.
+  const findings = deps.lintContent?.(doc) || []
+  if (findings.length > 0) result.findings = findings
+
+  return result
+}
+
+/**
+ * Natural sort comparator for filenames (handles numeric prefixes).
+ */
+function naturalSort(a, b) {
+  return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' })
+}
+
+/**
+ * Main inspect entry point.
+ */
+export async function inspect(args) {
+  const flags = parseArgs(args)
+
+  if (flags.help || !flags.target) {
+    console.log(`
+Usage: uniweb inspect <path> [options]
+
+Inspect the parsed content shape of a markdown file or page folder.
+
+Arguments:
+  <path>        Path to a .md file or a page folder
+
+Options:
+  --raw         Show ProseMirror AST instead of flat content shape
+  --full        Include empty fields (matches runtime guarantees)
+  --sequence    Include sequence array (document-order elements)
+  -h, --help    Show this help
+`)
+    return
+  }
+
+  const target = resolve(process.cwd(), flags.target)
+  const deps = await loadDependencies()
+
+  let stat
+  try {
+    stat = statSync(target)
+  } catch {
+    console.error(`${colors.red}✗${colors.reset} Not found: ${flags.target}`)
+    process.exit(1)
+  }
+
+  const options = { raw: flags.raw, full: flags.full, sequence: flags.sequence }
+
+  if (stat.isFile()) {
+    if (extname(target) !== '.md') {
+      console.error(
+        `${colors.red}✗${colors.reset} Expected a .md file: ${flags.target}`
+      )
+      process.exit(1)
+    }
+    const content = readFileSync(target, 'utf8')
+    const result = processFile(content, basename(target), deps, options)
+    console.log(JSON.stringify(result, null, 2))
+  } else if (stat.isDirectory()) {
+    const files = readdirSync(target)
+      .filter(
+        (f) => extname(f) === '.md' && !f.startsWith('_') && f !== 'README.md'
+      )
+      .sort(naturalSort)
+
+    if (files.length === 0) {
+      console.error(
+        `${colors.yellow}No .md files found in: ${flags.target}${colors.reset}`
+      )
+      return
+    }
+
+    const results = files.map((file) => {
+      const content = readFileSync(resolve(target, file), 'utf8')
+      const result = processFile(content, file, deps, options)
+      result._file = file
+      return result
+    })
+
+    console.log(JSON.stringify(results, null, 2))
+  }
+}

package/src/commands/invite.js

@@ -0,0 +1,24 @@
+/**
+ * invite — RESERVED (not available on the new backend yet).
+ *
+ * The foundation client-invite flow ran against the legacy platform (the PHP
+ * backend + Cloudflare Worker) the CLI no longer talks to. Client onboarding is
+ * handled in the Uniweb app for now; a new-backend CLI equivalent isn't built.
+ * The command name is kept reserved so a future rebuild can claim it without a
+ * breaking change.
+ */
+
+export async function invite() {
+  console.error(
+    "\x1b[31m✗\x1b[0m `uniweb invite` isn't available on the new backend yet."
+  )
+  console.error(
+    '  The legacy client-invite flow was retired with the PHP backend.'
+  )
+  console.error(
+    '  Invite clients to your foundation from the Uniweb app for now.'
+  )
+  process.exit(1)
+}
+
+export default invite

package/src/commands/org.js

@@ -0,0 +1,96 @@
+/**
+ * uniweb org — the orgs you belong to, on the backend you are logged in to.
+ *
+ *   uniweb org list                 Your personal scope, and the orgs you're a member of.
+ *   uniweb org create <handle>      Create an org; you become a member.
+ *
+ * ⭐ You need no org to register a foundation: `@<your handle>` is your personal scope
+ * (2026-09-23). An org is for a scope — and sites — you share, and it needs a handle
+ * of its own: a backend refuses one named after an account, yours included.
+ *
+ * Auth: the session of the backend you are logged in to (`uniweb login`) / UNIWEB_TOKEN.
+ */
+
+import { BackendClient } from '../backend/client.js'
+import { validateHandle, bareHandle } from '../utils/registry-orgs.js'
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m'
+}
+const error = (m) => console.error(`${colors.red}✗${colors.reset} ${m}`)
+const success = (m) => console.log(`${colors.green}✓${colors.reset} ${m}`)
+
+export async function org(args = []) {
+  const sub = args[0]
+
+  if (sub === 'list') {
+    const client = new BackendClient({ args, command: 'Listing orgs' })
+    const { account_handle: mine, orgs: all } = await client.fetchOrgs()
+    // An org named after you — made before 2026-09-23 — is your personal scope's `@`.
+    const orgs = all.filter((u) => u.handle !== mine)
+    if (mine) {
+      console.log(
+        `Your personal scope: ${colors.bright}@${mine}${colors.reset}${colors.dim} — register under it with no org${colors.reset}`
+      )
+    }
+    if (!orgs.length) {
+      console.log(
+        `You belong to no org. To share a scope and sites with others: uniweb org create <handle>`
+      )
+      return { exitCode: 0 }
+    }
+    console.log('Your orgs:')
+    for (const u of orgs) {
+      console.log(
+        `  ${colors.bright}@${u.handle}${colors.reset}${u.is_primary ? `${colors.dim} (primary)${colors.reset}` : ''}`
+      )
+    }
+    return { exitCode: 0 }
+  }
+
+  if (sub === 'create') {
+    const handle = bareHandle(args[1])
+    if (!handle) {
+      error('Usage: uniweb org create <handle>')
+      return { exitCode: 2 }
+    }
+    const invalid = validateHandle(handle)
+    if (invalid) {
+      error(invalid)
+      return { exitCode: 2 }
+    }
+    const client = new BackendClient({ args, command: 'Creating an org' })
+    try {
+      // Named after you, it is your personal scope already — and a backend refuses it.
+      const { account_handle: mine } = await client.fetchOrgs()
+      if (mine && handle === mine) {
+        error(
+          `@${handle} is your personal scope already — you can register under it with no org. An org needs a handle of its own.`
+        )
+        return { exitCode: 2 }
+      }
+      const org = await client.createOrg(handle)
+      success(
+        `Created ${colors.bright}@${org.handle}${colors.reset} — you're a member${org.is_primary ? ' (primary)' : ''}.`
+      )
+      console.log(
+        `${colors.dim}Register under it: uniweb register --scope @${org.handle}${colors.reset}`
+      )
+      return { exitCode: 0 }
+    } catch (err) {
+      error(err.message)
+      return { exitCode: 1 }
+    }
+  }
+
+  console.log('uniweb org <command>')
+  console.log('  list             Your personal scope, and the orgs you belong to')
+  console.log('  create <handle>  Create an org (you become a member)')
+  return { exitCode: sub ? 2 : 0 }
+}
+
+export default org