agentweaver 0.1.14 → 0.1.16

package/dist/runtime/planning-bundle.js

@@ -0,0 +1,123 @@
+import { existsSync } from "node:fs";
+import { designFile, designJsonFile, latestArtifactIteration, planFile, planJsonFile, qaFile, qaJsonFile, } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+import { validateStructuredArtifacts } from "../structured-artifacts.js";
+function planningPrefixes(options) {
+    return options.requireQa ? ["design", "plan", "qa"] : ["design", "plan"];
+}
+function maxPlanningIteration(taskKey, options) {
+    let maxIteration = null;
+    for (const prefix of planningPrefixes(options)) {
+        for (const extension of ["md", "json"]) {
+            const iteration = latestArtifactIteration(taskKey, prefix, extension);
+            if (iteration === null) {
+                continue;
+            }
+            maxIteration = maxIteration === null ? iteration : Math.max(maxIteration, iteration);
+        }
+    }
+    return maxIteration;
+}
+export function planningBundlePaths(taskKey, iteration) {
+    return {
+        designFile: designFile(taskKey, iteration),
+        designJsonFile: designJsonFile(taskKey, iteration),
+        planFile: planFile(taskKey, iteration),
+        planJsonFile: planJsonFile(taskKey, iteration),
+        qaFile: qaFile(taskKey, iteration),
+        qaJsonFile: qaJsonFile(taskKey, iteration),
+    };
+}
+function requiredPlanningPaths(bundle, options) {
+    const required = [
+        bundle.designFile,
+        bundle.designJsonFile,
+        bundle.planFile,
+        bundle.planJsonFile,
+    ];
+    if (options.requireQa) {
+        required.push(bundle.qaFile, bundle.qaJsonFile);
+    }
+    return required;
+}
+export function findLatestCompletedPlanningIteration(taskKey, options) {
+    const latestKnownIteration = maxPlanningIteration(taskKey, options);
+    if (latestKnownIteration === null) {
+        return null;
+    }
+    for (let iteration = latestKnownIteration; iteration >= 1; iteration -= 1) {
+        const bundle = planningBundlePaths(taskKey, iteration);
+        const requiredPaths = requiredPlanningPaths(bundle, options);
+        if (requiredPaths.every((candidate) => existsSync(candidate))) {
+            return iteration;
+        }
+    }
+    return null;
+}
+export function resolveLatestCompletedPlanningIteration(taskKey, options) {
+    const resolvedIteration = findLatestCompletedPlanningIteration(taskKey, options);
+    if (resolvedIteration !== null) {
+        return resolvedIteration;
+    }
+    const fallbackIteration = maxPlanningIteration(taskKey, options) ?? 1;
+    const fallbackBundle = planningBundlePaths(taskKey, fallbackIteration);
+    const requiredPaths = requiredPlanningPaths(fallbackBundle, options);
+    const missing = requiredPaths.filter((candidate) => !existsSync(candidate));
+    throw new TaskRunnerError(`${options.missingMessage}\nMissing files: ${missing.join(", ")}`);
+}
+export function inspectLatestPlanningBundle(taskKey) {
+    const latestKnownIteration = maxPlanningIteration(taskKey, { requireQa: true });
+    if (latestKnownIteration === null) {
+        return {
+            status: "missing",
+            planningIteration: null,
+            missingFiles: [],
+            bundle: null,
+            errorMessage: "Implement mode requires planning artifacts from the planning phase, but none were found.",
+        };
+    }
+    const bundle = planningBundlePaths(taskKey, latestKnownIteration);
+    const missingFiles = requiredPlanningPaths(bundle, { requireQa: true }).filter((candidate) => !existsSync(candidate));
+    if (missingFiles.length > 0) {
+        return {
+            status: "incomplete",
+            planningIteration: latestKnownIteration,
+            missingFiles,
+            bundle,
+            errorMessage: `Implement mode requires a complete planning bundle for iteration ${latestKnownIteration}.` +
+                `\nMissing files: ${missingFiles.join(", ")}`,
+        };
+    }
+    try {
+        validateStructuredArtifacts([
+            { path: bundle.designJsonFile, schemaId: "implementation-design/v1" },
+            { path: bundle.planJsonFile, schemaId: "implementation-plan/v1" },
+            { path: bundle.qaJsonFile, schemaId: "qa-plan/v1" },
+        ], `Implement mode requires a valid structured planning bundle for iteration ${latestKnownIteration}.`);
+    }
+    catch (error) {
+        return {
+            status: "invalid",
+            planningIteration: latestKnownIteration,
+            missingFiles: [],
+            bundle,
+            errorMessage: error.message,
+        };
+    }
+    return {
+        status: "valid",
+        planningIteration: latestKnownIteration,
+        missingFiles: [],
+        bundle,
+    };
+}
+export function resolveLatestPlanningBundle(taskKey) {
+    const inspection = inspectLatestPlanningBundle(taskKey);
+    if (inspection.status !== "valid") {
+        throw new TaskRunnerError(inspection.errorMessage);
+    }
+    return {
+        planningIteration: inspection.planningIteration,
+        ...inspection.bundle,
+    };
+}

package/dist/runtime/ready-to-merge.js

@@ -0,0 +1,31 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { readyToMergeFile } from "../artifacts.js";
+export function clearReadyToMergeFile(taskKey) {
+    const filePath = readyToMergeFile(taskKey);
+    if (!existsSync(filePath)) {
+        return false;
+    }
+    rmSync(filePath);
+    return true;
+}
+export function writeReadyToMergeFile(taskKey, options = {}) {
+    const filePath = readyToMergeFile(taskKey);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const summary = options.summary?.trim();
+    const lines = options.mdLang === "ru"
+        ? [
+            "# Готово к слиянию",
+            "",
+            "Блокирующих замечаний не найдено по текущему порогу severity.",
+            ...(summary ? ["", "## Summary", "", summary] : []),
+        ]
+        : [
+            "# Ready to Merge",
+            "",
+            "No blocking findings were detected at the configured severity threshold.",
+            ...(summary ? ["", "## Summary", "", summary] : []),
+        ];
+    writeFileSync(filePath, `${lines.join("\n")}\n`, "utf8");
+    return filePath;
+}

package/dist/runtime/review-input-contract.js

@@ -0,0 +1,100 @@
+import { existsSync } from "node:fs";
+import { designFile, designJsonFile, instantTaskInputJsonFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, requireArtifacts, taskContextJsonFile, } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+import { validateStructuredArtifacts } from "../structured-artifacts.js";
+import { resolveLatestCompletedPlanningIteration } from "./planning-bundle.js";
+const OPTIONAL_INPUT_NOT_PROVIDED = "not provided";
+function resolveOptionalPromptFile(filePath) {
+    if (!existsSync(filePath)) {
+        return {
+            present: false,
+            path: null,
+            promptValue: OPTIONAL_INPUT_NOT_PROVIDED,
+        };
+    }
+    return {
+        present: true,
+        path: filePath,
+        promptValue: filePath,
+    };
+}
+function resolveOptionalValidatedStructuredFile(filePath, schemaId, message) {
+    const resolved = resolveOptionalPromptFile(filePath);
+    if (!resolved.present) {
+        return resolved;
+    }
+    validateStructuredArtifacts([{ path: filePath, schemaId }], message);
+    return resolved;
+}
+export function inspectReviewInputContract(taskKey) {
+    let planningIteration;
+    try {
+        planningIteration = resolveLatestCompletedPlanningIteration(taskKey, {
+            requireQa: false,
+            missingMessage: "Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.",
+        });
+    }
+    catch (error) {
+        if (error instanceof TaskRunnerError) {
+            return { status: "missing-planning" };
+        }
+        throw error;
+    }
+    const contract = {
+        planningIteration,
+        designFile: designFile(taskKey, planningIteration),
+        designJsonFile: designJsonFile(taskKey, planningIteration),
+        planFile: planFile(taskKey, planningIteration),
+        planJsonFile: planJsonFile(taskKey, planningIteration),
+        hasTaskContextJsonFile: false,
+        taskContextJsonFilePath: null,
+        taskContextJsonFile: OPTIONAL_INPUT_NOT_PROVIDED,
+        hasJiraTaskFile: false,
+        jiraTaskFilePath: null,
+        jiraTaskFile: OPTIONAL_INPUT_NOT_PROVIDED,
+        hasTaskInputJsonFile: false,
+        taskInputJsonFilePath: null,
+        taskInputJsonFile: OPTIONAL_INPUT_NOT_PROVIDED,
+    };
+    requireArtifacts([contract.designFile, contract.designJsonFile, contract.planFile, contract.planJsonFile], "Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
+    validateStructuredArtifacts([
+        { path: contract.designJsonFile, schemaId: "implementation-design/v1" },
+        { path: contract.planJsonFile, schemaId: "implementation-plan/v1" },
+    ], "Structured review requires valid design and plan structured artifacts.");
+    const taskContextIteration = latestArtifactIteration(taskKey, "task-context", "json");
+    const taskContext = taskContextIteration === null
+        ? { present: false, path: null, promptValue: OPTIONAL_INPUT_NOT_PROVIDED }
+        : resolveOptionalValidatedStructuredFile(taskContextJsonFile(taskKey, taskContextIteration), "task-context/v1", "Structured review task-context structured artifact is invalid.");
+    const jiraTask = resolveOptionalPromptFile(jiraTaskFile(taskKey));
+    const taskInput = resolveOptionalValidatedStructuredFile(instantTaskInputJsonFile(taskKey), "user-input/v1", "Structured review instant-task input structured artifact is invalid.");
+    if (!taskContext.present && !jiraTask.present && !taskInput.present) {
+        return {
+            status: "missing-task-context",
+            planningIteration,
+        };
+    }
+    contract.hasTaskContextJsonFile = taskContext.present;
+    contract.taskContextJsonFilePath = taskContext.path;
+    contract.taskContextJsonFile = taskContext.promptValue;
+    contract.hasJiraTaskFile = jiraTask.present;
+    contract.jiraTaskFilePath = jiraTask.path;
+    contract.jiraTaskFile = jiraTask.promptValue;
+    contract.hasTaskInputJsonFile = taskInput.present;
+    contract.taskInputJsonFilePath = taskInput.path;
+    contract.taskInputJsonFile = taskInput.promptValue;
+    return {
+        status: "ready",
+        contract,
+    };
+}
+export function resolveReviewInputContract(taskKey) {
+    const inspection = inspectReviewInputContract(taskKey);
+    if (inspection.status === "ready") {
+        return inspection.contract;
+    }
+    if (inspection.status === "missing-planning") {
+        throw new TaskRunnerError("Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
+    }
+    throw new TaskRunnerError(`Structured review requires a normalized task-context artifact, or legacy Jira/instant-task context, in scope '${taskKey}'.`);
+}
+export { OPTIONAL_INPUT_NOT_PROVIDED };

package/dist/scope.js

@@ -43,7 +43,7 @@ export function detectGitBranchName() {
 export function detectProjectRoot() {
     return gitOutput(["rev-parse", "--show-toplevel"]) ?? process.cwd();
 }
-export function buildProjectScopeKey(explicitScope) {
+export function buildProjectScopeKey(explicitScope, jiraIssueKey) {
     const projectRoot = detectProjectRoot();
     const worktreeHash = shortHash(projectRoot);
     if (explicitScope?.trim()) {
@@ -54,6 +54,14 @@ export function buildProjectScopeKey(explicitScope) {
             projectRoot,
         };
     }
+    if (jiraIssueKey?.trim()) {
+        return {
+            scopeKey: `${sanitizeScopeName(jiraIssueKey)}@${worktreeHash}`,
+            gitBranchName: detectGitBranchName(),
+            worktreeHash,
+            projectRoot,
+        };
+    }
     const branchName = detectGitBranchName();
     const branchSlug = sanitizeScopeName(branchName ?? "detached-head");
     return {
@@ -72,7 +80,8 @@ export function parseJiraContext(jiraRef) {
     };
 }
 export function resolveProjectScope(explicitScope, jiraRef) {
-    const { scopeKey, gitBranchName, worktreeHash, projectRoot } = buildProjectScopeKey(explicitScope);
+    const jiraIssueKey = jiraRef?.trim() ? extractIssueKey(jiraRef) : undefined;
+    const { scopeKey, gitBranchName, worktreeHash, projectRoot } = buildProjectScopeKey(explicitScope, jiraIssueKey);
     ensureScopeWorkspaceDir(scopeKey);
     const baseScope = {
         scopeType: "project",

package/dist/structured-artifact-schema-registry.js

@@ -3,9 +3,11 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { TaskRunnerError } from "./errors.js";
 export const STRUCTURED_ARTIFACT_SCHEMA_IDS = [
+    "artifact-manifest/v1",
     "bug-analysis/v1",
     "bug-fix-design/v1",
     "bug-fix-plan/v1",
+    "design-review/v1",
     "gitlab-mr-diff/v1",
     "gitlab-review/v1",
     "implementation-design/v1",
@@ -17,9 +19,17 @@ export const STRUCTURED_ARTIFACT_SCHEMA_IDS = [
     "review-assessment/v1",
     "review-findings/v1",
     "review-fix-report/v1",
+    "task-context/v1",
     "task-summary/v1",
     "user-input/v1",
 ];
+export const ARTIFACT_PAYLOAD_SCHEMA_IDS = [
+    ...STRUCTURED_ARTIFACT_SCHEMA_IDS,
+    "helper-json/v1",
+    "markdown/v1",
+    "opaque-file/v1",
+    "plain-text/v1",
+];
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 export const SCHEMA_REGISTRY_PATH = path.join(MODULE_DIR, "structured-artifact-schemas.json");
 function isRecord(value) {

package/dist/structured-artifact-schemas.json

@@ -485,6 +485,123 @@
     },
     "required": ["summary", "test_scenarios", "non_functional_checks"]
   },
+  "design-review/v1": {
+    "type": "object",
+    "properties": {
+      "summary": { "type": "string", "nonEmpty": true },
+      "status": {
+        "type": "string",
+        "enum": ["approved", "approved_with_warnings", "needs_revision"]
+      },
+      "blocking_findings": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "title": { "type": "string", "nonEmpty": true },
+            "description": { "type": "string", "nonEmpty": true },
+            "affected_artifacts": {
+              "type": "array",
+              "items": { "type": "string", "nonEmpty": true },
+              "minItems": 1
+            }
+          },
+          "required": ["title", "description", "affected_artifacts"]
+        }
+      },
+      "major_findings": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "title": { "type": "string", "nonEmpty": true },
+            "description": { "type": "string", "nonEmpty": true },
+            "affected_artifacts": {
+              "type": "array",
+              "items": { "type": "string", "nonEmpty": true },
+              "minItems": 1
+            }
+          },
+          "required": ["title", "description", "affected_artifacts"]
+        }
+      },
+      "warnings": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "title": { "type": "string", "nonEmpty": true },
+            "description": { "type": "string", "nonEmpty": true },
+            "affected_artifacts": {
+              "type": "array",
+              "items": { "type": "string", "nonEmpty": true },
+              "minItems": 1
+            }
+          },
+          "required": ["title", "description", "affected_artifacts"]
+        }
+      },
+      "missing_information": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "title": { "type": "string", "nonEmpty": true },
+            "description": { "type": "string", "nonEmpty": true },
+            "affected_artifacts": {
+              "type": "array",
+              "items": { "type": "string", "nonEmpty": true },
+              "minItems": 1
+            }
+          },
+          "required": ["title", "description", "affected_artifacts"]
+        }
+      },
+      "consistency_checks": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": { "type": "string", "nonEmpty": true },
+            "status": { "type": "string", "nonEmpty": true },
+            "details": { "type": "string", "nonEmpty": true }
+          },
+          "required": ["name", "status", "details"]
+        }
+      },
+      "qa_coverage_gaps": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "title": { "type": "string", "nonEmpty": true },
+            "description": { "type": "string", "nonEmpty": true },
+            "affected_artifacts": {
+              "type": "array",
+              "items": { "type": "string", "nonEmpty": true },
+              "minItems": 1
+            }
+          },
+          "required": ["title", "description", "affected_artifacts"]
+        }
+      },
+      "recommended_actions": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      }
+    },
+    "required": [
+      "summary",
+      "status",
+      "blocking_findings",
+      "major_findings",
+      "warnings",
+      "missing_information",
+      "consistency_checks",
+      "qa_coverage_gaps",
+      "recommended_actions"
+    ]
+  },
   "review-findings/v1": {
     "type": "object",
     "properties": {
@@ -495,7 +612,7 @@
         "items": {
           "type": "object",
           "properties": {
-            "severity": { "type": "string", "nonEmpty": true },
+            "severity": { "type": "string", "enum": ["blocker", "critical", "high", "medium", "low", "info"] },
             "title": { "type": "string", "nonEmpty": true },
             "description": { "type": "string", "nonEmpty": true }
           },
@@ -543,6 +660,145 @@
     },
     "required": ["summary", "completed_actions", "validation_steps"]
   },
+  "helper-json/v1": {
+    "type": "json"
+  },
+  "markdown/v1": {
+    "type": "string",
+    "nonEmpty": true
+  },
+  "opaque-file/v1": {
+    "type": "bytes"
+  },
+  "plain-text/v1": {
+    "type": "string",
+    "nonEmpty": true
+  },
+  "artifact-manifest/v1": {
+    "type": "object",
+    "properties": {
+      "artifact_id": { "type": "string", "nonEmpty": true },
+      "logical_key": { "type": "string", "nonEmpty": true, "pattern": "^[a-z0-9][a-z0-9._/-]*$" },
+      "scope": { "type": "string", "nonEmpty": true },
+      "run_id": { "type": "string", "nonEmpty": true },
+      "flow_id": { "type": "string", "nonEmpty": true },
+      "phase_id": { "type": "string", "nonEmpty": true },
+      "step_id": { "type": "string", "nonEmpty": true },
+      "kind": { "type": "string", "enum": ["artifact", "file"] },
+      "version": { "type": "number" },
+      "payload_family": { "type": "string", "enum": ["structured-json", "markdown", "plain-text", "helper-json", "opaque-file"] },
+      "schema_id": { "type": "string", "nonEmpty": true },
+      "schema_version": { "type": "number" },
+      "created_at": { "type": "string", "nonEmpty": true },
+      "producer": {
+        "type": "object",
+        "properties": {
+          "node": { "type": "string", "nonEmpty": true },
+          "executor": { "type": "string", "nonEmpty": true },
+          "model": { "type": "string", "nonEmpty": true },
+          "summary": { "type": "string", "nonEmpty": true }
+        },
+        "required": ["node"]
+      },
+      "inputs": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "source": { "type": "string", "enum": ["manifest", "external-path"] },
+            "path": { "type": "string", "nonEmpty": true },
+            "artifact_id": { "type": "string", "nonEmpty": true },
+            "logical_key": { "type": "string", "nonEmpty": true, "pattern": "^[a-z0-9][a-z0-9._/-]*$" },
+            "schema_id": { "type": "string", "nonEmpty": true },
+            "schema_version": { "type": "number" }
+          },
+          "required": ["source", "path"]
+        }
+      },
+      "content_hash": { "type": "string", "nonEmpty": true, "pattern": "^sha256:[a-f0-9]{64}$" },
+      "status": { "type": "string", "enum": ["ready", "superseded", "stale"] },
+      "payload_path": { "type": "string", "nonEmpty": true },
+      "manifest_path": { "type": "string", "nonEmpty": true },
+      "publication_key": { "type": "string", "nonEmpty": true },
+      "supersedes": { "type": "string", "nonEmpty": true },
+      "status_reason": { "type": "string", "nonEmpty": true },
+      "diagnostics": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "code": { "type": "string", "nonEmpty": true },
+            "severity": { "type": "string", "enum": ["info", "warning", "error"] },
+            "message": { "type": "string", "nonEmpty": true }
+          },
+          "required": ["code", "severity", "message"]
+        }
+      }
+    },
+    "required": [
+      "artifact_id",
+      "logical_key",
+      "scope",
+      "run_id",
+      "flow_id",
+      "phase_id",
+      "step_id",
+      "kind",
+      "version",
+      "payload_family",
+      "schema_id",
+      "schema_version",
+      "created_at",
+      "producer",
+      "inputs",
+      "content_hash",
+      "status",
+      "payload_path",
+      "manifest_path",
+      "publication_key"
+    ]
+  },
+  "task-context/v1": {
+    "type": "object",
+    "properties": {
+      "source_type": {
+        "type": "string",
+        "nonEmpty": true,
+        "enum": ["jira", "manual"]
+      },
+      "title": { "type": "string", "nonEmpty": true },
+      "summary": { "type": "string", "nonEmpty": true },
+      "problem": { "type": "string", "nonEmpty": true },
+      "goal": { "type": "string", "nonEmpty": true },
+      "acceptance_criteria": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "constraints": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "references": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "notes": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      }
+    },
+    "required": [
+      "source_type",
+      "title",
+      "summary",
+      "problem",
+      "goal",
+      "acceptance_criteria",
+      "constraints",
+      "references",
+      "notes"
+    ]
+  },
   "task-summary/v1": {
     "type": "object",
     "properties": {