Stufe 5: Jahresplanung mit Versionen, 12 Monaten, Plan/Ist und BWA-Import (0.22.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-21 21:20:22 +00:00
parent ee5b468502
commit 1d1ba3ace4
19 changed files with 6595 additions and 12 deletions

422
src/domain/jahresplan.ts Normal file
View File

@@ -0,0 +1,422 @@
// Jahresfinanzplanung (Stufe 5, Henning 21.10.2026, Entwurf finanzen/entwurf-jahresplan): ein Jahresplan wird aus
// Bausteinen gebaut (Mitarbeiter, Investitionen, Annahmen) und rechnet die „Treppe“ nach Roos:
// Stunden × Satz + Material/Sub mit Aufschlag = Umsatz → Rohertrag → Personal + Werbung (Ziel ≤ 55 % vom Rohertrag)
// → laufende Kosten → Abschreibungen → Gewinn (Ziel 20 % vom Rohertrag). Der Monatsplan verteilt den Umsatz nach
// der Saison und rechnet bis zum Kontostand am Monatsende. Alle Beträge netto in Cent.
import type { Cent } from "./geld.js";
import type { Posten } from "./liquiditaet.js";
export interface PlanMitarbeiter {
id: string;
name: string;
/** Inhaber: „brutto“ ist der Unternehmerlohn je Monat; angestellt: Bruttolohn je Monat */
art: "inhaber" | "angestellt";
/** verkaufbare Stunden bei einem vollen Jahr */
stunden: number;
brutto: Cent;
/** Arbeitgeberanteile usw., Vorschlag 1,25 */
faktor: number;
/** erster und letzter Monat im Planjahr (1–12) */
eintritt: number;
austritt: number;
/** kommt neu dazu: steht noch nicht in den laufenden Kosten, zählt in der Liquidität als Plan mit */
neu: boolean;
}
export interface PlanInvestition {
id: string;
name: string;
betrag: Cent;
/** Monat der Anschaffung (1–12) */
monat: number;
art: "kauf" | "kredit" | "leasing";
/** Kredit: Eigenanteil; Leasing: Sonderzahlung */
anzahlung: Cent;
/** Kredit- bzw. Leasinglaufzeit in Monaten */
laufzeit: number;
/** Zins % im Jahr (Kredit) */
zins: number;
/** Leasingrate je Monat */
rate: Cent;
/** Nutzungsdauer für die Abschreibung in Jahren (Kauf und Kredit) */
nutzungsdauer: number;
}
export interface PlanAnnahmen {
stundensatz: Cent;
materialEinkauf: Cent;
materialAufschlag: number;
subEinkauf: Cent;
subAufschlag: number;
/** laufende Kosten je Monat ohne Personal (aus „Laufende Kosten“) */
laufendMonat: Cent;
preissteigerung: number;
werbungMonat: Cent;
/** Abschreibungen auf das, was schon da ist, je Jahr */
afaBisher: Cent;
/** Tilgung laufender Kredite je Monat */
tilgungBisher: Cent;
/** Steuer-Vorauszahlungen je Quartal (März, Juni, September, Dezember) */
steuerQuartal: Cent;
kontostandStart: Cent;
mindestgrenze: Cent;
}
export interface PlanDaten {
mitarbeiter: PlanMitarbeiter[];
investitionen: PlanInvestition[];
annahmen: PlanAnnahmen;
/** Anteil am Jahresumsatz je Monat in % */
saison: number[];
}
/** typisch für eine Zimmerei: ruhiger Winter, Saison Mai bis November (Entwurf) */
export const SAISON_HANDWERK = [4, 4, 6, 8, 10, 10, 10, 10, 10, 10, 10, 8];
export const SAISON_GLEICH = Array.from({ length: 12 }, () => 100 / 12);
export const ZIEL_PERSONAL = 55;
export const ZIEL_GEWINN = 20;
export function leererPlan(vorgaben: Partial<PlanAnnahmen> = {}): PlanDaten {
return {
mitarbeiter: [],
investitionen: [],
annahmen: {
stundensatz: 6200, materialEinkauf: 0, materialAufschlag: 15, subEinkauf: 0, subAufschlag: 10,
laufendMonat: 0, preissteigerung: 3, werbungMonat: 0, afaBisher: 0, tilgungBisher: 0, steuerQuartal: 0,
kontostandStart: 0, mindestgrenze: 0, ...vorgaben,
},
saison: [...SAISON_HANDWERK],
};
}
const MONATE = Array.from({ length: 12 }, (_, i) => i + 1);
const null12 = (): Cent[] => Array(12).fill(0);
/** Betrag nach Gewichten auf 12 Monate, Summe bleibt genau (größter Rest) */
export function verteile(betrag: Cent, gewichte: number[]): Cent[] {
const g = gewichte.map((x) => (Number.isFinite(x) && x > 0 ? x : 0));
const s = g.reduce((a, b) => a + b, 0);
if (!s) return verteile(betrag, Array(12).fill(1));
const roh = g.map((x) => (betrag * x) / s);
const teile = roh.map((x) => Math.floor(x));
let rest = betrag - teile.reduce((a, b) => a + b, 0);
const reihenfolge = roh.map((x, i) => [x - Math.floor(x), i] as const).sort((a, b) => b[0] - a[0]);
for (let k = 0; rest > 0; k = (k + 1) % 12, rest--) teile[reihenfolge[k]![1]]! += 1;
return teile;
}
export const aktiv = (m: PlanMitarbeiter, monat: number) => monat >= m.eintritt && monat <= m.austritt;
export const monateAktiv = (m: PlanMitarbeiter) => Math.max(0, Math.min(12, m.austritt) - Math.max(1, m.eintritt) + 1);
export const stundenImJahr = (m: PlanMitarbeiter) => Math.round((m.stunden * monateAktiv(m)) / 12);
export const personalMonat = (m: PlanMitarbeiter): Cent => (m.art === "inhaber" ? m.brutto : Math.round(m.brutto * m.faktor));
/** Annuität: gleiche Monatsrate aus Zins und Tilgung */
export function annuitaet(betrag: Cent, zinsJahr: number, monate: number): Cent {
if (betrag <= 0 || monate <= 0) return 0;
const i = zinsJahr / 1200;
return Math.round(i ? (betrag * i) / (1 - (1 + i) ** -monate) : betrag / monate);
}
export interface InvestitionImJahr {
/** was vom Konto geht: Kauf, Anzahlung, Kredit- oder Leasingrate */
abfluss: Cent[];
/** Kosten in der Treppe: Zinsen und Leasing */
kosten: Cent[];
afa: Cent[];
/** Kreditrate bzw. Leasingrate je Monat (zur Anzeige) */
rate: Cent;
afaJahr: Cent;
}
export function investitionImJahr(v: PlanInvestition): InvestitionImJahr {
const abfluss = null12(), kosten = null12(), afa = null12();
const m0 = Math.min(12, Math.max(1, v.monat)) - 1;
let rate = 0;
if (v.art === "kauf") abfluss[m0]! += v.betrag;
if (v.art === "kredit") {
abfluss[m0]! += v.anzahlung;
const kredit = Math.max(0, v.betrag - v.anzahlung);
rate = annuitaet(kredit, v.zins, v.laufzeit);
let rest = kredit;
for (let k = 1; k <= v.laufzeit && m0 + k < 12 && rest > 0; k++) {
const zins = Math.round((rest * v.zins) / 1200);
const zahlung = Math.min(rate, rest + zins);
abfluss[m0 + k]! += zahlung;
kosten[m0 + k]! += zins;
rest -= zahlung - zins;
}
}
if (v.art === "leasing") {
abfluss[m0]! += v.anzahlung;
rate = v.rate;
// Sonderzahlung verteilt über die Laufzeit als Kosten
const anteil = v.laufzeit > 0 ? Math.round(v.anzahlung / v.laufzeit) : v.anzahlung;
for (let k = 1; k <= v.laufzeit && m0 + k < 12; k++) { abfluss[m0 + k]! += v.rate; kosten[m0 + k]! += v.rate; }
for (let k = 0; k < v.laufzeit && m0 + k < 12; k++) kosten[m0 + k]! += anteil;
}
if (v.art !== "leasing" && v.nutzungsdauer > 0) {
const monatlich = v.betrag / (v.nutzungsdauer * 12);
// ab dem Monat der Anschaffung (monatsgenau wie im Steuerrecht), Summe kaufmännisch gerundet
const jahr = Math.round(monatlich * (12 - m0));
verteile(jahr, MONATE.map((m) => (m - 1 >= m0 ? 1 : 0))).forEach((x, i) => (afa[i] = x));
}
return { abfluss, kosten, afa, rate, afaJahr: afa.reduce((a, b) => a + b, 0) };
}
export type Ampel = "gruen" | "gelb" | "rot";
export const ampelPersonal = (p: number): Ampel => (p <= ZIEL_PERSONAL ? "gruen" : p <= ZIEL_PERSONAL + 5 ? "gelb" : "rot");
export const ampelGewinn = (p: number): Ampel => (p >= ZIEL_GEWINN ? "gruen" : p >= ZIEL_GEWINN - 5 ? "gelb" : "rot");
export interface Treppe {
stunden: number;
stundenUmsatz: Cent;
materialUmsatz: Cent;
subUmsatz: Cent;
umsatz: Cent;
wareneinsatz: Cent;
rohertrag: Cent;
personal: Cent;
unternehmerlohn: Cent;
werbung: Cent;
personalWerbung: Cent;
laufend: Cent;
afa: Cent;
gewinn: Cent;
/** in % vom Rohertrag */
quotePersonal: number;
quoteLaufend: number;
quoteAfa: number;
quoteGewinn: number;
ampelPersonal: Ampel;
ampelGewinn: Ampel;
/** fehlender Gewinn bis 20 % vom Rohertrag (0 = Ziel erreicht) */
luecke: Cent;
}
/** Zeilen des Monatsplans, Ausgaben positiv */
export interface Monate {
umsatz: Cent[];
waren: Cent[];
rohertrag: Cent[];
personal: Cent[];
unternehmerlohn: Cent[];
werbung: Cent[];
laufend: Cent[];
investition: Cent[];
steuer: Cent[];
ueberschuss: Cent[];
kontostand: Cent[];
/** Kosten in der Treppe je Monat (laufend inkl. Zinsen und Leasing), für Plan/Ist */
laufendKosten: Cent[];
afa: Cent[];
/** nur neue Mitarbeiter (Liquidität) */
personalNeu: Cent[];
}
export interface Rechnung {
treppe: Treppe;
monate: Monate;
investitionen: (InvestitionImJahr & { id: string })[];
/** knappster Monat (1–12) */
tief: { monat: number; kontostand: Cent; abstand: Cent };
}
const quote = (x: Cent, basis: Cent) => (basis > 0 ? Math.round((x / basis) * 1000) / 10 : 0);
export function rechne(d: PlanDaten): Rechnung {
const a = d.annahmen;
const stunden = d.mitarbeiter.reduce((s, m) => s + stundenImJahr(m), 0);
const stundenUmsatz = Math.round(stunden * a.stundensatz);
const materialUmsatz = Math.round(a.materialEinkauf * (1 + a.materialAufschlag / 100));
const subUmsatz = Math.round(a.subEinkauf * (1 + a.subAufschlag / 100));
const umsatz = stundenUmsatz + materialUmsatz + subUmsatz;
const wareneinsatz = a.materialEinkauf + a.subEinkauf;
const personal = null12(), unternehmerlohn = null12(), personalNeu = null12();
for (const m of d.mitarbeiter) {
for (const monat of MONATE) {
if (!aktiv(m, monat)) continue;
const k = personalMonat(m);
if (m.art === "inhaber") unternehmerlohn[monat - 1]! += k;
else personal[monat - 1]! += k;
if (m.neu) personalNeu[monat - 1]! += k;
}
}
const lfd = Math.round(a.laufendMonat * (1 + a.preissteigerung / 100));
const investitionen = d.investitionen.map((v) => ({ id: v.id, ...investitionImJahr(v) }));
const afaBisher = verteile(a.afaBisher, Array(12).fill(1));
const monate: Monate = {
umsatz: verteile(umsatz, d.saison),
waren: verteile(wareneinsatz, d.saison),
rohertrag: [], personal, unternehmerlohn, personalNeu,
werbung: Array(12).fill(a.werbungMonat),
laufend: Array(12).fill(lfd),
investition: MONATE.map((m) => a.tilgungBisher + investitionen.reduce((s, v) => s + v.abfluss[m - 1]!, 0)),
steuer: MONATE.map((m) => (m % 3 === 0 ? a.steuerQuartal : 0)),
laufendKosten: MONATE.map((m) => lfd + investitionen.reduce((s, v) => s + v.kosten[m - 1]!, 0)),
afa: MONATE.map((m) => afaBisher[m - 1]! + investitionen.reduce((s, v) => s + v.afa[m - 1]!, 0)),
ueberschuss: [], kontostand: [],
};
let stand = a.kontostandStart;
for (let i = 0; i < 12; i++) {
monate.rohertrag[i] = monate.umsatz[i]! - monate.waren[i]!;
monate.ueberschuss[i] = monate.rohertrag[i]! - personal[i]! - unternehmerlohn[i]! - monate.werbung[i]! - monate.laufend[i]! - monate.investition[i]! - monate.steuer[i]!;
stand += monate.ueberschuss[i]!;
monate.kontostand[i] = stand;
}
const s = (x: Cent[]) => x.reduce((p, q) => p + q, 0);
const rohertrag = umsatz - wareneinsatz;
const personalSumme = s(personal) + s(unternehmerlohn);
const werbung = s(monate.werbung);
const laufend = s(monate.laufendKosten);
const afa = s(monate.afa);
const gewinn = rohertrag - personalSumme - werbung - laufend - afa;
const quotePersonal = quote(personalSumme + werbung, rohertrag);
const quoteGewinn = quote(gewinn, rohertrag);
let ti = 0;
monate.kontostand.forEach((k, i) => { if (k < monate.kontostand[ti]!) ti = i; });
return {
treppe: {
stunden, stundenUmsatz, materialUmsatz, subUmsatz, umsatz, wareneinsatz, rohertrag,
personal: s(personal), unternehmerlohn: s(unternehmerlohn), werbung, personalWerbung: personalSumme + werbung,
laufend, afa, gewinn, quotePersonal, quoteLaufend: quote(laufend, rohertrag), quoteAfa: quote(afa, rohertrag), quoteGewinn,
ampelPersonal: ampelPersonal(quotePersonal), ampelGewinn: ampelGewinn(quoteGewinn),
luecke: Math.max(0, Math.ceil((rohertrag * ZIEL_GEWINN) / 100) - gewinn),
},
monate,
investitionen,
tief: { monat: ti + 1, kontostand: monate.kontostand[ti]!, abstand: monate.kontostand[ti]! - a.mindestgrenze },
};
}
export interface Vorschlag {
id: string;
text: string;
/** Gewinn danach minus Gewinn vorher */
mehrGewinn: Cent;
name: string;
daten: PlanDaten;
}
const kopie = (d: PlanDaten): PlanDaten => JSON.parse(JSON.stringify(d));
const euroGanz = (c: Cent) => `${Math.round(c / 100).toLocaleString("de-DE")} €`;
/**
* Was die Lücke zum Gewinnziel schließen würde, jeweils allein: Stundensatz, Material- oder Sub-Aufschlag.
* Mehr Umsatz hebt auch den Rohertrag und damit das Ziel, deshalb wird mit dem neuen Plan nachgerechnet.
*/
export function vorschlaege(d: PlanDaten): Vorschlag[] {
const r = rechne(d);
if (r.treppe.luecke <= 0) return [];
const a = d.annahmen;
const aus: Vorschlag[] = [];
const reicht = (x: PlanDaten) => rechne(x).treppe.luecke <= 0;
const suche = (start: number, schritt: number, setze: (x: PlanDaten, w: number) => void, max = 400): number | null => {
for (let w = start + schritt, i = 0; i < max; w += schritt, i++) {
const x = kopie(d);
setze(x, w);
if (reicht(x)) return w;
}
return null;
};
if (r.treppe.stunden > 0) {
const satz = suche(Math.ceil(a.stundensatz / 100) * 100, 100, (x, w) => (x.annahmen.stundensatz = w));
if (satz !== null) {
const x = kopie(d);
x.annahmen.stundensatz = satz;
aus.push({ id: "satz", text: `Stundensatz ${euroGanz(a.stundensatz)} → ${euroGanz(satz)}`, name: `Stundensatz ${euroGanz(satz)}`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x });
}
}
if (a.materialEinkauf > 0) {
const p = suche(Math.ceil(a.materialAufschlag), 1, (x, w) => (x.annahmen.materialAufschlag = w), 200);
if (p !== null) {
const x = kopie(d);
x.annahmen.materialAufschlag = p;
aus.push({ id: "material", text: `Material-Aufschlag ${a.materialAufschlag} → ${p} %`, name: `Material +${p} %`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x });
}
}
if (a.subEinkauf > 0) {
const p = suche(Math.ceil(a.subAufschlag), 1, (x, w) => (x.annahmen.subAufschlag = w), 200);
if (p !== null) {
const x = kopie(d);
x.annahmen.subAufschlag = p;
aus.push({ id: "sub", text: `Sub-Aufschlag ${a.subAufschlag} → ${p} %`, name: `Sub +${p} %`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x });
}
}
return aus;
}
const MONAT_KURZ = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
/** Satz zum knappsten Monat und was ihn verursacht, wie in der Liquidität */
export function knappText(d: PlanDaten, r: Rechnung): { satz: string; grund: string } {
const { monat, kontostand, abstand } = r.tief;
const name = MONAT_KURZ[monat - 1]!;
const satz = abstand >= 0
? `Am knappsten wird es Ende ${name} mit ${euroGanz(kontostand)}, ${euroGanz(abstand)} über deiner Mindestgrenze.`
: `Ende ${name} liegt der Kontostand bei ${euroGanz(kontostand)}, ${euroGanz(-abstand)} unter deiner Mindestgrenze.`;
const gruende: string[] = [];
const neue = d.mitarbeiter.filter((m) => m.art === "angestellt" && m.eintritt > 1 && m.eintritt <= monat);
if (neue.length) gruende.push(`${neue.map((m) => m.name).join(" und ")} ${neue.length > 1 ? "fangen" : "fängt"} an`);
const inv = d.investitionen.filter((v) => v.monat <= monat && v.monat >= monat - 2 && (v.art === "kauf" ? v.betrag : v.anzahlung) > 0);
if (inv.length) gruende.push(`${inv.map((v) => v.name).join(" und ")} ${v1(inv.length)} ${inv.some((v) => v.art === "kauf") ? "bezahlt" : "angezahlt"}`);
const saisonBis = d.saison.slice(0, monat);
const schnitt = d.saison.reduce((x, y) => x + y, 0) / 12;
if (saisonBis.at(-1)! < schnitt) gruende.push(`der Umsatz liegt bis dahin bei nur ${Math.round(Math.min(...saisonBis))}–${Math.round(Math.max(...saisonBis))} % je Monat`);
if (monat % 3 === 0 && d.annahmen.steuerQuartal > 0) gruende.push(`die Steuer-Vorauszahlung ist fällig`);
return { satz, grund: gruende.length ? `Grund: ${gruende.join(", ")}.` : "" };
}
const v1 = (n: number) => (n > 1 ? "werden" : "wird");
/** Plan-Zeilen, denen die BWA-Zeilen zugeordnet werden */
export const PLANZEILEN = ["umsatz", "material", "personal", "unternehmerlohn", "werbung", "laufend", "afa", "tilgung", "investition", "steuer"] as const;
export type Planzeile = (typeof PLANZEILEN)[number] | "ignorieren";
export const PLANZEILE_TEXT: Record<Planzeile, string> = {
umsatz: "Umsatz", material: "Material und Subunternehmer", personal: "Personal (Löhne)", unternehmerlohn: "Unternehmerlohn (Privatentnahmen)",
werbung: "Werbung", laufend: "Laufende Kosten", afa: "Abschreibungen", tilgung: "Tilgung", investition: "Investitionen",
steuer: "Steuer-Vorauszahlungen", ignorieren: "nicht im Plan (Steuer, Durchlauf, Summe)",
};
/** Planwerte eines Monats (oder kumuliert bis zum Monat) je Planzeile, Kosten positiv */
export function planWerte(r: Rechnung, monat: number, kumuliert: boolean): Record<(typeof PLANZEILEN)[number], Cent> {
const von = kumuliert ? 0 : monat - 1;
const s = (x: Cent[]) => x.slice(von, monat).reduce((a, b) => a + b, 0);
const m = r.monate;
const investition = r.investitionen.reduce((t, v) => t + v.abfluss.slice(von, monat).reduce((a, b) => a + b, 0), 0);
return {
umsatz: s(m.umsatz), material: s(m.waren), personal: s(m.personal), unternehmerlohn: s(m.unternehmerlohn), werbung: s(m.werbung),
laufend: s(m.laufendKosten), afa: s(m.afa), tilgung: s(m.investition) - investition, investition, steuer: s(m.steuer),
};
}
/**
* Vorschau für die Liquidität (Henning, Entwurf „12 Monate“): ab dem nächsten Monat zählt der Plan, soweit echte
* Zahlungen fehlen. Einnahmen und Material/Sub nur der Rest über den echten Posten des Monats; dazu Löhne neuer
* Mitarbeiter, neue Investitionen und Steuer-Vorauszahlungen. Laufende Kosten stehen schon echt in der Liquidität.
* Plan-Werte sind netto; echte Posten werden dafür um die Umsatzsteuer bereinigt.
*/
export function planPosten(alle: Posten[], plaene: { jahr: number; daten: PlanDaten }[], heute: string, ustSatz: number): Posten[] {
const aus: Posten[] = [];
const ab = heute.slice(0, 7);
const netto = (b: number) => Math.round(b / (1 + ustSatz / 100));
for (const p of plaene) {
const r = rechne(p.daten);
for (let i = 0; i < 12; i++) {
const monat = `${p.jahr}-${String(i + 1).padStart(2, "0")}`;
if (monat <= ab) continue;
const datum = `${monat}-15`, name = `${MONAT_KURZ[i]} ${p.jahr}`;
const imMonat = alle.filter((x) => x.datum.startsWith(monat));
const ein = imMonat.filter((x) => x.gruppe === "Projekteinnahmen").reduce((s, x) => s + netto(x.betrag), 0);
const kosten = -imMonat.filter((x) => x.gruppe === "Projektkosten").reduce((s, x) => s + netto(x.betrag), 0);
const plus = (bezeichnung: string, betrag: number) => { if (betrag) aus.push({ datum, gruppe: "Jahresplan", bezeichnung, betrag }); };
plus(`Plan: weitere Einnahmen ${name}`, Math.max(0, r.monate.umsatz[i]! - ein));
plus(`Plan: Material und Sub ${name}`, -Math.max(0, r.monate.waren[i]! - kosten));
plus(`Plan: Löhne neue Mitarbeiter ${name}`, -r.monate.personalNeu[i]!);
plus(`Plan: Investitionen ${name}`, -r.investitionen.reduce((s, v) => s + v.abfluss[i]!, 0));
plus(`Plan: Steuer-Vorauszahlung ${name}`, -r.monate.steuer[i]!);
}
}
return aus;
}