@happyvertical/smrt-ledgers 0.30.0

package/dist/index.js

@@ -0,0 +1,1172 @@
+import { ObjectRegistry, smrt, SmrtHierarchical, SmrtCollection, foreignKey, SmrtObject } from "@happyvertical/smrt-core";
+import { definePrompt, resolvePrompt } from "@happyvertical/smrt-prompts";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+import { BALANCE_EPSILON } from "./types.js";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+const smrtLedgersJournalSummarizePrompt = definePrompt({
+  key: "smrtLedgers.journal.summarize",
+  template: `Summarize this accounting journal entry:
+Number: {journalNumber}
+Date: {journalDate}
+Description: {journalDescription}
+Status: {journalStatus}
+Total: {journalTotal}
+Entries: {entryCount}
+Balanced: {journalBalanced}`,
+  editable: {
+    template: true,
+    profile: true,
+    model: true,
+    params: true
+  }
+});
+function promptMessageOptions(ai) {
+  return {
+    ...ai.params || {},
+    ...ai.model ? { model: ai.model } : {},
+    ...typeof ai.temperature === "number" ? { temperature: ai.temperature } : {},
+    ...typeof ai.maxTokens === "number" ? { maxTokens: ai.maxTokens } : {}
+  };
+}
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+let Account = class extends SmrtHierarchical {
+  tenantId = null;
+  /**
+   * Account number (e.g., "1000", "5030")
+   */
+  number = "";
+  /**
+   * Account name (e.g., "Cash", "Coffee Expense")
+   */
+  name = "";
+  /**
+   * Account description
+   */
+  description = "";
+  /**
+   * Account type - one of the 5 core types
+   */
+  type = "asset";
+  // parentId inherited from SmrtHierarchical (null = top-level)
+  /**
+   * Whether the account is active
+   */
+  active = true;
+  /**
+   * Extensible metadata
+   */
+  metadata = {};
+  constructor(options = {}) {
+    super(options);
+    if (options.number !== void 0) this.number = options.number;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.type !== void 0) this.type = options.type;
+    if (options.parentId !== void 0) this.parentId = options.parentId;
+    if (options.active !== void 0) this.active = options.active;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Check if this is a top-level account (no parent)
+   */
+  isTopLevel() {
+    return this.parentId === null;
+  }
+  /**
+   * Check if this is a debit-normal account (Asset, Expense)
+   * Debit-normal accounts increase with debits
+   */
+  isDebitNormal() {
+    return this.type === "asset" || this.type === "expense";
+  }
+  /**
+   * Check if this is a credit-normal account (Liability, Equity, Revenue)
+   * Credit-normal accounts increase with credits
+   */
+  isCreditNormal() {
+    return this.type === "liability" || this.type === "equity" || this.type === "revenue";
+  }
+  // Hierarchy traversal (getParent / getChildren / getAncestors /
+  // getDescendants / getHierarchy / moveTo) provided by SmrtHierarchical.
+  // Account-specific helpers (getFullPath / getBalance / createChild /
+  // toTreeNode) remain below.
+  /**
+   * Get full account path (e.g., "Assets > Current > Cash")
+   */
+  async getFullPath() {
+    const ancestors = await this.getAncestors();
+    const names = [...ancestors.map((a) => a.name), this.name];
+    return names.join(" > ");
+  }
+  /**
+   * Build tree node for this account and its children
+   */
+  async toTreeNode() {
+    const children = await this.getChildren();
+    const childNodes = await Promise.all(children.map((c) => c.toTreeNode()));
+    return {
+      account: this,
+      children: childNodes
+    };
+  }
+  /**
+   * Get the current balance of this account
+   */
+  async getBalance(asOfDate) {
+    if (!this.id) return 0;
+    const { JournalEntryCollection: JournalEntryCollection2 } = await Promise.resolve().then(() => JournalEntries);
+    const collection = await JournalEntryCollection2.create(
+      this.options
+    );
+    return await collection.getAccountBalance(this.id, asOfDate);
+  }
+  /**
+   * Create a sub-account under this account
+   */
+  async createChild(options) {
+    if (!this.id) {
+      throw new Error("Account must be saved before creating children");
+    }
+    const { AccountCollection: AccountCollection2 } = await Promise.resolve().then(() => Accounts);
+    const collection = await AccountCollection2.create(this.options);
+    const account = await collection.create({
+      ...options,
+      parentId: this.id,
+      type: this.type
+      // Inherit type from parent
+    });
+    await account.save();
+    return account;
+  }
+};
+__decorateClass$2([
+  tenantId({ nullable: true })
+], Account.prototype, "tenantId", 2);
+Account = __decorateClass$2([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], Account);
+class AccountCollection extends SmrtCollection {
+  static _itemClass = Account;
+  /**
+   * Find account by number
+   *
+   * @param number - Account number
+   * @returns Account or null
+   */
+  async findByNumber(number) {
+    const accounts = await this.list({
+      where: { number },
+      limit: 1
+    });
+    return accounts[0] || null;
+  }
+  /**
+   * Find accounts by type
+   *
+   * @param type - Account type
+   * @returns Array of accounts
+   */
+  async findByType(type) {
+    return await this.list({
+      where: { type },
+      orderBy: "number ASC"
+    });
+  }
+  /**
+   * Find all active accounts
+   *
+   * @returns Array of active accounts
+   */
+  async findActive() {
+    return await this.list({
+      where: { active: true },
+      orderBy: "number ASC"
+    });
+  }
+  /**
+   * Find top-level accounts (no parent)
+   *
+   * @returns Array of top-level accounts
+   */
+  async findTopLevel() {
+    return await this.list({
+      where: { parentId: null },
+      orderBy: "number ASC"
+    });
+  }
+  /**
+   * Find direct children of an account
+   *
+   * @param parentId - Parent account ID
+   * @returns Array of child accounts
+   */
+  async findChildren(parentId) {
+    return await this.list({
+      where: { parentId },
+      orderBy: "number ASC"
+    });
+  }
+  /**
+   * Get the complete account tree
+   *
+   * @returns AccountTree structure
+   */
+  async getTree() {
+    const allAccounts = await this.list({
+      orderBy: "number ASC"
+    });
+    const accountMap = /* @__PURE__ */ new Map();
+    const childrenMap = /* @__PURE__ */ new Map();
+    for (const account of allAccounts) {
+      if (account.id) {
+        accountMap.set(account.id, account);
+      }
+      if (!childrenMap.has(account.parentId || "")) {
+        childrenMap.set(account.parentId || "", []);
+      }
+      childrenMap.get(account.parentId || "")?.push(account);
+    }
+    const buildNode = (account) => {
+      const children = (account.id ? childrenMap.get(account.id) : []) || [];
+      return {
+        account,
+        children: children.map(buildNode)
+      };
+    };
+    const roots = childrenMap.get("") || [];
+    return {
+      roots: roots.map(buildNode)
+    };
+  }
+  /**
+   * Get or create an account by number
+   *
+   * @param number - Account number
+   * @param defaults - Default values if creating
+   * @returns Account
+   */
+  async getOrCreateByNumber(number, defaults = {}) {
+    const existing = await this.findByNumber(number);
+    if (existing) {
+      return existing;
+    }
+    const account = await this.create({
+      number,
+      name: defaults.name || number,
+      description: defaults.description || "",
+      type: defaults.type || "asset",
+      parentId: defaults.parentId || null
+    });
+    await account.save();
+    return account;
+  }
+  /**
+   * Find accounts grouped by type
+   *
+   * @returns Record of type to accounts array
+   */
+  async groupByType() {
+    const accounts = await this.findActive();
+    const grouped = {
+      asset: [],
+      liability: [],
+      equity: [],
+      revenue: [],
+      expense: []
+    };
+    for (const account of accounts) {
+      grouped[account.type].push(account);
+    }
+    return grouped;
+  }
+  /**
+   * Get all descendants of an account recursively
+   *
+   * @param accountId - Account ID
+   * @returns Array of all descendant accounts
+   */
+  async getDescendants(accountId) {
+    const descendants = [];
+    const queue = [accountId];
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (!currentId) continue;
+      const children = await this.findChildren(currentId);
+      for (const child of children) {
+        descendants.push(child);
+        if (child.id) {
+          queue.push(child.id);
+        }
+      }
+    }
+    return descendants;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Find all accounts belonging to a specific tenant
+   *
+   * @param tenantId - Tenant ID
+   * @returns Array of tenant's accounts
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global accounts (no tenant association)
+   *
+   * @returns Array of global accounts
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find accounts for a tenant plus all global accounts
+   *
+   * @param tenantId - Tenant ID
+   * @returns Array of tenant's accounts and global accounts
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const Accounts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AccountCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+let JournalEntry = class extends SmrtObject {
+  tenantId = null;
+  journalId = "";
+  accountId = "";
+  /**
+   * Debit amount (left side)
+   */
+  debit = 0;
+  /**
+   * Credit amount (right side)
+   */
+  credit = 0;
+  /**
+   * Currency code (e.g., "USD", "CAD", "EUR")
+   */
+  currency = "USD";
+  /**
+   * Exchange rate to base currency
+   */
+  exchangeRate = 1;
+  /**
+   * Line memo/description
+   */
+  memo = "";
+  /**
+   * Extensible metadata
+   */
+  metadata = {};
+  constructor(options = {}) {
+    super(options);
+    if (options.journalId !== void 0) this.journalId = options.journalId;
+    if (options.accountId !== void 0) this.accountId = options.accountId;
+    if (options.debit !== void 0) this.debit = options.debit;
+    if (options.credit !== void 0) this.credit = options.credit;
+    if (options.currency !== void 0) this.currency = options.currency;
+    if (options.exchangeRate !== void 0)
+      this.exchangeRate = options.exchangeRate;
+    if (options.memo !== void 0) this.memo = options.memo;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Validate entry before save
+   */
+  async validateBeforeSave() {
+    await super.validateBeforeSave();
+    if (this.debit < 0) {
+      throw new Error("Debit amount cannot be negative");
+    }
+    if (this.credit < 0) {
+      throw new Error("Credit amount cannot be negative");
+    }
+    if (this.debit > 0 && this.credit > 0) {
+      throw new Error("Entry cannot have both debit and credit amounts");
+    }
+    if (this.debit === 0 && this.credit === 0) {
+      throw new Error("Entry must have either a debit or credit amount");
+    }
+    if (this.exchangeRate <= 0) {
+      throw new Error("Exchange rate must be positive");
+    }
+  }
+  /**
+   * Check if this is a debit entry
+   */
+  isDebit() {
+    return this.debit > 0;
+  }
+  /**
+   * Check if this is a credit entry
+   */
+  isCredit() {
+    return this.credit > 0;
+  }
+  /**
+   * Get the entry amount (positive value regardless of debit/credit)
+   */
+  getAmount() {
+    return this.debit > 0 ? this.debit : this.credit;
+  }
+  /**
+   * Get the amount in base currency
+   */
+  getBaseAmount() {
+    return this.getAmount() * this.exchangeRate;
+  }
+  /**
+   * Get the parent journal
+   */
+  async getJournal() {
+    if (!this.journalId) return null;
+    const { JournalCollection: JournalCollection2 } = await Promise.resolve().then(() => Journals);
+    const collection = await JournalCollection2.create(this.options);
+    return await collection.get({ id: this.journalId });
+  }
+  /**
+   * Get the account
+   */
+  async getAccount() {
+    if (!this.accountId) return null;
+    const { AccountCollection: AccountCollection2 } = await Promise.resolve().then(() => Accounts);
+    const collection = await AccountCollection2.create(this.options);
+    return await collection.get({ id: this.accountId });
+  }
+  /**
+   * Get a formatted description of this entry
+   */
+  async getDescription() {
+    const account = await this.getAccount();
+    const accountName = account?.name || "Unknown Account";
+    const type = this.isDebit() ? "DR" : "CR";
+    const amount = this.getAmount().toFixed(2);
+    return `${type} ${accountName}: $${amount}${this.memo ? ` - ${this.memo}` : ""}`;
+  }
+};
+__decorateClass$1([
+  tenantId({ nullable: true })
+], JournalEntry.prototype, "tenantId", 2);
+__decorateClass$1([
+  foreignKey("Journal")
+], JournalEntry.prototype, "journalId", 2);
+__decorateClass$1([
+  foreignKey("Account")
+], JournalEntry.prototype, "accountId", 2);
+JournalEntry = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get"] },
+    // Created via Journal, not directly
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], JournalEntry);
+class JournalEntryCollection extends SmrtCollection {
+  static _itemClass = JournalEntry;
+  /**
+   * Find entries by journal
+   *
+   * @param journalId - Journal ID
+   * @returns Array of entries
+   */
+  async findByJournal(journalId) {
+    return await this.list({
+      where: { journalId }
+    });
+  }
+  /**
+   * Find entries by account
+   *
+   * @param accountId - Account ID
+   * @returns Array of entries
+   */
+  async findByAccount(accountId) {
+    return await this.list({
+      where: { accountId }
+    });
+  }
+  /**
+   * Get account balance
+   *
+   * For debit-normal accounts (Asset, Expense): balance = debits - credits
+   * For credit-normal accounts (Liability, Equity, Revenue): balance = credits - debits
+   *
+   * @param accountId - Account ID
+   * @param asOfDate - Optional date to calculate balance as of
+   * @returns Account balance
+   */
+  async getAccountBalance(accountId, asOfDate) {
+    const { JournalCollection: JournalCollection2 } = await Promise.resolve().then(() => Journals);
+    const journalCollection = await JournalCollection2.create(
+      this.options
+    );
+    const { AccountCollection: AccountCollection2 } = await Promise.resolve().then(() => Accounts);
+    const accountCollection = await AccountCollection2.create(
+      this.options
+    );
+    const account = await accountCollection.get({ id: accountId });
+    if (!account) {
+      throw new Error(`Account not found: ${accountId}`);
+    }
+    const allEntries = await this.findByAccount(accountId);
+    let totalDebits = 0;
+    let totalCredits = 0;
+    for (const entry of allEntries) {
+      const journal = await journalCollection.get({ id: entry.journalId });
+      if (!journal) continue;
+      if (!journal.isPosted()) continue;
+      if (asOfDate && journal.date > asOfDate) continue;
+      totalDebits += entry.debit;
+      totalCredits += entry.credit;
+    }
+    if (account.isDebitNormal()) {
+      return totalDebits - totalCredits;
+    } else {
+      return totalCredits - totalDebits;
+    }
+  }
+  /**
+   * Get trial balance
+   *
+   * @param asOfDate - Optional date for trial balance
+   * @returns Array of trial balance rows
+   */
+  async getTrialBalance(asOfDate) {
+    const { AccountCollection: AccountCollection2 } = await Promise.resolve().then(() => Accounts);
+    const accountCollection = await AccountCollection2.create(
+      this.options
+    );
+    const accounts = await accountCollection.findActive();
+    const rows = [];
+    for (const account of accounts) {
+      if (!account.id) continue;
+      const balance = await this.getAccountBalance(account.id, asOfDate);
+      if (Math.abs(balance) < BALANCE_EPSILON) continue;
+      rows.push({
+        accountId: account.id,
+        accountNumber: account.number,
+        accountName: account.name,
+        accountType: account.type,
+        debitBalance: account.isDebitNormal() && balance > 0 ? balance : 0,
+        creditBalance: account.isCreditNormal() && balance > 0 ? balance : 0
+      });
+    }
+    rows.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+    return rows;
+  }
+  /**
+   * Get total debits and credits for a date range
+   *
+   * @param start - Start date
+   * @param end - End date
+   * @returns Object with totalDebits and totalCredits
+   */
+  async getTotalsForDateRange(start, end) {
+    const { JournalCollection: JournalCollection2 } = await Promise.resolve().then(() => Journals);
+    const journalCollection = await JournalCollection2.create(
+      this.options
+    );
+    const journals = await journalCollection.findByDateRange(start, end);
+    let totalDebits = 0;
+    let totalCredits = 0;
+    for (const journal of journals) {
+      if (!journal.isPosted()) continue;
+      const entries = await this.findByJournal(journal.id);
+      for (const entry of entries) {
+        totalDebits += entry.debit;
+        totalCredits += entry.credit;
+      }
+    }
+    return { totalDebits, totalCredits };
+  }
+  /**
+   * Get entries for multiple accounts
+   *
+   * @param accountIds - Array of account IDs
+   * @returns Array of entries
+   */
+  async findByAccounts(accountIds) {
+    if (accountIds.length === 0) {
+      return [];
+    }
+    return await this.list({
+      where: { accountId: accountIds }
+    });
+  }
+  /**
+   * Get the running balance for an account (list of entries with running total)
+   *
+   * @param accountId - Account ID
+   * @returns Array of entries with running balance
+   */
+  async getAccountLedger(accountId) {
+    const { JournalCollection: JournalCollection2 } = await Promise.resolve().then(() => Journals);
+    const { AccountCollection: AccountCollection2 } = await Promise.resolve().then(() => Accounts);
+    const journalCollection = await JournalCollection2.create(
+      this.options
+    );
+    const accountCollection = await AccountCollection2.create(
+      this.options
+    );
+    const account = await accountCollection.get({ id: accountId });
+    if (!account) {
+      throw new Error(`Account not found: ${accountId}`);
+    }
+    const entries = await this.findByAccount(accountId);
+    const ledger = [];
+    let runningBalance = 0;
+    const entriesWithJournals = await Promise.all(
+      entries.map(async (entry) => ({
+        entry,
+        journal: await journalCollection.get({ id: entry.journalId })
+      }))
+    );
+    entriesWithJournals.sort((a, b) => {
+      if (!a.journal || !b.journal) return 0;
+      return a.journal.date.getTime() - b.journal.date.getTime();
+    });
+    for (const { entry, journal } of entriesWithJournals) {
+      if (!journal || !journal.isPosted()) continue;
+      if (account.isDebitNormal()) {
+        runningBalance += entry.debit - entry.credit;
+      } else {
+        runningBalance += entry.credit - entry.debit;
+      }
+      ledger.push({ entry, runningBalance });
+    }
+    return ledger;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Find all journal entries belonging to a specific tenant
+   *
+   * @param tenantId - Tenant ID
+   * @returns Array of tenant's journal entries
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global journal entries (no tenant association)
+   *
+   * @returns Array of global journal entries
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find journal entries for a tenant plus all global entries
+   *
+   * @param tenantId - Tenant ID
+   * @returns Array of tenant's entries and global entries
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const JournalEntries = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  JournalEntryCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let Journal = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Journal number (auto-generated sequence, e.g., "JNL-0001")
+   */
+  number = "";
+  /**
+   * Transaction date
+   */
+  date = /* @__PURE__ */ new Date();
+  /**
+   * Description of the financial event
+   */
+  description = "";
+  /**
+   * Source module that created this journal (e.g., "smrt-commerce", "manual")
+   */
+  sourceModule = "";
+  /**
+   * External reference (e.g., order ID, invoice number)
+   */
+  sourceRef = null;
+  /**
+   * Journal status: draft, posted, voided
+   */
+  status = "draft";
+  /**
+   * When the journal was posted (finalized)
+   */
+  postedAt = null;
+  /**
+   * When the journal was voided
+   */
+  voidedAt = null;
+  /**
+   * Reason for voiding (if voided)
+   */
+  voidReason = null;
+  /**
+   * Extensible metadata
+   */
+  metadata = {};
+  constructor(options = {}) {
+    super(options);
+    if (options.number !== void 0) this.number = options.number;
+    if (options.date !== void 0) this.date = options.date;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.sourceModule !== void 0)
+      this.sourceModule = options.sourceModule;
+    if (options.sourceRef !== void 0) this.sourceRef = options.sourceRef;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.postedAt !== void 0) this.postedAt = options.postedAt;
+    if (options.voidedAt !== void 0) this.voidedAt = options.voidedAt;
+    if (options.voidReason !== void 0) this.voidReason = options.voidReason;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Check if journal is in draft status
+   */
+  isDraft() {
+    return this.status === "draft";
+  }
+  /**
+   * Check if journal has been posted
+   */
+  isPosted() {
+    return this.status === "posted";
+  }
+  /**
+   * Check if journal has been voided
+   */
+  isVoided() {
+    return this.status === "voided";
+  }
+  /**
+   * Check if journal can be modified
+   */
+  isEditable() {
+    return this.status === "draft";
+  }
+  /**
+   * Get all entries for this journal
+   */
+  async getEntries() {
+    if (!this.id) return [];
+    const { JournalEntryCollection: JournalEntryCollection2 } = await Promise.resolve().then(() => JournalEntries);
+    const collection = await JournalEntryCollection2.create(
+      this.options
+    );
+    return await collection.findByJournal(this.id);
+  }
+  /**
+   * Calculate total debits
+   */
+  async getTotalDebits() {
+    const entries = await this.getEntries();
+    return entries.reduce((sum, entry) => sum + entry.debit, 0);
+  }
+  /**
+   * Calculate total credits
+   */
+  async getTotalCredits() {
+    const entries = await this.getEntries();
+    return entries.reduce((sum, entry) => sum + entry.credit, 0);
+  }
+  /**
+   * Check if journal entries are balanced (debits = credits)
+   */
+  async isBalanced() {
+    const debits = await this.getTotalDebits();
+    const credits = await this.getTotalCredits();
+    return Math.abs(debits - credits) < BALANCE_EPSILON;
+  }
+  /**
+   * Add an entry to this journal (only if draft)
+   */
+  async addEntry(data) {
+    if (!this.id) {
+      throw new Error("Journal must be saved before adding entries");
+    }
+    if (!this.isEditable()) {
+      throw new Error("Cannot add entries to a posted or voided journal");
+    }
+    const { JournalEntryCollection: JournalEntryCollection2 } = await Promise.resolve().then(() => JournalEntries);
+    const collection = await JournalEntryCollection2.create(
+      this.options
+    );
+    const entry = await collection.create({
+      journalId: this.id,
+      accountId: data.accountId,
+      debit: data.debit || 0,
+      credit: data.credit || 0,
+      currency: data.currency || "USD",
+      exchangeRate: data.exchangeRate || 1,
+      memo: data.memo || ""
+    });
+    await entry.save();
+  }
+  /**
+   * Post the journal (finalize and make immutable)
+   */
+  async post() {
+    if (!this.isDraft()) {
+      throw new Error("Only draft journals can be posted");
+    }
+    const balanced = await this.isBalanced();
+    if (!balanced) {
+      const debits = await this.getTotalDebits();
+      const credits = await this.getTotalCredits();
+      throw new Error(
+        `Journal is not balanced. Debits: ${debits}, Credits: ${credits}`
+      );
+    }
+    const entries = await this.getEntries();
+    if (entries.length === 0) {
+      throw new Error("Journal must have at least one entry");
+    }
+    this.status = "posted";
+    this.postedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Void the journal (mark as cancelled with reason)
+   */
+  async void(reason) {
+    if (this.isVoided()) {
+      throw new Error("Journal is already voided");
+    }
+    this.status = "voided";
+    this.voidedAt = /* @__PURE__ */ new Date();
+    this.voidReason = reason;
+    await this.save();
+  }
+  /**
+   * AI-powered: Generate a summary of this journal.
+   *
+   * Uses the `smrtLedgers.journal.summarize` prompt registered via
+   * `@happyvertical/smrt-prompts`, allowing tenant- or instance-level
+   * overrides of the template, model, and parameters at runtime.
+   *
+   * Only non-PII journal fields (number, date, description, status, balanced
+   * flag) plus aggregate totals and entry count are sent to the AI provider.
+   * Internal foreign-key fields (tenantId, sourceRef, individual entry
+   * account IDs) and the extensible `metadata` blob are intentionally
+   * excluded.
+   *
+   * @returns Generated summary text
+   */
+  async summarize() {
+    const entries = await this.getEntries();
+    const debits = await this.getTotalDebits();
+    const balanced = await this.isBalanced();
+    const db = this.options.db ?? this.options.persistence;
+    const resolvedPrompt = await resolvePrompt(
+      smrtLedgersJournalSummarizePrompt.key,
+      {
+        db,
+        tenantId: this.tenantId,
+        variables: {
+          journalNumber: this.number || "",
+          journalDate: this.date.toISOString().split("T")[0],
+          journalDescription: this.description || "",
+          journalStatus: this.status || "",
+          // Currency prefix folded into the value rather than the template
+          // — see the `smrtLedgersJournalSummarizePrompt` comment block.
+          journalTotal: `$${debits.toFixed(2)}`,
+          entryCount: String(entries.length),
+          journalBalanced: balanced ? "Yes" : "No"
+        }
+      }
+    );
+    const ai = await this.getAiClient();
+    const response = await ai.message(
+      resolvedPrompt.text,
+      promptMessageOptions(resolvedPrompt.ai)
+    );
+    return response.trim();
+  }
+};
+__decorateClass([
+  tenantId({ nullable: true })
+], Journal.prototype, "tenantId", 2);
+Journal = __decorateClass([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get", "create"] },
+    // No update/delete - immutable after posting
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], Journal);
+class JournalCollection extends SmrtCollection {
+  static _itemClass = Journal;
+  /**
+   * Generate next journal number
+   *
+   * Uses timestamp and random component to avoid collisions
+   * in concurrent environments without relying on shared state.
+   */
+  generateJournalNumber() {
+    const timestamp = Date.now().toString(36);
+    const randomPart = Math.random().toString(36).slice(2, 6);
+    return `JNL-${timestamp}-${randomPart}`;
+  }
+  /**
+   * Find journal by number
+   *
+   * @param number - Journal number
+   * @returns Journal or null
+   */
+  async findByNumber(number) {
+    const journals = await this.list({
+      where: { number },
+      limit: 1
+    });
+    return journals[0] || null;
+  }
+  /**
+   * Find journals by date range
+   *
+   * @param start - Start date
+   * @param end - End date
+   * @returns Array of journals
+   */
+  async findByDateRange(start, end) {
+    return await this.list({
+      where: {
+        "date >=": start.toISOString(),
+        "date <=": end.toISOString()
+      },
+      orderBy: "date ASC"
+    });
+  }
+  /**
+   * Find journals by source module
+   *
+   * @param sourceModule - Source module name
+   * @returns Array of journals
+   */
+  async findBySource(sourceModule) {
+    return await this.list({
+      where: { sourceModule },
+      orderBy: "date DESC"
+    });
+  }
+  /**
+   * Find journals by status
+   *
+   * @param status - Journal status
+   * @returns Array of journals
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "date DESC"
+    });
+  }
+  /**
+   * Find draft journals
+   *
+   * @returns Array of draft journals
+   */
+  async findDrafts() {
+    return await this.findByStatus("draft");
+  }
+  /**
+   * Find posted journals
+   *
+   * @returns Array of posted journals
+   */
+  async findPosted() {
+    return await this.findByStatus("posted");
+  }
+  /**
+   * Create a complete journal with entries
+   *
+   * @param data - Journal data with entries
+   * @returns Created journal
+   */
+  async createWithEntries(data) {
+    let totalDebits = 0;
+    let totalCredits = 0;
+    for (const entry of data.entries) {
+      totalDebits += entry.debit || 0;
+      totalCredits += entry.credit || 0;
+    }
+    if (Math.abs(totalDebits - totalCredits) >= BALANCE_EPSILON) {
+      throw new Error(
+        `Entries are not balanced. Debits: ${totalDebits}, Credits: ${totalCredits}`
+      );
+    }
+    if (data.entries.length === 0) {
+      throw new Error("Journal must have at least one entry");
+    }
+    const journalNumber = await this.generateJournalNumber();
+    const journal = await this.create({
+      number: journalNumber,
+      date: data.date || /* @__PURE__ */ new Date(),
+      description: data.description,
+      sourceModule: data.sourceModule || "manual",
+      sourceRef: data.sourceRef || null,
+      metadata: data.metadata || {}
+    });
+    await journal.save();
+    for (const entryData of data.entries) {
+      await journal.addEntry(entryData);
+    }
+    return journal;
+  }
+  /**
+   * Post a journal by ID
+   *
+   * @param journalId - Journal ID
+   * @returns Posted journal
+   */
+  async post(journalId) {
+    const journal = await this.get({ id: journalId });
+    if (!journal) {
+      throw new Error(`Journal not found: ${journalId}`);
+    }
+    await journal.post();
+    return journal;
+  }
+  /**
+   * Void a journal by ID
+   *
+   * @param journalId - Journal ID
+   * @param reason - Reason for voiding
+   * @returns Voided journal
+   */
+  async void(journalId, reason) {
+    const journal = await this.get({ id: journalId });
+    if (!journal) {
+      throw new Error(`Journal not found: ${journalId}`);
+    }
+    await journal.void(reason);
+    return journal;
+  }
+  /**
+   * Find journals by source reference
+   *
+   * @param sourceRef - External reference
+   * @returns Array of journals
+   */
+  async findBySourceRef(sourceRef) {
+    return await this.list({
+      where: { sourceRef },
+      orderBy: "date DESC"
+    });
+  }
+  /**
+   * Get journals for a specific month
+   *
+   * @param year - Year
+   * @param month - Month (1-12)
+   * @returns Array of journals
+   */
+  async findByMonth(year, month) {
+    const start = new Date(year, month - 1, 1);
+    const end = new Date(year, month, 0, 23, 59, 59, 999);
+    return await this.findByDateRange(start, end);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Find all journals belonging to a specific tenant
+   *
+   * @param tenantId - Tenant ID
+   * @returns Array of tenant's journals
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global journals (no tenant association)
+   *
+   * @returns Array of global journals
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find journals for a tenant plus all global journals
+   *
+   * @param tenantId - Tenant ID
+   * @returns Array of tenant's journals and global journals
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const Journals = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  JournalCollection
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Account,
+  AccountCollection,
+  Journal,
+  JournalCollection,
+  JournalEntry,
+  JournalEntryCollection,
+  promptMessageOptions,
+  smrtLedgersJournalSummarizePrompt
+};
+//# sourceMappingURL=index.js.map