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

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

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

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

@@ -10,6 +10,7 @@ Supports multiple chat sessions, each with their own history and auto-generated
 
 import asyncio
 import base64
+import difflib
 import io
 import json
 import logging
@@ -582,12 +583,31 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "search_masters",
-            "description": "Search master data (customers, suppliers, items, warehouses, accounts, companies, cost centers). Returns matching records.",
+            "description": "Search master data (customers, suppliers, items, warehouses, accounts, companies, cost centers). Case-insensitive, with fuzzy fallback for misspellings. By default matches across standard text fields (name, display name, address/city/zip); large free-text columns like description/templates are skipped unless named in `fields`. PREFER passing `fields` whenever you know which attribute you're matching on (e.g. a city, an email, a tax id) — it's faster, more precise, and avoids false hits from other columns. Returns matching records.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "master_type": {"type": "string", "enum": MASTER_TYPES},
                     "query": {"type": "string", "description": "Search term (empty string returns all)", "default": ""},
+                    "fields": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Recommended: the column(s) to search, e.g. [\"city\"] or [\"customer_name\"]. Narrowing here is faster and avoids matching unrelated columns. Omit only when you genuinely don't know which field holds the value, to search all standard text fields.",
+                    },
+                },
+                "required": ["master_type"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_master_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": {
+                    "master_type": {"type": "string", "enum": MASTER_TYPES},
                 },
                 "required": ["master_type"],
             },
@@ -608,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",
@@ -1077,26 +1099,139 @@ def _handle_convert_document(args):
     return services.convert_document(args["doctype"], args["name"], args["target_doctype"])
 
 
+# Columns that are technically text but are noise for free-text master search.
+_MASTER_SEARCH_SKIP_COLUMNS = {
+    "naming_series",
+    "owner",
+    "modified_by",
+    "creation",
+    "modified",
+    "created_at",
+    "updated_at",
+}
+
+# Large free-text columns excluded from the DEFAULT search: scanning/fuzzing a
+# big blob (e.g. an item description or an HTML template) is costly and rarely
+# how you identify a record. Still searchable on demand via the `fields` arg.
+_MASTER_BULK_TEXT_COLUMNS = {"description", "notes", "remarks", "terms", "comments"}
+
+# Minimum difflib similarity for a fuzzy (misspelled) match to be returned.
+_MASTER_FUZZY_THRESHOLD = 0.6
+# Bounds for the fuzzy scorer so a single large value can't blow up cost:
+# skip whole-value scoring past this length, and only score the first N tokens.
+_FUZZY_MAX_VALUE_LEN = 200
+_FUZZY_MAX_TOKENS = 16
+
+
+def _is_bulk_text_column(col):
+    return (col in _MASTER_BULK_TEXT_COLUMNS
+            or col.endswith("_template") or col.endswith("_html"))
+
+
+def _master_search_columns(db, doctype):
+    """Text columns worth matching a query against by default. Discovered from
+    the live schema (new text fields become searchable automatically), minus
+    audit noise and large free-text/template columns."""
+    cols = db._get_text_columns(doctype) - _MASTER_SEARCH_SKIP_COLUMNS
+    # Deterministic order keeps generated SQL and fuzzy scoring stable.
+    return sorted(c for c in cols if not _is_bulk_text_column(c))
+
+
+def _fuzzy_master_search(db, doctype, search_cols, query, has_disabled, limit):
+    """Fallback for misspellings: rank active rows by best per-field similarity.
+
+    Substring search misses typos ("Meynex" vs "medynex"), so when it finds
+    nothing we pull a capped candidate set and score it in Python with difflib —
+    portable across SQLite and Postgres, no DB extensions required."""
+    where = "WHERE disabled = 0 " if has_disabled else ""
+    candidates = db.sql(f'SELECT * FROM "{doctype}" {where}LIMIT 1000')
+
+    q = query.lower()
+    scored = []
+    for row in candidates:
+        best = 0.0
+        for col in search_cols:
+            val = row.get(col)
+            if not val:
+                continue
+            val = str(val).lower()
+            # Skip whole-value scoring of big blobs (low ratio anyway, high cost).
+            if len(val) <= _FUZZY_MAX_VALUE_LEN:
+                best = max(best, difflib.SequenceMatcher(None, q, val).ratio())
+            # Also score the first few words so a typo'd single token still
+            # matches a multi-word field (e.g. "medynex" within "medynex ag").
+            for token in val.split()[:_FUZZY_MAX_TOKENS]:
+                best = max(best, difflib.SequenceMatcher(None, q, token).ratio())
+        if best >= _MASTER_FUZZY_THRESHOLD:
+            scored.append((best, row))
+
+    scored.sort(key=lambda pair: pair[0], reverse=True)
+    return [dict(row) for _, row in scored[:limit]]
+
+
+def _handle_get_master_fields(args):
+    db = get_db()
+    master_type = args["master_type"]
+    entry = services.MASTER_TABLES.get(master_type)
+    if not entry:
+        return {"error": f"Unknown master type: {master_type}"}
+    doctype, _ = entry
+    default_search = _master_search_columns(db, doctype)
+    bulk = sorted(c for c in db._get_text_columns(doctype) if _is_bulk_text_column(c))
+    return {
+        "master_type": master_type,
+        "fields": sorted(db._get_table_columns(doctype)),
+        # What search_masters searches when `fields` is omitted.
+        "default_search_fields": default_search,
+        # Large text fields searched ONLY when named in search_masters `fields`.
+        "bulk_text_fields": bulk,
+    }
+
+
 def _handle_search_masters(args):
     db = get_db()
     master_type = args["master_type"]
-    query = args.get("query", "")
+    query = (args.get("query") or "").strip()
 
     entry = services.MASTER_TABLES.get(master_type)
     if not entry:
         return {"error": f"Unknown master type: {master_type}"}
 
-    doctype, name_field = entry
-    active_prefix = 'disabled = 0 AND ' if "disabled" in db._get_table_columns(doctype) else ""
+    doctype, _name_field = entry
+    has_disabled = "disabled" in db._get_table_columns(doctype)
+
     if not query:
-        filters = {"disabled": 0} if "disabled" in db._get_table_columns(doctype) else None
+        filters = {"disabled": 0} if has_disabled else None
         return db.get_all(doctype, filters=filters, fields=["*"], limit=20)
 
+    # Optional `fields` narrows the search to specific columns — cheaper, more
+    # precise, and the only way to reach bulk columns (description, templates)
+    # that the default search skips. Unknown names are ignored.
+    requested = args.get("fields") or []
+    if requested:
+        valid = db._get_table_columns(doctype)
+        search_cols = sorted(c for c in requested if c in valid)
+        if not search_cols:
+            return {"error": f"None of fields {requested} exist on {master_type}"}
+    else:
+        search_cols = _master_search_columns(db, doctype)
+
+    active_prefix = "disabled = 0 AND " if has_disabled else ""
+
+    # Case-insensitive substring match. lower() on both sides is portable (bare
+    # LIKE is case-insensitive on SQLite but case-sensitive on Postgres, which
+    # silently broke prod search); CAST lets targeted non-text columns match too.
+    where = " OR ".join(f'lower(CAST("{col}" AS TEXT)) LIKE ?' for col in search_cols)
+    pattern = f"%{query.lower()}%"
     rows = db.sql(
-        f'SELECT * FROM "{doctype}" WHERE {active_prefix}(name LIKE ? OR "{name_field}" LIKE ?) LIMIT 20',
-        [f"%{query}%", f"%{query}%"],
+        f'SELECT * FROM "{doctype}" WHERE {active_prefix}({where}) LIMIT 20',
+        [pattern] * len(search_cols),
     )
-    return [dict(r) for r in rows]
+    if rows:
+        return [dict(r) for r in rows]
+
+    # Nothing matched literally — try fuzzy matching to catch misspellings.
+    return _fuzzy_master_search(db, doctype, search_cols, query, has_disabled, limit=20)
 
 
 def _ignored_master_fields(master_type: str, data: dict) -> list[str]:
@@ -1135,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
 
@@ -1408,6 +1544,7 @@ TOOL_HANDLERS = {
     "cancel_document": _handle_cancel_document,
     "discard_document": _handle_discard_document,
     "convert_document": _handle_convert_document,
+    "get_master_fields": _handle_get_master_fields,
     "search_masters": _handle_search_masters,
     "create_master": _handle_create_master,
     "update_master": _handle_update_master,
@@ -1571,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
 
@@ -1726,7 +1871,10 @@ When you fill in `item_code`, `customer`, `supplier`, `warehouse`, `company`, et
 
 If the user refers to something by its human name ("bill them 8 hours of project mgmt", "add Redstone to the quote"), resolve the key first:
 - `search_masters(master_type="item", q="project management")` → returns `[{{name: "SVC-005", item_name: "Project Management"}}]`. Use `name` as `item_code`.
-- Same for customers, suppliers, warehouses, etc. — `search_masters` matches **both** the key and the display field.
+- 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.24 → 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.24 → 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.24 → lambda_erp-0.1.26}/lambda_erp/database.py

@@ -179,6 +179,7 @@ class Database:
         self._is_memory = (db_path == ":memory:")
         self._local = threading.local()
         self._col_cache = {}  # doctype -> set(columns); invalidated on ALTER
+        self._text_col_cache = {}  # doctype -> set(text columns); invalidated on ALTER
         if self._is_memory:
             self._lock = threading.Lock()
             self._shared_conn = self._open_conn()
@@ -1347,6 +1348,7 @@ class Database:
         if column not in self._get_table_columns(table):
             self.conn.execute(self._ddl(f'ALTER TABLE "{table}" ADD COLUMN {column} {definition}'))
             self._col_cache.pop(table, None)
+            self._text_col_cache.pop(table, None)
 
     def _migrate(self):
         """Run each pending migration in order, tracking applied versions."""
@@ -1517,6 +1519,34 @@ class Database:
         self._col_cache[doctype] = cols
         return cols
 
+    def _get_text_columns(self, doctype):
+        """Text/character columns of a table — the ones worth matching a
+        free-text search against. Discovered from the live schema so new
+        columns become searchable automatically. Cached; invalidated on ALTER."""
+        cached = self._text_col_cache.get(doctype)
+        if cached is not None:
+            return cached
+        if self.dialect == "postgres":
+            rows = self.conn.execute(
+                "SELECT column_name, data_type FROM information_schema.columns "
+                "WHERE table_name = ?",
+                [doctype],
+            ).fetchall()
+            cols = {
+                row[0]
+                for row in rows
+                if "char" in (row[1] or "").lower() or (row[1] or "").lower() in ("text", "citext")
+            }
+        else:
+            cursor = self.conn.execute(f'PRAGMA table_info("{doctype}")')
+            cols = {
+                row[1]
+                for row in cursor.fetchall()
+                if any(t in (row[2] or "").upper() for t in ("CHAR", "CLOB", "TEXT"))
+            }
+        self._text_col_cache[doctype] = cols
+        return cols
+
     def _select_fields(self, doctype, fields):
         """Build the SELECT column list, selecting only columns that exist and
         padding the rest as NULL. SQLite silently returns an unknown quoted

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

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