loadout-ai 0.7.0 → 0.9.0

package/dist/src/core/coordination/conflict-preview.js

@@ -0,0 +1,167 @@
+/**
+ * Conflict preview — detect and show what another agent changed in files
+ * you're about to write, before you write them.
+ *
+ * Uses the ownership map + git diff to surface inter-agent conflicts
+ * before they become merge problems.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getOwnership } from "./coordinator.js";
+const exec = promisify(execFile);
+/**
+ * Preview conflicts before writing to files.
+ *
+ * Checks the ownership map and git status to show what another agent
+ * has changed in files you want to write. Call this before claiming
+ * ownership or writing.
+ */
+export async function previewConflicts(projectRoot, agent, paths) {
+    const ownership = await getOwnership(projectRoot);
+    const conflicts = [];
+    const safe = [];
+    for (const path of paths) {
+        // Check if any ownership claim covers this path
+        let conflicting = null;
+        for (const claim of ownership.values()) {
+            if (claim.agent === agent)
+                continue; // Skip own claims
+            for (const ownedPath of claim.paths) {
+                if (pathOverlaps(path, ownedPath)) {
+                    conflicting = { agent: claim.agent, mode: claim.mode };
+                    break;
+                }
+            }
+            if (conflicting)
+                break;
+        }
+        if (!conflicting) {
+            safe.push(path);
+            continue;
+        }
+        // Get git diff for what the other agent changed
+        const { diff, linesChanged, status } = await getGitDiff(projectRoot, path);
+        conflicts.push({
+            path,
+            owner: conflicting.agent,
+            ownerMode: conflicting.mode,
+            diff,
+            linesChanged,
+            status,
+        });
+    }
+    return {
+        agent,
+        requestedPaths: paths,
+        conflicts,
+        safe,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Format conflict preview for terminal display.
+ */
+export function formatConflictPreview(preview) {
+    const lines = [];
+    if (preview.conflicts.length === 0) {
+        lines.push(`\x1b[32m✓\x1b[0m No conflicts — ${preview.safe.length} path(s) safe to write.`);
+        return lines.join("\n");
+    }
+    lines.push(`\x1b[33m⚠ ${preview.conflicts.length} conflict(s) detected\x1b[0m`);
+    lines.push("");
+    for (const c of preview.conflicts) {
+        const modeIcon = c.ownerMode === "exclusive" ? "🔒" : "🔓";
+        lines.push(`${modeIcon} \x1b[1m${c.path}\x1b[0m — owned by \x1b[36m${c.owner}\x1b[0m (${c.ownerMode})`);
+        if (c.status !== "unchanged") {
+            lines.push(`  ${c.status === "added" ? "➕" : c.status === "deleted" ? "➖" : "✏️"} ${c.linesChanged} line(s) ${c.status}`);
+        }
+        if (c.diff) {
+            // Show first 20 lines of diff
+            const diffLines = c.diff.split("\n").slice(0, 20);
+            for (const dl of diffLines) {
+                if (dl.startsWith("+") && !dl.startsWith("+++")) {
+                    lines.push(`  \x1b[32m${dl}\x1b[0m`);
+                }
+                else if (dl.startsWith("-") && !dl.startsWith("---")) {
+                    lines.push(`  \x1b[31m${dl}\x1b[0m`);
+                }
+                else if (dl.startsWith("@@")) {
+                    lines.push(`  \x1b[36m${dl}\x1b[0m`);
+                }
+            }
+            if (c.diff.split("\n").length > 20) {
+                lines.push(`  ... (${c.diff.split("\n").length - 20} more lines)`);
+            }
+        }
+        lines.push("");
+    }
+    if (preview.safe.length > 0) {
+        lines.push(`\x1b[32m✓\x1b[0m ${preview.safe.length} path(s) safe: ${preview.safe.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function pathOverlaps(requested, owned) {
+    // Normalize trailing slashes
+    const r = requested.replace(/\/$/, "");
+    const o = owned.replace(/\/$/, "");
+    // Exact match
+    if (r === o)
+        return true;
+    // Owned is a directory containing the requested path
+    if (r.startsWith(o + "/"))
+        return true;
+    // Requested is a directory containing the owned path
+    if (o.startsWith(r + "/"))
+        return true;
+    return false;
+}
+async function getGitDiff(projectRoot, path) {
+    try {
+        // Check if path has uncommitted changes
+        const { stdout: statusOut } = await exec("git", ["status", "--porcelain", "--", path], { cwd: projectRoot, timeout: 5000 });
+        if (!statusOut.trim()) {
+            // Check for committed changes vs main
+            try {
+                const { stdout: diffOut } = await exec("git", ["diff", "HEAD~5..HEAD", "--", path], { cwd: projectRoot, timeout: 5000 });
+                if (diffOut.trim()) {
+                    const added = (diffOut.match(/^\+[^+]/gm) ?? []).length;
+                    const removed = (diffOut.match(/^-[^-]/gm) ?? []).length;
+                    return {
+                        diff: diffOut,
+                        linesChanged: added + removed,
+                        status: "modified",
+                    };
+                }
+            }
+            catch {
+                // Not enough history
+            }
+            return { diff: "", linesChanged: 0, status: "unchanged" };
+        }
+        const statusCode = statusOut.trim().slice(0, 2);
+        if (statusCode.includes("A") || statusCode === "??") {
+            return { diff: "", linesChanged: 0, status: "added" };
+        }
+        if (statusCode.includes("D")) {
+            return { diff: "", linesChanged: 0, status: "deleted" };
+        }
+        // Get the actual diff
+        const { stdout: diffOut } = await exec("git", ["diff", "--", path], {
+            cwd: projectRoot,
+            timeout: 5000,
+        });
+        const added = (diffOut.match(/^\+[^+]/gm) ?? []).length;
+        const removed = (diffOut.match(/^-[^-]/gm) ?? []).length;
+        return {
+            diff: diffOut,
+            linesChanged: added + removed,
+            status: "modified",
+        };
+    }
+    catch {
+        return { diff: "", linesChanged: 0, status: "unchanged" };
+    }
+}

package/dist/src/core/coordination/contract-diff.js

@@ -0,0 +1,106 @@
+/**
+ * Contract diffing — when a contract revision bumps, auto-generate
+ * a structured delta showing exactly what changed between revisions.
+ */
+import { readCoordLog } from "./coordinator.js";
+/**
+ * Get all revisions of a named contract from the log.
+ */
+export async function getContractHistory(projectRoot, name) {
+    const log = await readCoordLog(projectRoot);
+    const revisions = [];
+    for (const event of log.events) {
+        if (event.type !== "contract" || !event.payload)
+            continue;
+        const payload = event.payload;
+        if (payload.name !== name)
+            continue;
+        revisions.push({
+            name: payload.name,
+            revision: payload.revision,
+            body: payload.body,
+            format: payload.format,
+            publisher: event.from,
+            eventId: event.id,
+            seq: event.seq,
+            timestamp: event.timestamp,
+        });
+    }
+    return revisions.sort((a, b) => a.revision - b.revision);
+}
+/**
+ * Diff two contract revisions and produce a structured delta.
+ */
+export function diffContracts(from, to) {
+    const fromLines = from.body.split("\n");
+    const toLines = to.body.split("\n");
+    const fromSet = new Set(fromLines);
+    const toSet = new Set(toLines);
+    const added = toLines.filter((l) => !fromSet.has(l) && l.trim());
+    const removed = fromLines.filter((l) => !toSet.has(l) && l.trim());
+    // Line-by-line comparison for changed lines at same positions
+    const changed = [];
+    const maxLines = Math.min(fromLines.length, toLines.length);
+    for (let i = 0; i < maxLines; i++) {
+        if (fromLines[i] !== toLines[i]) {
+            changed.push({ line: i + 1, from: fromLines[i], to: toLines[i] });
+        }
+    }
+    // Summary
+    const parts = [];
+    if (added.length)
+        parts.push(`${added.length} added`);
+    if (removed.length)
+        parts.push(`${removed.length} removed`);
+    if (changed.length)
+        parts.push(`${changed.length} changed`);
+    const summary = parts.length
+        ? `${parts.join(", ")} line(s)`
+        : "No differences";
+    return {
+        name: from.name,
+        fromRevision: from.revision,
+        toRevision: to.revision,
+        fromPublisher: from.publisher,
+        toPublisher: to.publisher,
+        added,
+        removed,
+        changed,
+        summary,
+    };
+}
+/**
+ * Diff the latest two revisions of a named contract.
+ */
+export async function diffLatestContract(projectRoot, name) {
+    const history = await getContractHistory(projectRoot, name);
+    if (history.length < 2)
+        return null;
+    return diffContracts(history[history.length - 2], history[history.length - 1]);
+}
+/**
+ * Format a contract delta for terminal display.
+ */
+export function formatContractDelta(delta) {
+    const lines = [];
+    lines.push(`\x1b[1m${delta.name}\x1b[0m rev${delta.fromRevision} → rev${delta.toRevision}`);
+    lines.push(`  by ${delta.fromPublisher} → ${delta.toPublisher} · ${delta.summary}`);
+    lines.push("");
+    if (delta.removed.length) {
+        for (const r of delta.removed.slice(0, 30)) {
+            lines.push(`\x1b[31m- ${r}\x1b[0m`);
+        }
+        if (delta.removed.length > 30) {
+            lines.push(`  ... ${delta.removed.length - 30} more removed`);
+        }
+    }
+    if (delta.added.length) {
+        for (const a of delta.added.slice(0, 30)) {
+            lines.push(`\x1b[32m+ ${a}\x1b[0m`);
+        }
+        if (delta.added.length > 30) {
+            lines.push(`  ... ${delta.added.length - 30} more added`);
+        }
+    }
+    return lines.join("\n");
+}