@pooder/core 2.1.0 → 2.2.0

package/package.json

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

package/src/context.ts

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

package/src/extension.ts

@@ -4,6 +4,11 @@ import Disposable from "./disposable";
 import CommandService from "./services/CommandService";
 import { ConfigurationService } from "./services";
 import ToolRegistryService from "./services/ToolRegistryService";
+import {
+  COMMAND_SERVICE,
+  CONFIGURATION_SERVICE,
+  TOOL_REGISTRY_SERVICE,
+} from "./services";
 
 interface ExtensionMetadata {
   name: string;
@@ -101,19 +106,20 @@ class ExtensionManager {
     // If registering configurations, update ConfigurationService defaults
     if (pointId === ContributionPointIds.CONFIGURATIONS) {
       const configService = this.context.services.get<ConfigurationService>(
-        "ConfigurationService",
+        CONFIGURATION_SERVICE,
       );
       configService?.initializeDefaults([item.data]);
     }
     if (pointId === ContributionPointIds.COMMANDS && item.data.handler) {
       const commandService =
-        this.context.services.get<CommandService>("CommandService")!;
+        this.context.services.get<CommandService>(COMMAND_SERVICE)!;
 
       return commandService.registerCommand(item.id, item.data.handler);
     }
     if (pointId === ContributionPointIds.TOOLS) {
-      const toolRegistry =
-        this.context.services.get<ToolRegistryService>("ToolRegistryService");
+      const toolRegistry = this.context.services.get<ToolRegistryService>(
+        TOOL_REGISTRY_SERVICE,
+      );
       if (!toolRegistry) return;
       return toolRegistry.registerTool(item.data);
     }

package/src/index.ts

@@ -1,4 +1,11 @@
-import { Service, ServiceRegistry } from "./service";
+import {
+  isServiceToken,
+  RegisterServiceOptions,
+  Service,
+  ServiceContext,
+  ServiceIdentifier,
+  ServiceRegistry,
+} from "./service";
 import EventBus from "./event";
 import { ExtensionManager } from "./extension";
 import Disposable from "./disposable";
@@ -9,6 +16,7 @@ import {
   ContributionRegistry,
 } from "./contribution";
 import {
+  CORE_SERVICE_TOKENS,
   CommandService,
   ConfigurationService,
   ToolRegistryService,
@@ -27,6 +35,16 @@ export { default as EventBus } from "./event";
 export class Pooder {
   readonly eventBus: EventBus = new EventBus();
   private readonly services: ServiceRegistry = new ServiceRegistry();
+  private readonly serviceContext: ServiceContext = {
+    eventBus: this.eventBus,
+    get: <T extends Service>(identifier: ServiceIdentifier<T>) =>
+      this.services.get(identifier),
+    getOrThrow: <T extends Service>(
+      identifier: ServiceIdentifier<T>,
+      errorMessage?: string,
+    ) => this.services.getOrThrow(identifier, errorMessage),
+    has: (identifier: ServiceIdentifier<Service>) => this.services.has(identifier),
+  };
   private readonly contributions: ContributionRegistry =
     new ContributionRegistry();
   readonly extensionManager: ExtensionManager;
@@ -36,31 +54,39 @@ export class Pooder {
     this.initDefaultContributionPoints();
 
     const commandService = new CommandService();
-    this.registerService(commandService, "CommandService");
+    this.registerService(commandService, CORE_SERVICE_TOKENS.COMMAND);
 
     const configurationService = new ConfigurationService();
-    this.registerService(configurationService, "ConfigurationService");
+    this.registerService(configurationService, CORE_SERVICE_TOKENS.CONFIGURATION);
 
     const toolRegistryService = new ToolRegistryService();
-    this.registerService(toolRegistryService, "ToolRegistryService");
+    this.registerService(toolRegistryService, CORE_SERVICE_TOKENS.TOOL_REGISTRY);
 
-    const toolSessionService = new ToolSessionService();
-    toolSessionService.setCommandService(commandService);
-    toolSessionService.setToolRegistry(toolRegistryService);
-    this.registerService(toolSessionService, "ToolSessionService");
+    const toolSessionService = new ToolSessionService({
+      commandService,
+      toolRegistry: toolRegistryService,
+    });
+    this.registerService(toolSessionService, CORE_SERVICE_TOKENS.TOOL_SESSION);
 
-    const workbenchService = new WorkbenchService();
-    workbenchService.setEventBus(this.eventBus);
-    workbenchService.setToolRegistry(toolRegistryService);
-    workbenchService.setToolSessionService(toolSessionService);
-    this.registerService(workbenchService, "WorkbenchService");
+    const workbenchService = new WorkbenchService({
+      eventBus: this.eventBus,
+      toolRegistry: toolRegistryService,
+      sessionService: toolSessionService,
+    });
+    this.registerService(workbenchService, CORE_SERVICE_TOKENS.WORKBENCH);
 
     // Create a restricted context for extensions
     const context: ExtensionContext = {
       eventBus: this.eventBus,
       services: {
-        get: <T extends Service>(serviceName: string) =>
-          this.services.get<T>(serviceName),
+        get: <T extends Service>(identifier: ServiceIdentifier<T>) =>
+          this.services.get(identifier),
+        getOrThrow: <T extends Service>(
+          identifier: ServiceIdentifier<T>,
+          errorMessage?: string,
+        ) => this.services.getOrThrow(identifier, errorMessage),
+        has: (identifier: ServiceIdentifier<Service>) =>
+          this.services.has(identifier),
       },
       contributions: {
         get: <T>(pointId: string) => this.getContributions<T>(pointId),
@@ -101,42 +127,138 @@ export class Pooder {
 
   // --- Service Management ---
 
-  registerService(service: Service, id?: string) {
-    const serviceId = id || service.constructor.name;
+  registerService<T extends Service>(
+    service: T,
+    identifier?: ServiceIdentifier<T>,
+    options: RegisterServiceOptions = {},
+  ): boolean {
+    const serviceIdentifier = this.resolveServiceIdentifier(service, identifier);
+    const serviceId = this.getServiceLabel(serviceIdentifier);
 
     try {
-      service?.init?.();
-    } catch (e) {
-      console.error(`Error initializing service ${serviceId}:`, e);
+      const initResult = this.invokeServiceHook(service, "init");
+      if (this.isPromiseLike(initResult)) {
+        throw new Error(
+          `Service "${serviceId}" init() is async. Use registerServiceAsync() instead.`,
+        );
+      }
+
+      this.services.register(serviceIdentifier, service, options);
+      this.eventBus.emit("service:register", service, { id: serviceId });
+      return true;
+    } catch (error) {
+      console.error(`Error initializing service ${serviceId}:`, error);
       return false;
     }
+  }
 
-    this.services.register(serviceId, service);
-    this.eventBus.emit("service:register", service);
+  async registerServiceAsync<T extends Service>(
+    service: T,
+    identifier?: ServiceIdentifier<T>,
+    options: RegisterServiceOptions = {},
+  ): Promise<boolean> {
+    const serviceIdentifier = this.resolveServiceIdentifier(service, identifier);
+    const serviceId = this.getServiceLabel(serviceIdentifier);
+
+    try {
+      await this.invokeServiceHookAsync(service, "init");
+      this.services.register(serviceIdentifier, service, options);
+      this.eventBus.emit("service:register", service, { id: serviceId });
+      return true;
+    } catch (error) {
+      console.error(`Error initializing service ${serviceId}:`, error);
+      return false;
+    }
+  }
+
+  unregisterService(service: Service, id?: ServiceIdentifier<Service>): boolean;
+  unregisterService(identifier: ServiceIdentifier<Service>): boolean;
+  unregisterService(
+    serviceOrIdentifier: Service | ServiceIdentifier<Service>,
+    id?: ServiceIdentifier<Service>,
+  ): boolean {
+    const resolvedIdentifier = this.resolveUnregisterIdentifier(
+      serviceOrIdentifier,
+      id,
+    );
+    const serviceId = this.getServiceLabel(resolvedIdentifier);
+    const registeredService = this.services.get(resolvedIdentifier);
+
+    if (!registeredService) {
+      console.warn(`Service ${serviceId} is not registered.`);
+      return true;
+    }
+
+    try {
+      const disposeResult = this.invokeServiceHook(registeredService, "dispose");
+      if (this.isPromiseLike(disposeResult)) {
+        throw new Error(
+          `Service "${serviceId}" dispose() is async. Use unregisterServiceAsync() instead.`,
+        );
+      }
+    } catch (error) {
+      console.error(`Error disposing service ${serviceId}:`, error);
+      return false;
+    }
+
+    this.services.delete(resolvedIdentifier);
+    this.eventBus.emit("service:unregister", registeredService, { id: serviceId });
     return true;
   }
 
-  unregisterService(service: Service, id?: string) {
-    const serviceId = id || service.constructor.name;
-    if (!this.services.has(serviceId)) {
+  async unregisterServiceAsync(
+    serviceOrIdentifier: Service | ServiceIdentifier<Service>,
+    id?: ServiceIdentifier<Service>,
+  ): Promise<boolean> {
+    const resolvedIdentifier = this.resolveUnregisterIdentifier(
+      serviceOrIdentifier,
+      id,
+    );
+    const serviceId = this.getServiceLabel(resolvedIdentifier);
+    const registeredService = this.services.get(resolvedIdentifier);
+
+    if (!registeredService) {
       console.warn(`Service ${serviceId} is not registered.`);
       return true;
     }
 
     try {
-      service?.dispose?.();
-    } catch (e) {
-      console.error(`Error disposing service ${serviceId}:`, e);
+      await this.invokeServiceHookAsync(registeredService, "dispose");
+    } catch (error) {
+      console.error(`Error disposing service ${serviceId}:`, error);
       return false;
     }
 
-    this.services.delete(serviceId);
-    this.eventBus.emit("service:unregister", service);
+    this.services.delete(resolvedIdentifier);
+    this.eventBus.emit("service:unregister", registeredService, { id: serviceId });
     return true;
   }
 
-  getService<T extends Service>(id: string): T | undefined {
-    return this.services.get<T>(id);
+  getService<T extends Service>(identifier: ServiceIdentifier<T>): T | undefined {
+    return this.services.get<T>(identifier);
+  }
+
+  getServiceOrThrow<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    errorMessage?: string,
+  ): T {
+    return this.services.getOrThrow(identifier, errorMessage);
+  }
+
+  hasService(identifier: ServiceIdentifier<Service>): boolean {
+    return this.services.has(identifier);
+  }
+
+  async dispose(): Promise<void> {
+    this.extensionManager.destroy();
+
+    const registrations = this.services.list().slice().reverse();
+    for (const item of registrations) {
+      const identifier = item.token ?? item.id;
+      await this.unregisterServiceAsync(identifier);
+    }
+
+    this.services.clear();
   }
 
   // --- Contribution Management ---
@@ -158,4 +280,59 @@ export class Pooder {
   getContributions<T>(pointId: string): Contribution<T>[] {
     return this.contributions.get<T>(pointId);
   }
+
+  private resolveServiceIdentifier<T extends Service>(
+    service: T,
+    identifier?: ServiceIdentifier<T>,
+  ): ServiceIdentifier<T> {
+    return identifier ?? service.constructor.name;
+  }
+
+  private resolveUnregisterIdentifier(
+    serviceOrIdentifier: Service | ServiceIdentifier<Service>,
+    id?: ServiceIdentifier<Service>,
+  ): ServiceIdentifier<Service> {
+    if (
+      typeof serviceOrIdentifier === "string" ||
+      isServiceToken(serviceOrIdentifier)
+    ) {
+      return serviceOrIdentifier;
+    }
+
+    return id ?? serviceOrIdentifier.constructor.name;
+  }
+
+  private getServiceLabel(identifier: ServiceIdentifier<Service>): string {
+    if (typeof identifier === "string") {
+      return identifier;
+    }
+    return identifier.name;
+  }
+
+  private invokeServiceHook(
+    service: Service,
+    hook: "init" | "dispose",
+  ): void | Promise<void> {
+    const handler = service[hook];
+    if (!handler) {
+      return;
+    }
+    return handler.call(service, this.serviceContext);
+  }
+
+  private async invokeServiceHookAsync(
+    service: Service,
+    hook: "init" | "dispose",
+  ): Promise<void> {
+    await this.invokeServiceHook(service, hook);
+  }
+
+  private isPromiseLike(value: unknown): value is Promise<unknown> {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      "then" in value &&
+      typeof (value as { then?: unknown }).then === "function"
+    );
+  }
 }

package/src/service.ts

@@ -1,25 +1,205 @@
+import type EventBus from "./event";
+
 export interface Service {
-  init?(): void;
-  dispose?(): void;
+  init?(context: ServiceContext): void | Promise<void>;
+  dispose?(context: ServiceContext): void | Promise<void>;
+}
+
+export interface ServiceToken<T extends Service = Service> {
+  readonly kind: "service-token";
+  readonly key: symbol;
+  readonly name: string;
+}
+
+export type ServiceIdentifier<T extends Service = Service> =
+  | string
+  | ServiceToken<T>;
+
+export interface ServiceContext {
+  readonly eventBus: EventBus;
+  get<T extends Service>(identifier: ServiceIdentifier<T>): T | undefined;
+  getOrThrow<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    errorMessage?: string,
+  ): T;
+  has(identifier: ServiceIdentifier<Service>): boolean;
+}
+
+export interface RegisterServiceOptions {
+  allowOverride?: boolean;
+}
+
+export interface RegisteredService<T extends Service = Service> {
+  readonly id: string;
+  readonly token?: ServiceToken<T>;
+  readonly service: T;
+}
+
+interface ServiceEntry<T extends Service = Service> {
+  token?: ServiceToken<T>;
+  name: string;
+  service: T;
+}
+
+interface NormalizedIdentifier<T extends Service = Service> {
+  token?: ServiceToken<T>;
+  name: string;
+}
+
+export function createServiceToken<T extends Service = Service>(
+  name: string,
+): ServiceToken<T> {
+  if (!name) {
+    throw new Error("Service token name is required.");
+  }
+
+  return Object.freeze({
+    kind: "service-token" as const,
+    key: Symbol(name),
+    name,
+  });
+}
+
+export function isServiceToken<T extends Service = Service>(
+  identifier: unknown,
+): identifier is ServiceToken<T> {
+  return (
+    typeof identifier === "object" &&
+    identifier !== null &&
+    "kind" in identifier &&
+    (identifier as { kind?: unknown }).kind === "service-token"
+  );
 }
 
 export class ServiceRegistry {
-  private services: Map<string, Service> = new Map();
+  private readonly servicesByName: Map<string, ServiceEntry> = new Map();
+  private readonly servicesByToken: Map<symbol, ServiceEntry> = new Map();
+  private readonly registrationOrder: ServiceEntry[] = [];
+
+  register<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    service: T,
+    options: RegisterServiceOptions = {},
+  ): T {
+    const normalized = this.normalizeIdentifier(identifier);
+    const existing = this.findEntry(normalized);
+
+    if (existing && !options.allowOverride) {
+      throw new Error(`Service "${normalized.name}" is already registered.`);
+    }
+    if (existing) {
+      this.removeEntry(existing);
+    }
 
-  register<T extends Service>(name: string, service: T): T {
-    this.services.set(name, service);
+    const entry: ServiceEntry<T> = {
+      token: normalized.token,
+      name: normalized.name,
+      service,
+    };
+
+    this.servicesByName.set(entry.name, entry);
+    if (entry.token) {
+      this.servicesByToken.set(entry.token.key, entry);
+    }
+    this.registrationOrder.push(entry as ServiceEntry);
     return service;
   }
 
-  get<T extends Service>(serviceName: string): T | undefined {
-    return this.services.get(serviceName) as T | undefined;
+  get<T extends Service>(identifier: ServiceIdentifier<T>): T | undefined;
+  get<T extends Service>(identifier: ServiceToken<T>): T | undefined;
+  get<T extends Service>(identifier: string): T | undefined;
+  get<T extends Service>(identifier: ServiceIdentifier<T>): T | undefined {
+    const normalized = this.normalizeIdentifier(identifier);
+    const entry = this.findEntry(normalized);
+    return entry?.service as T | undefined;
+  }
+
+  getOrThrow<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    errorMessage?: string,
+  ): T;
+  getOrThrow<T extends Service>(
+    identifier: ServiceToken<T>,
+    errorMessage?: string,
+  ): T;
+  getOrThrow<T extends Service>(identifier: string, errorMessage?: string): T;
+  getOrThrow<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    errorMessage?: string,
+  ): T {
+    const service = this.get(identifier);
+    if (service) {
+      return service;
+    }
+
+    const normalized = this.normalizeIdentifier(identifier);
+    throw new Error(errorMessage ?? `Service "${normalized.name}" not found.`);
   }
 
-  has(serviceName: string): boolean {
-    return this.services.has(serviceName);
+  has(identifier: ServiceIdentifier<Service>): boolean {
+    const normalized = this.normalizeIdentifier(identifier);
+    return Boolean(this.findEntry(normalized));
   }
 
-  delete(serviceName: string): void {
-    this.services.delete(serviceName);
+  delete(identifier: ServiceIdentifier<Service>): boolean {
+    const normalized = this.normalizeIdentifier(identifier);
+    const entry = this.findEntry(normalized);
+    if (!entry) {
+      return false;
+    }
+    this.removeEntry(entry);
+    return true;
+  }
+
+  list(): RegisteredService[] {
+    return this.registrationOrder.map((entry) => ({
+      id: entry.name,
+      token: entry.token,
+      service: entry.service,
+    }));
+  }
+
+  clear() {
+    this.servicesByName.clear();
+    this.servicesByToken.clear();
+    this.registrationOrder.length = 0;
+  }
+
+  private findEntry(
+    identifier: NormalizedIdentifier,
+  ): ServiceEntry | undefined {
+    if (identifier.token) {
+      return (
+        this.servicesByToken.get(identifier.token.key) ??
+        this.servicesByName.get(identifier.name)
+      );
+    }
+    return this.servicesByName.get(identifier.name);
+  }
+
+  private normalizeIdentifier<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+  ): NormalizedIdentifier<T> {
+    if (isServiceToken(identifier)) {
+      return { token: identifier, name: identifier.name };
+    }
+
+    const name = identifier.trim();
+    if (!name) {
+      throw new Error("Service identifier must be a non-empty string.");
+    }
+    return { name };
+  }
+
+  private removeEntry(entry: ServiceEntry) {
+    this.servicesByName.delete(entry.name);
+    if (entry.token) {
+      this.servicesByToken.delete(entry.token.key);
+    }
+
+    const index = this.registrationOrder.lastIndexOf(entry);
+    if (index >= 0) {
+      this.registrationOrder.splice(index, 1);
+    }
   }
 }

package/src/services/ToolSessionService.ts

@@ -1,8 +1,9 @@
 import { ToolContribution } from "../contribution";
 import Disposable from "../disposable";
-import { Service } from "../service";
+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";
 
@@ -21,11 +22,33 @@ export interface LeaveResult {
   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;
   }
@@ -84,12 +107,26 @@ export default class ToolSessionService implements Service {
   }
 
   private resolveTool(toolId: string): ToolContribution | undefined {
-    return this.toolRegistry?.getTool(toolId);
+    return this.getToolRegistry().getTool(toolId);
   }
 
   private async runCommand(commandId: string | undefined, ...args: any[]) {
-    if (!commandId || !this.commandService) return undefined;
-    return await this.commandService.executeCommand(commandId, ...args);
+    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> {