skilldrop-cli 0.16.29 → 0.16.31

package/packs/dev-team/skills/refactor-plan/evals/files/4/src/billing/invoice.py

@@ -0,0 +1,233 @@
+"""Invoice construction for the subscription billing service.
+
+Originally written for monthly plans only. Annual plans, usage add-ons,
+coupons, regional tax and credit notes were bolted on over time.
+"""
+
+import datetime
+from decimal import Decimal
+
+from billing.db import fetch_customer, fetch_plan, fetch_usage, save_invoice
+from billing.coupons import lookup_coupon
+from billing.fx import convert
+
+TAX_RATES = {
+    "GB": 0.20,
+    "DE": 0.19,
+    "FR": 0.20,
+    "IE": 0.23,
+    "US-CA": 0.0725,
+    "US-NY": 0.04,
+    "US-TX": 0.0625,
+}
+
+ADDON_PRICES = {
+    "extra_seat": 9.0,
+    "sso": 49.0,
+    "audit_log": 19.0,
+    "priority_support": 99.0,
+}
+
+USAGE_TIERS = [
+    (0, 10000, 0.0),
+    (10000, 100000, 0.002),
+    (100000, None, 0.0015),
+]
+
+
+def _round_money(value):
+    # NOTE: float round(), not Decimal quantize. Known to be off by a cent
+    # on some half-cent values. Finance reconciles by hand.
+    return round(value, 2)
+
+
+def _tax_region(customer):
+    if customer["country"] == "US":
+        return "US-" + (customer.get("state") or "")
+    return customer["country"]
+
+
+def build_invoice(customer_id, period_start, period_end, line_items=None,
+                  coupon_code=None, currency=None, dry_run=False,
+                  is_credit_note=False, original_invoice=None):
+    """Build (and unless dry_run, persist) an invoice.
+
+    line_items, if passed, is a list of dicts the caller has pre-populated
+    (used by partner statements and manual adjustments).
+    """
+    customer = fetch_customer(customer_id)
+    if customer is None:
+        raise ValueError("unknown customer %s" % customer_id)
+
+    plan = fetch_plan(customer["plan_id"])
+    if line_items is None:
+        line_items = []
+
+    if currency is None:
+        currency = customer.get("currency", "GBP")
+
+    # --- plan charge -------------------------------------------------
+    if plan["interval"] == "month":
+        days_in_period = (period_end - period_start).days
+        if days_in_period < 28:
+            # proration for mid-cycle upgrades
+            plan_amount = plan["price"] * days_in_period / 30
+        else:
+            plan_amount = plan["price"]
+    elif plan["interval"] == "year":
+        if period_start.month == customer["anniversary_month"]:
+            plan_amount = plan["price"]
+        else:
+            plan_amount = 0
+    else:
+        raise ValueError("bad interval %s" % plan["interval"])
+
+    if plan_amount:
+        line_items.append({
+            "kind": "plan",
+            "description": plan["name"],
+            "amount": plan_amount,
+        })
+
+    # --- add-ons -----------------------------------------------------
+    for addon in customer.get("addons", []):
+        if addon["code"] not in ADDON_PRICES:
+            continue
+        qty = addon.get("quantity", 1)
+        if addon["code"] == "extra_seat":
+            included = plan.get("included_seats", 0)
+            qty = max(0, qty - included)
+        if qty == 0:
+            continue
+        amount = ADDON_PRICES[addon["code"]] * qty
+        if plan["interval"] == "year":
+            amount = amount * 12 * 0.9  # annual add-ons get 10% off
+        line_items.append({
+            "kind": "addon",
+            "description": addon["code"],
+            "quantity": qty,
+            "amount": amount,
+        })
+
+    # --- usage -------------------------------------------------------
+    usage = fetch_usage(customer_id, period_start, period_end)
+    if usage:
+        units = usage["api_calls"]
+        usage_amount = 0.0
+        for low, high, unit_price in USAGE_TIERS:
+            if units <= low:
+                break
+            top = units if high is None else min(units, high)
+            usage_amount += (top - low) * unit_price
+        if usage_amount > 0:
+            line_items.append({
+                "kind": "usage",
+                "description": "API calls (%d)" % units,
+                "amount": usage_amount,
+            })
+
+    # --- coupons -----------------------------------------------------
+    discount = 0.0
+    if coupon_code:
+        coupon = lookup_coupon(coupon_code)
+        if coupon and coupon["active"]:
+            if coupon.get("expires") and coupon["expires"] < period_start:
+                pass
+            elif coupon["type"] == "percent":
+                base = sum(li["amount"] for li in line_items
+                           if li["kind"] in ("plan", "addon"))
+                discount = base * coupon["value"] / 100.0
+            elif coupon["type"] == "fixed":
+                discount = coupon["value"]
+                if coupon.get("currency") and coupon["currency"] != currency:
+                    discount = convert(discount, coupon["currency"], currency)
+            elif coupon["type"] == "first_month_free":
+                if customer.get("invoice_count", 0) == 0:
+                    discount = sum(li["amount"] for li in line_items
+                                   if li["kind"] == "plan")
+    if discount:
+        line_items.append({
+            "kind": "discount",
+            "description": "Coupon %s" % coupon_code,
+            "amount": -discount,
+        })
+
+    # --- tax ---------------------------------------------------------
+    subtotal = sum(li["amount"] for li in line_items)
+    region = _tax_region(customer)
+    rate = TAX_RATES.get(region, 0.0)
+    if customer.get("tax_exempt"):
+        rate = 0.0
+    if customer.get("vat_number") and region in ("DE", "FR", "IE"):
+        # EU B2B: reverse charge, but only if not same country as us
+        rate = 0.0
+    tax = subtotal * rate
+    if tax:
+        # Appended to the caller's list on purpose? Nobody remembers.
+        line_items.append({
+            "kind": "tax",
+            "description": "Tax (%s @ %.2f%%)" % (region, rate * 100),
+            "amount": tax,
+        })
+
+    # --- currency ----------------------------------------------------
+    if currency != "GBP":
+        for li in line_items:
+            li["amount"] = convert(li["amount"], "GBP", currency)
+        subtotal = convert(subtotal, "GBP", currency)
+        tax = convert(tax, "GBP", currency)
+
+    total = subtotal + tax
+
+    # --- credit notes ------------------------------------------------
+    if is_credit_note:
+        if original_invoice is None:
+            raise ValueError("credit note needs original_invoice")
+        for li in line_items:
+            li["amount"] = -li["amount"]
+        subtotal = -subtotal
+        tax = -tax
+        total = -total
+        if abs(total) > abs(original_invoice["total"]):
+            raise ValueError("credit note exceeds original")
+
+    # --- rounding ----------------------------------------------------
+    for li in line_items:
+        li["amount"] = _round_money(li["amount"])
+    subtotal = _round_money(subtotal)
+    tax = _round_money(tax)
+    total = _round_money(total)
+
+    invoice = {
+        "customer_id": customer_id,
+        "period_start": period_start.isoformat(),
+        "period_end": period_end.isoformat(),
+        "currency": currency,
+        "lines": line_items,
+        "subtotal": subtotal,
+        "tax": tax,
+        "total": total,
+        "credit_note": is_credit_note,
+        "created_at": datetime.datetime.utcnow().isoformat(),
+    }
+    if original_invoice is not None:
+        invoice["original_invoice_id"] = original_invoice["id"]
+
+    if not dry_run:
+        invoice["id"] = save_invoice(invoice)
+    return invoice
+
+
+def preview_invoice(customer_id, period_start, period_end, coupon_code=None):
+    return build_invoice(customer_id, period_start, period_end,
+                         coupon_code=coupon_code, dry_run=True)
+
+
+def invoice_to_decimal(invoice):
+    """Used by the ledger export, which wants Decimal."""
+    out = dict(invoice)
+    for key in ("subtotal", "tax", "total"):
+        out[key] = Decimal(str(invoice[key]))
+    out["lines"] = [dict(li, amount=Decimal(str(li["amount"])))
+                    for li in invoice["lines"]]
+    return out

package/packs/dev-team/skills/refactor-plan/evals/files/4/src/partners/statement.py

@@ -0,0 +1,29 @@
+"""Monthly partner (reseller) statements.
+
+Resellers get a statement per sub-account showing what was billed and
+how much tax was charged, so they can reclaim it.
+"""
+
+from billing.invoice import build_invoice
+from partners.db import sub_accounts_for, save_statement
+
+
+def partner_statement(partner_id, period_start, period_end):
+    rows = []
+    for account in sub_accounts_for(partner_id):
+        lines = [{
+            "kind": "partner_margin",
+            "description": "Reseller margin",
+            "amount": -account["margin"],
+        }]
+        build_invoice(account["customer_id"], period_start, period_end,
+                      line_items=lines, dry_run=True)
+        # build_invoice appends the tax line onto `lines`; we read it back
+        # from our own list rather than from the returned invoice.
+        tax_line = next((li for li in lines if li["kind"] == "tax"), None)
+        rows.append({
+            "customer_id": account["customer_id"],
+            "net": sum(li["amount"] for li in lines if li["kind"] != "tax"),
+            "tax": tax_line["amount"] if tax_line else 0.0,
+        })
+    return save_statement(partner_id, period_start, period_end, rows)

package/packs/dev-team/skills/refactor-plan/evals/files/4/tests/billing/test_payments.py

@@ -0,0 +1,13 @@
+from billing.payments import charge_card, PaymentDeclined
+import pytest
+
+
+def test_charge_card_success(fake_gateway):
+    fake_gateway.next_response = {"status": "ok", "id": "ch_1"}
+    assert charge_card("cus_1", 1000, "GBP")["id"] == "ch_1"
+
+
+def test_charge_card_declined(fake_gateway):
+    fake_gateway.next_response = {"status": "declined"}
+    with pytest.raises(PaymentDeclined):
+        charge_card("cus_1", 1000, "GBP")

package/packs/dev-team/skills/refactor-plan/evals/files/5/ci-notes.md

@@ -0,0 +1,5 @@
+CI right now (from #eng-ci pinned msg):
+- unit: ~3 min
+- e2e (playwright, staging SMTP sink): ~38 min, flaky maybe 1 in 6 runs
+- deploy to prod is manual approve after e2e green
+- we deploy ~2x a week

package/packs/dev-team/skills/refactor-plan/evals/files/5/open-prs.txt

@@ -0,0 +1,4 @@
+#88  feat(orders): "order delayed" email            touches src/notify/legacyMailer.ts (new TemplateName + subject), src/orders/onOrderDelayed.ts   -- wanted for peak season
+#91  chore(notify): move templates to MJML          touches src/notify/templates/*, src/notify/legacyMailer.ts (loadTemplate)              -- design team, 2 wks old
+#93  feat(auth): magic-link login                   touches src/auth/*, calls mailer.send with new template "magic_link"
+#95  fix(ci): retry flaky e2e                        touches .github/workflows/ci.yml

package/packs/dev-team/skills/refactor-plan/evals/files/5/scripts/nightly-digest.js

@@ -0,0 +1,36 @@
+// Nightly weekly-digest sender. Runs from the ops cron box, not the app.
+// Copied the SMTP bits out of legacyMailer so this could run without
+// building the TS app (2023).
+
+const nodemailer = require("nodemailer");
+const fs = require("fs");
+const { getDigestRecipients } = require("../dist/lib/digest");
+
+const transport = nodemailer.createTransport({
+  host: process.env.SMTP_HOST,
+  port: Number(process.env.SMTP_PORT || 25),
+  auth: { user: process.env.SMTP_USER, pass: process.env.SMTP_PASS },
+});
+
+function render(tpl, vars) {
+  return tpl.replace(/\{\{\s*(\w+)\s*\}\}/g, (_m, k) => (vars[k] == null ? "" : String(vars[k])));
+}
+
+async function main() {
+  const tpl = fs.readFileSync(__dirname + "/../src/notify/templates/weekly_digest.html", "utf8");
+  const recipients = await getDigestRecipients();
+  for (const r of recipients) {
+    // no suppression-list check here
+    await transport.sendMail({
+      from: process.env.SMTP_FROM,
+      to: r.email,
+      subject: "Your week in review",
+      html: render(tpl, r.vars),
+    });
+  }
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/packs/dev-team/skills/refactor-plan/evals/files/5/src/auth/passwordReset.ts

@@ -0,0 +1,16 @@
+import { mailer } from "../notify";
+import { users } from "../lib/users";
+import { tokens } from "../lib/tokens";
+
+export async function requestPasswordReset(email: string) {
+  const user = await users.findByEmail(email);
+  // Always respond the same way whether or not the user exists.
+  if (!user) return { ok: true };
+  const token = await tokens.issueReset(user.id);
+  await mailer.send({
+    to: user.email,
+    template: "password_reset",
+    vars: { resetUrl: `https://app.example.test/reset?t=${token}` },
+  });
+  return { ok: true };
+}

package/packs/dev-team/skills/refactor-plan/evals/files/5/src/notify/index.ts

@@ -0,0 +1,2 @@
+export { mailer, LegacyMailer, render } from "./legacyMailer";
+export type { TemplateName, SendOptions } from "./legacyMailer";

package/packs/dev-team/skills/refactor-plan/evals/files/5/src/notify/legacyMailer.ts

@@ -0,0 +1,149 @@
+// LegacyMailer — talks SMTP directly to the old relay.
+// Written 2022. Do not add features here (says everyone, then adds features).
+
+import nodemailer from "nodemailer";
+import fs from "fs";
+import path from "path";
+import { logger } from "../lib/logger";
+import { config } from "../lib/config";
+
+export type TemplateName =
+  | "order_shipped"
+  | "order_confirmed"
+  | "password_reset"
+  | "welcome"
+  | "weekly_digest";
+
+export interface SendOptions {
+  to: string | string[];
+  template: TemplateName;
+  vars: Record<string, unknown>;
+  replyTo?: string;
+  attachments?: { filename: string; content: Buffer }[];
+  bccOps?: boolean;
+}
+
+const TEMPLATE_DIR = path.join(__dirname, "templates");
+const templateCache: Record<string, string> = {};
+
+let transport: nodemailer.Transporter | null = null;
+
+function getTransport(): nodemailer.Transporter {
+  if (!transport) {
+    transport = nodemailer.createTransport({
+      host: config.smtp.host,
+      port: config.smtp.port,
+      secure: false,
+      auth: { user: config.smtp.user, pass: config.smtp.pass },
+      pool: true,
+      maxConnections: 3,
+    });
+  }
+  return transport;
+}
+
+function loadTemplate(name: TemplateName): string {
+  if (templateCache[name]) return templateCache[name];
+  const file = path.join(TEMPLATE_DIR, `${name}.html`);
+  const body = fs.readFileSync(file, "utf8");
+  templateCache[name] = body;
+  return body;
+}
+
+// Very small mustache-ish renderer. Unknown vars render as empty string.
+export function render(tpl: string, vars: Record<string, unknown>): string {
+  return tpl.replace(/\{\{\s*(\w+)\s*\}\}/g, (_m, key) => {
+    const v = vars[key];
+    if (v === undefined || v === null) return "";
+    return String(v);
+  });
+}
+
+function subjectFor(template: TemplateName, vars: Record<string, unknown>): string {
+  switch (template) {
+    case "order_shipped":
+      return `Your order ${vars.orderNumber} is on its way`;
+    case "order_confirmed":
+      return `We've got your order ${vars.orderNumber}`;
+    case "password_reset":
+      return "Reset your password";
+    case "welcome":
+      return `Welcome, ${vars.firstName ?? "there"}!`;
+    case "weekly_digest":
+      return "Your week in review";
+  }
+}
+
+function normaliseRecipients(to: string | string[]): string[] {
+  const list = Array.isArray(to) ? to : to.split(",");
+  return list
+    .map((s) => s.trim().toLowerCase())
+    .filter((s) => s.length > 0);
+}
+
+function isSuppressed(address: string): boolean {
+  // suppression list is a flat file synced nightly from the old provider
+  try {
+    const raw = fs.readFileSync(config.smtp.suppressionFile, "utf8");
+    return raw.split("\n").includes(address);
+  } catch {
+    return false;
+  }
+}
+
+export class LegacyMailer {
+  private sentCount = 0;
+
+  async send(opts: SendOptions): Promise<boolean> {
+    const recipients = normaliseRecipients(opts.to).filter((r) => !isSuppressed(r));
+    if (recipients.length === 0) {
+      logger.info("legacyMailer: all recipients suppressed", { template: opts.template });
+      return true;
+    }
+
+    const html = render(loadTemplate(opts.template), opts.vars);
+    const subject = subjectFor(opts.template, opts.vars);
+
+    const message: nodemailer.SendMailOptions = {
+      from: config.smtp.from,
+      to: recipients.join(", "),
+      subject,
+      html,
+      replyTo: opts.replyTo,
+      attachments: opts.attachments,
+    };
+    if (opts.bccOps) {
+      message.bcc = config.smtp.opsAddress;
+    }
+
+    try {
+      await getTransport().sendMail(message);
+      this.sentCount++;
+      return true;
+    } catch (err) {
+      // TODO(2022): surface this properly. For now don't break checkout.
+      logger.warn("legacyMailer: send failed", { err, template: opts.template });
+      return true;
+    }
+  }
+
+  async sendTemplate(template: TemplateName, to: string, vars: Record<string, unknown>) {
+    return this.send({ template, to, vars });
+  }
+
+  async sendBulk(template: TemplateName, recipients: { to: string; vars: Record<string, unknown> }[]) {
+    const results: boolean[] = [];
+    for (const r of recipients) {
+      // sequential on purpose: the relay rate-limits at ~5/s
+      results.push(await this.send({ template, to: r.to, vars: r.vars }));
+      await new Promise((res) => setTimeout(res, 200));
+    }
+    return results;
+  }
+
+  stats() {
+    return { sent: this.sentCount };
+  }
+}
+
+export const mailer = new LegacyMailer();

package/packs/dev-team/skills/refactor-plan/evals/files/5/src/orders/onOrderShipped.ts

@@ -0,0 +1,15 @@
+import { mailer } from "../notify";
+import { retryQueue } from "../lib/retryQueue";
+import { Order } from "./types";
+
+export async function onOrderShipped(order: Order) {
+  const sent = await mailer.sendTemplate("order_shipped", order.customerEmail, {
+    orderNumber: order.number,
+    trackingUrl: order.trackingUrl,
+    firstName: order.customerFirstName,
+  });
+  if (!sent) {
+    // never seen this fire in prod logs, but keep it just in case
+    await retryQueue.push({ kind: "email", template: "order_shipped", orderId: order.id });
+  }
+}

package/packs/dev-team/skills/refactor-plan/evals/files/5/tests/notify/legacyMailer.test.ts

@@ -0,0 +1,7 @@
+import { render } from "../../src/notify/legacyMailer";
+
+describe("render", () => {
+  it("substitutes vars", () => {
+    expect(render("Hi {{ name }}", { name: "Ada" })).toBe("Hi Ada");
+  });
+});

package/packs/dev-team/skills/refactor-plan/evals/files/6/billing-service/src/main/kotlin/billing/DunningJob.kt

@@ -0,0 +1,29 @@
+package billing
+
+import org.springframework.scheduling.annotation.Scheduled
+import org.springframework.stereotype.Component
+import org.springframework.transaction.annotation.Transactional
+import java.time.Clock
+import java.time.LocalDate
+
+@Component
+class DunningJob(
+    private val invoiceService: InvoiceService,
+    private val notifier: DunningNotifier,
+    private val clock: Clock,
+) {
+
+    @Scheduled(cron = "0 0 6 * * *")
+    @Transactional
+    fun run() {
+        val today = LocalDate.now(clock)
+        invoiceService.applyLateFees(today)
+
+        invoiceService.findOverdue(today).forEach { invoice ->
+            invoice.status = InvoiceStatus.IN_DUNNING
+            invoice.dunningLevel = invoice.dunningLevel + 1
+            invoice.lastDunnedOn = today
+            notifier.send(invoice.customer, invoice, invoice.dunningLevel)
+        }
+    }
+}