@safetnsr/md-pipe 0.2.0 → 0.3.0

package/dist/core/config.js

@@ -18,6 +18,61 @@ function findConfigFile(dir) {
     }
     return null;
 }
+function parseTriggerMatch(raw, name) {
+    const match = {};
+    if (raw.path)
+        match.path = String(raw.path);
+    if (raw.frontmatter)
+        match.frontmatter = raw.frontmatter;
+    if (raw.frontmatter_changed) {
+        if (!Array.isArray(raw.frontmatter_changed)) {
+            throw new Error(`Config error: trigger '${name}' frontmatter_changed must be an array`);
+        }
+        match.frontmatter_changed = raw.frontmatter_changed.map(String);
+    }
+    if (raw.tags) {
+        if (!Array.isArray(raw.tags)) {
+            throw new Error(`Config error: trigger '${name}' tags must be an array`);
+        }
+        match.tags = raw.tags.map(String);
+    }
+    if (raw.content !== undefined)
+        match.content = String(raw.content);
+    if (raw.content_regex !== undefined)
+        match.content_regex = String(raw.content_regex);
+    return match;
+}
+function parsePipelineStep(raw, pipelineName, index) {
+    const step = {};
+    if (raw.run !== undefined)
+        step.run = String(raw.run);
+    if (raw['update-frontmatter'] !== undefined)
+        step['update-frontmatter'] = raw['update-frontmatter'];
+    if (raw.webhook !== undefined)
+        step.webhook = raw.webhook;
+    if (raw.copy !== undefined) {
+        if (typeof raw.copy === 'string') {
+            step.copy = { to: raw.copy };
+        }
+        else {
+            step.copy = raw.copy;
+        }
+    }
+    if (raw.template !== undefined)
+        step.template = raw.template;
+    if (raw.continue_on_error !== undefined)
+        step.continue_on_error = Boolean(raw.continue_on_error);
+    // Validate at least one step type is present
+    const hasType = step.run !== undefined ||
+        step['update-frontmatter'] !== undefined ||
+        step.webhook !== undefined ||
+        step.copy !== undefined ||
+        step.template !== undefined;
+    if (!hasType) {
+        throw new Error(`Config error: pipeline '${pipelineName}' step[${index}] has no recognized step type (run, update-frontmatter, webhook, copy, template)`);
+    }
+    return step;
+}
 function loadConfig(configPath) {
     const raw = (0, fs_1.readFileSync)(configPath, 'utf-8');
     const parsed = yaml_1.default.parse(raw);
@@ -27,46 +82,54 @@ function loadConfig(configPath) {
     if (!parsed.watch || typeof parsed.watch !== 'string') {
         throw new Error(`Config error: 'watch' must be a string path (e.g. "./docs")`);
     }
-    if (!Array.isArray(parsed.triggers) || parsed.triggers.length === 0) {
-        throw new Error(`Config error: 'triggers' must be a non-empty array`);
+    const hasTriggers = Array.isArray(parsed.triggers) && parsed.triggers.length > 0;
+    const hasPipelines = Array.isArray(parsed.pipelines) && parsed.pipelines.length > 0;
+    if (!hasTriggers && !hasPipelines) {
+        throw new Error(`Config error: must have at least one 'triggers' entry or 'pipelines' entry`);
     }
     const configDir = (0, path_1.dirname)(configPath);
     const triggers = [];
-    for (let i = 0; i < parsed.triggers.length; i++) {
-        const t = parsed.triggers[i];
-        if (!t.name || typeof t.name !== 'string') {
-            throw new Error(`Config error: trigger[${i}] must have a 'name' string`);
-        }
-        if (!t.match || typeof t.match !== 'object') {
-            throw new Error(`Config error: trigger '${t.name}' must have a 'match' object`);
-        }
-        if (!t.run || typeof t.run !== 'string') {
-            throw new Error(`Config error: trigger '${t.name}' must have a 'run' string`);
-        }
-        const match = {};
-        if (t.match.path)
-            match.path = String(t.match.path);
-        if (t.match.frontmatter)
-            match.frontmatter = t.match.frontmatter;
-        if (t.match.frontmatter_changed) {
-            if (!Array.isArray(t.match.frontmatter_changed)) {
-                throw new Error(`Config error: trigger '${t.name}' frontmatter_changed must be an array`);
+    const pipelines = [];
+    // Parse legacy triggers
+    if (hasTriggers) {
+        for (let i = 0; i < parsed.triggers.length; i++) {
+            const t = parsed.triggers[i];
+            if (!t.name || typeof t.name !== 'string') {
+                throw new Error(`Config error: trigger[${i}] must have a 'name' string`);
+            }
+            if (!t.match || typeof t.match !== 'object') {
+                throw new Error(`Config error: trigger '${t.name}' must have a 'match' object`);
             }
-            match.frontmatter_changed = t.match.frontmatter_changed.map(String);
+            if (!t.run || typeof t.run !== 'string') {
+                throw new Error(`Config error: trigger '${t.name}' must have a 'run' string`);
+            }
+            const match = parseTriggerMatch(t.match, t.name);
+            const cwd = t.cwd === 'project' ? 'project' : (t.cwd === 'file' ? 'file' : undefined);
+            triggers.push({ name: t.name, match, run: t.run, ...(cwd ? { cwd } : {}) });
         }
-        if (t.match.tags) {
-            if (!Array.isArray(t.match.tags)) {
-                throw new Error(`Config error: trigger '${t.name}' tags must be an array`);
+    }
+    // Parse pipelines
+    if (hasPipelines) {
+        for (let i = 0; i < parsed.pipelines.length; i++) {
+            const p = parsed.pipelines[i];
+            if (!p.name || typeof p.name !== 'string') {
+                throw new Error(`Config error: pipeline[${i}] must have a 'name' string`);
             }
-            match.tags = t.match.tags.map(String);
+            if (!p.trigger || typeof p.trigger !== 'object') {
+                throw new Error(`Config error: pipeline '${p.name}' must have a 'trigger' object`);
+            }
+            if (!Array.isArray(p.steps) || p.steps.length === 0) {
+                throw new Error(`Config error: pipeline '${p.name}' must have a non-empty 'steps' array`);
+            }
+            const trigger = parseTriggerMatch(p.trigger, p.name);
+            const steps = p.steps.map((s, j) => parsePipelineStep(s, p.name, j));
+            pipelines.push({
+                name: p.name,
+                trigger,
+                steps,
+                ...(p.continue_on_error ? { continue_on_error: true } : {}),
+            });
         }
-        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 watchPath = (0, path_1.resolve)(configDir, parsed.watch);
@@ -74,7 +137,6 @@ function loadConfig(configPath) {
     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)
@@ -88,7 +150,7 @@ function loadConfig(configPath) {
             debounce = parsed.debounce;
         }
     }
-    return { watch: watchPath, configDir, triggers, ...(debounce ? { debounce } : {}) };
+    return { watch: watchPath, configDir, triggers, pipelines, ...(debounce ? { debounce } : {}) };
 }
 function generateDefaultConfig() {
     return `# md-pipe configuration
@@ -96,6 +158,7 @@ function generateDefaultConfig() {
 
 watch: ./docs
 
+# Legacy triggers (simple: match + run command)
 triggers:
   - name: publish
     match:
@@ -104,18 +167,17 @@ triggers:
         status: publish
     run: "echo Publishing $FILE"
 
-  - name: reindex
-    match:
-      frontmatter_changed:
-        - title
-        - tags
-        - category
-    run: "echo Reindexing $FILE — changed fields: $DIFF"
-
-  - name: urgent-notify
-    match:
-      tags:
-        - urgent
-    run: "echo URGENT: $FILE needs attention"
+# Pipelines (v0.3+): multi-step content pipelines
+# pipelines:
+#   - name: publish-post
+#     trigger:
+#       path: "posts/**"
+#       frontmatter: { status: publish }
+#       frontmatter_changed: [status]
+#     steps:
+#       - run: "echo Publishing {{fm.title}}"
+#       - update-frontmatter: { published_at: "{{now}}", published: true }
+#       - copy: { to: "./_site/posts" }
+#       - webhook: { url: "$WEBHOOK_URL" }
 `;
 }

package/dist/core/pipeline.d.ts

@@ -0,0 +1,48 @@
+import { TriggerMatch } from './config.js';
+import { MatchResult } from './matcher.js';
+import { type StepResult } from './steps/run.js';
+export interface PipelineStepDef {
+    run?: string;
+    'update-frontmatter'?: Record<string, unknown>;
+    webhook?: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+    copy?: {
+        to: string;
+        flatten?: boolean;
+    };
+    template?: {
+        src: string;
+        out: string;
+    };
+    continue_on_error?: boolean;
+}
+export interface PipelineDef {
+    name: string;
+    trigger: TriggerMatch;
+    steps: PipelineStepDef[];
+    continue_on_error?: boolean;
+}
+export interface PipelineResult {
+    pipelineName: string;
+    filePath: string;
+    steps: StepResult[];
+    success: boolean;
+    durationMs: number;
+}
+/**
+ * Execute a full pipeline: run steps in order, build context as we go.
+ */
+export declare function executePipeline(pipeline: PipelineDef, match: MatchResult, configDir: string, dryRun?: boolean): Promise<PipelineResult>;
+/**
+ * Convert a legacy trigger (with `run` string) into a single-step pipeline.
+ * This enables backward compatibility.
+ */
+export declare function triggerToPipeline(trigger: {
+    name: string;
+    match: TriggerMatch;
+    run: string;
+}): PipelineDef;

package/dist/core/pipeline.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePipeline = executePipeline;
+exports.triggerToPipeline = triggerToPipeline;
+const path_1 = require("path");
+const template_vars_js_1 = require("./template-vars.js");
+const run_js_1 = require("./steps/run.js");
+const update_frontmatter_js_1 = require("./steps/update-frontmatter.js");
+const webhook_js_1 = require("./steps/webhook.js");
+const copy_js_1 = require("./steps/copy.js");
+const template_js_1 = require("./steps/template.js");
+/**
+ * Detect the step type from a step definition.
+ */
+function getStepType(step) {
+    if (step.run !== undefined)
+        return 'run';
+    if (step['update-frontmatter'] !== undefined)
+        return 'update-frontmatter';
+    if (step.webhook !== undefined)
+        return 'webhook';
+    if (step.copy !== undefined)
+        return 'copy';
+    if (step.template !== undefined)
+        return 'template';
+    return null;
+}
+/**
+ * Execute a single pipeline step.
+ */
+async function executeStep(step, ctx, configDir, dryRun) {
+    const type = getStepType(step);
+    switch (type) {
+        case 'run':
+            return (0, run_js_1.executeRunStep)({ run: step.run }, ctx, (0, path_1.dirname)(ctx.file), dryRun);
+        case 'update-frontmatter':
+            return (0, update_frontmatter_js_1.executeUpdateFrontmatterStep)({ 'update-frontmatter': step['update-frontmatter'] }, ctx, dryRun);
+        case 'webhook':
+            return await (0, webhook_js_1.executeWebhookStep)({ webhook: step.webhook }, ctx, dryRun);
+        case 'copy':
+            return (0, copy_js_1.executeCopyStep)({ copy: step.copy }, ctx, configDir, dryRun);
+        case 'template':
+            return (0, template_js_1.executeTemplateStep)({ template: step.template }, ctx, configDir, dryRun);
+        default:
+            return {
+                type: 'unknown',
+                success: false,
+                stdout: '',
+                stderr: `Unknown step type in: ${JSON.stringify(step)}`,
+                exitCode: 1,
+                durationMs: 0,
+            };
+    }
+}
+/**
+ * Execute a full pipeline: run steps in order, build context as we go.
+ */
+async function executePipeline(pipeline, match, configDir, dryRun = false) {
+    const { file, diff } = match;
+    const ctx = (0, template_vars_js_1.buildContext)(file.filePath, file.relativePath, (0, path_1.dirname)(file.filePath), { ...file.frontmatter }, [...file.tags], file.content, file.body, diff);
+    const stepResults = [];
+    const pipelineStart = Date.now();
+    let allSuccess = true;
+    for (const step of pipeline.steps) {
+        const result = await executeStep(step, ctx, configDir, dryRun);
+        stepResults.push(result);
+        // Add step output to context for subsequent steps
+        const stepOutput = {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+        };
+        ctx.steps.push(stepOutput);
+        if (!result.success) {
+            allSuccess = false;
+            const continueOnError = step.continue_on_error ?? pipeline.continue_on_error ?? false;
+            if (!continueOnError) {
+                break;
+            }
+        }
+    }
+    return {
+        pipelineName: pipeline.name,
+        filePath: file.filePath,
+        steps: stepResults,
+        success: allSuccess,
+        durationMs: Date.now() - pipelineStart,
+    };
+}
+/**
+ * Convert a legacy trigger (with `run` string) into a single-step pipeline.
+ * This enables backward compatibility.
+ */
+function triggerToPipeline(trigger) {
+    return {
+        name: trigger.name,
+        trigger: trigger.match,
+        steps: [{ run: trigger.run }],
+    };
+}

package/dist/core/run-command.d.ts

@@ -0,0 +1,11 @@
+import { MdPipeConfig } from './config.js';
+import { PipelineResult } from './pipeline.js';
+export interface RunCommandResult {
+    success: boolean;
+    results: PipelineResult[];
+    errors: string[];
+}
+/**
+ * Run a named pipeline manually on a specific file or all matching files.
+ */
+export declare function runPipelineCommand(config: MdPipeConfig, pipelineName: string, filePath?: string, dryRun?: boolean): Promise<RunCommandResult>;

package/dist/core/run-command.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPipelineCommand = runPipelineCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const matcher_js_1 = require("./matcher.js");
+const pipeline_js_1 = require("./pipeline.js");
+function findMarkdownFiles(dir) {
+    const results = [];
+    function walk(current) {
+        const entries = (0, fs_1.readdirSync)(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = (0, path_1.resolve)(current, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                walk(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                results.push(full);
+            }
+        }
+    }
+    walk(dir);
+    return results;
+}
+/**
+ * Run a named pipeline manually on a specific file or all matching files.
+ */
+async function runPipelineCommand(config, pipelineName, filePath, dryRun = false) {
+    // Find the pipeline (check both pipelines and legacy triggers)
+    let pipeline;
+    pipeline = config.pipelines.find(p => p.name === pipelineName);
+    if (!pipeline) {
+        const trigger = config.triggers.find(t => t.name === pipelineName);
+        if (trigger) {
+            pipeline = (0, pipeline_js_1.triggerToPipeline)(trigger);
+        }
+    }
+    if (!pipeline) {
+        const available = [
+            ...config.pipelines.map(p => p.name),
+            ...config.triggers.map(t => t.name),
+        ];
+        return {
+            success: false,
+            results: [],
+            errors: [`Pipeline '${pipelineName}' not found. Available: ${available.join(', ') || 'none'}`],
+        };
+    }
+    const results = [];
+    const errors = [];
+    if (filePath) {
+        // Run on specific file
+        const absPath = (0, path_1.resolve)(filePath);
+        const relPath = (0, path_1.relative)(config.watch, absPath);
+        try {
+            const file = (0, matcher_js_1.parseMarkdownFile)(absPath, relPath);
+            const match = { trigger: { name: pipeline.name, match: pipeline.trigger, run: '' }, file, diff: null };
+            const result = await (0, pipeline_js_1.executePipeline)(pipeline, match, config.configDir, dryRun);
+            results.push(result);
+        }
+        catch (err) {
+            errors.push(`Error processing ${filePath}: ${err.message}`);
+        }
+    }
+    else {
+        // Run on all matching files
+        const files = findMarkdownFiles(config.watch);
+        for (const fp of files) {
+            const relPath = (0, path_1.relative)(config.watch, fp);
+            try {
+                const file = (0, matcher_js_1.parseMarkdownFile)(fp, relPath);
+                const triggerDef = { name: pipeline.name, match: pipeline.trigger, run: '' };
+                const match = (0, matcher_js_1.evaluateTrigger)(triggerDef, file);
+                if (match) {
+                    const result = await (0, pipeline_js_1.executePipeline)(pipeline, match, config.configDir, dryRun);
+                    results.push(result);
+                }
+            }
+            catch (err) {
+                errors.push(`Error processing ${fp}: ${err.message}`);
+            }
+        }
+    }
+    const success = errors.length === 0 && results.every(r => r.success);
+    return { success, results, errors };
+}

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

@@ -0,0 +1,10 @@
+import { TemplateContext } from '../template-vars.js';
+import type { StepResult } from './run.js';
+export interface CopyStepConfig {
+    copy: {
+        to: string;
+        /** If true, preserve directory structure relative to watch dir. Default: false */
+        flatten?: boolean;
+    };
+}
+export declare function executeCopyStep(config: CopyStepConfig, ctx: TemplateContext, configDir: string, dryRun: boolean): StepResult;

package/dist/core/steps/copy.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCopyStep = executeCopyStep;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const template_vars_js_1 = require("../template-vars.js");
+function executeCopyStep(config, ctx, configDir, dryRun) {
+    const start = Date.now();
+    try {
+        const destDir = (0, path_1.resolve)(configDir, (0, template_vars_js_1.expandTemplate)(config.copy.to, ctx));
+        const flatten = config.copy.flatten ?? false;
+        let destPath;
+        if (flatten) {
+            destPath = (0, path_1.join)(destDir, ctx.basename);
+        }
+        else {
+            destPath = (0, path_1.join)(destDir, ctx.relative);
+        }
+        if (!dryRun) {
+            (0, fs_1.mkdirSync)((0, path_1.dirname)(destPath), { recursive: true });
+            (0, fs_1.copyFileSync)(ctx.file, destPath);
+        }
+        return {
+            type: 'copy',
+            success: true,
+            stdout: `Copied to ${destPath}${dryRun ? ' [dry run]' : ''}`,
+            stderr: '',
+            exitCode: 0,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            type: 'copy',
+            success: false,
+            stdout: '',
+            stderr: err.message || String(err),
+            exitCode: 1,
+            durationMs: Date.now() - start,
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+import { TemplateContext } from '../template-vars.js';
+export interface RunStepConfig {
+    run: string;
+}
+export interface StepResult {
+    type: string;
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    durationMs: number;
+}
+export declare function executeRunStep(config: RunStepConfig, ctx: TemplateContext, cwd: string, dryRun: boolean): StepResult;

package/dist/core/steps/run.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeRunStep = executeRunStep;
+const child_process_1 = require("child_process");
+const template_vars_js_1 = require("../template-vars.js");
+function executeRunStep(config, ctx, cwd, dryRun) {
+    const command = (0, template_vars_js_1.expandTemplate)(config.run, ctx);
+    if (dryRun) {
+        return {
+            type: 'run',
+            success: true,
+            stdout: '[dry run]',
+            stderr: '',
+            exitCode: 0,
+            durationMs: 0,
+        };
+    }
+    const env = (0, template_vars_js_1.buildEnvVars)(ctx);
+    const start = Date.now();
+    try {
+        const stdout = (0, child_process_1.execSync)(command, {
+            cwd,
+            timeout: 30000,
+            encoding: 'utf-8',
+            env: { ...process.env, ...env },
+        });
+        return {
+            type: 'run',
+            success: true,
+            stdout: stdout.trim(),
+            stderr: '',
+            exitCode: 0,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            type: 'run',
+            success: false,
+            stdout: err.stdout?.trim() ?? '',
+            stderr: err.stderr?.trim() ?? '',
+            exitCode: err.status ?? 1,
+            durationMs: Date.now() - start,
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+import { TemplateContext } from '../template-vars.js';
+import type { StepResult } from './run.js';
+export interface TemplateStepConfig {
+    template: {
+        /** Path to template file (relative to config dir) */
+        src: string;
+        /** Output path (relative to config dir). Supports template vars. */
+        out: string;
+    };
+}
+export declare function executeTemplateStep(config: TemplateStepConfig, ctx: TemplateContext, configDir: string, dryRun: boolean): StepResult;

package/dist/core/steps/template.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTemplateStep = executeTemplateStep;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const template_vars_js_1 = require("../template-vars.js");
+function executeTemplateStep(config, ctx, configDir, dryRun) {
+    const start = Date.now();
+    try {
+        const srcPath = (0, path_1.resolve)(configDir, (0, template_vars_js_1.expandTemplate)(config.template.src, ctx));
+        const outPath = (0, path_1.resolve)(configDir, (0, template_vars_js_1.expandTemplate)(config.template.out, ctx));
+        const templateContent = (0, fs_1.readFileSync)(srcPath, 'utf-8');
+        const rendered = (0, template_vars_js_1.expandTemplate)(templateContent, ctx);
+        if (!dryRun) {
+            (0, fs_1.mkdirSync)((0, path_1.dirname)(outPath), { recursive: true });
+            (0, fs_1.writeFileSync)(outPath, rendered, 'utf-8');
+        }
+        return {
+            type: 'template',
+            success: true,
+            stdout: `Rendered ${srcPath} → ${outPath}${dryRun ? ' [dry run]' : ''}`,
+            stderr: '',
+            exitCode: 0,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            type: 'template',
+            success: false,
+            stdout: '',
+            stderr: err.message || String(err),
+            exitCode: 1,
+            durationMs: Date.now() - start,
+        };
+    }
+}

package/dist/core/steps/update-frontmatter.d.ts

@@ -0,0 +1,6 @@
+import { TemplateContext } from '../template-vars.js';
+import type { StepResult } from './run.js';
+export interface UpdateFrontmatterStepConfig {
+    'update-frontmatter': Record<string, unknown>;
+}
+export declare function executeUpdateFrontmatterStep(config: UpdateFrontmatterStepConfig, ctx: TemplateContext, dryRun: boolean): StepResult;