agentplane 0.3.6 → 0.3.8

package/dist/commands/shared/task-store.js

@@ -1,40 +1,44 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
-import { ensureDocSections, docChanged, extractTaskDoc, mergeTaskDoc, parseTaskReadme, renderTaskReadme, setMarkdownSection, } from "@agentplaneorg/core";
+import { applyTaskDocMutations, docChanged, extractTaskDoc, mergeTaskDoc, normalizeTaskDocVersion, parseTaskReadme, renderTaskReadme, taskDocToSectionMap, } from "@agentplaneorg/core";
 import { LocalBackend, taskRecordToData, } from "../../backends/task-backend.js";
 import { exitCodeForError } from "../../cli/exit-codes.js";
 import { CliError } from "../../shared/errors.js";
+import { assertExpectedTaskDoc, assertExpectedTaskSection, } from "../../shared/task-doc-conflicts.js";
 import { writeTextIfChanged } from "../../shared/write-if-changed.js";
 import { resolveDocUpdatedBy, taskDataToFrontmatter } from "./task-backend.js";
+export function setTaskFieldsIntent(task) {
+    return { kind: "set-task-fields", task };
+}
+export function appendTaskCommentsIntent(comments) {
+    return { kind: "append-comments", comments };
+}
+export function appendTaskCommentIntent(comment) {
+    return appendTaskCommentsIntent([comment]);
+}
+export function appendTaskEventsIntent(events) {
+    return { kind: "append-events", events };
+}
+export function appendTaskEventIntent(event) {
+    return appendTaskEventsIntent([event]);
+}
+export function replaceTaskDocIntent(opts) {
+    return { kind: "replace-doc", ...opts };
+}
+export function setTaskSectionIntent(opts) {
+    return { kind: "set-section", ...opts };
+}
+export function touchTaskDocMetaIntent(opts = {}) {
+    return { kind: "touch-doc-meta", ...opts };
+}
 function taskReadmePath(ctx, taskId) {
     return path.join(ctx.resolvedProject.gitRoot, ctx.config.paths.workflow_dir, taskId, "README.md");
 }
-function normalizeTaskDocVersion(value, fallback = 2) {
-    return value === 3 ? 3 : value === 2 ? 2 : fallback;
+function normalizeTaskRevision(value, fallback = 1) {
+    return Number.isInteger(value) && Number(value) > 0 ? Number(value) : fallback;
 }
-function normalizeDocComparison(text) {
-    return String(text ?? "")
-        .replaceAll("\r\n", "\n")
-        .trim();
-}
-function extractDocSectionText(doc, sectionName) {
-    const lines = doc.replaceAll("\r\n", "\n").split("\n");
-    let capturing = false;
-    const out = [];
-    for (const line of lines) {
-        const match = /^##\s+(.*)$/.exec(line.trim());
-        if (match) {
-            if (capturing)
-                break;
-            capturing = (match[1] ?? "").trim() === sectionName;
-            continue;
-        }
-        if (capturing)
-            out.push(line);
-    }
-    if (!capturing)
-        return null;
-    return out.join("\n").trimEnd();
+function readStoredTaskRevision(value) {
+    return Number.isInteger(value) && Number(value) > 0 ? Number(value) : null;
 }
 function normalizeComments(task) {
     return Array.isArray(task.comments)
@@ -54,51 +58,244 @@ function isConcurrentReadmeChangeError(err) {
         err.code === "E_IO" &&
         err.message.startsWith("Task README changed concurrently:"));
 }
-function throwTaskSectionConflict(opts) {
+function throwTaskRevisionConflict(opts) {
     throw new CliError({
         exitCode: exitCodeForError("E_VALIDATION"),
         code: "E_VALIDATION",
-        message: `Task README section changed concurrently: ${opts.taskId} ## ${opts.section} ` +
-            "(re-read the task and re-apply your change)",
+        message: `Task revision changed concurrently: ${opts.taskId} ` +
+            `(expected revision ${opts.expectedRevision}, current revision ${opts.currentRevision})`,
         context: {
             task_id: opts.taskId,
-            section: opts.section,
-            reason_code: "task_readme_section_conflict",
+            expected_revision: opts.expectedRevision,
+            current_revision: opts.currentRevision,
+            reason_code: "task_revision_conflict",
         },
     });
 }
-function throwTaskDocConflict(opts) {
-    throw new CliError({
-        exitCode: exitCodeForError("E_VALIDATION"),
-        code: "E_VALIDATION",
-        message: `Task README changed concurrently: ${opts.taskId} ` +
-            "(re-read the task and re-apply your change)",
-        context: {
-            task_id: opts.taskId,
-            reason_code: "task_readme_conflict",
-        },
+function applyDocMutationsToState(docState, mutations, opts) {
+    const applied = applyTaskDocMutations(docState, mutations, {
+        now: opts.docUpdatedAt,
     });
+    return {
+        ...docState,
+        doc: applied.doc,
+        sections: applied.sections,
+        doc_version: applied.doc_version,
+        doc_updated_at: applied.doc_updated_at,
+        doc_updated_by: applied.doc_updated_by,
+    };
+}
+function normalizeTaskStoreIntents(intents) {
+    if (!intents)
+        return [];
+    if (Array.isArray(intents)) {
+        return intents.filter((intent) => intent != null);
+    }
+    return [intents];
 }
-function applyTaskDocPatch(opts) {
-    if (opts.patch.kind === "replace-doc") {
-        if (opts.patch.expectedCurrentDoc !== undefined) {
-            const currentDoc = normalizeDocComparison(opts.currentDocRaw);
-            const expectedDoc = normalizeDocComparison(opts.patch.expectedCurrentDoc);
-            if (currentDoc !== expectedDoc) {
-                throwTaskDocConflict({ taskId: opts.taskId });
+function patchToIntents(patch) {
+    if (!patch)
+        return [];
+    const intents = [];
+    if (patch.task) {
+        intents.push(setTaskFieldsIntent(patch.task));
+    }
+    if (patch.appendComments && patch.appendComments.length > 0) {
+        intents.push(appendTaskCommentsIntent(patch.appendComments));
+    }
+    if (patch.appendEvents && patch.appendEvents.length > 0) {
+        intents.push(appendTaskEventsIntent(patch.appendEvents));
+    }
+    if (patch.doc) {
+        intents.push(patch.doc.kind === "replace-doc"
+            ? replaceTaskDocIntent({
+                doc: patch.doc.doc,
+                expectedCurrentDoc: patch.doc.expectedCurrentDoc,
+            })
+            : setTaskSectionIntent({
+                section: patch.doc.section,
+                text: patch.doc.text,
+                requiredSections: patch.doc.requiredSections,
+                expectedCurrentText: patch.doc.expectedCurrentText,
+            }));
+    }
+    if (patch.docMeta && (patch.doc !== undefined || patch.docMeta.touch === true)) {
+        intents.push(touchTaskDocMetaIntent({
+            updatedBy: patch.docMeta.updatedBy,
+            version: patch.docMeta.version,
+        }));
+    }
+    return intents;
+}
+export function taskStorePatchFromIntents(intents) {
+    const normalized = normalizeTaskStoreIntents(intents);
+    if (normalized.length === 0)
+        return null;
+    const patch = {};
+    for (const intent of normalized) {
+        switch (intent.kind) {
+            case "set-task-fields": {
+                patch.task = patch.task ? { ...patch.task, ...intent.task } : { ...intent.task };
+                break;
+            }
+            case "append-comments": {
+                if (intent.comments.length > 0) {
+                    patch.appendComments = [...(patch.appendComments ?? []), ...intent.comments];
+                }
+                break;
+            }
+            case "append-events": {
+                if (intent.events.length > 0) {
+                    patch.appendEvents = [...(patch.appendEvents ?? []), ...intent.events];
+                }
+                break;
+            }
+            case "replace-doc": {
+                const docPatch = {
+                    kind: "replace-doc",
+                    doc: intent.doc,
+                };
+                if (intent.expectedCurrentDoc === undefined) {
+                    patch.doc = docPatch;
+                    break;
+                }
+                docPatch.expectedCurrentDoc = intent.expectedCurrentDoc;
+                patch.doc = docPatch;
+                break;
+            }
+            case "set-section": {
+                const sectionPatch = {
+                    kind: "set-section",
+                    section: intent.section,
+                    text: intent.text,
+                    requiredSections: [...intent.requiredSections],
+                };
+                if (intent.expectedCurrentText === undefined) {
+                    patch.doc = sectionPatch;
+                    break;
+                }
+                sectionPatch.expectedCurrentText = intent.expectedCurrentText;
+                patch.doc = sectionPatch;
+                break;
+            }
+            case "touch-doc-meta": {
+                patch.docMeta = {
+                    touch: true,
+                    updatedBy: intent.updatedBy ?? patch.docMeta?.updatedBy,
+                    version: intent.version ?? patch.docMeta?.version,
+                };
+                break;
             }
         }
-        return opts.patch.doc;
     }
-    const baseDoc = ensureDocSections(opts.currentDocRaw, opts.patch.requiredSections);
-    if (opts.patch.expectedCurrentText !== undefined) {
-        const currentSection = normalizeDocComparison(extractDocSectionText(baseDoc, opts.patch.section));
-        const expectedSection = normalizeDocComparison(opts.patch.expectedCurrentText);
-        if (currentSection !== expectedSection) {
-            throwTaskSectionConflict({ taskId: opts.taskId, section: opts.patch.section });
+    return patch;
+}
+export async function mutateTaskStore(store, taskId, builder, opts = {}) {
+    if (typeof store.mutate === "function") {
+        return await store.mutate(taskId, builder, opts);
+    }
+    return await store.patch(taskId, async (current) => taskStorePatchFromIntents(await builder(current)), opts);
+}
+export function applyTaskStoreIntentsToTask(task, intents, opts = {}) {
+    const normalizedIntents = normalizeTaskStoreIntents(intents);
+    if (normalizedIntents.length === 0)
+        return { ...task };
+    const current = task;
+    const next = { ...current };
+    let docState = {
+        comments: next.comments ?? null,
+        doc: String(next.doc ?? ""),
+        doc_updated_by: next.doc_updated_by,
+        doc_version: normalizeTaskDocVersion(opts.currentDocVersion ?? task.doc_version),
+        owner: next.owner,
+        sections: next.sections ?? null,
+    };
+    let touchDoc = false;
+    for (const intent of normalizedIntents) {
+        switch (intent.kind) {
+            case "set-task-fields": {
+                Object.assign(next, intent.task);
+                docState = {
+                    ...docState,
+                    doc_updated_by: next.doc_updated_by,
+                    doc_version: normalizeTaskDocVersion(next.doc_version ?? docState.doc_version),
+                    owner: next.owner,
+                };
+                break;
+            }
+            case "append-comments": {
+                if (intent.comments.length > 0) {
+                    next.comments = [...normalizeComments(next), ...intent.comments];
+                    docState = { ...docState, comments: next.comments };
+                }
+                break;
+            }
+            case "append-events": {
+                if (intent.events.length > 0) {
+                    next.events = [...normalizeEvents(next), ...intent.events];
+                }
+                break;
+            }
+            case "replace-doc": {
+                if (intent.expectedCurrentDoc !== undefined) {
+                    assertExpectedTaskDoc({
+                        taskId: current.id,
+                        currentDoc: docState.doc,
+                        expectedDoc: intent.expectedCurrentDoc,
+                    });
+                }
+                docState = applyDocMutationsToState(docState, [{ kind: "replace-doc", doc: intent.doc }], {
+                    docUpdatedAt: opts.docUpdatedAt,
+                });
+                touchDoc = true;
+                break;
+            }
+            case "set-section": {
+                if (intent.expectedCurrentText !== undefined) {
+                    assertExpectedTaskSection({
+                        taskId: current.id,
+                        currentDoc: docState.doc,
+                        section: intent.section,
+                        expectedText: intent.expectedCurrentText,
+                    });
+                }
+                docState = applyDocMutationsToState(docState, [
+                    {
+                        kind: "set-section",
+                        section: intent.section,
+                        text: intent.text,
+                        requiredSections: intent.requiredSections,
+                    },
+                ], { docUpdatedAt: opts.docUpdatedAt });
+                touchDoc = true;
+                break;
+            }
+            case "touch-doc-meta": {
+                docState = applyDocMutationsToState(docState, [
+                    {
+                        kind: "touch-doc-meta",
+                        updatedBy: intent.updatedBy,
+                        version: intent.version,
+                    },
+                ], { docUpdatedAt: opts.docUpdatedAt });
+                touchDoc = true;
+                break;
+            }
         }
     }
-    return ensureDocSections(setMarkdownSection(baseDoc, opts.patch.section, opts.patch.text), opts.patch.requiredSections);
+    if (touchDoc) {
+        next.doc = docState.doc;
+        next.sections = docState.sections ?? taskDocToSectionMap(docState.doc);
+        next.doc_version = docState.doc_version;
+        next.doc_updated_at = docState.doc_updated_at;
+        next.doc_updated_by = docState.doc_updated_by;
+    }
+    return next;
+}
+function applyTaskStoreIntents(entry, intents) {
+    return applyTaskStoreIntentsToTask(entry.task, intents, {
+        currentDocVersion: normalizeTaskDocVersion(entry.parsed.frontmatter.doc_version),
+    });
 }
 async function readTaskReadmeCached(opts) {
     const readmePath = taskReadmePath(opts.ctx, opts.taskId);
@@ -126,7 +323,7 @@ async function readTaskReadmeCached(opts) {
         body: parsed.body,
         readmePath,
     });
-    return { task, readmePath, mtimeMs: st.mtimeMs, parsed };
+    return { task, readmePath, mtimeMs: st.mtimeMs, parsed, rawText: text };
 }
 async function ensureUnchangedOnDisk(opts) {
     const st = await stat(opts.readmePath);
@@ -138,6 +335,18 @@ async function ensureUnchangedOnDisk(opts) {
         });
     }
 }
+async function didReadmeChangeOnDisk(opts) {
+    try {
+        const st = await stat(opts.readmePath);
+        return st.mtimeMs !== opts.expectedMtimeMs;
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return true;
+        throw err;
+    }
+}
 export class TaskStore {
     ctx;
     cache = new Map();
@@ -169,45 +378,47 @@ export class TaskStore {
         this.cache.set(key, load);
         return await load;
     }
-    async update(taskId, updater) {
-        return await this.runWithRetry(taskId, async (entry) => {
+    async update(taskId, updater, opts = {}) {
+        return await this.runWithRetry(taskId, opts, async (entry) => {
             return await updater({ ...entry.task });
         });
     }
-    async patch(taskId, builder) {
-        return await this.runWithRetry(taskId, async (entry) => {
-            const patch = await builder({ ...entry.task });
-            if (!patch)
-                return { ...entry.task };
-            const current = entry.task;
-            const next = patch.task ? { ...current, ...patch.task } : { ...current };
-            if (patch.appendComments && patch.appendComments.length > 0) {
-                next.comments = [...normalizeComments(current), ...patch.appendComments];
-            }
-            if (patch.appendEvents && patch.appendEvents.length > 0) {
-                next.events = [...normalizeEvents(current), ...patch.appendEvents];
-            }
-            if (patch.doc) {
-                next.doc = applyTaskDocPatch({
-                    taskId: current.id,
-                    currentDocRaw: String(current.doc ?? ""),
-                    patch: patch.doc,
-                });
-            }
-            const touchDoc = patch.doc !== undefined || patch.docMeta?.touch === true;
-            if (touchDoc) {
-                const currentDocVersion = normalizeTaskDocVersion(entry.parsed.frontmatter.doc_version);
-                next.doc_version = normalizeTaskDocVersion(patch.docMeta?.version ?? current.doc_version, currentDocVersion);
-                next.doc_updated_at = new Date().toISOString();
-                next.doc_updated_by = patch.docMeta?.updatedBy ?? resolveDocUpdatedBy(next);
-            }
-            return next;
+    async patch(taskId, builder, opts = {}) {
+        return await this.mutate(taskId, async (current) => patchToIntents(await builder(current)), opts);
+    }
+    async mutate(taskId, builder, opts = {}) {
+        return await this.runWithRetry(taskId, opts, async (entry) => {
+            const intents = normalizeTaskStoreIntents(await builder({ ...entry.task }));
+            return applyTaskStoreIntents(entry, intents);
         });
     }
-    async runWithRetry(taskId, computeNext) {
+    async runWithRetry(taskId, opts, computeNext) {
         for (let attempt = 0; attempt < 2; attempt++) {
             const entry = await this.getCached(taskId);
-            const next = await computeNext(entry);
+            if (opts.expectedRevision !== undefined) {
+                const expectedRevision = normalizeTaskRevision(opts.expectedRevision);
+                const currentRevision = normalizeTaskRevision(entry.task.revision);
+                if (currentRevision !== expectedRevision) {
+                    throwTaskRevisionConflict({ taskId, expectedRevision, currentRevision });
+                }
+            }
+            let next;
+            try {
+                next = await computeNext(entry);
+            }
+            catch (err) {
+                if (attempt === 0 &&
+                    err instanceof CliError &&
+                    err.code === "E_VALIDATION" &&
+                    (await didReadmeChangeOnDisk({
+                        readmePath: entry.readmePath,
+                        expectedMtimeMs: entry.mtimeMs,
+                    }))) {
+                    this.cache.delete(taskId);
+                    continue;
+                }
+                throw err;
+            }
             try {
                 return await this.writeNextTask(taskId, entry, next);
             }
@@ -250,12 +461,19 @@ export class TaskStore {
             frontmatter.doc_updated_by.trim() === "") {
             frontmatter.doc_updated_by = resolveDocUpdatedBy(next);
         }
-        const rendered = renderTaskReadme(frontmatter, body);
+        const storedRevision = readStoredTaskRevision(entry.parsed.frontmatter.revision);
+        frontmatter.revision = storedRevision ?? 1;
+        let nextText = renderTaskReadme(frontmatter, body);
+        nextText = nextText.endsWith("\n") ? nextText : `${nextText}\n`;
+        if (storedRevision !== null && nextText !== entry.rawText) {
+            frontmatter.revision = storedRevision + 1;
+            nextText = renderTaskReadme(frontmatter, body);
+            nextText = nextText.endsWith("\n") ? nextText : `${nextText}\n`;
+        }
         await ensureUnchangedOnDisk({
             readmePath: entry.readmePath,
             expectedMtimeMs: entry.mtimeMs,
         });
-        const nextText = rendered.endsWith("\n") ? rendered : `${rendered}\n`;
         const changed = await writeTextIfChanged(entry.readmePath, nextText);
         // Refresh cache with latest content on disk.
         this.cache.set(taskId, (async () => {

package/dist/commands/task/add.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../src/commands/task/add.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAIpF,wBAAsB,UAAU,CAAC,IAAI,EAAE;IACrC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GAAG,OAAO,CAAC,MAAM,CAAC,CAyDlB"}
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../src/commands/task/add.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAKpF,wBAAsB,UAAU,CAAC,IAAI,EAAE;IACrC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GAAG,OAAO,CAAC,MAAM,CAAC,CA2DlB"}

package/dist/commands/task/add.js

@@ -1,6 +1,7 @@
 import { mapBackendError } from "../../cli/error-map.js";
 import { CliError } from "../../shared/errors.js";
 import { loadCommandContext } from "../shared/task-backend.js";
+import { applyTaskCollectionMutation } from "../shared/task-mutation.js";
 import { dedupeStrings, normalizeTaskStatus, nowIso } from "./shared.js";
 import { defaultTaskDocV3, TASK_DOC_VERSION_V3 } from "./doc-template.js";
 export async function cmdTaskAdd(opts) {
@@ -8,49 +9,50 @@ export async function cmdTaskAdd(opts) {
         const ctx = opts.ctx ??
             (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
         const status = normalizeTaskStatus(opts.status);
-        const existing = await ctx.taskBackend.listTasks();
-        const existingIds = new Set(existing.map((task) => task.id));
-        for (const taskId of opts.taskIds) {
-            if (existingIds.has(taskId)) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `Task already exists: ${taskId}`,
-                });
-            }
-        }
         const tags = dedupeStrings(opts.tags);
         const dependsOn = dedupeStrings(opts.dependsOn);
         const verify = dedupeStrings(opts.verify);
         const docUpdatedBy = (opts.commentAuthor ?? "").trim() || opts.owner;
-        const tasks = opts.taskIds.map((taskId) => ({
-            id: taskId,
-            title: opts.title,
-            description: opts.description,
-            status,
-            priority: opts.priority,
-            owner: opts.owner,
-            tags,
-            depends_on: dependsOn,
-            verify,
-            comments: opts.commentAuthor && opts.commentBody
-                ? [{ author: opts.commentAuthor, body: opts.commentBody }]
-                : [],
-            doc_version: TASK_DOC_VERSION_V3,
-            doc_updated_at: nowIso(),
-            doc_updated_by: docUpdatedBy,
-            id_source: "explicit",
-            doc: defaultTaskDocV3({ title: opts.title, description: opts.description }),
-        }));
-        if (ctx.taskBackend.writeTasks) {
-            await ctx.taskBackend.writeTasks(tasks);
-        }
-        else {
-            for (const task of tasks) {
-                await ctx.taskBackend.writeTask(task);
-            }
-        }
-        for (const task of tasks) {
+        const { tasksToWrite } = await applyTaskCollectionMutation({
+            ctx,
+            build: (existing) => {
+                const existingIds = new Set(existing.map((task) => task.id));
+                for (const taskId of opts.taskIds) {
+                    if (existingIds.has(taskId)) {
+                        throw new CliError({
+                            exitCode: 2,
+                            code: "E_USAGE",
+                            message: `Task already exists: ${taskId}`,
+                        });
+                    }
+                }
+                const tasksToWrite = opts.taskIds.map((taskId) => ({
+                    id: taskId,
+                    title: opts.title,
+                    description: opts.description,
+                    status,
+                    priority: opts.priority,
+                    owner: opts.owner,
+                    origin: { system: "manual" },
+                    tags,
+                    depends_on: dependsOn,
+                    verify,
+                    comments: opts.commentAuthor && opts.commentBody
+                        ? [{ author: opts.commentAuthor, body: opts.commentBody }]
+                        : [],
+                    doc_version: TASK_DOC_VERSION_V3,
+                    doc_updated_at: nowIso(),
+                    doc_updated_by: docUpdatedBy,
+                    id_source: "explicit",
+                    doc: defaultTaskDocV3({ title: opts.title, description: opts.description }),
+                }));
+                return {
+                    result: null,
+                    tasksToWrite,
+                };
+            },
+        });
+        for (const task of tasksToWrite) {
             process.stdout.write(`${task.id}\n`);
         }
         return 0;

package/dist/commands/task/block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../src/commands/task/block.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,2BAA2B,CAAC;AAiBnC,wBAAsB,QAAQ,CAAC,IAAI,EAAE;IACnC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;IACzB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CA2IlB"}
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../src/commands/task/block.ts"],"names":[],"mappings":"AAKA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAWpF,wBAAsB,QAAQ,CAAC,IAAI,EAAE;IACnC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;IACzB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CA+ElB"}