Une définition. Treize plateformes.
next-vibe transforme une seule définition TypeScript en treize plateformes à la fois : interface web interactive, commande CLI, outil MCP, écran mobile, tâche cron, WebSocket, panneau d'admin, et plus encore. Typage complet, zéro dérive, zéro répétition.
Vous avez construit la même chose treize fois.
Chaque fonctionnalité exige sa propre interface web, sa commande CLI, son outil MCP, son écran mobile, sa tâche cron, son handler WebSocket, son panneau d'admin, et plus encore. La même validation, la même i18n, la même gestion d'erreurs, juste habillées différemment. À chaque fois.
Votre IA construit ses propres outils.
Ajoutez un endpoint : il devient aussitôt une interface interactive sur mesure, une commande CLI, un outil appelable par l'IA, un outil de serveur MCP et une tâche planifiée. La stack est récursive : Claude Code construit next-vibe avec next-vibe.
Deux fichiers requis. Toutes les plateformes.
Chaque fonctionnalité vit dans un dossier. Seuls definition.ts et route.ts sont requis. Tout le reste est optionnel.
definition.ts : le contrat
Déclarez une seule fois vos champs, schémas Zod, libellés, types d'erreurs et exemples. Ce fichier est l'unique source de vérité : le framework le lit à l'exécution, sur chaque plateforme.
const { POST } = createEndpoint({
scopedTranslation,
method: Methods.POST,
path: ["explain", "to-my-boss"],
title: "post.title" as const,
description: "post.description" as const,
icon: "sparkles",
category: "endpointCategories.ai",
allowedRoles: [UserRole.CUSTOMER, UserRole.ADMIN] as const,
fields: customWidgetObject({
render: ExplainContainer,
usage: { request: "data", response: true } as const,
children: {
decision: requestField(scopedTranslation, {
type: WidgetType.FORM_FIELD,
fieldType: FieldDataType.TEXTAREA,
label: "post.decision.label" as const,
columns: 12,
schema: z.string().min(10),
}),
justification: responseField(scopedTranslation, {
type: WidgetType.TEXT,
content: "post.justification.content" as const,
schema: z.string(),
}),
},
}),
errorTypes: {
[EndpointErrorTypes.UNAUTHORIZED]: { title: "post.errors.unauthorized.title" as const, description: "post.errors.unauthorized.description" as const },
[EndpointErrorTypes.SERVER_ERROR]: { title: "post.errors.serverError.title" as const, description: "post.errors.serverError.description" as const },
// ... other error types
},
successTypes: { title: "post.success.title" as const, description: "post.success.description" as const },
examples: { requests: { default: { decision: "Tout réécrire en TypeScript" } }, responses: { default: { justification: "..." } } },
});
export type ExplainResponseOutput = typeof POST.types.ResponseOutput;
const definitions = { POST } as const;
export default definitions;repository.ts : la logique
La logique métier vit ici : requêtes en base, contrôles d'accès, gestion des erreurs avec success()/fail(). Le route.ts n'est qu'un mince délégateur. Validation, logs et enregistrement sur les plateformes se font automatiquement.
import "server-only";
export class ExplainRepository {
static async explainToMyBoss(
data: ExplainRequestOutput,
user: JwtPayloadType,
logger: EndpointLogger,
t: ExplainT,
): Promise<ResponseType<ExplainResponseOutput>> {
if (!user.id) {
return fail({ message: t("post.errors.unauthorized.title"), errorType: ErrorResponseTypes.UNAUTHORIZED });
}
try {
const [saved] = await db
.insert(explainResults)
.values({ userId: user.id, decision: data.decision })
.returning();
logger.info("Saved decision", { userId: user.id, id: saved.id });
return success({ justification: saved.justification ?? "" });
} catch (error) {
logger.error("Failed to save decision", parseError(error));
return fail({ message: t("post.errors.serverError.title"), errorType: ErrorResponseTypes.INTERNAL_ERROR });
}
}
}widget.tsx : l'interface (optionnel)
Sans widget, le framework affiche automatiquement vos champs partout. Ajoutez widget.tsx pour livrer une interface interactive entièrement sur mesure : le même composant s'affiche dans les panneaux d'admin, les widgets intégrés et les écrans mobiles.
"use client";
interface CustomWidgetProps {
field: {
value: ExplainResponseOutput | null | undefined;
} & (typeof definition.POST)["fields"];
}
export function ExplainContainer({ field }: CustomWidgetProps): JSX.Element {
const children = field.children;
const emptyField = useMemo(() => ({}), []);
return (
<Div className="flex flex-col gap-4 p-4">
<TextareaFieldWidget fieldName="decision" field={children.decision} />
<SubmitButtonWidget<typeof definition.POST>
field={{
text: "Explain to my boss",
loadingText: "Explaining...",
icon: "sparkles",
variant: "primary",
}}
/>
<FormAlertWidget field={emptyField} />
<AlertWidget
fieldName="justification"
field={withValue(children.justification, field.value?.justification, null)}
/>
</Div>
);
}Écrivez-le une fois. Faites-le tourner partout.
Voici un vrai endpoint de ce dépôt : il lit la fenêtre active sur un bureau Linux. Trois fichiers. Aucun code de liaison. Il apparaît comme page web, commande CLI, outil MCP, outil IA et tâche cron.
definition.ts
Chemin, alias, rôles, schéma Zod, widget, erreurs, exemples. Tout ce dont chaque surface a besoin, au même endroit.
// definition.ts - the ONE source of truth
const { POST } = createEndpoint({
scopedTranslation,
method: Methods.POST,
path: ["desktop", "get-focused-window"],
aliases: ["desktop-get-focused-window"] as const,
title: "get-focused-window.title",
icon: "eye",
allowedRoles: [UserRole.ADMIN, UserRole.PRODUCTION_OFF],
fields: customWidgetObject({
render: GetFocusedWindowWidget, // one widget, every platform
usage: { request: "data", response: true } as const,
children: {
windowTitle: responseField(scopedTranslation, {
type: WidgetType.TEXT,
label: "get-focused-window.response.windowTitle",
schema: z.string().optional(),
}),
pid: responseField(scopedTranslation, {
type: WidgetType.TEXT,
label: "get-focused-window.response.pid",
schema: z.number().optional(),
}),
},
}),
errorTypes: { /* all 9 EndpointErrorTypes - required */ },
successTypes: { /* title + description */ },
examples: { /* request + response samples */ },
});route.ts
Relie la définition à une fonction du repository. Ce handler est ce que chaque surface appelle.
// route.ts - wire definition to repository
export const { POST, tools } = endpointsHandler({
endpoint: getFocusedWindowEndpoints,
[Methods.POST]: {
email: undefined,
handler: ({ t, logger }) =>
DesktopWindowRepository.getFocusedWindow(t, logger),
},
});Ce que vous obtenez sans écrire une ligne de plus
Commande CLI
$ vibe desktop-get-focused-window
◆ Focused Window
Mozilla Firefox
pid: 2820 2293×916 monitor: DP-2Outil MCP
// .mcp.json - any MCP client (Claude, Cursor, ...)
{
"mcpServers": {
"my-app": { "command": "vibe", "args": ["mcp"] }
}
}
// the client now lists: desktop-get-focused-window
// input and output schemas come from the Zod fields aboveOutil appelable par une IA
// Same definition, exposed as a function-calling tool.
// The model reads the Zod schema + description. No wrapper.
//
// user: "What window am I looking at?"
// model: desktop-get-focused-window({})
// tool: { windowTitle: "Mozilla Firefox", pid: 2820 }
//
// Hide it from the model: add UserRole.AI_TOOL_OFFTâche cron
// task.ts - the same handler on a schedule
const task = createCronTask(
definition.POST,
tools.POST, // <- the route handler from route.ts
{
id: "credits-expire",
schedule: CRON_SCHEDULES.DAILY_MIDNIGHT,
category: TaskCategory.MAINTENANCE,
priority: CronTaskPriority.MEDIUM,
timeout: TASK_TIMEOUTS.SHORT,
enabled: true,
taskInput: undefined,
},
);
export const tasks: Task[] = [task];Ajoutez le vôtre en cinq lignes de shell
Créez le dossier, écrivez les trois fichiers, régénérez, vérifiez. Si vibe check affiche 0 erreur, ça marche partout.
mkdir -p src/desktop/get-focused-window
# write definition.ts, repository.ts, route.ts (+ widget.tsx)
vibe gen # regenerates route, CLI, MCP and tool registries
vibe check src/desktop/get-focused-window # 0 errors or it's not done
vibe desktop-get-focused-window # CLI, right now
# web: /en-US/tools/desktop-get-focused-window
# MCP: already listed - restart your clientUne définition. 13 plateformes. Zéro dérive.
Écrivez une seule définition d'endpoint. Vous obtenez automatiquement une interface web interactive, une commande CLI, un outil IA, un serveur MCP, une tâche cron, un WebSocket, un écran mobile, une app de bureau, un panneau d'admin, une compétence d'agent, et plus encore. Typé de bout en bout. Accès contrôlé par rôle. Zéro code passe-partout.
const { POST } = createEndpoint({
method: Methods.POST,
path: ["greet"],
allowedRoles: [UserRole.PUBLIC, UserRole.CUSTOMER, UserRole.ADMIN],
title: "Saluer l'utilisateur",
description: "Renvoie un message de bienvenue personnalisé",
icon: "hand-wave",
tags: ["salutations"],
fields: objectField({
type: WidgetType.CONTAINER,
title: "Formulaire de salutation",
usage: { request: "data", response: true },
children: {
name: requestField({
schema: z.string().min(1).max(100),
type: WidgetType.FORM_FIELD,
fieldType: FieldDataType.TEXT,
label: "Votre nom",
placeholder: "ex. Alice",
}),
message: responseField({
schema: z.string(),
type: WidgetType.ALERT,
}),
submitButton: widgetField({
type: WidgetType.SUBMIT_BUTTON,
text: "Dire bonjour",
}),
},
}),
examples: {
requests: { simpleGreeting: { name: "Alice" } },
responses: { simpleGreeting: { message: "Bonjour, Alice !" } },
},
});Ajoutez un chemin. L'endpoint REST existe.
Pas de configuration de routage. Pas de contrôleurs. Dès que vous définissez un chemin et un schéma, l'endpoint est en ligne sur /api/[locale]/[path]. Contrôle des rôles, validation et format des erreurs s'appliquent avant même que votre code s'exécute.
const res = await fetch("/api/fr-FR/greet", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ name: "Alice" }),
});
const { message } = await res.json();
// message → "Hello, Alice!"🌍API REST
HTTP standard, toujours disponible
Votre IA construit ses propres outils
Ajoutez un endpoint : il devient aussitôt un outil appelable par l'IA, une commande CLI, une interface web en direct et une tâche planifiée. La stack est récursive. Claude Code construit next-vibe avec next-vibe.
Du tableau de bord de voiture à la plateforme d'IA.
Même base de code, n'importe quelle surface. Ce sont de vrais produits qui tournent sur next-vibe : un PC de voiture, des boutiques en ligne, des sites de réservation, et unbottled.ai lui-même. Un seul framework, des produits radicalement différents.
Un autoradio complet
Des boutiques en ligne qui vendent
Sites de praticiens et de réservation
unbottled.ai
Pas de any. Pas de unknown. Pas de throw.
Les types doivent concorder entièrement, sans exception. Ce n'est pas une préférence de style. C'est une règle structurelle, imposée à la compilation par vibe check.
Remplacez-le par une vraie interface typée. Si vous avez besoin de any, votre architecture a un trou.
Même règle. unknown, c'est any avec des étapes en plus. Définissez le type.
Un object nu ne veut rien dire. Écrivez la forme que vous attendez vraiment.
Les assertions de type mentent au compilateur. Corrigez plutôt l'architecture.
Utilisez ResponseType<T> avec success(data) ou fail({message, errorType}). Les erreurs sont des données.
Chaque chaîne a besoin d'une clé de traduction. Le vérificateur repère les littéraux non traduits.
Forkez, demandez, livrez.
Vous êtes au niveau de unbottled.ai dès le premier jour.
Forker et cloner
Forkez sur GitHub, puis clonez votre fork en local.
git clone https://github.com/YOUR_USERNAME/next-vibe
cd next-vibe && bun installLancer le serveur
En développement local, vibe dev lance PostgreSQL dans Docker, exécute les migrations, insère les données initiales et active le rechargement à chaud. En production, vibe build && vibe start fait le premier déploiement. Ensuite, vibe rebuild met la production à jour sans aucune interruption.
# development
vibe dev
# production - premier démarrage
vibe build && vibe start
# production - après modifications
vibe rebuildSe connecter en admin
Ouvrez l'app et cliquez sur « Login as Admin » : l'assistant de configuration vous guide pour les clés API et le mot de passe admin.
Demander à l'IA
Ouvrez le chat unbottled.ai ou Claude Code et décrivez la fonctionnalité voulue. L'IA écrit tous les fichiers (définition, route, widget, i18n) et lance vibe check automatiquement.
# Dans le chat unbottled.ai ou Claude Code :
"Crée-moi une fonctionnalité qui explique mes décisions à mon chef"
# L'IA écrit tous les fichiers et lance vibe check automatiquementVous construisez quelque chose de grand ?
Nous aidons les équipes pour l'installation, les intégrations sur mesure, la revue d'architecture et le suivi du développement. Même base de code, votre déploiement.