martin-loop 0.1.4 → 1.3.0

package/dist/vendor/core/memory/palace.js

@@ -0,0 +1,379 @@
+import { createHash } from "node:crypto";
+import { appendFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { resolveMartinHome } from "../attestation/sign.js";
+import { loadActiveLearningHeuristics, runPromotionPipeline } from "./learning-pipeline.js";
+// ─── Stop words for relevance scoring ────────────────────────────────────────
+const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "for",
+    "from",
+    "into",
+    "keep",
+    "loop",
+    "not",
+    "the",
+    "this",
+    "that",
+    "with",
+    "without"
+]);
+// ─── Public API ───────────────────────────────────────────────────────────────
+export function resolveMemoryRoot(env = process.env) {
+    return env["MARTIN_MEMORY_DIR"]?.trim() || join(resolveMartinHome(), "memory");
+}
+export function createFileLoopMemoryStore(options = {}) {
+    const memoryRoot = options.memoryRoot ?? resolveMemoryRoot();
+    return {
+        async recall(input) {
+            const wingKey = buildWingKey(input.workspaceId, input.projectId);
+            const wingPath = join(memoryRoot, slugifyKey(wingKey));
+            const roomNames = await safeReaddir(wingPath);
+            const activeHeuristics = await loadActiveLearningHeuristics(memoryRoot);
+            if (roomNames.length === 0) {
+                return undefined;
+            }
+            const queryTokens = buildQueryTokens(input.objective, input.focus, input.previousAttempts);
+            const lastAttempt = input.previousAttempts.at(-1);
+            const scoredEntries = [];
+            for (const roomName of roomNames) {
+                if (roomName === "wing.json") {
+                    continue;
+                }
+                const drawers = await readDrawersFile(join(wingPath, roomName, "drawers.jsonl"));
+                for (const drawer of drawers) {
+                    const { score, reason } = scoreDrawer(drawer, queryTokens, lastAttempt, activeHeuristics.recallScoring);
+                    if (score <= 0) {
+                        continue;
+                    }
+                    scoredEntries.push({
+                        drawerId: drawer.drawerId,
+                        roomKey: drawer.roomKey,
+                        lesson: drawer.lesson,
+                        content: drawer.content,
+                        sourceRunId: drawer.sourceRunId,
+                        ...(drawer.sourceAttemptIndex !== undefined
+                            ? { sourceAttemptIndex: drawer.sourceAttemptIndex }
+                            : {}),
+                        score,
+                        reason
+                    });
+                }
+            }
+            const entries = scoredEntries
+                .sort((left, right) => right.score - left.score)
+                .slice(0, Math.max(1, input.limit ?? 3));
+            if (entries.length === 0) {
+                return undefined;
+            }
+            if (input.currentRunId && input.currentAttemptIndex !== undefined) {
+                await persistRecallAudit({
+                    memoryRoot,
+                    wingKey,
+                    runId: input.currentRunId,
+                    attemptIndex: input.currentAttemptIndex,
+                    entries
+                });
+            }
+            return {
+                wingKey,
+                recalledAt: new Date().toISOString(),
+                entries
+            };
+        },
+        async recordLoop(input) {
+            const wingKey = buildWingKey(input.loop.workspaceId, input.loop.projectId);
+            const wingPath = join(memoryRoot, slugifyKey(wingKey));
+            const drawers = buildMemoryDrawers(input);
+            const grouped = new Map();
+            for (const drawer of drawers) {
+                const bucket = grouped.get(drawer.roomKey) ?? [];
+                bucket.push(drawer);
+                grouped.set(drawer.roomKey, bucket);
+            }
+            await mkdir(wingPath, { recursive: true });
+            await writeJsonFile(join(wingPath, "wing.json"), {
+                wingKey,
+                workspaceId: input.loop.workspaceId,
+                projectId: input.loop.projectId,
+                roomCount: grouped.size,
+                updatedAt: input.loop.updatedAt
+            });
+            for (const [roomKey, roomDrawers] of grouped.entries()) {
+                const roomPath = join(wingPath, slugifyKey(roomKey));
+                const previousDrawers = await readDrawersFile(join(roomPath, "drawers.jsonl"));
+                await mkdir(roomPath, { recursive: true });
+                await writeJsonFile(join(roomPath, "room.json"), {
+                    wingKey,
+                    roomKey,
+                    roomTitle: roomDrawers[0]?.roomTitle ?? roomKey,
+                    roomType: roomDrawers[0]?.outcome === "failure" ? "failure" : "outcome",
+                    drawerCount: previousDrawers.length + roomDrawers.length,
+                    lastRunId: input.loop.loopId,
+                    updatedAt: input.loop.updatedAt
+                });
+                const payload = roomDrawers.map((drawer) => JSON.stringify(drawer)).join("\n");
+                await appendFile(join(roomPath, "drawers.jsonl"), `${payload}\n`, "utf8");
+            }
+            return {
+                roomCount: grouped.size,
+                drawerCount: drawers.length
+            };
+        },
+        async recordPriorLearning(input) {
+            // Phase 30 — Guarded Promotion Pipeline
+            // Runs the full shadow → holdout → approval gate pipeline before any
+            // heuristic insight is promoted to active status. Fail-open: any error
+            // keeps existing heuristics active and appends to audit log only.
+            const auditPath = join(memoryRoot, "prior-learning-audit.jsonl");
+            try {
+                const candidateId = `cand_${createHash("sha256")
+                    .update(JSON.stringify({ ...input, ts: Date.now() }))
+                    .digest("hex")
+                    .slice(0, 16)}`;
+                const existingScores = Array.isArray(input["existingScores"])
+                    ? input["existingScores"]
+                    : [];
+                const candidateScores = Array.isArray(input["candidateScores"])
+                    ? input["candidateScores"]
+                    : [];
+                const holdoutExistingScores = Array.isArray(input["holdoutExistingScores"])
+                    ? input["holdoutExistingScores"]
+                    : [];
+                const holdoutCandidateScores = Array.isArray(input["holdoutCandidateScores"])
+                    ? input["holdoutCandidateScores"]
+                    : [];
+                const candidate = {
+                    candidateId,
+                    sourceRunId: typeof input["sourceRunId"] === "string" ? input["sourceRunId"] : "unknown",
+                    heuristicFamily: typeof input["heuristicFamily"] === "string" ? input["heuristicFamily"] : "recall_scoring",
+                    description: typeof input["description"] === "string" ? input["description"] : "Prior learning candidate",
+                    payload: input,
+                    status: "pending_shadow",
+                    createdAt: new Date().toISOString()
+                };
+                const result = await runPromotionPipeline({
+                    candidate,
+                    existingScores,
+                    candidateScores,
+                    holdoutExistingScores,
+                    holdoutCandidateScores,
+                    pipelineRoot: memoryRoot
+                });
+                const auditEntry = JSON.stringify({
+                    candidateId,
+                    promoted: result.promoted,
+                    reason: result.reason,
+                    timestamp: new Date().toISOString()
+                });
+                await appendFile(auditPath, `${auditEntry}\n`, "utf8");
+            }
+            catch {
+                // Fail-open: append raw input to audit log, never block the caller
+                const fallbackEntry = JSON.stringify({ ...input, timestamp: new Date().toISOString() });
+                await appendFile(auditPath, `${fallbackEntry}\n`, "utf8");
+            }
+        }
+    };
+}
+function buildMemoryDrawers(input) {
+    const wingKey = buildWingKey(input.loop.workspaceId, input.loop.projectId);
+    const createdAt = input.loop.updatedAt;
+    const drawers = input.loop.attempts.map((attempt) => {
+        const failureClass = attempt.failureClass;
+        const roomKey = failureClass ? `failure/${failureClass}` : "outcome/completion";
+        const roomTitle = failureClass
+            ? `Failure · ${failureClass}`
+            : "Outcome · completion";
+        const lesson = failureClass
+            ? `A similar loop hit ${failureClass}${attempt.intervention ? ` and required ${attempt.intervention}` : ""}. Reuse that narrower recovery before widening scope or changing model.`
+            : `A similar loop completed without widening scope. Reuse the same narrow, verifier-first shape before trying a broader patch.`;
+        const content = [
+            input.loop.task.title,
+            input.loop.task.objective,
+            attempt.summary,
+            attempt.verifierSummary
+        ]
+            .filter((value) => Boolean(value?.trim()))
+            .join(" ");
+        return {
+            drawerId: buildDrawerId(input.loop.loopId, roomKey, attempt.index, createdAt),
+            wingKey,
+            roomKey,
+            roomTitle,
+            workspaceId: input.loop.workspaceId,
+            projectId: input.loop.projectId,
+            sourceRunId: input.loop.loopId,
+            sourceAttemptIndex: attempt.index,
+            outcome: failureClass ? "failure" : "completion",
+            ...(failureClass ? { failureClass } : {}),
+            ...(attempt.intervention ? { intervention: attempt.intervention } : {}),
+            tags: compact([
+                failureClass,
+                attempt.intervention,
+                ...extractPathTags(input.loop.task.allowedPaths)
+            ]),
+            tokens: buildDrawerTokens(content, failureClass, attempt.intervention),
+            lesson,
+            content,
+            createdAt
+        };
+    });
+    const runRoomKey = input.status === "completed" ? "outcome/completed" : "outcome/exited";
+    const runLesson = input.status === "completed"
+        ? `A prior loop finished inside the declared contract. Prefer the same bounded route before widening files, network, or dependency scope.`
+        : `A prior loop exited in ${input.lifecycleState}. Preserve the guardrail and avoid forcing a fake completion.`;
+    const runContent = [
+        input.loop.task.title,
+        input.loop.task.objective,
+        input.reason
+    ]
+        .filter((value) => Boolean(value?.trim()))
+        .join(" ");
+    drawers.push({
+        drawerId: buildDrawerId(input.loop.loopId, runRoomKey, 0, createdAt),
+        wingKey,
+        roomKey: runRoomKey,
+        roomTitle: input.status === "completed" ? "Outcome · completed" : "Outcome · exited",
+        workspaceId: input.loop.workspaceId,
+        projectId: input.loop.projectId,
+        sourceRunId: input.loop.loopId,
+        outcome: input.status === "completed" ? "completion" : "exit",
+        tags: compact([
+            input.status,
+            input.lifecycleState,
+            ...extractPathTags(input.loop.task.allowedPaths)
+        ]),
+        tokens: buildDrawerTokens(runContent, undefined, undefined),
+        lesson: runLesson,
+        content: runContent,
+        createdAt
+    });
+    return drawers;
+}
+function scoreDrawer(drawer, queryTokens, lastAttempt, heuristics) {
+    const reasons = [];
+    let score = 0;
+    if (lastAttempt?.failureClass && drawer.failureClass === lastAttempt.failureClass) {
+        score += heuristics.failureClassWeight;
+        reasons.push("matched failure class");
+    }
+    if (lastAttempt?.intervention && drawer.intervention === lastAttempt.intervention) {
+        score += heuristics.interventionWeight;
+        reasons.push("matched intervention");
+    }
+    const overlap = countIntersection(queryTokens, drawer.tokens);
+    if (overlap > 0) {
+        score += overlap * heuristics.tokenOverlapWeight;
+        reasons.push("matched objective tokens");
+    }
+    if (drawer.outcome === "completion") {
+        score += heuristics.completionWeight;
+        reasons.push("completion memory");
+    }
+    return {
+        score,
+        reason: reasons.join(" and ")
+    };
+}
+function buildQueryTokens(objective, focus, attempts) {
+    const lastAttempt = attempts.at(-1);
+    return uniqueTokens([
+        ...tokenize(objective),
+        ...tokenize(focus),
+        ...tokenize(lastAttempt?.summary ?? ""),
+        ...(lastAttempt?.failureClass ? [lastAttempt.failureClass] : []),
+        ...(lastAttempt?.intervention ? [lastAttempt.intervention] : [])
+    ]);
+}
+function buildDrawerTokens(content, failureClass, intervention) {
+    return uniqueTokens([
+        ...tokenize(content),
+        ...(failureClass ? [failureClass] : []),
+        ...(intervention ? [intervention] : [])
+    ]);
+}
+function tokenize(value) {
+    return (value.toLowerCase().match(/[a-z0-9_/-]{3,}/g) ?? []).filter((token) => !STOP_WORDS.has(token));
+}
+function uniqueTokens(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function countIntersection(left, right) {
+    const rightSet = new Set(right);
+    return left.filter((token) => rightSet.has(token)).length;
+}
+function extractPathTags(paths) {
+    return compact((paths ?? [])
+        .map((path) => path.split(/[\\/]/u)[0])
+        .filter((segment) => Boolean(segment && segment !== "**" && segment.trim().length > 0)));
+}
+function buildWingKey(workspaceId, projectId) {
+    return `${workspaceId}::${projectId}`;
+}
+function buildDrawerId(runId, roomKey, attemptIndex, createdAt) {
+    return createHash("sha256")
+        .update(`${runId}:${roomKey}:${String(attemptIndex)}:${createdAt}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+function slugifyKey(value) {
+    return value
+        .replace(/::/g, "--")
+        .replace(/[^a-zA-Z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+}
+async function readDrawersFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        return raw
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+async function safeReaddir(directory) {
+    try {
+        return await readdir(directory);
+    }
+    catch {
+        return [];
+    }
+}
+async function persistRecallAudit(input) {
+    const wingPath = join(input.memoryRoot, slugifyKey(input.wingKey));
+    await mkdir(wingPath, { recursive: true });
+    const recalledAt = new Date().toISOString();
+    const payload = input.entries
+        .map((entry) => JSON.stringify({
+        recallId: createHash("sha256")
+            .update(`${input.runId}:${String(input.attemptIndex)}:${entry.drawerId}:${recalledAt}`)
+            .digest("hex")
+            .slice(0, 16),
+        wingKey: input.wingKey,
+        roomKey: entry.roomKey,
+        drawerId: entry.drawerId,
+        runId: input.runId,
+        attemptIndex: input.attemptIndex,
+        recallScore: entry.score,
+        recallReason: entry.reason,
+        recalledAt
+    }))
+        .join("\n");
+    await appendFile(join(wingPath, "recalls.jsonl"), `${payload}\n`, "utf8");
+}
+async function writeJsonFile(path, value) {
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function compact(values) {
+    return values.filter((value) => Boolean(value?.trim()));
+}
+//# sourceMappingURL=palace.js.map

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

@@ -0,0 +1,22 @@
+export type MergeType = "ast" | "text" | "trivial";
+export type ConflictType = "same_function_body" | "delete_vs_modify" | "symbol_conflict";
+export interface MergeResult {
+    conflict: boolean;
+    conflictType?: ConflictType;
+    conflictReport?: string;
+    mergedDiff?: string;
+    mergeType: MergeType;
+    tsMorphError?: boolean;
+}
+export interface MergeArtifact {
+    runId: string;
+    patchA: string;
+    patchB: string;
+    result: MergeResult;
+    producedAt: string;
+}
+export declare function astMerge(baseSource: string, patchA: string, patchB: string, options?: {
+    filePath?: string;
+    runId?: string;
+}): MergeResult;
+export declare function buildMergeArtifact(runId: string, patchA: string, patchB: string, result: MergeResult): MergeArtifact;