lambda-erp 0.1.48__tar.gz → 0.2.0__tar.gz

{lambda_erp-0.1.48 → lambda_erp-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.1.48
+Version: 0.2.0
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: MIT
@@ -135,8 +135,22 @@ Each of those is hours of skilled work today. With a capable LLM in the loop, th
 
 ---
 
+## Set up your books by describing your business
+
+Standing up a new company usually means an accountant hand-building a chart of accounts. In Lambda ERP you do it in the chat: tell the assistant what kind of business you run and which country you're in, and it proposes the exact accounts — explaining the structure and the judgment calls, and creating nothing until you approve. It's the "chart-of-accounts design and mapping" work from above, done in seconds and reviewed by you.
+
+Two dimensions shape the chart, and they compose:
+
+- **Localization packs** bring a country's real chart and tax setup. Today: a **generic / international** chart (also the permanent fallback for anywhere not yet localized) and **Switzerland** — the *Kontenrahmen KMU*, in German, in CHF, with MWST tax templates at the current rates. Each country is a self-contained pack, so more can land without disturbing the ones already there — that's the roadmap, one jurisdiction at a time.
+- **Sector profiles** tailor the chart to how you operate — **services, retail / POS, hospitality, wholesale / distribution, import / export, manufacturing, construction** — adding the accounts that model actually needs (work-in-progress and retention for construction, food-vs-beverage cost lines for hospitality, landed-cost accounts for import/export, and so on). Profiles are country-independent: the same seven apply on top of every localization.
+
+The result is booked in one step — chart of accounts, sensible default accounts, tax templates, and a cost center — ready for opening balances. New here? The in-app **Tutorial** has a one-click **Get started** that opens the wizard in chat.
+
+---
+
 ## What works today
 
+- **Guided company setup through chat** — pick a country (generic or Switzerland, more coming) and business type, preview the exact chart of accounts, confirm, and it's booked
 - Full sales and purchase cycles (Quotation → Sales Order → Delivery Note → Sales Invoice → Payment Entry, and the buying equivalents)
 - Returns / credit notes / debit notes with proper GL and stock reversal
 - Moving-average stock ledger with negative-stock protection
@@ -176,7 +190,7 @@ Four things had to be true for this to work, and they all became true in the las
 
 Every company configuring an ERP runs into the same problems: local tax rules, common workflow patterns, industry-specific accounting quirks. Most of that knowledge isn't a competitive advantage — it's the same ground being re-covered separately at every implementation, by every team, in slightly different ways.
 
-We want Lambda ERP to be where that knowledge lives in public. The base system is MIT-licensed, and we're organizing the repo so that community contributions - a German VAT pack, a U.S. sales-tax-by-state module, an industry template for professional services - can slot in under `docs/` and be picked up by the LLM as reference material. The goal is a true community where running an ERP gets cheaper, faster, and more flexible for everyone, not just the implementer.
+We want Lambda ERP to be where that knowledge lives in public. The base system is MIT-licensed, and the repo has real seams for that knowledge to slot into: a new country's chart of accounts and tax rules is a self-contained **localization pack**, and an industry's way of operating is a **sector profile** — both live in `lambda_erp/accounting/setup/` and are documented for contributors in [`docs/agents/company_setup.md`](docs/agents/company_setup.md). A German VAT pack, a U.S. sales-tax-by-state module, a template for professional services — each is an additive contribution that every deployment picks up. The goal is a true community where running an ERP gets cheaper, faster, and more flexible for everyone, not just the implementer.
 
 ---
 

{lambda_erp-0.1.48 → lambda_erp-0.2.0}/README.md

@@ -108,8 +108,22 @@ Each of those is hours of skilled work today. With a capable LLM in the loop, th
 
 ---
 
+## Set up your books by describing your business
+
+Standing up a new company usually means an accountant hand-building a chart of accounts. In Lambda ERP you do it in the chat: tell the assistant what kind of business you run and which country you're in, and it proposes the exact accounts — explaining the structure and the judgment calls, and creating nothing until you approve. It's the "chart-of-accounts design and mapping" work from above, done in seconds and reviewed by you.
+
+Two dimensions shape the chart, and they compose:
+
+- **Localization packs** bring a country's real chart and tax setup. Today: a **generic / international** chart (also the permanent fallback for anywhere not yet localized) and **Switzerland** — the *Kontenrahmen KMU*, in German, in CHF, with MWST tax templates at the current rates. Each country is a self-contained pack, so more can land without disturbing the ones already there — that's the roadmap, one jurisdiction at a time.
+- **Sector profiles** tailor the chart to how you operate — **services, retail / POS, hospitality, wholesale / distribution, import / export, manufacturing, construction** — adding the accounts that model actually needs (work-in-progress and retention for construction, food-vs-beverage cost lines for hospitality, landed-cost accounts for import/export, and so on). Profiles are country-independent: the same seven apply on top of every localization.
+
+The result is booked in one step — chart of accounts, sensible default accounts, tax templates, and a cost center — ready for opening balances. New here? The in-app **Tutorial** has a one-click **Get started** that opens the wizard in chat.
+
+---
+
 ## What works today
 
+- **Guided company setup through chat** — pick a country (generic or Switzerland, more coming) and business type, preview the exact chart of accounts, confirm, and it's booked
 - Full sales and purchase cycles (Quotation → Sales Order → Delivery Note → Sales Invoice → Payment Entry, and the buying equivalents)
 - Returns / credit notes / debit notes with proper GL and stock reversal
 - Moving-average stock ledger with negative-stock protection
@@ -149,7 +163,7 @@ Four things had to be true for this to work, and they all became true in the las
 
 Every company configuring an ERP runs into the same problems: local tax rules, common workflow patterns, industry-specific accounting quirks. Most of that knowledge isn't a competitive advantage — it's the same ground being re-covered separately at every implementation, by every team, in slightly different ways.
 
-We want Lambda ERP to be where that knowledge lives in public. The base system is MIT-licensed, and we're organizing the repo so that community contributions - a German VAT pack, a U.S. sales-tax-by-state module, an industry template for professional services - can slot in under `docs/` and be picked up by the LLM as reference material. The goal is a true community where running an ERP gets cheaper, faster, and more flexible for everyone, not just the implementer.
+We want Lambda ERP to be where that knowledge lives in public. The base system is MIT-licensed, and the repo has real seams for that knowledge to slot into: a new country's chart of accounts and tax rules is a self-contained **localization pack**, and an industry's way of operating is a **sector profile** — both live in `lambda_erp/accounting/setup/` and are documented for contributors in [`docs/agents/company_setup.md`](docs/agents/company_setup.md). A German VAT pack, a U.S. sales-tax-by-state module, a template for professional services — each is an additive contribution that every deployment picks up. The goal is a true community where running an ERP gets cheaper, faster, and more flexible for everyone, not just the implementer.
 
 ---
 

{lambda_erp-0.1.48 → lambda_erp-0.2.0}/api/auth.py

@@ -680,14 +680,14 @@ def get_api_caller(request: Request) -> dict:
         raise HTTPException(status_code=401, detail="Empty bearer token")
 
     rows = db.sql(
-        'SELECT id, name, user, role, session_owner FROM "Api Key" WHERE key_hash = ? AND revoked = 0',
+        'SELECT id, name, owner, role, session_owner FROM "Api Key" WHERE key_hash = ? AND revoked = 0',
         [hash_api_key(token)],
     )
     if not rows:
         raise HTTPException(status_code=401, detail="Invalid API key")
     key = dict(rows[0])
 
-    owner = db.get_value("User", key["user"], ["name", "full_name", "role", "enabled"])
+    owner = db.get_value("User", key["owner"], ["name", "full_name", "role", "enabled"])
     if not owner or not owner.get("enabled"):
         raise HTTPException(status_code=401, detail="Invalid API key")
     effective_role = (
@@ -699,10 +699,10 @@ def get_api_caller(request: Request) -> dict:
 
     return {
         "name": key["session_owner"],
-        "full_name": f"{owner.get('full_name') or key['user']} (API)",
+        "full_name": f"{owner.get('full_name') or key['owner']} (API)",
         "role": effective_role,
         "api_key_id": key["id"],
-        "api_key_user": key["user"],
+        "api_key_user": key["owner"],
     }
 
 
@@ -717,7 +717,11 @@ def _serialize_api_key(row: dict) -> dict:
     return {
         "id": row["id"],
         "name": row["name"],
-        "user": row.get("user"),
+        "user": row.get("owner"),
+        # Owner's display identity so the UI can group keys per user with a
+        # human name instead of the opaque USR-id (admins see many owners).
+        "owner_full_name": row.get("owner_full_name"),
+        "owner_email": row.get("owner_email"),
         "role": row["role"],
         "key_prefix": row["key_prefix"],
         "created_at": row.get("created_at"),
@@ -727,7 +731,7 @@ def _serialize_api_key(row: dict) -> dict:
 
 
 def _get_key_or_404(db, key_id: str) -> dict:
-    rows = db.sql('SELECT id, user, revoked FROM "Api Key" WHERE id = ?', [key_id])
+    rows = db.sql('SELECT id, owner, revoked FROM "Api Key" WHERE id = ?', [key_id])
     if not rows:
         raise HTTPException(status_code=404, detail="API key not found")
     return dict(rows[0])
@@ -735,7 +739,7 @@ def _get_key_or_404(db, key_id: str) -> dict:
 
 def _require_key_access(key: dict, user: dict) -> None:
     """A key is managed by its owner; admins can manage every key."""
-    if key["user"] != user["name"] and user["role"] != "admin":
+    if key["owner"] != user["name"] and user["role"] != "admin":
         raise HTTPException(status_code=403, detail="Not your API key")
 
 
@@ -743,21 +747,26 @@ def _require_key_access(key: dict, user: dict) -> None:
 def list_api_keys(user: dict = Depends(require_viewer)):
     """List API keys (metadata only — the token is never returned).
 
-    Users see their own keys; admins see everyone's.
+    Users see their own keys; admins see everyone's. Each key carries its
+    owner's display name/email and an `is_mine` flag so the UI can group keys
+    per user (your own first) and warn before touching someone else's.
     """
     db = get_db()
+    base = (
+        'SELECT k.id, k.name, k.owner, k.role, k.key_prefix, k.created_at, '
+        'k.last_used_at, k.revoked, u.full_name AS owner_full_name, u.email AS owner_email '
+        'FROM "Api Key" k LEFT JOIN "User" u ON u.name = k.owner '
+    )
     if user["role"] == "admin":
-        rows = db.sql(
-            'SELECT id, name, user, role, key_prefix, created_at, last_used_at, revoked '
-            'FROM "Api Key" ORDER BY created_at DESC'
-        )
+        rows = db.sql(base + 'ORDER BY k.created_at DESC')
     else:
-        rows = db.sql(
-            'SELECT id, name, user, role, key_prefix, created_at, last_used_at, revoked '
-            'FROM "Api Key" WHERE user = ? ORDER BY created_at DESC',
-            [user["name"]],
-        )
-    return [_serialize_api_key(dict(r)) for r in rows]
+        rows = db.sql(base + 'WHERE k.owner = ? ORDER BY k.created_at DESC', [user["name"]])
+    out = []
+    for r in rows:
+        d = _serialize_api_key(dict(r))
+        d["is_mine"] = d["user"] == user["name"]
+        out.append(d)
+    return out
 
 
 @router.post("/api-keys")
@@ -789,16 +798,18 @@ def create_api_key(data: ApiKeyCreate, user: dict = Depends(require_viewer)):
     created_at = now()
     db.sql(
         'INSERT INTO "Api Key" '
-        '(id, name, user, key_hash, key_prefix, role, session_owner, created_at, last_used_at, revoked) '
+        '(id, name, owner, key_hash, key_prefix, role, session_owner, created_at, last_used_at, revoked) '
         'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0)',
         [key_id, name, user["name"], key_hash, key_prefix, role, f"api:{user['name']}", created_at, None],
     )
     db.conn.commit()
     row = {
-        "id": key_id, "name": name, "user": user["name"], "role": role, "key_prefix": key_prefix,
+        "id": key_id, "name": name, "owner": user["name"], "role": role, "key_prefix": key_prefix,
         "created_at": created_at, "last_used_at": None, "revoked": 0,
+        "owner_full_name": user.get("full_name"), "owner_email": user.get("email"),
     }
     result = _serialize_api_key(row)
+    result["is_mine"] = True
     result["token"] = token  # shown once
     return result
 

{lambda_erp-0.1.48 → lambda_erp-0.2.0}/api/chat.py

@@ -1067,6 +1067,75 @@ TOOLS = [
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "plan_company_setup",
+            "description": (
+                "PREVIEW a new company's chart of accounts — creates NOTHING. Use this "
+                "when the user asks to set up a company / get started / create their books. "
+                "Returns the proposed jurisdiction, currency, the full account tree, the "
+                "sector-specific accounts that would be added, the company default-account "
+                "wiring, and — importantly — `sector.guidance` (why the chart looks this way) "
+                "and `sector.big_decisions` (points you MUST confirm with the user before "
+                "applying). Call this first, walk the user through the plan and the big "
+                "decisions in plain language, and only call `apply_company_setup` once they "
+                "confirm.\n\n"
+                "`sector` is one of: services, retail_pos, hospitality, distribution, "
+                "import_export, manufacturing, construction. If you're unsure which fits, "
+                "ASK the user about their business rather than guessing. `country` selects "
+                "the jurisdiction chart. Available: 'generic' (international, USD) and 'CH' "
+                "(Switzerland — Kontenrahmen KMU, German account names, CHF, with MWST tax "
+                "templates). Any other country falls back to the generic chart — tell the "
+                "user when `jurisdiction.is_fallback` is true."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "The company name"},
+                    "sector": {
+                        "type": "string",
+                        "enum": ["services", "retail_pos", "hospitality", "distribution",
+                                 "import_export", "manufacturing", "construction"],
+                        "description": "Operating-mode profile. Omit if the business is generic/unknown.",
+                    },
+                    "country": {"type": "string", "description": "Jurisdiction code, e.g. 'CH'. Defaults to generic."},
+                    "variant": {"type": "string", "description": "Sub-chart variant, e.g. 'skr03' (rarely needed)."},
+                    "currency": {"type": "string", "description": "Base currency, e.g. 'USD', 'CHF'. Defaults to the pack currency."},
+                },
+                "required": ["name"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "apply_company_setup",
+            "description": (
+                "CREATE the company, its chart of accounts (base + sector overlay), the "
+                "company default accounts, any jurisdiction tax accounts, and the default "
+                "cost center — in one step. Only call this AFTER `plan_company_setup` and "
+                "AFTER the user has explicitly confirmed the plan and any big decisions. "
+                "Refuses if the company already has accounts (admin-only). Pass the SAME "
+                "arguments you used for the plan the user approved."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "The company name (must match the approved plan)"},
+                    "sector": {
+                        "type": "string",
+                        "enum": ["services", "retail_pos", "hospitality", "distribution",
+                                 "import_export", "manufacturing", "construction"],
+                    },
+                    "country": {"type": "string"},
+                    "variant": {"type": "string"},
+                    "currency": {"type": "string"},
+                },
+                "required": ["name"],
+            },
+        },
+    },
 ]
 
 # ---------------------------------------------------------------------------
@@ -1583,6 +1652,34 @@ def _handle_update_custom_analytics_report(args, user_info: dict | None = None,
     return row
 
 
+def _handle_plan_company_setup(args):
+    from lambda_erp.accounting.setup import plan_company_setup
+    name = (args.get("name") or "").strip()
+    if not name:
+        return {"error": "A company name is required to plan the setup."}
+    return plan_company_setup(
+        name,
+        country=(args.get("country") or None),
+        variant=(args.get("variant") or None),
+        sector=(args.get("sector") or None),
+        currency=(args.get("currency") or None),
+    )
+
+
+def _handle_apply_company_setup(args):
+    from lambda_erp.accounting.setup import apply_company_setup
+    name = (args.get("name") or "").strip()
+    if not name:
+        return {"error": "A company name is required to apply the setup."}
+    return apply_company_setup(
+        name,
+        country=(args.get("country") or None),
+        variant=(args.get("variant") or None),
+        sector=(args.get("sector") or None),
+        currency=(args.get("currency") or None),
+    )
+
+
 TOOL_HANDLERS = {
     "list_documents": _handle_list_documents,
     "get_document": _handle_get_document,
@@ -1606,6 +1703,8 @@ TOOL_HANDLERS = {
     "create_custom_analytics_report": lambda args: _handle_create_custom_analytics_report(args),
     "get_custom_analytics_report": lambda args: _handle_get_custom_analytics_report(args),
     "update_custom_analytics_report": lambda args: _handle_update_custom_analytics_report(args),
+    "plan_company_setup": _handle_plan_company_setup,
+    "apply_company_setup": _handle_apply_company_setup,
 }
 
 # ---------------------------------------------------------------------------
@@ -1747,6 +1846,21 @@ Always include the view link after creating, submitting, converting, or updating
     else:
         role_desc = "You have **viewer** access — you can view documents, master data, and reports, but you cannot create or modify data. If the user asks you to create or change something, let them know they need a manager or admin to do that."
 
+    # Only admins can run setup, so only they get the wizard playbook (keeps the
+    # prompt lean for everyone else). Triggered from chat OR the Tutorial page's
+    # "Get started" button, which sends a set-up-my-company message.
+    if user_role == "admin":
+        company_setup_section = """## Guided company setup (chart of accounts)
+When the user wants to **set up a new company**, get started, or create their books/chart of accounts, run the guided setup — do NOT hand-create accounts one by one:
+1. **Identify the business type.** Which of these fits: services/consulting, retail/POS, hospitality/F&B, distribution/wholesale, import/export, manufacturing, or construction? If the conversation doesn't make it obvious, ASK — never guess the sector.
+2. **Preview with `plan_company_setup`** (company name + sector + country/currency if known). This creates NOTHING; it returns the proposed chart.
+3. **Walk them through the plan** in plain language: the sector-specific accounts (`sector_added_accounts`) and the `sector.guidance` (why the chart is shaped this way). Present every item in `sector.big_decisions` and get an explicit yes/no on each — these are the decisions you must not make for them.
+4. **Only after they confirm, call `apply_company_setup`** with the SAME arguments to create the company, accounts, defaults, and cost center.
+If `jurisdiction.is_fallback` is true, tell the user their country isn't localized yet and you're using the generic international chart for now.
+"""
+    else:
+        company_setup_section = ""
+
     return f"""You are an ERP assistant for Lambda ERP. Today's date is {date.today().isoformat()}.
 
 You help users manage their business by creating documents, looking up data, and running reports — all through natural conversation.
@@ -1768,7 +1882,7 @@ When you do build a custom report, pass a plain-language `intent` to `create_cus
 ## Current User
 You are speaking with **{user_name}** (role: **{user_role}**).
 {role_desc}
-
+{company_setup_section}
 {company_context}
 {analytics_context}
 {uom_context}
@@ -2392,6 +2506,17 @@ async def run_thinking_loop(
         tool_handlers["update_master"] = denied
         tool_handlers["delete_master"] = denied
 
+    # Company setup (chart of accounts, defaults, cost center) is admin-only,
+    # mirroring POST /api/setup/company. Non-admins can still be *shown* a plan?
+    # No — even the preview reveals structure they can't act on, so deny both.
+    if user_role != "admin":
+        setup_denied = lambda _args: {
+            "error": "Setting up a company is an admin task. Ask an administrator "
+                     "to run the guided setup, or open it yourself from the Tutorial."
+        }
+        tool_handlers["plan_company_setup"] = setup_denied
+        tool_handlers["apply_company_setup"] = setup_denied
+
     # Scope session-aware tools without mutating globals.
     if session_id:
         tool_handlers["retrieve_chat_history"] = lambda args: _handle_retrieve_chat_history(args, session_id)

{lambda_erp-0.1.48 → lambda_erp-0.2.0}/api/routers/setup.py

@@ -7,6 +7,12 @@ from fastapi import APIRouter, Depends
 from lambda_erp.database import get_db
 from lambda_erp.utils import _dict, flt, nowdate
 from lambda_erp.accounting.chart_of_accounts import setup_chart_of_accounts, setup_cost_center
+from lambda_erp.accounting.setup import (
+    plan_company_setup,
+    apply_company_setup,
+    list_profiles,
+    list_packs,
+)
 from api.auth import require_role
 
 # Sample US corporate addresses (streets, cities, states) used to auto-fill
@@ -94,17 +100,71 @@ def create_company(data: dict, _user: dict = Depends(require_role("admin"))):
         **contact,
     ))
 
-    setup_chart_of_accounts(name, currency)
-    cost_center = setup_cost_center(name)
+    # Route the chart through the localization-pack engine. The jurisdiction is
+    # taken from the company `country` (falls back to the generic pack for any
+    # unlocalized country), and an optional `sector` applies an operating-mode
+    # overlay. With neither, this is byte-identical to the legacy
+    # setup_chart_of_accounts + setup_cost_center path.
+    result = apply_company_setup(
+        name,
+        country=(contact.get("country") or None),
+        variant=(data.get("variant") or None),
+        sector=(data.get("sector") or None),
+        currency=currency,
+    )
+    if not result.get("ok"):
+        return {"detail": result.get("error", "setup failed")}
 
     return {
         "ok": True,
         "company": name,
-        "cost_center": cost_center,
+        "cost_center": result["cost_center"],
         "currency": currency,
+        "jurisdiction": result["jurisdiction"],
+        "sector": result["sector"],
+        "accounts_created": result["accounts_created"],
+        "sector_added_accounts": result["sector_added_accounts"],
+    }
+
+
+@router.get("/profiles")
+def setup_profiles(_user: dict = Depends(require_role("viewer"))):
+    """List the available sector profiles and jurisdiction packs for setup."""
+    return {
+        "sectors": [
+            {
+                "key": p.key,
+                "label": p.label,
+                "summary": p.summary,
+                "big_decisions": p.big_decisions,
+            }
+            for p in list_profiles()
+        ],
+        "jurisdictions": [
+            {"key": p.key, "label": p.label, "currency": p.currency,
+             "has_standard_tax": p.setup_tax is not None}
+            for p in list_packs()
+        ],
     }
 
 
+@router.post("/plan")
+def setup_plan(data: dict, _user: dict = Depends(require_role("admin"))):
+    """Preview a company's chart of accounts without creating anything.
+
+    Expects: {"name": "...", "country": "CH"?, "variant": "skr03"?,
+              "sector": "manufacturing"?, "currency": "USD"?}
+    """
+    name = data.get("name") or "New Company"
+    return plan_company_setup(
+        name,
+        country=(data.get("country") or None),
+        variant=(data.get("variant") or None),
+        sector=(data.get("sector") or None),
+        currency=(data.get("currency") or None),
+    )
+
+
 @router.post("/seed-demo")
 def seed_demo(_user: dict = Depends(require_role("admin"))):
     """Seed demo master data (customers, suppliers, items, warehouse).
@@ -229,7 +289,13 @@ def import_account_balances(data: dict, _user: dict = Depends(require_role("admi
 
     db = get_db()
     abbr = company[:4].upper()
-    equity_account = f"Opening Balance Equity - {abbr}"
+    # Read the balancing account from the company default rather than hardcoding
+    # the English name — localization packs use their own (e.g. the Swiss pack's
+    # "2990 Eröffnungsbilanz"). Mirrors the Opening Stock path in stock_entry.py.
+    equity_account = (
+        db.get_value("Company", company, "default_opening_balance_equity")
+        or f"Opening Balance Equity - {abbr}"
+    )
 
     accounts = []
     total_debit = 0

{lambda_erp-0.1.48 → lambda_erp-0.2.0}/frontend/src/api/client.ts

@@ -454,10 +454,13 @@ export const api = {
     request<Array<{
       id: string; name: string; user?: string; role: string; key_prefix: string;
       created_at?: string; last_used_at?: string | null; revoked: boolean;
+      owner_full_name?: string | null; owner_email?: string | null; is_mine?: boolean;
     }>>("/auth/api-keys"),
   createApiKey: (name: string, role: string) =>
-    request<{ id: string; name: string; user?: string; role: string; key_prefix: string; token: string }>(
-      "/auth/api-keys", { method: "POST", body: JSON.stringify({ name, role }) }),
+    request<{
+      id: string; name: string; user?: string; role: string; key_prefix: string; token: string;
+      owner_full_name?: string | null; owner_email?: string | null; is_mine?: boolean;
+    }>("/auth/api-keys", { method: "POST", body: JSON.stringify({ name, role }) }),
   revokeApiKey: (id: string) =>
     request<{ id: string; revoked: boolean }>(
       `/auth/api-keys/${encodeURIComponent(id)}/revoke`, { method: "POST" }),

{lambda_erp-0.1.48 → lambda_erp-0.2.0}/lambda_erp/accounting/chart_of_accounts.py

@@ -111,21 +111,50 @@ STANDARD_CHART = {
 }
 
 
-def setup_chart_of_accounts(company_name, currency="USD"):
-    """Create all accounts for a company from the standard chart.
+# Company default-account wiring for the standard/generic chart, keyed
+# {company_field: leaf_account_name} (un-suffixed). The company abbreviation
+# suffix (" - ABBR") is appended at write time by apply_company_defaults. The
+# generic localization pack reuses this so the new setup engine and this legacy
+# path stay in lockstep.
+STANDARD_DEFAULTS = {
+    "default_receivable_account": "Accounts Receivable",
+    "default_payable_account": "Accounts Payable",
+    "default_income_account": "Sales Revenue",
+    "default_expense_account": "Cost of Goods Sold",
+    "round_off_account": "Round Off",
+    "stock_in_hand_account": "Stock In Hand",
+    "stock_received_but_not_billed": "Stock Received But Not Billed",
+    "stock_adjustment_account": "Stock Adjustment",
+    "default_opening_balance_equity": "Opening Balance Equity",
+    "default_freight_in_account": "Freight In",
+    "default_customs_account": "Customs & Duties",
+    "default_exchange_gain_loss_account": "Exchange Gain/Loss",
+    "default_unrealized_exchange_account": "Unrealized Exchange Gain/Loss",
+}
 
-    This mirrors the reference implementation's setup wizard step that creates the Chart of Accounts
-    from a template when a new company is created.
+
+def account_abbr(company_name):
+    """The 4-char company suffix used across the chart (e.g. 'Lambda' -> 'LAMB')."""
+    return company_name[:4].upper()
+
+
+def create_accounts_from_tree(company_name, tree, currency="USD"):
+    """Write an account tree for a company. Shared by the legacy setup and the
+    localization-pack engine so there is exactly one account writer.
+
+    ``tree`` is ``{account_name: {root_type?, report_type?, account_type?,
+    children?}}``. root_type / report_type inherit from the parent when omitted.
+    Does NOT commit — the caller owns the transaction boundary.
     """
     db = get_db()
 
-    def _create_accounts(tree, parent=None, root_type=None, report_type=None):
-        for account_name, details in tree.items():
+    def _create(subtree, parent=None, root_type=None, report_type=None):
+        for account_name, details in subtree.items():
             rt = details.get("root_type", root_type)
             rpt = details.get("report_type", report_type)
             has_children = "children" in details
 
-            name = f"{account_name} - {company_name[:4].upper()}"
+            name = f"{account_name} - {account_abbr(company_name)}"
 
             account = _dict(
                 name=name,
@@ -141,28 +170,35 @@ def setup_chart_of_accounts(company_name, currency="USD"):
             db.insert("Account", account)
 
             if has_children:
-                _create_accounts(details["children"], parent=name, root_type=rt, report_type=rpt)
-
-    _create_accounts(STANDARD_CHART)
-
-    # Set up company defaults
-    abbr = company_name[:4].upper()
-    db.set_value("Company", company_name, {
-        "default_receivable_account": f"Accounts Receivable - {abbr}",
-        "default_payable_account": f"Accounts Payable - {abbr}",
-        "default_income_account": f"Sales Revenue - {abbr}",
-        "default_expense_account": f"Cost of Goods Sold - {abbr}",
-        "round_off_account": f"Round Off - {abbr}",
-        "stock_in_hand_account": f"Stock In Hand - {abbr}",
-        "stock_received_but_not_billed": f"Stock Received But Not Billed - {abbr}",
-        "stock_adjustment_account": f"Stock Adjustment - {abbr}",
-        "default_opening_balance_equity": f"Opening Balance Equity - {abbr}",
-        "default_freight_in_account": f"Freight In - {abbr}",
-        "default_customs_account": f"Customs & Duties - {abbr}",
-        "default_exchange_gain_loss_account": f"Exchange Gain/Loss - {abbr}",
-        "default_unrealized_exchange_account": f"Unrealized Exchange Gain/Loss - {abbr}",
-    })
+                _create(details["children"], parent=name, root_type=rt, report_type=rpt)
+
+    _create(tree)
+
 
+def apply_company_defaults(company_name, defaults):
+    """Point Company default-account fields at the created leaf accounts.
+
+    ``defaults`` is ``{company_field: leaf_account_name}`` (un-suffixed); the
+    company suffix is appended here. Does NOT commit.
+    """
+    abbr = account_abbr(company_name)
+    resolved = {field: f"{leaf} - {abbr}" for field, leaf in defaults.items()}
+    if resolved:
+        db = get_db()
+        db.set_value("Company", company_name, resolved)
+
+
+def setup_chart_of_accounts(company_name, currency="USD"):
+    """Create all accounts for a company from the standard chart.
+
+    This mirrors the reference implementation's setup wizard step that creates the Chart of Accounts
+    from a template when a new company is created. It is the jurisdiction-neutral
+    legacy path; the localization-pack engine (``lambda_erp.accounting.setup``)
+    builds on the same writer to support sector overlays and other jurisdictions.
+    """
+    db = get_db()
+    create_accounts_from_tree(company_name, STANDARD_CHART, currency)
+    apply_company_defaults(company_name, STANDARD_DEFAULTS)
     db.commit()
     return True