lambda-erp 0.1.44__tar.gz → 0.1.46__tar.gz

{lambda_erp-0.1.44 → lambda_erp-0.1.46}/PKG-INFO

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

{lambda_erp-0.1.44 → lambda_erp-0.1.46}/api/chat.py

@@ -34,7 +34,7 @@ from api.demo_limits import (
     limiter as demo_limiter,
 )
 from api.providers import cost_of_anthropic_call, cost_of_openai_call, cost_of_transcription
-from api.routers.masters import create_master_record, update_master_record, MASTER_IDENTITY_ALIAS
+from api.routers.masters import create_master_record, update_master_record, delete_master_record, MASTER_IDENTITY_ALIAS
 from lambda_erp.database import get_db
 from lambda_erp.utils import flt, now, nowdate
 
@@ -661,6 +661,29 @@ TOOLS = [
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "delete_master",
+            "description": (
+                "Delete a master record (customer, supplier, item, ...). ADMIN role only. "
+                "Reference-protected and safe by design: an UNREFERENCED record is permanently deleted; "
+                "a record referenced anywhere (documents, GL, stock, ...) is NOT deleted — it is automatically "
+                "disabled/archived instead and the result names the blocking reference (status='disabled'). "
+                "Use when the user explicitly asks to delete/remove a master record (e.g. a mistakenly created "
+                "or duplicate one). If they merely want it out of the way, prefer update_master with "
+                "{\"disabled\": 1}. Example: {\"master_type\":\"customer\",\"name\":\"CUST-007\"}"
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "master_type": {"type": "string", "enum": MASTER_TYPES},
+                    "name": {"type": "string", "description": "Existing master record ID/name to delete."},
+                },
+                "required": ["master_type", "name"],
+            },
+        },
+    },
     {
         "type": "function",
         "function": {
@@ -1304,6 +1327,31 @@ def _handle_update_master(args):
     return result
 
 
+def _handle_delete_master(args, user_info=None):
+    """Reference-protected master deletion, gated to the admin role.
+
+    Registered per-run (run_thinking_loop scopes it with the caller's
+    user_info) — NOT in the base TOOL_HANDLERS dict, whose handlers are
+    called with (args) only.
+    """
+    role = (user_info or {}).get("role")
+    if role != "admin":
+        return {
+            "error": (
+                "Deleting master records requires the admin role. Ask an ERP admin to do it, "
+                "or disable the record instead: update_master with {\"disabled\": 1}."
+            )
+        }
+    name = args.get("name")
+    if not name:
+        return {"error": "You must pass the existing master record 'name' to delete. Example: {\"master_type\":\"customer\",\"name\":\"CUST-007\"}"}
+    try:
+        return dict(delete_master_record(args["master_type"], name))
+    except Exception as exc:
+        detail = getattr(exc, "detail", None)
+        return {"error": detail or str(exc)}
+
+
 def _handle_get_current_time(args):
     from datetime import datetime, timezone
     now = datetime.now(timezone.utc)
@@ -1855,7 +1903,7 @@ For purchased goods, prefer Purchase Receipt when receiving separately from bill
 - **Draft (docstatus=0):** Document is editable. Has NO financial impact — no GL entries, no stock movement. Can be updated freely.
 - **Submitted (docstatus=1):** Document is locked. GL entries and stock ledger entries are posted. Cannot be edited — only cancelled.
 - **Cancelled (docstatus=2):** GL and stock entries are reversed. Document is permanently archived. Cannot be reused or edited.
-- **There is NO delete operation.** Documents are permanent records. This is by design for audit integrity.
+- **DOCUMENTS have NO delete operation.** Documents are permanent records — by design for audit integrity. This rule applies to DOCUMENTS ONLY; never claim master records can't be deleted "for audit integrity" (see Master Data Deletion below).
 - **To void a draft you no longer need:** submit it first (docstatus 0→1), then cancel it (docstatus 1→2). Do NOT tell the user to "delete" anything.
 - **To correct a submitted document:** cancel it and create a new one with the correct values.
 - Only submitted documents can be converted (e.g. Sales Order → Sales Invoice). Draft or cancelled documents cannot.
@@ -1864,6 +1912,9 @@ For purchased goods, prefer Purchase Receipt when receiving separately from bill
 ## Master Data Types
 customer, supplier, item, warehouse, account, company, cost-center
 
+## Master Data Deletion
+Master records CAN be deleted — use the `delete_master` tool (ADMIN role only). It is reference-protected: an unreferenced record (e.g. a mistakenly created or duplicate one) is permanently deleted; a record referenced by any document, GL entry, or stock data is NOT deleted but automatically disabled/archived instead, and the result names the blocking reference — relay that reason to the user. When the user merely wants a record out of the way (not destroyed), prefer `update_master` with `{"disabled": 1}`. Non-admin users: explain that deletion needs an admin and offer to disable instead.
+
 ## Warehouse Master Rules
 - To create a warehouse via `create_master`, you MUST pass a `data` object.
 - `warehouse_name` is required.
@@ -2325,6 +2376,9 @@ async def run_thinking_loop(
     )
 
     tool_handlers = dict(TOOL_HANDLERS)
+    # delete_master needs the caller's role (admin-only) — scoped here rather
+    # than in TOOL_HANDLERS, whose handlers are called with (args) only.
+    tool_handlers["delete_master"] = lambda args: _handle_delete_master(args, user_info)
 
     user_role = user_info.get("role") if user_info else None
     demo_mode = is_demo_role(user_role)
@@ -2333,9 +2387,10 @@ async def run_thinking_loop(
     max_completion = demo_max_completion_tokens() if demo_mode else 4096
 
     if demo_mode:
-        denied = lambda _args: {"error": "Demo mode cannot create or update master data."}
+        denied = lambda _args: {"error": "Demo mode cannot create, update, or delete master data."}
         tool_handlers["create_master"] = denied
         tool_handlers["update_master"] = denied
+        tool_handlers["delete_master"] = denied
 
     # Scope session-aware tools without mutating globals.
     if session_id:

{lambda_erp-0.1.44 → lambda_erp-0.1.46}/api/routers/masters.py

@@ -353,11 +353,19 @@ def update_master(master_type: str, name: str, data: dict, _user: dict = _manage
     return update_master_record(master_type, name, data)
 
 
-@router.delete("/{master_type}/{name}")
-def delete_master(master_type: str, name: str, _user: dict = _admin):
+def delete_master_record(master_type: str, name: str) -> dict:
+    """Delete a master record with reference protection — the ONLY sanctioned
+    delete path (the tables have no FK constraints, so every caller — the REST
+    route below AND the chat agent's delete_master tool — must go through here).
+
+    Unreferenced record → hard delete. Referenced record → auto-disabled instead
+    (when the doctype has a `disabled` column) with the blocking reference named,
+    else a 409. Raising HTTPException keeps route behavior; the chat handler
+    catches it and surfaces `detail` as the tool error.
+    """
     doctype, _ = _get_table(master_type)
     if not doctype:
-        return {"detail": f"Unknown master type: {master_type}"}
+        raise HTTPException(status_code=422, detail=f"Unknown master type: {master_type}")
     db = get_db()
     if not db.exists(doctype, name):
         raise HTTPException(status_code=404, detail=f"{doctype} {name} not found")
@@ -374,6 +382,11 @@ def delete_master(master_type: str, name: str, _user: dict = _admin):
     return {"ok": True, "status": "deleted"}
 
 
+@router.delete("/{master_type}/{name}")
+def delete_master(master_type: str, name: str, _user: dict = _admin):
+    return delete_master_record(master_type, name)
+
+
 @router.get("/account/tree")
 def account_tree(company: str | None = None, _user: dict = _viewer):
     """Return Chart of Accounts as a nested tree."""

{lambda_erp-0.1.44 → lambda_erp-0.1.46}/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.44 → lambda_erp-0.1.46}/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.44 → lambda_erp-0.1.46}/pyproject.toml

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