refactor: update README and restructure kernel package; remove registry and loader, add ObjectOS plugin

Author: hotlong

packages/kernel/README.md

@@ -1,15 +1,13 @@
 # @objectos/kernel
 
-The metadata management system for ObjectOS. This package provides a generic framework for discovering, loading, and managing metadata from various sources (files, npm packages, etc.).
-
-While it includes plugins specifically for ObjectOS schemas (Objects, Apps, Hooks), it is designed to be extensible for any metadata-driven application.
+The core runtime for ObjectOS, extending ObjectQL with application-specific capabilities.
 
 ## Features
 
-- **MetadataRegistry**: A central in-memory store for all loaded metadata.
-- **MetadataLoader**: A plugin-based file scanner that populates the registry.
-- **Dynamic Loading**: Support for loading metadata from local directories or NPM packages at runtime.
-- **ObjectQL Plugins**: Built-in support for loading `.object.yml`, `.app.yml`, `.hook.ts`, etc.
+- **ObjectOS Runtime**: Extends `ObjectQL` to provide a full application kernel.
+- **App Metadata**: Built-in support for loading `.app.yml` for application configuration and navigation.
+- **Data Loading**: Built-in support for loading `.data.yml` for seed data.
+- **MetadataRegistry**: Inherits the central metadata store from ObjectQL.
 
 ## Installation
 
@@ -21,123 +19,59 @@ npm install @objectos/kernel
 
 ### Basic Usage
 
+`ObjectOS` is a drop-in replacement for `ObjectQL`. It automatically registers plugins to handle ObjectOS specific metadata formats.
+
 ```typescript
-import { MetadataRegistry, MetadataLoader } from '@objectos/kernel';
-
-const registry = new MetadataRegistry();
-const loader = new MetadataLoader(registry);
-
-// Register custom plugin (optional)
-loader.use({
-    name: 'custom-report',
-    glob: ['**/*.report.yml'],
-    handler: (ctx) => {
-        // parsing logic...
-        ctx.registry.register('report', { ... });
+import { ObjectOS } from '@objectos/kernel';
+
+const kernel = new ObjectOS({
+    datasources: {
+        'default': {
+             client: 'sqlite3',
+             connection: { filename: ':memory:' }
+        }
     }
 });
 
-// Load from a directory
-loader.load('/path/to/project');
+// Initialize (connects to DB, loads plugins)
+await kernel.init();
 
-// Access metadata
-const reports = registry.list('report');
+// Use standard ObjectQL methods
+const users = await kernel.find('user', {});
 ```
 
-### Loading ObjectQL Schemas
-
-If you are building a system that needs to understand ObjectQL schemas without running the full ORM:
-
-```typescript
-import { MetadataRegistry, MetadataLoader, registerObjectQLPlugins } from '@objectos/kernel';
-
-const registry = new MetadataRegistry();
-const loader = new MetadataLoader(registry);
-
-// Register standard ObjectQL plugins (objects, apps, hooks, data)
-registerObjectQLPlugins(loader);
+### Metadata Loading
+
+The kernel automatically scans for:
+- `*.object.yml` (Standard ObjectQL)
+- `*.app.yml` (ObjectOS Apps)
+- `*.data.yml` (ObjectOS Data Seeding)
+
+```yaml
+# my-app.app.yml
+code: my_crm
+name: CRM
+icon: users
+menu:
+  - type: header
+    label: Sales
+  - type: object
+    object: lead
+```
 
-// Load standard schemas
-loader.load('./src');
+## API
 
-const objects = registry.list('object');
-console.log(objects.map(o => o.name));
-```
+### `ObjectOS`
 
-### Working with App Metadata and Menus
+Extends `ObjectQL` class.
 
-Apps can define custom navigation menus, similar to Airtable interfaces:
+- `constructor(config)`
+  - `config.datasources`: Database connections.
+  - `config.packages`: List of NPM packages to scan for metadata.
 
-```typescript
-import { 
-    MetadataRegistry, 
-    MetadataLoader, 
-    registerObjectQLPlugins, 
-    AppConfig, 
-    AppMenuItem,
-    isAppMenuSection 
-} from '@objectos/kernel';
-
-const registry = new MetadataRegistry();
-const loader = new MetadataLoader(registry);
-
-registerObjectQLPlugins(loader);
-loader.load('./src');
-
-// Get app configuration
-const app = registry.get('app', 'MyApp') as AppConfig;
-
-if (app && app.menu) {
-    // Render menu sections or items
-    app.menu.forEach((entry) => {
-        // Use type guard to determine if it's a section or direct item
-        if (isAppMenuSection(entry)) {
-            // It's a menu section
-            console.log(`Section: ${entry.label || 'Unnamed'}`);
-            console.log(`  Collapsible: ${entry.collapsible}`);
-            
-            entry.items.forEach((item) => {
-                renderMenuItem(item);
-            });
-        } else {
-            // It's a direct menu item
-            renderMenuItem(entry);
-        }
-    });
-}
-
-function renderMenuItem(item: AppMenuItem) {
-    console.log(`  - ${item.label} (${item.type || 'page'})`);
-    
-    // Handle different menu item types
-    switch (item.type) {
-        case 'object':
-            console.log(`    Object: ${item.object}`);
-            break;
-        case 'page':
-            console.log(`    Page: ${item.url}`);
-            break;
-        case 'url':
-            console.log(`    URL: ${item.url}`);
-            break;
-    }
-    
-    if (item.badge) {
-        console.log(`    Badge: ${item.badge}`);
-    }
-}
-```
+### Plugins
 
-## API
+Internal plugins are automatically registered:
 
-### `MetadataRegistry`
-- `register(type, metadata)`
-- `unregister(type, id)`
-- `unregisterPackage(packageName)`
-- `get(type, id)`
-- `list(type)`
-
-### `MetadataLoader`
-- `use(plugin)`
-- `load(dir)`
-- `loadPackage(packageName)`
+- **AppPlugin**: Loads `**/*.app.yml`
+- **DataPlugin**: Loads `**/*.data.yml`

packages/kernel/src/index.ts

@@ -1,5 +1,3 @@
-export * from './registry';
-export * from './loader';
 export * from './objectos';
 
 // Re-export specific types if needed to avoid conflicts

packages/kernel/src/plugins/objectql.ts

@@ -0,0 +1,56 @@
+import * as yaml from 'js-yaml';
+import * as path from 'path';
+
+export const ObjectOSPlugin = {
+    name: 'objectos-core',
+    setup(app: any) {
+        // Apps
+        app.addLoader({
+            name: 'app',
+            glob: ['**/*.app.yml', '**/*.app.yaml'],
+            handler: (ctx: any) => {
+                try {
+                    const doc = yaml.load(ctx.content) as any;
+                    const id = doc.code || doc.id || doc.name;
+                    if (id) {
+                        ctx.registry.register('app', {
+                            type: 'app',
+                            id: id,
+                            path: ctx.file,
+                            package: ctx.packageName,
+                            content: doc
+                        });
+                    }
+                } catch (e) {
+                     console.error(`Error loading app from ${ctx.file}:`, e);
+                }
+            }
+        });
+
+        // Data
+        app.addLoader({
+            name: 'data',
+            glob: ['**/*.data.yml', '**/*.data.yaml'],
+            handler: (ctx: any) => {
+                try {
+                    const content = ctx.content;
+                    const data = yaml.load(content);
+                    if (!Array.isArray(data)) return;
+
+                    const basename = path.basename(ctx.file);
+                    const objectName = basename.replace(/\.data\.ya?ml$/, '');
+                    
+                    const entry = ctx.registry.getEntry('object', objectName);
+                    if (entry) {
+                        const config = entry.content as any;
+                        config.data = data; 
+                    } else {
+                        console.warn(`Found data for unknown object '${objectName}' in ${ctx.file}`);
+                    }
+                } catch (e) {
+                    console.error(`Error loading data from ${ctx.file}:`, e);
+                }
+            }
+        });
+    }
+}