@safetnsr/md-pipe 0.1.0 → 0.2.0

package/README.md

@@ -33,6 +33,7 @@ md-pipe watch
 
 ```yaml
 watch: ./docs
+debounce: 500       # ms, for watch mode (default: 200)
 
 triggers:
   - name: publish
@@ -40,6 +41,7 @@ triggers:
       path: "posts/**"
       frontmatter:
         status: publish
+    cwd: project     # run from config dir instead of file dir
     run: "./scripts/deploy.sh $FILE"
 
   - name: reindex
@@ -73,7 +75,9 @@ triggers:
 | `--config, -c <path>` | Path to config file |
 | `--dry-run` | Show matches without executing actions |
 | `--json` | Output in JSON format |
-| `--verbose` | Show detailed output |
+| `--verbose` | Show trigger + file + first line of command |
+| `--debug` | Show full interpolated commands |
+| `--state <path>` | State file for idempotent `once` mode |
 | `--version, -v` | Show version |
 | `--help, -h` | Show help |
 
@@ -93,6 +97,13 @@ match:
     type: blog
 ```
 
+### Negation — match anything except a value
+```yaml
+match:
+  frontmatter:
+    status: "!draft"    # matches publish, review, etc — NOT draft
+```
+
 ### `frontmatter_changed` — fires when specific fields change
 ```yaml
 match:
@@ -110,8 +121,32 @@ match:
     - review
 ```
 
+### `content` — match body text (substring)
+```yaml
+match:
+  content: "TODO"       # fires on files containing "TODO" in the body
+```
+
+### `content_regex` — match body text (regex)
+```yaml
+match:
+  content_regex: "\\[ \\]"   # unchecked checkboxes
+```
+
 Matchers can be combined — all conditions must match for the trigger to fire.
 
+## Trigger Options
+
+### `cwd` — working directory for commands
+```yaml
+triggers:
+  - name: build
+    match:
+      path: "**"
+    cwd: project    # "project" = config dir, "file" = file dir (default)
+    run: bash scripts/build.sh $FILE
+```
+
 ## Environment Variables
 
 Scripts receive these env vars:
@@ -125,6 +160,52 @@ Scripts receive these env vars:
 | `$FRONTMATTER` | JSON string of all frontmatter |
 | `$DIFF` | JSON string of changed frontmatter fields |
 | `$TAGS` | Comma-separated list of tags |
+| `$FM_<field>` | Direct access to frontmatter fields |
+
+### `$FM_` variables
+
+Every frontmatter field is exposed as `$FM_<fieldname>`:
+
+```yaml
+---
+title: "Hello World"
+status: publish
+version: "2.1"
+---
+```
+
+```bash
+echo $FM_title    # → Hello World
+echo $FM_status   # → publish
+echo $FM_version  # → 2.1
+```
+
+No more `node -pe "JSON.parse(...)"` to extract a single field!
+
+## Idempotent Mode (--state)
+
+For CI/cron use, `--state` tracks which files have been processed:
+
+```bash
+# First run: processes all matching files
+md-pipe once --state .md-pipe-state.json
+
+# Second run: skips unchanged files
+md-pipe once --state .md-pipe-state.json
+```
+
+The state file tracks content hashes per trigger+file combo. Only fires when actual content changes.
+
+## Watch Mode Debouncing
+
+File saves can trigger multiple events. Configure debounce in your config:
+
+```yaml
+debounce: 500       # milliseconds (default: 200)
+# or
+debounce: "500ms"
+debounce: "2s"
+```
 
 ## Agent Interface (--json)
 
@@ -136,6 +217,7 @@ md-pipe once --json
 {
   "total": 42,
   "matched": 3,
+  "skipped": 0,
   "actions": [
     {
       "triggerName": "publish",
@@ -166,7 +248,9 @@ md-pipe watch --json
 
 **Digital garden** — auto-generate RSS feed when new posts are added
 
-**CI/CD for markdown** — `md-pipe once` in your CI pipeline to validate or transform docs
+**CI/CD for markdown** — `md-pipe once --state .state.json` in your CI pipeline for idempotent processing
+
+**TODO tracking** — find files with `content: "TODO"` or `content_regex: "\\[ \\]"` for unchecked tasks
 
 ## Pair With
 

package/dist/cli.js

@@ -11,7 +11,7 @@ const config_js_1 = require("./core/config.js");
 const watcher_js_1 = require("./core/watcher.js");
 const once_js_1 = require("./core/once.js");
 const test_file_js_1 = require("./core/test-file.js");
-const VERSION = '0.1.0';
+const VERSION = '0.2.0';
 function printHelp() {
     console.log(`
 ${chalk_1.default.bold('md-pipe')} — event-driven automation for markdown directories
@@ -27,17 +27,23 @@ ${chalk_1.default.bold('Flags:')}
   --config, -c <path>       Path to config file (default: .md-pipe.yml)
   --dry-run                 Show matches without executing actions
   --json                    Output in JSON format
-  --verbose                 Show detailed output
+  --verbose                 Show trigger + file + first line of command
+  --debug                   Show full interpolated commands
+  --state <path>            State file for idempotent once mode
   --version, -v             Show version
   --help, -h                Show this help
 
 ${chalk_1.default.bold('Config (.md-pipe.yml):')}
   watch: ./docs
+  debounce: 500       # ms, for watch mode (default: 200)
   triggers:
     - name: publish
       match:
         path: "posts/**"
         frontmatter: { status: publish }
+        content: "TODO"            # body substring
+        content_regex: "\\\\[\\\\s\\\\]"  # body regex
+      cwd: project     # "project" or "file" (default)
       run: "echo Publishing $FILE"
 
 ${chalk_1.default.bold('Env vars passed to scripts:')}
@@ -48,6 +54,7 @@ ${chalk_1.default.bold('Env vars passed to scripts:')}
   $FRONTMATTER   JSON string of all frontmatter
   $DIFF          JSON string of changed frontmatter fields
   $TAGS          Comma-separated list of tags
+  $FM_<field>    Direct access to frontmatter (e.g. $FM_title, $FM_status)
 
 ${chalk_1.default.bold('More:')} https://github.com/safetnsr/md-pipe
 `);
@@ -59,6 +66,8 @@ function parseArgs(args) {
     let dryRun = false;
     let json = false;
     let verbose = false;
+    let debug = false;
+    let state;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg === '--help' || arg === '-h') {
@@ -81,6 +90,14 @@ function parseArgs(args) {
             verbose = true;
             continue;
         }
+        if (arg === '--debug') {
+            debug = true;
+            continue;
+        }
+        if (arg === '--state') {
+            state = args[++i];
+            continue;
+        }
         if (arg === '--config' || arg === '-c') {
             config = args[++i];
             continue;
@@ -94,7 +111,7 @@ function parseArgs(args) {
             continue;
         }
     }
-    return { command: command || 'help', file, config, dryRun, json, verbose };
+    return { command: command || 'help', file, config, dryRun, json, verbose, debug, state };
 }
 function getConfig(configPath) {
     const cwd = process.cwd();
@@ -105,6 +122,14 @@ function getConfig(configPath) {
     }
     return (0, config_js_1.loadConfig)(cfgPath);
 }
+/** Format command for display: verbose shows first line, debug shows full */
+function formatCommand(command, debug) {
+    if (debug)
+        return command;
+    const firstLine = command.split('\n')[0].trim();
+    const truncated = firstLine.length > 80 ? firstLine.slice(0, 77) + '...' : firstLine;
+    return command.includes('\n') ? truncated + ' …' : truncated;
+}
 async function cmdInit() {
     const target = (0, path_1.resolve)(process.cwd(), '.md-pipe.yml');
     if ((0, fs_1.existsSync)(target)) {
@@ -125,13 +150,15 @@ async function cmdWatch(opts) {
     watcher.on('ready', () => {
         console.log(chalk_1.default.green('✓') + ` Watching ${config.watch}`);
         console.log(chalk_1.default.dim(`  ${config.triggers.length} trigger(s) loaded`));
+        if (config.debounce)
+            console.log(chalk_1.default.dim(`  debounce: ${config.debounce}ms`));
         if (opts.dryRun)
             console.log(chalk_1.default.yellow('  [dry-run mode — actions will not execute]'));
         console.log(chalk_1.default.dim('  Press Ctrl+C to stop\n'));
     });
     watcher.on('match', (result) => {
         if (opts.json)
-            return; // json mode outputs on action
+            return;
         const ts = new Date().toLocaleTimeString();
         console.log(chalk_1.default.dim(`[${ts}]`) + ' ' +
             chalk_1.default.cyan(`▸ ${result.trigger.name}`) + ' ' +
@@ -146,8 +173,9 @@ async function cmdWatch(opts) {
         const status = result.exitCode === 0
             ? chalk_1.default.green('✓')
             : chalk_1.default.red(`✗ exit ${result.exitCode}`);
-        console.log(`  ${status} ${chalk_1.default.dim(result.command)}`);
-        if (result.stdout && opts.verbose) {
+        const cmdDisplay = formatCommand(result.command, opts.debug);
+        console.log(`  ${status} ${chalk_1.default.dim(cmdDisplay)}`);
+        if (result.stdout && (opts.verbose || opts.debug)) {
             console.log(chalk_1.default.dim('    ' + result.stdout.replace(/\n/g, '\n    ')));
         }
         if (result.stderr) {
@@ -171,13 +199,16 @@ function cmdOnce(opts) {
         console.error(chalk_1.default.red(`Watch directory not found: ${config.watch}`));
         process.exit(1);
     }
-    const result = (0, once_js_1.runOnce)(config, opts.dryRun);
+    const result = (0, once_js_1.runOnce)(config, opts.dryRun, opts.state);
     if (opts.json) {
         console.log(JSON.stringify(result, null, 2));
         return;
     }
     console.log(chalk_1.default.bold('md-pipe once'));
-    console.log(chalk_1.default.dim(`  Scanned ${result.total} files, ${result.matched} trigger match(es)\n`));
+    let summary = `  Scanned ${result.total} files, ${result.matched} trigger match(es)`;
+    if (result.skipped > 0)
+        summary += `, ${result.skipped} skipped (unchanged)`;
+    console.log(chalk_1.default.dim(summary + '\n'));
     if (opts.dryRun) {
         console.log(chalk_1.default.yellow('  [dry-run mode — actions were not executed]\n'));
     }
@@ -185,8 +216,9 @@ function cmdOnce(opts) {
         const status = action.exitCode === 0
             ? chalk_1.default.green('✓')
             : chalk_1.default.red(`✗ exit ${action.exitCode}`);
-        console.log(`${status} ${chalk_1.default.cyan(action.triggerName)} → ${chalk_1.default.dim(action.command)}`);
-        if (action.stdout && opts.verbose) {
+        const cmdDisplay = formatCommand(action.command, opts.debug);
+        console.log(`${status} ${chalk_1.default.cyan(action.triggerName)} → ${chalk_1.default.dim(cmdDisplay)}`);
+        if (action.stdout && (opts.verbose || opts.debug)) {
             console.log(chalk_1.default.dim('  ' + action.stdout));
         }
         if (action.stderr) {

package/dist/core/config.d.ts

@@ -3,15 +3,20 @@ export interface TriggerMatch {
     frontmatter?: Record<string, unknown>;
     frontmatter_changed?: string[];
     tags?: string[];
+    content?: string;
+    content_regex?: string;
 }
 export interface TriggerDef {
     name: string;
     match: TriggerMatch;
     run: string;
+    cwd?: 'project' | 'file';
 }
 export interface MdPipeConfig {
     watch: string;
+    configDir: string;
     triggers: TriggerDef[];
+    debounce?: number;
 }
 export declare function findConfigFile(dir: string): string | null;
 export declare function loadConfig(configPath: string): MdPipeConfig;

package/dist/core/config.js

@@ -30,6 +30,7 @@ function loadConfig(configPath) {
     if (!Array.isArray(parsed.triggers) || parsed.triggers.length === 0) {
         throw new Error(`Config error: 'triggers' must be a non-empty array`);
     }
+    const configDir = (0, path_1.dirname)(configPath);
     const triggers = [];
     for (let i = 0; i < parsed.triggers.length; i++) {
         const t = parsed.triggers[i];
@@ -59,12 +60,35 @@ function loadConfig(configPath) {
             }
             match.tags = t.match.tags.map(String);
         }
-        triggers.push({ name: t.name, match, run: t.run });
+        if (t.match.content !== undefined)
+            match.content = String(t.match.content);
+        if (t.match.content_regex !== undefined)
+            match.content_regex = String(t.match.content_regex);
+        // cwd option
+        const cwd = t.cwd === 'project' ? 'project' : (t.cwd === 'file' ? 'file' : undefined);
+        triggers.push({ name: t.name, match, run: t.run, ...(cwd ? { cwd } : {}) });
     }
     // Resolve watch path relative to config file directory
-    const configDir = (0, path_1.dirname)(configPath);
     const watchPath = (0, path_1.resolve)(configDir, parsed.watch);
-    return { watch: watchPath, triggers };
+    // Debounce
+    let debounce;
+    if (parsed.debounce !== undefined) {
+        if (typeof parsed.debounce === 'string') {
+            // Parse "500ms" or "1s"
+            const ms = parsed.debounce.match(/^(\d+)\s*ms$/i);
+            const s = parsed.debounce.match(/^(\d+)\s*s$/i);
+            if (ms)
+                debounce = parseInt(ms[1], 10);
+            else if (s)
+                debounce = parseInt(s[1], 10) * 1000;
+            else
+                debounce = parseInt(parsed.debounce, 10) || undefined;
+        }
+        else if (typeof parsed.debounce === 'number') {
+            debounce = parsed.debounce;
+        }
+    }
+    return { watch: watchPath, configDir, triggers, ...(debounce ? { debounce } : {}) };
 }
 function generateDefaultConfig() {
     return `# md-pipe configuration

package/dist/core/matcher.d.ts

@@ -3,6 +3,7 @@ export interface FileState {
     filePath: string;
     relativePath: string;
     content: string;
+    body: string;
     frontmatter: Record<string, unknown>;
     tags: string[];
 }
@@ -19,6 +20,8 @@ export declare function parseMarkdownContent(content: string, filePath: string,
 export declare function matchPath(relativePath: string, pattern: string): boolean;
 export declare function matchFrontmatter(frontmatter: Record<string, unknown>, expected: Record<string, unknown>): boolean;
 export declare function matchTags(fileTags: string[], requiredTags: string[]): boolean;
+export declare function matchContent(body: string, substring: string): boolean;
+export declare function matchContentRegex(body: string, pattern: string): boolean;
 export declare function computeFrontmatterDiff(oldFm: Record<string, unknown>, newFm: Record<string, unknown>, watchFields: string[]): Record<string, {
     old: unknown;
     new: unknown;

package/dist/core/matcher.js

@@ -8,6 +8,8 @@ exports.parseMarkdownContent = parseMarkdownContent;
 exports.matchPath = matchPath;
 exports.matchFrontmatter = matchFrontmatter;
 exports.matchTags = matchTags;
+exports.matchContent = matchContent;
+exports.matchContentRegex = matchContentRegex;
 exports.computeFrontmatterDiff = computeFrontmatterDiff;
 exports.evaluateTrigger = evaluateTrigger;
 const micromatch_1 = __importDefault(require("micromatch"));
@@ -20,9 +22,11 @@ function parseMarkdownFile(filePath, relativePath) {
 function parseMarkdownContent(content, filePath, relativePath) {
     let frontmatter = {};
     let tags = [];
+    let body = content;
     try {
         const parsed = (0, gray_matter_1.default)(content);
         frontmatter = parsed.data || {};
+        body = parsed.content || '';
         // Extract tags from frontmatter
         if (Array.isArray(frontmatter.tags)) {
             tags = frontmatter.tags.map(String);
@@ -31,7 +35,7 @@ function parseMarkdownContent(content, filePath, relativePath) {
     catch {
         // File has no valid frontmatter — that's fine
     }
-    return { filePath, relativePath, content, frontmatter, tags };
+    return { filePath, relativePath, content, body, frontmatter, tags };
 }
 function matchPath(relativePath, pattern) {
     return micromatch_1.default.isMatch(relativePath, pattern);
@@ -39,6 +43,15 @@ function matchPath(relativePath, pattern) {
 function matchFrontmatter(frontmatter, expected) {
     for (const [key, val] of Object.entries(expected)) {
         const actual = frontmatter[key];
+        // Negation: "!value" means match anything EXCEPT that value
+        if (typeof val === 'string' && val.startsWith('!')) {
+            const negated = val.slice(1);
+            if (actual === undefined)
+                continue; // undefined != negated, so it passes
+            if (String(actual) === negated)
+                return false;
+            continue;
+        }
         if (typeof val === 'object' && val !== null && !Array.isArray(val)) {
             if (typeof actual !== 'object' || actual === null || Array.isArray(actual))
                 return false;
@@ -69,6 +82,18 @@ function matchTags(fileTags, requiredTags) {
         return normalized.includes(norm);
     });
 }
+function matchContent(body, substring) {
+    return body.includes(substring);
+}
+function matchContentRegex(body, pattern) {
+    try {
+        const re = new RegExp(pattern);
+        return re.test(body);
+    }
+    catch {
+        return false;
+    }
+}
 function computeFrontmatterDiff(oldFm, newFm, watchFields) {
     const diff = {};
     for (const field of watchFields) {
@@ -98,6 +123,16 @@ function evaluateTrigger(trigger, file, previousFrontmatter) {
         if (!matchTags(file.tags, match.tags))
             return null;
     }
+    // Check content substring
+    if (match.content) {
+        if (!matchContent(file.body, match.content))
+            return null;
+    }
+    // Check content regex
+    if (match.content_regex) {
+        if (!matchContentRegex(file.body, match.content_regex))
+            return null;
+    }
     // Check frontmatter_changed (requires previous state)
     if (match.frontmatter_changed) {
         if (!previousFrontmatter) {

package/dist/core/once.d.ts

@@ -3,7 +3,8 @@ import { RunResult } from './runner.js';
 export interface OnceResult {
     total: number;
     matched: number;
+    skipped: number;
     actions: RunResult[];
     errors: string[];
 }
-export declare function runOnce(config: MdPipeConfig, dryRun?: boolean): OnceResult;
+export declare function runOnce(config: MdPipeConfig, dryRun?: boolean, statePath?: string): OnceResult;

package/dist/core/once.js

@@ -5,6 +5,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const matcher_js_1 = require("./matcher.js");
 const runner_js_1 = require("./runner.js");
+const state_js_1 = require("./state.js");
 function findMarkdownFiles(dir) {
     const results = [];
     function walk(current) {
@@ -22,11 +23,17 @@ function findMarkdownFiles(dir) {
     walk(dir);
     return results;
 }
-function runOnce(config, dryRun = false) {
+function runOnce(config, dryRun = false, statePath) {
     const files = findMarkdownFiles(config.watch);
     const actions = [];
     const errors = [];
     let matched = 0;
+    let skipped = 0;
+    // Load state if state path provided
+    let state = null;
+    if (statePath) {
+        state = (0, state_js_1.loadState)(statePath);
+    }
     for (const filePath of files) {
         const relativePath = (0, path_1.relative)(config.watch, filePath);
         let file;
@@ -43,11 +50,24 @@ function runOnce(config, dryRun = false) {
                 continue;
             const match = (0, matcher_js_1.evaluateTrigger)(trigger, file);
             if (match) {
+                // If state tracking, check if file has changed
+                if (state && !(0, state_js_1.hasChanged)(state, trigger.name, relativePath, file.content)) {
+                    skipped++;
+                    continue;
+                }
                 matched++;
-                const result = (0, runner_js_1.executeAction)(match, dryRun);
+                const result = (0, runner_js_1.executeAction)(match, dryRun, config.configDir);
                 actions.push(result);
+                // Mark as processed in state
+                if (state && !dryRun) {
+                    (0, state_js_1.markProcessed)(state, trigger.name, relativePath, file.content);
+                }
             }
         }
     }
-    return { total: files.length, matched, actions, errors };
+    // Save state if tracking
+    if (state && statePath && !dryRun) {
+        (0, state_js_1.saveState)(statePath, state);
+    }
+    return { total: files.length, matched, skipped, actions, errors };
 }

package/dist/core/runner.d.ts

@@ -8,4 +8,4 @@ export interface RunResult {
     stderr: string;
     durationMs: number;
 }
-export declare function executeAction(match: MatchResult, dryRun?: boolean): RunResult;
+export declare function executeAction(match: MatchResult, dryRun?: boolean, configDir?: string): RunResult;

package/dist/core/runner.js

@@ -18,7 +18,22 @@ function interpolateCommand(template, match) {
         .replace(/\$DIFF/g, diffJson)
         .replace(/\$TAGS/g, tags);
 }
-function executeAction(match, dryRun = false) {
+function buildFmEnvVars(frontmatter) {
+    const env = {};
+    for (const [key, val] of Object.entries(frontmatter)) {
+        const envKey = `FM_${key}`;
+        if (val === null || val === undefined)
+            continue;
+        if (typeof val === 'object') {
+            env[envKey] = JSON.stringify(val);
+        }
+        else {
+            env[envKey] = String(val);
+        }
+    }
+    return env;
+}
+function executeAction(match, dryRun = false, configDir) {
     const command = interpolateCommand(match.trigger.run, match);
     const triggerName = match.trigger.name;
     const filePath = match.file.filePath;
@@ -33,10 +48,19 @@ function executeAction(match, dryRun = false) {
             durationMs: 0,
         };
     }
+    // Determine cwd: "project" = configDir, "file" = file's directory (default)
+    let cwd;
+    if (match.trigger.cwd === 'project' && configDir) {
+        cwd = configDir;
+    }
+    else {
+        cwd = (0, path_1.dirname)(match.file.filePath);
+    }
+    const fmEnv = buildFmEnvVars(match.file.frontmatter);
     const start = Date.now();
     try {
         const stdout = (0, child_process_1.execSync)(command, {
-            cwd: (0, path_1.dirname)(match.file.filePath),
+            cwd,
             timeout: 30000,
             encoding: 'utf-8',
             env: {
@@ -48,6 +72,7 @@ function executeAction(match, dryRun = false) {
                 FRONTMATTER: JSON.stringify(match.file.frontmatter),
                 DIFF: match.diff ? JSON.stringify(match.diff) : '{}',
                 TAGS: match.file.tags.join(','),
+                ...fmEnv,
             },
         });
         return {

package/dist/core/state.d.ts

@@ -0,0 +1,17 @@
+export interface StateEntry {
+    hash: string;
+    processedAt: string;
+}
+export interface StateFile {
+    version: 1;
+    entries: Record<string, StateEntry>;
+}
+export declare function loadState(statePath: string): StateFile;
+export declare function saveState(statePath: string, state: StateFile): void;
+export declare function computeFileHash(content: string): string;
+/**
+ * Returns true if the file+trigger combo has changed since last run.
+ * Key format: "triggerName::relativePath"
+ */
+export declare function hasChanged(state: StateFile, triggerName: string, relativePath: string, content: string): boolean;
+export declare function markProcessed(state: StateFile, triggerName: string, relativePath: string, content: string): void;

package/dist/core/state.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.computeFileHash = computeFileHash;
+exports.hasChanged = hasChanged;
+exports.markProcessed = markProcessed;
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+function loadState(statePath) {
+    if (!(0, fs_1.existsSync)(statePath)) {
+        return { version: 1, entries: {} };
+    }
+    try {
+        const raw = (0, fs_1.readFileSync)(statePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version === 1 && parsed.entries)
+            return parsed;
+        return { version: 1, entries: {} };
+    }
+    catch {
+        return { version: 1, entries: {} };
+    }
+}
+function saveState(statePath, state) {
+    (0, fs_1.writeFileSync)(statePath, JSON.stringify(state, null, 2), 'utf-8');
+}
+function computeFileHash(content) {
+    return (0, crypto_1.createHash)('sha256').update(content).digest('hex').slice(0, 16);
+}
+/**
+ * Returns true if the file+trigger combo has changed since last run.
+ * Key format: "triggerName::relativePath"
+ */
+function hasChanged(state, triggerName, relativePath, content) {
+    const key = `${triggerName}::${relativePath}`;
+    const hash = computeFileHash(content);
+    const existing = state.entries[key];
+    return !existing || existing.hash !== hash;
+}
+function markProcessed(state, triggerName, relativePath, content) {
+    const key = `${triggerName}::${relativePath}`;
+    state.entries[key] = {
+        hash: computeFileHash(content),
+        processedAt: new Date().toISOString(),
+    };
+}

package/dist/core/test-file.js

@@ -13,8 +13,17 @@ function testFile(config, filePath) {
     const file = (0, matcher_js_1.parseMarkdownFile)(absPath, relativePath);
     const matches = [];
     for (const trigger of config.triggers) {
-        // Skip frontmatter_changed in test mode (no previous state)
+        // For frontmatter_changed triggers, still check other conditions first
         if (trigger.match.frontmatter_changed) {
+            const staticMatch = { ...trigger.match };
+            delete staticMatch.frontmatter_changed;
+            const hasStaticConditions = staticMatch.path || staticMatch.frontmatter || staticMatch.tags || staticMatch.content || staticMatch.content_regex;
+            if (hasStaticConditions) {
+                const staticTrigger = { ...trigger, match: staticMatch };
+                const staticResult = (0, matcher_js_1.evaluateTrigger)(staticTrigger, file);
+                if (!staticResult)
+                    continue;
+            }
             matches.push({
                 triggerName: trigger.name,
                 reason: `frontmatter_changed: would fire on changes to [${trigger.match.frontmatter_changed.join(', ')}] (no previous state to diff in test mode)`,
@@ -30,6 +39,10 @@ function testFile(config, filePath) {
                 reasons.push(`frontmatter matches ${JSON.stringify(trigger.match.frontmatter)}`);
             if (trigger.match.tags)
                 reasons.push(`has tags [${trigger.match.tags.join(', ')}]`);
+            if (trigger.match.content)
+                reasons.push(`body contains "${trigger.match.content}"`);
+            if (trigger.match.content_regex)
+                reasons.push(`body matches /${trigger.match.content_regex}/`);
             matches.push({
                 triggerName: trigger.name,
                 reason: reasons.join(' + ') || 'all conditions matched',

package/dist/core/watcher.d.ts

@@ -13,6 +13,8 @@ export declare class MdPipeWatcher extends EventEmitter {
     private fsWatcher;
     private frontmatterCache;
     private dryRun;
+    private debounceMs;
+    private debounceTimers;
     constructor(config: MdPipeConfig, dryRun?: boolean);
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/core/watcher.js

@@ -11,28 +11,48 @@ class MdPipeWatcher extends events_1.EventEmitter {
     fsWatcher = null;
     frontmatterCache = new Map();
     dryRun;
+    debounceMs;
+    debounceTimers = new Map();
     constructor(config, dryRun = false) {
         super();
         this.config = config;
         this.dryRun = dryRun;
+        this.debounceMs = config.debounce ?? 200;
     }
     async start() {
         const watchDir = this.config.watch;
-        this.fsWatcher = (0, chokidar_1.watch)('**/*.md', {
-            cwd: watchDir,
+        this.fsWatcher = (0, chokidar_1.watch)(watchDir, {
             ignoreInitial: true,
             persistent: true,
             awaitWriteFinish: {
-                stabilityThreshold: 200,
+                stabilityThreshold: this.debounceMs,
                 pollInterval: 50,
             },
         });
-        this.fsWatcher.on('add', (relPath) => this.handleFile(relPath, 'add'));
-        this.fsWatcher.on('change', (relPath) => this.handleFile(relPath, 'change'));
+        const handleEvent = (absPath, event) => {
+            if (!absPath.endsWith('.md'))
+                return;
+            const relPath = (0, path_1.relative)(watchDir, absPath);
+            // Debounce: cancel any pending timer for this file
+            const existing = this.debounceTimers.get(relPath);
+            if (existing)
+                clearTimeout(existing);
+            this.debounceTimers.set(relPath, setTimeout(() => {
+                this.debounceTimers.delete(relPath);
+                this.handleFile(relPath, event);
+            }, this.debounceMs));
+        };
+        this.fsWatcher.on('add', (p) => handleEvent(p, 'add'));
+        this.fsWatcher.on('change', (p) => handleEvent(p, 'change'));
         this.fsWatcher.on('ready', () => this.emit('ready'));
         this.fsWatcher.on('error', (err) => this.emit('error', err instanceof Error ? err : new Error(String(err))));
     }
     async stop() {
+        // Clear pending debounce timers
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
         if (this.fsWatcher) {
             await this.fsWatcher.close();
             this.fsWatcher = null;
@@ -54,7 +74,7 @@ class MdPipeWatcher extends events_1.EventEmitter {
             const match = (0, matcher_js_1.evaluateTrigger)(trigger, file, previousFm);
             if (match) {
                 this.emit('match', match);
-                const result = (0, runner_js_1.executeAction)(match, this.dryRun);
+                const result = (0, runner_js_1.executeAction)(match, this.dryRun, this.config.configDir);
                 this.emit('action', result);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safetnsr/md-pipe",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Event-driven automation for markdown directories. entr watches files. md-pipe understands them.",
   "main": "./dist/cli.js",
   "bin": {