@pooder/core 2.0.0 → 2.2.0

package/src/services/ConfigurationService.ts

@@ -1,107 +1,107 @@
-import { Service } from "../service";
-import EventBus from "../event";
-import { ConfigurationContribution } from "../contribution";
-
-export default class ConfigurationService implements Service {
-  private configValues: Map<string, any> = new Map();
-  private eventBus: EventBus = new EventBus();
-
-  /**
-   * Get a configuration value.
-   */
-  get<T = any>(key: string, defaultValue?: T): T {
-    if (this.configValues.has(key)) {
-      return this.configValues.get(key);
-    }
-    return defaultValue as T;
-  }
-
-  /**
-   * Update a configuration value.
-   * Emits 'change' event.
-   */
-  update(key: string, value: any) {
-    const oldValue = this.configValues.get(key);
-    if (oldValue !== value) {
-      this.configValues.set(key, value);
-      this.eventBus.emit(`change:${key}`, { key, value, oldValue });
-      this.eventBus.emit("change", { key, value, oldValue });
-    }
-  }
-
-  /**
-   * Listen for changes to a specific configuration key.
-   */
-  onDidChange(
-    key: string,
-    callback: (event: { key: string; value: any; oldValue: any }) => void,
-  ) {
-    this.eventBus.on(`change:${key}`, callback);
-    return {
-      dispose: () => this.eventBus.off(`change:${key}`, callback),
-    };
-  }
-
-  /**
-   * Listen for any configuration change.
-   */
-  onAnyChange(
-    callback: (event: { key: string; value: any; oldValue: any }) => void,
-  ) {
-    this.eventBus.on("change", callback);
-    return {
-      dispose: () => this.eventBus.off("change", callback),
-    };
-  }
-
-  /**
-   * Export current configuration state as a JSON-serializable object.
-   * Useful for saving configuration templates.
-   */
-  export(): Record<string, any> {
-    const exportData: Record<string, any> = {};
-    for (const [key, value] of this.configValues) {
-      exportData[key] = value;
-    }
-    return exportData;
-  }
-
-  /**
-   * Import configuration from a JSON object.
-   * This will merge the provided configuration with the current state,
-   * overwriting existing keys and triggering change events.
-   */
-  import(data: Record<string, any>): void {
-    if (!data || typeof data !== "object") {
-      console.warn("ConfigurationService: Import data must be an object.");
-      return;
-    }
-    Object.entries(data).forEach(([key, value]) => {
-      this.update(key, value);
-    });
-  }
-
-  /**
-   * Initialize configuration with defaults from contributions.
-   * This should be called when a contribution is registered.
-   */
-  initializeDefaults(contributions: ConfigurationContribution[]) {
-    contributions.forEach((contrib) => {
-      if (!contrib.id) {
-        console.warn(
-          "Configuration contribution missing 'id'. Skipping default initialization.",
-          contrib,
-        );
-        return;
-      }
-      if (!this.configValues.has(contrib.id) && contrib.default !== undefined) {
-        this.configValues.set(contrib.id, contrib.default);
-      }
-    });
-  }
-
-  dispose() {
-    this.configValues.clear();
-    // EventBus doesn't have a clear/dispose in the snippet, but it's fine for now.
-  }
-}
+import { Service } from "../service";
+import EventBus from "../event";
+import { ConfigurationContribution } from "../contribution";
+
+export default class ConfigurationService implements Service {
+  private configValues: Map<string, any> = new Map();
+  private eventBus: EventBus = new EventBus();
+
+  /**
+   * Get a configuration value.
+   */
+  get<T = any>(key: string, defaultValue?: T): T {
+    if (this.configValues.has(key)) {
+      return this.configValues.get(key);
+    }
+    return defaultValue as T;
+  }
+
+  /**
+   * Update a configuration value.
+   * Emits 'change' event.
+   */
+  update(key: string, value: any) {
+    const oldValue = this.configValues.get(key);
+    if (oldValue !== value) {
+      this.configValues.set(key, value);
+      this.eventBus.emit(`change:${key}`, { key, value, oldValue });
+      this.eventBus.emit("change", { key, value, oldValue });
+    }
+  }
+
+  /**
+   * Listen for changes to a specific configuration key.
+   */
+  onDidChange(
+    key: string,
+    callback: (event: { key: string; value: any; oldValue: any }) => void,
+  ) {
+    this.eventBus.on(`change:${key}`, callback);
+    return {
+      dispose: () => this.eventBus.off(`change:${key}`, callback),
+    };
+  }
+
+  /**
+   * Listen for any configuration change.
+   */
+  onAnyChange(
+    callback: (event: { key: string; value: any; oldValue: any }) => void,
+  ) {
+    this.eventBus.on("change", callback);
+    return {
+      dispose: () => this.eventBus.off("change", callback),
+    };
+  }
+
+  /**
+   * Export current configuration state as a JSON-serializable object.
+   * Useful for saving configuration templates.
+   */
+  export(): Record<string, any> {
+    const exportData: Record<string, any> = {};
+    for (const [key, value] of this.configValues) {
+      exportData[key] = value;
+    }
+    return exportData;
+  }
+
+  /**
+   * Import configuration from a JSON object.
+   * This will merge the provided configuration with the current state,
+   * overwriting existing keys and triggering change events.
+   */
+  import(data: Record<string, any>): void {
+    if (!data || typeof data !== "object") {
+      console.warn("ConfigurationService: Import data must be an object.");
+      return;
+    }
+    Object.entries(data).forEach(([key, value]) => {
+      this.update(key, value);
+    });
+  }
+
+  /**
+   * Initialize configuration with defaults from contributions.
+   * This should be called when a contribution is registered.
+   */
+  initializeDefaults(contributions: ConfigurationContribution[]) {
+    contributions.forEach((contrib) => {
+      if (!contrib.id) {
+        console.warn(
+          "Configuration contribution missing 'id'. Skipping default initialization.",
+          contrib,
+        );
+        return;
+      }
+      if (!this.configValues.has(contrib.id) && contrib.default !== undefined) {
+        this.configValues.set(contrib.id, contrib.default);
+      }
+    });
+  }
+
+  dispose() {
+    this.configValues.clear();
+    // EventBus doesn't have a clear/dispose in the snippet, but it's fine for now.
+  }
+}

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,213 @@
+import { ToolContribution } from "../contribution";
+import Disposable from "../disposable";
+import { Service, ServiceContext } from "../service";
+import CommandService from "./CommandService";
+import ToolRegistryService from "./ToolRegistryService";
+import { COMMAND_SERVICE, TOOL_REGISTRY_SERVICE } from "./tokens";
+
+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;
+}
+
+interface ToolSessionServiceDependencies {
+  commandService?: CommandService;
+  toolRegistry?: ToolRegistryService;
+}
+
+export default class ToolSessionService implements Service {
+  private readonly sessions = new Map<string, ToolSessionState>();
+  private commandService?: CommandService;
+  private toolRegistry?: ToolRegistryService;
+
+  constructor(dependencies: ToolSessionServiceDependencies = {}) {
+    this.commandService = dependencies.commandService;
+    this.toolRegistry = dependencies.toolRegistry;
+  }
+
+  init(context: ServiceContext) {
+    this.commandService ??= context.get(COMMAND_SERVICE);
+    this.toolRegistry ??= context.get(TOOL_REGISTRY_SERVICE);
+
+    if (!this.commandService) {
+      throw new Error("ToolSessionService requires CommandService.");
+    }
+    if (!this.toolRegistry) {
+      throw new Error("ToolSessionService requires 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.getToolRegistry().getTool(toolId);
+  }
+
+  private async runCommand(commandId: string | undefined, ...args: any[]) {
+    if (!commandId) return undefined;
+    return await this.getCommandService().executeCommand(commandId, ...args);
+  }
+
+  private getCommandService(): CommandService {
+    if (!this.commandService) {
+      throw new Error("ToolSessionService is not initialized.");
+    }
+    return this.commandService;
+  }
+
+  private getToolRegistry(): ToolRegistryService {
+    if (!this.toolRegistry) {
+      throw new Error("ToolSessionService is not initialized.");
+    }
+    return this.toolRegistry;
+  }
+
+  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();
+  }
+}

package/src/services/WorkbenchService.ts

@@ -1,30 +1,209 @@
-import { Service } from "../service";
+import Disposable from "../disposable";
 import EventBus from "../event";
+import { Service, ServiceContext } from "../service";
+import ToolRegistryService from "./ToolRegistryService";
+import ToolSessionService from "./ToolSessionService";
+import { TOOL_REGISTRY_SERVICE, TOOL_SESSION_SERVICE } from "./tokens";
+
+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;
+}
+
+interface WorkbenchServiceDependencies {
+  eventBus?: EventBus;
+  toolRegistry?: ToolRegistryService;
+  sessionService?: ToolSessionService;
+}
 
 export default class WorkbenchService implements Service {
   private _activeToolId: string | null = null;
   private eventBus?: EventBus;
+  private toolRegistry?: ToolRegistryService;
+  private sessionService?: ToolSessionService;
+  private guards: GuardItem[] = [];
 
-  init() {
-    // Initialization logic if needed
+  constructor(dependencies: WorkbenchServiceDependencies = {}) {
+    this.eventBus = dependencies.eventBus;
+    this.toolRegistry = dependencies.toolRegistry;
+    this.sessionService = dependencies.sessionService;
+  }
+
+  init(context: ServiceContext) {
+    this.eventBus ??= context.eventBus;
+    this.toolRegistry ??= context.get(TOOL_REGISTRY_SERVICE);
+    this.sessionService ??= context.get(TOOL_SESSION_SERVICE);
+
+    if (!this.eventBus) {
+      throw new Error("WorkbenchService requires EventBus.");
+    }
+    if (!this.toolRegistry) {
+      throw new Error("WorkbenchService requires ToolRegistryService.");
+    }
+    if (!this.sessionService) {
+      throw new Error("WorkbenchService requires ToolSessionService.");
+    }
   }
 
   dispose() {
-    // Cleanup logic if needed
+    this.guards = [];
   }
 
   setEventBus(bus: EventBus) {
     this.eventBus = bus;
   }
 
-  get activeToolId() {
+  setToolRegistry(toolRegistry: ToolRegistryService) {
+    this.toolRegistry = toolRegistry;
+  }
+
+  setToolSessionService(sessionService: ToolSessionService) {
+    this.sessionService = sessionService;
+  }
+
+  get activeToolId(): string | null {
     return this._activeToolId;
   }
 
-  activate(id: string) {
-    if (this._activeToolId === id) return;
+  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> {
+    const eventBus = this.getEventBus();
+    const toolRegistry = this.getToolRegistry();
+    const sessionService = this.getSessionService();
+
+    if (this._activeToolId === id) {
+      return { ok: true, from: this._activeToolId, to: id };
+    }
+
+    if (id && !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) {
+      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) {
+      const leaveResult = await sessionService.handleBeforeLeave(context.from);
+      if (leaveResult.decision === "blocked") {
+        eventBus.emit("tool:switch:blocked", {
+          ...context,
+          reason: leaveResult.reason || "session-blocked",
+        });
+        return {
+          ok: false,
+          from: this._activeToolId,
+          to: id,
+          reason: leaveResult.reason || "session-blocked",
+        };
+      }
+      sessionService.deactivateSession(context.from);
+    }
+
+    if (id) {
+      const tool = toolRegistry.getTool(id);
+      if (tool?.interaction === "session" && tool.session?.autoBegin !== false) {
+        await sessionService.begin(id);
+      }
+    }
+
     const previous = this._activeToolId;
     this._activeToolId = id;
-    this.eventBus?.emit("tool:activated", { id, previous });
+    const reason = options?.reason;
+    eventBus.emit("tool:activated", { id, previous, reason });
+    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" });
+  }
+
+  private getEventBus(): EventBus {
+    if (!this.eventBus) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.eventBus;
+  }
+
+  private getToolRegistry(): ToolRegistryService {
+    if (!this.toolRegistry) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.toolRegistry;
+  }
+
+  private getSessionService(): ToolSessionService {
+    if (!this.sessionService) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.sessionService;
   }
 }