create-kvitton 0.4.0

package/dist/commands/create.js

@@ -0,0 +1,238 @@
+import { select, input, password, confirm } from "@inquirer/prompts";
+import ora from "ora";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { BokioClient } from "integrations-bokio";
+import { sanitizeOrgName } from "sync";
+import { initGitRepo, commitAll } from "../lib/git";
+import { createEnvFile } from "../lib/env";
+import { syncJournalEntries, syncChartOfAccounts } from "../sync/bokio-sync";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+async function createAgentsFile(targetDir, options) {
+    // Read template
+    const templatePath = path.join(__dirname, "../templates/AGENTS.md");
+    let template = await fs.readFile(templatePath, "utf-8");
+    // Replace placeholders
+    template = template.replace(/\{\{COMPANY_NAME\}\}/g, options.companyName);
+    template = template.replace(/\{\{PROVIDER\}\}/g, options.provider);
+    template = template.replace(/\{\{PROVIDER_LOWER\}\}/g, options.provider.toLowerCase());
+    // Write AGENTS.md
+    const agentsPath = path.join(targetDir, "AGENTS.md");
+    await fs.writeFile(agentsPath, template, "utf-8");
+    // Create CLAUDE.md symlink pointing to AGENTS.md
+    const claudePath = path.join(targetDir, "CLAUDE.md");
+    await fs.symlink("AGENTS.md", claudePath);
+}
+/**
+ * Validate UUID format
+ */
+function isValidUUID(value) {
+    return /^[0-9a-f-]{36}$/i.test(value.trim());
+}
+/**
+ * Validate folder name format
+ */
+function isValidFolderName(value) {
+    return /^[a-z0-9-]+$/.test(value.trim());
+}
+export async function createBookkeepingRepo(name, options = {}) {
+    const { yes: acceptDefaults = false } = options;
+    console.log("\n  Create a new bookkeeping repository\n");
+    // 1. Determine provider (CLI arg or prompt)
+    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);
+    }
+    // 2. Get token from env var (required for Bokio)
+    const envToken = process.env.BOKIO_TOKEN;
+    let token;
+    if (envToken) {
+        token = envToken;
+        console.log("  Using BOKIO_TOKEN from environment");
+    }
+    else {
+        // Interactive mode - prompt for token
+        console.log("\n  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}/...)\n");
+        console.log("  Tip: Set BOKIO_TOKEN env var to avoid entering token each time\n");
+        token = await password({
+            message: "Enter your Bokio API token:",
+            mask: "*",
+        });
+    }
+    // 3. Get company ID (CLI arg or prompt)
+    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);
+    }
+    // 4. Validate credentials
+    const spinner = ora("Validating credentials...").start();
+    const client = new BokioClient({ token, companyId: companyId.trim() });
+    let companyName;
+    try {
+        const companyInfo = await client.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);
+    }
+    // 5. Determine folder name (CLI arg, default, or prompt)
+    const suggestedName = `kvitton-${sanitizeOrgName(companyName)}`;
+    let folderName;
+    if (name) {
+        // CLI argument provided
+        if (!isValidFolderName(name)) {
+            console.error("Error: Folder name should only contain lowercase letters, numbers, and hyphens");
+            process.exit(1);
+        }
+        folderName = name;
+    }
+    else if (acceptDefaults) {
+        // --yes flag: use suggested name
+        folderName = suggestedName;
+        console.log(`  Using folder name: ${folderName}`);
+    }
+    else {
+        // Interactive prompt
+        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 = path.resolve(process.cwd(), folderName.trim());
+    // Check if directory exists
+    try {
+        await fs.access(targetDir);
+        if (acceptDefaults) {
+            // With --yes, abort if directory exists
+            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 {
+        // Directory doesn't exist, good
+    }
+    // 6. Create folder and initialize git
+    const gitSpinner = ora("Initializing repository...").start();
+    await fs.mkdir(targetDir, { recursive: true });
+    await initGitRepo(targetDir);
+    gitSpinner.succeed("Repository initialized");
+    // 7. Create .env file
+    await createEnvFile(targetDir, {
+        PROVIDER: "bokio",
+        BOKIO_TOKEN: token,
+        BOKIO_COMPANY_ID: companyId.trim(),
+    });
+    console.log("  Created .env with credentials");
+    // 8. Create AGENTS.md and CLAUDE.md symlink
+    await createAgentsFile(targetDir, {
+        companyName,
+        provider: "Bokio",
+    });
+    console.log("  Created AGENTS.md and CLAUDE.md symlink");
+    // 9. Sync chart of accounts
+    const accountsSpinner = ora("Syncing chart of accounts...").start();
+    const { accountsCount } = await syncChartOfAccounts(client, targetDir);
+    accountsSpinner.succeed(`Synced ${accountsCount} accounts to accounts.yaml`);
+    // 10. Sync journal entries (CLI flag, default, or prompt)
+    let shouldSync;
+    if (options.sync !== undefined) {
+        // Explicit --sync or --no-sync flag
+        shouldSync = options.sync;
+    }
+    else if (acceptDefaults) {
+        // --yes flag: default to sync
+        shouldSync = true;
+    }
+    else {
+        // Interactive prompt
+        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 syncJournalEntries(client, 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(`\n  Downloaded files for ${result.entriesWithFilesDownloaded}/${result.entriesCount} entries`);
+        }
+        console.log("  Sync complete!");
+    }
+    // 11. Final commit
+    const commitSpinner = ora("Creating initial commit...").start();
+    await commitAll(targetDir, "Initial sync from Bokio");
+    commitSpinner.succeed("Initial commit created");
+    // 12. Success message
+    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
+  `);
+}