@mandipadk7/kavi 0.1.0

package/dist/git.js

@@ -0,0 +1,289 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDir } from "./fs.js";
+import { buildSessionId } from "./paths.js";
+import { runCommand } from "./process.js";
+export async function detectRepoRoot(cwd) {
+    const result = await runCommand("git", [
+        "rev-parse",
+        "--show-toplevel"
+    ], {
+        cwd
+    });
+    if (result.code !== 0) {
+        throw new Error(result.stderr.trim() || "Not inside a git repository.");
+    }
+    return result.stdout.trim();
+}
+export async function getHeadCommit(repoRoot) {
+    const result = await runCommand("git", [
+        "rev-parse",
+        "HEAD"
+    ], {
+        cwd: repoRoot
+    });
+    if (result.code !== 0) {
+        throw new Error("Unable to resolve HEAD. Create an initial commit before opening a Kavi session.");
+    }
+    return result.stdout.trim();
+}
+export async function getCurrentBranch(repoRoot) {
+    const result = await runCommand("git", [
+        "branch",
+        "--show-current"
+    ], {
+        cwd: repoRoot
+    });
+    if (result.code !== 0) {
+        throw new Error(result.stderr.trim() || "Unable to resolve current branch.");
+    }
+    return result.stdout.trim();
+}
+export async function getBranchCommit(repoRoot, ref) {
+    const result = await runCommand("git", [
+        "rev-parse",
+        ref
+    ], {
+        cwd: repoRoot
+    });
+    if (result.code !== 0) {
+        throw new Error(result.stderr.trim() || `Unable to resolve ${ref}.`);
+    }
+    return result.stdout.trim();
+}
+export async function resolveTargetBranch(repoRoot, configuredBranch) {
+    const exists = await runCommand("git", [
+        "show-ref",
+        "--verify",
+        `refs/heads/${configuredBranch}`
+    ], {
+        cwd: repoRoot
+    });
+    if (exists.code === 0) {
+        return configuredBranch;
+    }
+    return getCurrentBranch(repoRoot);
+}
+async function ensureDetachedWorktree(repoRoot, worktreePath, baseCommit) {
+    const result = await runCommand("git", [
+        "worktree",
+        "add",
+        "--detach",
+        worktreePath,
+        baseCommit
+    ], {
+        cwd: repoRoot
+    });
+    if (result.code !== 0 && !result.stderr.includes("already exists")) {
+        throw new Error(result.stderr.trim() || `Unable to create worktree ${worktreePath}.`);
+    }
+}
+async function ensureBranch(worktreePath, branchName, baseCommit) {
+    const exists = await runCommand("git", [
+        "rev-parse",
+        "--verify",
+        branchName
+    ], {
+        cwd: worktreePath
+    });
+    if (exists.code !== 0) {
+        const createResult = await runCommand("git", [
+            "checkout",
+            "-b",
+            branchName,
+            baseCommit
+        ], {
+            cwd: worktreePath
+        });
+        if (createResult.code !== 0) {
+            throw new Error(createResult.stderr.trim() || `Unable to create branch ${branchName}.`);
+        }
+        return;
+    }
+    const checkoutResult = await runCommand("git", [
+        "checkout",
+        branchName
+    ], {
+        cwd: worktreePath
+    });
+    if (checkoutResult.code !== 0) {
+        throw new Error(checkoutResult.stderr.trim() || `Unable to checkout ${branchName}.`);
+    }
+}
+export async function ensureWorktrees(repoRoot, paths, sessionId, _config, baseCommit) {
+    await ensureDir(paths.worktreeRoot);
+    const agents = [
+        "codex",
+        "claude"
+    ];
+    const worktrees = [];
+    for (const agent of agents){
+        const worktreePath = path.join(paths.worktreeRoot, `${agent}-${sessionId}`);
+        const branchName = `kavi/${sessionId}/${agent}`;
+        await ensureDetachedWorktree(repoRoot, worktreePath, baseCommit);
+        await ensureBranch(worktreePath, branchName, baseCommit);
+        worktrees.push({
+            agent,
+            path: worktreePath,
+            branch: branchName
+        });
+    }
+    return worktrees;
+}
+export async function createGitignoreEntries(repoRoot) {
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    let content = "";
+    try {
+        content = await fs.readFile(gitignorePath, "utf8");
+    } catch  {
+        content = "";
+    }
+    const entries = [
+        ".kavi/state",
+        ".kavi/runtime"
+    ];
+    const missing = entries.filter((entry)=>!content.split(/\r?\n/).includes(entry));
+    if (missing.length === 0) {
+        return;
+    }
+    const prefix = content.trimEnd() ? "\n" : "";
+    await fs.writeFile(gitignorePath, `${content.trimEnd()}${prefix}${missing.join("\n")}\n`, "utf8");
+}
+export async function landBranches(repoRoot, targetBranch, worktrees, validationCommand, sessionId, integrationRoot) {
+    const commandsRun = [];
+    const snapshotCommits = [];
+    const targetHead = await getBranchCommit(repoRoot, targetBranch);
+    const integrationId = buildSessionId().slice(0, 8);
+    const integrationBranch = `kavi/land/${sessionId}/${integrationId}`;
+    const integrationPath = path.join(integrationRoot, `${sessionId}-${integrationId}`);
+    await ensureDir(integrationRoot);
+    const addIntegration = await runCommand("git", [
+        "worktree",
+        "add",
+        "-b",
+        integrationBranch,
+        integrationPath,
+        targetHead
+    ], {
+        cwd: repoRoot
+    });
+    commandsRun.push(`git worktree add -b ${integrationBranch} ${integrationPath} ${targetHead}`);
+    if (addIntegration.code !== 0) {
+        throw new Error(addIntegration.stderr.trim() || `Unable to create integration worktree at ${integrationPath}.`);
+    }
+    for (const worktree of worktrees){
+        const snapshot = await snapshotWorktree(worktree, sessionId);
+        snapshotCommits.push(snapshot);
+        if (snapshot.createdCommit) {
+            commandsRun.push(`git -C ${worktree.path} add -A`);
+            commandsRun.push(`git -C ${worktree.path} -c user.name=Kavi -c user.email=kavi@local.invalid commit -m "kavi: snapshot ${worktree.agent} ${sessionId}"`);
+        }
+        const merge = await runCommand("git", [
+            "merge",
+            "--no-ff",
+            "--no-edit",
+            worktree.branch
+        ], {
+            cwd: integrationPath
+        });
+        commandsRun.push(`git -C ${integrationPath} merge --no-ff --no-edit ${worktree.branch}`);
+        if (merge.code !== 0) {
+            throw new Error(merge.stderr.trim() || `Unable to merge branch ${worktree.branch} into integration branch ${integrationBranch}.`);
+        }
+    }
+    if (validationCommand.trim()) {
+        const validation = await runCommand("zsh", [
+            "-lc",
+            validationCommand
+        ], {
+            cwd: integrationPath
+        });
+        commandsRun.push(validationCommand);
+        if (validation.code !== 0) {
+            throw new Error(`Validation command failed.\n${validation.stdout}\n${validation.stderr}`.trim());
+        }
+    }
+    const currentBranch = await getCurrentBranch(repoRoot).catch(()=>"");
+    if (currentBranch === targetBranch) {
+        const mergeIntegration = await runCommand("git", [
+            "merge",
+            "--ff-only",
+            integrationBranch
+        ], {
+            cwd: repoRoot
+        });
+        commandsRun.push(`git merge --ff-only ${integrationBranch}`);
+        if (mergeIntegration.code !== 0) {
+            throw new Error(mergeIntegration.stderr.trim() || `Unable to fast-forward ${targetBranch} to ${integrationBranch}.`);
+        }
+    } else {
+        const updateRef = await runCommand("git", [
+            "update-ref",
+            `refs/heads/${targetBranch}`,
+            `refs/heads/${integrationBranch}`,
+            targetHead
+        ], {
+            cwd: repoRoot
+        });
+        commandsRun.push(`git update-ref refs/heads/${targetBranch} refs/heads/${integrationBranch} ${targetHead}`);
+        if (updateRef.code !== 0) {
+            throw new Error(updateRef.stderr.trim() || `Unable to advance ${targetBranch}; it changed while landing was in progress.`);
+        }
+    }
+    return {
+        commandsRun,
+        integrationBranch,
+        integrationPath,
+        snapshotCommits
+    };
+}
+async function snapshotWorktree(worktree, sessionId) {
+    const status = await runCommand("git", [
+        "status",
+        "--short"
+    ], {
+        cwd: worktree.path
+    });
+    if (status.code !== 0) {
+        throw new Error(status.stderr.trim() || `Unable to inspect worktree ${worktree.path}.`);
+    }
+    if (!status.stdout.trim()) {
+        return {
+            agent: worktree.agent,
+            createdCommit: false,
+            commit: await getBranchCommit(worktree.path, "HEAD")
+        };
+    }
+    const add = await runCommand("git", [
+        "add",
+        "-A"
+    ], {
+        cwd: worktree.path
+    });
+    if (add.code !== 0) {
+        throw new Error(add.stderr.trim() || `Unable to stage worktree ${worktree.path}.`);
+    }
+    const commitMessage = `kavi: snapshot ${worktree.agent} ${sessionId}`;
+    const commit = await runCommand("git", [
+        "-c",
+        "user.name=Kavi",
+        "-c",
+        "user.email=kavi@local.invalid",
+        "commit",
+        "-m",
+        commitMessage
+    ], {
+        cwd: worktree.path
+    });
+    if (commit.code !== 0) {
+        throw new Error(commit.stderr.trim() || `Unable to snapshot worktree ${worktree.path}.`);
+    }
+    return {
+        agent: worktree.agent,
+        createdCommit: true,
+        commit: await getBranchCommit(worktree.path, "HEAD")
+    };
+}
+
+
+//# sourceURL=git.ts

package/dist/history.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { ensureDir } from "./fs.js";
+export class EventHistory {
+    db;
+    constructor(db){
+        this.db = db;
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        type TEXT NOT NULL,
+        payload_json TEXT NOT NULL
+      );
+    `);
+    }
+    static async open(paths, sessionId) {
+        if (process.env.KAVI_ENABLE_SQLITE_HISTORY !== "1") {
+            return null;
+        }
+        await ensureDir(paths.homeStateDir);
+        const dbPath = path.join(paths.homeStateDir, `${sessionId}.sqlite`);
+        const sqlite = await import("node:sqlite");
+        return new EventHistory(new sqlite.DatabaseSync(dbPath));
+    }
+    insert(sessionId, event) {
+        const statement = this.db.prepare(`
+      INSERT OR REPLACE INTO events (id, session_id, timestamp, type, payload_json)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        statement.run(event.id, sessionId, event.timestamp, event.type, JSON.stringify(event.payload));
+    }
+    close() {
+        this.db.close();
+    }
+}
+
+
+//# sourceURL=history.ts