agentweaver 0.1.14 → 0.1.16

package/dist/structured-artifacts.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { TaskRunnerError } from "./errors.js";
-import { STRUCTURED_ARTIFACT_SCHEMA_IDS, getStructuredArtifactSchema, } from "./structured-artifact-schema-registry.js";
-export { STRUCTURED_ARTIFACT_SCHEMA_IDS };
+import { ARTIFACT_PAYLOAD_SCHEMA_IDS, STRUCTURED_ARTIFACT_SCHEMA_IDS, getStructuredArtifactSchema, } from "./structured-artifact-schema-registry.js";
+export { ARTIFACT_PAYLOAD_SCHEMA_IDS, STRUCTURED_ARTIFACT_SCHEMA_IDS };
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -11,9 +11,19 @@ function schemaLabel(node) {
     }
     switch (node.type) {
         case "string":
+            if (node.enum && node.enum.length > 0) {
+                return `one of: ${node.enum.join(", ")}`;
+            }
+            if (node.pattern) {
+                return "a string with the expected format";
+            }
             return node.nonEmpty ? "a non-empty string" : "a string";
         case "boolean":
             return "a boolean";
+        case "bytes":
+            return "a binary file";
+        case "json":
+            return "valid JSON";
         case "number":
             return "a number";
         case "null":
@@ -43,9 +53,27 @@ function validateNode(value, schema, currentPath) {
             if (typeof value !== "string" || (schema.nonEmpty && value.trim().length === 0)) {
                 return [`${currentPath} must be ${schemaLabel(schema)}`];
             }
+            if (schema.enum && !schema.enum.includes(value)) {
+                return [`${currentPath} must be ${schemaLabel(schema)}`];
+            }
+            if (schema.pattern) {
+                try {
+                    const pattern = new RegExp(schema.pattern);
+                    if (!pattern.test(value)) {
+                        return [`${currentPath} must be ${schemaLabel(schema)}`];
+                    }
+                }
+                catch {
+                    return [`${currentPath} uses an invalid schema pattern`];
+                }
+            }
             return [];
         case "boolean":
             return typeof value === "boolean" ? [] : [`${currentPath} must be a boolean`];
+        case "bytes":
+            return value instanceof Uint8Array ? [] : [`${currentPath} must be a binary file`];
+        case "json":
+            return validateJsonValue(value, currentPath);
         case "number":
             return typeof value === "number" && !Number.isNaN(value) ? [] : [`${currentPath} must be a number`];
         case "null":
@@ -79,6 +107,28 @@ function validateNode(value, schema, currentPath) {
         }
     }
 }
+function validateJsonValue(value, currentPath) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => validateJsonValue(item, `${currentPath}[${index}]`));
+    }
+    if (!isRecord(value)) {
+        return [`${currentPath} must be valid JSON`];
+    }
+    return Object.entries(value).flatMap(([key, candidate]) => validateJsonValue(candidate, `${currentPath}.${key}`));
+}
+function validateArtifactPayloadValue(value, schemaId, label = "$") {
+    const schema = getStructuredArtifactSchema(schemaId);
+    const issues = validateNode(value, schema, label);
+    if (issues.length > 0) {
+        throw new TaskRunnerError(`Structured artifact ${label} failed schema ${schemaId} validation:\n${issues.join("\n")}`);
+    }
+}
 export function validateStructuredArtifact(path, schemaId) {
     if (!existsSync(path)) {
         throw new TaskRunnerError(`Structured artifact file not found: ${path}`);
@@ -90,11 +140,38 @@ export function validateStructuredArtifact(path, schemaId) {
     catch (error) {
         throw new TaskRunnerError(`Structured artifact ${path} is not valid JSON: ${error.message}`);
     }
-    const schema = getStructuredArtifactSchema(schemaId);
-    const issues = validateNode(parsed, schema, path);
-    if (issues.length > 0) {
-        throw new TaskRunnerError(`Structured artifact ${path} failed schema ${schemaId} validation:\n${issues.join("\n")}`);
+    validateArtifactPayloadValue(parsed, schemaId, path);
+}
+export function validateStructuredArtifactValue(value, schemaId, label = "$") {
+    validateArtifactPayloadValue(value, schemaId, label);
+}
+export function isArtifactPayloadSchemaId(schemaId) {
+    return ARTIFACT_PAYLOAD_SCHEMA_IDS.includes(schemaId);
+}
+export function validateArtifactPayload(path, schemaId) {
+    if (!existsSync(path)) {
+        throw new TaskRunnerError(`Structured artifact file not found: ${path}`);
+    }
+    if (schemaId === "markdown/v1" || schemaId === "plain-text/v1") {
+        validateArtifactPayloadValue(readFileSync(path, "utf8"), schemaId, path);
+        return;
+    }
+    if (schemaId === "helper-json/v1") {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch (error) {
+            throw new TaskRunnerError(`Structured artifact ${path} is not valid JSON: ${error.message}`);
+        }
+        validateArtifactPayloadValue(parsed, schemaId, path);
+        return;
+    }
+    if (schemaId === "opaque-file/v1") {
+        validateArtifactPayloadValue(readFileSync(path), schemaId, path);
+        return;
     }
+    validateStructuredArtifact(path, schemaId);
 }
 export function validateStructuredArtifacts(items, message) {
     try {

package/dist/user-input.js

@@ -19,6 +19,69 @@ export function defaultValueForField(field) {
 export function buildInitialUserInputValues(fields) {
     return Object.fromEntries(fields.map((field) => [field.id, defaultValueForField(field)]));
 }
+export function applyInitialUserInputValues(fields, initialValues) {
+    if (!initialValues) {
+        return fields;
+    }
+    return fields.map((field) => {
+        const initialValue = initialValues[field.id];
+        if (initialValue === undefined) {
+            return field;
+        }
+        if (field.type === "boolean" && typeof initialValue === "boolean") {
+            return { ...field, default: initialValue };
+        }
+        if (field.type === "text" && typeof initialValue === "string") {
+            return { ...field, default: initialValue };
+        }
+        if (field.type === "single-select" && typeof initialValue === "string") {
+            return { ...field, default: initialValue };
+        }
+        if (field.type === "multi-select"
+            && Array.isArray(initialValue)
+            && initialValue.every((item) => typeof item === "string")) {
+            return { ...field, default: [...initialValue] };
+        }
+        return field;
+    });
+}
+function defaultSelectValue(field) {
+    if (field.type === "single-select") {
+        return field.default ?? field.options[0]?.value ?? "";
+    }
+    return [...(field.default ?? [])];
+}
+export function resolveFieldOptions(field, values) {
+    return field.optionsFromValues?.(values) ?? field.options;
+}
+export function resolveFieldDefinition(field, values) {
+    if (field.type !== "single-select" && field.type !== "multi-select") {
+        return field;
+    }
+    return {
+        ...field,
+        options: resolveFieldOptions(field, values),
+    };
+}
+export function normalizeUserInputFieldValue(field, values) {
+    if (field.type !== "single-select" && field.type !== "multi-select") {
+        return;
+    }
+    const allowedValues = new Set(resolveFieldOptions(field, values).map((option) => option.value));
+    if (field.type === "single-select") {
+        const currentValue = typeof values[field.id] === "string" ? String(values[field.id]) : "";
+        if (!allowedValues.has(currentValue)) {
+            const fallback = defaultSelectValue(resolveFieldDefinition(field, values));
+            values[field.id] = typeof fallback === "string" ? fallback : "";
+        }
+        return;
+    }
+    const currentValue = values[field.id];
+    const currentValues = Array.isArray(currentValue)
+        ? currentValue.filter((item) => typeof item === "string")
+        : [];
+    values[field.id] = currentValues.filter((item) => typeof item === "string" && allowedValues.has(item));
+}
 export function validateUserInputValues(form, values) {
     for (const field of form.fields) {
         const value = values[field.id];
@@ -38,24 +101,26 @@ export function validateUserInputValues(form, values) {
             continue;
         }
         if (field.type === "single-select") {
+            const options = resolveFieldOptions(field, values);
             if (typeof value !== "string") {
                 throw new TaskRunnerError(`Field '${field.label}' must be a string.`);
             }
             if (field.required && normalizeText(value).length === 0) {
                 throw new TaskRunnerError(`Field '${field.label}' is required.`);
             }
-            if (value && !field.options.some((option) => option.value === value)) {
+            if (value && !options.some((option) => option.value === value)) {
                 throw new TaskRunnerError(`Field '${field.label}' contains an unknown option '${value}'.`);
             }
             continue;
         }
+        const options = resolveFieldOptions(field, values);
         if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
             throw new TaskRunnerError(`Field '${field.label}' must be a string array.`);
         }
         if (field.required && value.length === 0) {
             throw new TaskRunnerError(`Field '${field.label}' requires at least one selected option.`);
         }
-        const allowed = new Set(field.options.map((option) => option.value));
+        const allowed = new Set(options.map((option) => option.value));
         for (const item of value) {
             if (!allowed.has(item)) {
                 throw new TaskRunnerError(`Field '${field.label}' contains an unknown option '${item}'.`);
@@ -113,7 +178,9 @@ export async function requestUserInputInTerminal(form) {
             process.stdout.write(`${form.description.trim()}\n`);
         }
         const values = buildInitialUserInputValues(form.fields);
-        for (const field of form.fields) {
+        for (const rawField of form.fields) {
+            normalizeUserInputFieldValue(rawField, values);
+            const field = resolveFieldDefinition(rawField, values);
             if (field.type === "boolean") {
                 while (true) {
                     const current = values[field.id];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentweaver",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "CLI orchestrator for Jira/Codex engineering workflows",
   "keywords": [
     "agent",
@@ -51,13 +51,16 @@
   },
   "devDependencies": {
     "@types/node": "^20.17.30",
+    "@types/react": "^18.3.12",
     "@types/semver": "^7.7.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.4"
   },
   "dependencies": {
+    "ink": "^5.2.1",
     "markdown-it": "^14.1.1",
-    "neo-blessed": "^0.2.0",
+    "react": "^18.3.1",
     "semver": "^7.7.4"
   }
 }