@prestyj/cli 5.0.1 → 5.1.1

package/dist/app-sidecar.js

@@ -19,6 +19,9 @@ import { randomUUID } from "node:crypto";
 import { parseArgs } from "node:util";
 import { runJsonMode } from "./modes/json-mode.js";
 import { AgentSession } from "./core/agent-session.js";
+import { buildNolanSystemPrompt } from "./core/nolan-prompt.js";
+import { buildNolanDigest } from "./core/nolan-context.js";
+import { collectProjectContext } from "./system-prompt.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { MOONSHOT_OAUTH_KEY } from "@prestyj/core";
 import { loginAnthropic } from "./core/oauth/anthropic.js";
@@ -537,6 +540,53 @@ async function main() {
     process.on("SIGINT", () => void shutdown());
     process.on("SIGTERM", () => void shutdown());
 }
+/** Nolan's read-only tool allow-list. Excludes every mutating tool (write/edit/
+ *  bash/tasks/subagent/generate_image/enter_plan/exit_plan/task_*) so the mentor
+ *  agent can research + see, but never change the repo. */
+const NOLAN_ALLOWED_TOOLS = [
+    "read",
+    "grep",
+    "find",
+    "ls",
+    "source_path",
+    "web_fetch",
+    "web_search",
+    "screenshot",
+];
+/** MCP servers Nolan is allowed to use. kencode-search lets him look into real
+ *  public repos / verify against actual code instead of assuming — core to how
+ *  he's meant to work. Read-only research; no other MCP server is connected. */
+const NOLAN_ALLOWED_MCP_SERVERS = ["kencode-search"];
+/** Extract the plain text of the most recent assistant message (Nolan's reply).
+ *  Strips tool-call / image blocks, returning just the prose Nolan streamed. */
+function lastAssistantText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== "assistant")
+            continue;
+        if (typeof m.content === "string")
+            return m.content;
+        return m.content
+            .map((c) => (c.type === "text" && "text" in c && typeof c.text === "string" ? c.text : ""))
+            .join("");
+    }
+    return "";
+}
+/**
+ * Assemble Nolan's context digest for one `@Nolan` question: project docs (up the
+ * tree) + git/env + the build session's compaction summary + recent activity.
+ * Prepended to the user's question as Nolan's prompt body each turn.
+ */
+async function buildNolanContext(buildSession, cwd, gitBranch, question) {
+    const projectContext = await collectProjectContext(cwd).catch(() => []);
+    return buildNolanDigest({
+        question,
+        projectContext,
+        cwd,
+        gitBranch,
+        messages: buildSession.getMessages(),
+    });
+}
 /**
  * Build one in-process agent session: its AgentSession, SSE client set, event
  * bridge, task runner, auth/login bridge, and the full HTTP route table exposed
@@ -695,6 +745,72 @@ async function createSession(deps, opts) {
     // 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.
     let serveController = null;
+    // ── Nolan Grout (mentor agent) ─────────────────────────────────
+    // A second, read-only AgentSession on this same window. The user talks to him
+    // with `@Nolan …`; he reads EZ Coder's transcript (one-way — EZ Coder never sees
+    // Nolan's) and hands back runnable prompts + mentorship. Created lazily on the
+    // first `@Nolan` so windows that never use Nolan pay zero cost. His events ride the
+    // SAME SSE stream with `ken_`-prefixed types, routed to the Nolan bubble.
+    let nolanSession = null;
+    let nolanAbort = new AbortController();
+    let nolanRunning = false;
+    let pendingNolanModel = null;
+    const nolanToolCallNames = new Map();
+    async function syncNolanModel(provider, model) {
+        if (nolanRunning) {
+            pendingNolanModel = { provider, model };
+            return;
+        }
+        if (!nolanSession)
+            return;
+        const st = nolanSession.getState();
+        if (st.provider === provider && st.model === model)
+            return;
+        await nolanSession.switchModel(provider, model);
+        log("INFO", "app-sidecar", "ken session model synced", { provider, model });
+    }
+    async function ensureNolanSession() {
+        if (nolanSession)
+            return nolanSession;
+        const st = session.getState();
+        const ken = new AgentSession({
+            provider: st.provider,
+            model: st.model,
+            cwd,
+            systemPrompt: buildNolanSystemPrompt(),
+            allowedTools: NOLAN_ALLOWED_TOOLS,
+            allowedMcpServers: NOLAN_ALLOWED_MCP_SERVERS,
+            transient: true,
+            signal: nolanAbort.signal,
+        });
+        await ken.initialize();
+        // Bridge Nolan's bus to the shared SSE fan-out with ken_-prefixed types so the
+        // webview routes them to the Nolan bubble, never EZ Coder's.
+        ken.eventBus.on("text_delta", (d) => broadcast("nolan_text_delta", d));
+        ken.eventBus.on("thinking_delta", (d) => broadcast("nolan_thinking_delta", d));
+        ken.eventBus.on("tool_call_start", (d) => {
+            nolanToolCallNames.set(d.toolCallId, d.name);
+            broadcast("nolan_tool_call_start", d);
+        });
+        ken.eventBus.on("tool_call_update", (d) => broadcast("nolan_tool_call_update", d));
+        ken.eventBus.on("tool_call_end", (d) => {
+            nolanToolCallNames.delete(d.toolCallId);
+            broadcast("nolan_tool_call_end", d);
+        });
+        // Native server tools (Anthropic web_search) stream text both before AND
+        // after them in the same turn; forward so the webview can break the bubble
+        // (otherwise "...work.Local tools..." glues together). Mirrors the build bus.
+        ken.eventBus.on("server_tool_call", (d) => broadcast("nolan_server_tool_call", d));
+        ken.eventBus.on("turn_end", (d) => broadcast("nolan_turn_end", d));
+        ken.eventBus.on("error", (d) => {
+            const message = d.error instanceof Error ? d.error.message : String(d.error);
+            log("ERROR", "app-sidecar", "ken error", { message });
+            broadcast("nolan_error", { message });
+        });
+        nolanSession = ken;
+        log("INFO", "app-sidecar", "ken 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).
     {
@@ -805,6 +921,9 @@ async function createSession(deps, opts) {
         };
     }
     async function authStatusPayload() {
+        // Native (Rust) writes to auth.json bypass this daemon's cache; re-read so
+        // the reported connection state matches what's actually on disk.
+        await auth.reload();
         const providers = await Promise.all(AUTH_PROVIDERS.map(async (p) => ({
             ...p,
             connected: await auth.hasProviderAuth(p.value),
@@ -1040,9 +1159,33 @@ async function createSession(deps, opts) {
                     }
                 }
                 const history = [];
+                // Nolan (mentor) turns to interleave: group by the non-system message count
+                // they were recorded after, so each lands right after that message. A
+                // turn becomes two wire rows: the `@Nolan` question (user) + Nolan's reply
+                // (assistant), both flagged `ken` so the webview tints them.
+                const nolanByCount = new Map();
+                for (const turn of session.getNolanTurns()) {
+                    const list = nolanByCount.get(turn.afterMessageCount) ?? [];
+                    list.push(turn);
+                    nolanByCount.set(turn.afterMessageCount, list);
+                }
+                const flushNolan = (count) => {
+                    const turns = nolanByCount.get(count);
+                    if (!turns)
+                        return;
+                    nolanByCount.delete(count);
+                    for (const turn of turns) {
+                        history.push({ role: "user", text: `@Nolan ${turn.question}`, ken: true });
+                        history.push({ role: "assistant", text: turn.reply, ken: true });
+                    }
+                };
+                let nonSystemCount = 0;
+                // Turns recorded before any build message (anchor 0) render at the top.
+                flushNolan(0);
                 for (const msg of messages) {
                     if (msg.role === "system")
                         continue;
+                    nonSystemCount++;
                     if (msg.role === "tool") {
                         // Tool result messages: check for ImageContent blocks (screenshots,
                         // generated images) and emit a toolImages entry.
@@ -1132,7 +1275,14 @@ async function createSession(deps, opts) {
                             });
                         }
                     }
-                }
+                    // Interleave any Nolan turns recorded right after this message.
+                    flushNolan(nonSystemCount);
+                }
+                // Flush remaining Nolan turns whose anchor is at/after the message count
+                // (e.g. asked before any build message, or anchors beyond the current
+                // count after compaction shrank the history) so none are dropped.
+                for (const count of [...nolanByCount.keys()].sort((a, b) => a - b))
+                    flushNolan(count);
                 json(res, 200, { history });
             })();
             return;
@@ -1207,6 +1357,67 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Nolan Grout (mentor): an independent read-only advisory run on the nolanSession.
+        // Runs concurrently with a build run — its events are ken_-prefixed so the
+        // 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") {
+            void readBody(req).then(async (raw) => {
+                let text;
+                try {
+                    text = JSON.parse(raw).text ?? "";
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!text.trim()) {
+                    json(res, 400, { error: "empty prompt" });
+                    return;
+                }
+                if (nolanRunning) {
+                    json(res, 409, { error: "Nolan is already thinking — wait for his reply." });
+                    return;
+                }
+                json(res, 202, { accepted: true });
+                nolanRunning = true;
+                broadcast("nolan_run_start", { text });
+                try {
+                    const ken = await ensureNolanSession();
+                    const digest = await buildNolanContext(session, cwd, gitBranch, text);
+                    await ken.prompt(digest);
+                    // Record the turn against the BUILD session so it persists + survives
+                    // resume (advisory custom entry, never an LLM message). Reply is Nolan's
+                    // last assistant message; skip persistence if he produced nothing.
+                    const reply = lastAssistantText(ken.getMessages());
+                    if (reply.trim())
+                        await session.persistNolanTurn(text, reply);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    log("ERROR", "app-sidecar", "ken run failed", { message });
+                    broadcast("nolan_error", { message });
+                }
+                finally {
+                    nolanRunning = false;
+                    broadcast("nolan_run_end", {});
+                    const pending = pendingNolanModel;
+                    pendingNolanModel = null;
+                    if (pending)
+                        await syncNolanModel(pending.provider, pending.model);
+                }
+            });
+            return;
+        }
+        if (method === "POST" && url === "/ken/cancel") {
+            nolanAbort.abort();
+            nolanAbort = new AbortController();
+            nolanSession?.setSignal(nolanAbort.signal);
+            nolanRunning = false;
+            broadcast("nolan_run_end", { cancelled: true });
+            json(res, 200, { cancelled: true });
+            return;
+        }
         if (method === "POST" && url === "/enhance") {
             void readBody(req).then(async (raw) => {
                 let text;
@@ -1397,6 +1608,10 @@ async function createSession(deps, opts) {
         }
         if (method === "GET" && url === "/models") {
             void (async () => {
+                // The desktop app writes API keys natively (Rust → auth.json), bypassing
+                // this daemon's AuthStorage cache. Re-read from disk so a provider the
+                // user just logged in for (e.g. Xiaomi/MiMo) shows up in the list.
+                await auth.reload();
                 const loggedIn = [];
                 for (const p of ALL_PROVIDERS) {
                     if (await auth.hasProviderAuth(p))
@@ -1432,7 +1647,11 @@ async function createSession(deps, opts) {
                     json(res, 409, { error: "cannot switch model while running" });
                     return;
                 }
+                // Pick up any natively-written keys (desktop app) before resolving the
+                // new model's credentials, so switching to a just-added provider works.
+                await auth.reload();
                 await session.switchModel(target.provider, target.id);
+                await syncNolanModel(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.
@@ -1986,6 +2205,8 @@ async function createSession(deps, opts) {
             await serveController.stop().catch(() => { });
         for (const c of clients)
             c.res.end();
+        nolanAbort.abort();
+        await nolanSession?.dispose().catch(() => { });
         await session.dispose().catch(() => { });
     }
     return {