@kadi.build/core 0.0.1-alpha.2 → 0.0.1-alpha.3

package/examples/example-agent/abilities/hash-go/0.0.1/cmd/hash_ability/main.go

@@ -0,0 +1,340 @@
+// A minimal JSON-RPC 2.0 server over stdin/stdout for the "hash-go" ability.
+// - Uses LSP-style framing: Kadi-Content-Length header + JSON body
+// - Implements:
+//     __kadi_init       : handshake/version negotiation
+//     __kadi_discover   : returns functions/tools metadata
+//     digest            : computes sha256/md5 hex digest of input text
+//
+// This follows the LSP-style protocol used by spawnJSONRPCProcess() in kadi-core.
+
+package main
+
+import (
+	"crypto/md5"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// RPCRequest models a JSON-RPC request coming from the agent.
+// ID is left as interface{} so we can echo back either number or string.
+type RPCRequest struct {
+	JSONRPC string          `json:"jsonrpc"`
+	ID      interface{}     `json:"id"`
+	Method  string          `json:"method"`
+	Params  json.RawMessage `json:"params"`
+}
+
+// RPCError is the error object defined by JSON-RPC 2.0.
+type RPCError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+// RPCResponse models a JSON-RPC response. Either Result or Error is present.
+type RPCResponse struct {
+	JSONRPC string      `json:"jsonrpc"`
+	ID      interface{} `json:"id"`
+	Result  interface{} `json:"result,omitempty"`
+	Error   *RPCError   `json:"error,omitempty"`
+}
+
+// digestParams describes the input we expect for the "digest" method/tool.
+type digestParams struct {
+	Text string `json:"text"`
+	Algo string `json:"algo"` // "sha256" (default) or "md5"
+}
+
+// toolSpec models an MCP-style tool descriptor.
+type toolSpec struct {
+	Name         string                 `json:"name"`
+	Title        string                 `json:"title,omitempty"`
+	Description  string                 `json:"description,omitempty"`
+	InputSchema  map[string]interface{} `json:"inputSchema"`
+	OutputSchema map[string]interface{} `json:"outputSchema,omitempty"`
+}
+
+func main() {
+	// Loop forever: read LSP-style frames → handle → write response.
+	for {
+		// Read headers byte by byte until we find \r\n\r\n
+		headers := make(map[string]string)
+		headerData := make([]byte, 0)
+
+		// Read until we find the header delimiter \r\n\r\n
+		delimiter := []byte{'\r', '\n', '\r', '\n'}
+		for {
+			b := make([]byte, 1)
+			_, err := os.Stdin.Read(b)
+			if err != nil {
+				if err == io.EOF {
+					return // Clean exit
+				}
+				fmt.Fprintf(os.Stderr, "Error reading header byte: %v\n", err)
+				return
+			}
+			headerData = append(headerData, b[0])
+
+			// Check if we have the delimiter
+			if len(headerData) >= 4 {
+				if string(headerData[len(headerData)-4:]) == string(delimiter) {
+					break
+				}
+			}
+		}
+
+		// Parse headers (exclude the delimiter)
+		headerSection := string(headerData[:len(headerData)-4])
+		lines := strings.Split(headerSection, "\r\n")
+
+		for _, line := range lines {
+			if strings.Contains(line, ":") {
+				parts := strings.SplitN(line, ":", 2)
+				if len(parts) == 2 {
+					name := strings.TrimSpace(parts[0])
+					value := strings.TrimSpace(parts[1])
+					headers[name] = value
+				}
+			}
+		}
+
+		// Extract Content-Length
+		contentLengthStr, ok := headers["Kadi-Content-Length"]
+		if !ok {
+			fmt.Fprintf(os.Stderr, "Missing Content-Length header\n")
+			continue
+		}
+
+		contentLength, err := strconv.Atoi(contentLengthStr)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Invalid Content-Length: %v\n", err)
+			continue
+		}
+
+		// Read the JSON body
+		body := make([]byte, contentLength)
+		_, err = io.ReadFull(os.Stdin, body)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error reading body: %v\n", err)
+			continue
+		}
+
+		var req RPCRequest
+		if err := json.Unmarshal(body, &req); err != nil {
+			// If the request can't be parsed, return a JSON-RPC parse error (-32700).
+			writeResponse(RPCResponse{
+				JSONRPC: "2.0",
+				ID:      nil,
+				Error:   &RPCError{Code: -32700, Message: "parse error: " + err.Error()},
+			})
+			continue
+		}
+
+		// Dispatch by method. Each handler returns (result, *RPCError).
+		var (
+			result interface{}
+			rerr   *RPCError
+		)
+
+		switch req.Method {
+		case "__kadi_init":
+			// Handshake/version negotiation. You can return metadata here.
+			result, rerr = handleInit(req.Params)
+
+		case "__kadi_discover":
+			// Return functions map + optional tools array (mirrors MCP).
+			result, rerr = handleDiscover()
+
+		case "digest":
+			// Direct method call (what loadAbility().call("digest", ...) would use).
+			result, rerr = handleDigest(req.Params)
+
+		default:
+			// Method not found (-32601) per JSON-RPC.
+			rerr = &RPCError{Code: -32601, Message: "method not found: " + req.Method}
+		}
+
+		// Send the response using LSP-style framing.
+		writeResponse(RPCResponse{
+			JSONRPC: "2.0",
+			ID:      req.ID,
+			Result:  result,
+			Error:   rerr,
+		})
+	}
+}
+
+// writeResponse serializes and prints a JSON-RPC response using LSP-style framing.
+// Format: Content-Length header + JSON body
+func writeResponse(resp RPCResponse) {
+	b, err := json.Marshal(resp)
+	if err != nil {
+		// As a last resort, emit a generic error with no ID.
+		fallback := RPCResponse{
+			JSONRPC: "2.0",
+			ID:      nil,
+			Error:   &RPCError{Code: -32603, Message: "internal error: " + err.Error()},
+		}
+		b, _ = json.Marshal(fallback)
+	}
+
+	// Write LSP-style frame: headers + body
+	header := fmt.Sprintf("Kadi-Content-Length: %d\r\nContent-Type: application/kadi-jsonrpc; charset=utf-8\r\n\r\n", len(b))
+	fmt.Print(header)
+	fmt.Print(string(b))
+}
+
+/* ----------------------------- Handlers ---------------------------------- */
+
+// handleInit replies to __kadi_init. You can extend this with capabilities.
+func handleInit(params json.RawMessage) (interface{}, *RPCError) {
+	// Optionally parse params to inspect the API version.
+	var payload map[string]interface{}
+	_ = json.Unmarshal(params, &payload)
+
+	// Return metadata; you could also include "functions" here to skip discover.
+	return map[string]interface{}{
+		"api": "1.0",
+		"ability": map[string]interface{}{
+			"name":    "hash-go",
+			"version": "0.0.1",
+		},
+	}, nil
+}
+
+// handleDiscover advertises callable functions (your loader can auto-stub from this).
+// We also include an MCP-compatible "tools" array for symmetry.
+func handleDiscover() (interface{}, *RPCError) {
+	input, output := digestSchemas()
+
+	return map[string]interface{}{
+		"functions": map[string]interface{}{
+			"digest": map[string]interface{}{
+				"inputSchema":  input,
+				"outputSchema": output,
+			},
+		},
+		"tools": []toolSpec{
+			{
+				Name:        "digest",
+				Title:       "Compute Digest",
+				Description: "Return a hex digest (sha256 default) of the input text.",
+				InputSchema: input,
+				OutputSchema: map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"algo": map[string]interface{}{"type": "string"},
+						"hex":  map[string]interface{}{"type": "string"},
+					},
+					"required": []string{"algo", "hex"},
+				},
+			},
+		},
+	}, nil
+}
+
+// handleToolsList matches MCP "tools/list": return the list of tools.
+func handleToolsList() (interface{}, *RPCError) {
+	input, _ := digestSchemas()
+	tools := []toolSpec{
+		{
+			Name:        "digest",
+			Title:       "Compute Digest",
+			Description: "Return a hex digest (sha256 default) of the input text.",
+			InputSchema: input,
+			OutputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"algo": map[string]interface{}{"type": "string"},
+					"hex":  map[string]interface{}{"type": "string"},
+				},
+				"required": []string{"algo", "hex"},
+			},
+		},
+	}
+	return tools, nil
+}
+
+// handleToolsCall matches MCP "tools/call": expects {"name": "...", "arguments": {...}}
+func handleToolsCall(params json.RawMessage) (interface{}, *RPCError) {
+	var p struct {
+		Name      string          `json:"name"`
+		Arguments json.RawMessage `json:"arguments"`
+	}
+	if err := json.Unmarshal(params, &p); err != nil {
+		return nil, &RPCError{Code: -32602, Message: "invalid params: " + err.Error()}
+	}
+	switch p.Name {
+	case "digest":
+		// Reuse our regular digest handler for the arguments payload.
+		return handleDigest(p.Arguments)
+	default:
+		return nil, &RPCError{Code: -32601, Message: "tool not found: " + p.Name}
+	}
+}
+
+// handleDigest is the actual business logic: compute a digest and return algo+hex.
+func handleDigest(params json.RawMessage) (interface{}, *RPCError) {
+	var p digestParams
+	if err := json.Unmarshal(params, &p); err != nil {
+		return nil, &RPCError{Code: -32602, Message: "invalid params: " + err.Error()}
+	}
+	if p.Algo == "" {
+		p.Algo = "sha256"
+	}
+
+	textBytes := []byte(p.Text)
+	switch strings.ToLower(p.Algo) {
+	case "sha256":
+		sum := sha256.Sum256(textBytes)
+		return map[string]interface{}{
+			"algo": "sha256",
+			"hex":  hex.EncodeToString(sum[:]),
+		}, nil
+	case "md5":
+		sum := md5.Sum(textBytes)
+		return map[string]interface{}{
+			"algo": "md5",
+			"hex":  hex.EncodeToString(sum[:]),
+		}, nil
+	default:
+		return nil, &RPCError{Code: -32602, Message: "unsupported algo: " + p.Algo}
+	}
+}
+
+/* --------------------------- JSON Schemas -------------------------------- */
+
+// digestSchemas returns the JSON Schemas for input/output (as plain Go maps).
+func digestSchemas() (input map[string]interface{}, output map[string]interface{}) {
+	input = map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"text": map[string]interface{}{
+				"type":        "string",
+				"description": "Input text to hash.",
+			},
+			"algo": map[string]interface{}{
+				"type":        "string",
+				"enum":        []interface{}{"sha256", "md5"},
+				"default":     "sha256",
+				"description": "Hash algorithm.",
+			},
+		},
+		"required": []string{"text"},
+	}
+
+	output = map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"algo": map[string]interface{}{"type": "string"},
+			"hex":  map[string]interface{}{"type": "string"},
+		},
+		"required": []string{"algo", "hex"},
+	}
+	return
+}

package/examples/example-agent/abilities/hash-go/0.0.1/go.mod

@@ -0,0 +1,3 @@
+module hash_ability
+
+go 1.21

package/examples/example-agent/agent.json

@@ -0,0 +1,39 @@
+{
+  "name": "example-agent",
+  "kind": "agent",
+  "version": "0.0.1",
+  "license": "MIT",
+  "description": "Example agent that calls echo-js ability written in Javascript and hash-go written Golang if you have it",
+  "repo": "",
+  "lib": "",
+  "brokers": {
+    "local": "ws://127.0.0.1:8080",
+    "remote": "ws://146.190.121.213:8080"
+  },
+  "abilities": {
+    "echo-js": "0.0.1",
+    "hash-go": "0.0.1",
+    "nlp-py": "0.0.1"
+  },
+  "scripts": {
+    "preflight": "npm uninstall @kadi.build/core && npm cache clean --force && npm pack ../../ && npm install kadi.build-core-0.0.1-alpha.2.tgz && rm kadi.build-core-0.0.1-alpha.2.tgz",
+    "setup": "kadi install ../example-abilities/* --force && npm install",
+    "start": "node index.js",
+    "stop": "",
+    "clean": "rm -rf node_modules && rm -rf abilities"
+  },
+  "deploy": {
+    "services": {
+      "example-agent": {
+        "image": "example-agent:0.0.1",
+        "ports": ["8080:8080"],
+        "stdin_open": true,
+        "tty": true,
+        "networks": ["net"]
+      }
+    },
+    "networks": {
+      "net": {}
+    }
+  }
+}

package/examples/example-agent/index.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+// npm install ../../kadi.build-core-0.0.1-alpha.2.tgz
+import { loadAbility } from '@kadi.build/core';
+
+async function main() {
+  console.log('🎬 KADI LoadAbility Mechanism Demo');
+  console.log('====================================================');
+
+  // === WORKING ABILITIES ===
+  console.log('\n✅ === WORKING ABILITIES ===');
+
+  // try {
+  //   console.log('\n🔧 Loading hash-go ability (Go)...');
+  //   let goAbility = await loadAbility('hash-go');
+  //   console.log('Available methods:', goAbility.__list());
+  //   const hashGoResult = await goAbility.digest({
+  //     text: 'I am calling hash-go digest method from Javascript',
+  //     algo: 'sha256'
+  //   });
+  //   console.log('Go digest result:', hashGoResult);
+
+  //   // This is done on purpose to test the error handling
+  //   const someFunctionResult = await goAbility.someFunction({
+  //     message: 'this function does not exist'
+  //   });
+
+  //   console.log('Go ability someFunction result:', someFunctionResult);
+  // } catch (err) {
+  //   console.error('❌ hash-go failed:', err.message);
+  // }
+
+  try {
+    console.log('\n🔧 Loading echo-js ability using native (Javascript)...');
+    let echoJsAbility = await loadAbility('echo-js');
+
+    // Subscribe first
+    echoJsAbility.events.on('echo:test-event', (data) => {
+      console.log(`[NATIVE] echo:test-event received:`, data);
+    });
+
+    console.log('Available methods:', echoJsAbility.__list());
+    const echoJsResult = await echoJsAbility.echo({
+      message: 'I am calling echo-js echo method from Javascript'
+    });
+    console.log('Echo-js echo result:', echoJsResult);
+  } catch (err) {
+    console.error('❌ echo-js failed:', err.message);
+  }
+
+  try {
+    console.log('\n🔧 Loading echo-js ability using stdio (Javascript)...');
+    let echoJsAbility = await loadAbility('echo-js', 'stdio');
+    console.log('Available methods:', echoJsAbility.__list());
+
+    // Subscribe first
+    echoJsAbility.events.on('echo:test-event', (data) => {
+      console.log(`[STDIO] echo:test-event received:`, data);
+    });
+    // Now trigger the method that emits the event
+    const echoJsResult = await echoJsAbility.echo({
+      message: 'I am calling echo-js echo method from Javascript'
+    });
+
+    console.log('Echo-js echo result:', echoJsResult);
+  } catch (err) {
+    console.error('❌ echo-js failed:', err.message);
+  }
+
+  // try {
+  //   console.log('\n🔧 Loading echo-js ability using broker (Javascript)...');
+  //   let echoJsAbility = await loadAbility('echo-js', 'broker');
+  //   console.log('Available methods:', echoJsAbility.__list());
+  //   const echoJsResult = await echoJsAbility.echo({
+  //     message:
+  //       'I am calling echo-js echo method from Javascript - ability speaking through Broker - open your browser to http://kadi.build/network.html to see the network'
+  //   });
+  //   console.log('Echo-js ability result:', echoJsResult);
+
+  //   const sayMessageResult = await echoJsAbility.say_message({
+  //     message: 'I am calling echo-js say_message method from Javascript'
+  //   });
+  //   console.log('say_message result:', sayMessageResult);
+  // } catch (err) {
+  //   console.error('❌ echo-js failed:', err.message);
+  // }
+}
+
+// Start the agent
+main().catch((err) => {
+  // Display a concise, user-friendly message
+  console.error('❌ ' + (err?.message || err));
+  // Exit gracefully (0) so parent runner does not
+  // print an additional stack trace
+  process.exit(0);
+});
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\nShutting down...');
+  process.exit(0);
+});

package/examples/example-agent/package-lock.json

@@ -0,0 +1,93 @@
+{
+  "name": "example-agent",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "example-agent",
+      "version": "0.0.1",
+      "license": "ISC",
+      "dependencies": {
+        "@kadi.build/core": "file:kadi.build-core-0.0.1-alpha.2.tgz"
+      }
+    },
+    "node_modules/@kadi.build/core": {
+      "version": "0.0.1-alpha.2",
+      "resolved": "file:kadi.build-core-0.0.1-alpha.2.tgz",
+      "integrity": "sha512-CLLvPCq6ZiUWb0pSIIUfBJdpbsB23J8Ie0lZ8OynTO9j98cOfUISMIBo4iL3vgMVA7E0UNf1hD+whVBWQSdqeA==",
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^5.5.0",
+        "debug": "^4.4.1",
+        "events": "^3.3.0",
+        "ws": "^8.16.0"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.0.tgz",
+      "integrity": "sha512-46QrSQFyVSEyYAgQ22hQ+zDa60YHA4fBstHmtSApj1Y5vKtG27fWowW03jCk5KcbXEWPZUIR894aARCA/G1kfQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/events": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.x"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package/examples/example-agent/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "example-agent",
+  "version": "0.0.1",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@kadi.build/core": "file:kadi.build-core-0.0.1-alpha.2.tgz"
+  }
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@kadi.build/core",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.1-alpha.3",
   "description": "A module that is a comprehensive toolkit for developers integrating with the KADI infrastructure.",
-  "main": "index.js",
+  "main": "src/index.js",
   "type": "module",
   "scripts": {
     "format": "prettier --write .",
@@ -17,6 +17,8 @@
   ],
   "license": "MIT",
   "dependencies": {
+    "chalk": "^5.5.0",
+    "debug": "^4.4.1",
     "events": "^3.3.0",
     "ws": "^8.16.0"
   },