@kevludwig/eve-lexware-office 0.1.0

package/dist/extension/tools/due_payment_reminders.d.ts

@@ -0,0 +1,39 @@
+/** Which overdue invoices are due for a reminder now — the same rule a scheduled run applies. Reads only. */
+declare const _default: import("eve/tools").ToolDefinition<Record<string, never>, {
+    test_mode: boolean;
+    due: {
+        invoice_id: string;
+        voucher_number: string;
+        customer_name: string;
+        open_amount: number;
+        due_date: string;
+        days_overdue: number;
+    }[];
+    not_yet: {
+        voucher_number: string;
+        customer_name: string;
+        open_amount: number;
+        reason: string;
+        conversation?: string | undefined;
+    }[];
+}> & {
+    execute(input: Record<string, never>, ctx: import("eve/tools").ToolContext): Promise<{
+        test_mode: boolean;
+        due: {
+            invoice_id: string;
+            voucher_number: string;
+            customer_name: string;
+            open_amount: number;
+            due_date: string;
+            days_overdue: number;
+        }[];
+        not_yet: {
+            voucher_number: string;
+            customer_name: string;
+            open_amount: number;
+            reason: string;
+            conversation?: string | undefined;
+        }[];
+    }>;
+};
+export default _default;

package/dist/extension/tools/due_payment_reminders.mjs

@@ -0,0 +1,56 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { shortDate } from "../lib/format.mjs";
+import { client, config, ledger } from "../lib/runtime.mjs";
+import { z } from "zod";
+import { DEFAULT_REMINDER_POLICY, daysSince, selectDueReminders } from "@kevludwig/lexware-office";
+import { defineTool } from "eve/tools";
+function describeHold(hold, immediateTermDays) {
+	switch (hold.kind) {
+		case "too-early": return hold.immediate ? `sofort fällig — erinnert wird ab ${shortDate(hold.earliest)} (intern ${immediateTermDays} Tage Zahlungsziel, dann Puffer)` : `erinnert wird ab ${shortDate(hold.earliest)}`;
+		case "sent": return `schon erinnert am ${shortDate(hold.at)}`;
+		case "pending": return `Erinnerung wartet seit ${shortDate(hold.at)} auf Freigabe`;
+		case "declined": return `Erinnerung am ${shortDate(hold.at)} abgebrochen — vorerst Ruhe`;
+		case "no-address": return "für den Kunden ist keine E-Mail-Adresse hinterlegt";
+		case "unreadable": return "Status oder Adresse gerade nicht lesbar — vorsichtshalber ausgelassen";
+	}
+}
+var due_payment_reminders_default = defineTool({
+	description: "Prüft, zu welchen überfälligen Rechnungen jetzt eine Zahlungserinnerung fällig ist (Puffer nach Fälligkeit, Zahlungsziel bei sofort fälligen Rechnungen, schon erinnert, wartet auf Freigabe, abgebrochen, keine Adresse). `due` enthält je Rechnung genau die Werte für das Tool send_payment_reminder; `not_yet` die übrigen mit Grund. Liest nur.",
+	inputSchema: z.object({}).strict(),
+	async execute(_input, ctx) {
+		const reminders = config().reminders;
+		const policy = {
+			...DEFAULT_REMINDER_POLICY,
+			...reminders.policy
+		};
+		const { due, held } = await selectDueReminders(client(), ledger(), {
+			policy,
+			signal: ctx.abortSignal
+		});
+		const link = config().conversationUrl;
+		return {
+			test_mode: reminders.mode !== "live",
+			due: due.map(({ invoice }) => ({
+				invoice_id: invoice.id,
+				voucher_number: invoice.voucherNumber,
+				customer_name: invoice.contactName,
+				open_amount: invoice.openAmount,
+				due_date: invoice.dueDate,
+				days_overdue: daysSince(invoice.dueDate)
+			})),
+			not_yet: held.map(({ invoice, hold }) => ({
+				voucher_number: invoice.voucherNumber,
+				customer_name: invoice.contactName,
+				open_amount: invoice.openAmount,
+				reason: describeHold(hold, policy.immediatePaymentTermDays),
+				...hold.kind === "pending" && hold.sessionId && link ? { conversation: link(hold.sessionId) } : {}
+			}))
+		};
+	}
+});
+export { due_payment_reminders_default as default };

package/dist/extension/tools/read.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    path: string;
+    query?: Record<string, string | number | boolean> | undefined;
+}, unknown> & {
+    execute(input: {
+        path: string;
+        query?: Record<string, string | number | boolean> | undefined;
+    }, ctx: import("eve/tools").ToolContext): Promise<unknown>;
+};
+export default _default;

package/dist/extension/tools/read.mjs

@@ -0,0 +1,83 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { client } from "../lib/runtime.mjs";
+import { z } from "zod";
+import { describeError, query } from "@kevludwig/lexware-office";
+import { defineTool } from "eve/tools";
+const UUID = "[0-9a-fA-F-]{36}";
+const READABLE = [
+	new RegExp(`^/contacts(/${UUID})?$`),
+	new RegExp(`^/articles(/${UUID})?$`),
+	new RegExp(`^/vouchers/${UUID}$`),
+	/^\/voucherlist$/,
+	new RegExp(`^/invoices/${UUID}$`),
+	new RegExp(`^/credit-notes/${UUID}$`),
+	new RegExp(`^/delivery-notes/${UUID}$`),
+	new RegExp(`^/down-payment-invoices/${UUID}$`),
+	new RegExp(`^/dunnings/${UUID}$`),
+	new RegExp(`^/order-confirmations/${UUID}$`),
+	new RegExp(`^/quotations/${UUID}$`),
+	new RegExp(`^/payments/${UUID}$`),
+	new RegExp(`^/recurring-templates(/${UUID})?$`),
+	new RegExp(`^/event-subscriptions(/${UUID})?$`),
+	new RegExp(`^/files/${UUID}/status$`),
+	/^\/posting-categories$/,
+	/^\/payment-conditions$/,
+	/^\/print-layouts$/,
+	/^\/countries$/,
+	/^\/profile$/
+];
+const MAX_LIST_CHARS = 12e3;
+const MAX_DOCUMENT_CHARS = 6e4;
+var read_default = defineTool({
+	description: "Liest Daten aus Lexware Office: Kontakte, Artikel, Belegliste, einzelne Belege, Buchungskategorien, Zahlungsbedingungen, Profil, Länder. Nur lesend. Nützlich, um eine Kundennummer aufzulösen, eine Buchungskategorie zu finden oder zu prüfen, ob ein Beleg schon existiert.",
+	inputSchema: z.object({
+		path: z.string().trim().min(2).max(200).describe("Pfad ohne Basis-URL, z.B. '/contacts', '/voucherlist' oder '/posting-categories'. Nur lesende Endpunkte."),
+		query: z.record(z.string(), z.union([
+			z.string(),
+			z.number(),
+			z.boolean()
+		])).optional().describe("Query-Parameter, z.B. { number: 10001 } für /contacts oder { voucherType: 'invoice', voucherStatus: 'overdue' } für /voucherlist — dort sind voucherType und voucherStatus Pflicht.")
+	}).strict(),
+	async execute(input, ctx) {
+		const path = input.path.startsWith("/") ? input.path : `/${input.path}`;
+		if (path.includes("?")) return { error: `Query-Parameter gehören in das Feld \`query\`, nicht in den Pfad (${path}).` };
+		if (!READABLE.some((pattern) => pattern.test(path))) return { error: `${path} ist über dieses Tool nicht lesbar. Lesbar sind: /contacts, /articles, /voucherlist, /vouchers/{id}, /invoices/{id}, /credit-notes/{id}, /delivery-notes/{id}, /down-payment-invoices/{id}, /dunnings/{id}, /order-confirmations/{id}, /quotations/{id}, /payments/{id}, /recurring-templates, /event-subscriptions, /files/{id}/status, /posting-categories, /payment-conditions, /print-layouts, /countries, /profile.` };
+		try {
+			return truncate(await client().request(`${path}${query(input.query ?? {})}`, { signal: ctx.abortSignal }));
+		} catch (error) {
+			return { error: describeError(error) };
+		}
+	}
+});
+function truncate(data) {
+	const rendered = JSON.stringify(data) ?? "";
+	const isList = Boolean(data && typeof data === "object" && Array.isArray(data.content));
+	const max = isList ? MAX_LIST_CHARS : MAX_DOCUMENT_CHARS;
+	if (rendered.length <= max) return data;
+	if (isList) {
+		const page = data;
+		const kept = [];
+		let size = 0;
+		for (const entry of page.content) {
+			const length = (JSON.stringify(entry) ?? "").length + 1;
+			if (size + length > max) break;
+			kept.push(entry);
+			size += length;
+		}
+		return {
+			...page,
+			content: kept,
+			_truncated: `Nur ${kept.length} von ${page.content.length} Einträgen gezeigt. Grenze über die Query-Parameter ein (size, voucherDateFrom).`
+		};
+	}
+	return {
+		_truncated: `Antwort auf ${max} Zeichen gekürzt.`,
+		data: rendered.slice(0, max)
+	};
+}
+export { read_default as default };

package/dist/extension/tools/send_payment_reminder.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A friendly payment reminder by mail, with the invoice PDF attached. The
+ * text comes from the mount's template, the recipient from Lexware Office and
+ * the mode — never from the model. Sent at most once per invoice and round.
+ */
+declare const _default: import("eve/tools").ToolDefinition<{
+    invoice_id: string;
+    voucher_number: string;
+    customer_name: string;
+    open_amount: number;
+    due_date: string;
+}, {
+    sent: boolean;
+    note: string;
+    to?: undefined;
+    cc?: undefined;
+    test?: undefined;
+    invoice?: undefined;
+    openAmount?: undefined;
+    attachment?: undefined;
+} | {
+    sent: boolean;
+    to: string;
+    cc: readonly string[];
+    test: boolean;
+    invoice: string;
+    openAmount: number;
+    attachment: string;
+    note: string;
+}> & {
+    execute(input: {
+        invoice_id: string;
+        voucher_number: string;
+        customer_name: string;
+        open_amount: number;
+        due_date: string;
+    }, ctx: import("eve/tools").ToolContext): Promise<{
+        sent: boolean;
+        note: string;
+        to?: undefined;
+        cc?: undefined;
+        test?: undefined;
+        invoice?: undefined;
+        openAmount?: undefined;
+        attachment?: undefined;
+    } | {
+        sent: boolean;
+        to: string;
+        cc: readonly string[];
+        test: boolean;
+        invoice: string;
+        openAmount: number;
+        attachment: string;
+        note: string;
+    }>;
+};
+export default _default;

package/dist/extension/tools/send_payment_reminder.mjs

@@ -0,0 +1,180 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { shortDate } from "../lib/format.mjs";
+import { approverPolicy, client, config, ledger, renderReminder } from "../lib/runtime.mjs";
+import { saveWarnings } from "../lib/findings.mjs";
+import { readJournal, writeJournal } from "../lib/journal.mjs";
+import { bindReminderTarget, boundReminderTarget } from "../lib/state.mjs";
+import { z } from "zod";
+import { DEFAULT_REMINDER_POLICY, contactEmail, daysPastReminderDue, daysSince, describeError, earliestReminderDate, findOverdueInvoice, isDueImmediately, sendReminder } from "@kevludwig/lexware-office";
+import { defineTool } from "eve/tools";
+const inputSchema = z.object({
+	invoice_id: z.string().uuid().describe("Id der überfälligen Rechnung in Lexware Office"),
+	voucher_number: z.string().trim().min(1).max(50).describe("Rechnungsnummer, z.B. RE20260192"),
+	customer_name: z.string().trim().min(1).max(255).describe("Kunde laut Lexware Office"),
+	open_amount: z.number().positive().describe("Offener Betrag laut Lexware Office"),
+	due_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Fälligkeitsdatum yyyy-MM-dd laut Lexware Office")
+}).strict();
+const sameName = (a, b) => a !== void 0 && a.replace(/\s+/g, " ").trim() === b.replace(/\s+/g, " ").trim();
+var send_payment_reminder_default = defineTool({
+	description: "Schickt eine freundliche Zahlungserinnerung zu einer überfälligen Rechnung per E-Mail, mit der Rechnung als PDF im Anhang. Die Werte (Nummer, Kunde, offener Betrag, Fälligkeit) übernimmst du unverändert aus Lexware Office bzw. aus dem Tool due_payment_reminders — dieses Tool prüft sie. Der Text ist fest vorgegeben. Verschickt wird erst nach Freigabe.",
+	inputSchema,
+	approval: {
+		request: async (ctx) => {
+			const input = ctx.toolInput;
+			if (!input?.invoice_id) return "user-approval";
+			const reminders = config().reminders;
+			const policy = {
+				...DEFAULT_REMINDER_POLICY,
+				...reminders.policy
+			};
+			let invoice;
+			try {
+				invoice = await findOverdueInvoice(client(), input.invoice_id, ctx.abortSignal);
+			} catch (error) {
+				return {
+					type: "denied",
+					reason: `Lexware Office nicht erreichbar (${describeError(error)}). Später erneut versuchen.`
+				};
+			}
+			if (!invoice) return {
+				type: "denied",
+				reason: `Rechnung ${input.voucher_number ?? input.invoice_id} ist nicht (mehr) überfällig — keine Erinnerung nötig.`
+			};
+			const mismatches = [
+				input.voucher_number !== invoice.voucherNumber && `Rechnungsnummer ${invoice.voucherNumber}`,
+				Math.abs((input.open_amount ?? 0) - invoice.openAmount) > .01 && `offener Betrag ${invoice.openAmount}`,
+				input.due_date !== invoice.dueDate && `Fälligkeit ${invoice.dueDate}`,
+				!sameName(input.customer_name, invoice.contactName) && `Kunde „${invoice.contactName}“`
+			].filter(Boolean);
+			if (mismatches.length > 0) return {
+				type: "denied",
+				reason: `Die Angaben passen nicht zu Lexware Office. Richtig ist: ${mismatches.join(", ")}. Rufe das Tool mit diesen Werten erneut auf.`
+			};
+			let customer = null;
+			if (invoice.contactId) try {
+				customer = await contactEmail(client(), invoice.contactId, ctx.abortSignal);
+			} catch (error) {
+				console.warn(`[lexware] Customer address not readable: ${describeError(error)}`);
+			}
+			const live = reminders.mode === "live";
+			const to = live ? customer : reminders.ownerEmail ?? null;
+			if (!to) return {
+				type: "denied",
+				reason: live ? `Für ${invoice.contactName} ist keine E-Mail-Adresse hinterlegt — keine Erinnerung möglich. Melde das dem Nutzer.` : "Im Testmodus fehlt reminders.ownerEmail — kein Testversand möglich. Melde das dem Nutzer."
+			};
+			const cc = live && reminders.ccOwner && reminders.ownerEmail && reminders.ownerEmail !== to ? [reminders.ownerEmail] : [];
+			let earlier;
+			try {
+				earlier = await ledger().read(invoice.id);
+			} catch (error) {
+				return {
+					type: "denied",
+					reason: `Ob zu ${invoice.voucherNumber} schon erinnert wurde, ist gerade nicht lesbar. Später erneut versuchen.`
+				};
+			}
+			const findings = [live ? {
+				kind: "note",
+				title: "Empfänger",
+				value: cc.length ? `${to}, Cc ${cc.join(", ")}` : to
+			} : {
+				kind: "note",
+				title: "Testmodus",
+				value: `Geht an ${to}, nicht an den Kunden (im Echtbetrieb: ${customer ?? "keine Adresse hinterlegt"})`
+			}];
+			if (daysPastReminderDue(invoice, policy) < policy.minDaysOverdue) findings.push({
+				kind: "note",
+				title: "⚠ Früh",
+				value: isDueImmediately(invoice) ? `Sofort fällig, erinnert wird sonst erst ab ${shortDate(earliestReminderDate(invoice, policy))}` : `Erst ${daysSince(invoice.dueDate)} Tage überfällig — erinnert wird sonst ab ${shortDate(earliestReminderDate(invoice, policy))}`
+			});
+			if (earlier?.status === "sent") findings.push({
+				kind: "note",
+				title: "⚠ Schon erinnert",
+				value: `Am ${shortDate(earlier.at)} ging bereits eine Erinnerung raus${earlier.recipient ? ` an ${earlier.recipient}` : ""}`
+			});
+			if (earlier?.status === "pending" && earlier.sessionId && earlier.sessionId !== ctx.session.id) {
+				const link = config().conversationUrl?.(earlier.sessionId);
+				findings.push({
+					kind: "note",
+					title: "⚠ Wartet schon",
+					value: `Eine Erinnerung wartet seit ${shortDate(earlier.at)} in einer anderen Unterhaltung${link ? ` (${link})` : ""} — verschickt wird höchstens eine`
+				});
+			}
+			if (!reminders.sendMail) findings.push({
+				kind: "note",
+				title: "⚠ Mailversand fehlt",
+				value: "Ohne reminders.sendMail wird nichts verschickt."
+			});
+			saveWarnings(ctx.callId, findings);
+			bindReminderTarget(ctx.callId, {
+				invoiceId: invoice.id,
+				voucherNumber: invoice.voucherNumber,
+				voucherDate: invoice.voucherDate,
+				dueDate: invoice.dueDate,
+				currency: invoice.currency,
+				to,
+				cc,
+				test: !live,
+				customer,
+				earlierSentAt: earlier?.status === "sent" ? earlier.at : void 0
+			});
+			if (earlier?.status !== "sent") await ledger().markPending(invoice, ctx.session.id).catch(() => {});
+			return "user-approval";
+		},
+		response: approverPolicy
+	},
+	async execute(_input, ctx) {
+		const target = boundReminderTarget(ctx.callId);
+		if (!target) throw new Error("Abgebrochen: Die an die Freigabe gebundenen Angaben fehlen — nichts verschickt.");
+		const sendMail = config().reminders.sendMail;
+		if (!sendMail) throw new Error("Abgebrochen: Der Mailversand ist nicht eingerichtet (reminders.sendMail) — nichts verschickt.");
+		const journal = await readJournal("reminder", ctx.callId);
+		if (journal) {
+			if (journal.status === "created") await ledger().write({
+				invoiceId: target.invoiceId,
+				voucherNumber: target.voucherNumber,
+				status: "sent",
+				recipient: target.to,
+				sessionId: ctx.session.id
+			}).catch(() => {});
+			return journal.status === "created" ? {
+				sent: true,
+				note: "Wiederaufnahme: Die Erinnerung war bereits verschickt."
+			} : {
+				sent: false,
+				note: "Wiederaufnahme nach Abbruch: Ob die Erinnerung rausging, ist unklar. Im Postausgang nachsehen."
+			};
+		}
+		await writeJournal("reminder", ctx.callId, { status: "pending" });
+		const outcome = await sendReminder(client(), ledger(), target, {
+			render: renderReminder(),
+			sendMail,
+			owner: ctx.callId,
+			sessionId: ctx.session.id,
+			signal: ctx.abortSignal
+		});
+		if (!outcome.sent) return {
+			sent: false,
+			note: outcome.reason === "paid" ? `Rechnung ${target.voucherNumber} ist inzwischen nicht mehr überfällig — nichts verschickt.` : `Zu ${target.voucherNumber} ist über eine andere Freigabe schon eine Erinnerung rausgegangen oder unterwegs — nichts verschickt.`
+		};
+		await writeJournal("reminder", ctx.callId, {
+			status: "created",
+			resourceId: target.invoiceId
+		});
+		return {
+			sent: true,
+			to: target.to,
+			cc: target.cc ?? [],
+			test: target.test,
+			invoice: target.voucherNumber,
+			openAmount: outcome.openAmount,
+			attachment: outcome.attachment,
+			note: target.test ? `Testversand an ${target.to}. Im Echtbetrieb ginge die Erinnerung an ${target.customer ?? "den Kunden (keine Adresse hinterlegt)"}.` : `Erinnerung an ${target.to} verschickt.`
+		};
+	}
+});
+export { send_payment_reminder_default as default };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+// Generated by eve. Do not edit by hand.
+
+export { default } from "./extension/extension.js";
+export { default as eve_lexware_office } from "./extension/extension.js";

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import extension_default from "./extension/extension.mjs";
+export { extension_default as default, extension_default as eve_lexware_office };

package/dist/tools/index.d.ts

@@ -0,0 +1,10 @@
+// Generated by eve. Do not edit by hand.
+
+export { default as create_customer } from "../extension/tools/create_customer.js";
+export { default as create_invoice } from "../extension/tools/create_invoice.js";
+export { default as create_order_confirmation } from "../extension/tools/create_order_confirmation.js";
+export { default as create_purchase_invoice } from "../extension/tools/create_purchase_invoice.js";
+export { default as create_quotation } from "../extension/tools/create_quotation.js";
+export { default as due_payment_reminders } from "../extension/tools/due_payment_reminders.js";
+export { default as read } from "../extension/tools/read.js";
+export { default as send_payment_reminder } from "../extension/tools/send_payment_reminder.js";

package/dist/tools/index.mjs

@@ -0,0 +1,15 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import create_customer_default from "../extension/tools/create_customer.mjs";
+import create_invoice_default from "../extension/tools/create_invoice.mjs";
+import create_order_confirmation_default from "../extension/tools/create_order_confirmation.mjs";
+import create_purchase_invoice_default from "../extension/tools/create_purchase_invoice.mjs";
+import create_quotation_default from "../extension/tools/create_quotation.mjs";
+import due_payment_reminders_default from "../extension/tools/due_payment_reminders.mjs";
+import read_default from "../extension/tools/read.mjs";
+import send_payment_reminder_default from "../extension/tools/send_payment_reminder.mjs";
+export { create_customer_default as create_customer, create_invoice_default as create_invoice, create_order_confirmation_default as create_order_confirmation, create_purchase_invoice_default as create_purchase_invoice, create_quotation_default as create_quotation, due_payment_reminders_default as due_payment_reminders, read_default as read, send_payment_reminder_default as send_payment_reminder };

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@kevludwig/eve-lexware-office",
+  "version": "0.1.0",
+  "type": "module",
+  "eve": {
+    "extension": {
+      "source": "./extension",
+      "dist": "./dist/extension"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./tools": {
+      "types": "./dist/tools/index.d.ts",
+      "default": "./dist/tools/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@vercel/blob": "^2.8.0",
+    "zod": "4.5.4",
+    "@kevludwig/lexware-office": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.x",
+    "eve": "0.63.0",
+    "typescript": "7.0.2"
+  },
+  "peerDependencies": {
+    "eve": "*"
+  },
+  "description": "eve extension for Lexware Office: read the account, create customers, quotations, order confirmations, invoices and purchase invoices, and send payment reminders — every write behind an approval.",
+  "license": "MIT",
+  "author": "Kevin Ludwig",
+  "keywords": [
+    "eve",
+    "eve-extension",
+    "agent",
+    "lexware",
+    "lexware-office",
+    "lexoffice"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kevludwig/eve-lexware-office.git",
+    "directory": "packages/eve-lexware-office"
+  },
+  "homepage": "https://github.com/kevludwig/eve-lexware-office/tree/main/packages/eve-lexware-office#readme",
+  "bugs": {
+    "url": "https://github.com/kevludwig/eve-lexware-office/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "eve extension build",
+    "typecheck": "tsc",
+    "pretest": "eve extension build",
+    "test": "node --test --experimental-test-module-mocks test/*.test.ts"
+  }
+}