jaz-cli 2.0.0

package/assets/skills/conversion/references/option1-full.md

@@ -0,0 +1,145 @@
+# Full Conversion (Option 1) — Complete Transaction History
+
+## Overview
+
+The Full Conversion transfers **all transaction details** for FY and FY-1 (typically 2 financial years). This preserves the complete audit trail including individual invoices, bills, payments, journals, and more.
+
+**Result:** On Jaz, the ledger shows every transaction from the source system. The Trial Balance at any date within the conversion period matches the source.
+
+## Required Input Files
+
+**No date range (reference data):**
+1. Chart of Accounts — full CoA list
+2. Contact list (customers + suppliers) with details
+3. Item list (products/services)
+4. Tax profile list
+5. Exchange rate table (rates for the conversion period)
+
+**As-on date (FYE or start date):**
+6. Trial Balance — opening balances at conversion start
+7. AR Aging — outstanding receivables at conversion start
+8. AP Aging — outstanding payables at conversion start
+9. Fixed Asset Register — assets with accumulated depreciation
+
+**Conversion period range:**
+10. Detailed invoice listing (with line items)
+11. Detailed bill listing (with line items)
+12. Payment details (invoice payments + bill payments)
+13. General Ledger report (all journal entries)
+14. Credit note listing (customer + supplier)
+15. Bank statement / bank records
+16. Cash-in / cash-out entries
+17. Cash transfer records
+
+## Execution Order
+
+### Phase 1: Foundation (same as Quick)
+1. Currencies + exchange rates
+2. Chart of Accounts (full match or replace)
+3. Tax profile discovery + mapping
+4. Contacts (customers + suppliers)
+5. Items (products/services with pricing)
+
+### Phase 2: Opening Balances
+If converting mid-FY (not from the very start of the ledger):
+- Create a TTB journal for opening balances at the conversion start date
+- This is the same pattern as Quick Conversion Phase 3
+
+### Phase 3: Transactions (chronological order within the period)
+
+#### 3.1 Invoices
+Create each source invoice with its original:
+- Date (`valueDate`)
+- Reference number
+- Contact
+- Line items (account, description, quantity, unit price, tax)
+- Currency + exchange rate (for FX invoices)
+
+#### 3.2 Bills
+Same pattern as invoices but via `POST /api/v1/bills`.
+
+#### 3.3 Journal Entries
+Source GL entries that aren't invoices/bills/payments → create as journal entries.
+- Map each line to the correct CoA account
+- Preserve debit/credit direction
+- Note: Journals have NO top-level currency field
+
+#### 3.4 Credit Notes
+- Customer credit notes via `POST /api/v1/customer-credit-notes`
+- Supplier credit notes via `POST /api/v1/supplier-credit-notes`
+
+#### 3.5 Cash Entries
+- Cash-in entries (deposits received)
+- Cash-out entries (payments made directly from bank)
+- Cash transfers between bank accounts
+
+### Phase 4: Settlements
+
+#### 4.1 Invoice Payments
+For each payment in the source:
+```
+POST /api/v1/invoices/<invoiceResourceId>/payments
+{
+  "payments": [{
+    "paymentAmount": <bank currency amount>,
+    "transactionAmount": <invoice currency amount>,
+    "accountResourceId": "<bank account ID>",
+    "paymentMethod": "BANK_TRANSFER",
+    "reference": "<payment ref>",
+    "valueDate": "<payment date>"
+  }]
+}
+```
+
+#### 4.2 Bill Payments
+Same pattern via `POST /api/v1/bills/<billResourceId>/payments`.
+
+#### 4.3 Credit Note Applications
+Apply credit notes to invoices/bills if the source shows them as applied.
+
+### Phase 5: Post-Transaction Data
+
+#### 5.1 Bank Records
+Import bank statements for reconciliation:
+- Via `POST /api/v1/bank-records/import` (multipart form)
+- Or via individual `POST /api/v1/bank-records`
+
+#### 5.2 Fixed Assets
+Transfer existing assets with accumulated depreciation:
+```
+POST /api/v1/transfer-fixed-assets
+```
+This preserves the asset's cost basis and accumulated depreciation — do NOT use the "new asset" endpoint which would reset depreciation.
+
+### Phase 6: Verify
+Pull TB from Jaz at multiple dates (conversion start, mid-period, period end) and compare against source.
+
+## Key Differences from Quick Conversion
+
+| Aspect | Quick | Full |
+|--------|-------|------|
+| Transactions created | Conversion invoices/bills only | All original transactions |
+| Date on documents | Original dates (FYE fallback) | Original dates |
+| Exchange rates | Explicit FYE rate (zero UGL) | Original rates per transaction |
+| Payments | None (just open balances) | All payments linked to documents |
+| Journals | TTB only | TTB + all source journals |
+| Verification points | TB at FYE only | TB at multiple dates |
+| Complexity | Low-medium | High |
+| Time to execute | Hours | Days |
+
+## Edge Cases
+
+### Payments That Cross Invoices
+A single payment may cover multiple invoices. Create separate payment records for each invoice, splitting the amount.
+
+### Void/Deleted Transactions
+Skip voided transactions — they don't affect balances. If the source shows a void + reversal, only the reversal matters.
+
+### Inter-Company Transactions
+If the source has inter-company entries, these must map to the correct contact + accounts on each side.
+
+### Unrealized FX Gains/Losses
+Unlike Quick Conversion (where prior UGL is captured in the TTB and conversion invoices use explicit FYE rate for zero UGL), Full Conversion replicates **all transactions at their original rates**. Any unrealized FX revaluation journals from the source system should be replicated as manual journals in Jaz if they fall within the conversion period. This preserves the full historical UGL trail.
+
+### Inventory
+If the source has inventory items with WAC (Weighted Average Cost), the opening inventory value must match. Create inventory adjustments if needed.

package/assets/skills/conversion/references/option2-quick.md

@@ -0,0 +1,197 @@
+# Quick Conversion (Option 2) — Opening Balances at FYE
+
+## Overview
+
+The Quick Conversion transfers **opening balances** into Jaz as at the Financial Year End (FYE) date. It creates open AR/AP as conversion transactions (invoices/bills) and transfers all other balances via a TTB journal entry.
+
+**Result:** On Jaz, the Trial Balance at FYE matches the source system. Open receivables and payables exist as documents that can receive future payments.
+
+## Required Input Files
+
+1. **Chart of Accounts** — full CoA list from source system
+2. **Trial Balance at FYE** — all account balances as at the FYE date
+3. **AR Aging at FYE** — outstanding receivable invoices (per customer, per currency)
+4. **AP Aging at FYE** — outstanding payable bills (per supplier, per currency)
+5. **Contact list** — customer and supplier details
+6. **Tax profiles** — tax codes used in the source system
+7. **Exchange rates** — closing rates for all currencies as at FYE
+
+## Execution Order
+
+### Phase 1: Foundation
+
+#### 1.1 Currencies
+- Enable all required currencies on the org
+- Set FYE closing exchange rates
+- These must exist before creating CoA entries with foreign currency
+
+#### 1.2 Chart of Accounts
+Two modes:
+
+**Fresh org (default system CoA):**
+1. GET existing CoA from Jaz
+2. Identify system-generated accounts (cannot delete)
+3. Delete non-system accounts that aren't in the source CoA
+4. Create/update accounts to match source CoA
+5. Create two clearing accounts:
+   - **"AR Conversion Clearing"** — type: `Other Current Assets`, `classificationType: "Current Assets"`
+   - **"AP Conversion Clearing"** — type: `Other Current Liabilities`, `classificationType: "Current Liabilities"`
+
+**Existing org:**
+1. GET existing CoA from Jaz
+2. Fuzzy match source accounts to existing (by code AND name)
+3. Create any missing accounts
+4. Create clearing accounts if they don't exist
+
+#### 1.3 Tax Profiles
+- GET existing tax profiles from Jaz (read-only — cannot create)
+- Match source tax codes to Jaz tax profiles
+- Common mappings: "GST 9%" → SR (Standard Rated), "No Tax" → ES (Exempt Supply)
+
+#### 1.4 Contacts
+- Create customer and supplier contacts from source data
+- Ensure each contact has: name, type (customer/supplier/both), currency if FX
+
+### Phase 2: Conversion Transactions
+
+#### 2.1 Conversion Invoices (AR)
+For each line in the AR Aging report:
+
+```
+POST /api/v1/invoices
+{
+  "contactResourceId": "<customer resource ID>",
+  "reference": "CONV-INV-<sequence>",
+  "valueDate": "<original invoice date or FYE date>",
+  "dueDate": "<original due date or FYE date>",
+  "currency": {                                       // ONLY if FX
+    "sourceCurrency": "<invoice currency>",
+    "exchangeRate": <FYE closing rate>                // explicit — ensures zero UGL
+  },
+  "lineItems": [{
+    "name": "Conversion balance — <original invoice ref>",
+    "quantity": 1,
+    "unitPrice": <outstanding amount in source currency>,
+    "accountResourceId": "<AR Conversion Clearing account ID>",
+    "taxProfileResourceId": "<exempt tax profile ID>"
+  }]
+}
+```
+
+**Effect:** DR Accounts Receivable, CR AR Conversion Clearing
+
+**Dates:** Use original dates from the aging report (preserves aging schedules). Fall back to FYE date if not available.
+
+**FX invoices:** Use `currency: { sourceCurrency: "USD", exchangeRate: 1.35 }` (object form with explicit FYE rate). The `exchangeRate` field overrides Jaz's auto-fetch, ensuring zero UGL on day 1. See "FX Invoices/Bills — Dates vs. Rates" in Edge Cases below.
+
+#### 2.2 Conversion Bills (AP)
+For each line in the AP Aging report:
+
+```
+POST /api/v1/bills
+{
+  "contactResourceId": "<supplier resource ID>",
+  "reference": "CONV-BILL-<sequence>",
+  "valueDate": "<original bill date or FYE date>",
+  "dueDate": "<original due date or FYE date>",
+  "currency": {                                       // ONLY if FX
+    "sourceCurrency": "<bill currency>",
+    "exchangeRate": <FYE closing rate>
+  },
+  "lineItems": [{
+    "name": "Conversion balance — <original bill ref>",
+    "quantity": 1,
+    "unitPrice": <outstanding amount in source currency>,
+    "accountResourceId": "<AP Conversion Clearing account ID>",
+    "taxProfileResourceId": "<exempt tax profile ID>"
+  }]
+}
+```
+
+**Effect:** DR AP Conversion Clearing, CR Accounts Payable
+
+### Phase 3: Transfer Trial Balance (TTB)
+
+Create a single journal entry that transfers ALL balances from the source TB, with special handling for AR and AP:
+
+```
+POST /api/v1/journals
+{
+  "reference": "TTB-CONVERSION",
+  "valueDate": "<FYE date>",
+  "journalEntries": [
+    // For each account in the TB (except AR and AP):
+    { "accountResourceId": "<account ID>", "amount": <balance>, "type": "DEBIT" },
+    { "accountResourceId": "<account ID>", "amount": <balance>, "type": "CREDIT" },
+
+    // For AR: debit to AR Conversion Clearing (NOT to Accounts Receivable)
+    { "accountResourceId": "<AR Clearing ID>", "amount": <AR balance>, "type": "DEBIT" },
+
+    // For AP: credit to AP Conversion Clearing (NOT to Accounts Payable)
+    { "accountResourceId": "<AP Clearing ID>", "amount": <AP balance>, "type": "CREDIT" }
+  ]
+}
+```
+
+**Why AR/AP are different:** The conversion invoices (Phase 2) already created the AR/AP balances. If the TTB also put balances into AR/AP, they'd be doubled. Instead, the TTB debits/credits the clearing accounts, which nets them to zero.
+
+**The clearing accounts MUST net to zero after the TTB.** If they don't:
+- AR Clearing balance ≠ 0 → the AR aging total doesn't match the TB's AR balance
+- AP Clearing balance ≠ 0 → the AP aging total doesn't match the TB's AP balance
+
+### Phase 4: Lock & Verify
+
+#### 4.1 Lock Date
+Set the accounting lock date to the FYE date to prevent accidental edits to the converted data.
+
+#### 4.2 Verify
+Pull the Trial Balance from Jaz at the FYE date. Compare against the source TB.
+See `verification.md` for the full checklist format.
+
+## Edge Cases
+
+### FX Invoices/Bills — Dates vs. Rates (Critical)
+
+Quick conversion transfers **open** (unpaid) FX invoices/bills from the prior platform. These must be handled carefully to avoid unrealized gain/loss (UGL) variances:
+
+**The problem:** The prior platform already computed UGL up to the FYE date. That UGL is captured in the TTB journal (Phase 3) as part of the Unrealized FX Gain/Loss account balance. If we record conversion invoices at a different rate, Jaz would compute its own UGL — doubling up.
+
+**The solution:** Record FX conversion invoices/bills with:
+- **Original dates** (valueDate + dueDate from the aging report) — so aging schedules are correct
+- **Explicit FYE exchange rate** — so Jaz sees zero UGL on day 1
+
+```
+POST /api/v1/invoices
+{
+  "valueDate": "<original invoice date>",     // preserves aging schedule
+  "dueDate": "<original due date>",           // preserves aging buckets
+  "currency": {
+    "sourceCurrency": "USD",
+    "exchangeRate": 1.35                      // explicit FYE rate — overrides auto-fetch
+  },
+  ...
+}
+```
+
+**Why this works:**
+1. FYE rate = transferred transaction rate → zero UGL in Jaz on day 1
+2. Prior platform's UGL is already in the TTB journal (Unrealized FX Gain/Loss account)
+3. When a future payment is recorded against the conversion invoice, Jaz computes RGL against the FYE rate only — which is correct, because the balance was already marked-to-market at FYE
+4. Original dates on the invoices preserve correct aging bucket positions (30/60/90/120+ days)
+
+**When dates aren't available:** Some aging reports only show contact name + amount (no individual dates). In this case, fall back to FYE date for both valueDate and dueDate. Aging schedules will be flat ("current") but FX handling remains correct.
+
+**Rate source:** FYE rates come from the exchange rates file (e.g., MAS closing rates). They're set on the org in Phase 1 via `POST /organization-currencies/:code/rates` and also passed explicitly on each FX transaction to guarantee the rate is used regardless of valueDate.
+
+### Partially Paid Invoices in AR Aging
+The AR Aging shows only the **outstanding** balance. Create the conversion invoice for the outstanding amount only — the historical payments are not relevant for Quick Conversion.
+
+### Negative Balances in AR/AP Aging
+A negative AR balance = customer overpayment (credit balance). Create as a customer credit note, not a negative invoice.
+A negative AP balance = supplier overpayment. Create as a supplier credit note.
+
+### Multiple Invoices Per Customer
+The AR Aging may show multiple outstanding invoices per customer. Create separate conversion invoices for each — they may need to be paid separately later.
+
+### Rounding
+Always use the exact amounts from the source. If the source TB has $1,234.57, the TTB journal must use $1,234.57. Rounding errors of even $0.01 will cause TB mismatch.

package/assets/skills/conversion/references/verification.md

@@ -0,0 +1,142 @@
+# Verification — TB Comparison and Checklist Generation
+
+## Post-Execution Verification Flow
+
+After all conversion transactions are created, verify accuracy by comparing the Trial Balance on Jaz against the source TB.
+
+### Step 1: Pull Jaz Trial Balance
+
+```
+GET /api/v1/reports/trial-balance?asOnDate=<FYE date>
+```
+
+This returns all account balances as at the specified date.
+
+### Step 2: Parse Source Trial Balance
+
+From the parsed input files, extract the source TB with:
+- Account code
+- Account name
+- Debit balance (or positive amount)
+- Credit balance (or negative amount)
+
+### Step 3: Compare
+
+For each account, compare:
+```
+Difference = Jaz balance - Source balance
+```
+
+**Tolerance:** $0.00 — there should be NO difference. Even $0.01 must be investigated and resolved.
+
+### Step 4: Categorize Differences
+
+| Category | Likely Cause | Fix |
+|----------|-------------|-----|
+| **Missing account** | Account exists in source but not in Jaz | Create the account + journal entry for the balance |
+| **Extra account** | Account in Jaz but not in source | Check if it's a system account (ignore) or a mapping error |
+| **Amount mismatch ≤ $1** | FX rounding | Small adjustment journal with note |
+| **Amount mismatch > $1** | Missing or extra transaction | Investigate GL detail, find the discrepancy |
+| **AR/AP mismatch** | Clearing account didn't net to zero | Check conversion invoices/bills vs TTB |
+| **Sign reversal** | Debit/credit direction wrong | Reverse the journal entry or void and recreate |
+
+### Step 5: Fix and Re-Verify
+
+After each fix:
+1. Pull Jaz TB again
+2. Compare again
+3. Repeat until all differences are resolved
+
+## Verification Checklist Format
+
+Generate a checklist in this format for customer sign-off:
+
+```
+CONVERSION CHECKLIST
+====================
+Client:     <Company Name>
+Source:      <Source System (e.g., Xero, QuickBooks)>
+Type:        <Quick Conversion / Full Conversion>
+FYE Date:    <e.g., 2023-12-31>
+Converted:   <e.g., 2026-02-14>
+Converted By: <name>
+
+TRIAL BALANCE COMPARISON (as at <FYE date>)
+--------------------------------------------
+                            Source          Jaz             Diff
+Total Assets                $XXX,XXX.XX     $XXX,XXX.XX     $0.00
+Total Liabilities           $XXX,XXX.XX     $XXX,XXX.XX     $0.00
+Total Equity                $XXX,XXX.XX     $XXX,XXX.XX     $0.00
+Total Revenue               $XXX,XXX.XX     $XXX,XXX.XX     $0.00
+Total Expenses              $XXX,XXX.XX     $XXX,XXX.XX     $0.00
+--------------------------------------------
+Net Balance                 $0.00           $0.00           $0.00
+
+AR / AP VERIFICATION
+--------------------------------------------
+Open Receivables            $XXX,XXX.XX     $XXX,XXX.XX     $0.00
+Open Payables               $XXX,XXX.XX     $XXX,XXX.XX     $0.00
+AR Clearing Balance                         $0.00
+AP Clearing Balance                         $0.00
+
+ENTITIES CREATED
+--------------------------------------------
+Chart of Accounts           XX
+Contacts                    XX
+Tax Profiles (mapped)       XX
+Currencies Enabled          XX
+Conversion Invoices (AR)    XX
+Conversion Bills (AP)       XX
+TTB Journal                 1
+Lock Date Set               <FYE date>
+
+FX RATES APPLIED
+--------------------------------------------
+USD                         1.3500
+EUR                         1.4500
+JPY                         0.0092
+
+NOTES
+--------------------------------------------
+- <Any adjustments made, rounding notes, special handling>
+- <Any known limitations or follow-up items>
+
+Verified by: _______________     Date: _______________
+Approved by: _______________     Date: _______________
+```
+
+## Detailed Account-Level Comparison
+
+For complex conversions, also generate a per-account comparison:
+
+```
+ACCOUNT-LEVEL COMPARISON (as at <FYE date>)
+--------------------------------------------
+Code    Account Name                Source      Jaz         Diff
+1000    Cash at Bank (SGD)          $50,000     $50,000     $0
+1001    USD Bank Account            $10,000     $10,000     $0
+1100    Accounts Receivable         $25,000     $25,000     $0
+1200    Prepaid Expenses            $3,000      $3,000      $0
+1299    AR Conversion Clearing      -           $0          $0
+...
+```
+
+This is the definitive proof that the conversion is accurate. Every account must match.
+
+## Quick Conversion Specific Checks
+
+1. **Clearing accounts net to zero** — both AR and AP clearing
+2. **Open AR on Jaz = AR Aging from source** — check total and per-customer
+3. **Open AP on Jaz = AP Aging from source** — check total and per-supplier
+4. **TB on Jaz = TB from source** — every account
+5. **Lock date is set** — prevents accidental edits to historical data
+6. **FX rates match** — Jaz closing rates = source closing rates at FYE
+
+## Full Conversion Specific Checks
+
+All Quick checks plus:
+1. **TB matches at multiple dates** — not just FYE, also mid-period spot checks
+2. **Invoice count matches** — total invoices created = total in source
+3. **Payment count matches** — total payments applied = total in source
+4. **GL detail spot check** — pick 5-10 random transactions, verify amounts and accounts
+5. **Bank reconciliation** — bank records imported match bank statement

package/dist/commands/init.js

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import prompts from 'prompts';
+import { SKILL_DESCRIPTIONS } from '../types/index.js';
+import { installSkills } from '../utils/template.js';
+import { logger } from '../utils/logger.js';
+export async function initCommand(options) {
+    logger.title('Jaz AI — Skill Installer');
+    let skillType = options.skill ?? 'all';
+    // Prompt for skill selection if not specified
+    if (!options.skill) {
+        const response = await prompts({
+            type: 'select',
+            name: 'skill',
+            message: 'Which skills do you want to install?',
+            choices: [
+                {
+                    title: `Both (Recommended)`,
+                    description: 'API reference + data conversion',
+                    value: 'all',
+                },
+                {
+                    title: 'API only',
+                    description: SKILL_DESCRIPTIONS.api,
+                    value: 'api',
+                },
+                {
+                    title: 'Conversion only',
+                    description: SKILL_DESCRIPTIONS.conversion,
+                    value: 'conversion',
+                },
+            ],
+            initial: 0,
+        });
+        if (!response.skill) {
+            logger.warn('Installation cancelled');
+            return;
+        }
+        skillType = response.skill;
+    }
+    const skillLabel = skillType === 'all'
+        ? 'api + conversion'
+        : skillType;
+    logger.info(`Installing: ${chalk.cyan(skillLabel)}`);
+    const spinner = ora('Installing skill files...').start();
+    const cwd = process.cwd();
+    try {
+        spinner.text = 'Copying skill files...';
+        const installedPaths = await installSkills(cwd, skillType, options.force ?? false);
+        spinner.succeed('Skills installed!');
+        console.log();
+        logger.info('Installed:');
+        installedPaths.forEach((folder) => {
+            console.log(`  ${chalk.green('+')} ${folder}/`);
+        });
+        console.log();
+        logger.success('Jaz AI skills installed successfully!');
+        console.log();
+        console.log(chalk.bold('Next steps:'));
+        console.log(chalk.dim('  1. Restart Claude Code'));
+        console.log(chalk.dim('  2. Try: "Create an invoice with line items and tax"'));
+        if (skillType === 'all' || skillType === 'conversion') {
+            console.log(chalk.dim('  3. Try: "Convert this Xero trial balance to Jaz"'));
+        }
+        console.log();
+        console.log(chalk.dim(`  Docs: ${chalk.underline('https://help.jaz.ai')}`));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail('Installation failed');
+        if (error instanceof Error) {
+            logger.error(error.message);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/update.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { installSkills } from '../utils/template.js';
+import { logger } from '../utils/logger.js';
+export async function updateCommand(options) {
+    logger.title('Jaz AI — Update Skills');
+    const skillType = options.skill ?? 'all';
+    const spinner = ora('Updating skill files...').start();
+    try {
+        const installedPaths = await installSkills(process.cwd(), skillType, true);
+        spinner.succeed('Skills updated!');
+        console.log();
+        logger.info('Updated:');
+        installedPaths.forEach((folder) => {
+            console.log(`  ${chalk.green('+')} ${folder}/`);
+        });
+        console.log();
+        logger.success('Restart Claude Code to pick up changes.');
+        console.log();
+    }
+    catch (error) {
+        spinner.fail('Update failed');
+        if (error instanceof Error) {
+            logger.error(error.message);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/versions.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { logger } from '../utils/logger.js';
+import { fetchReleases, GitHubRateLimitError } from '../utils/github.js';
+export async function versionsCommand() {
+    logger.title('Jaz AI — Available Versions');
+    const spinner = ora('Fetching versions from GitHub...').start();
+    try {
+        const releases = await fetchReleases();
+        if (releases.length === 0) {
+            spinner.warn('No releases found');
+            return;
+        }
+        spinner.succeed(`Found ${releases.length} version(s)`);
+        console.log();
+        releases.forEach((release, i) => {
+            const tag = release.tag_name;
+            const date = new Date(release.published_at).toLocaleDateString();
+            const label = i === 0 ? chalk.green(' (latest)') : '';
+            console.log(`  ${chalk.cyan(tag)}${label}  ${chalk.dim(date)}`);
+        });
+        console.log();
+    }
+    catch (error) {
+        if (error instanceof GitHubRateLimitError) {
+            spinner.fail('GitHub rate limit reached. Try again later.');
+        }
+        else if (error instanceof Error) {
+            spinner.fail(`Failed to fetch versions: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { initCommand } from './commands/init.js';
+import { versionsCommand } from './commands/versions.js';
+import { updateCommand } from './commands/update.js';
+import { SKILL_TYPES } from './types/index.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const program = new Command();
+program
+    .name('jaz')
+    .description('CLI to install Jaz AI skills for Claude Code')
+    .version(pkg.version);
+program
+    .command('init')
+    .description('Install Jaz AI skills into the current project')
+    .option('-s, --skill <type>', `Skill to install (${SKILL_TYPES.join(', ')})`)
+    .option('-f, --force', 'Overwrite existing files')
+    .action(async (options) => {
+    if (options.skill && !SKILL_TYPES.includes(options.skill)) {
+        console.error(`Invalid skill type: ${options.skill}`);
+        console.error(`Valid types: ${SKILL_TYPES.join(', ')}`);
+        process.exit(1);
+    }
+    await initCommand({
+        skill: options.skill,
+        force: options.force,
+    });
+});
+program
+    .command('versions')
+    .description('List available versions')
+    .action(versionsCommand);
+program
+    .command('update')
+    .description('Update Jaz AI skills to latest version')
+    .option('-s, --skill <type>', `Skill to update (${SKILL_TYPES.join(', ')})`)
+    .action(async (options) => {
+    if (options.skill && !SKILL_TYPES.includes(options.skill)) {
+        console.error(`Invalid skill type: ${options.skill}`);
+        console.error(`Valid types: ${SKILL_TYPES.join(', ')}`);
+        process.exit(1);
+    }
+    await updateCommand({
+        skill: options.skill,
+    });
+});
+program.parse();

package/dist/types/index.js

@@ -0,0 +1,5 @@
+export const SKILL_TYPES = ['api', 'conversion', 'all'];
+export const SKILL_DESCRIPTIONS = {
+    api: 'Jaz/Juan REST API reference — 55 rules, endpoint catalog, error catalog, field mapping',
+    conversion: 'Data conversion pipeline — Xero, QuickBooks, Sage, Excel migration to Jaz',
+};