lambda-erp 0.6.0__tar.gz → 0.6.2__tar.gz

{lambda_erp-0.6.0 → lambda_erp-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.6.0
+Version: 0.6.2
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0

{lambda_erp-0.6.0 → lambda_erp-0.6.2}/api/chat.py

@@ -463,7 +463,9 @@ TOOLS = [
                 "type": "object",
                 "properties": {
                     "doctype": {"type": "string", "enum": DOCUMENT_SLUGS, "description": "Document type slug"},
-                    "filters": {"type": "object", "description": "Optional filters like {\"status\": \"Draft\", \"customer\": \"CUST-001\"}", "default": {}},
+                    "filters": {"type": "object", "description": "Optional equality filters on any column, e.g. {\"status\": \"Draft\", \"customer\": \"CUST-001\", \"lead_id\": \"LEAD-3316\"}", "default": {}},
+                    "order_by": {"type": "string", "description": "Optional column to sort by (e.g. \"occurred_at\" for a timeline). Defaults to creation."},
+                    "order": {"type": "string", "enum": ["asc", "desc"], "description": "Sort direction (default desc)", "default": "desc"},
                     "limit": {"type": "integer", "description": "Max results (default 20, max 500)", "default": 20},
                 },
                 "required": ["doctype"],
@@ -1175,6 +1177,38 @@ def _extra_master_types():
     return sorted(m for m in services.MASTER_TABLES if m not in MASTER_TYPES)
 
 
+def _chat_doctype_section() -> str:
+    """A '## Custom record types' block for doctypes registered via
+    register_chat_doctype: each type's description, key fields, and its
+    LINK_FIELDS relationships (read live from the Document class). Tells the
+    model these are driven with the DOCUMENT tools and how they attach to a
+    parent (e.g. a contact links to a lead via `lead_id`). Empty when none."""
+    slugs = [s for s in services.CHAT_DOCTYPES if s in services.SLUG_TO_DOCTYPE]
+    if not slugs:
+        return ""
+    lines = []
+    for slug in slugs:
+        meta = services.CHAT_DOCTYPES[slug]
+        doctype = services.SLUG_TO_DOCTYPE[slug]
+        cls = services.DOCUMENT_CLASSES.get(doctype)
+        links = getattr(cls, "LINK_FIELDS", None) or {}
+        line = f"- **{doctype}** (slug `{slug}`): {meta['description']}"
+        if meta.get("fields"):
+            line += f" Key fields: {', '.join('`' + f + '`' for f in meta['fields'])}."
+        if links:
+            link_str = ", ".join(f"`{f}` → the {t}'s name" for f, t in links.items())
+            line += f" Links: {link_str}."
+        lines.append(line)
+    return (
+        "\n\n## Custom record types (deployment-specific)\n"
+        "Manage these with the DOCUMENT tools (`create_document`, `update_document`, "
+        "`list_documents`, `get_document`) — NOT the master tools — so their `validate()` "
+        "runs. To attach one to a parent, set its link field to the parent record's `name` "
+        "(find the parent first, e.g. with `search_masters` or `list_documents`). Do not put "
+        "child data on the parent's own fields.\n" + "\n".join(lines)
+    )
+
+
 def build_tools():
     """TOOLS with the doctype/master enums widened from the live registries.
 
@@ -1217,6 +1251,8 @@ def _handle_list_documents(args):
         args["doctype"],
         filters=args.get("filters"),
         limit=args.get("limit", 20),
+        order_by=args.get("order_by"),
+        order=args.get("order", "desc"),
     )
     for row in rows:
         for key in child_keys:
@@ -1898,6 +1934,7 @@ def build_system_prompt(user_info: dict | None = None, channel: str = "web"):
         f"display = `{services.MASTER_TABLES[m][1]}`"
         for m in extra_masters
     )
+    chat_doctype_section = _chat_doctype_section()
 
     # 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
@@ -2006,7 +2043,7 @@ When a user asks you to do something they don't have permission for, explain wha
 - **Buying:** purchase-order, purchase-invoice
 - **Accounting:** payment-entry, journal-entry, budget, subscription, bank-transaction
 - **Stock:** stock-entry, delivery-note, purchase-receipt
-- **Settings:** pricing-rule{extension_doctypes_line}
+- **Settings:** pricing-rule{extension_doctypes_line}{chat_doctype_section}
 
 ## Document Workflow & What Each Document Does
 

{lambda_erp-0.6.0 → lambda_erp-0.6.2}/api/services.py

@@ -216,6 +216,23 @@ def register_master(slug: str, table: str, name_field: str, *,
         MASTER_IDENTITY_ALIAS[slug] = identity_alias
 
 
+# Chat guidance for registered doctypes: slug -> {"description", "fields"}. The
+# document tools (create/update/list/get_document) already accept any registered
+# doctype and run its validate(); this registry only teaches the AI chat WHAT a
+# custom doctype is and HOW it links, so it uses the validated document path
+# instead of, say, scribbling on a parent's fields. Relationships are read
+# automatically from the Document class's LINK_FIELDS — not declared here.
+CHAT_DOCTYPES: dict = {}
+
+
+def register_chat_doctype(slug: str, *, description: str, fields: list | None = None) -> None:
+    """Give the AI chat a description (and optional key-field hints) for a doctype
+    already registered via `register_doctype`, so build_system_prompt can tell the
+    model what it is and how it links (LINK_FIELDS are surfaced automatically).
+    No new tools — the document tools already cover every registered doctype."""
+    CHAT_DOCTYPES[slug] = {"description": description, "fields": fields or []}
+
+
 def get_document_class(doctype_slug: str):
     """Get document class from URL slug."""
     doctype = SLUG_TO_DOCTYPE.get(doctype_slug)

{lambda_erp-0.6.0 → lambda_erp-0.6.2}/lambda_erp/database.py

@@ -1391,13 +1391,80 @@ class Database:
             self._col_cache.pop(table, None)
             self._text_col_cache.pop(table, None)
 
+    def _alter_table_lock_safe(self, statements, cache_tables, *,
+                               lock_timeout_ms=3000, retries=8, backoff=0.5):
+        """Run ALTER TABLE DDL with a bounded lock wait + retry on Postgres.
+
+        A schema change (ADD/DROP COLUMN) needs an ACCESS EXCLUSIVE lock; during
+        a rolling deploy the OLD app revision is still live and querying the
+        table, so an unbounded ALTER blocks *indefinitely* — and because these
+        migrations run in the app lifespan before it serves, a blocked ALTER
+        fails the container's startup probe and crash-loops the revision (this
+        actually happened in production). Bounding `lock_timeout` turns "hang
+        forever" into "fail fast", and retrying catches a gap between the old
+        revision's queries. If every attempt times out it raises, so the caller
+        (e.g. the plugin migration runner) can retry on the next boot rather
+        than hang. SQLite has no concurrent revision, so it runs directly."""
+        if self.dialect != "postgres":
+            for s in statements:
+                self.conn.execute(self._ddl(s))
+            self.conn.commit()
+            for t in cache_tables:
+                self._col_cache.pop(t, None)
+                self._text_col_cache.pop(t, None)
+            return
+
+        import time as _time
+        last = None
+        try:
+            for _ in range(retries):
+                try:
+                    self.conn.execute(f"SET lock_timeout = '{int(lock_timeout_ms)}ms'")
+                    for s in statements:
+                        self.conn.execute(self._ddl(s))
+                    self.conn.commit()
+                    for t in cache_tables:
+                        self._col_cache.pop(t, None)
+                        self._text_col_cache.pop(t, None)
+                    return
+                except Exception as e:
+                    last = e
+                    self.conn.rollback()
+                    _time.sleep(backoff)
+            raise RuntimeError(
+                f"lock-contended DDL failed after {retries} attempts: {statements!r}: {last!r}"
+            )
+        finally:
+            # lock_timeout is a session setting; restore the default so it
+            # doesn't leak onto later queries on this (pooled) connection.
+            try:
+                self.conn.execute("RESET lock_timeout")
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+
     def ensure_column(self, table: str, column: str, definition: str) -> None:
-        """Idempotently add a column if it's missing. Public helper for plugin
-        migrations registered via api.services.register_migration — the same
-        backend-portable, PRAGMA/information_schema-guarded add the core's own
-        migrations use. `definition` is the SQLite-flavoured column type (e.g.
-        "TEXT", "INTEGER DEFAULT 0"); it is translated per dialect via _ddl."""
-        self._add_column_if_missing(table, column, definition)
+        """Idempotently add a column if it's missing, LOCK-SAFELY. Public helper
+        for plugin migrations registered via api.services.register_migration.
+
+        On Postgres the ADD COLUMN is bounded by `lock_timeout` + retry so a
+        migration can't hang the boot against a live old revision during a
+        rolling deploy (see _alter_table_lock_safe). SQLite adds directly. The
+        `definition` is the SQLite-flavoured column type (e.g. "TEXT",
+        "INTEGER DEFAULT 0"); it is translated per dialect via _ddl."""
+        if column in self._get_table_columns(table):
+            return
+        self._alter_table_lock_safe(
+            [f'ALTER TABLE "{table}" ADD COLUMN {column} {definition}'], [table])
+
+    def drop_column(self, table: str, column: str) -> None:
+        """Idempotently drop a column if present, LOCK-SAFELY (same rolling-deploy
+        protection as ensure_column). No-op if the column is already gone.
+        Requires SQLite >= 3.35 for the SQLite backend (DROP COLUMN support)."""
+        if column not in self._get_table_columns(table):
+            return
+        self._alter_table_lock_safe(
+            [f'ALTER TABLE "{table}" DROP COLUMN "{column}"'], [table])
 
     def _migrate(self):
         """Run each pending migration in order, tracking applied versions."""

{lambda_erp-0.6.0 → lambda_erp-0.6.2}/pyproject.toml

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