dotmd-cli 0.12.0 → 0.13.1

package/README.md

@@ -113,7 +113,8 @@ dotmd coverage [--json]      Metadata coverage report
 dotmd stats [--json]         Doc health dashboard
 dotmd graph [--dot|--json]   Visualize document relationships
 dotmd deps [file]            Dependency tree or overview
-dotmd context [--summarize]  Compact briefing (LLM-oriented)
+dotmd briefing               Compact summary for session start
+dotmd context [--summarize]  Full briefing (LLM-oriented)
 dotmd focus [status]         Detailed view for one status group
 dotmd query [filters]        Filtered search
 dotmd plans                  List all plans

package/bin/dotmd.mjs

@@ -4,29 +4,6 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import { resolveConfig } from '../src/config.mjs';
-import { buildIndex } from '../src/index.mjs';
-import { renderCompactList, renderVerboseList, renderContext, renderCheck, renderCoverage, buildCoverage } from '../src/render.mjs';
-import { renderIndexFile, writeIndex } from '../src/index-file.mjs';
-import { runFocus, runQuery } from '../src/query.mjs';
-import { runStatus, runArchive, runTouch, runBulkArchive, runPickup, runFinish } from '../src/lifecycle.mjs';
-import { runInit } from '../src/init.mjs';
-import { runNew } from '../src/new.mjs';
-import { runCompletions } from '../src/completions.mjs';
-import { runWatch } from '../src/watch.mjs';
-import { runDiff } from '../src/diff.mjs';
-import { runLint } from '../src/lint.mjs';
-import { runRename } from '../src/rename.mjs';
-import { runMigrate } from '../src/migrate.mjs';
-import { runFixRefs, fixBrokenRefs } from '../src/fix-refs.mjs';
-import { buildGraph, renderGraphText, renderGraphDot, renderGraphJson } from '../src/graph.mjs';
-import { runDoctor } from '../src/doctor.mjs';
-import { buildStats, renderStats, renderStatsJson } from '../src/stats.mjs';
-import { runSummary } from '../src/summary.mjs';
-import { runDeps, runUnblocks } from '../src/deps.mjs';
-import { runHealth } from '../src/health.mjs';
-import { runGlossary } from '../src/glossary.mjs';
-import { runExport } from '../src/export.mjs';
-import { runNotion } from '../src/notion.mjs';
 import { die, warn, levenshtein } from '../src/util.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -39,7 +16,8 @@ const HELP = {
 View & Query:
   list [--verbose] [--json]         List docs grouped by status (default command)
   json                              Full index as JSON
-  context [--summarize] [--json]    Compact briefing (LLM-oriented)
+  briefing [--json]                 Compact summary for session start (5-10 lines)
+  context [--summarize] [--json]    Full briefing (LLM-oriented)
   focus [status] [--json]           Detailed view for one status group
   query [filters] [--json]          Filtered search (--status, --keyword, --stale, etc.)
   coverage [--json]                 Metadata coverage report
@@ -191,7 +169,15 @@ Shows detailed info for all docs matching the given status (default: active).
 Options:
   --json                 Output as JSON`,
 
-  context: `dotmd context — compact briefing (LLM-oriented)
+  briefing: `dotmd briefing — compact summary for session start
+
+Shows plan statuses with next steps, doc/research counts, and health
+in 5-10 lines. Designed for LLM context injection.
+
+Options:
+  --json                 Output as JSON`,
+
+  context: `dotmd context — full briefing (LLM-oriented)
 
 Generates a compact status briefing designed for AI/LLM consumption.
 
@@ -418,6 +404,7 @@ async function main() {
   }
 
   if (command === 'completions') {
+    const { runCompletions } = await import('../src/completions.mjs');
     runCompletions(args.slice(1));
     return;
   }
@@ -438,12 +425,13 @@ async function main() {
 
   // Init — now has access to config for Claude command generation
   if (command === 'init') {
+    const { runInit } = await import('../src/init.mjs');
     runInit(process.cwd(), config.configFound ? config : null);
     return;
   }
 
   // Watch is a pure proxy — pass raw args so the child process gets all flags
-  if (command === 'watch') { runWatch(args.slice(1), config); return; }
+  if (command === 'watch') { const { runWatch } = await import('../src/watch.mjs'); runWatch(args.slice(1), config); return; }
 
   // Strip global flags from restArgs so commands don't have to filter them
   const restArgs = [];
@@ -476,35 +464,41 @@ async function main() {
 
   // Preset aliases
   if (config.presets[command]) {
+    const { buildIndex } = await import('../src/index.mjs');
+    const { runQuery } = await import('../src/query.mjs');
     const index = buildIndex(config);
     runQuery(index, [...config.presets[command], ...restArgs], config);
     return;
   }
 
   // Commands that handle their own index building
-  if (command === 'diff') { runDiff(restArgs, config); return; }
-  if (command === 'summary') { runSummary(restArgs, config); return; }
-  if (command === 'deps') { runDeps(restArgs, config); return; }
-  if (command === 'unblocks') { runUnblocks(restArgs, config); return; }
-  if (command === 'health') { runHealth(restArgs, config); return; }
-  if (command === 'glossary') { runGlossary(restArgs, config); return; }
-  if (command === 'export') { runExport(restArgs, config, { dryRun, root: rootArg, type: typeArg }); return; }
-  if (command === 'notion') { await runNotion(restArgs, config, { dryRun }); return; }
+  if (command === 'diff') { const { runDiff } = await import('../src/diff.mjs'); runDiff(restArgs, config); return; }
+  if (command === 'summary') { const { runSummary } = await import('../src/summary.mjs'); runSummary(restArgs, config); return; }
+  if (command === 'deps') { const { runDeps } = await import('../src/deps.mjs'); runDeps(restArgs, config); return; }
+  if (command === 'unblocks') { const { runUnblocks } = await import('../src/deps.mjs'); runUnblocks(restArgs, config); return; }
+  if (command === 'health') { const { runHealth } = await import('../src/health.mjs'); runHealth(restArgs, config); return; }
+  if (command === 'glossary') { const { runGlossary } = await import('../src/glossary.mjs'); runGlossary(restArgs, config); return; }
+  if (command === 'export') { const { runExport } = await import('../src/export.mjs'); runExport(restArgs, config, { dryRun, root: rootArg, type: typeArg }); return; }
+  if (command === 'notion') { const { runNotion } = await import('../src/notion.mjs'); await runNotion(restArgs, config, { dryRun }); return; }
 
   // Lifecycle commands
-  if (command === 'pickup') { await runPickup(restArgs, config, { dryRun }); return; }
-  if (command === 'finish') { await runFinish(restArgs, config, { dryRun }); return; }
-  if (command === 'status') { await runStatus(restArgs, config, { dryRun }); return; }
-  if (command === 'archive') { runArchive(restArgs, config, { dryRun }); return; }
-  if (command === 'bulk' && restArgs[0] === 'archive') { runBulkArchive(restArgs.slice(1), config, { dryRun }); return; }
-  if (command === 'touch') { runTouch(restArgs, config, { dryRun }); return; }
-  if (command === 'new') { await runNew(restArgs, config, { dryRun, root: rootArg }); return; }
-  if (command === 'lint') { runLint(restArgs, config, { dryRun }); return; }
-  if (command === 'rename') { await runRename(restArgs, config, { dryRun }); return; }
-  if (command === 'migrate') { runMigrate(restArgs, config, { dryRun }); return; }
-  if (command === 'fix-refs') { runFixRefs(restArgs, config, { dryRun }); return; }
-  if (command === 'doctor') { runDoctor(restArgs, config, { dryRun }); return; }
-
+  if (command === 'pickup') { const { runPickup } = await import('../src/lifecycle.mjs'); await runPickup(restArgs, config, { dryRun }); return; }
+  if (command === 'finish') { const { runFinish } = await import('../src/lifecycle.mjs'); await runFinish(restArgs, config, { dryRun }); return; }
+  if (command === 'status') { const { runStatus } = await import('../src/lifecycle.mjs'); await runStatus(restArgs, config, { dryRun }); return; }
+  if (command === 'archive') { const { runArchive } = await import('../src/lifecycle.mjs'); runArchive(restArgs, config, { dryRun }); return; }
+  if (command === 'bulk' && restArgs[0] === 'archive') { const { runBulkArchive } = await import('../src/lifecycle.mjs'); runBulkArchive(restArgs.slice(1), config, { dryRun }); return; }
+  if (command === 'touch') { const { runTouch } = await import('../src/lifecycle.mjs'); runTouch(restArgs, config, { dryRun }); return; }
+  if (command === 'new') { const { runNew } = await import('../src/new.mjs'); await runNew(restArgs, config, { dryRun, root: rootArg }); return; }
+  if (command === 'lint') { const { runLint } = await import('../src/lint.mjs'); runLint(restArgs, config, { dryRun }); return; }
+  if (command === 'rename') { const { runRename } = await import('../src/rename.mjs'); await runRename(restArgs, config, { dryRun }); return; }
+  if (command === 'migrate') { const { runMigrate } = await import('../src/migrate.mjs'); runMigrate(restArgs, config, { dryRun }); return; }
+  if (command === 'fix-refs') { const { runFixRefs } = await import('../src/fix-refs.mjs'); runFixRefs(restArgs, config, { dryRun }); return; }
+  if (command === 'doctor') { const { runDoctor } = await import('../src/doctor.mjs'); runDoctor(restArgs, config, { dryRun }); return; }
+
+  // All remaining commands need the index + render modules
+  const { buildIndex } = await import('../src/index.mjs');
+  const { renderCompactList, renderVerboseList, renderContext, renderBriefing, renderCheck, renderCoverage, buildCoverage } = await import('../src/render.mjs');
+  const { runFocus, runQuery } = await import('../src/query.mjs');
   const index = buildIndex(config);
 
   // Apply --root and --type filters
@@ -561,6 +555,8 @@ async function main() {
 
     if (fix) {
       // Auto-fix: broken refs, then lint, then rebuild index
+      const { fixBrokenRefs } = await import('../src/fix-refs.mjs');
+      const { runLint } = await import('../src/lint.mjs');
       fixBrokenRefs(config, { dryRun, quiet: false });
       runLint(['--fix'], config, { dryRun });
       if (config.indexPath) {
@@ -620,6 +616,7 @@ async function main() {
   }
 
   if (command === 'stats') {
+    const { buildStats, renderStats, renderStatsJson } = await import('../src/stats.mjs');
     const stats = buildStats(index, config);
     if (args.includes('--json')) {
       process.stdout.write(renderStatsJson(stats));
@@ -634,6 +631,7 @@ async function main() {
       die('Index generation is not configured. Add an `index` section to your dotmd.config.mjs.');
     }
     const write = args.includes('--write');
+    const { renderIndexFile, writeIndex } = await import('../src/index-file.mjs');
     const rendered = renderIndexFile(index, config);
     if (write && !dryRun) {
       writeIndex(rendered, config);
@@ -648,6 +646,24 @@ async function main() {
 
   if (command === 'focus') { runFocus(index, restArgs, config); return; }
   if (command === 'query') { runQuery(index, restArgs, config); return; }
+  if (command === 'briefing') {
+    if (args.includes('--json')) {
+      const plans = index.docs.filter(d => d.type === 'plan');
+      const docs = index.docs.filter(d => d.type === 'doc');
+      const research = index.docs.filter(d => d.type === 'research');
+      const stale = index.docs.filter(d => d.isStale && !config.lifecycle.skipStaleFor.has(d.status)).length;
+      process.stdout.write(JSON.stringify({
+        plans: { total: plans.length, inSession: plans.filter(d => d.status === 'in-session').map(d => ({ path: d.path, title: d.title, nextStep: d.nextStep })), active: plans.filter(d => d.status === 'active').map(d => ({ path: d.path, title: d.title, nextStep: d.nextStep })) },
+        docs: { total: docs.length, active: docs.filter(d => !config.lifecycle.terminalStatuses.has(d.status)).length },
+        research: { total: research.length, active: research.filter(d => d.status === 'active').length },
+        stale, errorCount: index.errors.length, warningCount: index.warnings.length,
+      }, null, 2) + '\n');
+    } else {
+      process.stdout.write(renderBriefing(index, config));
+    }
+    return;
+  }
+
   if (command === 'context') {
     const summarize = args.includes('--summarize');
     const modelIdx = args.indexOf('--model');
@@ -703,6 +719,7 @@ async function main() {
   }
 
   if (command === 'graph') {
+    const { buildGraph, renderGraphText, renderGraphDot, renderGraphJson } = await import('../src/graph.mjs');
     const statusFilter = (() => { const i = args.indexOf('--status'); return i !== -1 && args[i + 1] ? args[i + 1] : null; })();
     const moduleFilter = (() => { const i = args.indexOf('--module'); return i !== -1 && args[i + 1] ? args[i + 1] : null; })();
     const surfaceFilter = (() => { const i = args.indexOf('--surface'); return i !== -1 && args[i + 1] ? args[i + 1] : null; })();
@@ -723,7 +740,7 @@ async function main() {
 
   // Unknown command — suggest closest match
   const allCommands = [
-    'list', 'json', 'check', 'coverage', 'stats', 'graph', 'deps', 'context',
+    'list', 'json', 'check', 'coverage', 'stats', 'graph', 'deps', 'briefing', 'context',
     'focus', 'query', 'plans', 'stale', 'actionable', 'index', 'pickup', 'finish', 'status', 'archive', 'touch', 'doctor',
     'fix-refs', 'lint', 'rename', 'migrate', 'notion', 'export', 'summary',
     'watch', 'diff', 'new', 'init', 'completions',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotmd-cli",
-  "version": "0.12.0",
+  "version": "0.13.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/completions.mjs

@@ -1,7 +1,7 @@
 import { die } from './util.mjs';
 
 const COMMANDS = [
-  'list', 'json', 'check', 'coverage', 'stats', 'graph', 'deps', 'unblocks', 'health', 'glossary', 'context', 'focus', 'query',
+  'list', 'json', 'check', 'coverage', 'stats', 'graph', 'deps', 'unblocks', 'health', 'glossary', 'briefing', 'context', 'focus', 'query',
   'plans', 'stale', 'actionable', 'index', 'pickup', 'finish', 'status', 'archive', 'bulk', 'touch', 'doctor', 'lint', 'rename', 'migrate',
   'fix-refs', 'notion', 'export', 'summary', 'watch', 'diff', 'init', 'new', 'completions',
 ];
@@ -32,6 +32,7 @@ const COMMAND_FLAGS = {
   plans: ['--status', '--json', '--sort', '--limit', '--all', '--stale', '--has-next-step'],
   stale: ['--json', '--sort', '--limit', '--all'],
   actionable: ['--json', '--sort', '--limit', '--all'],
+  briefing: ['--json'],
   pickup: ['--json'],
   finish: ['--json'],
   status: [],

package/src/git.mjs

@@ -19,6 +19,24 @@ export function getGitLastModified(relPath, repoRoot) {
   return result.stdout.trim();
 }
 
+export function getGitLastModifiedBatch(repoRoot) {
+  const result = spawnSync('git', [
+    'log', '--format=commit %aI', '--name-only', '--diff-filter=ACDMR', 'HEAD',
+  ], { cwd: repoRoot, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
+  if (result.error || result.status !== 0) return new Map();
+
+  const map = new Map();
+  let currentDate = null;
+  for (const line of result.stdout.split('\n')) {
+    if (line.startsWith('commit ')) {
+      currentDate = line.slice(7).trim();
+    } else if (line && currentDate && !map.has(line)) {
+      map.set(line, currentDate);
+    }
+  }
+  return map;
+}
+
 export function gitMv(source, target, repoRoot) {
   ensureGit();
   const result = spawnSync('git', ['mv', source, target], {

package/src/lifecycle.mjs

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { extractFrontmatter, parseSimpleFrontmatter, replaceFrontmatter } from './frontmatter.mjs';
 import { asString, toRepoPath, die, warn, resolveDocPath, escapeRegex } from './util.mjs';
-import { gitMv, getGitLastModified } from './git.mjs';
+import { gitMv, getGitLastModified, getGitLastModifiedBatch } from './git.mjs';
 import { buildIndex, collectDocFiles } from './index.mjs';
 import { renderIndexFile, writeIndex } from './index-file.mjs';
 import { green, dim, yellow } from './color.mjs';
@@ -356,6 +356,7 @@ export function runTouch(argv, config, opts = {}) {
 
     const prefix = dryRun ? dim('[dry-run] ') : '';
     let synced = 0;
+    const gitDates = getGitLastModifiedBatch(config.repoRoot);
 
     for (const filePath of allFiles) {
       const repoPath = toRepoPath(filePath, config.repoRoot);
@@ -368,7 +369,7 @@ export function runTouch(argv, config, opts = {}) {
       if (config.lifecycle.skipStaleFor.has(status)) continue;
 
       const fmUpdated = asString(parsed.updated);
-      const gitDate = getGitLastModified(repoPath, config.repoRoot);
+      const gitDate = gitDates.get(repoPath) ?? null;
       if (!gitDate) continue;
 
       const gitDay = gitDate.slice(0, 10);

package/src/query.mjs

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { capitalize, toSlug, warn } from './util.mjs';
 import { renderProgressBar } from './render.mjs';
 import { computeDaysSinceUpdate, computeIsStale } from './validate.mjs';
-import { getGitLastModified } from './git.mjs';
+import { getGitLastModifiedBatch } from './git.mjs';
 import { extractFrontmatter } from './frontmatter.mjs';
 import { summarizeDocBody } from './ai.mjs';
 import { dim } from './color.mjs';
@@ -128,8 +128,9 @@ export function filterDocs(docs, filters, config) {
   if (filters.updatedSince) result = result.filter(d => d.updated && d.updated >= filters.updatedSince);
 
   if (filters.git) {
+    const gitDates = getGitLastModifiedBatch(config.repoRoot);
     for (const doc of result) {
-      const gitDate = getGitLastModified(doc.path, config.repoRoot);
+      const gitDate = gitDates.get(doc.path) ?? null;
       if (gitDate) {
         doc.daysSinceUpdate = computeDaysSinceUpdate(gitDate);
         doc.isStale = computeIsStale(doc.status, gitDate, config);

package/src/render.mjs

@@ -258,6 +258,44 @@ function _renderContext(index, config, opts = {}) {
   return `${lines.join('\n').trimEnd()}\n`;
 }
 
+export function renderBriefing(index, config) {
+  const lines = [];
+  const plans = index.docs.filter(d => d.type === 'plan');
+  const docs = index.docs.filter(d => d.type === 'doc');
+  const research = index.docs.filter(d => d.type === 'research');
+  const untyped = index.docs.filter(d => !d.type);
+
+  if (plans.length) {
+    const bySt = {};
+    for (const p of plans) { bySt[p.status] = (bySt[p.status] ?? 0) + 1; }
+    const counts = Object.entries(bySt).map(([s, n]) => `${n} ${s}`).join(', ');
+    lines.push(`${plans.length} plans: ${counts}`);
+    const show = plans.filter(p => p.status === 'in-session' || p.status === 'active');
+    for (const p of show) {
+      const next = p.nextStep ? `next: ${p.nextStep}` : '(no next step)';
+      lines.push(`  > ${path.basename(p.path, '.md')} (${p.status}) ${next}`);
+    }
+  }
+
+  const parts = [];
+  if (docs.length) {
+    const active = docs.filter(d => !config.lifecycle.terminalStatuses.has(d.status)).length;
+    const rest = docs.length - active;
+    parts.push(`${active} docs active` + (rest ? `, ${rest} other` : ''));
+  }
+  if (research.length) {
+    const active = research.filter(d => d.status === 'active').length;
+    parts.push(`${active} research active`);
+  }
+  if (untyped.length) parts.push(`${untyped.length} untyped`);
+  if (parts.length) lines.push(parts.join(' | '));
+
+  const stale = index.docs.filter(d => d.isStale && !config.lifecycle.skipStaleFor.has(d.status)).length;
+  lines.push(`Stale: ${stale} | Errors: ${index.errors.length} | Warnings: ${index.warnings.length}`);
+
+  return lines.join('\n') + '\n';
+}
+
 export function renderCheck(index, config, opts = {}) {
   const defaultRenderer = (idx) => _renderCheck(idx, opts);
   if (config.hooks.renderCheck) {

package/src/validate.mjs

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { asString } from './util.mjs';
-import { getGitLastModified } from './git.mjs';
+import { getGitLastModified, getGitLastModifiedBatch } from './git.mjs';
 import { toRepoPath } from './util.mjs';
 
 const NOW = new Date();
@@ -150,11 +150,12 @@ export function checkBidirectionalReferences(docs, config) {
 
 export function checkGitStaleness(docs, config) {
   const warnings = [];
+  const gitDates = getGitLastModifiedBatch(config.repoRoot);
   for (const doc of docs) {
     if (config.lifecycle.skipStaleFor.has(doc.status)) continue;
     if (!doc.updated) continue;
 
-    const gitDate = getGitLastModified(doc.path, config.repoRoot);
+    const gitDate = gitDates.get(doc.path) ?? null;
     if (!gitDate) continue;
 
     const gitDay = gitDate.slice(0, 10);