agentplane 0.3.6 → 0.3.8

package/dist/backends/task-backend/local-backend.js

@@ -1,17 +1,18 @@
-import { mkdir, readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
-import { docChanged, parseTaskReadme, renderTaskReadme, taskReadmePath, } from "@agentplaneorg/core";
-import { isRecord } from "../../shared/guards.js";
-import { writeTextIfChanged } from "../../shared/write-if-changed.js";
-import { buildTaskIndexEntry, loadTaskIndex, resolveTaskIndexPath, saveTaskIndex, } from "../task-index.js";
-import { DEFAULT_DOC_UPDATED_BY, defaultPlanApproval, defaultVerificationResult, extractTaskDoc, generateTaskId, invalidLengthMessage, mapLimit, mergeTaskDoc, missingTaskIdMessage, normalizeDocVersion, nowIso, resolveDocUpdatedByFromFrontmatter, resolveDocUpdatedByFromTask, taskRecordToData, validateTaskId, writeTasksExportFromTasks, } from "./shared.js";
+import { DEFAULT_DOC_UPDATED_BY, } from "./shared.js";
+import { setLocalTaskDoc, touchLocalTaskDocMetadata } from "./local-backend-doc.js";
+import { getLocalTask, getLocalTaskDoc, getLocalTasks, listLocalTasks, } from "./local-backend-read.js";
+import { exportLocalProjectionSnapshot, exportLocalTasksJson, generateLocalTaskId, normalizeLocalTasks, writeLocalTask, writeLocalTasks, } from "./local-backend-write.js";
 export class LocalBackend {
     id = "local";
     capabilities = {
         canonical_source: "local",
         projection: "canonical",
+        projection_read_mode: "native",
         reads_from_projection_by_default: true,
         writes_task_readmes: true,
+        supports_task_revisions: true,
+        supports_revision_guarded_writes: true,
         may_access_network_on_read: false,
         may_access_network_on_write: false,
         supports_projection_refresh: false,
@@ -26,360 +27,54 @@ export class LocalBackend {
         this.updatedBy = settings?.updatedBy ?? DEFAULT_DOC_UPDATED_BY;
     }
     async generateTaskId(opts) {
-        const length = opts.length;
-        if (length < 4)
-            throw new Error(invalidLengthMessage(length, 4));
-        const attempts = Math.max(1, opts.attempts);
-        return await generateTaskId({
-            length,
-            attempts,
-            isAvailable: async (taskId) => {
-                const readmePath = taskReadmePath(this.root, taskId);
-                try {
-                    await readFile(readmePath, "utf8");
-                    return false;
-                }
-                catch (err) {
-                    const code = err?.code;
-                    if (code === "ENOENT")
-                        return true;
-                    throw err;
-                }
+        return await generateLocalTaskId(this.backendContext(), opts);
+    }
+    backendContext() {
+        return {
+            root: this.root,
+            updatedBy: this.updatedBy,
+            setLastListWarnings: (warnings) => {
+                this.lastListWarnings = warnings;
             },
-        });
+        };
     }
     async listTasks() {
-        const tasks = [];
-        const warnings = [];
-        const entries = await readdir(this.root, { withFileTypes: true }).catch(() => []);
-        const indexPath = resolveTaskIndexPath(this.root);
-        const cachedIndex = await loadTaskIndex(indexPath);
-        const cachedEntryByPath = new Map();
-        if (cachedIndex) {
-            for (const [readmePath, taskId] of Object.entries(cachedIndex.byPath)) {
-                const entry = cachedIndex.byId[taskId];
-                if (entry)
-                    cachedEntryByPath.set(readmePath, entry);
-            }
-        }
-        let indexDirty = cachedIndex === null;
-        const nextById = {};
-        const nextByPath = {};
-        const seen = new Set();
-        // Deterministic ordering helps both users and tests; keep I/O bounded to avoid storms.
-        const dirs = entries
-            .filter((e) => e.isDirectory())
-            .map((e) => e.name)
-            .toSorted();
-        const results = await mapLimit(dirs, 32, async (dirName) => {
-            const readme = path.join(this.root, dirName, "README.md");
-            let stats;
-            try {
-                stats = await stat(readme);
-            }
-            catch {
-                warnings.push(`skip:${dirName}: missing_or_unreadable_readme`);
-                return null;
-            }
-            if (!stats.isFile())
-                return null;
-            const cached = cachedEntryByPath.get(readme);
-            if (cached?.mtimeMs === stats.mtimeMs) {
-                return { task: cached.task, index: cached, mtimeMs: stats.mtimeMs, readme };
-            }
-            indexDirty = true;
-            let text = "";
-            try {
-                text = await readFile(readme, "utf8");
-            }
-            catch {
-                warnings.push(`skip:${dirName}: unreadable_readme`);
-                return null;
-            }
-            let parsed;
-            try {
-                parsed = parseTaskReadme(text);
-            }
-            catch {
-                warnings.push(`skip:${dirName}: invalid_readme_frontmatter`);
-                return null;
-            }
-            const fm = parsed.frontmatter;
-            if (!isRecord(fm) || Object.keys(fm).length === 0) {
-                warnings.push(`skip:${dirName}: empty_or_invalid_frontmatter`);
-                return null;
-            }
-            const taskId = (typeof fm.id === "string" ? fm.id : dirName).trim();
-            const task = taskRecordToData({
-                id: taskId,
-                frontmatter: fm,
-                body: parsed.body,
-                readmePath: readme,
-            });
-            return { task, index: null, mtimeMs: stats.mtimeMs, readme };
-        });
-        for (const res of results) {
-            if (!res)
-                continue;
-            const taskId = res.task.id.trim();
-            if (taskId) {
-                validateTaskId(taskId);
-                if (seen.has(taskId))
-                    throw new Error(`Duplicate task id in local backend: ${taskId}`);
-                seen.add(taskId);
-            }
-            tasks.push(res.task);
-            if (taskId) {
-                const entry = res.index ?? buildTaskIndexEntry(res.task, res.readme, res.mtimeMs);
-                nextById[taskId] = entry;
-                nextByPath[entry.readmePath] = taskId;
-            }
-        }
-        if (cachedIndex && indexDirty === false) {
-            const cachedPaths = Object.keys(cachedIndex.byPath);
-            const nextPaths = Object.keys(nextByPath);
-            if (cachedPaths.length === nextPaths.length) {
-                for (const readmePath of nextPaths) {
-                    if (cachedIndex.byPath[readmePath] === nextByPath[readmePath]) {
-                        continue;
-                    }
-                    indexDirty = true;
-                    break;
-                }
-            }
-            else {
-                indexDirty = true;
-            }
-        }
-        if (indexDirty) {
-            try {
-                await saveTaskIndex(indexPath, { schema_version: 2, byId: nextById, byPath: nextByPath });
-            }
-            catch {
-                // Best-effort cache; ignore failures.
-            }
-        }
-        this.lastListWarnings = warnings;
-        return tasks;
+        return (await listLocalTasks(this.backendContext(), "full"));
     }
     async listProjectionTasks() {
-        return await this.listTasks();
+        return (await listLocalTasks(this.backendContext(), "projection"));
     }
     getLastListWarnings() {
         return [...this.lastListWarnings];
     }
     async getTask(taskId) {
-        const readme = taskReadmePath(this.root, taskId);
-        let text = "";
-        try {
-            text = await readFile(readme, "utf8");
-        }
-        catch (err) {
-            const code = err?.code;
-            if (code === "ENOENT")
-                return null;
-            throw err;
-        }
-        const parsed = parseTaskReadme(text);
-        const task = taskRecordToData({
-            id: taskId,
-            frontmatter: parsed.frontmatter,
-            body: parsed.body,
-            readmePath: readme,
-        });
-        return task;
+        return await getLocalTask(this.backendContext(), taskId);
     }
     async getTasks(taskIds) {
-        // Keep ordering stable for callers; use limited parallelism to avoid IO storms.
-        return await mapLimit(taskIds, 8, async (taskId) => await this.getTask(taskId));
+        return await getLocalTasks(this.backendContext(), taskIds);
     }
     async getTaskDoc(taskId) {
-        const readme = taskReadmePath(this.root, taskId);
-        const text = await readFile(readme, "utf8");
-        const parsed = parseTaskReadme(text);
-        return extractTaskDoc(parsed.body);
+        return await getLocalTaskDoc(this.backendContext(), taskId);
     }
-    async writeTask(task) {
-        const taskId = task.id.trim();
-        if (!taskId)
-            throw new Error(missingTaskIdMessage());
-        validateTaskId(taskId);
-        const readme = taskReadmePath(this.root, taskId);
-        let body = "";
-        let existingDoc = "";
-        let existingFrontmatter = {};
-        try {
-            const text = await readFile(readme, "utf8");
-            const parsed = parseTaskReadme(text);
-            body = parsed.body;
-            existingDoc = extractTaskDoc(parsed.body);
-            existingFrontmatter = parsed.frontmatter;
-        }
-        catch (err) {
-            const code = err?.code;
-            if (code !== "ENOENT")
-                throw err;
-        }
-        const payload = { ...task };
-        delete payload.doc;
-        for (const [key, value] of Object.entries(payload)) {
-            if (value === undefined)
-                delete payload[key];
-        }
-        for (const key of ["doc_version", "doc_updated_at", "doc_updated_by"]) {
-            if (payload[key] === undefined && existingFrontmatter[key] !== undefined) {
-                payload[key] = existingFrontmatter[key];
-            }
-        }
-        if (payload.plan_approval === undefined && existingFrontmatter.plan_approval !== undefined) {
-            payload.plan_approval = existingFrontmatter.plan_approval;
-        }
-        if (payload.plan_approval === undefined) {
-            payload.plan_approval = defaultPlanApproval();
-        }
-        if (payload.verification === undefined && existingFrontmatter.verification !== undefined) {
-            payload.verification = existingFrontmatter.verification;
-        }
-        if (payload.verification === undefined) {
-            payload.verification = defaultVerificationResult();
-        }
-        const existingDocVersion = normalizeDocVersion(existingFrontmatter.doc_version);
-        if (task.doc !== undefined) {
-            const docText = String(task.doc ?? "");
-            body = mergeTaskDoc(body, docText);
-            if (docChanged(existingDoc, docText)) {
-                payload.doc_version = normalizeDocVersion(task.doc_version, existingDocVersion);
-                payload.doc_updated_at = nowIso();
-                payload.doc_updated_by = resolveDocUpdatedByFromTask(task, this.updatedBy);
-            }
-        }
-        payload.doc_version = normalizeDocVersion(payload.doc_version, existingDocVersion);
-        if (payload.doc_updated_at === undefined || payload.doc_updated_at === "") {
-            payload.doc_updated_at = nowIso();
-        }
-        if (payload.doc_updated_by === undefined || payload.doc_updated_by === "") {
-            payload.doc_updated_by = resolveDocUpdatedByFromTask(task, this.updatedBy);
-        }
-        await mkdir(path.dirname(readme), { recursive: true });
-        const text = renderTaskReadme(payload, body || "");
-        await writeTextIfChanged(readme, text.endsWith("\n") ? text : `${text}\n`);
+    async writeTask(task, opts) {
+        await writeLocalTask(this.backendContext(), task, opts);
     }
-    async setTaskDoc(taskId, doc, updatedBy) {
-        const readme = taskReadmePath(this.root, taskId);
-        const text = await readFile(readme, "utf8");
-        const parsed = parseTaskReadme(text);
-        const docText = String(doc ?? "");
-        const body = mergeTaskDoc(parsed.body, docText);
-        const frontmatter = { ...parsed.frontmatter };
-        const currentDocVersion = normalizeDocVersion(frontmatter.doc_version);
-        if (docChanged(extractTaskDoc(parsed.body), docText) || !frontmatter.doc_updated_at) {
-            frontmatter.doc_version = currentDocVersion;
-            frontmatter.doc_updated_at = nowIso();
-            frontmatter.doc_updated_by = resolveDocUpdatedByFromFrontmatter(frontmatter, updatedBy, this.updatedBy);
-        }
-        frontmatter.doc_version = normalizeDocVersion(frontmatter.doc_version, currentDocVersion);
-        const next = renderTaskReadme(frontmatter, body);
-        await writeTextIfChanged(readme, next.endsWith("\n") ? next : `${next}\n`);
+    async setTaskDoc(taskId, doc, updatedBy, opts) {
+        await setLocalTaskDoc(this.backendContext(), taskId, doc, updatedBy, opts);
     }
-    async touchTaskDocMetadata(taskId, updatedBy) {
-        const readme = taskReadmePath(this.root, taskId);
-        const text = await readFile(readme, "utf8");
-        const parsed = parseTaskReadme(text);
-        const frontmatter = { ...parsed.frontmatter };
-        frontmatter.doc_version = normalizeDocVersion(frontmatter.doc_version);
-        frontmatter.doc_updated_at = nowIso();
-        frontmatter.doc_updated_by = resolveDocUpdatedByFromFrontmatter(frontmatter, updatedBy, this.updatedBy);
-        const next = renderTaskReadme(frontmatter, parsed.body || "");
-        await writeTextIfChanged(readme, next.endsWith("\n") ? next : `${next}\n`);
+    async touchTaskDocMetadata(taskId, updatedBy, opts) {
+        await touchLocalTaskDocMetadata(this.backendContext(), taskId, updatedBy, opts);
     }
-    async writeTasks(tasks) {
-        await mapLimit(tasks, 4, async (task) => {
-            await this.writeTask(task);
-            return null;
-        });
+    async writeTasks(tasks, opts) {
+        await writeLocalTasks(this.backendContext(), tasks, opts);
     }
     async normalizeTasks() {
-        const entries = await readdir(this.root, { withFileTypes: true }).catch(() => []);
-        const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-        const results = await mapLimit(dirs, 8, async (dirName) => {
-            const readme = path.join(this.root, dirName, "README.md");
-            let text = "";
-            try {
-                text = await readFile(readme, "utf8");
-            }
-            catch {
-                return { taskId: "", scanned: false, changed: false };
-            }
-            let parsed;
-            try {
-                parsed = parseTaskReadme(text);
-            }
-            catch {
-                return { taskId: "", scanned: false, changed: false };
-            }
-            const fm = parsed.frontmatter;
-            if (!isRecord(fm) || Object.keys(fm).length === 0) {
-                return { taskId: "", scanned: false, changed: false };
-            }
-            const taskId = (typeof fm.id === "string" ? fm.id : dirName).trim();
-            if (taskId)
-                validateTaskId(taskId);
-            const task = taskRecordToData({
-                id: taskId,
-                frontmatter: fm,
-                body: parsed.body,
-                readmePath: readme,
-            });
-            // Render using the same normalization rules as writeTask, but avoid rewriting the file when the
-            // rendered output is identical (prevents mtime churn and diff-noise).
-            const payload = { ...task };
-            delete payload.doc;
-            for (const [key, value] of Object.entries(payload)) {
-                if (value === undefined)
-                    delete payload[key];
-            }
-            for (const key of ["doc_version", "doc_updated_at", "doc_updated_by"]) {
-                if (payload[key] === undefined && fm[key] !== undefined)
-                    payload[key] = fm[key];
-            }
-            if (payload.plan_approval === undefined && fm.plan_approval !== undefined) {
-                payload.plan_approval = fm.plan_approval;
-            }
-            if (payload.plan_approval === undefined)
-                payload.plan_approval = defaultPlanApproval();
-            if (payload.verification === undefined && fm.verification !== undefined) {
-                payload.verification = fm.verification;
-            }
-            if (payload.verification === undefined)
-                payload.verification = defaultVerificationResult();
-            payload.doc_version = normalizeDocVersion(payload.doc_version, normalizeDocVersion(fm.doc_version));
-            if (payload.doc_updated_at === undefined || payload.doc_updated_at === "") {
-                payload.doc_updated_at = nowIso();
-            }
-            if (payload.doc_updated_by === undefined || payload.doc_updated_by === "") {
-                payload.doc_updated_by = resolveDocUpdatedByFromTask(task, this.updatedBy);
-            }
-            const next = renderTaskReadme(payload, parsed.body || "");
-            const didWrite = await writeTextIfChanged(readme, next.endsWith("\n") ? next : `${next}\n`);
-            return { taskId, scanned: true, changed: didWrite };
-        });
-        const seen = new Set();
-        for (const { taskId } of results) {
-            if (!taskId)
-                continue;
-            if (seen.has(taskId))
-                throw new Error(`Duplicate task id in local backend: ${taskId}`);
-            seen.add(taskId);
-        }
-        const scanned = results.reduce((acc, r) => acc + (r.scanned ? 1 : 0), 0);
-        const changed = results.reduce((acc, r) => acc + (r.changed ? 1 : 0), 0);
-        return { scanned, changed };
+        return await normalizeLocalTasks(this.backendContext());
     }
     async exportTasksJson(outputPath) {
-        const tasks = await this.listTasks();
-        await writeTasksExportFromTasks({ outputPath, tasks });
+        await exportLocalTasksJson(this.backendContext(), outputPath);
     }
     async exportProjectionSnapshot(outputPath) {
-        await this.exportTasksJson(outputPath);
+        await exportLocalProjectionSnapshot(this.backendContext(), outputPath);
     }
 }

package/dist/backends/task-backend/redmine/backend-cache-doc.d.ts

@@ -0,0 +1,40 @@
+import { type TaskData, type TaskSummary, type TaskWriteOptions } from "../shared.js";
+type RedmineCachePort = {
+    listTasks: () => Promise<TaskData[]>;
+    listProjectionTasks?: () => Promise<TaskSummary[]>;
+    normalizeTasks?: () => Promise<{
+        scanned: number;
+        changed: number;
+    }>;
+    getTask: (taskId: string) => Promise<TaskData | null>;
+    writeTask: (task: TaskData, opts?: TaskWriteOptions) => Promise<void>;
+};
+export type RedmineCacheDocContext = {
+    cache: RedmineCachePort | null;
+    customFields: Record<string, unknown>;
+    ownerAgent: string;
+    batchSize: number;
+    findIssueByTaskId: (taskId: string) => Promise<Record<string, unknown> | null>;
+    issueToTask: (issue: Record<string, unknown>, taskIdOverride?: string) => TaskData | null;
+    customFieldValue: (issue: Record<string, unknown>, fieldId: unknown) => string | null;
+    appendCustomField: (fields: Record<string, unknown>[], key: string, value: unknown) => void;
+    requestJson: (method: string, reqPath: string, payload?: Record<string, unknown>, params?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    assertExpectedRevisionSupported: (taskId: string, opts?: TaskWriteOptions) => void;
+    assertExpectedRevision: (taskId: string, expectedRevision: number | undefined, currentRevision: number) => void;
+    cacheTask: (task: TaskData, dirty: boolean) => Promise<void>;
+};
+export declare function listRedmineTasks(context: RedmineCacheDocContext): Promise<TaskData[]>;
+export declare function listRedmineProjectionTasks(context: RedmineCacheDocContext): Promise<TaskSummary[]>;
+export declare function exportRedmineTasksJson(context: RedmineCacheDocContext, outputPath: string): Promise<void>;
+export declare function exportRedmineProjectionSnapshot(context: RedmineCacheDocContext, outputPath: string): Promise<void>;
+export declare function normalizeRedmineTasks(context: RedmineCacheDocContext): Promise<{
+    scanned: number;
+    changed: number;
+}>;
+export declare function getRedmineTask(context: RedmineCacheDocContext, taskId: string): Promise<TaskData | null>;
+export declare function getRedmineTasks(context: RedmineCacheDocContext, taskIds: string[]): Promise<(TaskData | null)[]>;
+export declare function getRedmineTaskDoc(context: RedmineCacheDocContext, taskId: string): Promise<string>;
+export declare function setRedmineTaskDoc(context: RedmineCacheDocContext, taskId: string, doc: string, updatedBy?: string, opts?: TaskWriteOptions): Promise<void>;
+export declare function touchRedmineTaskDocMetadata(context: RedmineCacheDocContext, taskId: string, updatedBy?: string, opts?: TaskWriteOptions): Promise<void>;
+export {};
+//# sourceMappingURL=backend-cache-doc.d.ts.map

package/dist/backends/task-backend/redmine/backend-cache-doc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-cache-doc.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/backend-cache-doc.ts"],"names":[],"mappings":"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"}

package/dist/backends/task-backend/redmine/backend-cache-doc.js

@@ -0,0 +1,178 @@
+import { taskDocToSectionMap } from "@agentplaneorg/core";
+import { BackendError, RedmineUnavailable, ensureDocMetadata, mapLimit, redmineConfigMissingEnvMessage, redmineIssueIdMissingMessage, toStringSafe, toTaskSummaries, unknownTaskIdMessage, writeTasksExportFromTasks, } from "../shared.js";
+import { buildRedmineCanonicalStateWithOptions, parseRedmineCanonicalState } from "./state.js";
+function revisionNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+export async function listRedmineTasks(context) {
+    if (!context.cache) {
+        throw new BackendError("Redmine cache is disabled; projection reads are unavailable", "E_BACKEND");
+    }
+    return await context.cache.listTasks();
+}
+export async function listRedmineProjectionTasks(context) {
+    if (!context.cache) {
+        throw new BackendError("Redmine cache is disabled; projection reads are unavailable", "E_BACKEND");
+    }
+    return context.cache.listProjectionTasks
+        ? await context.cache.listProjectionTasks()
+        : toTaskSummaries(await context.cache.listTasks());
+}
+export async function exportRedmineTasksJson(context, outputPath) {
+    const tasks = await listRedmineTasks(context);
+    await writeTasksExportFromTasks({ outputPath, tasks });
+}
+export async function exportRedmineProjectionSnapshot(context, outputPath) {
+    if (!context.cache) {
+        throw new BackendError("Redmine cache is disabled; projection snapshot export is unavailable", "E_BACKEND");
+    }
+    const tasks = await context.cache.listTasks();
+    await writeTasksExportFromTasks({ outputPath, tasks });
+}
+export async function normalizeRedmineTasks(context) {
+    if (context.cache?.normalizeTasks)
+        return await context.cache.normalizeTasks();
+    return { scanned: 0, changed: 0 };
+}
+export async function getRedmineTask(context, taskId) {
+    if (!context.cache) {
+        throw new BackendError("Redmine cache is disabled; projection reads are unavailable", "E_BACKEND");
+    }
+    return (await context.cache.getTask(taskId)) ?? null;
+}
+export async function getRedmineTasks(context, taskIds) {
+    return await mapLimit(taskIds, context.batchSize, async (taskId) => await getRedmineTask(context, taskId));
+}
+export async function getRedmineTaskDoc(context, taskId) {
+    const task = await getRedmineTask(context, taskId);
+    if (!task)
+        throw new Error(unknownTaskIdMessage(taskId));
+    return toStringSafe(task.doc);
+}
+export async function setRedmineTaskDoc(context, taskId, doc, updatedBy, opts) {
+    if (!context.customFields.doc) {
+        throw new BackendError(redmineConfigMissingEnvMessage("AGENTPLANE_REDMINE_CUSTOM_FIELDS_DOC"), "E_BACKEND");
+    }
+    try {
+        const issue = await context.findIssueByTaskId(taskId);
+        if (!issue)
+            throw new Error(unknownTaskIdMessage(taskId));
+        const issueIdText = toStringSafe(issue.id);
+        if (!issueIdText)
+            throw new Error(redmineIssueIdMissingMessage());
+        const cachedTask = context.issueToTask(issue, taskId);
+        const currentState = parseRedmineCanonicalState(context.customFieldValue(issue, context.customFields.canonical_state));
+        context.assertExpectedRevisionSupported(taskId, opts);
+        context.assertExpectedRevision(taskId, opts?.expectedRevision, currentState?.revision ?? 1);
+        const taskDoc = {
+            doc: String(doc ?? ""),
+            doc_version: cachedTask?.doc_version,
+        };
+        ensureDocMetadata(taskDoc, updatedBy);
+        const nextSections = taskDocToSectionMap(String(taskDoc.doc ?? ""));
+        const nextRevision = Math.max(revisionNumber(cachedTask?.revision), revisionNumber(currentState?.revision), 0) + 1;
+        const customFields = [];
+        context.appendCustomField(customFields, "doc", taskDoc.doc);
+        const nextCanonicalState = buildRedmineCanonicalStateWithOptions({
+            id: taskId,
+            title: cachedTask?.title ?? "",
+            description: cachedTask?.description ?? "",
+            status: cachedTask?.status ?? "TODO",
+            priority: cachedTask?.priority ?? "med",
+            owner: cachedTask?.owner ?? context.ownerAgent,
+            depends_on: cachedTask?.depends_on ?? [],
+            tags: cachedTask?.tags ?? [],
+            verify: cachedTask?.verify ?? [],
+            doc: taskDoc.doc,
+            sections: nextSections,
+            revision: nextRevision,
+            plan_approval: cachedTask?.plan_approval,
+            verification: cachedTask?.verification,
+            events: cachedTask?.events,
+        }, { base: currentState, revision: nextRevision });
+        if (nextCanonicalState) {
+            context.appendCustomField(customFields, "canonical_state", nextCanonicalState);
+        }
+        context.appendCustomField(customFields, "doc_version", taskDoc.doc_version);
+        context.appendCustomField(customFields, "doc_updated_at", taskDoc.doc_updated_at);
+        context.appendCustomField(customFields, "doc_updated_by", taskDoc.doc_updated_by);
+        await context.requestJson("PUT", `issues/${issueIdText}.json`, {
+            issue: { custom_fields: customFields },
+        });
+        if (cachedTask) {
+            cachedTask.doc = taskDoc.doc;
+            cachedTask.sections = nextSections;
+            cachedTask.revision = nextRevision;
+            cachedTask.doc_version = taskDoc.doc_version;
+            cachedTask.doc_updated_at = taskDoc.doc_updated_at;
+            cachedTask.doc_updated_by = taskDoc.doc_updated_by;
+            await context.cacheTask(cachedTask, false);
+        }
+    }
+    catch (err) {
+        if (!(err instanceof RedmineUnavailable))
+            throw err;
+        if (!context.cache)
+            throw err;
+        const cached = await context.cache.getTask(taskId);
+        if (!cached)
+            throw new Error(unknownTaskIdMessage(taskId));
+        context.assertExpectedRevisionSupported(taskId, opts);
+        context.assertExpectedRevision(taskId, opts?.expectedRevision, cached.revision ?? 1);
+        cached.doc = String(doc ?? "");
+        cached.sections = taskDocToSectionMap(cached.doc);
+        cached.revision = Math.max(revisionNumber(cached.revision), 0) + 1;
+        ensureDocMetadata(cached, updatedBy);
+        cached.dirty = true;
+        await context.cache.writeTask(cached, opts);
+    }
+}
+export async function touchRedmineTaskDocMetadata(context, taskId, updatedBy, opts) {
+    try {
+        const issue = await context.findIssueByTaskId(taskId);
+        if (!issue)
+            throw new Error(unknownTaskIdMessage(taskId));
+        const issueIdText = toStringSafe(issue.id);
+        if (!issueIdText)
+            throw new Error(redmineIssueIdMissingMessage());
+        const docValue = context.customFieldValue(issue, context.customFields.doc);
+        const cachedTask = context.issueToTask(issue, taskId);
+        const currentState = parseRedmineCanonicalState(context.customFieldValue(issue, context.customFields.canonical_state));
+        context.assertExpectedRevisionSupported(taskId, opts);
+        context.assertExpectedRevision(taskId, opts?.expectedRevision, currentState?.revision ?? 1);
+        const taskDoc = {
+            doc: docValue ?? "",
+            doc_version: cachedTask?.doc_version,
+        };
+        ensureDocMetadata(taskDoc, updatedBy);
+        const customFields = [];
+        context.appendCustomField(customFields, "doc_version", taskDoc.doc_version);
+        context.appendCustomField(customFields, "doc_updated_at", taskDoc.doc_updated_at);
+        context.appendCustomField(customFields, "doc_updated_by", taskDoc.doc_updated_by);
+        if (customFields.length > 0) {
+            await context.requestJson("PUT", `issues/${issueIdText}.json`, {
+                issue: { custom_fields: customFields },
+            });
+            if (cachedTask) {
+                cachedTask.doc_version = taskDoc.doc_version;
+                cachedTask.doc_updated_at = taskDoc.doc_updated_at;
+                cachedTask.doc_updated_by = taskDoc.doc_updated_by;
+                await context.cacheTask(cachedTask, false);
+            }
+        }
+    }
+    catch (err) {
+        if (!(err instanceof RedmineUnavailable))
+            throw err;
+        if (!context.cache)
+            throw err;
+        const cached = await context.cache.getTask(taskId);
+        if (!cached)
+            throw new Error(unknownTaskIdMessage(taskId));
+        context.assertExpectedRevisionSupported(taskId, opts);
+        context.assertExpectedRevision(taskId, opts?.expectedRevision, cached.revision ?? 1);
+        ensureDocMetadata(cached, updatedBy);
+        cached.dirty = true;
+        await context.cache.writeTask(cached, opts);
+    }
+}

package/dist/backends/task-backend/redmine/backend-report.d.ts

@@ -0,0 +1,10 @@
+import { type TaskBackendInspectionResult, type TaskData } from "../shared.js";
+export type RedmineReportContext = {
+    projectId: string;
+    customFields: Record<string, unknown>;
+    requestJson: (method: string, reqPath: string, payload?: Record<string, unknown>, params?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+};
+export declare function inspectRedmineConfiguration(context: RedmineReportContext): Promise<TaskBackendInspectionResult>;
+export declare function diffRedmineTasks(localTask: TaskData, remoteTask: TaskData): string;
+export declare function redmineTasksDiffer(localTask: TaskData, remoteTask: TaskData): boolean;
+//# sourceMappingURL=backend-report.d.ts.map

package/dist/backends/task-backend/redmine/backend-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-report.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/backend-report.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,2BAA2B,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE/E,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,WAAW,EAAE,CACX,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvC,CAAC;AAEF,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,2BAA2B,CAAC,CAsBtC;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,GAAG,MAAM,CAalF;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,GAAG,OAAO,CAIrF"}