@kenkaiiii/ggcoder 5.13.3 → 5.14.0

package/dist/app-sidecar.js

@@ -22,6 +22,8 @@ import { formatError } from "@kenkaiiii/gg-ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
 import { AgentSession } from "./core/agent-session.js";
+import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, sessionsDirForChatAgent, } from "./chat-agents/index.js";
+import { buildMemoryTools, MemoryStore } from "./chat-agents/memory.js";
 import { buildKenSystemPrompt, buildKenAutopilotSystemPrompt } from "./core/ken-prompt.js";
 import { buildKenDigest, buildKenAutopilotContext, buildKenAutopilotPlanContext, } from "./core/ken-context.js";
 import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
@@ -508,6 +510,13 @@ async function main() {
     // request to its window's session via the `x-gg-session` header (and the
     // `?session=` query for the SSE /events stream).
     const sessions = new Map();
+    const memoryStore = new MemoryStore({
+        onChange: ({ memories }) => {
+            for (const ctx of sessions.values()) {
+                ctx.broadcast("memory_change", { count: memories.length });
+            }
+        },
+    });
     // XP/rank progress — loaded once per daemon; awards fan out to every window.
     // Each frame is tagged `origin: true` only for the session that earned the
     // XP, so that window alone plays sounds/chips while the rest just re-render.
@@ -606,7 +615,7 @@ async function main() {
             return;
         }
         // ── Daemon-level routes (session lifecycle) ──────────────────────────
-        // Create a session for a window: { cwd, sessionPath? } → { sessionId }.
+        // Create a session for a window: { mode?, cwd, sessionPath? } → { sessionId }.
         if (method === "POST" && url === "/session") {
             void daemonReadBody(req).then(async (raw) => {
                 let body = {};
@@ -616,15 +625,22 @@ async function main() {
                 catch {
                     /* empty/invalid body → defaults below */
                 }
+                const mode = body.mode === "chat" ? "chat" : "code";
+                const chatAgent = parseChatAgentId(body.chatAgent);
                 const sessionCwd = typeof body.cwd === "string" && body.cwd
                     ? body.cwd
                     : (process.env.GG_APP_CWD ?? process.cwd());
                 const sessionPath = typeof body.sessionPath === "string" && body.sessionPath ? body.sessionPath : undefined;
                 const id = randomUUID();
                 try {
-                    const ctx = await createSession({ auth, paths, progress }, { id, cwd: sessionCwd, sessionPath });
+                    const ctx = await createSession({ auth, paths, progress, memoryStore }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
                     sessions.set(id, ctx);
-                    log("INFO", "app-sidecar", "session created", { id, cwd: sessionCwd });
+                    log("INFO", "app-sidecar", "session created", {
+                        id,
+                        mode,
+                        chatAgent,
+                        cwd: sessionCwd,
+                    });
                     daemonJson(res, 200, { sessionId: id });
                 }
                 catch (err) {
@@ -775,8 +791,14 @@ function buildKenContext(buildSession, cwd, gitBranch, question, workflowCommand
     });
 }
 async function createProgressManager(agentDir, broadcastAll) {
-    // Boot: recovery chain main → backup → one-time session-history rebuild → empty.
-    let file = await loadProgress({ rebuild: () => rebuildFromSessions() });
+    // Boot: recovery chain main → backup → coding + chat session rebuild → empty.
+    const coderSessionsDir = path.join(agentDir, "sessions");
+    let file = await loadProgress({
+        rebuild: () => rebuildFromSessions([
+            coderSessionsDir,
+            ...CHAT_AGENT_IDS.map((agentId) => chatAgentSessionsDir(coderSessionsDir, agentId)),
+        ]),
+    });
     // Don't re-celebrate an old levelUp event on boot.
     let lastSeenNonce = file.lastEvent?.nonce ?? null;
     log("INFO", "app-sidecar", "progress loaded", {
@@ -864,8 +886,10 @@ async function createProgressManager(agentDir, broadcastAll) {
  * logger, PATH, shared auth file, and radio live at the daemon level.
  */
 async function createSession(deps, opts) {
-    const { auth, progress } = deps;
+    const { auth, progress, memoryStore } = deps;
     const paths = deps.paths;
+    const mode = opts.mode;
+    const chatAgent = opts.chatAgent;
     const cwd = opts.cwd;
     // Base host for parsing request-URL query params (value is irrelevant to
     // parsing); the daemon owns the real listen host.
@@ -968,51 +992,51 @@ async function createSession(deps, opts) {
     // empty/unset starts a fresh session.
     const resumeSessionPath = opts.sessionPath;
     let abort = new AbortController();
-    const session = new AgentSession({
+    const baseSessionOptions = {
         provider,
         model,
         cwd,
         thinkingLevel,
         sessionId: resumeSessionPath,
         signal: abort.signal,
-        // The shell gates window readiness on the GG_APP_LISTENING handshake, which
-        // can't fire until initialize() resolves. Connect MCP in the background so a
-        // slow or hanging stdio server (e.g. a first-run `npx -y @playwright/mcp`
-        // download) can't delay the sidecar past the webview's startup timeout
-        // ("sidecar did not start in time"). Tools attach when the servers come up.
+        // Keep MCP startup off the readiness path in both modes.
         backgroundMcpConnect: true,
-        // Plan mode: the agent's enter_plan/exit_plan tools drive these. We flip
-        // session plan state (rebuilds the system prompt + enforces read-only
-        // tools) and surface the transition to the webview.
-        onEnterPlan: async (reason) => {
-            await session.setPlanMode(true);
-            broadcast("plan_enter", { reason: reason ?? "" });
-            // Persist the plan-mode banner so a resumed session still shows it.
-            void session.persistAppMarker("plan", { reason: reason ?? "" }).catch(() => { });
-        },
-        onExitPlan: async (planPath) => {
-            await session.setPlanMode(false);
-            // Surface the plan's path + markdown so the webview can show the review
-            // modal (Accept / Feedback / Reject). Best-effort content read.
-            let content;
-            try {
-                content = await fs.readFile(planPath, "utf-8");
-            }
-            catch {
-                content = "";
-            }
-            // Record the submitted plan so the autopilot gate can route this turn
-            // into a PLAN review instead of a stale work review (plan mode is
-            // already false here, so the gate's planMode check alone never catches
-            // a submission). setPendingPlan bumps planGeneration, which invalidates
-            // any in-flight Ken plan review racing a user action.
-            setPendingPlan(planPath, content);
-            broadcast("plan_exit", { planPath, content });
-            return "Plan submitted for user review. Wait for the user to approve, reject, or dismiss it before implementing.";
-        },
-    });
+    };
+    let session;
+    if (mode === "chat") {
+        session = createChatAgent(chatAgent, {
+            ...baseSessionOptions,
+            sessionsDir: paths.sessionsDir,
+            additionalTools: buildMemoryTools(memoryStore),
+            getSystemPromptTail: () => memoryStore.renderForPrompt(),
+        });
+    }
+    else {
+        session = new AgentSession({
+            ...baseSessionOptions,
+            // Plan mode belongs only to the coding agent.
+            onEnterPlan: async (reason) => {
+                await session.setPlanMode(true);
+                broadcast("plan_enter", { reason: reason ?? "" });
+                void session.persistAppMarker("plan", { reason: reason ?? "" }).catch(() => { });
+            },
+            onExitPlan: async (planPath) => {
+                await session.setPlanMode(false);
+                let content;
+                try {
+                    content = await fs.readFile(planPath, "utf-8");
+                }
+                catch {
+                    content = "";
+                }
+                setPendingPlan(planPath, content);
+                broadcast("plan_exit", { planPath, content });
+                return "Plan submitted for user review. Wait for the user to approve, reject, or dismiss it before implementing.";
+            },
+        });
+    }
     await session.initialize();
-    log("INFO", "app-sidecar", "session ready", { provider, model, cwd });
+    log("INFO", "app-sidecar", "session ready", { provider, model, mode, chatAgent, cwd });
     // Footer extras (context window, git branch, background tasks). The git
     // branch is resolved once at startup and refreshed lazily; the context
     // window follows the active model.
@@ -1081,7 +1105,7 @@ async function createSession(deps, opts) {
     // 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);
+    let autopilot = mode === "code" && (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;
@@ -1758,6 +1782,8 @@ async function createSession(deps, opts) {
             const st = session.getState();
             json(res, 200, {
                 ...st,
+                mode,
+                chatAgent,
                 running,
                 ready: true,
                 thinkingLevel: session.getThinkingLevel() ?? null,
@@ -1773,6 +1799,26 @@ async function createSession(deps, opts) {
             json(res, 200, progress.snapshot());
             return;
         }
+        if (method === "GET" && url === "/memories") {
+            void memoryStore
+                .snapshot()
+                .then((snapshot) => json(res, 200, snapshot))
+                .catch((error) => json(res, 500, { error: error instanceof Error ? error.message : String(error) }));
+            return;
+        }
+        if (method === "DELETE" && url.startsWith("/memories/")) {
+            const id = decodeURIComponent(url.slice("/memories/".length));
+            if (!id) {
+                json(res, 400, { error: "memory id is required" });
+                return;
+            }
+            void memoryStore
+                .forget(id)
+                .then(() => memoryStore.snapshot())
+                .then((snapshot) => json(res, 200, snapshot))
+                .catch((error) => json(res, 500, { error: error instanceof Error ? error.message : String(error) }));
+            return;
+        }
         if (method === "GET" && (url === "/events" || url.startsWith("/events?"))) {
             res.writeHead(200, {
                 "content-type": "text/event-stream",
@@ -1788,6 +1834,8 @@ async function createSession(deps, opts) {
                 type: "ready",
                 data: {
                     ...st,
+                    mode,
+                    chatAgent,
                     running,
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
@@ -1903,7 +1951,11 @@ async function createSession(deps, opts) {
                 json(res, 400, { error: "missing cwd query param" });
                 return;
             }
-            void listRecentSessions(target, 5)
+            const requestedAgent = new URL(url, `http://${host}`).searchParams.get("chatAgent");
+            const sessionsDir = mode === "chat" || requestedAgent
+                ? sessionsDirForChatAgent(paths.sessionsDir, requestedAgent ?? chatAgent)
+                : paths.sessionsDir;
+            void listRecentSessions(target, 5, sessionsDir)
                 .then((sessions) => json(res, 200, { sessions }))
                 .catch(() => json(res, 200, { sessions: [] }));
             return;
@@ -2210,9 +2262,12 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "GET" && url === "/commands") {
+            if (mode === "chat") {
+                json(res, 200, { commands: [] });
+                return;
+            }
             // Workflow commands with agent functionality: built-in prompt templates +
-            // the user's own `.gg/commands/*.md`. UI commands (model/quit/etc.) are
-            // handled webview-side and intentionally excluded.
+            // the user's own `.gg/commands/*.md`.
             void (async () => {
                 const builtins = PROMPT_COMMANDS.map((c) => ({
                     name: c.name,
@@ -2350,6 +2405,10 @@ async function createSession(deps, opts) {
         // webview keeps the bubbles separate. The context digest is assembled fresh
         // from the BUILD session's transcript each turn (one-way mirror).
         if (method === "POST" && url === "/ken/prompt") {
+            if (mode === "chat") {
+                json(res, 404, { error: "Ken is not available in GG Chat." });
+                return;
+            }
             void readBody(req).then(async (raw) => {
                 let text;
                 try {
@@ -2405,6 +2464,10 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "POST" && url === "/autopilot") {
+            if (mode === "chat") {
+                json(res, 404, { error: "Autopilot is not available in GG Chat." });
+                return;
+            }
             void readBody(req).then(async (raw) => {
                 let enabled;
                 try {
@@ -3260,6 +3323,8 @@ async function createSession(deps, opts) {
     }
     return {
         id: opts.id,
+        mode,
+        chatAgent,
         cwd,
         sessionPath: opts.sessionPath,
         session,