agentplane 0.1.8 → 0.2.0

package/dist/backends/task-backend/local-backend.d.ts

@@ -0,0 +1,28 @@
+import { type TaskBackend, type TaskData } from "./shared.js";
+export declare class LocalBackend implements TaskBackend {
+    id: string;
+    root: string;
+    updatedBy: string;
+    constructor(settings?: {
+        dir?: string;
+        updatedBy?: string;
+    });
+    generateTaskId(opts: {
+        length: number;
+        attempts: number;
+    }): Promise<string>;
+    listTasks(): Promise<TaskData[]>;
+    getTask(taskId: string): Promise<TaskData | null>;
+    getTasks(taskIds: string[]): Promise<(TaskData | null)[]>;
+    getTaskDoc(taskId: string): Promise<string>;
+    writeTask(task: TaskData): Promise<void>;
+    setTaskDoc(taskId: string, doc: string, updatedBy?: string): Promise<void>;
+    touchTaskDocMetadata(taskId: string, updatedBy?: string): Promise<void>;
+    writeTasks(tasks: TaskData[]): Promise<void>;
+    normalizeTasks(): Promise<{
+        scanned: number;
+        changed: number;
+    }>;
+    exportTasksJson(outputPath: string): Promise<void>;
+}
+//# sourceMappingURL=local-backend.d.ts.map

package/dist/backends/task-backend/local-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-backend.d.ts","sourceRoot":"","sources":["../../../src/backends/task-backend/local-backend.ts"],"names":[],"mappings":"AAqBA,OAAO,EAiBL,KAAK,WAAW,EAChB,KAAK,QAAQ,EACd,MAAM,aAAa,CAAC;AAErB,qBAAa,YAAa,YAAW,WAAW;IAC9C,EAAE,SAAW;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;gBAEN,QAAQ,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAKrD,cAAc,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAqB3E,SAAS,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IA4EhC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAoBjD,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC;IAKzD,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO3C,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAyExC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB1E,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvE,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5C,cAAc,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAoF/D,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAIzD"}

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

@@ -0,0 +1,335 @@
+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, DOC_VERSION, defaultPlanApproval, defaultVerificationResult, extractTaskDoc, generateTaskId, invalidLengthMessage, mapLimit, mergeTaskDoc, missingTaskIdMessage, nowIso, resolveDocUpdatedByFromFrontmatter, resolveDocUpdatedByFromTask, taskRecordToData, validateTaskId, writeTasksExportFromTasks, } from "./shared.js";
+export class LocalBackend {
+    id = "local";
+    root;
+    updatedBy;
+    constructor(settings) {
+        this.root = path.resolve(settings?.dir ?? ".agentplane/tasks");
+        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;
+                }
+            },
+        });
+    }
+    async listTasks() {
+        const tasks = [];
+        const entries = await readdir(this.root, { withFileTypes: true }).catch(() => []);
+        const indexPath = resolveTaskIndexPath(this.root);
+        const cachedIndex = await loadTaskIndex(indexPath);
+        const cachedByPath = new Map();
+        if (cachedIndex) {
+            for (const entry of cachedIndex.tasks) {
+                cachedByPath.set(entry.readmePath, entry);
+            }
+        }
+        const nextIndex = [];
+        const seen = new Set();
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const readme = path.join(this.root, entry.name, "README.md");
+            let stats;
+            try {
+                stats = await stat(readme);
+            }
+            catch {
+                continue;
+            }
+            if (!stats.isFile())
+                continue;
+            const cached = cachedByPath.get(readme);
+            if (cached?.mtimeMs === stats.mtimeMs) {
+                const taskId = cached.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(cached.task);
+                nextIndex.push(cached);
+                continue;
+            }
+            let text = "";
+            try {
+                text = await readFile(readme, "utf8");
+            }
+            catch {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = parseTaskReadme(text);
+            }
+            catch {
+                continue;
+            }
+            const fm = parsed.frontmatter;
+            if (!isRecord(fm) || Object.keys(fm).length === 0)
+                continue;
+            const taskId = (typeof fm.id === "string" ? fm.id : entry.name).trim();
+            if (taskId) {
+                validateTaskId(taskId);
+                if (seen.has(taskId)) {
+                    throw new Error(`Duplicate task id in local backend: ${taskId}`);
+                }
+                seen.add(taskId);
+            }
+            const task = taskRecordToData({
+                id: taskId,
+                frontmatter: fm,
+                body: parsed.body,
+                readmePath: readme,
+            });
+            tasks.push(task);
+            nextIndex.push(buildTaskIndexEntry(task, readme, stats.mtimeMs));
+        }
+        try {
+            await saveTaskIndex(indexPath, { schema_version: 1, tasks: nextIndex });
+        }
+        catch {
+            // Best-effort cache; ignore failures.
+        }
+        return tasks;
+    }
+    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;
+    }
+    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));
+    }
+    async getTaskDoc(taskId) {
+        const readme = taskReadmePath(this.root, taskId);
+        const text = await readFile(readme, "utf8");
+        const parsed = parseTaskReadme(text);
+        return extractTaskDoc(parsed.body);
+    }
+    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();
+        }
+        if (task.doc !== undefined) {
+            const docText = String(task.doc ?? "");
+            body = mergeTaskDoc(body, docText);
+            if (docChanged(existingDoc, docText)) {
+                payload.doc_version = DOC_VERSION;
+                payload.doc_updated_at = nowIso();
+                payload.doc_updated_by = resolveDocUpdatedByFromTask(task, this.updatedBy);
+            }
+        }
+        if (payload.doc_version !== DOC_VERSION) {
+            payload.doc_version = 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);
+        }
+        await mkdir(path.dirname(readme), { recursive: true });
+        const text = renderTaskReadme(payload, body || "");
+        await writeTextIfChanged(readme, text.endsWith("\n") ? text : `${text}\n`);
+    }
+    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 };
+        if (docChanged(extractTaskDoc(parsed.body), docText) || !frontmatter.doc_updated_at) {
+            frontmatter.doc_version = DOC_VERSION;
+            frontmatter.doc_updated_at = nowIso();
+            frontmatter.doc_updated_by = resolveDocUpdatedByFromFrontmatter(frontmatter, updatedBy, this.updatedBy);
+        }
+        if (frontmatter.doc_version !== DOC_VERSION) {
+            frontmatter.doc_version = DOC_VERSION;
+        }
+        const next = renderTaskReadme(frontmatter, body);
+        await writeTextIfChanged(readme, next.endsWith("\n") ? next : `${next}\n`);
+    }
+    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 = 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 writeTasks(tasks) {
+        await mapLimit(tasks, 4, async (task) => {
+            await this.writeTask(task);
+            return null;
+        });
+    }
+    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();
+            if (payload.doc_version !== DOC_VERSION)
+                payload.doc_version = 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 };
+    }
+    async exportTasksJson(outputPath) {
+        const tasks = await this.listTasks();
+        await writeTasksExportFromTasks({ outputPath, tasks });
+    }
+}

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

@@ -0,0 +1,8 @@
+export declare function requestJson(opts: {
+    baseUrl: string;
+    apiKey: string;
+}, method: string, reqPath: string, payload?: Record<string, unknown>, params?: Record<string, unknown>, requestOpts?: {
+    attempts?: number;
+    backoff?: number;
+}): Promise<Record<string, unknown>>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/client.ts"],"names":[],"mappings":"AAIA,wBAAsB,WAAW,CAC/B,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzC,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,EAChC,WAAW,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GACpD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAqDlC"}

package/dist/backends/task-backend/redmine/client.js

@@ -0,0 +1,60 @@
+import { isRecord } from "../../../shared/guards.js";
+import { BackendError, RedmineUnavailable, sleep, toStringSafe } from "../shared.js";
+export async function requestJson(opts, method, reqPath, payload, params, requestOpts) {
+    let url = `${opts.baseUrl}/${reqPath.replace(/^\//u, "")}`;
+    if (params) {
+        const search = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            search.append(key, toStringSafe(value));
+        }
+        const qs = search.toString();
+        if (qs)
+            url += `?${qs}`;
+    }
+    const attempts = Math.max(1, requestOpts?.attempts ?? 3);
+    const backoff = requestOpts?.backoff ?? 0.5;
+    let lastError = null;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            const resp = await fetch(url, {
+                method,
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Redmine-API-Key": opts.apiKey,
+                },
+                body: payload ? JSON.stringify(payload) : undefined,
+            });
+            const text = await resp.text();
+            if (!resp.ok) {
+                if ((resp.status === 429 || resp.status >= 500) && attempt < attempts) {
+                    await sleep(backoff * attempt * 1000);
+                    continue;
+                }
+                throw new BackendError(`Redmine API error: ${resp.status} ${text}`, "E_BACKEND");
+            }
+            if (!text)
+                return {};
+            try {
+                const parsed = JSON.parse(text);
+                if (isRecord(parsed))
+                    return parsed;
+                return {};
+            }
+            catch {
+                return {};
+            }
+        }
+        catch (err) {
+            lastError = err;
+            if (err instanceof BackendError)
+                throw err;
+            if (attempt >= attempts) {
+                throw new RedmineUnavailable("Redmine unavailable");
+            }
+            await sleep(backoff * attempt * 1000);
+        }
+    }
+    throw lastError instanceof Error ? lastError : new RedmineUnavailable("Redmine unavailable");
+}

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

@@ -0,0 +1,12 @@
+export type TaskComment = {
+    author: string;
+    body: string;
+};
+export declare function normalizeComments(value: unknown): TaskComment[];
+export declare function appendCommentNotes(opts: {
+    issueId: string;
+    existingComments: TaskComment[];
+    desiredComments: TaskComment[];
+    requestJson: (method: string, reqPath: string, payload?: Record<string, unknown>, params?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+}): Promise<void>;
+//# sourceMappingURL=comments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/comments.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,WAAW,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,EAAE,CAW/D;AAmBD,wBAAsB,kBAAkB,CAAC,IAAI,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAChC,eAAe,EAAE,WAAW,EAAE,CAAC;IAC/B,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,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBhB"}

package/dist/backends/task-backend/redmine/comments.js

@@ -0,0 +1,54 @@
+import { isRecord } from "../../../shared/guards.js";
+import { toStringSafe } from "../shared.js";
+export function normalizeComments(value) {
+    if (Array.isArray(value)) {
+        return value.filter((item) => isRecord(item) ? typeof item.author === "string" && typeof item.body === "string" : false);
+    }
+    if (isRecord(value))
+        return [value];
+    if (typeof value === "string" && value.trim()) {
+        return [{ author: "redmine", body: value.trim() }];
+    }
+    return [];
+}
+function commentsToPairs(comments) {
+    const pairs = [];
+    for (const comment of comments) {
+        const author = toStringSafe(comment.author).trim();
+        const body = toStringSafe(comment.body).trim();
+        if (!author && !body)
+            continue;
+        pairs.push([author, body]);
+    }
+    return pairs;
+}
+function formatCommentNote(author = "unknown", body = "") {
+    const authorText = author;
+    const bodyText = body;
+    return `[comment] ${authorText}: ${bodyText}`.trim();
+}
+export async function appendCommentNotes(opts) {
+    const issueIdText = toStringSafe(opts.issueId);
+    if (!issueIdText)
+        return;
+    const existingPairs = commentsToPairs(opts.existingComments);
+    const desiredPairs = commentsToPairs(opts.desiredComments);
+    if (desiredPairs.length === 0)
+        return;
+    if (desiredPairs.length < existingPairs.length)
+        return;
+    if (existingPairs.length > 0) {
+        const prefix = desiredPairs.slice(0, existingPairs.length);
+        const matches = prefix.length === existingPairs.length &&
+            prefix.every((pair, idx) => pair[0] === existingPairs[idx]?.[0] && pair[1] === existingPairs[idx]?.[1]);
+        if (!matches)
+            return;
+    }
+    const newPairs = desiredPairs.slice(existingPairs.length);
+    for (const [author, body] of newPairs) {
+        const note = formatCommentNote(author, body);
+        if (note) {
+            await opts.requestJson("PUT", `issues/${issueIdText}.json`, { issue: { notes: note } });
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+export declare function customFieldValue(issue: Record<string, unknown>, fieldId: unknown): string | null;
+export declare function setIssueCustomFieldValue(issue: Record<string, unknown>, fieldId: unknown, value: unknown): void;
+export declare function appendCustomField(opts: {
+    customFields: Record<string, unknown>;
+    fields: Record<string, unknown>[];
+    key: string;
+    value: unknown;
+}): void;
+//# sourceMappingURL=fields.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/fields.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAUhG;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,OAAO,GACb,IAAI,CAYN;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,IAAI,CAQP"}

package/dist/backends/task-backend/redmine/fields.js

@@ -0,0 +1,38 @@
+import { isRecord } from "../../../shared/guards.js";
+import { toStringSafe } from "../shared.js";
+export function customFieldValue(issue, fieldId) {
+    if (!fieldId)
+        return null;
+    const fields = Array.isArray(issue.custom_fields) ? issue.custom_fields : [];
+    for (const field of fields) {
+        if (isRecord(field) && field.id === fieldId) {
+            const value = field.value;
+            return value !== undefined && value !== null ? toStringSafe(value) : "";
+        }
+    }
+    return null;
+}
+export function setIssueCustomFieldValue(issue, fieldId, value) {
+    const fields = Array.isArray(issue.custom_fields) ? issue.custom_fields : [];
+    let found = false;
+    const updated = fields.map((field) => {
+        if (isRecord(field) && field.id === fieldId) {
+            found = true;
+            return { ...field, value };
+        }
+        return field;
+    });
+    if (!found)
+        updated.push({ id: fieldId, value });
+    issue.custom_fields = updated;
+}
+export function appendCustomField(opts) {
+    const fieldId = opts.customFields?.[opts.key];
+    if (!fieldId)
+        return;
+    let payloadValue = opts.value;
+    if (Array.isArray(opts.value) || isRecord(opts.value)) {
+        payloadValue = JSON.stringify(opts.value);
+    }
+    opts.fields.push({ id: fieldId, value: payloadValue });
+}

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

@@ -0,0 +1,20 @@
+import { type TaskData } from "../shared.js";
+export declare function startDateFromTaskId(taskId: string): string | null;
+export declare function doneRatioForStatus(status: string): number | null;
+export declare function issueToTask(opts: {
+    issue: Record<string, unknown>;
+    taskIdOverride?: string;
+    reverseStatus: Map<number, string>;
+    customFields: Record<string, unknown>;
+    ownerAgent: string;
+    defaultDocVersion: number;
+}): TaskData | null;
+export declare function taskToIssuePayload(opts: {
+    task: TaskData;
+    existingIssue?: Record<string, unknown>;
+    statusMap: Record<string, unknown>;
+    assigneeId: number | null;
+    customFields: Record<string, unknown>;
+    appendCustomField: (fields: Record<string, unknown>[], key: string, value: unknown) => void;
+}): Record<string, unknown>;
+//# sourceMappingURL=mapping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/mapping.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,cAAc,CAAC;AAMtB,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASjE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIhE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,QAAQ,GAAG,IAAI,CAwDlB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,IAAI,EAAE,QAAQ,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7F,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsC1B"}