lambda-erp 0.1.43__tar.gz → 0.1.45__tar.gz

{lambda_erp-0.1.43 → lambda_erp-0.1.45}/PKG-INFO

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

{lambda_erp-0.1.43 → lambda_erp-0.1.45}/api/chat.py

@@ -622,7 +622,7 @@ TOOLS = [
                 "Every record's id is `name`. Customer/Supplier/Item/Warehouse auto-generate it (CUST-/SUPP-/ITEM-/WH-NNN) when omitted; Company/Account/Cost Center have NO auto-id, so `name` is required for them.\n\n"
                 "**Customer fields:** name (optional custom id; auto CUST-NNN), customer_name (required), customer_group, territory, default_currency, credit_limit, email, phone, address, city, zip_code, country, tax_id, contact_person (named contact at the customer), contact_email, contact_phone.\n"
                 "**Supplier fields:** name (optional custom id; auto SUPP-NNN), supplier_name (required), supplier_group, default_currency, email, phone, address, city, zip_code, country, tax_id.\n"
-                "**Item fields:** item_code (the unique item code/id, e.g. \"SVC-SPARK\" — optional, may use ANY prefix, not just ITEM; auto-generated as ITEM-NNN if omitted), item_name (required, the human-readable name), item_group, stock_uom, standard_rate, is_stock_item, default_warehouse, description.\n"
+                "**Item fields:** item_code (the unique item code/id, e.g. \"SVC-SPARK\" — optional, may use ANY prefix, not just ITEM; auto-generated as ITEM-NNN if omitted), item_name (required, the human-readable name), item_group, stock_uom (prefer one of the units listed under 'Item Units' in the system context — exact spelling; a new unit is allowed when none fits), standard_rate, is_stock_item, default_warehouse, description.\n"
                 "**Warehouse fields:** name (optional custom id; auto WH-NNN), warehouse_name (required), company, parent_warehouse (omit or null when not needed), address, city, zip_code, country.\n"
                 "**Company fields:** name (the company id — optional, defaults to company_name), company_name (required), default_currency, email, phone, address, city, zip_code, country, tax_id.\n"
                 "**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"
@@ -1623,11 +1623,37 @@ def _prompt_analytics_context() -> str:
     )
 
 
+def _prompt_uom_context() -> str:
+    """Dynamic list of the item units (stock_uom) currently in use.
+
+    The unit list is NOT a fixed vocabulary — users add new units simply by
+    using them — so the guidance is rebuilt from the Item table on every turn
+    rather than hardcoded. Nudging the agent toward existing spellings keeps
+    items consistent (and matching the GUI's dropdown), while still allowing a
+    genuinely new unit when none fits.
+    """
+    try:
+        rows = get_db().get_all("Item", fields=["stock_uom"], limit=1000)
+    except Exception:
+        return ""
+    uoms = sorted({(row.get("stock_uom") or "").strip() for row in rows} - {""})
+    if not uoms:
+        return ""
+    return (
+        "## Item Units (stock_uom)\n"
+        f"Units currently in use in this ERP: {', '.join(uoms)}.\n"
+        "When creating or editing items, PREFER one of these exact spellings so "
+        "items stay consistent. A new unit is allowed when none of them fits — "
+        "use a short singular noun (e.g. \"Stück\", \"Bottle\", \"Hour\").\n"
+    )
+
+
 def build_system_prompt(user_info: dict | None = None, channel: str = "web"):
     user_name = user_info.get("full_name", "User") if user_info else "User"
     user_role = user_info.get("role", "viewer") if user_info else "viewer"
     company_context = _prompt_company_context()
     analytics_context = _prompt_analytics_context()
+    uom_context = _prompt_uom_context()
 
     # Channel-aware link guidance. On the "web" channel the reader is a browser
     # inside the ERP, so web-relative links are clickable. On the "api" channel the
@@ -1697,7 +1723,7 @@ You are speaking with **{user_name}** (role: **{user_role}**).
 
 {company_context}
 {analytics_context}
-
+{uom_context}
 ## User Roles
 Lambda ERP has four roles:
 - **admin**: Full access to everything — documents, masters, reports, company setup, and user management (inviting team members, changing roles).

{lambda_erp-0.1.43 → lambda_erp-0.1.45}/api/routers/reports.py

@@ -121,6 +121,112 @@ def trial_balance(
                     company, presentation_currency, to_date)
 
 
+def _chart_of_accounts(db, company=None, from_date=None, to_date=None):
+    """Chart of accounts (every account, incl. groups and zero-balance ones)
+    with period balances — the tree the GUI renders.
+
+    Balance semantics follow standard presentation:
+      - Balance Sheet accounts: CLOSING balance as of ``to_date`` (all postings
+        up to and including it; ``from_date`` is ignored for them).
+      - P&L accounts: movement WITHIN [from_date, to_date].
+    Values are natural-signed per root_type (Asset/Expense: debit − credit;
+    Liability/Equity/Income: credit − debit) so revenue reads positive.
+    Group accounts roll up every descendant's balance (plus any postings of
+    their own, though entries normally land on leaves).
+    """
+    acc_filters = {}
+    if company:
+        acc_filters["company"] = company
+    accounts = db.get_all(
+        "Account", filters=acc_filters,
+        fields=["name", "account_name", "parent_account", "root_type",
+                "report_type", "account_type", "is_group", "disabled"],
+        order_by="name",
+    )
+
+    def _movement(where_extra, params_extra):
+        clause = "is_cancelled = 0" + where_extra
+        params = list(params_extra)
+        if company:
+            clause += " AND company = ?"
+            params.append(company)
+        found = db.sql(
+            f"""SELECT account,
+                       COALESCE(SUM(debit), 0) AS d,
+                       COALESCE(SUM(credit), 0) AS c
+                FROM "GL Entry" WHERE {clause} GROUP BY account""",
+            params,
+        )
+        return {r["account"]: (flt(r["d"], 2), flt(r["c"], 2)) for r in found}
+
+    bs_where, bs_params = "", []
+    if to_date:
+        bs_where, bs_params = " AND posting_date <= ?", [to_date]
+    bs_map = _movement(bs_where, bs_params)
+
+    if from_date or to_date:
+        pl_where, pl_params = "", []
+        if from_date:
+            pl_where += " AND posting_date >= ?"
+            pl_params.append(from_date)
+        if to_date:
+            pl_where += " AND posting_date <= ?"
+            pl_params.append(to_date)
+        pl_map = _movement(pl_where, pl_params)
+    else:
+        pl_map = bs_map
+
+    rows = []
+    by_name = {}
+    for acc in accounts:
+        is_pl = acc.get("report_type") == "Profit and Loss"
+        d, c = (pl_map if is_pl else bs_map).get(acc["name"], (0.0, 0.0))
+        if acc.get("root_type") in ("Liability", "Equity", "Income"):
+            natural = c - d
+        else:
+            natural = d - c
+        row = {
+            "name": acc["name"],
+            "account_name": acc.get("account_name"),
+            "parent_account": acc.get("parent_account") or None,
+            "root_type": acc.get("root_type"),
+            "account_type": acc.get("account_type"),
+            "is_group": bool(acc.get("is_group")),
+            "disabled": bool(acc.get("disabled")),
+            "balance": flt(natural, 2),
+            "has_entries": bool(d or c),
+        }
+        rows.append(row)
+        by_name[row["name"]] = row
+
+    # Roll every account's own balance up its ancestor chain so group rows
+    # show subtree totals.
+    subtree_extra = {r["name"]: 0.0 for r in rows}
+    for row in rows:
+        parent = row["parent_account"]
+        while parent and parent in by_name:
+            subtree_extra[parent] += row["balance"]
+            parent = by_name[parent]["parent_account"]
+    for row in rows:
+        if row["is_group"]:
+            row["balance"] = flt(row["balance"] + subtree_extra[row["name"]], 2)
+            row["has_entries"] = row["has_entries"] or bool(subtree_extra[row["name"]])
+
+    return {"accounts": rows, "from_date": from_date, "to_date": to_date}
+
+
+@router.get("/chart-of-accounts")
+def chart_of_accounts(
+    company: str | None = None,
+    from_date: str | None = None,
+    to_date: str | None = None,
+    presentation_currency: str | None = None,
+):
+    db = get_db()
+    return _present(db, _chart_of_accounts(db, company, from_date, to_date),
+                    company, presentation_currency, to_date)
+
+
 def _general_ledger(db, filters=None):
     filters = filters or {}
     where = ["is_cancelled = 0"]

{lambda_erp-0.1.43 → lambda_erp-0.1.45}/frontend/src/api/client.ts

@@ -226,6 +226,11 @@ export const api = {
       `/reports/trial-balance${qs(params)}`,
     ),
 
+  chartOfAccounts: (params?: Record<string, string>) =>
+    request<{ accounts: any[]; from_date: string | null; to_date: string | null }>(
+      `/reports/chart-of-accounts${qs(params)}`,
+    ),
+
   generalLedger: (params?: Record<string, string>) =>
     request<{
       rows: any[];

{lambda_erp-0.1.43 → lambda_erp-0.1.45}/pyproject.toml

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