@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/partial-edit-apply.js

@@ -0,0 +1,337 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { writeFileAtomic } from "./atomic-write.js";
+import { createFileTime } from "./file-time.js";
+import { detectLineEnding, normalizeToLF, restoreLineEndings } from "./host-edit-normalize.js";
+import { PathKeyedMap } from "./path-keyed-map.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { boundedEditIndexes, createReadGuardEditBatchSummary, formatBoundedEditIndexes, logReadGuardEvent } from "./read-guard-logger.js";
+const MAX_APPLIED_RECORDS_PER_FILE = 8;
+export const MAX_APPLIED_RECORD_FILES = 64;
+export function stripOldTextTrailingWhitespace(value) {
+  const lines = value.replace(/\r\n/g, `
+`).split(`
+`).map((l) => l.trimEnd());
+  while (lines.length > 1 && lines[lines.length - 1] === "")
+    lines.pop();
+  return lines.join(`
+`);
+}
+function editPairDigest(oldText, newText) {
+  return createHash("sha256").update(JSON.stringify([oldText, newText ?? ""]), "utf8").digest("hex");
+}
+function countLfOccurrences(content, needle) {
+  if (!needle)
+    return 0;
+  let count = 0;
+  let pos = 0;
+  while (pos < content.length) {
+    const idx = content.indexOf(needle, pos);
+    if (idx === -1)
+      break;
+    count += 1;
+    pos = idx + needle.length;
+  }
+  return count;
+}
+export function isExactAppliedRetry(args) {
+  const { contentLf, oldKey, newKey, contentHash, expectedContentHash, expectedAfterWriteHash } = args;
+  const haveExpectedHash = expectedContentHash !== undefined || expectedAfterWriteHash !== undefined;
+  if (haveExpectedHash) {
+    const matchesKnownState = contentHash !== undefined && (contentHash === expectedContentHash || contentHash === expectedAfterWriteHash);
+    if (!matchesKnownState)
+      return false;
+  }
+  if (!oldKey)
+    return false;
+  if (newKey === "")
+    return countLfOccurrences(contentLf, oldKey) === 0;
+  if (!newKey.includes(oldKey)) {
+    return countLfOccurrences(contentLf, oldKey) === 0 && countLfOccurrences(contentLf, newKey) >= 1;
+  }
+  const newOccurrences = [];
+  let pos = 0;
+  while (pos < contentLf.length) {
+    const idx = contentLf.indexOf(newKey, pos);
+    if (idx === -1)
+      break;
+    newOccurrences.push([idx, idx + newKey.length]);
+    pos = idx + newKey.length;
+  }
+  if (newOccurrences.length === 0)
+    return false;
+  pos = 0;
+  while (pos < contentLf.length) {
+    const idx = contentLf.indexOf(oldKey, pos);
+    if (idx === -1)
+      break;
+    const end = idx + oldKey.length;
+    if (!newOccurrences.some(([s, e]) => s <= idx && e >= end))
+      return false;
+    pos = end;
+  }
+  return true;
+}
+
+export class PartialApplyRecordStore {
+  files = new PathKeyedMap(normalizeMapKey, MAX_APPLIED_RECORD_FILES);
+  find(filePath, oldText, newText) {
+    if (!oldText)
+      return;
+    const pairDigest = editPairDigest(oldText, newText);
+    const records = this.files.get(filePath) ?? [];
+    return records.find((r) => r.pairDigest === pairDigest);
+  }
+  record(filePath, oldText, newText, contentHash) {
+    if (!oldText)
+      return;
+    const pairDigest = editPairDigest(oldText, newText);
+    const records = this.files.get(filePath) ?? [];
+    const existing = records.findIndex((r) => r.pairDigest === pairDigest);
+    if (existing >= 0)
+      records.splice(existing, 1);
+    const entry = {
+      pairDigest,
+      contentHash: contentHash ?? hashFile(filePath),
+      appliedAtMs: Date.now()
+    };
+    if (records.length >= MAX_APPLIED_RECORDS_PER_FILE)
+      records.shift();
+    records.push(entry);
+    this.files.set(filePath, records);
+  }
+  noteAfterWriteHash(filePath, oldText, newText, afterWriteContentHash) {
+    if (!oldText)
+      return;
+    const pairDigest = editPairDigest(oldText, newText);
+    const record = this.files.get(filePath)?.find((r) => r.pairDigest === pairDigest);
+    if (record)
+      record.afterWriteContentHash = afterWriteContentHash;
+  }
+  clear() {
+    this.files.clear();
+  }
+  get fileCount() {
+    return this.files.size;
+  }
+}
+const fileLock = createFileTime("partial-edit-apply");
+function hashBytes(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function hashFile(filePath) {
+  try {
+    return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+  } catch {
+    return;
+  }
+}
+
+class PartialApplyRejectionError extends Error {
+  reason;
+  detail;
+  constructor(reason, detail) {
+    super(detail);
+    this.reason = reason;
+    this.detail = detail;
+    this.name = "PartialApplyRejectionError";
+  }
+}
+export async function applyPartiallyApplicableEdits(args) {
+  const startedAt = Date.now();
+  const summaryRef = args.summary;
+  const correlationId = args.correlationId;
+  const logBatchEvent = (entry) => logReadGuardEvent({ ...entry, correlationId });
+  const reject = (reason, detail) => {
+    logBatchEvent({
+      event: "edit_partial_apply_rejected",
+      filePath: args.filePath,
+      metadata: {
+        tool: "edit",
+        rejectionReason: reason,
+        detail,
+        editCount: args.edits.length
+      }
+    });
+    return {
+      appliedCount: 0,
+      appliedTotal: 0,
+      appliedIndices: "",
+      postEditStatus: "not_run",
+      rejected: { reason, detail }
+    };
+  };
+  if (args.edits.length === 0) {
+    return reject("invalid_batch", "no preflight-approved edits were carried into the apply step");
+  }
+  const snapshot = args.edits[0].snapshot;
+  for (const edit of args.edits) {
+    if (edit.snapshot.hash !== snapshot.hash) {
+      return reject("invalid_batch", "carried edits reference different snapshot identities; the batch must be rebuilt from one preflight");
+    }
+  }
+  const commit = () => {
+    const rawBytes = fs.readFileSync(args.filePath);
+    if (hashBytes(rawBytes) !== snapshot.hash) {
+      throw new PartialApplyRejectionError("stale_snapshot", "the file changed since the preflight resolved these edits; rebuild the edit from the current content");
+    }
+    const raw = rawBytes.toString("utf8");
+    const ending = detectLineEnding(raw);
+    const lf = normalizeToLF(raw);
+    const ordered = [...args.edits].sort((a, b) => a.spanStart - b.spanStart);
+    for (let i = 0;i < ordered.length; i += 1) {
+      const edit = ordered[i];
+      if (lf.slice(edit.spanStart, edit.spanEnd) !== edit.appliedSpanText) {
+        throw new PartialApplyRejectionError("span_changed", `edits[${edit.originalIndex}] span no longer holds the text the preflight approved; the batch must be rebuilt from a fresh preflight`);
+      }
+      if (i > 0) {
+        const prev = ordered[i - 1];
+        if (edit.spanStart < prev.spanEnd) {
+          throw new PartialApplyRejectionError("span_overlap", `edits[${prev.originalIndex}] and edits[${edit.originalIndex}] resolved to overlapping spans; extend one oldText to disambiguate the location`);
+        }
+      }
+    }
+    let committed = lf;
+    for (let i = ordered.length - 1;i >= 0; i -= 1) {
+      const edit = ordered[i];
+      const newText = normalizeToLF(edit.newText ?? "");
+      committed = committed.slice(0, edit.spanStart) + newText + committed.slice(edit.spanEnd);
+    }
+    const output = restoreLineEndings(committed, ending);
+    const targetPath = fs.lstatSync(args.filePath).isSymbolicLink() ? fs.realpathSync(args.filePath) : args.filePath;
+    const mode = fs.statSync(args.filePath).mode & 4095;
+    writeFileAtomic(targetPath, output, {
+      bestEffort: false,
+      mode
+    });
+    return hashBytes(Buffer.from(output, "utf8"));
+  };
+  let commitStatus = "committed";
+  let committedContentHash;
+  try {
+    await fileLock.withLock(args.filePath, async () => {
+      committedContentHash = commit();
+      for (const edit of args.edits) {
+        args.recordStore?.record(args.filePath, edit.oldText, edit.newText, committedContentHash);
+      }
+    });
+  } catch (error) {
+    if (error instanceof PartialApplyRejectionError) {
+      commitStatus = "not_attempted";
+      const baseSummary = summaryRef ?? createReadGuardEditBatchSummary({
+        requestedIndexes: boundedEditIndexes(args.edits.map((edit) => edit.originalIndex)),
+        requestedTotal: args.edits.length
+      });
+      const summary = createReadGuardEditBatchSummary({
+        ...baseSummary,
+        participantIds: correlationId ? [...baseSummary.participantIds, correlationId] : baseSummary.participantIds,
+        participantTotal: correlationId ? baseSummary.participantTotal + 1 : baseSummary.participantTotal,
+        commitStatus,
+        postEditStatus: "not_run",
+        terminalStatus: "blocked",
+        durationMs: Date.now() - startedAt
+      });
+      logBatchEvent({
+        event: "edit_batch_summary",
+        filePath: args.filePath,
+        metadata: { tool: "edit", editBatchSummary: summary }
+      });
+      return reject(error.reason, error.detail);
+    }
+    commitStatus = "failed";
+    if (summaryRef || correlationId) {
+      const summary = createReadGuardEditBatchSummary({
+        ...summaryRef ?? {
+          requestedIndexes: boundedEditIndexes(args.edits.map((edit) => edit.originalIndex)),
+          requestedTotal: args.edits.length
+        },
+        appliedIndexes: [],
+        appliedTotal: 0,
+        participantIds: correlationId ? [correlationId] : undefined,
+        participantTotal: correlationId ? 1 : undefined,
+        commitStatus,
+        terminalStatus: "failed",
+        durationMs: Date.now() - startedAt
+      });
+      logBatchEvent({
+        event: "edit_batch_summary",
+        filePath: args.filePath,
+        metadata: { tool: "edit", editBatchSummary: summary }
+      });
+    }
+    throw error;
+  }
+  let postEditOutput;
+  let postEditStatus = "not_run";
+  if (args.afterWrite) {
+    try {
+      postEditOutput = await args.afterWrite();
+      postEditStatus = "succeeded";
+      if (args.recordStore) {
+        const afterWriteHash = hashFile(args.filePath);
+        if (afterWriteHash !== undefined && afterWriteHash !== committedContentHash) {
+          for (const edit of args.edits) {
+            args.recordStore.noteAfterWriteHash(args.filePath, edit.oldText, edit.newText, afterWriteHash);
+          }
+        }
+      }
+    } catch (error) {
+      postEditStatus = "failed";
+      if (!summaryRef && !correlationId)
+        throw error;
+    }
+  }
+  const appliedIndexes = boundedEditIndexes(args.edits.map((edit) => edit.originalIndex));
+  if (!summaryRef && !correlationId) {
+    return {
+      appliedCount: args.edits.length,
+      appliedTotal: args.edits.length,
+      appliedIndices: formatBoundedEditIndexes(appliedIndexes),
+      postEditOutput,
+      postEditStatus
+    };
+  }
+  const baseSummary = summaryRef ?? createReadGuardEditBatchSummary({
+    requestedIndexes: appliedIndexes,
+    requestedTotal: args.edits.length,
+    resolvedIndexes: appliedIndexes,
+    resolvedTotal: args.edits.length
+  });
+  const summary = createReadGuardEditBatchSummary({
+    ...baseSummary,
+    appliedIndexes,
+    appliedTotal: args.edits.length,
+    participantIds: correlationId ? [...baseSummary.participantIds, correlationId] : baseSummary.participantIds,
+    participantTotal: correlationId ? baseSummary.participantTotal + 1 : baseSummary.participantTotal,
+    commitStatus,
+    postEditStatus,
+    terminalStatus: postEditStatus === "failed" ? "failed" : "success",
+    durationMs: Date.now() - startedAt
+  });
+  if (postEditStatus === "failed") {
+    logBatchEvent({
+      event: "edit_post_edit_pipeline_failed",
+      filePath: args.filePath,
+      metadata: {
+        tool: "edit",
+        commitStatus,
+        appliedCount: args.edits.length,
+        appliedIndexes,
+        appliedTotal: args.edits.length
+      }
+    });
+  }
+  logBatchEvent({
+    event: "edit_batch_summary",
+    filePath: args.filePath,
+    metadata: { tool: "edit", editBatchSummary: summary }
+  });
+  return {
+    appliedCount: args.edits.length,
+    appliedTotal: args.edits.length,
+    appliedIndices: formatBoundedEditIndexes(appliedIndexes),
+    postEditOutput,
+    postEditStatus,
+    summary
+  };
+}

package/extensions/dm-lens/dist/clients/path-attribution-telemetry.js

@@ -0,0 +1,31 @@
+import { logLatency } from "./latency-logger.js";
+import { getProcessSingleton } from "./process-singletons.js";
+const VERIFIED_GUESS_FAMILY = "path-attribution-verified-guess-count";
+const VERIFIED_GUESS_VERSION = 1;
+function verifiedGuessCount() {
+  return getProcessSingleton(VERIFIED_GUESS_FAMILY, VERIFIED_GUESS_VERSION, () => ({
+    count: 0
+  }));
+}
+export function recordVerifiedPathAttributionGuess() {
+  verifiedGuessCount().count += 1;
+}
+export function getVerifiedPathAttributionGuessCount() {
+  return verifiedGuessCount().count;
+}
+export function emitVerifiedPathAttributionRollup(filePath) {
+  const cell = verifiedGuessCount();
+  if (cell.count === 0)
+    return;
+  logLatency({
+    type: "phase",
+    phase: "path_attribution_verified_rollup",
+    filePath,
+    durationMs: 0,
+    metadata: { count: cell.count }
+  });
+  cell.count = 0;
+}
+export function resetVerifiedPathAttributionGuessCount() {
+  verifiedGuessCount().count = 0;
+}

package/extensions/dm-lens/dist/clients/path-keyed-map.js

@@ -0,0 +1,57 @@
+import { BoundedFifoMap } from "./bounded-cache.js";
+
+export class PathKeyedMap {
+  normalize;
+  store;
+  constructor(normalize, maxEntries) {
+    this.normalize = normalize;
+    this.store = maxEntries === undefined ? new Map : new BoundedFifoMap(maxEntries);
+  }
+  get size() {
+    return this.store.size;
+  }
+  get(path) {
+    return this.store.get(this.normalize(path))?.value;
+  }
+  has(path) {
+    return this.store.has(this.normalize(path));
+  }
+  set(path, value) {
+    this.store.set(this.normalize(path), { displayPath: path, value });
+    return this;
+  }
+  delete(path) {
+    if (this.store.delete(this.normalize(path)))
+      return true;
+    for (const [key, entry] of this.store) {
+      if (entry.displayPath !== path)
+        continue;
+      this.store.delete(key);
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    this.store.clear();
+  }
+  *keys() {
+    for (const entry of this.store.values())
+      yield entry.displayPath;
+  }
+  *values() {
+    for (const entry of this.store.values())
+      yield entry.value;
+  }
+  *entries() {
+    for (const entry of this.store.values())
+      yield [entry.displayPath, entry.value];
+  }
+  forEach(callback) {
+    for (const entry of this.store.values()) {
+      callback(entry.value, entry.displayPath, this);
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}