create-kvitton 0.4.0

package/dist/index.js

@@ -0,0 +1,1283 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/create.ts
+import { select, input, password, confirm } from "@inquirer/prompts";
+import ora from "ora";
+import * as path5 from "node:path";
+import * as fs5 from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+// ../../integrations/bokio/dist/config.js
+var BOKIO_CONFIG = {
+  API_BASE_URL: "https://api.bokio.se",
+  API_VERSION: "v1",
+  RATE_LIMIT: {
+    MAX_REQUESTS: 200,
+    WINDOW_SECONDS: 60
+  }
+};
+// ../../integrations/bokio/dist/schemas.js
+import { z } from "zod";
+var BokioPaginationSchema = z.object({
+  totalItems: z.number(),
+  totalPages: z.number(),
+  currentPage: z.number()
+}).passthrough();
+var JournalEntryItemSchema = z.object({
+  id: z.number(),
+  debit: z.number(),
+  credit: z.number(),
+  account: z.number()
+}).passthrough();
+var JournalEntrySchema = z.object({
+  id: z.string().uuid(),
+  title: z.string(),
+  journalEntryNumber: z.string(),
+  date: z.string(),
+  items: z.array(JournalEntryItemSchema),
+  reversingJournalEntryId: z.string().uuid().nullable().optional(),
+  reversedByJournalEntryId: z.string().uuid().nullable().optional()
+}).passthrough();
+var JournalEntriesResponseSchema = z.object({
+  totalItems: z.number(),
+  totalPages: z.number(),
+  currentPage: z.number(),
+  items: z.array(JournalEntrySchema)
+}).passthrough();
+var BokioErrorSchema = z.object({
+  status: z.number(),
+  message: z.string(),
+  errorId: z.string().optional(),
+  errors: z.array(z.object({
+    field: z.string().optional(),
+    message: z.string()
+  })).optional()
+}).passthrough();
+var CompanyInfoSchema = z.object({
+  name: z.string(),
+  organizationNumber: z.string().nullable().optional(),
+  vatNumber: z.string().nullable().optional(),
+  address: z.object({
+    street: z.string().nullable().optional(),
+    zipCode: z.string().nullable().optional(),
+    city: z.string().nullable().optional(),
+    country: z.string().nullable().optional()
+  }).nullable().optional()
+}).passthrough();
+var UploadSchema = z.object({
+  id: z.string().uuid(),
+  description: z.string().nullable(),
+  contentType: z.string(),
+  journalEntryId: z.string().uuid().nullable().optional()
+}).passthrough();
+var UploadsResponseSchema = z.object({
+  totalItems: z.number(),
+  totalPages: z.number(),
+  currentPage: z.number(),
+  items: z.array(UploadSchema)
+}).passthrough();
+var CreateJournalEntryItemSchema = z.object({
+  debit: z.number(),
+  credit: z.number(),
+  account: z.number()
+});
+var CreateJournalEntryRequestSchema = z.object({
+  title: z.string(),
+  date: z.string(),
+  items: z.array(CreateJournalEntryItemSchema)
+});
+var FiscalYearSchema = z.object({
+  id: z.string().uuid(),
+  startDate: z.string(),
+  endDate: z.string(),
+  accountingMethod: z.enum(["cash", "accrual"]),
+  status: z.enum(["open", "closed"])
+}).passthrough();
+var FiscalYearsResponseSchema = z.object({
+  totalItems: z.number(),
+  totalPages: z.number(),
+  currentPage: z.number(),
+  items: z.array(FiscalYearSchema)
+}).passthrough();
+var AccountSchema = z.object({
+  account: z.number(),
+  name: z.string(),
+  accountType: z.enum(["basePlanAccount", "customAccount"])
+}).passthrough();
+var ChartOfAccountsResponseSchema = z.array(AccountSchema);
+// ../../integrations/core/dist/errors.js
+class IntegrationError extends Error {
+  code;
+  statusCode;
+  cause;
+  constructor(message, code, statusCode, cause) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.cause = cause;
+    this.name = "IntegrationError";
+  }
+}
+
+class AuthenticationError extends IntegrationError {
+  constructor(message, cause) {
+    super(message, "AUTHENTICATION_ERROR", 401, cause);
+    this.name = "AuthenticationError";
+  }
+}
+
+class TokenExpiredError extends IntegrationError {
+  constructor(message = "Access token has expired", cause) {
+    super(message, "TOKEN_EXPIRED", 401, cause);
+    this.name = "TokenExpiredError";
+  }
+}
+
+class RateLimitError extends IntegrationError {
+  retryAfterMs;
+  constructor(retryAfterMs, cause) {
+    super(retryAfterMs ? `Rate limit exceeded. Retry after ${retryAfterMs}ms` : "Rate limit exceeded", "RATE_LIMIT_EXCEEDED", 429, cause);
+    this.retryAfterMs = retryAfterMs;
+    this.name = "RateLimitError";
+  }
+}
+
+class ApiError extends IntegrationError {
+  response;
+  constructor(message, statusCode, response, cause) {
+    super(message, "API_ERROR", statusCode, cause);
+    this.response = response;
+    this.name = "ApiError";
+  }
+}
+
+class ValidationError extends IntegrationError {
+  zodError;
+  constructor(message, zodError) {
+    super(message, "VALIDATION_ERROR", 422);
+    this.zodError = zodError;
+    this.name = "ValidationError";
+  }
+  get issues() {
+    return this.zodError.issues;
+  }
+}
+// ../../integrations/core/dist/validation.js
+function validate(schema, data, context) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    console.error(`Validation failed for ${context}:`, result.error.issues);
+    throw new ValidationError(`Invalid ${context}`, result.error);
+  }
+  return result.data;
+}
+// ../../integrations/core/dist/http-client.js
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 1000,
+  maxDelayMs: 1e4
+};
+var DEFAULT_TIMEOUT = 30000;
+
+class HttpClient {
+  config;
+  retryConfig;
+  constructor(config, retryConfig) {
+    this.config = config;
+    this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
+  }
+  async request(path, options = {}) {
+    const { method = "GET", headers = {}, body, timeout } = options;
+    if (this.config.rateLimiter) {
+      await this.config.rateLimiter.acquire();
+    }
+    const accessToken = await this.config.getAccessToken();
+    const url = `${this.config.baseUrl}${path}`;
+    const requestHeaders = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Bearer ${accessToken}`,
+      ...this.config.defaultHeaders,
+      ...headers
+    };
+    const controller = new AbortController;
+    const timeoutMs = timeout ?? this.config.timeout ?? DEFAULT_TIMEOUT;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    let lastError;
+    for (let attempt = 0;attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: requestHeaders,
+          body: body ? JSON.stringify(body) : undefined,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          return await response.json();
+        }
+        if (response.status === 401) {
+          throw new AuthenticationError("Authentication failed");
+        }
+        if (response.status === 429) {
+          const retryAfter = response.headers.get("Retry-After");
+          const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : 1000;
+          if (attempt < this.retryConfig.maxRetries) {
+            console.log(`[HttpClient] Rate limited, waiting ${retryAfterMs}ms before retry ${attempt + 1}/${this.retryConfig.maxRetries}`);
+            await new Promise((resolve) => setTimeout(resolve, retryAfterMs));
+            continue;
+          }
+          throw new RateLimitError(retryAfterMs);
+        }
+        if (response.status >= 500 && attempt < this.retryConfig.maxRetries) {
+          lastError = new ApiError(`Server error: ${response.status}`, response.status, await response.text().catch(() => {
+            return;
+          }));
+          await this.delay(attempt);
+          continue;
+        }
+        const errorBody = await response.text().catch(() => {
+          return;
+        });
+        throw new ApiError(`Request failed: ${response.status}`, response.status, errorBody);
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof AuthenticationError || error instanceof RateLimitError || error instanceof ApiError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new ApiError("Request timeout", 408);
+        }
+        if (attempt < this.retryConfig.maxRetries) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          await this.delay(attempt);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError ?? new ApiError("Request failed after retries", 500);
+  }
+  async delay(attempt) {
+    const delayMs = Math.min(this.retryConfig.baseDelayMs * 2 ** attempt, this.retryConfig.maxDelayMs);
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  async get(path, headers) {
+    return this.request(path, { method: "GET", headers });
+  }
+  async post(path, body, headers) {
+    return this.request(path, { method: "POST", body, headers });
+  }
+  async put(path, body, headers) {
+    return this.request(path, { method: "PUT", body, headers });
+  }
+  async patch(path, body, headers) {
+    return this.request(path, { method: "PATCH", body, headers });
+  }
+  async delete(path, headers) {
+    return this.request(path, { method: "DELETE", headers });
+  }
+  async uploadFormData(path, formData, headers) {
+    if (this.config.rateLimiter) {
+      await this.config.rateLimiter.acquire();
+    }
+    const accessToken = await this.config.getAccessToken();
+    const url = `${this.config.baseUrl}${path}`;
+    const requestHeaders = {
+      Accept: "application/json",
+      Authorization: `Bearer ${accessToken}`,
+      ...this.config.defaultHeaders,
+      ...headers
+    };
+    delete requestHeaders["Content-Type"];
+    const controller = new AbortController;
+    const timeoutMs = this.config.timeout ?? DEFAULT_TIMEOUT;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: requestHeaders,
+        body: formData,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        return await response.json();
+      }
+      if (response.status === 401) {
+        throw new AuthenticationError("Authentication failed");
+      }
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : 1000;
+        throw new RateLimitError(retryAfterMs);
+      }
+      const errorBody = await response.text().catch(() => {
+        return;
+      });
+      throw new ApiError(`Upload failed: ${response.status}`, response.status, errorBody);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof AuthenticationError || error instanceof RateLimitError || error instanceof ApiError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new ApiError("Upload timeout", 408);
+      }
+      throw error;
+    }
+  }
+  async downloadBinary(path, headers) {
+    if (this.config.rateLimiter) {
+      await this.config.rateLimiter.acquire();
+    }
+    const accessToken = await this.config.getAccessToken();
+    const url = `${this.config.baseUrl}${path}`;
+    const requestHeaders = {
+      Authorization: `Bearer ${accessToken}`,
+      ...this.config.defaultHeaders,
+      ...headers
+    };
+    const controller = new AbortController;
+    const timeoutMs = this.config.timeout ?? DEFAULT_TIMEOUT;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: requestHeaders,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        if (response.status === 401) {
+          throw new AuthenticationError("Authentication failed");
+        }
+        if (response.status === 429) {
+          const retryAfter = response.headers.get("Retry-After");
+          const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : undefined;
+          throw new RateLimitError(retryAfterMs);
+        }
+        const errorBody = await response.text().catch(() => {
+          return;
+        });
+        throw new ApiError(`Download failed: ${response.status}`, response.status, errorBody);
+      }
+      const contentDisposition = response.headers.get("Content-Disposition");
+      const filenameMatch = contentDisposition?.match(/filename="?([^";\n]+)"?/);
+      return {
+        data: await response.arrayBuffer(),
+        contentType: response.headers.get("Content-Type") ?? "application/octet-stream",
+        filename: filenameMatch?.[1]
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof AuthenticationError || error instanceof RateLimitError || error instanceof ApiError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new ApiError("Download timeout", 408);
+      }
+      throw error;
+    }
+  }
+}
+// ../../integrations/core/dist/rate-limiter.js
+class TokenBucketRateLimiter {
+  config;
+  tokens;
+  lastRefill;
+  waitQueue = [];
+  constructor(config) {
+    this.config = config;
+    this.tokens = config.maxTokens;
+    this.lastRefill = Date.now();
+  }
+  async acquire() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.waitQueue.push(resolve);
+      this.scheduleRefill();
+    });
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    const tokensToAdd = Math.floor(elapsed / this.config.refillIntervalMs) * this.config.refillAmount;
+    if (tokensToAdd > 0) {
+      this.tokens = Math.min(this.config.maxTokens, this.tokens + tokensToAdd);
+      this.lastRefill = now;
+      while (this.tokens >= 1 && this.waitQueue.length > 0) {
+        this.tokens -= 1;
+        const resolve = this.waitQueue.shift();
+        resolve?.();
+      }
+    }
+    if (this.waitQueue.length > 0) {
+      this.scheduleRefill();
+    }
+  }
+  scheduleRefill() {
+    const timeUntilNextToken = this.config.refillIntervalMs - (Date.now() - this.lastRefill) % this.config.refillIntervalMs;
+    setTimeout(() => {
+      this.refill();
+    }, timeUntilNextToken);
+  }
+  static forFortnox() {
+    return new TokenBucketRateLimiter({
+      maxTokens: 20,
+      refillIntervalMs: 250,
+      refillAmount: 1
+    });
+  }
+  static forBokio() {
+    return new TokenBucketRateLimiter({
+      maxTokens: 200,
+      refillIntervalMs: 300,
+      refillAmount: 1
+    });
+  }
+}
+// ../../integrations/core/dist/auth/token-manager.js
+var DEFAULT_REFRESH_BUFFER_SECONDS = 300;
+
+class TokenManager {
+  tokenStore;
+  tokenRefresher;
+  refreshBufferSeconds;
+  tokenCache = new Map;
+  refreshLocks = new Map;
+  constructor(config) {
+    this.tokenStore = config.tokenStore;
+    this.tokenRefresher = config.tokenRefresher;
+    this.refreshBufferSeconds = config.refreshBufferSeconds ?? DEFAULT_REFRESH_BUFFER_SECONDS;
+  }
+  getCacheKey(integration, userId, organizationId) {
+    return `${integration}:${userId}:${organizationId}`;
+  }
+  async getValidAccessToken(integration, userId, organizationId) {
+    const cacheKey = this.getCacheKey(integration, userId, organizationId);
+    const cached = this.tokenCache.get(cacheKey);
+    if (cached && !this.isTokenExpiringSoon(cached.expiresAt)) {
+      return cached.accessToken;
+    }
+    const storedToken = await this.tokenStore.getToken(integration, userId, organizationId);
+    if (!storedToken) {
+      throw new TokenExpiredError("No token found for this integration");
+    }
+    if (this.isTokenExpiringSoon(storedToken.expiresAt)) {
+      const refreshedToken = await this.refreshTokenWithLock(integration, userId, organizationId, storedToken);
+      return refreshedToken.accessToken;
+    }
+    this.tokenCache.set(cacheKey, {
+      accessToken: storedToken.accessToken,
+      expiresAt: storedToken.expiresAt,
+      version: storedToken.version
+    });
+    return storedToken.accessToken;
+  }
+  isTokenExpiringSoon(expiresAt) {
+    const bufferMs = this.refreshBufferSeconds * 1000;
+    return expiresAt.getTime() - bufferMs <= Date.now();
+  }
+  async refreshTokenWithLock(integration, userId, organizationId, storedToken) {
+    const cacheKey = this.getCacheKey(integration, userId, organizationId);
+    const existingRefresh = this.refreshLocks.get(cacheKey);
+    if (existingRefresh) {
+      return existingRefresh;
+    }
+    const refreshPromise = this.performRefresh(integration, userId, organizationId, storedToken);
+    this.refreshLocks.set(cacheKey, refreshPromise);
+    try {
+      const result = await refreshPromise;
+      return result;
+    } finally {
+      this.refreshLocks.delete(cacheKey);
+    }
+  }
+  async performRefresh(integration, userId, organizationId, storedToken) {
+    const cacheKey = this.getCacheKey(integration, userId, organizationId);
+    try {
+      const newTokenResponse = await this.tokenRefresher.refreshToken(storedToken.refreshToken);
+      const updatedToken = await this.tokenStore.updateToken(storedToken.id, newTokenResponse, storedToken.version);
+      this.tokenCache.set(cacheKey, {
+        accessToken: updatedToken.accessToken,
+        expiresAt: updatedToken.expiresAt,
+        version: updatedToken.version
+      });
+      return updatedToken;
+    } catch (error) {
+      this.tokenCache.delete(cacheKey);
+      throw error;
+    }
+  }
+  async storeNewToken(integration, userId, organizationId, tokenResponse) {
+    const storedToken = await this.tokenStore.saveToken(integration, userId, organizationId, tokenResponse);
+    const cacheKey = this.getCacheKey(integration, userId, organizationId);
+    this.tokenCache.set(cacheKey, {
+      accessToken: storedToken.accessToken,
+      expiresAt: storedToken.expiresAt,
+      version: storedToken.version
+    });
+    return storedToken;
+  }
+  async revokeToken(integration, userId, organizationId) {
+    await this.tokenStore.deleteToken(integration, userId, organizationId);
+    const cacheKey = this.getCacheKey(integration, userId, organizationId);
+    this.tokenCache.delete(cacheKey);
+  }
+  clearCache() {
+    this.tokenCache.clear();
+  }
+}
+// ../../integrations/bokio/dist/client.js
+class BokioClient {
+  httpClient;
+  _companyId;
+  constructor(config) {
+    this._companyId = config.companyId;
+    this.httpClient = new HttpClient({
+      baseUrl: BOKIO_CONFIG.API_BASE_URL,
+      getAccessToken: async () => config.token,
+      rateLimiter: TokenBucketRateLimiter.forBokio(),
+      defaultHeaders: {
+        Accept: "application/json"
+      }
+    });
+  }
+  get companyId() {
+    return this._companyId;
+  }
+  buildPath(endpoint) {
+    return `/${BOKIO_CONFIG.API_VERSION}/companies/${this._companyId}${endpoint}`;
+  }
+  async get(endpoint) {
+    return this.httpClient.get(this.buildPath(endpoint));
+  }
+  async post(endpoint, body) {
+    return this.httpClient.post(this.buildPath(endpoint), body);
+  }
+  async validateConnection() {
+    try {
+      await this.getJournalEntries({ page: 1, pageSize: 1 });
+      return { valid: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return { valid: false, error: message };
+    }
+  }
+  async getJournalEntries(params) {
+    const page = params?.page ?? 1;
+    const pageSize = params?.pageSize ?? 100;
+    const query = `?page=${page}&pageSize=${pageSize}`;
+    const raw = await this.get(`/journal-entries${query}`);
+    const response = validate(JournalEntriesResponseSchema, raw, "JournalEntriesResponse");
+    return {
+      data: response.items,
+      pagination: {
+        currentPage: response.currentPage,
+        pageSize,
+        totalItems: response.totalItems,
+        totalPages: response.totalPages,
+        hasNextPage: response.currentPage < response.totalPages,
+        hasPreviousPage: response.currentPage > 1
+      }
+    };
+  }
+  async getJournalEntry(id) {
+    const raw = await this.get(`/journal-entries/${id}`);
+    return validate(JournalEntrySchema, raw, "JournalEntry");
+  }
+  async getCompanyInformation() {
+    const raw = await this.get("/company-information");
+    return validate(CompanyInfoSchema, raw, "CompanyInfo");
+  }
+  async getFiscalYears(params) {
+    const page = params?.page ?? 1;
+    const pageSize = params?.pageSize ?? 100;
+    const query = `?page=${page}&pageSize=${pageSize}`;
+    const raw = await this.get(`/fiscal-years${query}`);
+    const response = validate(FiscalYearsResponseSchema, raw, "FiscalYearsResponse");
+    return {
+      data: response.items,
+      pagination: {
+        currentPage: response.currentPage,
+        pageSize,
+        totalItems: response.totalItems,
+        totalPages: response.totalPages,
+        hasNextPage: response.currentPage < response.totalPages,
+        hasPreviousPage: response.currentPage > 1
+      }
+    };
+  }
+  async getChartOfAccounts() {
+    const raw = await this.get("/chart-of-accounts");
+    return validate(ChartOfAccountsResponseSchema, raw, "ChartOfAccounts");
+  }
+  async getUploads(params) {
+    const page = params?.page ?? 1;
+    const pageSize = params?.pageSize ?? 25;
+    const queryParts = [`page=${page}`, `pageSize=${pageSize}`];
+    if (params?.query) {
+      queryParts.push(`query=${encodeURIComponent(params.query)}`);
+    }
+    const queryString = `?${queryParts.join("&")}`;
+    const raw = await this.get(`/uploads${queryString}`);
+    const response = validate(UploadsResponseSchema, raw, "UploadsResponse");
+    return {
+      data: response.items,
+      pagination: {
+        currentPage: response.currentPage,
+        pageSize,
+        totalItems: response.totalItems,
+        totalPages: response.totalPages,
+        hasNextPage: response.currentPage < response.totalPages,
+        hasPreviousPage: response.currentPage > 1
+      }
+    };
+  }
+  async getUpload(id) {
+    const raw = await this.get(`/uploads/${id}`);
+    return validate(UploadSchema, raw, "Upload");
+  }
+  async downloadFile(id) {
+    return this.httpClient.downloadBinary(this.buildPath(`/uploads/${id}/download`));
+  }
+  async createJournalEntry(request) {
+    const raw = await this.post("/journal-entries", request);
+    return validate(JournalEntrySchema, raw, "JournalEntry");
+  }
+  async uploadFile(options) {
+    const formData = new FormData;
+    formData.append("file", options.file, options.filename);
+    if (options.description) {
+      formData.append("description", options.description);
+    }
+    if (options.journalEntryId) {
+      formData.append("journalEntryId", options.journalEntryId);
+    }
+    const raw = await this.httpClient.uploadFormData(this.buildPath("/uploads"), formData);
+    return validate(UploadSchema, raw, "Upload");
+  }
+}
+// ../sync/dist/transformers/bokio.js
+function mapBokioEntryToJournalEntry(entry) {
+  const voucherNumberMatch = entry.journalEntryNumber.match(/\d+/);
+  const voucherNumber = voucherNumberMatch ? parseInt(voucherNumberMatch[0], 10) : 0;
+  const seriesCode = entry.journalEntryNumber.replace(/\d+/g, "") || undefined;
+  const lines = entry.items.map((item, idx) => ({
+    lineNumber: idx + 1,
+    account: String(item.account),
+    debit: { amount: item.debit, currency: "SEK" },
+    credit: { amount: item.credit, currency: "SEK" }
+  }));
+  const totalDebit = entry.items.reduce((sum, item) => sum + item.debit, 0);
+  const totalCredit = entry.items.reduce((sum, item) => sum + item.credit, 0);
+  return {
+    series: seriesCode,
+    entryNumber: voucherNumber,
+    entryDate: entry.date,
+    description: entry.title,
+    status: "POSTED",
+    currency: "SEK",
+    externalId: entry.id,
+    totalDebit: { amount: totalDebit, currency: "SEK" },
+    totalCredit: { amount: totalCredit, currency: "SEK" },
+    lines,
+    sourceIntegration: "bokio",
+    sourceSyncedAt: new Date().toISOString()
+  };
+}
+// ../sync/dist/storage/filesystem.js
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+
+class FilesystemStorageService {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  resolvePath(relativePath) {
+    return path.join(this.basePath, relativePath);
+  }
+  contentHash(content) {
+    return crypto.createHash("sha1").update(content).digest("hex");
+  }
+  async readFile(filePath) {
+    const absolutePath = this.resolvePath(filePath);
+    const content = await fs.readFile(absolutePath, "utf-8");
+    return {
+      content,
+      sha: this.contentHash(content)
+    };
+  }
+  async writeFile(filePath, content, _options) {
+    const absolutePath = this.resolvePath(filePath);
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+    await fs.writeFile(absolutePath, content, "utf-8");
+  }
+  async listDirectory(dirPath) {
+    const absolutePath = this.resolvePath(dirPath);
+    const entries = [];
+    try {
+      const items = await fs.readdir(absolutePath, { withFileTypes: true });
+      for (const item of items) {
+        if (item.isFile()) {
+          entries.push({
+            name: item.name,
+            type: "file",
+            path: path.join(dirPath, item.name)
+          });
+        } else if (item.isDirectory()) {
+          entries.push({
+            name: item.name,
+            type: "dir",
+            path: path.join(dirPath, item.name)
+          });
+        }
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+    return entries;
+  }
+  async deleteFile(filePath, _sha, _message) {
+    const absolutePath = this.resolvePath(filePath);
+    await fs.unlink(absolutePath);
+  }
+  getPublicUrl(_path) {
+    return null;
+  }
+  async exists(filePath) {
+    try {
+      await fs.access(this.resolvePath(filePath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async renameDirectory(oldPath, newPath) {
+    const absoluteOldPath = this.resolvePath(oldPath);
+    const absoluteNewPath = this.resolvePath(newPath);
+    await fs.mkdir(path.dirname(absoluteNewPath), { recursive: true });
+    await fs.rename(absoluteOldPath, absoluteNewPath);
+  }
+}
+// ../sync/dist/utils/file-namer.js
+function journalEntryDirName(entry) {
+  const series = entry.voucher_series_code || "";
+  const voucher = String(entry.voucher_number || "000").padStart(3, "0");
+  const date = entry.entry_date;
+  const description = slugify(entry.description || entry.id?.slice(0, 8) || "entry");
+  const parts = [series, voucher, date, description].filter(Boolean);
+  return parts.join("-");
+}
+function journalEntryPath(fiscalYear, series, entryNumber, entryDate, description) {
+  const fyDir = fiscalYearDirName(fiscalYear);
+  const entryDir = journalEntryDirName({
+    voucher_series_code: series,
+    voucher_number: entryNumber,
+    entry_date: entryDate,
+    description
+  });
+  return `journal-entries/${fyDir}/${entryDir}/entry.yaml`;
+}
+function journalEntryDirFromPath(entryPath) {
+  return entryPath.replace(/\/entry\.yaml$/, "");
+}
+function fiscalYearDirName(year) {
+  if (typeof year === "number") {
+    return `FY-${year}`;
+  }
+  return `FY-${year.start_date.slice(0, 4)}`;
+}
+function slugify(text, maxLength = 30) {
+  return text.toLowerCase().slice(0, maxLength).replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function sanitizeOrgName(name) {
+  return slugify(name, 50);
+}
+// ../sync/dist/utils/yaml.js
+import YAML from "yaml";
+function parseYaml(yaml) {
+  return YAML.parse(yaml);
+}
+function toYaml(data) {
+  const cleanData = removeNulls(data);
+  return YAML.stringify(cleanData, {
+    indent: 2,
+    lineWidth: 120,
+    minContentWidth: 0,
+    doubleQuotedAsJSON: true
+  });
+}
+function removeNulls(obj) {
+  if (obj === null || obj === undefined) {
+    return;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(removeNulls).filter((item) => item !== undefined);
+  }
+  if (typeof obj === "object" && obj !== null) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const cleanValue = removeNulls(value);
+      if (cleanValue !== undefined) {
+        result[key] = cleanValue;
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+// ../sync/dist/services/document-download.js
+import * as fs2 from "node:fs/promises";
+import * as path2 from "node:path";
+function slugify2(text, maxLength = 40) {
+  return text.toLowerCase().slice(0, maxLength).replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+var EXTENSION_MAP = {
+  "application/pdf": ".pdf",
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/tiff": ".tiff",
+  "application/octet-stream": ".bin"
+};
+async function downloadFilesForEntry(options) {
+  const { storage, repoPath, entryDir, journalEntryId, downloader, sourceIntegration } = options;
+  const linkedFiles = await downloader.getFilesForEntry(journalEntryId);
+  if (linkedFiles.length === 0) {
+    return 0;
+  }
+  const documentsPath = `${entryDir}/documents.yaml`;
+  let existingDocs = [];
+  try {
+    const { content } = await storage.readFile(documentsPath);
+    existingDocs = parseYaml(content) || [];
+  } catch {}
+  const downloadedSourceIds = new Set(existingDocs.filter((d) => d.sourceIntegration === sourceIntegration).map((d) => d.sourceId));
+  let filesDownloaded = 0;
+  const absoluteDir = path2.join(repoPath, entryDir);
+  await fs2.mkdir(absoluteDir, { recursive: true });
+  for (const file of linkedFiles) {
+    if (downloadedSourceIds.has(file.id)) {
+      continue;
+    }
+    try {
+      const result = await downloader.downloadFile(file.id);
+      const ext = EXTENSION_MAP[file.contentType || result.contentType] || ".bin";
+      const baseName = file.description ? slugify2(file.description) : file.id.slice(0, 8);
+      const existingFilenames = existingDocs.map((d) => d.fileName);
+      let filename = `${baseName}${ext}`;
+      let counter = 1;
+      while (existingFilenames.includes(filename)) {
+        filename = `${baseName}-${counter}${ext}`;
+        counter++;
+      }
+      const filePath = path2.join(absoluteDir, filename);
+      const buffer = Buffer.from(result.data);
+      await fs2.writeFile(filePath, buffer);
+      existingDocs.push({
+        fileName: filename,
+        mimeType: file.contentType || result.contentType,
+        sourceIntegration,
+        sourceId: file.id
+      });
+      filesDownloaded++;
+    } catch (error) {
+      console.error(`
+  Warning: Failed to download file ${file.id}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  if (filesDownloaded > 0) {
+    await storage.writeFile(documentsPath, toYaml(existingDocs));
+  }
+  return filesDownloaded;
+}
+// src/lib/git.ts
+import simpleGit from "simple-git";
+import * as fs3 from "node:fs/promises";
+import * as path3 from "node:path";
+var GITIGNORE = `# Environment files with secrets
+.env
+.env.*
+
+# CLI cache
+.kvitton/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Editor files
+.vscode/
+.idea/
+*.swp
+`;
+async function initGitRepo(repoPath) {
+  const git = simpleGit(repoPath);
+  await git.init();
+  await fs3.writeFile(path3.join(repoPath, ".gitignore"), GITIGNORE);
+}
+async function commitAll(repoPath, message) {
+  const git = simpleGit(repoPath);
+  await git.add(".");
+  const status = await git.status();
+  if (status.files.length > 0) {
+    await git.commit(message);
+  }
+}
+
+// src/lib/env.ts
+import * as fs4 from "node:fs/promises";
+import * as path4 from "node:path";
+async function createEnvFile(repoPath, variables) {
+  const lines = Object.entries(variables).map(([key, value]) => `${key}=${value}`).join(`
+`);
+  await fs4.writeFile(path4.join(repoPath, ".env"), `${lines}
+`);
+}
+
+// src/sync/bokio-sync.ts
+function createBokioDownloader(client2) {
+  return {
+    async getFilesForEntry(journalEntryId) {
+      const response = await client2.getUploads({
+        query: `journalEntryId==${journalEntryId}`
+      });
+      return response.data.map((upload) => ({
+        id: upload.id,
+        contentType: upload.contentType,
+        description: upload.description ?? undefined
+      }));
+    },
+    async downloadFile(id) {
+      return client2.downloadFile(id);
+    }
+  };
+}
+async function syncJournalEntries2(client2, repoPath, options, onProgress) {
+  const storage2 = new FilesystemStorageService(repoPath);
+  const fiscalYearsResponse = await client2.getFiscalYears();
+  const fiscalYears = fiscalYearsResponse.data;
+  const firstPage = await client2.getJournalEntries({ page: 1, pageSize: 1 });
+  const totalEntries = firstPage.pagination.totalItems;
+  onProgress({ current: 0, total: totalEntries, message: "Starting sync..." });
+  if (totalEntries === 0) {
+    await writeFiscalYearsMetadata(storage2, fiscalYears);
+    return {
+      entriesCount: 0,
+      fiscalYearsCount: fiscalYears.length,
+      entriesWithFilesDownloaded: 0
+    };
+  }
+  const allEntries = [];
+  let page = 1;
+  const pageSize = 100;
+  while (true) {
+    const response = await client2.getJournalEntries({ page, pageSize });
+    allEntries.push(...response.data);
+    onProgress({ current: allEntries.length, total: totalEntries });
+    if (!response.pagination.hasNextPage)
+      break;
+    page++;
+  }
+  let entriesWithFilesDownloaded = 0;
+  const downloader = createBokioDownloader(client2);
+  for (const entry of allEntries) {
+    const fiscalYear = findFiscalYear(entry.date, fiscalYears);
+    if (!fiscalYear)
+      continue;
+    const fyYear = parseInt(fiscalYear.startDate.slice(0, 4), 10);
+    const entryDir = await writeJournalEntry(storage2, fyYear, entry);
+    if (options.downloadFiles !== false && entryDir) {
+      const filesDownloaded = await downloadFilesForEntry({
+        storage: storage2,
+        repoPath,
+        entryDir,
+        journalEntryId: entry.id,
+        downloader,
+        sourceIntegration: "bokio"
+      });
+      if (filesDownloaded > 0) {
+        entriesWithFilesDownloaded++;
+      }
+    }
+  }
+  await writeFiscalYearsMetadata(storage2, fiscalYears);
+  return {
+    entriesCount: allEntries.length,
+    fiscalYearsCount: fiscalYears.length,
+    entriesWithFilesDownloaded
+  };
+}
+function findFiscalYear(date, fiscalYears) {
+  return fiscalYears.find((fy) => date >= fy.startDate && date <= fy.endDate);
+}
+async function writeJournalEntry(storage2, 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 yamlContent = toYaml(journalEntry);
+  await storage2.writeFile(entryPath, yamlContent);
+  return journalEntryDirFromPath(entryPath);
+}
+async function writeFiscalYearsMetadata(storage2, 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 storage2.writeFile(metadataPath, yamlContent);
+  }
+}
+async function syncChartOfAccounts(client2, repoPath) {
+  const storage2 = new FilesystemStorageService(repoPath);
+  const bokioAccounts = await client2.getChartOfAccounts();
+  const accounts = [...bokioAccounts].sort((a, b) => a.account - b.account).map((account) => ({
+    code: account.account.toString(),
+    name: account.name,
+    description: account.name
+  }));
+  const yamlContent = toYaml({ accounts });
+  await storage2.writeFile("accounts.yaml", yamlContent);
+  return { accountsCount: accounts.length };
+}
+
+// src/commands/create.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
+async function createAgentsFile(targetDir, options) {
+  const templatePath = path5.join(__dirname2, "../templates/AGENTS.md");
+  let template = await fs5.readFile(templatePath, "utf-8");
+  template = template.replace(/\{\{COMPANY_NAME\}\}/g, options.companyName);
+  template = template.replace(/\{\{PROVIDER\}\}/g, options.provider);
+  template = template.replace(/\{\{PROVIDER_LOWER\}\}/g, options.provider.toLowerCase());
+  const agentsPath = path5.join(targetDir, "AGENTS.md");
+  await fs5.writeFile(agentsPath, template, "utf-8");
+  const claudePath = path5.join(targetDir, "CLAUDE.md");
+  await fs5.symlink("AGENTS.md", claudePath);
+}
+function isValidUUID(value) {
+  return /^[0-9a-f-]{36}$/i.test(value.trim());
+}
+function isValidFolderName(value) {
+  return /^[a-z0-9-]+$/.test(value.trim());
+}
+async function createBookkeepingRepo(name, options = {}) {
+  const { yes: acceptDefaults = false } = options;
+  console.log(`
+  Create a new bookkeeping repository
+`);
+  let provider = options.provider;
+  if (!provider) {
+    provider = await select({
+      message: "Select your accounting provider:",
+      choices: [
+        { name: "Bokio", value: "bokio" },
+        { name: "Fortnox (coming soon)", value: "fortnox", disabled: true }
+      ]
+    });
+  }
+  if (provider !== "bokio") {
+    console.log("Only Bokio is supported at this time.");
+    process.exit(1);
+  }
+  const envToken = process.env.BOKIO_TOKEN;
+  let token;
+  if (envToken) {
+    token = envToken;
+    console.log("  Using BOKIO_TOKEN from environment");
+  } else {
+    console.log(`
+  To connect to Bokio, you need:`);
+    console.log("  - API Token: Bokio app > Settings > Integrations > Create Integration");
+    console.log(`  - Company ID: From your Bokio URL (app.bokio.se/{companyId}/...)
+`);
+    console.log(`  Tip: Set BOKIO_TOKEN env var to avoid entering token each time
+`);
+    token = await password({
+      message: "Enter your Bokio API token:",
+      mask: "*"
+    });
+  }
+  let companyId = options.companyId;
+  if (!companyId) {
+    companyId = await input({
+      message: "Enter your Bokio Company ID:",
+      validate: (value) => {
+        if (!value.trim())
+          return "Company ID is required";
+        if (!isValidUUID(value)) {
+          return "Company ID should be a UUID (e.g., 12345678-1234-1234-1234-123456789abc)";
+        }
+        return true;
+      }
+    });
+  } else if (!isValidUUID(companyId)) {
+    console.error("Error: Company ID should be a UUID (e.g., 12345678-1234-1234-1234-123456789abc)");
+    process.exit(1);
+  }
+  const spinner = ora("Validating credentials...").start();
+  const client2 = new BokioClient({ token, companyId: companyId.trim() });
+  let companyName;
+  try {
+    const companyInfo = await client2.getCompanyInformation();
+    companyName = companyInfo.name;
+    spinner.succeed(`Connected to: ${companyName}`);
+  } catch (error) {
+    spinner.fail("Failed to connect to Bokio");
+    console.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+  const suggestedName = `kvitton-${sanitizeOrgName(companyName)}`;
+  let folderName;
+  if (name) {
+    if (!isValidFolderName(name)) {
+      console.error("Error: Folder name should only contain lowercase letters, numbers, and hyphens");
+      process.exit(1);
+    }
+    folderName = name;
+  } else if (acceptDefaults) {
+    folderName = suggestedName;
+    console.log(`  Using folder name: ${folderName}`);
+  } else {
+    folderName = await input({
+      message: "Repository folder name:",
+      default: suggestedName,
+      validate: (value) => {
+        if (!value.trim())
+          return "Folder name is required";
+        if (!isValidFolderName(value)) {
+          return "Folder name should only contain lowercase letters, numbers, and hyphens";
+        }
+        return true;
+      }
+    });
+  }
+  const targetDir = path5.resolve(process.cwd(), folderName.trim());
+  try {
+    await fs5.access(targetDir);
+    if (acceptDefaults) {
+      console.error(`Error: Directory ${folderName} already exists`);
+      process.exit(1);
+    }
+    const overwrite = await confirm({
+      message: `Directory ${folderName} already exists. Continue anyway?`,
+      default: false
+    });
+    if (!overwrite) {
+      console.log("Aborted.");
+      process.exit(0);
+    }
+  } catch {}
+  const gitSpinner = ora("Initializing repository...").start();
+  await fs5.mkdir(targetDir, { recursive: true });
+  await initGitRepo(targetDir);
+  gitSpinner.succeed("Repository initialized");
+  await createEnvFile(targetDir, {
+    PROVIDER: "bokio",
+    BOKIO_TOKEN: token,
+    BOKIO_COMPANY_ID: companyId.trim()
+  });
+  console.log("  Created .env with credentials");
+  await createAgentsFile(targetDir, {
+    companyName,
+    provider: "Bokio"
+  });
+  console.log("  Created AGENTS.md and CLAUDE.md symlink");
+  const accountsSpinner = ora("Syncing chart of accounts...").start();
+  const { accountsCount } = await syncChartOfAccounts(client2, targetDir);
+  accountsSpinner.succeed(`Synced ${accountsCount} accounts to accounts.yaml`);
+  let shouldSync;
+  if (options.sync !== undefined) {
+    shouldSync = options.sync;
+  } else if (acceptDefaults) {
+    shouldSync = true;
+  } else {
+    shouldSync = await confirm({
+      message: "Sync existing journal entries from Bokio?",
+      default: true
+    });
+  }
+  let entriesCount = 0;
+  let fiscalYearsCount = 0;
+  if (shouldSync) {
+    const shouldDownloadFiles = options.downloadFiles !== false;
+    const result = await syncJournalEntries2(client2, targetDir, { downloadFiles: shouldDownloadFiles }, (progress) => {
+      process.stdout.write(`\r  Syncing: ${progress.current}/${progress.total} entries`);
+    });
+    entriesCount = result.entriesCount;
+    fiscalYearsCount = result.fiscalYearsCount;
+    if (result.entriesWithFilesDownloaded > 0) {
+      console.log(`
+  Downloaded files for ${result.entriesWithFilesDownloaded}/${result.entriesCount} entries`);
+    }
+    console.log("  Sync complete!");
+  }
+  const commitSpinner = ora("Creating initial commit...").start();
+  await commitAll(targetDir, "Initial sync from Bokio");
+  commitSpinner.succeed("Initial commit created");
+  console.log(`
+  Success! Created ${folderName} at ${targetDir}
+
+  Summary:
+    - ${accountsCount} accounts
+    - ${fiscalYearsCount} fiscal year(s)
+    - ${entriesCount} journal entries
+
+  Next steps:
+    cd ${folderName}
+
+  Your bookkeeping data is stored as YAML files:
+    journal-entries/FY-2024/A-001-2024-01-15-invoice/entry.yaml
+
+  Commands:
+    kvitton sync-journal  Sync journal entries from Bokio
+    kvitton sync-inbox    Download inbox files from Bokio
+    kvitton company-info  Display company information
+  `);
+}
+
+// src/index.ts
+var program = new Command;
+program.name("create-kvitton").description("Create a new kvitton bookkeeping git repository").version("0.4.0").argument("[name]", "Repository folder name").option("-p, --provider <provider>", "Accounting provider (bokio)", "bokio").option("-c, --company-id <id>", "Company ID (UUID from provider)").option("-s, --sync", "Sync journal entries after creation", true).option("--no-sync", "Skip syncing journal entries").option("-d, --download-files", "Download files for journal entries", true).option("--no-download-files", "Skip downloading files").option("-y, --yes", "Accept defaults without prompting").addHelpText("after", `
+Environment Variables:
+  BOKIO_TOKEN       Bokio API token (required for non-interactive mode)
+
+Examples:
+  $ create-kvitton
+  $ create-kvitton my-company-books
+  $ create-kvitton my-repo --company-id abc-123-def --sync
+  $ create-kvitton my-repo -c abc-123 --no-download-files
+  $ BOKIO_TOKEN=xxx create-kvitton my-repo -c abc-123 -y
+`).action((name, options) => {
+  createBookkeepingRepo(name, options);
+});
+program.parse();