@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/clients/bundled-resource-health.js

@@ -1,41 +0,0 @@
-import * as fs from "node:fs";
-import { incrementDegradationCount } from "./degradation-ledger.js";
-import { notifyUserDegradation } from "./user-notify.js";
-export function classifyBundledResourceDir(dir, countEntries = (d) => fs.readdirSync(d).length) {
-  let entryCount;
-  try {
-    entryCount = countEntries(dir);
-  } catch (error) {
-    const fsErrorCode = error?.code ?? "UNKNOWN";
-    if (fsErrorCode === "ENOENT")
-      return { status: "absent" };
-    return { status: "unreadable", fsErrorCode };
-  }
-  return entryCount > 0 ? { status: "healthy", entryCount } : { status: "empty" };
-}
-export function describeBundledResourceHealth(health, dir, emptyDescription = `${dir} exists but holds nothing`) {
-  switch (health.status) {
-    case "absent":
-      return `no such directory: ${dir}`;
-    case "unreadable":
-      return `cannot read ${dir} (${health.fsErrorCode})`;
-    case "empty":
-      return emptyDescription;
-    default:
-      return `${dir}: unexpected health status`;
-  }
-}
-export function reportBundledResourceDirHealth(kind, dir, health, label, reasonOverride, notifyMessage) {
-  if (health.status === "healthy")
-    return;
-  const reason = reasonOverride ?? describeBundledResourceHealth(health, dir);
-  const isFirstOccurrence = incrementDegradationCount({
-    kind,
-    subject: dir,
-    reason,
-    metadata: health.status === "unreadable" ? { fsErrorCode: health.fsErrorCode } : undefined
-  });
-  if (isFirstOccurrence) {
-    notifyUserDegradation(notifyMessage ?? `dm-lens: ${label} unavailable — ${reason}.`, "warning");
-  }
-}

package/extensions/dm-lens/dist/clients/bus-events-logger.js

@@ -1,48 +0,0 @@
-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 { getMaxLogSizeMB } from "./log-cleanup.js";
-import { logLatency } from "./latency-logger.js";
-const BUS_EVENTS_LOG_FILE = path.join(getGlobalDmLensLogDir(), "bus-events.log");
-const writer = createNdjsonLogger({
-  filePath: BUS_EVENTS_LOG_FILE,
-  maxBytes: getMaxLogSizeMB() * 1024 * 1024
-});
-const eventRollupCounts = new Map;
-function bumpRollupCount(event, outcome) {
-  const existing = eventRollupCounts.get(event) ?? {
-    emitted: 0,
-    skipped_stale_session: 0,
-    emit_failed: 0
-  };
-  existing[outcome] += 1;
-  eventRollupCounts.set(event, existing);
-}
-export function logBusEvent(entry) {
-  if (entry.outcome === "emitted" || entry.outcome === "skipped_stale_session" || entry.outcome === "emit_failed") {
-    bumpRollupCount(entry.event, entry.outcome);
-  }
-  if (isTestMode()) {
-    return;
-  }
-  writer.log({ ts: new Date().toISOString(), ...entry });
-}
-export function getBusEventRollupCounts() {
-  return Object.fromEntries(eventRollupCounts);
-}
-export function resetBusEventRollupCounts() {
-  eventRollupCounts.clear();
-}
-export function emitBusEventRollupAtSessionEnd(cwd) {
-  for (const [event, counts] of eventRollupCounts) {
-    logLatency({
-      type: "phase",
-      phase: "session_end_bus_rollup",
-      filePath: cwd,
-      durationMs: 0,
-      metadata: { event, ...counts }
-    });
-  }
-  resetBusEventRollupCounts();
-}

package/extensions/dm-lens/dist/clients/bus-publish.js

@@ -1,117 +0,0 @@
-import { logBusEvent } from "./bus-events-logger.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { appendRecentTouches } from "./recent-touches.js";
-import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter } from "./live-bus-emitter.js";
-export const BUS_FILES_TOUCHED_EVENT = "dmlens:files:touched";
-export const BUS_FILES_TOUCHED_VERSION = 1;
-const BUS_LOG_PATH_CAP = 64;
-const liveEmitter = createLiveBusEmitter();
-let hasLoggedFailure = false;
-let hasLoggedUnwired = false;
-let hasLoggedDisabled = false;
-export function wireBusEmitter(emitFn) {
-  liveEmitter.wire(emitFn);
-}
-export function wireBusEmitterGetter(getter) {
-  liveEmitter.wireGetter(getter);
-}
-export function _resetForTests() {
-  liveEmitter.reset();
-  hasLoggedFailure = false;
-  hasLoggedUnwired = false;
-  hasLoggedDisabled = false;
-  _envCache = undefined;
-}
-let _envCache;
-export function isBusPublishEnabled() {
-  if (_envCache === undefined) {
-    _envCache = process.env.DM_LENS_BUS_PUBLISH !== "0";
-  }
-  return _envCache;
-}
-export function publishFilesTouched(args) {
-  if (args.origin === "bus")
-    return;
-  if (args.paths.length === 0)
-    return;
-  if (!isBusPublishEnabled()) {
-    if (!hasLoggedDisabled) {
-      hasLoggedDisabled = true;
-      logBusEvent({
-        event: BUS_FILES_TOUCHED_EVENT,
-        outcome: "skipped_disabled",
-        cwd: normalizeFilePath(args.cwd),
-        reason: args.reason
-      });
-    }
-    return;
-  }
-  appendRecentTouches({
-    cwd: args.cwd,
-    reason: args.reason,
-    paths: args.paths,
-    sessionId: args.sessionId
-  }).catch((err) => {
-    args.dbg?.(`bus-publish: recent-touches append failed: ${err}`);
-  });
-  const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
-    event: BUS_FILES_TOUCHED_EVENT,
-    cwd: normalizeFilePath(args.cwd),
-    reason: args.reason
-  }));
-  if (resolution.outcome === "stale-session")
-    return;
-  if (resolution.outcome === "unwired") {
-    if (!hasLoggedUnwired) {
-      hasLoggedUnwired = true;
-      logBusEvent({
-        event: BUS_FILES_TOUCHED_EVENT,
-        outcome: "skipped_unwired",
-        cwd: normalizeFilePath(args.cwd),
-        reason: args.reason
-      });
-    }
-    return;
-  }
-  const busEmit = resolution.emit;
-  try {
-    const payload = {
-      v: BUS_FILES_TOUCHED_VERSION,
-      source: "dm-lens",
-      reason: args.reason,
-      paths: args.paths.map((p) => normalizeFilePath(p)),
-      cwd: normalizeFilePath(args.cwd)
-    };
-    if (args.fixes && args.fixes.length > 0) {
-      payload.fixes = args.fixes.map((f) => ({
-        ...f,
-        path: normalizeFilePath(f.path)
-      }));
-    }
-    busEmit(BUS_FILES_TOUCHED_EVENT, payload);
-    hasLoggedFailure = false;
-    logBusEvent({
-      event: BUS_FILES_TOUCHED_EVENT,
-      outcome: "emitted",
-      cwd: payload.cwd,
-      reason: args.reason,
-      fileCount: payload.paths.length,
-      writer: "dm-lens",
-      paths: payload.paths.slice(0, BUS_LOG_PATH_CAP)
-    });
-  } catch (err) {
-    logBusEvent({
-      event: BUS_FILES_TOUCHED_EVENT,
-      outcome: "emit_failed",
-      cwd: normalizeFilePath(args.cwd),
-      reason: args.reason,
-      error: String(err),
-      ctxSource: resolution.ctxSource
-    });
-    if (!hasLoggedFailure) {
-      hasLoggedFailure = true;
-      recordStaleBusFailure(BUS_FILES_TOUCHED_EVENT, err);
-      args.dbg?.(`bus-publish: dmlens:files:touched emit failed (further failures suppressed): ${err}`);
-    }
-  }
-}

package/extensions/dm-lens/dist/clients/cache/rule-cache.js

@@ -1,103 +0,0 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { reportBundledResourceDirHealth } from "../bundled-resource-health.js";
-import { getProjectDataDir } from "../file-utils.js";
-import { readJsonCache } from "../json-cache-read.js";
-import { BUNDLED_QUERIES_ROOT, getBundledQueriesRootHealth } from "../tree-sitter-query-loader.js";
-import { writeFileAtomic } from "../atomic-write.js";
-import { compareOrdinal } from "../string-utils.js";
-export const CACHE_VERSION = "v7";
-export { BUNDLED_QUERIES_ROOT as BUNDLED_RULES_ROOT } from "../tree-sitter-query-loader.js";
-function isBundledRuleFile(resolvedFile) {
-  return resolvedFile === BUNDLED_QUERIES_ROOT || resolvedFile.startsWith(BUNDLED_QUERIES_ROOT + path.sep);
-}
-function reportBundledRulesRootHealth() {
-  reportBundledResourceDirHealth("tree-sitter-queries-dir-missing", BUNDLED_QUERIES_ROOT, getBundledQueriesRootHealth(), "bundled tree-sitter query rules");
-}
-
-export class RuleCache {
-  cacheFile;
-  cacheDir;
-  language;
-  constructor(language, rootDir = process.cwd()) {
-    this.language = language;
-    reportBundledRulesRootHealth();
-    this.cacheDir = path.join(getProjectDataDir(rootDir), "cache");
-    this.cacheFile = path.join(this.cacheDir, `${language}-rules-${CACHE_VERSION}.json`);
-  }
-  ensureCacheDir() {
-    if (!fs.existsSync(this.cacheDir)) {
-      fs.mkdirSync(this.cacheDir, { recursive: true });
-    }
-  }
-  computeRuleHash(ruleFiles) {
-    const hash = crypto.createHash("sha256");
-    for (const file of ruleFiles.sort(compareOrdinal)) {
-      const resolved = path.resolve(file);
-      if (!fs.existsSync(resolved))
-        continue;
-      const stat = fs.statSync(resolved);
-      hash.update(`${file}:${stat.mtimeMs}:${stat.size}`);
-      if (!isBundledRuleFile(resolved)) {
-        hash.update(fs.readFileSync(resolved));
-      }
-    }
-    return hash.digest("hex").slice(0, 16);
-  }
-  get(ruleFiles) {
-    try {
-      this.ensureCacheDir();
-      if (!fs.existsSync(this.cacheFile))
-        return null;
-      const currentHash = this.computeRuleHash(ruleFiles);
-      const cached = readJsonCache(this.cacheFile, (parsed) => {
-        const entry = parsed;
-        if (entry.version !== CACHE_VERSION || entry.ruleHash !== currentHash) {
-          return;
-        }
-        return entry;
-      });
-      return cached ?? null;
-    } catch {
-      return null;
-    }
-  }
-  set(ruleFiles, queries) {
-    try {
-      this.ensureCacheDir();
-      const entry = {
-        version: CACHE_VERSION,
-        timestamp: Date.now(),
-        ruleHash: this.computeRuleHash(ruleFiles),
-        queries
-      };
-      writeFileAtomic(this.cacheFile, JSON.stringify(entry, null, 2));
-      this.pruneStaleVersions();
-    } catch {}
-  }
-  pruneStaleVersions() {
-    const currentName = path.basename(this.cacheFile);
-    const pattern = new RegExp(`^${this.language}-rules-v\\d+\\.json$`);
-    let dirents;
-    try {
-      dirents = fs.readdirSync(this.cacheDir);
-    } catch {
-      return;
-    }
-    for (const name of dirents) {
-      if (name === currentName || !pattern.test(name))
-        continue;
-      try {
-        fs.unlinkSync(path.join(this.cacheDir, name));
-      } catch {}
-    }
-  }
-  clear() {
-    try {
-      if (fs.existsSync(this.cacheFile)) {
-        fs.unlinkSync(this.cacheFile);
-      }
-    } catch {}
-  }
-}

package/extensions/dm-lens/dist/clients/cache-manager.js

@@ -1,340 +0,0 @@
-import { createSubsystemLogger } from "./extension-log.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getProjectDataDir } from "./file-utils.js";
-import { writeFileAtomic } from "./atomic-write.js";
-import { readJsonCache, readJsonCacheAsync } from "./json-cache-read.js";
-import { isUnderDir, normalizeMapKey } from "./path-utils.js";
-const DEFAULT_MAX_AGE_MS = 30 * 60 * 1000;
-const DEFAULT_TURN_STATE = {
-  files: {},
-  turnCycles: 0,
-  maxCycles: 3,
-  lastUpdated: ""
-};
-export const MCP_TURN_STATE_OWNER_ID = `mcp-${process.pid}`;
-const TURN_OWNER_STALE_MS = 30 * 60 * 1000;
-function getLensDir(cwd) {
-  return getProjectDataDir(cwd);
-}
-function getCacheDir(cwd) {
-  return path.join(getLensDir(cwd), "cache");
-}
-function getTurnStatePath(cwd) {
-  return path.join(getLensDir(cwd), "turn-state.json");
-}
-
-export class CacheManager {
-  log;
-  constructor(verbose = false) {
-    this.log = verbose ? createSubsystemLogger("cache") : () => {};
-  }
-  toTurnStateKey(filePath, cwd) {
-    const cwdNorm = normalizeMapKey(path.resolve(cwd));
-    const fileNorm = normalizeMapKey(path.resolve(cwd, filePath));
-    const rel = path.relative(cwdNorm, fileNorm).replace(/\\/g, "/");
-    if (!rel || rel === ".")
-      return fileNorm;
-    if (rel === ".." || rel.startsWith("../"))
-      return fileNorm;
-    return rel;
-  }
-  isTurnStatePathWithinRoot(filePath, projectRoot) {
-    const root = path.resolve(projectRoot);
-    const abs = path.resolve(root, filePath);
-    if (normalizeMapKey(abs) === normalizeMapKey(root))
-      return false;
-    return isUnderDir(abs, root);
-  }
-  getTurnFileState(filePath, cwd) {
-    const state = this.readTurnState(cwd);
-    const key = this.toTurnStateKey(filePath, cwd);
-    return state.files[key];
-  }
-  freshAgeMs(scanner, meta, maxAgeMs) {
-    const age = Date.now() - new Date(meta.timestamp).getTime();
-    if (age > maxAgeMs) {
-      this.log(`Cache stale: ${scanner} (age: ${Math.round(age / 1000)}s, max: ${maxAgeMs / 1000}s)`);
-      return null;
-    }
-    return age;
-  }
-  async readCacheAsync(scanner, cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
-    const cachePath = path.join(getCacheDir(cwd), `${scanner}.json`);
-    const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
-    const onReadError = (err) => {
-      this.log(`Cache miss: ${scanner} — ${err}`);
-    };
-    const meta = await readJsonCacheAsync(metaPath, (parsed) => parsed, onReadError);
-    if (meta === undefined)
-      return null;
-    const age = this.freshAgeMs(scanner, meta, maxAgeMs);
-    if (age === null)
-      return null;
-    const data = await readJsonCacheAsync(cachePath, (parsed) => parsed, onReadError);
-    if (data === undefined)
-      return null;
-    this.log(`Cache hit: ${scanner} (age: ${Math.round(age / 1000)}s)`);
-    return { data, meta };
-  }
-  readCache(scanner, cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
-    const cachePath = path.join(getCacheDir(cwd), `${scanner}.json`);
-    const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
-    if (!fs.existsSync(cachePath) || !fs.existsSync(metaPath)) {
-      this.log(`Cache miss: ${scanner} (files don't exist)`);
-      return null;
-    }
-    try {
-      const onReadError = (err) => {
-        this.log(`Cache read error: ${scanner} — ${err}`);
-      };
-      const meta = readJsonCache(metaPath, (parsed) => parsed, onReadError);
-      if (meta === undefined)
-        return null;
-      const age = this.freshAgeMs(scanner, meta, maxAgeMs);
-      if (age === null)
-        return null;
-      const data = readJsonCache(cachePath, (parsed) => parsed, onReadError);
-      if (data === undefined)
-        return null;
-      this.log(`Cache hit: ${scanner} (age: ${Math.round(age / 1000)}s)`);
-      return { data, meta };
-    } catch (err) {
-      this.log(`Cache read error: ${scanner} — ${err}`);
-      return null;
-    }
-  }
-  writeCache(scanner, data, cwd, extraMeta) {
-    const cacheDir = getCacheDir(cwd);
-    fs.mkdirSync(cacheDir, { recursive: true });
-    const cachePath = path.join(cacheDir, `${scanner}.json`);
-    const metaPath = path.join(cacheDir, `${scanner}.meta.json`);
-    const meta = {
-      timestamp: new Date().toISOString(),
-      ...extraMeta
-    };
-    writeFileAtomic(cachePath, JSON.stringify(data, null, 2), {
-      bestEffort: false
-    });
-    writeFileAtomic(metaPath, JSON.stringify(meta, null, 2), {
-      bestEffort: false
-    });
-    this.log(`Cache written: ${scanner}`);
-  }
-  inspectCache(scanner, cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
-    const cachePath = path.join(getCacheDir(cwd), `${scanner}.json`);
-    const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
-    for (const cachePathname of [cachePath, metaPath]) {
-      try {
-        fs.statSync(cachePathname);
-      } catch (err) {
-        if (err.code === "ENOENT")
-          return "missing";
-        return "unreadable";
-      }
-    }
-    try {
-      const meta = readJsonCache(metaPath, (parsed) => parsed);
-      if (!meta || typeof meta.timestamp !== "string")
-        return "malformed";
-      const timestamp = new Date(meta.timestamp).getTime();
-      if (!Number.isFinite(timestamp))
-        return "malformed";
-      const age = Date.now() - timestamp;
-      if (age < 0 || age > maxAgeMs)
-        return age < 0 ? "malformed" : "stale";
-      const data = readJsonCache(cachePath, (parsed) => parsed);
-      return data === undefined ? "malformed" : "fresh";
-    } catch {
-      return "unreadable";
-    }
-  }
-  isCacheFresh(scanner, cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
-    const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
-    if (!fs.existsSync(metaPath))
-      return false;
-    try {
-      const meta = readJsonCache(metaPath, (parsed) => parsed);
-      if (meta === undefined)
-        return false;
-      const age = Date.now() - new Date(meta.timestamp).getTime();
-      return age <= maxAgeMs;
-    } catch {
-      return false;
-    }
-  }
-  clearCache(scanner, cwd) {
-    const cachePath = path.join(getCacheDir(cwd), `${scanner}.json`);
-    const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
-    for (const p of [cachePath, metaPath]) {
-      try {
-        fs.unlinkSync(p);
-      } catch (err) {
-        if (err.code !== "ENOENT") {
-          this.log(`Failed to delete ${p}: ${err}`);
-        }
-      }
-    }
-  }
-  readTurnState(cwd) {
-    const statePath = getTurnStatePath(cwd);
-    if (!fs.existsSync(statePath)) {
-      return {
-        ...DEFAULT_TURN_STATE,
-        files: {},
-        lastUpdated: new Date().toISOString()
-      };
-    }
-    const state = readJsonCache(statePath, (parsed) => parsed);
-    return state ?? {
-      ...DEFAULT_TURN_STATE,
-      files: {},
-      lastUpdated: new Date().toISOString()
-    };
-  }
-  writeTurnState(state, cwd) {
-    const lensDir = getLensDir(cwd);
-    fs.mkdirSync(lensDir, { recursive: true });
-    const statePath = getTurnStatePath(cwd);
-    state.lastUpdated = new Date().toISOString();
-    writeFileAtomic(statePath, JSON.stringify(state, null, 2));
-  }
-  getTurnStateAccess(cwd, owner) {
-    const state = this.readTurnState(cwd);
-    const hasFiles = Object.keys(state.files ?? {}).length > 0;
-    if (!state.owner) {
-      if (!state.sessionId || state.sessionId === owner.id) {
-        if (hasFiles && this.turnStatePredatesSession(state, owner)) {
-          return "available";
-        }
-        return "owned";
-      }
-      return "available";
-    }
-    if (state.owner.kind === owner.kind && state.owner.id === owner.id) {
-      return "owned";
-    }
-    if (!hasFiles)
-      return "owned";
-    return this.isTurnStateOwnerStale(state.owner) ? "available" : "foreign-live";
-  }
-  turnStatePredatesSession(state, owner) {
-    const startedAt = owner.sessionStartedAt;
-    if (startedAt === undefined || !Number.isFinite(startedAt))
-      return false;
-    const lastUpdated = Date.parse(state.lastUpdated ?? "");
-    if (!Number.isFinite(lastUpdated))
-      return true;
-    return lastUpdated < startedAt;
-  }
-  isTurnStateOwnerStale(owner) {
-    if (owner.pid > 0 && owner.pid !== process.pid) {
-      try {
-        process.kill(owner.pid, 0);
-        return false;
-      } catch {
-        return true;
-      }
-    }
-    const lastSeen = Date.parse(owner.lastSeen);
-    return !Number.isFinite(lastSeen) || Date.now() - lastSeen > TURN_OWNER_STALE_MS;
-  }
-  addModifiedRange(filePath, range, importsChanged, cwd, sessionId, ownerKind = "pi", projectRoot) {
-    const containmentRoot = projectRoot ?? cwd;
-    if (!this.isTurnStatePathWithinRoot(filePath, containmentRoot)) {
-      this.log(`turn-state: rejected out-of-project path ${filePath} (project root ${containmentRoot})`);
-      return this.readTurnState(cwd);
-    }
-    const state = this.readTurnState(cwd);
-    if (sessionId) {
-      const owner = {
-        kind: ownerKind,
-        id: sessionId,
-        pid: process.pid,
-        lastSeen: new Date().toISOString()
-      };
-      if (this.getTurnStateAccess(cwd, owner) === "foreign-live")
-        return state;
-      state.sessionId = sessionId;
-      state.owner = owner;
-    }
-    const normalizedPath = this.toTurnStateKey(filePath, cwd);
-    const existing = state.files[normalizedPath];
-    if (existing) {
-      existing.modifiedRanges = this.mergeRanges([
-        ...existing.modifiedRanges,
-        range
-      ]);
-      existing.importsChanged = existing.importsChanged || importsChanged;
-      existing.lastEdit = new Date().toISOString();
-    } else {
-      state.files[normalizedPath] = {
-        modifiedRanges: [range],
-        importsChanged,
-        lastEdit: new Date().toISOString()
-      };
-    }
-    this.writeTurnState(state, cwd);
-    return state;
-  }
-  clearTurnState(cwd, owner) {
-    const currentState = this.readTurnState(cwd);
-    const isCurrentOwner = this.getTurnStateAccess(cwd, owner) !== "foreign-live";
-    if (!isCurrentOwner && process.pid !== currentState.owner?.pid)
-      return false;
-    const state = {
-      ...DEFAULT_TURN_STATE,
-      files: {},
-      lastUpdated: new Date().toISOString(),
-      sessionId: owner.id,
-      owner: {
-        kind: owner.kind,
-        id: owner.id,
-        pid: process.pid,
-        lastSeen: new Date().toISOString(),
-        sessionStartedAt: owner.sessionStartedAt
-      }
-    };
-    this.writeTurnState(state, cwd);
-    return true;
-  }
-  incrementTurnCycle(cwd, owner) {
-    const state = this.readTurnState(cwd);
-    const isCurrentOwner = this.getTurnStateAccess(cwd, owner) !== "foreign-live";
-    if (!isCurrentOwner && process.pid !== state.owner?.pid)
-      return state;
-    state.turnCycles++;
-    this.writeTurnState(state, cwd);
-    return state;
-  }
-  isMaxCyclesExceeded(cwd) {
-    const state = this.readTurnState(cwd);
-    return state.turnCycles >= state.maxCycles;
-  }
-  getFilesForJscpd(cwd) {
-    const state = this.readTurnState(cwd);
-    return Object.keys(state.files).filter((f) => /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|rb|java|cs|php|cpp|c|h|hpp|swift|kt)$/.test(f));
-  }
-  getFilesForMadge(cwd) {
-    const state = this.readTurnState(cwd);
-    return Object.entries(state.files).filter(([, f]) => f.importsChanged).map(([p]) => p);
-  }
-  mergeRanges(ranges) {
-    if (ranges.length === 0)
-      return [];
-    const sorted = [...ranges].sort((a, b) => a.start - b.start);
-    const merged = [sorted[0]];
-    for (const current of sorted.slice(1)) {
-      const last = merged[merged.length - 1];
-      if (current.start <= last.end + 1) {
-        last.end = Math.max(last.end, current.end);
-      } else {
-        merged.push({ ...current });
-      }
-    }
-    return merged;
-  }
-  isLineInModifiedRange(line, ranges) {
-    return ranges.some((r) => r.start <= line && line <= r.end);
-  }
-}