@kenkaiiii/ggcoder 5.4.2 → 5.5.0

package/dist/app-sidecar.js

@@ -20,8 +20,9 @@ import { parseArgs } from "node:util";
 import { formatError } from "@kenkaiiii/gg-ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { AgentSession } from "./core/agent-session.js";
-import { buildKenSystemPrompt } from "./core/ken-prompt.js";
-import { buildKenDigest } from "./core/ken-context.js";
+import { buildKenSystemPrompt, buildKenAutopilotSystemPrompt } from "./core/ken-prompt.js";
+import { buildKenDigest, buildKenAutopilotContext } from "./core/ken-context.js";
+import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
 import { collectProjectContext } from "./system-prompt.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { MOONSHOT_OAUTH_KEY, XIAOMI_CREDITS_KEY } from "@kenkaiiii/gg-core";
@@ -39,7 +40,7 @@ import { getNextThinkingLevel, getSupportedThinkingLevels, isThinkingLevelSuppor
 import { PROMPT_COMMANDS } from "./core/prompt-commands.js";
 import { loadCustomCommands } from "./core/custom-commands.js";
 import { discoverProjects, listRecentSessions } from "./core/project-discovery.js";
-import { loadTasksSync, saveTasksSync, getNextPendingTask, markTaskInProgress, } from "./core/tasks-store.js";
+import { loadTasksSync, saveTasksSync, pruneDoneTasksSync, getNextPendingTask, markTaskInProgress, } from "./core/tasks-store.js";
 import { initLogger, log } from "./core/logger.js";
 import { RADIO_STATIONS, getCurrentStation, playRadio, stopRadio } from "./core/radio.js";
 import { enrichProcessPath } from "./core/shell-path.js";
@@ -80,6 +81,7 @@ async function loadAppSettings() {
             // Preserve the per-project map verbatim (validated + written by the
             // model/thinking handlers below).
             projectModels: raw.projectModels && typeof raw.projectModels === "object" ? raw.projectModels : undefined,
+            autopilot: raw.autopilot && typeof raw.autopilot === "object" ? raw.autopilot : undefined,
         };
     }
     catch {
@@ -103,6 +105,19 @@ async function saveProjectModelPrefs(cwd, prefs) {
     s.projectModels = { ...(s.projectModels ?? {}), [key]: prefs };
     await saveAppSettings(s);
 }
+/** Read this project's persisted autopilot flag (default off). */
+async function loadAutopilot(cwd) {
+    const s = await loadAppSettings();
+    return s.autopilot?.[projectModelKey(cwd)] ?? false;
+}
+/** Persist this project's autopilot flag via read-modify-write so the rest of
+ *  the settings file (projectsRoot, model map, other projects) is preserved. */
+async function saveAutopilot(cwd, enabled) {
+    const s = await loadAppSettings();
+    const key = projectModelKey(cwd);
+    s.autopilot = { ...(s.autopilot ?? {}), [key]: enabled };
+    await saveAppSettings(s);
+}
 /**
  * Persist the active model selection to ~/.gg/settings.json so it survives app
  * restarts. Mirrors the CLI's handleModelSelect persistence (App.tsx).
@@ -759,6 +774,24 @@ async function createSession(deps, opts) {
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
     let running = false;
     let titleGenerated = false;
+    // Autopilot (auto-review) toggle for THIS window's project. Loaded from
+    // gg-app.json on boot; flipped via POST /autopilot. When on, POST /prompt runs
+    // runAutopilotCycle after the user's turn settles — Ken auto-reviews the work
+    // and drives the review→prompt→review loop.
+    let autopilot = await loadAutopilot(cwd);
+    // True while an autopilot review is in flight (used to defer kenAuto model
+    // switches, like kenRunning does for chat Ken, and to drive the spinner).
+    let autopilotReviewing = false;
+    // True for the WHOLE autopilot cycle (reviews + injected runs). The build
+    // `running` flag is false during the review windows between injected runs, so
+    // this is the extra guard that makes a user /prompt queue as steering instead
+    // of starting a run that would collide with an injected one on the same
+    // session (AgentSession.prompt has no concurrency guard).
+    let autopilotActive = false;
+    // Set by /cancel to break out of an in-flight autopilot cycle between steps.
+    let autopilotCancelled = false;
+    // Hard cap on review→prompt→review rounds per user turn (loop safety).
+    const MAX_AUTOPILOT_ROUNDS = 3;
     // ── Telegram serve (remote control via Telegram) ───────────
     // A single embedded serve session lives in this sidecar process. Only the main
     // window's home screen exposes the controls, so there's one bot per app.
@@ -827,6 +860,53 @@ async function createSession(deps, opts) {
         log("INFO", "app-sidecar", "ken session ready", { provider: st.provider, model: st.model });
         return ken;
     }
+    // ── Autopilot Ken (auto-reviewer) ──────────────────────────
+    // A THIRD read-only AgentSession, separate from chat Ken. In autopilot mode
+    // Ken silently reviews each finished GG Coder turn and returns a verdict
+    // (PROMPT / ALL_CLEAR / HUMAN). Its bus is intentionally NOT bridged to the
+    // ken_* chat bubbles — the review is silent; we read its final assistant text
+    // and parse it. Uses the lean autopilot system prompt + the same read-only
+    // tools. Created lazily on the first autopilot cycle.
+    let kenAutoSession = null;
+    let kenAutoAbort = new AbortController();
+    let pendingKenAutoModel = null;
+    async function syncKenAutoModel(provider, model) {
+        if (autopilotReviewing) {
+            pendingKenAutoModel = { provider, model };
+            return;
+        }
+        if (!kenAutoSession)
+            return;
+        const st = kenAutoSession.getState();
+        if (st.provider === provider && st.model === model)
+            return;
+        await kenAutoSession.switchModel(provider, model);
+        log("INFO", "app-sidecar", "ken autopilot session model synced", { provider, model });
+    }
+    async function ensureKenAutoSession() {
+        if (kenAutoSession)
+            return kenAutoSession;
+        const st = session.getState();
+        const ken = new AgentSession({
+            provider: st.provider,
+            model: st.model,
+            cwd,
+            systemPrompt: buildKenAutopilotSystemPrompt(),
+            allowedTools: KEN_ALLOWED_TOOLS,
+            allowedMcpServers: KEN_ALLOWED_MCP_SERVERS,
+            transient: true,
+            signal: kenAutoAbort.signal,
+        });
+        await ken.initialize();
+        // Deliberately no bus bridge: the review is silent. Errors surface via the
+        // runAutopilotReview try/catch as autopilot_error frames.
+        kenAutoSession = ken;
+        log("INFO", "app-sidecar", "ken autopilot session ready", {
+            provider: st.provider,
+            model: st.model,
+        });
+        return ken;
+    }
     // Resumed session: if it already has a conversation, generate its title now so
     // the title bar shows it immediately on load (not just after the next prompt).
     {
@@ -861,6 +941,14 @@ async function createSession(deps, opts) {
             gitBranch = await getGitBranch(cwd).catch(() => gitBranch);
             gitIsRepo = await isGitRepo(cwd).catch(() => gitIsRepo);
             broadcast("run_end", {});
+            // Autopilot's review loop is driven explicitly from POST /prompt (see
+            // runAutopilotCycle), NOT from this shared finally — that keeps the
+            // injected GG Coder runs this cycle triggers from recursively re-entering
+            // the loop through the same bracket.
+            // The agent may have marked project tasks done during the run — prune the
+            // completed ones so they drop out of the Tasks modal automatically (users
+            // never have to delete finished tasks by hand).
+            broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
             // Queue drains into the run as steering, so it's empty by run_end —
             // sync the webview indicator.
             broadcast("queued", { count: session.getQueuedCount() });
@@ -876,6 +964,79 @@ async function createSession(deps, opts) {
             }
         }
     }
+    // ── Autopilot orchestration ─────────────────────────────────
+    // One review = prompt the kenAuto session with the review digest, read its
+    // final assistant text, parse a verdict. Returns null on failure (surfaced as
+    // an autopilot_error frame) so the cycle stops rather than looping blind.
+    async function runAutopilotReview() {
+        autopilotReviewing = true;
+        broadcast("autopilot_review_start", {});
+        try {
+            const ken = await ensureKenAutoSession();
+            const projectContext = await collectProjectContext(cwd).catch(() => []);
+            const digest = buildKenAutopilotContext({
+                projectContext,
+                cwd,
+                gitBranch,
+                messages: session.getMessages(),
+            });
+            await ken.prompt(digest);
+            return parseAutopilotVerdict(lastAssistantText(ken.getMessages()));
+        }
+        catch (err) {
+            broadcastError("autopilot_error", "autopilot review failed", err);
+            return null;
+        }
+        finally {
+            autopilotReviewing = false;
+            // Apply any model switch that landed mid-review.
+            const pending = pendingKenAutoModel;
+            pendingKenAutoModel = null;
+            if (pending)
+                await syncKenAutoModel(pending.provider, pending.model);
+        }
+    }
+    // Drive the review→prompt→review loop for one finished user turn. Only ever
+    // called from POST /prompt after the user's own run resolves — never from the
+    // task runner, resume, /ken, or error paths, so there's no recursion and no
+    // guard tangle. Bounded by MAX_AUTOPILOT_ROUNDS and cancellable between steps.
+    async function runAutopilotCycle() {
+        if (!autopilot || autopilotCancelled)
+            return;
+        autopilotActive = true;
+        try {
+            // Lean context per user turn: wipe prior review history so each new turn
+            // starts cheap, while within this cycle the few review messages persist so
+            // Ken remembers what he already asked GG Coder to fix.
+            await kenAutoSession?.newSession().catch(() => { });
+            for (let round = 1; round <= MAX_AUTOPILOT_ROUNDS; round++) {
+                if (autopilotCancelled)
+                    return;
+                const verdict = await runAutopilotReview();
+                if (!verdict || autopilotCancelled)
+                    return;
+                if (verdict.kind === "all_clear") {
+                    broadcast("autopilot_done", {});
+                    return;
+                }
+                if (verdict.kind === "human") {
+                    broadcast("autopilot_human", { reason: verdict.reason });
+                    return;
+                }
+                // prompt → show a compact Ken-tinted marker (not the prompt body), then
+                // feed GG Coder. Bracketed by runAgent so the run streams normally; the
+                // shared finally no longer re-triggers autopilot, so this can't recurse.
+                broadcast("autopilot_prompted", { round, body: verdict.body });
+                await runAgent(verdict.body, () => session.prompt(verdict.body));
+                if (autopilotCancelled)
+                    return;
+            }
+            broadcast("autopilot_capped", { rounds: MAX_AUTOPILOT_ROUNDS });
+        }
+        finally {
+            autopilotActive = false;
+        }
+    }
     // ── Task runner (project task list → sessions) ──────────────
     // Mirrors the CLI's task flow: each task runs in its OWN fresh session, with a
     // completion hint instructing the agent to mark the task done via the tasks
@@ -897,8 +1058,8 @@ async function createSession(deps, opts) {
             `tasks({ action: "done", id: "${shortId}" })`;
         await runAgent(task.title, () => session.prompt(task.prompt + completionHint));
         // The agent typically marks the task done via the tasks tool during the run;
-        // push the refreshed list so the webview's task modal reflects it.
-        broadcast("tasks_list", { tasks: loadTasksSync(cwd) });
+        // prune completed tasks and push the refreshed list so the modal drops them.
+        broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
         return true;
     }
     async function runTasks(startId, all) {
@@ -993,6 +1154,7 @@ async function createSession(deps, opts) {
                 thinkingLevel: session.getThinkingLevel() ?? null,
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                 supportsVideo: getModel(st.model)?.supportsVideo ?? false,
+                autopilot,
                 ...footerExtras(),
             });
             return;
@@ -1016,6 +1178,7 @@ async function createSession(deps, opts) {
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                     supportsVideo: getModel(st.model)?.supportsVideo ?? false,
+                    autopilot,
                     ...footerExtras(),
                 },
             })}\n\n`);
@@ -1339,10 +1502,13 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "empty prompt" });
                     return;
                 }
-                if (running) {
-                    // Queue prompts as mid-run steering (mirrors the CLI). Attachments are
-                    // persisted to .gg/uploads first so the queued media rides the same
-                    // native-block path as a non-queued attachment prompt when it drains.
+                if (running || autopilotActive) {
+                    // Queue prompts as mid-run steering (mirrors the CLI). Also queue while
+                    // an autopilot cycle is active but between injected runs (build idle,
+                    // Ken reviewing) so the message never starts a run that collides with
+                    // an injected one on the same session. Attachments are persisted to
+                    // .gg/uploads first so the queued media rides the same native-block
+                    // path as a non-queued attachment prompt when it drains.
                     const prepared = attachments.length > 0 ? await prepareAttachments(cwd, attachments) : [];
                     const count = session.queueMessage(text, prepared);
                     broadcast("queued", { count });
@@ -1350,6 +1516,9 @@ async function createSession(deps, opts) {
                     return;
                 }
                 json(res, 202, { accepted: true });
+                // Fresh user turn: clear any cancel flag left from a prior cycle so this
+                // turn's autopilot review can run.
+                autopilotCancelled = false;
                 await runAgent(text, async () => {
                     if (attachments.length > 0) {
                         // Persist each attachment under .gg/uploads so files are inspectable
@@ -1365,6 +1534,11 @@ async function createSession(deps, opts) {
                         await session.prompt(text);
                     }
                 });
+                // After the user's run settles, kick off Ken's auto-review loop. This is
+                // the ONLY entry point into the cycle — it drives any follow-up GG Coder
+                // runs itself, so the shared runAgent finally never recurses.
+                if (autopilot && !autopilotCancelled)
+                    await runAutopilotCycle();
             });
             return;
         }
@@ -1427,6 +1601,24 @@ async function createSession(deps, opts) {
             json(res, 200, { cancelled: true });
             return;
         }
+        if (method === "POST" && url === "/autopilot") {
+            void readBody(req).then(async (raw) => {
+                let enabled;
+                try {
+                    enabled = Boolean(JSON.parse(raw).enabled);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                autopilot = enabled;
+                await saveAutopilot(cwd, enabled);
+                log("INFO", "app-sidecar", "autopilot toggled", { enabled: String(enabled) });
+                broadcast("autopilot", { autopilot: enabled });
+                json(res, 200, { autopilot: enabled });
+            });
+            return;
+        }
         if (method === "POST" && url === "/enhance") {
             void readBody(req).then(async (raw) => {
                 let text;
@@ -1456,7 +1648,7 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "GET" && url === "/tasks") {
-            json(res, 200, { tasks: loadTasksSync(cwd) });
+            json(res, 200, { tasks: pruneDoneTasksSync(cwd) });
             return;
         }
         // ── Radio (app-wide) ──────────────────────────────────────
@@ -1576,6 +1768,7 @@ async function createSession(deps, opts) {
                 }
                 await session.switchModel(target.provider, target.id);
                 await syncKenModel(target.provider, target.id);
+                await syncKenAutoModel(target.provider, target.id);
                 // Clamp the reasoning level to what the new model supports (mirrors the
                 // CLI): keep thinking on at the first supported tier if it was on but
                 // the prior level is unsupported here; leave it off if it was off.
@@ -1657,6 +1850,13 @@ async function createSession(deps, opts) {
             running = false;
             // Stop a run-all sweep so the next pending task isn't auto-started.
             taskRunAll = false;
+            // Stop any in-flight autopilot cycle: flag it so the loop bails between
+            // steps, and abort a review that's mid-prompt on the kenAuto session.
+            autopilotCancelled = true;
+            kenAutoAbort.abort();
+            kenAutoAbort = new AbortController();
+            kenAutoSession?.setSignal(kenAutoAbort.signal);
+            autopilotReviewing = false;
             // Drop any queued steering and return it so the webview can restore it to
             // the composer.
             const drained = session.drainQueue();
@@ -2143,7 +2343,9 @@ async function createSession(deps, opts) {
         for (const c of clients)
             c.res.end();
         kenAbort.abort();
+        kenAutoAbort.abort();
         await kenSession?.dispose().catch(() => { });
+        await kenAutoSession?.dispose().catch(() => { });
         await session.dispose().catch(() => { });
     }
     return {