agentweaver 0.1.7 → 0.1.9

package/dist/structured-artifacts.js

@@ -1,284 +1,121 @@
 import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { TaskRunnerError } from "./errors.js";
+export const STRUCTURED_ARTIFACT_SCHEMA_IDS = [
+    "bug-analysis/v1",
+    "bug-fix-design/v1",
+    "bug-fix-plan/v1",
+    "gitlab-mr-diff/v1",
+    "gitlab-review/v1",
+    "implementation-design/v1",
+    "implementation-plan/v1",
+    "jira-description/v1",
+    "mr-description/v1",
+    "planning-questions/v1",
+    "qa-plan/v1",
+    "review-findings/v1",
+    "review-fix-report/v1",
+    "review-reply/v1",
+    "task-summary/v1",
+    "user-input/v1",
+];
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const SCHEMA_REGISTRY_PATH = path.join(MODULE_DIR, "structured-artifact-schemas.json");
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function expectNonEmptyString(value, path, issues) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        issues.push(`${path} must be a non-empty string`);
+function schemaLabel(node) {
+    if ("anyOf" in node) {
+        return "a valid value";
     }
-}
-function expectBoolean(value, path, issues) {
-    if (typeof value !== "boolean") {
-        issues.push(`${path} must be a boolean`);
-    }
-}
-function expectObject(value, path, issues) {
-    if (!isRecord(value)) {
-        issues.push(`${path} must be an object`);
-        return false;
-    }
-    return true;
-}
-function expectStringArray(value, path, issues, allowEmpty = false) {
-    if (!Array.isArray(value)) {
-        issues.push(`${path} must be an array`);
-        return;
-    }
-    if (!allowEmpty && value.length === 0) {
-        issues.push(`${path} must not be empty`);
-        return;
-    }
-    value.forEach((item, index) => expectNonEmptyString(item, `${path}[${index}]`, issues));
-}
-function expectObjectArray(value, path, issues, validateItem, allowEmpty = false) {
-    if (!Array.isArray(value)) {
-        issues.push(`${path} must be an array`);
-        return;
+    switch (node.type) {
+        case "string":
+            return node.nonEmpty ? "a non-empty string" : "a string";
+        case "boolean":
+            return "a boolean";
+        case "number":
+            return "a number";
+        case "null":
+            return "null";
+        case "array":
+            return "an array";
+        case "object":
+            return "an object";
     }
-    if (!allowEmpty && value.length === 0) {
-        issues.push(`${path} must not be empty`);
-        return;
-    }
-    value.forEach((item, index) => {
-        const itemPath = `${path}[${index}]`;
-        if (!expectObject(item, itemPath, issues)) {
-            return;
-        }
-        validateItem(item, itemPath, issues);
-    });
-}
-function validateBriefText(value, path, issues) {
-    if (!expectObject(value, path, issues)) {
-        return;
-    }
-    expectNonEmptyString(value.summary, `${path}.summary`, issues);
 }
-function expectNumber(value, path, issues) {
-    if (typeof value !== "number" || Number.isNaN(value)) {
-        issues.push(`${path} must be a number`);
-    }
-}
-function implementationDesignSchema() {
-    return {
-        id: "implementation-design/v1",
-        validate({ path, value }) {
-            const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
+function validateNode(value, schema, currentPath) {
+    if ("anyOf" in schema) {
+        let bestIssues = null;
+        for (const option of schema.anyOf) {
+            const issues = validateNode(value, option, currentPath);
+            if (issues.length === 0) {
+                return [];
             }
-            expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            expectStringArray(value.goals, `${path}.goals`, issues);
-            expectStringArray(value.non_goals, `${path}.non_goals`, issues, true);
-            expectStringArray(value.components, `${path}.components`, issues);
-            expectObjectArray(value.decisions, `${path}.decisions`, issues, (item, itemPath, currentIssues) => {
-                expectNonEmptyString(item.component, `${itemPath}.component`, currentIssues);
-                expectNonEmptyString(item.decision, `${itemPath}.decision`, currentIssues);
-                expectNonEmptyString(item.rationale, `${itemPath}.rationale`, currentIssues);
-            });
-            expectStringArray(value.risks, `${path}.risks`, issues, true);
-            expectStringArray(value.open_questions, `${path}.open_questions`, issues, true);
-            return issues;
-        },
-    };
-}
-function implementationPlanSchema() {
-    return {
-        id: "implementation-plan/v1",
-        validate({ path, value }) {
-            const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
-            }
-            expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            expectStringArray(value.prerequisites, `${path}.prerequisites`, issues, true);
-            expectObjectArray(value.implementation_steps, `${path}.implementation_steps`, issues, (item, itemPath, currentIssues) => {
-                expectNonEmptyString(item.id, `${itemPath}.id`, currentIssues);
-                expectNonEmptyString(item.title, `${itemPath}.title`, currentIssues);
-                expectNonEmptyString(item.details, `${itemPath}.details`, currentIssues);
-            });
-            expectStringArray(value.tests, `${path}.tests`, issues);
-            expectStringArray(value.rollout_notes, `${path}.rollout_notes`, issues, true);
-            return issues;
-        },
-    };
-}
-function qaPlanSchema() {
-    return {
-        id: "qa-plan/v1",
-        validate({ path, value }) {
-            const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
+            if (bestIssues === null || issues.length < bestIssues.length) {
+                bestIssues = issues;
             }
-            expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            expectObjectArray(value.test_scenarios, `${path}.test_scenarios`, issues, (item, itemPath, currentIssues) => {
-                expectNonEmptyString(item.id, `${itemPath}.id`, currentIssues);
-                expectNonEmptyString(item.title, `${itemPath}.title`, currentIssues);
-                expectNonEmptyString(item.expected_result, `${itemPath}.expected_result`, currentIssues);
-            });
-            expectStringArray(value.non_functional_checks, `${path}.non_functional_checks`, issues, true);
-            return issues;
-        },
-    };
-}
-function bugAnalysisSchema() {
-    return {
-        id: "bug-analysis/v1",
-        validate({ path, value }) {
-            const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
-            }
-            expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            if (expectObject(value.suspected_root_cause, `${path}.suspected_root_cause`, issues)) {
-                expectNonEmptyString(value.suspected_root_cause.hypothesis, `${path}.suspected_root_cause.hypothesis`, issues);
-                expectNonEmptyString(value.suspected_root_cause.confidence, `${path}.suspected_root_cause.confidence`, issues);
+        }
+        return bestIssues ?? [`${currentPath} must be ${schemaLabel(schema)}`];
+    }
+    switch (schema.type) {
+        case "string":
+            if (typeof value !== "string" || (schema.nonEmpty && value.trim().length === 0)) {
+                return [`${currentPath} must be ${schemaLabel(schema)}`];
             }
-            expectStringArray(value.reproduction_steps, `${path}.reproduction_steps`, issues);
-            expectStringArray(value.affected_components, `${path}.affected_components`, issues);
-            expectStringArray(value.evidence, `${path}.evidence`, issues);
-            expectStringArray(value.risks, `${path}.risks`, issues, true);
-            expectStringArray(value.open_questions, `${path}.open_questions`, issues, true);
-            return issues;
-        },
-    };
-}
-function bugFixDesignSchema() {
-    return {
-        id: "bug-fix-design/v1",
-        validate: implementationDesignSchema().validate,
-    };
-}
-function bugFixPlanSchema() {
-    return {
-        id: "bug-fix-plan/v1",
-        validate: implementationPlanSchema().validate,
-    };
-}
-function reviewFindingsSchema() {
-    return {
-        id: "review-findings/v1",
-        validate({ path, value }) {
-            const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
+            return [];
+        case "boolean":
+            return typeof value === "boolean" ? [] : [`${currentPath} must be a boolean`];
+        case "number":
+            return typeof value === "number" && !Number.isNaN(value) ? [] : [`${currentPath} must be a number`];
+        case "null":
+            return value === null ? [] : [`${currentPath} must be null`];
+        case "array": {
+            if (!Array.isArray(value)) {
+                return [`${currentPath} must be an array`];
             }
-            expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            expectBoolean(value.ready_to_merge, `${path}.ready_to_merge`, issues);
-            expectObjectArray(value.findings, `${path}.findings`, issues, (item, itemPath, currentIssues) => {
-                expectNonEmptyString(item.severity, `${itemPath}.severity`, currentIssues);
-                expectNonEmptyString(item.title, `${itemPath}.title`, currentIssues);
-                expectNonEmptyString(item.description, `${itemPath}.description`, currentIssues);
-            }, true);
-            return issues;
-        },
-    };
-}
-function reviewReplySchema() {
-    return {
-        id: "review-reply/v1",
-        validate({ path, value }) {
-            const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
+            if (schema.minItems !== undefined && value.length < schema.minItems) {
+                return [schema.minItems === 1 ? `${currentPath} must not be empty` : `${currentPath} must contain at least ${schema.minItems} items`];
             }
-            expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            expectObjectArray(value.responses, `${path}.responses`, issues, (item, itemPath, currentIssues) => {
-                expectNonEmptyString(item.finding_title, `${itemPath}.finding_title`, currentIssues);
-                expectNonEmptyString(item.disposition, `${itemPath}.disposition`, currentIssues);
-                expectNonEmptyString(item.action, `${itemPath}.action`, currentIssues);
-            }, true);
-            expectBoolean(value.ready_to_merge, `${path}.ready_to_merge`, issues);
-            return issues;
-        },
-    };
-}
-function reviewFixReportSchema() {
-    return {
-        id: "review-fix-report/v1",
-        validate({ path, value }) {
-            const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
+            return value.flatMap((item, index) => validateNode(item, schema.items, `${currentPath}[${index}]`));
+        }
+        case "object": {
+            if (!isRecord(value)) {
+                return [`${currentPath} must be an object`];
             }
-            expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            expectStringArray(value.completed_actions, `${path}.completed_actions`, issues);
-            expectStringArray(value.validation_steps, `${path}.validation_steps`, issues, true);
-            return issues;
-        },
-    };
-}
-function gitlabReviewSchema() {
-    return {
-        id: "gitlab-review/v1",
-        validate({ path, value }) {
             const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
+            const properties = schema.properties ?? {};
+            const required = new Set(schema.required ?? []);
+            for (const propertyName of required) {
+                issues.push(...validateNode(value[propertyName], properties[propertyName] ?? { type: "object" }, `${currentPath}.${propertyName}`));
             }
-            expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            expectNonEmptyString(value.merge_request_url, `${path}.merge_request_url`, issues);
-            expectNonEmptyString(value.project_path, `${path}.project_path`, issues);
-            expectNumber(value.merge_request_iid, `${path}.merge_request_iid`, issues);
-            expectNonEmptyString(value.fetched_at, `${path}.fetched_at`, issues);
-            expectObjectArray(value.comments, `${path}.comments`, issues, (item, itemPath, currentIssues) => {
-                expectNonEmptyString(item.id, `${itemPath}.id`, currentIssues);
-                expectNonEmptyString(item.discussion_id, `${itemPath}.discussion_id`, currentIssues);
-                expectNonEmptyString(item.body, `${itemPath}.body`, currentIssues);
-                expectNonEmptyString(item.author, `${itemPath}.author`, currentIssues);
-                expectNonEmptyString(item.created_at, `${itemPath}.created_at`, currentIssues);
-                if (item.file_path !== undefined && item.file_path !== null) {
-                    expectNonEmptyString(item.file_path, `${itemPath}.file_path`, currentIssues);
+            for (const [propertyName, propertySchema] of Object.entries(properties)) {
+                if (required.has(propertyName) || !(propertyName in value)) {
+                    continue;
                 }
-            }, true);
-            return issues;
-        },
-    };
-}
-function userInputSchema() {
-    return {
-        id: "user-input/v1",
-        validate({ path, value }) {
-            const issues = [];
-            if (!expectObject(value, path, issues)) {
-                return issues;
+                issues.push(...validateNode(value[propertyName], propertySchema, `${currentPath}.${propertyName}`));
             }
-            expectNonEmptyString(value.form_id, `${path}.form_id`, issues);
-            expectNonEmptyString(value.submitted_at, `${path}.submitted_at`, issues);
-            expectObject(value.values, `${path}.values`, issues);
             return issues;
-        },
-    };
+        }
+    }
 }
-const schemas = {
-    "bug-analysis/v1": bugAnalysisSchema(),
-    "bug-fix-design/v1": bugFixDesignSchema(),
-    "bug-fix-plan/v1": bugFixPlanSchema(),
-    "gitlab-review/v1": gitlabReviewSchema(),
-    "implementation-design/v1": implementationDesignSchema(),
-    "implementation-plan/v1": implementationPlanSchema(),
-    "jira-description/v1": { id: "jira-description/v1", validate: ({ path, value }) => {
-            const issues = [];
-            validateBriefText(value, path, issues);
-            return issues;
-        } },
-    "mr-description/v1": { id: "mr-description/v1", validate: ({ path, value }) => {
-            const issues = [];
-            validateBriefText(value, path, issues);
-            return issues;
-        } },
-    "qa-plan/v1": qaPlanSchema(),
-    "review-findings/v1": reviewFindingsSchema(),
-    "review-fix-report/v1": reviewFixReportSchema(),
-    "review-reply/v1": reviewReplySchema(),
-    "task-summary/v1": { id: "task-summary/v1", validate: ({ path, value }) => {
-            const issues = [];
-            validateBriefText(value, path, issues);
-            return issues;
-        } },
-    "user-input/v1": userInputSchema(),
-};
+function loadSchemaRegistry() {
+    if (!existsSync(SCHEMA_REGISTRY_PATH)) {
+        throw new TaskRunnerError(`Structured artifact schema registry not found: ${SCHEMA_REGISTRY_PATH}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(SCHEMA_REGISTRY_PATH, "utf8"));
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to parse structured artifact schema registry: ${error.message}`);
+    }
+    if (!isRecord(parsed)) {
+        throw new TaskRunnerError(`Structured artifact schema registry ${SCHEMA_REGISTRY_PATH} must be a JSON object.`);
+    }
+    return parsed;
+}
+const schemas = loadSchemaRegistry();
 export function validateStructuredArtifact(path, schemaId) {
     if (!existsSync(path)) {
         throw new TaskRunnerError(`Structured artifact file not found: ${path}`);
@@ -290,7 +127,11 @@ export function validateStructuredArtifact(path, schemaId) {
     catch (error) {
         throw new TaskRunnerError(`Structured artifact ${path} is not valid JSON: ${error.message}`);
     }
-    const issues = schemas[schemaId].validate({ path, value: parsed });
+    const schema = schemas[schemaId];
+    if (!schema) {
+        throw new TaskRunnerError(`Structured artifact schema is not registered: ${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")}`);
     }

package/dist/user-input.js

@@ -83,6 +83,13 @@ function parseBoolean(value) {
     return null;
 }
 export async function requestUserInputInTerminal(form) {
+    if (form.fields.length === 0) {
+        return {
+            formId: form.formId,
+            submittedAt: new Date().toISOString(),
+            values: {},
+        };
+    }
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         throw new TaskRunnerError(`Flow requires interactive user input for form '${form.formId}', but no TTY is available.`);
     }

package/docker-compose.yml

@@ -260,7 +260,7 @@ services:
         read_only: true
         bind:
           create_host_path: false
-    entrypoint: ["/usr/local/bin/run_go_tests.sh"]
+    entrypoint: ["/usr/local/bin/run_go_tests.py"]
     cap_drop:
       - ALL
     security_opt:
@@ -321,7 +321,7 @@ services:
         read_only: true
         bind:
           create_host_path: false
-    entrypoint: ["/usr/local/bin/run_go_linter.sh"]
+    entrypoint: ["/usr/local/bin/run_go_linter.py"]
     cap_drop:
       - ALL
     security_opt:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentweaver",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "CLI orchestrator for Jira/Codex/Claude engineering workflows",
   "keywords": [
     "agent",
@@ -32,8 +32,8 @@
     "docker-compose.yml",
     "Dockerfile.codex",
     "verify_build.sh",
-    "run_go_tests.sh",
-    "run_go_linter.sh",
+    "run_go_tests.py",
+    "run_go_linter.py",
     "run_go_coverage.sh"
   ],
   "publishConfig": {

package/run_go_linter.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+ROOT_DIR = Path(os.environ.get("VERIFY_BUILD_ROOT_DIR") or os.getcwd()).resolve()
+
+
+def log(message: str) -> None:
+    print(message, file=sys.stderr)
+
+
+def strip_ansi(value: str) -> str:
+    import re
+
+    return re.sub(r"\x1b\[[0-9;]*m", "", value)
+
+
+def emit_result(
+    ok: bool,
+    kind: str,
+    stage: str,
+    exit_code: int,
+    summary: str,
+    command: str,
+    details: dict[str, object] | None = None,
+) -> None:
+    payload = {
+        "ok": ok,
+        "kind": kind,
+        "stage": stage,
+        "exitCode": exit_code,
+        "summary": summary,
+        "command": command,
+        "details": details or {},
+    }
+    print(json.dumps(payload, ensure_ascii=False))
+
+
+def fail(exit_code: int, summary: str, command: str, details: dict[str, object] | None = None) -> "Never":
+    emit_result(False, "linter", "run_go_linter", exit_code, summary, command, details)
+    raise SystemExit(exit_code)
+
+
+def require_cmd(command: str) -> None:
+    if shutil.which(command):
+        return
+    fail(
+        2,
+        f"Missing required command: {command}",
+        command,
+        {"failedStep": "require_cmd", "missingCommand": command},
+    )
+
+
+def collect_issues(output: str) -> list[str]:
+    issues: list[str] = []
+    for raw_line in output.splitlines():
+        cleaned = strip_ansi(raw_line).rstrip("\r").strip()
+        if not cleaned or cleaned.startswith("==>"):
+            continue
+        issues.append(cleaned)
+    return issues
+
+
+def run_command(argv: list[str]) -> tuple[int, str]:
+    completed = subprocess.run(
+        argv,
+        cwd=ROOT_DIR,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        errors="replace",
+        check=False,
+    )
+    output = completed.stdout or ""
+    if output:
+        print(output, end="" if output.endswith("\n") else "\n", file=sys.stderr)
+    return completed.returncode, output
+
+
+def run_step(label: str, argv: list[str], failed_step: str, summary: str) -> None:
+    log(label)
+    exit_code, output = run_command(argv)
+    if exit_code == 0:
+        return
+
+    fail(
+        exit_code,
+        summary,
+        " ".join(argv),
+        {
+            "failedStep": failed_step,
+            "tool": argv[0],
+            "raw": output,
+            "issues": collect_issues(output),
+        },
+    )
+
+
+def main() -> int:
+    require_cmd("go")
+    require_cmd("golangci-lint")
+
+    os.chdir(ROOT_DIR)
+
+    run_step("==> Generating code (go generate ./...)", ["go", "generate", "./..."], "go-generate", "go generate failed")
+    run_step("==> Running linter (golangci-lint run)", ["golangci-lint", "run"], "golangci-lint", "golangci-lint failed")
+
+    emit_result(
+        True,
+        "linter",
+        "run_go_linter",
+        0,
+        "Linter checks passed",
+        "go generate ./... && golangci-lint run",
+        {"steps": ["go-generate", "golangci-lint"]},
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())