codeep 2.1.3 → 2.1.4

package/README.md

@@ -181,7 +181,7 @@ Codeep works as a **full AI coding agent** that autonomously:
 ### Context Persistence
 - **Save conversations** - Continue where you left off
 - **Per-project context** - Each project maintains its own history
-- **Automatic summarization** - Old messages are summarized to save space
+- **Automatic summarization** - When prior history overflows the agent's context budget, the dropped (oldest) messages are condensed into a short recap (decisions, constraints, unfinished threads) instead of being silently truncated — so long sessions don't forget how they started. One cheap LLM call, made only on overflow and cached per session; opt out with `autoSummarizeHistory: false` (`/settings`)
 
 ### Web & MCP Tools
 - Agent can fetch documentation and web content

package/dist/config/index.d.ts

@@ -27,6 +27,11 @@ interface ConfigSchema {
      *  small background API call (uses the active model) once per session.
      *  Default true; set false to avoid any unsolicited API calls. */
     autoSessionTitle: boolean;
+    /** When prior chat history overflows the agent's context budget, summarize
+     *  the dropped (oldest) messages via one LLM call instead of silently
+     *  discarding them — so long sessions keep early decisions/constraints.
+     *  Default true; set false to fall back to plain truncation (no extra call). */
+    autoSummarizeHistory: boolean;
     /** Absolute workspace roots whose project-local `.codeep/hooks/*` the user
      *  has approved to run. Untrusted projects' hooks are skipped (a cloned repo
      *  can't execute shell on first tool call). Granted via `/hooks trust`. */

package/dist/config/index.js

@@ -167,6 +167,7 @@ function createConfig() {
         language: 'en',
         autoSave: true,
         autoSessionTitle: true,
+        autoSummarizeHistory: true,
         trustedHookProjects: [],
         currentSessionId: '',
         temperature: 0.7,

package/dist/utils/agent.js

@@ -11,7 +11,7 @@ const debug = (...args) => {
     }
 };
 // Import chat layer (prompt building + API calls)
-import { agentChat, getAgentSystemPrompt, getFallbackSystemPrompt, loadProjectRules, loadProgressLog, writeProgressLog, formatChatHistoryForAgent, } from './agentChat.js';
+import { agentChat, getAgentSystemPrompt, getFallbackSystemPrompt, loadProjectRules, loadProgressLog, writeProgressLog, formatChatHistoryForAgent, summarizeEarlierHistory, } from './agentChat.js';
 import { ApiError } from '../api/index.js';
 export { loadProjectRules, loadProgressLog, writeProgressLog, formatChatHistoryForAgent };
 /**
@@ -242,7 +242,13 @@ export async function runAgent(prompt, projectContext, options = {}) {
     if (taskCtx) {
         systemPrompt += taskCtx;
     }
-    // Inject prior chat session context
+    // Inject prior chat session context. When the history overflows the budget,
+    // prepend an LLM recap of the dropped (oldest) messages so long sessions
+    // keep early decisions/constraints, then the recent messages verbatim.
+    const earlierSummary = await summarizeEarlierHistory(opts.chatHistory);
+    if (earlierSummary) {
+        systemPrompt += earlierSummary;
+    }
     const chatHistoryStr = formatChatHistoryForAgent(opts.chatHistory);
     if (chatHistoryStr) {
         systemPrompt += chatHistoryStr;

package/dist/utils/agentChat.d.ts

@@ -52,6 +52,21 @@ export declare function formatChatHistoryForAgent(history?: Array<{
     role: 'user' | 'assistant';
     content: string;
 }>, maxChars?: number): string;
+/**
+ * Summarize the OVERFLOW that `formatChatHistoryForAgent` drops. When prior
+ * history exceeds `maxChars`, that function keeps only the most recent messages
+ * and silently discards the older ones — losing early decisions/constraints on
+ * long sessions. This condenses those dropped messages into a short recap that
+ * the caller prepends *before* the recent verbatim history.
+ *
+ * Returns '' when: opted out (`autoSummarizeHistory === false`), nothing
+ * overflows, or the summarization call fails (graceful fallback — the recent
+ * history still goes in, we just don't add a recap).
+ */
+export declare function summarizeEarlierHistory(history?: Array<{
+    role: 'user' | 'assistant';
+    content: string;
+}>, maxChars?: number): Promise<string>;
 export declare function getAgentSystemPrompt(projectContext: ProjectContext): string;
 export declare function getFallbackSystemPrompt(projectContext: ProjectContext, additionalTools?: AdditionalToolDef[]): string;
 /**

package/dist/utils/agentChat.js

@@ -13,6 +13,7 @@
  */
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { createHash } from 'crypto';
 import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from './projectIntelligence.js';
 import { syncProgress, generateProjectId } from './codeepCloud.js';
@@ -180,6 +181,84 @@ export function formatChatHistoryForAgent(history, maxChars = 16000) {
     const lines = selected.map(m => `**${m.role === 'user' ? 'User' : 'Assistant'}:** ${m.content}`).join('\n\n');
     return `\n\n## Prior Conversation Context\nThe following is the recent chat history from this session. Use it as background context to understand the user's intent, but focus on completing the current task.\n\n${lines}`;
 }
+// Same noise filter formatChatHistoryForAgent uses — kept in sync so the two
+// functions agree on which messages are "real" conversation.
+function filterAgentHistory(history) {
+    return history.filter(m => {
+        const content = m.content.trimStart();
+        if (content.startsWith('[AGENT]') || content.startsWith('[DRY RUN]'))
+            return false;
+        if (content.startsWith('Agent completed') || content.startsWith('Agent failed') || content.startsWith('Agent stopped'))
+            return false;
+        return true;
+    });
+}
+// Cache summaries by a hash of the dropped messages, so re-running the agent in
+// the same session (same overflow) doesn't re-summarize on every task.
+const earlierSummaryCache = new Map();
+/**
+ * Summarize the OVERFLOW that `formatChatHistoryForAgent` drops. When prior
+ * history exceeds `maxChars`, that function keeps only the most recent messages
+ * and silently discards the older ones — losing early decisions/constraints on
+ * long sessions. This condenses those dropped messages into a short recap that
+ * the caller prepends *before* the recent verbatim history.
+ *
+ * Returns '' when: opted out (`autoSummarizeHistory === false`), nothing
+ * overflows, or the summarization call fails (graceful fallback — the recent
+ * history still goes in, we just don't add a recap).
+ */
+export async function summarizeEarlierHistory(history, maxChars = 16000) {
+    if (config.get('autoSummarizeHistory') === false)
+        return '';
+    if (!history || history.length === 0)
+        return '';
+    const filtered = filterAgentHistory(history);
+    if (filtered.length === 0)
+        return '';
+    // Mirror formatChatHistoryForAgent's newest→oldest budget walk to find which
+    // messages it KEEPS; everything older than the oldest kept message is dropped.
+    let totalChars = 0;
+    let firstKept = filtered.length;
+    for (let i = filtered.length - 1; i >= 0; i--) {
+        const entry = `${filtered[i].role === 'user' ? 'User' : 'Assistant'}: ${filtered[i].content}`;
+        if (totalChars + entry.length > maxChars && firstKept < filtered.length)
+            break;
+        if (entry.length > maxChars) {
+            firstKept = i;
+            break;
+        }
+        firstKept = i;
+        totalChars += entry.length;
+    }
+    const dropped = filtered.slice(0, firstKept);
+    if (dropped.length === 0)
+        return '';
+    const key = createHash('sha256')
+        .update(dropped.map(m => `${m.role}:${m.content}`).join(''))
+        .digest('hex');
+    const cached = earlierSummaryCache.get(key);
+    if (cached)
+        return cached;
+    // Compact transcript of the dropped messages, capped so the summarization
+    // prompt stays cheap even when a lot has overflowed.
+    const transcript = dropped
+        .map(m => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content.replace(/\s+/g, ' ').slice(0, 600)}`)
+        .join('\n')
+        .slice(0, 24000);
+    const system = 'You are condensing the EARLIER part of an ongoing coding session that no longer fits the context window. Summarize what happened in 3-6 sentences: concrete decisions made, constraints/requirements stated, files or APIs involved, and anything still unfinished. Past tense, no preamble, no bullet headers — just the recap.';
+    try {
+        const { chat } = await import('../api/index.js');
+        const summary = (await chat(transcript, [{ role: 'system', content: system }])).trim();
+        if (!summary)
+            return '';
+        const block = `\n\n## Earlier Conversation (summarized)\nThe earlier part of this session was condensed to fit context. Treat it as established background:\n\n${summary}`;
+        earlierSummaryCache.set(key, block);
+        return block;
+    }
+    catch {
+        return ''; // graceful — recent verbatim history still gets injected
+    }
+}
 export function getAgentSystemPrompt(projectContext) {
     const root = projectContext.root || process.cwd();
     // State the real underlying model/provider so "which model are you"

package/dist/utils/shell.js

@@ -74,6 +74,37 @@ const ALLOWED_COMMANDS = new Set([
     // HTTP tools
     'http', 'https',
 ]);
+// Interpreter flags that execute inline code straight from the command line.
+// Without this check, a whitelisted runtime (`node`, `python`, …) becomes
+// arbitrary code execution — `node -e "<anything>"`, `python -c "<anything>"` —
+// bypassing the command whitelist entirely. File execution (`node app.js`)
+// stays allowed; only the eval flags are blocked.
+const INLINE_EVAL_SHORT = {
+    node: ['e', 'p'], bun: ['e'], python: ['c'], python3: ['c'], php: ['r'], ruby: ['e'], perl: ['e', 'E'],
+};
+const INLINE_EVAL_LONG = {
+    node: ['--eval', '--print'], deno: ['eval'], bun: ['--eval'],
+};
+function hasInlineEval(command, args) {
+    const short = INLINE_EVAL_SHORT[command] ?? [];
+    const long = INLINE_EVAL_LONG[command] ?? [];
+    if (short.length === 0 && long.length === 0)
+        return false;
+    for (const arg of args) {
+        if (arg.startsWith('--')) {
+            if (long.includes(arg.split('=')[0]))
+                return true; // --eval / --print(=...)
+        }
+        else if (arg.length > 1 && arg.startsWith('-')) {
+            if (arg.slice(1).split('').some((l) => short.includes(l)))
+                return true; // -e, -c, -pe …
+        }
+        else if (long.includes(arg)) {
+            return true; // bare subcommand, e.g. `deno eval`
+        }
+    }
+    return false;
+}
 /**
  * Validate if a command is safe to execute
  */
@@ -86,6 +117,11 @@ export function validateCommand(command, args, options) {
     if (!ALLOWED_COMMANDS.has(command)) {
         return { valid: false, reason: `Command '${command}' is not in the allowed list` };
     }
+    // Block inline-code execution that would turn a whitelisted interpreter into
+    // arbitrary code execution (the whitelist alone doesn't stop `node -e "…"`).
+    if (hasInlineEval(command, args)) {
+        return { valid: false, reason: `Inline code execution via '${command}' (e.g. -e/-c/--eval) is not allowed in agent mode — put the code in a file and run that, or run it yourself.` };
+    }
     // Check full command string against dangerous patterns
     const fullCommand = `${command} ${args.join(' ')}`;
     for (const pattern of BLOCKED_PATTERNS) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",