@mandipadk7/kavi 0.1.0

package/dist/config.js

@@ -0,0 +1,175 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, fileExists } from "./fs.js";
+import { parseToml } from "./toml.js";
+const DEFAULT_CONFIG = `version = 1
+base_branch = "main"
+validation_command = "npm test"
+message_limit = 6
+
+[routing]
+frontend_keywords = ["frontend", "ui", "ux", "design", "copy", "react", "css", "html"]
+backend_keywords = ["backend", "api", "server", "db", "schema", "migration", "auth", "test"]
+
+[agents.codex]
+role = "planning-backend"
+model = ""
+
+[agents.claude]
+role = "frontend-intent"
+model = ""
+`;
+const DEFAULT_PROMPTS = {
+    "codex.md": `You are Codex inside Kavi.
+
+Default role:
+- Own planning, architecture, backend, debugging, and review-heavy work.
+- Keep updates compact and task-scoped.
+- Emit peer messages only when they materially help Claude.
+`,
+    "claude.md": `You are Claude inside Kavi.
+
+Default role:
+- Own frontend, UX, intent-shaping, copy, and product-sense work.
+- Keep updates compact and task-scoped.
+- Emit peer messages only when they materially help Codex.
+`
+};
+const DEFAULT_HOME_CONFIG = `version = 1
+
+[runtime]
+node_bin = ""
+codex_bin = "codex"
+claude_bin = "claude"
+`;
+function asString(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}
+function asNumber(value, fallback) {
+    return typeof value === "number" ? value : fallback;
+}
+function asStringArray(value, fallback) {
+    return Array.isArray(value) ? value.map((item)=>String(item)) : fallback;
+}
+export function defaultConfig() {
+    return {
+        version: 1,
+        baseBranch: "main",
+        validationCommand: "npm test",
+        messageLimit: 6,
+        routing: {
+            frontendKeywords: [
+                "frontend",
+                "ui",
+                "ux",
+                "design",
+                "copy",
+                "react",
+                "css",
+                "html"
+            ],
+            backendKeywords: [
+                "backend",
+                "api",
+                "server",
+                "db",
+                "schema",
+                "migration",
+                "auth",
+                "test"
+            ]
+        },
+        agents: {
+            codex: {
+                role: "planning-backend",
+                model: ""
+            },
+            claude: {
+                role: "frontend-intent",
+                model: ""
+            }
+        }
+    };
+}
+export function defaultHomeConfig() {
+    return {
+        version: 1,
+        runtime: {
+            nodeBin: "",
+            codexBin: "codex",
+            claudeBin: "claude"
+        }
+    };
+}
+export async function ensureProjectScaffold(paths) {
+    await ensureDir(paths.kaviDir);
+    await ensureDir(paths.promptsDir);
+    await ensureDir(paths.stateDir);
+    await ensureDir(paths.runtimeDir);
+    await ensureDir(paths.runsDir);
+    if (!await fileExists(paths.configFile)) {
+        await fs.writeFile(paths.configFile, DEFAULT_CONFIG, "utf8");
+    }
+    for (const [fileName, content] of Object.entries(DEFAULT_PROMPTS)){
+        const promptPath = path.join(paths.promptsDir, fileName);
+        if (!await fileExists(promptPath)) {
+            await fs.writeFile(promptPath, content, "utf8");
+        }
+    }
+}
+export async function ensureHomeConfig(paths) {
+    await ensureDir(paths.homeConfigDir);
+    if (!await fileExists(paths.homeConfigFile)) {
+        await fs.writeFile(paths.homeConfigFile, DEFAULT_HOME_CONFIG, "utf8");
+    }
+}
+export async function loadConfig(paths) {
+    if (!await fileExists(paths.configFile)) {
+        return defaultConfig();
+    }
+    const content = await fs.readFile(paths.configFile, "utf8");
+    const parsed = parseToml(content);
+    const routing = parsed.routing ?? {};
+    const agents = parsed.agents ?? {};
+    const codex = agents.codex ?? {};
+    const claude = agents.claude ?? {};
+    return {
+        version: asNumber(parsed.version, 1),
+        baseBranch: asString(parsed.base_branch, "main"),
+        validationCommand: asString(parsed.validation_command, "npm test"),
+        messageLimit: asNumber(parsed.message_limit, 6),
+        routing: {
+            frontendKeywords: asStringArray(routing.frontend_keywords, defaultConfig().routing.frontendKeywords),
+            backendKeywords: asStringArray(routing.backend_keywords, defaultConfig().routing.backendKeywords)
+        },
+        agents: {
+            codex: {
+                role: asString(codex.role, "planning-backend"),
+                model: asString(codex.model, "")
+            },
+            claude: {
+                role: asString(claude.role, "frontend-intent"),
+                model: asString(claude.model, "")
+            }
+        }
+    };
+}
+export async function loadHomeConfig(paths) {
+    if (!await fileExists(paths.homeConfigFile)) {
+        return defaultHomeConfig();
+    }
+    const content = await fs.readFile(paths.homeConfigFile, "utf8");
+    const parsed = parseToml(content);
+    const runtime = parsed.runtime ?? {};
+    return {
+        version: asNumber(parsed.version, 1),
+        runtime: {
+            nodeBin: asString(runtime.node_bin, ""),
+            codexBin: asString(runtime.codex_bin, "codex"),
+            claudeBin: asString(runtime.claude_bin, "claude")
+        }
+    };
+}
+
+
+//# sourceURL=config.ts

package/dist/daemon.js

@@ -0,0 +1,202 @@
+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 { nowIso } from "./paths.js";
+import { buildAdHocTask, buildKickoffTasks } from "./router.js";
+import { loadSessionRecord, recordEvent, saveSessionRecord } from "./session.js";
+import { saveTaskArtifact } from "./task-artifacts.js";
+export class KaviDaemon {
+    paths;
+    session;
+    managedSessionId = "";
+    running = false;
+    processing = false;
+    interval = null;
+    stopResolver = null;
+    constructor(paths){
+        this.paths = paths;
+    }
+    async start() {
+        this.session = await loadSessionRecord(this.paths);
+        this.managedSessionId = this.session.id;
+        this.session.status = "running";
+        this.session.daemonPid = process.pid;
+        this.session.daemonHeartbeatAt = new Date().toISOString();
+        await saveSessionRecord(this.paths, this.session);
+        await recordEvent(this.paths, this.session.id, "daemon.started", {
+            daemonPid: process.pid
+        });
+        this.running = true;
+        void this.tick();
+        this.interval = setInterval(()=>{
+            void this.tick();
+        }, 1000);
+        await new Promise((resolve)=>{
+            this.stopResolver = resolve;
+        });
+    }
+    async tick() {
+        if (!this.running || this.processing) {
+            return;
+        }
+        this.processing = true;
+        try {
+            const onDiskSession = await loadSessionRecord(this.paths);
+            if (onDiskSession.id !== this.managedSessionId || onDiskSession.status === "stopped") {
+                this.running = false;
+                if (this.interval) {
+                    clearInterval(this.interval);
+                    this.interval = null;
+                }
+                this.stopResolver?.();
+                return;
+            }
+            this.session = onDiskSession;
+            this.session.daemonPid = process.pid;
+            this.session.daemonHeartbeatAt = new Date().toISOString();
+            await saveSessionRecord(this.paths, this.session);
+            await this.consumeQueuedCommands();
+            if (this.session.tasks.length === 0 && this.session.goal) {
+                this.session.tasks = buildKickoffTasks(this.session.goal);
+                await saveSessionRecord(this.paths, this.session);
+                await recordEvent(this.paths, this.session.id, "tasks.kickoff_created", {
+                    count: this.session.tasks.length
+                });
+            }
+            const pending = this.session.tasks.filter((task)=>task.status === "pending");
+            for (const task of pending){
+                await this.runTask(task);
+            }
+        } finally{
+            this.processing = false;
+        }
+    }
+    async consumeQueuedCommands() {
+        const commands = await consumeCommands(this.paths);
+        if (commands.length === 0) {
+            return;
+        }
+        for (const command of commands){
+            if (command.type === "shutdown") {
+                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", {});
+                if (this.interval) {
+                    clearInterval(this.interval);
+                    this.interval = null;
+                }
+                this.stopResolver?.();
+                return;
+            }
+            if (command.type === "kickoff" && typeof command.payload.prompt === "string") {
+                this.session.goal = command.payload.prompt;
+                this.session.tasks.push(...buildKickoffTasks(command.payload.prompt));
+                await saveSessionRecord(this.paths, this.session);
+                await recordEvent(this.paths, this.session.id, "tasks.kickoff_enqueued", {
+                    count: 2
+                });
+                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}`));
+                await saveSessionRecord(this.paths, this.session);
+                await recordEvent(this.paths, this.session.id, "task.enqueued", {
+                    owner
+                });
+            }
+        }
+    }
+    async runTask(task) {
+        const startedAt = nowIso();
+        task.status = "running";
+        task.updatedAt = startedAt;
+        await saveSessionRecord(this.paths, this.session);
+        await recordEvent(this.paths, this.session.id, "task.started", {
+            taskId: task.id,
+            owner: task.owner
+        });
+        try {
+            let envelope;
+            let peerMessages;
+            let rawOutput = null;
+            if (task.owner === "codex") {
+                const result = await runCodexTask(this.session, task, this.paths);
+                envelope = result.envelope;
+                rawOutput = result.raw;
+                peerMessages = buildCodexPeerMessages(result.envelope, "codex", task.id);
+                await this.markAgent("codex", result.envelope.summary, 0, null);
+            } 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`);
+            } 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();
+            this.session.peerMessages.push(...peerMessages);
+            await saveSessionRecord(this.paths, this.session);
+            await saveTaskArtifact(this.paths, {
+                taskId: task.id,
+                sessionId: this.session.id,
+                title: task.title,
+                owner: task.owner,
+                status: task.status,
+                summary: task.summary,
+                rawOutput,
+                error: null,
+                envelope,
+                startedAt,
+                finishedAt: task.updatedAt
+            });
+            await recordEvent(this.paths, this.session.id, "task.completed", {
+                taskId: task.id,
+                owner: task.owner,
+                status: task.status,
+                peerMessages: peerMessages.length
+            });
+        } catch (error) {
+            task.status = "failed";
+            task.summary = error instanceof Error ? error.message : String(error);
+            task.updatedAt = new Date().toISOString();
+            await this.markAgent(task.owner, task.summary, 1, task.owner === "claude" ? `${this.session.id}-claude` : null);
+            await saveSessionRecord(this.paths, this.session);
+            await saveTaskArtifact(this.paths, {
+                taskId: task.id,
+                sessionId: this.session.id,
+                title: task.title,
+                owner: task.owner,
+                status: task.status,
+                summary: task.summary,
+                rawOutput: null,
+                error: task.summary,
+                envelope: null,
+                startedAt,
+                finishedAt: task.updatedAt
+            });
+            await recordEvent(this.paths, this.session.id, "task.failed", {
+                taskId: task.id,
+                owner: task.owner,
+                error: task.summary
+            });
+        }
+    }
+    async markAgent(agent, summary, exitCode, sessionId) {
+        this.session.agentStatus[agent] = {
+            ...this.session.agentStatus[agent],
+            lastRunAt: new Date().toISOString(),
+            lastExitCode: exitCode,
+            sessionId,
+            summary
+        };
+    }
+}
+
+
+//# sourceURL=daemon.ts

package/dist/doctor.js

@@ -0,0 +1,78 @@
+import { fileExists } from "./fs.js";
+import { runCommand } from "./process.js";
+import { hasSupportedNode, minimumNodeMajor, resolveSessionRuntime } from "./runtime.js";
+function normalizeVersion(output) {
+    return output.trim().split(/\s+/).slice(-1)[0] ?? output.trim();
+}
+export async function runDoctor(repoRoot, paths) {
+    const checks = [];
+    const runtime = await resolveSessionRuntime(paths);
+    const nodeVersion = await runCommand(runtime.nodeExecutable, [
+        "--version"
+    ], {
+        cwd: repoRoot
+    });
+    checks.push({
+        name: "node",
+        ok: nodeVersion.code === 0 && hasSupportedNode(nodeVersion.stdout.replace(/^v/, "").trim()),
+        detail: nodeVersion.code === 0 ? `${nodeVersion.stdout.trim()} via ${runtime.nodeExecutable} (need >= ${minimumNodeMajor()})` : nodeVersion.stderr.trim()
+    });
+    const codexVersion = await runCommand(runtime.codexExecutable, [
+        "--version"
+    ], {
+        cwd: repoRoot
+    });
+    checks.push({
+        name: "codex",
+        ok: codexVersion.code === 0,
+        detail: codexVersion.code === 0 ? `${normalizeVersion(codexVersion.stdout)} via ${runtime.codexExecutable}` : codexVersion.stderr.trim()
+    });
+    const claudeVersion = await runCommand(runtime.claudeExecutable, [
+        "--version"
+    ], {
+        cwd: repoRoot
+    });
+    checks.push({
+        name: "claude",
+        ok: claudeVersion.code === 0,
+        detail: claudeVersion.code === 0 ? `${claudeVersion.stdout.trim()} via ${runtime.claudeExecutable}` : claudeVersion.stderr.trim()
+    });
+    const worktreeCheck = await runCommand("git", [
+        "worktree",
+        "list"
+    ], {
+        cwd: repoRoot
+    });
+    checks.push({
+        name: "git-worktree",
+        ok: worktreeCheck.code === 0,
+        detail: worktreeCheck.code === 0 ? "available" : worktreeCheck.stderr.trim()
+    });
+    const appServerCheck = await runCommand(runtime.codexExecutable, [
+        "app-server",
+        "--help"
+    ], {
+        cwd: repoRoot
+    });
+    checks.push({
+        name: "codex-app-server",
+        ok: appServerCheck.code === 0,
+        detail: appServerCheck.code === 0 ? "supported" : appServerCheck.stderr.trim()
+    });
+    const authCheck = await fileExists(`${process.env.HOME}/.codex/auth.json`);
+    checks.push({
+        name: "codex-auth-file",
+        ok: authCheck,
+        detail: authCheck ? "present" : "missing ~/.codex/auth.json"
+    });
+    const homeConfigCheck = await fileExists(paths.homeConfigFile);
+    checks.push({
+        name: "home-config",
+        ok: true,
+        detail: homeConfigCheck ? "present" : "will be created on demand"
+    });
+    return checks;
+}
+
+
+//# sourceURL=doctor.ts

package/dist/fs.js

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function ensureDir(dirPath) {
+    await fs.mkdir(dirPath, {
+        recursive: true
+    });
+}
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+export async function writeJson(filePath, value) {
+    await ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+export async function readJson(filePath) {
+    const content = await fs.readFile(filePath, "utf8");
+    return JSON.parse(content);
+}
+export async function appendEvent(filePath, event) {
+    await ensureDir(path.dirname(filePath));
+    await fs.appendFile(filePath, `${JSON.stringify(event)}\n`, "utf8");
+}
+
+
+//# sourceURL=fs.ts