@pulse-editor/shared-utils 0.0.1 → 0.1.0

package/dist/imc/inter-module-communication.d.ts

@@ -0,0 +1,18 @@
+import { IMCMessageTypeEnum, ReceiverHandlerMap } from "../types/types";
+export declare class InterModuleCommunication {
+    private thisWindow;
+    private otherWindow;
+    private thisPendingTasks;
+    private otherPendingMessages;
+    private receiver;
+    private sender;
+    private moduleName;
+    private receiverHandlerMap;
+    private listener;
+    constructor(moduleName: string);
+    initThisWindow(window: Window): void;
+    initOtherWindow(window: Window): void;
+    close(): void;
+    sendMessage(type: IMCMessageTypeEnum, payload?: any, abortSignal?: AbortSignal): Promise<any>;
+    updateReceiverHandlerMap(receiverHandlerMap: ReceiverHandlerMap): void;
+}

package/dist/imc/inter-module-communication.js

@@ -0,0 +1 @@
+import{IMCMessageTypeEnum as e}from"../types/types.js";import{messageTimeout as s}from"../types/constants.js";import{MessageReceiver as i}from"./message-receiver.js";import{MessageSender as t}from"./message-sender.js";class r{constructor(e){this.moduleName=e}initThisWindow(e){this.thisWindow=e,this.receiverHandlerMap=new Map,this.thisPendingTasks=new Map;const s=new i(this.receiverHandlerMap,this.thisPendingTasks,this.moduleName);this.receiver=s,this.listener=e=>{if(!s)throw new Error("Receiver not initialized at module "+this.moduleName);const i=e.data,t=e.source;s.receiveMessage(t,i)},e.addEventListener("message",this.listener),console.log("Adding IMC listener in "+this.moduleName)}initOtherWindow(i){this.otherWindow=i,this.otherPendingMessages=new Map;const r=new t(i,s,this.otherPendingMessages,this.moduleName);if(this.sender=r,!this.receiverHandlerMap)throw new Error("You must initialize the current window first.");this.receiverHandlerMap.set(e.Acknowledge,(async(e,s)=>{const i=this.otherPendingMessages?.get(s.id);i&&(i.resolve(s.payload),this.otherPendingMessages?.delete(s.id))}))}close(){this.listener&&window.removeEventListener("message",this.listener)}async sendMessage(e,s,i){if(!this.sender)throw new Error("Sender not initialized");return await this.sender.sendMessage(e,s,i)}updateReceiverHandlerMap(e){if(!this.receiver)throw new Error("Receiver not initialized");this.receiverHandlerMap?.clear(),e.forEach(((e,s)=>{this.receiverHandlerMap?.set(s,e)}))}}export{r as InterModuleCommunication};

package/dist/imc/message-receiver.d.ts

@@ -0,0 +1,11 @@
+import { IMCMessage, ReceiverHandlerMap } from "../types/types";
+export declare class MessageReceiver {
+    private handlerMap;
+    private pendingTasks;
+    private moduleName;
+    constructor(listenerMap: ReceiverHandlerMap, pendingTasks: Map<string, {
+        controller: AbortController;
+    }>, moduleInfo: string);
+    receiveMessage(senderWindow: Window, message: IMCMessage): void;
+    private acknowledgeSender;
+}

package/dist/imc/message-receiver.js

@@ -0,0 +1 @@
+import{IMCMessageTypeEnum as e}from"../types/types.js";class s{constructor(e,s,o){this.handlerMap=e,this.pendingTasks=s,this.moduleName=o}receiveMessage(s,o){if(this.moduleName===o.from)return;if("development"===process.env.NODE_ENV&&console.log(`Module ${this.moduleName} received message from module ${o.from}:\n ${JSON.stringify(o)}`),o.type===e.Abort){const e=o.id,s=this.pendingTasks.get(e);return void(s&&(console.log("Aborting task",e),s.controller.abort(),this.pendingTasks.delete(e)))}const t=this.handlerMap.get(o.type);if(t){const n=new AbortController,i=n.signal;this.pendingTasks.set(o.id,{controller:n});t(s,o,i).then((t=>{i.aborted||o.type!==e.Acknowledge&&this.acknowledgeSender(s,o.id,t)})).catch((t=>{const n={id:o.id,type:e.Error,payload:t.message,from:this.moduleName};s.postMessage(n,"*")})).finally((()=>{this.pendingTasks.delete(o.id)}))}}acknowledgeSender(s,o,t){const n={id:o,type:e.Acknowledge,payload:t,from:this.moduleName};s.postMessage(n,"*")}}export{s as MessageReceiver};

package/dist/imc/message-sender.d.ts

@@ -0,0 +1,12 @@
+import { IMCMessageTypeEnum } from "../types/types";
+export declare class MessageSender {
+    private targetWindow;
+    private timeout;
+    private pendingMessages;
+    private moduleName;
+    constructor(targetWindow: Window, timeout: number, pendingMessages: Map<string, {
+        resolve: (result: any) => void;
+        reject: () => void;
+    }>, moduleInfo: string);
+    sendMessage(handlingType: IMCMessageTypeEnum, payload?: any, abortSignal?: AbortSignal): Promise<any>;
+}

package/dist/imc/message-sender.js

@@ -0,0 +1 @@
+import{IMCMessageTypeEnum as e}from"../types/types.js";class t{constructor(e,t,s,r){this.targetWindow=e,this.timeout=t,this.pendingMessages=s,this.moduleName=r}async sendMessage(t,s,r){const o=(new Date).getTime().toString(),i={id:o,type:t,payload:s,from:this.moduleName};return new Promise(((t,s)=>{if(r?.aborted)return s(new Error("Request aborted"));const n=()=>{this.pendingMessages.delete(o),this.targetWindow.postMessage({id:o,type:e.Abort,payload:JSON.stringify({status:"Task aborted",data:null})},"*"),s(new Error("Request aborted"))};r?.addEventListener("abort",n),this.pendingMessages.set(o,{resolve:t,reject:s}),this.targetWindow.postMessage(i,"*");const a=setTimeout((()=>{this.pendingMessages.delete(o),r?.removeEventListener("abort",n),s(new Error("Communication with Pulse Editor timeout."))}),this.timeout),d=this.pendingMessages.get(o);d&&(d.resolve=e=>{clearTimeout(a),r?.removeEventListener("abort",n),t(e)},d.reject=()=>{clearTimeout(a),r?.removeEventListener("abort",n),s()})}))}}export{t as MessageSender};

package/dist/main.d.ts

@@ -0,0 +1,5 @@
+export * from "./imc/inter-module-communication";
+export * from "./imc/message-sender";
+export * from "./imc/message-receiver";
+export * from "./types/types";
+export * from "./types/constants";

package/dist/main.js

@@ -0,0 +1 @@
+export{InterModuleCommunication}from"./imc/inter-module-communication.js";export{MessageSender}from"./imc/message-sender.js";export{MessageReceiver}from"./imc/message-receiver.js";export{AccessEnum,ExtensionTypeEnum,IMCMessageTypeEnum,NotificationTypeEnum}from"./types/types.js";export{messageTimeout}from"./types/constants.js";

package/dist/types/constants.d.ts

@@ -0,0 +1 @@
+export declare const messageTimeout = 300000;

package/dist/types/constants.js

@@ -0,0 +1 @@
+const e=3e5;export{e as messageTimeout};

package/dist/types/types.d.ts

@@ -0,0 +1,119 @@
+export declare enum IMCMessageTypeEnum {
+    WriteViewFile = "write-view-file",
+    RequestViewFile = "request-view-file",
+    Fetch = "fetch",
+    Notification = "notification",
+    ThemeChange = "theme-change",
+    InstallAgent = "install-agent",
+    RunAgentMethod = "run-agent-method",
+    InstallAgentTool = "install-agent-tool",
+    OCR = "ocr",
+    RequestTerminal = "request-terminal",
+    Ready = "ready",
+    Loaded = "loaded",
+    Acknowledge = "acknowledge",
+    Abort = "abort",
+    Error = "error"
+}
+export type IMCMessage = {
+    id: string;
+    from: string;
+    type: IMCMessageTypeEnum;
+    payload?: any;
+};
+export type ReceiverHandlerMap = Map<IMCMessageTypeEnum, {
+    (senderWindow: Window, message: IMCMessage, abortSignal?: AbortSignal): Promise<any>;
+}>;
+export type TextFileSelection = {
+    lineStart: number;
+    lineEnd: number;
+    text: string;
+};
+export type FileViewModel = {
+    fileContent: string;
+    filePath: string;
+    selections?: TextFileSelection[];
+    isActive: boolean;
+};
+export type FetchPayload = {
+    uri: string;
+    options?: RequestInit;
+};
+export declare enum NotificationTypeEnum {
+    Success = "success",
+    Error = "error",
+    Info = "info",
+    Warning = "warning"
+}
+export declare enum ExtensionTypeEnum {
+    Generic = "generic",
+    FileView = "file-view",
+    ConsoleView = "console-view"
+}
+export type ExtensionConfig = {
+    id: string;
+    version: string;
+    author?: string;
+    displayName?: string;
+    description?: string;
+    materialIcon?: string;
+    extensionType?: ExtensionTypeEnum;
+    fileTypes?: string[];
+    preview?: string;
+    enabledPlatforms?: Record<string, boolean>;
+};
+export type Agent = {
+    name: string;
+    version: string;
+    systemPrompt: string;
+    availableMethods: AgentMethod[];
+    LLMConfig: LLMConfig;
+    description: string;
+    tools?: AgentTool[];
+};
+/**
+ * An agent method is a sub task that an agent can perform.
+ */
+export type AgentMethod = {
+    access: AccessEnum;
+    name: string;
+    parameters: Record<string, AgentVariable>;
+    prompt: string;
+    returns: Record<string, AgentVariable>;
+    LLMConfig?: LLMConfig;
+};
+export type AgentVariable = {
+    type: AgentVariableType;
+    description: string;
+};
+export type AgentVariableType = "string" | "number" | "boolean" | AgentVariableTypeArray;
+type AgentVariableTypeArray = {
+    size: number;
+    elementType: AgentVariableType;
+};
+/**
+ * A tool that agent can use during method execution.
+ *
+ * This is linked to a callback function created by user,
+ * tool developer, or extension.
+ *
+ * The tool may optionally return a value to running
+ * agent method.
+ */
+export type AgentTool = {
+    access: AccessEnum;
+    name: string;
+    description: string;
+    parameters: Record<string, AgentVariable>;
+    returns: Record<string, AgentVariable>;
+};
+export type LLMConfig = {
+    provider: string;
+    modelName: string;
+    temperature: number;
+};
+export declare enum AccessEnum {
+    public = "public",
+    private = "private"
+}
+export {};

package/dist/types/types.js

@@ -0,0 +1 @@
+var e,i,n,t;!function(e){e.WriteViewFile="write-view-file",e.RequestViewFile="request-view-file",e.Fetch="fetch",e.Notification="notification",e.ThemeChange="theme-change",e.InstallAgent="install-agent",e.RunAgentMethod="run-agent-method",e.InstallAgentTool="install-agent-tool",e.OCR="ocr",e.RequestTerminal="request-terminal",e.Ready="ready",e.Loaded="loaded",e.Acknowledge="acknowledge",e.Abort="abort",e.Error="error"}(e||(e={})),function(e){e.Success="success",e.Error="error",e.Info="info",e.Warning="warning"}(i||(i={})),function(e){e.Generic="generic",e.FileView="file-view",e.ConsoleView="console-view"}(n||(n={})),function(e){e.public="public",e.private="private"}(t||(t={}));export{t as AccessEnum,n as ExtensionTypeEnum,e as IMCMessageTypeEnum,i as NotificationTypeEnum};

package/package.json

@@ -1,13 +1,30 @@
-{
-    "name": "@pulse-editor/shared-utils",
-    "version": "0.0.1",
-    "type": "module",
-    "main": "src/main.ts",
-    "dependencies": {
-        "@pulse-editor/types": "*",
-        "typescript": "^5.7.3"
-    },
-    "devDependencies": {
-        "@types/node": "^22.13.1"
-    }
-}
+{
+    "name": "@pulse-editor/shared-utils",
+    "version": "0.1.0",
+    "main": "dist/main.js",
+    "type": "module",
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "rollup -c",
+        "lint": "eslint ."
+    },
+    "devDependencies": {
+        "@babel/core": "^7.26.10",
+        "@babel/preset-env": "^7.26.9",
+        "@eslint/js": "^9.25.0",
+        "@rollup/plugin-babel": "^6.0.4",
+        "@rollup/plugin-node-resolve": "^16.0.1",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^12.1.2",
+        "@types/node": "^22.13.1",
+        "eslint": "^9.25.0",
+        "rollup": "^4.40.0",
+        "typescript": "^5.8.3",
+        "typescript-eslint": "^8.30.1"
+    }
+}

package/src/inter-module-communication.ts

@@ -1,137 +0,0 @@
-import {
-  messageTimeout,
-  IMCMessage,
-  IMCMessageTypeEnum,
-  ReceiverHandlerMap,
-} from "@pulse-editor/types";
-import { MessageReceiver } from "./message-receiver";
-import { MessageSender } from "./message-sender";
-
-export class InterModuleCommunication {
-  private thisWindow: Window | undefined;
-  private otherWindow: Window | undefined;
-
-  /* Wait current module to finish tasks to return a response or acknowledgement. */
-  private thisPendingTasks:
-    | Map<
-        string,
-        {
-          controller: AbortController;
-        }
-      >
-    | undefined;
-
-  /* Wait the other module to return a response or acknowledgement. */
-  private otherPendingMessages:
-    | Map<
-        string,
-        {
-          resolve: (result: any) => void;
-          reject: () => void;
-        }
-      >
-    | undefined;
-
-  private receiver: MessageReceiver | undefined;
-  private sender: MessageSender | undefined;
-
-  private moduleName: string;
-
-  private receiverHandlerMap: ReceiverHandlerMap | undefined;
-
-  private listener: ((event: MessageEvent) => void) | undefined;
-
-  constructor(moduleName: string) {
-    this.moduleName = moduleName;
-  }
-
-  /* Initialize a receiver to receive message. */
-  public initThisWindow(window: Window) {
-    this.thisWindow = window;
-    this.receiverHandlerMap = new Map();
-    this.thisPendingTasks = new Map();
-
-    const receiver = new MessageReceiver(
-      this.receiverHandlerMap,
-      this.thisPendingTasks,
-      this.moduleName
-    );
-    this.receiver = receiver;
-
-    this.listener = (event: MessageEvent<IMCMessage>) => {
-      if (!receiver) {
-        throw new Error(
-          "Receiver not initialized at module " + this.moduleName
-        );
-      }
-
-      const message = event.data;
-      const win = event.source as Window;
-      receiver.receiveMessage(win, message);
-    };
-    window.addEventListener("message", this.listener);
-    console.log("Adding IMC listener in " + this.moduleName);
-  }
-
-  /* Initialize a sender to send message ot the other window. */
-  public initOtherWindow(window: Window) {
-    this.otherWindow = window;
-    this.otherPendingMessages = new Map();
-
-    const sender = new MessageSender(
-      window,
-      messageTimeout,
-      this.otherPendingMessages,
-      this.moduleName
-    );
-    this.sender = sender;
-
-    if (!this.receiverHandlerMap) {
-      throw new Error("You must initialize the current window first.");
-    }
-
-    // Add an acknowledgement handler in current window's receiver for results of sent messages.
-    // The current window must be initialized first. i.e. call initThisWindow() before initOtherWindow().
-    this.receiverHandlerMap.set(
-      IMCMessageTypeEnum.Acknowledge,
-      async (senderWindow: Window, message: IMCMessage) => {
-        const pendingMessage = this.otherPendingMessages?.get(message.id);
-        if (pendingMessage) {
-          pendingMessage.resolve(message.payload);
-          this.otherPendingMessages?.delete(message.id);
-        }
-      }
-    );
-  }
-
-  public close() {
-    if (this.listener) {
-      window.removeEventListener("message", this.listener);
-    }
-  }
-
-  public async sendMessage(
-    type: IMCMessageTypeEnum,
-    payload?: any,
-    abortSignal?: AbortSignal
-  ): Promise<any> {
-    if (!this.sender) {
-      throw new Error("Sender not initialized");
-    }
-
-    return await this.sender.sendMessage(type, payload, abortSignal);
-  }
-
-  public updateReceiverHandlerMap(
-    receiverHandlerMap: ReceiverHandlerMap
-  ): void {
-    if (!this.receiver) {
-      throw new Error("Receiver not initialized");
-    }
-
-    this.receiverHandlerMap?.clear();
-    receiverHandlerMap.forEach((value, key) => {
-      this.receiverHandlerMap?.set(key, value);
-    });
-  }
-}

package/src/main.ts

@@ -1,5 +0,0 @@
-import { InterModuleCommunication } from "./inter-module-communication";
-import { MessageReceiver } from "./message-receiver";
-import { MessageSender } from "./message-sender";
-
-export { MessageReceiver, MessageSender, InterModuleCommunication };

package/src/message-receiver.ts

@@ -1,110 +0,0 @@
-import {
-  IMCMessage,
-  IMCMessageTypeEnum,
-  ReceiverHandlerMap,
-} from "@pulse-editor/types";
-
-export class MessageReceiver {
-  private handlerMap: ReceiverHandlerMap;
-  private pendingTasks: Map<
-    string,
-    {
-      controller: AbortController;
-    }
-  >;
-  private moduleName: string;
-
-  constructor(
-    listenerMap: ReceiverHandlerMap,
-    pendingTasks: Map<
-      string,
-      {
-        controller: AbortController;
-      }
-    >,
-    moduleInfo: string
-  ) {
-    this.handlerMap = listenerMap;
-    this.pendingTasks = pendingTasks;
-    this.moduleName = moduleInfo;
-  }
-
-  public receiveMessage(senderWindow: Window, message: IMCMessage) {
-    // Not handling messages from self
-    if (this.moduleName === message.from) return;
-
-    // Log the message in dev mode
-    if (process.env.NODE_ENV === "development") {
-      console.log(
-        `Module ${this.moduleName} received message from module ${message.from}:\n ${JSON.stringify(
-          message
-        )}`
-      );
-    }
-
-    // Abort the task if the message type is Abort
-    if (message.type === IMCMessageTypeEnum.Abort) {
-      const id = message.id;
-      const pendingTask = this.pendingTasks.get(id);
-
-      if (pendingTask) {
-        console.log("Aborting task", id);
-        pendingTask.controller.abort();
-        this.pendingTasks.delete(id);
-      }
-
-      return;
-    }
-
-    const handler = this.handlerMap.get(message.type);
-    if (handler) {
-      // Create abort controller to listen for abort signal from sender.
-      // Then save the message id and abort controller to the pending tasks.
-      const controller = new AbortController();
-      const signal = controller.signal;
-      this.pendingTasks.set(message.id, {
-        controller,
-      });
-
-      const promise = handler(senderWindow, message, signal);
-      promise
-        .then((result) => {
-          // Don't send the result if the task has been aborted
-          if (signal.aborted) return;
-
-          // Acknowledge the sender with the result if the message type is not Acknowledge
-          if (message.type !== IMCMessageTypeEnum.Acknowledge) {
-            this.acknowledgeSender(senderWindow, message.id, result);
-          }
-        })
-        .catch((error) => {
-          // Send the error message to the sender
-          const errMsg: IMCMessage = {
-            id: message.id,
-            type: IMCMessageTypeEnum.Error,
-            payload: error.message,
-            from: this.moduleName,
-          };
-
-          senderWindow.postMessage(errMsg, "*");
-        })
-        .finally(() => {
-          this.pendingTasks.delete(message.id);
-        });
-    }
-  }
-
-  private acknowledgeSender(
-    senderWindow: Window,
-    id: string,
-    payload: any
-  ): void {
-    const message: IMCMessage = {
-      id,
-      type: IMCMessageTypeEnum.Acknowledge,
-      payload: payload,
-      from: this.moduleName,
-    };
-    senderWindow.postMessage(message, "*");
-  }
-}

package/src/message-sender.ts

@@ -1,100 +0,0 @@
-import { IMCMessage, IMCMessageTypeEnum } from "@pulse-editor/types";
-
-export class MessageSender {
-  private targetWindow: Window;
-  private timeout: number;
-
-  private pendingMessages: Map<
-    string,
-    { resolve: (result: any) => void; reject: () => void }
-  >;
-
-  private moduleName: string;
-
-  constructor(
-    targetWindow: Window,
-    timeout: number,
-    pendingMessages: Map<
-      string,
-      { resolve: (result: any) => void; reject: () => void }
-    >,
-    moduleInfo: string
-  ) {
-    this.targetWindow = targetWindow;
-    this.timeout = timeout;
-
-    this.pendingMessages = pendingMessages;
-    this.moduleName = moduleInfo;
-  }
-
-  public async sendMessage(
-    handlingType: IMCMessageTypeEnum,
-    payload?: any,
-    abortSignal?: AbortSignal
-  ): Promise<any> {
-    // Generate a unique id for the message using timestamp
-    const id = new Date().getTime().toString();
-    const message: IMCMessage = {
-      id,
-      type: handlingType,
-      payload: payload,
-      from: this.moduleName,
-    };
-
-    return new Promise((resolve, reject) => {
-      // If the signal is already aborted, reject immediately
-      if (abortSignal?.aborted) {
-        return reject(new Error("Request aborted"));
-      }
-
-      const abortHandler = () => {
-        this.pendingMessages.delete(id);
-        // Notify the target window that the request has been aborted
-        this.targetWindow.postMessage(
-          {
-            id,
-            type: IMCMessageTypeEnum.Abort,
-            payload: JSON.stringify({
-              status: "Task aborted",
-              data: null,
-            }),
-          },
-          "*"
-        );
-        reject(new Error("Request aborted"));
-      };
-      // Attach abort listener
-      abortSignal?.addEventListener("abort", abortHandler);
-
-      // Send message
-      this.pendingMessages.set(id, {
-        resolve,
-        reject,
-      });
-      this.targetWindow.postMessage(message, "*");
-
-      // Check timeout
-      const timeoutId = setTimeout(() => {
-        this.pendingMessages.delete(id);
-        abortSignal?.removeEventListener("abort", abortHandler);
-        reject(new Error("Communication with Pulse Editor timeout."));
-      }, this.timeout);
-
-      // Ensure cleanup on resolution
-      const currentMessage = this.pendingMessages.get(id);
-      if (currentMessage) {
-        currentMessage.resolve = (result) => {
-          clearTimeout(timeoutId);
-          abortSignal?.removeEventListener("abort", abortHandler);
-          resolve(result);
-        };
-
-        currentMessage.reject = () => {
-          clearTimeout(timeoutId);
-          abortSignal?.removeEventListener("abort", abortHandler);
-          reject();
-        };
-      }
-    });
-  }
-}

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2020",
-        "outDir": "./dist",
-        "module": "ESNext",
-        "moduleResolution": "bundler",
-        "strict": true,
-        "declaration": true,
-        "types": [
-            "react",
-            "node"
-        ],
-        "baseUrl": ".",
-        "paths": {
-            "*": [
-                "node_modules/*",
-                "dist/*"
-            ]
-        }
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist",
-    ]
-}