@dotit/core 1.0.0

package/dist/workflow.d.ts

@@ -0,0 +1,18 @@
+import { IntentDocument, IntentBlock } from "./types.js";
+export interface WorkflowStep {
+    block: IntentBlock;
+    dependsOn: string[];
+    dependedOnBy: string[];
+    isGate: boolean;
+    isTerminal: boolean;
+    isParallel: boolean;
+}
+export interface WorkflowGraph {
+    entryPoints: string[];
+    steps: Record<string, WorkflowStep>;
+    executionOrder: string[][];
+    gatePositions: number[];
+    hasTerminal: boolean;
+    warnings: string[];
+}
+export declare function extractWorkflow(doc: IntentDocument): WorkflowGraph;

package/dist/workflow.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractWorkflow = extractWorkflow;
+const WORKFLOW_TYPES = new Set([
+    "step",
+    "gate",
+    "decision",
+    "parallel",
+    "wait",
+    "result",
+    "checkpoint",
+    "retry",
+    "call",
+    "handoff",
+    "trigger",
+    "loop",
+    "signal",
+    "error",
+    "audit",
+]);
+function collectWorkflowBlocks(blocks) {
+    const result = [];
+    for (const block of blocks) {
+        if (WORKFLOW_TYPES.has(block.type)) {
+            result.push(block);
+        }
+        if (block.children) {
+            result.push(...collectWorkflowBlocks(block.children));
+        }
+    }
+    return result;
+}
+function getStepId(block) {
+    return block.properties?.id || block.id;
+}
+function isInsideParallel(block, doc) {
+    function search(blocks, insideParallel) {
+        for (const b of blocks) {
+            const inP = insideParallel || b.type === "parallel";
+            if (b === block)
+                return inP;
+            if (b.children) {
+                const found = search(b.children, inP);
+                if (found)
+                    return true;
+            }
+        }
+        return false;
+    }
+    return search(doc.blocks, false);
+}
+function extractWorkflow(doc) {
+    if (!doc || !doc.blocks) {
+        return {
+            entryPoints: [],
+            steps: {},
+            executionOrder: [],
+            gatePositions: [],
+            hasTerminal: false,
+            warnings: ["Empty or invalid document"],
+        };
+    }
+    const warnings = [];
+    const workflowBlocks = collectWorkflowBlocks(doc.blocks);
+    if (workflowBlocks.length === 0) {
+        return {
+            entryPoints: [],
+            steps: {},
+            executionOrder: [],
+            gatePositions: [],
+            hasTerminal: false,
+            warnings: ["No workflow blocks found"],
+        };
+    }
+    const steps = {};
+    const idMap = new Map();
+    for (const block of workflowBlocks) {
+        const stepId = getStepId(block);
+        if (steps[stepId]) {
+            warnings.push(`Duplicate step ID: ${stepId}`);
+            continue;
+        }
+        idMap.set(stepId, block);
+        steps[stepId] = {
+            block,
+            dependsOn: [],
+            dependedOnBy: [],
+            isGate: block.type === "gate",
+            isTerminal: block.type === "result",
+            isParallel: isInsideParallel(block, doc),
+        };
+    }
+    for (const [stepId, step] of Object.entries(steps)) {
+        const depends = step.block.properties?.depends;
+        if (depends && typeof depends === "string") {
+            const deps = depends
+                .split(",")
+                .map((d) => d.trim())
+                .filter(Boolean);
+            for (const dep of deps) {
+                if (!steps[dep]) {
+                    warnings.push(`Step "${stepId}" depends on unknown step "${dep}"`);
+                    continue;
+                }
+                step.dependsOn.push(dep);
+                steps[dep].dependedOnBy.push(stepId);
+            }
+        }
+    }
+    const inDegree = {};
+    for (const id of Object.keys(steps)) {
+        inDegree[id] = steps[id].dependsOn.length;
+    }
+    const executionOrder = [];
+    const processed = new Set();
+    let iterationGuard = 0;
+    const maxIterations = Object.keys(steps).length + 1;
+    while (processed.size < Object.keys(steps).length &&
+        iterationGuard < maxIterations) {
+        iterationGuard++;
+        const batch = [];
+        for (const id of Object.keys(steps)) {
+            if (!processed.has(id) && inDegree[id] === 0) {
+                batch.push(id);
+            }
+        }
+        if (batch.length === 0) {
+            const remaining = Object.keys(steps).filter((id) => !processed.has(id));
+            warnings.push(`Cycle detected involving: ${remaining.join(", ")}`);
+            executionOrder.push(remaining);
+            for (const id of remaining) {
+                processed.add(id);
+            }
+            break;
+        }
+        executionOrder.push(batch);
+        for (const id of batch) {
+            processed.add(id);
+            for (const dependent of steps[id].dependedOnBy) {
+                inDegree[dependent]--;
+            }
+        }
+    }
+    const entryPoints = Object.keys(steps).filter((id) => steps[id].dependsOn.length === 0);
+    const gatePositions = [];
+    for (let i = 0; i < executionOrder.length; i++) {
+        if (executionOrder[i].some((id) => steps[id]?.isGate)) {
+            gatePositions.push(i);
+        }
+    }
+    const hasTerminal = Object.values(steps).some((s) => s.isTerminal);
+    return {
+        entryPoints,
+        steps,
+        executionOrder,
+        gatePositions,
+        hasTerminal,
+        warnings,
+    };
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@dotit/core",
+  "version": "1.0.0",
+  "description": "IntentText Parser, HTML Renderer, and Converters",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "intenttext",
+    "parser",
+    "markdown",
+    "semantic",
+    "ai"
+  ],
+  "author": "IntentText Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/intenttext/IntentText.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/intenttext/IntentText#readme",
+  "bugs": {
+    "url": "https://github.com/intenttext/IntentText/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "dependencies": {
+    "node-html-parser": "^7.0.2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "vitest run",
+    "size:report": "node scripts/report-package-size.cjs",
+    "size:check": "node scripts/check-package-size.cjs",
+    "pack:check": "node scripts/check-pack-footprint.cjs",
+    "keywords:check": "node scripts/check-keyword-consistency.cjs",
+    "parity:check": "node scripts/check-consumer-parity.cjs",
+    "check": "pnpm build && pnpm test && pnpm keywords:check && pnpm parity:check && pnpm pack:check",
+    "dev": "tsc --watch"
+  }
+}