libmodulor 0.4.0 → 0.5.0

package/dist/esm/product/manifest.d.ts

@@ -1,8 +1,23 @@
 import type { AppName } from '../app/index.js';
 import type { UCName } from '../uc/index.js';
 export interface ProductAppReg {
+    /**
+     * It must correspond to the app folder name in the {@link APPS_ROOT_PATH}.
+     */
     name: AppName;
+    /**
+     * By default, a product mounts all the enabled use cases of an app.
+     *
+     * With this, you can override this default behavior.
+     */
     ucds?: {
+        /**
+         * Use Cases to exclude from the product
+         *
+         * For example, you can have a generic `Auth` app, used in multiple products.
+         * Some of them will require `SignUp` while others won't. With this setting,
+         * you can exclude the use cases that you don't want. In this case, they won't be mounted.
+         */
         exclude?: UCName[];
     } | undefined;
 }

package/dist/esm/products/Helper/index.js

@@ -3,6 +3,9 @@ import { NodeCoreCLIManager } from '../../target/node-core-cli/NodeCoreCLIManage
 import container from './container.js';
 const i18nManager = container.get('I18nManager');
 await i18nManager.init();
+// Before screaming, yes, this is not using any powerful CLI library.
+// The goal is to reduce the usage of dependencies as much as possible.
+// As long as the built-in Node.js API allows to build it without too many workarounds, let's keep it this way.
 await container.resolve(NodeCoreCLIManager).handleCommand({
     appsRootPath: container
         .get('FSManager')

package/dist/esm/products/Helper/manifest.d.ts

@@ -1 +1,6 @@
-export const Manifest: import("../../product/index.js").ProductManifest;
+export declare const Manifest: {
+    appReg: {
+        name: "Helper";
+    }[];
+    name: string;
+};

package/dist/esm/std/BufferManager.d.ts

@@ -1,4 +1,22 @@
 export type BufferManagerBase64String = string;
+/**
+ * The `Buffer` api is available in Node and similar server side environments. But it's not in browsers.
+ *
+ * Hence the need for this interface to provide multiple implementations (e.g. using https://github.com/feross/buffer).
+ *
+ * But the problem is that both implementations are redundant.
+ *
+ * TODO : Consider alternatives to BufferManager
+ *
+ * Possible solutions :
+ *
+ *   - Import the buffer lib as a polyfill
+ *   - Use only ECMAScript compatible primitives (`ArrayBuffer`, `Uint8Array`, `DataView`, etc.)
+ *   - Use BinaryJS
+ *   - Use Fast-Buffer
+ *
+ * Note that for the last two, keeping this interface makes actually sense since other impl. not `Buffer`-like can be used.
+ */
 export interface BufferManager {
     decodeBase64<T extends string>(value: BufferManagerBase64String): T;
     decodeUint8Array<T extends string>(value: Uint8Array): T;

package/dist/esm/std/ClockManager.d.ts

@@ -1,4 +1,9 @@
 import type { Timestamp } from '../dt/index.js';
+/**
+ * A key representing the date (e.g. 20241125141012)
+ *
+ * Useful to set a prefix when naming files in order to sort them
+ */
 export type ClockManagerDateKey = string;
 export interface ClockManager {
     now(): Date;

package/dist/esm/std/EnvironmentManager.d.ts

@@ -3,6 +3,16 @@ export type EnvironmentManagerEnvVarName = string;
 type Browser = 'chrome' | 'edge' | 'firefox' | 'opera' | 'safari';
 type MobileOS = 'android' | 'ios';
 type OS = 'darwin' | 'linux' | 'macos' | 'windows' | 'windows_nt';
+/**
+ * The type of environment
+ *
+ * The goal of this is not to give the final platform where the runtime is executed.
+ * For instance, in the context of a browser, we want to know that it's running on 'firefox' and not 'macos'.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/platform
+ * @see https://reactnative.dev/docs/platform#os
+ * @see https://nodejs.org/api/os.html#ostype
+ */
 export type EnvironmentManagerType = Browser | MobileOS | OS | (string & {});
 export interface EnvironmentManager {
     cwd(): FilePath;

package/dist/esm/std/HTTPAPICaller.d.ts

@@ -18,6 +18,9 @@ export interface HTTPAPICallerInputOpts {
     xml?: XMLManagerParseOpts;
 }
 export interface HTTPAPICallerInput<AH extends object | undefined, Req extends object, ResBad, ResGood, O> {
+    /**
+     * They are the last ones to be set so they will override any other header already set by `authorizationHeader` or `basicAuth` if any.
+     */
     additionalHeadersBuilder?: AdditionalHeadersBuilder<AH> | undefined;
     authorizationHeader?: HTTPAPICallerAuthorizationHeader | undefined;
     basicAuth?: HTTPAPICallerBasicAuth | undefined;
@@ -25,6 +28,9 @@ export interface HTTPAPICallerInput<AH extends object | undefined, Req extends o
     errBuilder: ErrBuilder<ResBad>;
     method: HTTPMethod;
     opts?: HTTPAPICallerInputOpts | undefined;
+    /**
+     * If not set, it will assume that `ResGood` and `O` are the same and thus return `ResGood` as is.
+     */
     outputBuilder?: OutputBuilder<ResGood, O> | undefined;
     req?: {
         builder: ReqBuilder<Req>;

package/dist/esm/std/I18nManager.d.ts

@@ -7,8 +7,34 @@ export interface I18nManagerTOpts {
     vars?: Record<string, string>;
 }
 export interface I18nManager extends Initializable {
+    /**
+     * Add a translation key
+     *
+     * It might not work for all the implementations, depending on where the translations are stored.
+     *
+     * @param key
+     * @param value
+     */
     add<K extends I18nTranslationKey>(key: K, value: string): Promise<void>;
+    /**
+     * Get the current lang code
+     */
     l(): I18nLanguageCode;
+    /**
+     * Get the translation for the given key
+     *
+     * If the key is missing, it should return `opts.fallback` if any. Otherwise, it should return the key itself.
+     *
+     * Optionally it can fail (by throwing) but that is not recommended since it impacts end users.
+     *
+     * @param key
+     * @param opts
+     */
     t<T extends I18nTranslationKey>(key: T, opts?: I18nManagerTOpts): string;
+    /**
+     * Get the translation for the given key, otherwise `null`
+     * @param key
+     * @param opts
+     */
     tOrNull<T extends I18nTranslationKey>(key: T, opts?: I18nManagerTOpts): string | null;
 }

package/dist/esm/std/JWTManager.d.ts

@@ -16,6 +16,9 @@ export interface JWTManagerSettings extends Settings {
     jwt_manager_subject: string | null;
 }
 export type JWTManagerDecodeOpts = Pick<JWTManagerEncodeOpts, 'secret'> & {
+    /**
+     * The public key to verify JWTs using an `alg` of type `RS*`
+     */
     spki?: SSHPublicKey;
 };
 export interface JWTManagerEncodeOpts {
@@ -28,7 +31,30 @@ export interface JWTManagerEncodeOpts {
     sub?: JWTManagerSettings['jwt_manager_subject'];
 }
 export interface JWTManager {
+    /**
+     * Decode the token
+     *
+     * Pass the ad-hoc opts when using a specific `alg` (e.g. `spki` when decoding a `RS*` token).
+     * If invalid, it must throw an {@link UnauthorizedError} (no errors related to the impl. should be thrown).
+     *
+     * @param value
+     * @param opts
+     */
     decode<T extends JWTManagerPayload>(value: JWT, opts?: JWTManagerDecodeOpts): Promise<T>;
+    /**
+     * Encode the payload
+     *
+     * It uses the global {@link JWTManagerSettings} or the ones provided via `opts`.
+     *
+     * @param payload
+     * @param opts
+     */
     encode<T extends object>(payload: T, opts?: JWTManagerEncodeOpts): Promise<JWT>;
+    /**
+     * Check whether the token is usable or not
+     *
+     * Note that the signature is not checked. Indeed, the main purpose of this method is to be used client side to save some requests (e.g. when the token is expired).
+     * In this case, no need to send a request that will trigger an error. Better to renew the token at the client's initiative.
+     */
     isUsable(value: JWT): Promise<boolean>;
 }

package/dist/esm/std/JobManager.d.ts

@@ -13,5 +13,11 @@ export interface JobManagerSettings extends Settings {
     }[];
 }
 export interface JobManager extends Clearable, Initializable {
+    /**
+     * Send a new job on the queue for processing
+     * @param queueName
+     * @param jobName
+     * @param input
+     */
     dispatch<I>(queueName: JobManagerQueueName, jobName: JobManagerJobName, input: I): Promise<void>;
 }

package/dist/esm/std/LLMManager.d.ts

@@ -0,0 +1,25 @@
+import type { FreeTextLong } from '../dt/index.js';
+export type LLMManagerModel = string;
+export type LLMManagerTemperature = number;
+export interface LLMManagerSendReq {
+    messages: {
+        content: FreeTextLong;
+        /**
+         * In the case of OpenAI :
+         * > With o1 models and newer, developer messages replace the previous system messages
+         */
+        role: 'assistant' | 'developer' | 'system' | 'user';
+    }[];
+    model: LLMManagerModel;
+    temperature?: LLMManagerTemperature;
+}
+export interface LLMManagerSendRes {
+    choices: {
+        message: {
+            content: string;
+        };
+    }[];
+}
+export interface LLMManager {
+    send(req: LLMManagerSendReq): Promise<LLMManagerSendRes>;
+}

package/dist/esm/std/LLMManager.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/std/PromptManager.d.ts

@@ -1,4 +1,12 @@
 export interface PromptManagerPromptOpts<T extends string> {
+    /**
+     * Predicate to validate the input
+     *
+     * It keeps asking while the value is not valid, unless the user presses `Ctrl+C`.
+     *
+     * @param value
+     * @returns
+     */
     validate?: (value: T) => Promise<boolean>;
 }
 export interface PromptManager {

package/dist/esm/std/SettingsManager.d.ts

@@ -1,10 +1,29 @@
+/**
+ * Placeholder for string settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export declare const SettingsManagerMandatoryPlaceholder = "!<>!";
+/**
+ * Placeholder for array settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export declare const SettingsManagerMandatoryPlaceholderForArray: string[];
+/**
+ * Placeholder for object settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export declare const SettingsManagerMandatoryPlaceholderForObject: {
     '0': string;
 };
+/**
+ * A group of settings
+ *
+ * Prefix them with the thing that is configurable to avoid conflicts when defining settings together for a product and/or a target.
+ */
 export interface Settings {
 }
+/**
+ * Interface to implement by the classes that needs settings
+ *
+ * As `S`, pass the subset of settings that the class needs (e.g. `Pick<SomeSettings, 'setting_1'>`).
+ */
 export interface Configurable<S> {
     s(): S;
 }

package/dist/esm/std/SettingsManager.js

@@ -1,7 +1,16 @@
+/**
+ * Placeholder for string settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export const SettingsManagerMandatoryPlaceholder = '!<>!';
+/**
+ * Placeholder for array settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export const SettingsManagerMandatoryPlaceholderForArray = [
     SettingsManagerMandatoryPlaceholder,
 ];
+/**
+ * Placeholder for object settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export const SettingsManagerMandatoryPlaceholderForObject = {
     '0': SettingsManagerMandatoryPlaceholder,
 };

package/dist/esm/std/impl/ConsoleLogger.js

@@ -15,6 +15,7 @@ import { inject, injectable } from 'inversify';
 let ConsoleLogger = class ConsoleLogger {
     static { ConsoleLogger_1 = this; }
     settingsManager;
+    // Ordered by level
     static LEVELS = [
         'trace',
         'debug',
@@ -34,30 +35,35 @@ let ConsoleLogger = class ConsoleLogger {
         if (!this.shouldLog('debug')) {
             return;
         }
+        // biome-ignore lint/suspicious/noConsole: we want it
         console.debug(`${this.t()} [debug] ${message}`, ...meta);
     }
     error(err) {
         if (!this.shouldLog('error')) {
             return;
         }
+        // biome-ignore lint/suspicious/noConsole: we want it
         console.error(err);
     }
     info(message, ...meta) {
         if (!this.shouldLog('info')) {
             return;
         }
+        // biome-ignore lint/suspicious/noConsole: we want it
         console.info(`${this.t()} [info] ${message}`, ...meta);
     }
     trace(message, ...meta) {
         if (!this.shouldLog('trace')) {
             return;
         }
-        console.debug(`${this.t()} [trace] ${message}`, ...meta);
+        // biome-ignore lint/suspicious/noConsole: we want it
+        console.trace(`${this.t()} [trace] ${message}`, ...meta);
     }
     warn(message, ...meta) {
         if (!this.shouldLog('warn')) {
             return;
         }
+        // biome-ignore lint/suspicious/noConsole: we want it
         console.warn(`${this.t()} [warn] ${message}`, ...meta);
     }
     shouldLog(level) {

package/dist/esm/std/impl/FakeEmailManager.js

@@ -20,6 +20,7 @@ let FakeEmailManager = class FakeEmailManager {
         this.entries.push({ def, replyTo, to });
     }
     async verify() {
+        // Nothing to do
     }
 };
 FakeEmailManager = __decorate([

package/dist/esm/std/impl/FakeJobManager.js

@@ -20,6 +20,7 @@ let FakeJobManager = class FakeJobManager {
         this.entries.push({ input, jobName, queueName });
     }
     async init() {
+        // Nothing to do
     }
 };
 FakeJobManager = __decorate([

package/dist/esm/std/impl/FetchHTTPAPICallExecutor.d.ts

@@ -1,4 +1,13 @@
 import type { HTTPAPICallExecutor, HTTPAPICallExecutorFunc } from '../HTTPAPICallExecutor.js';
+/**
+ * Nowadays, most platforms include it as a global :
+ *
+ *   - Node : https://nodejs.org/api/globals.html#fetch
+ *   - RN   : https://reactnative.dev/docs/network#using-fetch
+ *   - Web  : https://developer.mozilla.org/fr/docs/Web/API/Fetch_API
+ *
+ * So we should be safe using it almost everywhere.
+ */
 export declare class FetchHTTPAPICallExecutor implements HTTPAPICallExecutor {
     fn<Res>(): HTTPAPICallExecutorFunc<Res>;
 }

package/dist/esm/std/impl/FetchHTTPAPICallExecutor.js

@@ -5,8 +5,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { injectable } from 'inversify';
+/**
+ * Nowadays, most platforms include it as a global :
+ *
+ *   - Node : https://nodejs.org/api/globals.html#fetch
+ *   - RN   : https://reactnative.dev/docs/network#using-fetch
+ *   - Web  : https://developer.mozilla.org/fr/docs/Web/API/Fetch_API
+ *
+ * So we should be safe using it almost everywhere.
+ */
 let FetchHTTPAPICallExecutor = class FetchHTTPAPICallExecutor {
     fn() {
+        // The generalization in HTTPAPICallExecutor is not exactly the same as the actual implementation
+        // @ts-ignore
         return fetch;
     }
 };

package/dist/esm/std/impl/MistralAILLMManager.d.ts

@@ -0,0 +1,17 @@
+import type { ApiKey } from '../../dt/index.js';
+import type { HTTPAPICaller } from '../HTTPAPICaller.js';
+import type { LLMManager, LLMManagerSendReq, LLMManagerSendRes } from '../LLMManager.js';
+import type { Configurable, Settings, SettingsManager } from '../SettingsManager.js';
+export interface MistralAILLMManagerSettings extends Settings {
+    mai_api_key: ApiKey;
+}
+type S = MistralAILLMManagerSettings;
+export declare class MistralAILLMManager implements Configurable<S>, LLMManager {
+    private httpAPICaller;
+    private settingsManager;
+    private static BASE_URL;
+    constructor(httpAPICaller: HTTPAPICaller, settingsManager: SettingsManager<S>);
+    s(): MistralAILLMManagerSettings;
+    send(req: LLMManagerSendReq): Promise<LLMManagerSendRes>;
+}
+export {};

package/dist/esm/std/impl/MistralAILLMManager.js

@@ -0,0 +1,56 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var MistralAILLMManager_1;
+import { inject, injectable } from 'inversify';
+let MistralAILLMManager = class MistralAILLMManager {
+    static { MistralAILLMManager_1 = this; }
+    httpAPICaller;
+    settingsManager;
+    static BASE_URL = 'https://api.mistral.ai/v1';
+    constructor(httpAPICaller, settingsManager) {
+        this.httpAPICaller = httpAPICaller;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            mai_api_key: this.settingsManager.get()('mai_api_key'),
+        };
+    }
+    async send(req) {
+        return await this.httpAPICaller.exec({
+            authorizationHeader: {
+                value: this.s().mai_api_key,
+                prefix: 'Bearer',
+            },
+            errBuilder: async (error) => {
+                if ('message' in error) {
+                    return error.message;
+                }
+                return error.detail.map((d) => d.msg).join('\n');
+            },
+            method: 'POST',
+            req: {
+                envelope: 'json',
+                builder: async () => req,
+            },
+            urlBuilder: async () => `${MistralAILLMManager_1.BASE_URL}/chat/completions`,
+        });
+    }
+};
+MistralAILLMManager = MistralAILLMManager_1 = __decorate([
+    injectable(),
+    __param(0, inject('HTTPAPICaller')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], MistralAILLMManager);
+export { MistralAILLMManager };

package/dist/esm/std/impl/NodeCryptoManager.js

@@ -7,10 +7,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import crypto from 'node:crypto';
 import { promisify } from 'node:util';
 import { injectable } from 'inversify';
+// https://nodejs.org/api/crypto.html#cryptopbkdf2password-salt-iterations-keylen-digest-callback
 const pbkdf2 = promisify(crypto.pbkdf2);
+// https://nodejs.org/api/crypto.html#cryptoscryptpassword-salt-keylen-options-callback
 const scrypt = promisify(crypto.scrypt);
 let NodeCryptoManager = class NodeCryptoManager {
     async clear() {
+        // Nothing to do
     }
     hash(algorithm, base, binaryToTextEncoding) {
         return crypto
@@ -35,9 +38,11 @@ let NodeCryptoManager = class NodeCryptoManager {
         return Uint8Array.from(result);
     }
     async randomString(length) {
+        // Not perfect in terms of randomness (because of Math.random() but pretty fine for now)
         let res = '';
         while (res.length < length) {
             const next = Math.random().toString(36).slice(2, 3);
+            // For now, we want only chars at the beginning, so it can be used as an identifier (i.e. in a database)
             if (res.length === 0 &&
                 Number.isInteger(Number.parseInt(next, 10))) {
                 continue;
@@ -50,7 +55,7 @@ let NodeCryptoManager = class NodeCryptoManager {
         return crypto.randomUUID();
     }
     async scrypt(password, salt, keyLength) {
-        const buffer = (await scrypt(password, salt, keyLength));
+        const buffer = (await scrypt(password, salt, keyLength)); // Forced to cast because it seems to be not typed correctly
         return buffer.toString('hex');
     }
 };

package/dist/esm/std/impl/NodeDeterministicCryptoManager.d.ts

@@ -1,6 +1,20 @@
 import type { UIntQuantity, UUID } from '../../dt/index.js';
 import type { CryptoManagerRandomString } from '../CryptoManager.js';
 import { NodeCryptoManager } from './NodeCryptoManager.js';
+/**
+ * A deterministic {@link CryptoManager} based on {@link NodeCryptoManager}
+ *
+ * The main purpose is to have an implementation that generates always the
+ * same data deterministically to make snapshot assertions in tests easier.
+ *
+ * WARNING : it keeps internal "seeds" to generate always the same data.
+ *
+ * In our case, it's an auto-incremented integer.
+ *
+ * So if the same implementation is used in multiple places
+ * (e.g. in concurrent tests within the same test suite),
+ * be ready for "race conditions" and inconsistencies.
+ */
 export declare class NodeDeterministicCryptoManager extends NodeCryptoManager {
     private randomStringIdx;
     private uuidIdx;

package/dist/esm/std/impl/NodeDeterministicCryptoManager.js

@@ -7,6 +7,20 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { createHash } from 'node:crypto';
 import { injectable } from 'inversify';
 import { NodeCryptoManager } from './NodeCryptoManager.js';
+/**
+ * A deterministic {@link CryptoManager} based on {@link NodeCryptoManager}
+ *
+ * The main purpose is to have an implementation that generates always the
+ * same data deterministically to make snapshot assertions in tests easier.
+ *
+ * WARNING : it keeps internal "seeds" to generate always the same data.
+ *
+ * In our case, it's an auto-incremented integer.
+ *
+ * So if the same implementation is used in multiple places
+ * (e.g. in concurrent tests within the same test suite),
+ * be ready for "race conditions" and inconsistencies.
+ */
 let NodeDeterministicCryptoManager = class NodeDeterministicCryptoManager extends NodeCryptoManager {
     randomStringIdx = 0;
     uuidIdx = 0;
@@ -33,14 +47,14 @@ let NodeDeterministicCryptoManager = class NodeDeterministicCryptoManager extend
         const hashBytes = hash.digest().subarray(0, 16);
         const bytes = Array.from(hashBytes);
         if (bytes[6] !== undefined) {
-            bytes[6] = (bytes[6] & 0x0f) | 0x40;
+            bytes[6] = (bytes[6] & 0x0f) | 0x40; // Set the version to 4 (UUID v4)
         }
         if (bytes[8] !== undefined) {
-            bytes[8] = (bytes[8] & 0x3f) | 0x80;
+            bytes[8] = (bytes[8] & 0x3f) | 0x80; // Set the variant to the correct RFC 4122 variant
         }
         const raw = bytes
             .map((byte) => {
-            return (byte + 0x1_00).toString(16).substring(1);
+            return (byte + 0x1_00).toString(16).substring(1); // Convert byte to hex
         })
             .join('');
         const uuid = [

package/dist/esm/std/impl/NodeFSManager.js

@@ -13,6 +13,9 @@ let NodeFSManager = class NodeFSManager {
         return true;
     }
     async cat(path, opts) {
+        // Be careful : omitting to pass an encoding makes it return a Buffer and not a string
+        // This can be problematic in some callers, manipulating the file as a string (e.g. startsWith, includes, etc.)
+        // So make sure to fallback on a default encoding
         return readFile(path, opts?.encoding ?? 'utf8');
     }
     async chmod(path, mode) {
@@ -25,6 +28,8 @@ let NodeFSManager = class NodeFSManager {
         await appendFile(src, content);
     }
     async exists(path) {
+        // Before, we could use fs.exists(path) but it's been deprecated : @deprecated since v1.0.0 Use `fs.stat()` or `fs.access()` instead
+        // Both functions are very unpractical to use because we need to wrap everything in a try/catch. It's too verbose !
         try {
             await stat(path);
             return true;
@@ -45,6 +50,11 @@ let NodeFSManager = class NodeFSManager {
         const parsedPath = parse(path);
         const stats = await stat(path);
         const { birthtime, size } = stats;
+        // For now there is nothing in the standard library to detect it.
+        // There are 3rd party packages like mime, mime-type, etc. but we prefer
+        // limiting the external dependencies.
+        // One can also call `file -b --mime-type /some/path` via exec/spawn if their
+        // system has this utility.
         const mimeType = null;
         const type = this.determineType(stats);
         return {

package/dist/esm/std/impl/NodeHTTPAPICallExecutorAgentBuilder.js

@@ -21,6 +21,8 @@ let NodeHTTPAPICallExecutorAgentBuilder = class NodeHTTPAPICallExecutorAgentBuil
     exec({ url, }) {
         if (url.protocol.startsWith('https')) {
             return new https.Agent({
+                // We allow self-signed certificates in non-prod environments
+                // This is useful when testing the CLI calling a the server from a docker container for example
                 rejectUnauthorized: this.environmentManager.isProd(),
             });
         }

package/dist/esm/std/impl/NodePromptManager.js

@@ -9,10 +9,13 @@ import { createInterface } from 'node:readline/promises';
 import { injectable } from 'inversify';
 let NodePromptManager = class NodePromptManager {
     async prompt(invite, opts) {
+        // TODO : Add keypress handling to hide when sensitive data is typed
         const readLine = createInterface({
             input: stdin,
             output: stdout,
         });
+        // To avoid "Warning: Detected unsettled top-level await at file:///[...]/dist/esm/xxx.js"
+        // when pressing Ctrl+C while being prompted
         readLine.on('SIGINT', () => {
             readLine.close();
             process.exit(0);

package/dist/esm/std/impl/OllamaLLMManager.d.ts

@@ -0,0 +1,20 @@
+import type { URL } from '../../dt/index.js';
+import type { HTTPAPICaller } from '../HTTPAPICaller.js';
+import type { LLMManager, LLMManagerSendReq, LLMManagerSendRes } from '../LLMManager.js';
+import type { Configurable, Settings, SettingsManager } from '../SettingsManager.js';
+/**
+ * Unlike the "commercial" APIs, Ollama does not secure the API with an API key
+ * @see https://github.com/ollama/ollama/issues/849
+ */
+export interface OllamaLLMManagerSettings extends Settings {
+    oll_base_url: URL;
+}
+type S = OllamaLLMManagerSettings;
+export declare class OllamaLLMManager implements Configurable<S>, LLMManager {
+    private httpAPICaller;
+    private settingsManager;
+    constructor(httpAPICaller: HTTPAPICaller, settingsManager: SettingsManager<S>);
+    s(): OllamaLLMManagerSettings;
+    send(req: LLMManagerSendReq): Promise<LLMManagerSendRes>;
+}
+export {};