jaz-cli 2.6.0 → 2.8.0

package/dist/__tests__/provision.test.js

@@ -0,0 +1,141 @@
+import { describe, it, expect } from 'vitest';
+import { calculateProvision } from '../calc/provision.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateProvision (standard)', () => {
+    const base = { amount: 500000, annualRate: 4, termMonths: 60 };
+    it('PV < nominal amount', () => {
+        const r = calculateProvision(base);
+        expect(r.presentValue).toBeLessThan(r.nominalAmount);
+    });
+    it('totalUnwinding = nominal - PV', () => {
+        const r = calculateProvision(base);
+        expect(r.totalUnwinding).toBe(Math.round((r.nominalAmount - r.presentValue) * 100) / 100);
+    });
+    it('schedule length = termMonths', () => {
+        const r = calculateProvision(base);
+        expect(r.schedule).toHaveLength(60);
+    });
+    it('final closing balance = nominal amount exactly', () => {
+        const r = calculateProvision(base);
+        expect(r.schedule[r.schedule.length - 1].closingBalance).toBe(500000);
+    });
+    it('opening balance = previous closing balance', () => {
+        const r = calculateProvision(base);
+        for (let i = 1; i < r.schedule.length; i++) {
+            expect(r.schedule[i].openingBalance).toBe(r.schedule[i - 1].closingBalance);
+        }
+    });
+    it('first opening balance = PV', () => {
+        const r = calculateProvision(base);
+        expect(r.schedule[0].openingBalance).toBe(r.presentValue);
+    });
+    it('all interest amounts are positive', () => {
+        const r = calculateProvision(base);
+        for (const row of r.schedule) {
+            expect(row.interest).toBeGreaterThan(0);
+        }
+    });
+    it('closing balance increases monotonically (unwinding)', () => {
+        const r = calculateProvision(base);
+        for (let i = 1; i < r.schedule.length; i++) {
+            expect(r.schedule[i].closingBalance).toBeGreaterThan(r.schedule[i - 1].openingBalance);
+        }
+    });
+});
+describe('calculateProvision (journal entries)', () => {
+    const base = { amount: 500000, annualRate: 4, termMonths: 60 };
+    it('initial journal: debits Provision Expense, credits Provision for Obligations', () => {
+        const r = calculateProvision(base);
+        expect(r.initialJournal.lines[0].account).toBe('Provision Expense');
+        expect(r.initialJournal.lines[0].debit).toBe(r.presentValue);
+        expect(r.initialJournal.lines[1].account).toBe('Provision for Obligations');
+        expect(r.initialJournal.lines[1].credit).toBe(r.presentValue);
+    });
+    it('initial journal is balanced', () => {
+        const r = calculateProvision(base);
+        const debits = r.initialJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.initialJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+    it('unwinding journals: debits Finance Cost, credits Provision', () => {
+        const r = calculateProvision(base);
+        for (const row of r.schedule) {
+            expect(row.journal.lines[0].account).toBe('Finance Cost \u2014 Unwinding');
+            expect(row.journal.lines[1].account).toBe('Provision for Obligations');
+        }
+    });
+    it('every unwinding journal is balanced', () => {
+        const r = calculateProvision(base);
+        for (const row of r.schedule) {
+            const debits = row.journal.lines.reduce((s, l) => s + l.debit, 0);
+            const credits = row.journal.lines.reduce((s, l) => s + l.credit, 0);
+            expect(debits).toBe(credits);
+        }
+    });
+});
+describe('calculateProvision (blueprint)', () => {
+    it('blueprint present when startDate given', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 60, startDate: '2025-01-01' });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint null without startDate', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 60 });
+        expect(r.blueprint).toBeNull();
+    });
+    it('step count = 1 recognition + N unwinding + 1 settlement', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.steps).toHaveLength(14); // 1 + 12 + 1
+    });
+    it('step 1 = journal (initial recognition)', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.steps[0].action).toBe('journal');
+    });
+    it('last step = cash-out (settlement)', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        const lastStep = r.blueprint.steps[r.blueprint.steps.length - 1];
+        expect(lastStep.action).toBe('cash-out');
+    });
+    it('settlement amount = nominal obligation', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        const lastStep = r.blueprint.steps[r.blueprint.steps.length - 1];
+        const debits = lastStep.lines.reduce((s, l) => s + l.debit, 0);
+        expect(debits).toBe(500000);
+    });
+    it('capsuleType is Provisions', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleType).toBe('Provisions');
+    });
+    it('capsuleDescription contains IAS 37', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleDescription).toContain('IAS 37');
+    });
+});
+describe('calculateProvision (currency)', () => {
+    it('currency passes through', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, currency: 'SGD' });
+        expect(r.currency).toBe('SGD');
+    });
+    it('currency null when not provided', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12 });
+        expect(r.currency).toBeNull();
+    });
+});
+describe('calculateProvision (validation)', () => {
+    it('rejects zero amount', () => {
+        expect(() => calculateProvision({ amount: 0, annualRate: 4, termMonths: 60 })).toThrow(CalcValidationError);
+    });
+    it('rejects negative rate', () => {
+        expect(() => calculateProvision({ amount: 500000, annualRate: -1, termMonths: 60 })).toThrow(CalcValidationError);
+    });
+    it('rejects zero term', () => {
+        expect(() => calculateProvision({ amount: 500000, annualRate: 4, termMonths: 0 })).toThrow(CalcValidationError);
+    });
+    it('rejects invalid date format', () => {
+        expect(() => calculateProvision({ amount: 500000, annualRate: 4, termMonths: 60, startDate: '01-01-2025' })).toThrow(CalcValidationError);
+    });
+    it('allows zero discount rate', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 0, termMonths: 12 });
+        expect(r.presentValue).toBe(500000); // no discounting
+    });
+});

package/dist/__tests__/validate.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { CalcValidationError, validatePositive, validateNonNegative, validatePositiveInteger, validateSalvageLessThanCost, validateDateFormat, validateRate, } from '../calc/validate.js';
+describe('validatePositive', () => {
+    it('passes for positive values', () => {
+        expect(() => validatePositive(1, 'x')).not.toThrow();
+        expect(() => validatePositive(0.01, 'x')).not.toThrow();
+        expect(() => validatePositive(1_000_000, 'x')).not.toThrow();
+    });
+    it('rejects zero', () => {
+        expect(() => validatePositive(0, 'Amount')).toThrow(CalcValidationError);
+        expect(() => validatePositive(0, 'Amount')).toThrow('positive number');
+    });
+    it('rejects negative', () => {
+        expect(() => validatePositive(-5, 'Principal')).toThrow(CalcValidationError);
+    });
+    it('rejects NaN and Infinity', () => {
+        expect(() => validatePositive(NaN, 'x')).toThrow(CalcValidationError);
+        expect(() => validatePositive(Infinity, 'x')).toThrow(CalcValidationError);
+    });
+});
+describe('validateNonNegative', () => {
+    it('passes for zero and positive', () => {
+        expect(() => validateNonNegative(0, 'x')).not.toThrow();
+        expect(() => validateNonNegative(100, 'x')).not.toThrow();
+    });
+    it('rejects negative', () => {
+        expect(() => validateNonNegative(-1, 'Salvage')).toThrow(CalcValidationError);
+        expect(() => validateNonNegative(-1, 'Salvage')).toThrow('zero or positive');
+    });
+});
+describe('validatePositiveInteger', () => {
+    it('passes for positive integers', () => {
+        expect(() => validatePositiveInteger(1, 'x')).not.toThrow();
+        expect(() => validatePositiveInteger(60, 'x')).not.toThrow();
+    });
+    it('rejects zero', () => {
+        expect(() => validatePositiveInteger(0, 'Term')).toThrow(CalcValidationError);
+    });
+    it('rejects non-integers', () => {
+        expect(() => validatePositiveInteger(1.5, 'Term')).toThrow(CalcValidationError);
+    });
+    it('rejects negative integers', () => {
+        expect(() => validatePositiveInteger(-3, 'Term')).toThrow(CalcValidationError);
+    });
+});
+describe('validateSalvageLessThanCost', () => {
+    it('passes when salvage < cost', () => {
+        expect(() => validateSalvageLessThanCost(5000, 50000)).not.toThrow();
+    });
+    it('rejects when salvage >= cost', () => {
+        expect(() => validateSalvageLessThanCost(50000, 50000)).toThrow(CalcValidationError);
+        expect(() => validateSalvageLessThanCost(60000, 50000)).toThrow(CalcValidationError);
+    });
+});
+describe('validateDateFormat', () => {
+    it('passes for valid YYYY-MM-DD', () => {
+        expect(() => validateDateFormat('2025-01-01')).not.toThrow();
+        expect(() => validateDateFormat('2025-12-31')).not.toThrow();
+    });
+    it('passes for undefined (optional)', () => {
+        expect(() => validateDateFormat(undefined)).not.toThrow();
+    });
+    it('rejects wrong format', () => {
+        expect(() => validateDateFormat('01-01-2025')).toThrow(CalcValidationError);
+        expect(() => validateDateFormat('2025/01/01')).toThrow(CalcValidationError);
+        expect(() => validateDateFormat('Jan 1 2025')).toThrow(CalcValidationError);
+    });
+    it('rejects invalid dates', () => {
+        expect(() => validateDateFormat('2025-13-01')).toThrow(CalcValidationError);
+    });
+});
+describe('validateRate', () => {
+    it('passes for normal rates', () => {
+        expect(() => validateRate(0, 'Rate')).not.toThrow();
+        expect(() => validateRate(6, 'Rate')).not.toThrow();
+        expect(() => validateRate(100, 'Rate')).not.toThrow();
+    });
+    it('rejects negative rates', () => {
+        expect(() => validateRate(-1, 'Rate')).toThrow(CalcValidationError);
+    });
+});

package/dist/calc/asset-disposal.js

@@ -77,19 +77,23 @@ export function calculateAssetDisposal(inputs) {
     validateNonNegative(proceeds, 'Disposal proceeds');
     validateDateFormat(acquisitionDate);
     validateDateFormat(disposalDate);
+    // Normalize monetary inputs to 2dp to guarantee balanced journals
+    const cost2 = round2(cost);
+    const salvage2 = round2(salvageValue);
+    const proceeds2 = round2(proceeds);
     // Validate disposal is after acquisition
     if (disposalDate <= acquisitionDate) {
         throw new CalcValidationError('Disposal date must be after acquisition date.');
     }
     const monthsHeld = monthsBetween(acquisitionDate, disposalDate);
-    const accumulatedDepreciation = computeAccumDepreciation(cost, salvageValue, usefulLifeYears, method, monthsHeld);
-    const netBookValue = round2(cost - accumulatedDepreciation);
-    const gainOrLoss = round2(proceeds - netBookValue);
+    const accumulatedDepreciation = computeAccumDepreciation(cost2, salvage2, usefulLifeYears, method, monthsHeld);
+    const netBookValue = round2(cost2 - accumulatedDepreciation);
+    const gainOrLoss = round2(proceeds2 - netBookValue);
     const isGain = gainOrLoss >= 0;
     // Build disposal journal entry
     const lines = [];
-    if (proceeds > 0) {
-        lines.push({ account: 'Cash / Bank Account', debit: proceeds, credit: 0 });
+    if (proceeds2 > 0) {
+        lines.push({ account: 'Cash / Bank Account', debit: proceeds2, credit: 0 });
     }
     if (accumulatedDepreciation > 0) {
         lines.push({ account: 'Accumulated Depreciation', debit: accumulatedDepreciation, credit: 0 });
@@ -97,7 +101,7 @@ export function calculateAssetDisposal(inputs) {
     if (!isGain) {
         lines.push({ account: 'Loss on Disposal', debit: Math.abs(gainOrLoss), credit: 0 });
     }
-    lines.push({ account: 'Fixed Asset (at cost)', debit: 0, credit: cost });
+    lines.push({ account: 'Fixed Asset (at cost)', debit: 0, credit: cost2 });
     if (isGain && gainOrLoss > 0) {
         lines.push({ account: 'Gain on Disposal', debit: 0, credit: gainOrLoss });
     }
@@ -110,16 +114,16 @@ export function calculateAssetDisposal(inputs) {
     const methodLabel = method === 'sl' ? 'Straight-line' : method === 'ddb' ? 'Double declining' : '150% declining';
     const workings = [
         `Asset Disposal Workings (IAS 16)`,
-        `Cost: ${fmtAmt(cost, c)} | Salvage: ${fmtAmt(salvageValue, c)} | Life: ${usefulLifeYears} years (${methodLabel})`,
+        `Cost: ${fmtAmt(cost2, c)} | Salvage: ${fmtAmt(salvage2, c)} | Life: ${usefulLifeYears} years (${methodLabel})`,
         `Acquired: ${acquisitionDate} | Disposed: ${disposalDate} | Held: ${monthsHeld} months`,
         `Accumulated depreciation: ${fmtAmt(accumulatedDepreciation, c)} | NBV: ${fmtAmt(netBookValue, c)}`,
-        `Proceeds: ${fmtAmt(proceeds, c)} | ${isGain ? (gainOrLoss > 0 ? `Gain: ${fmtAmt(gainOrLoss, c)}` : 'At book value (no gain/loss)') : `Loss: ${fmtAmt(Math.abs(gainOrLoss), c)}`}`,
-        `Method: IAS 16.68 — Gain/Loss = Proceeds − NBV = ${fmtAmt(proceeds, c)} − ${fmtAmt(netBookValue, c)} = ${fmtAmt(gainOrLoss, c)}`,
+        `Proceeds: ${fmtAmt(proceeds2, c)} | ${isGain ? (gainOrLoss > 0 ? `Gain: ${fmtAmt(gainOrLoss, c)}` : 'At book value (no gain/loss)') : `Loss: ${fmtAmt(Math.abs(gainOrLoss), c)}`}`,
+        `Method: IAS 16.68 — Gain/Loss = Proceeds − NBV = ${fmtAmt(proceeds2, c)} − ${fmtAmt(netBookValue, c)} = ${fmtAmt(gainOrLoss, c)}`,
     ].join('\n');
     let blueprint = null;
     blueprint = {
         capsuleType: 'Asset Disposal',
-        capsuleName: `Asset Disposal — ${fmtCapsuleAmount(cost, currency)} asset — ${disposalDate}`,
+        capsuleName: `Asset Disposal — ${fmtCapsuleAmount(cost2, currency)} asset — ${disposalDate}`,
         capsuleDescription: workings,
         tags: ['Asset Disposal'],
         customFields: { 'Asset Description': null },
@@ -132,12 +136,12 @@ export function calculateAssetDisposal(inputs) {
         type: 'asset-disposal',
         currency: currency ?? null,
         inputs: {
-            cost,
-            salvageValue,
+            cost: cost2,
+            salvageValue: salvage2,
             usefulLifeYears,
             acquisitionDate,
             disposalDate,
-            proceeds,
+            proceeds: proceeds2,
             method,
         },
         monthsHeld,

package/dist/calc/fixed-deposit.js

@@ -10,7 +10,7 @@
  */
 import { fv } from 'financial';
 import { round2, addMonths } from './types.js';
-import { validatePositive, validatePositiveInteger, validateDateFormat, validateRate } from './validate.js';
+import { CalcValidationError, validatePositive, validatePositiveInteger, validateDateFormat, validateRate } from './validate.js';
 import { journalStep, cashOutStep, cashInStep, fmtCapsuleAmount, fmtAmt } from './blueprint.js';
 export function calculateFixedDeposit(inputs) {
     const { principal, annualRate, termMonths, compounding = 'none', startDate, currency, } = inputs;
@@ -18,26 +18,28 @@ export function calculateFixedDeposit(inputs) {
     validateRate(annualRate, 'Annual rate');
     validatePositiveInteger(termMonths, 'Term (months)');
     validateDateFormat(startDate);
-    const monthlyRate = annualRate / 100 / 12;
-    // Compute total interest based on compounding method
+    // Compound interval validation — term must align with compounding frequency
+    const compIntervalMonths = compounding === 'monthly' ? 1 : compounding === 'quarterly' ? 3 : compounding === 'annually' ? 12 : 0;
+    if (compounding !== 'none' && termMonths % compIntervalMonths !== 0) {
+        throw new CalcValidationError(`Term (${termMonths} months) must be a multiple of ${compIntervalMonths} for ${compounding} compounding.`);
+    }
+    // Compute maturity value
     let maturityValue;
     if (compounding === 'none') {
         // Simple interest: Principal × Rate × Time
         maturityValue = round2(principal + principal * (annualRate / 100) * (termMonths / 12));
     }
     else {
-        // Compound interest using fv() from financial package
-        // fv(rate, nper, pmt, pv) — returns negative, negate
-        const periodsPerYear = compounding === 'monthly' ? 12 : compounding === 'quarterly' ? 4 : 1;
+        // Compound interest using fv() — one consistent periodic rate
+        const periodsPerYear = 12 / compIntervalMonths;
         const compoundRate = annualRate / 100 / periodsPerYear;
-        const totalCompoundPeriods = Math.floor(termMonths / (12 / periodsPerYear));
-        // fv() with negative pv (outflow) returns positive (inflow at maturity)
+        const totalCompoundPeriods = termMonths / compIntervalMonths;
         maturityValue = round2(fv(compoundRate, totalCompoundPeriods, 0, -principal));
     }
     const totalInterest = round2(maturityValue - principal);
     // Effective annual rate (for display)
     const effectiveRate = round2((Math.pow(maturityValue / principal, 12 / termMonths) - 1) * 100 * 100) / 100;
-    // Build monthly accrual schedule
+    // Build accrual schedule — accrue at compound intervals using the same periodic rate
     const schedule = [];
     let accruedTotal = 0;
     if (compounding === 'none') {
@@ -67,31 +69,38 @@ export function calculateFixedDeposit(inputs) {
         }
     }
     else {
-        // Compound interest: effective interest on growing carrying amount
+        // Compound interest: accrue at compound intervals using the periodic rate
+        // e.g. quarterly = every 3 months, interest accrues on the growing carrying amount
+        const periodicRate = annualRate / 100 / (12 / compIntervalMonths);
         let balance = principal;
-        for (let i = 1; i <= termMonths; i++) {
+        const totalPeriods = termMonths / compIntervalMonths;
+        for (let p = 1; p <= totalPeriods; p++) {
             const openingBalance = round2(balance);
-            const isFinal = i === termMonths;
+            const isFinal = p === totalPeriods;
             let interest;
             if (isFinal) {
                 // Final period: close to exact maturity value
                 interest = round2(maturityValue - openingBalance);
             }
             else {
-                interest = round2(openingBalance * monthlyRate);
+                interest = round2(openingBalance * periodicRate);
             }
             balance = round2(openingBalance + interest);
             accruedTotal = round2(accruedTotal + interest);
-            const date = startDate ? addMonths(startDate, i) : null;
+            const monthOffset = p * compIntervalMonths;
+            const date = startDate ? addMonths(startDate, monthOffset) : null;
+            const periodLabel = compounding === 'monthly'
+                ? `Month ${p}` : compounding === 'quarterly'
+                ? `Quarter ${p}` : `Year ${p}`;
             const journal = {
-                description: `Interest accrual — Month ${i} of ${termMonths}`,
+                description: `Interest accrual — ${periodLabel} of ${totalPeriods}`,
                 lines: [
                     { account: 'Accrued Interest Receivable', debit: interest, credit: 0 },
                     { account: 'Interest Income', debit: 0, credit: interest },
                 ],
             };
             schedule.push({
-                period: i,
+                period: p,
                 date,
                 openingBalance,
                 interest,
@@ -121,7 +130,7 @@ export function calculateFixedDeposit(inputs) {
         const steps = [
             cashOutStep(1, 'Transfer funds from operating account to fixed deposit', startDate, placementJournal.lines),
             ...schedule.map((row, idx) => journalStep(idx + 2, row.journal.description, row.date, row.journal.lines)),
-            cashInStep(termMonths + 2, 'Fixed deposit maturity — principal + accrued interest returned to Cash', addMonths(startDate, termMonths), maturityJournal.lines),
+            cashInStep(schedule.length + 2, 'Fixed deposit maturity — principal + accrued interest returned to Cash', addMonths(startDate, termMonths), maturityJournal.lines),
         ];
         const c = currency ?? undefined;
         const compoundLabel = compounding === 'none' ? 'Simple interest' : `Compound ${compounding}`;

package/dist/calc/lease.js

@@ -11,17 +11,21 @@
  */
 import { pv } from 'financial';
 import { round2, addMonths } from './types.js';
-import { validatePositive, validatePositiveInteger, validateDateFormat, validateRate } from './validate.js';
+import { CalcValidationError, validatePositive, validatePositiveInteger, validateDateFormat, validateRate } from './validate.js';
 import { journalStep, fixedAssetStep, fmtCapsuleAmount, fmtAmt } from './blueprint.js';
 export function calculateLease(inputs) {
     const { monthlyPayment, termMonths, annualRate, usefulLifeMonths, startDate, currency } = inputs;
     validatePositive(monthlyPayment, 'Monthly payment');
     validateRate(annualRate, 'Annual rate (IBR)');
     validatePositiveInteger(termMonths, 'Term (months)');
-    if (usefulLifeMonths !== undefined)
+    if (usefulLifeMonths !== undefined) {
         validatePositiveInteger(usefulLifeMonths, 'Useful life (months)');
+        if (usefulLifeMonths < termMonths) {
+            throw new CalcValidationError(`Useful life (${usefulLifeMonths} months) must be >= lease term (${termMonths} months) for hire purchase.`);
+        }
+    }
     validateDateFormat(startDate);
-    const isHirePurchase = usefulLifeMonths !== undefined && usefulLifeMonths > termMonths;
+    const isHirePurchase = usefulLifeMonths !== undefined;
     const monthlyRate = annualRate / 100 / 12;
     // PV of an ordinary annuity (payments at end of period)
     // pv() returns negative, negate for positive value

package/dist/commands/jobs.js

@@ -0,0 +1,184 @@
+import chalk from 'chalk';
+import { generateMonthEndBlueprint } from '../jobs/month-end.js';
+import { generateQuarterEndBlueprint } from '../jobs/quarter-end.js';
+import { generateYearEndBlueprint } from '../jobs/year-end.js';
+import { generateBankReconBlueprint } from '../jobs/bank-recon.js';
+import { generateGstVatBlueprint } from '../jobs/gst-vat.js';
+import { generatePaymentRunBlueprint } from '../jobs/payment-run.js';
+import { generateCreditControlBlueprint } from '../jobs/credit-control.js';
+import { generateSupplierReconBlueprint } from '../jobs/supplier-recon.js';
+import { generateAuditPrepBlueprint } from '../jobs/audit-prep.js';
+import { generateFaReviewBlueprint } from '../jobs/fa-review.js';
+import { printBlueprint, printBlueprintJson } from '../jobs/format.js';
+import { JobValidationError } from '../jobs/validate.js';
+/** Wrap job action with validation error handling. */
+function jobAction(fn) {
+    return (opts) => {
+        try {
+            fn(opts);
+        }
+        catch (err) {
+            if (err instanceof JobValidationError) {
+                console.error(chalk.red(`Error: ${err.message}`));
+                process.exit(1);
+            }
+            throw err;
+        }
+    };
+}
+export function registerJobsCommand(program) {
+    const jobs = program
+        .command('jobs')
+        .description('Accounting job blueprints — month-end, quarter-end, year-end, bank-recon, gst-vat, payment-run, credit-control, supplier-recon, audit-prep, fa-review');
+    // ── jaz jobs month-end ──────────────────────────────────────────
+    jobs
+        .command('month-end')
+        .description('Month-end close blueprint (5 phases, 18 steps)')
+        .requiredOption('--period <YYYY-MM>', 'Month period (e.g., 2025-01)')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateMonthEndBlueprint({
+            period: opts.period,
+            currency: opts.currency,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs quarter-end ────────────────────────────────────────
+    jobs
+        .command('quarter-end')
+        .description('Quarter-end close blueprint (monthly × 3 + quarterly extras)')
+        .requiredOption('--period <YYYY-QN>', 'Quarter period (e.g., 2025-Q1)')
+        .option('--incremental', 'Generate only quarterly extras (assumes months already closed)')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateQuarterEndBlueprint({
+            period: opts.period,
+            currency: opts.currency,
+            incremental: opts.incremental,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs year-end ───────────────────────────────────────────
+    jobs
+        .command('year-end')
+        .description('Year-end close blueprint (quarterly × 4 + annual extras)')
+        .requiredOption('--period <YYYY>', 'Fiscal year (e.g., 2025)')
+        .option('--incremental', 'Generate only annual extras (assumes quarters already closed)')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateYearEndBlueprint({
+            period: opts.period,
+            currency: opts.currency,
+            incremental: opts.incremental,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs bank-recon ─────────────────────────────────────────
+    jobs
+        .command('bank-recon')
+        .description('Bank reconciliation catch-up blueprint')
+        .option('--account <name>', 'Specific bank account name')
+        .option('--period <YYYY-MM>', 'Month period to reconcile')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateBankReconBlueprint({
+            account: opts.account,
+            period: opts.period,
+            currency: opts.currency,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs gst-vat ────────────────────────────────────────────
+    jobs
+        .command('gst-vat')
+        .description('GST/VAT filing preparation blueprint')
+        .requiredOption('--period <YYYY-QN>', 'Quarter period (e.g., 2025-Q1)')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateGstVatBlueprint({
+            period: opts.period,
+            currency: opts.currency,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs payment-run ────────────────────────────────────────
+    jobs
+        .command('payment-run')
+        .description('Payment run blueprint (bulk bill payments)')
+        .option('--due-before <YYYY-MM-DD>', 'Pay bills due on or before this date')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generatePaymentRunBlueprint({
+            dueBefore: opts.dueBefore,
+            currency: opts.currency,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs credit-control ─────────────────────────────────────
+    jobs
+        .command('credit-control')
+        .description('Credit control / AR chase blueprint')
+        .option('--overdue-days <days>', 'Minimum overdue days to include', (v) => {
+        const n = Number.parseInt(v, 10);
+        if (!Number.isFinite(n))
+            throw new JobValidationError(`overdue-days must be an integer (got "${v}")`);
+        return n;
+    })
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateCreditControlBlueprint({
+            overdueDays: opts.overdueDays,
+            currency: opts.currency,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs supplier-recon ─────────────────────────────────────
+    jobs
+        .command('supplier-recon')
+        .description('Supplier statement reconciliation blueprint')
+        .option('--supplier <name>', 'Specific supplier name')
+        .option('--period <YYYY-MM>', 'Month period')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateSupplierReconBlueprint({
+            supplier: opts.supplier,
+            period: opts.period,
+            currency: opts.currency,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs audit-prep ─────────────────────────────────────────
+    jobs
+        .command('audit-prep')
+        .description('Audit preparation pack blueprint')
+        .requiredOption('--period <YYYY>', 'Fiscal year (e.g., 2025)')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateAuditPrepBlueprint({
+            period: opts.period,
+            currency: opts.currency,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+    // ── jaz jobs fa-review ──────────────────────────────────────────
+    jobs
+        .command('fa-review')
+        .description('Fixed asset register review blueprint')
+        .option('--currency <code>', 'Currency code (e.g. SGD, USD)')
+        .option('--json', 'Output as JSON')
+        .action(jobAction((opts) => {
+        const bp = generateFaReviewBlueprint({
+            currency: opts.currency,
+        });
+        opts.json ? printBlueprintJson(bp) : printBlueprint(bp);
+    }));
+}

package/dist/index.js

@@ -7,6 +7,7 @@ import { initCommand } from './commands/init.js';
 import { versionsCommand } from './commands/versions.js';
 import { updateCommand } from './commands/update.js';
 import { registerCalcCommand } from './commands/calc.js';
+import { registerJobsCommand } from './commands/jobs.js';
 import { SKILL_TYPES } from './types/index.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -51,4 +52,5 @@ program
     });
 });
 registerCalcCommand(program);
+registerJobsCommand(program);
 program.parse();