agentweaver 0.1.16 → 0.1.18

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,
+                    },
+                },
+            ],
+        };
+    },
+};

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

@@ -0,0 +1,243 @@
+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 { loadProjectPlaybook } from "../../runtime/playbook.js";
+import { validateStructuredArtifact, validateStructuredArtifactValue } from "../../structured-artifacts.js";
+function readJson(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to read JSON from ${filePath}: ${error.message}`);
+    }
+}
+function finalPlaybookPaths(cwd) {
+    const dir = path.join(cwd, ".agentweaver", "playbook");
+    return {
+        dir,
+        manifestFile: path.join(dir, "manifest.yaml"),
+        projectFile: path.join(dir, "project.md"),
+        practiceFile: path.join(dir, "practices", "generated-rules.md"),
+        exampleFile: path.join(dir, "examples", "generated-example.md"),
+        templateFile: path.join(dir, "templates", "default.md"),
+    };
+}
+function detectExistingState(cwd, manifestFile) {
+    if (!existsSync(manifestFile)) {
+        return { status: "absent", blockedPaths: [], message: "No manifest-based playbook exists." };
+    }
+    try {
+        loadProjectPlaybook(cwd);
+        return { status: "accepted", blockedPaths: [manifestFile], message: "A valid manifest-based playbook already exists." };
+    }
+    catch (error) {
+        return {
+            status: "blocked",
+            blockedPaths: [manifestFile],
+            message: `Existing manifest-based playbook is invalid or partial: ${error.message}`,
+        };
+    }
+}
+function toFinalPlaybook(draft, draftJsonFile) {
+    const evidence = Array.from(new Set([
+        ...(Array.isArray(draft.evidence_paths) ? draft.evidence_paths : []),
+        ...draft.accepted_rules.flatMap((rule) => rule.evidence_paths),
+    ])).sort((left, right) => left.localeCompare(right));
+    return {
+        status: "accepted",
+        accepted_at: new Date().toISOString(),
+        source_draft_artifact: draftJsonFile,
+        summary: draft.summary,
+        rules: draft.accepted_rules,
+        evidence_paths: evidence,
+    };
+}
+function renderFinalMarkdown(finalPlaybook) {
+    const rules = Array.isArray(finalPlaybook.rules) ? finalPlaybook.rules : [];
+    return [
+        "# Project playbook",
+        "",
+        String(finalPlaybook.summary ?? ""),
+        "",
+        "## Required rules",
+        ...(rules.length === 0
+            ? ["- No accepted required rules."]
+            : rules.map((rule) => `- ${rule.title}: ${rule.rule}\n  Evidence: ${rule.evidence_paths.join(", ")}`)),
+        "",
+    ].join("\n");
+}
+function yamlStringArray(values) {
+    return Array.from(new Set(values.filter((value) => value.trim().length > 0))).sort();
+}
+function quotedYamlString(value) {
+    return JSON.stringify(value);
+}
+function yamlList(values, indent = "") {
+    return values.length > 0 ? values.map((value) => `${indent}- ${quotedYamlString(value)}`) : [`${indent}[]`];
+}
+function renderPracticeMarkdown(draft) {
+    const body = draft.accepted_rules.length === 0
+        ? "No accepted project rules were generated."
+        : draft.accepted_rules.map((rule) => `## ${rule.title}\n\n${rule.rule}\n\nEvidence: ${rule.evidence_paths.join(", ")}`).join("\n\n");
+    return [
+        "---",
+        'id: "practice.generated-rules"',
+        'title: "Generated project rules"',
+        "phases:",
+        ...yamlList(["plan", "design_review", "implement", "review", "repair"], "  "),
+        "priority: 10",
+        'severity: "must"',
+        "related_practices: []",
+        "related_examples: []",
+        "---",
+        "",
+        body,
+        "",
+    ].join("\n");
+}
+function renderExampleMarkdown() {
+    return [
+        "---",
+        'id: "example.generated-guidance"',
+        'title: "Generated guidance reference"',
+        "phases:",
+        ...yamlList(["plan", "design_review", "implement", "review", "repair"], "  "),
+        "priority: 0",
+        'severity: "info"',
+        "related_practices:",
+        ...yamlList(["practice.generated-rules"], "  "),
+        "related_examples: []",
+        "---",
+        "",
+        "Use this entry as a reference marker for generated playbook guidance.",
+        "",
+    ].join("\n");
+}
+function renderManifest(draft) {
+    const evidence = yamlStringArray([
+        ...(Array.isArray(draft.evidence_paths) ? draft.evidence_paths : []),
+        ...draft.accepted_rules.flatMap((rule) => rule.evidence_paths),
+    ]);
+    return [
+        "version: 1",
+        "project:",
+        '  name: "Generated Project Playbook"',
+        "context_budgets:",
+        "  plan: 1200",
+        "  design_review: 1000",
+        "  implement: 1400",
+        "  review: 1000",
+        "  repair: 1000",
+        "practices:",
+        "  paths:",
+        ...yamlList(["practices/generated-rules.md"], "    "),
+        "  globs: []",
+        "examples:",
+        "  paths:",
+        ...yamlList(["examples/generated-example.md"], "    "),
+        "  globs: []",
+        "templates:",
+        "  paths:",
+        ...yamlList(["templates/default.md"], "    "),
+        "  globs: []",
+        "always_include:",
+        ...yamlList(["project.md"], "  "),
+        "selection:",
+        "  include_examples: true",
+        "  max_examples: 1",
+        "evidence_paths:",
+        ...yamlList(evidence, "  "),
+        "",
+    ].join("\n");
+}
+function writeResult(filePath, result) {
+    validateStructuredArtifactValue(result, "playbook-write-result/v1", filePath);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(result, null, 2)}\n`, "utf8");
+}
+function baseResult(status, message, intendedFiles) {
+    return {
+        status,
+        message,
+        written_files: [],
+        skipped_files: [],
+        existing_playbook_path: "",
+        intended_files: intendedFiles,
+        blocked_paths: [],
+    };
+}
+export const playbookWriteNode = {
+    kind: "playbook-write",
+    version: 1,
+    async run(context, params) {
+        const { dir, manifestFile, projectFile, practiceFile, exampleFile, templateFile } = finalPlaybookPaths(context.cwd);
+        const intendedFiles = [manifestFile, projectFile, practiceFile, exampleFile, templateFile];
+        const answers = existsSync(params.answersJsonFile) ? readJson(params.answersJsonFile) : {};
+        const accepted = answers.final_write_accepted === true;
+        let result;
+        if (!accepted) {
+            result = baseResult("not_accepted", "Final playbook write was not accepted in playbook-answers.json.", intendedFiles);
+            writeResult(params.writeResultJsonFile, result);
+            return { value: { ...result, finalJsonFile: manifestFile, finalMarkdownFile: projectFile, finalManifestFile: manifestFile }, outputs: outputSpecs(context.issueKey, params.writeResultJsonFile) };
+        }
+        if (context.dryRun) {
+            result = baseResult("dry_run_written", "Dry-run mode accepted the generated manifest layout but did not write final playbook files.", intendedFiles);
+            writeResult(params.writeResultJsonFile, result);
+            return { value: { ...result, finalJsonFile: manifestFile, finalMarkdownFile: projectFile, finalManifestFile: manifestFile }, outputs: outputSpecs(context.issueKey, params.writeResultJsonFile) };
+        }
+        const existing = detectExistingState(context.cwd, manifestFile);
+        if (existing.status === "accepted") {
+            result = {
+                ...baseResult("skipped_valid_existing", existing.message, intendedFiles),
+                skipped_files: intendedFiles,
+                existing_playbook_path: manifestFile,
+            };
+            writeResult(params.writeResultJsonFile, result);
+            return { value: { ...result, finalJsonFile: manifestFile, finalMarkdownFile: projectFile, finalManifestFile: manifestFile }, outputs: outputSpecs(context.issueKey, params.writeResultJsonFile) };
+        }
+        if (existing.status === "blocked") {
+            result = {
+                ...baseResult("blocked", existing.message, intendedFiles),
+                blocked_paths: existing.blockedPaths,
+            };
+            writeResult(params.writeResultJsonFile, result);
+            return { value: { ...result, finalJsonFile: manifestFile, finalMarkdownFile: projectFile, finalManifestFile: manifestFile }, outputs: outputSpecs(context.issueKey, params.writeResultJsonFile) };
+        }
+        validateStructuredArtifact(params.draftJsonFile, "playbook-draft/v1");
+        const draft = readJson(params.draftJsonFile);
+        const finalPlaybook = toFinalPlaybook(draft, params.draftJsonFile);
+        mkdirSync(dir, { recursive: true });
+        mkdirSync(path.dirname(practiceFile), { recursive: true });
+        mkdirSync(path.dirname(exampleFile), { recursive: true });
+        mkdirSync(path.dirname(templateFile), { recursive: true });
+        writeFileSync(manifestFile, renderManifest(draft), "utf8");
+        writeFileSync(projectFile, renderFinalMarkdown(finalPlaybook), "utf8");
+        writeFileSync(practiceFile, renderPracticeMarkdown(draft), "utf8");
+        writeFileSync(exampleFile, renderExampleMarkdown(), "utf8");
+        writeFileSync(templateFile, "# Default Template\n", "utf8");
+        loadProjectPlaybook(context.cwd);
+        result = {
+            ...baseResult("written", "Accepted playbook was written to the canonical manifest.yaml layout.", intendedFiles),
+            written_files: intendedFiles,
+        };
+        writeResult(params.writeResultJsonFile, result);
+        return { value: { ...result, finalJsonFile: manifestFile, finalMarkdownFile: projectFile, finalManifestFile: manifestFile }, outputs: outputSpecs(context.issueKey, params.writeResultJsonFile) };
+    },
+};
+function outputSpecs(scopeKey, writeResultJsonFile) {
+    return [
+        {
+            kind: "artifact",
+            path: writeResultJsonFile,
+            required: true,
+            manifest: {
+                publish: true,
+                logicalKey: buildLogicalKeyForPayload(scopeKey, writeResultJsonFile),
+                payloadFamily: "structured-json",
+                schemaId: "playbook-write-result/v1",
+                schemaVersion: 1,
+            },
+        },
+    ];
+}

package/dist/pipeline/nodes/project-guidance-node.js

@@ -0,0 +1,69 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
+import { TaskRunnerError } from "../../errors.js";
+import { buildProjectGuidance, renderProjectGuidanceMarkdown } from "../../runtime/project-guidance.js";
+import { validateStructuredArtifactValue } from "../../structured-artifacts.js";
+function readTaskContext(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to read task context JSON ${filePath}: ${error.message}`);
+    }
+}
+export const projectGuidanceNode = {
+    kind: "project-guidance",
+    version: 1,
+    async run(context, params) {
+        const taskContext = readTaskContext(params.taskContextJsonFile);
+        const guidance = buildProjectGuidance({
+            projectRoot: context.cwd,
+            taskContext,
+            phase: params.phase,
+            ...(params.budgetLimit !== undefined ? { budgetLimit: params.budgetLimit } : {}),
+            ...(params.inlineThreshold !== undefined ? { inlineThreshold: params.inlineThreshold } : {}),
+            invalidPlaybookPolicy: params.invalidPlaybookPolicy ?? "fail_before_prompt",
+        });
+        validateStructuredArtifactValue(guidance, "project-guidance/v1", params.outputJsonFile);
+        mkdirSync(path.dirname(params.outputJsonFile), { recursive: true });
+        writeFileSync(params.outputJsonFile, `${JSON.stringify(guidance, null, 2)}\n`, "utf8");
+        const markdown = renderProjectGuidanceMarkdown(guidance, params.markdownLanguage ?? context.mdLang ?? "en");
+        mkdirSync(path.dirname(params.outputFile), { recursive: true });
+        writeFileSync(params.outputFile, markdown, "utf8");
+        return {
+            value: {
+                status: guidance.status,
+                phase: guidance.phase,
+                outputJsonFile: params.outputJsonFile,
+                outputFile: params.outputFile,
+            },
+            outputs: [
+                {
+                    kind: "artifact",
+                    path: params.outputJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputJsonFile),
+                        payloadFamily: "structured-json",
+                        schemaId: "project-guidance/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,
+                    },
+                },
+            ],
+        };
+    },
+};