@hasna/skills 0.0.2

package/skills/skill-invoice/src/commands/config.ts

@@ -0,0 +1,132 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { dirname } from "path";
+import { getConfigPath, ensureDir } from "../utils/paths.js";
+import { logger } from "../utils/logger.js";
+import { checkApiHealth } from "../lib/api.js";
+
+interface Config {
+  defaultCurrency: string;
+  defaultVatRate: number;
+  defaultPaymentTerms: number;
+  apiBaseUrl: string;
+}
+
+function loadConfig(): Config {
+  const configPath = getConfigPath();
+
+  if (!existsSync(configPath)) {
+    return {
+      defaultCurrency: "EUR",
+      defaultVatRate: 19,
+      defaultPaymentTerms: 30,
+      apiBaseUrl: "http://localhost:8007/api/v1",
+    };
+  }
+
+  const content = readFileSync(configPath, "utf-8");
+  return JSON.parse(content) as Config;
+}
+
+function saveConfig(config: Config): void {
+  const configPath = getConfigPath();
+  ensureDir(dirname(configPath));
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+export function registerConfigCommand(program: Command): void {
+  const config = program
+    .command("config")
+    .description("View and edit configuration");
+
+  config
+    .command("show")
+    .description("Show current configuration")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const cfg = loadConfig();
+
+      if (options.json) {
+        console.log(JSON.stringify(cfg, null, 2));
+        return;
+      }
+
+      logger.header("Configuration");
+      logger.label("Config file", getConfigPath());
+      console.log();
+
+      logger.label("Default Currency", cfg.defaultCurrency);
+      logger.label("Default VAT Rate", `${cfg.defaultVatRate}%`);
+      logger.label("Default Payment Terms", `${cfg.defaultPaymentTerms} days`);
+      logger.label("API Base URL", cfg.apiBaseUrl);
+
+      console.log();
+      console.log(chalk.bold("API Status:"));
+      const apiHealthy = await checkApiHealth();
+      logger.label(
+        "  Connection",
+        apiHealthy ? chalk.green("Connected") : chalk.red("Not available")
+      );
+    });
+
+  config
+    .command("set <key> <value>")
+    .description("Set a configuration value")
+    .action((key, value) => {
+      const cfg = loadConfig();
+      const validKeys = [
+        "defaultCurrency",
+        "defaultVatRate",
+        "defaultPaymentTerms",
+        "apiBaseUrl",
+      ];
+
+      if (!validKeys.includes(key)) {
+        logger.error(`Invalid config key: ${key}`);
+        logger.info(`Valid keys: ${validKeys.join(", ")}`);
+        process.exit(1);
+      }
+
+      if (key === "defaultVatRate" || key === "defaultPaymentTerms") {
+        (cfg as unknown as Record<string, number>)[key] = parseFloat(value);
+      } else {
+        (cfg as unknown as Record<string, string>)[key] = value;
+      }
+
+      saveConfig(cfg);
+      logger.success(`Set ${key} = ${value}`);
+    });
+
+  config
+    .command("reset")
+    .description("Reset configuration to defaults")
+    .action(() => {
+      const defaultConfig: Config = {
+        defaultCurrency: "EUR",
+        defaultVatRate: 19,
+        defaultPaymentTerms: 30,
+        apiBaseUrl: "http://localhost:8007/api/v1",
+      };
+
+      saveConfig(defaultConfig);
+      logger.success("Configuration reset to defaults");
+    });
+
+  config
+    .command("test")
+    .description("Test API connection")
+    .action(async () => {
+      logger.info("Testing API connection...");
+
+      const healthy = await checkApiHealth();
+
+      if (healthy) {
+        logger.success("API connection successful");
+      } else {
+        logger.error("API connection failed");
+        logger.info("Make sure the API service is running:");
+        logger.info("  docker-compose up -d");
+      }
+    });
+}

package/skills/skill-invoice/src/commands/generate.ts

@@ -0,0 +1,177 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import {
+  listCompaniesLocal,
+  loadCompanyLocal,
+  createLocalInvoice,
+} from "../lib/storage.js";
+import { createInvoice, downloadInvoicePdf, checkApiHealth } from "../lib/api.js";
+import { logger } from "../utils/logger.js";
+import { getInvoicesDir, ensureDir } from "../utils/paths.js";
+import { join } from "path";
+
+export function registerGenerateCommand(program: Command): void {
+  program
+    .command("generate")
+    .description("Generate a new invoice")
+    .requiredOption("--issuer <id>", "Issuer company ID")
+    .requiredOption("--client <id>", "Client company ID")
+    .requiredOption("-d, --description <description>", "Item description")
+    .requiredOption("-a, --amount <amount>", "Item amount (price)")
+    .option("-q, --quantity <quantity>", "Item quantity", "1")
+    .option("-c, --currency <currency>", "Currency code", "EUR")
+    .option("-v, --vat <rate>", "VAT rate percentage", "19")
+    .option("-n, --notes <notes>", "Invoice notes")
+    .option("--due-days <days>", "Payment due in days", "30")
+    .option("--api", "Use API instead of local storage")
+    .option("-o, --output <file>", "Output PDF file path")
+    .option("--json", "Output result as JSON")
+    .action(async (options) => {
+      try {
+        const useApi = options.api && (await checkApiHealth());
+
+        // Load companies
+        const issuer = loadCompanyLocal(options.issuer);
+        const client = loadCompanyLocal(options.client);
+
+        if (!issuer) {
+          logger.error(`Issuer company not found: ${options.issuer}`);
+          logger.info("Use 'service-invoicegenerate companies list' to see available companies");
+          process.exit(1);
+        }
+
+        if (!client) {
+          logger.error(`Client company not found: ${options.client}`);
+          logger.info("Use 'service-invoicegenerate companies list' to see available companies");
+          process.exit(1);
+        }
+
+        const items = [
+          {
+            description: options.description,
+            quantity: parseFloat(options.quantity),
+            unitPrice: parseFloat(options.amount),
+            vatRate: parseFloat(options.vat),
+          },
+        ];
+
+        logger.header("Invoice Generator");
+        logger.label("Issuer", issuer.name);
+        logger.label("Client", client.name);
+        logger.label("Amount", `${options.amount} ${options.currency}`);
+        logger.label("VAT", `${options.vat}%`);
+        logger.divider();
+
+        let invoice;
+
+        if (useApi) {
+          logger.info("Generating invoice via API...");
+          invoice = await createInvoice({
+            issuer,
+            client,
+            items,
+            currency: options.currency,
+            notes: options.notes,
+          });
+        } else {
+          logger.info("Generating invoice locally...");
+          invoice = createLocalInvoice(issuer, client, items, {
+            currency: options.currency,
+            notes: options.notes,
+            dueInDays: parseInt(options.dueDays, 10),
+          });
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(invoice, null, 2));
+        } else {
+          console.log();
+          logger.success("Invoice generated successfully");
+          console.log();
+          logger.label("Invoice Number", invoice.number);
+          logger.label("Subtotal", `${invoice.subtotal.toFixed(2)} ${invoice.currency}`);
+          logger.label("VAT", `${invoice.vatAmount.toFixed(2)} ${invoice.currency}`);
+          logger.label("Total", chalk.bold(`${invoice.total.toFixed(2)} ${invoice.currency}`));
+          logger.label("Issue Date", invoice.issueDate);
+          logger.label("Due Date", invoice.dueDate);
+          logger.label("ID", invoice.id);
+        }
+
+        // Download PDF if output specified and API available
+        if (options.output && useApi) {
+          logger.info("Downloading PDF...");
+          await downloadInvoicePdf(invoice.id, options.output);
+          logger.success(`PDF saved to ${options.output}`);
+        } else if (options.output) {
+          // Save JSON locally as fallback
+          const outputPath = options.output.replace(/\.pdf$/i, ".json");
+          const fs = require("fs");
+          fs.writeFileSync(outputPath, JSON.stringify(invoice, null, 2));
+          logger.success(`Invoice JSON saved to ${outputPath}`);
+          logger.warning("PDF generation requires running API service");
+        }
+      } catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("quick")
+    .description("Quick invoice generation with minimal options")
+    .requiredOption("--from <name>", "Issuer company name (will create if not exists)")
+    .requiredOption("--to <name>", "Client company name (will create if not exists)")
+    .requiredOption("-a, --amount <amount>", "Invoice amount")
+    .requiredOption("-d, --description <description>", "Service/product description")
+    .option("-c, --currency <currency>", "Currency code", "EUR")
+    .option("--json", "Output result as JSON")
+    .action(async (options) => {
+      try {
+        const {
+          createLocalCompany,
+          listCompaniesLocal,
+          createLocalInvoice,
+        } = await import("../lib/storage.js");
+
+        // Find or create issuer
+        let issuer = listCompaniesLocal().find(
+          (c) => c.name.toLowerCase() === options.from.toLowerCase()
+        );
+        if (!issuer) {
+          issuer = createLocalCompany({ name: options.from });
+          logger.info(`Created issuer company: ${issuer.name}`);
+        }
+
+        // Find or create client
+        let client = listCompaniesLocal().find(
+          (c) => c.name.toLowerCase() === options.to.toLowerCase()
+        );
+        if (!client) {
+          client = createLocalCompany({ name: options.to });
+          logger.info(`Created client company: ${client.name}`);
+        }
+
+        const items = [
+          {
+            description: options.description,
+            quantity: 1,
+            unitPrice: parseFloat(options.amount),
+          },
+        ];
+
+        const invoice = createLocalInvoice(issuer, client, items, {
+          currency: options.currency,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(invoice, null, 2));
+        } else {
+          logger.success(`Invoice ${invoice.number} created`);
+          logger.label("Total", `${invoice.total.toFixed(2)} ${invoice.currency}`);
+        }
+      } catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+}

package/skills/skill-invoice/src/commands/invoices.ts

@@ -0,0 +1,218 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import {
+  listInvoicesLocal,
+  loadInvoiceLocal,
+} from "../lib/storage.js";
+import {
+  listInvoices,
+  getInvoice,
+  downloadInvoicePdf,
+  checkApiHealth,
+} from "../lib/api.js";
+import { logger } from "../utils/logger.js";
+import type { Invoice } from "../types/index.js";
+
+export function registerInvoicesCommand(program: Command): void {
+  const invoices = program.command("invoices").description("Manage invoices");
+
+  invoices
+    .command("list")
+    .alias("ls")
+    .description("List all invoices")
+    .option("-n, --limit <count>", "Limit number of invoices", "20")
+    .option("--api", "Use API instead of local storage")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        let invoiceList: Invoice[];
+
+        if (options.api && (await checkApiHealth())) {
+          invoiceList = await listInvoices();
+        } else {
+          invoiceList = listInvoicesLocal();
+        }
+
+        invoiceList = invoiceList.slice(0, parseInt(options.limit, 10));
+
+        if (options.json) {
+          console.log(JSON.stringify(invoiceList, null, 2));
+          return;
+        }
+
+        logger.header("Invoices");
+
+        if (invoiceList.length === 0) {
+          logger.warning("No invoices found");
+          logger.info("Generate one with: service-invoicegenerate generate --issuer <id> --client <id> -d 'Description' -a 1000");
+          return;
+        }
+
+        for (const invoice of invoiceList) {
+          console.log();
+          console.log(
+            chalk.bold.cyan(invoice.number),
+            getStatusBadge(invoice.status)
+          );
+          console.log(
+            chalk.gray(`${invoice.issuer.name} → ${invoice.client.name}`)
+          );
+          console.log(
+            chalk.yellow("Total:"),
+            chalk.bold(`${invoice.total.toFixed(2)} ${invoice.currency}`)
+          );
+          console.log(
+            chalk.yellow("Date:"),
+            invoice.issueDate,
+            chalk.gray(`Due: ${invoice.dueDate}`)
+          );
+        }
+      } catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+
+  invoices
+    .command("show <id>")
+    .description("Show invoice details")
+    .option("--json", "Output as JSON")
+    .action((id, options) => {
+      // Try to find by ID or invoice number
+      let invoice = loadInvoiceLocal(id);
+
+      if (!invoice) {
+        const allInvoices = listInvoicesLocal();
+        invoice =
+          allInvoices.find((inv) => inv.number === id) ||
+          allInvoices.find((inv) => inv.id.startsWith(id)) ||
+          null;
+      }
+
+      if (!invoice) {
+        logger.error(`Invoice not found: ${id}`);
+        process.exit(1);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify(invoice, null, 2));
+        return;
+      }
+
+      logger.header(`Invoice ${invoice.number}`);
+      console.log(getStatusBadge(invoice.status));
+      console.log();
+
+      logger.label("ID", invoice.id);
+      logger.label("Issue Date", invoice.issueDate);
+      logger.label("Due Date", invoice.dueDate);
+
+      console.log();
+      console.log(chalk.bold("From:"));
+      logger.label("  Name", invoice.issuer.name);
+      if (invoice.issuer.vatNumber) {
+        logger.label("  VAT", invoice.issuer.vatNumber);
+      }
+
+      console.log();
+      console.log(chalk.bold("To:"));
+      logger.label("  Name", invoice.client.name);
+      if (invoice.client.vatNumber) {
+        logger.label("  VAT", invoice.client.vatNumber);
+      }
+
+      console.log();
+      console.log(chalk.bold("Items:"));
+      for (const item of invoice.items) {
+        console.log(
+          chalk.gray("  •"),
+          item.description,
+          chalk.gray(`(${item.quantity} x ${item.unitPrice.toFixed(2)})`)
+        );
+      }
+
+      console.log();
+      logger.divider();
+      logger.label("Subtotal", `${invoice.subtotal.toFixed(2)} ${invoice.currency}`);
+      logger.label("VAT", `${invoice.vatAmount.toFixed(2)} ${invoice.currency}`);
+      console.log(
+        chalk.bold("Total:"),
+        chalk.bold.green(`${invoice.total.toFixed(2)} ${invoice.currency}`)
+      );
+
+      if (invoice.notes) {
+        console.log();
+        console.log(chalk.bold("Notes:"));
+        console.log(chalk.gray(invoice.notes));
+      }
+    });
+
+  invoices
+    .command("download <id>")
+    .description("Download invoice as PDF")
+    .requiredOption("-o, --output <file>", "Output file path")
+    .action(async (id, options) => {
+      try {
+        if (!(await checkApiHealth())) {
+          logger.error("API service not available");
+          logger.info("Start the API service with: docker-compose up -d");
+          process.exit(1);
+        }
+
+        // Find invoice
+        let invoice = loadInvoiceLocal(id);
+        if (!invoice) {
+          const allInvoices = listInvoicesLocal();
+          invoice =
+            allInvoices.find((inv) => inv.number === id) ||
+            allInvoices.find((inv) => inv.id.startsWith(id)) ||
+            null;
+        }
+
+        const invoiceId = invoice?.id || id;
+
+        logger.info(`Downloading PDF for invoice ${id}...`);
+        await downloadInvoicePdf(invoiceId, options.output);
+        logger.success(`PDF saved to ${options.output}`);
+      } catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+
+  invoices
+    .command("export <id>")
+    .description("Export invoice as JSON")
+    .requiredOption("-o, --output <file>", "Output file path")
+    .action((id, options) => {
+      let invoice = loadInvoiceLocal(id);
+
+      if (!invoice) {
+        const allInvoices = listInvoicesLocal();
+        invoice =
+          allInvoices.find((inv) => inv.number === id) ||
+          allInvoices.find((inv) => inv.id.startsWith(id)) ||
+          null;
+      }
+
+      if (!invoice) {
+        logger.error(`Invoice not found: ${id}`);
+        process.exit(1);
+      }
+
+      const fs = require("fs");
+      fs.writeFileSync(options.output, JSON.stringify(invoice, null, 2));
+      logger.success(`Invoice exported to ${options.output}`);
+    });
+}
+
+function getStatusBadge(status: string): string {
+  const badges: Record<string, string> = {
+    draft: chalk.gray("[DRAFT]"),
+    sent: chalk.blue("[SENT]"),
+    paid: chalk.green("[PAID]"),
+    overdue: chalk.red("[OVERDUE]"),
+    cancelled: chalk.yellow("[CANCELLED]"),
+  };
+  return badges[status] || chalk.gray(`[${status.toUpperCase()}]`);
+}

package/skills/skill-invoice/src/lib/api.ts

@@ -0,0 +1,124 @@
+import type {
+  Company,
+  Invoice,
+  CreateInvoiceRequest,
+  ApiConfig,
+} from "../types/index.js";
+
+function getApiConfig(): ApiConfig {
+  return {
+    baseUrl: process.env.API_BASE_URL || "http://localhost:8007/api/v1",
+    timeout: parseInt(process.env.API_TIMEOUT || "30000", 10),
+  };
+}
+
+async function apiRequest<T>(
+  endpoint: string,
+  options: RequestInit = {}
+): Promise<T> {
+  const config = getApiConfig();
+  const url = `${config.baseUrl}${endpoint}`;
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), config.timeout);
+
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(
+        (error as { detail?: string }).detail ||
+          `API error: ${response.status} ${response.statusText}`
+      );
+    }
+
+    return response.json() as Promise<T>;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function listCompanies(): Promise<Company[]> {
+  return apiRequest<Company[]>("/companies");
+}
+
+export async function getCompany(id: string): Promise<Company> {
+  return apiRequest<Company>(`/companies/${id}`);
+}
+
+export async function createCompany(
+  company: Omit<Company, "id">
+): Promise<Company> {
+  return apiRequest<Company>("/companies", {
+    method: "POST",
+    body: JSON.stringify(company),
+  });
+}
+
+export async function updateCompany(
+  id: string,
+  company: Partial<Company>
+): Promise<Company> {
+  return apiRequest<Company>(`/companies/${id}`, {
+    method: "PUT",
+    body: JSON.stringify(company),
+  });
+}
+
+export async function deleteCompany(id: string): Promise<void> {
+  await apiRequest<void>(`/companies/${id}`, {
+    method: "DELETE",
+  });
+}
+
+export async function listInvoices(): Promise<Invoice[]> {
+  return apiRequest<Invoice[]>("/invoices");
+}
+
+export async function getInvoice(id: string): Promise<Invoice> {
+  return apiRequest<Invoice>(`/invoices/${id}`);
+}
+
+export async function createInvoice(
+  request: CreateInvoiceRequest
+): Promise<Invoice> {
+  return apiRequest<Invoice>("/invoices", {
+    method: "POST",
+    body: JSON.stringify(request),
+  });
+}
+
+export async function downloadInvoicePdf(
+  id: string,
+  outputPath: string
+): Promise<void> {
+  const config = getApiConfig();
+  const url = `${config.baseUrl}/invoices/${id}/pdf`;
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download PDF: ${response.statusText}`);
+  }
+
+  const buffer = await response.arrayBuffer();
+  const fs = require("fs");
+  fs.writeFileSync(outputPath, Buffer.from(buffer));
+}
+
+export async function checkApiHealth(): Promise<boolean> {
+  try {
+    const config = getApiConfig();
+    const response = await fetch(`${config.baseUrl.replace("/api/v1", "")}/health`);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}