buchpilot-mcp 0.1.1

package/src/tools/contacts.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import type { IAccountingBackend } from "../backends/types.js";
+
+export const contactSchemas = {
+  create_contact: z.object({
+    type: z.enum(["person", "company"]).describe("Kontakttyp: Person oder Firma"),
+    name: z.string().describe("Nachname (Person) oder Firmenname (Firma)"),
+    firstName: z.string().optional().describe("Vorname (nur bei Person)"),
+    email: z.string().optional().describe("E-Mail-Adresse"),
+    role: z.enum(["customer", "vendor", "both"]).default("customer").describe("Rolle: Kunde, Lieferant, oder beides"),
+    backend: z.string().optional().describe("Backend (z.B. 'lexoffice'). Leer = default"),
+  }),
+  get_contact: z.object({
+    id: z.string().describe("Kontakt-ID"),
+    backend: z.string().optional(),
+  }),
+  list_contacts: z.object({
+    name: z.string().optional().describe("Nach Name filtern"),
+    email: z.string().optional().describe("Nach E-Mail filtern"),
+    role: z.enum(["customer", "vendor"]).optional().describe("Nach Rolle filtern"),
+    limit: z.number().default(25).describe("Maximale Anzahl"),
+    backend: z.string().optional(),
+  }),
+  update_contact: z.object({
+    id: z.string().describe("Kontakt-ID"),
+    name: z.string().optional().describe("Neuer Name"),
+    firstName: z.string().optional().describe("Neuer Vorname"),
+    email: z.string().optional().describe("Neue E-Mail"),
+    backend: z.string().optional(),
+  }),
+};
+
+export function registerContactTools(
+  server: any,
+  getBackend: (name?: string) => IAccountingBackend,
+) {
+  server.tool(
+    "create_contact",
+    "Erstellt einen neuen Kontakt (Person oder Firma) im Buchhaltungssystem. Creates a new contact (person or company).",
+    contactSchemas.create_contact.shape,
+    async (args: z.infer<typeof contactSchemas.create_contact>) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.createContact({
+        type: args.type,
+        name: args.name,
+        firstName: args.firstName,
+        email: args.email,
+        role: args.role,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "get_contact",
+    "Ruft einen Kontakt per ID ab. Gets a contact by ID.",
+    contactSchemas.get_contact.shape,
+    async (args: z.infer<typeof contactSchemas.get_contact>) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.getContact(args.id);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "list_contacts",
+    "Listet Kontakte auf mit optionalen Filtern. Lists contacts with optional filters.",
+    contactSchemas.list_contacts.shape,
+    async (args: z.infer<typeof contactSchemas.list_contacts>) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.listContacts({
+        name: args.name,
+        email: args.email,
+        role: args.role,
+        limit: args.limit,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "update_contact",
+    "Aktualisiert einen bestehenden Kontakt. Updates an existing contact.",
+    contactSchemas.update_contact.shape,
+    async (args: z.infer<typeof contactSchemas.update_contact>) => {
+      const backend = getBackend(args.backend);
+      const { id, backend: _, ...updateFields } = args;
+      const result = await backend.updateContact(id, updateFields);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+}

package/src/tools/invoices.ts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import type { IAccountingBackend } from "../backends/types.js";
+
+const lineItemSchema = z.object({
+  name: z.string().describe("Positionsname"),
+  quantity: z.number().default(1).describe("Menge"),
+  unitPrice: z.number().describe("Einzelpreis netto"),
+  taxRate: z.number().default(19).describe("Steuersatz in Prozent"),
+});
+
+export const invoiceSchemas = {
+  create_invoice: z.object({
+    contactId: z.string().describe("Kontakt-ID des Rechnungsempfaengers"),
+    date: z.string().describe("Rechnungsdatum (ISO 8601, z.B. 2026-03-18)"),
+    lineItems: z.array(lineItemSchema).min(1).describe("Rechnungspositionen"),
+    title: z.string().optional().describe("Rechnungstitel"),
+    introduction: z.string().optional().describe("Einleitungstext"),
+    remark: z.string().optional().describe("Schlusstext"),
+    currency: z.string().default("EUR").describe("Waehrung"),
+    finalize: z.boolean().default(false).describe("Rechnung direkt finalisieren (nicht mehr editierbar)"),
+    backend: z.string().optional(),
+  }),
+  get_invoice: z.object({
+    id: z.string().describe("Rechnungs-ID"),
+    backend: z.string().optional(),
+  }),
+  list_invoices: z.object({
+    status: z.enum(["draft", "open", "paid", "overdue"]).optional().describe("Nach Status filtern"),
+    contactId: z.string().optional().describe("Nach Kontakt filtern"),
+    limit: z.number().default(25).describe("Maximale Anzahl"),
+    backend: z.string().optional(),
+  }),
+  get_invoice_pdf: z.object({
+    id: z.string().describe("Rechnungs-ID"),
+    backend: z.string().optional(),
+  }),
+  update_invoice: z.object({
+    id: z.string().describe("Rechnungs-ID"),
+    title: z.string().optional(),
+    introduction: z.string().optional(),
+    remark: z.string().optional(),
+    backend: z.string().optional(),
+  }),
+};
+
+export function registerInvoiceTools(
+  server: any,
+  getBackend: (name?: string) => IAccountingBackend,
+) {
+  server.tool(
+    "create_invoice",
+    "Erstellt eine neue Rechnung mit Positionen. Creates a new invoice with line items.",
+    invoiceSchemas.create_invoice.shape,
+    async (args: z.infer<typeof invoiceSchemas.create_invoice>) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.createInvoice({
+        contactId: args.contactId,
+        date: args.date,
+        lineItems: args.lineItems,
+        title: args.title,
+        introduction: args.introduction,
+        remark: args.remark,
+        currency: args.currency,
+        finalize: args.finalize,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "get_invoice",
+    "Ruft eine Rechnung per ID ab. Gets an invoice by ID.",
+    invoiceSchemas.get_invoice.shape,
+    async (args: z.infer<typeof invoiceSchemas.get_invoice>) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.getInvoice(args.id);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "list_invoices",
+    "Listet Rechnungen auf. Kann nach Status filtern (draft, open, paid, overdue). Lists invoices with optional status filter.",
+    invoiceSchemas.list_invoices.shape,
+    async (args: z.infer<typeof invoiceSchemas.list_invoices>) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.listInvoices({
+        status: args.status,
+        contactId: args.contactId,
+        limit: args.limit,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "get_invoice_pdf",
+    "Laedt eine Rechnung als PDF herunter (Base64-kodiert). Downloads an invoice as PDF (base64-encoded).",
+    invoiceSchemas.get_invoice_pdf.shape,
+    async (args: z.infer<typeof invoiceSchemas.get_invoice_pdf>) => {
+      const backend = getBackend(args.backend);
+      const { data, filename } = await backend.getInvoicePdf(args.id);
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify({
+            filename,
+            size_bytes: data.length,
+            base64: data.toString("base64"),
+            hint: "PDF ist base64-kodiert. Zum Speichern: Buffer.from(base64, 'base64') oder als data-URI verwenden.",
+          }, null, 2),
+        }],
+      };
+    },
+  );
+
+  server.tool(
+    "update_invoice",
+    "Aktualisiert eine bestehende Rechnung (nur Entwuerfe). Updates a draft invoice.",
+    invoiceSchemas.update_invoice.shape,
+    async (args: z.infer<typeof invoiceSchemas.update_invoice>) => {
+      const backend = getBackend(args.backend);
+      const { id, backend: _, ...updateFields } = args;
+      const result = await backend.updateInvoice(id, updateFields);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+}

package/src/tools/quotations.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import type { IAccountingBackend } from "../backends/types.js";
+
+const lineItemSchema = z.object({
+  name: z.string().describe("Positionsname"),
+  quantity: z.number().default(1).describe("Menge"),
+  unitPrice: z.number().describe("Einzelpreis netto"),
+  taxRate: z.number().default(19).describe("Steuersatz in Prozent"),
+});
+
+export function registerQuotationTools(
+  server: any,
+  getBackend: (name?: string) => IAccountingBackend,
+) {
+  server.tool(
+    "create_quotation",
+    "Erstellt ein neues Angebot mit Positionen. Creates a new quotation with line items.",
+    {
+      contactId: z.string().describe("Kontakt-ID"),
+      date: z.string().describe("Angebotsdatum (ISO 8601)"),
+      lineItems: z.array(lineItemSchema).min(1).describe("Angebotspositionen"),
+      expirationDate: z.string().optional().describe("Gueltig bis (ISO 8601)"),
+      title: z.string().optional().describe("Angebotstitel"),
+      introduction: z.string().optional().describe("Einleitungstext"),
+      remark: z.string().optional().describe("Schlusstext"),
+      finalize: z.boolean().default(false).describe("Angebot direkt finalisieren"),
+      backend: z.string().optional(),
+    },
+    async (args: any) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.createQuotation({
+        contactId: args.contactId,
+        date: args.date,
+        lineItems: args.lineItems,
+        expirationDate: args.expirationDate,
+        title: args.title,
+        introduction: args.introduction,
+        remark: args.remark,
+        finalize: args.finalize,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "get_quotation",
+    "Ruft ein Angebot per ID ab. Gets a quotation by ID.",
+    {
+      id: z.string().describe("Angebots-ID"),
+      backend: z.string().optional(),
+    },
+    async (args: any) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.getQuotation(args.id);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+}

package/src/tools/sync.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { IAccountingBackend } from "../backends/types.js";
+
+export function registerSyncTools(
+  server: any,
+  getBackend: (name?: string) => IAccountingBackend,
+) {
+  server.tool(
+    "get_overdue_invoices",
+    "Listet alle ueberfaelligen Rechnungen mit Betrag und Faelligkeitsdatum. Lists all overdue invoices with amount and due date.",
+    {
+      days_overdue: z.number().default(0).describe("Mindestens X Tage ueberfaellig (0 = alle ueberfaelligen)"),
+      limit: z.number().default(50).describe("Maximale Anzahl"),
+      backend: z.string().optional(),
+    },
+    async (args: any) => {
+      const backend = getBackend(args.backend);
+      const invoices = await backend.listInvoices({ status: "overdue", limit: args.limit });
+
+      const now = Date.now();
+      const filtered = args.days_overdue > 0
+        ? invoices.filter((inv) => {
+            const dueTime = new Date(inv.dueDate).getTime();
+            const daysOver = (now - dueTime) / (1000 * 60 * 60 * 24);
+            return daysOver >= args.days_overdue;
+          })
+        : invoices;
+
+      const totalOverdue = filtered.reduce((sum, inv) => sum + inv.totalGross, 0);
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify({
+            count: filtered.length,
+            total_overdue_amount: Math.round(totalOverdue * 100) / 100,
+            currency: "EUR",
+            invoices: filtered.map((inv) => ({
+              id: inv.id,
+              number: inv.number,
+              totalGross: inv.totalGross,
+              dueDate: inv.dueDate,
+              daysOverdue: Math.floor((now - new Date(inv.dueDate).getTime()) / (1000 * 60 * 60 * 24)),
+            })),
+          }, null, 2),
+        }],
+      };
+    },
+  );
+}

package/src/tools/vouchers.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import type { IAccountingBackend } from "../backends/types.js";
+
+export function registerVoucherTools(
+  server: any,
+  getBackend: (name?: string) => IAccountingBackend,
+) {
+  server.tool(
+    "create_voucher",
+    "Erstellt einen neuen Beleg (Eingangsrechnung, Gutschrift). Creates a new voucher (purchase invoice, credit note).",
+    {
+      type: z.enum(["purchaseinvoice", "purchasecreditnote", "any"]).describe("Belegtyp"),
+      date: z.string().describe("Belegdatum (ISO 8601)"),
+      totalGross: z.number().describe("Bruttobetrag"),
+      taxRate: z.number().default(19).describe("Steuersatz in Prozent"),
+      contactId: z.string().optional().describe("Kontakt-ID (optional)"),
+      remark: z.string().optional().describe("Bemerkung"),
+      backend: z.string().optional(),
+    },
+    async (args: any) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.createVoucher({
+        type: args.type,
+        date: args.date,
+        totalGross: args.totalGross,
+        taxRate: args.taxRate,
+        contactId: args.contactId,
+        remark: args.remark,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "get_voucher",
+    "Ruft einen Beleg per ID ab. Gets a voucher by ID.",
+    {
+      id: z.string().describe("Beleg-ID"),
+      backend: z.string().optional(),
+    },
+    async (args: any) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.getVoucher(args.id);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  server.tool(
+    "list_vouchers",
+    "Listet Belege auf mit optionalen Filtern. Lists vouchers with optional filters.",
+    {
+      type: z.enum(["purchaseinvoice", "purchasecreditnote", "any"]).optional().describe("Nach Typ filtern"),
+      limit: z.number().default(25).describe("Maximale Anzahl"),
+      backend: z.string().optional(),
+    },
+    async (args: any) => {
+      const backend = getBackend(args.backend);
+      const result = await backend.listVouchers({
+        type: args.type,
+        limit: args.limit,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"]
+}