dotmd-cli 0.47.0 → 0.48.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotmd-cli",
-  "version": "0.47.0",
+  "version": "0.48.1",
   "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

@@ -58,10 +58,19 @@ const DEFAULTS = {
     skipStaleFor: ['archived', 'reference', 'partial', 'queued-after'],
     skipWarningsFor: ['archived', 'partial', 'queued-after'],
     terminalStatuses: ['archived', 'deprecated', 'reference'],
+    // F15: opt-in per-status `{ filed: true }` in `types.<type>.statuses`
+    // populates this map (status → dirName). Empty by default — archive: true
+    // remains a separate primitive untouched.
+    filedStatuses: {},
   },
 
   taxonomy: {
     surfaces: null,
+    // modules: when null (default), the project doesn't enumerate product
+    // modules — the modules-required validator silently skips. When set to
+    // an array, modules are taxonomy-enforced AND moduleRequiredFor activates.
+    // Mirrors the long-standing semantics of `taxonomy.surfaces`.
+    modules: null,
     moduleRequiredFor: ['partial', 'paused', 'awaiting', 'queued-after'],
   },
 
@@ -126,6 +135,12 @@ function normalizeRichStatuses(config, userConfig) {
     skipWarningsFor: [],
     terminalStatuses: [],
     moduleRequiredFor: [],
+    // F15: status-name → directory-name (defaults to the status name verbatim).
+    // Filed statuses move docs into <root>/<dirName>/ on transition INTO the
+    // status, and back to flat <root>/ on transition OUT. Separate from
+    // archive: true to avoid touching that long-standing primitive's
+    // semantics.
+    filedStatuses: {},
     staleDays: {},
     statusOrder: [],
     context: { expanded: [], listed: [], counted: [] },
@@ -177,6 +192,11 @@ function normalizeRichStatuses(config, userConfig) {
       if ((p.skipWarnings || quietImpliesSkipWarnings) && !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 (p.filed && !derived.filedStatuses[name]) {
+        // dirName defaults to the status name; users can override with
+        // `filed: 'custom-dir'` (string form) instead of `filed: true`.
+        derived.filedStatuses[name] = typeof p.filed === 'string' ? p.filed : name;
+      }
 
       if (!derived.statusOrder.includes(name)) derived.statusOrder.push(name);
     }
@@ -222,6 +242,9 @@ function applyDerivedConfig(config, userConfig, derived) {
   if (!userConfig.lifecycle?.terminalStatuses && derived.terminalStatuses.length) {
     config.lifecycle.terminalStatuses = derived.terminalStatuses;
   }
+  if (!userConfig.lifecycle?.filedStatuses && Object.keys(derived.filedStatuses).length) {
+    config.lifecycle.filedStatuses = derived.filedStatuses;
+  }
 
   // taxonomy.moduleRequiredFor
   if (!userConfig.taxonomy?.moduleRequiredFor && derived.moduleRequiredFor.length) {
@@ -426,6 +449,9 @@ export async function resolveConfig(cwd, explicitConfigPath) {
   const validSurfaces = config.taxonomy.surfaces
     ? new Set(config.taxonomy.surfaces)
     : null;
+  const validModules = config.taxonomy.modules
+    ? new Set(config.taxonomy.modules)
+    : null;
   const moduleRequiredStatuses = new Set(config.taxonomy.moduleRequiredFor);
 
   const indexPath = config.index?.path
@@ -442,6 +468,9 @@ export async function resolveConfig(cwd, explicitConfigPath) {
   const skipStaleFor = new Set(lifecycle.skipStaleFor);
   const skipWarningsFor = new Set(lifecycle.skipWarningsFor);
   const terminalStatuses = new Set(lifecycle.terminalStatuses);
+  // F15: filedStatuses keyed by status name, value = directory name. Empty
+  // object when no status opts in via `filed: true` (or `filed: '<dirname>'`).
+  const filedStatuses = new Map(Object.entries(lifecycle.filedStatuses ?? {}));
 
   // Warn if rootStatuses keys don't match any configured root
   for (const rootKey of Object.keys(rootStatusesRaw)) {
@@ -473,9 +502,10 @@ export async function resolveConfig(cwd, explicitConfigPath) {
     rootValidStatuses,
     staleDaysByStatus,
 
-    lifecycle: { archiveStatuses, skipStaleFor, skipWarningsFor, terminalStatuses },
+    lifecycle: { archiveStatuses, skipStaleFor, skipWarningsFor, terminalStatuses, filedStatuses },
 
     validSurfaces,
+    validModules,
     moduleRequiredStatuses,
 
     indexPath,

package/src/lifecycle.mjs

@@ -168,9 +168,22 @@ export async function runStatus(argv, config, opts = {}) {
   const today = nowIso();
   const archiveDir = path.join(fileRoot, config.archiveDir);
   const relFromRoot = path.relative(fileRoot, filePath);
+  const relSegments = relFromRoot.split(path.sep);
   const inArchive = relFromRoot.startsWith(config.archiveDir + '/') || relFromRoot.startsWith(config.archiveDir + path.sep);
   const isArchiving = config.lifecycle.archiveStatuses.has(newStatus) && !inArchive;
   const isUnarchiving = !config.lifecycle.archiveStatuses.has(newStatus) && inArchive;
+
+  // F15 filing: a status with `filed: true` lives in `<root>/<dirName>/`. The
+  // current parent dir under root tells us whether the file is in some
+  // "bucket" right now. Archiving keeps its own path; filing is a separate
+  // primitive that fires only when the new status is filed (and isn't an
+  // archive transition — archive wins by being earlier in the conditional).
+  const filedStatuses = config.lifecycle.filedStatuses ?? new Map();
+  const newFiledDir = filedStatuses.get(newStatus) ?? null;
+  const oldFiledDir = oldStatus ? (filedStatuses.get(oldStatus) ?? null) : null;
+  const currentBucket = relSegments.length > 1 ? relSegments[0] : null;
+  const isFiling = !isArchiving && !isUnarchiving && newFiledDir && currentBucket !== newFiledDir;
+  const isUnfiling = !isArchiving && !isUnarchiving && !newFiledDir && oldFiledDir && currentBucket === oldFiledDir;
   let finalPath = filePath;
 
   if (dryRun) {
@@ -186,7 +199,17 @@ export async function runStatus(argv, config, opts = {}) {
       process.stdout.write(`${prefix} Would move: ${toRepoPath(filePath, config.repoRoot)} → ${toRepoPath(targetPath, config.repoRoot)}\n`);
       finalPath = targetPath;
     }
-    if ((isArchiving || isUnarchiving) && config.indexPath) {
+    if (isFiling) {
+      const targetPath = path.join(fileRoot, newFiledDir, path.basename(filePath));
+      process.stdout.write(`${prefix} Would file: ${toRepoPath(filePath, config.repoRoot)} → ${toRepoPath(targetPath, config.repoRoot)}\n`);
+      finalPath = targetPath;
+    }
+    if (isUnfiling) {
+      const targetPath = path.join(fileRoot, path.basename(filePath));
+      process.stdout.write(`${prefix} Would unfile: ${toRepoPath(filePath, config.repoRoot)} → ${toRepoPath(targetPath, config.repoRoot)}\n`);
+      finalPath = targetPath;
+    }
+    if ((isArchiving || isUnarchiving || isFiling || isUnfiling) && config.indexPath) {
       process.stdout.write(`${prefix} Would regenerate index\n`);
     }
     process.stdout.write(`${prefix} ${toRepoPath(finalPath, config.repoRoot)}: ${oldStatus ?? 'unknown'} → ${newStatus}\n`);
@@ -212,6 +235,24 @@ export async function runStatus(argv, config, opts = {}) {
     finalPath = targetPath;
   }
 
+  if (isFiling) {
+    const targetDir = path.join(fileRoot, newFiledDir);
+    mkdirSync(targetDir, { recursive: true });
+    const targetPath = path.join(targetDir, path.basename(filePath));
+    if (existsSync(targetPath)) { die(`Target already exists: ${toRepoPath(targetPath, config.repoRoot)}`); }
+    const result = gitMv(filePath, targetPath, config.repoRoot);
+    if (result.status !== 0) { die(result.stderr || 'git mv failed.'); }
+    finalPath = targetPath;
+  }
+
+  if (isUnfiling) {
+    const targetPath = path.join(fileRoot, path.basename(filePath));
+    if (existsSync(targetPath)) { die(`Target already exists: ${toRepoPath(targetPath, config.repoRoot)}`); }
+    const result = gitMv(filePath, targetPath, config.repoRoot);
+    if (result.status !== 0) { die(result.stderr || 'git mv failed.'); }
+    finalPath = targetPath;
+  }
+
   // Regen the index on every status change — `active → planned` etc. drift
   // the per-status sections just as much as archive crossings. Archive paths
   // also benefit (replaces the previously-gated regen). `--no-index` skips

package/src/validate.mjs

@@ -19,6 +19,11 @@ const BUILTIN_TYPE_DIR_NAMES = ['plans', 'prompts'];
 function liveTypeDirsForRoots(config) {
   const set = new Set();
   const roots = config.docsRoots || (config.docsRoot ? [config.docsRoot] : []);
+  // F15: filed-status bucket dirs are "live" too — a doc whose status is
+  // an archive status but whose parent dir is a filed bucket should still
+  // trigger the archive-drift warning (the file needs to move into the
+  // archive bucket).
+  const filedDirs = [...((config.lifecycle?.filedStatuses?.values?.()) ?? [])];
   for (const root of roots) {
     const rootRel = path.relative(config.repoRoot, root).split(path.sep).join('/');
     // The root itself is a live dir (covers flat-array layouts where the
@@ -40,6 +45,11 @@ function liveTypeDirsForRoots(config) {
         set.add(rootRel ? `${rootRel}/${tmpl.dir}` : tmpl.dir);
       }
     }
+    // F15: filed bucket dirs joined to each root.
+    for (const dirName of filedDirs) {
+      if (path.basename(rootRel) === dirName) continue;
+      set.add(rootRel ? `${rootRel}/${dirName}` : dirName);
+    }
   }
   return set;
 }
@@ -107,8 +117,13 @@ export function validateDoc(doc, frontmatter, headingTitle, config) {
     doc.errors.push({ path: doc.path, level: 'error', message: '`modules` must be a YAML list when present.' });
   }
 
-  if (config.moduleRequiredStatuses.has(doc.status) && !doc.modules?.length) {
-    doc.errors.push({ path: doc.path, level: 'error', message: '`modules` is required for active/ready/planned/blocked docs; use a real module, `platform`, or `none`.' });
+  // modules-required gate: only fires when the project has actively declared
+  // a module taxonomy (`taxonomy.modules` is an array). Repos with no product
+  // modules (CLIs, dev tooling, single-domain apps) shouldn't be forced to
+  // sprinkle `modules: [none]` on every plan as a sentinel. Mirrors the
+  // long-standing `taxonomy.surfaces` opt-in semantics.
+  if (config.validModules && config.moduleRequiredStatuses.has(doc.status) && !doc.modules?.length) {
+    doc.errors.push({ path: doc.path, level: 'error', message: '`modules` is required for this status; declare a real module from `taxonomy.modules`, or `none` as the explicit no-module sentinel.' });
   }
 
   if (config.validSurfaces && !config.lifecycle.skipWarningsFor.has(doc.status)) {