@octaviaflow/flow-rules 0.1.0

package/dist/rules/nodeConfigStatus.js

@@ -0,0 +1,217 @@
+/**
+ * Node Config Status Utility
+ *
+ * Determines the status indicator for a workflow node based on
+ * how completely its configuration has been filled out relative
+ * to the action definition's input schema.
+ *
+ * Handles:
+ * - Nested config keys (e.g., "visualConfig.tables" → config.visualConfig.tables)
+ * - Conditional required fields (only enforced when their condition is met)
+ * - Default values (count as filled if present)
+ */
+import { getActionById } from '../catalog/index';
+/**
+ * Action IDs whose nodes should not display a config status indicator.
+ */
+const HIDDEN_STATUS_ACTIONS = new Set(['console_log']);
+/**
+ * Check if a config value is considered "filled" (non-empty).
+ */
+function isFieldFilled(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value === 'string')
+        return value.trim().length > 0;
+    if (typeof value === 'number')
+        return true;
+    if (typeof value === 'boolean')
+        return true;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length > 0;
+    return false;
+}
+/**
+ * Some actions persist part of their required configuration out-of-band rather
+ * than in `node.config`. The Connector Trigger is the canonical case: its
+ * watched entity/operation events are registered in the backend webhook
+ * subscription store (keyed by flow + connector), and the node config only
+ * carries a `subscribed` / `eventCount` summary of that subscription. For such
+ * fields, that summary — not a literal `config.<key>` value — is the source of
+ * truth for whether the field is configured.
+ *
+ * Returns true when the given required field should be treated as satisfied by
+ * an out-of-band signal, so it is not falsely reported as missing. Removing a
+ * subscription resets the summary (eventCount → 0), so an unconfigured trigger
+ * still fails validation as expected.
+ */
+function isSatisfiedOutOfBand(actionId, fieldKey, config) {
+    if (actionId === 'connector_trigger' && fieldKey === 'events') {
+        return Number(config.eventCount ?? 0) > 0;
+    }
+    // Messaging actions: the body can be plain text OR Block Kit, and the config
+    // panel stores the text under `text` while the action definition names the
+    // field `message` (its legacy alias). Without this, a Slack step that sends
+    // perfectly well reported "Missing required settings: message" — and since
+    // Flow Doctor errors BLOCK ACTIVATION, such a flow could run manually but
+    // never be scheduled.
+    if (MESSAGE_BODY_ACTIONS.has(actionId) && (fieldKey === 'message' || fieldKey === 'text')) {
+        const text = config.text ?? config.message;
+        if (typeof text === 'string' && text.trim().length > 0)
+            return true;
+        return Array.isArray(config.blocks) && config.blocks.length > 0;
+    }
+    return false;
+}
+/** Actions whose body may be text or blocks — see `isSatisfiedOutOfBand`. */
+const MESSAGE_BODY_ACTIONS = new Set([
+    'slack_message',
+    'teams_message',
+    'google_chat',
+]);
+/**
+ * Resolve a nested key path (e.g., "visualConfig.tables") from a config object.
+ */
+function getNestedValue(config, keyPath) {
+    const parts = keyPath.split('.');
+    let current = config;
+    for (const part of parts) {
+        if (current === null || current === undefined || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Evaluate whether a conditional field should be active (visible/required)
+ * based on the current config values.
+ *
+ * A field with conditionals is only required when at least one "show" or
+ * "require" condition is satisfied.
+ */
+function isFieldActive(field, config) {
+    if (!field.conditional || field.conditional.length === 0) {
+        return true;
+    }
+    // Check if any "show" or "require" condition is met
+    return field.conditional.some((cond) => {
+        if (cond.action !== 'show' && cond.action !== 'require') {
+            return false;
+        }
+        const fieldValue = getNestedValue(config, cond.field);
+        switch (cond.operator) {
+            case '==': return fieldValue === cond.value;
+            case '!=': return fieldValue !== cond.value;
+            case '>': return fieldValue > cond.value;
+            case '<': return fieldValue < cond.value;
+            case '>=': return fieldValue >= cond.value;
+            case '<=': return fieldValue <= cond.value;
+            case 'in': return Array.isArray(cond.value) && cond.value.includes(fieldValue);
+            case 'not_in': return Array.isArray(cond.value) && !cond.value.includes(fieldValue);
+            case 'contains':
+                return typeof fieldValue === 'string' && fieldValue.includes(cond.value);
+            default: return false;
+        }
+    });
+}
+/**
+ * Determine the config completeness status of a workflow node.
+ *
+ * Status logic:
+ * - "valid"        → All active required fields are filled (or no required fields exist)
+ * - "warning"      → Some active required fields are missing, but at least one field has data
+ * - "error"        → Has active required fields and none are filled, config is empty
+ * - "unconfigured" → Action definition not found (unknown action type)
+ */
+export function getNodeConfigStatus(node) {
+    // Some actions should never show a status indicator
+    if (HIDDEN_STATUS_ACTIONS.has(node.actionDefinitionId)) {
+        return {
+            status: 'hidden',
+            requiredTotal: 0,
+            requiredFilled: 0,
+            optionalTotal: 0,
+            optionalFilled: 0,
+            missingRequired: [],
+            filledOptional: [],
+        };
+    }
+    const definition = getActionById(node.actionDefinitionId);
+    if (!definition) {
+        return {
+            status: 'unconfigured',
+            requiredTotal: 0,
+            requiredFilled: 0,
+            optionalTotal: 0,
+            optionalFilled: 0,
+            missingRequired: [],
+            filledOptional: [],
+        };
+    }
+    const fields = definition.inputSchema?.fields ?? [];
+    const config = node.config ?? {};
+    // Filter to only active (visible) fields based on conditionals
+    const activeFields = fields.filter(f => !f.hidden && isFieldActive(f, config));
+    const requiredFields = activeFields.filter(f => f.validation?.required);
+    const optionalFields = activeFields.filter(f => !f.validation?.required);
+    const missingRequired = [];
+    let requiredFilled = 0;
+    for (const field of requiredFields) {
+        const value = getNestedValue(config, field.key);
+        if (isFieldFilled(value)) {
+            requiredFilled++;
+        }
+        else if (isFieldFilled(field.defaultValue)) {
+            // Field has a defaultValue — count as filled
+            requiredFilled++;
+        }
+        else if (isSatisfiedOutOfBand(node.actionDefinitionId, field.key, config)) {
+            // Field is configured out-of-band (e.g. Connector Trigger events live in
+            // the backend subscription store, mirrored here as an eventCount summary)
+            requiredFilled++;
+        }
+        else {
+            missingRequired.push(field.key);
+        }
+    }
+    const filledOptional = [];
+    let optionalFilled = 0;
+    for (const field of optionalFields) {
+        const value = getNestedValue(config, field.key);
+        if (isFieldFilled(value)) {
+            optionalFilled++;
+            filledOptional.push(field.key);
+        }
+    }
+    const requiredTotal = requiredFields.length;
+    const optionalTotal = optionalFields.length;
+    let status;
+    if (requiredTotal === 0) {
+        // No required fields → always valid (e.g., manual_trigger)
+        status = 'valid';
+    }
+    else if (missingRequired.length === 0) {
+        // All required fields filled
+        status = 'valid';
+    }
+    else if (requiredFilled > 0 || optionalFilled > 0) {
+        // Partially configured — some required fields still missing
+        status = 'warning';
+    }
+    else {
+        // Nothing configured at all but has required fields
+        status = 'error';
+    }
+    return {
+        status,
+        requiredTotal,
+        requiredFilled,
+        optionalTotal,
+        optionalFilled,
+        missingRequired,
+        filledOptional,
+    };
+}

package/dist/rules/workflowValidator.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Workflow Validation System — rules engine v2 (DEV-220)
+ *
+ * Validates nodes, edges, and overall workflow structure on every
+ * STRUCTURAL canvas change (WorkflowContext applies it selectively —
+ * selection/viewport/drag churn never re-runs it). Results feed:
+ *   - the FlowToolbarIssues indicator (badge + hover overlay)
+ *   - per-node error/warning badges (flowAdapter → DS BaseNode status)
+ *   - activation gating (useFlowLifecycle: errors block Activate;
+ *     Save is NEVER blocked; warnings never block anything)
+ *
+ * Severity model (ADR-flow-pause-and-rules-v2):
+ *   error   → the flow cannot work as built (missing trigger, broken edge,
+ *             cycle, missing required config). Blocks Activate.
+ *   warning → it will run, but probably not the way the user thinks
+ *             ("won't run" orphans, multi-flow canvas, duplicate edges).
+ */
+import { WorkflowNode, WorkflowEdge } from '../catalog/workflow';
+export interface ValidationError {
+    id: string;
+    type: 'node' | 'edge' | 'workflow';
+    severity: 'error' | 'warning';
+    message: string;
+    nodeId?: string;
+    edgeId?: string;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+}
+/**
+ * Validate a single node.
+ */
+export declare function validateNode(node: WorkflowNode, allNodes: WorkflowNode[], allEdges: WorkflowEdge[]): ValidationError[];
+/**
+ * Validate a single edge. `allEdges` powers real duplicate detection —
+ * only the SECOND-and-later instance of a duplicate is flagged, so one
+ * duplicate pair yields one warning, not two.
+ */
+export declare function validateEdge(edge: WorkflowEdge, allNodes: WorkflowNode[], allEdges?: WorkflowEdge[]): ValidationError[];
+/**
+ * Validate entire workflow.
+ */
+export declare function validateWorkflow(nodes: WorkflowNode[], edges: WorkflowEdge[]): ValidationResult;
+/**
+ * Get validation status for a specific node
+ */
+export declare function getNodeValidationStatus(nodeId: string, validationResult: ValidationResult): 'valid' | 'error' | 'warning';
+/**
+ * Get validation status for a specific edge
+ */
+export declare function getEdgeValidationStatus(edgeId: string, validationResult: ValidationResult): 'valid' | 'error' | 'warning';

package/dist/rules/workflowValidator.js

@@ -0,0 +1,358 @@
+/**
+ * Workflow Validation System — rules engine v2 (DEV-220)
+ *
+ * Validates nodes, edges, and overall workflow structure on every
+ * STRUCTURAL canvas change (WorkflowContext applies it selectively —
+ * selection/viewport/drag churn never re-runs it). Results feed:
+ *   - the FlowToolbarIssues indicator (badge + hover overlay)
+ *   - per-node error/warning badges (flowAdapter → DS BaseNode status)
+ *   - activation gating (useFlowLifecycle: errors block Activate;
+ *     Save is NEVER blocked; warnings never block anything)
+ *
+ * Severity model (ADR-flow-pause-and-rules-v2):
+ *   error   → the flow cannot work as built (missing trigger, broken edge,
+ *             cycle, missing required config). Blocks Activate.
+ *   warning → it will run, but probably not the way the user thinks
+ *             ("won't run" orphans, multi-flow canvas, duplicate edges).
+ */
+import { getNodeConfigStatus } from './nodeConfigStatus';
+const nodeName = (n) => n.label || n.id;
+/**
+ * Validate a single node.
+ */
+export function validateNode(node, allNodes, allEdges) {
+    const errors = [];
+    // Check required fields
+    if (!node.id || node.id.trim().length === 0) {
+        errors.push({
+            id: `node-${node.id}-id`,
+            type: 'node',
+            severity: 'error',
+            message: 'Node ID is required',
+            nodeId: node.id,
+        });
+    }
+    if (!node.label || node.label.trim().length === 0) {
+        errors.push({
+            id: `node-${node.id}-label`,
+            type: 'node',
+            severity: 'error',
+            message: 'Node label is required',
+            nodeId: node.id,
+        });
+    }
+    // Config completeness — computed LIVE from the action definition's
+    // required fields (the persisted `isValid` flag goes stale between the
+    // loader and the current edit). Missing required fields are an ERROR and
+    // are named so the issues list is actionable.
+    const cfg = getNodeConfigStatus(node);
+    if (cfg.missingRequired.length > 0) {
+        const fields = cfg.missingRequired.slice(0, 4).join(', ');
+        const more = cfg.missingRequired.length > 4 ? ` +${cfg.missingRequired.length - 4} more` : '';
+        errors.push({
+            id: `node-${node.id}-config`,
+            type: 'node',
+            severity: 'error',
+            // Actionable for END USERS: name the exact fields AND the fix action.
+            message: `Missing required settings: ${fields}${more}. Open the step and fill them in.`,
+            nodeId: node.id,
+        });
+    }
+    // Trigger nodes must have at least one outgoing connection to be useful
+    const hasOutput = allEdges.some(edge => edge.source === node.id);
+    if (!hasOutput && node.type === 'trigger') {
+        errors.push({
+            id: `node-${node.id}-output`,
+            type: 'node',
+            severity: 'warning',
+            message: `Trigger "${nodeName(node)}" has no outgoing connections`,
+            nodeId: node.id,
+        });
+    }
+    return errors;
+}
+/**
+ * Validate a single edge. `allEdges` powers real duplicate detection —
+ * only the SECOND-and-later instance of a duplicate is flagged, so one
+ * duplicate pair yields one warning, not two.
+ */
+export function validateEdge(edge, allNodes, allEdges = []) {
+    const errors = [];
+    // Check if source node exists
+    const sourceNode = allNodes.find(n => n.id === edge.source);
+    if (!sourceNode) {
+        errors.push({
+            id: `edge-${edge.id}-source`,
+            type: 'edge',
+            severity: 'error',
+            message: `Source node "${edge.source}" does not exist`,
+            edgeId: edge.id,
+        });
+    }
+    // Check if target node exists
+    const targetNode = allNodes.find(n => n.id === edge.target);
+    if (!targetNode) {
+        errors.push({
+            id: `edge-${edge.id}-target`,
+            type: 'edge',
+            severity: 'error',
+            message: `Target node "${edge.target}" does not exist`,
+            edgeId: edge.id,
+        });
+    }
+    // Check for self-loops
+    if (edge.source === edge.target) {
+        errors.push({
+            id: `edge-${edge.id}-loop`,
+            type: 'edge',
+            severity: 'error',
+            message: 'Nodes cannot connect to themselves',
+            edgeId: edge.id,
+        });
+    }
+    // Duplicate edges: same source/target (and same handles when present).
+    // (v1 shipped with `duplicateCount = 1` hard-coded — the rule could
+    // never fire. DEV-220 fixed it.)
+    const key = (e) => `${e.source}|${e.sourceHandle ?? ''}→${e.target}|${e.targetHandle ?? ''}`;
+    const myKey = key(edge);
+    const firstIndex = allEdges.findIndex(e => key(e) === myKey);
+    const myIndex = allEdges.findIndex(e => e.id === edge.id);
+    if (firstIndex !== -1 && myIndex > firstIndex) {
+        errors.push({
+            id: `edge-${edge.id}-duplicate`,
+            type: 'edge',
+            severity: 'warning',
+            message: `Duplicate connection between "${sourceNode ? nodeName(sourceNode) : edge.source}" and "${targetNode ? nodeName(targetNode) : edge.target}"`,
+            edgeId: edge.id,
+        });
+    }
+    return errors;
+}
+/**
+ * Validate entire workflow.
+ */
+export function validateWorkflow(nodes, edges) {
+    const allErrors = [];
+    // Check for at least one trigger node
+    const hasTrigger = nodes.some(node => node.type === 'trigger');
+    if (!hasTrigger) {
+        allErrors.push({
+            id: 'workflow-trigger',
+            type: 'workflow',
+            severity: 'error',
+            message: 'Workflow must have at least one trigger node',
+        });
+    }
+    // Check for at least one action node
+    const hasAction = nodes.some(node => node.type === 'action');
+    if (!hasAction && nodes.length > 0) {
+        allErrors.push({
+            id: 'workflow-action',
+            type: 'workflow',
+            severity: 'warning',
+            message: 'Workflow should have at least one action node',
+        });
+    }
+    // Validate individual nodes
+    nodes.forEach(node => {
+        const nodeErrors = validateNode(node, nodes, edges);
+        allErrors.push(...nodeErrors);
+    });
+    // Validate individual edges
+    edges.forEach(edge => {
+        const edgeErrors = validateEdge(edge, nodes, edges);
+        allErrors.push(...edgeErrors);
+    });
+    // ── Cycle detection (DEV-220) ──
+    // Kahn's algorithm over the execution edges; anything the topological
+    // sort can't reach sits on (or strictly behind) a cycle. The Engine
+    // APPENDS such steps to the order silently, so a cycle produces
+    // undefined ordering at run time — an error here, not a curiosity.
+    if (nodes.length > 0 && edges.length > 0) {
+        const inDegree = new Map(nodes.map(n => [n.id, 0]));
+        const out = new Map();
+        for (const e of edges) {
+            if (e.source === e.target)
+                continue; // self-loops flagged per-edge already
+            if (!inDegree.has(e.source) || !inDegree.has(e.target))
+                continue; // dangling flagged already
+            inDegree.set(e.target, (inDegree.get(e.target) ?? 0) + 1);
+            const list = out.get(e.source);
+            if (list)
+                list.push(e.target);
+            else
+                out.set(e.source, [e.target]);
+        }
+        const queue = nodes.filter(n => (inDegree.get(n.id) ?? 0) === 0).map(n => n.id);
+        let visited = 0;
+        while (queue.length) {
+            const cur = queue.shift();
+            visited++;
+            for (const next of out.get(cur) ?? []) {
+                const d = (inDegree.get(next) ?? 1) - 1;
+                inDegree.set(next, d);
+                if (d === 0)
+                    queue.push(next);
+            }
+        }
+        if (visited < nodes.length) {
+            const stuck = nodes.filter(n => (inDegree.get(n.id) ?? 0) > 0);
+            const names = stuck.slice(0, 3).map(nodeName).join(', ');
+            const more = stuck.length > 3 ? ` +${stuck.length - 3} more` : '';
+            allErrors.push({
+                id: 'workflow-cycle',
+                type: 'workflow',
+                severity: 'error',
+                message: `Circular connection detected involving: ${names}${more}. Break the loop — execution order is undefined inside a cycle.`,
+                nodeId: stuck[0]?.id,
+            });
+        }
+    }
+    // ── DEV-207: "won't run" warnings ──
+    // Execution is reachability-from-entry: a node runs only if it is reachable,
+    // following edges, from a trigger. Flag configured nodes that WON'T run so
+    // the consequence is explicit (a stray, unconnected Slack step silently not
+    // firing is the exact footgun this prevents).
+    const isTrigger = (n) => n.type === 'trigger' || String(n.actionDefinitionId ?? '').endsWith('_trigger');
+    const triggerIds = nodes.filter(isTrigger).map(n => n.id);
+    // Forward reachability from every trigger, closed over parent/child so a
+    // container's body counts as reachable when the container is (mirrors the
+    // Engine's executionScope).
+    const adjacency = new Map();
+    for (const e of edges) {
+        const list = adjacency.get(e.source);
+        if (list)
+            list.push(e.target);
+        else
+            adjacency.set(e.source, [e.target]);
+    }
+    const reachable = new Set(triggerIds);
+    const queue = [...triggerIds];
+    while (queue.length) {
+        const cur = queue.shift();
+        for (const next of adjacency.get(cur) ?? []) {
+            if (!reachable.has(next)) {
+                reachable.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const n of nodes) {
+            if (reachable.has(n.id)) {
+                if (n.parentId && !reachable.has(n.parentId)) {
+                    reachable.add(n.parentId);
+                    changed = true;
+                }
+            }
+            else if (n.parentId && reachable.has(n.parentId)) {
+                reachable.add(n.id);
+                changed = true;
+            }
+        }
+    }
+    nodes.forEach(node => {
+        if (isTrigger(node))
+            return;
+        const isConnected = edges.some(e => e.source === node.id || e.target === node.id);
+        // With ≥1 trigger, "won't run" is precise: not reachable from any trigger.
+        // With NO trigger yet (a draft), fall back to the connectivity check so we
+        // still flag a fully-orphaned node without spamming every step of a
+        // trigger-less work-in-progress.
+        const wontRun = triggerIds.length > 0 ? !reachable.has(node.id) : !isConnected;
+        if (wontRun) {
+            allErrors.push({
+                id: `node-${node.id}-orphan`,
+                type: 'node',
+                severity: 'warning',
+                message: isConnected
+                    ? `"${nodeName(node)}" isn't reachable from a trigger and won't run.`
+                    : `"${nodeName(node)}" isn't connected to a flow and won't run.`,
+                nodeId: node.id,
+            });
+        }
+    });
+    // ── Multi-flow canvas advisory (DEV-220 / ADR multi-graph decision) ──
+    // Multiple disconnected trigger trees on one canvas are LEGAL (component-
+    // scoped execution isolates them), but usually a maintainability smell —
+    // warn, never block. Components are weakly-connected (undirected) with the
+    // same parent/child closure as reachability.
+    if (triggerIds.length > 1) {
+        const parentOf = new Map(nodes.filter(n => n.parentId).map(n => [n.id, n.parentId]));
+        const undirected = new Map();
+        const link = (a, b) => {
+            const la = undirected.get(a);
+            if (la)
+                la.push(b);
+            else
+                undirected.set(a, [b]);
+        };
+        for (const e of edges) {
+            link(e.source, e.target);
+            link(e.target, e.source);
+        }
+        for (const [child, parent] of parentOf) {
+            link(child, parent);
+            link(parent, child);
+        }
+        const seen = new Set();
+        let flowsWithTrigger = 0;
+        for (const t of triggerIds) {
+            if (seen.has(t))
+                continue;
+            flowsWithTrigger++;
+            const stack = [t];
+            seen.add(t);
+            while (stack.length) {
+                const cur = stack.pop();
+                for (const next of undirected.get(cur) ?? []) {
+                    if (!seen.has(next)) {
+                        seen.add(next);
+                        stack.push(next);
+                    }
+                }
+            }
+        }
+        if (flowsWithTrigger > 1) {
+            allErrors.push({
+                id: 'workflow-multi-flow',
+                type: 'workflow',
+                severity: 'warning',
+                message: `This canvas holds ${flowsWithTrigger} separate flows. Each trigger runs only its own flow — consider splitting them into separate flows for clarity.`,
+            });
+        }
+    }
+    const errors = allErrors.filter(e => e.severity === 'error');
+    const warnings = allErrors.filter(e => e.severity === 'warning');
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Get validation status for a specific node
+ */
+export function getNodeValidationStatus(nodeId, validationResult) {
+    const hasError = validationResult.errors.some(e => e.nodeId === nodeId);
+    if (hasError)
+        return 'error';
+    const hasWarning = validationResult.warnings.some(e => e.nodeId === nodeId);
+    if (hasWarning)
+        return 'warning';
+    return 'valid';
+}
+/**
+ * Get validation status for a specific edge
+ */
+export function getEdgeValidationStatus(edgeId, validationResult) {
+    const hasError = validationResult.errors.some(e => e.edgeId === edgeId);
+    if (hasError)
+        return 'error';
+    const hasWarning = validationResult.warnings.some(e => e.edgeId === edgeId);
+    if (hasWarning)
+        return 'warning';
+    return 'valid';
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@octaviaflow/flow-rules",
+  "version": "0.1.0",
+  "description": "The flow action catalog and the rules engine behind Flow Doctor — one definition of what a step accepts and what makes a flow valid, shared by the editor and the server",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.13",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "bun": ">=1.2.0"
+  },
+  "keywords": ["octaviaflow", "workflow", "actions", "validation", "flow-doctor"],
+  "author": "Octaviaflow Team",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OctaviaFlow/Octaviaflow-System.git",
+    "directory": "Octaviaflow-Flow-Rules"
+  },
+  "bugs": "https://github.com/OctaviaFlow/Octaviaflow-System/issues",
+  "homepage": "https://github.com/OctaviaFlow/Octaviaflow-System/tree/main/Octaviaflow-Flow-Rules#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}