javi-forge 1.5.0 → 1.6.1

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

package/dist/lib/workflow/validator.js

@@ -0,0 +1,189 @@
+import fs from "fs-extra";
+import path from "path";
+/**
+ * Built-in check functions that map node `check` attributes to project validations.
+ * Each check receives the project directory and returns { pass, detail }.
+ */
+const BUILTIN_CHECKS = {
+    "has-linter": async (dir) => {
+        const eslintConfig = [
+            ".eslintrc",
+            ".eslintrc.js",
+            ".eslintrc.json",
+            ".eslintrc.yml",
+            "eslint.config.js",
+            "eslint.config.mjs",
+            "eslint.config.ts",
+        ];
+        const ruffConfig = ["ruff.toml", ".ruff.toml"];
+        const golangci = [".golangci.yml", ".golangci.yaml"];
+        const configs = [...eslintConfig, ...ruffConfig, ...golangci];
+        for (const cfg of configs) {
+            if (await fs.pathExists(path.join(dir, cfg))) {
+                return { pass: true, detail: `Found ${cfg}` };
+            }
+        }
+        // Check package.json for eslint dependency
+        const pkgPath = path.join(dir, "package.json");
+        if (await fs.pathExists(pkgPath)) {
+            try {
+                const pkg = (await fs.readJson(pkgPath));
+                const deps = {
+                    ...pkg["devDependencies"],
+                    ...pkg["dependencies"],
+                };
+                if (deps["eslint"] || deps["biome"] || deps["oxlint"]) {
+                    return { pass: true, detail: "Linter found in package.json" };
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        return { pass: false, detail: "No linter configuration found" };
+    },
+    "has-tests": async (dir) => {
+        const testPatterns = [
+            "src/**/*.test.ts",
+            "src/**/*.test.tsx",
+            "src/**/*.spec.ts",
+            "tests/",
+            "test/",
+            "__tests__/",
+            "src/**/*_test.go",
+            "*_test.go",
+            "tests/test_*.py",
+            "test_*.py",
+        ];
+        for (const pattern of testPatterns) {
+            const target = path.join(dir, pattern.split("*")[0] ?? "");
+            if (await fs.pathExists(target)) {
+                return {
+                    pass: true,
+                    detail: `Found test path: ${pattern.split("*")[0]}`,
+                };
+            }
+        }
+        return { pass: false, detail: "No test files or directories found" };
+    },
+    "has-ci": async (dir) => {
+        const ciPaths = [
+            ".github/workflows",
+            ".gitlab-ci.yml",
+            ".woodpecker.yml",
+            ".woodpecker/",
+            "Jenkinsfile",
+            ".circleci/config.yml",
+        ];
+        for (const p of ciPaths) {
+            if (await fs.pathExists(path.join(dir, p))) {
+                return { pass: true, detail: `Found ${p}` };
+            }
+        }
+        return { pass: false, detail: "No CI configuration found" };
+    },
+    "has-dockerfile": async (dir) => {
+        const dockerfiles = [
+            "Dockerfile",
+            "docker-compose.yml",
+            "docker-compose.yaml",
+            "compose.yml",
+            "compose.yaml",
+        ];
+        for (const f of dockerfiles) {
+            if (await fs.pathExists(path.join(dir, f))) {
+                return { pass: true, detail: `Found ${f}` };
+            }
+        }
+        return { pass: false, detail: "No Dockerfile or compose file found" };
+    },
+    "has-security": async (dir) => {
+        const secPaths = [
+            ".javi-forge/security-baseline.json",
+            "semgrep.yml",
+            ".semgrep.yml",
+            ".snyk",
+        ];
+        for (const p of secPaths) {
+            if (await fs.pathExists(path.join(dir, p))) {
+                return { pass: true, detail: `Found ${p}` };
+            }
+        }
+        return { pass: false, detail: "No security scanning configuration found" };
+    },
+    "has-docs": async (dir) => {
+        const docPaths = ["docs/", "README.md", "doc/", "documentation/"];
+        for (const p of docPaths) {
+            if (await fs.pathExists(path.join(dir, p))) {
+                return { pass: true, detail: `Found ${p}` };
+            }
+        }
+        return { pass: false, detail: "No documentation found" };
+    },
+    "has-changelog": async (dir) => {
+        const files = ["CHANGELOG.md", "CHANGES.md", "HISTORY.md"];
+        for (const f of files) {
+            if (await fs.pathExists(path.join(dir, f))) {
+                return { pass: true, detail: `Found ${f}` };
+            }
+        }
+        return { pass: false, detail: "No changelog found" };
+    },
+    "has-license": async (dir) => {
+        const files = ["LICENSE", "LICENSE.md", "LICENSE.txt", "LICENCE"];
+        for (const f of files) {
+            if (await fs.pathExists(path.join(dir, f))) {
+                return { pass: true, detail: `Found ${f}` };
+            }
+        }
+        return { pass: false, detail: "No license file found" };
+    },
+};
+/**
+ * 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 async function validateWorkflow(graph, projectDir) {
+    const results = [];
+    for (const node of graph.nodes) {
+        if (!node.check) {
+            results.push({
+                node: node.id,
+                status: "skip",
+                detail: "No check defined",
+            });
+            continue;
+        }
+        const checkFn = BUILTIN_CHECKS[node.check];
+        if (!checkFn) {
+            results.push({
+                node: node.id,
+                status: "skip",
+                detail: `Unknown check: ${node.check}`,
+            });
+            continue;
+        }
+        try {
+            const { pass, detail } = await checkFn(projectDir);
+            results.push({
+                node: node.id,
+                status: pass ? "pass" : "fail",
+                detail,
+            });
+        }
+        catch (e) {
+            results.push({
+                node: node.id,
+                status: "fail",
+                detail: `Check error: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
+    }
+    return results;
+}
+/** Expose check names for testing and documentation */
+export function getAvailableChecks() {
+    return Object.keys(BUILTIN_CHECKS);
+}
+//# sourceMappingURL=validator.js.map

package/dist/tasks/index.d.ts

@@ -0,0 +1,4 @@
+export { generateTaskId, createTask, addSubtask, buildTaskTree, findTask, type TaskNode, type TaskStatus, } from './task-id.js';
+export { TaskTracker } from './task-tracker.js';
+export { getDefaultScaffoldTasks } from './scaffold-tasks.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tasks/index.js

@@ -0,0 +1,4 @@
+export { generateTaskId, createTask, addSubtask, buildTaskTree, findTask, } from './task-id.js';
+export { TaskTracker } from './task-tracker.js';
+export { getDefaultScaffoldTasks } from './scaffold-tasks.js';
+//# sourceMappingURL=index.js.map

package/dist/tasks/scaffold-tasks.d.ts

@@ -0,0 +1,3 @@
+import { type TaskNode } from './task-id.js';
+export declare function getDefaultScaffoldTasks(): TaskNode[];
+//# sourceMappingURL=scaffold-tasks.d.ts.map

package/dist/tasks/scaffold-tasks.js

@@ -0,0 +1,14 @@
+import { createTask, addSubtask } from './task-id.js';
+export function getDefaultScaffoldTasks() {
+    const setup = createTask({ title: 'Setup project structure' });
+    addSubtask(setup, { title: 'Initialize git repository' });
+    addSubtask(setup, { title: 'Configure TypeScript' });
+    addSubtask(setup, { title: 'Setup linter and formatter' });
+    const testing = createTask({ title: 'Setup testing' });
+    addSubtask(testing, { title: 'Configure test runner' });
+    addSubtask(testing, { title: 'Write initial tests' });
+    const ci = createTask({ title: 'Create CI pipeline' });
+    const deploy = createTask({ title: 'Deploy to production' });
+    return [setup, testing, ci, deploy];
+}
+//# sourceMappingURL=scaffold-tasks.js.map

package/dist/tasks/task-id.d.ts

@@ -0,0 +1,30 @@
+export type TaskStatus = 'todo' | 'in-progress' | 'done';
+export type TaskNode = {
+    id: string;
+    title: string;
+    description?: string;
+    status: TaskStatus;
+    parentId?: string;
+    children: TaskNode[];
+    dependencies: string[];
+    assignee?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function generateTaskId(content: {
+    title: string;
+    description?: string;
+    parentId?: string;
+}): string;
+export declare function createTask(params: {
+    title: string;
+    description?: string;
+    parentId?: string;
+}): TaskNode;
+export declare function addSubtask(parent: TaskNode, childParams: {
+    title: string;
+    description?: string;
+}): TaskNode;
+export declare function buildTaskTree(flat: TaskNode[]): TaskNode[];
+export declare function findTask(tree: TaskNode[], id: string): TaskNode | undefined;
+//# sourceMappingURL=task-id.d.ts.map

package/dist/tasks/task-id.js

@@ -0,0 +1,55 @@
+import { createHash } from 'node:crypto';
+export function generateTaskId(content) {
+    const input = [content.title, content.description ?? '', content.parentId ?? ''].join('|');
+    return createHash('sha256').update(input).digest('hex').slice(0, 7);
+}
+export function createTask(params) {
+    const now = new Date().toISOString();
+    return {
+        id: generateTaskId(params),
+        title: params.title,
+        description: params.description,
+        status: 'todo',
+        parentId: params.parentId,
+        children: [],
+        dependencies: [],
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export function addSubtask(parent, childParams) {
+    const child = createTask({
+        title: childParams.title,
+        description: childParams.description,
+        parentId: parent.id,
+    });
+    parent.children.push(child);
+    return child;
+}
+export function buildTaskTree(flat) {
+    const map = new Map();
+    for (const node of flat) {
+        map.set(node.id, { ...node, children: [] });
+    }
+    const roots = [];
+    for (const node of map.values()) {
+        if (node.parentId && map.has(node.parentId)) {
+            map.get(node.parentId).children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    return roots;
+}
+export function findTask(tree, id) {
+    for (const node of tree) {
+        if (node.id === id)
+            return node;
+        const found = findTask(node.children, id);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+//# sourceMappingURL=task-id.js.map

package/dist/tasks/task-tracker.d.ts

@@ -0,0 +1,15 @@
+import { type TaskNode, type TaskStatus } from './task-id.js';
+export declare class TaskTracker {
+    private tasks;
+    addTask(title: string, description?: string, parentId?: string): TaskNode;
+    updateStatus(id: string, status: TaskStatus): void;
+    assignTask(id: string, assignee: string): void;
+    addDependency(taskId: string, dependsOnId: string): void;
+    getBlockedTasks(): TaskNode[];
+    getReadyTasks(): TaskNode[];
+    toMarkdown(): string;
+    toJSON(): string;
+    static fromJSON(json: string): TaskTracker;
+    private findFlat;
+}
+//# sourceMappingURL=task-tracker.d.ts.map

package/dist/tasks/task-tracker.js

@@ -0,0 +1,81 @@
+import { createTask } from './task-id.js';
+export class TaskTracker {
+    tasks = [];
+    addTask(title, description, parentId) {
+        const task = createTask({ title, description, parentId });
+        if (parentId) {
+            const parent = this.findFlat(parentId);
+            if (parent) {
+                parent.children.push(task);
+            }
+        }
+        this.tasks.push(task);
+        return task;
+    }
+    updateStatus(id, status) {
+        const task = this.findFlat(id);
+        if (!task)
+            throw new Error(`Task "${id}" not found`);
+        task.status = status;
+        task.updatedAt = new Date().toISOString();
+    }
+    assignTask(id, assignee) {
+        const task = this.findFlat(id);
+        if (!task)
+            throw new Error(`Task "${id}" not found`);
+        task.assignee = assignee;
+        task.updatedAt = new Date().toISOString();
+    }
+    addDependency(taskId, dependsOnId) {
+        const task = this.findFlat(taskId);
+        if (!task)
+            throw new Error(`Task "${taskId}" not found`);
+        const dep = this.findFlat(dependsOnId);
+        if (!dep)
+            throw new Error(`Dependency "${dependsOnId}" not found`);
+        task.dependencies.push(dependsOnId);
+    }
+    getBlockedTasks() {
+        return this.tasks.filter((t) => {
+            if (t.dependencies.length === 0)
+                return false;
+            return t.dependencies.some((depId) => {
+                const dep = this.findFlat(depId);
+                return !dep || dep.status !== 'done';
+            });
+        });
+    }
+    getReadyTasks() {
+        return this.tasks.filter((t) => {
+            if (t.status !== 'todo')
+                return false;
+            if (t.dependencies.length === 0)
+                return true;
+            return t.dependencies.every((depId) => {
+                const dep = this.findFlat(depId);
+                return dep?.status === 'done';
+            });
+        });
+    }
+    toMarkdown() {
+        return this.tasks
+            .map((t) => {
+            const check = t.status === 'done' ? 'x' : ' ';
+            const assignee = t.assignee ? ` @${t.assignee}` : '';
+            return `- [${check}] ${t.title}${assignee}`;
+        })
+            .join('\n');
+    }
+    toJSON() {
+        return JSON.stringify(this.tasks);
+    }
+    static fromJSON(json) {
+        const tracker = new TaskTracker();
+        tracker.tasks = JSON.parse(json);
+        return tracker;
+    }
+    findFlat(id) {
+        return this.tasks.find((t) => t.id === id);
+    }
+}
+//# sourceMappingURL=task-tracker.js.map