@dennisrongo/dsh-todo 0.4.1 → 0.5.0

package/lib/index.js

@@ -48,8 +48,8 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/index.ts
-import { readFileSync, renameSync, existsSync } from "node:fs";
-import { isAbsolute, join as join2, resolve as resolve2 } from "node:path";
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, renameSync, existsSync, unlinkSync } from "node:fs";
+import { isAbsolute, join as join3, resolve as resolve2 } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { z } from "zod";
@@ -92,6 +92,14 @@ var MAX_TEXT = 500;
 var MAX_DESC = 5e3;
 var MAX_LABEL = 60;
 var MAX_ITEMS = 1e3;
+var SUGGESTIONS_DIR = ".dsh";
+var SUGGESTIONS_FILE = `${SUGGESTIONS_DIR}/suggestions.json`;
+var SUGGESTIONS_FILE_RE = /^suggestions(-[a-z0-9]+)?\.json$/;
+function suggestionsFileFor(runId) {
+  return `${SUGGESTIONS_DIR}/suggestions-${runId}.json`;
+}
+__name(suggestionsFileFor, "suggestionsFileFor");
+var MAX_SUGGESTIONS = 12;
 
 // src/db.ts
 var DOT_DSH = ".dsh";
@@ -216,6 +224,337 @@ function writeList(db, items, revision, updatedAt = Date.now()) {
 }
 __name(writeList, "writeList");
 
+// src/scan.ts
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join as join2, relative, sep } from "node:path";
+var DIGEST_BYTE_CAP = 24e3;
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  "bower_components",
+  "jspm_packages",
+  "lib",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".output",
+  ".parcel-cache",
+  ".turbo",
+  ".cache",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".tox",
+  ".mypy_cache",
+  ".pytest_cache",
+  "target",
+  "vendor",
+  "vendored",
+  "third_party",
+  "thirdparty",
+  "generated",
+  "__generated__",
+  "Pods",
+  "Carthage",
+  "DerivedData"
+]);
+var SOURCE_EXT = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".rb",
+  ".php",
+  ".cs",
+  ".swift",
+  ".kt",
+  ".scala",
+  ".sh"
+]);
+var MAX_FILES_WALKED = 4e3;
+var MAX_TREE_ENTRIES = 300;
+var MAX_COMMENTS = 80;
+var MAX_UNTESTED = 40;
+var MAX_COMMENT_LINE = 160;
+var README_BYTES = 4e3;
+var MANIFEST_BYTES = 2e3;
+var MAX_DEPTH = 8;
+var SCAN_CEILING_FACTOR = 10;
+var MAX_FILES_READ = 400;
+var MAX_READ_BYTES = 2 * 1024 * 1024;
+function posix(path) {
+  return path.split(sep).join("/");
+}
+__name(posix, "posix");
+function walk(root) {
+  const files = [];
+  let truncated = false;
+  const visit = /* @__PURE__ */ __name((dir, depth) => {
+    if (depth > MAX_DEPTH || files.length >= MAX_FILES_WALKED) {
+      truncated = true;
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= MAX_FILES_WALKED) {
+        truncated = true;
+        return;
+      }
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+        visit(join2(dir, entry.name), depth + 1);
+      } else if (entry.isFile()) {
+        files.push(posix(relative(root, join2(dir, entry.name))));
+      }
+    }
+  }, "visit");
+  try {
+    if (!statSync(root).isDirectory()) return { files: [], truncated: false };
+  } catch {
+    return { files: [], truncated: false };
+  }
+  visit(root, 0);
+  return { files, truncated };
+}
+__name(walk, "walk");
+function readText(path, limit = Number.MAX_SAFE_INTEGER) {
+  let raw;
+  try {
+    if (statSync(path).size > MAX_READ_BYTES) return "";
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return "";
+  }
+  if (raw.includes("\0")) return "";
+  return raw.length > limit ? raw.slice(0, limit) : raw;
+}
+__name(readText, "readText");
+function skippedForSize(path) {
+  try {
+    return statSync(path).size > MAX_READ_BYTES;
+  } catch {
+    return false;
+  }
+}
+__name(skippedForSize, "skippedForSize");
+var COMMENT_RE = /(?:^|\s)(?:\/\/|#|\/\*|\*)\s*(TODO|FIXME|HACK)\b[:\s]?(.*)$/;
+function collectComments(root, files) {
+  const ceiling = MAX_COMMENTS * SCAN_CEILING_FACTOR;
+  const kept = [];
+  let total = 0;
+  let read = 0;
+  let skipped = 0;
+  let bounded = false;
+  for (const rel of files) {
+    const dot = rel.lastIndexOf(".");
+    if (dot < 0 || !SOURCE_EXT.has(rel.slice(dot))) continue;
+    if (total >= ceiling || read >= MAX_FILES_READ) {
+      bounded = true;
+      break;
+    }
+    const full = join2(root, rel);
+    if (skippedForSize(full)) {
+      skipped += 1;
+      continue;
+    }
+    read += 1;
+    const text = readText(full);
+    if (text === "") continue;
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i += 1) {
+      const match = COMMENT_RE.exec(lines[i]);
+      if (match === null) continue;
+      total += 1;
+      if (kept.length >= MAX_COMMENTS) continue;
+      const body = match[2].trim().slice(0, MAX_COMMENT_LINE);
+      kept.push(`${rel}:${i + 1}  ${match[1]} ${body}`.trimEnd());
+    }
+  }
+  return { kept, total, bounded, skippedForSize: skipped };
+}
+__name(collectComments, "collectComments");
+function hasTest(base, testNames) {
+  return testNames.has(`${base}.test`) || testNames.has(`${base}.spec`) || testNames.has(`test_${base}`) || testNames.has(`${base}_test`) || testNames.has(base);
+}
+__name(hasTest, "hasTest");
+function collectUntested(files) {
+  const testNames = /* @__PURE__ */ new Set();
+  for (const rel of files) {
+    const name = rel.slice(rel.lastIndexOf("/") + 1);
+    const stem = name.replace(/\.[^.]+$/, "");
+    if (/(^|[./_-])(test|spec)([./_-]|$)/i.test(rel)) {
+      testNames.add(stem);
+      testNames.add(stem.replace(/\.(test|spec)$/i, ""));
+    }
+  }
+  const ceiling = MAX_UNTESTED * SCAN_CEILING_FACTOR;
+  const kept = [];
+  let total = 0;
+  let bounded = false;
+  for (const rel of files) {
+    const dot = rel.lastIndexOf(".");
+    if (dot < 0 || !SOURCE_EXT.has(rel.slice(dot))) continue;
+    if (/(^|[./_-])(test|spec)([./_-]|$)/i.test(rel)) continue;
+    const stem = rel.slice(rel.lastIndexOf("/") + 1).replace(/\.[^.]+$/, "");
+    if (/^(index|main|types|constants)$/i.test(stem)) continue;
+    if (hasTest(stem, testNames)) continue;
+    if (total >= ceiling) {
+      bounded = true;
+      break;
+    }
+    total += 1;
+    if (kept.length < MAX_UNTESTED) kept.push(rel);
+  }
+  return { kept, total, bounded, skippedForSize: 0 };
+}
+__name(collectUntested, "collectUntested");
+function sectionHeader(title, total, kept, options = {}) {
+  const bound = options.bounded === true ? "+" : "";
+  const skipped = options.skippedForSize ?? 0;
+  const note = skipped > 0 ? ` (${skipped} file(s) too large to read)` : "";
+  const counts = kept < total || options.bounded === true ? `(${total}${bound} found, showing ${kept})` : `(${total})`;
+  return `### ${title} ${counts}${note}`;
+}
+__name(sectionHeader, "sectionHeader");
+function fileHeader(name, text, limit) {
+  if (text.length < limit) return `### ${name}`;
+  return `### ${name} (clipped to first ${Math.round(limit / 1e3)} KB)`;
+}
+__name(fileHeader, "fileHeader");
+function assemble(sections, walkTruncated) {
+  const parts = walkTruncated ? sections.concat(
+    "[walk truncated \u2014 this workspace is deeper or larger than one scan walks; files below the depth or count limit were never examined]"
+  ) : sections;
+  const joined = parts.join("\n\n");
+  if (joined.length <= DIGEST_BYTE_CAP) {
+    return { digest: joined, truncated: walkTruncated };
+  }
+  const marker = "\n\n[digest truncated \u2014 the workspace is larger than one scan can carry]";
+  return { digest: joined.slice(0, DIGEST_BYTE_CAP - marker.length) + marker, truncated: true };
+}
+__name(assemble, "assemble");
+function buildDigest(root) {
+  const { files, truncated } = walk(root);
+  const sections = [];
+  let sectionTruncated = false;
+  const tree = files.slice(0, MAX_TREE_ENTRIES);
+  if (tree.length > 0) {
+    if (tree.length < files.length) sectionTruncated = true;
+    sections.push(`${sectionHeader("Files", files.length, tree.length)}
+${tree.join("\n")}`);
+  }
+  const readmeName = files.find((f) => /^readme(\.md|\.txt)?$/i.test(f));
+  if (readmeName !== void 0) {
+    const raw = readText(join2(root, readmeName), README_BYTES);
+    const text = raw.trim();
+    if (text !== "") {
+      if (raw.length >= README_BYTES) sectionTruncated = true;
+      sections.push(`${fileHeader(readmeName, raw, README_BYTES)}
+${text}`);
+    }
+  }
+  const manifest = files.find((f) => f === "package.json");
+  if (manifest !== void 0) {
+    const raw = readText(join2(root, manifest), MANIFEST_BYTES);
+    const text = raw.trim();
+    if (text !== "") {
+      if (raw.length >= MANIFEST_BYTES) sectionTruncated = true;
+      sections.push(`${fileHeader("package.json", raw, MANIFEST_BYTES)}
+${text}`);
+    }
+  }
+  const comments = collectComments(root, files);
+  if (comments.kept.length > 0 || comments.skippedForSize > 0) {
+    if (comments.kept.length < comments.total || comments.bounded || comments.skippedForSize > 0) sectionTruncated = true;
+    sections.push(
+      sectionHeader(
+        "Unresolved comments (TODO/FIXME/HACK)",
+        comments.total,
+        comments.kept.length,
+        { bounded: comments.bounded, skippedForSize: comments.skippedForSize }
+      ) + (comments.kept.length > 0 ? "\n" + comments.kept.join("\n") : "")
+    );
+  }
+  const untested = collectUntested(files);
+  if (untested.kept.length > 0) {
+    if (untested.kept.length < untested.total || untested.bounded) sectionTruncated = true;
+    sections.push(
+      sectionHeader(
+        "Untested modules (name-based hint, not a coverage run)",
+        untested.total,
+        untested.kept.length,
+        { bounded: untested.bounded }
+      ) + "\n" + untested.kept.join("\n")
+    );
+  }
+  return assemble(sections, truncated || sectionTruncated);
+}
+__name(buildDigest, "buildDigest");
+
+// src/suggest.ts
+function unfence(raw) {
+  const open = /```[ \t]*[A-Za-z0-9_-]*[ \t]*\r?\n?/.exec(raw);
+  if (open === null) return raw;
+  const lead = raw.slice(0, open.index);
+  if (lead.includes("[") || lead.includes("{")) return raw;
+  const body = raw.slice(open.index + open[0].length);
+  const close = body.lastIndexOf("```");
+  return close === -1 ? raw : body.slice(0, close);
+}
+__name(unfence, "unfence");
+function parseSuggestions(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(unfence(raw));
+  } catch (cause) {
+    return { ok: false, error: `the scan wrote invalid JSON: ${cause instanceof Error ? cause.message : String(cause)}` };
+  }
+  const list = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.suggestions) ? parsed.suggestions : void 0;
+  if (list === void 0) {
+    return { ok: false, error: "the scan did not write a list of suggestions" };
+  }
+  const suggestions = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of list) {
+    if (entry === null || typeof entry !== "object") continue;
+    const row = entry;
+    const title = typeof row.title === "string" ? row.title.trim() : "";
+    if (title.length === 0) continue;
+    const stored = title.slice(0, MAX_TEXT);
+    const key = stored.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const evidence = typeof row.evidence === "string" ? row.evidence.trim().slice(0, MAX_LABEL) : "";
+    suggestions.push({
+      title: stored,
+      rationale: typeof row.rationale === "string" ? row.rationale.trim().slice(0, MAX_DESC) : "",
+      priority: toPriority(row.priority),
+      // Absent optional fields are ABSENT KEYS, never '', matching TodoItem.
+      ...evidence.length > 0 ? { evidence } : {}
+    });
+    if (suggestions.length >= MAX_SUGGESTIONS) break;
+  }
+  return { ok: true, suggestions };
+}
+__name(parseSuggestions, "parseSuggestions");
+
 // src/index.ts
 var todoItemSchema = z.object({
   id: z.string().min(1),
@@ -240,7 +579,7 @@ var todoDomainSpec = {
   name: "dsh_todo",
   version: 2
 };
-var _replace_dec, _list_dec, _a, _init, _b;
+var _readSuggestions_dec, _scanDigest_dec, _replace_dec, _list_dec, _a, _init, _b;
 var _TodoService = class _TodoService extends (_b = TypertRemoteService) {
   /**
    * @param ctx - host context carrying the workspace registry.
@@ -267,19 +606,19 @@ var _TodoService = class _TodoService extends (_b = TypertRemoteService) {
    * Runs once per harness home; a workspace whose db already has content is
    * left untouched, so a half-finished migration never clobbers newer data.
    */
-  async [(_a = Service.init, _list_dec = [Remote], _replace_dec = [Remote], _a)]() {
+  async [(_a = Service.init, _list_dec = [Remote], _replace_dec = [Remote], _scanDigest_dec = [Remote], _readSuggestions_dec = [Remote], _a)]() {
     this.ctx.effect(() => () => this.close(), "dsh-todo: close workspace databases");
     const home = process.env.DSH_HOME;
     if (!home) return;
-    const legacyPath = join2(home, "storages", "dsh_todo.json");
-    const registryPath = join2(home, "storages", "workspace.json");
+    const legacyPath = join3(home, "storages", "dsh_todo.json");
+    const registryPath = join3(home, "storages", "workspace.json");
     try {
       if (!existsSync(legacyPath)) return;
-      const legacy = JSON.parse(readFileSync(legacyPath, "utf8"));
+      const legacy = JSON.parse(readFileSync2(legacyPath, "utf8"));
       const records = legacy?.tables?.workspaces ?? {};
       let mapping = {};
       if (existsSync(registryPath)) {
-        mapping = JSON.parse(readFileSync(registryPath, "utf8"))?.tables?.workspaces ?? {};
+        mapping = JSON.parse(readFileSync2(registryPath, "utf8"))?.tables?.workspaces ?? {};
       }
       let importedItems = 0;
       let importedWorkspaces = 0;
@@ -367,6 +706,69 @@ var _TodoService = class _TodoService extends (_b = TypertRemoteService) {
       return { ok: true, list: this.readList(db) };
     });
   }
+  async scanDigest(request) {
+    return buildDigest(this.workspaceDir(request?.workspaceId));
+  }
+  async readSuggestions(request) {
+    const dir = this.workspaceDir(request?.workspaceId);
+    const runId = request?.runId;
+    if (typeof runId !== "string" || !/^[a-z0-9]+$/.test(runId)) {
+      throw new Error("dsh-todo: runId must be a non-empty lowercase alphanumeric string");
+    }
+    const path = join3(dir, ...suggestionsFileFor(runId).split("/"));
+    this.sweepOrphanResults(dir, runId);
+    let raw;
+    try {
+      raw = readFileSync2(path, "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return { status: "pending" };
+      return { status: "error", error: `dsh-todo: the scan result could not be read: ${code ?? String(err)}` };
+    }
+    const parsed = parseSuggestions(raw);
+    try {
+      unlinkSync(path);
+    } catch {
+    }
+    if (!parsed.ok) return { status: "error", error: parsed.error };
+    return { status: "ready", suggestions: parsed.suggestions };
+  }
+  /**
+   * Delete every result file that is not the run currently reading.
+   *
+   * Per-run paths fix the cross-run bleed but introduce their own litter: a
+   * scan whose modal was closed still finishes and writes, and nobody ever
+   * reads that file. One orphan per abandoned scan accumulates in `.dsh`
+   * indefinitely, and abandoning a scan is the ordinary case, not the rare one.
+   *
+   * Sweeping on every poll — rather than at scan start — is deliberate and
+   * cheaper than it looks: a scan already polls this endpoint every 1.5s, one
+   * `readdir` of `.dsh` is trivially small beside the digest walk that preceded
+   * it, and it means a run started from a build with no sweep at all is still
+   * cleaned up by the next one. It also collects the legacy fixed-path file, so
+   * an upgrade needs no migration step.
+   *
+   * The regex is anchored on both ends: `.dsh` holds `todo.db` and whatever
+   * else the harness keeps there, and a sweep that guessed wider would delete a
+   * neighbour's data. Failure is swallowed throughout — this is housekeeping,
+   * and a scan that produced an answer must not fail over tidying.
+   *
+   * @param dir - the resolved workspace directory.
+   * @param runId - the run whose file must SURVIVE.
+   */
+  sweepOrphanResults(dir, runId) {
+    const keep = suggestionsFileFor(runId).split("/").pop();
+    try {
+      for (const name of readdirSync2(join3(dir, SUGGESTIONS_DIR))) {
+        if (name === keep || !SUGGESTIONS_FILE_RE.test(name)) continue;
+        try {
+          unlinkSync(join3(dir, SUGGESTIONS_DIR, name));
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
   /** Queue one whole read/compare/write behind this workspace's prior write. */
   async enqueue(workspaceId, run) {
     const prior = this.tails.get(workspaceId) ?? Promise.resolve();
@@ -418,6 +820,8 @@ var _TodoService = class _TodoService extends (_b = TypertRemoteService) {
 _init = __decoratorStart(_b);
 __decorateElement(_init, 1, "list", _list_dec, _TodoService);
 __decorateElement(_init, 1, "replace", _replace_dec, _TodoService);
+__decorateElement(_init, 1, "scanDigest", _scanDigest_dec, _TodoService);
+__decorateElement(_init, 1, "readSuggestions", _readSuggestions_dec, _TodoService);
 __decoratorMetadata(_init, _TodoService);
 __name(_TodoService, "TodoService");
 // Per-fiber service grants: the workspace registry property is only readable