tiime-cli 1.1.0

package/dist/cli.js

@@ -0,0 +1,2639 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { defineCommand as defineCommand14, renderUsage, runMain } from "citty";
+
+// src/cli/commands/auth.ts
+import * as p from "@clack/prompts";
+import { defineCommand } from "citty";
+
+// src/sdk/auth.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { ofetch } from "ofetch";
+var AUTH0_DOMAIN = "auth0.tiime.fr";
+var AUTH0_CLIENT_ID = "iEbsbe3o66gcTBfGRa012kj1Rb6vjAND";
+var AUTH0_AUDIENCE = "https://chronos/";
+var CONFIG_DIR = join(homedir(), ".config", "tiime");
+var AUTH_FILE = join(CONFIG_DIR, "auth.json");
+var KEYCHAIN_ACCOUNT = "tiime-cli";
+var KEYCHAIN_SERVICE = "tiime-credentials";
+var saveCredentialsToKeychain = (email, password2) => {
+  try {
+    const payload = JSON.stringify({ email, password: password2 });
+    execSync(
+      `security add-generic-password -a "${KEYCHAIN_ACCOUNT}" -s "${KEYCHAIN_SERVICE}" -w '${payload.replace(/'/g, "'\\''")}' -U`,
+      { stdio: "ignore" }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+};
+var loadCredentialsFromKeychain = () => {
+  try {
+    const raw = execSync(
+      `security find-generic-password -a "${KEYCHAIN_ACCOUNT}" -s "${KEYCHAIN_SERVICE}" -w`,
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    const data = JSON.parse(raw);
+    if (typeof data === "object" && data !== null && "email" in data && "password" in data && typeof data.email === "string" && typeof data.password === "string") {
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var saveCredentialsToFile = (email, password2) => {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const filePath = join(CONFIG_DIR, "credentials.json");
+  writeFileSync(filePath, JSON.stringify({ email, password: password2 }, null, 2), {
+    mode: 384
+  });
+};
+var loadCredentialsFromFile = () => {
+  try {
+    const filePath = join(CONFIG_DIR, "credentials.json");
+    if (existsSync(filePath)) {
+      const data = JSON.parse(readFileSync(filePath, "utf-8"));
+      if (typeof data === "object" && data !== null && "email" in data && "password" in data && typeof data.email === "string" && typeof data.password === "string") {
+        return data;
+      }
+    }
+  } catch {
+  }
+  return null;
+};
+var saveCredentials = (email, password2) => {
+  if (!saveCredentialsToKeychain(email, password2)) {
+    saveCredentialsToFile(email, password2);
+  }
+};
+var loadCredentials = () => {
+  return loadCredentialsFromKeychain() ?? loadCredentialsFromFile();
+};
+var TokenManager = class {
+  tokens = null;
+  constructor() {
+    this.loadFromDisk();
+  }
+  async login(email, password2) {
+    const response = await ofetch(`https://${AUTH0_DOMAIN}/oauth/token`, {
+      method: "POST",
+      body: {
+        grant_type: "password",
+        client_id: AUTH0_CLIENT_ID,
+        audience: AUTH0_AUDIENCE,
+        scope: "openid email",
+        username: email,
+        password: password2
+      }
+    });
+    this.tokens = {
+      access_token: response.access_token,
+      expires_at: Date.now() + response.expires_in * 1e3
+    };
+    this.saveToDisk();
+    saveCredentials(email, password2);
+    return this.tokens;
+  }
+  async getValidToken() {
+    if (!this.tokens || this.isExpired()) {
+      const creds = loadCredentials();
+      if (creds) {
+        const tokens = await this.login(creds.email, creds.password);
+        return tokens.access_token;
+      }
+      throw new Error(
+        this.tokens ? "Token expired. Run `tiime auth login` to re-authenticate." : "Not authenticated. Run `tiime auth login` first."
+      );
+    }
+    return this.tokens.access_token;
+  }
+  isAuthenticated() {
+    return this.tokens !== null && !this.isExpired();
+  }
+  logout() {
+    this.tokens = null;
+    if (existsSync(AUTH_FILE)) {
+      writeFileSync(AUTH_FILE, "{}");
+    }
+  }
+  getTokenInfo() {
+    if (!this.tokens) {
+      return { email: null, expiresAt: null };
+    }
+    try {
+      const payload = JSON.parse(
+        Buffer.from(
+          this.tokens.access_token.split(".")[1],
+          "base64"
+        ).toString()
+      );
+      return {
+        email: payload["tiime/userEmail"] || null,
+        expiresAt: new Date(this.tokens.expires_at)
+      };
+    } catch {
+      return { email: null, expiresAt: new Date(this.tokens.expires_at) };
+    }
+  }
+  isExpired() {
+    if (!this.tokens) return true;
+    return Date.now() >= this.tokens.expires_at - 6e4;
+  }
+  loadFromDisk() {
+    try {
+      if (existsSync(AUTH_FILE)) {
+        const data = JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+        if (data.access_token && data.expires_at) {
+          this.tokens = data;
+        }
+      }
+    } catch {
+    }
+  }
+  saveToDisk() {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(AUTH_FILE, JSON.stringify(this.tokens, null, 2));
+  }
+};
+
+// src/cli/output.ts
+import Table from "cli-table3";
+import { consola } from "consola";
+
+// src/sdk/errors.ts
+var TiimeError = class extends Error {
+  constructor(message, status, endpoint, details) {
+    super(message);
+    this.status = status;
+    this.endpoint = endpoint;
+    this.details = details;
+    this.name = "TiimeError";
+  }
+  toJSON() {
+    return {
+      error: this.name,
+      message: this.message,
+      status: this.status,
+      endpoint: this.endpoint,
+      details: this.details
+    };
+  }
+};
+
+// src/cli/output.ts
+var formatArg = {
+  format: {
+    type: "string",
+    description: "Format de sortie (json, table, csv)",
+    default: "json"
+  }
+};
+var stringifyValue = (value) => {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+};
+var outputJson = (data) => {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+};
+var outputTable = (data) => {
+  if (Array.isArray(data) && data.length > 0 && typeof data[0] === "object" && data[0] !== null) {
+    const keys = Object.keys(data[0]);
+    const table = new Table({ head: keys });
+    for (const row of data) {
+      const record = row;
+      table.push(keys.map((key) => stringifyValue(record[key])));
+    }
+    process.stdout.write(`${table.toString()}
+`);
+  } else if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+    const table = new Table();
+    for (const [key, value] of Object.entries(
+      data
+    )) {
+      table.push({ [key]: stringifyValue(value) });
+    }
+    process.stdout.write(`${table.toString()}
+`);
+  } else {
+    outputJson(data);
+  }
+};
+var escapeCsvField = (value) => {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+};
+var outputCsv = (data) => {
+  if (Array.isArray(data) && data.length > 0 && typeof data[0] === "object" && data[0] !== null) {
+    const keys = Object.keys(data[0]);
+    const header = keys.map(escapeCsvField).join(",");
+    const lines = data.map((row) => {
+      const record = row;
+      return keys.map((key) => escapeCsvField(stringifyValue(record[key]))).join(",");
+    });
+    process.stdout.write(`${header}
+${lines.join("\n")}
+`);
+  } else if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+    const entries = Object.entries(data);
+    const header = "key,value";
+    const lines = entries.map(
+      ([key, value]) => `${escapeCsvField(key)},${escapeCsvField(stringifyValue(value))}`
+    );
+    process.stdout.write(`${header}
+${lines.join("\n")}
+`);
+  } else {
+    outputJson(data);
+  }
+};
+var output = (data, options) => {
+  const format = options?.format ?? "json";
+  if (!["json", "table", "csv"].includes(format)) {
+    process.stderr.write(
+      `${JSON.stringify({ error: `Format invalide : "${format}". Utilisez json, table ou csv.` })}
+`
+    );
+    process.exit(1);
+  }
+  switch (format) {
+    case "table":
+      outputTable(data);
+      break;
+    case "csv":
+      outputCsv(data);
+      break;
+    default:
+      outputJson(data);
+      break;
+  }
+};
+var outputColoredStatus = (data) => {
+  const {
+    company_id,
+    bank_accounts,
+    invoices,
+    pending_quotations,
+    total_clients,
+    unimputed_transactions
+  } = data;
+  console.error("");
+  console.error(`  \u{1F4CA} R\xE9sum\xE9 \u2014 Entreprise #${company_id}`);
+  for (const a of bank_accounts) {
+    console.error(
+      `  \u{1F4B0} Soldes : ${a.name} ${a.balance.toFixed(2)}${a.currency === "EUR" ? "\u20AC" : a.currency}`
+    );
+  }
+  console.error(
+    `  \u{1F4C4} Factures : ${invoices.drafts} brouillon(s), ${invoices.unpaid} impay\xE9e(s)`
+  );
+  console.error(`  \u{1F4CB} Devis en cours : ${pending_quotations}`);
+  console.error(`  \u{1F465} Clients : ${total_clients}`);
+  if (unimputed_transactions > 0) {
+    console.error(`  \u26A0\uFE0F  Transactions non imput\xE9es : ${unimputed_transactions}`);
+  } else {
+    console.error(`  \u2705 Toutes les transactions sont imput\xE9es`);
+  }
+  console.error("");
+};
+var outputError = (error) => {
+  if (error instanceof TiimeError) {
+    process.stderr.write(`${JSON.stringify(error.toJSON())}
+`);
+  } else {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${JSON.stringify({ error: message })}
+`);
+  }
+  process.exit(1);
+};
+
+// src/cli/commands/auth.ts
+var authCommand = defineCommand({
+  meta: { name: "auth", description: "Gestion de l'authentification" },
+  subCommands: {
+    login: defineCommand({
+      meta: { name: "login", description: "Se connecter \xE0 Tiime" },
+      args: {
+        email: {
+          type: "string",
+          description: "Adresse email"
+        },
+        password: {
+          type: "string",
+          description: "Mot de passe"
+        }
+      },
+      async run({ args }) {
+        const hasArgs = args.email && args.password;
+        if (hasArgs) {
+          try {
+            const tm = new TokenManager();
+            await tm.login(args.email, args.password);
+            const info = tm.getTokenInfo();
+            output({
+              status: "authenticated",
+              email: info.email,
+              expires_at: info.expiresAt?.toISOString()
+            });
+          } catch (e) {
+            outputError(e);
+          }
+          return;
+        }
+        p.intro("Connexion \xE0 Tiime");
+        const email = await p.text({
+          message: "Adresse email",
+          placeholder: "vous@example.com",
+          validate: (value) => {
+            if (!value || !value.includes("@")) return "Adresse email invalide";
+          }
+        });
+        if (p.isCancel(email)) {
+          p.cancel("Connexion annul\xE9e.");
+          return;
+        }
+        const password2 = await p.password({
+          message: "Mot de passe",
+          validate: (value) => {
+            if (!value) return "Le mot de passe est requis";
+          }
+        });
+        if (p.isCancel(password2)) {
+          p.cancel("Connexion annul\xE9e.");
+          return;
+        }
+        const s = p.spinner();
+        s.start("Authentification en cours...");
+        try {
+          const tm = new TokenManager();
+          await tm.login(email, password2);
+          const info = tm.getTokenInfo();
+          s.stop("Authentification r\xE9ussie");
+          p.outro(`Connect\xE9 en tant que ${info.email ?? email}`);
+        } catch (e) {
+          s.stop("Authentification \xE9chou\xE9e");
+          const message = e instanceof Error ? e.message : "Erreur inconnue";
+          p.cancel(message);
+        }
+      }
+    }),
+    logout: defineCommand({
+      meta: { name: "logout", description: "Se d\xE9connecter de Tiime" },
+      run() {
+        const tm = new TokenManager();
+        tm.logout();
+        output({ status: "logged_out" });
+      }
+    }),
+    status: defineCommand({
+      meta: {
+        name: "status",
+        description: "Afficher le statut d'authentification"
+      },
+      run() {
+        const tm = new TokenManager();
+        const info = tm.getTokenInfo();
+        output({
+          authenticated: tm.isAuthenticated(),
+          email: info.email,
+          expires_at: info.expiresAt?.toISOString() ?? null
+        });
+      }
+    })
+  }
+});
+
+// src/cli/commands/bank.ts
+import { defineCommand as defineCommand2 } from "citty";
+
+// src/sdk/client.ts
+import { ofetch as ofetch2 } from "ofetch";
+
+// src/sdk/resources/bank-accounts.ts
+var BankAccountsResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  list(enabled) {
+    return this.fetch(
+      `/companies/${this.companyId}/bank_accounts`,
+      { query: enabled !== void 0 ? { enabled } : void 0 }
+    );
+  }
+  get(bankAccountId) {
+    return this.fetch(
+      `/companies/${this.companyId}/bank_accounts/${bankAccountId}`
+    );
+  }
+  async balance() {
+    const accounts = await this.list(true);
+    return accounts.map((a) => ({
+      name: a.name,
+      balance_amount: a.balance_amount,
+      currency: a.balance_currency
+    }));
+  }
+};
+
+// src/sdk/resources/bank-transactions.ts
+var BankTransactionsResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  list(params) {
+    const start = ((params?.page ?? 1) - 1) * (params?.pageSize ?? 100);
+    const end = start + (params?.pageSize ?? 100);
+    const { page: _, pageSize: __, from, to, search, ...query } = params ?? {};
+    if (from) query.transaction_date_start = from;
+    if (to) query.transaction_date_end = to;
+    if (search) query.wording = search;
+    return this.fetch(
+      `/companies/${this.companyId}/bank_transactions`,
+      {
+        query: { hide_refused: false, ...query },
+        headers: {
+          Accept: "application/vnd.tiime.bank_transactions.v2+json,application/vnd.tiime.bank_transactions.without_documents+json",
+          Range: `items=${start}-${end}`
+        }
+      }
+    );
+  }
+  async listAll(params) {
+    const pageSize = params?.pageSize ?? 200;
+    const all = [];
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const response = await this.list({ ...params, page, pageSize });
+      all.push(...response.transactions);
+      hasMore = response.transactions.length === pageSize;
+      page++;
+    }
+    return all;
+  }
+  unimputed() {
+    return this.fetch(
+      `/companies/${this.companyId}/bank_transactions/unimputed`
+    );
+  }
+};
+
+// src/sdk/resources/clients.ts
+var ClientsResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  list(params) {
+    return this.fetch(`/companies/${this.companyId}/clients`, {
+      query: params,
+      headers: {
+        Accept: "application/vnd.tiime.timeline.v2+json",
+        Range: "items=0-*"
+      }
+    });
+  }
+  get(clientId) {
+    return this.fetch(
+      `/companies/${this.companyId}/clients/${clientId}`
+    );
+  }
+  create(params) {
+    return this.fetch(`/companies/${this.companyId}/clients`, {
+      method: "POST",
+      body: params
+    });
+  }
+  search(query) {
+    return this.fetch(`/companies/${this.companyId}/clients`, {
+      query: { search: query },
+      headers: {
+        Accept: "application/vnd.tiime.timeline.v2+json",
+        Range: "items=0-*"
+      }
+    });
+  }
+};
+
+// src/sdk/resources/company.ts
+var CompanyResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  get() {
+    return this.fetch(`/companies/${this.companyId}`);
+  }
+  users() {
+    return this.fetch(`/companies/${this.companyId}/users`);
+  }
+  appConfig() {
+    return this.fetch(`/companies/${this.companyId}/app_config`);
+  }
+  accountingPeriod(rangeYear = 1) {
+    return this.fetch(
+      `/companies/${this.companyId}/accounting_period/current`,
+      { query: { range_year: rangeYear } }
+    );
+  }
+  tiles(keys) {
+    return this.fetch(`/companies/${this.companyId}/tiles`, {
+      query: { keys: keys.join(",") }
+    });
+  }
+  dashboardBlocks(displayGroup = "monitoring") {
+    return this.fetch(`/companies/${this.companyId}/dashboard_blocks`, {
+      query: { sorts: "rank:asc", display_group: displayGroup }
+    });
+  }
+};
+
+// src/sdk/resources/documents.ts
+var DocumentsResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  list(params) {
+    const start = ((params?.page ?? 1) - 1) * (params?.pageSize ?? 25);
+    const end = start + (params?.pageSize ?? 25);
+    const { page: _, pageSize: __, ...query } = params ?? {};
+    return this.fetch(`/companies/${this.companyId}/documents`, {
+      query: {
+        sorts: "created_at:desc",
+        expand: "file_family,preview_available",
+        ...query
+      },
+      headers: {
+        Accept: "application/vnd.tiime.documents.v2+json,application/vnd.tiime.docs.query+json,application/vnd.tiime.docs.imputation+json",
+        Range: `items=${start}-${end}`
+      }
+    });
+  }
+  categories() {
+    return this.fetch(
+      `/companies/${this.companyId}/document_categories`,
+      {
+        headers: {
+          Accept: "application/vnd.tiime.documents.v3+json"
+        }
+      }
+    );
+  }
+  preview(documentId) {
+    return this.fetch(
+      `/companies/${this.companyId}/documents/${documentId}/preview`
+    );
+  }
+  upload(file, filename, type) {
+    const formData = new FormData();
+    formData.append("file", new Blob([file]), filename);
+    if (type) {
+      formData.append("type", type);
+    }
+    return this.fetch(`/companies/${this.companyId}/documents`, {
+      method: "POST",
+      body: formData
+    });
+  }
+  async download(documentId) {
+    return this.fetch(
+      `/companies/${this.companyId}/documents/${documentId}/download`,
+      {
+        headers: { Accept: "application/octet-stream" }
+      }
+    );
+  }
+};
+
+// src/sdk/resources/expense-reports.ts
+var ExpenseReportsResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  list(sorts = "metadata.date:desc") {
+    return this.fetch(
+      `/companies/${this.companyId}/expense_reports`,
+      {
+        query: { expand: "total_amount", sorts },
+        headers: { Range: "items=0-25" }
+      }
+    );
+  }
+  get(expenseReportId) {
+    return this.fetch(
+      `/companies/${this.companyId}/expense_reports/${expenseReportId}`
+    );
+  }
+  create(params) {
+    return this.fetch(
+      `/companies/${this.companyId}/expense_reports`,
+      {
+        method: "POST",
+        body: params
+      }
+    );
+  }
+};
+
+// src/sdk/resources/invoices.ts
+var DEFAULT_INVOICE_TEMPLATE = {
+  template: "advanced",
+  status: "draft",
+  due_date_mode: "thirty_days",
+  title_enabled: true,
+  free_field_enabled: false,
+  free_field: "",
+  discount_enabled: false,
+  bank_detail_enabled: true,
+  payment_condition_enabled: true,
+  payment_condition: "En cas de retard de paiement, une p\xE9nalit\xE9 de 3 fois le taux d'int\xE9r\xEAt l\xE9gal sera appliqu\xE9e, \xE0 laquelle s'ajoutera une indemnit\xE9 forfaitaire pour frais de recouvrement de 40\u20AC.",
+  text_lines: []
+};
+var InvoicesResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  list(params) {
+    const start = ((params?.page ?? 1) - 1) * (params?.pageSize ?? 25);
+    const end = start + (params?.pageSize ?? 25);
+    const query = {
+      sorts: params?.sorts ?? "invoice_number:desc"
+    };
+    if (params?.status) query.status = params.status;
+    return this.fetch(`/companies/${this.companyId}/invoices`, {
+      query,
+      headers: { Range: `items=${start}-${end}` }
+    });
+  }
+  async listAll(params) {
+    const pageSize = params?.pageSize ?? 100;
+    const all = [];
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const batch = await this.list({
+        sorts: params?.sorts,
+        status: params?.status,
+        page,
+        pageSize
+      });
+      all.push(...batch);
+      hasMore = batch.length === pageSize;
+      page++;
+    }
+    return all;
+  }
+  get(invoiceId) {
+    return this.fetch(
+      `/companies/${this.companyId}/invoices/${invoiceId}`
+    );
+  }
+  create(params) {
+    const body = { ...DEFAULT_INVOICE_TEMPLATE, ...params };
+    for (const line of body.lines ?? []) {
+      line.line_amount = line.quantity * line.unit_amount;
+      line.sequence ??= 1;
+      line.invoicing_category_type ??= "benefit";
+      line.discount_description ??= "";
+      line.discount_amount ??= null;
+      line.discount_percentage ??= null;
+    }
+    return this.fetch(`/companies/${this.companyId}/invoices`, {
+      method: "POST",
+      body
+    });
+  }
+  update(invoiceId, params) {
+    return this.fetch(
+      `/companies/${this.companyId}/invoices/${invoiceId}`,
+      {
+        method: "PUT",
+        body: params
+      }
+    );
+  }
+  send(invoiceId, params) {
+    return this.fetch(
+      `/companies/${this.companyId}/invoices/${invoiceId}/send`,
+      {
+        method: "POST",
+        body: params
+      }
+    );
+  }
+  async downloadPdf(invoiceId) {
+    return this.fetch(
+      `/companies/${this.companyId}/invoices/${invoiceId}/pdf`,
+      {
+        headers: { Accept: "application/pdf" }
+      }
+    );
+  }
+  delete(invoiceId) {
+    return this.fetch(
+      `/companies/${this.companyId}/invoices/${invoiceId}`,
+      { method: "DELETE" }
+    );
+  }
+  async duplicate(invoiceId, overrides) {
+    const source = await this.get(invoiceId);
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const lines = source.lines.map((l) => ({
+      description: l.description,
+      quantity: overrides?.quantity ?? l.quantity,
+      unit_amount: l.unit_amount,
+      vat_type: l.vat_type,
+      invoicing_unit: l.invoicing_unit,
+      invoicing_category_type: l.invoicing_category_type,
+      article: l.article
+    }));
+    return this.create({
+      client: source.client_id ? { id: source.client_id } : null,
+      emission_date: overrides?.emission_date ?? today,
+      title: source.title,
+      title_enabled: !!source.title,
+      lines,
+      status: "draft"
+    });
+  }
+};
+
+// src/sdk/resources/labels.ts
+var LabelsResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  list() {
+    return this.fetch(`/companies/${this.companyId}/labels`, {
+      headers: {
+        Accept: "application/vnd.tiime.labels.v2+json"
+      }
+    });
+  }
+  standard() {
+    return this.fetch(`/companies/${this.companyId}/standard_labels`);
+  }
+  tags() {
+    return this.fetch(`/companies/${this.companyId}/tags`, {
+      query: { expand: "tag_detail" }
+    });
+  }
+};
+
+// src/sdk/resources/quotations.ts
+var QuotationsResource = class {
+  constructor(fetch, companyId) {
+    this.fetch = fetch;
+    this.companyId = companyId;
+  }
+  list(expand = "invoices") {
+    return this.fetch(`/companies/${this.companyId}/quotations`, {
+      query: { expand },
+      headers: { Range: "items=0-25" }
+    });
+  }
+  get(quotationId) {
+    return this.fetch(
+      `/companies/${this.companyId}/quotations/${quotationId}`
+    );
+  }
+  create(params) {
+    return this.fetch(`/companies/${this.companyId}/quotations`, {
+      method: "POST",
+      body: params
+    });
+  }
+  async downloadPdf(quotationId) {
+    return this.fetch(
+      `/companies/${this.companyId}/quotations/${quotationId}/pdf`,
+      {
+        headers: { Accept: "application/pdf" }
+      }
+    );
+  }
+  send(quotationId, params) {
+    return this.fetch(
+      `/companies/${this.companyId}/quotations/${quotationId}/send`,
+      {
+        method: "POST",
+        body: params
+      }
+    );
+  }
+};
+
+// src/sdk/resources/users.ts
+var UsersResource = class {
+  constructor(fetch) {
+    this.fetch = fetch;
+  }
+  me() {
+    return this.fetch("/users/me");
+  }
+  legalInformations() {
+    return this.fetch("/users/me/legal_informations");
+  }
+  settings(companyId) {
+    return this.fetch(`/users/me/companies/${companyId}/settings`);
+  }
+};
+
+// src/sdk/client.ts
+var BASE_URL = "https://chronos-api.tiime-apps.com/v1";
+var TiimeClient = class {
+  fetch;
+  tokenManager;
+  companyId;
+  constructor(options) {
+    this.companyId = options.companyId;
+    this.tokenManager = options.tokenManager ?? new TokenManager();
+    this.fetch = ofetch2.create({
+      baseURL: BASE_URL,
+      retry: 2,
+      retryDelay: 500,
+      retryStatusCodes: [408, 429, 500, 502, 503, 504],
+      headers: {
+        "tiime-app": "tiime",
+        "tiime-app-version": "4.30.3",
+        "tiime-app-platform": "cli"
+      },
+      onRequest: async ({ options: options2 }) => {
+        const token = await this.tokenManager.getValidToken();
+        options2.headers.set("Authorization", `Bearer ${token}`);
+      },
+      onResponseError: ({ request, response }) => {
+        throw new TiimeError(
+          response.statusText || `HTTP ${response.status}`,
+          response.status,
+          String(request),
+          response._data
+        );
+      }
+    });
+  }
+  listCompanies() {
+    return this.fetch("/companies", {
+      headers: {
+        Accept: "application/vnd.tiime.companies.v2+json",
+        Range: "items=0-101"
+      }
+    });
+  }
+  get users() {
+    return new UsersResource(this.fetch);
+  }
+  get company() {
+    return new CompanyResource(this.fetch, this.companyId);
+  }
+  get clients() {
+    return new ClientsResource(this.fetch, this.companyId);
+  }
+  get invoices() {
+    return new InvoicesResource(this.fetch, this.companyId);
+  }
+  get quotations() {
+    return new QuotationsResource(this.fetch, this.companyId);
+  }
+  get bankAccounts() {
+    return new BankAccountsResource(this.fetch, this.companyId);
+  }
+  get bankTransactions() {
+    return new BankTransactionsResource(this.fetch, this.companyId);
+  }
+  get documents() {
+    return new DocumentsResource(this.fetch, this.companyId);
+  }
+  get expenseReports() {
+    return new ExpenseReportsResource(this.fetch, this.companyId);
+  }
+  get labels() {
+    return new LabelsResource(this.fetch, this.companyId);
+  }
+};
+
+// src/cli/config.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var CONFIG_DIR2 = join2(homedir2(), ".config", "tiime");
+var CONFIG_FILE = join2(CONFIG_DIR2, "config.json");
+var loadConfig = () => {
+  try {
+    if (existsSync2(CONFIG_FILE)) {
+      return JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+};
+var saveConfig = (config) => {
+  if (!existsSync2(CONFIG_DIR2)) {
+    mkdirSync2(CONFIG_DIR2, { recursive: true });
+  }
+  writeFileSync2(CONFIG_FILE, JSON.stringify(config, null, 2));
+};
+var getCompanyId = () => {
+  const config = loadConfig();
+  if (!config.companyId) {
+    throw new Error(
+      "Aucune entreprise configur\xE9e. Ex\xE9cutez `tiime company use <id>` d'abord."
+    );
+  }
+  return config.companyId;
+};
+
+// src/cli/commands/bank.ts
+var bankCommand = defineCommand2({
+  meta: { name: "bank", description: "Comptes bancaires et transactions" },
+  subCommands: {
+    balance: defineCommand2({
+      meta: {
+        name: "balance",
+        description: "Afficher les soldes des comptes"
+      },
+      args: { ...formatArg },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const balances = await client.bankAccounts.balance();
+          output(balances, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    accounts: defineCommand2({
+      meta: { name: "accounts", description: "Lister les comptes bancaires" },
+      args: {
+        ...formatArg,
+        enabled: {
+          type: "boolean",
+          description: "Uniquement les comptes actifs",
+          default: true
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const accounts = await client.bankAccounts.list(args.enabled);
+          output(accounts, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    transactions: defineCommand2({
+      meta: {
+        name: "transactions",
+        description: "Lister les transactions bancaires"
+      },
+      args: {
+        "bank-account": {
+          type: "string",
+          description: "Filtrer par ID de compte bancaire"
+        },
+        "hide-refused": {
+          type: "boolean",
+          description: "Masquer les transactions refus\xE9es",
+          default: false
+        },
+        sort: {
+          type: "string",
+          description: "Tri champ:direction (ex: date:desc)"
+        },
+        page: { type: "string", description: "Num\xE9ro de page", default: "1" },
+        "page-size": {
+          type: "string",
+          description: "\xC9l\xE9ments par page",
+          default: "100"
+        },
+        from: {
+          type: "string",
+          description: "Date de d\xE9but (YYYY-MM-DD)"
+        },
+        to: {
+          type: "string",
+          description: "Date de fin (YYYY-MM-DD)"
+        },
+        search: {
+          type: "string",
+          description: "Rechercher par libell\xE9"
+        },
+        all: {
+          type: "boolean",
+          description: "R\xE9cup\xE9rer toutes les pages",
+          default: false
+        },
+        ...formatArg
+      },
+      async run({ args }) {
+        try {
+          const fmt = { format: args.format };
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const params = {
+            bank_account: args["bank-account"] ? Number(args["bank-account"]) : void 0,
+            hide_refused: args["hide-refused"],
+            sorts: args.sort,
+            from: args.from,
+            to: args.to,
+            search: args.search
+          };
+          if (args.all) {
+            const transactions = await client.bankTransactions.listAll(params);
+            output(transactions, fmt);
+          } else {
+            const transactions = await client.bankTransactions.list({
+              ...params,
+              page: Number(args.page),
+              pageSize: Number(args["page-size"])
+            });
+            output(transactions, fmt);
+          }
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    unimputed: defineCommand2({
+      meta: {
+        name: "unimputed",
+        description: "Transactions non imput\xE9es"
+      },
+      args: { ...formatArg },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const transactions = await client.bankTransactions.unimputed();
+          output(transactions, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    })
+  }
+});
+
+// src/cli/commands/clients.ts
+import { defineCommand as defineCommand3 } from "citty";
+var clientsCommand = defineCommand3({
+  meta: { name: "clients", description: "Gestion des clients" },
+  subCommands: {
+    list: defineCommand3({
+      meta: { name: "list", description: "Lister les clients" },
+      args: {
+        ...formatArg,
+        archived: {
+          type: "boolean",
+          description: "Inclure les clients archiv\xE9s",
+          default: false
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const clients = await client.clients.list({
+            archived: args.archived
+          });
+          output(clients, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    get: defineCommand3({
+      meta: { name: "get", description: "D\xE9tails d'un client" },
+      args: {
+        id: { type: "string", description: "ID du client", required: true }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const result = await client.clients.get(Number(args.id));
+          output(result);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    create: defineCommand3({
+      meta: { name: "create", description: "Cr\xE9er un client" },
+      args: {
+        name: {
+          type: "string",
+          description: "Nom du client",
+          required: true
+        },
+        address: {
+          type: "string",
+          description: "Adresse du client"
+        },
+        "postal-code": {
+          type: "string",
+          description: "Code postal"
+        },
+        city: {
+          type: "string",
+          description: "Ville"
+        },
+        email: {
+          type: "string",
+          description: "Adresse email"
+        },
+        phone: {
+          type: "string",
+          description: "Num\xE9ro de t\xE9l\xE9phone"
+        },
+        siret: {
+          type: "string",
+          description: "SIREN ou SIRET"
+        },
+        professional: {
+          type: "boolean",
+          description: "Client professionnel",
+          default: true
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const result = await client.clients.create({
+            name: args.name,
+            address: args.address,
+            postal_code: args["postal-code"],
+            city: args.city,
+            email: args.email,
+            phone: args.phone,
+            siren_or_siret: args.siret,
+            professional: args.professional
+          });
+          output(result);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    search: defineCommand3({
+      meta: { name: "search", description: "Rechercher un client" },
+      args: {
+        ...formatArg,
+        query: {
+          type: "string",
+          description: "Terme de recherche",
+          required: true
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const results = await client.clients.search(args.query);
+          output(results, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    })
+  }
+});
+
+// src/cli/commands/company.ts
+import { defineCommand as defineCommand4 } from "citty";
+var companyCommand = defineCommand4({
+  meta: { name: "company", description: "Gestion de l'entreprise" },
+  subCommands: {
+    list: defineCommand4({
+      meta: { name: "list", description: "Lister toutes les entreprises" },
+      args: { ...formatArg },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: 0 });
+          const companies = await client.listCompanies();
+          output(
+            companies.map((c) => ({
+              id: c.id,
+              name: c.name,
+              legal_form: c.legal_form,
+              siret: c.siret,
+              city: c.city
+            })),
+            { format: args.format }
+          );
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    get: defineCommand4({
+      meta: { name: "get", description: "D\xE9tails de l'entreprise active" },
+      async run() {
+        try {
+          const client = new TiimeClient({
+            companyId: getCompanyId()
+          });
+          const company = await client.company.get();
+          output(company);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    use: defineCommand4({
+      meta: { name: "use", description: "D\xE9finir l'entreprise active" },
+      args: {
+        id: {
+          type: "string",
+          description: "ID de l'entreprise",
+          required: true
+        }
+      },
+      run({ args }) {
+        const config = loadConfig();
+        config.companyId = Number(args.id);
+        saveConfig(config);
+        output({ status: "ok", companyId: config.companyId });
+      }
+    }),
+    me: defineCommand4({
+      meta: {
+        name: "me",
+        description: "Info utilisateur courant (inclut active_company)"
+      },
+      async run() {
+        try {
+          const client = new TiimeClient({ companyId: 0 });
+          const user = await client.users.me();
+          output(user);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    })
+  }
+});
+
+// src/cli/commands/completion.ts
+import { defineCommand as defineCommand5 } from "citty";
+var commands = {
+  auth: {
+    description: "Gestion de l'authentification",
+    subs: {
+      login: "Se connecter",
+      logout: "Se d\xE9connecter",
+      status: "Statut de connexion"
+    }
+  },
+  company: {
+    description: "Gestion de l'entreprise",
+    subs: {
+      list: "Lister les entreprises",
+      get: "D\xE9tails de l'entreprise active",
+      use: "D\xE9finir l'entreprise active",
+      me: "Info utilisateur"
+    }
+  },
+  invoices: {
+    description: "Gestion des factures",
+    subs: {
+      list: "Lister les factures",
+      get: "D\xE9tails d'une facture",
+      create: "Cr\xE9er une facture",
+      duplicate: "Dupliquer une facture",
+      update: "Modifier une facture",
+      send: "Envoyer par email",
+      pdf: "T\xE9l\xE9charger le PDF",
+      delete: "Supprimer un brouillon"
+    }
+  },
+  clients: {
+    description: "Gestion des clients",
+    subs: {
+      list: "Lister les clients",
+      get: "D\xE9tails d'un client",
+      create: "Cr\xE9er un client",
+      search: "Rechercher un client"
+    }
+  },
+  bank: {
+    description: "Comptes et transactions",
+    subs: {
+      accounts: "Comptes bancaires",
+      balance: "Soldes des comptes",
+      transactions: "Transactions bancaires",
+      unimputed: "Transactions non imput\xE9es"
+    }
+  },
+  quotations: {
+    description: "Gestion des devis",
+    subs: {
+      list: "Lister les devis",
+      get: "D\xE9tails d'un devis",
+      create: "Cr\xE9er un devis",
+      pdf: "T\xE9l\xE9charger le PDF",
+      send: "Envoyer par email"
+    }
+  },
+  expenses: {
+    description: "Notes de frais",
+    subs: {
+      list: "Lister les notes de frais",
+      get: "D\xE9tails d'une note de frais",
+      create: "Cr\xE9er une note de frais"
+    }
+  },
+  documents: {
+    description: "Gestion des documents",
+    subs: {
+      list: "Lister les documents",
+      categories: "Cat\xE9gories de documents",
+      upload: "Uploader un justificatif",
+      download: "T\xE9l\xE9charger un document"
+    }
+  },
+  labels: {
+    description: "Labels et tags",
+    subs: {
+      list: "Labels personnalis\xE9s",
+      standard: "Labels standards",
+      tags: "Tags"
+    }
+  },
+  status: {
+    description: "R\xE9sum\xE9 rapide de la situation",
+    subs: {}
+  },
+  open: {
+    description: "Ouvrir Tiime dans le navigateur",
+    subs: {}
+  },
+  version: {
+    description: "Afficher la version",
+    subs: {}
+  },
+  completion: {
+    description: "Script d'autocompl\xE9tion",
+    subs: {}
+  }
+};
+var topLevelNames = Object.keys(commands);
+var commonFlags = ["--format", "--id", "--all"];
+var generateZsh = () => {
+  const esc = (s) => s.replace(/'/g, "'\\''");
+  const subcases = topLevelNames.filter((cmd) => Object.keys(commands[cmd].subs).length > 0).map((cmd) => {
+    const subs = Object.entries(commands[cmd].subs).map(([name, desc]) => `'${name}:${esc(desc)}'`).join(" ");
+    return `			${cmd})
+				local -a subcmds
+				subcmds=(${subs})
+				_describe 'sous-commande' subcmds
+				;;`;
+  }).join("\n");
+  return `#compdef tiime
+
+_tiime() {
+	local -a top_commands
+	top_commands=(
+${topLevelNames.map((c) => `		'${c}:${esc(commands[c].description)}'`).join("\n")}
+	)
+
+	if (( CURRENT == 2 )); then
+		_describe 'commande' top_commands
+		return
+	fi
+
+	local cmd="\${words[2]}"
+
+	if (( CURRENT == 3 )); then
+		case "$cmd" in
+${subcases}
+		esac
+		return
+	fi
+
+	# Position 4+ : proposer les flags courants
+	_arguments \\
+		'--format[Format de sortie (json, table, csv)]' \\
+		'--id[Identifiant de la ressource]' \\
+		'--all[R\xE9cup\xE9rer tous les r\xE9sultats]'
+}
+
+compdef _tiime tiime
+`;
+};
+var generateBash = () => {
+  const subcases = topLevelNames.filter((cmd) => Object.keys(commands[cmd].subs).length > 0).map((cmd) => {
+    const subs = Object.keys(commands[cmd].subs).join(" ");
+    return `			${cmd})
+				COMPREPLY=( $(compgen -W "${subs}" -- "$cur") )
+				return
+				;;`;
+  }).join("\n");
+  return `_tiime() {
+	local cur prev cmd
+	cur="\${COMP_WORDS[COMP_CWORD]}"
+	prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+	if [[ \${COMP_CWORD} -eq 1 ]]; then
+		COMPREPLY=( $(compgen -W "${topLevelNames.join(" ")}" -- "$cur") )
+		return
+	fi
+
+	cmd="\${COMP_WORDS[1]}"
+
+	if [[ \${COMP_CWORD} -eq 2 ]]; then
+		case "$cmd" in
+${subcases}
+		esac
+		return
+	fi
+
+	# Position 3+ : proposer les flags courants
+	COMPREPLY=( $(compgen -W "${commonFlags.join(" ")}" -- "$cur") )
+}
+
+complete -F _tiime tiime
+`;
+};
+var generateFish = () => {
+  const esc = (s) => s.replace(/'/g, "\\'");
+  const lines = [
+    "# Disable file completions by default",
+    "complete -c tiime -f",
+    "",
+    "# Top-level commands",
+    ...topLevelNames.map(
+      (cmd) => `complete -c tiime -n '__fish_use_subcommand' -a '${cmd}' -d '${esc(commands[cmd].description)}'`
+    ),
+    "",
+    "# Subcommands"
+  ];
+  for (const cmd of topLevelNames) {
+    const subs = commands[cmd].subs;
+    const subNames = Object.keys(subs);
+    if (subNames.length > 0) {
+      const condition = `__fish_seen_subcommand_from ${cmd}; and not __fish_seen_subcommand_from ${subNames.join(" ")}`;
+      for (const [sub, desc] of Object.entries(subs)) {
+        lines.push(
+          `complete -c tiime -n '${condition}' -a '${sub}' -d '${esc(desc)}'`
+        );
+      }
+      lines.push("");
+    }
+  }
+  lines.push("# Common flags");
+  for (const cmd of topLevelNames) {
+    const subNames = Object.keys(commands[cmd].subs);
+    if (subNames.length > 0) {
+      const condition = `__fish_seen_subcommand_from ${subNames.join(" ")}`;
+      lines.push(
+        `complete -c tiime -n '${condition}' -l format -d 'Format de sortie'`
+      );
+      lines.push(
+        `complete -c tiime -n '${condition}' -l id -d 'Identifiant de la ressource'`
+      );
+      lines.push(
+        `complete -c tiime -n '${condition}' -l all -d 'R\xE9cup\xE9rer tous les r\xE9sultats'`
+      );
+    }
+  }
+  return `${lines.join("\n")}
+`;
+};
+var completionCommand = defineCommand5({
+  meta: {
+    name: "completion",
+    description: "G\xE9n\xE9rer le script d'autocompl\xE9tion shell"
+  },
+  args: {
+    shell: {
+      type: "string",
+      description: "Shell cible (zsh, bash, fish)",
+      default: "zsh"
+    }
+  },
+  run({ args }) {
+    const shell = args.shell;
+    switch (shell) {
+      case "zsh":
+        process.stdout.write(generateZsh());
+        break;
+      case "bash":
+        process.stdout.write(generateBash());
+        break;
+      case "fish":
+        process.stdout.write(generateFish());
+        break;
+      default:
+        process.stderr.write(
+          `Shell non support\xE9 : ${shell}. Utilisez zsh, bash ou fish.
+`
+        );
+        process.exit(1);
+    }
+  }
+});
+
+// src/cli/commands/documents.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { basename } from "path";
+import { defineCommand as defineCommand6 } from "citty";
+var documentsCommand = defineCommand6({
+  meta: { name: "documents", description: "Gestion des documents" },
+  subCommands: {
+    list: defineCommand6({
+      meta: { name: "list", description: "Lister les documents" },
+      args: {
+        ...formatArg,
+        type: {
+          type: "string",
+          description: "Type de document (ex: receipt)"
+        },
+        source: {
+          type: "string",
+          description: "Source du document (ex: accountant)"
+        },
+        page: { type: "string", description: "Num\xE9ro de page", default: "1" }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const docs = await client.documents.list({
+            types: args.type,
+            source: args.source,
+            page: Number(args.page)
+          });
+          output(docs, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    upload: defineCommand6({
+      meta: { name: "upload", description: "Uploader un justificatif" },
+      args: {
+        file: {
+          type: "string",
+          description: "Chemin du fichier \xE0 uploader",
+          required: true
+        },
+        type: {
+          type: "string",
+          description: "Type de document"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const fileBuffer = readFileSync3(args.file);
+          const filename = basename(args.file);
+          const result = await client.documents.upload(
+            fileBuffer,
+            filename,
+            args.type
+          );
+          output(result);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    download: defineCommand6({
+      meta: { name: "download", description: "T\xE9l\xE9charger un document" },
+      args: {
+        id: {
+          type: "string",
+          description: "ID du document",
+          required: true
+        },
+        output: {
+          type: "string",
+          description: "Chemin de sortie du fichier"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const documentId = Number(args.id);
+          const data = await client.documents.download(documentId);
+          const outputPath = args.output ?? `document-${documentId}`;
+          writeFileSync3(outputPath, Buffer.from(data));
+          output({ status: "downloaded", path: outputPath });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    categories: defineCommand6({
+      meta: {
+        name: "categories",
+        description: "Lister les cat\xE9gories de documents"
+      },
+      args: { ...formatArg },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const categories = await client.documents.categories();
+          output(categories, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    })
+  }
+});
+
+// src/cli/commands/expenses.ts
+import { defineCommand as defineCommand7 } from "citty";
+var expensesCommand = defineCommand7({
+  meta: { name: "expenses", description: "Gestion des notes de frais" },
+  subCommands: {
+    list: defineCommand7({
+      meta: { name: "list", description: "Lister les notes de frais" },
+      args: {
+        ...formatArg,
+        sort: {
+          type: "string",
+          description: "Tri champ:direction",
+          default: "metadata.date:desc"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const expenses = await client.expenseReports.list(args.sort);
+          output(expenses, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    get: defineCommand7({
+      meta: { name: "get", description: "D\xE9tails d'une note de frais" },
+      args: {
+        id: {
+          type: "string",
+          description: "ID de la note de frais",
+          required: true
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const expense = await client.expenseReports.get(Number(args.id));
+          output(expense);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    create: defineCommand7({
+      meta: { name: "create", description: "Cr\xE9er une note de frais" },
+      args: {
+        name: {
+          type: "string",
+          description: "Nom de la note de frais",
+          required: true
+        },
+        date: {
+          type: "string",
+          description: "Date (YYYY-MM-DD)"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const expense = await client.expenseReports.create({
+            name: args.name,
+            metadata: args.date ? { date: args.date } : void 0
+          });
+          output(expense);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    })
+  }
+});
+
+// src/cli/commands/invoices.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+import { defineCommand as defineCommand8 } from "citty";
+var invoicesCommand = defineCommand8({
+  meta: { name: "invoices", description: "Gestion des factures" },
+  subCommands: {
+    list: defineCommand8({
+      meta: { name: "list", description: "Lister les factures" },
+      args: {
+        ...formatArg,
+        sort: {
+          type: "string",
+          description: "Tri champ:direction (ex: invoice_number:desc)",
+          default: "invoice_number:desc"
+        },
+        status: {
+          type: "string",
+          description: "Filtrer par statut (draft, saved, sent, paid)"
+        },
+        page: { type: "string", description: "Num\xE9ro de page", default: "1" },
+        "page-size": {
+          type: "string",
+          description: "\xC9l\xE9ments par page",
+          default: "25"
+        },
+        all: {
+          type: "boolean",
+          description: "R\xE9cup\xE9rer toutes les pages",
+          default: false
+        }
+      },
+      async run({ args }) {
+        try {
+          const fmt = { format: args.format };
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          if (args.all) {
+            const invoices = await client.invoices.listAll({
+              sorts: args.sort,
+              status: args.status
+            });
+            output(invoices, fmt);
+          } else {
+            const invoices = await client.invoices.list({
+              sorts: args.sort,
+              status: args.status,
+              page: Number(args.page),
+              pageSize: Number(args["page-size"])
+            });
+            output(invoices, fmt);
+          }
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    get: defineCommand8({
+      meta: { name: "get", description: "D\xE9tails d'une facture" },
+      args: {
+        id: { type: "string", description: "ID de la facture", required: true }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const invoice = await client.invoices.get(Number(args.id));
+          output(invoice);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    create: defineCommand8({
+      meta: {
+        name: "create",
+        description: "Cr\xE9er une facture (brouillon par d\xE9faut)"
+      },
+      args: {
+        "client-id": {
+          type: "string",
+          description: "ID du client"
+        },
+        "client-name": {
+          type: "string",
+          description: "Nom du client (si pas de client-id)"
+        },
+        date: {
+          type: "string",
+          description: "Date d'\xE9mission (YYYY-MM-DD, d\xE9faut : aujourd'hui)"
+        },
+        title: {
+          type: "string",
+          description: "Titre de la facture"
+        },
+        description: {
+          type: "string",
+          description: "Description de la ligne (ligne simple)"
+        },
+        quantity: {
+          type: "string",
+          description: "Quantit\xE9 (ligne simple)",
+          default: "1"
+        },
+        "unit-price": {
+          type: "string",
+          description: "Prix unitaire HT (ligne simple)"
+        },
+        unit: {
+          type: "string",
+          description: "Code unit\xE9 (day, hour, unit, etc.)"
+        },
+        vat: {
+          type: "string",
+          description: "Code TVA (normal=20%, reduced=10%, super_reduced=5.5%, none=0%)",
+          default: "normal"
+        },
+        lines: {
+          type: "string",
+          description: `Multi-lignes en JSON : '[{"description":"Dev","quantity":20,"unit_price":540,"unit":"day"}]'`
+        },
+        "free-field": {
+          type: "string",
+          description: "Champ libre (ex : r\xE9f\xE9rence contrat)"
+        },
+        status: {
+          type: "string",
+          description: "Statut : draft (d\xE9faut) ou saved (num\xE9rot\xE9e)",
+          default: "draft"
+        },
+        "dry-run": {
+          type: "boolean",
+          description: "Pr\xE9visualiser le payload sans cr\xE9er la facture",
+          default: false
+        }
+      },
+      async run({ args }) {
+        try {
+          const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          const unitMap = {
+            day: 3,
+            hour: 2,
+            unit: 1,
+            package: 4,
+            word: 5,
+            character: 6,
+            page: 7
+          };
+          let invoiceLines;
+          if (args.lines) {
+            const parsed = JSON.parse(args.lines);
+            invoiceLines = parsed.map((l) => ({
+              description: l.description,
+              quantity: l.quantity,
+              unit_amount: l.unit_price,
+              vat_type: { code: l.vat ?? args.vat },
+              invoicing_unit: l.unit ? { id: unitMap[l.unit] ?? 1, code: l.unit } : null
+            }));
+          } else {
+            if (!args.description || !args["unit-price"]) {
+              outputError(
+                "--description et --unit-price sont requis pour une ligne simple (ou utilisez --lines pour du multi-lignes)"
+              );
+              return;
+            }
+            invoiceLines = [
+              {
+                description: args.description,
+                quantity: Number(args.quantity),
+                unit_amount: Number(args["unit-price"]),
+                vat_type: { code: args.vat },
+                invoicing_unit: args.unit ? { id: unitMap[args.unit] ?? 1, code: args.unit } : null
+              }
+            ];
+          }
+          const params = {
+            emission_date: args.date ?? today,
+            title: args.title ?? null,
+            lines: invoiceLines,
+            status: args.status
+          };
+          if (args["client-id"]) {
+            params.client = { id: Number(args["client-id"]) };
+          } else if (args["client-name"]) {
+            params.client_name = args["client-name"];
+          }
+          if (args["free-field"]) {
+            params.free_field = args["free-field"];
+            params.free_field_enabled = true;
+          }
+          if (args["dry-run"]) {
+            output({ dry_run: true, payload: params });
+            return;
+          }
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const invoice = await client.invoices.create(params);
+          output(invoice);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    duplicate: defineCommand8({
+      meta: {
+        name: "duplicate",
+        description: "Dupliquer une facture existante en brouillon"
+      },
+      args: {
+        id: {
+          type: "string",
+          description: "ID de la facture source",
+          required: true
+        },
+        date: {
+          type: "string",
+          description: "Date d'\xE9mission de la copie (YYYY-MM-DD, d\xE9faut : aujourd'hui)"
+        },
+        quantity: {
+          type: "string",
+          description: "Remplacer la quantit\xE9 pour toutes les lignes"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const invoice = await client.invoices.duplicate(Number(args.id), {
+            emission_date: args.date,
+            quantity: args.quantity ? Number(args.quantity) : void 0
+          });
+          output(invoice);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    update: defineCommand8({
+      meta: { name: "update", description: "Mettre \xE0 jour une facture" },
+      args: {
+        id: {
+          type: "string",
+          description: "ID de la facture",
+          required: true
+        },
+        title: {
+          type: "string",
+          description: "Nouveau titre de la facture"
+        },
+        status: {
+          type: "string",
+          description: "Nouveau statut (draft, saved)"
+        },
+        date: {
+          type: "string",
+          description: "Nouvelle date d'\xE9mission (YYYY-MM-DD)"
+        },
+        "free-field": {
+          type: "string",
+          description: "Nouveau champ libre"
+        }
+      },
+      async run({ args }) {
+        try {
+          const updates = {};
+          if (args.title !== void 0) updates.title = args.title;
+          if (args.status !== void 0) updates.status = args.status;
+          if (args.date !== void 0) updates.emission_date = args.date;
+          if (args["free-field"] !== void 0) {
+            updates.free_field = args["free-field"];
+            updates.free_field_enabled = true;
+          }
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const invoice = await client.invoices.update(
+            Number(args.id),
+            updates
+          );
+          output(invoice);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    send: defineCommand8({
+      meta: { name: "send", description: "Envoyer une facture par email" },
+      args: {
+        id: {
+          type: "string",
+          description: "ID de la facture",
+          required: true
+        },
+        email: {
+          type: "string",
+          description: "Adresse email du destinataire",
+          required: true
+        },
+        subject: {
+          type: "string",
+          description: "Objet de l'email"
+        },
+        message: {
+          type: "string",
+          description: "Corps du message"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          await client.invoices.send(Number(args.id), {
+            recipients: [{ email: args.email }],
+            subject: args.subject,
+            message: args.message
+          });
+          output({
+            status: "sent",
+            id: Number(args.id),
+            email: args.email
+          });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    pdf: defineCommand8({
+      meta: {
+        name: "pdf",
+        description: "T\xE9l\xE9charger le PDF d'une facture"
+      },
+      args: {
+        id: {
+          type: "string",
+          description: "ID de la facture",
+          required: true
+        },
+        output: {
+          type: "string",
+          description: "Chemin de sortie du fichier (d\xE9faut : facture-{id}.pdf)"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const buffer = await client.invoices.downloadPdf(Number(args.id));
+          const filePath = args.output ?? `facture-${args.id}.pdf`;
+          writeFileSync4(filePath, Buffer.from(buffer));
+          output({ status: "downloaded", path: filePath });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    delete: defineCommand8({
+      meta: { name: "delete", description: "Supprimer une facture brouillon" },
+      args: {
+        id: {
+          type: "string",
+          description: "ID de la facture \xE0 supprimer",
+          required: true
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          await client.invoices.delete(Number(args.id));
+          output({ status: "deleted", id: Number(args.id) });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    })
+  }
+});
+
+// src/cli/commands/labels.ts
+import { defineCommand as defineCommand9 } from "citty";
+var labelsCommand = defineCommand9({
+  meta: { name: "labels", description: "Gestion des labels et tags" },
+  subCommands: {
+    list: defineCommand9({
+      meta: { name: "list", description: "Lister les labels personnalis\xE9s" },
+      args: { ...formatArg },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const labels = await client.labels.list();
+          output(labels, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    standard: defineCommand9({
+      meta: { name: "standard", description: "Lister les labels standards" },
+      args: { ...formatArg },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const labels = await client.labels.standard();
+          output(labels, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    tags: defineCommand9({
+      meta: { name: "tags", description: "Lister les tags" },
+      args: { ...formatArg },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const tags = await client.labels.tags();
+          output(tags, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    })
+  }
+});
+
+// src/cli/commands/open.ts
+import { exec } from "child_process";
+import { defineCommand as defineCommand10 } from "citty";
+var APP_BASE_URL = "https://apps.tiime.fr";
+var sections = {
+  invoices: "/invoicing/invoices",
+  quotations: "/invoicing/quotations",
+  clients: "/invoicing/clients",
+  bank: "/bank",
+  documents: "/documents",
+  expenses: "/expense-reports"
+};
+var buildUrl = (section) => {
+  if (!section) {
+    return APP_BASE_URL;
+  }
+  const path = sections[section];
+  if (!path) {
+    throw new Error(
+      `Section inconnue : ${section}. Sections disponibles : ${Object.keys(sections).join(", ")}`
+    );
+  }
+  const companyId = getCompanyId();
+  return `${APP_BASE_URL}/companies/${companyId}${path}`;
+};
+var openCommand = defineCommand10({
+  meta: {
+    name: "open",
+    description: "Ouvrir Tiime dans le navigateur"
+  },
+  args: {
+    section: {
+      type: "positional",
+      description: `Section \xE0 ouvrir (${Object.keys(sections).join(", ")})`,
+      required: false
+    }
+  },
+  run({ args }) {
+    try {
+      const url = buildUrl(args.section);
+      exec(`open "${url}"`);
+      output({ opened: url });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+
+// src/cli/commands/quotations.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+import { defineCommand as defineCommand11 } from "citty";
+var quotationsCommand = defineCommand11({
+  meta: { name: "quotations", description: "Gestion des devis" },
+  subCommands: {
+    list: defineCommand11({
+      meta: { name: "list", description: "Lister les devis" },
+      args: { ...formatArg },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const quotations = await client.quotations.list();
+          output(quotations, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    get: defineCommand11({
+      meta: { name: "get", description: "D\xE9tails d'un devis" },
+      args: {
+        id: { type: "string", description: "ID du devis", required: true }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const quotation = await client.quotations.get(Number(args.id));
+          output(quotation);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    create: defineCommand11({
+      meta: {
+        name: "create",
+        description: "Cr\xE9er un devis (brouillon par d\xE9faut)"
+      },
+      args: {
+        "client-id": {
+          type: "string",
+          description: "ID du client"
+        },
+        date: {
+          type: "string",
+          description: "Date du devis (YYYY-MM-DD, d\xE9faut : aujourd'hui)"
+        },
+        title: {
+          type: "string",
+          description: "Titre du devis"
+        },
+        description: {
+          type: "string",
+          description: "Description de la ligne (ligne simple)"
+        },
+        quantity: {
+          type: "string",
+          description: "Quantit\xE9 (ligne simple)",
+          default: "1"
+        },
+        "unit-price": {
+          type: "string",
+          description: "Prix unitaire HT (ligne simple)"
+        },
+        vat: {
+          type: "string",
+          description: "Code TVA (normal=20%, reduced=10%, super_reduced=5.5%, none=0%)",
+          default: "normal"
+        },
+        status: {
+          type: "string",
+          description: "Statut : draft (d\xE9faut) ou saved",
+          default: "draft"
+        }
+      },
+      async run({ args }) {
+        try {
+          const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          if (!args.description || !args["unit-price"]) {
+            outputError(
+              "--description et --unit-price sont requis pour cr\xE9er un devis"
+            );
+            return;
+          }
+          const lines = [
+            {
+              description: args.description,
+              quantity: Number(args.quantity),
+              unit_amount: Number(args["unit-price"]),
+              vat_type: { code: args.vat }
+            }
+          ];
+          const params = {
+            date: args.date ?? today,
+            title: args.title ?? null,
+            lines,
+            status: args.status
+          };
+          if (args["client-id"]) {
+            params.client = { id: Number(args["client-id"]) };
+          }
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const quotation = await client.quotations.create(params);
+          output(quotation);
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    pdf: defineCommand11({
+      meta: {
+        name: "pdf",
+        description: "T\xE9l\xE9charger le PDF d'un devis"
+      },
+      args: {
+        id: {
+          type: "string",
+          description: "ID du devis",
+          required: true
+        },
+        output: {
+          type: "string",
+          description: "Chemin de sortie du fichier (d\xE9faut : devis-{id}.pdf)"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const buffer = await client.quotations.downloadPdf(Number(args.id));
+          const filePath = args.output ?? `devis-${args.id}.pdf`;
+          writeFileSync5(filePath, Buffer.from(buffer));
+          output({ status: "downloaded", path: filePath });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    send: defineCommand11({
+      meta: { name: "send", description: "Envoyer un devis par email" },
+      args: {
+        id: {
+          type: "string",
+          description: "ID du devis",
+          required: true
+        },
+        email: {
+          type: "string",
+          description: "Adresse email du destinataire",
+          required: true
+        },
+        subject: {
+          type: "string",
+          description: "Objet de l'email"
+        },
+        message: {
+          type: "string",
+          description: "Corps du message"
+        }
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          await client.quotations.send(Number(args.id), {
+            recipients: [{ email: args.email }],
+            subject: args.subject,
+            message: args.message
+          });
+          output({
+            status: "sent",
+            id: Number(args.id),
+            email: args.email
+          });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    })
+  }
+});
+
+// src/cli/commands/status.ts
+import { defineCommand as defineCommand12 } from "citty";
+var statusCommand = defineCommand12({
+  meta: { name: "status", description: "R\xE9sum\xE9 rapide de la situation" },
+  args: { ...formatArg },
+  async run({ args }) {
+    try {
+      const client = new TiimeClient({ companyId: getCompanyId() });
+      const [
+        accounts,
+        draftInvoices,
+        unpaidInvoices,
+        unimputed,
+        clients,
+        quotations
+      ] = await Promise.all([
+        client.bankAccounts.list(true),
+        client.invoices.list({ status: "draft" }),
+        client.invoices.list({ status: "sent" }),
+        client.bankTransactions.unimputed(),
+        client.clients.list(),
+        client.quotations.list()
+      ]);
+      const pendingQuotations = quotations.filter(
+        (q) => q.status !== "accepted" && q.status !== "declined"
+      );
+      const data = {
+        company_id: client.companyId,
+        bank_accounts: accounts.map((a) => ({
+          name: a.name,
+          balance: a.balance_amount,
+          currency: a.balance_currency
+        })),
+        invoices: {
+          drafts: draftInvoices.length,
+          unpaid: unpaidInvoices.length
+        },
+        pending_quotations: pendingQuotations.length,
+        total_clients: clients.length,
+        unimputed_transactions: unimputed.length
+      };
+      const format = args.format;
+      output(data, { format });
+      if (format === "json") {
+        outputColoredStatus(data);
+      }
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+
+// src/cli/commands/version.ts
+import { defineCommand as defineCommand13 } from "citty";
+var versionCommand = defineCommand13({
+  meta: { name: "version", description: "Afficher la version" },
+  run() {
+    output({ version: "1.0.0", node: process.version });
+  }
+});
+
+// src/cli/i18n.ts
+var descriptionTranslations = {
+  // Main
+  "CLI pour la comptabilit\xE9 Tiime \u2014 sortie JSON pour agents IA": "CLI for Tiime accounting \u2014 JSON output for AI agents",
+  // Top-level commands
+  "Gestion de l'authentification": "Authentication management",
+  "Gestion de l'entreprise": "Company management",
+  "Gestion des factures": "Invoice management",
+  "Gestion des clients": "Client management",
+  "Comptes bancaires et transactions": "Bank accounts and transactions",
+  "Gestion des devis": "Quotation management",
+  "Gestion des notes de frais": "Expense report management",
+  "Gestion des documents": "Document management",
+  "Gestion des labels et tags": "Label and tag management",
+  "R\xE9sum\xE9 rapide de la situation": "Quick status summary",
+  "Ouvrir Tiime dans le navigateur": "Open Tiime in browser",
+  "Afficher la version": "Show version",
+  "G\xE9n\xE9rer le script d'autocompl\xE9tion shell": "Generate shell completion script",
+  // Common subcommands
+  "Se connecter \xE0 Tiime": "Log in to Tiime",
+  "Se d\xE9connecter de Tiime": "Log out from Tiime",
+  "Afficher le statut d'authentification": "Show authentication status",
+  "Lister les entreprises": "List companies",
+  "Lister toutes les entreprises": "List all companies",
+  "D\xE9tails de l'entreprise active": "Active company details",
+  "D\xE9finir l'entreprise active": "Set active company",
+  "Info utilisateur": "User info",
+  "Info utilisateur courant (inclut active_company)": "Current user info (includes active_company)",
+  "Lister les factures": "List invoices",
+  "D\xE9tails d'une facture": "Invoice details",
+  "Cr\xE9er une facture (brouillon par d\xE9faut)": "Create an invoice (draft by default)",
+  "Dupliquer une facture existante en brouillon": "Duplicate an invoice as draft",
+  "Mettre \xE0 jour une facture": "Update an invoice",
+  "Envoyer une facture par email": "Send an invoice by email",
+  "T\xE9l\xE9charger le PDF d'une facture": "Download invoice PDF",
+  "Supprimer une facture brouillon": "Delete a draft invoice",
+  "Lister les clients": "List clients",
+  "D\xE9tails d'un client": "Client details",
+  "Cr\xE9er un client": "Create a client",
+  "Rechercher un client": "Search for a client",
+  "Afficher les soldes des comptes": "Show account balances",
+  "Lister les comptes bancaires": "List bank accounts",
+  "Lister les transactions bancaires": "List bank transactions",
+  "Transactions non imput\xE9es": "Unmatched transactions",
+  "Lister les devis": "List quotations",
+  "D\xE9tails d'un devis": "Quotation details",
+  "Cr\xE9er un devis": "Create a quotation",
+  "T\xE9l\xE9charger le PDF d'un devis": "Download quotation PDF",
+  "Envoyer un devis par email": "Send a quotation by email",
+  "Lister les notes de frais": "List expense reports",
+  "D\xE9tails d'une note de frais": "Expense report details",
+  "Cr\xE9er une note de frais": "Create an expense report",
+  "Lister les documents": "List documents",
+  "Lister les cat\xE9gories de documents": "List document categories",
+  "Uploader un justificatif": "Upload a receipt",
+  "T\xE9l\xE9charger un document": "Download a document",
+  "Labels personnalis\xE9s": "Custom labels",
+  "Lister les labels personnalis\xE9s": "List custom labels",
+  "Labels standards": "Standard labels",
+  "Lister les labels standards": "List standard labels",
+  Tags: "Tags",
+  "Lister les tags": "List tags",
+  // Arg descriptions
+  "Format de sortie (json, table, csv)": "Output format (json, table, csv)",
+  "ID de la facture": "Invoice ID",
+  "ID du client": "Client ID",
+  "ID du devis": "Quotation ID",
+  "ID de la facture source": "Source invoice ID",
+  "ID de la facture \xE0 supprimer": "Invoice ID to delete",
+  "ID du document": "Document ID",
+  "Nom du client": "Client name",
+  "Nom du client (si pas de client-id)": "Client name (if no client-id)",
+  "Date d'\xE9mission (YYYY-MM-DD, d\xE9faut : aujourd'hui)": "Issue date (YYYY-MM-DD, default: today)",
+  "Titre de la facture": "Invoice title",
+  "Description de la ligne (ligne simple)": "Line description (single line)",
+  "Quantit\xE9 (ligne simple)": "Quantity (single line)",
+  "Prix unitaire HT (ligne simple)": "Unit price excl. tax (single line)",
+  "Code unit\xE9 (day, hour, unit, etc.)": "Unit code (day, hour, unit, etc.)",
+  "Code TVA (normal=20%, reduced=10%, super_reduced=5.5%, none=0%)": "VAT code (normal=20%, reduced=10%, super_reduced=5.5%, none=0%)",
+  'Multi-lignes en JSON : \'[{"description":"Dev","quantity":20,"unit_price":540,"unit":"day"}]\'': `Multi-line JSON: '[{"description":"Dev","quantity":20,"unit_price":540,"unit":"day"}]'`,
+  "Champ libre (ex : r\xE9f\xE9rence contrat)": "Free field (e.g.: contract reference)",
+  "Statut : draft (d\xE9faut) ou saved (num\xE9rot\xE9e)": "Status: draft (default) or saved (numbered)",
+  "Pr\xE9visualiser le payload sans cr\xE9er la facture": "Preview payload without creating invoice",
+  "Adresse email du destinataire": "Recipient email address",
+  "Objet de l'email": "Email subject",
+  "Corps du message": "Message body",
+  "Chemin de sortie du fichier": "Output file path",
+  "Adresse email": "Email address",
+  "Mot de passe": "Password",
+  "ID de l'entreprise": "Company ID",
+  "Tri champ:direction (ex: invoice_number:desc)": "Sort field:direction (e.g.: invoice_number:desc)",
+  "Filtrer par statut (draft, saved, sent, paid)": "Filter by status (draft, saved, sent, paid)",
+  "Num\xE9ro de page": "Page number",
+  "\xC9l\xE9ments par page": "Items per page",
+  "R\xE9cup\xE9rer toutes les pages": "Fetch all pages",
+  "Inclure les clients archiv\xE9s": "Include archived clients",
+  "Adresse du client": "Client address",
+  "Code postal": "Postal code",
+  Ville: "City",
+  "Num\xE9ro de t\xE9l\xE9phone": "Phone number",
+  "SIREN ou SIRET": "SIREN or SIRET",
+  "Client professionnel": "Professional client",
+  "Terme de recherche": "Search term",
+  "Uniquement les comptes actifs": "Active accounts only",
+  "Filtrer par ID de compte bancaire": "Filter by bank account ID",
+  "Masquer les transactions refus\xE9es": "Hide refused transactions",
+  "Tri champ:direction (ex: date:desc)": "Sort field:direction (e.g.: date:desc)",
+  "Date de d\xE9but (YYYY-MM-DD)": "Start date (YYYY-MM-DD)",
+  "Date de fin (YYYY-MM-DD)": "End date (YYYY-MM-DD)",
+  "Rechercher par libell\xE9": "Search by label",
+  "Tri champ:direction": "Sort field:direction",
+  "Type de document (ex: receipt)": "Document type (e.g.: receipt)",
+  "Source du document (ex: accountant)": "Document source (e.g.: accountant)",
+  "Chemin du fichier \xE0 uploader": "File path to upload",
+  "Type de document": "Document type",
+  "Shell cible (zsh, bash, fish)": "Target shell (zsh, bash, fish)",
+  "Nouveau titre de la facture": "New invoice title",
+  "Nouveau statut (draft, saved)": "New status (draft, saved)",
+  "Nouvelle date d'\xE9mission (YYYY-MM-DD)": "New issue date (YYYY-MM-DD)",
+  "Nouveau champ libre": "New free field",
+  "Date d'\xE9mission de la copie (YYYY-MM-DD, d\xE9faut : aujourd'hui)": "Copy issue date (YYYY-MM-DD, default: today)",
+  "Remplacer la quantit\xE9 pour toutes les lignes": "Replace quantity for all lines",
+  "Section \xE0 ouvrir (invoices, quotations, clients, bank, documents, expenses)": "Section to open (invoices, quotations, clients, bank, documents, expenses)",
+  "Nom de la note de frais": "Expense report name",
+  "Date (YYYY-MM-DD)": "Date (YYYY-MM-DD)",
+  "Titre du devis": "Quotation title"
+};
+var frameworkTranslations = {
+  fr: {
+    USAGE: "UTILISATION",
+    COMMANDS: "COMMANDES",
+    OPTIONS: "OPTIONS",
+    ARGUMENTS: "ARGUMENTS",
+    "(required)": "(requis)",
+    "Use %cmd% for more information about a command.": "Utilisez %cmd% pour plus d'informations sur une commande."
+  },
+  en: {}
+};
+var getLang = () => {
+  if (process.env.TIIME_LANG) return process.env.TIIME_LANG;
+  const sysLang = process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || "";
+  if (sysLang.startsWith("fr")) return "fr";
+  if (sysLang.startsWith("en")) return "en";
+  return "fr";
+};
+var translateHelp = (text2) => {
+  const lang = getLang();
+  let result = text2;
+  if (lang === "fr") {
+    const dict = frameworkTranslations.fr;
+    for (const [en, fr] of Object.entries(dict)) {
+      if (en.includes("%cmd%")) continue;
+      result = result.replaceAll(en, fr);
+    }
+    const usePattern = /Use (.*) for more information about a command\./g;
+    const useReplacement = dict["Use %cmd% for more information about a command."];
+    if (useReplacement) {
+      result = result.replace(
+        usePattern,
+        (_match, cmd) => useReplacement.replace("%cmd%", cmd)
+      );
+    }
+  }
+  if (lang === "en") {
+    for (const [fr, en] of Object.entries(descriptionTranslations)) {
+      result = result.replaceAll(fr, en);
+    }
+  }
+  return result;
+};
+
+// src/cli/index.ts
+var main = defineCommand14({
+  meta: {
+    name: "tiime",
+    version: "1.0.0",
+    description: "CLI pour la comptabilit\xE9 Tiime \u2014 sortie JSON pour agents IA"
+  },
+  subCommands: {
+    auth: authCommand,
+    company: companyCommand,
+    invoices: invoicesCommand,
+    clients: clientsCommand,
+    bank: bankCommand,
+    quotations: quotationsCommand,
+    expenses: expensesCommand,
+    documents: documentsCommand,
+    labels: labelsCommand,
+    status: statusCommand,
+    open: openCommand,
+    version: versionCommand,
+    completion: completionCommand
+  }
+});
+var showTranslatedUsage = async (cmd, parent) => {
+  const usage = await renderUsage(cmd, parent);
+  console.log(`${translateHelp(usage)}
+`);
+};
+runMain(main, { showUsage: showTranslatedUsage });