feat(search): improve search feature and displaying results in dashboard

feat(mcp): add search feature

Author: marle3003

acceptance/petstore_test.go

@@ -389,7 +389,7 @@ func (suite *PetStoreSuite) TestSearch_Paging() {
 			assert.Len(t, items, 10)
 			evt := items[0].(map[string]interface{})
 			assert.Equal(t, "HTTP", evt["type"])
-			assert.Equal(t, "GET /pet/{petId}", evt["title"])
+			assert.Equal(t, "/pet/{petId}", evt["title"])
 			assert.Equal(t, "Swagger Petstore", evt["domain"])
 		}),
 	)

engine/common/host.go

@@ -176,9 +176,20 @@ func (e *JobExecution) AppendLog(level, message string) {
 }
 
 func (e *JobExecution) Title() string {
+	if e.Error != nil {
+		return fmt.Sprintf("Error in: %v", e.Tags["name"])
+	}
 	return e.Tags["name"]
 }
 
+func (e *JobExecution) Metadata() map[string]string {
+	return nil
+}
+
+func (e *JobExecution) Domain() string {
+	return "Job Execution"
+}
+
 type FakerNode interface {
 	Name() string
 	Fake(r *generator.Request) (interface{}, error)

engine/host.go

@@ -102,8 +102,9 @@ func (sh *scriptHost) Cron(expr string, handler func(), opt common.JobOptions) (
 }
 
 func (sh *scriptHost) newJobFunc(handler func(), opt common.JobOptions, schedule string, id int) func() {
+	name := filepath.Base(sh.name)
 	tags := map[string]string{
-		"name":    sh.name,
+		"name":    name,
 		"file":    sh.name,
 		"fileKey": sh.file.Info.Key(),
 	}

mcp/data/automation-core.md

@@ -44,6 +44,35 @@ interface Mokapi {
      * getEvents({ apiType: 'http', name: 'Swagger Petstore', path: '/pets' })
      */
     getEvents(traits: HttpTraits | KafkaTraits, limit?: number): Event[];
+
+    /**
+     * Returns a specific event from Mokapi based on the id
+     * @param id The id of the event
+     * @example
+     * getEvent('6cbca4f8-ea25-4f66-861c-44d8b15321b1')
+     */
+    getEvent(id: string): Event[];
+
+    /**
+     * Advanced Search across all APIs, Topics, and Documentation.
+     * By default, multiple terms are combined with OR (results contain at least one term). Use prefixes to enforce stricter matches.
+     *
+     * QUERY SYNTAX:
+     * - Simple: `petstore` (Search in all fields)
+     *   Type: `type:kafka` (Search only Kafka)
+     * - Exact: `"Swagger Petstore"` (Use quotes for phrases)
+     * - Exclude: `petstore -kafka` (Exclude terms with '-')
+     * - Wildcard: `pet*` (Matches "pet", "pets", "petstore")
+     * - Fuzy: `pet~` (Matches "pets", "pest" or slight typos)
+     * - Fields: `name:petstore`, `path:/pets`, `description:dog`
+     * - Boosting: `path:/pets^2` (Make path matches more important)
+     * - Numeric Ranges: `statusCode:>=200
+     *
+     * @param queryText The search term or complex query string.
+     * @param index Page index for pagination (starts at 0).
+     * @param limit Number of results (default 10).
+     */
+    search(queryText: string, index?: number, limit?: number): SearchResult
 }
 
 type ApiType =  'http' | 'kafka' | 'ldap' | 'mail'
@@ -53,6 +82,33 @@ interface ApiSummary {
     type: ApiType;
 }
 
+interface SearchResult {
+    items: SearchResultItem[]
+    total: number
+}
+
+interface SearchResultItem {
+    /** The type of the resource (e.g., 'http', 'kafka', 'event') */
+    type: string
+    /** The name of the API */
+    domain: string
+    /** A human-readable title or summary */
+    title: string
+    /**
+     * Relevant text snippets showing where the match was found.
+     * Useful to see context like 'GET /pets' or 'Topic: orders'.
+     */
+    fragments: string[]
+    /**
+     * Additional context specific to the result type.
+     * - HTTP: includes 'method', 'path', 'service'
+     * - Kafka: includes 'topic', 'service'
+     */
+    metadata: Record<string, string>
+    
+    time?: string
+}
+
 /**
  * JSON Schema defines a JSON-based format for describing the structure of JSON data
  * @example
@@ -201,4 +257,5 @@ interface Schema {
 }
 
 type SchemaType = "object" | "array" | "number" | "integer" | "string" | "boolean" | "null";
+
 ```

mcp/data/automation.md

@@ -39,4 +39,32 @@ mokapi.getEvents()
 Get latest HTTP events for a specific API
 ```typescript
 mokapi.getEvents({ type: 'http', name: 'Petstore' })
-```
+```
+
+Search for all POST endpoints related to "payments".
+```typescript
+// 1. Search for a specific capability
+const searchResponse = mokapi.search("method:POST AND path:*payments*");
+let op = null
+if (searchResponse.items.length > 0) {
+    const match = searchResponse.items[0];
+
+    // 2. Use metadata to load the full API specification
+    const api = mokapi.getApi(match.metadata.service);
+
+    // 3. Find the specific operation to see allowed status codes/schemas
+    // Tip: Use the path from metadata to identify the correct operation
+    const opSummary = api.getOperations().find(x => x.path === match.metadata.path && x.method === match.metadata.method);
+
+    if (opSummary) {
+        op = api.getOperation(opSummary.id);
+    }
+}
+op
+```
+
+Search for errors (404 or 500) related to the Petstore
+```typescript
+const errors = mokapi.search('+api:"Petstore" +event.data.response.statusCode:>=400 +type:event')
+errors.items.map(x => mokapi.getEvent(x.metadata.id))
+```

mcp/run.go

@@ -9,6 +9,7 @@ import (
 	"mokapi/js/faker"
 	"mokapi/providers/openapi"
 	"mokapi/runtime"
+	"mokapi/runtime/search"
 	"mokapi/schema/json/generator"
 	"reflect"
 	"slices"
@@ -136,6 +137,8 @@ func (m *mokapi) init(obj *goja.Object) {
 	_ = obj.Set("getApi", m.getApi)
 	_ = obj.Set("fake", m.fake)
 	_ = obj.Set("getEvents", m.getEvents)
+	_ = obj.Set("getEvent", m.getEvent)
+	_ = obj.Set("search", m.search)
 }
 
 func (m *mokapi) getApis() []ApiSummary {
@@ -184,6 +187,50 @@ func (m *mokapi) fake(v goja.Value) (any, error) {
 	return generator.New(&generator.Request{Schema: js})
 }
 
+type SearchResult struct {
+	Items []SearchResultItem `json:"items"`
+	Total uint64             `json:"total"`
+}
+
+type SearchResultItem struct {
+	Type      string            `json:"type"`
+	Domain    string            `json:"domain,omitempty"`
+	Title     string            `json:"title"`
+	Fragments []string          `json:"fragments,omitempty"`
+	Metadata  map[string]string `json:"metadata"`
+	Time      string            `json:"time,omitempty"`
+}
+
+func (m *mokapi) search(queryText string, index int, limit int) (SearchResult, error) {
+	if limit == 0 {
+		limit = 10
+	}
+	r := search.Request{
+		QueryText: queryText,
+		Index:     index,
+		Limit:     limit,
+	}
+
+	sr, err := m.app.Search(r)
+	if err != nil {
+		return SearchResult{}, err
+	}
+	result := SearchResult{
+		Total: sr.Total,
+	}
+	for _, item := range sr.Results {
+		result.Items = append(result.Items, SearchResultItem{
+			Type:      item.Type,
+			Domain:    item.Domain,
+			Title:     item.Title,
+			Fragments: item.Fragments,
+			Metadata:  item.Params,
+			Time:      item.Time,
+		})
+	}
+	return result, nil
+}
+
 type customFieldNameMapper struct {
 }
 

mcp/run_events.go

@@ -32,6 +32,18 @@ func (m *mokapi) getEvents(vTraits goja.Value, vLimit goja.Value) ([]events.Even
 	}
 }
 
+func (m *mokapi) getEvent(id string) (events.Event, error) {
+	if id == "" {
+		return events.Event{}, fmt.Errorf("expected id parameter in GUID format, got '%v'", id)
+	}
+
+	e := m.app.Events.GetEvent(id)
+	if e.Id == "" {
+		return e, fmt.Errorf("event %s not found. Use `mokapi.search('type:event ...')` to search for existing events", id)
+	}
+	return e, nil
+}
+
 func parseTraits(v goja.Value, vm *goja.Runtime) (events.Traits, error) {
 	traits := events.Traits{}
 

mcp/run_events_test.go

@@ -19,21 +19,25 @@ func (t *testEvent) Title() string {
 	return t.Name
 }
 
+func (t *testEvent) Metadata() map[string]string { return nil }
+
 func TestEvents(t *testing.T) {
 	testcases := []struct {
 		name string
 		app  *runtime.App
 		code string
-		test func(t *testing.T, evts []events.Event, err error)
+		test func(t *testing.T, result any, err error)
 	}{
 		{
 			name: "without params should not error",
 			code: "mokapi.getEvents()",
 			app: runtimetest.NewApp(
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("http"), &testEvent{Name: "test-1"}),
 			),
-			test: func(t *testing.T, evts []events.Event, err error) {
+			test: func(t *testing.T, result any, err error) {
 				require.NoError(t, err)
+				require.IsType(t, []events.Event{}, result)
+				evts := result.([]events.Event)
 				require.Len(t, evts, 1)
 				require.Equal(t, &testEvent{Name: "test-1"}, evts[0].Data)
 			},
@@ -45,8 +49,10 @@ func TestEvents(t *testing.T) {
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("kafka"), &testEvent{Name: "test-1"}),
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("http"), &testEvent{Name: "test-2"}),
 			),
-			test: func(t *testing.T, evts []events.Event, err error) {
+			test: func(t *testing.T, result any, err error) {
 				require.NoError(t, err)
+				require.IsType(t, []events.Event{}, result)
+				evts := result.([]events.Event)
 				require.Len(t, evts, 1)
 				require.Equal(t, &testEvent{Name: "test-2"}, evts[0].Data)
 			},
@@ -58,8 +64,10 @@ func TestEvents(t *testing.T) {
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").WithName("foo"), &testEvent{Name: "test-1"}),
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").WithName("bar"), &testEvent{Name: "test-2"}),
 			),
-			test: func(t *testing.T, evts []events.Event, err error) {
+			test: func(t *testing.T, result any, err error) {
 				require.NoError(t, err)
+				require.IsType(t, []events.Event{}, result)
+				evts := result.([]events.Event)
 				require.Len(t, evts, 1)
 				require.Equal(t, &testEvent{Name: "test-2"}, evts[0].Data)
 			},
@@ -71,8 +79,10 @@ func TestEvents(t *testing.T) {
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("path", "/users"), &testEvent{Name: "test-1"}),
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("path", "/pets"), &testEvent{Name: "test-2"}),
 			),
-			test: func(t *testing.T, evts []events.Event, err error) {
+			test: func(t *testing.T, result any, err error) {
 				require.NoError(t, err)
+				require.IsType(t, []events.Event{}, result)
+				evts := result.([]events.Event)
 				require.Len(t, evts, 1)
 				require.Equal(t, &testEvent{Name: "test-2"}, evts[0].Data)
 			},
@@ -84,12 +94,27 @@ func TestEvents(t *testing.T) {
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("method", "GET"), &testEvent{Name: "test-1"}),
 				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("method", "POST"), &testEvent{Name: "test-2"}),
 			),
-			test: func(t *testing.T, evts []events.Event, err error) {
+			test: func(t *testing.T, result any, err error) {
 				require.NoError(t, err)
+				require.IsType(t, []events.Event{}, result)
+				evts := result.([]events.Event)
 				require.Len(t, evts, 1)
 				require.Equal(t, &testEvent{Name: "test-2"}, evts[0].Data)
 			},
 		},
+		{
+			name: "get specific event",
+			code: "mokapi.getEvent(mokapi.getEvents({ method: 'GET' })[0].id)",
+			app: runtimetest.NewApp(
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("method", "GET"), &testEvent{Name: "test-1"}),
+			),
+			test: func(t *testing.T, result any, err error) {
+				require.NoError(t, err)
+				require.IsType(t, events.Event{}, result)
+				evt := result.(events.Event)
+				require.Equal(t, &testEvent{Name: "test-1"}, evt.Data)
+			},
+		},
 	}
 
 	for _, tc := range testcases {
@@ -100,9 +125,8 @@ func TestEvents(t *testing.T) {
 				context.Background(),
 				mcp.RunInput{Code: tc.code},
 			)
-			require.IsType(t, []events.Event{}, r.Result)
 
-			tc.test(t, r.Result.([]events.Event), err)
+			tc.test(t, r.Result, err)
 		})
 	}
 }