@useconductor/conductor 1.0.0

package/src/plugins/builtin/calculator.ts

@@ -0,0 +1,178 @@
+import { Plugin, PluginTool } from '../manager.js';
+import { Conductor } from '../../core/conductor.js';
+import { create, type MathJsInstance } from 'mathjs';
+import * as mathjs from 'mathjs';
+
+const math: MathJsInstance = create(mathjs.all, {});
+
+export class CalculatorPlugin implements Plugin {
+  name = 'calculator';
+  description = 'Math expressions, unit conversions, date calculations';
+  version = '1.0.0';
+
+  async initialize(_conductor: Conductor): Promise<void> {}
+  isConfigured(): boolean {
+    return true;
+  }
+
+  getTools(): PluginTool[] {
+    return [
+      {
+        name: 'calc_math',
+        description:
+          'Evaluate a math expression. Supports +, -, *, /, **, %, sqrt(), abs(), sin(), cos(), tan(), log(), ceil(), floor(), round(), PI, E',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            expression: { type: 'string', description: 'Math expression, e.g. "sqrt(144) + 2 ** 3"' },
+          },
+          required: ['expression'],
+        },
+        handler: async (input: { expression: string }) => {
+          try {
+            const result = math.evaluate(input.expression);
+            if (typeof result === 'number' && !isFinite(result)) {
+              throw new Error('Result is not a finite number');
+            }
+            return { expression: input.expression, result };
+          } catch (err: unknown) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Math evaluation failed: ${msg}`);
+          }
+        },
+      },
+      {
+        name: 'calc_convert',
+        description: 'Convert between units. Supports: km/mi/m/ft/in/cm, kg/lb/oz/g, °C/°F/K, L/gal/ml, GB/MB/KB/TB',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            value: { type: 'number', description: 'Value to convert' },
+            from: { type: 'string', description: 'Source unit' },
+            to: { type: 'string', description: 'Target unit' },
+          },
+          required: ['value', 'from', 'to'],
+        },
+        handler: async (input: { value: number; from: string; to: string }) => {
+          const f = input.from.toLowerCase().trim();
+          const t = input.to.toLowerCase().trim();
+          const v = input.value;
+
+          type ConversionTable = Record<string, Record<string, (n: number) => number>>;
+          const conversions: ConversionTable = {
+            km: {
+              m: (n) => n * 1000,
+              mi: (n) => n * 0.621371,
+              ft: (n) => n * 3280.84,
+              cm: (n) => n * 100000,
+              in: (n) => n * 39370.1,
+            },
+            mi: {
+              km: (n) => n * 1.60934,
+              m: (n) => n * 1609.34,
+              ft: (n) => n * 5280,
+              cm: (n) => n * 160934,
+              in: (n) => n * 63360,
+            },
+            m: {
+              km: (n) => n / 1000,
+              mi: (n) => n / 1609.34,
+              ft: (n) => n * 3.28084,
+              cm: (n) => n * 100,
+              in: (n) => n * 39.3701,
+            },
+            ft: {
+              m: (n) => n * 0.3048,
+              km: (n) => n * 0.0003048,
+              mi: (n) => n / 5280,
+              cm: (n) => n * 30.48,
+              in: (n) => n * 12,
+            },
+            cm: {
+              m: (n) => n / 100,
+              km: (n) => n / 100000,
+              ft: (n) => n / 30.48,
+              in: (n) => n / 2.54,
+              mi: (n) => n / 160934,
+            },
+            in: {
+              cm: (n) => n * 2.54,
+              ft: (n) => n / 12,
+              m: (n) => n * 0.0254,
+              km: (n) => n * 0.0000254,
+              mi: (n) => n / 63360,
+            },
+            kg: { lb: (n) => n * 2.20462, oz: (n) => n * 35.274, g: (n) => n * 1000 },
+            lb: { kg: (n) => n * 0.453592, oz: (n) => n * 16, g: (n) => n * 453.592 },
+            oz: { kg: (n) => n * 0.0283495, lb: (n) => n / 16, g: (n) => n * 28.3495 },
+            g: { kg: (n) => n / 1000, lb: (n) => n / 453.592, oz: (n) => n / 28.3495 },
+            c: { f: (n) => (n * 9) / 5 + 32, k: (n) => n + 273.15 },
+            f: { c: (n) => ((n - 32) * 5) / 9, k: (n) => ((n - 32) * 5) / 9 + 273.15 },
+            k: { c: (n) => n - 273.15, f: (n) => ((n - 273.15) * 9) / 5 + 32 },
+            '°c': { '°f': (n) => (n * 9) / 5 + 32, k: (n) => n + 273.15 },
+            '°f': { '°c': (n) => ((n - 32) * 5) / 9, k: (n) => ((n - 32) * 5) / 9 + 273.15 },
+            l: { gal: (n) => n * 0.264172, ml: (n) => n * 1000 },
+            gal: { l: (n) => n * 3.78541, ml: (n) => n * 3785.41 },
+            ml: { l: (n) => n / 1000, gal: (n) => n / 3785.41 },
+            tb: { gb: (n) => n * 1024, mb: (n) => n * 1048576, kb: (n) => n * 1073741824 },
+            gb: { tb: (n) => n / 1024, mb: (n) => n * 1024, kb: (n) => n * 1048576 },
+            mb: { gb: (n) => n / 1024, tb: (n) => n / 1048576, kb: (n) => n * 1024 },
+            kb: { mb: (n) => n / 1024, gb: (n) => n / 1048576, tb: (n) => n / 1073741824 },
+          };
+
+          if (f === t) return { value: v, from: f, to: t, result: v };
+
+          const conv = conversions[f]?.[t];
+          if (!conv)
+            throw new Error(
+              `Cannot convert from "${input.from}" to "${input.to}". Supported: km/mi/m/ft/in/cm, kg/lb/oz/g, C/F/K, L/gal/ml, GB/MB/KB/TB`,
+            );
+
+          return { value: v, from: input.from, to: input.to, result: Number(conv(v).toFixed(6)) };
+        },
+      },
+      {
+        name: 'calc_date',
+        description: 'Calculate days between dates, or add/subtract days from a date',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            date: { type: 'string', description: 'Start date (YYYY-MM-DD) or "today"' },
+            add_days: { type: 'number', description: 'Days to add (negative to subtract)' },
+            end_date: { type: 'string', description: 'End date for difference calculation' },
+          },
+          required: ['date'],
+        },
+        handler: async (input: { date: string; add_days?: number; end_date?: string }) => {
+          const start = input.date === 'today' ? new Date() : new Date(input.date);
+          if (isNaN(start.getTime())) throw new Error(`Invalid date: ${input.date}`);
+
+          if (input.end_date) {
+            const end = input.end_date === 'today' ? new Date() : new Date(input.end_date);
+            if (isNaN(end.getTime())) throw new Error(`Invalid end date: ${input.end_date}`);
+            const diff = Math.round((end.getTime() - start.getTime()) / 86400000);
+            return { start: start.toISOString().split('T')[0], end: end.toISOString().split('T')[0], days: diff };
+          }
+
+          if (input.add_days !== undefined) {
+            const result = new Date(start);
+            result.setDate(result.getDate() + input.add_days);
+            return {
+              start: start.toISOString().split('T')[0],
+              added: input.add_days,
+              result: result.toISOString().split('T')[0],
+              day_of_week: result.toLocaleDateString('en-US', { weekday: 'long' }),
+            };
+          }
+
+          return {
+            date: start.toISOString().split('T')[0],
+            day_of_week: start.toLocaleDateString('en-US', { weekday: 'long' }),
+            unix_timestamp: Math.floor(start.getTime() / 1000),
+            iso: start.toISOString(),
+          };
+        },
+      },
+    ];
+  }
+}

package/src/plugins/builtin/colors.ts

@@ -0,0 +1,201 @@
+import { Plugin, PluginTool } from '../manager.js';
+import { Conductor } from '../../core/conductor.js';
+
+export class ColorPlugin implements Plugin {
+  name = 'colors';
+  description = 'Color conversion (hex/rgb/hsl), palette generation, contrast checking';
+  version = '1.0.0';
+
+  async initialize(_conductor: Conductor): Promise<void> {}
+  isConfigured(): boolean {
+    return true;
+  }
+
+  private hexToRgb(hex: string): { r: number; g: number; b: number } {
+    hex = hex.replace('#', '');
+    if (hex.length === 3)
+      hex = hex
+        .split('')
+        .map((c) => c + c)
+        .join('');
+    const n = parseInt(hex, 16);
+    return { r: (n >> 16) & 255, g: (n >> 8) & 255, b: n & 255 };
+  }
+
+  private rgbToHex(r: number, g: number, b: number): string {
+    return '#' + [r, g, b].map((c) => c.toString(16).padStart(2, '0')).join('');
+  }
+
+  private rgbToHsl(r: number, g: number, b: number): { h: number; s: number; l: number } {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b),
+      min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    if (max === min) return { h: 0, s: 0, l: Math.round(l * 100) };
+    const d = max - min;
+    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    let h = 0;
+    if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+    else if (max === g) h = ((b - r) / d + 2) / 6;
+    else h = ((r - g) / d + 4) / 6;
+    return { h: Math.round(h * 360), s: Math.round(s * 100), l: Math.round(l * 100) };
+  }
+
+  private luminance(r: number, g: number, b: number): number {
+    const a = [r, g, b].map((v) => {
+      v /= 255;
+      return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+    });
+    return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+  }
+
+  getTools(): PluginTool[] {
+    return [
+      {
+        name: 'color_convert',
+        description: 'Convert a color between hex, RGB, and HSL formats',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            color: { type: 'string', description: 'Color value: "#ff5733", "rgb(255,87,51)", or "hsl(11,100%,60%)"' },
+          },
+          required: ['color'],
+        },
+        handler: async (input: { color: string }) => {
+          let r: number, g: number, b: number;
+          const c = input.color.trim();
+
+          if (c.startsWith('#') || /^[0-9a-fA-F]{3,6}$/.test(c)) {
+            ({ r, g, b } = this.hexToRgb(c));
+          } else if (c.startsWith('rgb')) {
+            const m = c.match(/(\d+)/g);
+            if (!m || m.length < 3) throw new Error('Invalid RGB format');
+            [r, g, b] = m.map(Number);
+          } else {
+            throw new Error('Provide hex (#ff5733) or rgb(255,87,51)');
+          }
+
+          const hsl = this.rgbToHsl(r, g, b);
+          return {
+            hex: this.rgbToHex(r, g, b),
+            rgb: `rgb(${r}, ${g}, ${b})`,
+            hsl: `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`,
+            values: { r, g, b, h: hsl.h, s: hsl.s, l: hsl.l },
+          };
+        },
+      },
+      {
+        name: 'color_contrast',
+        description: 'Check WCAG contrast ratio between two colors',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            foreground: { type: 'string', description: 'Foreground color (hex)' },
+            background: { type: 'string', description: 'Background color (hex)' },
+          },
+          required: ['foreground', 'background'],
+        },
+        handler: async (input: { foreground: string; background: string }) => {
+          const fg = this.hexToRgb(input.foreground);
+          const bg = this.hexToRgb(input.background);
+          const l1 = this.luminance(fg.r, fg.g, fg.b);
+          const l2 = this.luminance(bg.r, bg.g, bg.b);
+          const ratio = (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+          return {
+            foreground: input.foreground,
+            background: input.background,
+            ratio: Number(ratio.toFixed(2)),
+            aa_normal: ratio >= 4.5 ? 'PASS' : 'FAIL',
+            aa_large: ratio >= 3 ? 'PASS' : 'FAIL',
+            aaa_normal: ratio >= 7 ? 'PASS' : 'FAIL',
+            aaa_large: ratio >= 4.5 ? 'PASS' : 'FAIL',
+          };
+        },
+      },
+      {
+        name: 'color_palette',
+        description: 'Generate a color palette (complementary, analogous, triadic, or random)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            base: { type: 'string', description: 'Base color in hex (e.g. "#ff5733")' },
+            type: {
+              type: 'string',
+              description: 'Palette type: complementary, analogous, triadic, random',
+              default: 'analogous',
+            },
+          },
+          required: ['base'],
+        },
+        handler: async (input: { base: string; type?: string }) => {
+          const { r, g, b } = this.hexToRgb(input.base);
+          const hsl = this.rgbToHsl(r, g, b);
+          const type = input.type || 'analogous';
+
+          const hslToHex = (h: number, s: number, l: number): string => {
+            h = ((h % 360) + 360) % 360;
+            s /= 100;
+            l /= 100;
+            const c = (1 - Math.abs(2 * l - 1)) * s;
+            const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+            const m = l - c / 2;
+            let rr = 0,
+              gg = 0,
+              bb = 0;
+            if (h < 60) {
+              rr = c;
+              gg = x;
+            } else if (h < 120) {
+              rr = x;
+              gg = c;
+            } else if (h < 180) {
+              gg = c;
+              bb = x;
+            } else if (h < 240) {
+              gg = x;
+              bb = c;
+            } else if (h < 300) {
+              rr = x;
+              bb = c;
+            } else {
+              rr = c;
+              bb = x;
+            }
+            return this.rgbToHex(Math.round((rr + m) * 255), Math.round((gg + m) * 255), Math.round((bb + m) * 255));
+          };
+
+          let colors: string[];
+          switch (type) {
+            case 'complementary':
+              colors = [input.base, hslToHex(hsl.h + 180, hsl.s, hsl.l)];
+              break;
+            case 'triadic':
+              colors = [input.base, hslToHex(hsl.h + 120, hsl.s, hsl.l), hslToHex(hsl.h + 240, hsl.s, hsl.l)];
+              break;
+            case 'random':
+              colors = Array.from(
+                { length: 5 },
+                () =>
+                  '#' +
+                  Math.floor(Math.random() * 16777215)
+                    .toString(16)
+                    .padStart(6, '0'),
+              );
+              break;
+            default: // analogous
+              colors = [
+                hslToHex(hsl.h - 30, hsl.s, hsl.l),
+                input.base,
+                hslToHex(hsl.h + 30, hsl.s, hsl.l),
+                hslToHex(hsl.h + 60, hsl.s, hsl.l),
+              ];
+          }
+
+          return { base: input.base, type, palette: colors };
+        },
+      },
+    ];
+  }
+}