@averagejoeslab/puppuccino-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,980 @@
+import { z, ZodType } from 'zod';
+import * as _ai_sdk_openai from '@ai-sdk/openai';
+import * as _ai_sdk_anthropic from '@ai-sdk/anthropic';
+import { EventEmitter } from 'node:events';
+
+/**
+ * Configuration management for Puppuccino
+ */
+
+/**
+ * MCP Server configuration
+ */
+declare const MCPServerSchema: z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodEnum<["stdio", "http", "sse"]>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    transport: "stdio" | "http" | "sse";
+    enabled: boolean;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    name: string;
+    transport: "stdio" | "http" | "sse";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+    enabled?: boolean | undefined;
+}>;
+type MCPServer = z.infer<typeof MCPServerSchema>;
+/**
+ * Hook configuration
+ */
+declare const HookSchema: z.ZodObject<{
+    event: z.ZodEnum<["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop", "PreCompact", "SessionEnd"]>;
+    matcher: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<["command", "prompt", "agent"]>;
+    command: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "command" | "prompt" | "agent";
+    event: "SessionStart" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "Stop" | "PreCompact" | "SessionEnd";
+    command?: string | undefined;
+    matcher?: string | undefined;
+    prompt?: string | undefined;
+    agent?: string | undefined;
+}, {
+    type: "command" | "prompt" | "agent";
+    event: "SessionStart" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "Stop" | "PreCompact" | "SessionEnd";
+    command?: string | undefined;
+    matcher?: string | undefined;
+    prompt?: string | undefined;
+    agent?: string | undefined;
+}>;
+type Hook = z.infer<typeof HookSchema>;
+/**
+ * Permission configuration
+ */
+declare const PermissionsSchema: z.ZodObject<{
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    autoApprove: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    yolo: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    yolo: boolean;
+    allowedTools?: string[] | undefined;
+    disallowedTools?: string[] | undefined;
+    autoApprove?: string[] | undefined;
+}, {
+    allowedTools?: string[] | undefined;
+    disallowedTools?: string[] | undefined;
+    autoApprove?: string[] | undefined;
+    yolo?: boolean | undefined;
+}>;
+type Permissions = z.infer<typeof PermissionsSchema>;
+/**
+ * Full configuration schema
+ */
+declare const ConfigSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["anthropic", "openai", "groq", "local"]>>;
+    model: z.ZodDefault<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        transport: z.ZodEnum<["stdio", "http", "sse"]>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        url: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        transport: "stdio" | "http" | "sse";
+        enabled: boolean;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+        env?: Record<string, string> | undefined;
+    }, {
+        name: string;
+        transport: "stdio" | "http" | "sse";
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+        env?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+    }>>>;
+    permissions: z.ZodOptional<z.ZodObject<{
+        allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        autoApprove: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        yolo: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        yolo: boolean;
+        allowedTools?: string[] | undefined;
+        disallowedTools?: string[] | undefined;
+        autoApprove?: string[] | undefined;
+    }, {
+        allowedTools?: string[] | undefined;
+        disallowedTools?: string[] | undefined;
+        autoApprove?: string[] | undefined;
+        yolo?: boolean | undefined;
+    }>>;
+    hooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        event: z.ZodEnum<["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop", "PreCompact", "SessionEnd"]>;
+        matcher: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<["command", "prompt", "agent"]>;
+        command: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+        agent: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "command" | "prompt" | "agent";
+        event: "SessionStart" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "Stop" | "PreCompact" | "SessionEnd";
+        command?: string | undefined;
+        matcher?: string | undefined;
+        prompt?: string | undefined;
+        agent?: string | undefined;
+    }, {
+        type: "command" | "prompt" | "agent";
+        event: "SessionStart" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "Stop" | "PreCompact" | "SessionEnd";
+        command?: string | undefined;
+        matcher?: string | undefined;
+        prompt?: string | undefined;
+        agent?: string | undefined;
+    }>, "many">>>;
+    skills: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        disabled: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: string[] | undefined;
+        disabled?: string[] | undefined;
+    }, {
+        enabled?: string[] | undefined;
+        disabled?: string[] | undefined;
+    }>>;
+    session: z.ZodOptional<z.ZodObject<{
+        persistHistory: z.ZodDefault<z.ZodBoolean>;
+        maxHistoryDays: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        persistHistory: boolean;
+        maxHistoryDays: number;
+    }, {
+        persistHistory?: boolean | undefined;
+        maxHistoryDays?: number | undefined;
+    }>>;
+    theme: z.ZodDefault<z.ZodEnum<["dark", "light", "kaldi"]>>;
+    agent: z.ZodOptional<z.ZodObject<{
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        maxTurns: z.ZodDefault<z.ZodNumber>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokens: number;
+        maxTurns: number;
+        systemPrompt?: string | undefined;
+    }, {
+        maxTokens?: number | undefined;
+        maxTurns?: number | undefined;
+        systemPrompt?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    provider: "anthropic" | "openai" | "groq" | "local";
+    model: string;
+    theme: "dark" | "light" | "kaldi";
+    agent?: {
+        maxTokens: number;
+        maxTurns: number;
+        systemPrompt?: string | undefined;
+    } | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+    mcpServers?: Record<string, {
+        name: string;
+        transport: "stdio" | "http" | "sse";
+        enabled: boolean;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+        env?: Record<string, string> | undefined;
+    }> | undefined;
+    permissions?: {
+        yolo: boolean;
+        allowedTools?: string[] | undefined;
+        disallowedTools?: string[] | undefined;
+        autoApprove?: string[] | undefined;
+    } | undefined;
+    hooks?: Record<string, {
+        type: "command" | "prompt" | "agent";
+        event: "SessionStart" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "Stop" | "PreCompact" | "SessionEnd";
+        command?: string | undefined;
+        matcher?: string | undefined;
+        prompt?: string | undefined;
+        agent?: string | undefined;
+    }[]> | undefined;
+    skills?: {
+        enabled?: string[] | undefined;
+        disabled?: string[] | undefined;
+    } | undefined;
+    session?: {
+        persistHistory: boolean;
+        maxHistoryDays: number;
+    } | undefined;
+}, {
+    agent?: {
+        maxTokens?: number | undefined;
+        maxTurns?: number | undefined;
+        systemPrompt?: string | undefined;
+    } | undefined;
+    provider?: "anthropic" | "openai" | "groq" | "local" | undefined;
+    model?: string | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+    mcpServers?: Record<string, {
+        name: string;
+        transport: "stdio" | "http" | "sse";
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+        env?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+    }> | undefined;
+    permissions?: {
+        allowedTools?: string[] | undefined;
+        disallowedTools?: string[] | undefined;
+        autoApprove?: string[] | undefined;
+        yolo?: boolean | undefined;
+    } | undefined;
+    hooks?: Record<string, {
+        type: "command" | "prompt" | "agent";
+        event: "SessionStart" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "Stop" | "PreCompact" | "SessionEnd";
+        command?: string | undefined;
+        matcher?: string | undefined;
+        prompt?: string | undefined;
+        agent?: string | undefined;
+    }[]> | undefined;
+    skills?: {
+        enabled?: string[] | undefined;
+        disabled?: string[] | undefined;
+    } | undefined;
+    session?: {
+        persistHistory?: boolean | undefined;
+        maxHistoryDays?: number | undefined;
+    } | undefined;
+    theme?: "dark" | "light" | "kaldi" | undefined;
+}>;
+type Config = z.infer<typeof ConfigSchema>;
+/**
+ * Configuration file locations
+ */
+declare const CONFIG_PATHS: {
+    project: string[];
+    user: string[];
+};
+/**
+ * Data directory locations
+ */
+declare function getDataDir(): string;
+/**
+ * Sessions directory
+ */
+declare function getSessionsDir(): string;
+/**
+ * Load and merge configuration from all sources
+ */
+declare function loadConfig(projectDir?: string): Config;
+/**
+ * Save configuration to file
+ */
+declare function saveConfig(config: Partial<Config>, path: string): void;
+/**
+ * Get default user config path
+ */
+declare function getUserConfigPath(): string;
+
+/**
+ * Tool definitions and registry for Puppuccino
+ */
+
+/**
+ * Tool definition
+ */
+interface Tool {
+    name: string;
+    description: string;
+    parameters: ZodType;
+    execute: (input: Record<string, unknown>) => Promise<string>;
+}
+/**
+ * Tool result
+ */
+interface ToolResult {
+    success: boolean;
+    output: string;
+    error?: string;
+}
+/**
+ * Read tool - Read file contents
+ */
+declare const ReadTool: Tool;
+/**
+ * Write tool - Write content to a file
+ */
+declare const WriteTool: Tool;
+/**
+ * Edit tool - Replace text in a file
+ */
+declare const EditTool: Tool;
+/**
+ * Glob tool - Find files by pattern
+ */
+declare const GlobTool: Tool;
+/**
+ * Grep tool - Search file contents
+ */
+declare const GrepTool: Tool;
+/**
+ * Bash tool - Execute shell commands
+ */
+declare const BashTool: Tool;
+/**
+ * List tool - List directory contents
+ */
+declare const ListTool: Tool;
+/**
+ * All built-in tools
+ */
+declare const BUILTIN_TOOLS: Tool[];
+/**
+ * Tool registry
+ */
+declare class ToolRegistry {
+    private tools;
+    constructor();
+    /**
+     * Register a tool
+     */
+    register(tool: Tool): void;
+    /**
+     * Unregister a tool
+     */
+    unregister(name: string): void;
+    /**
+     * Get a tool by name
+     */
+    get(name: string): Tool | undefined;
+    /**
+     * Get all registered tools
+     */
+    all(): Tool[];
+    /**
+     * Check if a tool exists
+     */
+    has(name: string): boolean;
+    /**
+     * Execute a tool
+     */
+    execute(name: string, input: Record<string, unknown>): Promise<ToolResult>;
+}
+/**
+ * Create a tool registry instance
+ */
+declare function createToolRegistry(): ToolRegistry;
+
+/**
+ * Provider types
+ */
+type ProviderType = 'anthropic' | 'openai' | 'groq' | 'local';
+/**
+ * Message types
+ */
+interface Message {
+    role: 'user' | 'assistant' | 'system';
+    content: string | ContentBlock[];
+}
+interface ContentBlock {
+    type: 'text' | 'tool_use' | 'tool_result';
+    text?: string;
+    id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    tool_use_id?: string;
+    content?: string;
+}
+/**
+ * Tool call from LLM
+ */
+interface ToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/**
+ * Response from LLM
+ */
+interface LLMResponse {
+    text: string;
+    toolCalls: ToolCall[];
+    finishReason: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}
+/**
+ * Chat options
+ */
+interface ChatOptions {
+    model: string;
+    messages: Message[];
+    tools?: Tool[];
+    systemPrompt?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+/**
+ * Stream event
+ */
+interface StreamEvent {
+    type: 'text' | 'tool_call_start' | 'tool_call_end' | 'finish';
+    text?: string;
+    toolCall?: ToolCall;
+    finishReason?: string;
+}
+/**
+ * Create a provider instance based on config
+ */
+declare function createProvider(config: Config): _ai_sdk_anthropic.AnthropicProvider | _ai_sdk_openai.OpenAIProvider;
+/**
+ * Provider class for LLM interactions
+ */
+declare class Provider {
+    private config;
+    private sdk;
+    constructor(config: Config);
+    /**
+     * Send a chat request and get a response
+     */
+    chat(options: ChatOptions): Promise<LLMResponse>;
+    /**
+     * Stream a chat response
+     */
+    chatStream(options: ChatOptions): AsyncGenerator<StreamEvent>;
+    /**
+     * Get current provider type
+     */
+    get providerType(): ProviderType;
+    /**
+     * Get current model
+     */
+    get model(): string;
+}
+/**
+ * Create a provider instance
+ */
+declare function createProviderInstance(config: Config): Provider;
+
+/**
+ * Hooks system for lifecycle events
+ */
+
+/**
+ * Hook events
+ */
+type HookEvent = 'SessionStart' | 'UserPromptSubmit' | 'PreToolUse' | 'PostToolUse' | 'Stop' | 'PreCompact' | 'SessionEnd';
+/**
+ * Hook context passed to hooks
+ */
+interface HookContext {
+    event: HookEvent;
+    [key: string]: unknown;
+}
+/**
+ * Hook result
+ */
+interface HookResult {
+    blocked: boolean;
+    reason?: string;
+    output?: string;
+}
+/**
+ * Hooks runner
+ */
+declare class HooksRunner {
+    private hooks;
+    constructor(hooks?: Record<string, Hook[]>);
+    /**
+     * Add a hook
+     */
+    add(event: HookEvent, hook: Hook): void;
+    /**
+     * Remove all hooks for an event
+     */
+    clear(event: HookEvent): void;
+    /**
+     * Run all hooks for an event
+     */
+    run(event: HookEvent, context?: Partial<HookContext>): Promise<HookResult>;
+    /**
+     * Get all hooks for an event
+     */
+    get(event: HookEvent): Hook[];
+}
+/**
+ * Create a hooks runner
+ */
+declare function createHooksRunner(hooks?: Record<string, Hook[]>): HooksRunner;
+
+/**
+ * Permission system for tool execution
+ */
+
+/**
+ * Permission check result
+ */
+interface PermissionResult {
+    permitted: boolean;
+    reason?: string;
+    requiresConfirmation?: boolean;
+}
+/**
+ * Permission checker
+ */
+declare class PermissionChecker {
+    private config;
+    constructor(config?: Permissions);
+    /**
+     * Check if a tool execution is permitted
+     */
+    check(toolName: string, input: Record<string, unknown>): Promise<PermissionResult>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<Permissions>): void;
+    /**
+     * Enable YOLO mode
+     */
+    enableYolo(): void;
+    /**
+     * Disable YOLO mode
+     */
+    disableYolo(): void;
+    /**
+     * Add an auto-approve pattern
+     */
+    addAutoApprove(pattern: string): void;
+}
+/**
+ * Create a permission checker
+ */
+declare function createPermissionChecker(config?: Permissions): PermissionChecker;
+
+/**
+ * Agent loop - the core agentic execution engine
+ */
+
+/**
+ * Agent event types
+ */
+type AgentEvent = {
+    type: 'thinking';
+} | {
+    type: 'text';
+    content: string;
+} | {
+    type: 'text_delta';
+    delta: string;
+} | {
+    type: 'tool_start';
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    name: string;
+    result: ToolResult;
+} | {
+    type: 'tool_denied';
+    name: string;
+    reason: string;
+} | {
+    type: 'error';
+    error: string;
+} | {
+    type: 'done';
+    response: LLMResponse;
+};
+/**
+ * Agent state
+ */
+interface AgentState {
+    messages: Message[];
+    provider: Provider;
+    tools: ToolRegistry;
+    hooks?: HooksRunner;
+    permissions?: PermissionChecker;
+    systemPrompt?: string;
+    maxTurns?: number;
+    onPermissionRequest?: (toolName: string, input: Record<string, unknown>) => Promise<boolean>;
+}
+/**
+ * Default system prompt
+ */
+declare const DEFAULT_SYSTEM_PROMPT = "You are Kaldi, a helpful AI coding assistant. You're a Great Pyrenees who loves helping developers write great code.\n\nYou have access to tools to read, write, and edit files, search the codebase, and execute commands. Use these tools to help the user with their coding tasks.\n\nWhen making changes:\n- Read files before editing them to understand the context\n- Make minimal, focused changes\n- Explain what you're doing and why\n- Be careful with destructive operations\n\nBe friendly, helpful, and thorough in your responses.";
+/**
+ * Run the agent loop
+ */
+declare function runAgentLoop(state: AgentState): AsyncGenerator<AgentEvent>;
+/**
+ * Simple synchronous agent run (collects all events)
+ */
+declare function runAgent(state: AgentState): Promise<{
+    events: AgentEvent[];
+    messages: Message[];
+}>;
+/**
+ * Create an agent state
+ */
+declare function createAgentState(provider: Provider, tools: ToolRegistry, options?: Partial<Omit<AgentState, 'provider' | 'tools' | 'messages'>>): AgentState;
+
+/**
+ * Session management for conversation persistence
+ */
+
+/**
+ * Session metadata
+ */
+interface SessionMeta {
+    id: string;
+    name?: string;
+    createdAt: string;
+    updatedAt: string;
+    projectPath?: string;
+    model?: string;
+    messageCount: number;
+}
+/**
+ * Full session with messages
+ */
+interface Session extends SessionMeta {
+    messages: Message[];
+}
+/**
+ * Create a new session
+ */
+declare function createSession(options?: {
+    name?: string;
+    projectPath?: string;
+    model?: string;
+}): Session;
+/**
+ * Save a session to disk
+ */
+declare function saveSession(session: Session): void;
+/**
+ * Append a message to a session
+ */
+declare function appendMessage(sessionId: string, message: Message): void;
+/**
+ * Load a session from disk
+ */
+declare function loadSession(id: string): Session | null;
+/**
+ * List all sessions
+ */
+declare function listSessions(): SessionMeta[];
+/**
+ * Delete a session
+ */
+declare function deleteSession(id: string): boolean;
+/**
+ * Get the most recent session
+ */
+declare function getRecentSession(): Session | null;
+/**
+ * Fork a session (create a copy with new ID)
+ */
+declare function forkSession(id: string): Session | null;
+/**
+ * Session manager class
+ */
+declare class SessionManager {
+    private currentSession;
+    /**
+     * Start a new session
+     */
+    start(options?: Parameters<typeof createSession>[0]): Session;
+    /**
+     * Resume an existing session
+     */
+    resume(id: string): Session | null;
+    /**
+     * Resume the most recent session
+     */
+    resumeRecent(): Session | null;
+    /**
+     * Get current session
+     */
+    get current(): Session | null;
+    /**
+     * Add a message to current session
+     */
+    addMessage(message: Message): void;
+    /**
+     * Save current session
+     */
+    save(): void;
+    /**
+     * Clear current session messages
+     */
+    clear(): void;
+    /**
+     * End current session
+     */
+    end(): void;
+}
+/**
+ * Create a session manager
+ */
+declare function createSessionManager(): SessionManager;
+
+/**
+ * MCP (Model Context Protocol) client for tool integration
+ */
+
+/**
+ * MCP connection to a single server
+ */
+declare class MCPConnection extends EventEmitter {
+    private server;
+    private process;
+    private messageId;
+    private pendingRequests;
+    private buffer;
+    private tools;
+    private initialized;
+    constructor(server: MCPServer);
+    /**
+     * Connect to the MCP server
+     */
+    connect(): Promise<void>;
+    /**
+     * Handle incoming data
+     */
+    private handleData;
+    /**
+     * Send a request and wait for response
+     */
+    private request;
+    /**
+     * Initialize the MCP connection
+     */
+    private initialize;
+    /**
+     * Get tools from this server
+     */
+    getTools(): Tool[];
+    /**
+     * Convert MCP tool to our Tool format
+     */
+    private convertTool;
+    /**
+     * Call a tool on this server
+     */
+    callTool(name: string, input: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    get isConnected(): boolean;
+}
+/**
+ * MCP client managing multiple servers
+ */
+declare class MCPClient {
+    private connections;
+    /**
+     * Add and connect to an MCP server
+     */
+    addServer(server: MCPServer): Promise<void>;
+    /**
+     * Remove an MCP server
+     */
+    removeServer(name: string): void;
+    /**
+     * Get all tools from all servers
+     */
+    getTools(): Tool[];
+    /**
+     * Call a tool (parses the mcp__server__tool format)
+     */
+    callTool(name: string, input: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Disconnect all servers
+     */
+    disconnectAll(): void;
+    /**
+     * Get connected server names
+     */
+    get servers(): string[];
+}
+/**
+ * Create an MCP client
+ */
+declare function createMCPClient(): MCPClient;
+
+/**
+ * Skills system for reusable prompts and capabilities
+ */
+/**
+ * Skill metadata from YAML frontmatter
+ */
+interface SkillMeta {
+    name: string;
+    description?: string;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    allowedTools?: string[];
+    model?: string;
+    context?: 'fork' | 'inline';
+    agent?: string;
+}
+/**
+ * Full skill definition
+ */
+interface Skill extends SkillMeta {
+    content: string;
+    path: string;
+}
+/**
+ * Skills loader
+ */
+declare class SkillsLoader {
+    private skills;
+    private projectPath?;
+    constructor(projectPath?: string);
+    /**
+     * Reload all skills
+     */
+    reload(): void;
+    /**
+     * Get a skill by name
+     */
+    get(name: string): Skill | undefined;
+    /**
+     * Get all skills
+     */
+    all(): Skill[];
+    /**
+     * Get user-invocable skills
+     */
+    userInvocable(): Skill[];
+    /**
+     * Get model-invocable skills
+     */
+    modelInvocable(): Skill[];
+    /**
+     * Check if a skill exists
+     */
+    has(name: string): boolean;
+    /**
+     * Expand a skill's content with arguments
+     */
+    expand(name: string, args?: string): string | null;
+}
+/**
+ * Create a skills loader
+ */
+declare function createSkillsLoader(projectPath?: string): SkillsLoader;
+
+/**
+ * Context management for project and memory
+ */
+/**
+ * Project context information
+ */
+interface ProjectContext {
+    path: string;
+    name: string;
+    gitRoot?: string;
+    packageJson?: Record<string, unknown>;
+    readme?: string;
+    structure: string;
+}
+/**
+ * Load project context
+ */
+declare function loadProjectContext(projectPath: string): ProjectContext;
+/**
+ * Format project context as system prompt addition
+ */
+declare function formatProjectContext(context: ProjectContext): string;
+/**
+ * Memory entry for conversation context
+ */
+interface MemoryEntry {
+    type: 'summary' | 'fact' | 'preference';
+    content: string;
+    timestamp: string;
+}
+/**
+ * Conversation memory
+ */
+declare class Memory {
+    private entries;
+    private maxEntries;
+    /**
+     * Add an entry
+     */
+    add(type: MemoryEntry['type'], content: string): void;
+    /**
+     * Get all entries
+     */
+    all(): MemoryEntry[];
+    /**
+     * Get entries by type
+     */
+    byType(type: MemoryEntry['type']): MemoryEntry[];
+    /**
+     * Format memory for system prompt
+     */
+    format(): string;
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Export entries
+     */
+    export(): MemoryEntry[];
+    /**
+     * Import entries
+     */
+    import(entries: MemoryEntry[]): void;
+}
+/**
+ * Create a memory instance
+ */
+declare function createMemory(): Memory;
+
+/**
+ * @puppuccino/core - Core engine for Puppuccino AI coding agent
+ *
+ * This package provides the fundamental building blocks for the Puppuccino
+ * coding agent, including the agent loop, tools, providers, and more.
+ */
+
+declare const VERSION = "0.1.0";
+
+export { type AgentEvent, type AgentState, BUILTIN_TOOLS, BashTool, CONFIG_PATHS, type ChatOptions, type Config, ConfigSchema, type ContentBlock, DEFAULT_SYSTEM_PROMPT, EditTool, GlobTool, GrepTool, type Hook, type HookContext, type HookEvent, type HookResult, HookSchema, HooksRunner, type LLMResponse, ListTool, MCPClient, MCPConnection, type MCPServer, MCPServerSchema, Memory, type MemoryEntry, type Message, PermissionChecker, type PermissionResult, type Permissions, PermissionsSchema, type ProjectContext, Provider, type ProviderType, ReadTool, type Session, SessionManager, type SessionMeta, type Skill, type SkillMeta, SkillsLoader, type StreamEvent, type Tool, type ToolCall, ToolRegistry, type ToolResult, VERSION, WriteTool, appendMessage, createAgentState, createHooksRunner, createMCPClient, createMemory, createPermissionChecker, createProvider, createProviderInstance, createSession, createSessionManager, createSkillsLoader, createToolRegistry, deleteSession, forkSession, formatProjectContext, getDataDir, getRecentSession, getSessionsDir, getUserConfigPath, listSessions, loadConfig, loadProjectContext, loadSession, runAgent, runAgentLoop, saveConfig, saveSession };