martin-loop 0.1.4 → 1.3.0

package/dist/vendor/core/graph/adapters.js

@@ -0,0 +1,91 @@
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/**
+ * Abstract interface to ensure the system can hot-swap external graph engines
+ * (like Neo4j) without rewriting the core calculation logic when workspace scale grows.
+ */
+export class AbstractGraphStore {
+}
+export class JsonAdjacencyGraphAdapter extends AbstractGraphStore {
+    adjacencyFilePath;
+    constructor(adjacencyFilePath) {
+        super();
+        this.adjacencyFilePath = adjacencyFilePath;
+    }
+    async queryRegressions(targetFiles, _objective) {
+        try {
+            const data = await fs.readFile(this.adjacencyFilePath, "utf8");
+            const adjacencyList = JSON.parse(data);
+            const hotspots = [];
+            for (const file of targetFiles) {
+                if (adjacencyList[file] && adjacencyList[file].regressionCount > 0) {
+                    hotspots.push(adjacencyList[file]);
+                }
+            }
+            return hotspots;
+        }
+        catch {
+            // If the adjacency file does not exist yet, or parsing fails, return empty context natively
+            return [];
+        }
+    }
+    async ingestRun(_record) {
+        // In a real execution, we parse the record for "verification_failed" events
+        // and upsert the files into the JSON map.
+        // Stubbed for standard interface completion.
+    }
+}
+/**
+ * GitBlameGraphAdapter
+ *
+ * Derives repository hotspots from live git history — no static JSON file required.
+ *
+ * For each target file, runs `git log --oneline --follow -- <file>` to count
+ * how many commits have touched it. Files with a commit count >= the configured
+ * threshold are returned as hotspots. The regression count is the git commit count,
+ * which is a reliable, repo-native signal of churn / instability.
+ *
+ * Fail-open: any git error (not a repo, file not tracked, git not installed) returns
+ * an empty result for that file — never throws.
+ */
+export class GitBlameGraphAdapter extends AbstractGraphStore {
+    repoRoot;
+    commitThreshold;
+    constructor(repoRoot, 
+    /** Files with >= this many commits are classified as hotspots. Default: 5 */
+    commitThreshold = 5) {
+        super();
+        this.repoRoot = repoRoot;
+        this.commitThreshold = commitThreshold;
+    }
+    async queryRegressions(targetFiles, _objective) {
+        const hotspots = [];
+        for (const file of targetFiles) {
+            const count = await this.countCommits(file);
+            if (count >= this.commitThreshold) {
+                hotspots.push({
+                    file,
+                    regressionCount: count,
+                    associatedTaskTypes: ["churn", "high-frequency-change"]
+                });
+            }
+        }
+        return hotspots;
+    }
+    async ingestRun(_record) {
+        // Live adapter — reads directly from git history, no ingest needed.
+    }
+    async countCommits(file) {
+        try {
+            const { stdout } = await execFileAsync("git", ["log", "--oneline", "--follow", "--", file], { cwd: this.repoRoot });
+            return stdout.trim().split("\n").filter(Boolean).length;
+        }
+        catch {
+            // git not available, file not tracked, or not inside a git repo — safe fallback
+            return 0;
+        }
+    }
+}
+//# sourceMappingURL=adapters.js.map

package/dist/vendor/core/graph/hotspots.d.ts

@@ -0,0 +1,22 @@
+import type { LoopMemoryStore } from "../memory/palace.js";
+import type { MartinGraphAdapter } from "./adapters.js";
+export interface RepoHotspot {
+    file: string;
+    regressionCount: number;
+    lastFailureClass?: string;
+    associatedTaskTypes: string[];
+}
+export interface GraphContextAssembly {
+    hotspotsDetected: RepoHotspot[];
+    suggestedContextAdditions: string[];
+}
+export declare class MartinGraph {
+    private readonly memoryStore?;
+    private readonly graphAdapter?;
+    constructor(memoryStore?: LoopMemoryStore | undefined, graphAdapter?: MartinGraphAdapter | undefined);
+    /**
+     * Translates a raw array of memory briefs into a structural hotspot map identifying
+     * files that frequently fail verification or cause rollbacks.
+     */
+    assembleHotspotContext(targetFiles: string[], objective: string): Promise<GraphContextAssembly>;
+}

package/dist/vendor/core/graph/hotspots.js

@@ -0,0 +1,30 @@
+export class MartinGraph {
+    memoryStore;
+    graphAdapter;
+    constructor(memoryStore, graphAdapter) {
+        this.memoryStore = memoryStore;
+        this.graphAdapter = graphAdapter;
+    }
+    /**
+     * Translates a raw array of memory briefs into a structural hotspot map identifying
+     * files that frequently fail verification or cause rollbacks.
+     */
+    async assembleHotspotContext(targetFiles, objective) {
+        if (!this.memoryStore && !this.graphAdapter) {
+            return { hotspotsDetected: [], suggestedContextAdditions: [] };
+        }
+        try {
+            // Pull real statistics from the underlying database / persistence layer
+            const hotspots = this.graphAdapter
+                ? await this.graphAdapter.queryRegressions(targetFiles, objective)
+                : [];
+            const riskyFiles = hotspots.filter((h) => h.regressionCount > 2);
+            const suggestedContextAdditions = riskyFiles.map((h) => `CRITICAL: The file '${h.file}' has regressed ${h.regressionCount} times in similar past tasks. Double-check types and imports before patching.`);
+            return { hotspotsDetected: hotspots, suggestedContextAdditions };
+        }
+        catch {
+            return { hotspotsDetected: [], suggestedContextAdditions: [] };
+        }
+    }
+}
+//# sourceMappingURL=hotspots.js.map

package/dist/vendor/core/graph/index.d.ts

@@ -0,0 +1 @@
+export * from "./hotspots.js";

package/dist/vendor/core/graph/index.js

@@ -0,0 +1,2 @@
+export * from "./hotspots.js";
+//# sourceMappingURL=index.js.map

package/dist/vendor/core/honey/honey-tokens.d.ts

@@ -0,0 +1,32 @@
+export interface HoneyTokenSet {
+    runId: string;
+    tokens: string[];
+}
+export interface Patch {
+    patchId: string;
+    diff: string;
+    changedFiles: string[];
+}
+export interface HoneyTokenViolation {
+    trapId: "T13";
+    severity: "block";
+    description: string;
+    matchedToken: string;
+}
+/**
+ * Generates 3 HMAC-derived canary symbols per run.
+ *
+ * Properties:
+ * - Deterministic: same runId + secret always produces same tokens
+ * - Isolated: different runIds produce different tokens (no cross-run reuse)
+ * - Format: __martin_canary_{hmac_prefix}__
+ */
+export declare function generateHoneyTokenSet(runId: string, secret: string): HoneyTokenSet;
+/**
+ * Scans a patch diff for any honey token references.
+ * Pure string grep — zero model calls, zero API cost.
+ *
+ * Returns T13 GroundingViolation if a canary token appears in the patch,
+ * null if the patch is clean.
+ */
+export declare function scanPatchForHoneyTokens(patch: Patch, tokens: HoneyTokenSet): HoneyTokenViolation | null;

package/dist/vendor/core/honey/honey-tokens.js

@@ -0,0 +1,44 @@
+import { createHmac } from "node:crypto";
+// ─── Token Generation ─────────────────────────────────────────────────────────
+/**
+ * Generates 3 HMAC-derived canary symbols per run.
+ *
+ * Properties:
+ * - Deterministic: same runId + secret always produces same tokens
+ * - Isolated: different runIds produce different tokens (no cross-run reuse)
+ * - Format: __martin_canary_{hmac_prefix}__
+ */
+export function generateHoneyTokenSet(runId, secret) {
+    const tokens = [];
+    for (let i = 0; i < 3; i++) {
+        const hmac = createHmac("sha256", secret)
+            .update(`${runId}:canary:${i}`)
+            .digest("hex");
+        // Use a deterministic 16-char prefix per slot to keep tokens distinct
+        const prefix = hmac.slice(i * 8, i * 8 + 16);
+        tokens.push(`__martin_canary_${prefix}__`);
+    }
+    return { runId, tokens };
+}
+// ─── Scan ─────────────────────────────────────────────────────────────────────
+/**
+ * Scans a patch diff for any honey token references.
+ * Pure string grep — zero model calls, zero API cost.
+ *
+ * Returns T13 GroundingViolation if a canary token appears in the patch,
+ * null if the patch is clean.
+ */
+export function scanPatchForHoneyTokens(patch, tokens) {
+    for (const token of tokens.tokens) {
+        if (patch.diff.includes(token)) {
+            return {
+                trapId: "T13",
+                severity: "block",
+                description: `Honey token reference detected in patch ${patch.patchId} — instant rejection.`,
+                matchedToken: token
+            };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=honey-tokens.js.map

package/dist/vendor/core/index.d.ts

@@ -1,18 +1,20 @@
-import { type ApprovalPolicy, type CostProvenance, type ExecutionProfile, type FailureClass, type InterventionType, type LoopArtifact, type LoopAttempt, type LoopBudget, type LoopRecord, type LoopTask } from "../contracts/index.js";
+import { type ApprovalPolicy, type CostProvenance, type ExecutionProfile, type FailureClass, type InterventionType, type LoopArtifact, type LoopAttempt, type LoopBudget, type MutationMode, type LoopRecord, type LoopTask } from "../contracts/index.js";
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, type ExitDecision } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
 import { captureRollbackBoundary, restoreRollbackBoundary } from "./rollback.js";
 import { type RunStore } from "./persistence/index.js";
-export type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase } from "../contracts/index.js";
+export type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase } from "../contracts/index.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, restoreRollbackBoundary };
 export type { BudgetPreflightDecision, BudgetPreflightInput, CostGovernorState, EvidenceVectorInput, EvaluatedPatchDecision, ExitDecision, FailureAssessment, PatchDecisionInput, RecoveryDecision, RecoveryRecipe } from "./policy.js";
 export type { ResolvedExecutionProfile, SafetyLeashDecision, SafetyViolation } from "./leash.js";
 export type { GroundingScanResult, GroundingViolation, GroundingViolationKind, RepoGroundingHit, RepoGroundingIndex } from "./grounding.js";
+export { runContextIntegrityPrecheck } from "./context-integrity.js";
+export type { ContextIntegrityPrecheck, ContextIntegrityVerdict } from "./context-integrity.js";
 export { compilePromptPacket } from "./compiler.js";
 export type { PromptPacket, CompilerAdapterRequest } from "./compiler.js";
-export { createFileRunStore, makeLedgerEvent, resolveRunsRoot } from "./persistence/index.js";
-export type { AttemptArtifacts, LedgerEvent, LedgerEventKind, RunContract, RunStore } from "./persistence/index.js";
+export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile, resolveRunsRoot } from "./persistence/index.js";
+export type { AttemptArtifacts, LedgerEvent, LedgerEventKind, LoopAttemptRecord, LoopRunRecord, RunContract, RunStore } from "./persistence/index.js";
 export { compileAndPersistContext } from "./persistence/index.js";
 export type { CompileResult } from "./persistence/index.js";
 export interface MartinAdapterRequest {
@@ -23,6 +25,7 @@ export interface MartinAdapterRequest {
         objective: string;
         verificationPlan: string[];
         verificationStack?: LoopTask["verificationStack"];
+        mutationMode?: MutationMode;
         /** Absolute path to the repository root. */
         repoRoot?: string;
         /** Glob patterns for files the agent may modify. Empty = no restriction. */