@mandipadk7/kavi 0.1.1 → 0.1.2

package/dist/daemon.js

@@ -1,12 +1,17 @@
+import fs from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
 import { consumeCommands } from "./command-queue.js";
 import { buildPeerMessages as buildClaudePeerMessages, runClaudeTask } from "./adapters/claude.js";
 import { buildPeerMessages as buildCodexPeerMessages, runCodexTask } from "./adapters/codex.js";
+import { buildDecisionReplay } from "./adapters/shared.js";
+import { listApprovalRequests, resolveApprovalRequest } from "./approvals.js";
 import { addDecisionRecord, upsertPathClaim } from "./decision-ledger.js";
-import { listWorktreeChangedPaths } from "./git.js";
+import { getWorktreeDiffReview, listWorktreeChangedPaths } from "./git.js";
 import { nowIso } from "./paths.js";
 import { buildAdHocTask, buildKickoffTasks } from "./router.js";
-import { loadSessionRecord, recordEvent, saveSessionRecord } from "./session.js";
-import { saveTaskArtifact } from "./task-artifacts.js";
+import { loadSessionRecord, readRecentEvents, recordEvent, saveSessionRecord } from "./session.js";
+import { loadTaskArtifact, saveTaskArtifact } from "./task-artifacts.js";
 export class KaviDaemon {
     paths;
     session;
@@ -15,6 +20,10 @@ export class KaviDaemon {
     processing = false;
     interval = null;
     stopResolver = null;
+    rpcServer = null;
+    clients = new Set();
+    subscribers = new Set();
+    mutationQueue = Promise.resolve();
     constructor(paths){
         this.paths = paths;
     }
@@ -28,6 +37,7 @@ export class KaviDaemon {
         await recordEvent(this.paths, this.session.id, "daemon.started", {
             daemonPid: process.pid
         });
+        await this.startRpcServer();
         this.running = true;
         void this.tick();
         this.interval = setInterval(()=>{
@@ -37,6 +47,343 @@ export class KaviDaemon {
             this.stopResolver = resolve;
         });
     }
+    async startRpcServer() {
+        await fs.mkdir(path.dirname(this.paths.socketPath), {
+            recursive: true
+        });
+        await fs.rm(this.paths.socketPath, {
+            force: true
+        }).catch(()=>{});
+        this.rpcServer = net.createServer((socket)=>{
+            this.clients.add(socket);
+            socket.setEncoding("utf8");
+            let buffer = "";
+            socket.on("data", (chunk)=>{
+                buffer += chunk;
+                while(true){
+                    const newlineIndex = buffer.indexOf("\n");
+                    if (newlineIndex === -1) {
+                        return;
+                    }
+                    const line = buffer.slice(0, newlineIndex).trim();
+                    buffer = buffer.slice(newlineIndex + 1);
+                    if (!line) {
+                        continue;
+                    }
+                    let request;
+                    try {
+                        request = JSON.parse(line);
+                    } catch (error) {
+                        this.writeRpc(socket, {
+                            id: "parse-error",
+                            error: {
+                                message: error instanceof Error ? error.message : "Unable to parse RPC payload."
+                            }
+                        });
+                        continue;
+                    }
+                    void this.handleRpcRequest(socket, request);
+                }
+            });
+            const cleanup = ()=>{
+                this.clients.delete(socket);
+                this.subscribers.delete(socket);
+            };
+            socket.on("error", cleanup);
+            socket.on("close", cleanup);
+        });
+        await new Promise((resolve, reject)=>{
+            this.rpcServer?.once("error", reject);
+            this.rpcServer?.listen(this.paths.socketPath, ()=>{
+                this.rpcServer?.off("error", reject);
+                resolve();
+            });
+        });
+    }
+    writeRpc(socket, response, onWritten) {
+        socket.write(`${JSON.stringify(response)}\n`, onWritten);
+    }
+    writeNotification(socket, notification) {
+        socket.write(`${JSON.stringify(notification)}\n`);
+    }
+    async handleRpcRequest(socket, request) {
+        try {
+            const dispatch = await this.dispatchRpc(socket, request.method, request.params ?? {});
+            this.writeRpc(socket, {
+                id: request.id,
+                result: dispatch.result
+            }, ()=>{
+                if (dispatch.shutdownAfterResponse) {
+                    void this.stopFromRpc();
+                }
+            });
+        } catch (error) {
+            this.writeRpc(socket, {
+                id: request.id,
+                error: {
+                    message: error instanceof Error ? error.message : String(error)
+                }
+            });
+        }
+    }
+    async dispatchRpc(socket, method, params) {
+        switch(method){
+            case "ping":
+                return {
+                    result: {
+                        ok: true,
+                        sessionId: this.session.id
+                    }
+                };
+            case "snapshot":
+                return {
+                    result: await this.buildSnapshot()
+                };
+            case "subscribe":
+                this.subscribers.add(socket);
+                return {
+                    result: await this.buildSnapshot()
+                };
+            case "kickoff":
+                await this.kickoffFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "enqueueTask":
+                await this.enqueueRpcTask(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "shutdown":
+                return {
+                    result: {
+                        ok: true
+                    },
+                    shutdownAfterResponse: true
+                };
+            case "resolveApproval":
+                await this.resolveApprovalFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "taskArtifact":
+                return {
+                    result: await this.getTaskArtifactFromRpc(params)
+                };
+            case "events":
+                return {
+                    result: await this.getEventsFromRpc(params)
+                };
+            case "worktreeDiff":
+                return {
+                    result: await this.getWorktreeDiffFromRpc(params)
+                };
+            case "notifyExternalUpdate":
+                await this.publishSnapshot(typeof params.reason === "string" && params.reason.trim() ? params.reason.trim() : "external.update");
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            default:
+                throw new Error(`Unknown RPC method: ${method}`);
+        }
+    }
+    async buildSnapshot() {
+        const session = await loadSessionRecord(this.paths);
+        const events = await readRecentEvents(this.paths, 30);
+        const approvals = await listApprovalRequests(this.paths, {
+            includeResolved: true
+        });
+        const worktreeDiffs = await Promise.all(session.worktrees.map(async (worktree)=>({
+                agent: worktree.agent,
+                paths: await listWorktreeChangedPaths(worktree.path, session.baseCommit).catch(()=>[])
+            })));
+        return {
+            session,
+            events,
+            approvals,
+            worktreeDiffs
+        };
+    }
+    async runMutation(fn) {
+        const previous = this.mutationQueue;
+        let release = ()=>{};
+        this.mutationQueue = new Promise((resolve)=>{
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await fn();
+        } finally{
+            release();
+        }
+    }
+    async enqueueRpcTask(params) {
+        await this.runMutation(async ()=>{
+            const prompt = typeof params.prompt === "string" ? params.prompt : "";
+            if (!prompt.trim()) {
+                throw new Error("enqueueTask requires a prompt.");
+            }
+            const owner = params.owner === "claude" ? "claude" : "codex";
+            const commandId = `rpc-${Date.now()}`;
+            const taskId = `task-${commandId}`;
+            const task = buildAdHocTask(owner, prompt, taskId, {
+                routeReason: typeof params.routeReason === "string" ? params.routeReason : null,
+                claimedPaths: Array.isArray(params.claimedPaths) ? params.claimedPaths.map((item)=>String(item)) : []
+            });
+            this.session.tasks.push(task);
+            addDecisionRecord(this.session, {
+                kind: "route",
+                agent: owner,
+                taskId,
+                summary: `Routed task to ${owner}`,
+                detail: typeof params.routeReason === "string" ? params.routeReason : `Task enqueued for ${owner}.`,
+                metadata: {
+                    strategy: typeof params.routeStrategy === "string" ? params.routeStrategy : "unknown",
+                    confidence: typeof params.routeConfidence === "number" ? params.routeConfidence : null,
+                    claimedPaths: task.claimedPaths
+                }
+            });
+            upsertPathClaim(this.session, {
+                taskId,
+                agent: owner,
+                source: "route",
+                paths: task.claimedPaths,
+                note: task.routeReason
+            });
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "task.enqueued", {
+                owner,
+                via: "rpc"
+            });
+            await this.publishSnapshot("task.enqueued");
+        });
+    }
+    async kickoffFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const prompt = typeof params.prompt === "string" ? params.prompt : "";
+            if (!prompt.trim()) {
+                throw new Error("kickoff requires a prompt.");
+            }
+            this.session.goal = prompt;
+            this.session.tasks.push(...buildKickoffTasks(prompt));
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "tasks.kickoff_enqueued", {
+                count: 2,
+                via: "rpc"
+            });
+            await this.publishSnapshot("tasks.kickoff_enqueued");
+        });
+    }
+    async stopFromRpc() {
+        await this.runMutation(async ()=>{
+            this.session.status = "stopped";
+            this.running = false;
+            this.session.daemonHeartbeatAt = new Date().toISOString();
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "daemon.stopped", {
+                via: "rpc"
+            });
+            if (this.interval) {
+                clearInterval(this.interval);
+                this.interval = null;
+            }
+            await this.closeRpcServer();
+            this.stopResolver?.();
+        });
+    }
+    async resolveApprovalFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const requestId = typeof params.requestId === "string" ? params.requestId : "";
+            const decision = params.decision === "deny" ? "deny" : "allow";
+            const remember = params.remember === true;
+            if (!requestId) {
+                throw new Error("resolveApproval requires a requestId.");
+            }
+            const request = await resolveApprovalRequest(this.paths, requestId, decision, remember);
+            addDecisionRecord(this.session, {
+                kind: "approval",
+                agent: request.agent,
+                summary: `${decision === "allow" ? "Approved" : "Denied"} ${request.toolName}`,
+                detail: request.summary,
+                metadata: {
+                    requestId: request.id,
+                    remember,
+                    toolName: request.toolName
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "approval.resolved", {
+                requestId: request.id,
+                decision,
+                remember,
+                agent: request.agent,
+                toolName: request.toolName,
+                via: "rpc"
+            });
+            await this.publishSnapshot("approval.resolved");
+        });
+    }
+    async getTaskArtifactFromRpc(params) {
+        const taskId = typeof params.taskId === "string" ? params.taskId : "";
+        if (!taskId) {
+            throw new Error("taskArtifact requires a taskId.");
+        }
+        return await loadTaskArtifact(this.paths, taskId);
+    }
+    async getEventsFromRpc(params) {
+        const limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? params.limit : 20;
+        return await readRecentEvents(this.paths, limit);
+    }
+    async getWorktreeDiffFromRpc(params) {
+        const agent = params.agent === "claude" ? "claude" : "codex";
+        const filePath = typeof params.filePath === "string" ? params.filePath : null;
+        const worktree = this.session.worktrees.find((item)=>item.agent === agent);
+        if (!worktree) {
+            throw new Error(`No managed worktree found for ${agent}.`);
+        }
+        return await getWorktreeDiffReview(agent, worktree.path, this.session.baseCommit, filePath);
+    }
+    async publishSnapshot(reason) {
+        if (this.subscribers.size === 0) {
+            return;
+        }
+        const snapshot = await this.buildSnapshot();
+        const notification = {
+            method: "snapshot.updated",
+            params: {
+                reason,
+                snapshot
+            }
+        };
+        for (const subscriber of this.subscribers){
+            this.writeNotification(subscriber, notification);
+        }
+    }
+    async closeRpcServer() {
+        const server = this.rpcServer;
+        this.rpcServer = null;
+        for (const client of this.clients){
+            client.end();
+        }
+        this.clients.clear();
+        this.subscribers.clear();
+        if (server) {
+            await new Promise((resolve)=>{
+                server.close(()=>resolve());
+            });
+        }
+        await fs.rm(this.paths.socketPath, {
+            force: true
+        }).catch(()=>{});
+    }
     async tick() {
         if (!this.running || this.processing) {
             return;
@@ -50,6 +397,7 @@ export class KaviDaemon {
                     clearInterval(this.interval);
                     this.interval = null;
                 }
+                await this.closeRpcServer();
                 this.stopResolver?.();
                 return;
             }
@@ -64,6 +412,7 @@ export class KaviDaemon {
                 await recordEvent(this.paths, this.session.id, "tasks.kickoff_created", {
                     count: this.session.tasks.length
                 });
+                await this.publishSnapshot("tasks.kickoff_created");
             }
             const pending = this.session.tasks.filter((task)=>task.status === "pending");
             for (const task of pending){
@@ -89,6 +438,7 @@ export class KaviDaemon {
                     clearInterval(this.interval);
                     this.interval = null;
                 }
+                await this.closeRpcServer();
                 this.stopResolver?.();
                 return;
             }
@@ -99,6 +449,7 @@ export class KaviDaemon {
                 await recordEvent(this.paths, this.session.id, "tasks.kickoff_enqueued", {
                     count: 2
                 });
+                await this.publishSnapshot("tasks.kickoff_enqueued");
                 continue;
             }
             if (command.type === "enqueue" && typeof command.payload.prompt === "string") {
@@ -132,6 +483,7 @@ export class KaviDaemon {
                 await recordEvent(this.paths, this.session.id, "task.enqueued", {
                     owner
                 });
+                await this.publishSnapshot("task.enqueued");
             }
         }
     }
@@ -144,6 +496,7 @@ export class KaviDaemon {
             taskId: task.id,
             owner: task.owner
         });
+        await this.publishSnapshot("task.started");
         try {
             let envelope;
             let peerMessages;
@@ -159,7 +512,7 @@ export class KaviDaemon {
                 envelope = result.envelope;
                 rawOutput = result.raw;
                 peerMessages = buildClaudePeerMessages(result.envelope, "claude", task.id);
-                await this.markAgent("claude", result.envelope.summary, 0, `${this.session.id}-claude`);
+                await this.markAgent("claude", result.envelope.summary, 0, result.sessionId);
             } else {
                 throw new Error(`Unsupported task owner ${task.owner}.`);
             }
@@ -194,6 +547,7 @@ export class KaviDaemon {
             });
             this.session.peerMessages.push(...peerMessages);
             await saveSessionRecord(this.paths, this.session);
+            const decisionReplay = buildDecisionReplay(this.session, task, task.owner === "claude" ? "claude" : "codex");
             await saveTaskArtifact(this.paths, {
                 taskId: task.id,
                 sessionId: this.session.id,
@@ -201,6 +555,9 @@ export class KaviDaemon {
                 owner: task.owner,
                 status: task.status,
                 summary: task.summary,
+                routeReason: task.routeReason,
+                claimedPaths: task.claimedPaths,
+                decisionReplay,
                 rawOutput,
                 error: null,
                 envelope,
@@ -213,6 +570,7 @@ export class KaviDaemon {
                 status: task.status,
                 peerMessages: peerMessages.length
             });
+            await this.publishSnapshot("task.completed");
         } catch (error) {
             task.status = "failed";
             task.summary = error instanceof Error ? error.message : String(error);
@@ -245,6 +603,7 @@ export class KaviDaemon {
             });
             await this.markAgent(task.owner, task.summary, 1, task.owner === "claude" ? `${this.session.id}-claude` : null);
             await saveSessionRecord(this.paths, this.session);
+            const decisionReplay = buildDecisionReplay(this.session, task, task.owner === "claude" ? "claude" : "codex");
             await saveTaskArtifact(this.paths, {
                 taskId: task.id,
                 sessionId: this.session.id,
@@ -252,6 +611,9 @@ export class KaviDaemon {
                 owner: task.owner,
                 status: task.status,
                 summary: task.summary,
+                routeReason: task.routeReason,
+                claimedPaths: task.claimedPaths,
+                decisionReplay,
                 rawOutput: null,
                 error: task.summary,
                 envelope: null,
@@ -263,6 +625,7 @@ export class KaviDaemon {
                 owner: task.owner,
                 error: task.summary
             });
+            await this.publishSnapshot("task.failed");
         }
     }
     async markAgent(agent, summary, exitCode, sessionId) {

package/dist/git.js

@@ -59,6 +59,45 @@ function uniqueSorted(values) {
         ...new Set(values)
     ].sort();
 }
+async function isUntrackedPath(worktreePath, filePath) {
+    const result = await runCommand("git", [
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+        "--",
+        filePath
+    ], {
+        cwd: worktreePath
+    });
+    if (result.code !== 0) {
+        throw new Error(result.stderr.trim() || `Unable to inspect untracked status for ${filePath}.`);
+    }
+    return parsePathList(result.stdout).includes(filePath);
+}
+async function buildSyntheticAddedFilePatch(worktreePath, filePath) {
+    const absolutePath = path.join(worktreePath, filePath);
+    const content = await fs.readFile(absolutePath, "utf8");
+    const normalized = content.replaceAll("\r", "");
+    const endsWithNewline = normalized.endsWith("\n");
+    const lines = normalized.length === 0 ? [] : normalized.replace(/\n$/, "").split("\n");
+    const patchLines = [
+        `diff --git a/${filePath} b/${filePath}`,
+        "new file mode 100644",
+        "--- /dev/null",
+        `+++ b/${filePath}`
+    ];
+    if (lines.length > 0) {
+        patchLines.push(`@@ -0,0 +1,${lines.length} @@`);
+        patchLines.push(...lines.map((line)=>`+${line}`));
+        if (!endsWithNewline) {
+            patchLines.push("\");
+        }
+    }
+    return {
+        stat: lines.length > 0 ? `new file | ${lines.length} insertion${lines.length === 1 ? "" : "s"}(+)` : "new file | empty",
+        patch: patchLines.join("\n")
+    };
+}
 export async function resolveTargetBranch(repoRoot, configuredBranch) {
     const exists = await runCommand("git", [
         "show-ref",
@@ -204,6 +243,64 @@ export async function listWorktreeChangedPaths(worktreePath, baseCommit) {
         ...parsePathList(untracked.stdout)
     ]);
 }
+export async function getWorktreeDiffReview(agent, worktreePath, baseCommit, filePath) {
+    const changedPaths = await listWorktreeChangedPaths(worktreePath, baseCommit);
+    const selectedPath = filePath && changedPaths.includes(filePath) ? filePath : changedPaths[0] ?? null;
+    if (!selectedPath) {
+        return {
+            agent,
+            changedPaths,
+            selectedPath: null,
+            stat: "No changed files in this worktree.",
+            patch: ""
+        };
+    }
+    if (await isUntrackedPath(worktreePath, selectedPath)) {
+        const synthetic = await buildSyntheticAddedFilePatch(worktreePath, selectedPath);
+        return {
+            agent,
+            changedPaths,
+            selectedPath,
+            stat: synthetic.stat,
+            patch: synthetic.patch
+        };
+    }
+    const [statResult, patchResult] = await Promise.all([
+        runCommand("git", [
+            "diff",
+            "--stat",
+            "--find-renames",
+            baseCommit,
+            "--",
+            selectedPath
+        ], {
+            cwd: worktreePath
+        }),
+        runCommand("git", [
+            "diff",
+            "--find-renames",
+            "--unified=3",
+            baseCommit,
+            "--",
+            selectedPath
+        ], {
+            cwd: worktreePath
+        })
+    ]);
+    if (statResult.code !== 0) {
+        throw new Error(statResult.stderr.trim() || `Unable to build diff stat for ${selectedPath}.`);
+    }
+    if (patchResult.code !== 0) {
+        throw new Error(patchResult.stderr.trim() || `Unable to build diff patch for ${selectedPath}.`);
+    }
+    return {
+        agent,
+        changedPaths,
+        selectedPath,
+        stat: statResult.stdout.trim() || "No diff stat available.",
+        patch: patchResult.stdout.trim() || "No textual patch available."
+    };
+}
 export async function findOverlappingWorktreePaths(worktrees, baseCommit) {
     const pathSets = await Promise.all(worktrees.map(async (worktree)=>({
             agent: worktree.agent,