javi-forge 1.6.0 → 1.7.0

package/dist/lib/workflow/validator.js

@@ -0,0 +1,189 @@
+import path from "node:path";
+import fs from "fs-extra";
+/**
+ * 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 { getDefaultScaffoldTasks } from "./scaffold-tasks.js";
+export { addSubtask, buildTaskTree, createTask, findTask, generateTaskId, type TaskNode, type TaskStatus, } from "./task-id.js";
+export { TaskTracker } from "./task-tracker.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/tasks/index.js

@@ -0,0 +1,4 @@
+export { getDefaultScaffoldTasks } from "./scaffold-tasks.js";
+export { addSubtask, buildTaskTree, createTask, findTask, generateTaskId, } from "./task-id.js";
+export { TaskTracker } from "./task-tracker.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 { addSubtask, createTask } 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,59 @@
+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

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
-export type Stack = 'node' | 'python' | 'go' | 'rust' | 'java-gradle' | 'java-maven' | 'elixir';
-export type CIProvider = 'github' | 'gitlab' | 'woodpecker';
-export type MemoryOption = 'engram' | 'obsidian-brain' | 'memory-simple' | 'none';
+export type Stack = "node" | "python" | "go" | "rust" | "java-gradle" | "java-maven" | "elixir";
+export type CIProvider = "github" | "gitlab" | "woodpecker";
+export type MemoryOption = "engram" | "obsidian-brain" | "memory-simple" | "none";
+export type HookProfile = "minimal" | "standard" | "strict";
 export interface InitOptions {
     projectName: string;
     projectDir: string;
@@ -13,6 +14,14 @@ export interface InitOptions {
     mock: boolean;
     contextDir: boolean;
     claudeMd: boolean;
+    securityHooks: boolean;
+    hookProfile: HookProfile;
+    codeGraph: boolean;
+    dockerDeploy: boolean;
+    /** Service name for docker rollout (default: 'app') */
+    dockerServiceName: string;
+    /** Scaffold local AI dev stack (Ollama + optional services) */
+    localAi: boolean;
     dryRun: boolean;
 }
 export interface StackClaudeMdEntry {
@@ -28,7 +37,7 @@ export interface StackContextEntry {
 export interface InitStep {
     id: string;
     label: string;
-    status: 'pending' | 'running' | 'done' | 'error' | 'skipped';
+    status: "pending" | "running" | "done" | "error" | "skipped";
     detail?: string;
 }
 export interface StackDetection {
@@ -48,7 +57,7 @@ export interface ForgeManifest {
 }
 export interface DoctorCheck {
     label: string;
-    status: 'ok' | 'fail' | 'skip';
+    status: "ok" | "fail" | "skip";
     detail?: string;
 }
 export interface DoctorSection {
@@ -58,6 +67,13 @@ export interface DoctorSection {
 export interface DoctorResult {
     sections: DoctorSection[];
 }
+export type TddPipelineMode = "strict" | "warn";
+export interface TddPipelineResult {
+    installed: string[];
+    skipped: string[];
+    errors: string[];
+    mode: TddPipelineMode;
+}
 export interface PluginManifest {
     name: string;
     version: string;
@@ -103,6 +119,21 @@ export interface PluginSyncResult {
     added: string[];
     removed: string[];
     unchanged: string[];
+    wired: AutoWireEntry[];
+    unwired: AutoWireEntry[];
+}
+export type AutoWireTarget = "claude-md" | "settings-json";
+export interface AutoWireEntry {
+    plugin: string;
+    target: AutoWireTarget;
+    capability: string;
+    /** e.g. skill path or hook command */
+    value: string;
+}
+export interface AutoWireResult {
+    wired: AutoWireEntry[];
+    unwired: AutoWireEntry[];
+    errors: string[];
 }
 export interface AgentSkillEntry {
     name: string;
@@ -118,6 +149,22 @@ export interface AgentSkillsManifest {
         forge_source?: string;
     };
 }
+/**
+ * Aggregated skills.json that merges multiple plugins into a single
+ * Agent Skills spec manifest. Used by `npx skills add` and 40+ AI agents.
+ */
+export interface AggregatedSkillsManifest {
+    name: string;
+    version: string;
+    description: string;
+    skills: AgentSkillEntry[];
+    sources: AgentSkillSource[];
+}
+export interface AgentSkillSource {
+    plugin: string;
+    version: string;
+    repository?: string;
+}
 export interface CodexTomlEntry {
     name: string;
     model: string;
@@ -128,7 +175,7 @@ export interface CodexExportResult {
     files?: string[];
     error?: string;
 }
-export type SecuritySeverity = 'critical' | 'high' | 'moderate' | 'low' | 'info';
+export type SecuritySeverity = "critical" | "high" | "moderate" | "low" | "info";
 export interface SecurityFinding {
     id: string;
     severity: SecuritySeverity;
@@ -139,16 +186,33 @@ export interface SecurityFinding {
 export interface SecurityBaseline {
     version: string;
     createdAt: string;
+    updatedAt?: string;
     stack: string;
     buildTool: string;
     findings: SecurityFinding[];
     findingKeys: string[];
+    allowlist?: string[];
+}
+export interface SecurityCheckOptions {
+    minSeverity?: SecuritySeverity;
+    staleDays?: number;
 }
 export interface SecurityCheckResult {
     baseline: SecurityBaseline;
     current: SecurityFinding[];
     regressions: SecurityFinding[];
     resolved: SecurityFinding[];
+    filteredRegressions: SecurityFinding[];
+    staleWarning?: string;
+    summary: SecuritySummary;
+}
+export interface SecuritySummary {
+    total: number;
+    bySeverity: Record<SecuritySeverity, number>;
+    regressionCount: number;
+    resolvedCount: number;
+    filteredCount: number;
+    baselineAge: number;
 }
 export interface SkillCriticalRule {
     skillName: string;
@@ -157,22 +221,37 @@ export interface SkillCriticalRule {
     /** Normalized rule for comparison (lowercase, trimmed) */
     normalized: string;
 }
+export type ConflictKind = "regex-pair" | "directive-clash";
 export interface SkillConflict {
     ruleA: SkillCriticalRule;
     ruleB: SkillCriticalRule;
     reason: string;
+    /** How the conflict was detected */
+    kind: ConflictKind;
 }
 export interface SkillBudgetEntry {
     skillName: string;
     skillPath: string;
     tokens: number;
 }
+export interface SkillBudgetSuggestion {
+    /** Skills to disable in this suggestion set */
+    disableSkills: string[];
+    /** Total tokens freed by disabling these skills */
+    tokensSaved: number;
+    /** Remaining tokens after disabling */
+    remainingTokens: number;
+    /** Whether this set brings usage under budget */
+    meetsbudget: boolean;
+}
 export interface SkillBudgetResult {
     entries: SkillBudgetEntry[];
     totalTokens: number;
     budget: number;
     overBudget: boolean;
     suggestions: string[];
+    /** Structured optimization sets: minimal combinations to meet budget */
+    optimizations: SkillBudgetSuggestion[];
 }
 export interface SkillDuplicate {
     skillA: string;
@@ -186,16 +265,26 @@ export interface SkillDoctorResult {
     budget: SkillBudgetResult;
     duplicates: SkillDuplicate[];
 }
+export type SkillGrade = "A" | "B" | "C" | "D" | "F";
 export interface SkillScore {
     skillName: string;
     completeness: number;
     clarity: number;
     testability: number;
     tokenEfficiency: number;
+    safety: number;
+    agentReadiness: number;
     overall: number;
+    grade: SkillGrade;
     threshold: number;
     passing: boolean;
 }
+export interface SkillRegistryGateResult {
+    skillName: string;
+    score: SkillScore;
+    accepted: boolean;
+    reason?: string;
+}
 export interface SkillBenchmarkCheck {
     name: string;
     passed: boolean;
@@ -206,4 +295,43 @@ export interface SkillBenchmarkResult {
     checks: SkillBenchmarkCheck[];
     passRate: number;
 }
+declare const WORKFLOW_FORMAT: {
+    readonly DOT: "dot";
+    readonly MERMAID: "mermaid";
+};
+export type WorkflowFormat = (typeof WORKFLOW_FORMAT)[keyof typeof WORKFLOW_FORMAT];
+declare const WORKFLOW_VALIDATION_STATUS: {
+    readonly PASS: "pass";
+    readonly FAIL: "fail";
+    readonly SKIP: "skip";
+};
+export type WorkflowValidationStatus = (typeof WORKFLOW_VALIDATION_STATUS)[keyof typeof WORKFLOW_VALIDATION_STATUS];
+export { WORKFLOW_FORMAT, WORKFLOW_VALIDATION_STATUS };
+export interface WorkflowNode {
+    id: string;
+    label: string;
+    check?: string;
+    metadata?: Record<string, string>;
+}
+export interface WorkflowEdge {
+    from: string;
+    to: string;
+    label?: string;
+}
+export interface WorkflowGraph {
+    name: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    format: WorkflowFormat;
+}
+export interface WorkflowValidationResult {
+    node: string;
+    status: WorkflowValidationStatus;
+    detail?: string;
+}
+export interface WorkflowDiscoveryEntry {
+    name: string;
+    path: string;
+    format: WorkflowFormat;
+}
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -1,2 +1,12 @@
-export {};
+// ── Workflow Graphs ─────────────────────────────────────────────────────────
+const WORKFLOW_FORMAT = {
+    DOT: "dot",
+    MERMAID: "mermaid",
+};
+const WORKFLOW_VALIDATION_STATUS = {
+    PASS: "pass",
+    FAIL: "fail",
+    SKIP: "skip",
+};
+export { WORKFLOW_FORMAT, WORKFLOW_VALIDATION_STATUS };
 //# sourceMappingURL=index.js.map

package/dist/ui/AnalyzeUI.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import React from "react";
 interface Props {
     dryRun: boolean;
 }