c0de-agent 0.0.0 → 1.0.0

package/dist/session/session.js

@@ -0,0 +1,144 @@
+import { eq } from 'drizzle-orm';
+import { sessions } from '../db/schema.js';
+import { generateId } from '../shared/index.js';
+/** Convert a DB row (with Date timestamps) to the shared Session type (with number timestamps). */
+export function rowToSession(row) {
+    const created = row.createdAt instanceof Date ? row.createdAt.getTime() : new Date(row.createdAt).getTime();
+    const updated = row.updatedAt instanceof Date ? row.updatedAt.getTime() : new Date(row.updatedAt).getTime();
+    return {
+        id: row.id,
+        title: row.title,
+        parentId: row.parentId,
+        projectId: row.projectId,
+        branchPoint: row.branchPoint,
+        metadata: (row.metadata ?? {}),
+        agentType: row.agentType ?? null,
+        worktreePath: row.worktreePath ?? null,
+        createdAt: created,
+        updatedAt: updated,
+    };
+}
+/** Create a new root session. */
+async function createSession(handle, title, projectId, agentType) {
+    const [row] = await handle.db
+        .insert(sessions)
+        .values({ title, projectId: projectId ?? null, agentType: agentType ?? null })
+        .returning();
+    if (!row)
+        throw new Error('Failed to insert session');
+    return rowToSession(row);
+}
+/** Get a session by id, or null if not found. */
+async function getSession(handle, id) {
+    const [row] = await handle.db.select().from(sessions).where(eq(sessions.id, id));
+    return row ? rowToSession(row) : null;
+}
+/** List all sessions. */
+async function listSessions(handle) {
+    const rows = await handle.db.select().from(sessions);
+    return rows.map(rowToSession);
+}
+/** Delete a session (cascades to entries, archives, snapshots via FK). */
+async function deleteSession(handle, id) {
+    await handle.db.delete(sessions).where(eq(sessions.id, id));
+}
+/** Update a session's title. */
+async function updateSessionTitle(handle, id, title) {
+    await handle.db.update(sessions).set({ title, updatedAt: new Date() }).where(eq(sessions.id, id));
+}
+/** Bump updatedAt to now (used after appending messages). */
+async function touchSession(handle, id) {
+    await handle.db.update(sessions).set({ updatedAt: new Date() }).where(eq(sessions.id, id));
+}
+/** 规格化工具集并计算前缀指纹。tools 顺序不影响指纹（按 name 排序）。 */
+export function segmentFingerprint(systemPrompt, tools) {
+    const norm = JSON.stringify({
+        systemPrompt,
+        tools: [...tools]
+            .map((t) => ({ name: t.name, description: t.description, parameters: t.parameters }))
+            .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)),
+    });
+    let h = 5381;
+    for (let i = 0; i < norm.length; i++)
+        h = ((h << 5) + h + norm.charCodeAt(i)) | 0;
+    return (h >>> 0).toString(16);
+}
+/**
+ * 将旧 metadata.llmDetails 迁移为单个 legacy segment。
+ * - 无 llmDetails 或已有 segments → 原样返回。
+ * - 否则取首条的 systemPrompt/tools 作为段首快照，所有旧 detail 转为 calls，
+ *   responseText 从 responseChunks 的 text 块拼接提取。
+ * 幂等：迁移后 llmDetails 字段被移除，不会重复迁移。
+ */
+export function migrateLegacyDetails(meta) {
+    if (meta.segments !== undefined)
+        return meta;
+    const legacy = meta.llmDetails;
+    if (!Array.isArray(legacy) || legacy.length === 0)
+        return meta;
+    const first = legacy[0];
+    const segment = {
+        id: generateId(),
+        fingerprint: segmentFingerprint(first.systemPrompt, first.tools ?? []),
+        provider: first.provider,
+        model: first.model,
+        systemPrompt: first.systemPrompt,
+        tools: first.tools ?? [],
+        startedAt: first.timestamp,
+        trigger: 'initial',
+        ...(first.contextWindow !== undefined ? { contextWindow: first.contextWindow } : {}),
+        calls: legacy.map((d) => {
+            const detail = d;
+            return {
+                id: detail.id,
+                timestamp: detail.timestamp,
+                usage: detail.usage,
+                latency: detail.latency,
+                cost: detail.cost,
+                ...(detail.thinking ? { thinking: detail.thinking } : {}),
+                responseText: (detail.responseChunks ?? [])
+                    .map((c) => (c._tag === 'text' && typeof c.text === 'string' ? c.text : ''))
+                    .join(''),
+            };
+        }),
+    };
+    const { llmDetails: _omit, ...rest } = meta;
+    return { ...rest, segments: [segment] };
+}
+/** 读取会话 metadata.segments（读取时顺带迁移旧 llmDetails）。 */
+export async function getLLMSegments(handle, id) {
+    const [row] = await handle.db.select().from(sessions).where(eq(sessions.id, id));
+    if (!row)
+        return [];
+    const meta = migrateLegacyDetails((row.metadata ?? {}));
+    return meta.segments ?? [];
+}
+/** 全量替换会话 metadata.segments（每轮 loop 结束写入；段数据轻量）。 */
+export async function saveLLMSegments(handle, id, segments) {
+    const [row] = await handle.db.select().from(sessions).where(eq(sessions.id, id));
+    if (!row)
+        return;
+    const meta = migrateLegacyDetails((row.metadata ?? {}));
+    const { segments: _omit, ...rest } = meta;
+    const next = { ...rest, segments };
+    await handle.db
+        .update(sessions)
+        .set({ metadata: next, updatedAt: new Date() })
+        .where(eq(sessions.id, id));
+}
+/** 更新会话 metadata.lastRun（agent run 开始/结束时写入；重启后检测中断用）。 */
+async function updateSessionLastRun(handle, id, lastRun) {
+    const [row] = await handle.db.select().from(sessions).where(eq(sessions.id, id));
+    if (!row)
+        return;
+    const meta = (row.metadata ?? {});
+    await handle.db
+        .update(sessions)
+        .set({ metadata: { ...meta, lastRun }, updatedAt: new Date() })
+        .where(eq(sessions.id, id));
+}
+async function listSessionsByProject(handle, projectId) {
+    const rows = await handle.db.select().from(sessions).where(eq(sessions.projectId, projectId));
+    return rows.map(rowToSession);
+}
+export { createSession, deleteSession, getSession, listSessions, listSessionsByProject, touchSession, updateSessionLastRun, updateSessionTitle, };

package/dist/session/snapshot.d.ts

@@ -0,0 +1,11 @@
+import type { DB } from '../db/client.js';
+import type { FileSnapshot } from './types.js';
+/** Create or update a file snapshot. Always creates a new version. Returns the snapshot id. */
+declare function upsertFileSnapshot(handle: DB, sessionId: string, filePath: string, content: string): Promise<string>;
+/** Get all snapshots for a session. */
+declare function getFileSnapshots(handle: DB, sessionId: string): Promise<FileSnapshot[]>;
+/** Get the latest snapshot for a specific file, or null. */
+declare function getLatestFileSnapshot(handle: DB, sessionId: string, filePath: string): Promise<FileSnapshot | null>;
+/** Quick check: return cached file content if a snapshot exists, else null. */
+declare function checkFileSnapshot(handle: DB, sessionId: string, filePath: string): Promise<string | null>;
+export { checkFileSnapshot, getFileSnapshots, getLatestFileSnapshot, upsertFileSnapshot };

package/dist/session/snapshot.js

@@ -0,0 +1,60 @@
+import { createHash } from 'node:crypto';
+import { and, desc, eq } from 'drizzle-orm';
+import { fileSnapshots } from '../db/schema.js';
+import { estimateTokens } from './token.js';
+function rowToSnapshot(row) {
+    const createdAt = row.createdAt instanceof Date ? row.createdAt.getTime() : new Date(row.createdAt).getTime();
+    return {
+        id: row.id,
+        sessionId: row.sessionId,
+        filePath: row.filePath,
+        content: row.content,
+        contentHash: row.contentHash,
+        tokenCount: row.tokenCount ?? 0,
+        version: row.version ?? 1,
+        createdAt,
+    };
+}
+/** Create or update a file snapshot. Always creates a new version. Returns the snapshot id. */
+async function upsertFileSnapshot(handle, sessionId, filePath, content) {
+    const contentHash = createHash('sha256').update(content).digest('hex');
+    const tokenCount = estimateTokens(content);
+    const [existing] = await handle.db
+        .select()
+        .from(fileSnapshots)
+        .where(and(eq(fileSnapshots.sessionId, sessionId), eq(fileSnapshots.filePath, filePath)))
+        .orderBy(desc(fileSnapshots.version))
+        .limit(1);
+    const version = (existing?.version ?? 0) + 1;
+    const [row] = await handle.db
+        .insert(fileSnapshots)
+        .values({ sessionId, filePath, content, contentHash, tokenCount, version })
+        .returning();
+    if (!row)
+        throw new Error('Failed to insert file snapshot');
+    return row.id;
+}
+/** Get all snapshots for a session. */
+async function getFileSnapshots(handle, sessionId) {
+    const rows = await handle.db
+        .select()
+        .from(fileSnapshots)
+        .where(eq(fileSnapshots.sessionId, sessionId));
+    return rows.map(rowToSnapshot);
+}
+/** Get the latest snapshot for a specific file, or null. */
+async function getLatestFileSnapshot(handle, sessionId, filePath) {
+    const [row] = await handle.db
+        .select()
+        .from(fileSnapshots)
+        .where(and(eq(fileSnapshots.sessionId, sessionId), eq(fileSnapshots.filePath, filePath)))
+        .orderBy(desc(fileSnapshots.version))
+        .limit(1);
+    return row ? rowToSnapshot(row) : null;
+}
+/** Quick check: return cached file content if a snapshot exists, else null. */
+async function checkFileSnapshot(handle, sessionId, filePath) {
+    const snapshot = await getLatestFileSnapshot(handle, sessionId, filePath);
+    return snapshot?.content ?? null;
+}
+export { checkFileSnapshot, getFileSnapshots, getLatestFileSnapshot, upsertFileSnapshot };

package/dist/session/squash.d.ts

@@ -0,0 +1,9 @@
+import type { DB } from '../db/client.js';
+import type { CompactionResult, SquashConfig, Summarizer } from './types.js';
+/**
+ * Squash the most recent `count` messages into a summary, keeping `keepRecent` verbatim.
+ * Similar to `git rebase -i + squash`: compresses recent interactions while preserving
+ * the conversation prefix and a small tail for cache stability.
+ */
+declare function squashRecent(handle: DB, sessionId: string, count: number, summarizer: Summarizer, config?: Partial<SquashConfig>): Promise<CompactionResult>;
+export { squashRecent };

package/dist/session/squash.js

@@ -0,0 +1,88 @@
+import { generateId } from '../shared/index.js';
+import { archiveOriginalEntries } from './archive.js';
+import { extractHotFiles } from './compaction.js';
+import { deleteEntriesByIds, getMessages, insertEntry } from './message.js';
+import { upsertFileSnapshot } from './snapshot.js';
+import { estimateTokens } from './token.js';
+const DEFAULT_SQUASH_CONFIG = {
+    keepRecent: 2,
+    preserveFileSnapshots: true,
+    archiveOriginal: true,
+};
+/**
+ * Squash the most recent `count` messages into a summary, keeping `keepRecent` verbatim.
+ * Similar to `git rebase -i + squash`: compresses recent interactions while preserving
+ * the conversation prefix and a small tail for cache stability.
+ */
+async function squashRecent(handle, sessionId, count, summarizer, config) {
+    const cfg = { ...DEFAULT_SQUASH_CONFIG, ...config };
+    const messages = await getMessages(handle, sessionId);
+    if (messages.length < count + cfg.keepRecent) {
+        return { compacted: false, reason: 'too_few_messages' };
+    }
+    const tailStart = messages.length - cfg.keepRecent;
+    const squashStart = messages.length - count;
+    const toSquash = messages.slice(squashStart, tailStart);
+    const keepTail = messages.slice(tailStart);
+    if (toSquash.length === 0) {
+        return { compacted: false, reason: 'nothing_to_compact' };
+    }
+    const history = toSquash
+        .map((m) => `[${m.role}] ${m.content.map((p) => (p._tag === 'text' ? p.text : JSON.stringify(p))).join(' ')}`)
+        .join('\n');
+    const prompt = `将以下最近的交互压缩为简洁摘要，保留关键决策和上下文，丢弃冗余细节。
+重点保留：修改了哪些文件、做了什么决策、当前进度、下一步计划。
+
+## 最近操作
+[简要描述做了什么]
+
+## 修改的文件
+- path: 变更描述
+
+## 关键决策
+[做出的重要决策]
+
+## 当前状态
+[进度和下一步]
+
+---
+交互历史：
+${history}`;
+    const summary = await summarizer(prompt);
+    const squashEntryId = generateId();
+    const archiveId = cfg.archiveOriginal
+        ? await archiveOriginalEntries(handle, sessionId, toSquash, 'squash', summary, squashEntryId)
+        : generateId();
+    const fileSnapshotIds = [];
+    if (cfg.preserveFileSnapshots) {
+        const hotFiles = extractHotFiles(toSquash);
+        for (const file of hotFiles) {
+            const id = await upsertFileSnapshot(handle, sessionId, file.path, file.content);
+            fileSnapshotIds.push(id);
+        }
+    }
+    await deleteEntriesByIds(handle, toSquash.map((m) => m.id));
+    await insertEntry(handle, {
+        id: squashEntryId,
+        sessionId,
+        tag: 'squash',
+        content: {
+            summary,
+            squashedEntryIds: toSquash.map((m) => m.id),
+            archiveId,
+        },
+        tokenCount: estimateTokens(summary),
+        // Position at the first squashed message's timestamp so it sorts between
+        // the prefix and the kept tail under createdAt-ascending order.
+        createdAt: toSquash[0] ? new Date(toSquash[0].createdAt) : new Date(),
+    });
+    return {
+        compacted: true,
+        summary,
+        archiveId,
+        fileSnapshots: fileSnapshotIds,
+        compactedCount: toSquash.length,
+        keptCount: keepTail.length,
+    };
+}
+export { squashRecent };

package/dist/session/token.d.ts

@@ -0,0 +1,10 @@
+import type { MessageContent } from '../shared/types/message.js';
+/**
+ * CJK-aware token estimate.
+ * Chinese/CJK characters ≈ 2 tokens each (denser encoding).
+ * Other characters ≈ 4 chars/token (standard heuristic).
+ */
+declare const estimateTokens: (text: string) => number;
+/** Sum token estimates across all parts of a message's content array. */
+declare const estimateMessageTokens: (content: MessageContent[]) => number;
+export { estimateMessageTokens, estimateTokens };

package/dist/session/token.js

@@ -0,0 +1,33 @@
+/**
+ * CJK-aware token estimate.
+ * Chinese/CJK characters ≈ 2 tokens each (denser encoding).
+ * Other characters ≈ 4 chars/token (standard heuristic).
+ */
+const estimateTokens = (text) => {
+    if (text.length === 0)
+        return 0;
+    const cjkCount = text.match(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/g)?.length ?? 0;
+    const otherCount = text.length - cjkCount;
+    return Math.ceil(cjkCount * 2 + otherCount / 4);
+};
+/** Sum token estimates across all parts of a message's content array. */
+const estimateMessageTokens = (content) => {
+    let total = 0;
+    for (const part of 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;
+};
+export { estimateMessageTokens, estimateTokens };

package/dist/session/types.d.ts

@@ -0,0 +1,122 @@
+import type { MessageRole } from '../shared/types/base.js';
+import type { ChatMessage } from '../shared/types/llm.js';
+import type { Message, MessageContent, Session, SessionMetadata } from '../shared/types/message.js';
+export type { MessageRole } from '../shared/types/base.js';
+export type { ChatMessage, Message, MessageContent, Session, SessionMetadata };
+/** A compaction summary entry — replaces compacted messages with a summary. */
+type CompactionEntry = {
+    _tag: 'compaction';
+    id: string;
+    sessionId: string;
+    summary: string;
+    originalEntryIds: string[];
+    archiveId: string;
+    tokenCount: number;
+    createdAt: number;
+};
+/** A squash entry — compresses recent interactions into a summary. */
+type SquashEntry = {
+    _tag: 'squash';
+    id: string;
+    sessionId: string;
+    summary: string;
+    squashedEntryIds: string[];
+    archiveId: string;
+    tokenCount: number;
+    createdAt: number;
+};
+/** Records that a session was forked from another. */
+type BranchSummaryEntry = {
+    _tag: 'branch_summary';
+    id: string;
+    sessionId: string;
+    summary: string;
+    sourceSessionId: string;
+    createdAt: number;
+};
+/** A steering instruction injected mid-conversation. */
+type SteeringEntry = {
+    _tag: 'steering';
+    id: string;
+    sessionId: string;
+    content: string;
+    createdAt: number;
+};
+/** All session entries, ordered chronologically. Narrow via `'_tag' in entry`. */
+type SessionEntry = Message | CompactionEntry | SquashEntry | BranchSummaryEntry | SteeringEntry;
+/** Input for `appendMessage` — role + content; id/timestamps auto-generated. */
+type MessageInput = {
+    role: MessageRole;
+    content: MessageContent[];
+    tokenCount?: number;
+};
+/** A hot file detected from tool-call history. */
+type HotFile = {
+    path: string;
+    content: string;
+    tokenCount: number;
+    accessCount: number;
+};
+/** Configuration for compaction. */
+type CompactionConfig = {
+    /** Token budget for the recent-message keep window. Messages are retained
+     *  from the newest backward until their cumulative token count exceeds this
+     *  value; everything older is summarized. Drives compaction by tokens, not
+     *  by a fixed message count. */
+    keepRecentTokens: number;
+    preserveSnapshots: boolean;
+};
+/** Result of a compaction or squash operation. */
+type CompactionResult = {
+    compacted: true;
+    summary: string;
+    archiveId: string;
+    fileSnapshots: string[];
+    compactedCount: number;
+    keptCount: number;
+} | {
+    compacted: false;
+    reason: 'too_few_messages' | 'nothing_to_compact';
+};
+/** Configuration for squash. */
+type SquashConfig = {
+    keepRecent: number;
+    preserveFileSnapshots: boolean;
+    archiveOriginal: boolean;
+};
+/** Injected summarizer — the session layer does NOT import the LLM package. */
+type Summarizer = (prompt: string) => Promise<string>;
+/** Parsed `@[archive:<id>]` / `@[squash:<n>]` reference. */
+type ArchiveRef = {
+    type: 'archive' | 'squash';
+    id: string;
+};
+/** A node in the session tree. */
+type SessionTreeNode = {
+    session: Session;
+    children: SessionTreeNode[];
+};
+/** A decoded compaction archive row. */
+type CompactionArchive = {
+    id: string;
+    sessionId: string;
+    compactionId: string;
+    archiveType: 'compaction' | 'squash';
+    originalEntries: SessionEntry[];
+    summary: string;
+    tokenCount: number;
+    searchableText: string;
+    createdAt: number;
+};
+/** A decoded file snapshot row. */
+type FileSnapshot = {
+    id: string;
+    sessionId: string;
+    filePath: string;
+    content: string;
+    contentHash: string;
+    tokenCount: number;
+    version: number;
+    createdAt: number;
+};
+export type { ArchiveRef, BranchSummaryEntry, CompactionArchive, CompactionConfig, CompactionEntry, CompactionResult, FileSnapshot, HotFile, MessageInput, SessionEntry, SessionTreeNode, SquashConfig, SquashEntry, SteeringEntry, Summarizer, };

package/dist/session/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './types/index.js';
+export { generateId, now } from './utils.js';

package/dist/shared/index.js

@@ -0,0 +1 @@
+export { generateId, now } from './utils.js';