dotmd-cli 0.86.0 → 0.87.1

package/src/diff.mjs

@@ -3,7 +3,7 @@ import { extractFrontmatter, parseSimpleFrontmatter } from './frontmatter.mjs';
 import { asString, toRepoPath, die, warn } from './util.mjs';
 import { gitDiffSince } from './git.mjs';
 import { buildIndex, resolveDocArg } from './index.mjs';
-import { summarizeDiffText, DEFAULT_MODEL } from './ai.mjs';
+import { summarizeDiffText } from './ai.mjs';
 import { bold, dim } from './color.mjs';
 
 export function runDiff(argv, config) {
@@ -12,7 +12,7 @@ export function runDiff(argv, config) {
   let stat = false;
   let sinceOverride = null;
   let summarize = false;
-  let model = DEFAULT_MODEL;
+  let model;
 
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--stat') { stat = true; continue; }

package/src/errors-read.mjs

@@ -0,0 +1,30 @@
+import { readGlobalErrors, globalErrorLogPath } from './journal.mjs';
+import { die } from './util.mjs';
+import { dim, red } from './color.mjs';
+
+// `runlist errors` — the newest failed runlist commands, from the cross-repo
+// error log every failing invocation appends to.
+function parseArgs(argv) {
+  const opts = { limit: 20, repo: null, asJson: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--limit' || a === '--tail') {
+      const n = Number(argv[++i]);
+      if (!Number.isInteger(n) || n < 1) die(`${a} takes a whole number of entries, 1 or more.`);
+      opts.limit = n;
+    } else if (a === '--repo' && argv[i + 1]) opts.repo = argv[++i];
+    else if (a === '--json') opts.asJson = true;
+  }
+  return opts;
+}
+
+export function runErrors(argv) {
+  const opts = parseArgs(argv);
+  const entries = readGlobalErrors({ limit: opts.limit, repo: opts.repo });
+  if (opts.asJson) { process.stdout.write(`${JSON.stringify(entries, null, 2)}\n`); return; }
+  if (!entries.length) { process.stdout.write(`No failed runlist commands recorded in ${globalErrorLogPath()}.\n`); return; }
+  for (const e of entries) {
+    const repo = e.repo ? dim(` ${e.repo.split('/').pop()}`) : '';
+    process.stdout.write(`[${e.at}]${repo} ${e.command}\n  ${red(e.message ?? '(no message)')}\n`);
+  }
+}

package/src/fix-refs.mjs

@@ -43,9 +43,7 @@ export function fixBrokenRefs(config, opts = {}) {
 
   // ── Fix broken frontmatter references ────────────────────────────────
 
-  const brokenRefErrors = index.errors.filter(e =>
-    e.message.includes('does not resolve to an existing file')
-  );
+  const brokenRefErrors = index.errors.filter(error => error.meta?.kind === 'ref-resolution');
 
   if (brokenRefErrors.length > 0) {
     const fixesByDoc = new Map();
@@ -101,12 +99,12 @@ export function fixBrokenRefs(config, opts = {}) {
   // ── Fix broken body links ────────────────────────────────────────────
 
   for (const doc of index.docs) {
-    const brokenBodyWarnings = doc.warnings.filter(w =>
-      w.meta?.kind === 'body-link-resolution'
-        && w.meta?.targetKind === 'document'
-        && w.meta?.reason === 'missing'
+    const brokenBodyErrors = doc.errors.filter(error =>
+      error.meta?.kind === 'body-link-resolution'
+        && error.meta?.targetKind === 'document'
+        && error.meta?.reason === 'missing'
     );
-    if (!brokenBodyWarnings.length) continue;
+    if (!brokenBodyErrors.length) continue;
 
     const absPath = path.join(config.repoRoot, doc.path);
     let raw = readFileSync(absPath, 'utf8');
@@ -116,10 +114,10 @@ export function fixBrokenRefs(config, opts = {}) {
     const bodyFixes = [];
     const seenBodyTargets = new Set();
 
-    for (const warn of brokenBodyWarnings) {
-      const brokenHref = warn.meta.relPath;
-      const rawHref = warn.meta.rawHref ?? brokenHref;
-      const targetKey = `${warn.meta.angle ? 'angle' : 'plain'}:${rawHref}`;
+    for (const error of brokenBodyErrors) {
+      const brokenHref = error.meta.relPath;
+      const rawHref = error.meta.rawHref ?? brokenHref;
+      const targetKey = `${error.meta.angle ? 'angle' : 'plain'}:${rawHref}`;
       if (seenBodyTargets.has(targetKey)) continue;
       seenBodyTargets.add(targetKey);
       const brokenBasename = path.basename(brokenHref);
@@ -133,11 +131,11 @@ export function fixBrokenRefs(config, opts = {}) {
 
       const suffixAt = rawHref.search(/[?#]/);
       const suffix = suffixAt === -1 ? '' : rawHref.slice(suffixAt);
-      const renderedHref = warn.meta.angle
+      const renderedHref = error.meta.angle
         ? `<${correctHref}${suffix}>`
         : `${correctHref.replace(/([\s()[\]<>])/g, '\\$1')}${suffix}`;
       const linkRegex = new RegExp(
-        '(\\]\\(\\s*)' + (warn.meta.angle ? '<' : '') + escapeRegex(rawHref) + (warn.meta.angle ? '>' : '') + '(?=\\s|\\))',
+        '(\\]\\(\\s*)' + (error.meta.angle ? '<' : '') + escapeRegex(rawHref) + (error.meta.angle ? '>' : '') + '(?=\\s|\\))',
         'g'
       );
       let replacements = 0;

package/src/journal.mjs

@@ -322,6 +322,32 @@ export function recordGlobalError({ config, startMs, args, err, version }) {
   }
 }
 
+// The newest failures first, as `{ at, command, message, repo, exit }`: the
+// current file, then its one rollover. Reads what `recordGlobalError` wrote
+// (argv and message already sanitized there); nothing else is kept per line.
+export function readGlobalErrors({ limit = 20, repo = null } = {}) {
+  const file = globalErrorLogPath();
+  const backup = globalErrorLogBackupPath();
+  purgeLegacyTelemetry(file, backup);
+  pruneStaleBackup(backup);
+  const out = [];
+  for (const source of [file, backup]) {
+    const lines = readLogLines(source).reverse();
+    for (const e of lines) {
+      if (repo && !String(e.repo ?? '').includes(repo)) continue;
+      out.push({
+        at: e.ts ?? null,
+        command: ['runlist', ...(Array.isArray(e.argv) ? e.argv : [])].join(' '),
+        message: e.err ?? null,
+        repo: e.repo ?? null,
+        exit: e.exit ?? null,
+      });
+      if (limit && out.length >= limit) return out;
+    }
+  }
+  return out;
+}
+
 // Misuse log: always-on, cross-repo, append-only record of every wrong-move the
 // PreToolUse guard intercepts (committing a gitignored prompt, `cat`-ing a
 // prompt instead of `dotmd use`, hand-editing a `status:` field, …). This is

package/src/lint.mjs

@@ -4,7 +4,7 @@ import { extractFrontmatter, parseSimpleFrontmatter, replaceFrontmatter } from '
 import { asString, toRepoPath, escapeRegex, warn } from './util.mjs';
 import { buildIndex, collectDocFiles } from './index.mjs';
 import { updateFrontmatter } from './lifecycle.mjs';
-import { runMLX, checkUvAvailable } from './ai.mjs';
+import { runModel } from './ai.mjs';
 import { bold, green, yellow, dim } from './color.mjs';
 import { authorizeManagedSweep, findLexicalDocsRoot } from './managed-path.mjs';
 
@@ -274,7 +274,7 @@ export function runLint(argv, config, opts = {}) {
         const statusList = inferTypeSet ? [...inferTypeSet].join(', ') : config.statusOrder.join(', ');
         const { body } = extractFrontmatter(raw);
         const prompt = `Given this markdown document, classify it into exactly one of these statuses: ${statusList}.\nReply with ONLY the status word, nothing else.\n\nFile: ${repoPath}\n\n${(body ?? '').slice(0, 4000)}`;
-        const result = runMLX(prompt, { maxTokens: 10 });
+        const result = runModel(prompt, { maxTokens: 10 });
         const suggested = result?.trim().toLowerCase().split(/\s+/)[0];
         const inferValid = inferTypeSet ?? config.validStatuses;
         if (suggested && inferValid.has(suggested)) {

package/src/model-request.mjs

@@ -0,0 +1,33 @@
+// HTTP requests to the local model server, run as a child process so the
+// synchronous callers (summaries, lint's status inference) can wait on them
+// without every render path turning async. Reads a list of
+// {url, method, body, timeoutMs} as JSON on stdin, sends them in order, and
+// writes the list of {ok, status, json, error} as JSON on stdout.
+
+const input = JSON.parse(await new Promise(resolve => {
+  let data = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { data += chunk; });
+  process.stdin.on('end', () => resolve(data));
+}));
+
+async function send(input) {
+  try {
+    const res = await fetch(input.url, {
+      method: input.method ?? 'GET',
+      headers: input.body ? { 'content-type': 'application/json' } : undefined,
+      body: input.body ? JSON.stringify(input.body) : undefined,
+      signal: AbortSignal.timeout(input.timeoutMs ?? 10000),
+    });
+    const text = await res.text();
+    let json = null;
+    try { json = JSON.parse(text); } catch { /* non-JSON body; status says enough */ }
+  return { ok: res.ok, status: res.status, json, error: res.ok ? null : (json?.error ?? text.slice(0, 200)) };
+  } catch (err) {
+    return { ok: false, status: 0, json: null, error: err.name === 'TimeoutError' ? 'timed out' : (err.cause?.code ?? err.message) };
+  }
+}
+
+const out = [];
+for (const req of [input].flat()) out.push(await send(req));
+process.stdout.write(JSON.stringify(Array.isArray(input) ? out : out[0]));