Add AI agent and app generation docs, update navigation

Introduces new documentation for generating apps with AI and building autonomous data agents. Updates navigation in VitePress config to include new tutorials and reorganizes sidebar structure. Enhances the AI coding assistant guide with usage strategies and adds an IDE setup guide for improved developer experience.

Author: hotlong

docs/.vitepress/config.mts

@@ -37,6 +37,7 @@ export default defineConfig({
             { text: '1. Task Manager (Beginner)', link: '/tutorials/task-manager' },
             { text: '2. Micro-CRM (Intermediate)', link: '/tutorials/crm-system' },
             { text: '3. Federated Data (Advanced)', link: '/tutorials/federation' },
+            { text: '4. AI Data Agent (AI-Native)', link: '/tutorials/ai-agent' },
           ]
         }
       ],
@@ -60,7 +61,8 @@ export default defineConfig({
            text: 'AI-Native Ecosystem',
            items: [
              { text: 'Overview', link: '/ai/' },
-             { text: 'Building AI Apps', link: '/ai/building-apps' },
+             { text: 'Generating Apps (Zero-Shot)', link: '/ai/generating-apps' },
+             { text: 'Building AI Agents', link: '/ai/building-apps' },
              { text: 'AI Coding Assistant', link: '/ai/coding-assistant' },
            ]
          }
@@ -69,34 +71,39 @@ export default defineConfig({
       // Sidebar for Guide section
       '/guide/': [
         {
-          text: 'Start Here',
+          text: 'Getting Started',
           items: [
             { text: 'Introduction', link: '/guide/' },
             { text: 'Why ObjectQL?', link: '/guide/architecture/why-objectql' },
             { text: 'Quick Start', link: '/guide/getting-started' },
-            { text: '🤖 AI Coding Setup', link: '/ai/coding-assistant' },
+            { text: 'IDE Setup', link: '/guide/ide-setup' },
           ]
         },
         {
-          text: 'Core Fundamentals',
+          text: 'Data & Logic Layers',
           items: [
             { text: 'Data Modeling', link: '/guide/data-modeling' },
-            { text: 'Page Metadata', link: '/guide/page-metadata' },
-            { text: 'Metadata Organization', link: '/guide/metadata-organization' },
             { text: 'Querying Data', link: '/guide/querying' },
-            { text: 'Business Logic', link: '/guide/logic-hooks' },
+            { text: 'Business Logic (Hooks)', link: '/guide/logic-hooks' },
+            { text: 'Custom Actions (RPC)', link: '/guide/logic-actions' },
           ]
         },
         {
-          text: 'Advanced Features',
+          text: 'System Architecture',
           items: [
+            { text: 'File Organization', link: '/guide/metadata-organization' },
             { text: 'Microservices & Federation', link: '/guide/microservices' },
-            { text: 'Custom Actions (RPC)', link: '/guide/logic-actions' },
             { text: 'Plugin System', link: '/guide/plugins' },
           ]
         },
         {
-          text: 'Integration & Deployment',
+          text: 'Low-Code UI',
+          items: [
+            { text: 'Page & Layouts', link: '/guide/page-metadata' },
+          ]
+        },
+        {
+          text: 'Operations & Deployment',
           items: [
             { text: 'Server Integration', link: '/guide/server-integration' },
             { text: 'Database Drivers', link: '/guide/drivers/' },

docs/ai/coding-assistant.md

@@ -2,13 +2,47 @@
 
 One of the core design goals of ObjectQL is to be the **most LLM-friendly backend protocol**.
 
-If you are using **Cursor**, **GitHub Copilot Chat**, **Windsurf**, or **ChatGPT** for development, please copy the following **System Prompt** into your AI configuration or project rules (e.g., `.cursorrules`). This allows the AI to accurately understand ObjectQL's syntax and best practices.
+If you are using **Cursor**, **GitHub Copilot Chat**, **Windsurf**, or **ChatGPT** for development, please copy the following **System Prompt** into your AI configuration or project rules (e.g., `.cursorrules`). 
+This allows the AI to accurately understand ObjectQL's syntax and best practices.
+
+## How to Use Effectively
+
+### 1. "Before" vs "After"
+
+Without this prompt, Copilot assumes you are using a generic ORM (like TypeORM) and might hallucinate classes:
+
+> ❌ **Bad AI Output:**
+> `await getConnection().manager.find(Todo, { where: { priority: 'high' } })`
+> *(ObjectQL doesn't use classes or `getConnection`)*
+
+With the System Prompt, it understands the **Context + Repository** pattern:
+
+> ✅ **Good AI Output:**
+> `await ctx.object('todo').find({ filters: [['priority', '=', 'high']] })`
+
+### 2. Prompting Strategy
+
+When asking the AI to write code, be explicit about the schema you have defined.
+
+**User Prompt:**
+> "Write an API route to complete a todo item. The object is named 'todo' and has a 'completed' boolean field."
+
+**AI Response (with System Prompt):**
+```typescript
+app.post('/api/todo/:id/complete', async (req, res) => {
+    const { id } = req.params;
+    // Creates a context for the current user (if auth is handled)
+    const ctx = app.createContext({ userId: req.user?.id });
+    
+    await ctx.object('todo').update(id, { completed: true });
+    res.json({ success: true });
+});
+```
 
 ## Standard System Prompt
 
 Click the copy button in the top right to get the full prompt:
-
-````text
+`text
 You are an expert developer specializing in **ObjectQL**, a metadata-driven, low-code backend engine.
 
 ### Core Principles

docs/ai/generating-apps.md

@@ -0,0 +1,111 @@
+# Generating Apps with AI
+
+Because ObjectQL applications are defined primarily by **Metadata** (YAML/JSON) rather than **Code** (Classes/Functions), LLMs can generate complete, working backends in a single pass.
+
+This is "Zero-Shot Microservice Generation".
+
+## The Workflow
+
+1.  **Prompt**: You ask the AI to design a system (e.g., "A Property Management System").
+2.  **Generation**: The AI outputs a set of `*.object.yml` files.
+3.  **Execution**: You drop these files into your project, and the API is instantly live.
+
+## Prompting Guide
+
+To get the best results, use a prompt that enforces the ObjectQL schema format.
+
+### Template
+
+> **Act as an ObjectQL Architect.**
+>
+> I need a backend for **[APP_DESCRIPTION]**.
+>
+> Please generate the object definitions in YAML format.
+> Follow these rules:
+> 1. Use standard types: `text`, `number`, `boolean`, `select`, `date`, `lookup`.
+> 2. For relationships, use `type: lookup` with `reference_to: <object_name>`.
+> 3. Include `required: true` for important fields.
+> 4. Suggest 2-3 essential objects.
+>
+> Output the YAML for each object in a separate code block.
+
+### Example: Real Estate CRM
+
+**User:**
+> "I need a backend for a Real Estate Agency to track Properties and Agents."
+
+**AI Output:**
+
+```yaml
+# agent.object.yml
+name: agent
+fields:
+  name:
+    type: text
+    required: true
+  email:
+    type: email
+    required: true
+  phone:
+    type: phone
+  license_number:
+    type: text
+  status:
+    type: select
+    options: [active, inactive]
+```
+
+```yaml
+# property.object.yml
+name: property
+fields:
+  address:
+    type: textarea
+    required: true
+  price:
+    type: currency
+  bedrooms:
+    type: number
+  bathrooms:
+    type: number
+  listing_agent:
+    type: lookup
+    reference_to: agent
+  status:
+    type: select
+    options: [for_sale, sold, pending]
+```
+
+## Automating the Process
+
+You can build tools to automate this loop.
+
+### 1. The Generator Script
+Imagine a simple CLI tool that takes a user description and writes files to disk.
+
+```typescript
+import { generateSchema } from './my-llm-service'; // Wrapper around OpenAI
+
+async function main() {
+    const description = process.argv[2];
+    const schemas = await generateSchema(description);
+    
+    for (const schema of schemas) {
+        fs.writeFileSync(`${schema.name}.object.yml`, yaml.dump(schema));
+    }
+    
+    console.log("App generated! Starting server...");
+}
+```
+
+### 2. Hot Reloading
+Since ObjectQL can load metadata at runtime, you can build **Self-Evolving Apps**.
+1.  The App receives a request: "Add a 'renovation_date' field to Property."
+2.  The App calls an LLM to update the YAML.
+3.  The App reloads the metadata registry.
+4.  The new field is immediately available via API.
+
+## Summary
+
+ObjectQL turns software development into a **Content Generation** task. 
+Instead of generating complex imperative code (which is brittle), you generate simple declarative configurations (which are robust).

docs/ai/index.md

@@ -7,6 +7,14 @@ ObjectQL resides at the intersection of Data and Artificial Intelligence. It is
 
 ## Overview
 
+### ✨ Generating Apps
+Turn natural language into full backend systems instantly. Because ObjectQL uses declarative YAML/JSON, LLMs can "write" software by simply generating configuration files.
+
+*   [Zero-Shot Generation](/ai/generating-apps)
+*   [Prompt Templates](/ai/generating-apps#prompting-guide)
+
+[Start Generating →](/ai/generating-apps)
+
 ### 🏗️ Building AI Apps
 Learn how to use ObjectQL as the data engine for your RAG (Retrieval-Augmented Generation) applications, semantic search, and AI agents.
 

docs/guide/ide-setup.md

@@ -0,0 +1,24 @@
+# IDE Setup
+
+To get the best experience developing with ObjectQL, we recommend Visual Studio Code with the following configuration.
+
+## Visual Studio Code
+
+We recommend using [VS Code](https://code.visualstudio.com/) as your primary editor.
+
+### Recommended Extensions
+
+**1. YAML (Red Hat)**  
+Essential for editing `*.object.yml` files. It provides syntax highlighting and validation.  
+[Install Extension](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-yaml)
+
+**2. JSON (Official)**  
+For editing configuration files.
+
+## AI Assistant Configuration
+
+ObjectQL is designed to be "AI-Native". The most efficient way to write schema and hooks is by pairing with an LLM.
+
+We strongly recommend configuring your AI Coding Assistant (GitHub Copilot, Cursor, Windsurf) with our specialized System Prompts. These prompts teach the AI about ObjectQL's metadata protocol.
+
+[👉 Go to AI Coding Assistant Guide](/ai/coding-assistant)