@pooder/core 1.2.0 → 2.1.0

package/src/services/WorkbenchService.ts

@@ -0,0 +1,159 @@
+import Disposable from "../disposable";
+import EventBus from "../event";
+import { Service } from "../service";
+import ToolRegistryService from "./ToolRegistryService";
+import ToolSessionService from "./ToolSessionService";
+
+export interface ToolSwitchContext {
+  from: string | null;
+  to: string | null;
+  reason?: string;
+}
+
+export interface ToolSwitchResult {
+  ok: boolean;
+  from: string | null;
+  to: string | null;
+  reason?: string;
+}
+
+export type ToolSwitchGuard = (
+  context: ToolSwitchContext,
+) => boolean | Promise<boolean>;
+
+interface GuardItem {
+  guard: ToolSwitchGuard;
+  priority: number;
+}
+
+export default class WorkbenchService implements Service {
+  private _activeToolId: string | null = null;
+  private eventBus?: EventBus;
+  private toolRegistry?: ToolRegistryService;
+  private sessionService?: ToolSessionService;
+  private guards: GuardItem[] = [];
+
+  init() {}
+
+  dispose() {
+    this.guards = [];
+  }
+
+  setEventBus(bus: EventBus) {
+    this.eventBus = bus;
+  }
+
+  setToolRegistry(toolRegistry: ToolRegistryService) {
+    this.toolRegistry = toolRegistry;
+  }
+
+  setToolSessionService(sessionService: ToolSessionService) {
+    this.sessionService = sessionService;
+  }
+
+  get activeToolId(): string | null {
+    return this._activeToolId;
+  }
+
+  registerSwitchGuard(
+    guard: ToolSwitchGuard,
+    priority: number = 0,
+  ): Disposable {
+    const item: GuardItem = { 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);
+      },
+    };
+  }
+
+  private async runGuards(context: ToolSwitchContext): Promise<boolean> {
+    for (const { guard } of this.guards) {
+      const allowed = await Promise.resolve(guard(context));
+      if (!allowed) return false;
+    }
+    return true;
+  }
+
+  async switchTool(
+    id: string | null,
+    options?: { reason?: string },
+  ): Promise<ToolSwitchResult> {
+    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: ToolSwitchContext = {
+      from: this._activeToolId,
+      to: id,
+      reason: options?.reason,
+    };
+
+    const guardAllowed = await this.runGuards(context);
+    if (!guardAllowed) {
+      this.eventBus?.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") {
+        this.eventBus?.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?.interaction === "session" && tool.session?.autoBegin !== false) {
+        await this.sessionService.begin(id);
+      }
+    }
+
+    const previous = this._activeToolId;
+    this._activeToolId = id;
+    const reason = options?.reason;
+    this.eventBus?.emit("tool:activated", { id, previous, reason });
+    this.eventBus?.emit("tool:switch", { from: previous, to: id, reason });
+    return { ok: true, from: previous, to: id };
+  }
+
+  async activate(id: string | null): Promise<ToolSwitchResult> {
+    return await this.switchTool(id, { reason: "activate" });
+  }
+
+  async deactivate(): Promise<ToolSwitchResult> {
+    return await this.switchTool(null, { reason: "deactivate" });
+  }
+}

package/src/services/index.ts

@@ -1,4 +1,13 @@
 import CommandService from "./CommandService";
 import ConfigurationService from "./ConfigurationService";
+import ToolRegistryService from "./ToolRegistryService";
+import ToolSessionService from "./ToolSessionService";
+import WorkbenchService from "./WorkbenchService";
 
-export { CommandService, ConfigurationService };
+export {
+  CommandService,
+  ConfigurationService,
+  ToolRegistryService,
+  ToolSessionService,
+  WorkbenchService,
+};

package/src/test-extension-full.ts

@@ -57,9 +57,9 @@ export const fullExtension: Extension = {
           id: "test.tool.calculator",
           name: "Calculator",
           description: "Simple calculator",
-          execute: async (op: string, a: number, b: number) => {
-            if (op === "add") return a + b;
-            return 0;
+          interaction: "instant",
+          commands: {
+            execute: "test.declarative.auto",
           },
         } as ToolContribution,
       ],