dsh-desktop-kit 2.2.0 → 2.7.2

package/plugins/dsh-profile-transfer/transfer.js

@@ -256,7 +256,7 @@ const DEFAULT_SELECTION = {
   workspaceFolders: false,
   skills: true,
   memory: true,
-  projectsMemory: true,
+  projectsMemory: false,
   sessions: false,
   attachments: false,
   credentials: false,
@@ -342,6 +342,43 @@ function workspaceFolderEntries(home, options = {}) {
   return { entries, workspaces, capped };
 }
 
+/**
+ * Find transfer archives on a USB drive (or any folder), without unpacking.
+ * Used by the "USB / projects and code" shortcut in the Settings page.
+ */
+export function findTransferArchives(directory, { maxDepth = 2 } = {}) {
+  const root = path.resolve(String(directory ?? "").trim());
+  const found = [];
+  const walk = (current, depth) => {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const absolute = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === "pgruntime" || entry.name === "tmp") continue;
+        walk(absolute, depth + 1);
+        continue;
+      }
+      if (!entry.isFile() || !/^dsh-profile-.+\.tar\.gz$/u.test(entry.name)) continue;
+      try {
+        const stat = fs.statSync(absolute);
+        found.push({ path: absolute, name: entry.name, bytes: stat.size, human: humanSize(stat.size), mtimeMs: stat.mtimeMs });
+      } catch {
+        /* unreadable entry */
+      }
+    }
+  };
+  walk(root, 0);
+  found.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return { root, archives: found };
+}
+
 /**
  * Describe every exportable group with its real size on disk, so the UI can
  * show what will be included before the user presses the button.
@@ -752,6 +789,55 @@ function restoreWorkspaceRegistry(home, incoming, manifest) {
   return Object.keys(incomingWorkspaces).length;
 }
 
+/**
+ * Merge `projects-memory/registry.json` instead of overwriting it. The archive
+ * may come from a machine with different absolute roots: remap them and keep
+ * projects that exist only on this machine. Dossiers themselves are copied by
+ * the regular file pass, so local journals are never dropped here.
+ */
+function restoreProjectRegistry(home, incoming, manifest) {
+  if (incoming === null || typeof incoming !== "object") return { added: 0, merged: 0 };
+  const target = path.join(home, "projects-memory", "registry.json");
+  const current = readJson(target);
+  const merged = current !== null && typeof current === "object" && Array.isArray(current.projects)
+    ? current
+    : { version: 1, settings: {}, projects: [] };
+  merged.version = 1;
+  merged.settings = { ...(incoming.settings ?? {}), ...(merged.settings ?? {}) };
+  const byFingerprint = new Map();
+  const bySlug = new Map();
+  for (const project of merged.projects) {
+    if (typeof project?.slug !== "string") continue;
+    bySlug.set(project.slug, project);
+    if (typeof project.fingerprint === "string" && project.fingerprint.length > 0) byFingerprint.set(project.fingerprint, project);
+  }
+  let added = 0;
+  let mergedCount = 0;
+  for (const project of Array.isArray(incoming.projects) ? incoming.projects : []) {
+    if (project === null || typeof project !== "object" || typeof project.slug !== "string") continue;
+    const roots = (Array.isArray(project.roots) ? project.roots : [])
+      .filter((root) => typeof root === "string" && root.length > 0)
+      .map((root) => remapOriginPath(root, manifest.origin, home));
+    const fingerprint = typeof project.fingerprint === "string" ? project.fingerprint : undefined;
+    const existing = (fingerprint !== undefined ? byFingerprint.get(fingerprint) : undefined) ?? bySlug.get(project.slug);
+    if (existing) {
+      existing.roots = [...new Set([...(Array.isArray(existing.roots) ? existing.roots : []), ...roots])].slice(0, 8);
+      if (typeof existing.fingerprint !== "string" && fingerprint !== undefined) existing.fingerprint = fingerprint;
+      existing.updatedAt = new Date().toISOString();
+      mergedCount += 1;
+    } else {
+      const copy = { ...project, roots };
+      merged.projects.push(copy);
+      bySlug.set(copy.slug, copy);
+      if (fingerprint !== undefined) byFingerprint.set(fingerprint, copy);
+      added += 1;
+    }
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+  return { added, merged: mergedCount };
+}
+
 /** Restore the optional workspace folders next to their (remapped) workspace paths. */
 function restoreWorkspaceFolders(home, entries, manifest, warnings) {
   const groups = new Map();
@@ -839,7 +925,7 @@ export function applyBundle(options = {}) {
   const selection = normalizeSelection(options.selection ?? inspected.manifest.selection);
   const entries = parseTarGz(fs.readFileSync(archivePath));
   const warnings = [];
-  const restored = { profile: 0, localPlugins: 0, workspaces: 0, workspaceFolders: 0, skills: 0, memory: 0, projectsMemory: 0, config: 0, sessions: 0, attachments: 0, credentials: 0 };
+  const restored = { profile: 0, localPlugins: 0, workspaces: 0, workspaceFolders: 0, skills: 0, memory: 0, projectsMemory: 0, projectsRegistry: { added: 0, merged: 0 }, config: 0, sessions: 0, attachments: 0, credentials: 0 };
   let backupDir;
   if (options.backup !== false) backupDir = backupCurrent(home, profileName, selection);
 
@@ -901,6 +987,8 @@ export function applyBundle(options = {}) {
       continue;
     }
     if (relativePath.startsWith("payload/projects-memory/")) {
+      // Merged below instead of overwriting the local registry.
+      if (relativePath === "payload/projects-memory/registry.json") continue;
       writeEntry(path.join("projects-memory", relativePath.slice("payload/projects-memory/".length)), entry.data);
       restored.projectsMemory += 1;
       continue;
@@ -941,6 +1029,17 @@ export function applyBundle(options = {}) {
     }
   }
 
+  // Project registry: merge, never replace this machine's projects. Roots are
+  // remapped from the exporting machine (user home / DSH home).
+  const projectRegistryEntry = entries.find((entry) => entry.type === "0" && safeRelative(entry.path) === "payload/projects-memory/registry.json");
+  if (projectRegistryEntry !== undefined && selection.projectsMemory !== false) {
+    try {
+      restored.projectsRegistry = restoreProjectRegistry(home, JSON.parse(projectRegistryEntry.data.toString("utf8")), inspected.manifest);
+    } catch (error) {
+      warnings.push(`реестр проектов не слит: ${String(error?.message ?? error)}`);
+    }
+  }
+
   // Optional workspace folders: restored next to their (remapped) workspace paths.
   if (selection.workspaceFolders === true) {
     const folderEntries = entries.filter((entry) => entry.type === "0" && safeRelative(entry.path).startsWith("payload/workspace-folders/"));

package/plugins/dsh-project-memory/index.js

@@ -394,6 +394,58 @@ function ensureProjectDossier(project, options = {}) {
   }
 }
 
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readText(filePath));
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * A dossier can arrive before its registry entry does: dsh-memory-bridge pulls
+ * dossiers from the private exchange repository, and dsh-profile-transfer
+ * copies them from another machine. Adopt that folder instead of creating
+ * `<slug>-2`, otherwise the synced dossier stays orphaned and the bridge
+ * publishes a second project with a new exchange folder.
+ */
+function findSyncedDossier(registry, { name, fingerprint }) {
+  let entries;
+  try {
+    entries = fs.readdirSync(MEMORY_ROOT, { withFileTypes: true });
+  } catch {
+    return undefined;
+  }
+  const registered = new Set(registry.projects.map((project) => project.slug));
+  const expected = slugify(name);
+  let fallback;
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    if (registered.has(entry.name)) continue;
+    const directory = path.join(MEMORY_ROOT, entry.name);
+    if (!exists(path.join(directory, "PROJECT.md"))) continue;
+    const meta = readJsonSafe(path.join(directory, "project.json"));
+    if (typeof fingerprint === "string" && fingerprint.length > 0 && meta?.fingerprint === fingerprint) {
+      return { slug: entry.name, name: typeof meta.name === "string" && meta.name.length > 0 ? meta.name : name };
+    }
+    if (fallback === undefined && entry.name === expected) fallback = { slug: entry.name, name };
+  }
+  return fallback;
+}
+
+/**
+ * A registry entry whose roots are gone was imported from another machine.
+ * Re-point it at the local checkout instead of creating a duplicate project.
+ */
+function findStaleProject(registry, slug, root) {
+  const project = registry.projects.find((entry) => entry.slug === slug);
+  if (!project) return undefined;
+  const roots = Array.isArray(project.roots) ? project.roots.filter((entry) => typeof entry === "string") : [];
+  if (roots.some((entry) => normalizePath(entry) === normalizePath(root))) return undefined;
+  if (roots.some((entry) => exists(entry))) return undefined;
+  return project;
+}
+
 function createProject(registry, { name, root, stack, legacyDocs, autoCreated, confidence }) {
   if (typeof name !== "string" || name.trim().length === 0) throw new Error("project name is required");
   if (typeof root !== "string" || root.trim().length === 0) throw new Error("project root is required");
@@ -414,10 +466,48 @@ function createProject(registry, { name, root, stack, legacyDocs, autoCreated, c
     logAccess(`project-merged slug=${twin.slug} root=${resolvedRoot}`);
     return projectPublic(twin);
   }
-  let slug = slugify(name);
+  const expectedSlug = slugify(name);
+  const stale = findStaleProject(registry, expectedSlug, resolvedRoot);
+  if (stale) {
+    stale.roots = [resolvedRoot];
+    stale.fingerprint = fingerprint;
+    stale.updatedAt = nowIso();
+    if (typeof stale.stack !== "string" && typeof stack === "string") stale.stack = stack.slice(0, 200);
+    saveRegistry(registry);
+    ensureProjectDossier(stale);
+    logAccess(`project-relinked slug=${stale.slug} root=${resolvedRoot}`);
+    return projectPublic(stale);
+  }
+  const synced = findSyncedDossier(registry, { name, fingerprint });
+  if (synced) {
+    const project = {
+      slug: synced.slug,
+      name: String(synced.name || name).trim(),
+      roots: [resolvedRoot],
+      fingerprint,
+      legacyDocs: [],
+      stack: typeof stack === "string" ? stack.slice(0, 200) : undefined,
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+      lastAnalyzedAt: null,
+      lastScanAt: null,
+      lastScanHead: null,
+      scanVersion: null,
+      lastJournalAt: null,
+      lastGitHead: null,
+      confidence: "imported",
+      autoCreated: autoCreated === true,
+    };
+    registry.projects.push(project);
+    saveRegistry(registry);
+    ensureProjectDossier(project);
+    logAccess(`project-adopted slug=${project.slug} root=${resolvedRoot}`);
+    return projectPublic(project);
+  }
+  let slug = expectedSlug;
   let counter = 2;
   while (registry.projects.some((project) => project.slug === slug) || exists(path.join(MEMORY_ROOT, slug))) {
-    slug = `${slugify(name)}-${counter}`;
+    slug = `${expectedSlug}-${counter}`;
     counter += 1;
   }
   const project = {

package/plugins/dsh-project-memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-project-memory",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "private": true,
   "description": "Local per-project long-term memory for DSH: auto-detection, bounded local recon, auto-injected digest with recall, project_memory tool, automatic session journal.",
   "type": "module",

package/plugins/dsh-repo-map/README.md

@@ -0,0 +1,26 @@
+# dsh-repo-map
+
+Локальная структурная карта проекта для кодинг-задач: файлы, языки, символы,
+импорты, PageRank-подобный рейтинг и поиск релевантных файлов под запрос.
+
+## Зачем
+
+Модель не читает весь репозиторий. `repo_map` даёт «оглавление» и подсказывает,
+какие 5–15 файлов действительно стоит открыть — дешевле и точнее, чем слепой grep.
+
+## Инструмент
+
+`repo_map`:
+
+- `action: "map"` — дерево/топ файлов, символы, импорты;
+- `action: "find"` — релевантные файлы по запросу (`query`);
+- `action: "stats"` — количество файлов и языков;
+- `action: "refresh"` — сбросить кэш.
+
+`root` по умолчанию — cwd текущей сессии DSH. Кэш — 60 секунд, без сети и LLM.
+
+## Ограничения
+
+- Эвристика по расширениям и регулярным выражениям; это карта, а не type-checker.
+- Пропускает `node_modules`, `.git`, `dist`, `build`, `vendor`, `pgruntime`, `tmp`, `.dsh`.
+- Для очень больших репозиториев действует лимит файлов (по умолчанию 2500).

package/plugins/dsh-repo-map/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-repo-map
+      name: dsh-repo-map

package/plugins/dsh-repo-map/index.js

@@ -0,0 +1,99 @@
+/**
+ * dsh-repo-map — compact local repository map for coding tasks.
+ *
+ * The model gets a structural "table of contents" (files, symbols, imports,
+ * ranked relevance) instead of reading the whole tree. No network, no LLM.
+ */
+import path from "node:path";
+
+import { buildRepoMap, findRelevant } from "./lib/repo-map.js";
+
+export const inject = ["tools"];
+
+const CACHE_MS = 60_000;
+const cache = new Map();
+
+function rootOf(args, exec) {
+  const explicit = typeof args?.root === "string" ? args.root.trim() : "";
+  const cwd = exec?.agent?.session?.header?.cwd;
+  return path.resolve(explicit || cwd || process.cwd());
+}
+
+function indexPath(root, extra = {}) {
+  const now = Date.now();
+  const cached = cache.get(root);
+  if (cached && now - cached.at < CACHE_MS && !extra.refresh) return cached.promise;
+  const promise = buildRepoMap(root, extra).catch((error) => {
+    cache.delete(root);
+    throw error;
+  });
+  cache.set(root, { at: now, promise });
+  return promise;
+}
+
+function toolResult(value) {
+  return value;
+}
+
+function truncate(text, max = 24_000) {
+  return text.length <= max ? text : `${text.slice(0, max)}\n…`;
+}
+
+export function apply(ctx) {
+  const tool = {
+    name: "repo_map",
+    description:
+      "Local structural map of the current repository: top files, languages, symbols and imports, plus relevance search. Use before broad code exploration; then read only the relevant files. No network, no LLM.",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { type: "string", enum: ["map", "find", "stats", "refresh"], description: "map | find | stats | refresh" },
+        query: { type: "string", description: "Task/query for find: names, routes, errors, domain words." },
+        root: { type: "string", description: "Absolute project root; defaults to the current Session cwd." },
+        limit: { type: "integer", description: "Max files for find (1..50, default 12)." },
+        top: { type: "integer", description: "How many files to include in map (10..60)." },
+      },
+      required: ["action"],
+    },
+    timeoutMs: 25_000,
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render(_args, value) {
+        const text = typeof value?.text === "string" ? value.text : JSON.stringify(value);
+        return [{ type: "text", text: truncate(text) }];
+      },
+    },
+    async execute(args, exec) {
+      const root = rootOf(args, exec);
+      const action = String(args?.action ?? "map");
+      if (action === "find") {
+        const query = String(args?.query ?? "").trim();
+        if (query.length === 0) return toolResult({ ok: false, text: "repo_map find: укажите query" });
+        const map = await indexPath(root);
+        const relevant = await findRelevant(root, query, { map, limit: args?.limit });
+        const text = relevant.length === 0
+          ? `В ${path.basename(root)} ничего не найдено по запросу «${query}».`
+          : [
+            `Релевантные файлы для «${query}» (${relevant.length}):`,
+            ...relevant.map((entry) => `- ${entry.path}${entry.symbols.length > 0 ? ` — ${entry.symbols.slice(0, 6).join(", ")}` : ""}`),
+          ].join("\n");
+        return toolResult({ ok: true, root, query, files: relevant.map((entry) => entry.path), text });
+      }
+      if (action === "stats") {
+        const map = await indexPath(root, { refresh: args?.action === "refresh" });
+        return toolResult({
+          ok: true,
+          root,
+          files: map.files,
+          languages: map.languages,
+          text: `Файлов: ${map.files}\nЯзыки: ${Object.entries(map.languages).map(([name, count]) => `${name} ${count}`).join(", ")}`,
+        });
+      }
+      const map = await indexPath(root);
+      return toolResult({ ok: true, root, files: map.files, languages: map.languages, text: map.mapText });
+    },
+  };
+  ctx.tools.register(tool);
+  ctx.logger?.info?.(`[repo-map] tool ready`);
+}

package/plugins/dsh-repo-map/lib/repo-map.js

@@ -0,0 +1,170 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const SKIP_DIRS = new Set([
+  "node_modules", ".git", ".svn", ".hg", "dist", "build", "out", "coverage",
+  ".next", ".nuxt", ".cache", "vendor", "pgruntime", "tmp", ".dsh",
+]);
+const TEXT_EXT = new Map([
+  [".js", "javascript"], [".mjs", "javascript"], [".cjs", "javascript"],
+  [".ts", "typescript"], [".tsx", "typescript"], [".jsx", "javascript"],
+  [".vue", "vue"], [".svelte", "svelte"], [".php", "php"], [".py", "python"],
+  [".go", "go"], [".rs", "rust"], [".rb", "ruby"], [".java", "java"],
+  [".cs", "csharp"], [".kt", "kotlin"], [".swift", "swift"], [".json", "json"],
+  [".md", "markdown"], [".yml", "yaml"], [".yaml", "yaml"], [".toml", "toml"],
+  [".sql", "sql"], [".sh", "shell"], [".ps1", "powershell"],
+]);
+const MAX_FILE_BYTES = 160 * 1024;
+
+function safeRead(file) {
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return "";
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+export function walkProject(root, { maxFiles = 2500 } = {}) {
+  const files = [];
+  const walk = (directory) => {
+    if (files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) break;
+      if (entry.name.startsWith(".")) continue;
+      const absolute = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(absolute);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const ext = path.extname(entry.name).toLowerCase();
+      if (!TEXT_EXT.has(ext)) continue;
+      files.push({ absolute, relative: path.relative(root, absolute).replaceAll("\\", "/"), ext, language: TEXT_EXT.get(ext) });
+    }
+  };
+  walk(root);
+  return files;
+}
+
+function symbolsOf(text, language) {
+  const symbols = new Set();
+  const patterns = [
+    /(?:^|\n)\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?class\s+([A-Za-z_$][\w$]*)/gu,
+    /(?:^|\n)\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/gu,
+    /(?:^|\n)\s*(?:export\s+)?(?:const|let|var|interface|type|enum)\s+([A-Za-z_$][\w$]*)/gu,
+    /(?:^|\n)\s*def\s+([A-Za-z_][\w]*)/gu,
+    /(?:^|\n)\s*class\s+([A-Za-z_][\w]*)/gu,
+    /(?:^|\n)\s*function\s+([A-Za-z_][\w]*)/gu,
+    /(?:^|\n)\s*(?:public|private|protected|static|final|\s)*function\s+([A-Za-z_][\w]*)/gu,
+  ];
+  for (const pattern of patterns) {
+    for (const match of text.matchAll(pattern)) {
+      if (match[1] && !["if", "for", "while", "switch", "catch"].includes(match[1])) symbols.add(match[1]);
+    }
+  }
+  return [...symbols].slice(0, 40);
+}
+
+function importsOf(text) {
+  const imports = new Set();
+  const patterns = [
+    /\bfrom\s+["']([^"']+)["']/gu,
+    /\brequire\s*\(\s*["']([^"']+)["']\s*\)/gu,
+    /\bimport\s+["']([^"']+)["']/gu,
+    /\buse\s+([A-Za-z_\\][\w\\]*)/gu,
+  ];
+  for (const pattern of patterns) for (const match of text.matchAll(pattern)) if (match[1]) imports.add(match[1]);
+  return [...imports].slice(0, 60);
+}
+
+function resolveImport(fromFile, spec, fileSet) {
+  if (!spec.startsWith(".")) return null;
+  const base = path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), spec));
+  const candidates = [base, `${base}.js`, `${base}.mjs`, `${base}.cjs`, `${base}.ts`, `${base}.tsx`, `${base}.jsx`, `${base}.php`, `${base}.py`, `${base}/index.js`, `${base}/index.ts`];
+  return candidates.find((candidate) => fileSet.has(candidate)) ?? null;
+}
+
+/**
+ * Build a compact, deterministic repository map. No network, no model calls.
+ * @returns {Promise<{root:string, files:number, languages:Record<string,number>, entries:Array, mapText:string}>}
+ */
+export async function buildRepoMap(root, options = {}) {
+  const resolved = path.resolve(root);
+  const files = walkProject(resolved, options);
+  const fileSet = new Set(files.map((file) => file.relative));
+  const entries = [];
+  for (const file of files) {
+    const text = safeRead(file.absolute);
+    const symbols = symbolsOf(text, file.language);
+    const imports = importsOf(text);
+    const links = imports.map((spec) => resolveImport(file.relative, spec, fileSet)).filter(Boolean);
+    entries.push({
+      path: file.relative,
+      language: file.language,
+      bytes: Buffer.byteLength(text, "utf8"),
+      lines: text.split(/\r?\n/u).length,
+      symbols,
+      imports,
+      links,
+      score: 1 + links.length + symbols.length * 0.35 + Math.max(0, 4 - file.relative.split("/").length) * 0.4,
+    });
+  }
+  const byPath = new Map(entries.map((entry) => [entry.path, entry]));
+  for (let round = 0; round < 12; round += 1) {
+    const next = new Map(entries.map((entry) => [entry.path, entry.score * 0.65]));
+    for (const entry of entries) {
+      for (const link of entry.links) {
+        const target = byPath.get(link);
+        if (target) next.set(link, (next.get(link) ?? 0) + entry.score * 0.35 / Math.max(1, entry.links.length));
+      }
+    }
+    for (const entry of entries) entry.score = next.get(entry.path) ?? entry.score;
+  }
+  entries.sort((left, right) => right.score - left.score || left.path.localeCompare(right.path));
+  const languages = {};
+  for (const entry of entries) languages[entry.language] = (languages[entry.language] ?? 0) + 1;
+  const top = entries.slice(0, Math.max(10, Math.min(60, Number(options.top) || 40)));
+  const mapText = [
+    `Repository: ${path.basename(resolved)} · ${entries.length} files`,
+    `Languages: ${Object.entries(languages).map(([name, count]) => `${name} ${count}`).join(", ")}`,
+    "",
+    ...top.map((entry) => {
+      const symbols = entry.symbols.slice(0, 6).join(", ");
+      return `- ${entry.path}${symbols ? ` — ${symbols}` : ""}`;
+    }),
+  ].join("\n");
+  return { root: resolved, files: entries.length, languages, entries, mapText };
+}
+
+function tokens(value) {
+  return String(value ?? "")
+    .toLowerCase()
+    .split(/[^a-zа-я0-9_$]+/u)
+    .filter((part) => part.length >= 2);
+}
+
+/** Rank files for a query using path, symbols, imports and content-free heuristics. */
+export async function findRelevant(root, query, options = {}) {
+  const map = options.map ?? (await buildRepoMap(root, options));
+  const queryTokens = tokens(query);
+  const limit = Math.max(1, Math.min(50, Number(options.limit) || 12));
+  const scored = map.entries.map((entry) => {
+    const haystack = `${entry.path} ${entry.symbols.join(" ")} ${entry.imports.join(" ")}`.toLowerCase();
+    let score = 0;
+    for (const token of queryTokens) {
+      if (entry.path.toLowerCase().includes(token)) score += 4;
+      if (entry.symbols.some((symbol) => symbol.toLowerCase().includes(token))) score += 5;
+      if (haystack.includes(token)) score += 1;
+    }
+    return { ...entry, queryScore: score > 0 ? score + entry.score * 0.01 : 0 };
+  });
+  return scored.filter((entry) => entry.queryScore > 0).sort((a, b) => b.queryScore - a.queryScore).slice(0, limit);
+}

package/plugins/dsh-repo-map/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "dsh-repo-map",
+  "version": "1.0.0",
+  "description": "Compact local repository map and relevance search tool for DSH coding tasks: files, symbols, imports and ranking without network or LLM calls.",
+  "license": "MIT",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./lib": "./lib/repo-map.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "lib/**",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}