@pooder/core 1.2.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,6 +452,289 @@ 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;
+  }
+  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;
+    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" });
+  }
+};
+
 // src/index.ts
 var Pooder = class {
   constructor() {
@@ -458,6 +746,17 @@ 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,
       services: {
@@ -545,8 +844,12 @@ export {
   ConfigurationService,
   ContributionPointIds,
   ContributionRegistry,
+  event_default as EventBus,
   ExtensionManager,
   ExtensionRegistry,
   Pooder,
-  ServiceRegistry
+  ServiceRegistry,
+  ToolRegistryService,
+  ToolSessionService,
+  WorkbenchService
 };

package/package.json

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

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;
+  };
 }
 
 /**

package/src/extension.ts

@@ -3,6 +3,7 @@ import { Contribution, ContributionPointIds } from "./contribution";
 import Disposable from "./disposable";
 import CommandService from "./services/CommandService";
 import { ConfigurationService } from "./services";
+import ToolRegistryService from "./services/ToolRegistryService";
 
 interface ExtensionMetadata {
   name: string;
@@ -110,6 +111,12 @@ class ExtensionManager {
 
       return commandService.registerCommand(item.id, item.data.handler);
     }
+    if (pointId === ContributionPointIds.TOOLS) {
+      const toolRegistry =
+        this.context.services.get<ToolRegistryService>("ToolRegistryService");
+      if (!toolRegistry) return;
+      return toolRegistry.registerTool(item.data);
+    }
   }
 
   unregister(name: string) {

package/src/index.ts

@@ -8,7 +8,13 @@ import {
   ContributionPointIds,
   ContributionRegistry,
 } from "./contribution";
-import { CommandService, ConfigurationService } from "./services";
+import {
+  CommandService,
+  ConfigurationService,
+  ToolRegistryService,
+  ToolSessionService,
+  WorkbenchService,
+} from "./services";
 import { ExtensionContext } from "./context";
 
 export * from "./extension";
@@ -16,6 +22,7 @@ export * from "./context";
 export * from "./contribution";
 export * from "./service";
 export * from "./services";
+export { default as EventBus } from "./event";
 
 export class Pooder {
   readonly eventBus: EventBus = new EventBus();
@@ -34,6 +41,20 @@ export class Pooder {
     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");
+
     // Create a restricted context for extensions
     const context: ExtensionContext = {
       eventBus: this.eventBus,

package/src/services/ToolRegistryService.ts

@@ -0,0 +1,41 @@
+import { ToolContribution } from "../contribution";
+import Disposable from "../disposable";
+import { Service } from "../service";
+
+export default class ToolRegistryService implements Service {
+  private tools = new Map<string, ToolContribution>();
+
+  registerTool(tool: ToolContribution): Disposable {
+    if (!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: string) {
+    this.tools.delete(toolId);
+  }
+
+  getTool(toolId: string): ToolContribution | undefined {
+    return this.tools.get(toolId);
+  }
+
+  listTools(): ToolContribution[] {
+    return Array.from(this.tools.values());
+  }
+
+  hasTool(toolId: string): boolean {
+    return this.tools.has(toolId);
+  }
+
+  dispose() {
+    this.tools.clear();
+  }
+}

package/src/services/ToolSessionService.ts

@@ -0,0 +1,176 @@
+import { ToolContribution } from "../contribution";
+import Disposable from "../disposable";
+import { Service } from "../service";
+import CommandService from "./CommandService";
+import ToolRegistryService from "./ToolRegistryService";
+
+export type ToolSessionStatus = "idle" | "active";
+
+export interface ToolSessionState {
+  toolId: string;
+  status: ToolSessionStatus;
+  dirty: boolean;
+  startedAt?: number;
+  lastUpdatedAt?: number;
+}
+
+export type LeaveDecision = "allow" | "blocked";
+
+export interface LeaveResult {
+  decision: LeaveDecision;
+  reason?: string;
+}
+
+export default class ToolSessionService implements Service {
+  private readonly sessions = new Map<string, ToolSessionState>();
+  private commandService?: CommandService;
+  private toolRegistry?: ToolRegistryService;
+
+  setCommandService(commandService: CommandService) {
+    this.commandService = commandService;
+  }
+
+  setToolRegistry(toolRegistry: ToolRegistryService) {
+    this.toolRegistry = toolRegistry;
+  }
+
+  registerDirtyTracker(toolId: string, callback: () => boolean): Disposable {
+    const wrapped = () => {
+      try {
+        return callback();
+      } catch {
+        return false;
+      }
+    };
+    this.dirtyTrackers.set(toolId, wrapped);
+    return {
+      dispose: () => {
+        if (this.dirtyTrackers.get(toolId) === wrapped) {
+          this.dirtyTrackers.delete(toolId);
+        }
+      },
+    };
+  }
+
+  private readonly dirtyTrackers = new Map<string, () => boolean>();
+
+  private ensureSession(toolId: string): ToolSessionState {
+    const existing = this.sessions.get(toolId);
+    if (existing) return existing;
+
+    const created: ToolSessionState = {
+      toolId,
+      status: "idle",
+      dirty: false,
+    };
+    this.sessions.set(toolId, created);
+    return created;
+  }
+
+  getState(toolId: string): ToolSessionState {
+    return { ...this.ensureSession(toolId) };
+  }
+
+  isDirty(toolId: string): boolean {
+    const tracker = this.dirtyTrackers.get(toolId);
+    if (tracker) return tracker();
+    return this.ensureSession(toolId).dirty;
+  }
+
+  markDirty(toolId: string, dirty = true) {
+    const session = this.ensureSession(toolId);
+    session.dirty = dirty;
+    session.lastUpdatedAt = Date.now();
+  }
+
+  private resolveTool(toolId: string): ToolContribution | undefined {
+    return this.toolRegistry?.getTool(toolId);
+  }
+
+  private async runCommand(commandId: string | undefined, ...args: any[]) {
+    if (!commandId || !this.commandService) return undefined;
+    return await this.commandService.executeCommand(commandId, ...args);
+  }
+
+  async begin(toolId: string): Promise<void> {
+    const tool = this.resolveTool(toolId);
+    const session = this.ensureSession(toolId);
+    if (session.status === "active") return;
+
+    await this.runCommand(tool?.commands?.begin);
+    session.status = "active";
+    session.startedAt = Date.now();
+    session.lastUpdatedAt = session.startedAt;
+  }
+
+  async validate(toolId: string): Promise<{ ok: boolean; result?: any }> {
+    const tool = this.resolveTool(toolId);
+    if (!tool?.commands?.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 as any).ok), result };
+    }
+    return { ok: true, result };
+  }
+
+  async commit(toolId: string): Promise<{ ok: boolean; result?: any }> {
+    const tool = this.resolveTool(toolId);
+    const validateResult = await this.validate(toolId);
+    if (!validateResult.ok) return validateResult;
+
+    const result = await this.runCommand(tool?.commands?.commit);
+    const session = this.ensureSession(toolId);
+    session.dirty = false;
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+    return { ok: true, result };
+  }
+
+  async rollback(toolId: string): Promise<void> {
+    const tool = this.resolveTool(toolId);
+    await this.runCommand(tool?.commands?.rollback || tool?.commands?.reset);
+    const session = this.ensureSession(toolId);
+    session.dirty = false;
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+  }
+
+  deactivateSession(toolId: string) {
+    const session = this.ensureSession(toolId);
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+  }
+
+  async handleBeforeLeave(toolId: string): Promise<LeaveResult> {
+    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 = tool.session?.leavePolicy ?? "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();
+  }
+}