@csmedeiros/codemax 1.0.3 → 1.0.7

package/dist/conversation/agentGraph.js

@@ -1,433 +0,0 @@
-/**
- * LangChain agent graph (StateGraph + tools).
- */
-import { END, MessagesZodState, START, StateGraph, interrupt, } from '@langchain/langgraph';
-import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';
-import Database from 'better-sqlite3';
-import os from 'os';
-import fs from 'fs';
-import path from 'path';
-import { HumanMessage, RemoveMessage, SystemMessage, ToolMessage, } from '@langchain/core/messages';
-import { z } from 'zod';
-import { getConfig, updateConfig } from '../configuration/configManager.js';
-import { TOOLS, PLAN_TOOLS } from '../tooling/tools.js';
-import { SYSTEM_PROMPT, COMPACT_SUMMARY_PROMPT, buildCodemaxTurnDatetimeUserContent, } from './prompts/systemPrompt.js';
-import { PLAN_MODE_PROMPT } from './prompts/planPrompt.js';
-import { loadProjectSkills } from '../commands/slashCommands.js';
-import { loadWorkspaceRules, matchRules } from '../commands/cursorRules.js';
-import { ChatOpenAI } from '@langchain/openai';
-import { getContextWindow } from '../configuration/modelContextWindows.js';
-import { estimateTokens, shouldCompactMessages, computeKeepStart, } from './compactionUtils.js';
-export { estimateTokens, shouldCompactMessages, computeKeepStart };
-export const COMPACTION_SUMMARY_SENTINEL = '[COMPACTION_SUMMARY]';
-let model;
-export function initModel() {
-    const config = getConfig();
-    if (!config.apiKey) {
-        process.stderr.write('\x07'); // Alert beep
-        console.error('\n[CodeMax] FATAL: API Key is not set in ~/.codemax/config.json or environment.\n');
-        throw new Error('API_KEY missing');
-    }
-    model = new ChatOpenAI({
-        model: config.modelName,
-        apiKey: config.apiKey,
-        temperature: 0.3,
-        maxTokens: 16384,
-        streaming: true,
-        maxRetries: 0,
-        configuration: {
-            baseURL: config.baseURL || undefined,
-        },
-        modelKwargs: {
-            chat_template_kwargs: { enable_thinking: true, clear_thinking: false },
-        },
-    });
-}
-initModel();
-export function updateModelConfig(cfg) {
-    updateConfig(cfg);
-    initModel();
-}
-export const ToolExecutionMode = z.enum(['auto', 'ask', 'edits', 'plan']);
-/** Same shape as `MessagesAnnotation` + extra channels — required for `toolsCondition` / `ToolNode`. */
-const StateDefinition = MessagesZodState.extend({
-    files: z.record(z.string(), z.string()).default({}),
-    toolExecutionMode: ToolExecutionMode.default('ask'),
-    todos: z
-        .array(z.object({
-        id: z.string(),
-        task: z.string(),
-        status: z.enum(['pending', 'in_progress', 'completed']),
-    }))
-        .default([]),
-    activeSkill: z.string().optional(),
-    forceCompact: z.boolean().default(false),
-});
-async function callModel(state, config) {
-    const datetimeMsg = new HumanMessage(buildCodemaxTurnDatetimeUserContent());
-    const executionCwd = process.env['CODEMAX_SHELL_CWD'] ?? process.cwd();
-    const skills = loadProjectSkills(executionCwd);
-    const injected = [];
-    if (skills.length > 0) {
-        const descriptionsText = 'These are the available skills and its descriptions. You MUST read skills when the use case matches with the description.\n\n' +
-            skills.map(s => `${s.name}:\n\n${s.description}`).join('\n\n\n');
-        injected.push(new HumanMessage(descriptionsText));
-    }
-    if (state.activeSkill) {
-        injected.push(new HumanMessage(state.activeSkill));
-    }
-    const workspaceRules = loadWorkspaceRules(executionCwd);
-    const matchedRules = matchRules(workspaceRules, state.messages);
-    if (workspaceRules.length > 0) {
-        process.stderr.write(`[CodeMax:rules] loaded=${workspaceRules.length} matched=${matchedRules.length}` +
-            (matchedRules.length > 0
-                ? ` files=[${matchedRules.map(r => r.filename).join(', ')}]`
-                : '') +
-            '\n');
-    }
-    for (const rule of matchedRules) {
-        injected.push(new HumanMessage(`[Rule: ${rule.description}]\n\n${rule.content}`));
-    }
-    if (state.toolExecutionMode === 'plan') {
-        injected.unshift(new HumanMessage(PLAN_MODE_PROMPT));
-    }
-    const messages = [
-        new SystemMessage(SYSTEM_PROMPT),
-        ...injected,
-        datetimeMsg,
-        ...state.messages,
-    ];
-    const toolList = state.toolExecutionMode === 'plan' ? PLAN_TOOLS : TOOLS;
-    const activeLlm = model.bindTools(toolList);
-    const response = await activeLlm.invoke(messages, config);
-    return { messages: [response], activeSkill: undefined };
-}
-async function toolNode(state, config) {
-    const lastMessage = state.messages[state.messages.length - 1];
-    const toolCalls = lastMessage?.tool_calls ?? [];
-    const results = [];
-    let currentTodos = [...(state.todos || [])];
-    for (const toolCall of toolCalls) {
-        const { name } = toolCall;
-        const mode = state.toolExecutionMode;
-        if (state.toolExecutionMode === 'plan' &&
-            (name === 'writeFileTool' || name === 'editFileTool')) {
-            results.push(new ToolMessage({
-                tool_call_id: toolCall.id,
-                content: 'writeFileTool and editFileTool are disabled in Plan Mode. Use writePlanTool to output your plan.',
-            }));
-            continue;
-        }
-        let shouldInterrupt = false;
-        if (name === 'readFileTool') {
-            shouldInterrupt = false; // Read-only is always safe
-        }
-        else if (name === 'todoTool') {
-            shouldInterrupt = false; // Todo updates are safe
-        }
-        else if (mode === 'ask') {
-            shouldInterrupt = true;
-        }
-        else if (mode === 'edits') {
-            if (name === 'writeFileTool' || name === 'editFileTool') {
-                shouldInterrupt = false; // Auto-accept edits
-            }
-            else {
-                shouldInterrupt = true; // Ask for shellTool and others
-            }
-        }
-        else if (mode === 'auto') {
-            shouldInterrupt = false; // Auto-accept everything
-        }
-        if (shouldInterrupt) {
-            const response = interrupt({
-                type: 'tool_approval',
-                toolCall,
-            });
-            if (response.action === 'approve_always') {
-                state.toolExecutionMode = 'auto';
-            }
-            else if (response.action !== 'approve') {
-                results.push(new ToolMessage({
-                    tool_call_id: toolCall.id,
-                    content: 'Tool execution denied by user.',
-                }));
-                continue;
-            }
-        }
-        const activeToolList = state.toolExecutionMode === 'plan' ? PLAN_TOOLS : TOOLS;
-        const tool = activeToolList.find(t => t.name === name);
-        if (!tool) {
-            results.push(new ToolMessage({
-                tool_call_id: toolCall.id,
-                content: `Tool ${name} not found.`,
-            }));
-            continue;
-        }
-        let output;
-        try {
-            if (name === 'todoTool') {
-                const { action, id, task, status } = toolCall.args;
-                if (action === 'add') {
-                    currentTodos.push({
-                        id: Math.random().toString(36).substring(7),
-                        task: task,
-                        status: status || 'pending',
-                    });
-                }
-                else if (action === 'update') {
-                    currentTodos = currentTodos.map(t => t.id === id
-                        ? { ...t, task: task || t.task, status: status || t.status }
-                        : t);
-                }
-                else if (action === 'remove') {
-                    currentTodos = currentTodos.filter(t => t.id !== id);
-                }
-                output = new ToolMessage({
-                    tool_call_id: toolCall.id,
-                    content: 'Todo list updated.',
-                });
-            }
-            else {
-                output = await tool.invoke(toolCall, config);
-            }
-        }
-        catch (error) {
-            output = new ToolMessage({
-                tool_call_id: toolCall.id,
-                content: `Error: ${error?.message || String(error)}`,
-            });
-        }
-        results.push(output);
-    }
-    return {
-        messages: results,
-        toolExecutionMode: state.toolExecutionMode,
-        todos: currentTodos,
-    };
-}
-const memoryDir = path.join(os.homedir(), '.codemax', 'memory');
-fs.mkdirSync(memoryDir, { recursive: true });
-const memoryPath = path.join(memoryDir, 'MEMORY.sqlite');
-export const db = new Database(memoryPath);
-export { model };
-const checkpointer = new SqliteSaver(db);
-function shouldCompact(state) {
-    if (state.forceCompact)
-        return true;
-    const cfg = getConfig();
-    const window = getContextWindow(cfg.modelName);
-    return shouldCompactMessages(state.messages, {
-        threshold: cfg.compactionThreshold,
-        contextWindow: window,
-    });
-}
-let fullMessagesInitialized = false;
-function ensureFullMessagesTable() {
-    if (fullMessagesInitialized)
-        return;
-    db.exec(`
-		CREATE TABLE IF NOT EXISTS chat_messages_full (
-			thread_id TEXT PRIMARY KEY,
-			messages_json TEXT NOT NULL,
-			updated_at INTEGER NOT NULL
-		)
-	`);
-    fullMessagesInitialized = true;
-}
-function readStoredFullMessages(threadId) {
-    ensureFullMessagesTable();
-    try {
-        const row = db
-            .prepare(`SELECT messages_json FROM chat_messages_full WHERE thread_id = ?`)
-            .get(threadId);
-        if (!row)
-            return null;
-        return JSON.parse(row.messages_json);
-    }
-    catch {
-        return null;
-    }
-}
-function writeStoredFullMessages(threadId, raw) {
-    ensureFullMessagesTable();
-    try {
-        db.prepare(`INSERT INTO chat_messages_full (thread_id, messages_json, updated_at) VALUES (?, ?, ?)
-			 ON CONFLICT(thread_id) DO UPDATE SET messages_json = excluded.messages_json, updated_at = excluded.updated_at`).run(threadId, JSON.stringify(raw), Date.now());
-    }
-    catch {
-        // ignore
-    }
-}
-function serializeMessageForStorage(m) {
-    const type = m._getType();
-    const base = { id: m.id, type, content: m.content };
-    if (type === 'ai') {
-        const ai = m;
-        if (ai.tool_calls)
-            base.tool_calls = ai.tool_calls;
-    }
-    if (type === 'tool') {
-        const tm = m;
-        base.tool_call_id = tm.tool_call_id;
-        base.name = tm.name;
-    }
-    return base;
-}
-function persistFullHistorySnapshot(threadId, currentMessages) {
-    const serialized = currentMessages
-        .filter(m => {
-        const c = m.content;
-        const text = typeof c === 'string'
-            ? c
-            : Array.isArray(c)
-                ? c
-                    .map((b) => (typeof b === 'string' ? b : b?.text ?? ''))
-                    .join('')
-                : '';
-        return !text.startsWith(COMPACTION_SUMMARY_SENTINEL);
-    })
-        .map(serializeMessageForStorage);
-    const stored = readStoredFullMessages(threadId) ?? [];
-    const seenIds = new Set();
-    const merged = [];
-    for (const m of stored) {
-        const id = m?.id;
-        if (id && seenIds.has(id))
-            continue;
-        if (id)
-            seenIds.add(id);
-        merged.push(m);
-    }
-    for (const m of serialized) {
-        const id = m?.id;
-        if (id && seenIds.has(id))
-            continue;
-        if (id)
-            seenIds.add(id);
-        merged.push(m);
-    }
-    writeStoredFullMessages(threadId, merged);
-}
-async function compactMessages(state, config) {
-    const cfg = getConfig();
-    const window = getContextWindow(cfg.modelName);
-    const tokensToKeep = Math.max(1, Math.floor(0.15 * window));
-    const msgs = state.messages;
-    if (msgs.length === 0)
-        return { forceCompact: false };
-    let keepStart = computeKeepStart(msgs, tokensToKeep);
-    if (keepStart >= msgs.length)
-        keepStart = msgs.length - 1;
-    if (keepStart <= 0)
-        return { forceCompact: false };
-    const olderMessages = msgs.slice(0, keepStart);
-    const threadId = config?.configurable?.thread_id;
-    if (threadId) {
-        try {
-            persistFullHistorySnapshot(threadId, msgs);
-        }
-        catch {
-            // non-fatal
-        }
-    }
-    let summaryText = '';
-    try {
-        const summarizer = new ChatOpenAI({
-            model: cfg.modelName,
-            apiKey: cfg.apiKey,
-            temperature: 0.3,
-            maxTokens: 8000,
-            streaming: false,
-            maxRetries: 0,
-            configuration: { baseURL: cfg.baseURL || undefined },
-        });
-        const response = await summarizer.invoke([
-            new SystemMessage(COMPACT_SUMMARY_PROMPT),
-            ...olderMessages,
-            new HumanMessage('Produce the detailed compaction summary now as instructed.'),
-        ], config);
-        const c = response.content;
-        summaryText =
-            typeof c === 'string'
-                ? c
-                : Array.isArray(c)
-                    ? c
-                        .map((b) => (typeof b === 'string' ? b : b?.text ?? ''))
-                        .join('')
-                    : '';
-    }
-    catch (e) {
-        process.stderr.write(`[CodeMax:compact] summarization failed: ${e?.message || e}\n`);
-        return { forceCompact: false };
-    }
-    if (!summaryText.trim())
-        return { forceCompact: false };
-    const removeOps = [];
-    for (const m of olderMessages) {
-        if (m.id)
-            removeOps.push(new RemoveMessage({ id: m.id }));
-    }
-    const summaryMsg = new SystemMessage(`${COMPACTION_SUMMARY_SENTINEL}\n\n${summaryText.trim()}`);
-    return {
-        messages: [...removeOps, summaryMsg],
-        forceCompact: false,
-    };
-}
-function routeFromCallModel(state) {
-    if (state.forceCompact)
-        return 'compactMessages';
-    const last = state.messages[state.messages.length - 1];
-    const hasToolCalls = last && Array.isArray(last.tool_calls) && last.tool_calls.length > 0;
-    if (hasToolCalls)
-        return 'tools';
-    if (shouldCompact(state))
-        return 'compactMessages';
-    return END;
-}
-function routeFromTools(state) {
-    if (state.forceCompact || shouldCompact(state))
-        return 'compactMessages';
-    return 'callModel';
-}
-export const agent = new StateGraph(StateDefinition)
-    .addNode('callModel', callModel, {
-    retryPolicy: {
-        maxAttempts: 3,
-        initialInterval: 3000,
-        backoffFactor: 2.0,
-        retryOn: (error) => {
-            const isRateLimit = error?.code === 'MODEL_RATE_LIMIT' ||
-                error?.status === 429 ||
-                error?.message?.includes('429') ||
-                error?.name === 'RateLimitError';
-            const isAbort = error?.name === 'AbortError';
-            if (!isRateLimit && !isAbort) {
-                console.error('[CodeMax] Critical model error (skipping retry):', error);
-            }
-            return isRateLimit;
-        },
-    },
-})
-    .addNode('tools', toolNode)
-    .addNode('compactMessages', compactMessages)
-    .addEdge(START, 'callModel')
-    .addConditionalEdges('callModel', routeFromCallModel, [
-    'tools',
-    'compactMessages',
-    END,
-])
-    .addConditionalEdges('tools', routeFromTools, [
-    'compactMessages',
-    'callModel',
-])
-    .addEdge('compactMessages', 'callModel')
-    .compile({ checkpointer });
-export async function triggerCompaction(threadId) {
-    const config = { configurable: { thread_id: threadId } };
-    await agent.updateState(config, { forceCompact: true });
-    await agent.invoke(null, {
-        ...config,
-        recursionLimit: getConfig().recursionLimit,
-    });
-}

package/dist/conversation/agentTurn.d.ts

@@ -1,40 +0,0 @@
-import { ToolExecutionMode } from './agentGraph.js';
-export type AgentTurnEvent = {
-    type: 'on_tool_start';
-    toolName?: string;
-    input?: string;
-} | {
-    type: 'on_tool_end';
-    toolName?: string;
-    output?: string;
-} | {
-    type: 'on_tool_error';
-    error?: string;
-} | {
-    type: 'on_chat_start';
-} | {
-    type: 'on_chat_delta';
-    text: string;
-} | {
-    type: 'on_chat_end';
-} | {
-    type: 'on_interrupt';
-    payload: any;
-} | {
-    type: 'status';
-    text: string;
-} | {
-    type: 'on_state_update';
-    todos: any[];
-};
-export type AgentTurnOptions = {
-    prompt?: string;
-    threadId: string;
-    sessionId: string;
-    tracingEnabled: boolean;
-    signal?: AbortSignal;
-    toolExecutionMode?: ToolExecutionMode;
-    resumeResponse?: any;
-    activeSkill?: string;
-};
-export declare function streamAgentTurn(options: AgentTurnOptions): AsyncGenerator<AgentTurnEvent>;