@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/file-kinds.js

@@ -0,0 +1,313 @@
+import { basename, extname, win32 } from "node:path";
+import * as path from "node:path";
+import { isWindowsPath } from "./path-utils.js";
+import { findNearestDirWithMarker } from "./workspace-topology.js";
+export const KIND_EXTENSIONS = {
+  clojure: [".clj", ".cljc", ".cljs", ".edn"],
+  cmake: [".cmake"],
+  csharp: [".cs"],
+  css: [".css", ".less", ".sass", ".scss"],
+  cue: [".cue"],
+  cxx: [
+    ".c",
+    ".h",
+    ".c++",
+    ".cc",
+    ".cp",
+    ".cpp",
+    ".cxx",
+    ".hh",
+    ".hpp",
+    ".hxx",
+    ".inl",
+    ".ipp",
+    ".tpp",
+    ".txx",
+    ".c++m",
+    ".cppm",
+    ".cxxm",
+    ".ixx",
+    ".cu",
+    ".hip",
+    ".cuh",
+    ".m",
+    ".mm",
+    ".cl",
+    ".clcpp"
+  ],
+  dart: [".dart"],
+  docker: [".dockerfile"],
+  elixir: [".ex", ".exs"],
+  fish: [".fish"],
+  fsharp: [".fs", ".fsi", ".fsx"],
+  gleam: [".gleam"],
+  go: [".go"],
+  haskell: [".hs", ".lhs"],
+  "helm-template": [".tpl"],
+  html: [".htm", ".html"],
+  java: [".java"],
+  json: [".json", ".json5", ".jsonc"],
+  jsts: [
+    ".cjs",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".mts",
+    ".svelte",
+    ".ts",
+    ".tsx",
+    ".vue"
+  ],
+  kotlin: [".kt", ".kts"],
+  lean: [".lean"],
+  lua: [".lua"],
+  markdown: [".md", ".mdx"],
+  nix: [".nix"],
+  ocaml: [".ml", ".mli"],
+  php: [".php"],
+  powershell: [".ps1", ".psm1", ".psd1"],
+  prisma: [".prisma"],
+  python: [".py", ".pyi"],
+  ruby: [".gemspec", ".rake", ".rb", ".ru"],
+  rust: [".rs"],
+  shell: [".bash", ".sh", ".zsh"],
+  sql: [".sql"],
+  swift: [".swift"],
+  terraform: [".tf", ".tfvars"],
+  terragrunt: [],
+  toml: [".toml"],
+  yaml: [".yaml", ".yml"],
+  zig: [".zig", ".zon"]
+};
+function hasKindExtension(filePath, kind) {
+  const extension = extname(filePath).toLowerCase();
+  return KIND_EXTENSIONS[kind].some((candidate) => candidate === extension);
+}
+const JSTS_FACT_EXTENSIONS = new Set(KIND_EXTENSIONS.jsts.filter((extension) => ![".vue", ".svelte"].includes(extension)));
+export function isJstsFactFile(filePath) {
+  return JSTS_FACT_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+const NON_KIND_READABLE_EXTENSIONS = new Set([
+  ".txt",
+  ".env",
+  ".cfg",
+  ".conf",
+  ".ini",
+  ".xml"
+]);
+export function isReadableSourceFile(filePath) {
+  const extension = extname(filePath).toLowerCase();
+  return Object.keys(KIND_EXTENSIONS).some((kind) => hasKindExtension(filePath, kind)) || NON_KIND_READABLE_EXTENSIONS.has(extension);
+}
+export const LEAN_ROOT_MARKERS = [
+  "lakefile.lean",
+  "lakefile.toml",
+  "lean-toolchain"
+];
+export const DOTNET_CSHARP_ROOT_MARKERS = [
+  "*.csproj",
+  "*.sln",
+  "*.slnx"
+];
+export const DOTNET_FSHARP_ROOT_MARKERS = [
+  "*.fsproj",
+  "*.sln"
+];
+export const TERRAGRUNT_FILENAMES = [
+  "terragrunt.hcl",
+  "root.hcl"
+];
+const EXT_TO_KIND = new Map;
+for (const [kind, exts] of Object.entries(KIND_EXTENSIONS)) {
+  for (const ext of exts) {
+    EXT_TO_KIND.set(ext.toLowerCase(), kind);
+  }
+  for (const ext of exts) {
+    if (ext.startsWith(".")) {
+      EXT_TO_KIND.set(ext.slice(1).toLowerCase(), kind);
+    }
+  }
+}
+export const SPECIAL_FILENAMES = [
+  { pattern: /^CMakeLists\.txt$/i, kind: "cmake" },
+  { pattern: /^Makefile$/i, kind: "shell" },
+  { pattern: /^Dockerfile(\.\w+)?$/i, kind: "docker" },
+  ...TERRAGRUNT_FILENAMES.map((name) => ({
+    pattern: new RegExp(`^${name.replaceAll(".", "\\.")}$`, "i"),
+    kind: "terragrunt"
+  }))
+];
+export function isHelmYamlTemplatePath(filePath) {
+  const templatesSegment = isWindowsPath(filePath) ? /[\\/]templates[\\/]/i : /\/templates\//i;
+  if (!templatesSegment.test(filePath) || !/\.ya?ml$/i.test(filePath)) {
+    return false;
+  }
+  const pathApi = isWindowsPath(filePath) ? win32 : path;
+  return Boolean(findNearestDirWithMarker(pathApi.dirname(filePath), "chartYamlPath"));
+}
+export function detectFileKind(filePath) {
+  if (!filePath || typeof filePath !== "string") {
+    return;
+  }
+  if (isHelmYamlTemplatePath(filePath)) {
+    return "helm-template";
+  }
+  const base = basename(filePath);
+  for (const { pattern, kind } of SPECIAL_FILENAMES) {
+    if (pattern.test(base)) {
+      return kind;
+    }
+  }
+  const ext = extname(filePath).toLowerCase();
+  return EXT_TO_KIND.get(ext);
+}
+export function isFileKind(filePath, kind) {
+  const detected = detectFileKind(filePath);
+  if (!detected)
+    return false;
+  if (Array.isArray(kind)) {
+    return kind.includes(detected);
+  }
+  return detected === kind;
+}
+export function getFileKindsForExtension(ext) {
+  const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`;
+  const kind = EXT_TO_KIND.get(normalizedExt.toLowerCase());
+  return kind ? [kind] : [];
+}
+export const CODE_KINDS = new Set([
+  "clojure",
+  "cmake",
+  "csharp",
+  "cue",
+  "cxx",
+  "dart",
+  "docker",
+  "elixir",
+  "fish",
+  "fsharp",
+  "gleam",
+  "go",
+  "haskell",
+  "helm-template",
+  "java",
+  "jsts",
+  "kotlin",
+  "lean",
+  "lua",
+  "nix",
+  "ocaml",
+  "php",
+  "powershell",
+  "prisma",
+  "python",
+  "ruby",
+  "rust",
+  "shell",
+  "sql",
+  "swift",
+  "terraform",
+  "terragrunt",
+  "zig"
+]);
+export const NON_CODE_KINDS = new Set([
+  "css",
+  "html",
+  "json",
+  "markdown",
+  "toml",
+  "yaml"
+]);
+export function isCodeKindFile(filePath) {
+  const kind = detectFileKind(filePath);
+  return kind !== undefined && CODE_KINDS.has(kind);
+}
+export function getFileKindLabel(kind) {
+  const labels = {
+    jsts: "JavaScript/TypeScript",
+    python: "Python",
+    go: "Go",
+    rust: "Rust",
+    cxx: "C/C++",
+    cmake: "CMake",
+    shell: "Shell",
+    json: "JSON",
+    markdown: "Markdown",
+    css: "CSS",
+    yaml: "YAML",
+    sql: "SQL",
+    ruby: "Ruby",
+    html: "HTML",
+    docker: "Dockerfile",
+    php: "PHP",
+    powershell: "PowerShell",
+    prisma: "Prisma",
+    csharp: "C#",
+    fish: "Fish shell",
+    fsharp: "F#",
+    java: "Java",
+    kotlin: "Kotlin",
+    lean: "Lean 4",
+    swift: "Swift",
+    dart: "Dart",
+    lua: "Lua",
+    zig: "Zig",
+    haskell: "Haskell",
+    "helm-template": "Helm template",
+    elixir: "Elixir",
+    gleam: "Gleam",
+    ocaml: "OCaml",
+    clojure: "Clojure",
+    cue: "CUE",
+    terraform: "Terraform",
+    terragrunt: "Terragrunt",
+    nix: "Nix",
+    toml: "TOML"
+  };
+  return labels[kind] ?? kind;
+}
+export function getLanguageId(kind) {
+  const languageIds = {
+    jsts: "typescript",
+    python: "python",
+    go: "go",
+    rust: "rust",
+    cxx: "cpp",
+    cmake: "cmake",
+    shell: "shell",
+    json: "json",
+    markdown: "markdown",
+    css: "css",
+    yaml: "yaml",
+    sql: "sql",
+    ruby: "ruby",
+    html: "html",
+    docker: "dockerfile",
+    php: "php",
+    powershell: "powershell",
+    prisma: "prisma",
+    csharp: "csharp",
+    fish: "fish",
+    fsharp: "fsharp",
+    java: "java",
+    kotlin: "kotlin",
+    lean: "lean",
+    swift: "swift",
+    dart: "dart",
+    lua: "lua",
+    zig: "zig",
+    haskell: "haskell",
+    "helm-template": "helm",
+    elixir: "elixir",
+    gleam: "gleam",
+    ocaml: "ocaml",
+    clojure: "clojure",
+    cue: "cue",
+    terraform: "terraform",
+    terragrunt: "terragrunt",
+    nix: "nix",
+    toml: "toml"
+  };
+  return languageIds[kind] ?? "plaintext";
+}

package/extensions/dm-lens/dist/clients/file-mutation-queue.js

@@ -0,0 +1,95 @@
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { logExtension } from "./extension-log.js";
+import { compareOrdinal } from "./string-utils.js";
+let loadHostSdk;
+let hostQueue;
+let hostSessionManager;
+export function noteHostSessionManager(sessionManager) {
+  hostSessionManager = sessionManager;
+}
+export function setHostFileMutationQueueLoader(loader) {
+  loadHostSdk = loader;
+  hostQueue = undefined;
+}
+function unavailable(reason) {
+  recordDegradationOnce({
+    kind: "host-file-mutation-queue-unavailable",
+    subject: "withFileMutationQueue",
+    reason
+  });
+  return;
+}
+function resolved(sdk) {
+  if (typeof sdk.withFileMutationQueue !== "function")
+    return unavailable("the host SDK exports no withFileMutationQueue");
+  const hostCopy = hostSessionManager === undefined || typeof sdk.SessionManager !== "function" ? undefined : hostSessionManager instanceof sdk.SessionManager;
+  if (hostCopy === false) {
+    unavailable("the host SDK import loaded a second copy of the package (the host's session manager is not its SessionManager), so its queue does not order pi's own edits");
+  } else {
+    logExtension({
+      subsystem: "file-mutation-queue",
+      level: "debug",
+      message: "resolved the host's withFileMutationQueue",
+      metadata: { hostCopy: hostCopy ? "verified" : "unverified" }
+    });
+  }
+  return sdk.withFileMutationQueue;
+}
+function resolveHostQueue(loader) {
+  hostQueue ??= loader().then(resolved, (failure) => unavailable(failure instanceof Error ? failure.message : String(failure)));
+  return hostQueue;
+}
+export function withHostFileMutationQueue(filePath, fn) {
+  const loader = loadHostSdk;
+  if (!loader)
+    return fn();
+  return resolveHostQueue(loader).then((queue) => queue ? queue(resolve(filePath), fn) : fn());
+}
+export async function withHostFileMutationQueues(filePaths, fn) {
+  const keys = await Promise.all(filePaths.map((filePath) => {
+    const resolvedPath = resolve(filePath);
+    return realpath(resolvedPath).catch(() => resolvedPath);
+  }));
+  return [...new Set(keys)].sort(compareOrdinal).reduceRight((inner, key) => () => withHostFileMutationQueue(key, inner), fn)();
+}
+export function holdFileMutationQueue(filePath) {
+  if (!loadHostSdk)
+    return;
+  let entered;
+  let releaseHeld = () => {};
+  let released = false;
+  const outliving = [];
+  const acquire = () => {
+    entered ??= new Promise((resolveEntered, rejectEntered) => {
+      const held = new Promise((resolveHeld) => {
+        releaseHeld = resolveHeld;
+      });
+      withHostFileMutationQueue(filePath, () => {
+        resolveEntered();
+        return held;
+      }).catch(rejectEntered);
+    });
+    return entered;
+  };
+  return {
+    acquire,
+    enter(writer) {
+      if (!released) {
+        outliving.push(writer);
+        return acquire();
+      }
+      return new Promise((resolveEntered, rejectEntered) => {
+        withHostFileMutationQueue(filePath, () => {
+          resolveEntered();
+          return writer;
+        }).catch(rejectEntered);
+      });
+    },
+    release() {
+      released = true;
+      Promise.allSettled(outliving).then(() => releaseHeld());
+    }
+  };
+}

package/extensions/dm-lens/dist/clients/file-role.js

@@ -0,0 +1,50 @@
+import { basename, dirname, win32 } from "node:path";
+import { isGeneratedOrArtifact } from "./generated-artifacts.js";
+import { isWindowsPath } from "./path-utils.js";
+const RE_EXPORT_LINE = /^export\s+(type\s+)?\*\s+from\s+|^export\s*\{[^}]*\}\s+from\s+/;
+function isReExportBarrel(content) {
+  const lines = content.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && !l.startsWith("*") && !l.startsWith("/*"));
+  return lines.length > 0 && lines.every((l) => RE_EXPORT_LINE.test(l));
+}
+function isTypeStub(content) {
+  const lines = content.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && !l.startsWith("*") && !l.startsWith("/*") && l !== "{" && l !== "}");
+  if (lines.length < 4)
+    return false;
+  const typeOnlyLines = lines.filter((l) => /^(export\s+)?(interface|type|abstract\s+class|declare\s+(class|function|const|var|let|module|namespace|enum))\s+/.test(l) || /^(import\s+type\s+|import\s+\{)/.test(l) || /^export\s+type\s+\{/.test(l));
+  return typeOnlyLines.length / lines.length >= 0.75;
+}
+function testFileNameMatches(rawBase, base) {
+  return base.includes(".test.") || base.includes(".spec.") || base.includes("_test.") || base.includes("_spec.") || base.startsWith("test_") || base.startsWith("spec_") || /(Test|Tests|TestCase)\.(java|kt|kts|cs|fs|php)$/.test(rawBase);
+}
+export function isTestFileName(filePath) {
+  const windowsShaped = isWindowsPath(filePath);
+  const rawBase = windowsShaped ? win32.basename(filePath) : basename(filePath);
+  return testFileNameMatches(rawBase, rawBase.toLowerCase());
+}
+export function detectFileRole(filePath, content) {
+  const windowsShaped = isWindowsPath(filePath);
+  const rawBase = windowsShaped ? win32.basename(filePath) : basename(filePath);
+  const base = rawBase.toLowerCase();
+  const dir = (windowsShaped ? win32.dirname(filePath) : dirname(filePath)).replace(/\\/g, "/").toLowerCase();
+  if (testFileNameMatches(rawBase, base) || /(^|[\\/])__tests__([\\/]|$)/.test(dir) || dir.includes("/test/") || dir.includes("/tests/") || dir.includes("/spec/") || dir.includes("/specs/") || /[/_-]tests?\/?$/.test(dir) || /[/_-]specs?\/?$/.test(dir))
+    return "test";
+  if (isGeneratedOrArtifact(filePath, { content, includeDeclarations: false })) {
+    return "generated";
+  }
+  const forwardDir = dir.replace(/\\/g, "/");
+  if (forwardDir.includes("/migrations/") || forwardDir.includes("/migration/") || /\/\d{4,}_[a-z]/.test(forwardDir + "/" + base))
+    return "migration";
+  if (base.endsWith(".config.ts") || base.endsWith(".config.js") || base.endsWith(".config.mjs") || base.endsWith(".config.cjs") || base === "vite.config.ts" || base === "jest.config.ts" || base === "jest.config.js" || base === "webpack.config.js" || base === "rollup.config.js" || base === "tailwind.config.js" || base === "tailwind.config.ts" || base === "next.config.js" || base === "next.config.mjs")
+    return "config";
+  if (base.endsWith(".d.ts"))
+    return "stub";
+  if (content && isTypeStub(content))
+    return "stub";
+  const isIndexFile = base === "index.js" || base === "index.tsx" || base === "index.js" || base === "index.mjs" || base === "index.cjs" || base === "index.jsx" || base === "__init__.py" || base === "mod.rs";
+  if (isIndexFile) {
+    if (content && isReExportBarrel(content))
+      return "re-export";
+    return "init";
+  }
+  return "source";
+}

package/extensions/dm-lens/dist/clients/file-time.js

@@ -0,0 +1,112 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const globalState = {
+  reads: new Map,
+  locks: new Map
+};
+
+export class FileTime {
+  sessionID;
+  constructor(sessionID) {
+    this.sessionID = sessionID;
+  }
+  read(filePath) {
+    const absolutePath = path.resolve(filePath);
+    const stamp = createStamp(absolutePath);
+    let sessionReads = globalState.reads.get(this.sessionID);
+    if (!sessionReads) {
+      sessionReads = new Map;
+      globalState.reads.set(this.sessionID, sessionReads);
+    }
+    sessionReads.set(absolutePath, stamp);
+    return stamp;
+  }
+  get(filePath) {
+    const absolutePath = path.resolve(filePath);
+    const sessionReads = globalState.reads.get(this.sessionID);
+    return sessionReads?.get(absolutePath);
+  }
+  assert(filePath) {
+    const absolutePath = path.resolve(filePath);
+    const sessionReads = globalState.reads.get(this.sessionID);
+    const recorded = sessionReads?.get(absolutePath);
+    if (!recorded) {
+      throw new FileTimeError(`You must read file ${absolutePath} before modifying it. Use the read tool first.`, absolutePath, "not-read");
+    }
+    const current = createStamp(absolutePath);
+    const changed = current.mtime !== recorded.mtime || current.ctime !== recorded.ctime || current.size !== recorded.size;
+    if (changed) {
+      throw new FileTimeError(`File ${absolutePath} has been modified since it was last read.
+` + `Last modification: ${new Date(current.mtime ?? Date.now()).toISOString()}
+` + `Last read: ${recorded.readAt.toISOString()}
+
+` + `Please read the file again before modifying it.`, absolutePath, "modified");
+    }
+  }
+  hasChanged(filePath) {
+    const absolutePath = path.resolve(filePath);
+    const sessionReads = globalState.reads.get(this.sessionID);
+    const recorded = sessionReads?.get(absolutePath);
+    if (!recorded)
+      return true;
+    const current = createStamp(absolutePath);
+    return current.mtime !== recorded.mtime || current.ctime !== recorded.ctime || current.size !== recorded.size;
+  }
+  async withLock(filePath, fn) {
+    const absolutePath = path.resolve(filePath);
+    while (globalState.locks.has(absolutePath)) {
+      const existing = globalState.locks.get(absolutePath);
+      if (existing)
+        await existing;
+    }
+    const lockPromise = fn().finally(() => {
+      globalState.locks.delete(absolutePath);
+    });
+    globalState.locks.set(absolutePath, lockPromise.then(() => {}, () => {}));
+    return lockPromise;
+  }
+  clear() {
+    globalState.reads.delete(this.sessionID);
+  }
+  clearFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    const sessionReads = globalState.reads.get(this.sessionID);
+    sessionReads?.delete(absolutePath);
+  }
+}
+
+class FileTimeError extends Error {
+  filePath;
+  reason;
+  constructor(message, filePath, reason) {
+    super(message);
+    this.name = "FileTimeError";
+    this.filePath = filePath;
+    this.reason = reason;
+  }
+}
+function createStamp(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    return {
+      readAt: new Date,
+      mtime: stats.mtime.getTime(),
+      ctime: stats.ctime.getTime(),
+      size: stats.size
+    };
+  } catch {
+    return {
+      readAt: new Date,
+      mtime: undefined,
+      ctime: undefined,
+      size: undefined
+    };
+  }
+}
+export function createFileTime(sessionID) {
+  return new FileTime(sessionID);
+}
+export function clearAllSessions() {
+  globalState.reads.clear();
+  globalState.locks.clear();
+}