@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/agent/jobs-files.js

@@ -0,0 +1,65 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const run = promisify(execFile);
+async function git(cwd, args) {
+    return (await run("git", args, { cwd, maxBuffer: 16 * 1024 * 1024 })).stdout;
+}
+async function status(cwd) {
+    const out = await git(cwd, ["status", "--porcelain", "-z", "--untracked-files=all"]);
+    const entries = new Map();
+    const parts = out.split("\0").filter(Boolean);
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        const code = part.slice(0, 2);
+        entries.set(part.slice(3), code);
+        // A rename or copy lists its source as a separate entry.
+        if (code[0] === "R" || code[0] === "C")
+            index++;
+    }
+    return entries;
+}
+/** `undefined` when the folder is not in a git repository (the job's files then come from its calls). */
+export async function snapshotGit(cwd) {
+    try {
+        const head = (await git(cwd, ["rev-parse", "--verify", "-q", "HEAD"]).catch(() => "")).trim();
+        return { head, dirty: await status(cwd) };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The files that differ now from the snapshot: new changes, new commits. */
+export async function changedSince(cwd, before) {
+    if (!before)
+        return [];
+    try {
+        const now = await status(cwd);
+        const files = new Set();
+        for (const [path, code] of now)
+            if (before.dirty.get(path) !== code)
+                files.add(path);
+        for (const path of before.dirty.keys())
+            if (!now.has(path))
+                files.add(path);
+        if (before.head) {
+            const committed = await git(cwd, ["diff", "--name-only", "-z", `${before.head}..HEAD`]).catch(() => "");
+            for (const path of committed.split("\0").filter(Boolean))
+                files.add(path);
+        }
+        return [...files];
+    }
+    catch {
+        return [];
+    }
+}
+const WRITING = new Set(["write", "edit", "multiedit", "notebookedit"]);
+/** Paths a Claude-style write or edit call touched, relative to `root` when inside it. */
+export function pathsOfCall(name, input, root) {
+    if (!WRITING.has(name.toLowerCase()) || !input || typeof input !== "object")
+        return [];
+    const data = input;
+    const path = data.file_path ?? data.filePath ?? data.path ?? data.notebook_path;
+    if (typeof path !== "string" || !path)
+        return [];
+    return [root && path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path];
+}

package/packages/server/modules/agent/jobs-followup.js

@@ -0,0 +1,66 @@
+import { randomUUID } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { change, live, persist, record } from "./jobs-live.js";
+import { drive, isFinished, open, readJob } from "./jobs.js";
+import { loadJob, publicJob } from "./jobs-store.js";
+import { holdJobWorktree } from "./jobs-worktree.js";
+/** A finished job is being reopened right now: a second follow-up must not race it. */
+const resuming = new Set();
+/** Continues a finished job in the same record, copy and native session. */
+export async function followUpJob(id, text) {
+    const message = text.trim();
+    if (!message)
+        throw new Error("Напишите уточнение агенту");
+    const active = live.get(id);
+    if ((active && !isFinished(active.job.status)) || resuming.has(id))
+        throw new Error("Задание ещё работает: уточнение уйдёт в текущий ход");
+    if (active?.finalizing)
+        await active.finalizing;
+    if (live.has(id))
+        throw new Error("Задание ещё работает: уточнение уйдёт в текущий ход");
+    resuming.add(id);
+    let release;
+    try {
+        const initial = await readJob(id);
+        if (!initial)
+            return null;
+        if (initial.job.worktreeCleared)
+            throw new Error("Копия задания удалена или передана другому заданию");
+        if (initial.job.worktree)
+            release = holdJobWorktree(initial.job.worktree.id);
+        const found = await readJob(id);
+        if (!found)
+            return null;
+        const { job, journal } = found;
+        if (!isFinished(job.status))
+            throw new Error("Задание ещё работает: уточнение уйдёт в текущий ход");
+        if (!(await stat(job.cwd).catch(() => null))?.isDirectory())
+            throw new Error("Папка задания не найдена");
+        const previous = job.result;
+        const stored = live.get(id)?.job ?? (await loadJob(id));
+        const history = stored?.history?.length
+            ? structuredClone(stored.history)
+            : [
+                { role: "user", content: job.task },
+                { role: "assistant", content: previous.slice(0, 20_000) },
+            ];
+        if (history.at(-1)?.role === "user")
+            history.push({ role: "assistant", content: previous.slice(0, 20_000) });
+        job.history = [...history, { role: "user", content: message }];
+        job.result = "";
+        delete job.error;
+        delete job.endedAt;
+        job.pending = [];
+        job.messageId = randomUUID();
+        const entry = open(job, journal);
+        record(entry, "input", { text: message, followUp: true });
+        change(entry, "running");
+        await persist(entry);
+        void drive(entry, false, message, job.sessionId ? [] : history);
+        return publicJob(job);
+    }
+    finally {
+        release?.();
+        resuming.delete(id);
+    }
+}

package/packages/server/modules/agent/jobs-live.js

@@ -0,0 +1,180 @@
+import { pathsOfCall } from "./jobs-files.js";
+import { JOURNAL_LIMIT, saveJob, saveJournal, } from "./jobs-store.js";
+const CLIP = 4000;
+const SAVE_DELAY_MS = 400;
+/** The full answer kept with a job. */
+export const RESULT_LIMIT = 100_000;
+const TERMINAL = new Set(["done", "error", "stopped"]);
+export const isFinished = (status) => TERMINAL.has(status);
+const host = globalThis;
+export const live = (host.projectorAgentJobs ??= new Map());
+/** Big tool inputs and outputs are cut: the journal shows what happened, not every byte. */
+export function shrink(value) {
+    if (typeof value === "string")
+        return value.length > CLIP ? `${value.slice(0, CLIP)}…` : value;
+    if (value == null || typeof value !== "object")
+        return value;
+    try {
+        const text = JSON.stringify(value);
+        return text.length > CLIP ? `${text.slice(0, CLIP)}…` : value;
+    }
+    catch {
+        return "";
+    }
+}
+export function wake(entry) {
+    for (const waiter of [...entry.waiters])
+        waiter();
+}
+/** Writes the record now; the journal is written soon after, once per burst of events. */
+export async function persist(entry) {
+    await saveJob(entry.job).catch(() => { });
+}
+export function persistJournalLater(entry) {
+    if (entry.saveTimer)
+        return;
+    entry.saveTimer = setTimeout(() => {
+        entry.saveTimer = undefined;
+        void saveJournal(entry.job.id, entry.journal).catch(() => { });
+    }, SAVE_DELAY_MS);
+    entry.saveTimer.unref();
+}
+export async function flushJournal(entry) {
+    clearTimeout(entry.saveTimer);
+    entry.saveTimer = undefined;
+    await saveJournal(entry.job.id, entry.journal).catch(() => { });
+}
+export function record(entry, event, data) {
+    const at = Date.now();
+    const last = entry.journal.at(-1);
+    const text = data?.text;
+    if ((event === "text" || event === "thought") && typeof text === "string") {
+        const lastText = last?.data?.text;
+        if (last?.event === event && lastText !== undefined) {
+            last.data.text = lastText + text;
+            last.at = at;
+            persistJournalLater(entry);
+            return;
+        }
+    }
+    entry.journal.push({ at, event, data });
+    if (entry.journal.length > JOURNAL_LIMIT)
+        entry.journal.splice(0, entry.journal.length - JOURNAL_LIMIT);
+    persistJournalLater(entry);
+}
+export function change(entry, status) {
+    const { job } = entry;
+    if (job.status === status)
+        return;
+    job.status = status;
+    job.rev++;
+    record(entry, "status", { status });
+    void persist(entry);
+    wake(entry);
+}
+/** Back to `running` when nothing waits for the user any more. */
+export function settle(entry) {
+    if (entry.job.status === "needs-user" && !entry.job.pending.length)
+        change(entry, "running");
+}
+export function addPending(entry, card) {
+    entry.job.pending.push(card);
+    entry.job.rev++;
+    if (entry.job.status === "running")
+        change(entry, "needs-user");
+    else {
+        void persist(entry);
+        wake(entry);
+    }
+}
+export function dropPending(entry, id) {
+    const before = entry.job.pending.length;
+    entry.job.pending = entry.job.pending.filter((card) => card.id !== id);
+    if (entry.job.pending.length === before)
+        return;
+    entry.job.rev++;
+    void persist(entry);
+    wake(entry);
+    settle(entry);
+}
+/** Folds one event of the agent into the job: the journal, the answer, the cards that wait. */
+export function onEvent(entry, event, data) {
+    const { job } = entry;
+    const body = (data ?? {});
+    switch (event) {
+        case "text":
+            if (typeof body.text === "string")
+                entry.collected += body.text;
+            record(entry, event, { text: body.text });
+            return;
+        case "thought":
+            record(entry, event, { text: body.text });
+            return;
+        case "session": {
+            if (typeof body.id === "string")
+                job.sessionId = body.id;
+            job.rev++;
+            void persist(entry);
+            return;
+        }
+        case "tool": {
+            const name = String(body.name ?? "");
+            for (const path of pathsOfCall(name, body.input, job.cwd))
+                entry.touched.add(path);
+            record(entry, event, { ...body, input: shrink(body.input) });
+            return;
+        }
+        case "tool-result":
+            record(entry, event, { ...body, output: shrink(body.output) });
+            return;
+        case "input":
+            record(entry, event, body);
+            return;
+        case "task":
+            record(entry, event, body);
+            return;
+        case "permission-request": {
+            const id = String(body.id ?? "");
+            record(entry, event, { ...body, input: shrink(body.input) });
+            addPending(entry, {
+                id,
+                kind: "permission",
+                tool: String(body.tool ?? ""),
+                title: String(body.title || body.tool || "Разрешение"),
+                detail: typeof body.detail === "string" ? body.detail : undefined,
+                persistent: body.persistent === true,
+            });
+            return;
+        }
+        case "question-request": {
+            const id = String(body.id ?? "");
+            const questions = Array.isArray(body.questions) ? body.questions : [];
+            record(entry, event, body);
+            addPending(entry, {
+                id,
+                kind: "question",
+                title: typeof body.title === "string" && body.title ? body.title : "Вопрос агента",
+                questions: questions.map((item) => ({
+                    id: item.id,
+                    question: item.question,
+                    header: item.header,
+                    options: item.options ?? [],
+                    multiple: item.multiple === true,
+                    custom: item.custom,
+                    optional: item.optional,
+                })),
+                custom: body.custom === true,
+            });
+            return;
+        }
+        case "done":
+            if (typeof body.text === "string" && body.text)
+                entry.final = body.text;
+            return;
+        case "error":
+            entry.failure = String(body.error ?? "Ошибка агента");
+            return;
+        default:
+            return;
+    }
+}

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

@@ -0,0 +1,59 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+/** The replay history is server-only: API polls carry the current result instead. */
+export function publicJob(job) {
+    const copy = structuredClone(job);
+    delete copy.history;
+    return copy;
+}
+export const JOB_ID = /^[0-9a-f]{12}$/;
+/** Finished jobs are kept this long. */
+export const JOB_RETAIN_MS = 14 * 24 * 60 * 60 * 1000;
+export const JOURNAL_LIMIT = 1500;
+const jobsRoot = () => join(dataDir(), "agent", "jobs");
+/** The directory of a job; the identifier comes from a client, so its shape is checked. */
+export function jobDirectory(id) {
+    if (!JOB_ID.test(id))
+        throw new Error("Некорректный идентификатор задания");
+    return join(jobsRoot(), id);
+}
+export const newJobId = () => randomBytes(6).toString("hex");
+async function writeAtomic(file, data) {
+    const temporary = `${file}.${randomBytes(3).toString("hex")}.tmp`;
+    await writeFile(temporary, JSON.stringify(data), { mode: 0o600 });
+    await rename(temporary, file);
+}
+export async function saveJob(job) {
+    const dir = jobDirectory(job.id);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeAtomic(join(dir, "job.json"), job);
+}
+export async function saveJournal(id, journal) {
+    const dir = jobDirectory(id);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeAtomic(join(dir, "journal.json"), journal);
+}
+export async function loadJob(id) {
+    try {
+        return JSON.parse(await readFile(join(jobDirectory(id), "job.json"), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function loadJournal(id) {
+    try {
+        return JSON.parse(await readFile(join(jobDirectory(id), "journal.json"), "utf8"));
+    }
+    catch {
+        return [];
+    }
+}
+export async function jobIds() {
+    return (await readdir(jobsRoot()).catch(() => [])).filter((id) => JOB_ID.test(id));
+}
+export async function removeJobFiles(id) {
+    await rm(jobDirectory(id), { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+}

package/packages/server/modules/agent/jobs-worktree.js

@@ -0,0 +1,161 @@
+import { isFinished, live, persist, wake } from "./jobs-live.js";
+import { jobIds, loadJob, publicJob, saveJob } from "./jobs-store.js";
+import { readJob, startJob } from "./jobs.js";
+import { loadProjects } from "../projects/index.js";
+import { forkWorktree, mergeWorktree, removeWorktree } from "./worktrees.js";
+/** Copy mutations are exclusive across retry, fork, follow-up, merge and discard. */
+const host = globalThis;
+const copies = (host.projectorJobCopies ??= new Set());
+export function holdJobWorktree(id) {
+    if (copies.has(id))
+        throw new Error("Копия уже занята другим заданием");
+    copies.add(id);
+    return () => copies.delete(id);
+}
+async function assertCopyFree(id, owner) {
+    const jobs = await Promise.all((await jobIds()).map(async (item) => live.get(item)?.job ?? (await loadJob(item))));
+    if (jobs.some((job) => job && job.id !== owner && !isFinished(job.status) && job.worktree?.id === id))
+        throw new Error("Копия уже занята другим заданием");
+}
+function finishedCopy(job) {
+    if (!isFinished(job.status))
+        throw new Error("Дождитесь завершения задания");
+    if (!job.worktree)
+        throw new Error("Задание работает без копии");
+    return job.worktree;
+}
+/** Forgets the copy without making its old record read or resume another folder. */
+export async function clearJobWorktree(id) {
+    const settled = (job) => {
+        if (!isFinished(job.status))
+            throw new Error("Дождитесь завершения задания");
+        if (job.worktree) {
+            delete job.worktree;
+            job.worktreeCleared = true;
+            delete job.sessionId;
+            delete job.base;
+            delete job.dirty;
+            job.rev++;
+        }
+        return job;
+    };
+    const entry = live.get(id);
+    if (entry) {
+        const job = settled(entry.job);
+        await persist(entry);
+        wake(entry);
+        return publicJob(job);
+    }
+    const job = await loadJob(id);
+    if (!job)
+        return null;
+    settled(job);
+    await saveJob(job);
+    return publicJob(job);
+}
+/** Starts a second job in a new copy that begins from what this job's copy has now. */
+export async function forkJob(id, task) {
+    const initial = await readJob(id);
+    if (!initial)
+        return null;
+    const worktree = finishedCopy(initial.job);
+    const release = holdJobWorktree(worktree.id);
+    try {
+        const found = await readJob(id);
+        if (!found)
+            return null;
+        const { job } = found;
+        finishedCopy(job);
+        await assertCopyFree(worktree.id, id);
+        const project = (await loadProjects()).find((item) => item.id === job.projectId);
+        if (!project)
+            throw new Error("Проект не найден");
+        const copy = await forkWorktree(project.id, project.path, job.cwd);
+        return await startJob({
+            backend: job.backend,
+            task: task?.trim() || job.task,
+            projectId: job.projectId,
+            cwd: copy.cwd,
+            worktree: { id: copy.id, branch: copy.branch },
+            origin: job.origin,
+            role: job.role,
+            selection: job.selection,
+            permissionMode: job.permissionMode,
+            unattended: job.unattended,
+        });
+    }
+    finally {
+        release();
+    }
+}
+/** Starts the same task again after a failure: the same folder, copy and native session. */
+export async function retryJob(id, task, append = false) {
+    const initial = await readJob(id);
+    if (!initial)
+        return null;
+    if (initial.job.worktreeCleared)
+        throw new Error("Копия задания удалена или передана другому заданию");
+    if (!isFinished(initial.job.status))
+        throw new Error("Задание ещё работает");
+    const worktree = initial.job.worktree;
+    const release = worktree ? holdJobWorktree(worktree.id) : undefined;
+    try {
+        const found = await readJob(id);
+        if (!found)
+            return null;
+        const { job } = found;
+        if (job.worktreeCleared || !isFinished(job.status))
+            throw new Error("Задание ещё работает или его копия уже передана");
+        const text = task?.trim();
+        // A follow-up keeps the original goal; a retry with new words replaces it.
+        const nextTask = text ? (append ? `${job.task}\n\n${text}` : text) : job.task;
+        if (worktree)
+            await assertCopyFree(worktree.id, id);
+        const next = await startJob({
+            backend: job.backend,
+            task: nextTask,
+            projectId: job.projectId,
+            cwd: job.cwd,
+            worktree,
+            origin: job.origin,
+            sessionId: job.sessionId,
+            role: job.role,
+            selection: job.selection,
+            permissionMode: job.permissionMode,
+            unattended: job.unattended,
+        });
+        // The copy belongs to the new run now: the old record must not offer merge/discard on it.
+        if (worktree)
+            await clearJobWorktree(id);
+        return next;
+    }
+    finally {
+        release?.();
+    }
+}
+/** Merges or discards a copy only while no other job owns or is transferring it. */
+export async function settleJobWorktree(id, action) {
+    const initial = await readJob(id);
+    if (!initial)
+        return null;
+    const worktree = finishedCopy(initial.job);
+    const release = holdJobWorktree(worktree.id);
+    try {
+        const found = await readJob(id);
+        if (!found)
+            return null;
+        const { job } = found;
+        finishedCopy(job);
+        await assertCopyFree(worktree.id, id);
+        const project = (await loadProjects()).find((item) => item.id === job.projectId);
+        if (!project)
+            throw new Error("Проект не найден");
+        const result = action === "merge"
+            ? await mergeWorktree(project.id, worktree.id, project.path)
+            : (await removeWorktree(project.id, worktree.id, project.path), { discarded: true });
+        return { ...result, job: await clearJobWorktree(id) };
+    }
+    finally {
+        release();
+    }
+}