agentplane 0.2.24 → 0.2.26

package/dist/workflow-runtime/template.js

@@ -0,0 +1,94 @@
+import { diagnosticsToValidationResult } from "./markdown.js";
+function stringifyTemplateValue(value) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return String(value);
+    }
+    if (typeof value === "symbol") {
+        return value.description ? `Symbol(${value.description})` : "Symbol()";
+    }
+    return JSON.stringify(value) ?? "";
+}
+const DEFAULT_FILTERS = {
+    upper: (value) => stringifyTemplateValue(value).toUpperCase(),
+    lower: (value) => stringifyTemplateValue(value).toLowerCase(),
+    trim: (value) => stringifyTemplateValue(value).trim(),
+    json: (value) => JSON.stringify(value),
+};
+const DEFAULT_OPTIONS = {
+    strictVariables: true,
+    strictFilters: true,
+    allowedFilters: DEFAULT_FILTERS,
+};
+function getPathValue(context, dottedPath) {
+    const segments = dottedPath.split(".");
+    let current = context;
+    for (const segment of segments) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        const record = current;
+        current = record[segment];
+    }
+    return current;
+}
+export function validateTemplateStrict(template, context, options = {}) {
+    const opts = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+        allowedFilters: { ...DEFAULT_FILTERS, ...options.allowedFilters },
+    };
+    const diagnostics = [];
+    const re = /{{\s*([a-zA-Z_][\w.]*)(?:\s*\|\s*([a-zA-Z_][\w-]*))?\s*}}/g;
+    for (const match of template.matchAll(re)) {
+        const variable = match[1];
+        const filter = match[2];
+        if (variable && opts.strictVariables) {
+            const value = getPathValue(context, variable);
+            if (value === undefined) {
+                diagnostics.push({
+                    code: "WF_TEMPLATE_UNKNOWN_VARIABLE",
+                    severity: "ERROR",
+                    path: `template.${variable}`,
+                    message: `Unknown template variable: ${variable}`,
+                });
+            }
+        }
+        if (filter && opts.strictFilters && !opts.allowedFilters[filter]) {
+            diagnostics.push({
+                code: "WF_TEMPLATE_UNKNOWN_FILTER",
+                severity: "ERROR",
+                path: `template.filter.${filter}`,
+                message: `Unknown template filter: ${filter}`,
+            });
+        }
+    }
+    return diagnosticsToValidationResult(diagnostics);
+}
+export function renderTemplateStrict(template, context, options = {}) {
+    const opts = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+        allowedFilters: { ...DEFAULT_FILTERS, ...options.allowedFilters },
+    };
+    const validation = validateTemplateStrict(template, context, opts);
+    if (!validation.ok) {
+        return {
+            text: template,
+            diagnostics: validation.diagnostics,
+        };
+    }
+    const rendered = template.replaceAll(/{{\s*([a-zA-Z_][\w.]*)(?:\s*\|\s*([a-zA-Z_][\w-]*))?\s*}}/g, (_full, variable, filter) => {
+        let value = getPathValue(context, variable);
+        if (filter) {
+            value = opts.allowedFilters[filter]?.(value);
+        }
+        return stringifyTemplateValue(value);
+    });
+    return {
+        text: rendered,
+        diagnostics: [],
+    };
+}

package/dist/workflow-runtime/types.d.ts

@@ -0,0 +1,68 @@
+export type WorkflowMode = "direct" | "branch_pr";
+export type WorkflowApprovals = {
+    require_plan: boolean;
+    require_verify: boolean;
+    require_network: boolean;
+};
+export type WorkflowRetryPolicy = {
+    normal_exit_continuation: boolean;
+    abnormal_backoff: "exponential";
+    max_attempts: number;
+};
+export type WorkflowTimeouts = {
+    stall_seconds: number;
+};
+export type WorkflowFrontMatter = {
+    version: number;
+    mode: WorkflowMode;
+    owners: {
+        orchestrator: string;
+    };
+    approvals: WorkflowApprovals;
+    retry_policy: WorkflowRetryPolicy;
+    timeouts: WorkflowTimeouts;
+    in_scope_paths: string[];
+};
+export type WorkflowSectionName = "Prompt Template" | "Checks" | "Fallback";
+export type WorkflowSections = Record<string, string>;
+export type WorkflowDocument = {
+    frontMatter: WorkflowFrontMatter;
+    frontMatterRaw: Record<string, unknown>;
+    body: string;
+    sections: WorkflowSections;
+    promptTemplate: string;
+    sourcePath?: string;
+};
+export type WorkflowSeverity = "ERROR" | "WARN" | "INFO";
+export type WorkflowErrorCode = "WF_MISSING_FILE" | "WF_READ_FAILED" | "WF_FRONTMATTER_NOT_OBJECT" | "WF_PARSE_ERROR" | "WF_SCHEMA_MISSING" | "WF_SCHEMA_TYPE" | "WF_SCHEMA_ENUM" | "WF_SCHEMA_RANGE" | "WF_SCHEMA_UNKNOWN_KEY" | "WF_REQUIRED_SECTION_MISSING" | "WF_TEMPLATE_UNKNOWN_VARIABLE" | "WF_TEMPLATE_UNKNOWN_FILTER" | "WF_PATH_OUTSIDE_ROOT" | "WF_OWNER_NOT_FOUND" | "WF_POLICY_MISMATCH" | "WF_FIX_SKIPPED_UNSAFE";
+export type WorkflowDiagnostic = {
+    code: WorkflowErrorCode;
+    severity: WorkflowSeverity;
+    path: string;
+    message: string;
+};
+export type WorkflowValidationResult = {
+    ok: boolean;
+    diagnostics: WorkflowDiagnostic[];
+};
+export type WorkflowTemplateRenderOptions = {
+    strictVariables: boolean;
+    strictFilters: boolean;
+    allowedFilters: Record<string, (value: unknown) => unknown>;
+};
+export type WorkflowPaths = {
+    workflowPath: string;
+    legacyWorkflowPath: string;
+    lastKnownGoodPath: string;
+    workflowDir: string;
+};
+export type WorkflowBuildInput = {
+    baseTemplate: string;
+    projectOverrideTemplate?: string;
+    runtimeContext: Record<string, unknown>;
+};
+export type WorkflowBuildOutput = {
+    text: string;
+    diagnostics: WorkflowDiagnostic[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/workflow-runtime/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/workflow-runtime/types.ts"],"names":[],"mappings":"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"}

package/dist/workflow-runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workflow-runtime/validate.d.ts

@@ -0,0 +1,8 @@
+import type { AgentplaneConfig } from "@agentplaneorg/core";
+import type { WorkflowDocument, WorkflowValidationResult } from "./types.js";
+export declare function validateWorkflowDocument(document: WorkflowDocument, opts?: {
+    repoRoot?: string;
+    knownAgentIds?: Set<string>;
+    config?: AgentplaneConfig | null;
+}): WorkflowValidationResult;
+//# sourceMappingURL=validate.d.ts.map

package/dist/workflow-runtime/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/workflow-runtime/validate.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,KAAK,EAEV,gBAAgB,EAEhB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AA8VpB,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,CAAC,EAAE;IACL,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAClC,GACA,wBAAwB,CA0F1B"}

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.24",
+  "version": "0.2.26",
   "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.24",
+    "@agentplaneorg/core": "0.2.26",
     "yauzl": "^2.10.0"
   },
   "devDependencies": {