agentplane 0.3.23 → 0.3.26

package/dist/backends/task-backend/redmine/runtime-methods.js

@@ -1,86 +0,0 @@
-import { toStringSafe } from "../shared.js";
-import { doneRatioForStatus, startDateFromTaskId } from "./mapping.js";
-import { appendRedmineBackendCommentNotes, appendRedmineBackendCustomField, diffRedmineBackendTasks, findRedmineIssueByTaskId, listRedmineRemoteTasks, maybeParseRedmineBackendJson, normalizeRedmineBackendComments, redmineBackendCustomFieldValue, redmineBackendTasksDiffer, redmineIssueToTask, redmineTaskToIssuePayload, requestRedmineBackendJson, } from "./runtime-operations.js";
-import { assertRedmineExpectedRevision, assertRedmineExpectedRevisionSupported, cacheRedmineTask, coerceRedmineBackendDocVersion, ensureRedmineDocMetadata, redmineTaskIdFieldId, setRedmineIssueCustomField, } from "./runtime-state.js";
-export const redmineBackendRuntimeMethods = {
-    setInferredStatusByTaskStatus(next) {
-        this.inferredStatusByTaskStatus = next;
-    },
-    ensureDocMetadata(task) {
-        ensureRedmineDocMetadata(task);
-    },
-    async cacheTask(task, dirty) {
-        await cacheRedmineTask(this, task, dirty);
-    },
-    assertExpectedRevisionSupported(taskId, opts) {
-        assertRedmineExpectedRevisionSupported(this, taskId, opts);
-    },
-    assertExpectedRevision(taskId, expectedRevision, currentRevision) {
-        assertRedmineExpectedRevision(taskId, expectedRevision, currentRevision);
-    },
-    taskIdFieldId() {
-        return redmineTaskIdFieldId(this);
-    },
-    setIssueCustomFieldValue(issue, fieldId, value) {
-        setRedmineIssueCustomField(issue, fieldId, value);
-    },
-    async listTasksRemote() {
-        return await listRedmineRemoteTasks(this);
-    },
-    async findIssueByTaskId(taskId) {
-        return await findRedmineIssueByTaskId(this, taskId);
-    },
-    issueToTask(issue, taskIdOverride) {
-        return redmineIssueToTask(this, issue, taskIdOverride);
-    },
-    taskToIssuePayload(task, existingIssue) {
-        return redmineTaskToIssuePayload(this, task, existingIssue);
-    },
-    appendCustomField(fields, key, value) {
-        appendRedmineBackendCustomField(this, fields, key, value);
-    },
-    normalizeComments(value) {
-        return normalizeRedmineBackendComments(value);
-    },
-    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;
-    },
-    formatCommentNote(author = "unknown", body = "") {
-        return `[comment] ${author}: ${body}`.trim();
-    },
-    async appendCommentNotes(issueId, existingComments, desiredComments) {
-        await appendRedmineBackendCommentNotes(this, issueId, existingComments, desiredComments);
-    },
-    startDateFromTaskId(taskId) {
-        return startDateFromTaskId(taskId);
-    },
-    doneRatioForStatus(status) {
-        return doneRatioForStatus(status);
-    },
-    customFieldValue(issue, fieldId) {
-        return redmineBackendCustomFieldValue(issue, fieldId);
-    },
-    maybeParseJson(value) {
-        return maybeParseRedmineBackendJson(value);
-    },
-    coerceDocVersion(value) {
-        return coerceRedmineBackendDocVersion(value);
-    },
-    diffTasks(localTask, remoteTask) {
-        return diffRedmineBackendTasks(localTask, remoteTask);
-    },
-    tasksDiffer(localTask, remoteTask) {
-        return redmineBackendTasksDiffer(localTask, remoteTask);
-    },
-    async requestJson(method, reqPath, payload, params, opts) {
-        return await requestRedmineBackendJson(this, method, reqPath, payload, params, opts);
-    },
-};

package/dist/backends/task-backend/redmine/runtime-operations.d.ts

@@ -1,19 +0,0 @@
-import { type TaskData } from "../shared.js";
-import { type TaskComment } from "./comments.js";
-import type { RedmineBackendRuntimeHost } from "./runtime-context.js";
-export declare function listRedmineRemoteTasks(host: RedmineBackendRuntimeHost): Promise<TaskData[]>;
-export declare function findRedmineIssueByTaskId(host: RedmineBackendRuntimeHost, taskId: string): Promise<Record<string, unknown> | null>;
-export declare function redmineIssueToTask(host: RedmineBackendRuntimeHost, issue: Record<string, unknown>, taskIdOverride?: string): TaskData | null;
-export declare function redmineTaskToIssuePayload(host: RedmineBackendRuntimeHost, task: TaskData, existingIssue?: Record<string, unknown>): Record<string, unknown>;
-export declare function appendRedmineBackendCustomField(host: RedmineBackendRuntimeHost, fields: Record<string, unknown>[], key: string, value: unknown): void;
-export declare function normalizeRedmineBackendComments(value: unknown): TaskComment[];
-export declare function appendRedmineBackendCommentNotes(host: RedmineBackendRuntimeHost, issueId: string, existingComments: TaskComment[], desiredComments: TaskComment[]): Promise<void>;
-export declare function redmineBackendCustomFieldValue(issue: Record<string, unknown>, fieldId: unknown): string | null;
-export declare function maybeParseRedmineBackendJson(value: unknown): unknown;
-export declare function diffRedmineBackendTasks(localTask: TaskData, remoteTask: TaskData): string;
-export declare function redmineBackendTasksDiffer(localTask: TaskData, remoteTask: TaskData): boolean;
-export declare function requestRedmineBackendJson(host: RedmineBackendRuntimeHost, method: string, reqPath: string, payload?: Record<string, unknown>, params?: Record<string, unknown>, opts?: {
-    attempts?: number;
-    backoff?: number;
-}): Promise<Record<string, unknown>>;
-//# sourceMappingURL=runtime-operations.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"runtime-operations.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/runtime-operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AAgBvB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAGtE,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAWjG;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,yBAAyB,EAC/B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAczC;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,yBAAyB,EAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,CAAC,EAAE,MAAM,GACtB,QAAQ,GAAG,IAAI,CASjB;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,yBAAyB,EAC/B,IAAI,EAAE,QAAQ,EACd,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,yBAAyB,EAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACjC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,GACb,IAAI,CAEN;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,EAAE,CAE7E;AAED,wBAAsB,gCAAgC,CACpD,IAAI,EAAE,yBAAyB,EAC/B,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,WAAW,EAAE,EAC/B,eAAe,EAAE,WAAW,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,OAAO,GACf,MAAM,GAAG,IAAI,CAEf;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEpE;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,GAAG,MAAM,CAEzF;AAED,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,GAAG,OAAO,CAE5F;AAED,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,yBAAyB,EAC/B,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,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CASlC"}

package/dist/backends/task-backend/redmine/runtime-operations.js

@@ -1,83 +0,0 @@
-import { DOC_VERSION } from "../shared.js";
-import { appendCommentNotes as appendCommentNotesImpl, normalizeComments as normalizeCommentsImpl, } from "./comments.js";
-import { requestJson as requestRedmineJson } from "./client.js";
-import { appendCustomField as appendRedmineCustomField, customFieldValue as redmineCustomFieldValue, } from "./fields.js";
-import { issueToTask as issueToTaskImpl, taskToIssuePayload as taskToIssuePayloadImpl, } from "./mapping.js";
-import { maybeParseJson as maybeParseRedmineJson } from "./parse.js";
-import { findIssueByTaskId as findIssueByTaskIdImpl, listTasksRemote as listTasksRemoteImpl, } from "./remote.js";
-import { diffRedmineTasks, redmineTasksDiffer } from "./backend-report.js";
-import { redmineTaskIdFieldId } from "./runtime-state.js";
-export async function listRedmineRemoteTasks(host) {
-    const taskFieldId = redmineTaskIdFieldId(host);
-    return await listTasksRemoteImpl({
-        projectId: host.projectId,
-        taskFieldId,
-        issueCache: host.issueCache,
-        requestJson: async (method, reqPath, payload, params) => await host.requestJson(method, reqPath, payload, params),
-        customFieldValue: (issue, fieldId) => host.customFieldValue(issue, fieldId),
-        issueToTask: (issue, taskIdOverride) => host.issueToTask(issue, taskIdOverride),
-    });
-}
-export async function findRedmineIssueByTaskId(host, taskId) {
-    const taskFieldId = redmineTaskIdFieldId(host);
-    return await findIssueByTaskIdImpl({
-        taskId,
-        projectId: host.projectId,
-        taskFieldId,
-        issueCache: host.issueCache,
-        requestJson: async (method, reqPath, payload, params) => await host.requestJson(method, reqPath, payload, params),
-        customFieldValue: (issue, fieldId) => host.customFieldValue(issue, fieldId),
-        refreshList: async () => {
-            await host.listTasksRemote();
-        },
-    });
-}
-export function redmineIssueToTask(host, issue, taskIdOverride) {
-    return issueToTaskImpl({
-        issue,
-        taskIdOverride,
-        reverseStatus: host.reverseStatus,
-        customFields: host.customFields,
-        ownerAgent: host.ownerAgent,
-        defaultDocVersion: DOC_VERSION,
-    });
-}
-export function redmineTaskToIssuePayload(host, task, existingIssue) {
-    return taskToIssuePayloadImpl({
-        task,
-        existingIssue,
-        statusMap: host.statusMap,
-        assigneeId: host.assigneeId,
-        customFields: host.customFields,
-        appendCustomField: (fields, key, value) => appendRedmineBackendCustomField(host, fields, key, value),
-    });
-}
-export function appendRedmineBackendCustomField(host, fields, key, value) {
-    appendRedmineCustomField({ customFields: host.customFields, fields, key, value });
-}
-export function normalizeRedmineBackendComments(value) {
-    return normalizeCommentsImpl(value);
-}
-export async function appendRedmineBackendCommentNotes(host, issueId, existingComments, desiredComments) {
-    await appendCommentNotesImpl({
-        issueId,
-        existingComments,
-        desiredComments,
-        requestJson: async (method, reqPath, payload, params) => await requestRedmineBackendJson(host, method, reqPath, payload, params),
-    });
-}
-export function redmineBackendCustomFieldValue(issue, fieldId) {
-    return redmineCustomFieldValue(issue, fieldId);
-}
-export function maybeParseRedmineBackendJson(value) {
-    return maybeParseRedmineJson(value);
-}
-export function diffRedmineBackendTasks(localTask, remoteTask) {
-    return diffRedmineTasks(localTask, remoteTask);
-}
-export function redmineBackendTasksDiffer(localTask, remoteTask) {
-    return redmineTasksDiffer(localTask, remoteTask);
-}
-export async function requestRedmineBackendJson(host, method, reqPath, payload, params, opts) {
-    return await requestRedmineJson({ baseUrl: host.baseUrl, apiKey: host.apiKey }, method, reqPath, payload, params, opts);
-}

package/dist/backends/task-backend/redmine/runtime-state.d.ts

@@ -1,10 +0,0 @@
-import { type TaskData, type TaskDocMeta, type TaskWriteOptions } from "../shared.js";
-import type { RedmineBackendRuntimeHost } from "./runtime-context.js";
-export declare function ensureRedmineDocMetadata(task: TaskDocMeta): void;
-export declare function cacheRedmineTask(host: RedmineBackendRuntimeHost, task: TaskData, dirty: boolean): Promise<void>;
-export declare function assertRedmineExpectedRevisionSupported(host: RedmineBackendRuntimeHost, taskId: string, opts?: TaskWriteOptions): void;
-export declare function assertRedmineExpectedRevision(taskId: string, expectedRevision: number | undefined, currentRevision: number): void;
-export declare function redmineTaskIdFieldId(host: RedmineBackendRuntimeHost): unknown;
-export declare function setRedmineIssueCustomField(issue: Record<string, unknown>, fieldId: unknown, value: unknown): void;
-export declare function coerceRedmineBackendDocVersion(value: unknown): 2 | 3 | null;
-//# sourceMappingURL=runtime-state.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"runtime-state.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/runtime-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAEtE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAKhE;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,yBAAyB,EAC/B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,IAAI,CAAC,CAIf;AAED,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,yBAAyB,EAC/B,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,gBAAgB,GACtB,IAAI,CAON;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,eAAe,EAAE,MAAM,GACtB,IAAI,CASN;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAO7E;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,OAAO,GACb,IAAI,CAEN;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAG3E"}

package/dist/backends/task-backend/redmine/runtime-state.js

@@ -1,45 +0,0 @@
-import { DEFAULT_DOC_UPDATED_BY, BackendError, normalizeDocVersion, nowIso, redmineConfigMissingEnvMessage, } from "../shared.js";
-import { setIssueCustomFieldValue as setRedmineIssueCustomFieldValue } from "./fields.js";
-export function ensureRedmineDocMetadata(task) {
-    if (task.doc === undefined)
-        return;
-    task.doc_version = normalizeDocVersion(task.doc_version);
-    task.doc_updated_at ??= nowIso();
-    task.doc_updated_by ??= DEFAULT_DOC_UPDATED_BY;
-}
-export async function cacheRedmineTask(host, task, dirty) {
-    if (!host.cache)
-        return;
-    const next = { ...task, dirty };
-    await host.cache.writeTask(next);
-}
-export function assertRedmineExpectedRevisionSupported(host, taskId, opts) {
-    if (opts?.expectedRevision === undefined)
-        return;
-    if (host.capabilities.supports_revision_guarded_writes)
-        return;
-    throw new BackendError(`Task revision guarding is unavailable for ${taskId} without AGENTPLANE_REDMINE_CUSTOM_FIELDS_CANONICAL_STATE`, "E_BACKEND");
-}
-export function assertRedmineExpectedRevision(taskId, expectedRevision, currentRevision) {
-    if (expectedRevision === undefined)
-        return;
-    const expected = Math.trunc(expectedRevision);
-    if (expected <= 0 || expected === currentRevision)
-        return;
-    throw new BackendError(`Task revision changed concurrently: ${taskId} ` +
-        `(expected revision ${expected}, current revision ${currentRevision})`, "E_BACKEND");
-}
-export function redmineTaskIdFieldId(host) {
-    const fieldId = host.customFields?.task_id;
-    if (fieldId)
-        return fieldId;
-    throw new BackendError(redmineConfigMissingEnvMessage("AGENTPLANE_REDMINE_CUSTOM_FIELDS_TASK_ID"), "E_BACKEND");
-}
-export function setRedmineIssueCustomField(issue, fieldId, value) {
-    setRedmineIssueCustomFieldValue(issue, fieldId, value);
-}
-export function coerceRedmineBackendDocVersion(value) {
-    if (value === 2 || value === 3)
-        return value;
-    return null;
-}

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

@@ -1,19 +0,0 @@
-import type { TaskData } from "../shared/types.js";
-export type RedmineCanonicalState = {
-    revision?: number;
-    origin?: TaskData["origin"];
-    runner?: TaskData["runner"];
-    sections?: Record<string, string>;
-    plan_approval?: TaskData["plan_approval"];
-    verification?: TaskData["verification"];
-    events?: TaskData["events"];
-};
-type BuildRedmineCanonicalStateOptions = {
-    base?: RedmineCanonicalState | null;
-    revision?: number | null;
-};
-export declare function parseRedmineCanonicalState(value: unknown): RedmineCanonicalState | null;
-export declare function buildRedmineCanonicalState(task: TaskData): RedmineCanonicalState | null;
-export declare function buildRedmineCanonicalStateWithOptions(task: TaskData, opts?: BuildRedmineCanonicalStateOptions): RedmineCanonicalState | null;
-export {};
-//# sourceMappingURL=state.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/redmine/state.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAGnD,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC5B,MAAM,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC1C,YAAY,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC;IACxC,MAAM,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,iCAAiC,GAAG;IACvC,IAAI,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AA6BF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,qBAAqB,GAAG,IAAI,CAiCvF;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,QAAQ,GAAG,qBAAqB,GAAG,IAAI,CAEvF;AAED,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE,iCAAiC,GACvC,qBAAqB,GAAG,IAAI,CAiD9B"}

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

@@ -1,109 +0,0 @@
-import { taskDocToSectionMap } from "@agentplaneorg/core/tasks";
-import { isRecord } from "../../../shared/guards.js";
-import { normalizeEvents } from "../shared/events.js";
-import { normalizePlanApproval, normalizeTaskOrigin, normalizeTaskRunnerOutcome, normalizeVerificationResult, } from "../shared/normalize.js";
-import { toStringSafe } from "../shared/strings.js";
-function normalizeRevision(value) {
-    return Number.isInteger(value) && Number(value) > 0 ? Number(value) : undefined;
-}
-function normalizeCanonicalSections(value) {
-    if (!isRecord(value))
-        return undefined;
-    const out = {};
-    for (const [title, text] of Object.entries(value)) {
-        const normalizedTitle = title.trim();
-        if (!normalizedTitle || typeof text !== "string")
-            continue;
-        out[normalizedTitle] = text.replaceAll("\r\n", "\n").trimEnd();
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-function maybeParseJsonString(value) {
-    if (value === null || value === undefined)
-        return null;
-    const raw = toStringSafe(value).trim();
-    if (!raw)
-        return null;
-    if (!raw.startsWith("{"))
-        return raw;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return raw;
-    }
-}
-export function parseRedmineCanonicalState(value) {
-    const parsed = maybeParseJsonString(value);
-    if (!isRecord(parsed))
-        return null;
-    const revision = normalizeRevision(parsed.revision);
-    const origin = normalizeTaskOrigin(parsed.origin) ?? undefined;
-    const runner = normalizeTaskRunnerOutcome(parsed.runner) ?? undefined;
-    const sections = normalizeCanonicalSections(parsed.sections);
-    const planApproval = normalizePlanApproval(parsed.plan_approval) ?? undefined;
-    const verification = normalizeVerificationResult(parsed.verification) ?? undefined;
-    const events = normalizeEvents(parsed.events);
-    if (revision === undefined &&
-        origin === undefined &&
-        runner === undefined &&
-        sections === undefined &&
-        planApproval === undefined &&
-        verification === undefined &&
-        events.length === 0) {
-        return null;
-    }
-    return {
-        ...(revision === undefined ? {} : { revision }),
-        ...(origin ? { origin } : {}),
-        ...(runner ? { runner } : {}),
-        ...(sections ? { sections } : {}),
-        ...(planApproval ? { plan_approval: planApproval } : {}),
-        ...(verification ? { verification } : {}),
-        ...(events.length > 0 ? { events } : {}),
-    };
-}
-export function buildRedmineCanonicalState(task) {
-    return buildRedmineCanonicalStateWithOptions(task);
-}
-export function buildRedmineCanonicalStateWithOptions(task, opts) {
-    const base = opts?.base ?? null;
-    const revision = normalizeRevision(opts?.revision) ??
-        normalizeRevision(task.revision) ??
-        normalizeRevision(base?.revision);
-    const origin = normalizeTaskOrigin(task.origin) ?? normalizeTaskOrigin(base?.origin) ?? undefined;
-    const runner = normalizeTaskRunnerOutcome(task.runner) ??
-        normalizeTaskRunnerOutcome(base?.runner) ??
-        undefined;
-    const sections = normalizeCanonicalSections(task.sections) ??
-        (typeof task.doc === "string" && task.doc.trim().length > 0
-            ? taskDocToSectionMap(task.doc)
-            : undefined) ??
-        normalizeCanonicalSections(base?.sections);
-    const planApproval = normalizePlanApproval(task.plan_approval) ??
-        normalizePlanApproval(base?.plan_approval) ??
-        undefined;
-    const verification = normalizeVerificationResult(task.verification) ??
-        normalizeVerificationResult(base?.verification) ??
-        undefined;
-    const events = normalizeEvents(task.events);
-    const fallbackEvents = events.length > 0 ? events : normalizeEvents(base?.events);
-    if (revision === undefined &&
-        origin === undefined &&
-        runner === undefined &&
-        sections === undefined &&
-        planApproval === undefined &&
-        verification === undefined &&
-        fallbackEvents.length === 0) {
-        return null;
-    }
-    return {
-        ...(revision === undefined ? {} : { revision }),
-        ...(origin ? { origin } : {}),
-        ...(runner ? { runner } : {}),
-        ...(sections ? { sections } : {}),
-        ...(planApproval ? { plan_approval: planApproval } : {}),
-        ...(verification ? { verification } : {}),
-        ...(fallbackEvents.length > 0 ? { events: fallbackEvents } : {}),
-    };
-}

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

@@ -1,68 +0,0 @@
-import type { LocalBackend } from "./local-backend.js";
-import { type TaskCanonicalStateMigrationResult, type TaskBackend, type TaskBackendInspectionResult, type TaskData, type TaskSummary, type TaskWriteOptions } from "./shared.js";
-export type RedmineSettings = {
-    url?: string;
-    api_key?: string;
-    project_id?: string;
-    status_map?: Record<string, unknown>;
-    custom_fields?: Record<string, unknown>;
-    batch_size?: number;
-    batch_pause?: number;
-    owner_agent?: string;
-    cache_dir?: string;
-};
-export declare class RedmineBackend implements TaskBackend {
-    id: string;
-    capabilities: TaskBackend["capabilities"];
-    baseUrl: string;
-    apiKey: string;
-    projectId: string;
-    assigneeId: number | null;
-    ownerAgent: string;
-    statusMap: Record<string, unknown>;
-    customFields: Record<string, unknown>;
-    batchSize: number;
-    batchPauseMs: number;
-    cache: LocalBackend | null;
-    issueCache: Map<string, Record<string, unknown>>;
-    reverseStatus: Map<number, string>;
-    inferredStatusByTaskStatus: Map<string, number> | null;
-    constructor(settings: RedmineSettings, opts: {
-        cache?: LocalBackend | null;
-    });
-    setInferredStatusByTaskStatus(next: Map<string, number> | null): void;
-    private runtimeHost;
-    generateTaskId(opts: {
-        length: number;
-        attempts: number;
-    }): Promise<string>;
-    listTasks(): Promise<TaskData[]>;
-    listProjectionTasks(): Promise<TaskSummary[]>;
-    exportTasksJson(outputPath: string): Promise<void>;
-    exportProjectionSnapshot(outputPath: string): Promise<void>;
-    refreshProjection(opts: {
-        allowNetwork: boolean;
-        quiet?: boolean;
-        conflict?: "diff" | "prefer-local" | "prefer-remote" | "fail";
-    }): Promise<void>;
-    normalizeTasks(): Promise<{
-        scanned: number;
-        changed: number;
-    }>;
-    migrateCanonicalState(): Promise<TaskCanonicalStateMigrationResult>;
-    inspectConfiguration(): Promise<TaskBackendInspectionResult>;
-    getTask(taskId: string): Promise<TaskData | null>;
-    getTasks(taskIds: string[]): Promise<(TaskData | null)[]>;
-    getTaskDoc(taskId: string): Promise<string>;
-    setTaskDoc(taskId: string, doc: string, updatedBy?: string, opts?: TaskWriteOptions): Promise<void>;
-    touchTaskDocMetadata(taskId: string, updatedBy?: string, opts?: TaskWriteOptions): Promise<void>;
-    writeTask(task: TaskData, opts?: TaskWriteOptions): Promise<void>;
-    writeTasks(tasks: TaskData[], opts?: TaskWriteOptions): Promise<void>;
-    sync(opts: {
-        direction: "push" | "pull";
-        conflict: "diff" | "prefer-local" | "prefer-remote" | "fail";
-        quiet: boolean;
-        confirm: boolean;
-    }): Promise<void>;
-}
-//# sourceMappingURL=redmine-backend.d.ts.map

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

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

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

@@ -1,147 +0,0 @@
-import { isRecord } from "../../shared/guards.js";
-import { getRedmineTask, getRedmineTaskDoc, getRedmineTasks, listRedmineProjectionTasks, listRedmineTasks, normalizeRedmineTasks, exportRedmineProjectionSnapshot, exportRedmineTasksJson, setRedmineTaskDoc, touchRedmineTaskDocMetadata, } from "./redmine/backend-cache-doc.js";
-import { inspectRedmineConfiguration } from "./redmine/backend-report.js";
-import { generateRedmineTaskId, migrateRedmineCanonicalState, syncPullRedmine, syncRedmine, writeRedmineTask, writeRedmineTasks, } from "./redmine/backend-sync.js";
-import { createRedmineCacheDocContext, createRedmineReportContext, createRedmineSyncContext, redmineBackendRuntimeMethods, } from "./redmine/backend-runtime.js";
-import { readRedmineEnv } from "./redmine/env.js";
-import { BackendError, firstNonEmptyString, redmineConfigMissingEnvMessage, } from "./shared.js";
-export class RedmineBackend {
-    id = "redmine";
-    capabilities = {
-        canonical_source: "remote",
-        projection: "cache",
-        projection_read_mode: "native",
-        reads_from_projection_by_default: true,
-        writes_task_readmes: true,
-        supports_task_revisions: false,
-        supports_revision_guarded_writes: false,
-        may_access_network_on_read: false,
-        may_access_network_on_write: true,
-        supports_projection_refresh: true,
-        supports_push_sync: true,
-        supports_snapshot_export: true,
-    };
-    baseUrl;
-    apiKey;
-    projectId;
-    assigneeId;
-    ownerAgent;
-    statusMap;
-    customFields;
-    batchSize;
-    batchPauseMs;
-    cache;
-    issueCache = new Map();
-    reverseStatus = new Map();
-    inferredStatusByTaskStatus = null;
-    constructor(settings, opts) {
-        const env = readRedmineEnv();
-        this.baseUrl = firstNonEmptyString(env.url, settings.url).replaceAll(/\/+$/gu, "");
-        this.apiKey = firstNonEmptyString(env.apiKey, settings.api_key);
-        this.projectId = firstNonEmptyString(env.projectId, settings.project_id);
-        this.assigneeId = env.assigneeId ?? null;
-        this.statusMap = isRecord(settings.status_map) ? settings.status_map : {};
-        this.customFields = {
-            ...(isRecord(settings.custom_fields) ? settings.custom_fields : {}),
-            ...env.customFields,
-        };
-        this.batchSize =
-            env.batch.size ??
-                (typeof settings.batch_size === "number" && Number.isFinite(settings.batch_size)
-                    ? Math.max(1, Math.trunc(settings.batch_size))
-                    : 20);
-        this.batchPauseMs =
-            env.batch.pauseMs ??
-                (typeof settings.batch_pause === "number" && Number.isFinite(settings.batch_pause)
-                    ? settings.batch_pause >= 1
-                        ? Math.trunc(settings.batch_pause)
-                        : Math.round(settings.batch_pause * 1000)
-                    : 500);
-        this.ownerAgent = firstNonEmptyString(env.ownerAgent, settings.owner_agent, "REDMINE");
-        this.cache = opts.cache ?? null;
-        const missingEnvKeys = [];
-        if (!this.baseUrl)
-            missingEnvKeys.push("AGENTPLANE_REDMINE_URL");
-        if (!this.apiKey)
-            missingEnvKeys.push("AGENTPLANE_REDMINE_API_KEY");
-        if (!this.projectId)
-            missingEnvKeys.push("AGENTPLANE_REDMINE_PROJECT_ID");
-        if (missingEnvKeys.length > 0) {
-            throw new BackendError(redmineConfigMissingEnvMessage(missingEnvKeys), "E_BACKEND");
-        }
-        if (!this.customFields?.task_id) {
-            throw new BackendError(redmineConfigMissingEnvMessage("AGENTPLANE_REDMINE_CUSTOM_FIELDS_TASK_ID"), "E_BACKEND");
-        }
-        const supportsStructuredRevisions = Boolean(this.customFields?.canonical_state);
-        this.capabilities = {
-            ...this.capabilities,
-            supports_task_revisions: supportsStructuredRevisions,
-            supports_revision_guarded_writes: supportsStructuredRevisions,
-        };
-        for (const [key, value] of Object.entries(this.statusMap)) {
-            if (typeof value === "number")
-                this.reverseStatus.set(value, key);
-        }
-    }
-    setInferredStatusByTaskStatus(next) {
-        this.inferredStatusByTaskStatus = next;
-    }
-    runtimeHost() {
-        return this;
-    }
-    async generateTaskId(opts) {
-        return await generateRedmineTaskId(createRedmineSyncContext(this.runtimeHost()), opts);
-    }
-    async listTasks() {
-        return await listRedmineTasks(createRedmineCacheDocContext(this.runtimeHost()));
-    }
-    async listProjectionTasks() {
-        return await listRedmineProjectionTasks(createRedmineCacheDocContext(this.runtimeHost()));
-    }
-    async exportTasksJson(outputPath) {
-        await exportRedmineTasksJson(createRedmineCacheDocContext(this.runtimeHost()), outputPath);
-    }
-    async exportProjectionSnapshot(outputPath) {
-        await exportRedmineProjectionSnapshot(createRedmineCacheDocContext(this.runtimeHost()), outputPath);
-    }
-    async refreshProjection(opts) {
-        if (!opts.allowNetwork) {
-            throw new BackendError("Projection refresh requires network access approval", "E_BACKEND");
-        }
-        await syncPullRedmine(createRedmineSyncContext(this.runtimeHost()), opts.conflict ?? "prefer-remote", opts.quiet ?? true);
-    }
-    async normalizeTasks() {
-        return await normalizeRedmineTasks(createRedmineCacheDocContext(this.runtimeHost()));
-    }
-    async migrateCanonicalState() {
-        return await migrateRedmineCanonicalState(createRedmineSyncContext(this.runtimeHost()));
-    }
-    async inspectConfiguration() {
-        return await inspectRedmineConfiguration(createRedmineReportContext(this.runtimeHost()));
-    }
-    async getTask(taskId) {
-        return await getRedmineTask(createRedmineCacheDocContext(this.runtimeHost()), taskId);
-    }
-    async getTasks(taskIds) {
-        return await getRedmineTasks(createRedmineCacheDocContext(this.runtimeHost()), taskIds);
-    }
-    async getTaskDoc(taskId) {
-        return await getRedmineTaskDoc(createRedmineCacheDocContext(this.runtimeHost()), taskId);
-    }
-    async setTaskDoc(taskId, doc, updatedBy, opts) {
-        await setRedmineTaskDoc(createRedmineCacheDocContext(this.runtimeHost()), taskId, doc, updatedBy, opts);
-    }
-    async touchTaskDocMetadata(taskId, updatedBy, opts) {
-        await touchRedmineTaskDocMetadata(createRedmineCacheDocContext(this.runtimeHost()), taskId, updatedBy, opts);
-    }
-    async writeTask(task, opts) {
-        await writeRedmineTask(createRedmineSyncContext(this.runtimeHost()), task, opts);
-    }
-    async writeTasks(tasks, opts) {
-        await writeRedmineTasks(createRedmineSyncContext(this.runtimeHost()), tasks, opts);
-    }
-    async sync(opts) {
-        await syncRedmine(createRedmineSyncContext(this.runtimeHost()), opts);
-    }
-}
-Object.assign(RedmineBackend.prototype, redmineBackendRuntimeMethods);

package/dist/backends/task-backend/shared/concurrency.d.ts

@@ -1,3 +0,0 @@
-export declare function sleep(ms: number): Promise<void>;
-export declare function mapLimit<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
-//# sourceMappingURL=concurrency.d.ts.map

package/dist/backends/task-backend/shared/concurrency.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/shared/concurrency.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GACzC,OAAO,CAAC,CAAC,EAAE,CAAC,CAkBd"}

package/dist/backends/task-backend/shared/concurrency.js

@@ -1,21 +0,0 @@
-export function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export async function mapLimit(items, limit, fn) {
-    const bounded = Math.max(1, Math.floor(limit));
-    const out = [];
-    out.length = items.length;
-    let nextIndex = 0;
-    const worker = async () => {
-        for (;;) {
-            const i = nextIndex;
-            nextIndex++;
-            if (i >= items.length)
-                return;
-            out[i] = await fn(items[i], i);
-        }
-    };
-    const workers = Array.from({ length: Math.min(bounded, items.length) }, () => worker());
-    await Promise.all(workers);
-    return out;
-}

package/dist/backends/task-backend/shared/constants.d.ts

@@ -1,6 +0,0 @@
-import type { TaskDocVersion } from "@agentplaneorg/core/tasks";
-export declare const TASK_ID_RE: RegExp;
-export declare const DEFAULT_DOC_UPDATED_BY = "agentplane";
-export declare const DOC_VERSION: TaskDocVersion;
-export declare const SUPPORTED_DOC_VERSIONS: readonly [3];
-//# sourceMappingURL=constants.d.ts.map