@softize/opus 8.6.6

package/registry/hooks/opus-check-on-stop.mjs

@@ -0,0 +1,114 @@
+/**
+ * Hook Stop da base Opus: quando o turno termina, roda o `opus check` dos apps que a
+ * sessão MEXEU (arquivos alterados no git) e BLOQUEIA o fim do turno se houver violação
+ * — exit 2 devolve os findings ao agente, que se corrige na hora. O gate da casa deixa
+ * de depender de alguém lembrar de rodar.
+ *
+ * Fail-open por princípio: sem git, sem bin do opus, crash ou timeout do check → exit 0
+ * (infra nunca trava a sessão). Só bloqueia em violação REAL (a linha `✗ opus check`).
+ * Escopo por app alterado de propósito: violação pré-existente em app não tocado não
+ * pode travar o turno dos outros.
+ */
+import { execFileSync } from 'node:child_process'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+let event = {}
+try {
+  event = JSON.parse(readFileSync(0, 'utf8'))
+} catch {
+  /* Sem stdin legível → segue com defaults. */
+}
+// Anti-loop: este Stop já foi bloqueado por hook antes → deixa parar.
+if (event.stop_hook_active === true) process.exit(0)
+
+const root = process.env.CLAUDE_PROJECT_DIR ?? process.cwd()
+
+// Arquivos alterados (staged + unstaged + untracked). Sem git → fail-open.
+let changed = []
+try {
+  changed = execFileSync('git', ['-C', root, 'status', '--porcelain'], { encoding: 'utf8' })
+    .split('\n')
+    .map((l) => l.slice(3).trim())
+    .filter((l) => l.length > 0)
+    // Rename (`a -> b`): o caminho que interessa é o destino.
+    .map((l) => (l.includes(' -> ') ? l.split(' -> ')[1] : l))
+} catch {
+  process.exit(0)
+}
+if (changed.length === 0) process.exit(0)
+
+// Apps opus-based = diretórios com o marcador opus.json (raiz inclusa).
+const SKIP = new Set(['node_modules', 'dist', 'build', 'coverage', '.next'])
+function findApps(dir, depth) {
+  const acc = existsSync(join(dir, 'opus.json')) ? [dir] : []
+  if (depth === 0) return acc
+  let entries = []
+  try {
+    entries = readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return acc
+  }
+  for (const e of entries) {
+    if (!e.isDirectory() || e.name.startsWith('.') || SKIP.has(e.name)) continue
+    acc.push(...findApps(join(dir, e.name), depth - 1))
+  }
+  return acc
+}
+
+// Só os apps que a sessão tocou (app mais específico primeiro, pra um app aninhado
+// não cair no ancestral).
+const apps = findApps(root, 3).sort((a, b) => b.length - a.length)
+const touched = new Set()
+for (const rel of changed) {
+  const app = apps.find((a) => a === root || join(root, rel).startsWith(`${a}/`))
+  if (app !== undefined) touched.add(app)
+}
+
+/**
+ * Bin do opus pro app: sobe do app até a raiz (repo simples / hoisted) e, se não achar,
+ * desce UM nível (app composto — pacotes api/web dentro do app, o pnpm instala o bin
+ * no node_modules de cada pacote). Sem bin → fail-open (o app fica de fora).
+ */
+function opusBinFor(appDir) {
+  let dir = appDir
+  for (;;) {
+    const bin = join(dir, 'node_modules', '.bin', 'opus')
+    if (existsSync(bin)) return bin
+    if (dir === root || dirname(dir) === dir) break
+    dir = dirname(dir)
+  }
+  try {
+    for (const e of readdirSync(appDir, { withFileTypes: true })) {
+      if (!e.isDirectory() || e.name.startsWith('.') || SKIP.has(e.name)) continue
+      const bin = join(appDir, e.name, 'node_modules', '.bin', 'opus')
+      if (existsSync(bin)) return bin
+    }
+  } catch {
+    /* Ilegível → sem bin. */
+  }
+  return null
+}
+
+const failures = []
+for (const app of touched) {
+  const bin = opusBinFor(app)
+  if (bin === null) continue
+  try {
+    execFileSync(bin, ['check'], { cwd: app, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 45_000 })
+  } catch (err) {
+    // Sem cor: o destinatário é o agente, não um terminal.
+    const out = `${err.stdout ?? ''}${err.stderr ?? ''}`.replace(/\x1b\[[0-9;]*m/g, '')
+    // Violação de verdade tem a linha ✗ e exit 1; qualquer outra falha é infra → segue.
+    if (err.status === 1 && out.includes('✗ opus check')) {
+      const rel = app === root ? '.' : app.slice(root.length + 1)
+      failures.push(`# ${rel}\n${out.trim()}`)
+    }
+  }
+}
+
+if (failures.length === 0) process.exit(0)
+process.stderr.write(
+  `O opus check reprovou nos apps alterados — corrija as violações antes de encerrar o turno:\n\n${failures.join('\n\n')}\n`,
+)
+process.exit(2)

package/registry/skills/create-action/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: create-action
+description: Cria uma opus action no formato canônico (passa no opus check por construção). Use ao implementar uma nova action/endpoint num projeto Opus-based.
+---
+
+# create-action
+
+Procedimento pra criar uma **opus action** padronizada. Gera o esqueleto certo e
+deixa você só com a lógica — sem decorar convenção, sem reprovar no `opus check`.
+
+> Língua: **código em inglês; comentários/UI em pt-BR** (ver `code-style.md`).
+
+## Passo a passo
+
+1. **Decida** `<resource>.<verb>` e o `kind`:
+   - `list` — lista paginada · `view` — leitura de um recurso
+   - `form` — mutação com campos de UI · `simple` — mutação atômica
+   - Namespacing por sub-área é ok: `ticket.sla.check`.
+
+2. **Gere o esqueleto** (formato canônico, ordem dos campos correta):
+   ```bash
+   node scaffold.mjs <resource> <verb> <kind>   # ex.: ticket create form
+   ```
+   Cole o resultado em `src/domains/<resource>/actions/<verb>.ts`.
+
+3. **Preencha**: `input`/`output` (zod + `t.*` pra tipos lógicos), `summary`/`label`
+   (pt-BR), e o `handler` (a lógica). Não reordene os campos.
+
+4. **Exporte no barrel** `src/domains/<resource>/actions/index.ts` e garanta que o
+   domínio está registrado no `src/runtime.ts` (`defineDomain` + `runtime.register`).
+
+5. **Front (quando aplicável)**: invoque via `@softize/opus/client` + `ui/react`
+   (`useLookupAction`/`useTriggerAction`/`useFormAction`/`useViewAction`) — **não**
+   escreva fetch/tipos na mão.
+
+6. **Valide**: `opus check src` → tem que dar **0 violação**. Rode antes do handoff.
+
+## O contrato é o `actions.md`
+
+Kinds, ordem canônica dos campos e garantias vivem na página Actions (`/docs/actions`;
+`node_modules/@softize/opus/src/ui/docs/content/actions.md`) — não reproduza aqui. O
+`scaffold.mjs` já emite a ordem certa e o `opus check` cobra; esta skill é o
+PROCEDIMENTO, não a referência.
+
+Checklist rápido do que o `opus check` reprova (antes do handoff):
+- `name` = `<resource>(.<sub>)*.<verb>`, minúsculo, ponto.
+- `kind` ∈ `simple|form|list|view`.
+- Campos na ordem canônica (do scaffold; ver `actions.md`).
+- `defineAction` é **`export const`**.

package/registry/skills/create-action/scaffold.mjs

@@ -0,0 +1,122 @@
+/**
+ * Scaffold de opus action — gera o esqueleto canônico (passa no `opus check` por
+ * construção: action-name, kind, field-order, export). O agente preenche a lógica.
+ *
+ * Uso: node scaffold.mjs <resource> <verb> [kind=simple]
+ *   ex.: node scaffold.mjs widget list list     → const widgetList (widget.list)
+ *        node scaffold.mjs user set-password simple
+ *
+ * Comentários em pt-BR (UI/comentários em PT; código em inglês — ver code-style.md).
+ */
+
+const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1)
+const camel = (verb) => verb.split('-').map((p, i) => (i === 0 ? p : cap(p))).join('')
+/** const name = resource + PascalVerb. Ex.: user + set-password → userSetPassword. */
+const constName = (resource, verb) => resource + verb.split('-').map(cap).join('')
+
+const HEAD = `import { z } from 'zod'
+import { defineAction } from '@softize/opus/core'
+`
+
+/** Gera o conteúdo .ts canônico da action pro kind. */
+export function actionTemplate({ resource, verb, kind = 'simple' }) {
+  const cn = constName(resource, verb)
+  const name = `${resource}.${verb}`
+
+  if (kind === 'list') {
+    return `${HEAD}
+export const ${cn} = defineAction({
+  name: '${name}',
+  kind: 'list',
+  summary: 'TODO: o que lista (pt-BR)',
+  input: z.object({
+    // TODO: filtros / paginação
+  }),
+  output: z.object({
+    // TODO: shape de um item
+    id: z.string(),
+  }),
+  paginate: 'cursor',
+  handler: async (_ctx, _input) => {
+    // TODO: buscar
+    return { items: [], cursor: { next: null }, total: 0 }
+  },
+})
+`
+  }
+
+  if (kind === 'form') {
+    return `${HEAD}
+export const ${cn} = defineAction({
+  name: '${name}',
+  kind: 'form',
+  label: 'TODO: rótulo (pt-BR)',
+  messages: { success: 'TODO', error: 'TODO' },
+  input: z.object({
+    // TODO: campos do form
+  }),
+  output: z.object({ id: z.string() }),
+  fields: {
+    // TODO: { campo: { label: 'pt-BR' } }
+  },
+  handler: async (_ctx, _input) => {
+    // TODO: criar/editar
+    return { id: '' }
+  },
+  invalidates: ['${resource}.list'],
+})
+`
+  }
+
+  if (kind === 'view') {
+    return `${HEAD}
+export const ${cn} = defineAction({
+  name: '${name}',
+  kind: 'view',
+  summary: 'TODO: o que retorna (pt-BR)',
+  input: z.object({ id: z.string() }),
+  output: z.object({
+    // TODO: shape do recurso
+    id: z.string(),
+  }),
+  handler: async (_ctx, input) => {
+    // TODO: carregar
+    return { id: input.id }
+  },
+})
+`
+  }
+
+  // simple (default)
+  return `${HEAD}
+export const ${cn} = defineAction({
+  name: '${name}',
+  kind: 'simple',
+  label: 'TODO: rótulo (pt-BR)',
+  messages: { success: 'TODO', error: 'TODO' },
+  input: z.object({ id: z.string() }),
+  output: z.object({ ok: z.boolean() }),
+  handler: async (_ctx, _input) => {
+    // TODO: mutação
+    return { ok: true }
+  },
+  invalidates: ['${resource}.list'],
+})
+`
+}
+
+/** Nome do arquivo sugerido (kebab do verb). */
+export function actionFileName(verb) {
+  return `${verb}.ts`
+}
+
+// CLI: imprime o template no stdout (a skill diz onde colar).
+const isMain = import.meta.url === `file://${process.argv[1]}`
+if (isMain) {
+  const [resource, verb, kind] = process.argv.slice(2)
+  if (!resource || !verb) {
+    console.error('uso: node scaffold.mjs <resource> <verb> [kind=simple|form|list|view]')
+    process.exit(1)
+  }
+  process.stdout.write(actionTemplate({ resource, verb, kind }))
+}

package/registry/templates/app/_gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+*.local

package/registry/templates/app/_npmrc

@@ -0,0 +1 @@
+@softize:registry=https://registry.softize.com.br/

package/registry/templates/app/_opus/_gitignore

@@ -0,0 +1,5 @@
+# Só o manifest.json é COMMITADO (lockfile da spec — o CI cobra a frescura).
+# openapi/docs/client-stubs são derivados descartáveis do `opus gen`.
+*
+!.gitignore
+!manifest.json

package/registry/templates/app/_prettierrc.json

@@ -0,0 +1,6 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "printWidth": 110,
+  "trailingComma": "all"
+}

package/registry/templates/app/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="pt-BR">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <title>{{APP_NAME}}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/registry/templates/app/opus.config.ts

@@ -0,0 +1,16 @@
+/**
+ * opus.config.ts — consumido pelo `opus gen` (manifest/openapi/docs) e, quando o app
+ * ganhar banco, pelo `opus db` (adicione `entities`, a factory `database` e o `schema`
+ * — o script SQL idempotente que o `opus db migrate` aplica).
+ * `domains` = os domínios registrados: a fonte da spec — o `opus gen` projeta o
+ * manifest.json commitado (o CI cobra a frescura via manifest:check).
+ */
+import { tasksDomain } from './src/domains/tasks/index.ts'
+
+export default {
+  domains: [tasksDomain],
+  entities: [],
+  naming: 'snake',
+  migrations: './migrations',
+  output: '.opus',
+}

package/registry/templates/app/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "{{APP_NAME}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "dev:design": "vite --mode design --configLoader runner",
+    "build": "tsc --noEmit && vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "format": "prettier --write src",
+    "format:check": "prettier --check src",
+    "manifest": "opus gen",
+    "manifest:check": "opus gen && git diff --exit-code .opus/manifest.json"
+  },
+  "dependencies": {
+    "@hookform/resolvers": "^3.0.0",
+    "@softize/opus": "^{{OPUS_VERSION}}",
+    "@tanstack/react-query": "^5.0.0",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.460.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-hook-form": "^7.0.0",
+    "tailwind-merge": "^3.3.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.1.0",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.3.4",
+    "prettier": "^3.3.0",
+    "tailwindcss": "^4.1.0",
+    "tsx": "^4.19.0",
+    "tw-animate-css": "^1.2.5",
+    "typescript": "^5.6.0",
+    "vite": "^6.0.0",
+    "vitest": "^2.1.0"
+  }
+}

package/registry/templates/app/pnpm-workspace.yaml

@@ -0,0 +1,11 @@
+# Permissão de build scripts (o pnpm bloqueia por default): o postinstall do
+# @softize/opus roda o `opus setup` (pin + bloco gerenciado do CLAUDE.md) a cada
+# install; o esbuild (vite) compila o binário nativo.
+allowBuilds:
+  '@softize/opus': true
+  esbuild: true
+
+# A base é do nosso registry (confiada): fora da quarentena de release do pnpm —
+# senão um bump nas primeiras 24h da versão resolveria versão velha.
+minimumReleaseAgeExclude:
+  - '@softize/opus'

package/registry/templates/app/public/favicon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" rx="7" fill="#18181b" />
+  <circle cx="16" cy="16" r="7" fill="#fafafa" />
+</svg>

package/registry/templates/app/src/App.tsx

@@ -0,0 +1,37 @@
+import type { z } from 'zod'
+import { Badge, Card, useListAction } from '@softize/opus/ui/react'
+import { Task, taskList } from './domains/tasks/actions/list.ts'
+
+type TaskItem = z.infer<typeof Task>
+
+/** Página inicial do esqueleto: prova a fundação (tema + componentes do Opus) e o
+ *  domínio-exemplo. Troque tudo — este arquivo é seu. */
+export function App(): React.ReactElement {
+  // O front consome o CONTRATO via /api — o plugin opusDesign (vite.config.ts)
+  // serve o backend no próprio dev server: dev normal executa o handler real;
+  // `pnpm dev:design` responde com o mockHandler, isolado de qualquer backend.
+  const { items, isLoading } = useListAction<TaskItem>(taskList)
+
+  return (
+    <main className="flex min-h-full items-center justify-center bg-background p-6">
+      <Card className="w-full max-w-md p-6">
+        <h1 className="mb-1 text-lg font-semibold">{'{{APP_NAME}}'}</h1>
+        <p className="mb-4 text-sm text-muted-foreground">
+          Esqueleto criado pelo opus create. A spec vive nas declarações do domínio.
+        </p>
+        {isLoading ? (
+          <p className="text-sm text-muted-foreground">Carregando…</p>
+        ) : (
+          <ul className="space-y-2">
+            {items.map((t) => (
+              <li key={t.id} className="flex items-center justify-between gap-2 text-sm">
+                <span>{t.title}</span>
+                <Badge variant={t.done ? 'default' : 'secondary'}>{t.done ? 'Feita' : 'Aberta'}</Badge>
+              </li>
+            ))}
+          </ul>
+        )}
+      </Card>
+    </main>
+  )
+}

package/registry/templates/app/src/domains/tasks/actions/list.test.ts

@@ -0,0 +1,34 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { runAction } from '@softize/opus/testing'
+import { Task, taskList, taskListImpl } from './list.ts'
+
+// O harness roda o MESMO pipeline do runtime (valida input, cobra auth, valida
+// output) — teste pelo contrato, não chamando o handler à mão.
+describe('task.list', () => {
+  it('o bound (handler real) lista as fixtures com o shape do contrato', async () => {
+    const { output } = await runAction(taskListImpl, {}, { user: { id: 'u1' } })
+    expect(output.total).toBe(2)
+    expect(output.items[0]).toMatchObject({ id: '1', done: true })
+  })
+
+  it('sem usuário, barra: a action não é pública', async () => {
+    await expect(runAction(taskListImpl, {})).rejects.toMatchObject({ code: 'auth.unauthenticated' })
+  })
+
+  describe('modo design (o que o `pnpm dev:design` serve)', () => {
+    afterEach(() => {
+      // OPUS_MODE é global do processo — limpa pra não vazar entre testes.
+      delete process.env['OPUS_MODE']
+    })
+
+    it('o contrato puro responde pelo mockHandler, com dado válido pro schema', async () => {
+      process.env['OPUS_MODE'] = 'design'
+      const { output } = await runAction(taskList, {}, { user: { id: 'u1' } })
+      expect(output.items.length).toBeGreaterThan(0)
+      // `list` pula a validação de output no pipeline — afirme item a item.
+      for (const item of output.items) {
+        expect(Task.safeParse(item).success).toBe(true)
+      }
+    })
+  })
+})

package/registry/templates/app/src/domains/tasks/actions/list.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+import { bindAction, defineContract } from '@softize/opus/core'
+import { fakeMany } from '@softize/opus/testing'
+
+/** Item do domínio-exemplo — o schema alimenta contrato, mock e testes. */
+export const Task = z.object({ id: z.string(), title: z.string(), done: z.boolean() })
+
+// O split canônico contrato↔handler: o CONTRATO é declarativo e roda nos dois
+// lados (a SPA consome via useListAction); o BINDING é server-only. Em
+// `pnpm dev:design` o mockHandler responde (dado fake do próprio schema);
+// no dev normal e em prod, o handler real do binding assume.
+export const taskList = defineContract({
+  name: 'task.list',
+  kind: 'list',
+  summary: 'Lista as tarefas do exemplo.',
+  description:
+    'Lista as tarefas do domínio-exemplo (fixtures em memória). Referência do formato ' +
+    'canônico de uma action list — contrato separado do handler, paginação por cursor.',
+  input: z.object({}),
+  output: Task,
+  paginate: 'cursor',
+  mockHandler: async () => ({ items: fakeMany(Task, 5), cursor: { next: null }, total: 5 }),
+})
+
+// Fixture em memória — o domínio-exemplo não tem banco; troque pelo seu repositório.
+const TASKS = [
+  { id: '1', title: 'Conhecer a base Opus.', done: true },
+  { id: '2', title: 'Modelar o primeiro domínio real.', done: false },
+]
+
+export const taskListImpl = bindAction(taskList, {
+  handler: async () => ({ items: TASKS, cursor: { next: null }, total: TASKS.length }),
+})

package/registry/templates/app/src/domains/tasks/index.ts

@@ -0,0 +1,13 @@
+import { defineDomain } from '@softize/opus/core'
+import { taskListImpl } from './actions/list.ts'
+
+/** Domínio-exemplo do esqueleto. Troque pelo seu domínio real — a skill
+ *  `create-action` gera actions novas no formato canônico. O domínio registra
+ *  o BOUND (contrato + handler); o contrato puro é o que a web consome. */
+export const tasksDomain = defineDomain({
+  name: 'task',
+  description:
+    'Domínio-exemplo do esqueleto: uma lista de tarefas em memória. Serve de referência ' +
+    'do formato canônico (defineDomain + contrato↔handler com description = a spec).',
+  actions: { taskList: taskListImpl },
+})

package/registry/templates/app/src/index.css

@@ -0,0 +1,18 @@
+/* Tailwind v4 (CSS-first): o entry vem do Opus (Tailwind + tokens + @theme).
+   Sobrescreva vars aqui pra dar identidade ao projeto. */
+@import '@softize/opus/ui/theme.css';
+
+/* Os componentes do Opus vivem em node_modules — o Tailwind os ignora por padrão;
+   aponta a fonte explicitamente pra gerar as classes que eles usam. */
+@source '../node_modules/@softize/opus/src/ui/**/*.{ts,tsx}';
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  html,
+  body,
+  #root {
+    height: 100%;
+  }
+}

package/registry/templates/app/src/main.tsx

@@ -0,0 +1,25 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { TbdlibProvider, TooltipProvider } from '@softize/opus/ui/react'
+import { fetchClient } from '@softize/opus/client/fetch'
+import { App } from './App.tsx'
+import './index.css'
+
+// O trio de providers do padrão da casa — os hooks (useTriggerAction/useFormAction…)
+// exigem QueryClient + Tbdlib, e qualquer Tooltip da base exige o TooltipProvider.
+const queryClient = new QueryClient()
+// Same-origin (/api). Quando o app ganhar server próprio, aponte o baseUrl pra ele.
+const client = fetchClient({ baseUrl: '' })
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <QueryClientProvider client={queryClient}>
+      <TbdlibProvider client={client}>
+        <TooltipProvider>
+          <App />
+        </TooltipProvider>
+      </TbdlibProvider>
+    </QueryClientProvider>
+  </StrictMode>,
+)

package/registry/templates/app/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "verbatimModuleSyntax": true,
+    "baseUrl": ".",
+    "paths": { "@/*": ["./src/*"] }
+  },
+  "include": ["src", "opus.config.ts"]
+}

package/registry/templates/app/vite.config.ts

@@ -0,0 +1,46 @@
+import { defineConfig, type PluginOption } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * Modo design (`vite --mode design`, script dev:design): o runtime Opus sobe DENTRO do
+ * dev server e os mockHandler dos contratos respondem o `/api` — preview autossuficiente,
+ * isolado de prod (o plugin desliga o `server.proxy` sozinho; prefixo ex-proxy sem
+ * cobertura responde 503, nunca vaza pra porta real). Quando o app ganhar um backend real,
+ * o `dev` normal proxeia pra ele (adicione `server.proxy`); o preview de design segue nos
+ * mocks. O entry default do plugin é `./opus.config.ts` (a fonte da spec deste app).
+ *
+ * Import DINÂMICO NO TOP-LEVEL, de propósito, e em duas condições que andam juntas: (1) o
+ * @softize/opus embarca TS source e o config loader padrão (esbuild bundle — o que build e
+ * preview usam) externaliza um import ESTÁTICO, que o node ≥22 recusa (type-stripping sob
+ * node_modules, ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING) — por isso o plugin só carrega
+ * no dev:design, que roda com `--configLoader runner`, cujo pipeline transforma o TS; (2) o
+ * runner FECHA depois de avaliar o módulo, então o import fica no top-level (await), não
+ * dentro da função de config. O `apply` do próprio plugin re-confere o mode — o argv aqui é
+ * só quem evita o load fora do design.
+ */
+const DESIGN_RUN =
+  process.argv.includes('--mode=design') ||
+  process.argv.some((arg, i) => (arg === '--mode' || arg === '-m') && process.argv[i + 1] === 'design')
+
+async function designPlugin(): Promise<PluginOption> {
+  const { opusDesign } = await import('@softize/opus/vite')
+  return opusDesign()
+}
+
+const designPlugins: PluginOption[] = DESIGN_RUN ? [await designPlugin()] : []
+
+export default defineConfig({
+  plugins: [tailwindcss(), react(), ...designPlugins],
+  base: '/',
+  resolve: { alias: { '@': fileURLToPath(new URL('./src', import.meta.url)) } },
+  server: {
+    // PORT do ambiente (um orquestrador de preview pode injetar); local, cai no default.
+    port: Number(process.env.PORT ?? 5173),
+    // Dev server pode rodar atrás de um proxy de preview (host arbitrário) — libera por
+    // padrão (é dev). Restrinja com VITE_ALLOWED_HOSTS=".seu-dominio.com" se quiser.
+    allowedHosts: process.env.VITE_ALLOWED_HOSTS?.split(',').filter(Boolean) ?? true,
+  },
+  build: { outDir: 'dist', emptyOutDir: true },
+})

package/registry/templates/monorepo/_gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+*.local

package/registry/templates/monorepo/_npmrc

@@ -0,0 +1 @@
+@softize:registry=https://registry.softize.com.br/

package/registry/templates/monorepo/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "{{APP_NAME}}",
+  "private": true,
+  "scripts": {
+    "typecheck": "pnpm -r --if-present run typecheck",
+    "test": "pnpm -r --if-present run test",
+    "format": "pnpm -r --if-present run format"
+  }
+}