agentweaver 0.1.17 → 0.1.18

package/dist/pipeline/node-registry.js

@@ -21,8 +21,13 @@ import { localScriptCheckNode } from "./nodes/local-script-check-node.js";
 import { llmPromptNode } from "./nodes/llm-prompt-node.js";
 import { opencodePromptNode } from "./nodes/opencode-prompt-node.js";
 import { planCodexNode } from "./nodes/plan-codex-node.js";
+import { playbookInventoryNode } from "./nodes/playbook-inventory-node.js";
+import { playbookEnsureNode } from "./nodes/playbook-ensure-node.js";
+import { playbookQuestionsFormNode } from "./nodes/playbook-questions-form-node.js";
+import { playbookWriteNode } from "./nodes/playbook-write-node.js";
 import { planningBundleNode } from "./nodes/planning-bundle-node.js";
 import { planningQuestionsFormNode } from "./nodes/planning-questions-form-node.js";
+import { projectGuidanceNode } from "./nodes/project-guidance-node.js";
 import { readFileNode } from "./nodes/read-file-node.js";
 import { reviewFindingsFormNode } from "./nodes/review-findings-form-node.js";
 import { reviewVerdictNode } from "./nodes/review-verdict-node.js";
@@ -57,8 +62,13 @@ export const BUILT_IN_NODE_KINDS = [
     "llm-prompt",
     "opencode-prompt",
     "plan-codex",
+    "playbook-inventory",
+    "playbook-ensure",
+    "playbook-questions-form",
+    "playbook-write",
     "planning-bundle",
     "planning-questions-form",
+    "project-guidance",
     "read-file",
     "review-findings-form",
     "review-verdict",
@@ -93,8 +103,13 @@ const builtInNodes = {
     "llm-prompt": llmPromptNode,
     "opencode-prompt": opencodePromptNode,
     "plan-codex": planCodexNode,
+    "playbook-inventory": playbookInventoryNode,
+    "playbook-ensure": playbookEnsureNode,
+    "playbook-questions-form": playbookQuestionsFormNode,
+    "playbook-write": playbookWriteNode,
     "planning-bundle": planningBundleNode,
     "planning-questions-form": planningQuestionsFormNode,
+    "project-guidance": projectGuidanceNode,
     "read-file": readFileNode,
     "review-findings-form": reviewFindingsFormNode,
     "review-verdict": reviewVerdictNode,
@@ -228,6 +243,30 @@ const builtInNodeMetadata = {
         requiredParams: ["prompt", "requiredArtifacts"],
         executors: ["codex"],
     },
+    "playbook-inventory": {
+        kind: "playbook-inventory",
+        version: 1,
+        prompt: "forbidden",
+        requiredParams: ["outputJsonFile", "outputFile"],
+    },
+    "playbook-ensure": {
+        kind: "playbook-ensure",
+        version: 1,
+        prompt: "forbidden",
+        requiredParams: ["writeResultJsonFile"],
+    },
+    "playbook-questions-form": {
+        kind: "playbook-questions-form",
+        version: 1,
+        prompt: "forbidden",
+        requiredParams: ["questionsJsonFile", "answersJsonFile", "formId", "title"],
+    },
+    "playbook-write": {
+        kind: "playbook-write",
+        version: 1,
+        prompt: "forbidden",
+        requiredParams: ["draftJsonFile", "answersJsonFile", "writeResultJsonFile"],
+    },
     "planning-bundle": {
         kind: "planning-bundle",
         version: 1,
@@ -240,6 +279,12 @@ const builtInNodeMetadata = {
         prompt: "forbidden",
         requiredParams: ["planningQuestionsJsonFile", "formId", "title"],
     },
+    "project-guidance": {
+        kind: "project-guidance",
+        version: 1,
+        prompt: "forbidden",
+        requiredParams: ["taskContextJsonFile", "phase", "outputJsonFile", "outputFile"],
+    },
     "read-file": { kind: "read-file", version: 1, prompt: "forbidden", requiredParams: ["path"] },
     "review-findings-form": {
         kind: "review-findings-form",

package/dist/pipeline/nodes/flow-run-node.js

@@ -64,6 +64,8 @@ export function resolveNestedFlowParams(flowKind, flowParams) {
             hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
             taskInputJsonFilePath: contract.taskInputJsonFilePath,
             taskInputJsonFile: contract.taskInputJsonFile,
+            projectGuidanceFile: flowParams["projectGuidanceFile"] ?? "not provided",
+            projectGuidanceJsonFile: flowParams["projectGuidanceJsonFile"] ?? "not provided",
         }, {
             "params.designFile": contract.designFile,
             "params.designJsonFile": contract.designJsonFile,
@@ -135,6 +137,8 @@ export function resolveNestedFlowParams(flowKind, flowParams) {
             hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
             taskInputJsonFilePath: contract.taskInputJsonFilePath,
             taskInputJsonFile: contract.taskInputJsonFile,
+            projectGuidanceFile: flowParams["projectGuidanceFile"] ?? "not provided",
+            projectGuidanceJsonFile: flowParams["projectGuidanceJsonFile"] ?? "not provided",
         }, {
             "params.reviewFile": contract.reviewFile,
             "params.reviewJsonFile": contract.reviewJsonFile,
@@ -188,6 +192,8 @@ export function resolveNestedFlowParams(flowKind, flowParams) {
             hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
             taskInputJsonFilePath: contract.taskInputJsonFilePath,
             taskInputJsonFile: contract.taskInputJsonFile,
+            projectGuidanceFile: flowParams["projectGuidanceFile"] ?? "not provided",
+            projectGuidanceJsonFile: flowParams["projectGuidanceJsonFile"] ?? "not provided",
         }, {
             "params.designFile": contract.designFile,
             "params.designJsonFile": contract.designJsonFile,
@@ -218,7 +224,13 @@ export const flowRunNode = {
         const flow = await loadNamedDeclarativeFlow(fileName, context.cwd, {
             ...(context.registryContext ? { registryContext: context.registryContext } : {}),
         });
-        const resolvedFlowParams = resolveNestedFlowParams(flow.kind, flowParams);
+        const resolvedFlowParams = resolveNestedFlowParams(flow.kind, {
+            projectGuidanceFile: "not provided",
+            projectGuidanceJsonFile: "not provided",
+            repairProjectGuidanceFile: "not provided",
+            repairProjectGuidanceJsonFile: "not provided",
+            ...flowParams,
+        });
         const resumeValue = isFlowRunResumeEnvelope(context.resumeStepValue)
             && context.resumeStepValue.flowKind === flow.kind
             && context.resumeStepValue.flowVersion === flow.version

package/dist/pipeline/nodes/playbook-ensure-node.js

@@ -0,0 +1,115 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
+import { loadProjectPlaybook, PLAYBOOK_DIR, PLAYBOOK_MANIFEST } from "../../runtime/playbook.js";
+import { validateStructuredArtifactValue } from "../../structured-artifacts.js";
+function readWriteStatus(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        return typeof parsed.status === "string" ? parsed.status : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeResult(scopeKey, filePath, result) {
+    const artifact = {
+        status: result.status,
+        message: result.message,
+        written_files: result.written_files,
+        skipped_files: result.skipped_files,
+        existing_playbook_path: result.existing_playbook_path,
+        intended_files: result.intended_files,
+        blocked_paths: result.blocked_paths,
+    };
+    validateStructuredArtifactValue(artifact, "playbook-write-result/v1", filePath);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
+    return [
+        {
+            kind: "artifact",
+            path: filePath,
+            required: true,
+            manifest: {
+                publish: true,
+                logicalKey: buildLogicalKeyForPayload(scopeKey, filePath),
+                payloadFamily: "structured-json",
+                schemaId: "playbook-write-result/v1",
+                schemaVersion: 1,
+            },
+        },
+    ];
+}
+export const playbookEnsureNode = {
+    kind: "playbook-ensure",
+    version: 1,
+    async run(context, params) {
+        const playbookRoot = path.join(context.cwd, PLAYBOOK_DIR);
+        const manifestPath = path.join(playbookRoot, PLAYBOOK_MANIFEST);
+        const intendedFiles = [manifestPath];
+        const priorStatus = params.verifyAfterInit ? readWriteStatus(params.writeResultJsonFile) : null;
+        if (!existsSync(manifestPath)) {
+            if (params.verifyAfterInit && priorStatus === "dry_run_written") {
+                const result = {
+                    status: "dry_run_written",
+                    message: "Dry-run playbook generation was accepted; manifest.yaml was not written in dry-run mode.",
+                    written_files: [],
+                    skipped_files: [],
+                    existing_playbook_path: "",
+                    intended_files: intendedFiles,
+                    blocked_paths: [],
+                    shouldRunPlaybookInit: false,
+                    manifestPath,
+                };
+                return { value: result, outputs: writeResult(context.issueKey, params.writeResultJsonFile, result) };
+            }
+            const accepted = params.acceptPlaybookDraft === true;
+            const result = {
+                status: accepted ? "missing_playbook" : "blocked",
+                message: accepted
+                    ? `Playbook manifest is missing: ${manifestPath}. Running playbook-init because acceptPlaybookDraft is true.`
+                    : `Playbook manifest is missing: ${manifestPath}. Run 'agentweaver playbook-init --accept-playbook-draft' first, or rerun 'agentweaver auto-common-guided --accept-playbook-draft <jira>' to explicitly accept generated playbook content before planning.`,
+                written_files: [],
+                skipped_files: [],
+                existing_playbook_path: "",
+                intended_files: intendedFiles,
+                blocked_paths: accepted ? [] : [manifestPath],
+                shouldRunPlaybookInit: accepted,
+                manifestPath,
+            };
+            return { value: result, outputs: writeResult(context.issueKey, params.writeResultJsonFile, result) };
+        }
+        try {
+            loadProjectPlaybook(context.cwd);
+        }
+        catch (error) {
+            const result = {
+                status: "invalid_manifest",
+                message: `Invalid project playbook ${manifestPath}: ${error.message}`,
+                written_files: [],
+                skipped_files: [],
+                existing_playbook_path: "",
+                intended_files: intendedFiles,
+                blocked_paths: [manifestPath],
+                shouldRunPlaybookInit: false,
+                manifestPath,
+            };
+            return { value: result, outputs: writeResult(context.issueKey, params.writeResultJsonFile, result) };
+        }
+        const result = {
+            status: "skipped_valid_existing",
+            message: `Valid project playbook manifest exists: ${manifestPath}.`,
+            written_files: [],
+            skipped_files: [manifestPath],
+            existing_playbook_path: manifestPath,
+            intended_files: intendedFiles,
+            blocked_paths: [],
+            shouldRunPlaybookInit: false,
+            manifestPath,
+        };
+        return { value: result, outputs: writeResult(context.issueKey, params.writeResultJsonFile, result) };
+    },
+};

package/dist/pipeline/nodes/playbook-inventory-node.js

@@ -0,0 +1,51 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
+import { validateStructuredArtifactValue } from "../../structured-artifacts.js";
+import { collectRepoInventory, renderRepoInventoryMarkdown } from "../../playbook/repo-inventory.js";
+export const playbookInventoryNode = {
+    kind: "playbook-inventory",
+    version: 1,
+    async run(context, params) {
+        const inventory = collectRepoInventory(context.cwd);
+        validateStructuredArtifactValue(inventory, "repo-inventory/v1", params.outputJsonFile);
+        mkdirSync(path.dirname(params.outputJsonFile), { recursive: true });
+        mkdirSync(path.dirname(params.outputFile), { recursive: true });
+        writeFileSync(params.outputJsonFile, `${JSON.stringify(inventory, null, 2)}\n`, "utf8");
+        writeFileSync(params.outputFile, renderRepoInventoryMarkdown(inventory), "utf8");
+        return {
+            value: {
+                summary: inventory.summary,
+                outputJsonFile: params.outputJsonFile,
+                outputFile: params.outputFile,
+                evidenceCount: inventory.evidence.length,
+            },
+            outputs: [
+                {
+                    kind: "artifact",
+                    path: params.outputJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputJsonFile),
+                        payloadFamily: "structured-json",
+                        schemaId: "repo-inventory/v1",
+                        schemaVersion: 1,
+                    },
+                },
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                        payloadFamily: "markdown",
+                        schemaId: "markdown/v1",
+                        schemaVersion: 1,
+                    },
+                },
+            ],
+        };
+    },
+};

package/dist/pipeline/nodes/playbook-questions-form-node.js

@@ -0,0 +1,166 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
+import { TaskRunnerError } from "../../errors.js";
+import { validateStructuredArtifactValue } from "../../structured-artifacts.js";
+import { requestUserInputInTerminal } from "../../user-input.js";
+function nowIso8601() {
+    return new Date().toISOString();
+}
+function readQuestions(filePath) {
+    if (!existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        return Array.isArray(parsed.questions) ? parsed.questions : [];
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to read playbook questions from ${filePath}: ${error.message}`);
+    }
+}
+function readExistingAnswers(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to read playbook answers from ${filePath}: ${error.message}`);
+    }
+}
+function fieldForQuestion(question, index) {
+    const text = typeof question.text === "string" ? question.text.trim() : "";
+    if (!text) {
+        return null;
+    }
+    const id = typeof question.id === "string" && question.id.trim() ? question.id.trim() : `question_${index + 1}`;
+    return {
+        id,
+        type: "text",
+        label: text,
+        required: false,
+        multiline: true,
+        default: "",
+        ...(typeof question.rationale === "string" && question.rationale.trim() ? { help: question.rationale.trim() } : {}),
+    };
+}
+function answersFromValues(fields, values) {
+    return fields.map((field) => {
+        const value = values[field.id];
+        return {
+            question_id: field.id,
+            answer: typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value),
+        };
+    });
+}
+function writeAnswers(filePath, artifact) {
+    validateStructuredArtifactValue(artifact, "playbook-answers/v1", filePath);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
+}
+export const playbookQuestionsFormNode = {
+    kind: "playbook-questions-form",
+    version: 1,
+    async run(context, params) {
+        const mode = params.mode ?? "clarifications";
+        const existing = readExistingAnswers(params.answersJsonFile);
+        if (mode === "acceptance") {
+            let finalWriteAccepted = params.acceptDraft === true;
+            const interactive = context.requestUserInput !== requestUserInputInTerminal || (process.stdin.isTTY && process.stdout.isTTY);
+            if (params.acceptDraft !== true && interactive) {
+                const result = await (context.requestUserInput ?? requestUserInputInTerminal)({
+                    formId: params.formId,
+                    title: params.title,
+                    submitLabel: "Confirm",
+                    fields: [
+                        {
+                            id: "final_write_accepted",
+                            type: "boolean",
+                            label: "Write final .agentweaver/playbook files if safety checks pass?",
+                            required: true,
+                            default: false,
+                        },
+                    ],
+                });
+                finalWriteAccepted = result.values.final_write_accepted === true;
+            }
+            const artifact = {
+                summary: finalWriteAccepted ? "Final playbook write was accepted." : "Final playbook write was not accepted.",
+                answered_at: nowIso8601(),
+                answers: existing?.answers ?? [],
+                final_write_accepted: finalWriteAccepted,
+            };
+            writeAnswers(params.answersJsonFile, artifact);
+            return {
+                value: {
+                    formId: params.formId,
+                    questionCount: existing?.answers.length ?? 0,
+                    finalWriteAccepted,
+                    outputFile: params.answersJsonFile,
+                },
+                outputs: [
+                    {
+                        kind: "artifact",
+                        path: params.answersJsonFile,
+                        required: true,
+                        manifest: {
+                            publish: true,
+                            logicalKey: buildLogicalKeyForPayload(context.issueKey, params.answersJsonFile),
+                            payloadFamily: "structured-json",
+                            schemaId: "playbook-answers/v1",
+                            schemaVersion: 1,
+                        },
+                    },
+                ],
+            };
+        }
+        const fields = readQuestions(params.questionsJsonFile)
+            .map((question, index) => fieldForQuestion(question, index))
+            .filter((field) => field !== null);
+        let answers = [];
+        const interactive = fields.length === 0 || context.requestUserInput !== requestUserInputInTerminal || (process.stdin.isTTY && process.stdout.isTTY);
+        if (fields.length > 0 && !interactive) {
+            answers = fields.map((field) => ({ question_id: field.id, answer: "" }));
+        }
+        else if (fields.length > 0) {
+            const result = await (context.requestUserInput ?? requestUserInputInTerminal)({
+                formId: params.formId,
+                title: params.title,
+                submitLabel: "Continue",
+                fields,
+            });
+            answers = answersFromValues(fields, result.values);
+        }
+        const artifact = {
+            summary: fields.length === 0 ? "No clarification questions were required." : "Playbook clarification answers were recorded.",
+            answered_at: nowIso8601(),
+            answers,
+            final_write_accepted: params.acceptDraft === true,
+        };
+        writeAnswers(params.answersJsonFile, artifact);
+        return {
+            value: {
+                formId: params.formId,
+                questionCount: fields.length,
+                finalWriteAccepted: artifact.final_write_accepted,
+                outputFile: params.answersJsonFile,
+            },
+            outputs: [
+                {
+                    kind: "artifact",
+                    path: params.answersJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.answersJsonFile),
+                        payloadFamily: "structured-json",
+                        schemaId: "playbook-answers/v1",
+                        schemaVersion: 1,
+                    },
+                },
+            ],
+        };
+    },
+};