c0de-agent 1.0.0 → 1.1.0

package/dist/session/shake.js

@@ -0,0 +1,304 @@
+import { estimateTokens } from './token.js';
+/** Rough token cost of a placeholder line; used only for the savings gate. */
+const PLACEHOLDER_TOKEN_ESTIMATE = 16;
+/** 识别顶层 XML 元素（小写 tag，保守策略）。 */
+const OPENING_XML = /^<([a-z_-]+)(?:\s+[^>]*)?>$/;
+const CLOSING_XML = /^<\/([a-z_-]+)>$/;
+/** Auto-shake 默认配置：保护活跃尾部，保守阈值。 */
+export const DEFAULT_SHAKE_CONFIG = {
+    protectTokens: 16_000,
+    minSavings: 4_000,
+    fenceMinTokens: 400,
+    protectedTools: [],
+};
+/**
+ * 定位 fenced 代码块和顶层 XML 元素 span。返回字符偏移 [start, end) 数组，
+ * 覆盖完整块（含围栏/标签行，不含尾换行）。围栏内抑制 XML 检测。
+ * 未闭合围栏/标签不产生 range（保守策略）。
+ */
+export function scanTextForBlockRanges(text) {
+    const ranges = [];
+    let inFence = false;
+    let fenceStart = -1;
+    const tagStack = [];
+    let xmlStart = -1;
+    let lineStart = 0;
+    for (let i = 0; i <= text.length; i++) {
+        if (i !== text.length && text[i] !== '\n')
+            continue;
+        const line = text.slice(lineStart, i);
+        const lineEnd = i;
+        const trimmedStart = line.trimStart();
+        const isFenceLine = trimmedStart.startsWith('```') || trimmedStart.startsWith('~~~');
+        if (isFenceLine) {
+            if (!inFence) {
+                inFence = true;
+                fenceStart = lineStart;
+            }
+            else {
+                inFence = false;
+                ranges.push({ start: fenceStart, end: lineEnd });
+                fenceStart = -1;
+            }
+            lineStart = i + 1;
+            continue;
+        }
+        if (!inFence) {
+            // Only recognize top-level XML (no leading whitespace)
+            if (line.length === trimmedStart.length) {
+                const openingMatch = OPENING_XML.exec(trimmedStart);
+                if (openingMatch) {
+                    const tagName = openingMatch[1];
+                    if (tagName) {
+                        if (tagStack.length === 0)
+                            xmlStart = lineStart;
+                        tagStack.push(tagName);
+                    }
+                }
+                else {
+                    const closingMatch = CLOSING_XML.exec(trimmedStart);
+                    if (closingMatch &&
+                        tagStack.length > 0 &&
+                        tagStack[tagStack.length - 1] === closingMatch[1]) {
+                        tagStack.pop();
+                        if (tagStack.length === 0 && xmlStart >= 0) {
+                            ranges.push({ start: xmlStart, end: lineEnd });
+                            xmlStart = -1;
+                        }
+                    }
+                }
+            }
+        }
+        lineStart = i + 1;
+    }
+    return mergeRanges(ranges);
+}
+/** 按 start 升序，丢弃与已保留范围重叠的（嵌套取最外层）。 */
+function mergeRanges(ranges) {
+    if (ranges.length <= 1)
+        return ranges;
+    const sorted = [...ranges].sort((a, b) => a.start - b.start);
+    const kept = [];
+    let lastEnd = -1;
+    for (const range of sorted) {
+        if (range.start < lastEnd)
+            continue;
+        kept.push(range);
+        lastEnd = range.end;
+    }
+    return kept;
+}
+/** 单条消息的 token 估算（优先用缓存的 tokenCount）。 */
+function messageTokens(m) {
+    if (m.tokenCount > 0)
+        return m.tokenCount;
+    let total = 0;
+    for (const part of m.content) {
+        switch (part._tag) {
+            case 'text':
+            case 'thinking':
+            case 'steering':
+                total += estimateTokens(part.text);
+                break;
+            case 'tool_call':
+                total += estimateTokens(JSON.stringify(part.input));
+                break;
+            case 'tool_result':
+                total += estimateTokens(JSON.stringify(part.output));
+                break;
+        }
+    }
+    return total;
+}
+/** tool_result part 的输出文本。 */
+function toolResultText(output) {
+    if (output._tag === 'success')
+        return output.output;
+    if (output._tag === 'error')
+        return output.error;
+    if (output._tag === 'truncated')
+        return output.output;
+    return '';
+}
+/** 收集可 shake 的区域。纯函数，不修改输入。 */
+export function collectShakeRegions(messages, config) {
+    const n = messages.length;
+    if (n === 0)
+        return [];
+    // accumulatedAfter[i] = i 之后所有 message 的 token 总和
+    const accumulatedAfter = new Array(n);
+    let acc = 0;
+    for (let i = n - 1; i >= 0; i--) {
+        accumulatedAfter[i] = acc;
+        const m = messages[i];
+        if (m)
+            acc += messageTokens(m);
+    }
+    const regions = [];
+    for (let i = 0; i < n; i++) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        const afterTokens = accumulatedAfter[i] ?? 0;
+        const isAfterProtectWindow = afterTokens >= config.protectTokens;
+        if (!isAfterProtectWindow)
+            continue;
+        for (let partIndex = 0; partIndex < msg.content.length; partIndex++) {
+            const part = msg.content[partIndex];
+            if (!part)
+                continue;
+            // tool_result 区域
+            if (part._tag === 'tool_result') {
+                // 已 shaken 跳过
+                if ('shakenAt' in part.output && part.output.shakenAt)
+                    continue;
+                // protectedTools 跳过
+                if (config.protectedTools.includes(part.tool))
+                    continue;
+                const text = toolResultText(part.output);
+                if (text.length === 0)
+                    continue;
+                const tokens = estimateTokens(text);
+                if (tokens < config.fenceMinTokens)
+                    continue;
+                regions.push({
+                    kind: 'toolResult',
+                    id: `${msg.id}:toolResult:${partIndex}`,
+                    messageId: msg.id,
+                    messageIndex: i,
+                    partIndex,
+                    tokens,
+                    originalText: text,
+                    label: part.tool,
+                    toolCallId: part.id,
+                });
+                continue;
+            }
+            // text/thinking block 区域
+            if (part._tag === 'text' || part._tag === 'thinking') {
+                for (const range of scanTextForBlockRanges(part.text)) {
+                    const slice = part.text.slice(range.start, range.end);
+                    if (slice.length === 0)
+                        continue;
+                    const tokens = estimateTokens(slice);
+                    if (tokens < config.fenceMinTokens)
+                        continue;
+                    regions.push({
+                        kind: 'block',
+                        id: `${msg.id}:block:${partIndex}:${range.start}`,
+                        messageId: msg.id,
+                        messageIndex: i,
+                        partIndex,
+                        start: range.start,
+                        end: range.end,
+                        tokens,
+                        originalText: slice,
+                        label: msg.role,
+                    });
+                }
+            }
+        }
+    }
+    // minSavings 门控
+    let savings = 0;
+    for (const region of regions)
+        savings += Math.max(0, region.tokens - PLACEHOLDER_TOKEN_ESTIMATE);
+    if (savings < config.minSavings)
+        return [];
+    return regions;
+}
+/** 为区域生成占位符文本。 */
+function placeholderFor(region) {
+    if (region.kind === 'toolResult') {
+        return `[shaken: ${region.label}, ${region.tokens} tokens]`;
+    }
+    return '[shaken]';
+}
+/** 原位替换选中区域。返回新数组，不修改原数组。 */
+export function applyShakeRegions(messages, regions) {
+    if (regions.length === 0)
+        return messages;
+    // 按 messageId 分组
+    const byMessage = new Map();
+    for (const region of regions) {
+        const list = byMessage.get(region.messageId) ?? [];
+        list.push(region);
+        byMessage.set(region.messageId, list);
+    }
+    return messages.map((msg) => {
+        const msgRegions = byMessage.get(msg.id);
+        if (!msgRegions)
+            return msg;
+        // 深拷贝 content（保证不修改原对象）
+        const newContent = structuredClone(msg.content);
+        const now = Date.now();
+        // toolResult 区域：替换 output 文本
+        for (const region of msgRegions) {
+            if (region.kind !== 'toolResult')
+                continue;
+            const part = newContent[region.partIndex];
+            if (!part)
+                continue;
+            if (part._tag !== 'tool_result')
+                continue;
+            const placeholder = placeholderFor(region);
+            if (part.output._tag === 'success') {
+                part.output = { ...part.output, output: placeholder, shakenAt: now };
+            }
+            else if (part.output._tag === 'error') {
+                part.output = { ...part.output, error: placeholder, shakenAt: now };
+            }
+            else if (part.output._tag === 'truncated') {
+                part.output = { ...part.output, output: placeholder, shakenAt: now };
+            }
+        }
+        // block 区域：按 partIndex 分组，同一 text 内按 start 降序 splice
+        const blockByPart = new Map();
+        for (const region of msgRegions) {
+            if (region.kind !== 'block')
+                continue;
+            const list = blockByPart.get(region.partIndex) ?? [];
+            list.push(region);
+            blockByPart.set(region.partIndex, list);
+        }
+        for (const [partIndex, blockRegions] of blockByPart) {
+            const part = newContent[partIndex];
+            if (!part || (part._tag !== 'text' && part._tag !== 'thinking'))
+                continue;
+            const sorted = [...blockRegions].sort((a, b) => b.start - a.start);
+            let text = part.text;
+            for (const br of sorted) {
+                text = text.slice(0, br.start) + placeholderFor(br) + text.slice(br.end);
+            }
+            part.text = text;
+        }
+        return { ...msg, content: newContent };
+    });
+}
+/** 区域转 API 视图。protectWindow 窗口内的标记 isAfterProtectWindow=false。 */
+export function toRegionViews(regions, config, messages) {
+    const n = messages.length;
+    const accumulatedAfter = new Array(n);
+    let acc = 0;
+    for (let i = n - 1; i >= 0; i--) {
+        accumulatedAfter[i] = acc;
+        const m = messages[i];
+        if (m)
+            acc += messageTokens(m);
+    }
+    return regions.map((region) => ({
+        id: region.id,
+        kind: region.kind,
+        messageId: region.messageId,
+        messageIndex: region.messageIndex,
+        partIndex: region.partIndex,
+        tokens: region.tokens,
+        label: region.label,
+        preview: region.originalText.slice(0, 200),
+        placeholder: region.kind === 'toolResult'
+            ? `[shaken: ${region.label}, ${region.tokens} tokens]`
+            : '[shaken]',
+        isAfterProtectWindow: (accumulatedAfter[region.messageIndex] ?? 0) >= config.protectTokens,
+        ...(region.kind === 'toolResult' ? { toolCallId: region.toolCallId } : {}),
+    }));
+}

package/dist/session/types.d.ts

@@ -101,7 +101,7 @@ type CompactionArchive = {
     id: string;
     sessionId: string;
     compactionId: string;
-    archiveType: 'compaction' | 'squash';
+    archiveType: 'compaction' | 'squash' | 'shake';
     originalEntries: SessionEntry[];
     summary: string;
     tokenCount: number;

package/dist/shared/types/agent.d.ts

@@ -172,6 +172,18 @@ type AgentEvent = {
     agentType: string;
     success: boolean;
     output?: string;
+}
+/**
+ * 会话压缩成功后发出（spec: plugin-hooks `session:compact`）。
+ * 实际发生压缩（runCompaction 返回 compacted=true）时才 yield；
+ * nothing_to_compact 不发。archiveId/summary 仅在真实压缩时存在。
+ */
+ | {
+    _tag: 'compaction_done';
+    summary: string;
+    archiveId?: string;
+    compactedCount: number;
+    keptCount: number;
 } | {
     _tag: 'done';
 };
@@ -198,5 +210,20 @@ type AgentState = {
         provider: string;
         model: string;
     };
+    /**
+     * 压缩死锁标记：自动压缩成功后仍超阈值（如 keepRecentTokens 本身已超限）时置真，
+     * 暂停后续自动压缩以防每轮重复触发（无限循环）。收到新用户消息（agentLoop 重入）时重置。
+     */
+    compactionDeadEnd?: boolean;
+    /**
+     * 压缩退化监测器：压缩成功后初始化，监测接下来若干轮 assistant 回复。
+     * 若连续产生空回复（无实质文本且无 tool_call），发出非致命警告（不中断循环），
+     * 提示 agent 可能在"沉默退化"。remaining 耗尽即清除；新一轮用户输入
+     * （agentLoop 重入）时不会自动重置——它由压缩成功单独建立。
+     */
+    postCompactionMonitor?: {
+        remaining: number;
+        noTextStreak: number;
+    };
 };
 export type { AgentConfig, AgentError, AgentEvent, AgentState, AgentStatus, LLMCall, LLMSegment, PendingToolCall, SegmentTrigger, TokenBudget, };

package/dist/shared/types/config.d.ts

@@ -16,6 +16,16 @@ type CompactionConfig = {
     reserveTokens: number;
     /** Token budget for retaining recent messages verbatim. */
     keepRecentTokens: number;
+    /** 中轮压缩（mid-run compaction）：单个 turn 内工具执行后、下一次 LLM 请求前
+     * 按阈值静默压缩。与 turn-end 自动压缩独立——以本开关为闸门复用 shouldCompact
+     * 的阈值逻辑（不受 `enabled` 影响），默认关闭（保守开启）。 */
+    midTurnEnabled?: boolean;
+    /** 压缩摘要使用的模型覆盖。未设置时回退到会话主模型。
+     * 摘要任务对推理能力要求低，可指定便宜/快速模型以降低成本。 */
+    compactionModel?: {
+        provider: string;
+        model: string;
+    };
 };
 /** Tool-mode auto-selection configuration (spec §16.5). */
 type ToolMetricsConfig = {

package/dist/shared/types/llm.d.ts

@@ -117,6 +117,7 @@ type StreamChunk = {
     error: {
         message: string;
         retryable?: boolean;
+        classification?: 'context-overflow';
     };
 };
 export type { ChatMessage, ChatRequest, ChatTool, ContentPart, FinishReason, ModelCapabilities, ModelOverride, ModelRole, ProviderConfig, ProviderProtocol, StreamChunk, };

package/dist/shared/types/tool.d.ts

@@ -6,9 +6,11 @@ type ToolResult = {
     _tag: 'success';
     output: string;
     metadata?: Record<string, unknown>;
+    shakenAt?: number;
 } | {
     _tag: 'error';
     error: string;
+    shakenAt?: number;
 } | {
     _tag: 'permission_required';
     reason: string;
@@ -17,6 +19,7 @@ type ToolResult = {
     output: string;
     truncated: boolean;
     totalLines: number;
+    shakenAt?: number;
 };
 /** Context passed to a URL resolver (skill://, agent://, pr://, …). */
 type URLResolveContext = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c0de-agent",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Open-source AI coding assistant with Browser-Server architecture",
   "type": "module",
   "bin": {
@@ -50,7 +50,8 @@
   },
   "pnpm": {
     "onlyBuiltDependencies": [
-      "esbuild"
+      "esbuild",
+      "node-pty"
     ]
   },
   "devDependencies": {
@@ -69,10 +70,12 @@
     "@types/pg": "^8.20.0",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.18.1",
     "@vitejs/plugin-react": "^6.0.3",
     "@wyw-in-js/vite": "^2.1.0",
     "drizzle-kit": "^0.31.10",
     "happy-dom": "^20.10.6",
+    "node-gyp": "^13.0.1",
     "pg": "^8.22.0",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
@@ -89,6 +92,9 @@
     "@native-router/core": "^1.1.0",
     "@native-router/react": "^1.1.2",
     "@tanstack/react-query": "^5.101.2",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/xterm": "^6.0.0",
     "diff": "^9.0.0",
     "drizzle-orm": "^0.45.2",
     "fuzzysort": "^3.1.0",
@@ -96,10 +102,12 @@
     "hono": "^4.12.27",
     "lucide-react": "^1.22.0",
     "marked": "^18.0.5",
+    "node-pty": "^1.1.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "react-router-dom": "^7.18.0",
     "shiki": "^4.3.0",
-    "undici": "^8.5.0"
+    "undici": "^8.5.0",
+    "ws": "^8.21.0"
   }
 }