akm-cli 0.9.0-rc.2 → 0.9.0-rc.4

package/dist/core/file-lock.js

@@ -5,7 +5,7 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { openDatabase } from "../storage/database.js";
-import { isProcessAlive } from "./common.js";
+import { isProcessAlive, MAX_LOCK_METADATA_BYTES, readTextFileDescriptorWithLimit } from "./common.js";
 function readLockSnapshot(lockPath) {
     let fd;
     try {
@@ -17,7 +17,7 @@ function readLockSnapshot(lockPath) {
         throw err;
     }
     try {
-        const rawContent = fs.readFileSync(fd, "utf8");
+        const rawContent = readTextFileDescriptorWithLimit(fd, MAX_LOCK_METADATA_BYTES, "Lock metadata", lockPath);
         const stat = fs.fstatSync(fd);
         return {
             rawContent,

package/dist/core/improve-result.js

@@ -44,8 +44,26 @@ const COMMON_FIELDS = [
     "sync",
     "terminated",
 ];
-const V1_FIELDS = new Set([...COMMON_FIELDS, "profile", "profileFilteredRefs"]);
+const V1_FIELDS = new Set([...COMMON_FIELDS, "profile", "profileFilteredRefs", "stalenessDetection"]);
 const V2_FIELDS = new Set([...COMMON_FIELDS, "strategy", "strategyFilteredRefs"]);
+const STALENESS_DETECTION_FIELDS = new Set([
+    "considered",
+    "deprecated",
+    "confirmed",
+    "skipped",
+    "durationMs",
+    "warnings",
+]);
+const INTERRUPTED_V1_FIELDS = new Set([
+    "schemaVersion",
+    "ok",
+    "profile",
+    "scope",
+    "dryRun",
+    "plannedRefs",
+    "actions",
+    "terminated",
+]);
 function fail(message) {
     throw new Error(`invalid improve-result envelope: ${message}`);
 }
@@ -57,6 +75,33 @@ function requireExactFields(value, allowed) {
     if (unknown.length > 0)
         fail(`unknown field${unknown.length === 1 ? "" : "s"}: ${unknown.sort().join(", ")}`);
 }
+function isKnownInterruptedV1Partial(value) {
+    if (Object.keys(value).some((key) => !INTERRUPTED_V1_FIELDS.has(key)))
+        return false;
+    if (value.ok !== false || typeof value.dryRun !== "boolean")
+        return false;
+    if (value.profile !== undefined && typeof value.profile !== "string")
+        return false;
+    if (!Array.isArray(value.plannedRefs) || value.plannedRefs.length !== 0)
+        return false;
+    if (!Array.isArray(value.actions) || value.actions.length !== 0)
+        return false;
+    if (!isRecord(value.scope))
+        return false;
+    if (Object.keys(value.scope).some((key) => key !== "mode" && key !== "value"))
+        return false;
+    if (value.scope.mode !== "all" && value.scope.mode !== "type" && value.scope.mode !== "ref")
+        return false;
+    if (value.scope.value !== undefined && typeof value.scope.value !== "string")
+        return false;
+    if (!isRecord(value.terminated))
+        return false;
+    if (Object.keys(value.terminated).some((key) => !["reason", "at", "errorMessage"].includes(key)))
+        return false;
+    if (typeof value.terminated.reason !== "string" || typeof value.terminated.at !== "string")
+        return false;
+    return value.terminated.errorMessage === undefined || typeof value.terminated.errorMessage === "string";
+}
 function validateCommon(value) {
     if (typeof value.ok !== "boolean")
         fail("ok must be a boolean");
@@ -131,6 +176,32 @@ function validateCommon(value) {
         if (value[field] !== undefined && !isRecord(value[field]))
             fail(`${field} must be an object`);
     }
+    if (isRecord(value.terminated)) {
+        requireExactFields(value.terminated, new Set(["reason", "at", "errorMessage"]));
+        if (typeof value.terminated.reason !== "string" || typeof value.terminated.at !== "string") {
+            fail("terminated.reason and terminated.at must be strings");
+        }
+        if (value.terminated.errorMessage !== undefined && typeof value.terminated.errorMessage !== "string") {
+            fail("terminated.errorMessage must be a string when present");
+        }
+    }
+}
+function validateV1StalenessDetection(value) {
+    if (value === undefined)
+        return;
+    if (!isRecord(value))
+        fail("stalenessDetection must be an object");
+    const unknown = Object.keys(value).filter((key) => !STALENESS_DETECTION_FIELDS.has(key));
+    if (unknown.length > 0) {
+        fail(`stalenessDetection has unknown field${unknown.length === 1 ? "" : "s"}: ${unknown.sort().join(", ")}`);
+    }
+    for (const field of ["considered", "deprecated", "confirmed", "skipped", "durationMs"]) {
+        if (typeof value[field] !== "number")
+            fail(`stalenessDetection.${field} must be a number`);
+    }
+    if (!Array.isArray(value.warnings) || value.warnings.some((warning) => typeof warning !== "string")) {
+        fail("stalenessDetection.warnings must be an array of strings");
+    }
 }
 /** Decode the persisted public v1/v2 contract without guessing across versions. */
 export function decodeImproveResult(input) {
@@ -146,17 +217,25 @@ export function decodeImproveResult(input) {
     if (!isRecord(parsed))
         fail("root must be an object");
     if (parsed.schemaVersion === 1) {
-        requireExactFields(parsed, V1_FIELDS);
-        validateCommon(parsed);
-        if (parsed.profile !== undefined && typeof parsed.profile !== "string")
+        let normalized = parsed;
+        let normalizedLegacyPartial = false;
+        if (normalized.memorySummary === undefined && isKnownInterruptedV1Partial(normalized)) {
+            normalized = { ...normalized, memorySummary: { eligible: 0, derived: 0 } };
+            normalizedLegacyPartial = true;
+        }
+        requireExactFields(normalized, V1_FIELDS);
+        validateCommon(normalized);
+        validateV1StalenessDetection(normalized.stalenessDetection);
+        if (normalized.profile !== undefined && typeof normalized.profile !== "string")
             fail("profile must be a string");
-        if (parsed.profileFilteredRefs !== undefined && !Array.isArray(parsed.profileFilteredRefs)) {
+        if (normalized.profileFilteredRefs !== undefined && !Array.isArray(normalized.profileFilteredRefs)) {
             fail("profileFilteredRefs must be an array");
         }
         return {
-            envelope: parsed,
+            envelope: normalized,
             strategy: null,
-            legacyProfile: typeof parsed.profile === "string" ? parsed.profile : null,
+            legacyProfile: typeof normalized.profile === "string" ? normalized.profile : null,
+            normalizedLegacyPartial,
         };
     }
     if (parsed.schemaVersion === 2) {
@@ -172,6 +251,7 @@ export function decodeImproveResult(input) {
             envelope: parsed,
             strategy: parsed.strategy,
             legacyProfile: null,
+            normalizedLegacyPartial: false,
         };
     }
     fail(`unsupported schemaVersion: ${String(parsed.schemaVersion)}`);