sparkecoder 0.1.3

package/dist/index-BxpkHy7X.d.ts

@@ -0,0 +1,326 @@
+import { ModelMessage, streamText } from 'ai';
+import { S as Session, f as ToolExecution } from './schema-EPbMMFza.js';
+import { z } from 'zod';
+
+declare const ToolApprovalConfigSchema: z.ZodObject<{
+    bash: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    write_file: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    read_file: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    load_skill: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    todo: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    bash: boolean;
+    write_file: boolean;
+    read_file: boolean;
+    load_skill: boolean;
+    todo: boolean;
+}, {
+    bash?: boolean | undefined;
+    write_file?: boolean | undefined;
+    read_file?: boolean | undefined;
+    load_skill?: boolean | undefined;
+    todo?: boolean | undefined;
+}>;
+declare const SessionConfigSchema: z.ZodObject<{
+    toolApprovals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    approvalWebhook: z.ZodOptional<z.ZodString>;
+    skillsDirectory: z.ZodOptional<z.ZodString>;
+    maxContextChars: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    maxContextChars: number;
+    toolApprovals?: Record<string, boolean> | undefined;
+    approvalWebhook?: string | undefined;
+    skillsDirectory?: string | undefined;
+}, {
+    toolApprovals?: Record<string, boolean> | undefined;
+    approvalWebhook?: string | undefined;
+    skillsDirectory?: string | undefined;
+    maxContextChars?: number | undefined;
+}>;
+declare const SparkcoderConfigSchema: z.ZodObject<{
+    defaultModel: z.ZodDefault<z.ZodString>;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    toolApprovals: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        bash: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        write_file: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        read_file: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        load_skill: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        todo: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        bash: boolean;
+        write_file: boolean;
+        read_file: boolean;
+        load_skill: boolean;
+        todo: boolean;
+    }, {
+        bash?: boolean | undefined;
+        write_file?: boolean | undefined;
+        read_file?: boolean | undefined;
+        load_skill?: boolean | undefined;
+        todo?: boolean | undefined;
+    }>>>;
+    approvalWebhook: z.ZodOptional<z.ZodString>;
+    skills: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        directory: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        additionalDirectories: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        directory: string;
+        additionalDirectories: string[];
+    }, {
+        directory?: string | undefined;
+        additionalDirectories?: string[] | undefined;
+    }>>>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        maxChars: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        autoSummarize: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        keepRecentMessages: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        maxChars: number;
+        autoSummarize: boolean;
+        keepRecentMessages: number;
+    }, {
+        maxChars?: number | undefined;
+        autoSummarize?: boolean | undefined;
+        keepRecentMessages?: number | undefined;
+    }>>>;
+    server: z.ZodDefault<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        host: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        port: number;
+    }, {
+        host?: string | undefined;
+        port?: number | undefined;
+    }>>;
+    databasePath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    defaultModel: string;
+    toolApprovals: {
+        bash: boolean;
+        write_file: boolean;
+        read_file: boolean;
+        load_skill: boolean;
+        todo: boolean;
+    };
+    skills: {
+        directory: string;
+        additionalDirectories: string[];
+    };
+    context: {
+        maxChars: number;
+        autoSummarize: boolean;
+        keepRecentMessages: number;
+    };
+    server: {
+        host: string;
+        port: number;
+    };
+    databasePath: string;
+    workingDirectory?: string | undefined;
+    approvalWebhook?: string | undefined;
+}, {
+    workingDirectory?: string | undefined;
+    defaultModel?: string | undefined;
+    toolApprovals?: {
+        bash?: boolean | undefined;
+        write_file?: boolean | undefined;
+        read_file?: boolean | undefined;
+        load_skill?: boolean | undefined;
+        todo?: boolean | undefined;
+    } | undefined;
+    approvalWebhook?: string | undefined;
+    skills?: {
+        directory?: string | undefined;
+        additionalDirectories?: string[] | undefined;
+    } | undefined;
+    context?: {
+        maxChars?: number | undefined;
+        autoSummarize?: boolean | undefined;
+        keepRecentMessages?: number | undefined;
+    } | undefined;
+    server?: {
+        host?: string | undefined;
+        port?: number | undefined;
+    } | undefined;
+    databasePath?: string | undefined;
+}>;
+type ToolApprovalConfig = z.infer<typeof ToolApprovalConfigSchema>;
+type SessionConfig = z.infer<typeof SessionConfigSchema>;
+type SparkcoderConfig = z.infer<typeof SparkcoderConfigSchema>;
+interface ResolvedConfig extends Omit<SparkcoderConfig, 'server'> {
+    server: {
+        port: number;
+        host: string;
+    };
+    resolvedWorkingDirectory: string;
+    resolvedSkillsDirectories: string[];
+    resolvedDatabasePath: string;
+}
+
+interface ContextManagerOptions {
+    sessionId: string;
+    maxContextChars: number;
+    keepRecentMessages: number;
+    autoSummarize: boolean;
+}
+/**
+ * Manages conversation context including history and summarization
+ *
+ * Uses AI SDK's ModelMessage format directly for accurate message passing.
+ * Messages are stored in the exact format returned by response.messages.
+ */
+declare class ContextManager {
+    private sessionId;
+    private maxContextChars;
+    private keepRecentMessages;
+    private autoSummarize;
+    private summary;
+    constructor(options: ContextManagerOptions);
+    /**
+     * Get messages for the current context
+     * Returns ModelMessage[] that can be passed directly to streamText/generateText
+     */
+    getMessages(): Promise<ModelMessage[]>;
+    /**
+     * Summarize older messages to reduce context size
+     */
+    private summarizeContext;
+    /**
+     * Add a user message to the context
+     */
+    addUserMessage(text: string): void;
+    /**
+     * Add response messages from AI SDK directly
+     * This is the preferred method - use result.response.messages from streamText/generateText
+     */
+    addResponseMessages(messages: ModelMessage[]): void;
+    /**
+     * Get current context statistics
+     */
+    getStats(): {
+        messageCount: number;
+        contextChars: number;
+        hasSummary: boolean;
+    };
+    /**
+     * Clear all messages in the context
+     */
+    clear(): void;
+}
+
+/**
+ * Build the system prompt for the coding agent
+ */
+declare function buildSystemPrompt(options: {
+    workingDirectory: string;
+    skillsDirectories: string[];
+    sessionId: string;
+    customInstructions?: string;
+}): Promise<string>;
+
+interface AgentOptions {
+    sessionId?: string;
+    name?: string;
+    workingDirectory?: string;
+    model?: string;
+    sessionConfig?: Partial<SessionConfig>;
+}
+interface AgentRunOptions {
+    prompt: string;
+    onText?: (text: string) => void;
+    onToolCall?: (toolCall: {
+        toolCallId: string;
+        toolName: string;
+        input: unknown;
+    }) => void;
+    onToolResult?: (result: {
+        toolCallId: string;
+        toolName: string;
+        output: unknown;
+    }) => void;
+    onApprovalRequired?: (execution: ToolExecution) => void;
+    onStepFinish?: (step: {
+        text?: string;
+        toolCalls?: unknown[];
+        usage?: unknown;
+    }) => void;
+}
+interface AgentStreamResult {
+    sessionId: string;
+    stream: ReturnType<typeof streamText>;
+    waitForApprovals: () => Promise<ToolExecution[]>;
+    /** Call this after stream completes to save response messages */
+    saveResponseMessages: () => Promise<void>;
+}
+/**
+ * The main coding agent that orchestrates LLM interactions
+ */
+declare class Agent {
+    private session;
+    private context;
+    private tools;
+    private pendingApprovals;
+    private constructor();
+    /**
+     * Create or resume an agent session
+     */
+    static create(options?: AgentOptions): Promise<Agent>;
+    /**
+     * Get the session ID
+     */
+    get sessionId(): string;
+    /**
+     * Get session details
+     */
+    getSession(): Session;
+    /**
+     * Run the agent with a prompt (streaming)
+     */
+    stream(options: AgentRunOptions): Promise<AgentStreamResult>;
+    /**
+     * Run the agent with a prompt (non-streaming)
+     */
+    run(options: Omit<AgentRunOptions, 'onText'>): Promise<{
+        text: string;
+        steps: unknown[];
+    }>;
+    /**
+     * Wrap tools to add approval checking
+     */
+    private wrapToolsWithApproval;
+    /**
+     * Wait for all pending approvals
+     */
+    waitForApprovals(): Promise<ToolExecution[]>;
+    /**
+     * Approve a pending tool execution
+     */
+    approve(toolCallId: string): Promise<{
+        approved: true;
+    }>;
+    /**
+     * Reject a pending tool execution
+     */
+    reject(toolCallId: string, reason?: string): {
+        rejected: true;
+    };
+    /**
+     * Get pending approvals
+     */
+    getPendingApprovals(): ToolExecution[];
+    /**
+     * Get context statistics
+     */
+    getContextStats(): {
+        messageCount: number;
+        contextChars: number;
+        hasSummary: boolean;
+    };
+    /**
+     * Clear conversation context (start fresh)
+     */
+    clearContext(): void;
+}
+
+export { Agent as A, ContextManager as C, type ResolvedConfig as R, type SparkcoderConfig as S, type ToolApprovalConfig as T, type AgentOptions as a, type AgentRunOptions as b, type AgentStreamResult as c, buildSystemPrompt as d };

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+import { R as ResolvedConfig } from './index-BxpkHy7X.js';
+export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, S as SparkcoderConfig, T as ToolApprovalConfig } from './index-BxpkHy7X.js';
+export { ServerOptions, createApp, startServer, stopServer } from './server/index.js';
+export { closeDatabase, getDb, initDatabase, messageQueries, sessionQueries, skillQueries, terminalQueries, todoQueries, toolExecutionQueries } from './db/index.js';
+export { a as Message, M as ModelMessage, S as Session, g as SessionConfig, T as Terminal, d as TodoItem, f as ToolExecution } from './schema-EPbMMFza.js';
+export { createBashTool, createLoadSkillTool, createReadFileTool, createTerminalTool, createTodoTool, createTools, createWriteFileTool } from './tools/index.js';
+import { EventEmitter } from 'events';
+import 'ai';
+import 'zod';
+import 'hono/types';
+import 'hono';
+import 'drizzle-orm/better-sqlite3';
+import 'better-sqlite3';
+import 'drizzle-orm/sqlite-core';
+
+/**
+ * Load and parse the config file
+ */
+declare function loadConfig(configPath?: string, workingDirectory?: string): ResolvedConfig;
+
+interface SpawnOptions {
+    sessionId: string;
+    command: string;
+    cwd?: string;
+    name?: string;
+    env?: Record<string, string>;
+}
+interface TerminalInfo {
+    id: string;
+    name: string | null;
+    command: string;
+    cwd: string;
+    pid: number | null;
+    status: 'running' | 'stopped' | 'error';
+    exitCode: number | null;
+    error: string | null;
+    createdAt: Date;
+    stoppedAt: Date | null;
+}
+/**
+ * Manages terminal processes for agent sessions
+ * - Spawns background processes
+ * - Captures stdout/stderr in ring buffers
+ * - Tracks process lifecycle
+ * - Provides log access
+ */
+declare class TerminalManager extends EventEmitter {
+    private processes;
+    private static instance;
+    private constructor();
+    static getInstance(): TerminalManager;
+    /**
+     * Spawn a new background process
+     */
+    spawn(options: SpawnOptions): TerminalInfo;
+    /**
+     * Get logs from a terminal
+     */
+    getLogs(terminalId: string, tail?: number): {
+        logs: string;
+        lineCount: number;
+    } | null;
+    /**
+     * Get terminal status
+     */
+    getStatus(terminalId: string): TerminalInfo | null;
+    /**
+     * Kill a terminal process
+     */
+    kill(terminalId: string, signal?: 'SIGTERM' | 'SIGKILL'): boolean;
+    /**
+     * Write to a terminal's stdin
+     */
+    write(terminalId: string, input: string): boolean;
+    /**
+     * List all terminals for a session
+     */
+    list(sessionId: string): TerminalInfo[];
+    /**
+     * Get all running terminals for a session
+     */
+    getRunning(sessionId: string): TerminalInfo[];
+    /**
+     * Kill all terminals for a session (cleanup)
+     */
+    killAll(sessionId: string): number;
+    /**
+     * Clean up stopped terminals from memory (keep DB records)
+     */
+    cleanup(sessionId?: string): number;
+    /**
+     * Parse a command string into executable and arguments
+     */
+    private parseCommand;
+    private toTerminalInfo;
+}
+declare function getTerminalManager(): TerminalManager;
+
+/**
+ * Sparkecoder - A powerful coding agent CLI with HTTP API
+ *
+ * @packageDocumentation
+ */
+
+declare const VERSION = "0.1.0";
+
+export { ResolvedConfig, type TerminalInfo, VERSION, getTerminalManager, loadConfig };