agentplane 0.3.14 → 0.3.16

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

@@ -1,15 +1,10 @@
 import { isRecord } from "../../shared/guards.js";
-import { appendCommentNotes as appendCommentNotesImpl, normalizeComments as normalizeCommentsImpl, } from "./redmine/comments.js";
-import { requestJson as requestRedmineJson } from "./redmine/client.js";
-import { appendCustomField as appendRedmineCustomField, customFieldValue as redmineCustomFieldValue, setIssueCustomFieldValue as setRedmineIssueCustomFieldValue, } from "./redmine/fields.js";
-import { doneRatioForStatus, issueToTask as issueToTaskImpl, startDateFromTaskId, taskToIssuePayload as taskToIssuePayloadImpl, } from "./redmine/mapping.js";
-import { coerceDocVersion as coerceRedmineDocVersion, maybeParseJson as maybeParseRedmineJson, } from "./redmine/parse.js";
-import { findIssueByTaskId as findIssueByTaskIdImpl, listTasksRemote as listTasksRemoteImpl, } from "./redmine/remote.js";
 import { getRedmineTask, getRedmineTaskDoc, getRedmineTasks, listRedmineProjectionTasks, listRedmineTasks, normalizeRedmineTasks, exportRedmineProjectionSnapshot, exportRedmineTasksJson, setRedmineTaskDoc, touchRedmineTaskDocMetadata, } from "./redmine/backend-cache-doc.js";
-import { diffRedmineTasks, inspectRedmineConfiguration, redmineTasksDiffer, } from "./redmine/backend-report.js";
-import { generateRedmineTaskId, handleRedmineConflict, inferRedmineStatusIdForTaskStatus, loadRedmineInferredStatusByTaskStatus, migrateRedmineCanonicalState, selectRedmineInferredStatus, syncPullRedmine, syncPushRedmine, syncRedmine, writeRedmineTask, writeRedmineTasks, } from "./redmine/backend-sync.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, DEFAULT_DOC_UPDATED_BY, DOC_VERSION, firstNonEmptyString, normalizeDocVersion, nowIso, redmineConfigMissingEnvMessage, toStringSafe, } from "./shared.js";
+import { BackendError, firstNonEmptyString, redmineConfigMissingEnvMessage, } from "./shared.js";
 export class RedmineBackend {
     id = "redmine";
     capabilities = {
@@ -88,275 +83,65 @@ export class RedmineBackend {
                 this.reverseStatus.set(value, key);
         }
     }
-    cacheDocContext() {
-        return {
-            cache: this.cache,
-            customFields: this.customFields,
-            ownerAgent: this.ownerAgent,
-            batchSize: this.batchSize,
-            findIssueByTaskId: async (taskId) => await this.findIssueByTaskId(taskId),
-            issueToTask: (issue, taskIdOverride) => this.issueToTask(issue, taskIdOverride),
-            customFieldValue: (issue, fieldId) => this.customFieldValue(issue, fieldId),
-            appendCustomField: (fields, key, value) => this.appendCustomField(fields, key, value),
-            requestJson: async (method, reqPath, payload, params) => await this.requestJson(method, reqPath, payload, params),
-            assertExpectedRevisionSupported: (taskId, opts) => this.assertExpectedRevisionSupported(taskId, opts),
-            assertExpectedRevision: (taskId, expectedRevision, currentRevision) => this.assertExpectedRevision(taskId, expectedRevision, currentRevision),
-            cacheTask: async (task, dirty) => await this.cacheTask(task, dirty),
-        };
+    setInferredStatusByTaskStatus(next) {
+        this.inferredStatusByTaskStatus = next;
     }
-    reportContext() {
-        return {
-            projectId: this.projectId,
-            customFields: this.customFields,
-            requestJson: async (method, reqPath, payload, params) => await this.requestJson(method, reqPath, payload, params),
-        };
-    }
-    syncContext() {
-        return {
-            cache: this.cache,
-            customFields: this.customFields,
-            ownerAgent: this.ownerAgent,
-            projectId: this.projectId,
-            batchSize: this.batchSize,
-            batchPauseMs: this.batchPauseMs,
-            statusMap: this.statusMap,
-            issueCache: this.issueCache,
-            inferredStatusByTaskStatus: this.inferredStatusByTaskStatus,
-            setInferredStatusByTaskStatus: (next) => {
-                this.inferredStatusByTaskStatus = next;
-            },
-            listTasksRemote: async () => await this.listTasksRemote(),
-            writeTask: async (task, opts) => await this.writeTask(task, opts),
-            writeTasks: async (tasks, opts) => await this.writeTasks(tasks, opts),
-            findIssueByTaskId: async (taskId) => await this.findIssueByTaskId(taskId),
-            issueToTask: (issue, taskIdOverride) => this.issueToTask(issue, taskIdOverride),
-            taskToIssuePayload: (task, existingIssue) => this.taskToIssuePayload(task, existingIssue),
-            appendCustomField: (fields, key, value) => this.appendCustomField(fields, key, value),
-            customFieldValue: (issue, fieldId) => this.customFieldValue(issue, fieldId),
-            maybeParseJson: (value) => this.maybeParseJson(value),
-            normalizeComments: (value) => this.normalizeComments(value),
-            appendCommentNotes: async (issueId, existingComments, desiredComments) => await this.appendCommentNotes(issueId, existingComments, desiredComments),
-            cacheTask: async (task, dirty) => await this.cacheTask(task, dirty),
-            assertExpectedRevisionSupported: (taskId, opts) => this.assertExpectedRevisionSupported(taskId, opts),
-            assertExpectedRevision: (taskId, expectedRevision, currentRevision) => this.assertExpectedRevision(taskId, expectedRevision, currentRevision),
-            ensureDocMetadata: (task) => this.ensureDocMetadata(task),
-            diffTasks: (localTask, remoteTask) => this.diffTasks(localTask, remoteTask),
-            tasksDiffer: (localTask, remoteTask) => this.tasksDiffer(localTask, remoteTask),
-            taskIdFieldId: () => this.taskIdFieldId(),
-            setIssueCustomFieldValue: (issue, fieldId, value) => this.setIssueCustomFieldValue(issue, fieldId, value),
-            requestJson: async (method, reqPath, payload, params, opts) => await this.requestJson(method, reqPath, payload, params, opts),
-        };
+    runtimeHost() {
+        return this;
     }
     async generateTaskId(opts) {
-        return await generateRedmineTaskId(this.syncContext(), opts);
+        return await generateRedmineTaskId(createRedmineSyncContext(this.runtimeHost()), opts);
     }
     async listTasks() {
-        return await listRedmineTasks(this.cacheDocContext());
+        return await listRedmineTasks(createRedmineCacheDocContext(this.runtimeHost()));
     }
     async listProjectionTasks() {
-        return await listRedmineProjectionTasks(this.cacheDocContext());
+        return await listRedmineProjectionTasks(createRedmineCacheDocContext(this.runtimeHost()));
     }
     async exportTasksJson(outputPath) {
-        await exportRedmineTasksJson(this.cacheDocContext(), outputPath);
+        await exportRedmineTasksJson(createRedmineCacheDocContext(this.runtimeHost()), outputPath);
     }
     async exportProjectionSnapshot(outputPath) {
-        await exportRedmineProjectionSnapshot(this.cacheDocContext(), 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 this.syncPull(opts.conflict ?? "prefer-remote", opts.quiet ?? true);
+        await syncPullRedmine(createRedmineSyncContext(this.runtimeHost()), opts.conflict ?? "prefer-remote", opts.quiet ?? true);
     }
     async normalizeTasks() {
-        return await normalizeRedmineTasks(this.cacheDocContext());
+        return await normalizeRedmineTasks(createRedmineCacheDocContext(this.runtimeHost()));
     }
     async migrateCanonicalState() {
-        return await migrateRedmineCanonicalState(this.syncContext());
+        return await migrateRedmineCanonicalState(createRedmineSyncContext(this.runtimeHost()));
     }
     async inspectConfiguration() {
-        return await inspectRedmineConfiguration(this.reportContext());
+        return await inspectRedmineConfiguration(createRedmineReportContext(this.runtimeHost()));
     }
     async getTask(taskId) {
-        return await getRedmineTask(this.cacheDocContext(), taskId);
+        return await getRedmineTask(createRedmineCacheDocContext(this.runtimeHost()), taskId);
     }
     async getTasks(taskIds) {
-        return await getRedmineTasks(this.cacheDocContext(), taskIds);
+        return await getRedmineTasks(createRedmineCacheDocContext(this.runtimeHost()), taskIds);
     }
     async getTaskDoc(taskId) {
-        return await getRedmineTaskDoc(this.cacheDocContext(), taskId);
+        return await getRedmineTaskDoc(createRedmineCacheDocContext(this.runtimeHost()), taskId);
     }
     async setTaskDoc(taskId, doc, updatedBy, opts) {
-        await setRedmineTaskDoc(this.cacheDocContext(), taskId, doc, updatedBy, opts);
+        await setRedmineTaskDoc(createRedmineCacheDocContext(this.runtimeHost()), taskId, doc, updatedBy, opts);
     }
     async touchTaskDocMetadata(taskId, updatedBy, opts) {
-        await touchRedmineTaskDocMetadata(this.cacheDocContext(), taskId, updatedBy, opts);
+        await touchRedmineTaskDocMetadata(createRedmineCacheDocContext(this.runtimeHost()), taskId, updatedBy, opts);
     }
     async writeTask(task, opts) {
-        await writeRedmineTask(this.syncContext(), task, opts);
+        await writeRedmineTask(createRedmineSyncContext(this.runtimeHost()), task, opts);
     }
     async writeTasks(tasks, opts) {
-        await writeRedmineTasks(this.syncContext(), tasks, opts);
+        await writeRedmineTasks(createRedmineSyncContext(this.runtimeHost()), tasks, opts);
     }
     async sync(opts) {
-        await syncRedmine(this.syncContext(), opts);
-    }
-    ensureDocMetadata(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;
-    }
-    async syncPush(quiet, confirm) {
-        await syncPushRedmine(this.syncContext(), quiet, confirm);
-    }
-    async syncPull(conflict, quiet) {
-        await syncPullRedmine(this.syncContext(), conflict, quiet);
-    }
-    async handleConflict(taskId, localTask, remoteTask, conflict) {
-        await handleRedmineConflict(this.syncContext(), taskId, localTask, remoteTask, conflict);
-    }
-    diffTasks(localTask, remoteTask) {
-        return diffRedmineTasks(localTask, remoteTask);
-    }
-    tasksDiffer(localTask, remoteTask) {
-        return redmineTasksDiffer(localTask, remoteTask);
-    }
-    async cacheTask(task, dirty) {
-        if (!this.cache)
-            return;
-        const next = { ...task, dirty };
-        await this.cache.writeTask(next);
-    }
-    assertExpectedRevisionSupported(taskId, opts) {
-        if (opts?.expectedRevision === undefined)
-            return;
-        if (this.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");
-    }
-    assertExpectedRevision(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");
-    }
-    taskIdFieldId() {
-        const fieldId = this.customFields?.task_id;
-        if (fieldId)
-            return fieldId;
-        throw new BackendError(redmineConfigMissingEnvMessage("AGENTPLANE_REDMINE_CUSTOM_FIELDS_TASK_ID"), "E_BACKEND");
-    }
-    setIssueCustomFieldValue(issue, fieldId, value) {
-        setRedmineIssueCustomFieldValue(issue, fieldId, value);
-    }
-    async listTasksRemote() {
-        const taskFieldId = this.taskIdFieldId();
-        return await listTasksRemoteImpl({
-            projectId: this.projectId,
-            taskFieldId,
-            issueCache: this.issueCache,
-            requestJson: async (method, reqPath, payload, params) => await this.requestJson(method, reqPath, payload, params),
-            customFieldValue: (issue, fieldId) => this.customFieldValue(issue, fieldId),
-            issueToTask: (issue, taskIdOverride) => this.issueToTask(issue, taskIdOverride),
-        });
-    }
-    issueFromPayload(payload) {
-        return isRecord(payload.issue) ? payload.issue : null;
-    }
-    async inferStatusIdForTaskStatus(statusRaw) {
-        return await inferRedmineStatusIdForTaskStatus(this.syncContext(), statusRaw);
-    }
-    async loadInferredStatusByTaskStatus() {
-        return await loadRedmineInferredStatusByTaskStatus(this.syncContext());
-    }
-    selectInferredStatus(statuses, target) {
-        return selectRedmineInferredStatus(statuses, target);
-    }
-    async findIssueByTaskId(taskId) {
-        const taskFieldId = this.taskIdFieldId();
-        return await findIssueByTaskIdImpl({
-            taskId,
-            projectId: this.projectId,
-            taskFieldId,
-            issueCache: this.issueCache,
-            requestJson: async (method, reqPath, payload, params) => await this.requestJson(method, reqPath, payload, params),
-            customFieldValue: (issue, fieldId) => this.customFieldValue(issue, fieldId),
-            refreshList: async () => {
-                await this.listTasksRemote();
-            },
-        });
-    }
-    issueToTask(issue, taskIdOverride) {
-        return issueToTaskImpl({
-            issue,
-            taskIdOverride,
-            reverseStatus: this.reverseStatus,
-            customFields: this.customFields,
-            ownerAgent: this.ownerAgent,
-            defaultDocVersion: DOC_VERSION,
-        });
-    }
-    taskToIssuePayload(task, existingIssue) {
-        return taskToIssuePayloadImpl({
-            task,
-            existingIssue,
-            statusMap: this.statusMap,
-            assigneeId: this.assigneeId,
-            customFields: this.customFields,
-            appendCustomField: (fields, key, value) => this.appendCustomField(fields, key, value),
-        });
-    }
-    appendCustomField(fields, key, value) {
-        appendRedmineCustomField({ customFields: this.customFields, fields, key, value });
-    }
-    normalizeComments(value) {
-        return normalizeCommentsImpl(value);
-    }
-    async appendCommentNotes(issueId, existingComments, desiredComments) {
-        await appendCommentNotesImpl({
-            issueId,
-            existingComments,
-            desiredComments,
-            requestJson: async (method, reqPath, payload, params) => await this.requestJson(method, reqPath, payload, params),
-        });
-    }
-    startDateFromTaskId(taskId) {
-        return startDateFromTaskId(taskId);
-    }
-    doneRatioForStatus(status) {
-        return doneRatioForStatus(status);
-    }
-    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 = "") {
-        const authorText = author;
-        const bodyText = body;
-        return `[comment] ${authorText}: ${bodyText}`.trim();
-    }
-    customFieldValue(issue, fieldId) {
-        return redmineCustomFieldValue(issue, fieldId);
-    }
-    maybeParseJson(value) {
-        return maybeParseRedmineJson(value);
-    }
-    coerceDocVersion(value) {
-        return coerceRedmineDocVersion(value);
-    }
-    async requestJson(method, reqPath, payload, params, opts) {
-        return await requestRedmineJson({ baseUrl: this.baseUrl, apiKey: this.apiKey }, method, reqPath, payload, params, opts);
+        await syncRedmine(createRedmineSyncContext(this.runtimeHost()), opts);
     }
 }
+Object.assign(RedmineBackend.prototype, redmineBackendRuntimeMethods);

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

@@ -1,3 +1,15 @@
+/**
+ * Backend-local Redmine/task-backend error surface.
+ *
+ * Allowed here:
+ * - backend transport/domain errors and messages
+ * - backend-specific retry/unavailable sentinel types
+ *
+ * Do not add:
+ * - CLI usage helpers
+ * - shared cross-command error containers
+ * - generic runtime failures that are not backend-owned
+ */
 export declare class BackendError extends Error {
     code: "E_BACKEND" | "E_NETWORK";
     constructor(message: string, code: "E_BACKEND" | "E_NETWORK");

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/shared/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAa,SAAQ,KAAK;IACrC,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;gBACpB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,WAAW;CAI7D;AAED,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,OAAO,EAAE,MAAM;CAG5B;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,CAG9E;AAED,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEpF;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/backends/task-backend/shared/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;gBACpB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,WAAW;CAI7D;AAED,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,OAAO,EAAE,MAAM;CAG5B;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,CAG9E;AAED,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEpF;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD"}

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

@@ -1,3 +1,15 @@
+/**
+ * Backend-local Redmine/task-backend error surface.
+ *
+ * Allowed here:
+ * - backend transport/domain errors and messages
+ * - backend-specific retry/unavailable sentinel types
+ *
+ * Do not add:
+ * - CLI usage helpers
+ * - shared cross-command error containers
+ * - generic runtime failures that are not backend-owned
+ */
 export class BackendError extends Error {
     code;
     constructor(message, code) {

package/dist/cli/archive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../../src/cli/archive.ts"],"names":[],"mappings":"AAaA,KAAK,WAAW,GAAG,KAAK,GAAG,KAAK,CAAC;AAOjC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,eAAe,CACnC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAS9B;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAKtE;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwBhB;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,CA2BjG"}
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../../src/cli/archive.ts"],"names":[],"mappings":"AAUA,KAAK,WAAW,GAAG,KAAK,GAAG,KAAK,CAAC;AAOjC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,eAAe,CACnC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAS9B;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAKtE;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwBhB;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,CA2BjG"}

package/dist/cli/archive.js

@@ -1,12 +1,10 @@
-import { execFile } from "node:child_process";
 import { readFile } from "node:fs/promises";
-import { promisify } from "node:util";
 import path from "node:path";
 import { gunzipSync } from "node:zlib";
+import { runProcess } from "@agentplaneorg/core";
 import yauzl from "yauzl";
 import { CliError } from "../shared/errors.js";
 import { exitCodeForError } from "./exit-codes.js";
-const execFileAsync = promisify(execFile);
 export async function validateArchive(archivePath, type) {
     if (type === "zip") {
         const entries = await listZipEntries(archivePath);
@@ -45,10 +43,10 @@ export async function extractArchive(opts) {
         });
     }
     if (archiveType === "tar") {
-        await execFileAsync("tar", ["-xzf", opts.archivePath, "-C", opts.destDir]);
+        await runProcess({ command: "tar", args: ["-xzf", opts.archivePath, "-C", opts.destDir] });
         return;
     }
-    await execFileAsync("unzip", ["-q", opts.archivePath, "-d", opts.destDir]);
+    await runProcess({ command: "unzip", args: ["-q", opts.archivePath, "-d", opts.destDir] });
 }
 export function validateArchiveEntries(entries, symlinks) {
     const issues = [];

package/dist/cli/error-map.d.ts

@@ -1,4 +1,10 @@
-import { CliError } from "../shared/errors.js";
+import type { CliError } from "../shared/errors.js";
+export type NextAction = {
+    command: string;
+    reason: string;
+    reasonCode?: string;
+};
 export declare function mapCoreError(err: unknown, context: Record<string, unknown>): CliError;
 export declare function mapBackendError(err: unknown, context: Record<string, unknown>): CliError;
+export declare function writeError(err: CliError, jsonErrors: boolean): void;
 //# sourceMappingURL=error-map.d.ts.map

package/dist/cli/error-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-map.d.ts","sourceRoot":"","sources":["../../src/cli/error-map.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG/C,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CA+BrF;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAUxF"}
+{"version":3,"file":"error-map.d.ts","sourceRoot":"","sources":["../../src/cli/error-map.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAqCrF;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAMxF;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,GAAG,IAAI,CA6CnE"}