@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/dist/clients/read-bridge.js

@@ -0,0 +1,46 @@
+import { registerProcessBridge } from "./process-bridge.js";
+import { captureReadContentBinding } from "./read-guard.js";
+export const READ_BRIDGE_KEY = Symbol.for("dm-lens:read-bridge");
+function isValidEntry(entry) {
+  if (typeof entry !== "object" || entry === null)
+    return false;
+  const e = entry;
+  if (typeof e["filePath"] !== "string" || e["filePath"] === "")
+    return false;
+  const offset = e["requestedOffset"];
+  if (typeof offset !== "number" || !Number.isFinite(offset) || offset < 1 || !Number.isInteger(offset))
+    return false;
+  const limit = e["requestedLimit"];
+  if (limit !== undefined) {
+    if (typeof limit !== "number" || !Number.isFinite(limit) || limit < 1 || !Number.isInteger(limit))
+      return false;
+  }
+  return true;
+}
+export function registerReadBridge(deps) {
+  registerProcessBridge(READ_BRIDGE_KEY, () => ({
+    version: 1,
+    recordRead(entry) {
+      if (!isValidEntry(entry))
+        return;
+      if (!deps.isRecordable(entry.filePath))
+        return;
+      const offset = entry.requestedOffset;
+      const limit = entry.requestedLimit ?? Number.MAX_SAFE_INTEGER;
+      const contentBinding = captureReadContentBinding(entry.filePath, offset, limit);
+      deps.getReadGuard().recordRead({
+        filePath: entry.filePath,
+        requestedOffset: offset,
+        requestedLimit: limit,
+        effectiveOffset: offset,
+        effectiveLimit: limit,
+        expandedByLsp: false,
+        turnIndex: deps.getTurnIndex(),
+        writeIndex: deps.peekWriteIndex(),
+        timestamp: Date.now(),
+        source: `bridge:${entry.consumer ?? "unknown"}`,
+        ...contentBinding !== undefined && { contentBinding }
+      });
+    }
+  }));
+}

package/extensions/dm-lens/dist/clients/read-expansion.js

@@ -0,0 +1,218 @@
+import * as fs from "node:fs";
+import { extname } from "node:path";
+import { withBudget } from "./deadline-utils.js";
+import { EXTENSION_TO_GRAMMAR } from "./language-registry.js";
+export const EXPANSION_LIMIT_LINES = 100;
+const EXPANDED_SIZE_CAP_LINES = 300;
+export const EXPANSION_BUDGET_MS = 200;
+export function readExpansionLanguage(filePath) {
+  return EXTENSION_TO_GRAMMAR[extname(filePath).toLowerCase()];
+}
+const ENCLOSING_TYPES = {
+  typescript: [
+    "function_declaration",
+    "function_expression",
+    "arrow_function",
+    "method_definition",
+    "class_declaration"
+  ],
+  tsx: [
+    "function_declaration",
+    "function_expression",
+    "arrow_function",
+    "method_definition",
+    "class_declaration"
+  ],
+  javascript: [
+    "function_declaration",
+    "function_expression",
+    "arrow_function",
+    "method_definition",
+    "class_declaration"
+  ],
+  python: ["function_definition", "class_definition", "decorated_definition"],
+  go: ["function_declaration", "method_declaration"],
+  rust: ["function_item", "impl_item"],
+  ruby: ["method", "class", "module"],
+  java: [
+    "method_declaration",
+    "constructor_declaration",
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration"
+  ],
+  kotlin: ["function_declaration", "class_declaration", "object_declaration"],
+  dart: [
+    "function_declaration",
+    "method_declaration",
+    "class_definition",
+    "mixin_declaration"
+  ],
+  elixir: ["call"],
+  c: ["function_definition"],
+  cpp: ["function_definition", "class_specifier", "struct_specifier"],
+  csharp: [
+    "method_declaration",
+    "constructor_declaration",
+    "class_declaration",
+    "interface_declaration",
+    "struct_declaration"
+  ],
+  php: ["function_definition", "method_declaration", "class_declaration"],
+  swift: [
+    "function_declaration",
+    "class_declaration",
+    "protocol_declaration",
+    "init_declaration"
+  ],
+  lua: ["function_declaration", "function_definition"],
+  ocaml: ["value_definition", "module_definition"],
+  zig: ["function_declaration"],
+  bash: ["function_definition"]
+};
+function findEnclosingNodeForRange(node, startRow, endRow, types) {
+  const nodeStartRow = node.startPosition?.row ?? 0;
+  const nodeEndRow = node.endPosition?.row ?? nodeStartRow;
+  if (endRow < nodeStartRow || startRow > nodeEndRow)
+    return;
+  for (const child of node.children ?? []) {
+    const match = findEnclosingNodeForRange(child, startRow, endRow, types);
+    if (match)
+      return match;
+  }
+  return types.includes(node.type) ? node : undefined;
+}
+function getSymbolName(node) {
+  for (const child of node.children ?? []) {
+    if (child.type === "identifier" || child.type === "property_identifier" || child.type === "name") {
+      return child.text;
+    }
+  }
+  return node.type;
+}
+function buildAncestryChain(node, types) {
+  const chain = [];
+  let current = node.parent;
+  while (current) {
+    if (types.includes(current.type)) {
+      chain.push({
+        name: getSymbolName(current),
+        kind: current.type,
+        startLine: (current.startPosition?.row ?? 0) + 1
+      });
+    }
+    current = current.parent;
+  }
+  return chain.reverse();
+}
+function tryExpandMarkdownSection(content, requestedStartRow, requestedLimit, totalLines) {
+  const lines = content.split(/\r?\n/);
+  const lastRow = totalLines - 1;
+  let headingLevel = 7;
+  let sectionStartRow = 0;
+  let headingText = "";
+  for (let i = requestedStartRow;i >= 0; i--) {
+    const match = lines[i]?.match(/^(#{1,6})\s+(.*)/);
+    if (match) {
+      headingLevel = match[1].length;
+      sectionStartRow = i;
+      headingText = match[2].trim();
+      break;
+    }
+  }
+  let sectionEndRow = lastRow;
+  for (let i = sectionStartRow + 1;i <= lastRow; i++) {
+    const match = lines[i]?.match(/^(#{1,6})\s+/);
+    if (match && match[1].length <= headingLevel) {
+      sectionEndRow = i - 1;
+      break;
+    }
+  }
+  const expandedStart = sectionStartRow + 1;
+  const expandedEnd = sectionEndRow + 1;
+  const expandedSize = expandedEnd - expandedStart + 1;
+  if (expandedSize > EXPANDED_SIZE_CAP_LINES)
+    return;
+  if (expandedSize <= requestedLimit)
+    return;
+  return {
+    newOffset: expandedStart,
+    newLimit: expandedSize,
+    enclosingSymbol: {
+      name: headingText || "(untitled section)",
+      kind: "markdown_section",
+      startLine: expandedStart,
+      endLine: expandedEnd
+    }
+  };
+}
+export async function tryExpandRead(filePath, requestedOffset, requestedLimit, totalLines, tsClient) {
+  if (requestedLimit > EXPANSION_LIMIT_LINES)
+    return;
+  if (requestedLimit >= totalLines)
+    return;
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  const startedAt = Date.now();
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    if (ext === ".md" || ext === ".mdx") {
+      const requestedStartRow = requestedOffset - 1;
+      const result = tryExpandMarkdownSection(content, requestedStartRow, requestedLimit, totalLines);
+      if (!result)
+        return;
+      return { ...result, durationMs: Date.now() - startedAt };
+    }
+    const languageId = readExpansionLanguage(filePath);
+    if (!languageId)
+      return;
+    const enclosingTypes = ENCLOSING_TYPES[languageId];
+    if (!enclosingTypes)
+      return;
+    const initOk = await withBudget(tsClient.init(), EXPANSION_BUDGET_MS);
+    if (!initOk)
+      return;
+    const remaining = Math.max(0, EXPANSION_BUDGET_MS - (Date.now() - startedAt));
+    const requestedStartRow = requestedOffset - 1;
+    const requestedEndRow = Math.min(totalLines - 1, requestedOffset + requestedLimit - 2);
+    const parsed = await withBudget(tsClient.withParsedTree(filePath, languageId, content, (tree) => {
+      const node = findEnclosingNodeForRange(tree.rootNode, requestedStartRow, requestedEndRow, enclosingTypes);
+      if (!node)
+        return;
+      return {
+        name: getSymbolName(node),
+        kind: node.type,
+        startRow: node.startPosition.row,
+        endRow: node.endPosition?.row ?? node.startPosition.row,
+        ancestry: buildAncestryChain(node, enclosingTypes)
+      };
+    }), remaining);
+    const enclosing = parsed?.parsed ? parsed.value : undefined;
+    if (!enclosing)
+      return;
+    const symbolStart = enclosing.startRow + 1;
+    const symbolEnd = enclosing.endRow + 1;
+    const requestedStartLine = requestedOffset;
+    const requestedEndLine = requestedEndRow + 1;
+    const expandedStart = Math.min(requestedStartLine, symbolStart);
+    const expandedEnd = Math.max(requestedEndLine, symbolEnd);
+    const expandedSize = expandedEnd - expandedStart + 1;
+    if (expandedSize > EXPANDED_SIZE_CAP_LINES)
+      return;
+    if (expandedSize <= requestedLimit)
+      return;
+    return {
+      newOffset: expandedStart,
+      newLimit: expandedSize,
+      enclosingSymbol: {
+        name: enclosing.name,
+        kind: enclosing.kind,
+        startLine: symbolStart,
+        endLine: symbolEnd
+      },
+      ancestry: enclosing.ancestry.length > 0 ? enclosing.ancestry : undefined,
+      durationMs: Date.now() - startedAt
+    };
+  } catch {
+    return;
+  }
+}

package/extensions/dm-lens/dist/clients/read-guard-logger.js

@@ -0,0 +1,178 @@
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+import { normalizeFilePath } from "./path-utils.js";
+import { getTurnId } from "./turn-context.js";
+const READ_GUARD_LOG_DIR = getGlobalDmLensLogDir();
+const READ_GUARD_LOG_FILE = path.join(READ_GUARD_LOG_DIR, "read-guard.log");
+const READ_GUARD_LOG_BACKUP_FILE = path.join(READ_GUARD_LOG_DIR, "read-guard.log.1");
+const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.DM_LENS_READ_GUARD_MAX_BYTES ?? "1048576", 10) || 1048576);
+const writer = createNdjsonLogger({
+  filePath: READ_GUARD_LOG_FILE,
+  maxBytes: MAX_LOG_BYTES,
+  backupPath: READ_GUARD_LOG_BACKUP_FILE
+});
+const VERBOSE_READ_GUARD_LOG = process.env.DM_LENS_READ_GUARD_VERBOSE === "1" || process.env.DM_LENS_READ_GUARD_LOG === "verbose";
+const LOG_ALLOWED_EDITS = process.env.DM_LENS_READ_GUARD_LOG_ALLOWS === "1";
+const SNAPSHOT_LOG_SETTING = (process.env.DM_LENS_READ_GUARD_LOG_SNAPSHOTS ?? "1").toLowerCase();
+const LOG_SNAPSHOT_VALIDATION = !["0", "false", "off"].includes(SNAPSHOT_LOG_SETTING);
+const MAX_EDIT_BATCH_ITEMS = 100;
+let generatedCorrelationCounter = 0;
+export function sanitizeCorrelationId(value) {
+  if (typeof value !== "string" && typeof value !== "number")
+    return;
+  const sanitized = String(value).trim().replace(/[^a-zA-Z0-9._:-]/g, "_").slice(0, 64);
+  return sanitized.length > 0 ? sanitized : undefined;
+}
+export function getReadGuardCorrelationId(event) {
+  const value = event ?? {};
+  const details = value.details ?? {};
+  for (const candidate of [
+    details.readGuardCorrelationId,
+    details.toolCallId,
+    value.toolCallId,
+    value.callId,
+    value.requestId,
+    value.id
+  ]) {
+    const sanitized = sanitizeCorrelationId(candidate);
+    if (sanitized)
+      return sanitized;
+  }
+  generatedCorrelationCounter = (generatedCorrelationCounter + 1) % 1e6;
+  return `rg-${Date.now().toString(36)}-${generatedCorrelationCounter}`;
+}
+function validIndexes(indexes) {
+  return indexes.filter((index) => Number.isInteger(index) && index >= 0);
+}
+export function boundedEditIndexes(indexes) {
+  return [...new Set(validIndexes(indexes))].slice(0, MAX_EDIT_BATCH_ITEMS);
+}
+export function boundedIndexesForCount(count) {
+  const boundedCount = Math.max(0, Math.floor(count));
+  return Array.from({ length: Math.min(boundedCount, MAX_EDIT_BATCH_ITEMS) }, (_, index) => index);
+}
+export function formatBoundedEditIndexes(indexes) {
+  return boundedEditIndexes(indexes).map((index) => `edits[${index}]`).join(", ");
+}
+export function createReadGuardEditBatchSummary(args) {
+  const requestedSource = validIndexes(args.requestedIndexes);
+  const resolvedSource = validIndexes(args.resolvedIndexes ?? []);
+  const rejectedSource = (args.rejectedReasons ?? []).filter((entry) => Number.isInteger(entry.index) && entry.index >= 0);
+  const appliedSource = validIndexes(args.appliedIndexes ?? []);
+  const alreadyAppliedSource = validIndexes(args.alreadyAppliedIndexes ?? []);
+  const requestedIndexes = boundedEditIndexes(requestedSource);
+  const resolvedIndexes = boundedEditIndexes(resolvedSource);
+  const rejectedReasons = rejectedSource.slice(0, MAX_EDIT_BATCH_ITEMS);
+  const rejectedIndexes = boundedEditIndexes(rejectedSource.map((entry) => entry.index));
+  const appliedIndexes = boundedEditIndexes(appliedSource);
+  const alreadyAppliedIndexes = boundedEditIndexes(alreadyAppliedSource);
+  const participantSource = (args.participantIds ?? []).filter((id) => typeof id === "string" && id.length > 0);
+  const participantIds = [...new Set(participantSource)].slice(0, MAX_EDIT_BATCH_ITEMS);
+  const commitStatus = args.commitStatus ?? "not_attempted";
+  const postEditStatus = args.postEditStatus ?? "not_run";
+  const terminalStatus = args.terminalStatus ?? (postEditStatus === "failed" || commitStatus === "failed" ? "failed" : commitStatus === "not_attempted" && rejectedSource.length > 0 ? "blocked" : commitStatus === "no_changes" ? "skipped" : "success");
+  return {
+    requestedCount: requestedSource.length,
+    requestedTotal: args.requestedTotal ?? requestedSource.length,
+    requestedIndexes,
+    resolvedCount: resolvedSource.length,
+    resolvedTotal: args.resolvedTotal ?? resolvedSource.length,
+    resolvedIndexes,
+    rejectedCount: rejectedSource.length,
+    rejectedTotal: args.rejectedTotal ?? rejectedSource.length,
+    rejectedIndexes,
+    rejectedReasons,
+    appliedCount: appliedSource.length,
+    appliedTotal: args.appliedTotal ?? appliedSource.length,
+    appliedIndexes,
+    alreadyAppliedCount: alreadyAppliedSource.length,
+    alreadyAppliedTotal: args.alreadyAppliedTotal ?? alreadyAppliedSource.length,
+    alreadyAppliedIndexes,
+    participantIds,
+    participantTotal: args.participantTotal ?? participantSource.length,
+    participantIdsTruncated: (args.participantTotal ?? participantSource.length) > participantIds.length,
+    indexesTruncated: (args.requestedTotal ?? requestedSource.length) > requestedIndexes.length || (args.resolvedTotal ?? resolvedSource.length) > resolvedIndexes.length || (args.rejectedTotal ?? rejectedSource.length) > rejectedIndexes.length || (args.appliedTotal ?? appliedSource.length) > appliedIndexes.length || (args.alreadyAppliedTotal ?? alreadyAppliedSource.length) > alreadyAppliedIndexes.length,
+    commitStatus,
+    postEditStatus,
+    terminalStatus,
+    durationMs: Math.max(0, Math.min(args.durationMs ?? 0, 86400000))
+  };
+}
+export function shouldLogEvent(event) {
+  if (VERBOSE_READ_GUARD_LOG)
+    return true;
+  if (event === "edit_allowed")
+    return LOG_ALLOWED_EDITS;
+  if (event === "range_snapshot_validation")
+    return LOG_SNAPSHOT_VALIDATION;
+  return event === "edit_blocked" || event === "edit_warned" || event === "exemption_added" || event === "oldtext_not_found" || event === "oldtext_duplicate" || event === "oldtext_indent_autopatched" || event === "oldtext_trailing_ws_autopatched" || event === "oldtext_escape_autopatched" || event === "edit_range_relocated" || event === "edit_preflight_blocked" || event === "edit_partial_apply" || event === "edit_partial_apply_skipped" || event === "edit_partial_apply_rejected" || event === "edit_already_applied_retry" || event === "edit_post_edit_pipeline_failed" || event === "edit_batch_summary" || event === "edit_batch_summary_overflow" || event === "touched_lines_missing" || event === "read_cap_trimmed" || event === "read_file_evicted" || event === "edits_cap_trimmed";
+}
+const MAX_TELEMETRY_STRING = 512;
+const MAX_TELEMETRY_KEYS = 64;
+function boundTelemetryValue(value, pathName, depth) {
+  if (typeof value === "string") {
+    return value.length > MAX_TELEMETRY_STRING ? {
+      value: `${value.slice(0, MAX_TELEMETRY_STRING)}…`,
+      truncated: true,
+      arrayTotals: {}
+    } : { value, truncated: false, arrayTotals: {} };
+  }
+  if (Array.isArray(value)) {
+    const sampled = value.slice(0, MAX_EDIT_BATCH_ITEMS);
+    const bounded = sampled.map((item, index) => boundTelemetryValue(item, `${pathName}[${index}]`, depth + 1));
+    const arrayTotals = value.length > MAX_EDIT_BATCH_ITEMS ? { [pathName || "array"]: value.length } : {};
+    let truncated = value.length > MAX_EDIT_BATCH_ITEMS;
+    for (const item of bounded) {
+      truncated ||= item.truncated;
+      Object.assign(arrayTotals, item.arrayTotals);
+    }
+    return {
+      value: bounded.map((item) => item.value),
+      truncated,
+      arrayTotals
+    };
+  }
+  if (!value || typeof value !== "object" || depth >= 4) {
+    return { value, truncated: false, arrayTotals: {} };
+  }
+  const output = {};
+  let truncated = false;
+  const arrayTotals = {};
+  for (const [key, child] of Object.entries(value).slice(0, MAX_TELEMETRY_KEYS)) {
+    const bounded = boundTelemetryValue(child, pathName ? `${pathName}.${key}` : key, depth + 1);
+    output[key] = bounded.value;
+    truncated ||= bounded.truncated;
+    Object.assign(arrayTotals, bounded.arrayTotals);
+  }
+  if (Object.keys(value).length > MAX_TELEMETRY_KEYS)
+    truncated = true;
+  return { value: output, truncated, arrayTotals };
+}
+export function logReadGuardEvent(entry) {
+  if (isTestMode() || !shouldLogEvent(entry.event)) {
+    return;
+  }
+  const rawMetadata = entry.correlationId ? { ...entry.metadata, correlationId: entry.correlationId } : entry.metadata;
+  const bounded = boundTelemetryValue(rawMetadata, "metadata", 0);
+  const metadata = bounded.truncated && bounded.value && typeof bounded.value === "object" ? {
+    ...bounded.value,
+    telemetryTruncated: true,
+    telemetryArrayTotals: bounded.arrayTotals
+  } : bounded.value && typeof bounded.value === "object" ? bounded.value : undefined;
+  const { correlationId: _correlationId, ...logEntry } = entry;
+  writer.log({
+    ts: new Date().toISOString(),
+    ...logEntry,
+    turnId: getTurnId(),
+    filePath: normalizeFilePath(logEntry.filePath),
+    metadata
+  });
+}
+export function getReadGuardLogPath() {
+  return READ_GUARD_LOG_FILE;
+}
+export function flushReadGuardLog() {
+  return writer.flush();
+}