agentplane 0.2.25 → 0.3.1

package/dist/workflow-runtime/validate.js

@@ -0,0 +1,331 @@
+import path from "node:path";
+import { diagnosticsToValidationResult } from "./markdown.js";
+const ROOT_KEYS = new Set([
+    "version",
+    "mode",
+    "owners",
+    "approvals",
+    "retry_policy",
+    "timeouts",
+    "in_scope_paths",
+]);
+function push(diags, diagnostic) {
+    diags.push(diagnostic);
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function expectBoolean(diags, value, pathName, required) {
+    if (value === undefined) {
+        if (required) {
+            push(diags, {
+                code: "WF_SCHEMA_MISSING",
+                severity: "ERROR",
+                path: pathName,
+                message: `${pathName} is required.`,
+            });
+        }
+        return undefined;
+    }
+    if (typeof value !== "boolean") {
+        push(diags, {
+            code: "WF_SCHEMA_TYPE",
+            severity: "ERROR",
+            path: pathName,
+            message: `${pathName} must be a boolean.`,
+        });
+        return undefined;
+    }
+    return value;
+}
+function expectString(diags, value, pathName, required) {
+    if (value === undefined) {
+        if (required) {
+            push(diags, {
+                code: "WF_SCHEMA_MISSING",
+                severity: "ERROR",
+                path: pathName,
+                message: `${pathName} is required.`,
+            });
+        }
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        push(diags, {
+            code: "WF_SCHEMA_TYPE",
+            severity: "ERROR",
+            path: pathName,
+            message: `${pathName} must be a string.`,
+        });
+        return undefined;
+    }
+    if (value.trim().length === 0) {
+        push(diags, {
+            code: "WF_SCHEMA_RANGE",
+            severity: "ERROR",
+            path: pathName,
+            message: `${pathName} must be non-empty.`,
+        });
+        return undefined;
+    }
+    return value;
+}
+function expectIntegerInRange(diags, value, pathName, min, max, required) {
+    if (value === undefined) {
+        if (required) {
+            push(diags, {
+                code: "WF_SCHEMA_MISSING",
+                severity: "ERROR",
+                path: pathName,
+                message: `${pathName} is required.`,
+            });
+        }
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        push(diags, {
+            code: "WF_SCHEMA_TYPE",
+            severity: "ERROR",
+            path: pathName,
+            message: `${pathName} must be an integer.`,
+        });
+        return undefined;
+    }
+    if (value < min || value > max) {
+        push(diags, {
+            code: "WF_SCHEMA_RANGE",
+            severity: "ERROR",
+            path: pathName,
+            message: `${pathName} must be in [${min}, ${max}].`,
+        });
+        return undefined;
+    }
+    return value;
+}
+function validateUnknownKeys(diags, raw) {
+    for (const key of Object.keys(raw)) {
+        if (!ROOT_KEYS.has(key)) {
+            push(diags, {
+                code: "WF_SCHEMA_UNKNOWN_KEY",
+                severity: "ERROR",
+                path: `front_matter.${key}`,
+                message: `Unknown front matter key: ${key}`,
+            });
+        }
+    }
+}
+function validateMode(diags, value) {
+    const mode = expectString(diags, value, "front_matter.mode", true);
+    if (!mode)
+        return undefined;
+    if (mode !== "direct" && mode !== "branch_pr") {
+        push(diags, {
+            code: "WF_SCHEMA_ENUM",
+            severity: "ERROR",
+            path: "front_matter.mode",
+            message: "front_matter.mode must be one of: direct, branch_pr.",
+        });
+        return undefined;
+    }
+    return mode;
+}
+function validateOwners(diags, value, knownAgentIds) {
+    if (!isRecord(value)) {
+        push(diags, {
+            code: value === undefined ? "WF_SCHEMA_MISSING" : "WF_SCHEMA_TYPE",
+            severity: "ERROR",
+            path: "front_matter.owners",
+            message: "front_matter.owners must be an object.",
+        });
+        return undefined;
+    }
+    const orchestrator = expectString(diags, value.orchestrator, "front_matter.owners.orchestrator", true);
+    if (!orchestrator)
+        return undefined;
+    if (knownAgentIds && !knownAgentIds.has(orchestrator)) {
+        push(diags, {
+            code: "WF_OWNER_NOT_FOUND",
+            severity: "ERROR",
+            path: "front_matter.owners.orchestrator",
+            message: `Owner ${orchestrator} was not found in .agentplane/agents/*.json.`,
+        });
+    }
+    return { orchestrator };
+}
+function validateApprovals(diags, value) {
+    if (!isRecord(value)) {
+        push(diags, {
+            code: value === undefined ? "WF_SCHEMA_MISSING" : "WF_SCHEMA_TYPE",
+            severity: "ERROR",
+            path: "front_matter.approvals",
+            message: "front_matter.approvals must be an object.",
+        });
+        return undefined;
+    }
+    const require_plan = expectBoolean(diags, value.require_plan, "front_matter.approvals.require_plan", true);
+    const require_verify = expectBoolean(diags, value.require_verify, "front_matter.approvals.require_verify", true);
+    const require_network = expectBoolean(diags, value.require_network, "front_matter.approvals.require_network", true);
+    if (require_plan === undefined || require_verify === undefined || require_network === undefined) {
+        return undefined;
+    }
+    return { require_plan, require_verify, require_network };
+}
+function validateRetryPolicy(diags, value) {
+    if (!isRecord(value)) {
+        push(diags, {
+            code: value === undefined ? "WF_SCHEMA_MISSING" : "WF_SCHEMA_TYPE",
+            severity: "ERROR",
+            path: "front_matter.retry_policy",
+            message: "front_matter.retry_policy must be an object.",
+        });
+        return undefined;
+    }
+    const normal_exit_continuation = expectBoolean(diags, value.normal_exit_continuation, "front_matter.retry_policy.normal_exit_continuation", true);
+    const abnormal_backoff = expectString(diags, value.abnormal_backoff, "front_matter.retry_policy.abnormal_backoff", true);
+    if (abnormal_backoff && abnormal_backoff !== "exponential") {
+        push(diags, {
+            code: "WF_SCHEMA_ENUM",
+            severity: "ERROR",
+            path: "front_matter.retry_policy.abnormal_backoff",
+            message: "front_matter.retry_policy.abnormal_backoff must be exponential.",
+        });
+    }
+    const max_attempts = expectIntegerInRange(diags, value.max_attempts, "front_matter.retry_policy.max_attempts", 1, 100, true);
+    if (normal_exit_continuation === undefined || !abnormal_backoff || max_attempts === undefined) {
+        return undefined;
+    }
+    return {
+        normal_exit_continuation,
+        abnormal_backoff: "exponential",
+        max_attempts,
+    };
+}
+function validateTimeouts(diags, value) {
+    if (!isRecord(value)) {
+        push(diags, {
+            code: value === undefined ? "WF_SCHEMA_MISSING" : "WF_SCHEMA_TYPE",
+            severity: "ERROR",
+            path: "front_matter.timeouts",
+            message: "front_matter.timeouts must be an object.",
+        });
+        return undefined;
+    }
+    const stall_seconds = expectIntegerInRange(diags, value.stall_seconds, "front_matter.timeouts.stall_seconds", 1, 86_400, true);
+    if (stall_seconds === undefined)
+        return undefined;
+    return { stall_seconds };
+}
+function validateScopePaths(diags, value, repoRoot) {
+    if (!Array.isArray(value)) {
+        push(diags, {
+            code: value === undefined ? "WF_SCHEMA_MISSING" : "WF_SCHEMA_TYPE",
+            severity: "ERROR",
+            path: "front_matter.in_scope_paths",
+            message: "front_matter.in_scope_paths must be an array.",
+        });
+        return undefined;
+    }
+    const normalized = value
+        .map((item) => (typeof item === "string" ? item.trim() : ""))
+        .filter((item) => item.length > 0);
+    if (normalized.length === 0) {
+        push(diags, {
+            code: "WF_SCHEMA_RANGE",
+            severity: "ERROR",
+            path: "front_matter.in_scope_paths",
+            message: "front_matter.in_scope_paths must contain at least one path.",
+        });
+        return undefined;
+    }
+    if (repoRoot) {
+        for (const p of normalized) {
+            const candidate = path.resolve(repoRoot, p.replaceAll(/[*]{1,2}$/g, ""));
+            const rootPrefix = `${path.resolve(repoRoot)}${path.sep}`;
+            if (!(candidate === path.resolve(repoRoot) || candidate.startsWith(rootPrefix))) {
+                push(diags, {
+                    code: "WF_PATH_OUTSIDE_ROOT",
+                    severity: "ERROR",
+                    path: "front_matter.in_scope_paths",
+                    message: `Path escapes repository root: ${p}`,
+                });
+            }
+        }
+    }
+    return normalized;
+}
+export function validateWorkflowDocument(document, opts) {
+    const diags = [];
+    const raw = document.frontMatterRaw;
+    if (!isRecord(raw)) {
+        push(diags, {
+            code: "WF_FRONTMATTER_NOT_OBJECT",
+            severity: "ERROR",
+            path: "front_matter",
+            message: "Workflow front matter must decode to an object.",
+        });
+        return diagnosticsToValidationResult(diags);
+    }
+    validateUnknownKeys(diags, raw);
+    const version = expectIntegerInRange(diags, raw.version, "front_matter.version", 1, Number.MAX_SAFE_INTEGER, true);
+    const mode = validateMode(diags, raw.mode);
+    const owners = validateOwners(diags, raw.owners, opts?.knownAgentIds ?? null);
+    const approvals = validateApprovals(diags, raw.approvals);
+    const retry_policy = validateRetryPolicy(diags, raw.retry_policy);
+    const timeouts = validateTimeouts(diags, raw.timeouts);
+    const in_scope_paths = validateScopePaths(diags, raw.in_scope_paths, opts?.repoRoot);
+    if (opts?.config && mode && opts.config.workflow_mode !== mode) {
+        push(diags, {
+            code: "WF_POLICY_MISMATCH",
+            severity: "ERROR",
+            path: "front_matter.mode",
+            message: `workflow mode mismatch: WORKFLOW.md=${mode}, config=${opts.config.workflow_mode}`,
+        });
+    }
+    if (opts?.config && approvals) {
+        const cfgApprovals = opts.config.agents?.approvals;
+        if (cfgApprovals) {
+            if (cfgApprovals.require_plan !== approvals.require_plan) {
+                push(diags, {
+                    code: "WF_POLICY_MISMATCH",
+                    severity: "WARN",
+                    path: "front_matter.approvals.require_plan",
+                    message: "Approval mismatch with .agentplane/config.json (require_plan).",
+                });
+            }
+            if (cfgApprovals.require_verify !== approvals.require_verify) {
+                push(diags, {
+                    code: "WF_POLICY_MISMATCH",
+                    severity: "WARN",
+                    path: "front_matter.approvals.require_verify",
+                    message: "Approval mismatch with .agentplane/config.json (require_verify).",
+                });
+            }
+            if (cfgApprovals.require_network !== approvals.require_network) {
+                push(diags, {
+                    code: "WF_POLICY_MISMATCH",
+                    severity: "WARN",
+                    path: "front_matter.approvals.require_network",
+                    message: "Approval mismatch with .agentplane/config.json (require_network).",
+                });
+            }
+        }
+    }
+    if (version !== undefined &&
+        mode &&
+        owners &&
+        approvals &&
+        retry_policy &&
+        timeouts &&
+        in_scope_paths) {
+        document.frontMatter = {
+            version,
+            mode,
+            owners,
+            approvals,
+            retry_policy,
+            timeouts,
+            in_scope_paths,
+        };
+    }
+    return diagnosticsToValidationResult(diags);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentplane",
-  "version": "0.2.25",
+  "version": "0.3.1",
   "description": "Agent Plane CLI for task workflows, recipes, and project automation.",
   "keywords": [
     "agentplane",
@@ -48,14 +48,14 @@
   },
   "scripts": {
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true}); require('node:fs').rmSync('tsconfig.tsbuildinfo',{force:true});\"",
-    "build": "tsc -b",
+    "build": "tsc -b && node ../../scripts/write-build-manifest.mjs .",
     "typecheck": "tsc -b",
     "prepare": "npm run build",
     "prepack": "npm run clean && npm run build",
     "prepublishOnly": "node ../../scripts/enforce-github-publish.mjs && npm run prepack"
   },
   "dependencies": {
-    "@agentplaneorg/core": "0.2.25",
+    "@agentplaneorg/core": "0.3.1",
     "yauzl": "^2.10.0"
   },
   "devDependencies": {