javi-forge 1.5.0 → 1.6.1

package/dist/lib/stack-detector.js

@@ -0,0 +1,207 @@
+import fs from "fs-extra";
+import path from "path";
+// ── Stack-to-Skills Mapping ────────────────────────────────────────────────
+/**
+ * Maps detected project signals to recommended AI skills.
+ * Each key is a detection signal (file/dependency/pattern),
+ * and the value is the list of skills it implies.
+ */
+export const SIGNAL_SKILL_MAP = {
+    // Frameworks
+    react: ["react-19"],
+    next: ["nextjs-15", "react-19"],
+    angular: [],
+    vue: [],
+    django: ["django-drf", "pytest"],
+    flask: ["pytest"],
+    fastapi: ["pytest"],
+    // Languages / runtimes
+    typescript: ["typescript"],
+    python: ["pytest"],
+    go: [],
+    rust: [],
+    elixir: [],
+    // Styling
+    tailwindcss: ["tailwind-4"],
+    // State management
+    zustand: ["zustand-5"],
+    // Validation
+    zod: ["zod-4"],
+    // AI SDKs
+    ai: ["ai-sdk-5"],
+    "@ai-sdk": ["ai-sdk-5"],
+    // Testing
+    vitest: [],
+    jest: [],
+    pytest: ["pytest"],
+    playwright: ["playwright"],
+};
+/**
+ * Additional file-based signals that don't come from package.json dependencies.
+ */
+const FILE_SIGNALS = [
+    {
+        files: ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs"],
+        skills: ["tailwind-4"],
+    },
+    {
+        files: ["playwright.config.ts", "playwright.config.js"],
+        skills: ["playwright"],
+    },
+    { files: ["tsconfig.json"], skills: ["typescript"] },
+    {
+        files: ["pyproject.toml", "setup.py", "requirements.txt"],
+        skills: ["pytest"],
+    },
+    {
+        files: ["next.config.js", "next.config.mjs", "next.config.ts"],
+        skills: ["nextjs-15", "react-19"],
+    },
+];
+/**
+ * Docker-related files that indicate a containerized project.
+ * Used by the init command to suggest Docker zero-downtime deploy scaffolding.
+ */
+export const DOCKER_FILES = [
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+];
+/**
+ * Detect whether the project uses Docker (Dockerfile or compose file present).
+ */
+export async function detectDockerPresence(projectDir) {
+    for (const file of DOCKER_FILES) {
+        if (await fs.pathExists(path.join(projectDir, file))) {
+            return true;
+        }
+    }
+    return false;
+}
+// ── Core Detection ─────────────────────────────────────────────────────────
+/**
+ * Scan a project directory and detect its tech stack + recommended skills.
+ * Reads package.json deps, pyproject.toml, and well-known config files.
+ */
+export async function detectProjectStack(projectDir) {
+    const signals = [];
+    let stack = null;
+    // 1. Check Node.js (package.json)
+    const pkgPath = path.join(projectDir, "package.json");
+    if (await fs.pathExists(pkgPath)) {
+        stack = "node";
+        try {
+            const pkg = (await fs.readJson(pkgPath));
+            const allDeps = {
+                ...(pkg["dependencies"] ?? {}),
+                ...(pkg["devDependencies"] ?? {}),
+            };
+            for (const depName of Object.keys(allDeps)) {
+                const normalizedDep = depName.replace(/^@/, "").split("/")[0];
+                for (const [signal, skills] of Object.entries(SIGNAL_SKILL_MAP)) {
+                    if (normalizedDep === signal ||
+                        depName === signal ||
+                        depName.startsWith(`@${signal}/`)) {
+                        if (skills.length > 0) {
+                            signals.push({ signal: depName, source: "package.json", skills });
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            /* corrupt package.json — skip deps detection */
+        }
+    }
+    // 2. Check Python
+    const pythonFiles = ["pyproject.toml", "requirements.txt", "setup.py"];
+    for (const pyFile of pythonFiles) {
+        if (await fs.pathExists(path.join(projectDir, pyFile))) {
+            if (!stack)
+                stack = "python";
+            signals.push({
+                signal: pyFile,
+                source: "file exists",
+                skills: ["pytest"],
+            });
+            break;
+        }
+    }
+    // 3. Check Python deps from pyproject.toml
+    const pyprojectPath = path.join(projectDir, "pyproject.toml");
+    if (await fs.pathExists(pyprojectPath)) {
+        try {
+            const content = await fs.readFile(pyprojectPath, "utf-8");
+            if (/django/i.test(content)) {
+                signals.push({
+                    signal: "django",
+                    source: "pyproject.toml",
+                    skills: ["django-drf", "pytest"],
+                });
+            }
+            if (/fastapi/i.test(content)) {
+                signals.push({
+                    signal: "fastapi",
+                    source: "pyproject.toml",
+                    skills: ["pytest"],
+                });
+            }
+            if (/playwright/i.test(content)) {
+                signals.push({
+                    signal: "playwright",
+                    source: "pyproject.toml",
+                    skills: ["playwright"],
+                });
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    // 4. Check Go
+    if (await fs.pathExists(path.join(projectDir, "go.mod"))) {
+        if (!stack)
+            stack = "go";
+    }
+    // 5. Check Rust
+    if (await fs.pathExists(path.join(projectDir, "Cargo.toml"))) {
+        if (!stack)
+            stack = "rust";
+    }
+    // 6. Check Elixir
+    if (await fs.pathExists(path.join(projectDir, "mix.exs"))) {
+        if (!stack)
+            stack = "elixir";
+    }
+    // 7. Check Java
+    if ((await fs.pathExists(path.join(projectDir, "build.gradle"))) ||
+        (await fs.pathExists(path.join(projectDir, "build.gradle.kts")))) {
+        if (!stack)
+            stack = "java-gradle";
+    }
+    if (await fs.pathExists(path.join(projectDir, "pom.xml"))) {
+        if (!stack)
+            stack = "java-maven";
+    }
+    // 8. File-based signals
+    for (const { files, skills } of FILE_SIGNALS) {
+        for (const file of files) {
+            if (await fs.pathExists(path.join(projectDir, file))) {
+                signals.push({ signal: file, source: "file exists", skills });
+                break; // Only need one file per signal group
+            }
+        }
+    }
+    // De-duplicate recommended skills
+    const skillSet = new Set();
+    for (const s of signals) {
+        for (const skill of s.skills) {
+            skillSet.add(skill);
+        }
+    }
+    const recommendedSkills = [...skillSet].sort();
+    return { stack, signals, recommendedSkills };
+}
+//# sourceMappingURL=stack-detector.js.map

package/dist/lib/template.d.ts

@@ -1,4 +1,4 @@
-import type { Stack, CIProvider } from '../types/index.js';
+import type { CIProvider, Stack } from "../types/index.js";
 /**
  * Read a template file and replace __VAR_NAME__ placeholders.
  */
@@ -21,4 +21,19 @@ export declare function generateCIWorkflow(stack: Stack, provider: CIProvider):
  * Get the destination path for a CI workflow file within a project.
  */
 export declare function getCIDestination(provider: CIProvider): string;
+/**
+ * Get the template path for the zero-downtime Docker deploy workflow.
+ * Returns null if no template exists for the given provider.
+ */
+export declare function getDeployTemplatePath(provider: CIProvider): string | null;
+/**
+ * Get the destination path for the deploy workflow file within a project.
+ * Returns null if no mapping exists for the given provider.
+ */
+export declare function getDeployDestination(provider: CIProvider): string | null;
+/**
+ * Generate the zero-downtime Docker deploy workflow content.
+ * Replaces __SERVICE_NAME__ with the provided service name.
+ */
+export declare function generateDeployWorkflow(provider: CIProvider, serviceName: string): Promise<string | null>;
 //# sourceMappingURL=template.d.ts.map

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 fs from "fs-extra";
+import path from "path";
+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,19 @@
+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.
+ */
+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,68 @@
+import fs from "fs-extra";
+import path from "path";
+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.
+ */
+export async function loadBuiltinTemplate(name) {
+    for (const [ext, format] of Object.entries(WORKFLOW_EXTENSIONS)) {
+        const templatePath = path.join(WORKFLOW_TEMPLATES_DIR, `${name}${ext}`);
+        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