@emblemvault/hustle-react 1.0.0 → 1.1.0

package/dist/browser/hustle-react.js

@@ -3439,6 +3439,286 @@ var screenshotPlugin = {
   }
 };
 
+// src/plugins/pluginBuilder.ts
+var buildPluginTool = {
+  name: "build_plugin",
+  description: `Build a Hustle plugin definition. Use this tool to construct a plugin based on user requirements.
+
+## Plugin Structure
+
+A plugin consists of:
+- **name**: Unique identifier (lowercase, no spaces, e.g., "my-plugin")
+- **version**: Semantic version (e.g., "1.0.0")
+- **description**: What the plugin does
+- **tools**: Array of tool definitions the AI can call
+- **executorCode**: Object mapping tool names to JavaScript function code strings
+
+## Tool Definition Format
+
+Each tool needs:
+- **name**: Unique tool name (alphanumeric + underscore, e.g., "get_weather")
+- **description**: Clear description for the AI to understand when to use it
+- **parameters**: JSON Schema object defining the arguments
+
+Example tool:
+{
+  "name": "get_weather",
+  "description": "Get current weather for a city",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "city": { "type": "string", "description": "City name" },
+      "units": { "type": "string", "enum": ["celsius", "fahrenheit"], "description": "Temperature units" }
+    },
+    "required": ["city"]
+  }
+}
+
+## Executor Code Format
+
+Executors are async JavaScript functions that receive args and return a result.
+Write them as arrow function strings that will be eval'd:
+
+"async (args) => { const { city } = args; return { weather: 'sunny', city }; }"
+
+The function receives args as Record<string, unknown> and should return the result.
+You can use fetch(), standard browser APIs, and async/await.
+
+## Lifecycle Hooks (Optional)
+
+- **beforeRequestCode**: Modify messages before sending. Receives request object, must return modified request.
+  Example: "async (req) => { req.messages = req.messages.map(m => ({...m, content: m.content.toUpperCase()})); return req; }"
+
+- **afterResponseCode**: Process response after receiving. Receives response object.
+  Example: "async (res) => { console.log('Response:', res.content); }"
+
+- **onRegisterCode**: Called when plugin is registered.
+  Example: "async () => { console.log('Plugin loaded!'); }"
+
+- **onErrorCode**: Called on errors. Receives (error, context).
+  Example: "async (error, ctx) => { console.error('Error in', ctx.phase, error); }"`,
+  parameters: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: "Unique plugin identifier (lowercase, no spaces)"
+      },
+      version: {
+        type: "string",
+        description: 'Semantic version (e.g., "1.0.0")'
+      },
+      description: {
+        type: "string",
+        description: "What the plugin does"
+      },
+      tools: {
+        type: "array",
+        description: "Array of tool definitions",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Tool name" },
+            description: { type: "string", description: "Tool description for AI" },
+            parameters: { type: "object", description: "JSON Schema for arguments" }
+          },
+          required: ["name", "description", "parameters"]
+        }
+      },
+      executorCode: {
+        type: "object",
+        description: "Object mapping tool names to executor function code strings"
+      },
+      beforeRequestCode: {
+        type: "string",
+        description: "Optional: Code for beforeRequest hook"
+      },
+      afterResponseCode: {
+        type: "string",
+        description: "Optional: Code for afterResponse hook"
+      },
+      onRegisterCode: {
+        type: "string",
+        description: "Optional: Code for onRegister hook"
+      },
+      onErrorCode: {
+        type: "string",
+        description: "Optional: Code for onError hook"
+      }
+    },
+    required: ["name", "version", "description", "tools", "executorCode"]
+  }
+};
+var savePluginTool = {
+  name: "save_plugin",
+  description: "Save a built plugin as a JSON file. Opens a download dialog for the user.",
+  parameters: {
+    type: "object",
+    properties: {
+      plugin: {
+        type: "object",
+        description: "The plugin object to save (from build_plugin result)"
+      },
+      filename: {
+        type: "string",
+        description: "Filename without extension (defaults to plugin name)"
+      }
+    },
+    required: ["plugin"]
+  }
+};
+var installPluginTool = {
+  name: "install_plugin",
+  description: "Install a built plugin to browser storage so it persists and can be used.",
+  parameters: {
+    type: "object",
+    properties: {
+      plugin: {
+        type: "object",
+        description: "The plugin object to install (from build_plugin result)"
+      },
+      enabled: {
+        type: "boolean",
+        description: "Whether to enable the plugin immediately (default: true)"
+      }
+    },
+    required: ["plugin"]
+  }
+};
+var buildPluginExecutor = async (args2) => {
+  const {
+    name,
+    version,
+    description,
+    tools,
+    executorCode,
+    beforeRequestCode,
+    afterResponseCode,
+    onRegisterCode,
+    onErrorCode
+  } = args2;
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    return {
+      success: false,
+      error: "Plugin name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens"
+    };
+  }
+  if (!/^\d+\.\d+\.\d+/.test(version)) {
+    return {
+      success: false,
+      error: 'Version must be in semver format (e.g., "1.0.0")'
+    };
+  }
+  for (const tool of tools) {
+    if (!executorCode[tool.name]) {
+      return {
+        success: false,
+        error: `Missing executor code for tool: ${tool.name}`
+      };
+    }
+  }
+  const storedPlugin = {
+    name,
+    version,
+    description,
+    tools: tools.map((tool) => ({
+      ...tool,
+      executorCode: executorCode[tool.name]
+    })),
+    enabled: true,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (beforeRequestCode || afterResponseCode || onRegisterCode || onErrorCode) {
+    storedPlugin.hooksCode = {};
+    if (beforeRequestCode) storedPlugin.hooksCode.beforeRequestCode = beforeRequestCode;
+    if (afterResponseCode) storedPlugin.hooksCode.afterResponseCode = afterResponseCode;
+    if (onRegisterCode) storedPlugin.hooksCode.onRegisterCode = onRegisterCode;
+    if (onErrorCode) storedPlugin.hooksCode.onErrorCode = onErrorCode;
+  }
+  return {
+    success: true,
+    plugin: storedPlugin,
+    message: `Plugin "${name}" v${version} built successfully with ${tools.length} tool(s). Use save_plugin to download or install_plugin to add to browser storage.`
+  };
+};
+var savePluginExecutor = async (args2) => {
+  const { plugin, filename } = args2;
+  if (typeof window === "undefined") {
+    return { success: false, error: "Cannot save files in server environment" };
+  }
+  try {
+    const json2 = JSON.stringify(plugin, null, 2);
+    const blob = new Blob([json2], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `${filename || plugin.name}.json`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+    return {
+      success: true,
+      message: `Plugin saved as ${filename || plugin.name}.json`
+    };
+  } catch (error2) {
+    return {
+      success: false,
+      error: `Failed to save: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+    };
+  }
+};
+var installPluginExecutor = async (args2) => {
+  const { plugin, enabled = true } = args2;
+  if (typeof window === "undefined") {
+    return { success: false, error: "Cannot install plugins in server environment" };
+  }
+  try {
+    const instanceId = window.__hustleInstanceId || "global-demo";
+    const STORAGE_KEY = `hustle-plugins-${instanceId}`;
+    const stored = localStorage.getItem(STORAGE_KEY);
+    const plugins = stored ? JSON.parse(stored) : [];
+    const existingIndex = plugins.findIndex((p) => p.name === plugin.name);
+    const pluginToStore = {
+      ...plugin,
+      enabled,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (existingIndex >= 0) {
+      plugins[existingIndex] = pluginToStore;
+    } else {
+      plugins.push(pluginToStore);
+    }
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(plugins));
+    return {
+      success: true,
+      message: `Plugin "${plugin.name}" installed${enabled ? " and enabled" : ""}. Refresh the page or re-register plugins to activate.`,
+      action: existingIndex >= 0 ? "updated" : "installed"
+    };
+  } catch (error2) {
+    return {
+      success: false,
+      error: `Failed to install: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+    };
+  }
+};
+var pluginBuilderPlugin = {
+  name: "plugin-builder",
+  version: "1.0.0",
+  description: "Build custom plugins through conversation",
+  tools: [buildPluginTool, savePluginTool, installPluginTool],
+  executors: {
+    build_plugin: buildPluginExecutor,
+    save_plugin: savePluginExecutor,
+    install_plugin: installPluginExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Plugin Builder] Ready to help build custom plugins");
+    }
+  }
+};
+
 // src/plugins/index.ts
 var availablePlugins = [
   {
@@ -3468,6 +3748,10 @@ var availablePlugins = [
   {
     ...screenshotPlugin,
     description: "Take screenshots of the current page"
+  },
+  {
+    ...pluginBuilderPlugin,
+    description: "Build custom plugins through conversation with AI"
   }
 ];
 function getAvailablePlugin(name) {