@mandipadk7/kavi 0.1.7 → 1.0.0

package/dist/workflow.js

@@ -0,0 +1,450 @@
+import { buildClaimHotspots } from "./decision-ledger.js";
+import { buildOperatorRecommendations } from "./recommendations.js";
+function taskArtifactIndex(artifacts) {
+    return new Map(artifacts.map((artifact)=>[
+            artifact.taskId,
+            artifact
+        ]));
+}
+function taskIndex(snapshot) {
+    return new Map(snapshot.session.tasks.map((task)=>[
+            task.id,
+            task
+        ]));
+}
+function shortJson(value) {
+    try {
+        return JSON.stringify(value);
+    } catch  {
+        return String(value);
+    }
+}
+function summarizeTask(task, artifactByTask) {
+    const artifact = artifactByTask.get(task.id);
+    return {
+        taskId: task.id,
+        owner: task.owner,
+        title: task.title,
+        summary: artifact?.summary ?? task.summary ?? task.prompt,
+        finishedAt: artifact?.finishedAt ?? task.updatedAt,
+        claimedPaths: artifact?.claimedPaths ?? task.claimedPaths
+    };
+}
+function deriveWorkflowStage(params) {
+    const totalChangedPaths = params.changedByAgent.reduce((count, item)=>count + item.paths.length, 0);
+    const completedTasks = params.snapshot.session.tasks.filter((task)=>task.status === "completed").length;
+    if (params.pendingApprovals > 0) {
+        return {
+            id: "waiting_for_approval",
+            label: "Waiting For Approval",
+            detail: `${params.pendingApprovals} approval request(s) are blocking progress.`
+        };
+    }
+    if (params.blockedTasks > 0 || params.hotspots.length > 0) {
+        return {
+            id: "integration",
+            label: "Integration Needed",
+            detail: params.hotspots.length > 0 ? `${params.hotspots.length} overlapping path hotspot(s) need integration work.` : `${params.blockedTasks} task(s) are blocked and need review.`
+        };
+    }
+    if (params.runningTasks > 0 || params.pendingTasks > 0) {
+        return {
+            id: "working",
+            label: "Agents Working",
+            detail: `${params.runningTasks} running and ${params.pendingTasks} pending task(s) remain in flight.`
+        };
+    }
+    if (totalChangedPaths > 0) {
+        return {
+            id: "ready_to_land",
+            label: "Ready To Land",
+            detail: `${totalChangedPaths} changed path(s) are ready for final review and landing.`
+        };
+    }
+    if (params.latestLandReport) {
+        return {
+            id: "landed",
+            label: "Landed",
+            detail: `Latest merge landed in ${params.latestLandReport.targetBranch} at ${params.latestLandReport.createdAt}.`
+        };
+    }
+    if (completedTasks > 0) {
+        return {
+            id: "idle",
+            label: "Idle",
+            detail: "Completed task output exists, but there are no unlanded worktree changes."
+        };
+    }
+    return {
+        id: "bootstrapping",
+        label: "Bootstrapping",
+        detail: "Kavi is ready for the initial kickoff or the next operator task."
+    };
+}
+function buildAgentResults(snapshot, artifactByTask) {
+    const latestLandReport = snapshot.latestLandReport;
+    return [
+        "codex",
+        "claude"
+    ].map((agent)=>{
+        const completedTasks = snapshot.session.tasks.filter((task)=>task.owner === agent && task.status === "completed").sort((left, right)=>right.updatedAt.localeCompare(left.updatedAt));
+        const latestTask = completedTasks[0] ?? null;
+        const landedPaths = latestLandReport?.changedByAgent.find((changeSet)=>changeSet.agent === agent)?.paths ?? [];
+        return {
+            agent,
+            latestTaskId: latestTask?.id ?? null,
+            latestTaskTitle: latestTask?.title ?? null,
+            latestSummary: latestTask ? summarizeTask(latestTask, artifactByTask).summary : snapshot.session.agentStatus[agent].summary,
+            completedTaskCount: completedTasks.length,
+            changedPaths: snapshot.worktreeDiffs.find((diff)=>diff.agent === agent)?.paths ?? [],
+            lastRunAt: snapshot.session.agentStatus[agent].lastRunAt,
+            landedPaths
+        };
+    });
+}
+function toneForEvent(type) {
+    if (type === "task.failed") {
+        return "bad";
+    }
+    if (type === "approval.requested" || type === "land.overlap_detected" || type === "review.note_added") {
+        return "warn";
+    }
+    if (type === "task.completed" || type === "approval.resolved" || type === "land.completed" || type === "recommendation.applied") {
+        return "good";
+    }
+    return "normal";
+}
+function describeEvent(snapshot, event, artifactByTask) {
+    const payload = event.payload;
+    const tasks = taskIndex(snapshot);
+    const taskId = typeof payload.taskId === "string" ? payload.taskId : null;
+    const task = taskId ? tasks.get(taskId) ?? null : null;
+    const artifact = taskId ? artifactByTask.get(taskId) ?? null : null;
+    switch(event.type){
+        case "tasks.kickoff_enqueued":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Kickoff queued",
+                detail: snapshot.session.goal ? `Started a two-agent kickoff for goal: ${snapshot.session.goal}` : "Started the initial Codex and Claude kickoff tasks.",
+                tone: "good"
+            };
+        case "tasks.kickoff_created":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Kickoff tasks created",
+                detail: "Kavi created the initial Codex and Claude kickoff tasks.",
+                tone: "good"
+            };
+        case "daemon.started":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Session started",
+                detail: "The Kavi daemon is running and ready for operator commands.",
+                tone: "good"
+            };
+        case "daemon.stopped":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Session stopped",
+                detail: "The Kavi daemon has stopped for this repository session.",
+                tone: "muted"
+            };
+        case "repo.initialized":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Repository initialized",
+                detail: "Kavi initialized git for this project.",
+                tone: "good"
+            };
+        case "repo.bootstrap_committed":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Bootstrap commit created",
+                detail: "Kavi created the first base commit needed for managed worktrees.",
+                tone: "good"
+            };
+        case "task.enqueued":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: `Task queued for ${typeof payload.owner === "string" ? payload.owner : "agent"}`,
+                detail: task ? `${task.title} | ${task.prompt}` : shortJson(payload),
+                tone: "normal"
+            };
+        case "task.started":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: `Task started${task ? `: ${task.title}` : ""}`,
+                detail: task ? `${task.owner} is working on ${task.prompt}` : shortJson(payload),
+                tone: "normal"
+            };
+        case "task.completed":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: `Task completed${task ? `: ${task.title}` : ""}`,
+                detail: artifact?.summary ?? task?.summary ?? (typeof payload.summary === "string" ? payload.summary : shortJson(payload)),
+                tone: "good"
+            };
+        case "task.failed":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: `Task failed${task ? `: ${task.title}` : ""}`,
+                detail: typeof payload.error === "string" ? payload.error : artifact?.error ?? shortJson(payload),
+                tone: "bad"
+            };
+        case "approval.requested":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Approval requested",
+                detail: typeof payload.summary === "string" ? payload.summary : shortJson(payload),
+                tone: "warn"
+            };
+        case "approval.resolved":
+        case "approval.completed":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Approval resolved",
+                detail: shortJson(payload),
+                tone: "good"
+            };
+        case "recommendation.applied":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Recommendation applied",
+                detail: typeof payload.recommendationId === "string" ? `${payload.recommendationId} -> ${typeof payload.owner === "string" ? payload.owner : "agent"}` : shortJson(payload),
+                tone: "good"
+            };
+        case "recommendation.dismissed":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Recommendation dismissed",
+                detail: typeof payload.recommendationId === "string" ? `${payload.recommendationId}${typeof payload.reason === "string" ? ` | ${payload.reason}` : ""}` : shortJson(payload),
+                tone: "muted"
+            };
+        case "recommendation.restored":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Recommendation restored",
+                detail: typeof payload.recommendationId === "string" ? payload.recommendationId : shortJson(payload),
+                tone: "normal"
+            };
+        case "review.followup_queued":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Review follow-up queued",
+                detail: shortJson(payload),
+                tone: "normal"
+            };
+        case "review.note_added":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Review note added",
+                detail: shortJson(payload),
+                tone: "warn"
+            };
+        case "review.note_status_changed":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Review note status changed",
+                detail: shortJson(payload),
+                tone: "normal"
+            };
+        case "review.note_landed":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Review work landed",
+                detail: shortJson(payload),
+                tone: "good"
+            };
+        case "land.overlap_detected":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Landing blocked",
+                detail: `Overlapping paths detected before landing: ${Array.isArray(payload.overlappingPaths) ? payload.overlappingPaths.join(", ") : shortJson(payload)}`,
+                tone: "warn"
+            };
+        case "land.completed":
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: "Landing completed",
+                detail: typeof payload.targetBranch === "string" ? `Merged managed work into ${payload.targetBranch}` : shortJson(payload),
+                tone: "good"
+            };
+        default:
+            return {
+                id: event.id,
+                timestamp: event.timestamp,
+                title: event.type,
+                detail: shortJson(payload),
+                tone: toneForEvent(event.type)
+            };
+    }
+}
+export function buildWorkflowActivity(snapshot, artifacts = [], limit = 40) {
+    const artifactByTask = taskArtifactIndex(artifacts);
+    const entries = snapshot.events.map((event)=>describeEvent(snapshot, event, artifactByTask)).sort((left, right)=>right.timestamp.localeCompare(left.timestamp));
+    if (snapshot.session.goal) {
+        entries.push({
+            id: `goal:${snapshot.session.id}`,
+            timestamp: snapshot.session.createdAt,
+            title: "Session goal set",
+            detail: snapshot.session.goal,
+            tone: "good"
+        });
+    }
+    return entries.sort((left, right)=>right.timestamp.localeCompare(left.timestamp)).slice(0, Math.max(1, limit));
+}
+export function buildWorkflowSummary(snapshot, artifacts = []) {
+    const artifactByTask = taskArtifactIndex(artifacts);
+    const activeRecommendations = buildOperatorRecommendations(snapshot.session);
+    const allRecommendations = buildOperatorRecommendations(snapshot.session, {
+        includeDismissed: true
+    });
+    const hotspots = buildClaimHotspots(snapshot.session);
+    const changedByAgent = [
+        "codex",
+        "claude"
+    ].map((agent)=>({
+            agent,
+            paths: snapshot.worktreeDiffs.find((diff)=>diff.agent === agent)?.paths ?? []
+        }));
+    const completedTasks = snapshot.session.tasks.filter((task)=>task.status === "completed").sort((left, right)=>right.updatedAt.localeCompare(left.updatedAt)).map((task)=>summarizeTask(task, artifactByTask));
+    const blockers = [];
+    const warnings = [];
+    const pendingApprovals = snapshot.approvals.filter((approval)=>approval.status === "pending").length;
+    const runningTasks = snapshot.session.tasks.filter((task)=>task.status === "running").length;
+    const blockedTasks = snapshot.session.tasks.filter((task)=>task.status === "blocked").length;
+    const pendingTasks = snapshot.session.tasks.filter((task)=>task.status === "pending").length;
+    const openReviews = snapshot.session.reviewNotes.filter((note)=>note.status === "open").length;
+    if (pendingApprovals > 0) {
+        blockers.push(`${pendingApprovals} approval request(s) still need a decision.`);
+    }
+    if (runningTasks > 0) {
+        blockers.push(`${runningTasks} task(s) are still running.`);
+    }
+    if (blockedTasks > 0) {
+        blockers.push(`${blockedTasks} task(s) are blocked.`);
+    }
+    if (pendingTasks > 0) {
+        blockers.push(`${pendingTasks} task(s) are still pending.`);
+    }
+    if (hotspots.length > 0) {
+        blockers.push(`${hotspots.length} overlapping path hotspot(s) still need integration work.`);
+    }
+    if (openReviews > 0) {
+        warnings.push(`${openReviews} review thread(s) remain open.`);
+    }
+    if (activeRecommendations.length > 0) {
+        warnings.push(`${activeRecommendations.length} active recommendation(s) remain.`);
+    }
+    const totalChangedPaths = changedByAgent.reduce((count, item)=>count + item.paths.length, 0);
+    const state = blockers.length > 0 ? "blocked" : totalChangedPaths > 0 ? "ready" : "idle";
+    const stage = deriveWorkflowStage({
+        snapshot,
+        changedByAgent,
+        pendingApprovals,
+        runningTasks,
+        blockedTasks,
+        pendingTasks,
+        hotspots,
+        latestLandReport: snapshot.latestLandReport
+    });
+    const nextActions = [];
+    if (pendingApprovals > 0) {
+        nextActions.push("Resolve pending approvals.");
+    }
+    if (runningTasks > 0 || pendingTasks > 0) {
+        nextActions.push("Wait for active work to finish or review the activity stream for blockers.");
+    }
+    if (blockedTasks > 0 || hotspots.length > 0) {
+        nextActions.push("Address blocked work or overlap hotspots before landing.");
+    }
+    if (state === "ready") {
+        nextActions.push("Review the merged result summary, then run `kavi land`.");
+    }
+    if (state === "idle") {
+        nextActions.push("No unlanded worktree changes are currently present.");
+    }
+    return {
+        goal: snapshot.session.goal,
+        stage,
+        taskCounts: {
+            pending: pendingTasks,
+            running: runningTasks,
+            blocked: blockedTasks,
+            completed: snapshot.session.tasks.filter((task)=>task.status === "completed").length,
+            failed: snapshot.session.tasks.filter((task)=>task.status === "failed").length
+        },
+        approvalCounts: {
+            pending: pendingApprovals
+        },
+        reviewCounts: {
+            open: openReviews
+        },
+        recommendationCounts: {
+            active: activeRecommendations.length,
+            dismissed: allRecommendations.filter((item)=>item.status === "dismissed").length
+        },
+        landReadiness: {
+            state,
+            blockers,
+            warnings,
+            nextActions
+        },
+        changedByAgent,
+        completedTasks,
+        recentActivity: buildWorkflowActivity(snapshot, artifacts, 8),
+        latestLandReport: snapshot.latestLandReport
+    };
+}
+export function buildWorkflowResult(snapshot, artifacts = []) {
+    const artifactByTask = taskArtifactIndex(artifacts);
+    const summary = buildWorkflowSummary(snapshot, artifacts);
+    const latestLandReport = snapshot.latestLandReport;
+    const agentResults = buildAgentResults(snapshot, artifactByTask);
+    const headline = summary.stage.id === "landed" && latestLandReport ? `Merged work landed in ${latestLandReport.targetBranch}.` : summary.stage.id === "ready_to_land" ? "Managed work is ready for final review and landing." : summary.stage.id === "integration" ? "Cross-agent integration needs attention before landing." : summary.stage.id === "waiting_for_approval" ? "Operator approval is needed before work can continue." : summary.stage.id === "working" ? "Managed agents are actively working through the session." : summary.stage.id === "bootstrapping" ? "Kavi is ready to begin the session workflow." : "The session is currently idle.";
+    const summaryLines = [];
+    if (latestLandReport) {
+        summaryLines.push(...latestLandReport.summary);
+    } else {
+        summaryLines.push(summary.stage.detail);
+    }
+    for (const agent of agentResults){
+        summaryLines.push(`${agent.agent}: ${agent.latestSummary ?? "No completed result yet."}${agent.changedPaths.length > 0 ? ` | unlanded paths=${agent.changedPaths.join(", ")}` : ""}`);
+    }
+    return {
+        goal: summary.goal,
+        stage: summary.stage,
+        headline,
+        nextActions: summary.landReadiness.nextActions,
+        changedByAgent: summary.changedByAgent,
+        recentActivity: summary.recentActivity,
+        completedTasks: summary.completedTasks,
+        latestLandReport,
+        agentResults,
+        summaryLines
+    };
+}
+
+
+//# sourceURL=workflow.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandipadk7/kavi",
-  "version": "0.1.7",
+  "version": "1.0.0",
   "description": "Managed Codex + Claude collaboration TUI",
   "type": "module",
   "preferGlobal": true,