@safetnsr/md-pipe 0.2.0 → 0.3.0

package/dist/core/steps/update-frontmatter.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeUpdateFrontmatterStep = executeUpdateFrontmatterStep;
+const fs_1 = require("fs");
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const template_vars_js_1 = require("../template-vars.js");
+function executeUpdateFrontmatterStep(config, ctx, dryRun) {
+    const updates = (0, template_vars_js_1.expandDeep)(config['update-frontmatter'], ctx);
+    const start = Date.now();
+    try {
+        const raw = (0, fs_1.readFileSync)(ctx.file, 'utf-8');
+        const parsed = (0, gray_matter_1.default)(raw);
+        const fm = parsed.data || {};
+        // Apply updates
+        for (const [key, value] of Object.entries(updates)) {
+            fm[key] = coerceValue(value);
+        }
+        // Rebuild file: use gray-matter stringify
+        const output = gray_matter_1.default.stringify(parsed.content, fm);
+        if (!dryRun) {
+            (0, fs_1.writeFileSync)(ctx.file, output, 'utf-8');
+        }
+        // Update the context's frontmatter so subsequent steps see changes
+        Object.assign(ctx.frontmatter, fm);
+        const updatedFields = Object.keys(updates).join(', ');
+        return {
+            type: 'update-frontmatter',
+            success: true,
+            stdout: `Updated frontmatter: ${updatedFields}${dryRun ? ' [dry run]' : ''}`,
+            stderr: '',
+            exitCode: 0,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            type: 'update-frontmatter',
+            success: false,
+            stdout: '',
+            stderr: err.message || String(err),
+            exitCode: 1,
+            durationMs: Date.now() - start,
+        };
+    }
+}
+/**
+ * Coerce string values to appropriate types.
+ * "true"/"false" → boolean, numeric strings → numbers.
+ */
+function coerceValue(value) {
+    if (typeof value !== 'string')
+        return value;
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    // Don't coerce ISO dates or other strings that look numeric-ish
+    if (/^\d+$/.test(value) && value.length < 16)
+        return parseInt(value, 10);
+    if (/^\d+\.\d+$/.test(value) && value.length < 16)
+        return parseFloat(value);
+    return value;
+}

package/dist/core/steps/webhook.d.ts

@@ -0,0 +1,11 @@
+import { TemplateContext } from '../template-vars.js';
+import type { StepResult } from './run.js';
+export interface WebhookStepConfig {
+    webhook: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+}
+export declare function executeWebhookStep(config: WebhookStepConfig, ctx: TemplateContext, dryRun: boolean): Promise<StepResult>;

package/dist/core/steps/webhook.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWebhookStep = executeWebhookStep;
+const template_vars_js_1 = require("../template-vars.js");
+async function executeWebhookStep(config, ctx, dryRun) {
+    const start = Date.now();
+    const wh = config.webhook;
+    // Expand env vars in URL (e.g. $WEBHOOK_URL)
+    let url = (0, template_vars_js_1.expandTemplate)(wh.url, ctx);
+    url = expandEnvVars(url);
+    const method = (wh.method || 'POST').toUpperCase();
+    const headers = {
+        'Content-Type': 'application/json',
+        ...(wh.headers ? (0, template_vars_js_1.expandDeep)(wh.headers, ctx) : {}),
+    };
+    // Expand body
+    let body;
+    if (wh.body) {
+        const expanded = (0, template_vars_js_1.expandDeep)(wh.body, ctx);
+        // Also expand $ENV_VAR style in string values
+        body = JSON.stringify(expanded, (_key, val) => {
+            if (typeof val === 'string')
+                return expandEnvVars(val);
+            return val;
+        });
+    }
+    else {
+        // Default body: file info + frontmatter
+        body = JSON.stringify({
+            file: ctx.file,
+            relative: ctx.relative,
+            slug: ctx.slug,
+            frontmatter: ctx.frontmatter,
+        });
+    }
+    if (dryRun) {
+        return {
+            type: 'webhook',
+            success: true,
+            stdout: `[dry run] ${method} ${url}`,
+            stderr: '',
+            exitCode: 0,
+            durationMs: Date.now() - start,
+        };
+    }
+    try {
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: method !== 'GET' ? body : undefined,
+        });
+        const responseText = await response.text();
+        const success = response.ok;
+        return {
+            type: 'webhook',
+            success,
+            stdout: responseText.slice(0, 4096),
+            stderr: success ? '' : `HTTP ${response.status} ${response.statusText}`,
+            exitCode: success ? 0 : 1,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            type: 'webhook',
+            success: false,
+            stdout: '',
+            stderr: err.message || String(err),
+            exitCode: 1,
+            durationMs: Date.now() - start,
+        };
+    }
+}
+/**
+ * Expand $ENV_VAR and ${ENV_VAR} style variables from process.env
+ */
+function expandEnvVars(str) {
+    return str.replace(/\$\{?([A-Z_][A-Z0-9_]*)\}?/g, (_match, name) => {
+        return process.env[name] || '';
+    });
+}

package/dist/core/template-vars.d.ts

@@ -0,0 +1,43 @@
+export interface TemplateContext {
+    file: string;
+    dir: string;
+    basename: string;
+    relative: string;
+    slug: string;
+    frontmatter: Record<string, unknown>;
+    tags: string[];
+    content: string;
+    body: string;
+    diff: Record<string, {
+        old: unknown;
+        new: unknown;
+    }> | null;
+    steps: StepOutput[];
+}
+export interface StepOutput {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    [key: string]: unknown;
+}
+/**
+ * Expand template variables in a string.
+ * Supports: {{now}}, {{date}}, {{slug}}, {{file}}, {{basename}}, {{relative}},
+ *           {{dir}}, {{tags}}, {{fm.<field>}}, {{step.<index>.<field>}}
+ */
+export declare function expandTemplate(template: string, ctx: TemplateContext): string;
+/**
+ * Deep-expand all string values in an object/array/primitive.
+ */
+export declare function expandDeep(value: unknown, ctx: TemplateContext): unknown;
+/**
+ * Build a TemplateContext from file state and match info.
+ */
+export declare function buildContext(filePath: string, relativePath: string, dir: string, frontmatter: Record<string, unknown>, tags: string[], content: string, body: string, diff: Record<string, {
+    old: unknown;
+    new: unknown;
+}> | null): TemplateContext;
+/**
+ * Build env vars for shell commands (backward compatible + new).
+ */
+export declare function buildEnvVars(ctx: TemplateContext): Record<string, string>;

package/dist/core/template-vars.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandTemplate = expandTemplate;
+exports.expandDeep = expandDeep;
+exports.buildContext = buildContext;
+exports.buildEnvVars = buildEnvVars;
+const path_1 = require("path");
+/**
+ * Expand template variables in a string.
+ * Supports: {{now}}, {{date}}, {{slug}}, {{file}}, {{basename}}, {{relative}},
+ *           {{dir}}, {{tags}}, {{fm.<field>}}, {{step.<index>.<field>}}
+ */
+function expandTemplate(template, ctx) {
+    return template.replace(/\{\{([^}]+)\}\}/g, (_match, key) => {
+        const k = key.trim();
+        // Built-in variables
+        switch (k) {
+            case 'now':
+                return new Date().toISOString();
+            case 'date':
+                return new Date().toISOString().split('T')[0];
+            case 'timestamp':
+                return String(Date.now());
+            case 'slug':
+                return ctx.slug;
+            case 'file':
+                return ctx.file;
+            case 'basename':
+                return ctx.basename;
+            case 'relative':
+                return ctx.relative;
+            case 'dir':
+                return ctx.dir;
+            case 'tags':
+                return ctx.tags.join(',');
+            case 'content':
+                return ctx.body;
+        }
+        // Frontmatter access: {{fm.title}}, {{fm.status}}
+        if (k.startsWith('fm.')) {
+            const field = k.slice(3);
+            const val = ctx.frontmatter[field];
+            if (val === undefined || val === null)
+                return '';
+            if (typeof val === 'object')
+                return JSON.stringify(val);
+            return String(val);
+        }
+        // Step output access: {{step.0.stdout}}, {{step.1.exitCode}}
+        if (k.startsWith('step.')) {
+            const parts = k.slice(5).split('.');
+            const idx = parseInt(parts[0], 10);
+            const field = parts.slice(1).join('.');
+            if (isNaN(idx) || idx < 0 || idx >= ctx.steps.length)
+                return '';
+            const step = ctx.steps[idx];
+            if (!step)
+                return '';
+            const val = step[field];
+            if (val === undefined || val === null)
+                return '';
+            if (typeof val === 'object')
+                return JSON.stringify(val);
+            return String(val);
+        }
+        // Unknown variable — leave as-is
+        return `{{${k}}}`;
+    });
+}
+/**
+ * Deep-expand all string values in an object/array/primitive.
+ */
+function expandDeep(value, ctx) {
+    if (typeof value === 'string') {
+        return expandTemplate(value, ctx);
+    }
+    if (Array.isArray(value)) {
+        return value.map(v => expandDeep(v, ctx));
+    }
+    if (value !== null && typeof value === 'object') {
+        const result = {};
+        for (const [k, v] of Object.entries(value)) {
+            result[k] = expandDeep(v, ctx);
+        }
+        return result;
+    }
+    return value;
+}
+/**
+ * Build a TemplateContext from file state and match info.
+ */
+function buildContext(filePath, relativePath, dir, frontmatter, tags, content, body, diff) {
+    const ext = (0, path_1.extname)(relativePath);
+    const slug = (0, path_1.basename)(relativePath, ext);
+    return {
+        file: filePath,
+        dir,
+        basename: (0, path_1.basename)(filePath),
+        relative: relativePath,
+        slug,
+        frontmatter,
+        tags,
+        content,
+        body,
+        diff,
+        steps: [],
+    };
+}
+/**
+ * Build env vars for shell commands (backward compatible + new).
+ */
+function buildEnvVars(ctx) {
+    const env = {
+        FILE: ctx.file,
+        DIR: ctx.dir,
+        BASENAME: ctx.basename,
+        RELATIVE: ctx.relative,
+        SLUG: ctx.slug,
+        FRONTMATTER: JSON.stringify(ctx.frontmatter),
+        DIFF: ctx.diff ? JSON.stringify(ctx.diff) : '{}',
+        TAGS: ctx.tags.join(','),
+    };
+    // FM_ env vars
+    for (const [key, val] of Object.entries(ctx.frontmatter)) {
+        if (val === null || val === undefined)
+            continue;
+        env[`FM_${key}`] = typeof val === 'object' ? JSON.stringify(val) : String(val);
+    }
+    // Step outputs
+    for (let i = 0; i < ctx.steps.length; i++) {
+        const step = ctx.steps[i];
+        if (step.stdout)
+            env[`STEP_${i}_STDOUT`] = step.stdout;
+        if (step.stderr)
+            env[`STEP_${i}_STDERR`] = step.stderr;
+    }
+    // Last step output shortcut
+    if (ctx.steps.length > 0) {
+        const last = ctx.steps[ctx.steps.length - 1];
+        env.STEP_OUTPUT = last.stdout || '';
+    }
+    return env;
+}

package/dist/core/test-file.d.ts

@@ -6,6 +6,7 @@ export interface TestResult {
     tags: string[];
     matches: Array<{
         triggerName: string;
+        type: 'trigger' | 'pipeline';
         reason: string;
     }>;
 }

package/dist/core/test-file.js

@@ -12,8 +12,8 @@ function testFile(config, filePath) {
     const relativePath = (0, path_1.relative)(config.watch, absPath);
     const file = (0, matcher_js_1.parseMarkdownFile)(absPath, relativePath);
     const matches = [];
+    // Check legacy triggers
     for (const trigger of config.triggers) {
-        // For frontmatter_changed triggers, still check other conditions first
         if (trigger.match.frontmatter_changed) {
             const staticMatch = { ...trigger.match };
             delete staticMatch.frontmatter_changed;
@@ -26,34 +26,62 @@ function testFile(config, filePath) {
             }
             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)`,
+                type: 'trigger',
+                reason: `frontmatter_changed: would fire on changes to [${trigger.match.frontmatter_changed.join(', ')}]`,
             });
             continue;
         }
         const result = (0, matcher_js_1.evaluateTrigger)(trigger, file);
         if (result) {
-            const reasons = [];
-            if (trigger.match.path)
-                reasons.push(`path matches "${trigger.match.path}"`);
-            if (trigger.match.frontmatter)
-                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',
+                type: 'trigger',
+                reason: buildMatchReason(trigger.match),
             });
         }
     }
-    return {
-        filePath: absPath,
-        relativePath,
-        frontmatter: file.frontmatter,
-        tags: file.tags,
-        matches,
-    };
+    // Check pipelines
+    for (const pipeline of config.pipelines) {
+        const triggerDef = { name: pipeline.name, match: pipeline.trigger, run: '' };
+        if (pipeline.trigger.frontmatter_changed) {
+            const staticMatch = { ...pipeline.trigger };
+            delete staticMatch.frontmatter_changed;
+            const hasStaticConditions = staticMatch.path || staticMatch.frontmatter || staticMatch.tags || staticMatch.content || staticMatch.content_regex;
+            if (hasStaticConditions) {
+                const staticTrigger = { ...triggerDef, match: staticMatch };
+                const staticResult = (0, matcher_js_1.evaluateTrigger)(staticTrigger, file);
+                if (!staticResult)
+                    continue;
+            }
+            matches.push({
+                triggerName: pipeline.name,
+                type: 'pipeline',
+                reason: `frontmatter_changed: would fire on changes to [${pipeline.trigger.frontmatter_changed.join(', ')}] (${pipeline.steps.length} steps)`,
+            });
+            continue;
+        }
+        const result = (0, matcher_js_1.evaluateTrigger)(triggerDef, file);
+        if (result) {
+            matches.push({
+                triggerName: pipeline.name,
+                type: 'pipeline',
+                reason: `${buildMatchReason(pipeline.trigger)} (${pipeline.steps.length} steps)`,
+            });
+        }
+    }
+    return { filePath: absPath, relativePath, frontmatter: file.frontmatter, tags: file.tags, matches };
+}
+function buildMatchReason(match) {
+    const reasons = [];
+    if (match.path)
+        reasons.push(`path matches "${match.path}"`);
+    if (match.frontmatter)
+        reasons.push(`frontmatter matches ${JSON.stringify(match.frontmatter)}`);
+    if (match.tags)
+        reasons.push(`has tags [${match.tags.join(', ')}]`);
+    if (match.content)
+        reasons.push(`body contains "${match.content}"`);
+    if (match.content_regex)
+        reasons.push(`body matches /${match.content_regex}/`);
+    return reasons.join(' + ') || 'all conditions matched';
 }

package/dist/core/watcher.d.ts

@@ -2,9 +2,11 @@ import { EventEmitter } from 'events';
 import { MdPipeConfig } from './config.js';
 import { MatchResult } from './matcher.js';
 import { RunResult } from './runner.js';
+import { PipelineResult } from './pipeline.js';
 export interface WatcherEvents {
     match: (result: MatchResult) => void;
     action: (result: RunResult) => void;
+    pipeline: (result: PipelineResult) => void;
     error: (error: Error, filePath?: string) => void;
     ready: () => void;
 }

package/dist/core/watcher.js

@@ -6,6 +6,7 @@ const path_1 = require("path");
 const events_1 = require("events");
 const matcher_js_1 = require("./matcher.js");
 const runner_js_1 = require("./runner.js");
+const pipeline_js_1 = require("./pipeline.js");
 class MdPipeWatcher extends events_1.EventEmitter {
     config;
     fsWatcher = null;
@@ -33,7 +34,6 @@ class MdPipeWatcher extends events_1.EventEmitter {
             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);
@@ -48,7 +48,6 @@ class MdPipeWatcher extends events_1.EventEmitter {
         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);
         }
@@ -69,7 +68,7 @@ class MdPipeWatcher extends events_1.EventEmitter {
             return;
         }
         const previousFm = this.frontmatterCache.get(relativePath);
-        // Run through triggers
+        // Run legacy triggers
         for (const trigger of this.config.triggers) {
             const match = (0, matcher_js_1.evaluateTrigger)(trigger, file, previousFm);
             if (match) {
@@ -78,6 +77,23 @@ class MdPipeWatcher extends events_1.EventEmitter {
                 this.emit('action', result);
             }
         }
+        // Run pipelines
+        for (const pipeline of this.config.pipelines) {
+            // Create a synthetic trigger def for evaluation
+            const triggerDef = {
+                name: pipeline.name,
+                match: pipeline.trigger,
+                run: '', // not used, just for type compat
+            };
+            const match = (0, matcher_js_1.evaluateTrigger)(triggerDef, file, previousFm);
+            if (match) {
+                this.emit('match', match);
+                // Execute pipeline async
+                (0, pipeline_js_1.executePipeline)(pipeline, match, this.config.configDir, this.dryRun)
+                    .then(result => this.emit('pipeline', result))
+                    .catch(err => this.emit('error', err instanceof Error ? err : new Error(String(err)), absolutePath));
+            }
+        }
         // Cache frontmatter for diff tracking
         this.frontmatterCache.set(relativePath, { ...file.frontmatter });
     }

package/package.json

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