lambda-erp 0.1.25__tar.gz → 0.1.26__tar.gz

{lambda_erp-0.1.25 → lambda_erp-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.1.25
+Version: 0.1.26
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: MIT

{lambda_erp-0.1.25 → lambda_erp-0.1.26}/api/chat.py

@@ -603,7 +603,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "get_master_fields",
-            "description": "List the available columns of a master type (customer, supplier, item, ...). Call this BEFORE passing `fields` to search_masters (or before guessing column names) so you target real fields instead of guessing. Returns: `fields` (all columns), `default_search_fields` (what search_masters searches when `fields` is omitted), and `bulk_text_fields` (large text columns searched only when named in `fields`).",
+            "description": "List the available columns of a master type (customer, supplier, item, ...). Call this WHENEVER you're unsure which columns exist: before passing `fields` to search_masters, and before building a `data` payload for create_master/update_master when you're not certain a field exists or where a value belongs (e.g. a contact person, a tax id, a payment term). It lets you target real fields instead of guessing — or wrongly concluding a value can't be stored. Returns: `fields` (all columns), `default_search_fields` (what search_masters searches when `fields` is omitted), and `bulk_text_fields` (large text columns searched only when named in `fields`).",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -628,8 +628,10 @@ TOOLS = [
                 "**Account fields:** name (REQUIRED — full account id, conventionally \"<account_name> - <company abbr>\", e.g. \"Marketing Expenses - LAMB\"), account_name (required), company (required), root_type (Asset/Liability/Equity/Income/Expense), report_type (\"Balance Sheet\" or \"Profit and Loss\"), account_type (e.g. Receivable, Payable, Bank, Cash, Stock, Tax), parent_account, account_currency, is_group (0/1).\n"
                 "**Cost Center fields:** name (REQUIRED — e.g. \"Marketing - LAMB\"), cost_center_name (required), company (required), parent_cost_center, is_group (0/1).\n\n"
                 "zip_code is free text (e.g. \"8400\", \"ZH 8400\", \"59123\"), never numeric.\n"
+                "When the user names a contact person at a customer (e.g. \"Kontakt/Ansprechpartner ist Marlene Voss, 079 123 45 67\"), put the person's name in contact_person and their phone/email in contact_phone/contact_email — NOT in the company-level phone/email. There is no separate contact tool; contact-person data lives on these Customer columns, so never claim you cannot store a contact person.\n"
                 "Supplier example: {\"master_type\":\"supplier\",\"data\":{\"supplier_name\":\"Schlafteq\",\"email\":\"jacob@schlafteq.ch\",\"phone\":\"+1 555-0104\",\"address\":\"145 Harbor Rd\",\"city\":\"Seattle\",\"zip_code\":\"98101\",\"country\":\"US\",\"tax_id\":\"98-7654321\"}}\n"
-                "Item example (custom code): {\"master_type\":\"item\",\"data\":{\"item_code\":\"SVC-SPARK\",\"item_name\":\"Spark\",\"item_group\":\"Services\",\"is_stock_item\":0,\"standard_rate\":310}}"
+                "Item example (custom code): {\"master_type\":\"item\",\"data\":{\"item_code\":\"SVC-SPARK\",\"item_name\":\"Spark\",\"item_group\":\"Services\",\"is_stock_item\":0,\"standard_rate\":310}}\n"
+                "Customer example (with contact person): {\"master_type\":\"customer\",\"data\":{\"customer_name\":\"Foglio AG\",\"address\":\"Seeweg 12\",\"city\":\"Bramblewick\",\"zip_code\":\"9999\",\"contact_person\":\"Marlene Voss\",\"contact_phone\":\"079 123 45 67\"}}"
             ),
             "parameters": {
                 "type": "object",
@@ -1268,7 +1270,8 @@ def _handle_create_master(args):
     if ignored:
         result["_warning"] = (
             f"These fields were IGNORED because they are not valid columns on the {master_type}: "
-            f"{ignored}. Retry the call using the correct field names from the create_master tool description."
+            f"{ignored}. Call get_master_fields(master_type=\"{master_type}\") to see the real columns, "
+            f"then retry mapping those values onto valid field names."
         )
     return result
 
@@ -1705,6 +1708,14 @@ Shape — note it does NOT use `items`:
 
 To build one: ensure each offer already exists as its own Quotation (create them first if needed), then call create_document with doctype "proposal" and a data object whose `quotations` array references those quotations by name. Do NOT submit it; link the user to the PDF at `/api/documents/proposal/<name>/pdf` (and the editor at `/app/proposal/<name>`).
 
+### Notes / Terms markup (the `remarks` field)
+The `remarks` (Notes / Terms) field on quotations, sales orders, and invoices renders on the PDF with a small markup vocabulary, so when a user dictates offer notes, conditions, recurring services, or a sign-off you can compose a polished closing block instead of a flat paragraph. Put this ONLY in `remarks` (never in item descriptions):
+- `# Heading` at the start of a line -> bold heading
+- `*italic*` or `_italic_` -> italic; `**bold**` -> bold
+- `>> Period | Amount` at the start of a line -> a right-aligned price line that sits beside the heading/description above it; use it for separately- or recurring-billed items, e.g. `>> Monatlich | CHF 380.—`
+- Separate blocks with a blank line; a single newline is just a line break.
+Plain text (no special characters) still renders fine, so only reach for the markup when it improves a customer-facing note.
+
 ### Purchase Cycle
 Purchase Order → Purchase Receipt (receiving) / Purchase Invoice (billing) → Payment Entry
 
@@ -1863,6 +1874,7 @@ If the user refers to something by its human name ("bill them 8 hours of project
 - Same for customers, suppliers, warehouses, etc. — `search_masters` is **case-insensitive** and falls back to **fuzzy matching for misspellings**, so a typo'd name ("Meynex") still resolves. Trust its results instead of concluding "not found" after one narrow try.
 - **Prefer narrowing with `fields`** whenever you know the attribute: search a customer by city with `fields=["city"]`, by email with `fields=["contact_email"]`, etc. It's faster and avoids false matches from unrelated columns. Omitting `fields` searches all standard text fields (a good fallback when you're unsure where the value lives), but large free-text columns (e.g. item `description`) are only searched when you name them explicitly in `fields`.
 - **Don't guess column names** — call `get_master_fields(master_type=...)` first to see the real columns (and which are searched by default), then pass the exact names to `search_masters` `fields`. This also tells you which large text fields (like `description`) you must name explicitly to search.
+- **When unsure where a value belongs, discover the schema — don't guess or give up.** Before a `create_master`/`update_master` where you're not certain a field exists or which column fits (the user gives a contact person, a VAT/tax id, a payment term, an IBAN, …), call `get_master_fields(master_type=...)` and map the value onto the real column. Never tell the user you can't store something without checking the fields first — the master usually has a column for it (e.g. a customer's contact person goes in `contact_person`/`contact_phone`/`contact_email`, not the company-level `phone`/`email`).
 
 When you list masters back to the user (items on an invoice, customers on a report), include the key in parentheses so follow-ups are unambiguous. Example: "Project Management (SVC-005) — 16 Hour".
 

{lambda_erp-0.1.25 → lambda_erp-0.1.26}/api/pdf.py

@@ -6,6 +6,7 @@ from jinja2 import Environment, FileSystemLoader, ChoiceLoader
 from weasyprint import HTML
 from lambda_erp.database import get_db
 from api.services import load_document
+from api.remarks_md import render_remarks
 
 TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates")
 
@@ -201,6 +202,11 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
         taxes=taxes,
         show_warehouse=doctype in SHOW_WAREHOUSE,
         page_size=page_size,
+        # Notes / Terms rendered from a small markup subset (headings, bold/
+        # italic, right-aligned price lines) into safe HTML; templates style the
+        # emitted classes. Falls back to plain `doc.remarks` if a template
+        # doesn't use it. See api/remarks_md.py.
+        remarks_html=render_remarks(doc.get("remarks")),
     )
 
     # Let deployment plugins augment the context (e.g. a Swiss QR-bill image for

lambda_erp-0.1.26/api/remarks_md.py

@@ -0,0 +1,91 @@
+"""Lightweight markup for the Notes / Terms (`remarks`) block on documents.
+
+`remarks` is free text the user types on a document (quotation, sales order,
+invoice, …), but on the PDF it often wants to read like a real offer: italic
+asides, bold service headings, and a right-aligned recurring-price line beside a
+description. Rather than pulling in a full Markdown dependency we support a tiny,
+predictable subset and render it to **safe** HTML. `generate_pdf()` exposes the
+result as `remarks_html`; templates render it with `| safe` and style the emitted
+class names (`.rm-block`, `.rm-h`, `.rm-p`, `.rm-amt`) however they like — so a
+branded template can restyle the same markup without changing this converter.
+
+Syntax (authored in the same textarea, also what the chat assistant emits):
+  blank line              -> separates blocks (a float stays beside its block)
+  # Heading               -> bold heading line (leading #'s stripped)
+  *italic*   _italic_     -> italic
+  **bold**                -> bold
+  >> Monatlich | CHF 380.—  -> right-aligned price box (period over amount),
+                               floated beside the block's heading/description
+Everything is HTML-escaped first, so user text can't inject markup.
+"""
+import html
+import re
+
+
+def _inline(text):
+    """Escape, then apply inline **bold** / *italic* / _italic_."""
+    out = html.escape(text)
+    out = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", out)
+    out = re.sub(r"\*(.+?)\*", r"<em>\1</em>", out)
+    out = re.sub(r"_(.+?)_", r"<em>\1</em>", out)
+    return out
+
+
+def _price(line):
+    """`>> period | amount` -> a right-floated box with period over amount."""
+    body = line.lstrip()[2:].strip()  # drop the leading '>>'
+    if "|" in body:
+        period, amount = (p.strip() for p in body.split("|", 1))
+    else:
+        period, amount = "", body
+    parts = []
+    if period:
+        parts.append(f'<div class="rm-amt-period">{_inline(period)}</div>')
+    if amount:
+        parts.append(f'<div class="rm-amt-val">{_inline(amount)}</div>')
+    return f'<div class="rm-amt">{"".join(parts)}</div>'
+
+
+def _block(lines):
+    """Render one block (lines between blank lines) to HTML.
+
+    Price line(s) are emitted first and floated right so they sit beside the
+    heading/description that follow, matching a typical offer layout.
+    """
+    price_html = ""
+    body = ""
+    para = []
+
+    def flush_para():
+        nonlocal body, para
+        if para:
+            body += '<div class="rm-p">' + "<br>".join(_inline(p) for p in para) + "</div>"
+            para = []
+
+    for raw in lines:
+        stripped = raw.lstrip()
+        if stripped.startswith(">>"):
+            flush_para()
+            price_html += _price(raw)
+        elif stripped.startswith("#"):
+            flush_para()
+            heading = stripped.lstrip("#").strip()
+            body += f'<div class="rm-h">{_inline(heading)}</div>'
+        else:
+            para.append(raw)
+    flush_para()
+    return f'<div class="rm-block">{price_html}{body}</div>'
+
+
+def render_remarks(text):
+    """Convert the remarks free text to safe styled HTML (or '' if empty)."""
+    if not text or not text.strip():
+        return ""
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    blocks = []
+    for raw_block in re.split(r"\n[ \t]*\n", text):
+        lines = raw_block.split("\n")
+        if not any(l.strip() for l in lines):
+            continue
+        blocks.append(_block(lines))
+    return "".join(blocks)

{lambda_erp-0.1.25 → lambda_erp-0.1.26}/api/templates/document.html

@@ -48,6 +48,15 @@
 
   .footer { margin-top: 30px; padding-top: 10px; border-top: 1px solid #e5e7eb; font-size: 7.5pt; color: #999; text-align: center; }
   .remarks { margin-top: 15px; padding: 8px; background: #fefce8; border-radius: 4px; font-size: 8pt; color: #713f12; }
+  /* Structured notes (remarks_html). A template can restyle these freely. */
+  .remarks .rm-block { overflow: hidden; margin-bottom: 8px; }
+  .remarks .rm-block:last-child { margin-bottom: 0; }
+  .remarks .rm-h { font-weight: 700; }
+  .remarks .rm-h + .rm-p, .remarks .rm-p + .rm-p { margin-top: 2px; }
+  .remarks .rm-amt { float: right; text-align: right; margin: 0 0 4px 16px; }
+  .remarks .rm-amt-val { white-space: nowrap; }
+  .remarks em { font-style: italic; }
+  .remarks strong { font-weight: 700; }
 </style>
 </head>
 <body>
@@ -182,8 +191,10 @@
 </div>
 
 {# ---- Remarks ---- #}
-{% if doc.remarks %}
-<div class="remarks">
+{% if remarks_html is defined and remarks_html %}
+<div class="remarks">{{ remarks_html | safe }}</div>
+{% elif doc.remarks %}
+<div class="remarks" style="white-space: pre-line;">
   <strong>Remarks:</strong> {{ doc.remarks }}
 </div>
 {% endif %}

{lambda_erp-0.1.25 → lambda_erp-0.1.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.1.25"
+version = "0.1.26"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "MIT"