@mandipadk7/kavi 0.1.0

package/dist/paths.js

@@ -0,0 +1,43 @@
+import os from "node:os";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+export function resolveAppPaths(repoRoot) {
+    const home = os.homedir();
+    const safeRepoId = createHash("sha1").update(repoRoot).digest("hex").slice(0, 12);
+    const kaviDir = path.join(repoRoot, ".kavi");
+    const homeConfigDir = process.env.KAVI_HOME_CONFIG_DIR ?? path.join(home, ".config", "kavi");
+    const homeStateDir = process.env.KAVI_HOME_STATE_DIR ?? path.join(home, ".local", "state", "kavi");
+    const runtimeDir = path.join(kaviDir, "runtime");
+    const stateDir = path.join(kaviDir, "state");
+    const runsDir = path.join(runtimeDir, "runs");
+    return {
+        repoRoot,
+        kaviDir,
+        configFile: path.join(kaviDir, "config.toml"),
+        promptsDir: path.join(kaviDir, "prompts"),
+        stateDir,
+        runtimeDir,
+        runsDir,
+        stateFile: path.join(stateDir, "session.json"),
+        eventsFile: path.join(stateDir, "events.jsonl"),
+        approvalsFile: path.join(stateDir, "approvals.json"),
+        commandsFile: path.join(runtimeDir, "commands.jsonl"),
+        claudeSettingsFile: path.join(runtimeDir, "claude.settings.json"),
+        socketPath: path.join(runtimeDir, "kavid.sock"),
+        homeConfigDir,
+        homeConfigFile: path.join(homeConfigDir, "config.toml"),
+        homeApprovalRulesFile: path.join(homeConfigDir, "approval-rules.json"),
+        homeStateDir,
+        worktreeRoot: path.join(homeStateDir, "worktrees", safeRepoId),
+        integrationRoot: path.join(homeStateDir, "integration", safeRepoId)
+    };
+}
+export function buildSessionId() {
+    return randomUUID();
+}
+export function nowIso() {
+    return new Date().toISOString();
+}
+
+
+//# sourceURL=paths.ts

package/dist/process.js

@@ -0,0 +1,72 @@
+import { spawn } from "node:child_process";
+export async function runCommand(command, args, options = {}) {
+    return await new Promise((resolve)=>{
+        const child = spawn(command, args, {
+            ...options,
+            stdio: [
+                "ignore",
+                "pipe",
+                "pipe"
+            ]
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk)=>{
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk)=>{
+            stderr += chunk;
+        });
+        child.on("error", (error)=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve({
+                code: 127,
+                stdout,
+                stderr: `${stderr}${stderr ? "\n" : ""}${error instanceof Error ? error.message : String(error)}`
+            });
+        });
+        child.on("close", (code)=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve({
+                code: code ?? 1,
+                stdout,
+                stderr
+            });
+        });
+    });
+}
+export function spawnDetachedNode(nodeExecutable, args, cwd) {
+    const child = spawn(nodeExecutable, [
+        "--experimental-strip-types",
+        ...args
+    ], {
+        cwd,
+        detached: true,
+        stdio: "ignore"
+    });
+    child.unref();
+    return child.pid ?? -1;
+}
+export function isProcessAlive(pid) {
+    if (!pid || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+
+//# sourceURL=process.ts

package/dist/router.js

@@ -0,0 +1,55 @@
+import { nowIso } from "./paths.js";
+function containsKeyword(prompt, keywords) {
+    const lower = prompt.toLowerCase();
+    return keywords.some((keyword)=>lower.includes(keyword.toLowerCase()));
+}
+export function routePrompt(prompt, config) {
+    if (containsKeyword(prompt, config.routing.frontendKeywords)) {
+        return "claude";
+    }
+    if (containsKeyword(prompt, config.routing.backendKeywords)) {
+        return "codex";
+    }
+    return "codex";
+}
+export function buildKickoffTasks(goal) {
+    const timestamp = nowIso();
+    return [
+        {
+            id: "kickoff-codex",
+            title: "Codex kickoff plan",
+            owner: "codex",
+            status: "pending",
+            prompt: goal,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            summary: null
+        },
+        {
+            id: "kickoff-claude",
+            title: "Claude intent interpretation",
+            owner: "claude",
+            status: "pending",
+            prompt: goal,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            summary: null
+        }
+    ];
+}
+export function buildAdHocTask(owner, prompt, taskId) {
+    const timestamp = nowIso();
+    return {
+        id: taskId,
+        title: `Ad hoc task for ${owner}`,
+        owner,
+        status: "pending",
+        prompt,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        summary: null
+    };
+}
+
+
+//# sourceURL=router.ts

package/dist/runtime.js

@@ -0,0 +1,43 @@
+import process from "node:process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadHomeConfig } from "./config.js";
+const MINIMUM_NODE_MAJOR = 25;
+export function parseNodeMajor(version) {
+    const major = Number(version.split(".")[0] ?? "");
+    return Number.isFinite(major) ? major : 0;
+}
+export function hasSupportedNode(version = process.versions.node) {
+    return parseNodeMajor(version) >= MINIMUM_NODE_MAJOR;
+}
+export function minimumNodeMajor() {
+    return MINIMUM_NODE_MAJOR;
+}
+export function resolveKaviEntrypoint() {
+    const runtimePath = fileURLToPath(import.meta.url);
+    const extension = path.extname(runtimePath) || ".js";
+    return fileURLToPath(new URL(`./main${extension}`, import.meta.url));
+}
+export async function resolveSessionRuntime(paths) {
+    const homeConfig = await loadHomeConfig(paths);
+    return {
+        nodeExecutable: homeConfig.runtime.nodeBin.trim() || process.execPath,
+        codexExecutable: homeConfig.runtime.codexBin.trim() || "codex",
+        claudeExecutable: homeConfig.runtime.claudeBin.trim() || "claude",
+        kaviEntryPoint: resolveKaviEntrypoint()
+    };
+}
+export function shellEscape(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+export function buildKaviShellCommand(runtime, args) {
+    return [
+        shellEscape(runtime.nodeExecutable),
+        "--experimental-strip-types",
+        shellEscape(runtime.kaviEntryPoint),
+        ...args.map((arg)=>shellEscape(arg))
+    ].join(" ");
+}
+
+
+//# sourceURL=runtime.ts

package/dist/session.js

@@ -0,0 +1,113 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import { appendEvent, readJson, writeJson, fileExists } from "./fs.js";
+import { EventHistory } from "./history.js";
+import { nowIso } from "./paths.js";
+import { resolveSessionRuntime } from "./runtime.js";
+function initialAgentStatus(agent, transport) {
+    return {
+        agent,
+        available: true,
+        transport,
+        lastRunAt: null,
+        lastExitCode: null,
+        sessionId: null,
+        summary: null
+    };
+}
+export async function createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint) {
+    const timestamp = nowIso();
+    const record = {
+        id: sessionId,
+        repoRoot: paths.repoRoot,
+        baseCommit,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        socketPath: rpcEndpoint,
+        status: "starting",
+        goal,
+        daemonPid: null,
+        daemonHeartbeatAt: null,
+        config,
+        runtime,
+        worktrees,
+        tasks: [],
+        peerMessages: [],
+        agentStatus: {
+            codex: initialAgentStatus("codex", "codex-exec"),
+            claude: initialAgentStatus("claude", "claude-print")
+        }
+    };
+    await writeJson(paths.stateFile, record);
+    return record;
+}
+export async function loadSessionRecord(paths) {
+    const record = await readJson(paths.stateFile);
+    if (!record.runtime) {
+        record.runtime = await resolveSessionRuntime(paths);
+    }
+    return record;
+}
+export async function saveSessionRecord(paths, record) {
+    record.updatedAt = nowIso();
+    await writeJson(paths.stateFile, record);
+}
+export async function recordEvent(paths, sessionId, type, payload) {
+    const event = {
+        id: randomUUID(),
+        type,
+        timestamp: nowIso(),
+        payload
+    };
+    await appendEvent(paths.eventsFile, event);
+    const history = await EventHistory.open(paths, sessionId);
+    if (history) {
+        history.insert(sessionId, event);
+        history.close();
+    }
+}
+export async function sessionExists(paths) {
+    return fileExists(paths.stateFile);
+}
+export async function updateTask(paths, task) {
+    const session = await loadSessionRecord(paths);
+    const tasks = session.tasks.filter((item)=>item.id !== task.id);
+    tasks.push(task);
+    session.tasks = tasks.sort((a, b)=>a.createdAt.localeCompare(b.createdAt));
+    await saveSessionRecord(paths, session);
+}
+export async function addPeerMessages(paths, messages) {
+    if (messages.length === 0) {
+        return;
+    }
+    const session = await loadSessionRecord(paths);
+    session.peerMessages.push(...messages);
+    await saveSessionRecord(paths, session);
+}
+export async function markAgentRun(paths, agent, summary, exitCode, sessionId) {
+    const session = await loadSessionRecord(paths);
+    session.agentStatus[agent] = {
+        ...session.agentStatus[agent],
+        lastRunAt: nowIso(),
+        lastExitCode: exitCode,
+        sessionId,
+        summary
+    };
+    await saveSessionRecord(paths, session);
+}
+export async function readRecentEvents(paths, limit = 20) {
+    if (!await fileExists(paths.eventsFile)) {
+        return [];
+    }
+    const content = await fs.readFile(paths.eventsFile, "utf8");
+    return content.trim().split(/\r?\n/).filter(Boolean).slice(-limit).map((line)=>JSON.parse(line));
+}
+export function sessionHeartbeatAgeMs(session) {
+    if (!session.daemonHeartbeatAt) {
+        return null;
+    }
+    return Date.now() - new Date(session.daemonHeartbeatAt).getTime();
+}
+
+
+//# sourceURL=session.ts

package/dist/task-artifacts.js

@@ -0,0 +1,37 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, fileExists, readJson, writeJson } from "./fs.js";
+function artifactPath(paths, taskId) {
+    return path.join(paths.runsDir, `${taskId}.json`);
+}
+export async function saveTaskArtifact(paths, artifact) {
+    await ensureDir(paths.runsDir);
+    await writeJson(artifactPath(paths, artifact.taskId), artifact);
+}
+export async function loadTaskArtifact(paths, taskId) {
+    const filePath = artifactPath(paths, taskId);
+    if (!await fileExists(filePath)) {
+        return null;
+    }
+    return readJson(filePath);
+}
+export async function listTaskArtifacts(paths) {
+    if (!await fileExists(paths.runsDir)) {
+        return [];
+    }
+    const entries = await fs.readdir(paths.runsDir, {
+        withFileTypes: true
+    });
+    const artifacts = [];
+    for (const entry of entries){
+        if (!entry.isFile() || !entry.name.endsWith(".json")) {
+            continue;
+        }
+        const artifact = await readJson(path.join(paths.runsDir, entry.name));
+        artifacts.push(artifact);
+    }
+    return artifacts.sort((left, right)=>left.finishedAt.localeCompare(right.finishedAt));
+}
+
+
+//# sourceURL=task-artifacts.ts

package/dist/toml.js

@@ -0,0 +1,55 @@
+function parseScalar(value) {
+    const trimmed = value.trim();
+    if (trimmed === "true") {
+        return true;
+    }
+    if (trimmed === "false") {
+        return false;
+    }
+    if (/^-?\d+$/.test(trimmed)) {
+        return Number(trimmed);
+    }
+    if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) {
+        return trimmed.slice(1, -1).replaceAll("\\\"", "\"");
+    }
+    return trimmed;
+}
+function parseArray(value) {
+    const inner = value.trim().slice(1, -1).trim();
+    if (!inner) {
+        return [];
+    }
+    return inner.split(",").map((part)=>parseScalar(part)).map((part)=>String(part));
+}
+export function parseToml(content) {
+    const root = {};
+    let current = root;
+    for (const rawLine of content.split(/\r?\n/)){
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        if (line.startsWith("[") && line.endsWith("]")) {
+            const sectionPath = line.slice(1, -1).split(".");
+            current = root;
+            for (const part of sectionPath){
+                if (!(part in current)) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+            continue;
+        }
+        const separatorIndex = line.indexOf("=");
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        current[key] = value.startsWith("[") && value.endsWith("]") ? parseArray(value) : parseScalar(value);
+    }
+    return root;
+}
+
+
+//# sourceURL=toml.ts

package/dist/tui.js

@@ -0,0 +1,92 @@
+import readline from "node:readline";
+import process from "node:process";
+import { listApprovalRequests, resolveApprovalRequest } from "./approvals.js";
+import { appendCommand } from "./command-queue.js";
+import { loadSessionRecord, readRecentEvents } from "./session.js";
+function divider(title) {
+    return `\n=== ${title} ${"=".repeat(Math.max(1, 60 - title.length))}`;
+}
+function render(session, events, approvals) {
+    const agentLines = Object.values(session.agentStatus).map((status)=>`- ${status.agent}: ${status.transport} | last_exit=${status.lastExitCode ?? "-"} | last_run=${status.lastRunAt ?? "-"}`).join("\n");
+    const worktreeLines = session.worktrees.map((worktree)=>`- ${worktree.agent}: ${worktree.path} (${worktree.branch})`).join("\n");
+    const taskLines = session.tasks.map((task)=>`- ${task.id} | ${task.owner} | ${task.status} | ${task.title}${task.summary ? ` | ${task.summary}` : ""}`).join("\n");
+    const messageLines = session.peerMessages.slice(-8).map((message)=>`- ${message.from} -> ${message.to} [${message.intent}] ${message.subject}`).join("\n");
+    const approvalLines = approvals.slice(-6).map((request)=>`- ${request.id} | ${request.agent} | ${request.summary}`).join("\n");
+    const eventLines = events.slice(-8).map((event)=>`- ${event.timestamp} ${event.type}`).join("\n");
+    return [
+        "\u001bc",
+        `Kavi Session ${session.id}`,
+        `Repo: ${session.repoRoot}`,
+        `Goal: ${session.goal ?? "-"}`,
+        `Status: ${session.status}`,
+        divider("Agents"),
+        agentLines || "- none",
+        divider("Worktrees"),
+        worktreeLines || "- none",
+        divider("Tasks"),
+        taskLines || "- none",
+        divider("Approvals"),
+        approvalLines || "- none",
+        divider("Peer Messages"),
+        messageLines || "- none",
+        divider("Events"),
+        eventLines || "- none",
+        "\nKeys: q quit | r refresh | y approve latest | n deny latest | s shutdown daemon"
+    ].join("\n");
+}
+export async function attachTui(paths) {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    let closed = false;
+    const refresh = async ()=>{
+        const session = await loadSessionRecord(paths);
+        const events = await readRecentEvents(paths, 30);
+        const approvals = await listApprovalRequests(paths);
+        process.stdout.write(render(session, events, approvals));
+    };
+    const interval = setInterval(()=>{
+        void refresh();
+    }, 1500);
+    await refresh();
+    await new Promise((resolve)=>{
+        process.stdin.on("keypress", async (_str, key)=>{
+            if (key.name === "q" || key.ctrl && key.name === "c") {
+                closed = true;
+                clearInterval(interval);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdout.write("\n");
+                resolve();
+                return;
+            }
+            if (key.name === "r") {
+                await refresh();
+                return;
+            }
+            if (key.name === "s") {
+                await appendCommand(paths, "shutdown", {});
+                await refresh();
+                return;
+            }
+            if (key.name === "y" || key.name === "n") {
+                const approvals = await listApprovalRequests(paths);
+                const latest = approvals.sort((left, right)=>left.createdAt.localeCompare(right.createdAt)).pop();
+                if (!latest) {
+                    await refresh();
+                    return;
+                }
+                await resolveApprovalRequest(paths, latest.id, key.name === "y" ? "allow" : "deny", false);
+                await refresh();
+            }
+        });
+    });
+    if (!closed) {
+        clearInterval(interval);
+    }
+}
+
+
+//# sourceURL=tui.ts

package/dist/types.js

@@ -0,0 +1,3 @@
+
+
+//# sourceURL=types.ts

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@mandipadk7/kavi",
+  "version": "0.1.0",
+  "description": "Managed Codex + Claude collaboration TUI",
+  "type": "module",
+  "preferGlobal": true,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mandipadk/kavi.git"
+  },
+  "homepage": "https://github.com/mandipadk/kavi#readme",
+  "bugs": {
+    "url": "https://github.com/mandipadk/kavi/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": "bin/kavi.js",
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "node ./scripts/build.mjs",
+    "dev": "node ./bin/kavi.js",
+    "doctor": "node ./bin/kavi.js doctor",
+    "init": "node ./bin/kavi.js init",
+    "start": "node ./bin/kavi.js start",
+    "open": "node ./bin/kavi.js open",
+    "resume": "node ./bin/kavi.js resume",
+    "status": "node ./bin/kavi.js status",
+    "paths": "node ./bin/kavi.js paths",
+    "task": "node ./bin/kavi.js task",
+    "tasks": "node ./bin/kavi.js tasks",
+    "task-output": "node ./bin/kavi.js task-output",
+    "approvals": "node ./bin/kavi.js approvals",
+    "approve": "node ./bin/kavi.js approve",
+    "deny": "node ./bin/kavi.js deny",
+    "events": "node ./bin/kavi.js events",
+    "stop": "node ./bin/kavi.js stop",
+    "land": "node ./bin/kavi.js land",
+    "test": "node --experimental-strip-types --test src/**/*.test.ts",
+    "release:check": "npm run build && npm test && npm pack --dry-run --cache /tmp/kavi-npm-cache",
+    "publish:beta": "npm publish --access public --tag beta",
+    "publish:latest": "npm publish --access public",
+    "prepublishOnly": "npm run release:check"
+  },
+  "engines": {
+    "node": ">=25.0.0"
+  }
+}