@gravito/echo 3.0.1 → 3.1.0

package/dist/atlas/src/utils/levenshtein.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Calculate Levenshtein distance between two strings
+ * Used for "Did you mean?" suggestions
+ */
+export declare function levenshtein(a: string, b: string): number;
+/**
+ * Find similar strings from a list
+ */
+export declare function findSimilar(target: string, candidates: string[], maxDistance?: number, maxResults?: number): string[];

package/dist/core/src/Application.d.ts

@@ -115,15 +115,21 @@ export declare class Application {
     private booted;
     constructor(options: ApplicationConfig);
     /**
-     * Boot the application.
+     * Boot the application and its dependencies.
      *
-     * This will:
-     * 1. Load configuration files
-     * 2. Auto-discover providers (if enabled)
-     * 3. Register all providers
-     * 4. Bootstrap the core
+     * This method orchestrates the full application lifecycle:
+     * 1. Configuration: Loads all config files from the config directory.
+     * 2. Discovery: Auto-discovers ServiceProviders from the providers directory.
+     * 3. Registration: Registers all discovered and explicit providers.
+     * 4. Bootstrapping: Triggers the PlanetCore bootstrap sequence.
      *
-     * @returns Promise that resolves when boot is complete
+     * @returns Promise that resolves to the application instance for chaining.
+     *
+     * @example
+     * ```typescript
+     * const app = new Application({ basePath: import.meta.dir });
+     * await app.boot();
+     * ```
      */
     boot(): Promise<this>;
     /**
@@ -139,10 +145,19 @@ export declare class Application {
      */
     private discoverProviders;
     /**
-     * Get a service from the container.
+     * Resolve a service instance from the IoC container.
      *
-     * @param key - The service key
-     * @returns The resolved service
+     * This is a convenience wrapper around `container.make()`.
+     *
+     * @template T - The expected type of the service.
+     * @param key - The unique identifier or class name of the service.
+     * @returns The resolved service instance.
+     * @throws Error if the service is not bound in the container.
+     *
+     * @example
+     * ```typescript
+     * const db = app.make<Database>('db');
+     * ```
      */
     make<T>(key: string): T;
     /**
@@ -153,18 +168,29 @@ export declare class Application {
      */
     has(key: string): boolean;
     /**
-     * Get a configuration value.
+     * Retrieve a configuration value using dot notation.
+     *
+     * @template T - The expected type of the configuration value.
+     * @param key - The configuration key (e.g., 'app.name', 'database.connections.mysql').
+     * @param defaultValue - Optional value to return if the key is not found.
+     * @returns The configuration value or the default value.
      *
-     * @param key - The config key (supports dot notation)
-     * @param defaultValue - Default value if not found
-     * @returns The config value
+     * @example
+     * ```typescript
+     * const port = app.getConfig<number>('app.port', 3000);
+     * ```
      */
     getConfig<T>(key: string, defaultValue?: T): T;
     /**
-     * Create application path helper.
+     * Resolve an absolute path relative to the application base path.
+     *
+     * @param segments - Path segments to join with the base path.
+     * @returns The absolute path string.
      *
-     * @param segments - Path segments relative to base path
-     * @returns Absolute path
+     * @example
+     * ```typescript
+     * const storagePath = app.path('storage', 'logs');
+     * ```
      */
     path(...segments: string[]): string;
     /**

package/dist/core/src/CommandKernel.d.ts

@@ -0,0 +1,33 @@
+import type { Container } from './Container';
+/**
+ * CommandHandler type for custom CLI commands.
+ */
+export type CommandHandler = (args: string[], container: Container) => Promise<void> | void;
+/**
+ * CommandKernel - Structured CLI Command handling.
+ *
+ * Manages registration and execution of custom CLI commands that can
+ * reuse the application container and providers.
+ *
+ * @example
+ * ```typescript
+ * const kernel = new CommandKernel(container);
+ * kernel.register('greet', (args) => console.log('Hello', args[0]));
+ * await kernel.handle(['greet', 'Universe']);
+ * ```
+ */
+export declare class CommandKernel {
+    private container;
+    private commands;
+    constructor(container: Container);
+    /**
+     * Register a new command handler.
+     */
+    register(name: string, handler: CommandHandler): void;
+    /**
+     * Handle an incoming CLI command.
+     *
+     * @param argv - Array of command line arguments (e.g. process.argv.slice(2))
+     */
+    handle(argv: string[]): Promise<void>;
+}

package/dist/core/src/Container.d.ts

@@ -2,7 +2,26 @@
  * Factory type for creating service instances
  */
 export type Factory<T> = (container: Container) => T;
-export type BindingKey = string | symbol;
+/**
+ * ServiceMap interface for type-safe IoC resolution.
+ *
+ * Extend this interface via module augmentation to get type inference:
+ * @example
+ * ```typescript
+ * declare module '@gravito/core' {
+ *   interface ServiceMap {
+ *     logger: Logger
+ *     db: DatabaseConnection
+ *   }
+ * }
+ * ```
+ */
+export type ServiceMap = {};
+/**
+ * ServiceKey represents the allowed keys for service resolution.
+ * Includes keys from ServiceMap, generic strings, or symbols.
+ */
+export type ServiceKey = keyof ServiceMap | (string & {}) | symbol;
 /**
  * Container - Simple Dependency Injection Container.
  * Manages service bindings and singleton instances.
@@ -11,34 +30,79 @@ export type BindingKey = string | symbol;
 export declare class Container {
     private bindings;
     private instances;
+    private resolutionStack;
     /**
      * Bind a service to the container.
-     * New instance will be created on each resolution.
+     *
+     * A new instance will be created by the factory function every time the
+     * service is resolved from the container.
+     *
+     * @template T - The type of the service being bound.
+     * @param key - The unique identifier for the service.
+     * @param factory - The factory function that creates the service instance.
+     *
+     * @example
+     * ```typescript
+     * container.bind('logger', (c) => new ConsoleLogger());
+     * ```
      */
-    bind<T>(key: BindingKey, factory: Factory<T>): void;
+    bind<T>(key: ServiceKey, factory: Factory<T>): void;
     /**
      * Bind a shared service to the container (Singleton).
-     * Same instance will be returned on each resolution.
+     *
+     * The factory function will be called only once, and the same instance
+     * will be returned on every subsequent resolution.
+     *
+     * @template T - The type of the service being bound.
+     * @param key - The unique identifier for the service.
+     * @param factory - The factory function that creates the service instance.
+     *
+     * @example
+     * ```typescript
+     * container.singleton('db', (c) => new DatabaseConnection());
+     * ```
      */
-    singleton<T>(key: BindingKey, factory: Factory<T>): void;
+    singleton<T>(key: ServiceKey, factory: Factory<T>): void;
     /**
-     * Register an existing instance as shared service.
+     * Register an existing instance as a shared service.
+     *
+     * @param key - The unique identifier for the service.
+     * @param instance - The instance to register.
      */
-    instance<T>(key: BindingKey, instance: T): void;
+    instance<T>(key: ServiceKey, instance: T): void;
     /**
-     * Resolve a service from the container.
+     * Resolve a service instance from the container.
+     *
+     * Automatically handles singleton caching and factory execution.
+     *
+     * @template T - The expected type of the service.
+     * @param key - The unique identifier for the service.
+     * @returns The resolved service instance.
+     * @throws Error if the service key is not found in the container.
+     *
+     * @example
+     * ```typescript
+     * const logger = container.make<Logger>('logger');
+     * ```
      */
-    make<T>(key: BindingKey): T;
+    make<K extends keyof ServiceMap>(key: K): ServiceMap[K];
+    make<T>(key: ServiceKey): T;
     /**
-     * Check if a service is bound.
+     * Check if a service is bound or has an instance in the container.
+     *
+     * @param key - The service key to check.
+     * @returns True if the service exists.
      */
-    has(key: BindingKey): boolean;
+    has(key: ServiceKey): boolean;
     /**
-     * Flush all instances and bindings.
+     * Flush all instances and bindings from the container.
+     * Resets the container to an empty state.
      */
     flush(): void;
     /**
-     * Forget a specific instance (but keep binding)
+     * Forget a specific instance while keeping its binding.
+     *
+     * @param key - The service key to forget.
      */
-    forget(key: BindingKey): void;
+    forget(key: ServiceKey): void;
 }