kvitton-cli 0.4.2 → 0.4.5

package/dist/commands/sync-inbox.js

@@ -1,186 +0,0 @@
-import ora from "ora";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { toYaml, sanitizeOrgName } from "sync";
-import { loadConfig } from "../lib/env";
-import { createBokioClient } from "../lib/client";
-/**
- * Slugify text for terminal-friendly filenames
- */
-function slugify(text, maxLength = 30) {
-    return text
-        .toLowerCase()
-        .slice(0, maxLength)
-        .replace(/[^a-z0-9\s-]/g, "")
-        .replace(/\s+/g, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-|-$/g, "");
-}
-export async function syncInboxCommand() {
-    const cwd = process.cwd();
-    // Load config
-    const spinner = ora("Loading configuration...").start();
-    let config;
-    try {
-        config = loadConfig(cwd);
-        spinner.succeed(`Provider: ${config.provider}`);
-    }
-    catch (error) {
-        spinner.fail(error instanceof Error ? error.message : "Unknown error");
-        process.exit(1);
-    }
-    // Create client
-    const client = createBokioClient(config);
-    // Validate connection
-    const validateSpinner = ora("Connecting to Bokio...").start();
-    try {
-        const companyInfo = await client.getCompanyInformation();
-        validateSpinner.succeed(`Connected to: ${companyInfo.name}`);
-    }
-    catch (error) {
-        validateSpinner.fail("Failed to connect to Bokio");
-        console.error(error instanceof Error ? error.message : "Unknown error");
-        process.exit(1);
-    }
-    // Fetch uploads
-    const fetchSpinner = ora("Fetching inbox...").start();
-    const allUploads = [];
-    let page = 1;
-    const pageSize = 100;
-    while (true) {
-        const response = await client.getUploads({ page, pageSize });
-        allUploads.push(...response.data);
-        if (!response.pagination.hasNextPage)
-            break;
-        page++;
-    }
-    // Filter to unprocessed items (not linked to journal entry)
-    const unprocessedUploads = allUploads.filter((upload) => !upload.journalEntryId);
-    fetchSpinner.succeed(`Found ${unprocessedUploads.length} unprocessed inbox items (${allUploads.length} total)`);
-    if (unprocessedUploads.length === 0) {
-        console.log("\n  No new inbox items to download.\n");
-        return;
-    }
-    // Ensure inbox directory exists
-    const inboxDir = path.join(cwd, "inbox");
-    await fs.mkdir(inboxDir, { recursive: true });
-    // Download each unprocessed upload
-    let newCount = 0;
-    let existingCount = 0;
-    const today = new Date().toISOString().slice(0, 10);
-    // Track used directory names to handle duplicates
-    const usedDirNames = new Set();
-    // First, scan existing directories to avoid duplicates
-    try {
-        const existingDirs = await fs.readdir(inboxDir);
-        for (const dir of existingDirs) {
-            usedDirNames.add(dir);
-        }
-    }
-    catch {
-        // Inbox directory doesn't exist yet
-    }
-    for (const upload of unprocessedUploads) {
-        // Generate directory name: {date}-{description-slugified}
-        const slug = upload.description
-            ? slugify(upload.description)
-            : upload.id.slice(0, 8);
-        let dirName = `${today}-${slug}`;
-        // Check if this upload was already downloaded (by sourceId in existing document.yaml files)
-        const alreadyDownloaded = await isAlreadyDownloaded(inboxDir, upload.id);
-        if (alreadyDownloaded) {
-            existingCount++;
-            continue;
-        }
-        // Handle duplicate directory names by appending short ID
-        if (usedDirNames.has(dirName)) {
-            dirName = `${dirName}-${upload.id.slice(0, 8)}`;
-        }
-        usedDirNames.add(dirName);
-        const uploadDir = path.join(inboxDir, dirName);
-        process.stdout.write(`\r  Downloading: ${newCount + existingCount + 1}/${unprocessedUploads.length}`);
-        try {
-            // Create upload directory
-            await fs.mkdir(uploadDir, { recursive: true });
-            // Download file
-            const result = await client.downloadFile(upload.id);
-            // Determine file extension from content type
-            const ext = getExtensionFromContentType(upload.contentType || result.contentType);
-            // Generate filename: {description-slugified}.ext or document.ext
-            const filename = upload.description
-                ? `${slugify(upload.description)}${ext}`
-                : `document${ext}`;
-            // Save file
-            const filePath = path.join(uploadDir, filename);
-            const buffer = Buffer.from(result.data);
-            await fs.writeFile(filePath, buffer);
-            // Write document.yaml (ExportedInboxDocument format)
-            const document = {
-                kind: "OTHER",
-                status: "DRAFT",
-                fileName: filename,
-                mimeType: upload.contentType,
-                description: upload.description ?? undefined,
-                sourceIntegration: "bokio",
-                sourceId: upload.id,
-                uploadedAt: new Date().toISOString(),
-            };
-            const documentPath = path.join(uploadDir, "document.yaml");
-            await fs.writeFile(documentPath, toYaml(document));
-            newCount++;
-        }
-        catch (error) {
-            console.error(`\n  Failed to download ${upload.id}: ${error instanceof Error ? error.message : "Unknown error"}`);
-            // Clean up failed directory
-            try {
-                await fs.rm(uploadDir, { recursive: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    console.log(`\n
-  Sync complete!
-    - ${newCount} new inbox items downloaded
-    - ${existingCount} already existed
-`);
-}
-function getExtensionFromContentType(contentType) {
-    const map = {
-        "application/pdf": ".pdf",
-        "image/jpeg": ".jpg",
-        "image/png": ".png",
-        "image/gif": ".gif",
-        "image/webp": ".webp",
-        "image/tiff": ".tiff",
-        "application/octet-stream": ".bin",
-    };
-    return map[contentType] || ".bin";
-}
-/**
- * Check if an upload was already downloaded by scanning existing document.yaml files
- */
-async function isAlreadyDownloaded(inboxDir, sourceId) {
-    try {
-        const dirs = await fs.readdir(inboxDir, { withFileTypes: true });
-        for (const dir of dirs) {
-            if (!dir.isDirectory())
-                continue;
-            const documentPath = path.join(inboxDir, dir.name, "document.yaml");
-            try {
-                const content = await fs.readFile(documentPath, "utf-8");
-                if (content.includes(`sourceId: ${sourceId}`)) {
-                    return true;
-                }
-            }
-            catch {
-                // document.yaml doesn't exist or can't be read, skip
-            }
-        }
-    }
-    catch {
-        // Inbox directory doesn't exist
-    }
-    return false;
-}

package/dist/commands/sync-journal.js

@@ -1,490 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import ora from "ora";
-import { FilesystemStorageService, mapBokioEntryToJournalEntry, mapJournalEntryToBokioRequest, journalEntryPath, journalEntryDirFromPath, toYaml, parseYaml, fiscalYearDirName, downloadFilesForEntry, } from "sync";
-import { loadConfig } from "../lib/env";
-import { createBokioClient } from "../lib/client";
-/** File extensions that should be uploaded as documents */
-const UPLOADABLE_EXTENSIONS = [".pdf", ".png", ".jpg", ".jpeg"];
-/** Map file extensions to MIME types */
-const MIME_TYPES = {
-    ".pdf": "application/pdf",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-};
-export async function syncJournalCommand(options) {
-    const cwd = process.cwd();
-    // Load config
-    const spinner = ora("Loading configuration...").start();
-    let config;
-    try {
-        config = loadConfig(cwd);
-        spinner.succeed(`Provider: ${config.provider}`);
-    }
-    catch (error) {
-        spinner.fail(error instanceof Error ? error.message : "Unknown error");
-        process.exit(1);
-    }
-    // Create client
-    const client = createBokioClient(config);
-    // Validate connection
-    const validateSpinner = ora("Connecting to Bokio...").start();
-    try {
-        const companyInfo = await client.getCompanyInformation();
-        validateSpinner.succeed(`Connected to: ${companyInfo.name}`);
-    }
-    catch (error) {
-        validateSpinner.fail("Failed to connect to Bokio");
-        console.error(error instanceof Error ? error.message : "Unknown error");
-        process.exit(1);
-    }
-    // Determine which fiscal year(s) to sync
-    const targetYear = options.year
-        ? parseInt(options.year, 10)
-        : options.all
-            ? undefined
-            : new Date().getFullYear();
-    const yearLabel = targetYear ? `FY ${targetYear}` : "all years";
-    console.log(`  Syncing ${yearLabel}...\n`);
-    // Storage for file operations
-    const storage = new FilesystemStorageService(cwd);
-    // Sync chart of accounts first
-    const accountsSpinner = ora("Syncing chart of accounts...").start();
-    const accountsCount = await syncChartOfAccounts(client, storage);
-    accountsSpinner.succeed(`Synced ${accountsCount} accounts`);
-    // Sync journal entries
-    const shouldDownloadFiles = options.downloadFiles !== false;
-    const result = await syncJournalEntries(client, cwd, targetYear, shouldDownloadFiles, (progress) => {
-        process.stdout.write(`\r  Syncing: ${progress.current}/${progress.total} entries`);
-    });
-    const filesDownloadedLine = result.entriesWithFilesDownloaded > 0
-        ? `\n    - Downloaded files for ${result.entriesWithFilesDownloaded}/${result.totalEntries} entries`
-        : "";
-    console.log(`\n
-  Sync complete! (${yearLabel})
-    - ${accountsCount} accounts
-    - ${result.fiscalYearsCount} fiscal year(s)
-    - Downloaded: ${result.totalEntries} entries (${result.newEntries} new, ${result.existingEntries} existing)
-    - Uploaded: ${result.uploadedEntries} local entries${filesDownloadedLine}
-`);
-}
-/**
- * Create a FileDownloader adapter for BokioClient
- */
-function createBokioDownloader(client) {
-    return {
-        async getFilesForEntry(journalEntryId) {
-            // Bokio API requires query format: journalEntryId==UUID
-            const response = await client.getUploads({
-                query: `journalEntryId==${journalEntryId}`,
-            });
-            return response.data.map((upload) => ({
-                id: upload.id,
-                contentType: upload.contentType,
-                description: upload.description ?? undefined,
-            }));
-        },
-        async downloadFile(id) {
-            return client.downloadFile(id);
-        },
-    };
-}
-async function syncJournalEntries(client, repoPath, targetYear, downloadFiles, onProgress) {
-    const storage = new FilesystemStorageService(repoPath);
-    // 1. Fetch fiscal years
-    const fiscalYearsResponse = await client.getFiscalYears();
-    const allFiscalYears = fiscalYearsResponse.data;
-    // Filter fiscal years if targeting a specific year
-    const fiscalYears = targetYear
-        ? allFiscalYears.filter((fy) => parseInt(fy.startDate.slice(0, 4), 10) === targetYear)
-        : allFiscalYears;
-    if (targetYear && fiscalYears.length === 0) {
-        console.log(`  No fiscal year found for ${targetYear}`);
-        return {
-            totalEntries: 0,
-            newEntries: 0,
-            existingEntries: 0,
-            uploadedEntries: 0,
-            fiscalYearsCount: 0,
-            entriesWithFilesDownloaded: 0,
-        };
-    }
-    // 2. Fetch all entries with pagination
-    const allEntries = [];
-    let page = 1;
-    const pageSize = 100;
-    // First fetch to get total count
-    const firstPage = await client.getJournalEntries({ page: 1, pageSize: 1 });
-    const totalFromApi = firstPage.pagination.totalItems;
-    onProgress({ current: 0, total: totalFromApi });
-    if (totalFromApi === 0) {
-        await writeFiscalYearsMetadata(storage, fiscalYears);
-        // Even with no entries from API, we might have local entries to upload
-        const uploadedEntries = await uploadLocalEntries(client, storage, repoPath, fiscalYears);
-        return {
-            totalEntries: 0,
-            newEntries: 0,
-            existingEntries: 0,
-            uploadedEntries,
-            fiscalYearsCount: fiscalYears.length,
-            entriesWithFilesDownloaded: 0,
-        };
-    }
-    // Fetch all entries
-    while (true) {
-        const response = await client.getJournalEntries({ page, pageSize });
-        allEntries.push(...response.data);
-        onProgress({ current: allEntries.length, total: totalFromApi });
-        if (!response.pagination.hasNextPage)
-            break;
-        page++;
-    }
-    // 3. Filter entries by target fiscal year(s)
-    const entriesToSync = targetYear
-        ? allEntries.filter((entry) => {
-            const fy = findFiscalYear(entry.date, fiscalYears);
-            return fy !== undefined;
-        })
-        : allEntries;
-    // 4. Write each entry, tracking new vs existing, and download files
-    let newEntries = 0;
-    let existingEntries = 0;
-    let entriesWithFilesDownloaded = 0;
-    const downloader = createBokioDownloader(client);
-    for (const entry of entriesToSync) {
-        const fiscalYear = findFiscalYear(entry.date, allFiscalYears);
-        if (!fiscalYear)
-            continue;
-        const fyYear = parseInt(fiscalYear.startDate.slice(0, 4), 10);
-        const result = await writeJournalEntry(storage, fyYear, entry);
-        if (result.isNew) {
-            newEntries++;
-        }
-        else {
-            existingEntries++;
-        }
-        // Download files for this entry if enabled
-        if (downloadFiles && result.entryDir) {
-            const filesDownloaded = await downloadFilesForEntry({
-                storage,
-                repoPath,
-                entryDir: result.entryDir,
-                journalEntryId: entry.id,
-                downloader,
-                sourceIntegration: "bokio",
-            });
-            if (filesDownloaded > 0) {
-                entriesWithFilesDownloaded++;
-            }
-        }
-    }
-    // 5. Write fiscal year metadata
-    await writeFiscalYearsMetadata(storage, fiscalYears);
-    // 6. Upload local entries without externalId to Bokio
-    const uploadedEntries = await uploadLocalEntries(client, storage, repoPath, fiscalYears);
-    return {
-        totalEntries: entriesToSync.length,
-        newEntries,
-        existingEntries,
-        uploadedEntries,
-        fiscalYearsCount: fiscalYears.length,
-        entriesWithFilesDownloaded,
-    };
-}
-function findFiscalYear(date, fiscalYears) {
-    return fiscalYears.find((fy) => date >= fy.startDate && date <= fy.endDate);
-}
-async function writeJournalEntry(storage, fyYear, entry) {
-    const journalEntry = mapBokioEntryToJournalEntry({
-        id: entry.id,
-        journalEntryNumber: entry.journalEntryNumber,
-        date: entry.date,
-        title: entry.title,
-        items: entry.items.map((item) => ({
-            account: item.account,
-            debit: item.debit,
-            credit: item.credit,
-        })),
-    });
-    const entryPath = journalEntryPath(fyYear, journalEntry.series ?? null, journalEntry.entryNumber, journalEntry.entryDate, journalEntry.description);
-    const entryDir = journalEntryDirFromPath(entryPath);
-    // Check if entry already exists
-    const exists = await storage.exists(entryPath);
-    if (exists) {
-        return { isNew: false, entryDir };
-    }
-    const yamlContent = toYaml(journalEntry);
-    await storage.writeFile(entryPath, yamlContent);
-    return { isNew: true, entryDir };
-}
-async function writeFiscalYearsMetadata(storage, fiscalYears) {
-    for (const fy of fiscalYears) {
-        const fyDir = fiscalYearDirName({ start_date: fy.startDate });
-        const metadataPath = `journal-entries/${fyDir}/_fiscal-year.yaml`;
-        const metadata = {
-            id: fy.id,
-            startDate: fy.startDate,
-            endDate: fy.endDate,
-            status: fy.status,
-        };
-        const yamlContent = toYaml(metadata);
-        await storage.writeFile(metadataPath, yamlContent);
-    }
-}
-/**
- * Parse journal entry number from Bokio (e.g., "A123" -> { series: "A", entryNumber: 123 })
- */
-function parseJournalEntryNumber(journalEntryNumber) {
-    const numberMatch = journalEntryNumber.match(/\d+/);
-    const entryNumber = numberMatch ? parseInt(numberMatch[0], 10) : 0;
-    const series = journalEntryNumber.replace(/\d+/g, "") || undefined;
-    return {
-        series: series,
-        entryNumber,
-    };
-}
-/**
- * List local entries without externalId (not yet synced to provider)
- */
-async function listLocalEntriesWithoutExternalId(storage, fiscalYears) {
-    const result = [];
-    for (const fy of fiscalYears) {
-        const fyYear = parseInt(fy.startDate.slice(0, 4), 10);
-        const fyDir = `journal-entries/FY-${fyYear}`;
-        try {
-            const directories = await storage.listDirectory(fyDir);
-            for (const dir of directories) {
-                if (dir.type !== "dir" || dir.name.startsWith("_")) {
-                    continue;
-                }
-                const entryPath = `${dir.path}/entry.yaml`;
-                try {
-                    const { content } = await storage.readFile(entryPath);
-                    const entry = parseYaml(content);
-                    // Only include entries without externalId
-                    if (!entry.externalId) {
-                        result.push({
-                            entry,
-                            directoryPath: dir.path,
-                            fiscalYear: fy,
-                        });
-                    }
-                }
-                catch {
-                    // Skip entries that can't be read
-                }
-            }
-        }
-        catch {
-            // Fiscal year directory doesn't exist yet
-        }
-    }
-    return result;
-}
-/**
- * Upload local entries without externalId to Bokio
- */
-async function uploadLocalEntries(client, storage, repoPath, fiscalYears) {
-    const localEntries = await listLocalEntriesWithoutExternalId(storage, fiscalYears);
-    let uploadedCount = 0;
-    for (const { entry, directoryPath, fiscalYear } of localEntries) {
-        try {
-            // Upload to Bokio
-            const request = mapJournalEntryToBokioRequest(entry);
-            const bokioEntry = await client.createJournalEntry(request);
-            // Parse series and number from response
-            const parsed = parseJournalEntryNumber(bokioEntry.journalEntryNumber);
-            // Upload any document files in the directory
-            await uploadDocumentsForEntry(client, storage, path.join(repoPath, directoryPath), directoryPath, bokioEntry.id);
-            // Update entry with Bokio metadata (remove legacy fields)
-            const updatedEntry = {
-                ...entry,
-                externalId: bokioEntry.id,
-                series: parsed.series,
-                entryNumber: parsed.entryNumber,
-                sourceIntegration: "bokio",
-                sourceSyncedAt: new Date().toISOString(),
-                // Remove legacy fields by setting to undefined
-                voucherNumber: undefined,
-                voucherSeriesCode: undefined,
-            };
-            // Calculate new directory path
-            const fyYear = parseInt(fiscalYear.startDate.slice(0, 4), 10);
-            const newEntryPath = journalEntryPath(fyYear, updatedEntry.series ?? null, updatedEntry.entryNumber, updatedEntry.entryDate, updatedEntry.description);
-            const newDirPath = journalEntryDirFromPath(newEntryPath);
-            // Write updated entry.yaml
-            const yamlContent = toYaml(updatedEntry);
-            await storage.writeFile(`${directoryPath}/entry.yaml`, yamlContent);
-            // Rename directory if path changed
-            if (directoryPath !== newDirPath) {
-                // Check if target directory already exists
-                const targetExists = await storage.exists(`${newDirPath}/entry.yaml`);
-                if (targetExists) {
-                    console.warn(`  Warning: Cannot rename ${directoryPath} -> ${newDirPath} (target exists)`);
-                }
-                else {
-                    await storage.renameDirectory(directoryPath, newDirPath);
-                }
-            }
-            uploadedCount++;
-            console.log(`  Uploaded: ${entry.description} -> ${bokioEntry.journalEntryNumber}`);
-        }
-        catch (error) {
-            console.error(`  Failed to upload entry: ${entry.description}`, error instanceof Error ? error.message : error);
-        }
-    }
-    // Also retry document uploads for entries that have externalId but failed document upload
-    const retriedDocs = await retryFailedDocumentUploads(client, storage, repoPath, fiscalYears);
-    return uploadedCount + retriedDocs;
-}
-/**
- * Upload documents for a journal entry and update document.yaml with sourceIntegration/sourceId
- */
-async function uploadDocumentsForEntry(client, storage, absoluteDirPath, relativeDirPath, journalEntryId) {
-    const files = await fs.readdir(absoluteDirPath);
-    for (const filename of files) {
-        const ext = path.extname(filename).toLowerCase();
-        if (!UPLOADABLE_EXTENSIONS.includes(ext)) {
-            continue;
-        }
-        // Check if already uploaded via document.yaml
-        const docYamlPath = `${relativeDirPath}/document.yaml`;
-        let docMetadata = {};
-        try {
-            const { content } = await storage.readFile(docYamlPath);
-            docMetadata = parseYaml(content);
-            if (docMetadata.sourceIntegration === "bokio" && docMetadata.sourceId) {
-                // Already uploaded to Bokio
-                continue;
-            }
-        }
-        catch {
-            // No document.yaml, proceed with upload
-        }
-        try {
-            const filePath = path.join(absoluteDirPath, filename);
-            let fileBuffer = await fs.readFile(filePath);
-            // Check if file is base64 encoded (stored as text, not binary)
-            // Base64 PDF starts with "JVBERi" (%PDF- encoded)
-            const firstBytes = fileBuffer.subarray(0, 10).toString("utf8");
-            if (firstBytes.startsWith("JVBERi") || firstBytes.match(/^[A-Za-z0-9+/=]+$/)) {
-                // Decode base64
-                const base64Content = fileBuffer.toString("utf8");
-                fileBuffer = Buffer.from(base64Content, "base64");
-            }
-            const mimeType = MIME_TYPES[ext] || "application/octet-stream";
-            const file = new File([fileBuffer], filename, { type: mimeType });
-            const upload = await client.uploadFile({
-                file,
-                filename,
-                journalEntryId,
-            });
-            // Update document.yaml with Bokio source info
-            const updatedDocMetadata = {
-                ...docMetadata,
-                sourceIntegration: "bokio",
-                sourceId: upload.id,
-            };
-            await storage.writeFile(docYamlPath, toYaml(updatedDocMetadata));
-            console.log(`    Uploaded file: ${filename}`);
-        }
-        catch (fileError) {
-            console.warn(`\n  Warning: Failed to upload ${filename}`);
-            if (fileError &&
-                typeof fileError === "object" &&
-                "statusCode" in fileError) {
-                const apiErr = fileError;
-                console.warn(`    Status: ${apiErr.statusCode}`);
-                if (apiErr.response) {
-                    console.warn(`    Response: ${JSON.stringify(apiErr.response)}`);
-                }
-                else if (apiErr.message) {
-                    console.warn(`    Message: ${apiErr.message}`);
-                }
-            }
-            else if (fileError instanceof Error) {
-                console.warn(`    Error: ${fileError.message}`);
-            }
-            else {
-                console.warn(`    Error: ${fileError}`);
-            }
-        }
-    }
-}
-/**
- * Retry document uploads for entries synced to Bokio but with documents not yet uploaded
- */
-async function retryFailedDocumentUploads(client, storage, repoPath, fiscalYears) {
-    let retriedCount = 0;
-    for (const fy of fiscalYears) {
-        const fyYear = parseInt(fy.startDate.slice(0, 4), 10);
-        const fyDir = `journal-entries/FY-${fyYear}`;
-        try {
-            const directories = await storage.listDirectory(fyDir);
-            for (const dir of directories) {
-                if (dir.type !== "dir" || dir.name.startsWith("_")) {
-                    continue;
-                }
-                const entryPath = `${dir.path}/entry.yaml`;
-                const docPath = `${dir.path}/document.yaml`;
-                try {
-                    // Check if entry has externalId (already synced to Bokio)
-                    const { content: entryContent } = await storage.readFile(entryPath);
-                    const entry = parseYaml(entryContent);
-                    if (!entry.externalId || entry.sourceIntegration !== "bokio") {
-                        continue; // Not synced to Bokio yet
-                    }
-                    // Check if document.yaml exists and needs upload
-                    try {
-                        const { content: docContent } = await storage.readFile(docPath);
-                        const docMetadata = parseYaml(docContent);
-                        if (docMetadata.sourceIntegration === "bokio" && docMetadata.sourceId) {
-                            continue; // Already uploaded to Bokio
-                        }
-                        // Has document.yaml but not uploaded to Bokio - retry upload
-                        console.log(`\n  Retrying document upload for: ${entry.description}`);
-                        await uploadDocumentsForEntry(client, storage, path.join(repoPath, dir.path), dir.path, entry.externalId);
-                        retriedCount++;
-                    }
-                    catch {
-                        // No document.yaml, check for files to upload
-                        const absoluteDirPath = path.join(repoPath, dir.path);
-                        const files = await fs.readdir(absoluteDirPath);
-                        const hasUploadableFiles = files.some((f) => UPLOADABLE_EXTENSIONS.includes(path.extname(f).toLowerCase()));
-                        if (hasUploadableFiles) {
-                            console.log(`\n  Uploading documents for: ${entry.description}`);
-                            await uploadDocumentsForEntry(client, storage, absoluteDirPath, dir.path, entry.externalId);
-                            retriedCount++;
-                        }
-                    }
-                }
-                catch {
-                    // Skip entries that can't be read
-                }
-            }
-        }
-        catch {
-            // Fiscal year directory doesn't exist
-        }
-    }
-    return retriedCount;
-}
-/**
- * Sync chart of accounts from Bokio to accounts.yaml
- */
-async function syncChartOfAccounts(client, storage) {
-    const bokioAccounts = await client.getChartOfAccounts();
-    // Sort by account number and transform to expected format
-    const accounts = [...bokioAccounts]
-        .sort((a, b) => a.account - b.account)
-        .map((account) => ({
-        code: account.account.toString(),
-        name: account.name,
-        description: account.name,
-    }));
-    // Write accounts.yaml
-    const yamlContent = toYaml({ accounts });
-    await storage.writeFile("accounts.yaml", yamlContent);
-    return accounts.length;
-}

package/dist/lib/client.js

@@ -1,10 +0,0 @@
-import { BokioClient } from "integrations-bokio";
-export function createBokioClient(config) {
-    if (config.provider !== "bokio" || !config.bokio) {
-        throw new Error("Bokio configuration not found");
-    }
-    return new BokioClient({
-        token: config.bokio.token,
-        companyId: config.bokio.companyId,
-    });
-}