@dexto/core 1.5.8 → 1.6.0

package/dist/storage/database/providers/sqlite.cjs

@@ -1,66 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var sqlite_exports = {};
-__export(sqlite_exports, {
-  sqliteDatabaseProvider: () => sqliteDatabaseProvider
-});
-module.exports = __toCommonJS(sqlite_exports);
-var import_schemas = require("../schemas.js");
-var import_errors = require("../../errors.js");
-const sqliteDatabaseProvider = {
-  type: "sqlite",
-  configSchema: import_schemas.SqliteDatabaseSchema,
-  create: async (config, logger) => {
-    try {
-      const module2 = await import("../sqlite-store.js");
-      logger.info(`Creating SQLite database store: ${config.path}`);
-      return new module2.SQLiteStore(config, logger);
-    } catch (error) {
-      const err = error;
-      if (err.code === "ERR_MODULE_NOT_FOUND" && typeof err.message === "string" && err.message.includes("better-sqlite3")) {
-        throw import_errors.StorageError.dependencyNotInstalled(
-          "SQLite",
-          "better-sqlite3",
-          "npm install better-sqlite3"
-        );
-      }
-      throw error;
-    }
-  },
-  metadata: {
-    displayName: "SQLite",
-    description: "Local SQLite database for persistent storage",
-    requiresNetwork: false,
-    supportsListOperations: true
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  sqliteDatabaseProvider
-});

package/dist/storage/database/providers/sqlite.d.ts

@@ -1,20 +0,0 @@
-import type { DatabaseProvider } from '../provider.js';
-import type { SqliteDatabaseConfig } from '../schemas.js';
-/**
- * Provider for SQLite database storage.
- *
- * This provider stores data in a local SQLite database file using better-sqlite3.
- * It's ideal for single-machine deployments and development scenarios where
- * persistence is required without the overhead of a database server.
- *
- * Features:
- * - Uses better-sqlite3 for synchronous, fast operations
- * - WAL mode enabled for better concurrency
- * - No external server required
- * - Persistent storage survives restarts
- *
- * Note: better-sqlite3 is an optional dependency. Install it with:
- * npm install better-sqlite3
- */
-export declare const sqliteDatabaseProvider: DatabaseProvider<'sqlite', SqliteDatabaseConfig>;
-//# sourceMappingURL=sqlite.d.ts.map

package/dist/storage/database/providers/sqlite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../../../src/storage/database/providers/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAI1D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,EAAE,gBAAgB,CAAC,QAAQ,EAAE,oBAAoB,CA8BnF,CAAC"}

package/dist/storage/database/providers/sqlite.js

@@ -1,33 +0,0 @@
-import "../../../chunk-PTJYTZNU.js";
-import { SqliteDatabaseSchema } from "../schemas.js";
-import { StorageError } from "../../errors.js";
-const sqliteDatabaseProvider = {
-  type: "sqlite",
-  configSchema: SqliteDatabaseSchema,
-  create: async (config, logger) => {
-    try {
-      const module = await import("../sqlite-store.js");
-      logger.info(`Creating SQLite database store: ${config.path}`);
-      return new module.SQLiteStore(config, logger);
-    } catch (error) {
-      const err = error;
-      if (err.code === "ERR_MODULE_NOT_FOUND" && typeof err.message === "string" && err.message.includes("better-sqlite3")) {
-        throw StorageError.dependencyNotInstalled(
-          "SQLite",
-          "better-sqlite3",
-          "npm install better-sqlite3"
-        );
-      }
-      throw error;
-    }
-  },
-  metadata: {
-    displayName: "SQLite",
-    description: "Local SQLite database for persistent storage",
-    requiresNetwork: false,
-    supportsListOperations: true
-  }
-};
-export {
-  sqliteDatabaseProvider
-};

package/dist/storage/database/registry.cjs

@@ -1,50 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var registry_exports = {};
-__export(registry_exports, {
-  DatabaseRegistry: () => DatabaseRegistry,
-  databaseRegistry: () => databaseRegistry
-});
-module.exports = __toCommonJS(registry_exports);
-var import_errors = require("../errors.js");
-var import_base_registry = require("../../providers/base-registry.js");
-const databaseErrorFactory = {
-  alreadyRegistered: (type) => import_errors.StorageError.databaseProviderAlreadyRegistered(type),
-  notFound: (type, availableTypes) => import_errors.StorageError.unknownDatabaseProvider(type, availableTypes)
-};
-class DatabaseRegistry extends import_base_registry.BaseRegistry {
-  constructor() {
-    super(databaseErrorFactory);
-  }
-  /**
-   * Get all registered providers.
-   * Alias for getAll() for backward compatibility.
-   *
-   * @returns Array of providers
-   */
-  getProviders() {
-    return this.getAll();
-  }
-}
-const databaseRegistry = new DatabaseRegistry();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DatabaseRegistry,
-  databaseRegistry
-});

package/dist/storage/database/registry.d.ts

@@ -1,42 +0,0 @@
-import type { DatabaseProvider } from './provider.js';
-import { BaseRegistry } from '../../providers/base-registry.js';
-/**
- * Registry for database providers.
- *
- * This registry manages available database implementations and provides
- * runtime validation for configurations. Providers can be registered from
- * both core (built-in) and application layers (custom).
- *
- * The registry follows a global singleton pattern to allow registration
- * before configuration loading, while maintaining type safety through
- * provider interfaces.
- *
- * Extends BaseRegistry for common registry functionality.
- */
-export declare class DatabaseRegistry extends BaseRegistry<DatabaseProvider<any, any>> {
-    constructor();
-    /**
-     * Get all registered providers.
-     * Alias for getAll() for backward compatibility.
-     *
-     * @returns Array of providers
-     */
-    getProviders(): DatabaseProvider<any, any>[];
-}
-/**
- * Global singleton registry for database providers.
- *
- * This registry is used by the createDatabase factory and can be extended
- * with custom providers before configuration loading.
- *
- * Example usage in CLI/server layer:
- * ```typescript
- * import { databaseRegistry } from '@dexto/core';
- * import { mongoProvider } from './storage/mongo-provider.js';
- *
- * // Register custom provider before loading config
- * databaseRegistry.register(mongoProvider);
- * ```
- */
-export declare const databaseRegistry: DatabaseRegistry;
-//# sourceMappingURL=registry.d.ts.map

package/dist/storage/database/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/storage/database/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,EAAE,YAAY,EAA6B,MAAM,kCAAkC,CAAC;AAY3F;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAiB,SAAQ,YAAY,CAAC,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;;IAK1E;;;;;OAKG;IACH,YAAY,IAAI,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;CAG/C;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}

package/dist/storage/database/registry.js

@@ -1,26 +0,0 @@
-import "../../chunk-PTJYTZNU.js";
-import { StorageError } from "../errors.js";
-import { BaseRegistry } from "../../providers/base-registry.js";
-const databaseErrorFactory = {
-  alreadyRegistered: (type) => StorageError.databaseProviderAlreadyRegistered(type),
-  notFound: (type, availableTypes) => StorageError.unknownDatabaseProvider(type, availableTypes)
-};
-class DatabaseRegistry extends BaseRegistry {
-  constructor() {
-    super(databaseErrorFactory);
-  }
-  /**
-   * Get all registered providers.
-   * Alias for getAll() for backward compatibility.
-   *
-   * @returns Array of providers
-   */
-  getProviders() {
-    return this.getAll();
-  }
-}
-const databaseRegistry = new DatabaseRegistry();
-export {
-  DatabaseRegistry,
-  databaseRegistry
-};

package/dist/storage/database/schemas.cjs

@@ -1,97 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var schemas_exports = {};
-__export(schemas_exports, {
-  DATABASE_TYPES: () => DATABASE_TYPES,
-  DatabaseConfigSchema: () => DatabaseConfigSchema,
-  InMemoryDatabaseSchema: () => InMemoryDatabaseSchema,
-  PostgresDatabaseSchema: () => PostgresDatabaseSchema,
-  SqliteDatabaseSchema: () => SqliteDatabaseSchema
-});
-module.exports = __toCommonJS(schemas_exports);
-var import_zod = require("zod");
-var import_result = require("../../utils/result.cjs");
-var import_error_codes = require("../error-codes.js");
-var import_types = require("../../errors/types.cjs");
-const DATABASE_TYPES = ["in-memory", "sqlite", "postgres"];
-const BaseDatabaseSchema = import_zod.z.object({
-  maxConnections: import_zod.z.number().int().positive().optional().describe("Maximum connections"),
-  idleTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
-  connectionTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
-  options: import_zod.z.record(import_zod.z.any()).optional().describe("Backend-specific options")
-});
-const InMemoryDatabaseSchema = BaseDatabaseSchema.extend({
-  type: import_zod.z.literal("in-memory")
-  // In-memory database doesn't need connection options, but inherits pool options for consistency
-}).strict();
-const SqliteDatabaseSchema = BaseDatabaseSchema.extend({
-  type: import_zod.z.literal("sqlite"),
-  path: import_zod.z.string().describe(
-    "SQLite database file path (required for SQLite - CLI enrichment provides per-agent path)"
-  )
-}).strict();
-const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
-  type: import_zod.z.literal("postgres"),
-  url: (0, import_result.EnvExpandedString)().optional().describe("PostgreSQL connection URL (postgresql://...)"),
-  connectionString: (0, import_result.EnvExpandedString)().optional().describe("PostgreSQL connection string"),
-  host: import_zod.z.string().optional().describe("PostgreSQL host"),
-  port: import_zod.z.number().int().positive().optional().describe("PostgreSQL port"),
-  database: import_zod.z.string().optional().describe("PostgreSQL database name"),
-  password: import_zod.z.string().optional().describe("PostgreSQL password"),
-  // TODO: keyPrefix is reserved for future use - allows namespacing keys when multiple
-  // agents or environments share the same database (e.g., "dev:agent1:" vs "prod:agent2:")
-  keyPrefix: import_zod.z.string().optional().describe('Optional key prefix for namespacing (e.g., "dev:myagent:")')
-}).strict();
-const DatabaseConfigSchema = import_zod.z.discriminatedUnion(
-  "type",
-  [InMemoryDatabaseSchema, SqliteDatabaseSchema, PostgresDatabaseSchema],
-  {
-    errorMap: (issue, ctx) => {
-      if (issue.code === import_zod.z.ZodIssueCode.invalid_union_discriminator) {
-        return {
-          message: `Invalid database type. Expected 'in-memory', 'sqlite', or 'postgres'.`
-        };
-      }
-      return { message: ctx.defaultError };
-    }
-  }
-).describe("Database configuration").superRefine((data, ctx) => {
-  if (data.type === "postgres") {
-    if (!data.url && !data.connectionString && !data.host) {
-      ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
-        message: "PostgreSQL database requires one of 'url', 'connectionString', or 'host' to be specified",
-        path: ["url"],
-        params: {
-          code: import_error_codes.StorageErrorCode.CONNECTION_CONFIG_MISSING,
-          scope: import_types.ErrorScope.STORAGE,
-          type: import_types.ErrorType.USER
-        }
-      });
-    }
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DATABASE_TYPES,
-  DatabaseConfigSchema,
-  InMemoryDatabaseSchema,
-  PostgresDatabaseSchema,
-  SqliteDatabaseSchema
-});

package/dist/storage/database/schemas.d.ts

@@ -1,226 +0,0 @@
-import { z } from 'zod';
-export declare const DATABASE_TYPES: readonly ["in-memory", "sqlite", "postgres"];
-export type DatabaseType = (typeof DATABASE_TYPES)[number];
-export declare const InMemoryDatabaseSchema: z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"in-memory">;
-}, "strict", z.ZodTypeAny, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}>;
-export type InMemoryDatabaseConfig = z.output<typeof InMemoryDatabaseSchema>;
-export declare const SqliteDatabaseSchema: z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"sqlite">;
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-    type: "sqlite";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}, {
-    path: string;
-    type: "sqlite";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}>;
-export type SqliteDatabaseConfig = z.output<typeof SqliteDatabaseSchema>;
-export declare const PostgresDatabaseSchema: z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"postgres">;
-    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    host: z.ZodOptional<z.ZodString>;
-    port: z.ZodOptional<z.ZodNumber>;
-    database: z.ZodOptional<z.ZodString>;
-    password: z.ZodOptional<z.ZodString>;
-    keyPrefix: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    type: "postgres";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}, {
-    type: "postgres";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}>;
-export type PostgresDatabaseConfig = z.output<typeof PostgresDatabaseSchema>;
-export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"in-memory">;
-}, "strict", z.ZodTypeAny, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}>, z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"sqlite">;
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-    type: "sqlite";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}, {
-    path: string;
-    type: "sqlite";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}>, z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"postgres">;
-    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    host: z.ZodOptional<z.ZodString>;
-    port: z.ZodOptional<z.ZodNumber>;
-    database: z.ZodOptional<z.ZodString>;
-    password: z.ZodOptional<z.ZodString>;
-    keyPrefix: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    type: "postgres";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}, {
-    type: "postgres";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}>]>, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-} | {
-    path: string;
-    type: "sqlite";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-} | {
-    type: "postgres";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-} | {
-    path: string;
-    type: "sqlite";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-} | {
-    type: "postgres";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}>;
-export type DatabaseConfig = z.output<typeof DatabaseConfigSchema>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/storage/database/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/database/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,cAAc,8CAA+C,CAAC;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAoB3D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAGxB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;EAOtB,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGzE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC3B,CAAC;AAEP,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/storage/database/schemas.js

@@ -1,70 +0,0 @@
-import "../../chunk-PTJYTZNU.js";
-import { z } from "zod";
-import { EnvExpandedString } from "../../utils/result.js";
-import { StorageErrorCode } from "../error-codes.js";
-import { ErrorScope, ErrorType } from "../../errors/types.js";
-const DATABASE_TYPES = ["in-memory", "sqlite", "postgres"];
-const BaseDatabaseSchema = z.object({
-  maxConnections: z.number().int().positive().optional().describe("Maximum connections"),
-  idleTimeoutMillis: z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
-  connectionTimeoutMillis: z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
-  options: z.record(z.any()).optional().describe("Backend-specific options")
-});
-const InMemoryDatabaseSchema = BaseDatabaseSchema.extend({
-  type: z.literal("in-memory")
-  // In-memory database doesn't need connection options, but inherits pool options for consistency
-}).strict();
-const SqliteDatabaseSchema = BaseDatabaseSchema.extend({
-  type: z.literal("sqlite"),
-  path: z.string().describe(
-    "SQLite database file path (required for SQLite - CLI enrichment provides per-agent path)"
-  )
-}).strict();
-const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
-  type: z.literal("postgres"),
-  url: EnvExpandedString().optional().describe("PostgreSQL connection URL (postgresql://...)"),
-  connectionString: EnvExpandedString().optional().describe("PostgreSQL connection string"),
-  host: z.string().optional().describe("PostgreSQL host"),
-  port: z.number().int().positive().optional().describe("PostgreSQL port"),
-  database: z.string().optional().describe("PostgreSQL database name"),
-  password: z.string().optional().describe("PostgreSQL password"),
-  // TODO: keyPrefix is reserved for future use - allows namespacing keys when multiple
-  // agents or environments share the same database (e.g., "dev:agent1:" vs "prod:agent2:")
-  keyPrefix: z.string().optional().describe('Optional key prefix for namespacing (e.g., "dev:myagent:")')
-}).strict();
-const DatabaseConfigSchema = z.discriminatedUnion(
-  "type",
-  [InMemoryDatabaseSchema, SqliteDatabaseSchema, PostgresDatabaseSchema],
-  {
-    errorMap: (issue, ctx) => {
-      if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
-        return {
-          message: `Invalid database type. Expected 'in-memory', 'sqlite', or 'postgres'.`
-        };
-      }
-      return { message: ctx.defaultError };
-    }
-  }
-).describe("Database configuration").superRefine((data, ctx) => {
-  if (data.type === "postgres") {
-    if (!data.url && !data.connectionString && !data.host) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "PostgreSQL database requires one of 'url', 'connectionString', or 'host' to be specified",
-        path: ["url"],
-        params: {
-          code: StorageErrorCode.CONNECTION_CONFIG_MISSING,
-          scope: ErrorScope.STORAGE,
-          type: ErrorType.USER
-        }
-      });
-    }
-  }
-});
-export {
-  DATABASE_TYPES,
-  DatabaseConfigSchema,
-  InMemoryDatabaseSchema,
-  PostgresDatabaseSchema,
-  SqliteDatabaseSchema
-};