@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/agent/history-store.js

@@ -0,0 +1,320 @@
+import { createHash } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { chmod, readFile, rename } from "node:fs/promises";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+const ROOT = "";
+/**
+ * Every turn of every version of a chat is a row: `parent` is the turn it follows, so a fork is
+ * several rows with one parent. `pick` on the parent (or on `chats` for the first message) is the
+ * child the chat currently shows; without it the newest child is shown.
+ */
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS chats (
+    id TEXT PRIMARY KEY,
+    pick TEXT,
+    revision INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE TABLE IF NOT EXISTS turns (
+    chat TEXT NOT NULL,
+    id TEXT NOT NULL,
+    parent TEXT NOT NULL,
+    ord INTEGER NOT NULL,
+    pick TEXT,
+    hash TEXT NOT NULL,
+    data TEXT NOT NULL,
+    PRIMARY KEY (chat, id)
+  );
+  CREATE INDEX IF NOT EXISTS turns_parent ON turns (chat, parent, ord);
+  CREATE TABLE IF NOT EXISTS chat_index (
+    chat TEXT PRIMARY KEY,
+    scope TEXT NOT NULL,
+    backend TEXT NOT NULL,
+    title TEXT NOT NULL,
+    updated TEXT NOT NULL,
+    session TEXT
+  );
+  CREATE INDEX IF NOT EXISTS chat_index_scope ON chat_index (scope, backend, updated);
+  CREATE TABLE IF NOT EXISTS archives (
+    id TEXT PRIMARY KEY,
+    scope TEXT NOT NULL,
+    title TEXT NOT NULL,
+    updated TEXT NOT NULL,
+    pinned INTEGER NOT NULL DEFAULT 0,
+    project TEXT NOT NULL DEFAULT '',
+    backend TEXT NOT NULL DEFAULT ''
+  );
+  CREATE INDEX IF NOT EXISTS archives_scope ON archives (scope, pinned, updated);
+`;
+/** A column added after the table was first created; SQLite has no `ADD COLUMN IF NOT EXISTS`. */
+function ensureColumn(db, table, column, declaration) {
+    const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (!columns.some((item) => item.name === column))
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${declaration}`);
+}
+const databases = new Map();
+export function historyDatabase() {
+    const directory = join(dataDir(), "agent");
+    const file = join(directory, "history.sqlite");
+    const open = databases.get(file);
+    if (open)
+        return open;
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const db = new DatabaseSync(file);
+    db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA synchronous = NORMAL;");
+    db.exec(SCHEMA);
+    ensureColumn(db, "archives", "project", "TEXT NOT NULL DEFAULT ''");
+    ensureColumn(db, "archives", "backend", "TEXT NOT NULL DEFAULT ''");
+    // The native session a chat continues; older rows get it from their history on first read.
+    ensureColumn(db, "chat_index", "session", "TEXT");
+    // Feature overrides of a chat, as JSON; NULL means the user's defaults apply.
+    ensureColumn(db, "chats", "features", "TEXT");
+    // Judge settings of a chat, as JSON; NULL means the global settings apply.
+    ensureColumn(db, "chats", "judge", "TEXT");
+    // The role snapshot a chat started with, as JSON; NULL means the chat has no role.
+    ensureColumn(db, "chats", "role", "TEXT");
+    // Messages waiting for the answer, as JSON; NULL means the queue is empty.
+    ensureColumn(db, "chats", "queue", "TEXT");
+    void chmod(file, 0o600).catch(() => { });
+    databases.set(file, db);
+    return db;
+}
+/** Closes every opened database (a test removing its data directory, a restart). */
+export function closeHistoryStore() {
+    for (const db of databases.values())
+        db.close();
+    databases.clear();
+}
+const hashOf = (text) => createHash("sha1").update(text).digest("base64");
+/** The first thing the user said: what the chat is about. */
+export function chatTitle(turns) {
+    const first = turns.find((turn) => turn.role === "user");
+    const text = (first?.text ?? "").replace(/\s+/g, " ").trim();
+    return text.length > 80 ? `${text.slice(0, 79)}…` : text || "Без названия";
+}
+/** The native session a chat continues: the last answer's, unless the chat was cut back. */
+export function currentSession(turns) {
+    for (let index = turns.length - 1; index >= 0; index--) {
+        const turn = turns[index];
+        if (turn.role !== "assistant")
+            continue;
+        return turn.detached ? undefined : turn.session?.id;
+    }
+    return undefined;
+}
+/** Remembers the chat in the project's list; an empty chat is not worth listing. */
+function saveIndex(db, chat, turns, index) {
+    if (!index.project)
+        return;
+    if (!turns.length) {
+        db.prepare("DELETE FROM chat_index WHERE chat = ?").run(chat);
+        return;
+    }
+    const title = index.title || chatTitle(turns);
+    db.prepare(`INSERT INTO chat_index (chat, scope, backend, title, updated, session) VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT (chat) DO UPDATE SET
+       scope = excluded.scope, backend = excluded.backend,
+       title = CASE
+         WHEN ? IS NOT NULL THEN excluded.title
+         WHEN chat_index.title LIKE 'Ветка%' THEN chat_index.title
+         ELSE excluded.title
+       END,
+       updated = excluded.updated,
+       session = excluded.session`).run(chat, index.project, index.backend, title, new Date().toISOString(), currentSession(turns) ?? null, index.title || null);
+}
+/** Where a saved chat belongs, if it is in the project's list. */
+export function chatMetaOf(chat) {
+    const row = historyDatabase()
+        .prepare("SELECT scope, backend, title FROM chat_index WHERE chat = ?")
+        .get(chat);
+    return row ? { project: row.scope, backend: row.backend, title: row.title } : undefined;
+}
+/** Splits a version of the chat into rows; forks found along the way become sibling rows. */
+function flatten(turns, parent, rows, pick, 
+/** Place of the first turn among the turns that follow `parent`. */
+place = 0) {
+    let previous = parent;
+    for (let index = 0; index < turns.length; index++) {
+        const head = turns[index];
+        if (head.variants?.length) {
+            const position = Math.min(head.slot ?? head.variants.length, head.variants.length);
+            const versions = [...head.variants];
+            versions.splice(position, 0, turns.slice(index));
+            versions.forEach((version, ord) => {
+                if (!version.length)
+                    return;
+                const [first, ...rest] = version;
+                const alone = { ...first, variants: undefined, slot: undefined };
+                flatten([alone, ...rest], previous, rows, pick, ord);
+            });
+            const shown = versions[position]?.[0];
+            if (shown)
+                pick.set(previous, shown.id);
+            return;
+        }
+        rows.push(rowOf(head, previous, index === 0 ? place : 0));
+        previous = head.id;
+    }
+}
+function rowOf(turn, parent, ord) {
+    const { variants: _variants, slot: _slot, ...rest } = turn;
+    const data = JSON.stringify(rest);
+    return { id: turn.id, parent, ord, pick: null, hash: hashOf(`${parent}\n${ord}\n${data}`), data };
+}
+/** Replaces the saved chat with `turns`, rewriting only the rows that changed. */
+export function saveHistory(chat, turns, index) {
+    const rows = [];
+    const pick = new Map();
+    flatten(turns, ROOT, rows, pick);
+    const seen = new Set();
+    for (const row of rows) {
+        if (seen.has(row.id))
+            throw new Error(`Повторяющийся ID сообщения: ${row.id}`);
+        seen.add(row.id);
+    }
+    const db = historyDatabase();
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        const existing = new Map();
+        for (const row of db
+            .prepare("SELECT id, hash, pick FROM turns WHERE chat = ?")
+            .all(chat))
+            existing.set(row.id, { hash: row.hash, pick: row.pick });
+        const upsert = db.prepare(`INSERT INTO turns (chat, id, parent, ord, pick, hash, data) VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (chat, id) DO UPDATE SET
+         parent = excluded.parent, ord = excluded.ord, pick = excluded.pick,
+         hash = excluded.hash, data = excluded.data`);
+        for (const row of rows) {
+            const choice = pick.get(row.id) ?? null;
+            const before = existing.get(row.id);
+            existing.delete(row.id);
+            if (before && before.hash === row.hash && before.pick === choice)
+                continue;
+            upsert.run(chat, row.id, row.parent, row.ord, choice, row.hash, row.data);
+        }
+        const remove = db.prepare("DELETE FROM turns WHERE chat = ? AND id = ?");
+        for (const id of existing.keys())
+            remove.run(chat, id);
+        db.prepare(`INSERT INTO chats (id, pick, revision) VALUES (?, ?, 1)
+       ON CONFLICT (id) DO UPDATE SET pick = excluded.pick, revision = revision + 1`).run(chat, pick.get(ROOT) ?? null);
+        if (index)
+            saveIndex(db, chat, turns, index);
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+/** The feature ids this chat chose for itself; absent means the user's defaults apply. */
+export function readChatFeatures(chat) {
+    const db = historyDatabase();
+    const row = db.prepare("SELECT features FROM chats WHERE id = ?").get(chat);
+    if (!row?.features)
+        return undefined;
+    try {
+        const value = JSON.parse(row.features);
+        return Array.isArray(value)
+            ? value.filter((id) => typeof id === "string")
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Replaces the chat's feature overrides; `null` returns it to the user's defaults. */
+export function saveChatFeatures(chat, features) {
+    const db = historyDatabase();
+    db.prepare(`INSERT INTO chats (id, features) VALUES (?, ?)
+     ON CONFLICT (id) DO UPDATE SET features = excluded.features`).run(chat, features ? JSON.stringify(features) : null);
+}
+/** The chat as it is shown: the picked version, the others nested under the turn that forks them. */
+export function loadHistory(chat) {
+    const db = historyDatabase();
+    const meta = db.prepare("SELECT pick FROM chats WHERE id = ?").get(chat);
+    if (!meta)
+        return undefined;
+    const rows = db
+        .prepare("SELECT id, parent, ord, pick, data FROM turns WHERE chat = ? ORDER BY parent, ord")
+        .all(chat);
+    const children = new Map();
+    for (const row of rows) {
+        const list = children.get(row.parent);
+        if (list)
+            list.push(row);
+        else
+            children.set(row.parent, [row]);
+    }
+    const pickOf = new Map(rows.map((row) => [row.id, row.pick]));
+    pickOf.set(ROOT, meta.pick);
+    /** One version: follows single children, and nests the others where the chat forks. */
+    function chain(first) {
+        const out = [];
+        const visited = new Set();
+        let row = first;
+        while (row && !visited.has(row.id)) {
+            visited.add(row.id);
+            const turn = JSON.parse(row.data);
+            out.push(turn);
+            const next = children.get(row.id) ?? [];
+            if (next.length > 1) {
+                fork(row.id, next, out);
+                return out;
+            }
+            row = next[0];
+        }
+        return out;
+    }
+    /** Appends the shown version of the siblings under `parent`, with the other versions nested in its first turn. */
+    function fork(parent, siblings, out) {
+        const picked = pickOf.get(parent);
+        const index = Math.max(0, siblings.findIndex((item) => item.id === picked));
+        const slot = picked && siblings.some((item) => item.id === picked) ? index : siblings.length - 1;
+        const versions = siblings.map((item) => chain(item));
+        const shown = versions[slot];
+        shown[0].variants = versions.filter((_, at) => at !== slot);
+        shown[0].slot = slot;
+        out.push(...shown);
+    }
+    const top = children.get(ROOT) ?? [];
+    if (!top.length)
+        return [];
+    if (top.length === 1)
+        return chain(top[0]);
+    const out = [];
+    fork(ROOT, top, out);
+    return out;
+}
+/** How many saved versions of a chat exist, for diagnostics and tests. */
+export function historyRevision(chat) {
+    const row = historyDatabase().prepare("SELECT revision FROM chats WHERE id = ?").get(chat);
+    return row?.revision ?? 0;
+}
+export function deleteHistory(chat) {
+    const db = historyDatabase();
+    db.prepare("DELETE FROM turns WHERE chat = ?").run(chat);
+    db.prepare("DELETE FROM chats WHERE id = ?").run(chat);
+    db.prepare("DELETE FROM chat_index WHERE chat = ?").run(chat);
+}
+/** The JSON file an earlier version kept a chat in. */
+export function legacyHistoryPath(chat) {
+    return join(dataDir(), "agent", `${createHash("sha256").update(chat).digest("hex")}.json`);
+}
+/** Moves the chat of an older version out of its JSON file into the database, once. */
+export async function importLegacyHistory(chat, parse) {
+    const path = legacyHistoryPath(chat);
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    const turns = parse(JSON.parse(raw));
+    saveHistory(chat, turns);
+    await rename(path, `${path}.bak`);
+    return turns;
+}

package/packages/server/modules/agent/history.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { agentTaskSchema } from "../../../core/modules/agent-task/index.js";
+import { importLegacyHistory, loadHistory, saveChatFeatures, saveHistory, } from "./history-store.js";
+import { saveChatJudge } from "./judge-store.js";
+import { saveChatQueue } from "./queue-store.js";
+import { saveChatRole } from "./role-store.js";
+import { normalizeJudgeOverride } from "../../../core/modules/agent-judge/index.js";
+import { normalizeRoleSnapshot } from "../../../core/modules/agent-role/index.js";
+const partSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("text"), text: z.string() }),
+    z.object({
+        type: z.literal("file"),
+        path: z.string(),
+        directory: z.boolean().optional(),
+        range: z
+            .object({ from: z.number().int().positive(), to: z.number().int().positive() })
+            .refine((range) => range.to >= range.from)
+            .optional(),
+    }),
+    z.object({
+        type: z.literal("image"),
+        id: z.string(),
+        name: z.string(),
+        mime: z.string(),
+    }),
+    z.object({ type: z.literal("command"), name: z.string() }),
+]);
+const formSchema = z.object({
+    source: z.string(),
+    values: z.unknown(),
+    summary: z.string().optional(),
+});
+const queueSchema = z.array(z.object({
+    id: z.string(),
+    text: z.string(),
+    parts: z.array(partSchema),
+    form: formSchema.optional(),
+    auto: z.string().optional(),
+    autoTitle: z.string().optional(),
+}));
+const turnSchema = z.lazy(() => z.object({
+    id: z.string(),
+    role: z.enum(["user", "assistant"]),
+    text: z.string(),
+    /** When the message was written (ms since the epoch). */
+    at: z.number().optional(),
+    /** Native session of the backend that produced this turn, used to resume it. */
+    session: z.object({ backend: z.string(), id: z.string() }).optional(),
+    /** The agent process still answering this turn; lets a reloaded page rejoin it. */
+    run: z.string().optional(),
+    /** The IDE wrote this message after a job: shown as a note with the job's name. */
+    auto: z.string().optional(),
+    autoTitle: z.string().optional(),
+    /** Projector's instructions before a native session's first user message, shown separately. */
+    injected: z.string().optional(),
+    tools: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        status: z.enum(["running", "done", "error"]),
+        input: z.string().optional(),
+        detail: z.string(),
+        parent: z.string().optional(),
+        /** When the call started and ended (ms since the epoch), for showing how long it took. */
+        startedAt: z.number().optional(),
+        endedAt: z.number().optional(),
+    })),
+    tasks: z.array(agentTaskSchema).optional(),
+    content: z.array(partSchema).optional(),
+    /** A form answer: the block the user filled and the values that were sent. */
+    form: formSchema.optional(),
+    /** Tokens, cache use and cost of the answer, for the usage tooltip after a reload. */
+    usage: z
+        .object({
+        input: z.number(),
+        output: z.number(),
+        cacheRead: z.number(),
+        cacheWrite: z.number(),
+        first: z
+            .object({
+            input: z.number(),
+            output: z.number(),
+            cacheRead: z.number(),
+            cacheWrite: z.number(),
+        })
+            .optional(),
+        cost: z.number().optional(),
+    })
+        .optional(),
+    context: z
+        .object({
+        used: z.number(),
+        size: z.number(),
+        model: z.string().optional(),
+        compactAt: z.number().optional(),
+        categories: z.array(z.object({ name: z.string(), tokens: z.number() })).optional(),
+        cost: z.object({ amount: z.number(), currency: z.string() }).optional(),
+    })
+        .optional(),
+    parts: z
+        .array(z.discriminatedUnion("type", [
+        z.object({ type: z.literal("text"), text: z.string() }),
+        z.object({ type: z.literal("tool"), id: z.string() }),
+        z.object({ type: z.literal("note"), text: z.string() }),
+        z.object({ type: z.literal("thought"), text: z.string() }),
+        z.object({
+            type: z.literal("judge"),
+            tool: z.string(),
+            title: z.string().optional(),
+            verdict: z.object({
+                score: z.union([
+                    z.literal(1),
+                    z.literal(2),
+                    z.literal(3),
+                    z.literal(4),
+                    z.literal(5),
+                ]),
+                label: z.string(),
+                reason: z.string(),
+                confidence: z.enum(["high", "medium", "low"]),
+                effect: z.string().optional(),
+            }),
+            decision: z.literal("auto"),
+            at: z.number(),
+        }),
+    ]))
+        .optional(),
+    /** The isolated copy of the project this answer was written in. */
+    worktree: z.object({ id: z.string(), branch: z.string() }).optional(),
+    /** Transcript position after this answer: the next message branches off here if needed. */
+    tail: z.string().optional(),
+    /** The native session cannot be continued from this turn: the chat is replayed instead. */
+    detached: z.boolean().optional(),
+    /** Other versions of the conversation from this message on (it was edited or repeated). */
+    variants: z.array(z.array(turnSchema)).optional(),
+    /** Where the shown version stands among `variants`. */
+    slot: z.number().int().min(0).optional(),
+}));
+const schema = z.array(turnSchema);
+const featuresSchema = z.array(z.string().min(1).max(64)).max(50);
+export async function readAgentHistory(id) {
+    const saved = loadHistory(id) ?? (await importLegacyHistory(id, (value) => schema.parse(value)));
+    return schema.parse(saved ?? []);
+}
+export async function writeAgentHistory(id, value, index, features, judge, role, queue) {
+    const turns = schema.parse(value);
+    // Parsed before anything is written: a broken queue must not leave the chat half saved.
+    const queued = queue === undefined ? undefined : queue === null ? null : queueSchema.parse(queue);
+    saveHistory(id, turns, index);
+    // `undefined` keeps the chat's choice; `null` clears it back to the user's defaults.
+    if (features !== undefined)
+        saveChatFeatures(id, features === null ? null : featuresSchema.parse(features));
+    if (judge !== undefined)
+        saveChatJudge(id, judge === null ? null : (normalizeJudgeOverride(judge) ?? null));
+    if (role !== undefined)
+        saveChatRole(id, role === null ? null : (normalizeRoleSnapshot(role) ?? null));
+    // `undefined` keeps a queue saved before the field existed; `null` or `[]` empties it.
+    if (queued !== undefined)
+        saveChatQueue(id, queued);
+    return turns;
+}