martin-loop 0.1.5 → 1.3.0

package/dist/vendor/core/merge/ast-merge.js

@@ -0,0 +1,350 @@
+// ─── AST 3-Way Merge ──────────────────────────────────────────────────────────
+//
+// Deterministic merge of two unified-diff patches against a common base.
+// For .ts/.tsx files: uses ts-morph to detect structural conflicts.
+// For all other file types: falls back to 3-way text merge immediately.
+// ts-morph errors are caught; on failure tsMorphError=true and text merge is used.
+import { Project } from "ts-morph";
+import { textMerge } from "./text-merge.js";
+// ─── Patch parsing / application ─────────────────────────────────────────────
+/** Apply a unified diff patch to a source string (line-level, best-effort). */
+function applyPatch(source, patch) {
+    const lines = source.split("\n");
+    const result = [];
+    let lineIdx = 0;
+    const patchLines = patch.split("\n");
+    let patchIdx = 0;
+    // Skip file headers
+    while (patchIdx < patchLines.length &&
+        ((patchLines[patchIdx]?.startsWith("---") ?? false) ||
+            (patchLines[patchIdx]?.startsWith("+++") ?? false) ||
+            (patchLines[patchIdx]?.startsWith("diff") ?? false))) {
+        patchIdx++;
+    }
+    while (patchIdx < patchLines.length) {
+        const line = patchLines[patchIdx] ?? "";
+        if (line.startsWith("@@")) {
+            const match = line.match(/@@ -(\d+)(?:,\d+)? \+\d+(?:,\d+)? @@/);
+            if (match) {
+                const oldStart = parseInt(match[1] ?? "1", 10) - 1; // 0-based
+                while (lineIdx < oldStart && lineIdx < lines.length) {
+                    result.push(lines[lineIdx] ?? "");
+                    lineIdx++;
+                }
+            }
+            patchIdx++;
+            continue;
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            lineIdx++;
+            patchIdx++;
+        }
+        else if (line.startsWith("+") && !line.startsWith("+++")) {
+            result.push(line.slice(1));
+            patchIdx++;
+        }
+        else if (line.startsWith(" ")) {
+            if (lineIdx < lines.length) {
+                result.push(lines[lineIdx] ?? "");
+                lineIdx++;
+            }
+            patchIdx++;
+        }
+        else {
+            patchIdx++;
+        }
+    }
+    while (lineIdx < lines.length) {
+        result.push(lines[lineIdx] ?? "");
+        lineIdx++;
+    }
+    return result.join("\n");
+}
+// ─── LCS helpers for computeDiff ─────────────────────────────────────────────
+function lcsLines(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            const aLine = a[i - 1];
+            const bLine = b[j - 1];
+            if (aLine !== undefined && bLine !== undefined && aLine === bLine) {
+                dp[i][j] = (dp[i - 1][j - 1] ?? 0) + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j] ?? 0, dp[i][j - 1] ?? 0);
+            }
+        }
+    }
+    const result = [];
+    let i = m;
+    let j = n;
+    while (i > 0 && j > 0) {
+        const aLine = a[i - 1];
+        const bLine = b[j - 1];
+        if (aLine !== undefined && bLine !== undefined && aLine === bLine) {
+            result.unshift(aLine);
+            i--;
+            j--;
+        }
+        else if ((dp[i - 1][j] ?? 0) >= (dp[i][j - 1] ?? 0))
+            i--;
+        else
+            j--;
+    }
+    return result;
+}
+/** Compute a minimal unified diff string from original → modified using LCS. */
+function computeDiff(original, modified, filePath) {
+    if (original === modified)
+        return "";
+    const oLines = original.split("\n");
+    const mLines = modified.split("\n");
+    const hunks = [`--- a/${filePath}`, `+++ b/${filePath}`];
+    const common = lcsLines(oLines, mLines);
+    const ops = [];
+    let oi = 0;
+    let mi = 0;
+    let ci = 0;
+    while (oi < oLines.length || mi < mLines.length) {
+        const commonLine = common[ci];
+        const originalLine = oLines[oi];
+        const modifiedLine = mLines[mi];
+        if (commonLine !== undefined &&
+            originalLine !== undefined &&
+            modifiedLine !== undefined &&
+            originalLine === commonLine &&
+            modifiedLine === commonLine) {
+            ops.push({ type: "keep", line: commonLine });
+            oi++;
+            mi++;
+            ci++;
+        }
+        else if (modifiedLine !== undefined && (commonLine === undefined || modifiedLine !== commonLine)) {
+            ops.push({ type: "ins", line: modifiedLine });
+            mi++;
+        }
+        else {
+            ops.push({ type: "del", line: originalLine ?? "" });
+            oi++;
+        }
+    }
+    const changed = ops.map((op, idx) => (op.type !== "keep" ? idx : -1)).filter((x) => x >= 0);
+    if (changed.length === 0)
+        return "";
+    const ctx = 3;
+    const start = Math.max(0, changed[0] - ctx);
+    const end = Math.min(ops.length - 1, changed[changed.length - 1] + ctx);
+    const slice = ops.slice(start, end + 1);
+    const delCount = slice.filter((o) => o.type !== "ins").length;
+    const insCount = slice.filter((o) => o.type !== "del").length;
+    hunks.push(`@@ -${start + 1},${delCount} +${start + 1},${insCount} @@`);
+    for (const op of slice) {
+        if (op.type === "keep")
+            hunks.push(` ${op.line}`);
+        else if (op.type === "del")
+            hunks.push(`-${op.line}`);
+        else
+            hunks.push(`+${op.line}`);
+    }
+    return hunks.join("\n");
+}
+// ─── Symbol extraction ────────────────────────────────────────────────────────
+function extractSymbols(sf) {
+    const symbols = new Map();
+    for (const fn of sf.getFunctions()) {
+        const name = fn.getName();
+        if (name)
+            symbols.set(name, fn.getBodyText() ?? "");
+    }
+    for (const cls of sf.getClasses()) {
+        const name = cls.getName();
+        if (name)
+            symbols.set(name, cls.getText());
+    }
+    for (const decl of sf.getVariableDeclarations()) {
+        symbols.set(decl.getName(), decl.getInitializer()?.getText() ?? "");
+    }
+    return symbols;
+}
+function extractImports(sf) {
+    const result = new Set();
+    for (const imp of sf.getImportDeclarations()) {
+        result.add(imp.getText().trim());
+    }
+    return result;
+}
+// ─── AST-level conflict detection & merge ────────────────────────────────────
+function runAstMerge(baseSource, patchA, patchB, filePath) {
+    const sourceA = applyPatch(baseSource, patchA);
+    const sourceB = applyPatch(baseSource, patchB);
+    const project = new Project({ useInMemoryFileSystem: true });
+    const sfBase = project.createSourceFile("base.ts", baseSource);
+    const sfA = project.createSourceFile("a.ts", sourceA);
+    const sfB = project.createSourceFile("b.ts", sourceB);
+    const baseSymbols = extractSymbols(sfBase);
+    const aSymbols = extractSymbols(sfA);
+    const bSymbols = extractSymbols(sfB);
+    const baseImports = extractImports(sfBase);
+    const aImports = extractImports(sfA);
+    const bImports = extractImports(sfB);
+    // Detect changed/deleted symbols per patch
+    const aChanged = new Set();
+    const aDeleted = new Set();
+    for (const [name, body] of baseSymbols) {
+        if (!aSymbols.has(name))
+            aDeleted.add(name);
+        else if (aSymbols.get(name) !== body)
+            aChanged.add(name);
+    }
+    const bChanged = new Set();
+    const bDeleted = new Set();
+    for (const [name, body] of baseSymbols) {
+        if (!bSymbols.has(name))
+            bDeleted.add(name);
+        else if (bSymbols.get(name) !== body)
+            bChanged.add(name);
+    }
+    // delete_vs_modify conflicts
+    for (const name of aDeleted) {
+        if (bChanged.has(name)) {
+            return {
+                conflict: true,
+                conflictType: "delete_vs_modify",
+                conflictReport: `Symbol '${name}' was deleted by patchA but modified by patchB.`,
+                mergeType: "ast"
+            };
+        }
+    }
+    for (const name of bDeleted) {
+        if (aChanged.has(name)) {
+            return {
+                conflict: true,
+                conflictType: "delete_vs_modify",
+                conflictReport: `Symbol '${name}' was deleted by patchB but modified by patchA.`,
+                mergeType: "ast"
+            };
+        }
+    }
+    // same_function_body conflicts
+    for (const name of aChanged) {
+        if (bChanged.has(name) && aSymbols.get(name) !== bSymbols.get(name)) {
+            return {
+                conflict: true,
+                conflictType: "same_function_body",
+                conflictReport: `Symbol '${name}' was modified by both patchA and patchB with different bodies.`,
+                mergeType: "ast"
+            };
+        }
+    }
+    // Build merged source: start from sourceA, apply B's non-overlapping changes
+    let mergedSource = sourceA;
+    for (const name of bChanged) {
+        if (!aChanged.has(name)) {
+            const aBody = aSymbols.get(name) ?? baseSymbols.get(name);
+            const bBody = bSymbols.get(name);
+            if (aBody !== undefined && bBody !== undefined) {
+                mergedSource = mergedSource.replace(aBody, bBody);
+            }
+        }
+    }
+    // Merge imports: union of A + B, deduplicate
+    const addedByB = [...bImports].filter((imp) => !baseImports.has(imp) && !aImports.has(imp));
+    if (addedByB.length > 0) {
+        const sorted = [...addedByB].sort();
+        const m = mergedSource.match(/^(import[^\n]+\n)+/m);
+        if (m) {
+            const importBlock = m[0] ?? "";
+            const insertPos = (m.index ?? 0) + importBlock.length;
+            mergedSource =
+                mergedSource.slice(0, insertPos) +
+                    sorted.join("\n") +
+                    "\n" +
+                    mergedSource.slice(insertPos);
+        }
+    }
+    // Deduplicate identical import lines
+    const seen = new Set();
+    mergedSource = mergedSource
+        .split("\n")
+        .filter((line) => {
+        if (line.trimStart().startsWith("import ")) {
+            if (seen.has(line))
+                return false;
+            seen.add(line);
+        }
+        return true;
+    })
+        .join("\n");
+    const mergedDiff = computeDiff(baseSource, mergedSource, filePath);
+    return { conflict: false, mergeType: "ast", mergedDiff };
+}
+// ─── Patch overlap helpers ────────────────────────────────────────────────────
+function getPatchFilePath(patch) {
+    const match = patch.match(/^(?:---|\+\+\+) [ab]\/(.+)$/m);
+    return match?.[1] ?? undefined;
+}
+function patchesAreTriviallyNonOverlapping(patchA, patchB) {
+    const pathA = getPatchFilePath(patchA);
+    const pathB = getPatchFilePath(patchB);
+    if (!pathA || !pathB)
+        return false;
+    return pathA !== pathB;
+}
+function isTsFile(filePath) {
+    if (!filePath)
+        return false;
+    return filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+}
+// ─── Text fallback helper ─────────────────────────────────────────────────────
+function textFallback(baseSource, patchA, patchB, filePath, tsMorphError) {
+    const sourceA = applyPatch(baseSource, patchA);
+    const sourceB = applyPatch(baseSource, patchB);
+    const tr = textMerge(baseSource, sourceA, sourceB);
+    const mergedDiff = tr.hasConflicts
+        ? undefined
+        : computeDiff(baseSource, tr.merged, filePath);
+    return {
+        conflict: tr.hasConflicts,
+        mergeType: "text",
+        mergedDiff,
+        conflictReport: tr.hasConflicts
+            ? `Text merge produced ${tr.conflictMarkers} conflict marker(s).`
+            : undefined,
+        ...(tsMorphError ? { tsMorphError: true } : {})
+    };
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+export function astMerge(baseSource, patchA, patchB, options) {
+    const filePath = options?.filePath ?? "file.ts";
+    // Trivial: patches are for different files
+    if (patchesAreTriviallyNonOverlapping(patchA, patchB)) {
+        return {
+            conflict: false,
+            mergeType: "trivial",
+            mergedDiff: patchA + "\n" + patchB
+        };
+    }
+    // Non-TS: text merge immediately
+    if (!isTsFile(filePath)) {
+        return textFallback(baseSource, patchA, patchB, filePath);
+    }
+    // TS: attempt AST merge; wrap ALL ts-morph calls in try/catch
+    try {
+        return runAstMerge(baseSource, patchA, patchB, filePath);
+    }
+    catch {
+        return textFallback(baseSource, patchA, patchB, filePath, true);
+    }
+}
+export function buildMergeArtifact(runId, patchA, patchB, result) {
+    return {
+        runId,
+        patchA,
+        patchB,
+        result,
+        producedAt: new Date().toISOString()
+    };
+}
+//# sourceMappingURL=ast-merge.js.map

package/dist/vendor/core/merge/text-merge.d.ts

@@ -0,0 +1,12 @@
+export interface TextMergeResult {
+    merged: string;
+    hasConflicts: boolean;
+    conflictMarkers: number;
+}
+/**
+ * Standard 3-way text merge.
+ * Applies diffs from base→sideA and base→sideB to reconstruct merged output.
+ * Emits `<<<<<<<` / `=======` / `>>>>>>>` markers only where both sides
+ * changed the same region differently.
+ */
+export declare function textMerge(base: string, sideA: string, sideB: string): TextMergeResult;

package/dist/vendor/core/merge/text-merge.js

@@ -0,0 +1,182 @@
+// ─── 3-Way Text Merge ─────────────────────────────────────────────────────────
+//
+// Standard Myers / patience-style 3-way merge.
+// Produces <<<<<< / ====== / >>>>>> conflict markers only on overlapping hunks.
+// ─── LCS helpers ─────────────────────────────────────────────────────────────
+/** Longest common subsequence of two string arrays. Returns the LCS array. */
+function lcs(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            const aLine = a[i - 1];
+            const bLine = b[j - 1];
+            if (aLine !== undefined && bLine !== undefined && aLine === bLine) {
+                dp[i][j] = (dp[i - 1][j - 1] ?? 0) + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j] ?? 0, dp[i][j - 1] ?? 0);
+            }
+        }
+    }
+    // Backtrack
+    const result = [];
+    let i = m;
+    let j = n;
+    while (i > 0 && j > 0) {
+        const aLine = a[i - 1];
+        const bLine = b[j - 1];
+        if (aLine !== undefined && bLine !== undefined && aLine === bLine) {
+            result.unshift(aLine);
+            i--;
+            j--;
+        }
+        else if ((dp[i - 1][j] ?? 0) >= (dp[i][j - 1] ?? 0)) {
+            i--;
+        }
+        else {
+            j--;
+        }
+    }
+    return result;
+}
+/** Compute line-level diff from base → target using LCS. */
+function lineDiff(base, target) {
+    const common = lcs(base, target);
+    const ops = [];
+    let bi = 0;
+    let ti = 0;
+    let ci = 0;
+    while (bi < base.length || ti < target.length) {
+        const commonLine = common[ci];
+        const baseLine = base[bi];
+        const targetLine = target[ti];
+        if (commonLine !== undefined &&
+            baseLine !== undefined &&
+            targetLine !== undefined &&
+            baseLine === commonLine &&
+            targetLine === commonLine) {
+            ops.push({ type: "keep", line: commonLine });
+            bi++;
+            ti++;
+            ci++;
+        }
+        else if (targetLine !== undefined &&
+            (commonLine === undefined || targetLine !== commonLine)) {
+            ops.push({ type: "insert", line: targetLine });
+            ti++;
+        }
+        else {
+            ops.push({ type: "delete", line: baseLine ?? "" });
+            bi++;
+        }
+    }
+    return ops;
+}
+// ─── 3-Way merge ─────────────────────────────────────────────────────────────
+/**
+ * Standard 3-way text merge.
+ * Applies diffs from base→sideA and base→sideB to reconstruct merged output.
+ * Emits `<<<<<<<` / `=======` / `>>>>>>>` markers only where both sides
+ * changed the same region differently.
+ */
+export function textMerge(base, sideA, sideB) {
+    const baseLines = base.split("\n");
+    const aLines = sideA.split("\n");
+    const bLines = sideB.split("\n");
+    const aDiff = lineDiff(baseLines, aLines);
+    const bDiff = lineDiff(baseLines, bLines);
+    // Walk both diffs in parallel, tracking which lines each side changed
+    const merged = [];
+    let conflictMarkers = 0;
+    let ai = 0;
+    let bi = 0;
+    while (ai < aDiff.length || bi < bDiff.length) {
+        const aOp = aDiff[ai];
+        const bOp = bDiff[bi];
+        if (!aOp && bOp) {
+            if (bOp.type !== "delete")
+                merged.push(bOp.line);
+            bi++;
+            continue;
+        }
+        if (aOp && !bOp) {
+            if (aOp.type !== "delete")
+                merged.push(aOp.line);
+            ai++;
+            continue;
+        }
+        if (!aOp && !bOp)
+            break;
+        const currentA = aOp;
+        const currentB = bOp;
+        // Both sides keep the same line
+        if (currentA.type === "keep" && currentB.type === "keep" && currentA.line === currentB.line) {
+            merged.push(currentA.line);
+            ai++;
+            bi++;
+            continue;
+        }
+        // Only A changed
+        if (currentA.type !== "keep" && currentB.type === "keep") {
+            if (currentA.type === "insert")
+                merged.push(currentA.line);
+            // delete: skip
+            ai++;
+            continue;
+        }
+        // Only B changed
+        if (currentA.type === "keep" && currentB.type !== "keep") {
+            if (currentB.type === "insert")
+                merged.push(currentB.line);
+            // delete: skip
+            bi++;
+            continue;
+        }
+        // Both sides changed — collect diverging hunks
+        const aHunk = [];
+        const bHunk = [];
+        // Drain inserts from A
+        while (ai < aDiff.length && aDiff[ai].type === "insert") {
+            aHunk.push(aDiff[ai].line);
+            ai++;
+        }
+        // Skip deletes from A (base lines removed on A side)
+        while (ai < aDiff.length && aDiff[ai].type === "delete") {
+            ai++;
+        }
+        // Drain inserts from B
+        while (bi < bDiff.length && bDiff[bi].type === "insert") {
+            bHunk.push(bDiff[bi].line);
+            bi++;
+        }
+        // Skip deletes from B
+        while (bi < bDiff.length && bDiff[bi].type === "delete") {
+            bi++;
+        }
+        if (aHunk.length === 0 && bHunk.length === 0) {
+            // Pure deletes on both sides — nothing to emit
+            continue;
+        }
+        // If both hunks are identical, emit once (no conflict)
+        if (JSON.stringify(aHunk) === JSON.stringify(bHunk)) {
+            merged.push(...aHunk);
+            continue;
+        }
+        // Real conflict
+        conflictMarkers++;
+        merged.push("<<<<<<< sideA");
+        merged.push(...aHunk);
+        merged.push("=======");
+        merged.push(...bHunk);
+        merged.push(">>>>>>> sideB");
+    }
+    const mergedStr = merged.join("\n");
+    return {
+        merged: mergedStr,
+        hasConflicts: conflictMarkers > 0,
+        conflictMarkers
+    };
+}
+//# sourceMappingURL=text-merge.js.map

package/dist/vendor/core/otel/tracer.d.ts

@@ -0,0 +1,45 @@
+export interface SpanContext {
+    spanId: string;
+    traceId: string;
+    startTime: string;
+    endTime?: string;
+    attributes: Record<string, string | number | boolean>;
+    name: SpanName;
+    status: "OK" | "ERROR" | "UNSET";
+}
+export type SpanName = "martin.run" | "martin.attempt" | "martin.adapter_call" | "martin.patch_proof" | "martin.leash_check" | "martin.grounding_scan" | "martin.rollback" | "martin.gateway_policy" | "martin.router_decision";
+export declare const VALID_SPAN_NAMES: readonly SpanName[];
+export interface Tracer {
+    startSpan(name: SpanName, attributes?: Record<string, string | number | boolean>): SpanContext;
+    endSpan(span: SpanContext, status?: "OK" | "ERROR"): SpanContext;
+    recordException(span: SpanContext, error: Error): SpanContext;
+}
+/**
+ * Returns all spans collected in the current process.
+ * Useful for test assertions.
+ */
+export declare function getCollectedSpans(): SpanContext[];
+/**
+ * Resets the in-memory span array.
+ * Call this in test beforeEach/afterEach to isolate tests.
+ */
+export declare function clearCollectedSpans(): void;
+export interface TracerOptions {
+    endpoint?: string;
+}
+/**
+ * Creates a tracer instance. When endpoint is undefined or empty, uses the
+ * noop implementation (stores spans in memory, no network calls).
+ * When endpoint is set, the same noop is used — actual OTLP export is a
+ * future enhancement.
+ */
+export declare function createTracer(options?: TracerOptions): Tracer;
+/**
+ * Returns the default module-level tracer singleton.
+ * Initializes with a noop tracer if not already set.
+ */
+export declare function getTracer(): Tracer;
+/**
+ * Resets the default tracer singleton (for testing).
+ */
+export declare function resetDefaultTracer(): void;