dotmd-cli 0.14.1 → 0.14.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotmd-cli",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "description": "CLI for managing markdown documents with YAML frontmatter — index, query, validate, graph, export, Notion sync, AI summaries.",
   "type": "module",
   "license": "MIT",

package/src/config.mjs

@@ -5,6 +5,16 @@ import { die, warn } from './util.mjs';
 
 const CONFIG_FILENAMES = ['dotmd.config.mjs', '.dotmd.config.mjs', 'dotmd.config.js'];
 
+// Keys where user config replaces defaults entirely (not deep-merged).
+// These are flat maps or config sections where the user's version is authoritative —
+// default keys that the user omitted should NOT survive the merge.
+const REPLACE_KEYS = new Set([
+  'statuses.staleDays',
+  'statuses.rootStatuses',
+  'presets',
+  'context',
+]);
+
 const DEFAULTS = {
   root: '.',
   archiveDir: 'archived',
@@ -87,6 +97,118 @@ const DEFAULTS = {
   },
 };
 
+const VALID_CONTEXT_VALUES = new Set(['expanded', 'listed', 'counted']);
+
+/**
+ * Normalize rich status definitions (object form) into array form + derived config.
+ * When types.<type>.statuses is an object like:
+ *   { 'active': { context: 'expanded', staleDays: 14, requiresModule: true }, ... }
+ * this extracts all behavioral properties, converts statuses to an array for
+ * downstream processing, and returns derived values for lifecycle/taxonomy/context.
+ *
+ * Returns null if no types use object-form statuses.
+ */
+function normalizeRichStatuses(config, userConfig) {
+  const derived = {
+    archiveStatuses: [],
+    skipStaleFor: [],
+    skipWarningsFor: [],
+    terminalStatuses: [],
+    moduleRequiredFor: [],
+    staleDays: {},
+    statusOrder: [],
+    context: { expanded: [], listed: [], counted: [] },
+  };
+
+  let hasRich = false;
+
+  for (const [typeName, typeDef] of Object.entries(config.types ?? {})) {
+    if (!typeDef.statuses || Array.isArray(typeDef.statuses)) continue;
+    if (typeof typeDef.statuses !== 'object') continue;
+
+    hasRich = true;
+    const statusNames = [];
+    const typeContext = { expanded: [], listed: [], counted: [] };
+    const typeStaleDays = {};
+
+    for (const [name, props] of Object.entries(typeDef.statuses)) {
+      const p = props ?? {};
+      statusNames.push(name);
+
+      const ctx = p.context ?? 'counted';
+      if (typeContext[ctx]) typeContext[ctx].push(name);
+      // Global context: only add if not already in any bucket (first type wins)
+      const inGlobal = derived.context.expanded.includes(name) ||
+        derived.context.listed.includes(name) || derived.context.counted.includes(name);
+      if (!inGlobal && derived.context[ctx]) derived.context[ctx].push(name);
+
+      if (p.staleDays != null) {
+        typeStaleDays[name] = p.staleDays;
+        derived.staleDays[name] = p.staleDays;
+      }
+
+      if (p.archive && !derived.archiveStatuses.includes(name)) derived.archiveStatuses.push(name);
+      if (p.skipStale && !derived.skipStaleFor.includes(name)) derived.skipStaleFor.push(name);
+      if (p.skipWarnings && !derived.skipWarningsFor.includes(name)) derived.skipWarningsFor.push(name);
+      if (p.terminal && !derived.terminalStatuses.includes(name)) derived.terminalStatuses.push(name);
+      if (p.requiresModule && !derived.moduleRequiredFor.includes(name)) derived.moduleRequiredFor.push(name);
+
+      if (!derived.statusOrder.includes(name)) derived.statusOrder.push(name);
+    }
+
+    // Convert to array form for downstream pipeline
+    typeDef.statuses = statusNames;
+
+    // Derive type-level context/staleDays unless user explicitly provided them
+    const userTypeDef = userConfig.types?.[typeName];
+    if (!userTypeDef?.context) typeDef.context = typeContext;
+    if (!userTypeDef?.staleDays) typeDef.staleDays = typeStaleDays;
+  }
+
+  if (!hasRich) return null;
+  return derived;
+}
+
+/**
+ * Apply derived values from rich status definitions into the merged config.
+ * Explicit user config always wins over derived values.
+ */
+function applyDerivedConfig(config, userConfig, derived) {
+  // statuses.order — derive from types if user didn't explicitly set
+  if (!userConfig.statuses?.order && derived.statusOrder.length) {
+    config.statuses.order = derived.statusOrder;
+  }
+
+  // statuses.staleDays — merge derived as base, user overrides
+  if (!userConfig.statuses?.staleDays && Object.keys(derived.staleDays).length) {
+    config.statuses.staleDays = derived.staleDays;
+  }
+
+  // lifecycle — each sub-key independently
+  if (!userConfig.lifecycle?.archiveStatuses && derived.archiveStatuses.length) {
+    config.lifecycle.archiveStatuses = derived.archiveStatuses;
+  }
+  if (!userConfig.lifecycle?.skipStaleFor && derived.skipStaleFor.length) {
+    config.lifecycle.skipStaleFor = derived.skipStaleFor;
+  }
+  if (!userConfig.lifecycle?.skipWarningsFor && derived.skipWarningsFor.length) {
+    config.lifecycle.skipWarningsFor = derived.skipWarningsFor;
+  }
+  if (!userConfig.lifecycle?.terminalStatuses && derived.terminalStatuses.length) {
+    config.lifecycle.terminalStatuses = derived.terminalStatuses;
+  }
+
+  // taxonomy.moduleRequiredFor
+  if (!userConfig.taxonomy?.moduleRequiredFor && derived.moduleRequiredFor.length) {
+    config.taxonomy.moduleRequiredFor = derived.moduleRequiredFor;
+  }
+
+  // context — only the status-related arrays, not recentDays/recentLimit/etc
+  if (!userConfig.context?.expanded) config.context.expanded = derived.context.expanded;
+  if (!userConfig.context?.listed) config.context.listed = derived.context.listed;
+  if (!userConfig.context?.counted) config.context.counted = derived.context.counted;
+}
+
 function findConfigFile(startDir) {
   let dir = path.resolve(startDir);
   const root = path.parse(dir).root;
@@ -155,12 +277,14 @@ function validateConfig(userConfig, config, validStatuses, indexPath) {
   return warnings;
 }
 
-function deepMerge(defaults, overrides) {
+function deepMerge(defaults, overrides, parentPath = '') {
   const result = { ...defaults };
   for (const [key, value] of Object.entries(overrides)) {
+    const keyPath = parentPath ? `${parentPath}.${key}` : key;
     if (value != null && typeof value === 'object' && !Array.isArray(value) &&
-        result[key] != null && typeof result[key] === 'object' && !Array.isArray(result[key])) {
-      result[key] = deepMerge(result[key], value);
+        result[key] != null && typeof result[key] === 'object' && !Array.isArray(result[key]) &&
+        !REPLACE_KEYS.has(keyPath)) {
+      result[key] = deepMerge(result[key], value, keyPath);
     } else {
       result[key] = value;
     }
@@ -206,6 +330,10 @@ export async function resolveConfig(cwd, explicitConfigPath) {
 
   const config = deepMerge(DEFAULTS, userConfig);
 
+  // Normalize rich status definitions (object form → array + derived config)
+  const derived = normalizeRichStatuses(config, userConfig);
+  if (derived) applyDerivedConfig(config, userConfig, derived);
+
   const rootPaths = Array.isArray(config.root) ? config.root : [config.root];
   const docsRoots = rootPaths.map(r => path.resolve(configDir, r));
   const docsRoot = docsRoots[0]; // primary root for backwards compat

package/src/index.mjs

@@ -99,7 +99,8 @@ function walkMarkdownFiles(directory, files, excludedDirs, skipPaths, seen = new
   let entries;
   try {
     entries = readdirSync(directory, { withFileTypes: true });
-  } catch {
+  } catch (err) {
+    warn(`Could not read directory ${directory}: ${err.message}`);
     return;
   }
   for (const entry of entries) {

package/src/init.mjs

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import path from 'node:path';
 import { extractFrontmatter, parseSimpleFrontmatter } from './frontmatter.mjs';
 import { green, dim } from './color.mjs';
+import { warn } from './util.mjs';
 import { scaffoldClaudeCommands } from './claude-commands.mjs';
 
 const STARTER_CONFIG = `// dotmd.config.mjs — document management configuration
@@ -35,12 +36,12 @@ function scanExistingDocs(dir) {
 
   function walk(d) {
     let entries;
-    try { entries = readdirSync(d, { withFileTypes: true }); } catch { return; }
+    try { entries = readdirSync(d, { withFileTypes: true }); } catch (err) { warn(`Could not read ${d}: ${err.message}`); return; }
     for (const entry of entries) {
       if (entry.isDirectory()) { walk(path.join(d, entry.name)); continue; }
       if (!entry.name.endsWith('.md')) continue;
       let raw;
-      try { raw = readFileSync(path.join(d, entry.name), 'utf8'); } catch { continue; }
+      try { raw = readFileSync(path.join(d, entry.name), 'utf8'); } catch (err) { warn(`Could not read ${entry.name}: ${err.message}`); continue; }
       const { frontmatter } = extractFrontmatter(raw);
       if (!frontmatter) continue;
       const parsed = parseSimpleFrontmatter(frontmatter);

package/src/notion.mjs

@@ -402,7 +402,7 @@ export async function runNotionSync(argv, config, opts = {}) {
       try {
         const mdBlocks = await n2m.pageToMarkdown(remote.page.id);
         body = n2m.toMarkdownString(mdBlocks).parent ?? '';
-      } catch { /* skip body on error */ }
+      } catch (err) { warn(`Could not convert Notion page body for "${title}": ${err.message}`); }
 
       const content = `---\n${serializeFrontmatter(fm)}\n---\n\n# ${title}\n\n${body}`;
       const filePath = path.join(config.docsRoot, slug + '.md');
@@ -456,7 +456,7 @@ export async function runNotionSync(argv, config, opts = {}) {
       try {
         const mdBlocks = await n2m.pageToMarkdown(remote.page.id);
         body = n2m.toMarkdownString(mdBlocks).parent ?? '';
-      } catch { /* skip body on error */ }
+      } catch (err) { warn(`Could not convert Notion page body for "${title}": ${err.message}`); }
 
       const content = `---\n${serializeFrontmatter(fm)}\n---\n\n# ${title}\n\n${body}`;
       const filePath = path.join(config.repoRoot, local.path);

package/src/query.mjs

@@ -157,7 +157,7 @@ function getDocSummary(doc, config) {
     return config.hooks.summarizeDoc
       ? config.hooks.summarizeDoc(body, meta)
       : summarizeDocBody(body, meta);
-  } catch { return null; }
+  } catch (err) { warn(`Could not summarize ${doc.path}: ${err.message}`); return null; }
 }
 
 function renderQueryResults(docs, filters, config) {

package/src/render.mjs

@@ -151,7 +151,7 @@ function _renderContextSection(docs, ctx, opts, config, lines) {
           if (summary) {
             lines.push(`  ${''.padEnd(maxSlug)}  ${dim('ai: ' + truncate(summary, 120))}`);
           }
-        } catch { /* skip on failure */ }
+        } catch (err) { warn(`AI summary failed for ${doc.path}: ${err.message}`); }
       }
     }
     lines.push('');