📋 Update Log

Last Updated: 2026-07-17

This page tracks major updates across Rabetbase CLI, Lovrabet Runtime CLI, and the TypeScript SDK.

2026-07-17

Rabetbase CLI

✨ New role command group for roles and user groups — v2.3.4

Added rabetbase role list/detail/create/update/delete/user-add/user-remove/user-resolve, covering the full lifecycle and membership management of CUSTOM roles. Built-in roles DEV/ADMIN/USER cannot be modified; member changes read the full member list, merge-write, and output before/after for verification.
```
rabetbase role create --name Sales --remark "East China sales" --dry-run
rabetbase role user-add --role 12 --user alice --dry-run
rabetbase role user-remove --role Sales --user 1001 --yes
```
🔒 New permit command group for permission management — v2.3.4

Added rabetbase permit page-get/page-set/role-menus/role-menus-set/role-apis-set, supporting menu-page permissions (menu, create, update, delete, detail, export, row roles), granting/revoking role menu access, and revoking role API permissions by datasetCode. All write operations are high-risk-write: preview with --dry-run, then confirm with --yes.
```
rabetbase permit page-set --menu-id 55 --row-roles SELF --dry-run
rabetbase permit role-menus-set --role Sales --grant --menus orders,products --yes
rabetbase permit role-apis-set --role Sales --revoke --datasets ds-001,ds-002 --yes
```
✨ New app-config runtime app configuration management — v2.3.4

Added rabetbase app-config list/get/set/delete for managing runtime app-config keys. get is redacted by default; --reveal shows the plaintext value. set accepts values from command arguments, files, --stdin, or --from-env, and automatically decides create vs update. All writes support --dry-run.
```
rabetbase app-config list --tags webhook
printf '%s' "$API_KEY" | rabetbase app-config set vectorengine.apiKey --stdin
rabetbase app-config delete webhook.secret --dry-run
```
✨ New cli-skill install built-in skill installer — v2.3.4

Installs or refreshes the CLI Built-in Skill required by Rabetbase CLI, wrapping npx skills add ... -g -y so Agents get the matching skill guidance when using the CLI.
```
rabetbase cli-skill install
```
🧭 App registration moves from app add/remove to workspace add/remove — v2.3.4

rabetbase app add / app remove are now hidden deprecated aliases. The recommended entries are rabetbase workspace add <name> and rabetbase workspace remove <name>, with the same behavior but clearer semantics. Old commands still work and print a migration hint.
```
rabetbase workspace add order --appcode app-order-xxx
rabetbase workspace remove product
```
🧭 project init migrates to workspace init — v2.3.4

The preferred command to bind an app in the current directory is now rabetbase workspace init --appcode <appcode>. rabetbase project init remains as a compatibility alias with a migration hint.
✨ More dataset maintenance commands — v2.3.1 – v2.3.4
- dataset restore: recover deleted dataset metadata and related pages/menus by --id/--code/--dbid. This is high-risk-write; real execution requires --confirm, and bulk restore supports --expected-count to guard against target drift.
- dataset business-group-update: update a dataset's business model group by dataset code, with --expect-business-group current-value guard.
- dataset relation-create/relation-update/relation-delete: manage relations by dataset code + relationId, with delete using a CLI-specific by-ID endpoint and post-write readback via dataset detail.
- dataset generate-start: async DO V2 dataset generation from natural language or structured text. Defaults to a dry-run design snapshot; pass --apply and --design-file to submit the real creation task, then poll with dataset generate-status.
🩺 Database analysis and BFF route stabilization — v2.3.4 / v2.3.5

db analyze-start workflow parameters and pagination semantics are stable, diff flag behavior is locked, and the BFF ENDPOINT route contract is unified to avoid call failures caused by inconsistent routes across entry points.

Lovrabet Runtime CLI

✨ New file upload and ocr recognition commands — v2.1.7

Added lovrabet file upload, lovrabet file query-url, and lovrabet ocr recognize. Upload local files to the runtime and get a persistent filePath, or recognize text in images/PDFs by scene (invoice/general/form/idCard). Local files are uploaded, a temporary URL is fetched, and then OCR is called.
```
lovrabet file upload --file ./contract.pdf
lovrabet file query-url --filepath <filePath> --long-term
lovrabet ocr recognize --scene invoice --image-file ./invoice.jpg
lovrabet ocr recognize --scene form --image-url https://example.com/table.png
```
✨ Long-term file URLs and lossless ID parsing — v2.1.11

file query-url adds --long-term for long-lived URLs, useful for rich text, Markdown, or HTML that needs persistent links. Core JSON parsing now preserves large integer IDs without precision loss.
✨ New bff detail and BFF function name standardization — v2.1.13

lovrabet bff detail --name <functionName> queries a BFF endpoint contract by appCode + functionName, returning description, version, and modified time. Service Tree and API-doc discovery now align with a new function-name adapter, reducing name ambiguity when Agents call BFFs. GET /client/bff/endpoint/{appCode}/{functionName} now supports AK auth.
```
lovrabet bff detail --name calculatePrice
```
✨ app-config get returns the value directly — v2.1.14

lovrabet app-config get <key> now returns the configured value directly instead of just checking whether the key exists, simplifying Agent/script reads of runtime config. --reveal is no longer supported because the output is the value itself. For sensitive keys, read in-place in BFF via context.appConfig.get(...).
```
lovrabet app-config get vectorengine.apiKey
```
🧠 Skill install and push improvements — v2.1.7 / v2.1.9 / v2.1.11
- lovrabet skill install installs personal/company runtime Skills of the current app into the user-level Agent skill directory, with --code filtering, --scope personal|company, and --force refresh, and cleans up stale caches and links.
- lovrabet skill push --scope company submits a local Skill to the company scope and enters the review flow; remote metadata is refreshed and rabetbase CLI references are validated before push.
- Skill manifest round-trips recommended trigger examples, preserved and validated during push/sync.
- The former lovrabet skill pull has migrated to lovrabet skill install, unifying the install entry point.
🐛 Batch data update supports array IDs — v2.1.8

lovrabet data update now supports bulk updates with an array of IDs, with serialization aligned to the runtime server to reduce array-ID merge risk.
🐛 Rate-limit errors normalized — v2.1.11

Retry timing parsing, rate-limit error code aliases, and error normalization are unified, making exit codes more consistent when the CLI hits rate limits.

2026-06-30

Rabetbase CLI

🧭 App command surface tightened

The development CLI no longer keeps the compatibility entries rabetbase app remote and rabetbase app use. Platform app discovery now uses:
```
rabetbase app list --remote
```
Current-workspace default app binding now uses:
```
rabetbase workspace use --app <name>
```
Existing scripts should replace rabetbase app remote with rabetbase app list --remote, and replace rabetbase app use <name> with rabetbase workspace use --app <name>. For one-off command targeting, continue using global --app <name> or --appcode <code>.

2026-06-13

Rabetbase CLI

🧭 dataset list now shows DO V2 datasets directly

rabetbase dataset list now returns DO V2 datasets in the current app, including both DB_TABLE and METADATA sources. Use --source DB_TABLE when you only need database-backed datasets, or --source METADATA when you are working with text-generated page datasets.
```
rabetbase dataset list --source DB_TABLE
rabetbase dataset list --source METADATA
```
The old --include-metadata flow is no longer the recommended form. Existing scripts that assume dataset list only returns DB-table datasets should add --source DB_TABLE.
🔒 AppCode is no longer silently taken over by implicit context

The CLI will not automatically override project config from external context. In scripts, specify the app explicitly:
```
rabetbase dataset list --appcode <appcode>
```
If the command resolves to a different app than expected, it stops instead of sending the operation to the wrong app.
💡 Upgrade notices are quieter

Version notices now avoid repeated output. Manual upgrades still use rabetbase update; beta upgrades use rabetbase update --beta.

2026-06-03

Rabetbase CLI

🔒 Dataset write commands now require explicit selectors

Dataset write commands such as dataset delete, dataset field-update, dataset rename, and dataset extend-update now require an explicit target, usually --code <datasetCode>. Delete also supports --id or --dbid, but only one selector can be used at a time. Field, name, and extend changes support --dry-run previews and --expect-* guards to reduce accidental metadata changes by Agents or scripts.
✨ Safe dataset maintenance commands are now documented

Rabetbase CLI now includes dataset rename, dataset field-update, dataset extend-update, and dataset delete. delete is high-risk-write: preview the target scope first, pass --confirm for real deletion, and use --expected-count for bulk --dbid deletion to protect against target drift.
🧭 Dataset source filtering is explicit

rabetbase dataset list supports source filtering. Use --source DB_TABLE for database-backed datasets and --source METADATA for metadata datasets. SQL schema validation and custom SQL still require a DB_TABLE dataset with physical table context.
🧩 Menu resource update modes are explicit

rabetbase menu update supports --mode replace|patch. replace rewrites the supplied resource set, while patch only replaces resource types you pass in this run. Replace mode will not remove existing JS resources unless --force is explicitly provided.

Lovrabet Runtime CLI

📚 Personal knowledge-base commands

lovrabet kb list/detail/create/update/search can now manage personal knowledge-base entries and search visible company plus personal knowledge for the current app. Create and update read UTF-8 text or Markdown files and support --dry-run.
🧠 Runtime Skill platform sync

lovrabet skill pull materializes personal and company runtime Skills into local Agent skill directories. lovrabet skill push --dir <skillDir> pushes a local Skill directory into the personal runtime Skill scope. Public installation remains lovrabet skill install or npx skills add lovrabet/lovrabet-cli -g -y.
🧭 More stable dataset detail output

lovrabet dataset detail now normalizes v1 / v2 dataset field shapes, parses operation requestBody / responseBody, and includes dbtable, relatedPages, formatRules, validateRules, extend, and stats.

TypeScript SDK

🧩 Docs aligned with v1.4.1

SDK docs now cover runtimeDomain, authMode: "client-ak", X-User-AK, batchCreate(), and $notNull. serverUrl remains compatible but deprecated; new projects should use runtimeDomain.

2026-05-19

Rabetbase CLI

🔒 Smart List Page generation now previews by default

rabetbase page generate-start now returns a dry-run preview by default instead of submitting a real generation job. To actually start Smart List Page generation, pass --apply explicitly:
```
# Preview only; does not submit a generation job
rabetbase page generate-start --datasetcode <datasetCode>

# Actually submit the generation job
rabetbase page generate-start --datasetcode <datasetCode> --apply
```
This reduces the risk of Agents, scripts, or batch jobs accidentally triggering real writes. Existing automation that depends on real submission must add --apply.
🩺 Issue reporting is safer

rabetbase issue report now sanitizes descriptions before upload: oversized descriptions are truncated at 256KB, and sensitive fragments such as Cookie, Authorization, AccessKey, passwords, private keys, and JWTs are replaced with redaction markers. Truncation and redaction statistics are reported as attributes for troubleshooting.
💡 Unexpected failures now suggest an issue report command

When a command hits a platform API error or unexpected exception, the CLI prints a ready-to-copy rabetbase issue report command to stderr. Automation can disable this hint with RABETBASE_DISABLE_ISSUE_NUDGE=1.
🧭 Platform requests identify their invoke source

Development-side platform requests now include X-Invoke-Source: cli:rabetbase, helping backend services distinguish CLI calls from page or other entry points.

Lovrabet Runtime CLI

🌐 App list now exposes real i18n configuration

lovrabet app list items now include platform i18n data: enableI18n, languages, and i18nInfo. Use languages or i18nInfo.langs to determine supported app languages; locale is only a local compatibility field and does not represent actual app language support.
🧭 Runtime SDK calls identify their invoke source

Runtime calls issued through the SDK, such as lovrabet data, sql, and bff, now include X-Invoke-Source for backend observability and troubleshooting.

2026-04-28

Lovrabet Runtime CLI

🚀 Added the launch note for Lovrabet CLI as an AI operation suite for business scenarios

On April 21, 2026, Lovrabet CLI officially launched as the runtime operation entry that brings Lovrabet capabilities into the AI ecosystem. It turns app directories, datasets, data operations, SQL, BFF, and diagnostics into stable commands for Agents, delivery teams, business operations teams, and enterprise IT.
- Product page: Lovrabet CLI
- Documentation: Lovrabet CLI 2.0 for business systems
Its value is not to replace admin pages, but to turn enterprise data, rules, interfaces, and accumulated operating experience into business capabilities that AI can understand, call, audit, and reuse. A business request can then become a repeatable, controlled, and collaborative Agent workflow.
✨ Added lovrabet update and restored lovrabet skill install as the primary Skill install path

lovrabet update updates the CLI from npm, supports --latest, --beta, and --version, and refreshes the official Skill by default. lovrabet skill install is now the recommended CLI entry for installing the published Lovrabet Skill through the official skills tool.
🧭 App resolution semantics now treat defaultApp as a candidate, not strong context

In Agent workflows, explicit --app / --appcode wins. When no app is specified, defaultApp is only the first candidate to validate. If a request clearly points to a business domain such as orders, products, inventory, CRM, or tickets, the Agent should validate the default candidate with dataset search first, then expand to the app list when it does not match.
📚 Docs now separate the business path from advanced technical material

Lovrabet CLI 2.0 docs now include “Advanced usage: config, cache, and integration troubleshooting.” Details about .lovrabet.json, app cache, AccessKey scope, extension constants, and integration troubleshooting have been moved out of the business-user path and into a page for enterprise IT, delivery teams, extension developers, and Skill maintainers.

2026-04-20

Lovrabet Runtime CLI

✨ Added skill install and auth info — v2.0.3

lovrabet skill install can now install the published Lovrabet Skill directly through the official skills CLI. This release also adds lovrabet auth info, making it easier to verify which user the current access key actually belongs to.

2026-04-18

Rabetbase CLI

✨ Introduced a read-only data command group — v2.1.2-beta.1

rabetbase data filter and rabetbase data getOne bring SDK-style record querying directly into the CLI. They are especially useful for inspecting live data, validating field values, and troubleshooting front-end or BFF behavior without leaving the terminal.

2026-04-15

Rabetbase CLI

🔒 Version policy now supports both warnings and hard stops — v2.1.2-beta.1

The CLI now reads both the recommended stable version and the minimum supported version from the CDN:
- If your CLI is behind stableVersion, it shows an upgrade warning
- If it falls below minimumVersion, it blocks critical commands from running
That gives project creation, run flows, and similar entry points a consistent version floor, reducing failures caused by old CLIs talking to newer templates or protocols.

2026-04-13

Lovrabet Runtime CLI

🔄 Auth re-initialization is now centered on auth init — v2.0.2

The "wipe and rebuild auth config" flow has been consolidated into lovrabet auth init. It clears the current scope and writes back fresh auth config, making it the right recovery path when auth config becomes messy or inconsistent.

2026-04-12

TypeScript SDK

✨ v1.4.1 rounds out Client AK, batchCreate(), and $notNull support

This release completes three of the most practical runtime capabilities in one pass:
- Client AK authentication: SDK clients can now run in client-ak mode with only an accessKey, calling /client/ endpoints and automatically sending X-User-AK
- Batch creation: batchCreate() is now available, using paramList in OpenAPI mode and a raw array body in WebAPI / Client AK mode, with a limit of 1000 records per request
- Non-null filtering: filter() now supports the $notNull operator for concise "field must not be empty" queries

Lovrabet Runtime CLI

✨ Authentication and app-directory behavior were redesigned — v2.0.1 / v2.0.2

Across these releases, the runtime CLI converged on a cleaner AccessKey + remote app directory model:
- accessKey is now the primary authentication path, and doctor explicitly tells users that session-cookie auth has been removed
- app list and app pull now consistently revolve around the remote app directory plus local cache
- app use stores user intent such as defaultApp, while app import can migrate default-app selection from .rabetbase.json
🩺 Added doctor diagnostics and data batchCreate — v2.0.1

lovrabet doctor now helps verify global and project config, JSON validity, the active default app, and AccessKey state. At the same time, lovrabet data batchCreate adds batch writes using either a JSON array or { items: [...] }, aligning the CLI more closely with SDK behavior.

Rabetbase CLI

🧭 App views are now named more clearly: app discover → app remote — v2.1.2-beta.1

Platform-directory views and local-config views are now more clearly separated: rabetbase app list focuses on local or merged config, while rabetbase app remote shows which apps the current login can access on the platform.

2026-04-09

Rabetbase CLI

✨ Database connection (dblink) commands are now first-class — v2.1.0 / v2.1.1

The CLI now covers the full database-connection workflow with commands such as db list, db detail, db create, db update, db delete, db test, db analyze-start, db analyze-cancel, db analyze-status, db tables, and db diff. In practice, that brings connection setup, validation, schema analysis, and diff inspection out of the web console and into the terminal.
🩺 Multi-app diagnostics were tightened up further — v2.1.1

rabetbase doctor now shows the final effective configuration together with its source, and app list does a better job of marking the current app, the default app, and where each value came from.

2026-04-06

Rabetbase CLI

✨ SQL pull, config isolation, and API scoping all became more usable — v2.0.10 – v2.0.13

This batch of releases closes several high-frequency gaps that surfaced right after CLI 2.0 launched:
- sql pull can now batch-pull custom SQL from the platform into local .rabetbase/sql/
- inherit: false allows a project to opt out of global config merging entirely
- api list / api pull --global make the boundary between "project apps only" and "merged global + project apps" explicit
- upgrade --yes enables fully non-interactive upgrade flows for scripts and CI

2026-04-04

Rabetbase CLI 2.0

✨ Rabetbase CLI 2.0 Documentation Launch — A complete documentation overhaul for the 2.0 release

The CLI 2.0 docs have been rebuilt from scratch on a new architecture, covering every core module:
- Fresh Install and Upgrade from CLI 1.x as two standalone guides, cross-referencing each other
- Command Reference: 13 global flags explained (--jq, --dry-run, --yes, etc.) along with configuration fields
- Typical Use Cases rewritten around five real workflows: front-end data onboarding, SQL development, BFF scripting, AI-assisted development, and automation scripts
- API & Datasets, BFF Scripts, Code Generation & Menus, Custom SQL, Schema and other core command docs
- Configuration: Apps and Multi-App plus Config Reference, Risk Level Control, Maintenance & Diagnostics
- CLI 1.x Command Migration guide for existing users
👉 Rabetbase CLI 2.0 Documentation
📝 Documentation Structure Refinements
- Navbar: Lovrabet CLI replaced by Rabetbase CLI 2.0; MCP & Skills moved to archived docs
- Sidebar labels made more direct: "Fresh Install", "Upgrade from CLI 1.x", "Configuration: Apps and Multi-App"
- Stray --- horizontal rules removed throughout to prevent Docusaurus rendering artifacts
- Fixed intro.md → index.md route conflict so /docs/rabetbase-cli/ resolves correctly
🌐 Full English Translation — All Rabetbase CLI 2.0 docs now available in English

TypeScript SDK

✨ Streamlined update / delete API — v1.3.7 unifies the calling convention between front-end SDK and BFF contexts

Both update() and delete() now accept an object-style parameter, matching the context.client calling pattern inside BFF scripts:
```
// ✅ Recommended (object merge — consistent across front-end and BFF)
await client.models.users.update({ id: 1001, name: 'Zhang San' });
await client.models.users.update({ id: [1001, 1002], status: 'active' });
await client.models.users.delete({ id: 1001 });
await client.models.users.delete({ id: [1001, 1002, 1003] });

// ✅ Legacy style (still works)
await client.models.users.update(1001, { name: 'Zhang San' });
await client.models.users.delete(1001);
```
Why the change?
- Front-end SDK and BFF context.client now share the same calling convention, reducing cognitive overhead
- The object-merge style maps more naturally onto RESTful semantics — and AI-generated code reads better too
- The legacy positional style remains fully compatible; no existing code needs to change
🔧 runtimeDomain replaces serverUrl — v1.3.7

A new runtimeDomain configuration field aligns with the .rabetbase.json naming used by the CLI. The previous serverUrl is marked @deprecated but continues to work.
```
const client = createClient({
  appCode: 'your-app',
  runtimeDomain: 'https://runtime.my-company.com', // New field
  // serverUrl: '...', // Legacy field — still functional
});
```

2026-03-26

Note: The entries below belong to the CLI 1.x era. Rabetbase CLI 2.0 launched on 2026-04-04 — we recommend heading straight to the CLI 2.0 docs.

Lovrabet CLI

🔄 Skills Installation Method Changed - Recommend using npx skills for installation

Skills installation has migrated to the npx skills tool, the old lovrabet skill install command is deprecated:
```
# ✅ New method (Recommended)
npx skills add lovrabet/lovrabet-skill

# ❌ Old method (Deprecated)
# lovrabet skill install --cursor
```
Why the change?
- ✅ No CLI installation required, use npx directly
- ✅ Always use the latest version of Skills
- ✅ Better ecosystem alignment
👉 AI Skills Installation Documentation

Lovrabet SDK

✨ Batch Operations Support - v1.3.7 adds batch update and batch delete capabilities

SDK now supports batch operations, greatly improving data processing efficiency:
```
// Batch update - max 1000 records
await client.models.users.update(
  [1001, 1002, 1003, 1004, 1005],
  { status: "inactive", updateTime: new Date().toISOString() }
);

// Batch delete - max 1000 records
await client.models.orders.delete([1001, 1002, 1003]);
```
Core Features:
- Process up to 1000 records at once
- Supports both single ID and ID array formats
- Operations are atomic - all succeed or all fail
- Works in both OpenAPI and WebAPI modes
- Clear error messages when limits are exceeded
Use Cases:
- Batch status updates (e.g., activate/deactivate users)
- Batch field updates (e.g., set tags in bulk)
- Batch cleanup of test data
- Batch deletion of expired records
👉 API Usage Guide
📝 Documentation Enhancement - Added comprehensive usage guide

New help/lovrabet-sdk-guide.md (16KB) includes:
- Batch operations detailed explanations and best practices
- Advanced queries (filter method) complete guide
- Data export (Excel), SQL API, dropdown options, and all features
- Aggregation statistics (aggregate) usage guide
- Common questions and best practices

Lovrabet CLI

✨ Windows 10 Compatibility Optimization - v1.3.4 comprehensively improves Windows 10 support

CLI is now fully compatible with Windows 10, working properly in all mainstream terminals:

Core Improvements:
- 🔧 Path Handling Optimization - Uses path.join() instead of hardcoded separators, automatically adapts to Windows path format
- 🚀 Process Execution Optimization - Adopts execa instead of spawn, providing better cross-platform process management
- 🎨 Emoji Display Fix - Removes incompatible emojis, uses ASCII characters instead, ensuring proper display in CMD/PowerShell
Fix Examples:
```
# Before (displayed as boxes)
🚀 Generating documentation...
❌ Generation failed

# After (normal display)
* Generating documentation...
[ERROR] Generation failed
```
Test Coverage:
- ✅ Windows CMD - All features work normally
- ✅ PowerShell - All features work normally
- ✅ Git Bash - All features work normally (Recommended)
- ✅ WSL - All features work normally (Recommended)
- ✅ Cmder - All features work normally
👉 Windows Usage Guide
🗑️ Remove add page Command - v1.3.4 simplifies command set

Removed lovrabet add page command, recommend using more flexible approaches:

Alternative Solutions:
```
# Use API generation + manual page creation
lovrabet api pull              # Generate API configuration
# Then manually create page components, more flexible and controllable
```
Why Removed:
- Page template too simple, not suitable for real business scenarios
- Manual page creation more flexible, allows custom component structure
- Using SDK + API configuration is a better development pattern
👉 Command Reference

2026-02-12

Documentation Restructure

📝 Enhanced menu update command documentation - Added iterative update workflow instructions

Lovrabet CLI

✨ i18n Internationalization Support - v1.3.3 adds internationalization capabilities

CLI now supports multi-language switching, enhancing global user experience:
```
# Switch display language
lovrabet config set locale en    # English
lovrabet config set locale zh    # Chinese (default)
```
Core Features:
- Built-in Chinese and English support
- All prompt messages and documentation support multiple languages
- Easy to extend with new languages

Lovrabet SDK

✨ Filter Multi-table Query Support - Filter API now supports cross-table relational queries

Implement table joins without writing SQL, using dot notation for automatic association:

const result = await client.models.orders.filter({
  // Use dot notation in select to get related table fields
  select: [
    "id",
    "order_date",
    "total_amount",
    "customer.name",    // Related customer name
    "customer.phone",   // Related customer phone
    "customer.company", // Related customer company
  ],
  // Dot notation also works in where
  where: {
    status: { $eq: "completed" },
    "customer.is_signed": { $eq: true }, // Only signed customers
  },
  // orderBy also supports dot notation
  orderBy: [{ order_date: "desc" }, { "customer.name": "asc" }],
  currentPage: 1,
  pageSize: 20,
});

// Results automatically include related data
result.tableData.forEach((order) => {
  console.log(order.customer?.name); // Direct access to related fields
});

Core Features:

Use table_name.field_name syntax, no additional configuration needed
Automatic LEFT JOIN, ensuring main table data is preserved
Works in select, where, and orderBy
Supports up to 5 levels of nested associations
Field selection reduces data transfer
Fully compatible with filter conditions and sorting

👉 Filter API Complete Guide

2026-01-26

Lovrabet SDK

✨ New Model Alias Configuration Documentation - Detailed guide on human-friendly model access

Core Features:
- Use aliases instead of complex datasetCode to access datasets
- CLI auto-generates configuration, no manual writing needed
- Complete TypeScript type support
Access Method Comparison:
```
// Using alias (Recommended) - Clear and readable
const orders = await client.models.orders.filter();
const customers = await client.models.customers.filter();

// Using datasetCode - Less readable
const orders = await client.models.dataset_8d2dcbae08b54bdd84c00be558ed48df.filter();
```
CLI Auto-generation:
```
lovrabet api pull
```
Generated configuration includes:
- datasetCode - Dataset unique identifier
- tableName - Database table name
- alias - Human-friendly alias (camelCase format)
👉 Model Alias Configuration Documentation

📝 BFF API Documentation Release - Complete BFF API usage guide

BFF (Backend For Frontend) API is supported from v1.3.0:

// Call backend function
const result = await client.bff.execute({
  scriptName: 'calculatePrice',
  params: { productId: '123', quantity: 10 }
});

👉 BFF API Reference

📝 Syntax Sugar Documentation Release - Complete guide for safe and sqlSafe

Version Requirements:

safe function: v1.3.0+
sqlSafe function: v1.3.0+

Simplified error handling:

import { safe, sqlSafe } from "@lovrabet/sdk";

// safe - Regular API
const { data, error } = await safe(() => client.models.users.filter());
if (!error) {
  console.log(data);
}

// sqlSafe - SQL queries
const { data, error } = await sqlSafe(() =>
  client.sql.execute({ sqlCode: "xxx" })
);
if (!error) {
  console.log(`Found ${data.length} records`);
  data.forEach(row => console.log(row));
}

👉 Syntax Sugar Documentation

📝 SQL API Change Note - Recommend using new namespace approach

From v1.1.19, it's recommended to use client.sql.execute() instead of the old client.api.executeSql():

// ✅ Recommended: Use client.sql namespace
const data = await client.sql.execute({
  sqlCode: "fc8e7777-06e3847d",
  params: { userId: "123" }
});

// ⚠️ Compatible: Old method still works
const data = await client.api.executeSql("fc8e7777-06e3847d", {
  userId: "123"
});

👉 SQL API Usage Guide

Lovrabet Toolchain

🤖 AI Vibe Coding System - CLI, SDK, MCP trinity, fully empowering AI-assisted development

Three Core Tools:

Tool	Core Features	User Value
Lovrabet CLI	Project initialization, code generation, menu sync, AI integration	One-click completion of tedious configuration, saving 80% initialization time
Lovrabet SDK	TypeScript SDK with CRUD, Filter, SQL, BFF four major APIs	Type-safe data access, reducing 60% interface debugging time
Lovrabet MCP	AI IDE dataset access capability, automatic code generation	AI directly understands business models, code generation accuracy 90%+

🔧 Lovrabet CLI (v1.2.5+) - Development Efficiency Multiplier

# Project initialization
lovrabet init                    # Quick appCode configuration
lovrabet api pull                # Auto-generate SDK config (api.ts)

# AI integration (New)
lovrabet mcp install --cursor    # Configure Cursor MCP
lovrabet skill install --cursor  # Install development standards Skill

# Menu management
lovrabet menu sync               # Sync local pages to platform menu

User Value:

⚡ Quick Start: New project configured in 5 minutes, not 1 hour of manual setup
🎯 Zero Configuration Errors: Auto-generated config files, avoiding appCode, datasetCode typos
🔄 Auto Sync: One-click menu sync, no need to manually create on platform
🤖 AI Ready: One-click install MCP and Skill, AI immediately understands project structure

📦 Lovrabet SDK (v1.3.0+) - Type-Safe Data Access Layer

// CRUD operations
const users = await client.models.users.filter({ status: 'active' });
const user = await client.models.users.create({ name: 'Alice' });

// Advanced queries (Filter API)
const result = await client.models.orders.filter({
  where: { amount: { $gte: 100, $lte: 500 } },
  select: ['id', 'amount', 'status'],
  orderBy: [{ createTime: 'desc' }]
});

// Custom SQL (SQL API)
const stats = await client.sql.execute({
  sqlCode: 'user-stats',
  params: { startDate: '2025-01-01' }
});

// Backend functions (BFF API)
const price = await client.bff.execute({
  scriptName: 'calculatePrice',
  params: { productId: '123', quantity: 10 }
});

User Value:

🛡️ Type Safety: TypeScript hints throughout, catching 90% of errors at compile time
🚀 Development Speed: Unified API style, no need to memorize multiple interface specifications
🎨 Flexible Queries: Filter API supports complex conditions, no need to write SQL
🔌 Business Decoupling: BFF API encapsulates complex logic, frontend focuses on UI

🧠 Lovrabet MCP - AI's Dataset Knowledge Base

Enables AI IDEs (Cursor, Claude Code, Windsurf) to:

📊 Understand Data Models: Direct access to dataset fields, types, enum values, relationships
🤖 Generate Accurate Code: Generate SDK call code based on real metadata, 100% correct field names
🔍 Smart SQL Creation: 5-step workflow (validate→confirm→save→test→generate), preventing SQL errors
📝 Follow Standards: Skill guides AI to follow project development standards (API usage, UI standards, error handling)

Lovrabet Skill Six Modules:

Module	Features	Technical Value	Business Value
TypeScript SDK Usage	Complete Filter, SQL, BFF usage	Reduce API misuse	Lower 30% debugging time
MCP SQL Workflow	Mandatory validation process	Prevent SQL errors	Avoid data issues
AntD UI Standards	Avoid "AI-flavored" code	Unified UI style	Reduce UI rework
API Integration Guide	Standardized call patterns	Improve stability	Shorten 50% integration time
Menu Management	Automated sync	Avoid configuration errors	Improve ops efficiency
BFF Script Standards	Best practices	Improve maintainability	Reduce technical debt

Supported AI IDEs:

Cursor (.cursorrules + .cursor/skills/)
Windsurf (.windsurf/workflows/)
Claude Code (.claude/skills/)
Codex, OpenCode, Qoder, CodeBuddy, Trae

Overall Business Value:

📈 Development Efficiency Increased 3-5x: AI auto-generates code, reducing 60-80% repetitive work
🎯 Learning Cost Reduced 70%: New developers onboard in 1 day, no need to deeply learn all APIs
🛡️ Error Rate Decreased 80%: AI follows standards, avoiding common errors (SQL injection, field typos, etc.)
⚡ Delivery Cycle Shortened 40%: From requirements to launch, development time significantly compressed
🔄 Code Quality Improved: Unified style, smoother team collaboration, more efficient code reviews

👉 CLI Command Reference | SDK Quick Start | MCP Configuration Guide

📝 Skill Installation Directory Correction - Cursor skills install to .cursor/skills/ not .cursor/commands/

Correct File Structure:

your-project/
├── .cursorrules              # Cursor general rules
├── .cursor/
│   └── skills/               # Cursor skills ✅
├── .windsurf/
│   └── workflows/            # Windsurf workflows
├── .claude/
│   └── skills/               # Claude Code skills
└── .lovrabet/
    └── skill/                # Shared guides

Installation Command:

lovrabet skill install --cursor

👉 Skill Installation Documentation

Documentation Internationalization

🌐 Completed English Translation - All new and updated documentation synchronized to English version

New English Documentation:
- Model Alias Configuration
- BFF API Reference
- Syntax Sugar
- Skill Installation
Updated English Documentation:
- API Usage Guide - Added BFF API and SQL API change notes
- All version numbers corrected to v1.3.0
Access English Version:
- Visit /en/ path in browser
- Or use language switcher in top right corner

2026-01-02

Lovrabet SDK

🤖 AI-Friendly Error Handling - v1.2.5 enhanced LovrabetError, added description field

Optimized error messages for AI Coding scenarios, helping LLMs understand error causes and provide fix suggestions:

try {
  await client.models.users.create({ invalid_field: 'value' });
} catch (error) {
  if (error instanceof LovrabetError) {
    console.log(error.message);     // "Column invalid_field does not exist"
    console.log(error.code);        // "SERVER_ERROR"
    console.log(error.description);
    // "Server returned error: Column invalid_field does not exist. Error type: Parameter error. Status code: 400.
    //  Suggestion: Field "invalid_field" does not exist, please check if the field name is spelled correctly;
    //  Use MCP tool to get the correct field list for the dataset"
  }
}

Covered Error Types:

MODEL_NOT_FOUND - Model does not exist, provides available model list
CONFIG_NOT_FOUND - Configuration does not exist, provides registered configuration list
SERVER_ERROR - Server parameter error, provides field fix suggestions
401 Insufficient permissions - Login expired/appCode unauthorized/HTTPS/CORS and other suggestions
TIMEOUT - Request timeout, provides timeout configuration suggestions

2025-12-29 🎉 v1.2.0 Major Release

Lovrabet SDK v1.2.0

✨ Model Access Method Upgrade - Supports standard and alias methods

// Standard method (Recommended) - Uses dataset_ prefix + datasetCode
// Globally unique, convenient for AI tool code generation
const users = await client.models.dataset_8d2dcbae08b54bdd84c00be558ed48df.filter();

// Alias method (Syntactic sugar) - Uses configured alias
// Convenient for human reading, functionally identical to standard method
const users = await client.models.users.filter();

Alias is just a pointer, internally still uses datasetCode for access, all features are the same as standard method.

✨ Configuration Structure Redesign - Optimized for AI invocation, redesigned registerModels function parameter structure

registerModels({
  appCode: "your-app-code",
  models: [
    {
      datasetCode: "8d2dcbae08b54bdd84c00be558ed48df",
      tableName: "users",
      alias: "users",      // Optional: Model alias, syntactic sugar
      name: "User Table",  // Optional: UI display name
    },
  ],
});

New structure is centered on datasetCode as the core identifier, more AI-friendly, generated code is more standardized.

✨ Model Manager Enhancement - Added multiple management methods

// Get all model details
const details = client.getModelListDetails();
// Returns: [{ datasetCode: '8d2dcbae08b54bdd84c00be558ed48df', alias: 'users', name: 'User Table' }, ...]

// Dynamically add model
client.addModel({
  datasetCode: 'f7e6d5c4b3a2901234567890fedcba98',
  tableName: 'products',
  alias: 'products'
});

✅ Fully Backward Compatible - All existing code runs without modification

👉 SDK Configuration Guide | Quick Start

Lovrabet CLI v1.2.0

✨ SDK Version Compatibility Check - Automatically detects @lovrabet/sdk version in the project at startup
- Displays yellow warning to upgrade if version below 1.2.0 is detected
- Ensures access to latest features like model aliases

✨ API Configuration Structure Optimization - Generated configuration is more AI-friendly, supports model aliases

// api.ts generated by v1.2.0+
export const LOVRABET_MODELS_CONFIG = {
  appCode: 'my-app',
  models: [
    {
      datasetCode: '8d2dcbae08b54bdd84c00be558ed48df',
      tableName: 'users',
      alias: 'users',      // Model alias, convenient for code reading
      name: 'User Management',    // UI display name
    },
  ],
} as const;

👉 CLI Command Reference

Lovrabet MCP v1.2.0

⚡ Significant Performance and Stability Improvements - Full upgrade of underlying architecture, faster response, more stable operation
✨ Further Reduction of AI Hallucinations - Provides more precise field metadata (database type, length, auto-increment, etc.), helping AI generate more accurate code
✨ SDK/CLI Version Compatibility Guidance - Generated code automatically prompts SDK version requirements, guiding users to upgrade to 1.2.0+ to use new features like alias access

👉 MCP Service Documentation

2025-12-03

Lovrabet SDK

✨ New Excel Export Feature - v1.1.24 supports exporting datasets to Excel files

Export data quickly with excelExport() method:
```
// Export all data
const fileUrl = await client.models.users.excelExport();
window.open(fileUrl, '_blank');

// Export with filter conditions
const fileUrl = await client.models.users.excelExport({
  status: 'active',
  createTime: '2025-01-01'
});
```
Core Features:
- Returns downloadable file URL (OSS address)
- Supports passing filter conditions (ListParams)
- Direct use of window.open() to open download
- Only WebAPI mode (Cookie authentication) supported
👉 API Usage Guide | Practical Examples

2025-11-21

Lovrabet SDK

✨ Filter API Supports OpenAPI Mode - v1.1.22 extends filter() to full mode support

Starting from v1.1.22, filter() method supports both OpenAPI mode and WebAPI mode:

// Using filter in OpenAPI mode
const client = createClient({
  appCode: "your-app-code",
  accessKey: "your-access-key",
  models: { users: { tableName: "users", datasetCode: "ds-001" } },
});

const result = await client.models.users.filter({
  where: {
    $and: [
      { age: { $gte: 18, $lte: 45 } },
      { country: { $in: ["China", "United States"] } },
    ],
  },
  select: ["id", "name", "age"],
  orderBy: [{ createTime: "desc" }],
  currentPage: 1,
  pageSize: 20,
});

Updates:

OpenAPI mode now supports filter() advanced filtering queries
Maintains consistent API interface with WebAPI mode
Supports all conditional operators and logical combinations

👉 Filter API Complete Guide

2025-11-15

Lovrabet SDK

✨ New Filter API Advanced Filtering Query - v1.1.21 supports more powerful data filtering capabilities

Perform complex conditional queries via client.models.xxx.filter() method:
```
// Range query + fuzzy search + field filtering
const users = await client.models.users.filter({
  where: {
    age: { $gte: 18, $lte: 35 },           // Age 18-35
    username: { $contain: 'john' },        // Username contains john
    status: { $in: ['active', 'pending'] } // Status is active or pending
  },
  fields: ['id', 'username', 'age'],       // Only return these fields
  sortList: [{ createTime: 'desc' }],
  pageSize: 20
});
```
Core Advantages:
- Supports range queries ($gte, $lte)
- Supports fuzzy matching ($contain, $startWith, $endWith)
- Supports set operations ($in, $ne)
- Supports complex logic ($and, $or)
- Supports field filtering, reducing data transfer
Use Cases:
- Complex data filtering and search features
- Multi-condition combined queries
- Advanced data analysis and reporting
👉 Filter API Complete Guide

2025-11-11

Lovrabet SDK

✨ New SQL API Support - v1.1.19 supports executing custom SQL queries

Execute custom SQL configured on the platform via client.api.executeSql() method:
```
// Execute SQL query
const data = await client.api.executeSql("fc8e7777-06e3847d");

// Application layer checks execution results
if (data.execSuccess && data.execResult) {
  data.execResult.forEach((row) => {
    console.log(row);
  });
}
```
Core Features:
- Supports parameterized queries, preventing SQL injection
- Complete TypeScript type support
Use Cases:
- Complex data statistics and aggregation queries
- Cross-table relational queries
- Custom report data retrieval
- Flexible data analysis needs
👉 Detailed Usage Guide

2025-11-04

Lovrabet CLI

✨ New Menu Sync Command - v1.1.15 added lovrabet menu sync

After completing new page development, sync to Lovrabet platform with one command, automatically create menus:
```
lovrabet menu sync
```
Core Features:
- Automatically scan local src/pages directory, compare with platform menus
- Visualize differences (green ✓ exists, red ✗ not created)
- Batch create missing menus
- Support configuring JS/CSS CDN links
- Real-time URL format and reachability validation
Use Cases:
- Sync to platform after developing new pages
- Batch manage multiple page menus
- Ensure local and platform consistency
👉 Detailed Usage Guide

2025-10-25

OpenAPI Documentation

🐛 Fix terminology and example inconsistencies
- Unified datasetId → datasetCode across the board
- Unified datasetCode example naming
🎨 Optimize list return structure description
- Clarified filter returns include paging/tableData/tableColumns
- Aligned examples with descriptions, ready for direct copy and run

Lovrabet CLI

📝 Proofread command documentation
- Confirmed and supplemented lovrabet api doc and --datasetcode, --params option descriptions (aligned with implementation)

Lovrabet SDK

📝 README example alignment
- Unified examples to use datasetCode
- Supplemented filter return structure reading examples (reading paging and tableColumns)

2025-10-18

Lovrabet SDK

✨ New Select Options Interface - v1.1.18 supports quick retrieval of form option data

Added getSelectOptions() method for getting dropdown options from data tables
Returns standardized { label, value } format, directly applicable to frontend components
Automatically maps data table fields to option data
Suitable for Select, Radio, Checkbox, and other form components
Only WebAPI mode (Cookie authentication) supported

Example:

// Get select options
const options = await client.models.users.getSelectOptions({
  code: "user_id", // Field name used for option value
  label: "user_name", // Field name used for display text
});

// Return format:
// [
//   { label: 'Zhang San', value: 'user001' },
//   { label: 'Li Si', value: 'user002' }
// ]

// Use in React
<Select>
  {options.map((option) => (
    <Option key={option.value} value={option.value}>
      {option.label}
    </Option>
  ))}
</Select>;

📋 New Type Definitions - v1.1.17
- SelectOption interface: { label: string, value: string }
- SelectOptionsParams interface: { code: string, label: string }
⚠️ Clarified OpenAPI Mode Limitations - v1.1.18
- OpenAPI mode does not currently support delete() operation
- OpenAPI mode does not currently support getSelectOptions() operation
- If you need these features, please use WebAPI mode (Cookie authentication) or develop custom API interfaces

Lovrabet CLI

🎨 Optimized Naming Convention - v1.1.13 improved code generation standards
- Dataset name generation uses camelCase naming (lowercase first letter)
- Conforms to JavaScript/TypeScript variable naming conventions
- Examples:
  - order_items table → generates orderItems model (not OrderItems)
  - user_profile table → generates userProfile model (not UserProfile)
- Ensures consistent style of generated code, improves code readability
🔧 Code Generation Optimization - v1.1.13
- Simplified model configuration generation logic
- Improved code generation performance and maintainability

2025-10-17

Lovrabet CLI

✨ New lovrabet init Command - v1.1.12 supports quick initialization configuration for existing projects
- Add Lovrabet configuration support to existing projects
- Interactive appcode input with real-time format validation
- Automatically detect and prevent overwriting existing configuration files
- Inherit global configuration, no need to repeat settings
- Configuration file includes creation time and CLI version information
- Usage example:
```
# Interactive initialization
lovrabet init

# Directly specify appcode
lovrabet init --appcode my-app-code
```
✨ Enhanced lovrabet api doc - v1.1.12 supports on-demand generation and custom parameters
- Added --datasetcode parameter: specify dataset to generate documentation
- Supports multiple datasets (comma-separated)
- Intelligent validation: automatically checks if specified dataset codes exist
- Statistical feedback: shows number of matched datasets and invalid codes
- Supports passing JSON format additional parameters via --params parameter
- Usage example:
```
# Generate documentation for all datasets
lovrabet api doc

# Generate documentation only for specified dataset
lovrabet api doc --datasetcode ds_001

# Generate documentation for multiple specified datasets
lovrabet api doc --datasetcode ds_001,ds_002,ds_003

# Pass additional parameters
lovrabet api doc --params '{"customField": "value"}'
```
📊 Optimized File Naming Strategy - v1.1.12 improved filename uniqueness
- Extended short code from 4 to 6 digits
- Reduced possibility of filename conflicts

2025-10-16

Lovrabet SDK

✨ New List Sorting Feature - v1.1.16 supports multi-field combined sorting

Use SortOrder enum to control ascending/descending order
Supports multi-field priority sorting
Compatible with both OpenAPI and WebAPI modes

Example:

import { SortOrder } from "@lovrabet/sdk";

const users = await client.models.users.filter(
  { currentPage: 1, pageSize: 20 },
  [
    { priority: SortOrder.DESC }, // Priority descending
    { createTime: SortOrder.DESC }, // Create time descending
    { name: SortOrder.ASC }, // Name ascending
  ]
);

🔧 ModelConfig Interface Enhancement - Added optional name field, improved configuration flexibility
🐛 Debug Feature Optimization - v1.1.14 added debug logging feature
- Supports outputting complete HTTP request details (URL, Headers, Body)
- Enable via options.debug: true
- Convenient for troubleshooting API call issues

Lovrabet CLI

✨ Dataset Management Optimization - v1.1.10 comprehensively improved data management capabilities
- Intelligent deduplication mechanism: automatically identify and remove duplicate datasets
- Optimized SDK data retrieval page templates, streamlined UI components
- Enhanced table data processing capabilities, improved performance
📄 API Documentation Generation - Added automatic API documentation generation feature
- Automatically generate API usage documentation from datasets
- Provide complete interface descriptions and example code
- Support custom documentation templates
📊 Log System Enhancement - CLI log tracking capabilities fully upgraded
- Full process tracking of command execution
- Enhanced error localization capabilities
- Support log level filtering
🎯 User Experience Optimization
- Improved API configuration management workflow
- Optimized interactive prompts
- Improved command response speed

2025-10-12

Java OpenSDK

✨ New Complete Java OpenSDK documentation system
- 📖 Quick Start - Complete your first CRUD program in 5 minutes
- 📚 Core Concepts - SDK working principles and authentication mechanism explained in detail
- 📋 API Reference - Complete interface documentation and parameter descriptions
- 💡 Business Examples - 5 complete implementations of real scenarios (customer management, order sync, data dashboard, data middle platform, scheduled tasks)
- 🚀 Best Practices - Release and performance optimization guide
- ❓ FAQ - Covers troubleshooting for installation, configuration, and full development workflow
🎨 Optimized Documentation structure
- Adjusted menu order, arranged by learning path (Quick Start → Core Concepts → Examples → Best Practices → API Reference → FAQ)
- API Reference moved to end of menu, convenient for quick reference after getting started

Documentation Experience Optimization

🐛 Fixed Code block syntax highlighting issues
- Support for Java, Gradle, YAML, Bash, and other languages
- Added correct language identifiers for all code examples
🎨 Optimized Single document mode display
- Fixed page width limitation issue in single document mode
- Implemented responsive design, adaptive margins for different screen sizes (compressed margins on small screens, comfortable reading width on large screens)

Content Completion

📝 Updated Rabetbase introduction
- Supplemented OpenAPI current status description (beta phase, data query function only)
- Supplemented Java OpenSDK complete feature description (supports complete CRUD operations)
- Added quick start guide, categorized by tech stack (frontend developers, backend developers)
- Added technology selection comparison table to help developers choose appropriate solutions

Usage Instructions

This update log follows the following format:

✨ New - Brand new feature or documentation section
🎨 Optimized - Improved expression or structure of existing content
🐛 Fixed - Corrected errors or issues in documentation
📝 Completed / Updated - Supplemented or enriched existing content
🔐 Security - Security-related updates
⚡ Performance - Performance optimization-related updates
📊 Example - Added or updated code examples
🛠️ Tools - Development tools or auxiliary function-related
📖 Documentation - Documentation-related improvements

2026-07-17​

Rabetbase CLI​

Lovrabet Runtime CLI​

2026-06-30​

Rabetbase CLI​

2026-06-13​

Rabetbase CLI​

2026-06-03​

Rabetbase CLI​

Lovrabet Runtime CLI​

TypeScript SDK​

2026-05-19​

Rabetbase CLI​

Lovrabet Runtime CLI​

2026-04-28​

Lovrabet Runtime CLI​

2026-04-20​

Lovrabet Runtime CLI​

2026-04-18​

Rabetbase CLI​

2026-04-15​

Rabetbase CLI​

2026-04-13​

Lovrabet Runtime CLI​

2026-04-12​

TypeScript SDK​

Lovrabet Runtime CLI​

Rabetbase CLI​

2026-04-09​

Rabetbase CLI​

2026-04-06​

Rabetbase CLI​

2026-04-04​

Rabetbase CLI 2.0​

TypeScript SDK​

2026-03-26​

Lovrabet CLI​

Lovrabet SDK​

Lovrabet CLI​

2026-02-12​

Documentation Restructure​

Lovrabet CLI​

Lovrabet SDK​

2026-01-26​

Lovrabet SDK​

Lovrabet Toolchain​

Documentation Internationalization​

2026-01-02​

Lovrabet SDK​

2025-12-29 🎉 v1.2.0 Major Release​

Lovrabet SDK v1.2.0​

Lovrabet CLI v1.2.0​

Lovrabet MCP v1.2.0​

2025-12-03​

Lovrabet SDK​

2025-11-21​

Lovrabet SDK​

2025-11-15​

Lovrabet SDK​

2025-11-11​

Lovrabet SDK​

2025-11-04​

Lovrabet CLI​

2025-10-25​

OpenAPI Documentation​

Lovrabet CLI​

Lovrabet SDK​

2025-10-18​

Lovrabet SDK​

Lovrabet CLI​

2025-10-17​

Lovrabet CLI​

2025-10-16​

Lovrabet SDK​

Lovrabet CLI​

2025-10-12​

Java OpenSDK​

Documentation Experience Optimization​

Content Completion​

Usage Instructions​

2026-07-17

Rabetbase CLI

Lovrabet Runtime CLI

2026-06-30

Rabetbase CLI

2026-06-13

Rabetbase CLI

2026-06-03

Rabetbase CLI

Lovrabet Runtime CLI

TypeScript SDK

2026-05-19

Rabetbase CLI

Lovrabet Runtime CLI

2026-04-28

Lovrabet Runtime CLI

2026-04-20

Lovrabet Runtime CLI

2026-04-18

Rabetbase CLI

2026-04-15

Rabetbase CLI

2026-04-13

Lovrabet Runtime CLI

2026-04-12

TypeScript SDK

Lovrabet Runtime CLI

Rabetbase CLI

2026-04-09

Rabetbase CLI

2026-04-06

Rabetbase CLI

2026-04-04

Rabetbase CLI 2.0

TypeScript SDK

2026-03-26

Lovrabet CLI

Lovrabet SDK

Lovrabet CLI

2026-02-12

Documentation Restructure

Lovrabet CLI

Lovrabet SDK

2026-01-26

Lovrabet SDK

Lovrabet Toolchain

Documentation Internationalization

2026-01-02

Lovrabet SDK

2025-12-29 🎉 v1.2.0 Major Release

Lovrabet SDK v1.2.0

Lovrabet CLI v1.2.0

Lovrabet MCP v1.2.0

2025-12-03

Lovrabet SDK

2025-11-21

Lovrabet SDK

2025-11-15

Lovrabet SDK

2025-11-11

Lovrabet SDK

2025-11-04

Lovrabet CLI

2025-10-25

OpenAPI Documentation

Lovrabet CLI

Lovrabet SDK

2025-10-18

Lovrabet SDK

Lovrabet CLI

2025-10-17

Lovrabet CLI

2025-10-16

Lovrabet SDK

Lovrabet CLI

2025-10-12

Java OpenSDK

Documentation Experience Optimization

Content Completion

Usage Instructions