@pooder/core 2.0.0 → 2.1.0

package/dist/index.mjs

@@ -245,6 +245,11 @@ var ExtensionManager = class {
       const commandService = this.context.services.get("CommandService");
       return commandService.registerCommand(item.id, item.data.handler);
     }
+    if (pointId === ContributionPointIds.TOOLS) {
+      const toolRegistry = this.context.services.get("ToolRegistryService");
+      if (!toolRegistry) return;
+      return toolRegistry.registerTool(item.data);
+    }
   }
   unregister(name) {
     const extension = this.extensionRegistry.get(name);
@@ -447,27 +452,286 @@ var ConfigurationService = class {
   }
 };
 
+// src/services/ToolRegistryService.ts
+var ToolRegistryService = class {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
+  registerTool(tool) {
+    if (!(tool == null ? void 0 : tool.id)) {
+      throw new Error("ToolContribution.id is required.");
+    }
+    this.tools.set(tool.id, tool);
+    return {
+      dispose: () => {
+        if (this.tools.get(tool.id) === tool) {
+          this.tools.delete(tool.id);
+        }
+      }
+    };
+  }
+  unregisterTool(toolId) {
+    this.tools.delete(toolId);
+  }
+  getTool(toolId) {
+    return this.tools.get(toolId);
+  }
+  listTools() {
+    return Array.from(this.tools.values());
+  }
+  hasTool(toolId) {
+    return this.tools.has(toolId);
+  }
+  dispose() {
+    this.tools.clear();
+  }
+};
+
+// src/services/ToolSessionService.ts
+var ToolSessionService = class {
+  constructor() {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.dirtyTrackers = /* @__PURE__ */ new Map();
+  }
+  setCommandService(commandService) {
+    this.commandService = commandService;
+  }
+  setToolRegistry(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+  }
+  registerDirtyTracker(toolId, callback) {
+    const wrapped = () => {
+      try {
+        return callback();
+      } catch (e) {
+        return false;
+      }
+    };
+    this.dirtyTrackers.set(toolId, wrapped);
+    return {
+      dispose: () => {
+        if (this.dirtyTrackers.get(toolId) === wrapped) {
+          this.dirtyTrackers.delete(toolId);
+        }
+      }
+    };
+  }
+  ensureSession(toolId) {
+    const existing = this.sessions.get(toolId);
+    if (existing) return existing;
+    const created = {
+      toolId,
+      status: "idle",
+      dirty: false
+    };
+    this.sessions.set(toolId, created);
+    return created;
+  }
+  getState(toolId) {
+    return { ...this.ensureSession(toolId) };
+  }
+  isDirty(toolId) {
+    const tracker = this.dirtyTrackers.get(toolId);
+    if (tracker) return tracker();
+    return this.ensureSession(toolId).dirty;
+  }
+  markDirty(toolId, dirty = true) {
+    const session = this.ensureSession(toolId);
+    session.dirty = dirty;
+    session.lastUpdatedAt = Date.now();
+  }
+  resolveTool(toolId) {
+    var _a;
+    return (_a = this.toolRegistry) == null ? void 0 : _a.getTool(toolId);
+  }
+  async runCommand(commandId, ...args) {
+    if (!commandId || !this.commandService) return void 0;
+    return await this.commandService.executeCommand(commandId, ...args);
+  }
+  async begin(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    const session = this.ensureSession(toolId);
+    if (session.status === "active") return;
+    await this.runCommand((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.begin);
+    session.status = "active";
+    session.startedAt = Date.now();
+    session.lastUpdatedAt = session.startedAt;
+  }
+  async validate(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    if (!((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.validate)) {
+      return { ok: true };
+    }
+    const result = await this.runCommand(tool.commands.validate);
+    if (result === false) return { ok: false, result };
+    if (result && typeof result === "object" && "ok" in result) {
+      return { ok: Boolean(result.ok), result };
+    }
+    return { ok: true, result };
+  }
+  async commit(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    const validateResult = await this.validate(toolId);
+    if (!validateResult.ok) return validateResult;
+    const result = await this.runCommand((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.commit);
+    const session = this.ensureSession(toolId);
+    session.dirty = false;
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+    return { ok: true, result };
+  }
+  async rollback(toolId) {
+    var _a, _b;
+    const tool = this.resolveTool(toolId);
+    await this.runCommand(((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.rollback) || ((_b = tool == null ? void 0 : tool.commands) == null ? void 0 : _b.reset));
+    const session = this.ensureSession(toolId);
+    session.dirty = false;
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+  }
+  deactivateSession(toolId) {
+    const session = this.ensureSession(toolId);
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+  }
+  async handleBeforeLeave(toolId) {
+    var _a, _b;
+    const tool = this.resolveTool(toolId);
+    if (!tool) return { decision: "allow" };
+    if (tool.interaction !== "session") return { decision: "allow" };
+    const dirty = this.isDirty(toolId);
+    if (!dirty) return { decision: "allow" };
+    const leavePolicy = (_b = (_a = tool.session) == null ? void 0 : _a.leavePolicy) != null ? _b : "block";
+    if (leavePolicy === "commit") {
+      const committed = await this.commit(toolId);
+      if (!committed.ok) {
+        return { decision: "blocked", reason: "session-validation-failed" };
+      }
+      return { decision: "allow" };
+    }
+    if (leavePolicy === "rollback") {
+      await this.rollback(toolId);
+      return { decision: "allow" };
+    }
+    return { decision: "blocked", reason: "session-dirty" };
+  }
+  dispose() {
+    this.sessions.clear();
+    this.dirtyTrackers.clear();
+  }
+};
+
 // src/services/WorkbenchService.ts
 var WorkbenchService = class {
   constructor() {
     this._activeToolId = null;
+    this.guards = [];
   }
   init() {
   }
   dispose() {
+    this.guards = [];
   }
   setEventBus(bus) {
     this.eventBus = bus;
   }
+  setToolRegistry(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+  }
+  setToolSessionService(sessionService) {
+    this.sessionService = sessionService;
+  }
   get activeToolId() {
     return this._activeToolId;
   }
-  activate(id) {
-    var _a;
-    if (this._activeToolId === id) return;
+  registerSwitchGuard(guard, priority = 0) {
+    const item = { guard, priority };
+    this.guards.push(item);
+    this.guards.sort((a, b) => b.priority - a.priority);
+    return {
+      dispose: () => {
+        const index = this.guards.indexOf(item);
+        if (index >= 0) this.guards.splice(index, 1);
+      }
+    };
+  }
+  async runGuards(context) {
+    for (const { guard } of this.guards) {
+      const allowed = await Promise.resolve(guard(context));
+      if (!allowed) return false;
+    }
+    return true;
+  }
+  async switchTool(id, options) {
+    var _a, _b, _c, _d, _e;
+    if (this._activeToolId === id) {
+      return { ok: true, from: this._activeToolId, to: id };
+    }
+    if (id && this.toolRegistry && !this.toolRegistry.hasTool(id)) {
+      return {
+        ok: false,
+        from: this._activeToolId,
+        to: id,
+        reason: `tool-not-registered:${id}`
+      };
+    }
+    const context = {
+      from: this._activeToolId,
+      to: id,
+      reason: options == null ? void 0 : options.reason
+    };
+    const guardAllowed = await this.runGuards(context);
+    if (!guardAllowed) {
+      (_a = this.eventBus) == null ? void 0 : _a.emit("tool:switch:blocked", {
+        ...context,
+        reason: "blocked-by-guard"
+      });
+      return {
+        ok: false,
+        from: this._activeToolId,
+        to: id,
+        reason: "blocked-by-guard"
+      };
+    }
+    if (context.from && this.sessionService) {
+      const leaveResult = await this.sessionService.handleBeforeLeave(
+        context.from
+      );
+      if (leaveResult.decision === "blocked") {
+        (_b = this.eventBus) == null ? void 0 : _b.emit("tool:switch:blocked", {
+          ...context,
+          reason: leaveResult.reason || "session-blocked"
+        });
+        return {
+          ok: false,
+          from: this._activeToolId,
+          to: id,
+          reason: leaveResult.reason || "session-blocked"
+        };
+      }
+      this.sessionService.deactivateSession(context.from);
+    }
+    if (id && this.sessionService && this.toolRegistry) {
+      const tool = this.toolRegistry.getTool(id);
+      if ((tool == null ? void 0 : tool.interaction) === "session" && ((_c = tool.session) == null ? void 0 : _c.autoBegin) !== false) {
+        await this.sessionService.begin(id);
+      }
+    }
     const previous = this._activeToolId;
     this._activeToolId = id;
-    (_a = this.eventBus) == null ? void 0 : _a.emit("tool:activated", { id, previous });
+    const reason = options == null ? void 0 : options.reason;
+    (_d = this.eventBus) == null ? void 0 : _d.emit("tool:activated", { id, previous, reason });
+    (_e = this.eventBus) == null ? void 0 : _e.emit("tool:switch", { from: previous, to: id, reason });
+    return { ok: true, from: previous, to: id };
+  }
+  async activate(id) {
+    return await this.switchTool(id, { reason: "activate" });
+  }
+  async deactivate() {
+    return await this.switchTool(null, { reason: "deactivate" });
   }
 };
 
@@ -482,8 +746,16 @@ var Pooder = class {
     this.registerService(commandService, "CommandService");
     const configurationService = new ConfigurationService();
     this.registerService(configurationService, "ConfigurationService");
+    const toolRegistryService = new ToolRegistryService();
+    this.registerService(toolRegistryService, "ToolRegistryService");
+    const toolSessionService = new ToolSessionService();
+    toolSessionService.setCommandService(commandService);
+    toolSessionService.setToolRegistry(toolRegistryService);
+    this.registerService(toolSessionService, "ToolSessionService");
     const workbenchService = new WorkbenchService();
     workbenchService.setEventBus(this.eventBus);
+    workbenchService.setToolRegistry(toolRegistryService);
+    workbenchService.setToolSessionService(toolSessionService);
     this.registerService(workbenchService, "WorkbenchService");
     const context = {
       eventBus: this.eventBus,
@@ -577,5 +849,7 @@ export {
   ExtensionRegistry,
   Pooder,
   ServiceRegistry,
+  ToolRegistryService,
+  ToolSessionService,
   WorkbenchService
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pooder/core",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Core logic for Pooder editor",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/command.ts

@@ -1,10 +1,10 @@
-export interface CommandArgSchema {}
-
-export interface Command {
-  id: string;
-  handler: (...args: any[]) => any;
-  title?: string;
-  category?: string;
-  description?: string;
-  schema?: Record<string, CommandArgSchema>;
-}
+export interface CommandArgSchema {}
+
+export interface Command {
+  id: string;
+  handler: (...args: any[]) => any;
+  title?: string;
+  category?: string;
+  description?: string;
+  schema?: Record<string, CommandArgSchema>;
+}

package/src/context.ts

@@ -1,17 +1,17 @@
-import EventBus from "./event";
-import { Contribution } from "./contribution";
-import { Service } from "./service";
-import Disposable from "./disposable";
-
-interface ExtensionContext {
-  readonly eventBus: EventBus;
-  readonly services: {
-    get<T extends Service>(serviceName: string): T | undefined;
-  };
-  readonly contributions: {
-    get<T>(pointId: string): Contribution<T>[];
-    register<T>(pointId: string, contribution: Contribution<T>): Disposable;
-  };
-}
-
-export { ExtensionContext };
+import EventBus from "./event";
+import { Contribution } from "./contribution";
+import { Service } from "./service";
+import Disposable from "./disposable";
+
+interface ExtensionContext {
+  readonly eventBus: EventBus;
+  readonly services: {
+    get<T extends Service>(serviceName: string): T | undefined;
+  };
+  readonly contributions: {
+    get<T>(pointId: string): Contribution<T>[];
+    register<T>(pointId: string, contribution: Contribution<T>): Disposable;
+  };
+}
+
+export { ExtensionContext };

package/src/contribution/index.ts

@@ -1,12 +1,12 @@
-export * from "./points";
-export * from "./registry";
-
-export interface ContributionMetadata {
-  name: string;
-  extensionId: string;
-}
-export interface Contribution<T = any> {
-  id: string;
-  data: T;
-  metadata?: Partial<ContributionMetadata>;
-}
+export * from "./points";
+export * from "./registry";
+
+export interface ContributionMetadata {
+  name: string;
+  extensionId: string;
+}
+export interface Contribution<T = any> {
+  id: string;
+  data: T;
+  metadata?: Partial<ContributionMetadata>;
+}

package/src/contribution/points.ts

@@ -17,12 +17,36 @@ export interface CommandContribution {
 /**
  * Tool Contribution Data Definition
  */
+export type ToolInteraction = "instant" | "session" | "hybrid";
+
+export type ToolSessionLeavePolicy = "block" | "commit" | "rollback";
+
+export interface ToolCommandBindings {
+  execute?: string;
+  begin?: string;
+  validate?: string;
+  commit?: string;
+  rollback?: string;
+  reset?: string;
+}
+
 export interface ToolContribution {
   id: string;
   name: string;
-  description: string;
-  parameters?: Record<string, any>; // JSON Schema for parameters
-  execute: (...args: any[]) => Promise<any>;
+  description?: string;
+  icon?: string;
+  interaction: ToolInteraction;
+  parameters?: Record<string, any>;
+  commands?: ToolCommandBindings;
+  view?: {
+    id?: string;
+    type?: "sidebar" | "panel" | "editor" | "dialog";
+    location?: string;
+  };
+  session?: {
+    autoBegin?: boolean;
+    leavePolicy?: ToolSessionLeavePolicy;
+  };
 }
 
 /**