@lov3kaizen/agentsea-prompts 0.5.1

package/dist/index-CxHUTqKA.d.ts

@@ -0,0 +1,280 @@
+import { EventEmitter } from 'eventemitter3';
+import { P as PromptData, V as VariableDefinitions, R as RenderOptions, c as RenderedPrompt, C as CreatePromptInput, U as UpdatePromptInput, f as PromptQueryOptions } from './prompt.types-UpghZJIu.js';
+import { Z as StorageAdapter, E as EnvironmentConfig, a as VersionHistoryEntry, V as VersionInfo, e as DiffOptions, D as DiffResult, C as CreateBranchInput, B as BranchInfo, M as MergeOptions, f as MergeResult, R as RollbackOptions, i as RollbackResult, P as PromoteInput, j as PromotionResult, A as ABTestConfig, o as ABTestData, J as CreateReviewInput, F as ReviewRequest, Y as AuditLogQueryOptions, W as AuditLogEntry } from './storage.types-CNQ8CxaH.js';
+import { P as Prompt, a as PromptClient } from './Client-raKKKXgi.js';
+import Handlebars from 'handlebars';
+
+interface RegistryConfig {
+    storage: StorageAdapter;
+    defaultEnvironment?: string;
+    environments?: EnvironmentConfig[];
+    caching?: CacheConfig;
+    hooks?: RegistryHooks;
+}
+interface CacheConfig {
+    enabled: boolean;
+    ttl?: number;
+    maxSize?: number;
+}
+type RegistryEventType = 'prompt:created' | 'prompt:updated' | 'prompt:deleted' | 'prompt:promoted' | 'prompt:rolledback' | 'version:created' | 'branch:created' | 'branch:merged' | 'branch:deleted' | 'test:created' | 'test:started' | 'test:ended' | 'review:created' | 'review:approved' | 'review:rejected' | 'review:merged';
+interface RegistryEvent {
+    type: RegistryEventType;
+    promptId?: string;
+    promptName?: string;
+    version?: string;
+    environment?: string;
+    actor?: string;
+    timestamp: Date;
+    data?: Record<string, unknown>;
+}
+interface RegistryHooks {
+    beforeCreate?: (prompt: unknown) => Promise<unknown>;
+    afterCreate?: (prompt: unknown) => Promise<void>;
+    beforeUpdate?: (prompt: unknown, updates: unknown) => Promise<unknown>;
+    afterUpdate?: (prompt: unknown) => Promise<void>;
+    beforeDelete?: (promptId: string) => Promise<boolean>;
+    afterDelete?: (promptId: string) => Promise<void>;
+    beforePromote?: (promotion: unknown) => Promise<unknown>;
+    afterPromote?: (promotion: unknown) => Promise<void>;
+}
+interface RegistryStats {
+    totalPrompts: number;
+    totalVersions: number;
+    promptsByEnvironment: Record<string, number>;
+    promptsByStatus: Record<string, number>;
+    activeTests: number;
+    pendingReviews: number;
+}
+interface PartialDefinition {
+    name: string;
+    template: string;
+    description?: string;
+    variables?: string[];
+}
+
+declare class PromptVersion implements VersionHistoryEntry {
+    readonly promptId: string;
+    readonly promptName: string;
+    readonly version: string;
+    readonly hash: string;
+    readonly message?: string;
+    readonly author?: string;
+    readonly createdAt: Date;
+    readonly parentVersion?: string;
+    readonly branch?: string;
+    readonly environment: string;
+    readonly snapshot: PromptData;
+    constructor(data: VersionHistoryEntry);
+    getInfo(): VersionInfo;
+    toData(): VersionHistoryEntry;
+    isNewerThan(other: PromptVersion | string): boolean;
+    isOlderThan(other: PromptVersion | string): boolean;
+    toString(): string;
+    static fromPrompt(prompt: PromptData, options?: {
+        message?: string;
+        author?: string;
+        parentVersion?: string;
+        branch?: string;
+    }): PromptVersion;
+}
+declare class VersionHistory {
+    private versions;
+    private currentVersion;
+    constructor(versions?: PromptVersion[]);
+    add(version: PromptVersion): void;
+    get(version: string): PromptVersion | undefined;
+    getLatest(): PromptVersion | undefined;
+    getAll(limit?: number): PromptVersion[];
+    get count(): number;
+    getNextVersion(): string;
+    getByBranch(branch: string): PromptVersion[];
+    getByAuthor(author: string): PromptVersion[];
+    getByDateRange(start: Date, end: Date): PromptVersion[];
+    has(version: string): boolean;
+    getPrevious(version: string): PromptVersion | undefined;
+    getLineage(version: string): PromptVersion[];
+}
+
+interface TemplateCompileOptions {
+    strict?: boolean;
+    noEscape?: boolean;
+    knownHelpers?: Record<string, boolean>;
+    knownHelpersOnly?: boolean;
+}
+declare class PromptTemplate {
+    readonly template: string;
+    readonly variables: VariableDefinitions;
+    private compiledTemplate?;
+    private handlebars;
+    constructor(template: string, variables?: VariableDefinitions, options?: {
+        partials?: Record<string, string>;
+        helpers?: Record<string, unknown>;
+    });
+    private registerDefaultHelpers;
+    private inferVariables;
+    compile(options?: TemplateCompileOptions): HandlebarsTemplateDelegate;
+    render(variables: Record<string, unknown>, options?: RenderOptions): RenderedPrompt;
+    registerPartial(name: string, template: string): void;
+    registerHelper(name: string, helper: Handlebars.HelperDelegate): void;
+    getVariableNames(): string[];
+    clone(overrides?: {
+        template?: string;
+        variables?: VariableDefinitions;
+    }): PromptTemplate;
+}
+declare class Partial {
+    readonly name: string;
+    readonly template: string;
+    readonly description?: string;
+    readonly variables: string[];
+    constructor(config: {
+        name: string;
+        template: string;
+        description?: string;
+    });
+    toData(): {
+        name: string;
+        template: string;
+        description?: string;
+        variables: string[];
+    };
+}
+declare function compose(parts: Array<{
+    partial: string;
+    variables?: Record<string, unknown>;
+} | {
+    template: string;
+    variables?: Record<string, unknown>;
+}>, separator?: string): string;
+declare function createComposedTemplate(parts: Array<{
+    name?: string;
+    template: string;
+    condition?: string;
+}>, options?: {
+    separator?: string;
+    wrapInConditional?: boolean;
+}): string;
+
+declare class PromptRegistry extends EventEmitter<Record<RegistryEventType, [RegistryEvent]>> {
+    private storage;
+    private defaultEnvironment;
+    private environments;
+    private cache?;
+    private versionHistories;
+    private partials;
+    private initialized;
+    constructor(config: RegistryConfig);
+    initialize(): Promise<void>;
+    private ensureInitialized;
+    create(input: CreatePromptInput): Promise<Prompt>;
+    get(name: string, options?: {
+        environment?: string;
+        version?: string;
+    }): Promise<Prompt | null>;
+    getById(id: string, options?: {
+        environment?: string;
+    }): Promise<Prompt | null>;
+    update(name: string, updates: UpdatePromptInput, options?: {
+        environment?: string;
+        author?: string;
+    }): Promise<Prompt>;
+    delete(name: string, options?: {
+        environment?: string;
+    }): Promise<boolean>;
+    query(options?: PromptQueryOptions): Promise<Prompt[]>;
+    list(options?: {
+        environment?: string;
+    }): Promise<Prompt[]>;
+    render(name: string, variables: Record<string, unknown>, options?: RenderOptions & {
+        environment?: string;
+        version?: string;
+    }): Promise<RenderedPrompt>;
+    history(name: string, options?: {
+        environment?: string;
+        limit?: number;
+    }): Promise<PromptVersion[]>;
+    diff(name: string, options: DiffOptions): Promise<DiffResult>;
+    branch(name: string, input: CreateBranchInput, options?: {
+        environment?: string;
+    }): Promise<BranchInfo>;
+    merge(name: string, options: MergeOptions & {
+        environment?: string;
+    }): Promise<MergeResult>;
+    rollback(name: string, options: RollbackOptions & {
+        environment?: string;
+    }): Promise<RollbackResult>;
+    promote(name: string, options: PromoteInput): Promise<PromotionResult>;
+    getEnvironments(): EnvironmentConfig[];
+    registerPartial(partial: Partial | PartialDefinition): Promise<void>;
+    getPartial(name: string): Partial | undefined;
+    getPartials(): Partial[];
+    deletePartial(name: string): Promise<boolean>;
+    createABTest(config: ABTestConfig): Promise<ABTestData>;
+    getABTest(nameOrId: string): Promise<ABTestData | null>;
+    requestReview(name: string, input: CreateReviewInput): Promise<ReviewRequest>;
+    private logAudit;
+    getAuditLog(nameOrOptions?: string | AuditLogQueryOptions): Promise<AuditLogEntry[]>;
+    getStats(): Promise<RegistryStats>;
+    close(): Promise<void>;
+}
+
+interface PromptProviderConfig {
+    registry?: PromptRegistry;
+    client?: PromptClient;
+    environment?: string;
+    autoRefresh?: boolean;
+    cacheTtl?: number;
+}
+interface DynamicPromptConfig {
+    name: string;
+    variables?: Record<string, unknown>;
+    version?: string;
+    fallback?: string;
+}
+interface ProviderEvents {
+    'prompt:refreshed': {
+        name: string;
+        version: string;
+    };
+    'prompt:error': {
+        name: string;
+        error: unknown;
+    };
+}
+declare class PromptProvider extends EventEmitter<ProviderEvents> {
+    private registry?;
+    private client?;
+    private environment;
+    private autoRefresh;
+    private cache;
+    private cacheTtl;
+    constructor(config: PromptProviderConfig);
+    private setupAutoRefresh;
+    get(name: string, options?: {
+        version?: string;
+        forceRefresh?: boolean;
+    }): Promise<Prompt | null>;
+    render(name: string, variables: Record<string, unknown>, options?: RenderOptions & {
+        version?: string;
+    }): Promise<RenderedPrompt>;
+    dynamic(nameOrConfig: string | DynamicPromptConfig, defaultVariables?: Record<string, unknown>): () => Promise<string>;
+    static(name: string, variables?: Record<string, unknown>): () => string;
+    preload(names: string[]): Promise<void>;
+    clearCache(): void;
+    invalidate(name: string): void;
+    getCacheStats(): {
+        size: number;
+        prompts: string[];
+    };
+}
+declare function createSystemPrompt(provider: PromptProvider, name: string, variables?: Record<string, unknown>, options?: {
+    fallback?: string;
+}): () => Promise<string>;
+declare function createABTestPrompt(provider: PromptProvider, config: {
+    testName: string;
+    prompt: string;
+    variables?: Record<string, unknown>;
+    getUserId: (context: Record<string, unknown>) => string;
+}): (context: Record<string, unknown>) => Promise<string>;
+
+export { type CacheConfig as C, type DynamicPromptConfig as D, PromptVersion as P, type RegistryConfig as R, VersionHistory as V, PromptTemplate as a, Partial as b, compose as c, createComposedTemplate as d, PromptRegistry as e, PromptProvider as f, createSystemPrompt as g, createABTestPrompt as h, type PromptProviderConfig as i, type RegistryEvent as j, type RegistryEventType as k, type RegistryStats as l, type RegistryHooks as m, type PartialDefinition as n };

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+export { P as Prompt, a as PromptClient, d as PromptClientConfig, b as PromptLoader, c as createDynamicPrompt } from './Client-raKKKXgi.js';
+export { C as CacheConfig, D as DynamicPromptConfig, b as Partial, n as PartialDefinition, f as PromptProvider, i as PromptProviderConfig, e as PromptRegistry, a as PromptTemplate, P as PromptVersion, R as RegistryConfig, j as RegistryEvent, k as RegistryEventType, m as RegistryHooks, l as RegistryStats, V as VersionHistory, c as compose, h as createABTestPrompt, d as createComposedTemplate, g as createSystemPrompt } from './index-CxHUTqKA.js';
+export { BufferStorage, FileStorage } from './storage/index.js';
+import { V as VariableDefinitions } from './prompt.types-UpghZJIu.js';
+export { C as CreatePromptInput, P as PromptData, a as PromptMetadata, f as PromptQueryOptions, b as PromptStatus, R as RenderOptions, c as RenderedPrompt, U as UpdatePromptInput, d as VariableDefinition, e as VariableType } from './prompt.types-UpghZJIu.js';
+export { A as ABTestConfig, o as ABTestData, q as ABTestResults, p as ABTestStatus, Q as AccessCheck, S as AccessCheckResult, z as AssertionType, X as AuditAction, W as AuditLogEntry, Y as AuditLogQueryOptions, B as BranchInfo, K as Comment, C as CreateBranchInput, L as CreateCommentInput, J as CreateReviewInput, b as DiffHunk, c as DiffLine, d as DiffLineType, e as DiffOptions, D as DiffResult, n as EnvironmentComparison, E as EnvironmentConfig, m as EnvironmentSyncStatus, _ as FileStorageConfig, G as GetVariantOptions, h as MergeConflict, M as MergeOptions, f as MergeResult, g as MergeStrategy, s as MetricComparison, t as MetricRecord, N as Permission, a0 as PostgresStorageConfig, P as PromoteInput, k as PromotionRequest, j as PromotionResult, l as PromotionStatus, I as ReviewApproval, F as ReviewRequest, H as ReviewStatus, O as Role, R as RollbackOptions, i as RollbackResult, a1 as S3StorageConfig, $ as SQLiteStorageConfig, Z as StorageAdapter, y as TestAssertion, v as TestCase, w as TestCaseResult, x as TestRunResult, T as TestVariant, U as UserPermissions, u as VariantAssignment, r as VariantStats, a as VersionHistoryEntry, V as VersionInfo } from './storage.types-CNQ8CxaH.js';
+export { ABTest, createABTestConfig } from './testing/index.js';
+import { z } from 'zod';
+import 'eventemitter3';
+import 'handlebars';
+
+declare function hashContent(content: string): string;
+declare function generateId(): string;
+declare function generateVersion(num: number): string;
+declare function parseVersion(version: string): number;
+declare function incrementVersion(version: string): string;
+declare function compareVersions(a: string, b: string): number;
+declare function shortHash(hash: string, length?: number): string;
+
+declare function validatePromptName(name: string): {
+    valid: boolean;
+    error?: string;
+};
+declare function validateTemplate(template: string): {
+    valid: boolean;
+    error?: string;
+    variables: string[];
+};
+declare function validateVariables(variables: Record<string, unknown>, definitions: VariableDefinitions): {
+    valid: boolean;
+    errors: string[];
+};
+declare function createVariableSchema(definitions: VariableDefinitions): z.ZodSchema;
+declare function validateBranchName(name: string): {
+    valid: boolean;
+    error?: string;
+};
+declare function validateEnvironmentName(name: string): {
+    valid: boolean;
+    error?: string;
+};
+
+declare function normalizeTemplate(template: string): string;
+declare function formatPromptDisplay(template: string, options?: {
+    maxLines?: number;
+    truncateLength?: number;
+}): string;
+declare function formatVersion(version: string): string;
+declare function formatDate(date: Date): string;
+declare function formatRelativeTime(date: Date): string;
+declare function truncate(text: string, maxLength: number): string;
+declare function highlightVariables(template: string): string;
+declare function indent(text: string, spaces?: number): string;
+declare function wordWrap(text: string, maxWidth?: number): string;
+
+export { VariableDefinitions, compareVersions, createVariableSchema, formatDate, formatPromptDisplay, formatRelativeTime, formatVersion, generateId, generateVersion, hashContent, highlightVariables, incrementVersion, indent, normalizeTemplate, parseVersion, shortHash, truncate, validateBranchName, validateEnvironmentName, validatePromptName, validateTemplate, validateVariables, wordWrap };