Auto-Register Plugins for Custom Entity Schemas - Enable Hot-Reload Slash Commands #447

// 1. User creates schema via AI
await schemaService.createSchema({ id: 'invoice', fields: [...] });

// 2. Developer must manually register plugin (users can't do this!)
pluginRegistry.register({
  id: 'invoice',
  name: 'Invoice',
  config: { slashCommands: [...] }
});

// 3. Only then does "/invoice" appear in slash menu

// 1. User creates schema via AI
await schemaService.createSchema({ id: 'invoice', fields: [...] });

// 2. Plugin auto-registered immediately ✨
// 3. "/invoice" appears in slash menu (no restart needed)

// packages/desktop-app/src/lib/plugins/schema-plugin-loader.ts

export interface SchemaPluginConfig {
  id: string;
  name: string;
  description?: string;
  icon?: string;
}

/**
 * Convert a schema definition into a plugin definition
 */
export function createPluginFromSchema(
  schema: SchemaDefinition,
  schemaId: string
): PluginDefinition {
  return {
    id: schemaId,
    name: schema.content || schemaId,
    config: {
      slashCommands: [
        {
          id: schemaId,
          name: schema.content || schemaId,
          description: schema.properties?.description || `Create ${schema.content || schemaId}`,
          contentTemplate: '',
          nodeType: schemaId,
          priority: 50  // Lower than core types (100), higher than user commands (0)
        }
      ],
      canHaveChildren: true,
      canBeChild: true
    },
    node: {
      // Use generic custom entity component
      lazyLoad: () => import('../design/components/custom-entity-node.svelte')
    }
    // No custom viewer - falls back to BaseNodeViewer
  };
}

/**
 * Register a schema as a plugin immediately
 */
export async function registerSchemaPlugin(schemaId: string): Promise<void> {
  const schema = await schemaService.getSchema(schemaId);
  
  // Don't register core types (already registered in core-plugins.ts)
  if (schema.properties?.is_core === true) {
    return;
  }
  
  const plugin = createPluginFromSchema(schema, schemaId);
  pluginRegistry.register(plugin);
  
  console.log(`[SchemaPluginLoader] Registered plugin for custom entity: ${schemaId}`);
}

/**
 * Unregister a schema plugin
 */
export function unregisterSchemaPlugin(schemaId: string): void {
  pluginRegistry.unregister(schemaId);
  console.log(`[SchemaPluginLoader] Unregistered plugin: ${schemaId}`);
}

// packages/desktop-app/src/lib/plugins/schema-plugin-loader.ts (continued)

/**
 * Initialize schema plugin auto-registration
 * Call this once during app startup
 */
export async function initializeSchemaPluginSystem(): Promise<void> {
  // Register existing custom entity schemas on startup
  await registerExistingSchemas();
  
  // Listen for new schema creation events
  await listen<SchemaCreatedEvent>('schema:created', async (event) => {
    const { schema_id, is_core } = event.payload;
    
    if (!is_core) {
      await registerSchemaPlugin(schema_id);
    }
  });
  
  // Listen for schema deletion events
  await listen<SchemaDeletedEvent>('schema:deleted', (event) => {
    unregisterSchemaPlugin(event.payload.schema_id);
  });
}

/**
 * Register all existing custom entity schemas on app startup
 */
async function registerExistingSchemas(): Promise<void> {
  const schemas = await schemaService.getAllSchemas();
  
  for (const schema of schemas) {
    if (schema.properties?.is_core === false) {
      await registerSchemaPlugin(schema.id);
    }
  }
  
  console.log(`[SchemaPluginLoader] Registered ${schemas.length} custom entity schemas`);
}

<script lang="ts">
  import { onMount } from 'svelte';
  import { initializeSchemaPluginSystem } from '$lib/plugins/schema-plugin-loader';
  
  onMount(async () => {
    await initializeSchemaPluginSystem();
  });
</script>

// schema-plugin-loader.test.ts

describe('createPluginFromSchema', () => {
  it('converts schema to plugin definition', () => {
    const schema = {
      id: 'invoice',
      content: 'Invoice',
      properties: {
        is_core: false,
        description: 'Track invoices with amount and vendor'
      }
    };
    
    const plugin = createPluginFromSchema(schema, 'invoice');
    
    expect(plugin.id).toBe('invoice');
    expect(plugin.name).toBe('Invoice');
    expect(plugin.config.slashCommands).toHaveLength(1);
    expect(plugin.config.slashCommands[0].nodeType).toBe('invoice');
  });
  
  it('skips core types', async () => {
    const coreSchema = {
      properties: { is_core: true }
    };
    
    await registerSchemaPlugin('task');
    // Should not register (core type)
    expect(pluginRegistry.hasPlugin('task')).toBe(true); // Already registered by core
  });
});

describe('Schema plugin auto-registration', () => {
  it('registers plugin when schema created', async () => {
    // Create schema
    await schemaService.createSchema('invoice', fields);
    
    // Wait for event processing
    await waitFor(() => pluginRegistry.hasPlugin('invoice'));
    
    // Verify slash command
    const commands = slashCommandService.getCommands();
    expect(commands.find(c => c.id === 'invoice')).toBeDefined();
  });
  
  it('unregisters plugin when schema deleted', async () => {
    await schemaService.createSchema('invoice', fields);
    await waitFor(() => pluginRegistry.hasPlugin('invoice'));
    
    await schemaService.deleteSchema('invoice');
    await waitFor(() => !pluginRegistry.hasPlugin('invoice'));
    
    const commands = slashCommandService.getCommands();
    expect(commands.find(c => c.id === 'invoice')).toBeUndefined();
  });
});