Open source · MIT + GPL v3

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.

711+
endpoints typés
0
erreur de type à l'exécution
13
plateformes par endpoint
2
fichiers requis
Le problème

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.

API web
Interface React
CLI
Outil IA
Serveur MCP
React Native
Tâche cron
WebSocket
Electron
Panneau d'admin
Widget VibeFrame
Compétence d'agent
Nœud Vibe Sense
next-vibe construit les treize à partir d'un seul fichier.
Le framework

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.

J'ai besoin d'un endpoint qui liste les abonnements actifs avec leur statut de facturation. Trois fichiers, le pattern habituel.
Claude Opus 5.5
IA
Je délègue à Claude Code. Trois fichiers : definition.ts, repository.ts, route.ts. Il connaît les patterns.
C'est fait. Trois fichiers, 0 erreur de lint. L'endpoint des abonnements est en ligne comme interface d'admin interactive, commande CLI, outil appelable par l'IA et outil de serveur MCP, automatiquement. Aucun branchement supplémentaire.
0.64 Crédits
Le pattern

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.

definition.ts
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.

repository.ts
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.

widget.tsx
"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>
  );
}
Supprimez le dossier. La fonctionnalité disparaît de toutes les plateformes d'un coup.
Une seule définition

É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
// 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
// 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

L'alias devient une commande. La sortie est rendue par le même widget, mise en page pour le terminal.
terminal
$ vibe desktop-get-focused-window

  ◆ Focused Window
    Mozilla Firefox
    pid: 2820  2293×916  monitor: DP-2

Outil MCP

Pointez n'importe quel client MCP vers vibe mcp. Les schémas viennent directement des champs Zod.
.mcp.json
// .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 above

Outil appelable par une IA

Les modèles reçoivent un schéma de function calling généré à partir de la définition. Les rôles décident qui peut l'appeler.
tool-call
// 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_OFF

Tâche cron

Le même handler, désormais planifié. Voici le vrai fichier de tâche de notre job d'expiration des crédits.
task.ts
// 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];
Plus une page web sur /tools/<alias>, une route REST typée et un écran natif. Le widget s'affiche sur chacun d'eux. Supprimez le dossier de l'endpoint, et toutes les surfaces disparaissent avec lui.

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.

terminal
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 client
Le framework

Une 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 !" } },
  },
});
devient automatiquement
🌍fetch()

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!"

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.

✓Typé de bout en bout✓Accès contrôlé par rôle✓Validé par Zod✓Zéro code passe-partout
Construit 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.

Tableau de bord embarqué

Un autoradio complet

Navigation, climatisation, radio, Spotify, appels Bluetooth et diagnostic du véhicule en direct, plus Android Auto, sur un PC de voiture à écran tactile. Construit comme un fork de next-vibe.
E-commerce

Des boutiques en ligne qui vendent

Vitrine, panier, paiement, stock et caisse à partir d'une seule installation. Une vraie boutique tourne dessus aujourd'hui.
Réservations

Sites de praticiens et de réservation

Rendez-vous, dossiers clients, facturation et site public : la colonne vertébrale d'un cabinet. La même stack que la boutique.
Plateforme d'IA

unbottled.ai

126 modèles, chat, mémoire persistante, agents, facturation et MCP : le produit phare. Exactement cette base de code, en production.
La suprématie de TypeScript

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.

pas de any

Remplacez-le par une vraie interface typée. Si vous avez besoin de any, votre architecture a un trou.

pas de unknown

Même règle. unknown, c'est any avec des étapes en plus. Définissez le type.

pas de object nu

Un object nu ne veut rien dire. Écrivez la forme que vous attendez vraiment.

pas de as X

Les assertions de type mentent au compilateur. Corrigez plutôt l'architecture.

pas de throw

Utilisez ResponseType<T> avec success(data) ou fail({message, errorType}). Les erreurs sont des données.

pas de chaînes en dur

Chaque chaîne a besoin d'une clé de traduction. Le vérificateur repère les littéraux non traduits.

vibe check lance Oxlint (Rust), ESLint et la vérification de types TypeScript en parallèle. Zéro erreur exigée avant livraison.
Démarrer

Forkez, demandez, livrez.

Vous êtes au niveau de unbottled.ai dès le premier jour.

1

Forker et cloner

Forkez sur GitHub, puis clonez votre fork en local.

terminal
git clone https://github.com/YOUR_USERNAME/next-vibe
cd next-vibe && bun install
2

Lancer 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.

terminal
# development
vibe dev

# production - premier démarrage
vibe build && vibe start

# production - après modifications
vibe rebuild
3

Se 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.

4

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.

prompt
# 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 automatiquement
Entreprise

Vous 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.