@fugood/bricks-project 2.24.0-beta.4 → 2.24.0-beta.41

package/skills/bricks-design/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: bricks-design
+description: Create distinctive, production-grade BRICKS application interfaces with high design quality. Use this skill when the user asks to build BRICKS canvases, screens, layouts, or applications. Generates creative, polished BRICKS code that avoids generic aesthetics.
+license: Complete terms in LICENSE.txt (Apache-2.0, based on github.com/anthropics/skills)
+---
+
+This skill guides creation of distinctive, production-grade BRICKS application interfaces that avoid generic aesthetics. Implement working code with exceptional attention to visual design and creative choices.
+
+The user provides interface requirements: a screen, layout, application, or component to build. They may include context about the purpose, audience, platform, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a **bold** aesthetic direction:
+- **Purpose**: What problem does this interface solve? Who uses it? What platform(s)?
+- **Tone**: Pick a strong direction: brutally minimal, maximalist, retro-futuristic, organic/natural, luxury/refined, playful, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. Use these for inspiration but design one true to the aesthetic.
+- **Constraints**: Target platform (mobile, TV, desktop, kiosk), screen dimensions, accessibility needs.
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work — the key is intentionality, not intensity.
+
+Then implement working BRICKS TypeScript code that is:
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+## Aesthetics Guidelines
+
+### Typography
+Choose fonts that are beautiful, unique, and interesting. Avoid defaulting to system fonts — opt for distinctive choices that elevate the interface. Pair a characterful display font with a refined body font. Create clear typographic hierarchy through weight, size, spacing, and alignment. Use auto-scaling (`fontSizeVector`) when text should fill its container proportionally.
+
+### Color & Theme
+Commit to a cohesive palette. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. Use gradients for rich, atmospheric surfaces — multi-stop linear gradients create far more depth than flat fills. Use Data nodes as a shared color store for consistency across bricks.
+
+### Motion & Animation
+Focus on high-impact moments: one well-orchestrated canvas enter with staggered standby reveals creates more delight than scattered micro-interactions. Use spring animations for natural, bouncy UI elements. Use composed animations (parallel/sequence) for coordinated entrance choreography. Reserve looping animations (`breatheStart`) for attention-drawing elements — overuse dulls their impact.
+
+### Spatial Composition
+Absolute positioning gives total control — use it creatively. Overlap bricks. Create asymmetric layouts. Use generous negative space OR controlled density. Break grid expectations. Consider rotation for diagonal flow and perspective. Vary scale dramatically between elements for visual tension.
+
+### Depth & Atmosphere
+Create atmosphere through layered elements rather than flat solid colors:
+- **Gradients** with multiple color stops for rich backgrounds
+- **Shadows** for elevation and hierarchy
+- **Blur effects** (blur, progressive blur, liquid glass) for glass morphism on native platforms
+- **Opacity layering** — stack semi-transparent rects for texture and depth
+- **Border details** — per-side colors, styles, and widths for decorative framing
+
+### Interactive Polish
+Design interactions that feel tactile and responsive:
+- Scale/opacity animations on press for physical feedback
+- Focus states for TV/controller navigation
+- Outlet-driven switches for state-dependent visual changes
+- Deliberate long-press patterns for secondary actions
+
+## What to NEVER Do
+
+- **No generic aesthetics**: Avoid the same tired palette, the same safe layout, the same system font on every screen. Each design should feel distinct and intentional.
+- **No flat sameness**: Don't make every canvas look like the same template with different text. Vary spatial composition, color weight, animation timing, and typographic scale.
+- **No placeholder layouts**: Don't just center everything in a grid. Use the absolute positioning system to create spatial interest — overlap, offset, scale contrast.
+
+Vary between light and dark themes, different fonts, different aesthetics across generations. NEVER converge on common choices across designs.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate animations, layered rects, and rich gradients. Minimalist designs need restraint, precision in spacing, and carefully chosen typography. Elegance comes from executing the vision well.
+
+Remember: The agent is capable of extraordinary creative work. Don't hold back — show what can truly be created when thinking outside the box and committing fully to a distinctive vision.

package/tools/deploy.ts

@@ -4,29 +4,46 @@ import { parseArgs } from 'util'
 const cwd = process.cwd()
 
 const {
-  values: { changelogs: changelogsArg, 'changelogs-file': changelogsFile, yes },
+  values: {
+    changelogs: changelogsArg,
+    'changelogs-file': changelogsFile,
+    'auto-commit': autoCommit,
+    'auto-version': autoVersion,
+    version: versionArg,
+    yes,
+    help,
+  },
 } = parseArgs({
   args: Bun.argv.slice(2),
   options: {
     changelogs: { type: 'string' },
     'changelogs-file': { type: 'string' },
+    'auto-commit': { type: 'boolean' },
+    'auto-version': { type: 'boolean' },
+    version: { type: 'string' },
     yes: { type: 'boolean', short: 'y' },
+    help: { type: 'boolean', short: 'h' },
   },
   allowPositionals: true,
 })
 
+if (help) {
+  console.log(`Options:
+  --changelogs <text>        Changelogs text for the release
+  --changelogs-file <path>   Read changelogs from a file
+  --auto-commit              Auto-commit unstaged changes before deploying
+  --auto-version             Auto-bump patch version before deploying
+  --version <version>        Set explicit version for the release
+  -y, --yes                  Skip all prompts
+  -h, --help                 Show this help message`)
+  process.exit(0)
+}
+
 // Check git status
-const { exitCode } = await $`cd ${cwd} && git status`.nothrow()
+const { exitCode } = await $`cd ${cwd} && git status`.quiet().nothrow()
 const isGitRepo = exitCode === 0
 
-let commitId = ''
-if (isGitRepo) {
-  const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
-  if (unstagedChanges)
-    throw new Error('Unstaged changes found, please commit or stash your changes before deploying')
-
-  commitId = (await $`cd ${cwd} && git rev-parse HEAD`.text()).trim()
-} else if (!yes) {
+if (!isGitRepo && !yes) {
   const confirmContinue = prompt('No git repository found, continue? (y/n)')
   if (confirmContinue !== 'y') throw new Error('Deployment cancelled')
 }
@@ -35,9 +52,28 @@ if (isGitRepo) {
 const app = await Bun.file(`${cwd}/application.json`).json()
 const config = await Bun.file(`${cwd}/.bricks/build/application-config.json`).json()
 
-// Get version from project's package.json
+// Resolve version: explicit flag > auto-bump > package.json
 const pkgFile = Bun.file(`${cwd}/package.json`)
-const version = (await pkgFile.exists()) ? (await pkgFile.json()).version : undefined
+const pkgExists = await pkgFile.exists()
+let version: string | undefined
+
+if (versionArg) {
+  version = versionArg
+  if (pkgExists) {
+    const pkg = await pkgFile.json()
+    pkg.version = version
+    await Bun.write(`${cwd}/package.json`, JSON.stringify(pkg, null, 2) + '\n')
+  }
+} else if (autoVersion && pkgExists) {
+  const pkg = await pkgFile.json()
+  const parts = (pkg.version || '0.0.0').split('.')
+  parts[2] = String(Number(parts[2] || 0) + 1)
+  version = parts.join('.')
+  pkg.version = version
+  await Bun.write(`${cwd}/package.json`, JSON.stringify(pkg, null, 2) + '\n')
+} else {
+  version = pkgExists ? (await pkgFile.json()).version : undefined
+}
 
 // Get changelog from flag or file
 let changelogs = ''
@@ -53,6 +89,24 @@ if (changelogsArg) {
   changelogs = prompt('Enter changelogs (optional, press Enter to skip):') || ''
 }
 
+// Handle unstaged changes
+let commitId = ''
+if (isGitRepo) {
+  const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+  if (unstagedChanges) {
+    if (autoCommit) {
+      const commitMsg = `chore: release ${version || 'new version'}`
+      const commitBody = changelogs || '[no changelogs]'
+      await $`cd ${cwd} && git add -A && git commit -m ${commitMsg} -m ${commitBody}`
+    } else {
+      throw new Error(
+        'Unstaged changes found, please commit or stash your changes before deploying',
+      )
+    }
+  }
+  commitId = (await $`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+}
+
 // Ask for confirmation
 if (!yes) {
   const confirm = prompt('Are you sure you want to deploy? (y/n)')