@mandipadk7/kavi 0.1.0 → 0.1.2

package/dist/daemon.js

@@ -1,10 +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 { 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;
@@ -13,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;
     }
@@ -26,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(()=>{
@@ -35,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;
@@ -48,6 +397,7 @@ export class KaviDaemon {
                     clearInterval(this.interval);
                     this.interval = null;
                 }
+                await this.closeRpcServer();
                 this.stopResolver?.();
                 return;
             }
@@ -62,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){
@@ -87,6 +438,7 @@ export class KaviDaemon {
                     clearInterval(this.interval);
                     this.interval = null;
                 }
+                await this.closeRpcServer();
                 this.stopResolver?.();
                 return;
             }
@@ -97,15 +449,41 @@ 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") {
                 const owner = command.payload.owner === "claude" ? "claude" : "codex";
-                this.session.tasks.push(buildAdHocTask(owner, command.payload.prompt, `task-${command.id}`));
+                const taskId = `task-${command.id}`;
+                const task = buildAdHocTask(owner, command.payload.prompt, taskId, {
+                    routeReason: typeof command.payload.routeReason === "string" ? command.payload.routeReason : null,
+                    claimedPaths: Array.isArray(command.payload.claimedPaths) ? command.payload.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 command.payload.routeReason === "string" ? command.payload.routeReason : `Task enqueued for ${owner}.`,
+                    metadata: {
+                        strategy: typeof command.payload.routeStrategy === "string" ? command.payload.routeStrategy : "unknown",
+                        confidence: typeof command.payload.routeConfidence === "number" ? command.payload.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
                 });
+                await this.publishSnapshot("task.enqueued");
             }
         }
     }
@@ -118,6 +496,7 @@ export class KaviDaemon {
             taskId: task.id,
             owner: task.owner
         });
+        await this.publishSnapshot("task.started");
         try {
             let envelope;
             let peerMessages;
@@ -127,21 +506,48 @@ export class KaviDaemon {
                 envelope = result.envelope;
                 rawOutput = result.raw;
                 peerMessages = buildCodexPeerMessages(result.envelope, "codex", task.id);
-                await this.markAgent("codex", result.envelope.summary, 0, null);
+                await this.markAgent("codex", result.envelope.summary, 0, result.threadId);
             } else if (task.owner === "claude") {
                 const result = await runClaudeTask(this.session, task, this.paths);
                 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}.`);
             }
             task.status = envelope.status === "completed" ? "completed" : "blocked";
             task.summary = envelope.summary;
             task.updatedAt = new Date().toISOString();
+            if (task.owner === "codex" || task.owner === "claude") {
+                const worktree = this.session.worktrees.find((item)=>item.agent === task.owner);
+                if (worktree) {
+                    const changedPaths = await listWorktreeChangedPaths(worktree.path, this.session.baseCommit);
+                    task.claimedPaths = changedPaths;
+                    upsertPathClaim(this.session, {
+                        taskId: task.id,
+                        agent: task.owner,
+                        source: "diff",
+                        paths: changedPaths,
+                        note: task.summary
+                    });
+                }
+            }
+            addDecisionRecord(this.session, {
+                kind: "task",
+                agent: task.owner === "router" ? "router" : task.owner,
+                taskId: task.id,
+                summary: `${task.owner} task ${task.status}`,
+                detail: task.summary ?? envelope.summary,
+                metadata: {
+                    title: task.title,
+                    status: task.status,
+                    claimedPaths: task.claimedPaths
+                }
+            });
             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,
@@ -149,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,
@@ -161,12 +570,40 @@ 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);
             task.updatedAt = new Date().toISOString();
+            if (task.owner === "codex" || task.owner === "claude") {
+                const worktree = this.session.worktrees.find((item)=>item.agent === task.owner);
+                if (worktree) {
+                    const changedPaths = await listWorktreeChangedPaths(worktree.path, this.session.baseCommit);
+                    task.claimedPaths = changedPaths;
+                    upsertPathClaim(this.session, {
+                        taskId: task.id,
+                        agent: task.owner,
+                        source: "diff",
+                        paths: changedPaths,
+                        note: task.summary
+                    });
+                }
+            }
+            addDecisionRecord(this.session, {
+                kind: "task",
+                agent: task.owner === "router" ? "router" : task.owner,
+                taskId: task.id,
+                summary: `${task.owner} task failed`,
+                detail: task.summary,
+                metadata: {
+                    title: task.title,
+                    status: task.status,
+                    claimedPaths: task.claimedPaths
+                }
+            });
             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,
@@ -174,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,
@@ -185,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/decision-ledger.js

@@ -0,0 +1,75 @@
+import { randomUUID } from "node:crypto";
+import { nowIso } from "./paths.js";
+const MAX_DECISIONS = 80;
+function normalizePaths(paths) {
+    return [
+        ...new Set(paths.map((item)=>item.trim()).filter(Boolean))
+    ].sort();
+}
+export function addDecisionRecord(session, input) {
+    const record = {
+        id: randomUUID(),
+        kind: input.kind,
+        agent: input.agent,
+        taskId: input.taskId ?? null,
+        summary: input.summary,
+        detail: input.detail,
+        createdAt: nowIso(),
+        metadata: input.metadata ?? {}
+    };
+    session.decisions = [
+        ...session.decisions,
+        record
+    ].slice(-MAX_DECISIONS);
+    return record;
+}
+export function upsertPathClaim(session, input) {
+    const normalizedPaths = normalizePaths(input.paths);
+    const existing = session.pathClaims.find((claim)=>claim.taskId === input.taskId);
+    if (normalizedPaths.length === 0 && existing) {
+        existing.paths = [];
+        existing.status = "released";
+        existing.note = input.note ?? existing.note;
+        existing.updatedAt = nowIso();
+        return existing;
+    }
+    if (normalizedPaths.length === 0) {
+        return null;
+    }
+    if (existing) {
+        existing.agent = input.agent;
+        existing.source = input.source;
+        existing.paths = normalizedPaths;
+        existing.note = input.note ?? existing.note;
+        existing.status = input.status ?? "active";
+        existing.updatedAt = nowIso();
+        return existing;
+    }
+    const timestamp = nowIso();
+    const claim = {
+        id: randomUUID(),
+        taskId: input.taskId,
+        agent: input.agent,
+        source: input.source,
+        status: input.status ?? "active",
+        paths: normalizedPaths,
+        note: input.note ?? null,
+        createdAt: timestamp,
+        updatedAt: timestamp
+    };
+    session.pathClaims.push(claim);
+    return claim;
+}
+export function activePathClaims(session) {
+    return session.pathClaims.filter((claim)=>claim.status === "active" && claim.paths.length > 0);
+}
+export function findClaimConflicts(session, owner, claimedPaths) {
+    const normalizedPaths = normalizePaths(claimedPaths);
+    if (normalizedPaths.length === 0) {
+        return [];
+    }
+    return activePathClaims(session).filter((claim)=>claim.agent !== owner && claim.paths.some((item)=>normalizedPaths.includes(item)));
+}
+
+
+//# sourceURL=decision-ledger.ts