@dotit/core 1.0.0

package/dist/executor.js

@@ -0,0 +1,501 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorkflow = executeWorkflow;
+const workflow_1 = require("./workflow");
+const utils_1 = require("./utils");
+const DANGEROUS_PATH_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const MAX_PATH_DEPTH = 20;
+function getByPath(obj, path) {
+    const keys = path.split(".");
+    if (keys.length > MAX_PATH_DEPTH)
+        return undefined;
+    return keys.reduce((cur, key) => {
+        if (cur === null || cur === undefined)
+            return undefined;
+        if (DANGEROUS_PATH_KEYS.has(key))
+            return undefined;
+        if (Array.isArray(cur)) {
+            const idx = Number(key);
+            if (!isNaN(idx) && idx >= 0 && idx < cur.length)
+                return cur[idx];
+            return undefined;
+        }
+        if (typeof cur === "object") {
+            return Object.prototype.hasOwnProperty.call(cur, key)
+                ? cur[key]
+                : undefined;
+        }
+        return undefined;
+    }, obj);
+}
+function resolveValue(value, context) {
+    if (value === undefined || value === null)
+        return undefined;
+    const str = String(value);
+    const exactMatch = str.match(/^\{\{([^}]+)\}\}$/);
+    if (exactMatch) {
+        return getByPath(context, exactMatch[1].trim()) ?? str;
+    }
+    return resolveTemplate(str, context);
+}
+function resolveTemplate(template, context) {
+    if (!template.includes("{{"))
+        return template;
+    return template.replace(/\{\{([^}]+)\}\}/g, (_match, rawPath) => {
+        const path = rawPath.trim();
+        if (path.length > 200)
+            return _match;
+        const val = getByPath(context, path);
+        if (val !== undefined && val !== null)
+            return String(val);
+        return _match;
+    });
+}
+function tokenize(input) {
+    const tokens = [];
+    let i = 0;
+    while (i < input.length) {
+        if (input[i] === " " || input[i] === "\t") {
+            i++;
+            continue;
+        }
+        if (input[i] === "'" || input[i] === '"') {
+            const quote = input[i];
+            i++;
+            let val = "";
+            while (i < input.length && input[i] !== quote) {
+                if (input[i] === "\\" && i + 1 < input.length) {
+                    i++;
+                    val += input[i];
+                }
+                else {
+                    val += input[i];
+                }
+                i++;
+            }
+            i++;
+            tokens.push({ type: "string", value: val });
+            continue;
+        }
+        if (input[i] === "{" && input[i + 1] === "{") {
+            i += 2;
+            let path = "";
+            while (i < input.length && !(input[i] === "}" && input[i + 1] === "}")) {
+                path += input[i];
+                i++;
+            }
+            i += 2;
+            tokens.push({ type: "var", path: path.trim() });
+            continue;
+        }
+        const two = input.slice(i, i + 2);
+        if (two === "==" ||
+            two === "!=" ||
+            two === "<=" ||
+            two === ">=" ||
+            two === "&&" ||
+            two === "||") {
+            tokens.push({ type: "op", value: two });
+            i += 2;
+            continue;
+        }
+        if (input[i] === "<" || input[i] === ">") {
+            tokens.push({ type: "op", value: input[i] });
+            i++;
+            continue;
+        }
+        if (input[i] === "(") {
+            tokens.push({ type: "lparen" });
+            i++;
+            continue;
+        }
+        if (input[i] === ")") {
+            tokens.push({ type: "rparen" });
+            i++;
+            continue;
+        }
+        if ((input[i] >= "0" && input[i] <= "9") ||
+            (input[i] === "-" &&
+                i + 1 < input.length &&
+                input[i + 1] >= "0" &&
+                input[i + 1] <= "9")) {
+            let num = "";
+            if (input[i] === "-") {
+                num += "-";
+                i++;
+            }
+            while (i < input.length &&
+                ((input[i] >= "0" && input[i] <= "9") || input[i] === ".")) {
+                num += input[i];
+                i++;
+            }
+            tokens.push({ type: "number", value: Number(num) });
+            continue;
+        }
+        const rest = input.slice(i);
+        if (rest.startsWith("true") &&
+            (i + 4 >= input.length || !/\w/.test(input[i + 4]))) {
+            tokens.push({ type: "boolean", value: true });
+            i += 4;
+            continue;
+        }
+        if (rest.startsWith("false") &&
+            (i + 5 >= input.length || !/\w/.test(input[i + 5]))) {
+            tokens.push({ type: "boolean", value: false });
+            i += 5;
+            continue;
+        }
+        if (rest.startsWith("null") &&
+            (i + 4 >= input.length || !/\w/.test(input[i + 4]))) {
+            tokens.push({ type: "null" });
+            i += 4;
+            continue;
+        }
+        i++;
+    }
+    return tokens;
+}
+function atomValue(token, context) {
+    switch (token.type) {
+        case "string":
+            return token.value;
+        case "number":
+            return token.value;
+        case "boolean":
+            return token.value;
+        case "null":
+            return null;
+        case "var":
+            return getByPath(context, token.path);
+        default:
+            return undefined;
+    }
+}
+function compare(op, left, right) {
+    const lNum = typeof left === "number" ? left : Number(left);
+    const rNum = typeof right === "number" ? right : Number(right);
+    switch (op) {
+        case "==":
+            return left == right;
+        case "!=":
+            return left != right;
+        case "<":
+            return lNum < rNum;
+        case ">":
+            return lNum > rNum;
+        case "<=":
+            return lNum <= rNum;
+        case ">=":
+            return lNum >= rNum;
+        default:
+            return false;
+    }
+}
+function evaluateCondition(condition, context) {
+    if (!condition)
+        return true;
+    try {
+        const tokens = tokenize(condition);
+        let pos = 0;
+        function peek() {
+            return tokens[pos];
+        }
+        function advance() {
+            return tokens[pos++];
+        }
+        function parseExpr() {
+            return parseOr();
+        }
+        function parseOr() {
+            let left = parseAnd();
+            while (peek()?.type === "op" &&
+                peek().value === "||") {
+                advance();
+                const right = parseAnd();
+                left = left || right;
+            }
+            return left;
+        }
+        function parseAnd() {
+            let left = parseCmp();
+            while (peek()?.type === "op" &&
+                peek().value === "&&") {
+                advance();
+                const right = parseCmp();
+                left = left && right;
+            }
+            return left;
+        }
+        function parseCmp() {
+            const leftVal = parseAtom();
+            const next = peek();
+            if (next?.type === "op" && next.value !== "&&" && next.value !== "||") {
+                const op = advance().value;
+                const rightVal = parseAtom();
+                return compare(op, leftVal, rightVal);
+            }
+            return !!leftVal;
+        }
+        function parseAtom() {
+            const token = peek();
+            if (!token)
+                return undefined;
+            if (token.type === "lparen") {
+                advance();
+                const val = parseExpr();
+                if (peek()?.type === "rparen")
+                    advance();
+                return val;
+            }
+            advance();
+            return atomValue(token, context);
+        }
+        return parseExpr();
+    }
+    catch {
+        return false;
+    }
+}
+function findBlockById(doc, blockId) {
+    const all = (0, utils_1.flattenBlocks)(doc.blocks);
+    return all.find((b) => b.id === blockId || b.properties?.id === blockId);
+}
+function writeStatus(doc, blockId, status) {
+    const block = findBlockById(doc, blockId);
+    if (!block)
+        return;
+    if (!block.properties)
+        block.properties = {};
+    block.properties.status = status;
+}
+function updateBlockContent(doc, blockId, content) {
+    const block = findBlockById(doc, blockId);
+    if (!block)
+        return;
+    block.content = content;
+}
+function withTimeout(promise, ms, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), ms);
+        promise.then((val) => {
+            clearTimeout(timer);
+            resolve(val);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+async function executeWorkflow(document, runtime = {}) {
+    const options = {
+        maxSteps: 1000,
+        stepTimeout: 30000,
+        unknownTool: "warn",
+        dryRun: false,
+        ...runtime.options,
+    };
+    const workflow = (0, workflow_1.extractWorkflow)(document);
+    const context = {};
+    const allBlocks = (0, utils_1.flattenBlocks)(document.blocks);
+    for (const block of allBlocks) {
+        if (block.type === "context" && block.properties) {
+            for (const [k, v] of Object.entries(block.properties)) {
+                context[k] = v;
+            }
+        }
+    }
+    if (runtime.context) {
+        Object.assign(context, runtime.context);
+    }
+    const policies = [];
+    for (const block of allBlocks) {
+        if (block.type === "policy") {
+            policies.push(block);
+        }
+    }
+    if (policies.length > 0) {
+        context.__policies = policies;
+    }
+    for (const policy of policies) {
+        const requires = policy.properties?.requires;
+        if (requires !== "gate")
+            continue;
+        const condition = policy.properties?.if ||
+            (policy.properties?.always ? "true" : undefined);
+        if (!evaluateCondition(condition, context))
+            continue;
+        const hasApprovedGate = allBlocks.some((b) => b.type === "gate" && b.properties?.status === "approved");
+        if (!hasApprovedGate) {
+            return {
+                document,
+                context,
+                log: [],
+                status: "policy_blocked",
+                blockedByPolicy: policy,
+                error: new Error(`Policy "${policy.content}" requires an approved gate but none found`),
+            };
+        }
+    }
+    const log = [];
+    const resultDoc = structuredClone(document);
+    let stepCount = 0;
+    for (const batch of workflow.executionOrder) {
+        for (const blockId of batch) {
+            if (stepCount >= options.maxSteps) {
+                return {
+                    document: resultDoc,
+                    context,
+                    log,
+                    status: "error",
+                    error: new Error(`Max steps (${options.maxSteps}) reached`),
+                };
+            }
+            const block = findBlockById(resultDoc, blockId);
+            if (!block)
+                continue;
+            const entry = {
+                blockId: block.id,
+                blockType: block.type,
+                content: block.content,
+                status: "running",
+                timestamp: new Date().toISOString(),
+            };
+            const start = Date.now();
+            try {
+                switch (block.type) {
+                    case "step": {
+                        const toolName = block.properties?.tool;
+                        const inputKey = block.properties?.input;
+                        const outputKey = block.properties?.output;
+                        const input = resolveValue(inputKey, context);
+                        entry.input = input;
+                        if (options.dryRun) {
+                            entry.status = "dry_run";
+                            writeStatus(resultDoc, blockId, "dry_run");
+                            break;
+                        }
+                        if (!toolName) {
+                            entry.status = "skipped";
+                            writeStatus(resultDoc, blockId, "skipped");
+                            break;
+                        }
+                        const handler = runtime.tools?.[toolName];
+                        if (!handler) {
+                            if (options.unknownTool === "error") {
+                                throw new Error(`No tool handler registered for: ${toolName}`);
+                            }
+                            entry.status = "skipped";
+                            writeStatus(resultDoc, blockId, "skipped");
+                            break;
+                        }
+                        runtime.onStepStart?.(block, context);
+                        const output = await withTimeout(Promise.resolve(handler(input, context)), options.stepTimeout, `Step "${block.content}" timed out after ${options.stepTimeout}ms`);
+                        if (outputKey) {
+                            context[outputKey] = output;
+                        }
+                        runtime.onStepComplete?.(block, output, context);
+                        entry.output = output;
+                        entry.status = "completed";
+                        writeStatus(resultDoc, blockId, "done");
+                        stepCount++;
+                        break;
+                    }
+                    case "decision": {
+                        const condition = block.properties?.if;
+                        const thenTarget = block.properties?.then;
+                        const elseTarget = block.properties?.else;
+                        const result = evaluateCondition(condition, context);
+                        const nextTarget = result ? thenTarget : elseTarget;
+                        context.__lastDecision = {
+                            condition,
+                            result,
+                            took: nextTarget,
+                        };
+                        entry.status = "completed";
+                        entry.output = { condition, result, branch: nextTarget };
+                        writeStatus(resultDoc, blockId, "done");
+                        break;
+                    }
+                    case "gate": {
+                        if (options.dryRun) {
+                            entry.status = "dry_run";
+                            writeStatus(resultDoc, blockId, "dry_run");
+                            break;
+                        }
+                        if (!runtime.onGate) {
+                            writeStatus(resultDoc, blockId, "blocked");
+                            entry.status = "blocked";
+                            entry.durationMs = Date.now() - start;
+                            log.push(entry);
+                            return {
+                                document: resultDoc,
+                                context,
+                                log,
+                                status: "gate_blocked",
+                                blockedAt: block,
+                            };
+                        }
+                        const approved = await runtime.onGate(block, context);
+                        if (!approved) {
+                            writeStatus(resultDoc, blockId, "rejected");
+                            entry.status = "blocked";
+                            entry.durationMs = Date.now() - start;
+                            log.push(entry);
+                            return {
+                                document: resultDoc,
+                                context,
+                                log,
+                                status: "gate_blocked",
+                                blockedAt: block,
+                            };
+                        }
+                        writeStatus(resultDoc, blockId, "approved");
+                        entry.status = "completed";
+                        break;
+                    }
+                    case "audit": {
+                        const resolved = resolveTemplate(block.content, context);
+                        updateBlockContent(resultDoc, blockId, resolved);
+                        runtime.onAudit?.(block, context);
+                        entry.status = "completed";
+                        writeStatus(resultDoc, blockId, "done");
+                        break;
+                    }
+                    case "trigger": {
+                        entry.status = "completed";
+                        writeStatus(resultDoc, blockId, "done");
+                        break;
+                    }
+                    case "result": {
+                        const resolved = resolveTemplate(block.content, context);
+                        updateBlockContent(resultDoc, blockId, resolved);
+                        entry.status = "completed";
+                        writeStatus(resultDoc, blockId, "done");
+                        break;
+                    }
+                    default:
+                        entry.status = "skipped";
+                        break;
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                entry.status = "failed";
+                entry.error = error.message;
+                writeStatus(resultDoc, blockId, "failed");
+                runtime.onStepError?.(block, error, context);
+                entry.durationMs = Date.now() - start;
+                log.push(entry);
+                return { document: resultDoc, context, log, status: "error", error };
+            }
+            entry.durationMs = Date.now() - start;
+            log.push(entry);
+        }
+    }
+    return {
+        document: resultDoc,
+        context,
+        log,
+        status: options.dryRun ? "dry_run" : "completed",
+    };
+}

package/dist/history.d.ts

@@ -0,0 +1,10 @@
+import { RegistryEntry, RevisionEntry } from "./types";
+export declare function parseHistorySection(raw: string): {
+    registry: RegistryEntry[];
+    revisions: RevisionEntry[];
+    registryIntact: boolean;
+};
+export interface SaveHistoryOptions {
+    by: string;
+}
+export declare function updateHistory(previousSource: string, currentSource: string, options: SaveHistoryOptions): string;