@grafana/assistant 0.0.1-alpha.3 → 0.0.2

package/README.md

@@ -1,6 +1,6 @@
 # @grafana/assistant
 
-Type definitions for Grafana Assistant functions and dashboard operations.
+Type definitions and utilities for integrating with the Grafana Assistant.
 
 ## Installation
 
@@ -10,109 +10,143 @@ npm install @grafana/assistant
 
 ## Usage
 
+### Opening the Assistant Sidebar
+
 ```typescript
-import type { AddCallbackFunction, FunctionImplementation, DashboardOperations } from '@grafana/assistant';
+import { openAssistant, closeAssistant } from '@grafana/assistant';
 
-// Use the type to define your assistant function handler
-const registerFunction: AddCallbackFunction = (pluginId, namespace, functionName, functionImpl) => {
-  // Your implementation here
-};
+// Open the assistant with an initial prompt
+openAssistant({ prompt: 'Show me CPU usage over the last hour' });
+
+// Open the assistant without an initial prompt
+openAssistant({});
+
+// Close the assistant
+closeAssistant();
+```
 
-// Example function implementation
-const myFunction: FunctionImplementation = (param1, param2) => {
-  return `Result: ${param1} + ${param2}`;
+### Exposing Functions to the Assistant
+
+```typescript
+import { 
+  getExposeAssistantFunctionsConfig, 
+  newFunctionNamespace,
+  FunctionImplementation,
+  FunctionNamespace,
+  NamedFunctions 
+} from '@grafana/assistant';
+
+// Define your functions
+const myFunctions: NamedFunctions = {
+  getMetrics: (datasource: string) => {
+    return ['cpu_usage', 'memory_usage', 'disk_io'];
+  },
+  
+  calculateAverage: (values: number[]) => {
+    return values.reduce((a, b) => a + b, 0) / values.length;
+  }
 };
+
+// Create a namespace for your functions
+const namespace = newFunctionNamespace('myPlugin', myFunctions);
+
+// Export the configuration for your plugin
+export const getExtensionConfigs = () => [
+  getExposeAssistantFunctionsConfig([namespace])
+];
 ```
 
-## Types
+## API Reference
 
-### AddCallbackFunction
+### Sidebar Functions
 
-A function signature for registering assistant functions.
+#### `openAssistant(props: OpenAssistantProps): void`
+
+Opens the Grafana Assistant sidebar.
+
+**Parameters:**
+- `props: OpenAssistantProps` - Configuration object
+  - `prompt?: string` - Optional initial prompt to display in the assistant
+
+#### `closeAssistant(): void`
+
+Closes the Grafana Assistant sidebar.
+
+### Sidebar Types
+
+#### `OpenAssistantProps`
 
 ```typescript
-type AddCallbackFunction = (pluginId: string, namespace: string, functionName: string, functionImpl: FunctionImplementation) => void;
+type OpenAssistantProps = {
+  prompt?: string;
+};
 ```
 
-**Parameters:**
-- `pluginId: string` - The plugin ID of the function
-- `namespace: string` - The namespace for the function
-- `functionName: string` - The name of the function  
-- `functionImpl: FunctionImplementation` - The implementation of the function
+Configuration object for opening the assistant.
 
-### FunctionImplementation
+### Function Extension Types
 
-A type for function implementations that can be registered with the assistant.
+#### `CallbackFunction`
+
+```typescript
+type CallbackFunction = () => FunctionNamespace[];
+```
+
+A function that returns an array of function namespaces.
+
+#### `FunctionImplementation`
 
 ```typescript
 type FunctionImplementation = (...args: any[]) => any;
 ```
 
-### DashboardOperations
+A type for function implementations that can be exposed to the assistant.
 
-Operations available for dashboard manipulation.
+#### `NamedFunctions`
 
 ```typescript
-type DashboardOperations = {
-  addPanel: (vizPanel: VizPanel) => void;
-  duplicatePanel: (vizPanel: VizPanel) => void;
-  copyPanel: (vizPanel: VizPanel) => void;
-  pastePanel: () => void;
-  removePanel: (panel: VizPanel) => void;
-  createNewPanel: () => void;
-  createNewRow: () => void;
-  onEnterEditMode: () => void;
-  openSaveDrawer: (options?: SaveDrawerOptions) => void;
-  onStarDashboard: () => void;
-  canEditDashboard: () => boolean;
-  exitEditMode: (options: ExitEditModeOptions) => void;
-};
+type NamedFunctions = Record<string, FunctionImplementation>;
 ```
 
-## Example: Registering Dashboard Operations
+A record of function names to their implementations.
 
-Here's how Grafana core would register all dashboard operations:
+#### `FunctionNamespace`
 
 ```typescript
-Object.keys(DashboardOperations).forEach((actionName) => {
-  const action = DashboardOperations[actionName as keyof typeof DashboardOperations];
-  addCallbackFunction.fn('grafana', 'dashboarding', actionName, action);
-});
+type FunctionNamespace = {
+  namespace: string;
+  functions: NamedFunctions;
+};
 ```
 
-This example shows how to:
-1. Iterate through all available dashboard operations
-2. Extract each operation function
-3. Register it with the assistant using the 'dashboarding' namespace
+Groups functions under a namespace.
+
+### Utility Functions
+
+#### `newFunctionNamespace(namespace: string, functions: NamedFunctions): FunctionNamespace`
+
+Creates a new function namespace.
+
+**Parameters:**
+- `namespace: string` - The namespace identifier
+- `functions: NamedFunctions` - The functions to include in the namespace
+
+#### `getExposeAssistantFunctionsConfig(namespaces: FunctionNamespace[]): PluginExtensionAddedFunctionConfig`
+
+Creates a plugin extension configuration for exposing functions to the assistant.
+
+**Parameters:**
+- `namespaces: FunctionNamespace[]` - Array of function namespaces to expose
 
-## Example: Using Registered Functions
+### Constants
 
-Once functions are registered, they can be retrieved and used from the function registry:
+#### `CALLBACK_EXTENSION_POINT`
 
 ```typescript
-import { functionRegistry } from './functions/registry';
-import type { DashboardOperations } from '@grafana/assistant';
-
-// Retrieve a specific function from the registry
-const onEnterEditMode = functionRegistry.getFunction<DashboardOperations['onEnterEditMode']>(
-  'grafana',
-  'dashboarding',
-  'onEnterEditMode'
-);
-
-if (!onEnterEditMode) {
-  throw new Error('onEnterEditMode function not found');
-}
-
-// Use the retrieved function
-onEnterEditMode();
+const CALLBACK_EXTENSION_POINT = 'grafana-assistant-app/callback/v0-alpha';
 ```
 
-This example demonstrates:
-1. Using `functionRegistry.getFunction()` to retrieve registered functions by plugin ID, namespace, and function name
-2. Type-safe function retrieval using TypeScript generics
-3. Null checking before using the function
-4. Calling the retrieved function
+The extension point ID for registering assistant functions.
 
 ## License
 

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './dashboarding';
 export * from './functions';
+export * from './sidebar';

package/dist/index.js

@@ -1 +1 @@
-const a="grafana-assistant-app/callback/v0-alpha";function n(a,n){return{namespace:a,functions:n}}function t(n){return{title:"callback",targets:[a],fn:()=>n.map(a=>({namespace:a.namespace,functions:a.functions}))}}export{a as CALLBACK_EXTENSION_POINT,t as getExposeAssistantFunctionsConfig,n as newFunctionNamespace};
+import*as t from"@grafana/data";import*as n from"@grafana/runtime";var a={d:(t,n)=>{for(var e in n)a.o(n,e)&&!a.o(t,e)&&Object.defineProperty(t,e,{enumerable:!0,get:n[e]})},o:(t,n)=>Object.prototype.hasOwnProperty.call(t,n)};const e="grafana-assistant-app/callback/v0-alpha";function s(t,n){return{namespace:t,functions:n}}function o(t){return{title:"callback",targets:[e],fn:()=>t.map(t=>({namespace:t.namespace,functions:t.functions}))}}const p=(r={BusEventBase:()=>t.BusEventBase,BusEventWithPayload:()=>t.BusEventWithPayload},i={},a.d(i,r),i);var r,i;const c=(t=>{var n={};return a.d(n,t),n})({getAppEvents:()=>n.getAppEvents});class u extends p.BusEventWithPayload{}u.type="open-extension-sidebar";class l extends p.BusEventBase{}function f(t){!function(t,n,a){const e=new u({pluginId:"grafana-assistant-app",componentTitle:"Grafana Assistant",props:a});(0,c.getAppEvents)().publish(e)}(0,0,{initialPrompt:t.prompt})}function v(){!function(){const t=new l;(0,c.getAppEvents)().publish(t)}()}l.type="close-extension-sidebar";export{e as CALLBACK_EXTENSION_POINT,v as closeAssistant,o as getExposeAssistantFunctionsConfig,s as newFunctionNamespace,f as openAssistant};

package/dist/sidebar.d.ts

@@ -0,0 +1,14 @@
+export type OpenAssistantProps = {
+    prompt?: string;
+};
+/**
+ * Open the Grafana Assistant sidebar with a given initial prompt.
+ *
+ * @param props - The props to pass to the assistant.
+ * @param props.prompt - The initial prompt to display in the assistant.
+ */
+export declare function openAssistant(props: OpenAssistantProps): void;
+/**
+ * Close the Grafana Assistant sidebar.
+ */
+export declare function closeAssistant(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafana/assistant",
-  "version": "0.0.1-alpha.3",
+  "version": "0.0.2",
   "description": "Type definitions for Grafana Assistant functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,6 +32,8 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@grafana/scenes": ">=5.41.0"
+    "@grafana/scenes": ">=5.41.0",
+    "@grafana/runtime": ">=12.0.0",
+    "@grafana/data": ">=12.0.0"
   }
 } 

package/dist/dashboarding.d.ts

@@ -1,23 +0,0 @@
-import { VizPanel } from '@grafana/scenes';
-export type SaveDrawerOptions = {
-    saveAsCopy?: boolean;
-    onSaveSuccess?: () => void;
-};
-export type ExitEditModeOptions = {
-    skipConfirm: boolean;
-    restoreInitialState?: boolean;
-};
-export type DashboardOperations = {
-    addPanel: (vizPanel: VizPanel) => void;
-    duplicatePanel: (vizPanel: VizPanel) => void;
-    copyPanel: (vizPanel: VizPanel) => void;
-    pastePanel: () => void;
-    removePanel: (panel: VizPanel) => void;
-    createNewPanel: () => void;
-    createNewRow: () => void;
-    onEnterEditMode: () => void;
-    openSaveDrawer: (options?: SaveDrawerOptions) => void;
-    onStarDashboard: () => void;
-    canEditDashboard: () => boolean;
-    exitEditMode: (options: ExitEditModeOptions) => void;
-};