@aiderdesk/aiderdesk 0.61.0 → 0.62.0

package/out/resources/skills/extension-creator/assets/templates/ConfigComponent.jsx.template

@@ -0,0 +1,38 @@
+/**
+ * Config Component for {{EXTENSION_NAME}}
+ *
+ * Renders a settings UI in the ExtensionSettingsDialog.
+ *
+ * Available props:
+ * - config: Current config data from getConfigData()
+ * - updateConfig: Callback to mutate in-memory config (does NOT persist)
+ * - ui: UI components (Button, Checkbox, Input, Select, TextArea, etc.) — prefer these over raw HTML
+ * - icons: React Icons organized by set (Fi, Hi, Cg, etc.)
+ * - models: Available models
+ * - providers: Available providers
+ * - projectDir: Project directory path
+ * - task: Current TaskData
+ * - mode: Current mode string
+ * - api: ApplicationAPI reference
+ *
+ * Note: React is globally available (use React.useState, React.useEffect, etc.)
+ * Note: Prefer ui.* components over raw HTML elements for consistent styling
+ */
+
+({ config, updateConfig, ui }) => {
+  const { Input } = ui;
+
+  return (
+    <div className="flex flex-col gap-4">
+      <Input
+        label="My Setting Label"
+        value={config?.mySetting || ''}
+        onChange={(value) => updateConfig({ ...config, mySetting: value })}
+        placeholder="Enter a value..."
+      />
+      <p className="text-xs text-text-secondary -mt-2">
+        Description of what this setting controls and how it affects the extension behavior.
+      </p>
+    </div>
+  );
+};

package/out/resources/skills/extension-creator/assets/templates/folder-extension/config.ts.template

@@ -0,0 +1,29 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export interface {EXTENSION_NAME}Config {
+  // Add config properties
+}
+
+const DEFAULT_CONFIG: {EXTENSION_NAME}Config = {
+  // Add default values
+};
+
+const CONFIG_FILE = path.join(__dirname, 'config.json');
+
+export const loadConfig = async (): Promise<{EXTENSION_NAME}Config> => {
+  try {
+    const data = await fs.readFile(CONFIG_FILE, 'utf-8');
+    const config = JSON.parse(data);
+    return { ...DEFAULT_CONFIG, ...config };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+};
+
+export const saveConfig = async (config: {EXTENSION_NAME}Config): Promise<void> => {
+  await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+};

package/out/resources/skills/extension-creator/assets/templates/folder-extension/index.ts.template

@@ -0,0 +1,42 @@
+/**
+ * {EXTENSION_NAME} Extension
+ *
+ * {DESCRIPTION}
+ */
+
+import type { Extension, ExtensionContext, AgentStartedEvent, CommandDefinition } from '@aiderdesk/extensions';
+
+import { loadConfig, saveConfig } from './config';
+import type { {EXTENSION_NAME}Config } from './config';
+
+const DEFAULT_CONFIG: {EXTENSION_NAME}Config = {
+  // Add default config values
+};
+
+export default class {CLASS_NAME} implements Extension {
+  static metadata = {
+    name: '{EXTENSION_NAME}',
+    version: '1.0.0',
+    description: '{DESCRIPTION}',
+    author: '{AUTHOR}',
+    capabilities: ['events', 'commands'],
+  };
+
+  private config: {EXTENSION_NAME}Config = DEFAULT_CONFIG;
+
+  async onLoad(context: ExtensionContext): Promise<void> {
+    context.log('{EXTENSION_NAME} Extension loaded', 'info');
+    this.config = await loadConfig();
+  }
+
+  getCommands(_context: ExtensionContext): CommandDefinition[] {
+    return [
+      // Add commands here
+    ];
+  }
+
+  async onAgentStarted(event: AgentStartedEvent, context: ExtensionContext): Promise<void | Partial<AgentStartedEvent>> {
+    // Handle event
+    return undefined;
+  }
+}

package/out/resources/skills/extension-creator/assets/templates/folder-extension/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "{extension-name}",
+  "version": "1.0.0",
+  "description": "{DESCRIPTION}",
+  "main": "index.ts",
+  "keywords": ["aiderdesk", "extension"],
+  "author": "{AUTHOR}",
+  "license": "MIT",
+  "dependencies": {
+    // Add npm dependencies here
+  }
+}

package/out/resources/skills/extension-creator/assets/templates/folder-extension/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "lib": ["ES2020"],
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "forceConsistentCasingInFileNames": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist", "__tests__"]
+}

package/out/resources/skills/extension-creator/assets/templates/folder-extension-with-config/index.ts.template

@@ -0,0 +1,80 @@
+/**
+ * {EXTENSION_NAME} Extension
+ *
+ * {DESCRIPTION}
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import type { Extension, ExtensionContext } from '@aiderdesk/extensions';
+
+// Load config JSX at module level (read once, reused on every getConfigComponent call)
+const configComponentJsx = readFileSync(join(__dirname, './ConfigComponent.jsx'), 'utf-8');
+
+interface {EXTENSION_NAME}Config {
+  // Add your config properties here
+  mySetting: string;
+  enabled: boolean;
+}
+
+const DEFAULT_CONFIG: {EXTENSION_NAME}Config = {
+  mySetting: '',
+  enabled: true,
+};
+
+export default class {CLASS_NAME} implements Extension {
+  static metadata = {
+    name: '{EXTENSION_NAME}',
+    version: '1.0.0',
+    description: '{DESCRIPTION}',
+    author: '{AUTHOR}',
+    capabilities: ['context'],
+    // iconUrl: 'https://...',
+  };
+
+  private configPath: string;
+
+  constructor() {
+    this.configPath = join(__dirname, 'config.json');
+  }
+
+  async onLoad(context: ExtensionContext): Promise<void> {
+    context.log('{EXTENSION_NAME} Extension loaded', 'info');
+  }
+
+  // --- Config Component API ---
+
+  getConfigComponent(_context: ExtensionContext): string {
+    return configComponentJsx;
+  }
+
+  async getConfigData(_context: ExtensionContext): Promise<{EXTENSION_NAME}Config> {
+    try {
+      if (existsSync(this.configPath)) {
+        const data = readFileSync(this.configPath, 'utf-8');
+        const parsed = JSON.parse(data);
+        return { ...DEFAULT_CONFIG, ...parsed };
+      }
+    } catch {
+      // Ignore errors, fall back to defaults
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+
+  async saveConfigData(configData: unknown, _context: ExtensionContext): Promise<unknown> {
+    const merged: {EXTENSION_NAME}Config = {
+      ...DEFAULT_CONFIG,
+      ...configData as Partial<{EXTENSION_NAME}Config>,
+    };
+    writeFileSync(this.configPath, JSON.stringify(merged, null, 2), 'utf-8');
+    return merged;
+  }
+
+  // --- Event Handlers / Other Methods ---
+
+  // async onRuleFilesRetrieved(event: RuleFilesRetrievedEvent, context: ExtensionContext) {
+  //   const config = await this.getConfigData(context);
+  //   Use config values in your logic...
+  // }
+}

package/out/resources/skills/extension-creator/assets/templates/single-file.ts.template

@@ -0,0 +1,30 @@
+/**
+ * {EXTENSION_NAME} Extension
+ *
+ * {DESCRIPTION}
+ */
+
+import type { Extension, ExtensionContext } from '@aiderdesk/extensions';
+
+export default class {CLASS_NAME} implements Extension {
+  static metadata = {
+    name: '{EXTENSION_NAME}',
+    version: '1.0.0',
+    description: '{DESCRIPTION}',
+    author: '{AUTHOR}',
+    capabilities: ['{CAPABILITY}'],
+  };
+
+  async onLoad(context: ExtensionContext): Promise<void> {
+    context.log('{EXTENSION_NAME} Extension loaded', 'info');
+  }
+
+  // Add methods as needed:
+  // - getCommands()
+  // - getTools()
+  // - getAgents()
+  // - getModes()
+  // - onAgentStarted()
+  // - onToolCalled()
+  // etc.
+}

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];
+  }
+}
+```