@moltium/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,564 @@
+import * as express_serve_static_core from 'express-serve-static-core';
+import { Router } from 'express';
+import winston from 'winston';
+
+interface MoltbookConfig {
+    enabled: boolean;
+    apiKey: string;
+    baseUrl?: string;
+    postFrequency?: 'realtime' | 'hourly' | 'daily';
+    engagementRate?: 'low' | 'medium' | 'high';
+    autoReply?: boolean;
+    replyFilter?: (post: any) => boolean;
+}
+interface TwitterConfig {
+    enabled: boolean;
+    credentials: {
+        apiKey: string;
+        apiSecret: string;
+        accessToken: string;
+        accessSecret: string;
+        bearerToken?: string;
+    };
+    postFrequency?: 'realtime' | 'hourly' | 'daily';
+    replyToMentions?: boolean;
+    autoRetweet?: boolean;
+    maxTweetsPerDay?: number;
+    contentStrategy?: {
+        threadTopics?: string[];
+        hashtagStrategy?: string;
+        mentionBehavior?: string;
+    };
+}
+interface SocialPlatformConfig {
+    enabled: boolean;
+    [key: string]: unknown;
+}
+type SocialConfig = {
+    moltbook?: MoltbookConfig;
+    twitter?: TwitterConfig;
+} & Record<string, SocialPlatformConfig | MoltbookConfig | TwitterConfig | undefined>;
+interface BehaviorTrigger {
+    condition: (context: any) => boolean;
+    action: string;
+    params?: Record<string, unknown>;
+}
+interface RedisConfig {
+    url: string;
+    keyPrefix?: string;
+    ttl?: number;
+}
+interface PostgresConfig {
+    url: string;
+    schema?: string;
+    tableName?: string;
+}
+interface Plugin {
+    name: string;
+    version: string;
+    init?: (agent: any) => Promise<void>;
+    destroy?: () => Promise<void>;
+}
+interface AgentConfig {
+    name: string;
+    type?: string;
+    personality: {
+        traits: string[];
+        bio: string;
+        [key: string]: unknown;
+    };
+    llm: {
+        provider: 'anthropic' | 'openai';
+        model: string;
+        apiKey: string;
+        temperature?: number;
+        maxTokens?: number;
+        systemPrompt?: string;
+    };
+    social: SocialConfig;
+    behaviors: {
+        autonomous: boolean;
+        decisionMaking: 'llm-driven' | 'rule-based' | 'hybrid';
+        actionsPerHour?: number | ((context: any) => number);
+        sleepSchedule?: {
+            start: number;
+            end: number;
+            timezone?: string;
+        };
+        triggers?: BehaviorTrigger[];
+    };
+    memory: {
+        type: 'memory' | 'redis' | 'postgres' | 'hybrid';
+        retention?: string;
+        redis?: RedisConfig;
+        postgres?: PostgresConfig;
+    };
+    actions: string[];
+    customActions?: Action[];
+    webhooks?: {
+        onAction?: string | ((action: any, result: any) => Promise<void>);
+        onError?: string;
+    };
+    plugins?: Plugin[];
+}
+interface ActionContext {
+    agent: any;
+    memory: any;
+    llm: any;
+    parameters: Record<string, unknown>;
+}
+interface ActionResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+interface Action {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+    execute: (context: ActionContext) => Promise<ActionResult>;
+}
+interface Decision {
+    action: string;
+    reasoning: string;
+    parameters: Record<string, unknown>;
+}
+interface Experience {
+    type: string;
+    action: string;
+    result: ActionResult;
+    timestamp: Date;
+    context?: Record<string, unknown>;
+}
+interface DeploymentConfig {
+    platform: 'railway' | 'render' | 'aws' | 'digitalocean' | 'custom';
+    region?: string;
+    instanceType?: string;
+    autoScale?: boolean;
+    customConfig?: CustomDeploymentConfig;
+}
+interface DeploymentResult {
+    success: boolean;
+    url?: string;
+    deploymentId?: string;
+    logs?: string[];
+    error?: string;
+}
+interface DeploymentStatus {
+    state: 'running' | 'stopped' | 'deploying' | 'failed' | 'unknown';
+    url?: string;
+    uptime?: number;
+    lastDeployed?: Date;
+}
+interface CustomDeploymentConfig {
+    deploymentMethod: 'docker' | 'ssh' | 'cli' | 'api';
+    buildCommand: string;
+    startCommand: string;
+    environmentVariables?: Record<string, string>;
+    healthCheckUrl?: string;
+    port?: number;
+    docker?: CustomDockerConfig;
+    ssh?: CustomSSHConfig;
+    cli?: CustomCLIConfig;
+    api?: CustomAPIConfig;
+}
+interface CustomDockerConfig {
+    registry: string;
+    imageName: string;
+    tag?: string;
+    dockerfile?: string;
+    buildArgs?: Record<string, string>;
+    registryAuth?: {
+        username: string;
+        password: string;
+    };
+    hostUrl: string;
+    containerPort: number;
+    hostPort: number;
+}
+interface CustomSSHConfig {
+    host: string;
+    port: number;
+    username: string;
+    authMethod: 'password' | 'privateKey';
+    password?: string;
+    privateKeyPath?: string;
+    deploymentPath: string;
+    preDeployCommands?: string[];
+    postDeployCommands?: string[];
+}
+interface CustomCLIConfig {
+    cliName: string;
+    installCommand?: string;
+    loginCommand?: string;
+    deployCommand: string;
+    statusCommand?: string;
+    logsCommand?: string;
+    credentials?: Record<string, string>;
+}
+interface CustomAPIConfig {
+    baseUrl: string;
+    authType: 'bearer' | 'apiKey' | 'basic' | 'custom';
+    authToken?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    endpoints: {
+        deploy: string;
+        status?: string;
+        logs?: string;
+        rollback?: string;
+    };
+    requestMethod?: 'POST' | 'PUT';
+    payloadTemplate?: Record<string, unknown>;
+}
+interface PostResult {
+    id: string;
+    url?: string;
+    timestamp: Date;
+}
+interface ReplyResult {
+    id: string;
+    parentId: string;
+    url?: string;
+    timestamp: Date;
+}
+interface Mention {
+    id: string;
+    authorId: string;
+    authorName: string;
+    content: string;
+    timestamp: Date;
+    platform: string;
+}
+interface Profile {
+    id: string;
+    name: string;
+    bio?: string;
+    followers?: number;
+    following?: number;
+    platform: string;
+}
+
+interface LifecycleHooks {
+    onInit?: (agent: Agent) => Promise<void>;
+    onStart?: (agent: Agent) => Promise<void>;
+    onTick?: (agent: Agent) => Promise<void>;
+    onShutdown?: (agent: Agent) => Promise<void>;
+    onError?: (error: Error, agent: Agent) => Promise<void>;
+}
+type LifecycleEvent = keyof LifecycleHooks;
+
+declare class ActionRegistry {
+    private actions;
+    register(action: Action): void;
+    unregister(name: string): void;
+    get(name: string): Action | undefined;
+    has(name: string): boolean;
+    list(): Action[];
+    listNames(): string[];
+}
+
+declare abstract class Memory {
+    abstract remember(key: string, value: unknown, ttl?: number): Promise<void>;
+    abstract recall(key: string): Promise<unknown>;
+    abstract forget(key: string): Promise<void>;
+    abstract store(key: string, value: unknown): Promise<void>;
+    abstract retrieve(key: string): Promise<unknown>;
+    abstract delete(key: string): Promise<void>;
+    abstract addExperience(experience: Experience): Promise<void>;
+    abstract queryExperiences(query: string, limit?: number): Promise<Experience[]>;
+    abstract clear(): Promise<void>;
+}
+
+interface GenerateOptions {
+    temperature?: number;
+    maxTokens?: number;
+    stopSequences?: string[];
+    systemPrompt?: string;
+}
+interface Message {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface StructuredSchema {
+    type: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+}
+declare abstract class LLMProvider {
+    abstract name: string;
+    abstract generateText(prompt: string, options?: GenerateOptions): Promise<string>;
+    abstract generateStructured<T>(prompt: string, schema: StructuredSchema, options?: GenerateOptions): Promise<T>;
+    abstract chat(messages: Message[], options?: GenerateOptions): Promise<Message>;
+    abstract streamGenerate(prompt: string, options?: GenerateOptions): AsyncGenerator<string>;
+}
+
+interface FeedOptions {
+    limit?: number;
+    since?: Date;
+    cursor?: string;
+}
+interface TimelineOptions extends FeedOptions {
+    includeReplies?: boolean;
+    includeRetweets?: boolean;
+}
+interface Post {
+    id: string;
+    authorId: string;
+    authorName: string;
+    content: string;
+    timestamp: Date;
+    platform: string;
+    likes?: number;
+    replies?: number;
+    reposts?: number;
+    mentions?: string[];
+    url?: string;
+}
+
+declare abstract class SocialAdapter {
+    abstract platform: string;
+    abstract post(content: string): Promise<PostResult>;
+    abstract reply(id: string, content: string): Promise<ReplyResult>;
+    abstract like(id: string): Promise<void>;
+    abstract follow(userId: string): Promise<void>;
+    abstract getMentions(): Promise<Mention[]>;
+    abstract getFeed(options?: FeedOptions): Promise<Post[]>;
+    abstract getProfile(userId: string): Promise<Profile>;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+}
+
+type AgentState = 'idle' | 'initializing' | 'running' | 'stopping' | 'stopped' | 'error';
+declare class Agent {
+    readonly config: AgentConfig;
+    private state;
+    private llm;
+    private memory_;
+    private scheduler;
+    private actionRegistry;
+    private actionHandler;
+    private hooks;
+    private tickTimer?;
+    private systemPrompt;
+    socialAdapters: Record<string, SocialAdapter>;
+    constructor(config: AgentConfig, hooks?: LifecycleHooks);
+    get name(): string;
+    getState(): AgentState;
+    getMemory(): Memory;
+    getLLM(): LLMProvider;
+    getActionRegistry(): ActionRegistry;
+    setSystemPrompt(prompt: string): void;
+    appendSystemPrompt(additional: string): void;
+    getSystemPrompt(): string;
+    setHooks(hooks: LifecycleHooks): void;
+    mergeHooks(hooks: Partial<LifecycleHooks>): void;
+    setMemory(memory: Memory): void;
+    preloadMemory(entries: Record<string, unknown>): Promise<void>;
+    registerAction(action: Action): void;
+    init(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    think(): Promise<Decision>;
+    act(actionName: string, parameters?: Record<string, unknown>): Promise<ActionResult>;
+    learn(experience: Experience): Promise<void>;
+    tick(): Promise<void>;
+    registerMarkdownSkills(skills: Array<{
+        name: string;
+        description: string;
+    }>): void;
+    private initLLM;
+    private registerActions;
+    private initSocialAdapters;
+    private startAutonomousLoop;
+    private isSleeping;
+    private gatherContext;
+    private fireWebhook;
+}
+
+interface ScheduledJob {
+    name: string;
+    intervalMs: number;
+    handler: () => Promise<void>;
+    lastRun?: number;
+}
+declare class Scheduler {
+    private jobs;
+    private timers;
+    private running;
+    addJob(job: ScheduledJob): void;
+    removeJob(name: string): void;
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    getJobs(): ScheduledJob[];
+}
+
+type ConfigType = 'code' | 'markdown';
+declare class ConfigLoader {
+    private markdownParser;
+    load(directory: string): Promise<{
+        config: AgentConfig;
+        type: ConfigType;
+    }>;
+    loadCode(filePath: string): Promise<AgentConfig>;
+    loadMarkdown(filePath: string): Promise<AgentConfig>;
+}
+
+declare class MarkdownParser {
+    parse(markdown: string): Partial<AgentConfig>;
+    parseSkills(markdown: string): Array<{
+        name: string;
+        description: string;
+    }>;
+    private parseSections;
+    private findSection;
+    private parseIdentity;
+    private parseSocial;
+    private parseBehaviors;
+    private parseMemory;
+    private parseSleepSchedule;
+    private parseKeyValueLines;
+    private toSnakeCase;
+}
+
+declare function validateConfig(config: unknown): AgentConfig;
+
+declare class AnthropicProvider extends LLMProvider {
+    name: string;
+    private client;
+    private model;
+    constructor(apiKey: string, model?: string);
+    generateText(prompt: string, options?: GenerateOptions): Promise<string>;
+    generateStructured<T>(prompt: string, schema: StructuredSchema, options?: GenerateOptions): Promise<T>;
+    chat(messages: Message[], options?: GenerateOptions): Promise<Message>;
+    streamGenerate(prompt: string, options?: GenerateOptions): AsyncGenerator<string>;
+}
+
+declare class OpenAIProvider extends LLMProvider {
+    name: string;
+    private client;
+    private model;
+    constructor(apiKey: string, model?: string);
+    generateText(prompt: string, options?: GenerateOptions): Promise<string>;
+    generateStructured<T>(prompt: string, schema: StructuredSchema, options?: GenerateOptions): Promise<T>;
+    chat(messages: Message[], options?: GenerateOptions): Promise<Message>;
+    streamGenerate(prompt: string, options?: GenerateOptions): AsyncGenerator<string>;
+}
+
+declare function buildSystemPrompt(config: AgentConfig): string;
+declare function buildDecisionPrompt(context: Record<string, unknown>, availableActions: Array<{
+    name: string;
+    description: string;
+}>): string;
+declare function buildSkillPrompt(skillName: string, skillDescription: string, parameters: Record<string, unknown>): string;
+
+declare class ShortTermMemory extends Memory {
+    private cache;
+    private store_;
+    private experiences;
+    remember(key: string, value: unknown, ttl?: number): Promise<void>;
+    recall(key: string): Promise<unknown>;
+    forget(key: string): Promise<void>;
+    store(key: string, value: unknown): Promise<void>;
+    retrieve(key: string): Promise<unknown>;
+    delete(key: string): Promise<void>;
+    addExperience(experience: Experience): Promise<void>;
+    queryExperiences(query: string, limit?: number): Promise<Experience[]>;
+    clear(): Promise<void>;
+}
+
+declare class LongTermMemory extends Memory {
+    private redisConfig?;
+    private postgresConfig?;
+    private redis;
+    private pg;
+    private initialized;
+    constructor(options?: {
+        redis?: RedisConfig;
+        postgres?: PostgresConfig;
+    });
+    init(): Promise<void>;
+    remember(key: string, value: unknown, ttl?: number): Promise<void>;
+    recall(key: string): Promise<unknown>;
+    forget(key: string): Promise<void>;
+    store(key: string, value: unknown): Promise<void>;
+    retrieve(key: string): Promise<unknown>;
+    delete(key: string): Promise<void>;
+    addExperience(experience: Experience): Promise<void>;
+    queryExperiences(query: string, limit?: number): Promise<Experience[]>;
+    clear(): Promise<void>;
+    disconnect(): Promise<void>;
+    ensureSchema(): Promise<void>;
+    private initRedis;
+    private initPostgres;
+    private ensureRedis;
+    private ensurePostgres;
+    private redisKey;
+    private pgTable;
+    private pgExperienceTable;
+    private sanitizeName;
+}
+
+declare class MoltbookAdapter extends SocialAdapter {
+    platform: string;
+    private client;
+    private config;
+    constructor(config: MoltbookConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    post(content: string): Promise<PostResult>;
+    reply(postId: string, content: string): Promise<ReplyResult>;
+    like(postId: string): Promise<void>;
+    follow(userId: string): Promise<void>;
+    getMentions(): Promise<Mention[]>;
+    getFeed(options?: FeedOptions): Promise<Post[]>;
+    getProfile(userId: string): Promise<Profile>;
+}
+
+declare class TwitterAdapter extends SocialAdapter {
+    platform: string;
+    private config;
+    private client;
+    constructor(config: TwitterConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    post(content: string): Promise<PostResult>;
+    reply(tweetId: string, content: string): Promise<ReplyResult>;
+    like(tweetId: string): Promise<void>;
+    follow(userId: string): Promise<void>;
+    getMentions(): Promise<Mention[]>;
+    getFeed(options?: FeedOptions): Promise<Post[]>;
+    getProfile(userId: string): Promise<Profile>;
+}
+
+declare class ActionHandler {
+    private registry;
+    constructor(registry: ActionRegistry);
+    execute(actionName: string, context: ActionContext): Promise<ActionResult>;
+    getAvailableActions(): Array<{
+        name: string;
+        description: string;
+    }>;
+}
+
+/**
+ * Creates an Action from a markdown skill description.
+ * The skill's behavior is interpreted by the LLM at runtime.
+ */
+declare function createMarkdownAction(name: string, description: string, llmProvider: LLMProvider): Action;
+
+declare const builtInActions: Action[];
+
+interface ServerOptions {
+    port?: number;
+    host?: string;
+}
+declare function createApp(agent: Agent): express_serve_static_core.Express;
+declare function startServer(agent: Agent, options?: ServerOptions): Promise<void>;
+
+declare function createRoutes(agent: Agent): Router;
+
+declare function createLogger(label: string): winston.Logger;
+
+export { type Action, type ActionContext, ActionHandler, ActionRegistry, type ActionResult, Agent, type AgentConfig, type AgentState, AnthropicProvider, type BehaviorTrigger, ConfigLoader, type ConfigType, type CustomAPIConfig, type CustomCLIConfig, type CustomDeploymentConfig, type CustomDockerConfig, type CustomSSHConfig, type Decision, type DeploymentConfig, type DeploymentResult, type DeploymentStatus, type Experience, type FeedOptions, type GenerateOptions, LLMProvider, type LifecycleEvent, type LifecycleHooks, LongTermMemory, MarkdownParser, Memory, type Mention, type Message, MoltbookAdapter, type MoltbookConfig, OpenAIProvider, type Plugin, type Post, type PostResult, type PostgresConfig, type Profile, type RedisConfig, type ReplyResult, type ScheduledJob, Scheduler, ShortTermMemory, SocialAdapter, type SocialConfig, type SocialPlatformConfig, type StructuredSchema, type TimelineOptions, TwitterAdapter, type TwitterConfig, buildDecisionPrompt, buildSkillPrompt, buildSystemPrompt, builtInActions, createApp, createLogger, createMarkdownAction, createRoutes, startServer, validateConfig };