@promptbook/editable 0.100.0-4 → 0.100.0-40

package/esm/typings/src/book-2.0/agent-source/string_book.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Branded type for books
+ */
+export type string_book = string & {
+    readonly __type: 'book';
+};
+/**
+ * Type guard to check if a string is a valid agent source
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function isValidBook(value: string): value is string_book;
+/**
+ * Validates and converts a string to agent source branded type
+ * This function should be used when you have a string that you know represents agent source
+ * but need to convert it to the branded type for type safety
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function validateBook(source: string): string_book;
+/**
+ * Default book
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare const DEFAULT_BOOK: string_book;

package/esm/typings/src/book-2.0/commitments/ACTION/ACTION.d.ts

@@ -0,0 +1,38 @@
+import { BaseCommitmentDefinition } from '../_base/BaseCommitmentDefinition';
+import type { AgentModelRequirements } from '../_misc/AgentModelRequirements';
+/**
+ * ACTION commitment definition
+ *
+ * The ACTION commitment defines specific actions or capabilities that the agent can perform.
+ * This helps define what the agent is capable of doing and how it should approach tasks.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * ACTION Can generate code snippets and explain programming concepts
+ * ACTION Able to analyze data and provide insights
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare class ActionCommitmentDefinition extends BaseCommitmentDefinition<'ACTION'> {
+    constructor();
+    /**
+     * Short one-line description of ACTION.
+     */
+    get description(): string;
+    /**
+     * Markdown documentation for ACTION commitment.
+     */
+    get documentation(): string;
+    applyToAgentModelRequirements(requirements: AgentModelRequirements, content: string): AgentModelRequirements;
+}
+/**
+ * Singleton instance of the ACTION commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare const ActionCommitment: ActionCommitmentDefinition;
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/book-2.0/commitments/FORMAT/FORMAT.d.ts

@@ -0,0 +1,39 @@
+import { BaseCommitmentDefinition } from '../_base/BaseCommitmentDefinition';
+import type { AgentModelRequirements } from '../_misc/AgentModelRequirements';
+/**
+ * FORMAT commitment definition
+ *
+ * The FORMAT commitment defines the specific output structure and formatting
+ * that the agent should use in its responses. This includes data formats,
+ * response templates, and structural requirements.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * FORMAT Always respond in JSON format with 'status' and 'data' fields
+ * FORMAT Use markdown formatting for all code blocks
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare class FormatCommitmentDefinition extends BaseCommitmentDefinition<'FORMAT'> {
+    constructor();
+    /**
+     * Short one-line description of FORMAT.
+     */
+    get description(): string;
+    /**
+     * Markdown documentation for FORMAT commitment.
+     */
+    get documentation(): string;
+    applyToAgentModelRequirements(requirements: AgentModelRequirements, content: string): AgentModelRequirements;
+}
+/**
+ * Singleton instance of the FORMAT commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare const FormatCommitment: FormatCommitmentDefinition;
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/FrontendRAGService.d.ts

@@ -0,0 +1,48 @@
+import type { string_url } from '../../../types/typeAliases';
+import type { RAGConfig } from './types';
+import type { RetrievalResult } from './types';
+/**
+ * Frontend RAG Service that uses backend APIs for processing
+ * This avoids Node.js dependencies in the frontend
+ *
+ * @private - TODO: [🧠] Maybe should be public?
+ */
+export declare class FrontendRAGService {
+    private chunks;
+    private sources;
+    private config;
+    private isInitialized;
+    constructor(config?: Partial<RAGConfig>);
+    /**
+     * Initialize knowledge sources by processing them on the backend
+     */
+    initializeKnowledgeSources(sources: string_url[]): Promise<void>;
+    /**
+     * Get relevant context for a user query
+     */
+    getContextForQuery(query: string): Promise<string>;
+    /**
+     * Get relevant chunks for a query (for debugging/inspection)
+     */
+    getRelevantChunks(query: string): Promise<RetrievalResult[]>;
+    /**
+     * Get knowledge base statistics
+     */
+    getStats(): {
+        sources: number;
+        chunks: number;
+        isInitialized: boolean;
+    };
+    /**
+     * Check if the service is ready to use
+     */
+    isReady(): boolean;
+    /**
+     * Clear all knowledge sources
+     */
+    clearKnowledgeBase(): void;
+    /**
+     * Add a single knowledge source (for incremental updates)
+     */
+    addKnowledgeSource(url: string_url): Promise<void>;
+}

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/KNOWLEDGE.d.ts

@@ -0,0 +1,51 @@
+import { BaseCommitmentDefinition } from '../_base/BaseCommitmentDefinition';
+import type { AgentModelRequirements } from '../_misc/AgentModelRequirements';
+import { FrontendRAGService } from './FrontendRAGService';
+/**
+ * KNOWLEDGE commitment definition
+ *
+ * The KNOWLEDGE commitment adds specific knowledge, facts, or context to the agent
+ * using RAG (Retrieval-Augmented Generation) approach for external sources.
+ *
+ * Supports both direct text knowledge and external sources like PDFs.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * KNOWLEDGE The company was founded in 2020 and specializes in AI-powered solutions
+ * KNOWLEDGE https://example.com/company-handbook.pdf
+ * KNOWLEDGE https://example.com/product-documentation.pdf
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare class KnowledgeCommitmentDefinition extends BaseCommitmentDefinition<'KNOWLEDGE'> {
+    private ragService;
+    constructor();
+    /**
+     * Short one-line description of KNOWLEDGE.
+     */
+    get description(): string;
+    /**
+     * Markdown documentation for KNOWLEDGE commitment.
+     */
+    get documentation(): string;
+    applyToAgentModelRequirements(requirements: AgentModelRequirements, content: string): AgentModelRequirements;
+    /**
+     * Check if content is a URL
+     */
+    private isUrl;
+    /**
+     * Get RAG service instance for retrieving context during chat
+     */
+    getRagService(): FrontendRAGService;
+}
+/**
+ * Singleton instance of the KNOWLEDGE commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare const KnowledgeCommitment: KnowledgeCommitmentDefinition;
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/RAGService.d.ts

@@ -0,0 +1,54 @@
+import type { string_url } from '../../../types/typeAliases';
+import type { RAGConfig } from './types';
+import type { RetrievalResult } from './types';
+/**
+ * RAG (Retrieval-Augmented Generation) Service
+ * Handles knowledge source processing and retrieval
+ *
+ * @private
+ */
+export declare class RAGService {
+    private knowledgeBase;
+    private config;
+    constructor(config?: Partial<RAGConfig>);
+    /**
+     * Add a knowledge source from URL
+     */
+    addKnowledgeSource(url: string_url): Promise<void>;
+    /**
+     * Retrieve relevant chunks for a query
+     */
+    retrieveRelevantChunks(query: string): RetrievalResult[];
+    /**
+     * Get formatted context for the agent
+     */
+    getContextForQuery(query: string): string;
+    /**
+     * Get knowledge base statistics
+     */
+    getStats(): {
+        sources: number;
+        chunks: number;
+        lastUpdated: Date;
+    };
+    /**
+     * Clear all knowledge sources
+     */
+    clearKnowledgeBase(): void;
+    /**
+     * Tokenize query into words for relevance scoring
+     */
+    private tokenizeQuery;
+    /**
+     * Calculate relevance score between content and query words
+     * Simple keyword matching - in production, use embeddings
+     */
+    private calculateRelevanceScore;
+    /**
+     * Generate content hash for caching
+     */
+    private generateContentHash;
+}
+/**
+ * TODO: !!!! use the already existing RAG instead of this
+ */

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/processors/BaseKnowledgeProcessor.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { TODO_any } from '../../../../utils/organization/TODO_any';
+import type { string_url } from '../../../../types/typeAliases';
+import type { KnowledgeChunk } from '../types';
+import type { KnowledgeSourceFormat } from '../types';
+import type { RAGConfig } from '../types';
+/**
+ * Base class for knowledge source processors
+ * Provides common functionality for all knowledge processors
+ *
+ * @private
+ */
+export declare abstract class BaseKnowledgeProcessor {
+    protected readonly config: RAGConfig;
+    constructor(config?: Partial<RAGConfig>);
+    /**
+     * The format this processor supports
+     */
+    abstract readonly supportedFormat: KnowledgeSourceFormat;
+    /**
+     * Process a buffer and return knowledge chunks
+     */
+    abstract processBuffer(buffer: Buffer, sourceUrl: string_url): Promise<KnowledgeChunk[]>;
+    /**
+     * Generate a content hash for caching purposes
+     */
+    protected generateContentHash(content: string): string;
+    /**
+     * Generate a unique chunk ID
+     */
+    protected generateChunkId(sourceUrl: string_url, chunkIndex: number): string;
+    /**
+     * Split text into sentences for better chunking
+     */
+    protected splitIntoSentences(text: string): string[];
+    /**
+     * Get overlap text from the end of current chunk
+     */
+    protected getOverlapText(text: string, overlapSize: number): string;
+    /**
+     * Create chunks from text with proper overlap handling
+     */
+    protected createChunksFromText(text: string, sourceUrl: string_url, additionalMetadata?: Record<string, TODO_any>): KnowledgeChunk[];
+}

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/processors/PdfProcessor.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { string_url } from '../../../../types/typeAliases';
+import type { KnowledgeChunk } from '../types';
+import { BaseKnowledgeProcessor } from './BaseKnowledgeProcessor';
+/**
+ * PDF knowledge source processor
+ * Handles extraction and chunking of PDF documents
+ *
+ * @private
+ */
+export declare class PdfProcessor extends BaseKnowledgeProcessor {
+    readonly supportedFormat: "pdf";
+    /**
+     * Process PDF buffer and extract text content
+     */
+    processBuffer(buffer: Buffer, sourceUrl: string_url): Promise<KnowledgeChunk[]>;
+    /**
+     * Extract title from PDF text (first meaningful line)
+     */
+    private extractTitleFromText;
+    /**
+     * Create chunks from PDF text with page awareness
+     */
+    protected createChunksFromText(text: string, sourceUrl: string_url, pdfInfo: {
+        totalPages: number;
+    }): KnowledgeChunk[];
+}
+/**
+ * TODO: !!!! Implement this through standard knowledge scraper
+ */

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/processors/ProcessorFactory.d.ts

@@ -0,0 +1,23 @@
+import type { string_url } from '../../../../types/typeAliases';
+import type { KnowledgeSourceFormat } from '../types';
+import type { RAGConfig } from '../types';
+import { BaseKnowledgeProcessor } from './BaseKnowledgeProcessor';
+/**
+ * Factory for creating knowledge source processors
+ *
+ * @private
+ */
+export declare class ProcessorFactory {
+    /**
+     * Get processor for a specific format
+     */
+    static getProcessor(format: KnowledgeSourceFormat, config?: Partial<RAGConfig>): BaseKnowledgeProcessor;
+    /**
+     * Detect format from URL
+     */
+    static detectFormat(url: string_url): KnowledgeSourceFormat;
+    /**
+     * Get all supported formats
+     */
+    static getSupportedFormats(): KnowledgeSourceFormat[];
+}

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/processors/TextProcessor.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { string_url } from '../../../../types/typeAliases';
+import type { KnowledgeChunk } from '../types';
+import { BaseKnowledgeProcessor } from './BaseKnowledgeProcessor';
+/**
+ * Text knowledge source processor
+ * Handles plain text documents
+ *
+ * @private
+ */
+export declare class TextProcessor extends BaseKnowledgeProcessor {
+    readonly supportedFormat: "text";
+    /**
+     * Process text buffer and extract content
+     */
+    processBuffer(buffer: Buffer, sourceUrl: string_url): Promise<KnowledgeChunk[]>;
+}

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/types.d.ts

@@ -0,0 +1,56 @@
+import type { string_url } from '../../../types/typeAliases';
+/**
+ * Supported knowledge source formats
+ */
+export type KnowledgeSourceFormat = 'pdf' | 'text' | 'markdown' | 'html';
+/**
+ * Knowledge source metadata
+ */
+export interface KnowledgeSourceMetadata {
+    readonly url: string_url;
+    readonly format: KnowledgeSourceFormat;
+    readonly title?: string;
+    readonly lastFetched?: Date;
+    readonly contentHash?: string;
+}
+/**
+ * Processed knowledge chunk for RAG
+ */
+export interface KnowledgeChunk {
+    readonly id: string;
+    readonly sourceUrl: string_url;
+    readonly content: string;
+    readonly metadata: {
+        readonly pageNumber?: number;
+        readonly section?: string;
+        readonly chunkIndex: number;
+        readonly totalChunks: number;
+    };
+}
+/**
+ * Knowledge base containing all processed knowledge sources
+ */
+export interface KnowledgeBase {
+    readonly sources: KnowledgeSourceMetadata[];
+    readonly chunks: KnowledgeChunk[];
+    readonly lastUpdated: Date;
+}
+/**
+ * RAG retrieval result
+ */
+export interface RetrievalResult {
+    readonly chunk: KnowledgeChunk;
+    readonly relevanceScore: number;
+}
+/**
+ * Configuration for RAG processing
+ */
+export interface RAGConfig {
+    readonly maxChunkSize: number;
+    readonly chunkOverlap: number;
+    readonly maxRetrievedChunks: number;
+    readonly minRelevanceScore: number;
+}
+/**
+ * [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/book-2.0/commitments/KNOWLEDGE/utils/ragHelper.d.ts

@@ -0,0 +1,34 @@
+import type { AgentModelRequirements } from '../../_misc/AgentModelRequirements';
+import { FrontendRAGService } from '../FrontendRAGService';
+/**
+ * Helper utilities for RAG processing in chat systems
+ *
+ * @private
+ */
+export declare class RAGHelper {
+    /**
+     * Initialize knowledge sources from agent requirements
+     * This should be called when starting a chat session
+     */
+    static initializeKnowledgeSources(requirements: AgentModelRequirements): Promise<FrontendRAGService | null>;
+    /**
+     * Get relevant context for a user query
+     * This should be called before sending the query to the AI model
+     */
+    static getRelevantContext(ragService: FrontendRAGService | null, userQuery: string): Promise<string>;
+    /**
+     * Update system message with relevant context for a query
+     */
+    static updateSystemMessageWithContext(requirements: AgentModelRequirements, ragService: FrontendRAGService | null, userQuery: string): Promise<AgentModelRequirements>;
+    /**
+     * Get statistics about the knowledge base
+     */
+    static getKnowledgeStats(ragService: FrontendRAGService | null): {
+        sources: number;
+        chunks: number;
+        isInitialized: boolean;
+    } | null;
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/book-2.0/commitments/META_IMAGE/META_IMAGE.d.ts

@@ -0,0 +1,44 @@
+import { BaseCommitmentDefinition } from '../_base/BaseCommitmentDefinition';
+import type { AgentModelRequirements } from '../_misc/AgentModelRequirements';
+/**
+ * META IMAGE commitment definition
+ *
+ * The META IMAGE commitment sets the agent's avatar/profile image URL.
+ * This commitment is special because it doesn't affect the system message,
+ * but is handled separately in the parsing logic.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * META IMAGE https://example.com/avatar.jpg
+ * META IMAGE /assets/agent-avatar.png
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare class MetaImageCommitmentDefinition extends BaseCommitmentDefinition<'META IMAGE'> {
+    constructor();
+    /**
+     * Short one-line description of META IMAGE.
+     */
+    get description(): string;
+    /**
+     * Markdown documentation for META IMAGE commitment.
+     */
+    get documentation(): string;
+    applyToAgentModelRequirements(requirements: AgentModelRequirements, content: string): AgentModelRequirements;
+    /**
+     * Extracts the profile image URL from the content
+     * This is used by the parsing logic
+     */
+    extractProfileImageUrl(content: string): string | null;
+}
+/**
+ * Singleton instance of the META IMAGE commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare const MetaImageCommitment: MetaImageCommitmentDefinition;
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/book-2.0/commitments/META_LINK/META_LINK.d.ts

@@ -0,0 +1,56 @@
+import { BaseCommitmentDefinition } from '../_base/BaseCommitmentDefinition';
+import type { AgentModelRequirements } from '../_misc/AgentModelRequirements';
+/**
+ * META LINK commitment definition
+ *
+ * The `META LINK` commitment represents the link to the person from whom the agent is created.
+ * This commitment is special because it doesn't affect the system message,
+ * but is handled separately in the parsing logic for profile display.
+ *
+ * Example usage in agent source:
+ *
+ * ```
+ * META LINK https://twitter.com/username
+ * META LINK https://linkedin.com/in/profile
+ * META LINK https://github.com/username
+ * ```
+ *
+ * Multiple `META LINK` commitments can be used when there are multiple sources:
+ *
+ * ```book
+ * META LINK https://twitter.com/username
+ * META LINK https://linkedin.com/in/profile
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare class MetaLinkCommitmentDefinition extends BaseCommitmentDefinition<'META LINK'> {
+    constructor();
+    /**
+     * Short one-line description of META LINK.
+     */
+    get description(): string;
+    /**
+     * Markdown documentation for META LINK commitment.
+     */
+    get documentation(): string;
+    applyToAgentModelRequirements(requirements: AgentModelRequirements, content: string): AgentModelRequirements;
+    /**
+     * Extracts the profile link URL from the content
+     * This is used by the parsing logic
+     */
+    extractProfileLinkUrl(content: string): string | null;
+    /**
+     * Validates if the provided content is a valid URL
+     */
+    isValidUrl(content: string): boolean;
+}
+/**
+ * Singleton instance of the META LINK commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare const MetaLinkCommitment: MetaLinkCommitmentDefinition;
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/book-2.0/commitments/MODEL/MODEL.d.ts

@@ -0,0 +1,39 @@
+import { BaseCommitmentDefinition } from '../_base/BaseCommitmentDefinition';
+import type { AgentModelRequirements } from '../_misc/AgentModelRequirements';
+/**
+ * MODEL commitment definition
+ *
+ * The MODEL commitment specifies which AI model to use and can also set
+ * model-specific parameters like temperature, topP, and topK.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * MODEL gpt-4
+ * MODEL claude-3-opus temperature=0.3
+ * MODEL gpt-3.5-turbo temperature=0.8 topP=0.9
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare class ModelCommitmentDefinition extends BaseCommitmentDefinition<'MODEL'> {
+    constructor();
+    /**
+     * Short one-line description of MODEL.
+     */
+    get description(): string;
+    /**
+     * Markdown documentation for MODEL commitment.
+     */
+    get documentation(): string;
+    applyToAgentModelRequirements(requirements: AgentModelRequirements, content: string): AgentModelRequirements;
+}
+/**
+ * Singleton instance of the MODEL commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare const ModelCommitment: ModelCommitmentDefinition;
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/book-2.0/commitments/NOTE/NOTE.d.ts

@@ -0,0 +1,49 @@
+import { BaseCommitmentDefinition } from '../_base/BaseCommitmentDefinition';
+import type { AgentModelRequirements } from '../_misc/AgentModelRequirements';
+/**
+ * NOTE commitment definition
+ *
+ * The NOTE commitment is used to add comments to the agent source without making any changes
+ * to the system message or agent model requirements. It serves as a documentation mechanism
+ * for developers to add explanatory comments, reminders, or annotations directly in the agent source.
+ *
+ * Key features:
+ * - Makes no changes to the system message
+ * - Makes no changes to agent model requirements
+ * - Content is preserved in metadata.NOTE for debugging and inspection
+ * - Multiple NOTE commitments are aggregated together
+ * - Comments (# NOTE) are removed from the final system message
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * NOTE This agent was designed for customer support scenarios
+ * NOTE Remember to update the knowledge base monthly
+ * NOTE Performance optimized for quick response times
+ * ```
+ *
+ * The above notes will be stored in metadata but won't affect the agent's behavior.
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare class NoteCommitmentDefinition extends BaseCommitmentDefinition<'NOTE'> {
+    constructor();
+    /**
+     * Short one-line description of NOTE.
+     */
+    get description(): string;
+    /**
+     * Markdown documentation for NOTE commitment.
+     */
+    get documentation(): string;
+    applyToAgentModelRequirements(requirements: AgentModelRequirements, content: string): AgentModelRequirements;
+}
+/**
+ * Singleton instance of the NOTE commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+export declare const NoteCommitment: NoteCommitmentDefinition;
+/**
+ * [💞] Ignore a discrepancy between file name and entity name
+ */