javi-forge 1.6.0 → 1.7.0

package/dist/lib/template.js

@@ -1,11 +1,11 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { TEMPLATES_DIR, DEPENDABOT_FRAGMENTS_DIR, STACK_DEPENDABOT_MAP, STACK_CI_MAP, } from '../constants.js';
+import path from "node:path";
+import fs from "fs-extra";
+import { DEPENDABOT_FRAGMENTS_DIR, DEPLOY_DESTINATION_MAP, DEPLOY_TEMPLATE_MAP, STACK_CI_MAP, STACK_DEPENDABOT_MAP, TEMPLATES_DIR, } from "../constants.js";
 /**
  * Read a template file and replace __VAR_NAME__ placeholders.
  */
 export async function renderTemplate(templatePath, vars) {
-    let content = await fs.readFile(templatePath, 'utf-8');
+    let content = await fs.readFile(templatePath, "utf-8");
     for (const [key, value] of Object.entries(vars)) {
         const placeholder = `__${key}__`;
         content = content.replaceAll(placeholder, value);
@@ -17,12 +17,12 @@ export async function renderTemplate(templatePath, vars) {
  * Always includes github-actions fragment when provider is GitHub.
  */
 export async function generateDependabotYml(stacks, includeGitHubActions = true) {
-    const headerPath = path.join(DEPENDABOT_FRAGMENTS_DIR, 'header.yml');
-    let content = await fs.readFile(headerPath, 'utf-8');
+    const headerPath = path.join(DEPENDABOT_FRAGMENTS_DIR, "header.yml");
+    let content = await fs.readFile(headerPath, "utf-8");
     // Collect unique fragment names
     const fragments = new Set();
     if (includeGitHubActions)
-        fragments.add('github-actions');
+        fragments.add("github-actions");
     for (const stack of stacks) {
         const stackFragments = STACK_DEPENDABOT_MAP[stack] ?? [];
         for (const f of stackFragments)
@@ -32,8 +32,8 @@ export async function generateDependabotYml(stacks, includeGitHubActions = true)
     for (const fragmentName of fragments) {
         const fragmentPath = path.join(DEPENDABOT_FRAGMENTS_DIR, `${fragmentName}.yml`);
         if (await fs.pathExists(fragmentPath)) {
-            const fragment = await fs.readFile(fragmentPath, 'utf-8');
-            content += '\n' + fragment;
+            const fragment = await fs.readFile(fragmentPath, "utf-8");
+            content += `\n${fragment}`;
         }
     }
     return content;
@@ -58,21 +58,50 @@ export async function generateCIWorkflow(stack, provider) {
     const templatePath = getCITemplatePath(stack, provider);
     if (!templatePath)
         return null;
-    if (!await fs.pathExists(templatePath))
+    if (!(await fs.pathExists(templatePath)))
         return null;
-    return fs.readFile(templatePath, 'utf-8');
+    return fs.readFile(templatePath, "utf-8");
 }
 /**
  * Get the destination path for a CI workflow file within a project.
  */
 export function getCIDestination(provider) {
     switch (provider) {
-        case 'github':
-            return '.github/workflows/ci.yml';
-        case 'gitlab':
-            return '.gitlab-ci.yml';
-        case 'woodpecker':
-            return '.woodpecker.yml';
+        case "github":
+            return ".github/workflows/ci.yml";
+        case "gitlab":
+            return ".gitlab-ci.yml";
+        case "woodpecker":
+            return ".woodpecker.yml";
     }
 }
+/**
+ * Get the template path for the zero-downtime Docker deploy workflow.
+ * Returns null if no template exists for the given provider.
+ */
+export function getDeployTemplatePath(provider) {
+    const filename = DEPLOY_TEMPLATE_MAP[provider];
+    if (!filename)
+        return null;
+    return path.join(TEMPLATES_DIR, provider, filename);
+}
+/**
+ * Get the destination path for the deploy workflow file within a project.
+ * Returns null if no mapping exists for the given provider.
+ */
+export function getDeployDestination(provider) {
+    return DEPLOY_DESTINATION_MAP[provider] ?? null;
+}
+/**
+ * Generate the zero-downtime Docker deploy workflow content.
+ * Replaces __SERVICE_NAME__ with the provided service name.
+ */
+export async function generateDeployWorkflow(provider, serviceName) {
+    const templatePath = getDeployTemplatePath(provider);
+    if (!templatePath)
+        return null;
+    if (!(await fs.pathExists(templatePath)))
+        return null;
+    return renderTemplate(templatePath, { SERVICE_NAME: serviceName });
+}
 //# sourceMappingURL=template.js.map

package/dist/lib/workflow/discovery.d.ts

@@ -0,0 +1,27 @@
+import type { WorkflowDiscoveryEntry, WorkflowFormat } from "../../types/index.js";
+/** Workflow templates directory inside javi-forge package */
+export declare const WORKFLOW_TEMPLATES_DIR: string;
+/**
+ * Discover workflow files in a project's `.javi-forge/workflows/` directory.
+ */
+export declare function discoverWorkflows(projectDir: string): Promise<WorkflowDiscoveryEntry[]>;
+/**
+ * List available built-in workflow templates.
+ */
+export declare function listBuiltinTemplates(): Promise<WorkflowDiscoveryEntry[]>;
+/**
+ * Load a built-in template by name. Returns the file content or null if not found.
+ *
+ * The name argument is restricted to a strict kebab-case alphabet — anything
+ * with path separators, dots, or characters outside [a-z0-9-] is rejected
+ * outright. Without this check, an attacker (or a user with a typo) could
+ * pass --template "../../../etc/passwd" and walk out of WORKFLOW_TEMPLATES_DIR.
+ * The file would still need to end in .dot or .mermaid, but file-existence
+ * probes and arbitrary DOT-parse on attacker-controlled paths is enough to
+ * reject up front.
+ */
+export declare function loadBuiltinTemplate(name: string): Promise<{
+    content: string;
+    format: WorkflowFormat;
+} | null>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/lib/workflow/discovery.js

@@ -0,0 +1,85 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { TEMPLATES_DIR } from "../../constants.js";
+const WORKFLOW_EXTENSIONS = {
+    ".dot": "dot",
+    ".mermaid": "mermaid",
+};
+/** Workflow templates directory inside javi-forge package */
+export const WORKFLOW_TEMPLATES_DIR = path.join(TEMPLATES_DIR, "workflows");
+/**
+ * Discover workflow files in a project's `.javi-forge/workflows/` directory.
+ */
+export async function discoverWorkflows(projectDir) {
+    const workflowDir = path.join(projectDir, ".javi-forge", "workflows");
+    if (!(await fs.pathExists(workflowDir))) {
+        return [];
+    }
+    const entries = await fs.readdir(workflowDir);
+    const workflows = [];
+    for (const entry of entries) {
+        const ext = path.extname(entry);
+        const format = WORKFLOW_EXTENSIONS[ext];
+        if (format) {
+            workflows.push({
+                name: path.basename(entry, ext),
+                path: path.join(workflowDir, entry),
+                format,
+            });
+        }
+    }
+    return workflows;
+}
+/**
+ * List available built-in workflow templates.
+ */
+export async function listBuiltinTemplates() {
+    if (!(await fs.pathExists(WORKFLOW_TEMPLATES_DIR))) {
+        return [];
+    }
+    const entries = await fs.readdir(WORKFLOW_TEMPLATES_DIR);
+    const templates = [];
+    for (const entry of entries) {
+        const ext = path.extname(entry);
+        const format = WORKFLOW_EXTENSIONS[ext];
+        if (format) {
+            templates.push({
+                name: path.basename(entry, ext),
+                path: path.join(WORKFLOW_TEMPLATES_DIR, entry),
+                format,
+            });
+        }
+    }
+    return templates;
+}
+/**
+ * Load a built-in template by name. Returns the file content or null if not found.
+ *
+ * The name argument is restricted to a strict kebab-case alphabet — anything
+ * with path separators, dots, or characters outside [a-z0-9-] is rejected
+ * outright. Without this check, an attacker (or a user with a typo) could
+ * pass --template "../../../etc/passwd" and walk out of WORKFLOW_TEMPLATES_DIR.
+ * The file would still need to end in .dot or .mermaid, but file-existence
+ * probes and arbitrary DOT-parse on attacker-controlled paths is enough to
+ * reject up front.
+ */
+export async function loadBuiltinTemplate(name) {
+    if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name)) {
+        return null;
+    }
+    for (const [ext, format] of Object.entries(WORKFLOW_EXTENSIONS)) {
+        const templatePath = path.join(WORKFLOW_TEMPLATES_DIR, `${name}${ext}`);
+        // Defense in depth: even with the name regex above, ensure the
+        // resolved real path stays inside WORKFLOW_TEMPLATES_DIR.
+        const resolved = path.resolve(templatePath);
+        if (!resolved.startsWith(`${WORKFLOW_TEMPLATES_DIR}${path.sep}`)) {
+            continue;
+        }
+        if (await fs.pathExists(templatePath)) {
+            const content = await fs.readFile(templatePath, "utf-8");
+            return { content, format };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=discovery.js.map

package/dist/lib/workflow/index.d.ts

@@ -0,0 +1,5 @@
+export { discoverWorkflows, listBuiltinTemplates, loadBuiltinTemplate, WORKFLOW_TEMPLATES_DIR, } from "./discovery.js";
+export { parseDot, parseMermaid, WorkflowParseError } from "./parser.js";
+export { renderAscii } from "./renderer.js";
+export { getAvailableChecks, validateWorkflow } from "./validator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/workflow/index.js

@@ -0,0 +1,5 @@
+export { discoverWorkflows, listBuiltinTemplates, loadBuiltinTemplate, WORKFLOW_TEMPLATES_DIR, } from "./discovery.js";
+export { parseDot, parseMermaid, WorkflowParseError } from "./parser.js";
+export { renderAscii } from "./renderer.js";
+export { getAvailableChecks, validateWorkflow } from "./validator.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/workflow/parser.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowGraph } from "../../types/index.js";
+export declare class WorkflowParseError extends Error {
+    readonly line?: number | undefined;
+    constructor(message: string, line?: number | undefined);
+}
+/**
+ * Parse a DOT digraph string into a WorkflowGraph.
+ * Supports subset: `digraph [name] { A -> B; A [label="X" check="Y"]; }`
+ */
+export declare function parseDot(content: string, sourceName?: string): WorkflowGraph;
+/**
+ * Parse a Mermaid flowchart string into a WorkflowGraph.
+ * Supports subset: `flowchart LR/TD`, `A --> B`, `A[Label]`, `A -->|label| B`
+ */
+export declare function parseMermaid(content: string, sourceName?: string): WorkflowGraph;
+//# sourceMappingURL=parser.d.ts.map

package/dist/lib/workflow/parser.js

@@ -0,0 +1,198 @@
+export class WorkflowParseError extends Error {
+    line;
+    constructor(message, line) {
+        super(line !== undefined ? `Line ${line}: ${message}` : message);
+        this.line = line;
+        this.name = "WorkflowParseError";
+    }
+}
+// ── DOT Parser ──────────────────────────────────────────────────────────────
+/**
+ * Parse a DOT digraph string into a WorkflowGraph.
+ * Supports subset: `digraph [name] { A -> B; A [label="X" check="Y"]; }`
+ */
+export function parseDot(content, sourceName = "untitled") {
+    const trimmed = content.trim();
+    // Extract digraph header
+    const headerMatch = trimmed.match(/^digraph\s+(?:"([^"]+)"|(\w+))?\s*\{/i);
+    if (!headerMatch) {
+        throw new WorkflowParseError('Expected "digraph [name] {" at start of file');
+    }
+    const graphName = headerMatch[1] ?? headerMatch[2] ?? sourceName;
+    // Extract body between first { and last }
+    const openBrace = trimmed.indexOf("{");
+    const closeBrace = trimmed.lastIndexOf("}");
+    if (openBrace === -1 || closeBrace === -1 || closeBrace <= openBrace) {
+        throw new WorkflowParseError("Malformed digraph: missing braces");
+    }
+    const body = trimmed.slice(openBrace + 1, closeBrace);
+    const nodesMap = new Map();
+    const edges = [];
+    // Split by semicolons or newlines
+    const statements = body
+        .split(/[;\n]/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0 && !s.startsWith("//") && !s.startsWith("#"));
+    for (const stmt of statements) {
+        // Skip graph-level attributes like rankdir=LR
+        if (/^\w+=/.test(stmt) && !stmt.includes("->"))
+            continue;
+        // Edge: A -> B [label="..."]
+        const edgeMatch = stmt.match(/^"?(\w[\w\s-]*?)"?\s*->\s*"?(\w[\w\s-]*?)"?\s*(?:\[([^\]]*)\])?\s*$/);
+        if (edgeMatch) {
+            const fromId = edgeMatch[1]?.trim();
+            const toId = edgeMatch[2]?.trim();
+            const attrs = edgeMatch[3] ? parseAttributes(edgeMatch[3]) : {};
+            ensureNode(nodesMap, fromId);
+            ensureNode(nodesMap, toId);
+            edges.push({ from: fromId, to: toId, label: attrs.label });
+            continue;
+        }
+        // Node: A [label="..." check="..."]
+        const nodeMatch = stmt.match(/^"?(\w[\w\s-]*?)"?\s*\[([^\]]+)\]\s*$/);
+        if (nodeMatch) {
+            const nodeId = nodeMatch[1]?.trim();
+            const attrs = parseAttributes(nodeMatch[2]);
+            const node = ensureNode(nodesMap, nodeId);
+            if (attrs.label)
+                node.label = attrs.label;
+            if (attrs.check)
+                node.check = attrs.check;
+            // Store remaining attrs as metadata
+            const { label: _l, check: _c, ...rest } = attrs;
+            if (Object.keys(rest).length > 0)
+                node.metadata = rest;
+            continue;
+        }
+        // Chained edge: A -> B -> C
+        const chainMatch = stmt.match(/^[\w\s"-]+(?:\s*->\s*[\w\s"-]+)+$/);
+        if (chainMatch) {
+            const parts = stmt.split("->").map((p) => p.trim().replace(/^"|"$/g, ""));
+            for (let i = 0; i < parts.length - 1; i++) {
+                const fromId = parts[i]?.trim();
+                const toId = parts[i + 1]?.trim();
+                ensureNode(nodesMap, fromId);
+                ensureNode(nodesMap, toId);
+                edges.push({ from: fromId, to: toId });
+            }
+        }
+    }
+    if (nodesMap.size === 0) {
+        throw new WorkflowParseError("No nodes found in digraph");
+    }
+    return {
+        name: graphName,
+        nodes: Array.from(nodesMap.values()),
+        edges,
+        format: "dot",
+    };
+}
+// ── Mermaid Parser ──────────────────────────────────────────────────────────
+/**
+ * Parse a Mermaid flowchart string into a WorkflowGraph.
+ * Supports subset: `flowchart LR/TD`, `A --> B`, `A[Label]`, `A -->|label| B`
+ */
+export function parseMermaid(content, sourceName = "untitled") {
+    const lines = content
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    if (lines.length === 0) {
+        throw new WorkflowParseError("Empty mermaid file");
+    }
+    // First line must be flowchart directive
+    const headerMatch = lines[0]?.match(/^(?:flowchart|graph)\s+(LR|TD|TB|RL|BT)/i);
+    if (!headerMatch) {
+        throw new WorkflowParseError('Expected "flowchart LR|TD" or "graph LR|TD" at first line', 1);
+    }
+    const nodesMap = new Map();
+    const edges = [];
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        // Skip comments and style directives
+        if (line.startsWith("%%") ||
+            line.startsWith("style") ||
+            line.startsWith("classDef")) {
+            continue;
+        }
+        // Edge with label: A -->|label| B  or  A -- label --> B
+        const edgeLabelMatch = line.match(/^(\w[\w-]*?)(?:\[([^\]]+)\])?\s*-->?\|([^|]+)\|\s*(\w[\w-]*?)(?:\[([^\]]+)\])?\s*$/);
+        if (edgeLabelMatch) {
+            const fromId = edgeLabelMatch[1];
+            const fromLabel = edgeLabelMatch[2];
+            const edgeLabel = edgeLabelMatch[3]?.trim();
+            const toId = edgeLabelMatch[4];
+            const toLabel = edgeLabelMatch[5];
+            const fromNode = ensureNode(nodesMap, fromId);
+            if (fromLabel)
+                fromNode.label = fromLabel;
+            const toNode = ensureNode(nodesMap, toId);
+            if (toLabel)
+                toNode.label = toLabel;
+            edges.push({ from: fromId, to: toId, label: edgeLabel });
+            continue;
+        }
+        // Simple edge: A --> B  (possibly chained: A --> B --> C)
+        // Also handles node labels: A[Label] --> B[Label]
+        const edgeMatch = line.match(/(\w[\w-]*?)(?:\[([^\]]+)\])?\s*-->?\s*/);
+        if (edgeMatch && line.includes("-->")) {
+            const segments = line.split(/\s*-->\s*/);
+            for (let s = 0; s < segments.length; s++) {
+                const seg = segments[s]?.trim();
+                const segMatch = seg.match(/^(\w[\w-]*)(?:\[([^\]]+)\])?$/);
+                if (segMatch) {
+                    const nodeId = segMatch[1];
+                    const nodeLabel = segMatch[2];
+                    const node = ensureNode(nodesMap, nodeId);
+                    if (nodeLabel)
+                        node.label = nodeLabel;
+                }
+            }
+            // Create edges between consecutive segments
+            for (let s = 0; s < segments.length - 1; s++) {
+                const fromSeg = segments[s]?.trim().match(/^(\w[\w-]*)/);
+                const toSeg = segments[s + 1]?.trim().match(/^(\w[\w-]*)/);
+                if (fromSeg && toSeg) {
+                    edges.push({ from: fromSeg[1], to: toSeg[1] });
+                }
+            }
+            continue;
+        }
+        // Standalone node with label: A[Label]
+        const nodeMatch = line.match(/^(\w[\w-]*)\[([^\]]+)\]\s*$/);
+        if (nodeMatch) {
+            const node = ensureNode(nodesMap, nodeMatch[1]);
+            node.label = nodeMatch[2];
+        }
+    }
+    if (nodesMap.size === 0) {
+        throw new WorkflowParseError("No nodes found in flowchart");
+    }
+    return {
+        name: sourceName,
+        nodes: Array.from(nodesMap.values()),
+        edges,
+        format: "mermaid",
+    };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function ensureNode(nodesMap, id) {
+    let node = nodesMap.get(id);
+    if (!node) {
+        node = { id, label: id };
+        nodesMap.set(id, node);
+    }
+    return node;
+}
+function parseAttributes(attrStr) {
+    const attrs = {};
+    // Match key="value" or key=value pairs
+    const regex = /(\w+)\s*=\s*(?:"([^"]*)"|(\S+))/g;
+    let match;
+    // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic regex exec loop
+    while ((match = regex.exec(attrStr)) !== null) {
+        attrs[match[1]] = match[2] ?? match[3] ?? "";
+    }
+    return attrs;
+}
+//# sourceMappingURL=parser.js.map

package/dist/lib/workflow/renderer.d.ts

@@ -0,0 +1,9 @@
+import type { WorkflowGraph, WorkflowValidationResult } from "../../types/index.js";
+/**
+ * Render a WorkflowGraph as ASCII art.
+ * Linear pipelines render as: [lint] -> [test] -> [build]
+ * Branching renders with indentation.
+ * Optionally overlays validation results with pass/fail icons.
+ */
+export declare function renderAscii(graph: WorkflowGraph, validationResults?: WorkflowValidationResult[]): string;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/lib/workflow/renderer.js

@@ -0,0 +1,152 @@
+/**
+ * Render a WorkflowGraph as ASCII art.
+ * Linear pipelines render as: [lint] -> [test] -> [build]
+ * Branching renders with indentation.
+ * Optionally overlays validation results with pass/fail icons.
+ */
+export function renderAscii(graph, validationResults) {
+    if (graph.nodes.length === 0)
+        return "(empty graph)";
+    const resultMap = new Map();
+    if (validationResults) {
+        for (const r of validationResults) {
+            resultMap.set(r.node, r);
+        }
+    }
+    // Build adjacency and in-degree
+    const adjacency = new Map();
+    const inDegree = new Map();
+    for (const node of graph.nodes) {
+        adjacency.set(node.id, []);
+        inDegree.set(node.id, 0);
+    }
+    for (const edge of graph.edges) {
+        const children = adjacency.get(edge.from);
+        if (children)
+            children.push(edge.to);
+        inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+    }
+    // Find roots (in-degree 0)
+    const roots = graph.nodes
+        .filter((n) => (inDegree.get(n.id) ?? 0) === 0)
+        .map((n) => n.id);
+    if (roots.length === 0) {
+        // Cycle — just list all nodes
+        return graph.nodes
+            .map((n) => formatNode(n.id, n.label, resultMap))
+            .join(" -> ");
+    }
+    // Topological order using Kahn's algorithm
+    const queue = [...roots];
+    const ordered = [];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        ordered.push(current);
+        const children = adjacency.get(current) ?? [];
+        for (const child of children) {
+            const deg = (inDegree.get(child) ?? 1) - 1;
+            inDegree.set(child, deg);
+            if (deg <= 0 && !visited.has(child)) {
+                queue.push(child);
+            }
+        }
+    }
+    // Add any unvisited nodes (disconnected)
+    for (const node of graph.nodes) {
+        if (!visited.has(node.id))
+            ordered.push(node.id);
+    }
+    // Build label map
+    const labelMap = new Map();
+    for (const node of graph.nodes) {
+        labelMap.set(node.id, node.label);
+    }
+    // Build edge label map
+    const edgeLabelMap = new Map();
+    for (const edge of graph.edges) {
+        const key = `${edge.from}->${edge.to}`;
+        if (edge.label)
+            edgeLabelMap.set(key, edge.label);
+    }
+    // Render: try linear first, fall back to tree-like
+    const lines = [];
+    lines.push(`# ${graph.name}`);
+    lines.push("");
+    // Check if it's a simple linear chain
+    const isLinear = graph.nodes.every((n) => {
+        const children = adjacency.get(n.id) ?? [];
+        return children.length <= 1;
+    }) && roots.length === 1;
+    if (isLinear) {
+        const chain = [];
+        let current = roots[0];
+        while (current) {
+            chain.push(formatNode(current, labelMap.get(current) ?? current, resultMap));
+            const children = adjacency.get(current) ?? [];
+            const next = children[0];
+            if (next) {
+                const edgeKey = `${current}->${next}`;
+                const edgeLabel = edgeLabelMap.get(edgeKey);
+                if (edgeLabel) {
+                    chain.push(`--(${edgeLabel})-->`);
+                }
+            }
+            current = next;
+        }
+        lines.push(chain.join(" -> ").replace(/ -> --/g, " --"));
+    }
+    else {
+        // Tree-like rendering
+        for (const nodeId of ordered) {
+            const children = adjacency.get(nodeId) ?? [];
+            const nodeStr = formatNode(nodeId, labelMap.get(nodeId) ?? nodeId, resultMap);
+            if (children.length === 0) {
+                lines.push(`  ${nodeStr}`);
+            }
+            else {
+                const childStrs = children.map((c) => {
+                    const edgeKey = `${nodeId}->${c}`;
+                    const edgeLabel = edgeLabelMap.get(edgeKey);
+                    const arrow = edgeLabel ? `--(${edgeLabel})-->` : "->";
+                    return `${arrow} ${formatNode(c, labelMap.get(c) ?? c, resultMap)}`;
+                });
+                if (childStrs.length === 1) {
+                    lines.push(`  ${nodeStr} ${childStrs[0]}`);
+                }
+                else {
+                    lines.push(`  ${nodeStr}`);
+                    for (const cs of childStrs) {
+                        lines.push(`    ${cs}`);
+                    }
+                }
+            }
+        }
+    }
+    // Add validation legend if results are present
+    if (validationResults && validationResults.length > 0) {
+        lines.push("");
+        lines.push("---");
+        for (const r of validationResults) {
+            const icon = r.status === "pass" ? "\u2713" : r.status === "fail" ? "\u2717" : "-";
+            lines.push(`  ${icon} ${r.node}${r.detail ? `: ${r.detail}` : ""}`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatNode(id, label, resultMap) {
+    const result = resultMap.get(id);
+    if (result) {
+        const icon = result.status === "pass"
+            ? "\u2713"
+            : result.status === "fail"
+                ? "\u2717"
+                : "?";
+        return `[${icon} ${label}]`;
+    }
+    return `[${label}]`;
+}
+//# sourceMappingURL=renderer.js.map

package/dist/lib/workflow/validator.d.ts

@@ -0,0 +1,10 @@
+import type { WorkflowGraph, WorkflowValidationResult } from "../../types/index.js";
+/**
+ * Validate a project directory against a workflow graph.
+ * Nodes with a `check` attribute are evaluated against built-in checks.
+ * Nodes without a `check` attribute are skipped.
+ */
+export declare function validateWorkflow(graph: WorkflowGraph, projectDir: string): Promise<WorkflowValidationResult[]>;
+/** Expose check names for testing and documentation */
+export declare function getAvailableChecks(): string[];
+//# sourceMappingURL=validator.d.ts.map