@aiderdesk/aiderdesk 0.61.0 → 0.61.1

package/out/resources/skills/extension-creator/assets/templates/ui-component-external.ts.template

@@ -0,0 +1,91 @@
+/**
+ * {{EXTENSION_NAME}} Extension
+ *
+ * {{DESCRIPTION}}
+ * 
+ * This extension uses external JSX files for UI components.
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import type { 
+  Extension, 
+  ExtensionContext, 
+  UIComponentDefinition 
+} from '@aiderdesk/extensions';
+
+interface ComponentData {
+  // Define data structure passed to component
+  message: string;
+  count: number;
+}
+
+export default class {{CLASS_NAME}}Extension implements Extension {
+  static metadata = {
+    name: '{{EXTENSION_NAME}}',
+    version: '1.0.0',
+    description: '{{DESCRIPTION}}',
+    author: '{{AUTHOR}}',
+    capabilities: ['ui'],
+  };
+
+  private state = {
+    count: 0,
+    message: 'Hello!',
+  };
+
+  async onLoad(context: ExtensionContext): Promise<void> {
+    context.log('{{EXTENSION_NAME}} extension loaded', 'info');
+  }
+
+  getUIComponents(_context: ExtensionContext): UIComponentDefinition[] {
+    // Load JSX from external file
+    const jsx = readFileSync(join(__dirname, './Component.jsx'), 'utf-8');
+    
+    return [
+      {
+        id: '{{COMPONENT_ID}}',
+        placement: '{{PLACEMENT}}',
+        jsx,
+        loadData: true,
+        noDataCache: false, // Set to true if data should always be fresh
+      },
+    ];
+  }
+
+  async getUIExtensionData(
+    componentId: string,
+    _context: ExtensionContext
+  ): Promise<ComponentData | undefined> {
+    if (componentId === '{{COMPONENT_ID}}') {
+      return {
+        message: this.state.message,
+        count: this.state.count,
+      };
+    }
+    return undefined;
+  }
+
+  async executeUIExtensionAction(
+    componentId: string,
+    action: string,
+    args: unknown[],
+    context: ExtensionContext
+  ): Promise<unknown> {
+    if (componentId !== '{{COMPONENT_ID}}') return;
+
+    if (action === 'increment') {
+      this.state.count++;
+      context.triggerUIDataRefresh('{{COMPONENT_ID}}');
+      return { success: true, count: this.state.count };
+    }
+
+    if (action === 'set-message') {
+      this.state.message = args[0] as string;
+      context.triggerUIDataRefresh('{{COMPONENT_ID}}');
+      return { success: true };
+    }
+
+    return undefined;
+  }
+}

package/out/resources/skills/extension-creator/assets/templates/ui-component.ts.template

@@ -0,0 +1,79 @@
+/**
+ * {{EXTENSION_NAME}} Extension
+ *
+ * {{DESCRIPTION}}
+ */
+
+import type { 
+  Extension, 
+  ExtensionContext, 
+  UIComponentDefinition 
+} from '@aiderdesk/extensions';
+
+export default class {{CLASS_NAME}}Extension implements Extension {
+  static metadata = {
+    name: '{{EXTENSION_NAME}}',
+    version: '1.0.0',
+    description: '{{DESCRIPTION}}',
+    author: '{{AUTHOR}}',
+    capabilities: ['ui'],
+  };
+
+  async onLoad(context: ExtensionContext): Promise<void> {
+    context.log('{{EXTENSION_NAME}} extension loaded', 'info');
+  }
+
+  getUIComponents(_context: ExtensionContext): UIComponentDefinition[] {
+    return [
+      {
+        id: '{{COMPONENT_ID}}',
+        placement: '{{PLACEMENT}}', // e.g., 'task-status-bar-right'
+        jsx: `
+          ({ data, task, ui }) => {
+            // Component implementation
+            return (
+              <div className="flex items-center gap-2 text-sm">
+                <span>Hello from {{EXTENSION_NAME}}</span>
+              </div>
+            );
+          }
+        `,
+        loadData: false, // Set to true if component needs data
+      },
+    ];
+  }
+
+  // Optional: Provide data to components
+  async getUIExtensionData(
+    componentId: string,
+    _context: ExtensionContext
+  ): Promise<unknown> {
+    if (componentId === '{{COMPONENT_ID}}') {
+      return {
+        // Data to pass to component
+        message: 'Hello from extension!',
+      };
+    }
+    return undefined;
+  }
+
+  // Optional: Handle actions from components
+  async executeUIExtensionAction(
+    componentId: string,
+    action: string,
+    args: unknown[],
+    context: ExtensionContext
+  ): Promise<unknown> {
+    if (componentId === '{{COMPONENT_ID}}') {
+      if (action === 'my-action') {
+        context.log('Action executed with args: ' + JSON.stringify(args), 'info');
+        
+        // Trigger UI refresh if needed
+        context.triggerUIDataRefresh('{{COMPONENT_ID}}');
+        
+        return { success: true };
+      }
+    }
+    return undefined;
+  }
+}

package/out/resources/skills/extension-creator/references/command-definition.md

@@ -0,0 +1,170 @@
+# Command Definition
+
+Structure for defining slash commands in extensions.
+
+## CommandDefinition Interface
+
+```typescript
+interface CommandDefinition {
+  name: string;           // Command name (without /)
+  description: string;    // Shown in command palette
+  arguments?: CommandArgument[];
+  execute(args: string[], context: ExtensionContext): Promise<void>;
+}
+
+interface CommandArgument {
+  description: string;
+  required: boolean;
+  options?: string[];     // Predefined options for autocomplete
+}
+```
+
+## Simple Command Example
+
+```typescript
+const HELLO_COMMAND: CommandDefinition = {
+  name: 'hello',
+  description: 'Say hello',
+  arguments: [
+    { description: 'Name to greet', required: true }
+  ],
+  async execute(args: string[], context: ExtensionContext): Promise<void> {
+    const taskContext = context.getTaskContext();
+    if (!taskContext) {
+      context.log('No task context', 'error');
+      return;
+    }
+
+    const name = args[0] || 'World';
+    taskContext.addLogMessage('info', `Hello, ${name}!`);
+  }
+};
+```
+
+## Command with Options
+
+```typescript
+const THEME_COMMAND: CommandDefinition = {
+  name: 'theme',
+  description: 'Switch the AiderDesk theme',
+  arguments: [
+    {
+      description: 'Name of the theme to apply',
+      required: true,
+      options: ['dark', 'light', 'ocean', 'forest']
+    }
+  ],
+  async execute(args: string[], context: ExtensionContext): Promise<void> {
+    const taskContext = context.getTaskContext();
+    const themeName = args[0];
+
+    if (!themeName) {
+      taskContext?.addLogMessage('warning', 'Usage: /theme <theme-name>');
+      return;
+    }
+
+    await context.updateSettings({ theme: themeName });
+    taskContext?.addLogMessage('info', `Theme changed to: ${themeName}`);
+  }
+};
+```
+
+## Command with Config
+
+```typescript
+// In extension class
+private config: MyConfig;
+
+async onLoad(context: ExtensionContext): Promise<void> {
+  this.config = await loadConfig();
+}
+
+getCommands(_context: ExtensionContext): CommandDefinition[] {
+  return [{
+    name: 'my-setting',
+    description: 'Get or set a value',
+    arguments: [
+      { description: 'Value to set (optional)', required: false }
+    ],
+    execute: async (args: string[], context: ExtensionContext) => {
+      const taskContext = context.getTaskContext();
+      const [value] = args;
+
+      if (!value) {
+        // Show current value
+        taskContext?.addLogMessage('info', `Current: ${this.config.mySetting}`);
+      } else {
+        // Update value
+        this.config.mySetting = value;
+        await saveConfig(this.config);
+        taskContext?.addLogMessage('info', `Updated to: ${value}`);
+      }
+    }
+  }];
+}
+```
+
+## Multi-Argument Commands
+
+```typescript
+const CONFIG_COMMAND: CommandDefinition = {
+  name: 'config',
+  description: 'Manage extension settings',
+  arguments: [
+    { description: 'Setting name', required: true },
+    { description: 'Setting value', required: false }
+  ],
+  async execute(args: string[], context: ExtensionContext): Promise<void> {
+    const taskContext = context.getTaskContext();
+    const [setting, value] = args;
+
+    if (!setting) {
+      // Show all settings
+      const config = await loadConfig();
+      taskContext?.addLogMessage('info', `Settings:\n${JSON.stringify(config, null, 2)}`);
+      return;
+    }
+
+    if (!value) {
+      // Show specific setting
+      const config = await loadConfig();
+      taskContext?.addLogMessage('info', `${setting}: ${config[setting]}`);
+      return;
+    }
+
+    // Update setting
+    const config = await loadConfig();
+    config[setting] = value;
+    await saveConfig(config);
+    taskContext?.addLogMessage('info', `${setting} updated to: ${value}`);
+  }
+};
+```
+
+## Error Handling
+
+```typescript
+execute: async (args: string[], context: ExtensionContext) => {
+  const taskContext = context.getTaskContext();
+  if (!taskContext) {
+    context.log('No active task context', 'error');
+    return;
+  }
+
+  try {
+    // Command logic
+  } catch (error) {
+    taskContext.addLogMessage('error', `Command failed: ${error}`);
+  }
+}
+```
+
+## Registering Commands
+
+```typescript
+class MyExtension implements Extension {
+  getCommands(_context: ExtensionContext): CommandDefinition[] {
+    return [COMMAND_1, COMMAND_2];
+  }
+}
+```