tiime-cli 1.1.0 → 1.2.0

package/dist/cli.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { defineCommand as defineCommand14, renderUsage, runMain } from "citty";
+import { defineCommand as defineCommand15, renderUsage, runMain } from "citty";
 
-// src/cli/commands/auth.ts
-import * as p from "@clack/prompts";
+// src/cli/commands/audit.ts
 import { defineCommand } from "citty";
+import { consola as consola2 } from "consola";
+
+// src/sdk/client.ts
+import { ofetch as ofetch2 } from "ofetch";
 
 // src/sdk/auth.ts
 import { execSync } from "child_process";
@@ -166,10 +169,6 @@ var TokenManager = class {
   }
 };
 
-// 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) {
@@ -190,239 +189,6 @@ var TiimeError = class extends Error {
   }
 };
 
-// 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) {
@@ -492,6 +258,30 @@ var BankTransactionsResource = class {
       `/companies/${this.companyId}/bank_transactions/unimputed`
     );
   }
+  get(transactionId) {
+    return this.fetch(
+      `/companies/${this.companyId}/bank_transactions/${transactionId}`
+    );
+  }
+  labelSuggestions(transactionId) {
+    return this.fetch(
+      `/companies/${this.companyId}/bank_transactions/${transactionId}/label_suggestions`,
+      {
+        headers: {
+          Accept: "application/vnd.tiime.bank_transactions.label_suggestions.v2+json"
+        }
+      }
+    );
+  }
+  impute(transactionId, imputations) {
+    return this.fetch(
+      `/companies/${this.companyId}/bank_transactions/${transactionId}`,
+      {
+        method: "PATCH",
+        body: { imputations }
+      }
+    );
+  }
 };
 
 // src/sdk/resources/clients.ts
@@ -818,6 +608,14 @@ var QuotationsResource = class {
     );
   }
   create(params) {
+    for (const line of params.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}/quotations`, {
       method: "POST",
       body: params
@@ -931,42 +729,594 @@ var TiimeClient = class {
   }
 };
 
-// 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"));
+// src/cli/audit.ts
+var log = (...args) => console.error(...args);
+var batchAsync = async (items, batchSize, fn) => {
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    const batchResults = await Promise.all(batch.map(fn));
+    results.push(...batchResults);
+  }
+  return results;
+};
+async function auditForCompany(client, companyId, companyName, options) {
+  const unimputedFindings = [];
+  const appliedImputations = [];
+  log(`[${companyName}] R\xE9cup\xE9ration des transactions non imput\xE9es...`);
+  const unimputedTxs = await client.bankTransactions.unimputed();
+  log(
+    `[${companyName}] ${unimputedTxs.length} non imput\xE9es, r\xE9cup\xE9ration des suggestions...`
+  );
+  const suggestions = await batchAsync(unimputedTxs, 5, async (tx) => {
+    try {
+      const fullTx = tx.wording !== void 0 ? tx : await client.bankTransactions.get(tx.id);
+      const sug = await client.bankTransactions.labelSuggestions(tx.id);
+      return { tx: fullTx, suggestion: sug[0] ?? null };
+    } catch (e) {
+      log(
+        `[${companyName}] Erreur pour tx #${tx.id}: ${e instanceof Error ? e.message : e}`
+      );
+      return { tx, suggestion: null };
+    }
+  });
+  for (const { tx, suggestion } of suggestions) {
+    unimputedFindings.push({
+      transaction_id: tx.id,
+      wording: tx.wording,
+      amount: tx.amount,
+      currency: tx.currency,
+      transaction_date: tx.transaction_date,
+      suggested_label_id: suggestion?.id ?? null,
+      suggested_label_name: suggestion ? suggestion.name ?? suggestion.label : null
+    });
+    if (options.apply && suggestion) {
+      const imputationLabel = {
+        ...suggestion,
+        disabled: false
+      };
+      const imputationParams = [
+        {
+          label: imputationLabel,
+          amount: tx.amount,
+          documents: [],
+          accountant_detail_requests: []
+        }
+      ];
+      try {
+        await client.bankTransactions.impute(tx.id, imputationParams);
+        appliedImputations.push({
+          transaction_id: tx.id,
+          wording: tx.wording,
+          amount: tx.amount,
+          label_name: suggestion.name ?? suggestion.label,
+          status: "applied"
+        });
+      } catch {
+        appliedImputations.push({
+          transaction_id: tx.id,
+          wording: tx.wording,
+          amount: tx.amount,
+          label_name: suggestion.name ?? suggestion.label,
+          status: "error"
+        });
+      }
+    }
+  }
+  let from;
+  let to;
+  try {
+    const period = await client.company.accountingPeriod();
+    from = period.start_date;
+    to = period.end_date;
+  } catch {
+    const now = /* @__PURE__ */ new Date();
+    from = `${now.getFullYear()}-01-01`;
+    to = now.toISOString().slice(0, 10);
+  }
+  const missingDocuments = [];
+  const appliedIds = new Set(
+    appliedImputations.filter((a) => a.status === "applied").map((a) => a.transaction_id)
+  );
+  log(
+    `[${companyName}] V\xE9rification des documents manquants (${from} \u2192 ${to})...`
+  );
+  const allTransactions = await client.bankTransactions.listAll({ from, to });
+  for (const tx of allTransactions) {
+    if (tx.imputations.length === 0) continue;
+    if (appliedIds.has(tx.id)) continue;
+    const allEmpty = tx.imputations.every(
+      (imp) => imp.count_documents === 0 && imp.count_invoices === 0
+    );
+    if (allEmpty) {
+      missingDocuments.push({
+        transaction_id: tx.id,
+        wording: tx.wording,
+        amount: tx.amount,
+        currency: tx.currency,
+        transaction_date: tx.transaction_date,
+        operation_type: tx.operation_type,
+        label_name: tx.imputations[0].label.name ?? tx.imputations[0].label.label
+      });
+    }
+  }
+  const withSuggestions = unimputedFindings.filter(
+    (f) => f.suggested_label_id !== null
+  ).length;
+  return {
+    company_id: companyId,
+    company_name: companyName,
+    error: null,
+    unimputed_transactions: unimputedFindings,
+    missing_documents: missingDocuments,
+    applied_imputations: appliedImputations,
+    summary: {
+      total_unimputed: unimputedFindings.length,
+      total_unimputed_amount: unimputedFindings.reduce(
+        (sum, f) => sum + Math.abs(f.amount),
+        0
+      ),
+      with_suggestions: withSuggestions,
+      without_suggestions: unimputedFindings.length - withSuggestions,
+      total_missing_documents: missingDocuments.length,
+      total_missing_documents_amount: missingDocuments.reduce(
+        (sum, f) => sum + Math.abs(f.amount),
+        0
+      ),
+      applied_count: appliedImputations.filter((a) => a.status === "applied").length
+    }
+  };
+}
+function emptyReport(companyId, companyName, error) {
+  return {
+    company_id: companyId,
+    company_name: companyName,
+    error,
+    unimputed_transactions: [],
+    missing_documents: [],
+    applied_imputations: [],
+    summary: {
+      total_unimputed: 0,
+      total_unimputed_amount: 0,
+      with_suggestions: 0,
+      without_suggestions: 0,
+      total_missing_documents: 0,
+      total_missing_documents_amount: 0,
+      applied_count: 0
+    }
+  };
+}
+
+// src/cli/auto-impute.ts
+async function autoImputeForCompany(client, companyId, companyName, options) {
+  const proposals = [];
+  const transactions = await client.bankTransactions.unimputed();
+  for (const tx of transactions) {
+    const suggestions = await client.bankTransactions.labelSuggestions(tx.id);
+    const firstSuggestion = suggestions[0];
+    if (!firstSuggestion) {
+      proposals.push({
+        company_id: companyId,
+        company_name: companyName,
+        transaction_id: tx.id,
+        wording: tx.wording,
+        amount: tx.amount,
+        currency: tx.currency,
+        suggested_label_id: 0,
+        suggested_label_name: "(aucune suggestion)",
+        status: "skipped"
+      });
+      continue;
+    }
+    if (!options.apply) {
+      proposals.push({
+        company_id: companyId,
+        company_name: companyName,
+        transaction_id: tx.id,
+        wording: tx.wording,
+        amount: tx.amount,
+        currency: tx.currency,
+        suggested_label_id: firstSuggestion.id,
+        suggested_label_name: firstSuggestion.name ?? firstSuggestion.label,
+        status: "proposed"
+      });
+    } else {
+      const imputationLabel = {
+        ...firstSuggestion,
+        disabled: false
+      };
+      const imputationParams = [
+        {
+          label: imputationLabel,
+          amount: tx.amount,
+          documents: [],
+          accountant_detail_requests: []
+        }
+      ];
+      try {
+        await client.bankTransactions.impute(tx.id, imputationParams);
+        proposals.push({
+          company_id: companyId,
+          company_name: companyName,
+          transaction_id: tx.id,
+          wording: tx.wording,
+          amount: tx.amount,
+          currency: tx.currency,
+          suggested_label_id: firstSuggestion.id,
+          suggested_label_name: firstSuggestion.name ?? firstSuggestion.label,
+          status: "applied"
+        });
+      } catch {
+        proposals.push({
+          company_id: companyId,
+          company_name: companyName,
+          transaction_id: tx.id,
+          wording: tx.wording,
+          amount: tx.amount,
+          currency: tx.currency,
+          suggested_label_id: firstSuggestion.id,
+          suggested_label_name: firstSuggestion.name ?? firstSuggestion.label,
+          status: "error"
+        });
+      }
+    }
+  }
+  return proposals;
+}
+function resolveCompanyIds(parts, companies) {
+  return parts.map((p2) => {
+    if (/^\d+$/.test(p2)) return Number(p2);
+    const match = companies.find(
+      (c) => c.name.toLowerCase() === p2.toLowerCase()
+    );
+    if (!match) throw new Error(`Entreprise introuvable : "${p2}"`);
+    return match.id;
+  });
+}
+
+// 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/output.ts
+import Table from "cli-table3";
+import { consola } from "consola";
+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/audit.ts
+var auditCommand = defineCommand({
+  meta: {
+    name: "audit",
+    description: "Audit comptable multi-entreprises"
+  },
+  args: {
+    "all-companies": {
+      type: "boolean",
+      description: "Traiter toutes les entreprises",
+      default: false
+    },
+    company: {
+      type: "string",
+      description: "Entreprise(s) cible(s) (ID ou nom, s\xE9par\xE9s par des virgules)"
+    },
+    apply: {
+      type: "boolean",
+      description: "Appliquer les corrections automatiques (imputation auto)",
+      default: false
+    },
+    ...formatArg
+  },
+  async run({ args }) {
+    try {
+      let companyIds;
+      if (args["all-companies"]) {
+        const rootClient = new TiimeClient({ companyId: 0 });
+        const companies = await rootClient.listCompanies();
+        companyIds = companies.map((c) => c.id);
+      } else if (args.company) {
+        const parts = args.company.split(",").map((s) => s.trim());
+        const allNumeric = parts.every((p2) => /^\d+$/.test(p2));
+        if (allNumeric) {
+          companyIds = parts.map(Number);
+        } else {
+          const rootClient = new TiimeClient({ companyId: 0 });
+          const companies = await rootClient.listCompanies();
+          companyIds = resolveCompanyIds(parts, companies);
+        }
+      } else {
+        companyIds = [getCompanyId()];
+      }
+      const companyReports = [];
+      for (const companyId of companyIds) {
+        const client = new TiimeClient({ companyId });
+        let companyName = String(companyId);
+        try {
+          const info = await client.company.get();
+          companyName = info.name ?? String(companyId);
+        } catch {
+        }
+        try {
+          const report2 = await auditForCompany(client, companyId, companyName, {
+            apply: args.apply
+          });
+          companyReports.push(report2);
+        } catch (e) {
+          const message = e instanceof Error ? e.message : String(e);
+          consola2.error(`Erreur audit entreprise ${companyName}: ${message}`);
+          companyReports.push(emptyReport(companyId, companyName, message));
+        }
+      }
+      const report = {
+        date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+        companies: companyReports,
+        apply_mode: args.apply
+      };
+      output(report, { format: args.format });
+    } catch (e) {
+      outputError(e);
     }
-  } 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."
-    );
+});
+
+// src/cli/commands/auth.ts
+import * as p from "@clack/prompts";
+import { defineCommand as defineCommand2 } from "citty";
+var authCommand = defineCommand2({
+  meta: { name: "auth", description: "Gestion de l'authentification" },
+  subCommands: {
+    login: defineCommand2({
+      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: defineCommand2({
+      meta: { name: "logout", description: "Se d\xE9connecter de Tiime" },
+      run() {
+        const tm = new TokenManager();
+        tm.logout();
+        output({ status: "logged_out" });
+      }
+    }),
+    status: defineCommand2({
+      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
+        });
+      }
+    })
   }
-  return config.companyId;
-};
+});
 
 // src/cli/commands/bank.ts
-var bankCommand = defineCommand2({
+import { defineCommand as defineCommand3 } from "citty";
+var bankCommand = defineCommand3({
   meta: { name: "bank", description: "Comptes bancaires et transactions" },
   subCommands: {
-    balance: defineCommand2({
+    balance: defineCommand3({
       meta: {
         name: "balance",
         description: "Afficher les soldes des comptes"
@@ -982,7 +1332,7 @@ var bankCommand = defineCommand2({
         }
       }
     }),
-    accounts: defineCommand2({
+    accounts: defineCommand3({
       meta: { name: "accounts", description: "Lister les comptes bancaires" },
       args: {
         ...formatArg,
@@ -1002,7 +1352,7 @@ var bankCommand = defineCommand2({
         }
       }
     }),
-    transactions: defineCommand2({
+    transactions: defineCommand3({
       meta: {
         name: "transactions",
         description: "Lister les transactions bancaires"
@@ -1074,7 +1424,7 @@ var bankCommand = defineCommand2({
         }
       }
     }),
-    unimputed: defineCommand2({
+    unimputed: defineCommand3({
       meta: {
         name: "unimputed",
         description: "Transactions non imput\xE9es"
@@ -1089,16 +1439,189 @@ var bankCommand = defineCommand2({
           outputError(e);
         }
       }
+    }),
+    impute: defineCommand3({
+      meta: {
+        name: "impute",
+        description: "Imputer manuellement une transaction"
+      },
+      args: {
+        id: {
+          type: "string",
+          description: "ID de la transaction (requis)",
+          required: true
+        },
+        "label-id": {
+          type: "string",
+          description: "ID du label \xE0 assigner (requis)",
+          required: true
+        },
+        "label-name": {
+          type: "string",
+          description: "Nom du label (optionnel, pour affichage)"
+        },
+        "dry-run": {
+          type: "boolean",
+          description: "Pr\xE9visualiser sans appliquer",
+          default: false
+        },
+        ...formatArg
+      },
+      async run({ args }) {
+        try {
+          const client = new TiimeClient({ companyId: getCompanyId() });
+          const transactionId = Number(args.id);
+          const labelId = Number(args["label-id"]);
+          const [transaction, suggestions] = await Promise.all([
+            client.bankTransactions.get(transactionId),
+            client.bankTransactions.labelSuggestions(transactionId)
+          ]);
+          let matchedLabel = suggestions.find(
+            (s) => s.id === labelId
+          );
+          if (!matchedLabel) {
+            const [labels, standardLabels] = await Promise.all([
+              client.labels.list(),
+              client.labels.standard()
+            ]);
+            const allLabels = [...labels, ...standardLabels];
+            const found = allLabels.find((l) => l.id === labelId);
+            if (found) {
+              matchedLabel = {
+                id: found.id,
+                label: found.name,
+                name: found.name,
+                acronym: "",
+                color: found.color,
+                client: null
+              };
+            }
+          }
+          if (!matchedLabel) {
+            outputError(
+              new Error(
+                `Label #${labelId} introuvable dans les suggestions ni dans les labels disponibles`
+              )
+            );
+            return;
+          }
+          const imputationLabel = {
+            ...matchedLabel,
+            disabled: false
+          };
+          const imputationParams = [
+            {
+              label: imputationLabel,
+              amount: transaction.amount,
+              documents: [],
+              accountant_detail_requests: []
+            }
+          ];
+          const displayName = args["label-name"] ?? matchedLabel.name ?? matchedLabel.label;
+          if (args["dry-run"]) {
+            output(
+              {
+                dry_run: true,
+                transaction_id: transactionId,
+                wording: transaction.wording,
+                amount: transaction.amount,
+                currency: transaction.currency,
+                label_id: labelId,
+                label_name: displayName
+              },
+              { format: args.format }
+            );
+            return;
+          }
+          const result = await client.bankTransactions.impute(
+            transactionId,
+            imputationParams
+          );
+          output(result, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
+    }),
+    "auto-impute": defineCommand3({
+      meta: {
+        name: "auto-impute",
+        description: "Auto-imputer les transactions non imput\xE9es via les suggestions"
+      },
+      args: {
+        "dry-run": {
+          type: "boolean",
+          description: "Mode pr\xE9visualisation (par d\xE9faut)",
+          default: true
+        },
+        apply: {
+          type: "boolean",
+          description: "Appliquer les imputations (d\xE9sactive dry-run)",
+          default: false
+        },
+        "all-companies": {
+          type: "boolean",
+          description: "Traiter toutes les entreprises du compte (sinon entreprise active)",
+          default: false
+        },
+        company: {
+          type: "string",
+          description: "ID ou nom de l'entreprise cible (peut \xEAtre r\xE9p\xE9t\xE9 avec virgule : 50824,117954)"
+        },
+        ...formatArg
+      },
+      async run({ args }) {
+        try {
+          let companyIds;
+          if (args["all-companies"]) {
+            const rootClient = new TiimeClient({ companyId: 0 });
+            const companies = await rootClient.listCompanies();
+            companyIds = companies.map((c) => c.id);
+          } else if (args.company) {
+            const parts = args.company.split(",").map((s) => s.trim());
+            const allNumeric = parts.every((p2) => /^\d+$/.test(p2));
+            if (allNumeric) {
+              companyIds = parts.map(Number);
+            } else {
+              const rootClient = new TiimeClient({ companyId: 0 });
+              const companies = await rootClient.listCompanies();
+              companyIds = resolveCompanyIds(parts, companies);
+            }
+          } else {
+            companyIds = [getCompanyId()];
+          }
+          const allProposals = [];
+          for (const companyId of companyIds) {
+            const client = new TiimeClient({ companyId });
+            let companyName = String(companyId);
+            try {
+              const info = await client.company.get();
+              companyName = info.name ?? String(companyId);
+            } catch {
+            }
+            const proposals = await autoImputeForCompany(
+              client,
+              companyId,
+              companyName,
+              { apply: args.apply }
+            );
+            allProposals.push(...proposals);
+          }
+          output(allProposals, { format: args.format });
+        } catch (e) {
+          outputError(e);
+        }
+      }
     })
   }
 });
 
 // src/cli/commands/clients.ts
-import { defineCommand as defineCommand3 } from "citty";
-var clientsCommand = defineCommand3({
+import { defineCommand as defineCommand4 } from "citty";
+var clientsCommand = defineCommand4({
   meta: { name: "clients", description: "Gestion des clients" },
   subCommands: {
-    list: defineCommand3({
+    list: defineCommand4({
       meta: { name: "list", description: "Lister les clients" },
       args: {
         ...formatArg,
@@ -1120,7 +1643,7 @@ var clientsCommand = defineCommand3({
         }
       }
     }),
-    get: defineCommand3({
+    get: defineCommand4({
       meta: { name: "get", description: "D\xE9tails d'un client" },
       args: {
         id: { type: "string", description: "ID du client", required: true }
@@ -1135,7 +1658,7 @@ var clientsCommand = defineCommand3({
         }
       }
     }),
-    create: defineCommand3({
+    create: defineCommand4({
       meta: { name: "create", description: "Cr\xE9er un client" },
       args: {
         name: {
@@ -1192,7 +1715,7 @@ var clientsCommand = defineCommand3({
         }
       }
     }),
-    search: defineCommand3({
+    search: defineCommand4({
       meta: { name: "search", description: "Rechercher un client" },
       args: {
         ...formatArg,
@@ -1216,11 +1739,11 @@ var clientsCommand = defineCommand3({
 });
 
 // src/cli/commands/company.ts
-import { defineCommand as defineCommand4 } from "citty";
-var companyCommand = defineCommand4({
+import { defineCommand as defineCommand5 } from "citty";
+var companyCommand = defineCommand5({
   meta: { name: "company", description: "Gestion de l'entreprise" },
   subCommands: {
-    list: defineCommand4({
+    list: defineCommand5({
       meta: { name: "list", description: "Lister toutes les entreprises" },
       args: { ...formatArg },
       async run({ args }) {
@@ -1242,7 +1765,7 @@ var companyCommand = defineCommand4({
         }
       }
     }),
-    get: defineCommand4({
+    get: defineCommand5({
       meta: { name: "get", description: "D\xE9tails de l'entreprise active" },
       async run() {
         try {
@@ -1256,7 +1779,7 @@ var companyCommand = defineCommand4({
         }
       }
     }),
-    use: defineCommand4({
+    use: defineCommand5({
       meta: { name: "use", description: "D\xE9finir l'entreprise active" },
       args: {
         id: {
@@ -1272,7 +1795,7 @@ var companyCommand = defineCommand4({
         output({ status: "ok", companyId: config.companyId });
       }
     }),
-    me: defineCommand4({
+    me: defineCommand5({
       meta: {
         name: "me",
         description: "Info utilisateur courant (inclut active_company)"
@@ -1291,7 +1814,7 @@ var companyCommand = defineCommand4({
 });
 
 // src/cli/commands/completion.ts
-import { defineCommand as defineCommand5 } from "citty";
+import { defineCommand as defineCommand6 } from "citty";
 var commands = {
   auth: {
     description: "Gestion de l'authentification",
@@ -1516,7 +2039,7 @@ var generateFish = () => {
   return `${lines.join("\n")}
 `;
 };
-var completionCommand = defineCommand5({
+var completionCommand = defineCommand6({
   meta: {
     name: "completion",
     description: "G\xE9n\xE9rer le script d'autocompl\xE9tion shell"
@@ -1553,11 +2076,11 @@ var completionCommand = defineCommand5({
 // 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({
+import { defineCommand as defineCommand7 } from "citty";
+var documentsCommand = defineCommand7({
   meta: { name: "documents", description: "Gestion des documents" },
   subCommands: {
-    list: defineCommand6({
+    list: defineCommand7({
       meta: { name: "list", description: "Lister les documents" },
       args: {
         ...formatArg,
@@ -1585,7 +2108,7 @@ var documentsCommand = defineCommand6({
         }
       }
     }),
-    upload: defineCommand6({
+    upload: defineCommand7({
       meta: { name: "upload", description: "Uploader un justificatif" },
       args: {
         file: {
@@ -1614,7 +2137,7 @@ var documentsCommand = defineCommand6({
         }
       }
     }),
-    download: defineCommand6({
+    download: defineCommand7({
       meta: { name: "download", description: "T\xE9l\xE9charger un document" },
       args: {
         id: {
@@ -1640,7 +2163,7 @@ var documentsCommand = defineCommand6({
         }
       }
     }),
-    categories: defineCommand6({
+    categories: defineCommand7({
       meta: {
         name: "categories",
         description: "Lister les cat\xE9gories de documents"
@@ -1660,11 +2183,11 @@ var documentsCommand = defineCommand6({
 });
 
 // src/cli/commands/expenses.ts
-import { defineCommand as defineCommand7 } from "citty";
-var expensesCommand = defineCommand7({
+import { defineCommand as defineCommand8 } from "citty";
+var expensesCommand = defineCommand8({
   meta: { name: "expenses", description: "Gestion des notes de frais" },
   subCommands: {
-    list: defineCommand7({
+    list: defineCommand8({
       meta: { name: "list", description: "Lister les notes de frais" },
       args: {
         ...formatArg,
@@ -1684,7 +2207,7 @@ var expensesCommand = defineCommand7({
         }
       }
     }),
-    get: defineCommand7({
+    get: defineCommand8({
       meta: { name: "get", description: "D\xE9tails d'une note de frais" },
       args: {
         id: {
@@ -1703,7 +2226,7 @@ var expensesCommand = defineCommand7({
         }
       }
     }),
-    create: defineCommand7({
+    create: defineCommand8({
       meta: { name: "create", description: "Cr\xE9er une note de frais" },
       args: {
         name: {
@@ -1734,11 +2257,11 @@ var expensesCommand = defineCommand7({
 
 // src/cli/commands/invoices.ts
 import { writeFileSync as writeFileSync4 } from "fs";
-import { defineCommand as defineCommand8 } from "citty";
-var invoicesCommand = defineCommand8({
+import { defineCommand as defineCommand9 } from "citty";
+var invoicesCommand = defineCommand9({
   meta: { name: "invoices", description: "Gestion des factures" },
   subCommands: {
-    list: defineCommand8({
+    list: defineCommand9({
       meta: { name: "list", description: "Lister les factures" },
       args: {
         ...formatArg,
@@ -1787,7 +2310,7 @@ var invoicesCommand = defineCommand8({
         }
       }
     }),
-    get: defineCommand8({
+    get: defineCommand9({
       meta: { name: "get", description: "D\xE9tails d'une facture" },
       args: {
         id: { type: "string", description: "ID de la facture", required: true }
@@ -1802,7 +2325,7 @@ var invoicesCommand = defineCommand8({
         }
       }
     }),
-    create: defineCommand8({
+    create: defineCommand9({
       meta: {
         name: "create",
         description: "Cr\xE9er une facture (brouillon par d\xE9faut)"
@@ -1931,7 +2454,7 @@ var invoicesCommand = defineCommand8({
         }
       }
     }),
-    duplicate: defineCommand8({
+    duplicate: defineCommand9({
       meta: {
         name: "duplicate",
         description: "Dupliquer une facture existante en brouillon"
@@ -1964,7 +2487,7 @@ var invoicesCommand = defineCommand8({
         }
       }
     }),
-    update: defineCommand8({
+    update: defineCommand9({
       meta: { name: "update", description: "Mettre \xE0 jour une facture" },
       args: {
         id: {
@@ -2010,7 +2533,7 @@ var invoicesCommand = defineCommand8({
         }
       }
     }),
-    send: defineCommand8({
+    send: defineCommand9({
       meta: { name: "send", description: "Envoyer une facture par email" },
       args: {
         id: {
@@ -2050,7 +2573,7 @@ var invoicesCommand = defineCommand8({
         }
       }
     }),
-    pdf: defineCommand8({
+    pdf: defineCommand9({
       meta: {
         name: "pdf",
         description: "T\xE9l\xE9charger le PDF d'une facture"
@@ -2078,7 +2601,7 @@ var invoicesCommand = defineCommand8({
         }
       }
     }),
-    delete: defineCommand8({
+    delete: defineCommand9({
       meta: { name: "delete", description: "Supprimer une facture brouillon" },
       args: {
         id: {
@@ -2101,11 +2624,11 @@ var invoicesCommand = defineCommand8({
 });
 
 // src/cli/commands/labels.ts
-import { defineCommand as defineCommand9 } from "citty";
-var labelsCommand = defineCommand9({
+import { defineCommand as defineCommand10 } from "citty";
+var labelsCommand = defineCommand10({
   meta: { name: "labels", description: "Gestion des labels et tags" },
   subCommands: {
-    list: defineCommand9({
+    list: defineCommand10({
       meta: { name: "list", description: "Lister les labels personnalis\xE9s" },
       args: { ...formatArg },
       async run({ args }) {
@@ -2118,7 +2641,7 @@ var labelsCommand = defineCommand9({
         }
       }
     }),
-    standard: defineCommand9({
+    standard: defineCommand10({
       meta: { name: "standard", description: "Lister les labels standards" },
       args: { ...formatArg },
       async run({ args }) {
@@ -2131,7 +2654,7 @@ var labelsCommand = defineCommand9({
         }
       }
     }),
-    tags: defineCommand9({
+    tags: defineCommand10({
       meta: { name: "tags", description: "Lister les tags" },
       args: { ...formatArg },
       async run({ args }) {
@@ -2149,7 +2672,7 @@ var labelsCommand = defineCommand9({
 
 // src/cli/commands/open.ts
 import { exec } from "child_process";
-import { defineCommand as defineCommand10 } from "citty";
+import { defineCommand as defineCommand11 } from "citty";
 var APP_BASE_URL = "https://apps.tiime.fr";
 var sections = {
   invoices: "/invoicing/invoices",
@@ -2172,7 +2695,7 @@ var buildUrl = (section) => {
   const companyId = getCompanyId();
   return `${APP_BASE_URL}/companies/${companyId}${path}`;
 };
-var openCommand = defineCommand10({
+var openCommand = defineCommand11({
   meta: {
     name: "open",
     description: "Ouvrir Tiime dans le navigateur"
@@ -2197,11 +2720,11 @@ var openCommand = defineCommand10({
 
 // src/cli/commands/quotations.ts
 import { writeFileSync as writeFileSync5 } from "fs";
-import { defineCommand as defineCommand11 } from "citty";
-var quotationsCommand = defineCommand11({
+import { defineCommand as defineCommand12 } from "citty";
+var quotationsCommand = defineCommand12({
   meta: { name: "quotations", description: "Gestion des devis" },
   subCommands: {
-    list: defineCommand11({
+    list: defineCommand12({
       meta: { name: "list", description: "Lister les devis" },
       args: { ...formatArg },
       async run({ args }) {
@@ -2214,7 +2737,7 @@ var quotationsCommand = defineCommand11({
         }
       }
     }),
-    get: defineCommand11({
+    get: defineCommand12({
       meta: { name: "get", description: "D\xE9tails d'un devis" },
       args: {
         id: { type: "string", description: "ID du devis", required: true }
@@ -2229,7 +2752,7 @@ var quotationsCommand = defineCommand11({
         }
       }
     }),
-    create: defineCommand11({
+    create: defineCommand12({
       meta: {
         name: "create",
         description: "Cr\xE9er un devis (brouillon par d\xE9faut)"
@@ -2305,7 +2828,7 @@ var quotationsCommand = defineCommand11({
         }
       }
     }),
-    pdf: defineCommand11({
+    pdf: defineCommand12({
       meta: {
         name: "pdf",
         description: "T\xE9l\xE9charger le PDF d'un devis"
@@ -2333,7 +2856,7 @@ var quotationsCommand = defineCommand11({
         }
       }
     }),
-    send: defineCommand11({
+    send: defineCommand12({
       meta: { name: "send", description: "Envoyer un devis par email" },
       args: {
         id: {
@@ -2377,8 +2900,8 @@ var quotationsCommand = defineCommand11({
 });
 
 // src/cli/commands/status.ts
-import { defineCommand as defineCommand12 } from "citty";
-var statusCommand = defineCommand12({
+import { defineCommand as defineCommand13 } from "citty";
+var statusCommand = defineCommand13({
   meta: { name: "status", description: "R\xE9sum\xE9 rapide de la situation" },
   args: { ...formatArg },
   async run({ args }) {
@@ -2429,11 +2952,11 @@ var statusCommand = defineCommand12({
 });
 
 // src/cli/commands/version.ts
-import { defineCommand as defineCommand13 } from "citty";
-var versionCommand = defineCommand13({
+import { defineCommand as defineCommand14 } from "citty";
+var versionCommand = defineCommand14({
   meta: { name: "version", description: "Afficher la version" },
   run() {
-    output({ version: "1.0.0", node: process.version });
+    output({ version: "1.2.0", node: process.version });
   }
 });
 
@@ -2451,6 +2974,7 @@ var descriptionTranslations = {
   "Gestion des notes de frais": "Expense report management",
   "Gestion des documents": "Document management",
   "Gestion des labels et tags": "Label and tag management",
+  "Audit comptable multi-entreprises": "Multi-company accounting audit",
   "R\xE9sum\xE9 rapide de la situation": "Quick status summary",
   "Ouvrir Tiime dans le navigateur": "Open Tiime in browser",
   "Afficher la version": "Show version",
@@ -2562,7 +3086,10 @@ var descriptionTranslations = {
   "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"
+  "Titre du devis": "Quotation title",
+  "Traiter toutes les entreprises": "Process all companies",
+  "Entreprise(s) cible(s) (ID ou nom, s\xE9par\xE9s par des virgules)": "Target company(ies) (ID or name, comma-separated)",
+  "Appliquer les corrections automatiques (imputation auto)": "Apply automatic fixes (auto-imputation)"
 };
 var frameworkTranslations = {
   fr: {
@@ -2609,13 +3136,14 @@ var translateHelp = (text2) => {
 };
 
 // src/cli/index.ts
-var main = defineCommand14({
+var main = defineCommand15({
   meta: {
     name: "tiime",
     version: "1.0.0",
     description: "CLI pour la comptabilit\xE9 Tiime \u2014 sortie JSON pour agents IA"
   },
   subCommands: {
+    audit: auditCommand,
     auth: authCommand,
     company: companyCommand,
     invoices: invoicesCommand,