@bergetai/odoo-cli 0.8.1 → 0.9.2

package/README.md

@@ -26,11 +26,20 @@ odoo version
 
 # Partners (companies and contacts — res.partner)
 odoo partners list --company --json
+odoo partners list --search "acme" --tag "Partner" --json   # ilike on name/email, tag filter
 odoo partners show 51
+odoo partners tags                                          # tags with usage counts
 odoo partners create --name "Acme Corp" --is-company true --email info@acme.example
 odoo partners update 51 --email new@acme.example --dry-run
+odoo partners update 51 --add-tag "AI" --remove-tag "Draft" --dry-run
 odoo partners delete 54 --dry-run
 
+# Generic model introspection (any model with an XML-RPC API)
+odoo models fields res.partner --filter "^email" --json
+odoo models fields crm.lead --custom              # only x_* custom fields
+odoo models read res.partner --ids 51,52 --fields name,city
+odoo models read crm.lead --search "microsoft" --json  # ilike on name (max 100)
+
 # List and inspect records
 odoo crm leads list --open --limit 20
 odoo crm leads show 42
@@ -75,11 +84,12 @@ Note: `odoo --version` prints the CLI's own version; `odoo version` queries the
 ## Features
 
 - Read-only CRM surface (`crm leads list/show`) — default columns, `--fields`/`--all-fields`, `--limit`/`--offset`/`--order`, `--domain`/`--filter` with `fields_get` type checking, reference resolution (`--stage`/`--team`/`--assignee`/`--tag`), table/JSON output with `search_count` envelope
-- Partners surface (`partners list/show/create/update/delete`) — `res.partner` CRUD with `--company`/`--individual` filters, `--archived` (include inactive), first-class flags for `--name`, `--email`, `--phone`, `--website`, `--parent` (m2o), `--is-company`, `--street`, `--city`, `--zip`, `--country` (m2o), `--comment`, full `--dry-run` support, `--fields`/`--all-fields`, table/JSON output
+- Partners surface (`partners list/show/tags/create/update/delete`) — `res.partner` CRUD with `--company`/`--individual` filters, `--search` (case-insensitive name/email match), `--tag` (repeatable, resolves `res.partner.category` by exact name then ilike), `--archived` (include inactive), curated list columns (ID, Name, Company Type, City, Email, Is a Company, Tags, Salesperson), curated `show` view with tag names, salesperson, customer/supplier ranks plus every populated `x_studio*` custom field, `partners tags` (usage counts via `read_group`, sorted by usage), first-class mutation flags for `--name`, `--email`, `--phone`, `--website`, `--parent` (m2o), `--is-company`, `--street`, `--city`, `--zip`, `--country` (m2o), `--comment`, `--add-tag`/`--remove-tag` on update (unknown tags fail on add; removal silently skips tags the record lacks; protected fields `company_type` and `x_studio_invoice_approved` refuse writes), full `--dry-run` support, `--fields`/`--all-fields`, table/JSON output
 - Sales teams surface (`crm teams list/show/create/update/delete`) — `--archived` (include inactive teams), `--team-leader` (team leader, login/email/name), `--active`/`--use-leads`/`--use-opportunities`/`--invoiced-target`/`--color`/`--sequence`, full `--dry-run` support, `--fields`/`--all-fields`, table/JSON output
 - Read-only Helpdesk surface (`helpdesk tickets list/show`) — `--open`/`--closed` via stage `fold`, strict team-scoped stage resolution, module-not-installed error (exit 4)
 - Read-only Project surface (`project list/show`) — `--user` (project manager) and `--tag` filters, archived projects excluded by default, module-not-installed error (exit 4)
 - Read-only Project task surface (`project tasks list/show`) — `--project` (required on list, resolved by name or id), project-scoped `--stage`, `--assignee` (many2many `user_ids`), `--tag`, `--priority` (0/Low, 1/High), `--open`/`--closed` via the task's `is_closed` flag, `--domain`/`--filter`, table/JSON output with `search_count` envelope, module-not-installed error (exit 4)
+- Generic model surface (`models fields/read`) — introspect and read any model exposed through `execute_kw`: `fields` lists `fields_get` metadata (type, label, selection, relation, required, store) with `--filter <regex>` (case-insensitive on field name or label) and `--custom` (only `x_*` fields); `read` fetches up to 100 records by `--ids 1,2,3` or a name ilike `--search`, with `--fields a,b,c` (default: name). Unknown models/fields use the standard error taxonomy
 - Documents surface (`documents`) — `tree` (hierarchical folder listing with `--count`/`--depth`/`--folder`), `records list/show` (folders excluded by default, `--type folder|binary|url|all`, `--folder`/`--owner`/`--partner`/`--tag`), `folders list`, `records create` (folder via `--folder-type folder`, link via `--link <url>`), `records update` (move via `--folder`), `records delete`, `upload` (local file → base64 `datas`, MIME guessed from extension, `--dry-run` previews without sending bytes), and `records download <id>` (binary document → local file, `--out <path>`/`--force`, `--out -` streams to stdout). Everywhere a `--folder` is accepted, folders resolve by name, numeric id, or nested `'Parent > Child'` path (segments resolved within their parent, which disambiguates repeated folder names). Folders are `documents.document` rows with `type='folder'`; the hierarchy is `folder_id`. Module-not-installed error (exit 4)
 - Writes (`create`, `update`, `delete`) — single-call atomic batch `write`, client-side no-op diffing, delete convergence with `skipped` ids, post-failure "record may have been created" hint on `create`
 - `--dry-run` for all mutations — full validation, resolution, and before/after diffs without mutating

package/dist/cli.js

@@ -9,7 +9,8 @@ import { activitiesListCommand, activityDoneCommand, activityUpdateCommand, sche
 import { createTaskCommand, projectListCommand, projectShowCommand, tasksListCommand, tasksShowCommand, } from "./commands/project.js";
 import { documentsDocuments, documentsListCommand, foldersListCommand, documentsShowCommand, documentsCreateCommand, documentsUpdateCommand, documentsDeleteCommand, treeCommand, uploadCommand, downloadCommand, } from "./commands/documents.js";
 import { versionCommand } from "./commands/version.js";
-import { partnersCreateCommand, partnersDeleteCommand, partnersListCommand, partnersShowCommand, partnersUpdateCommand, resPartner, } from "./commands/partners.js";
+import { partnersCreateCommand, partnersDeleteCommand, partnersListCommand, partnersShowCommand, partnersTagsCommand, partnersUpdateCommand, resPartner, } from "./commands/partners.js";
+import { modelsFieldsCommand, modelsReadCommand, } from "./commands/models.js";
 import { CliError } from "./errors.js";
 import { applyGlobalOptions, enforceTransportSecurity, DEFAULT_TIMEOUT, } from "./global-options.js";
 import { printError } from "./output.js";
@@ -669,6 +670,8 @@ Examples:
         .option("--archived", "include archived partners (active = false) instead of active only")
         .option("--company", "only companies (is_company = true)")
         .option("--individual", "only individuals (is_company = false)")
+        .option("--search <text>", "ilike search on name or email")
+        .option("--tag <name|id>", "filter by tag; repeatable, AND-ed", collect, [])
         .option("--filter <f=v>", "equality filter; repeatable, AND-ed", collect, [])
         .option("--domain <json>", "Odoo domain as a JSON array (mutually exclusive with --filter)")
         .option("--fields <a,b,c>", "columns to display")
@@ -696,6 +699,8 @@ Examples:
         .command("update")
         .description("update partners (preview with --dry-run)"), resPartner)
         .argument("<id...>", "record ids")
+        .option("--add-tag <name>", "add a tag (res.partner.category); repeatable", collect, [])
+        .option("--remove-tag <name>", "remove a tag; repeatable, silently skipped when not present", collect, [])
         .action(async (ids, opts) => {
         await run((g) => partnersUpdateCommand(ids, opts, g), program);
     });
@@ -706,6 +711,47 @@ Examples:
         .action(async (ids) => {
         await run((g) => partnersDeleteCommand(ids, g), program);
     });
+    partners
+        .command("tags")
+        .description("list contact tags (res.partner.category) with usage counts")
+        .addHelpText("after", `
+Examples:
+  $ odoo partners tags
+  $ odoo partners tags --json`)
+        .action(async () => {
+        await run((g) => partnersTagsCommand(g), program);
+    });
+    const models = program
+        .command("models")
+        .description("generic model introspection (any model with an XML-RPC API)");
+    models
+        .command("fields")
+        .description("list a model's fields (fields_get with type metadata)")
+        .argument("<model>", "model technical name, e.g. res.partner")
+        .option("--filter <regex>", "case-insensitive regex on field name or label")
+        .option("--custom", "only custom (x_*) fields")
+        .addHelpText("after", `
+Examples:
+  $ odoo models fields res.partner
+  $ odoo models fields res.partner --filter "^email" --json
+  $ odoo models fields crm.lead --custom`)
+        .action(async (model, opts) => {
+        await run((g) => modelsFieldsCommand(model, opts, g), program);
+    });
+    models
+        .command("read")
+        .description("read up to 100 records by ids or name search")
+        .argument("<model>", "model technical name, e.g. res.partner")
+        .option("--ids <1,2,3>", "comma-separated record ids")
+        .option("--search <text>", "ilike search on the name field (used when --ids is omitted)")
+        .option("--fields <a,b,c>", "fields to read (default: name)")
+        .addHelpText("after", `
+Examples:
+  $ odoo models read res.partner --ids 51,52 --fields name,city
+  $ odoo models read crm.lead --search microsoft --json`)
+        .action(async (model, opts) => {
+        await run((g) => modelsReadCommand(model, opts, g), program);
+    });
     return program;
 }
 async function run(fn, program) {

package/dist/commands/models.js

@@ -0,0 +1,127 @@
+import { notFoundError, usageError } from "../errors.js";
+import { fieldsGet, ModelFields } from "../model.js";
+import { colorEnabled, printJson } from "../output.js";
+import { authenticatedClient } from "../resource.js";
+import { formatTable, humanCell } from "../table.js";
+const MAX_READ = 100;
+function parseFieldList(raw) {
+    const fields = raw
+        .split(",")
+        .map((f) => f.trim())
+        .filter((f) => f !== "");
+    if (fields.length === 0) {
+        throw usageError("--fields requires at least one field name");
+    }
+    return fields;
+}
+/**
+ * `odoo models fields <model>` — generic schema introspection via
+ * fields_get. Any model reachable through execute_kw works; an unknown
+ * model surfaces as the model_not_found taxonomy (exit 4).
+ */
+export async function modelsFieldsCommand(model, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const raw = await fieldsGet(client, model, [
+        "string",
+        "type",
+        "selection",
+        "relation",
+        "required",
+        "store",
+    ]);
+    let regex;
+    if (opts.filter !== undefined) {
+        try {
+            regex = new RegExp(opts.filter, "i");
+        }
+        catch {
+            throw usageError(`invalid --filter regex ${JSON.stringify(opts.filter)}`, "expected a valid regular expression");
+        }
+    }
+    const names = Object.keys(raw)
+        .filter((name) => {
+        if (opts.custom && !name.startsWith("x_"))
+            return false;
+        if (!regex)
+            return true;
+        return regex.test(name) || regex.test(String(raw[name]?.string ?? ""));
+    })
+        .sort((a, b) => a.localeCompare(b));
+    const fields = names.map((name) => {
+        const meta = raw[name] ?? {};
+        return {
+            name,
+            string: meta.string,
+            type: meta.type,
+            selection: meta.selection,
+            ...(meta.relation !== undefined
+                ? { relation: meta.relation }
+                : {}),
+            required: meta.required === true,
+            store: meta.store !== false,
+        };
+    });
+    if (globals.json) {
+        printJson({ model, fields });
+        return;
+    }
+    const headers = ["Field", "Type", "Label", "Relation", "Required", "Store"];
+    const rows = fields.map((f) => [
+        f.name,
+        String(f.type ?? ""),
+        String(f.string ?? ""),
+        String(f.relation ?? ""),
+        f.required ? "yes" : "",
+        f.store ? "" : "no",
+    ]);
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}
+/**
+ * `odoo models read <model>` — generic record reads. Exact ids via --ids or
+ * a name ilike search via --search; at most 100 records per call.
+ */
+export async function modelsReadCommand(model, opts, globals) {
+    if (opts.ids === undefined && opts.search === undefined) {
+        throw usageError("pass --ids or --search", "--ids reads exact records; --search ilike-matches the name field");
+    }
+    const client = await authenticatedClient(globals);
+    const meta = await ModelFields.load(client, model);
+    const fields = opts.fields !== undefined ? parseFieldList(opts.fields) : ["name"];
+    for (const field of fields) {
+        if (field !== "id" && !meta.get(field)) {
+            throw usageError(`unknown field ${JSON.stringify(field)} on ${model}`, "run `odoo models fields <model>` to list available fields");
+        }
+    }
+    let records;
+    if (opts.ids !== undefined) {
+        const idStrings = opts.ids
+            .split(",")
+            .map((s) => s.trim())
+            .filter((s) => s !== "");
+        if (idStrings.length === 0) {
+            throw usageError("--ids requires at least one record id");
+        }
+        for (const s of idStrings) {
+            if (!/^\d+$/.test(s)) {
+                throw usageError(`invalid record id ${JSON.stringify(s)}`, "ids are positive integers, comma-separated");
+            }
+        }
+        const ids = idStrings.map(Number);
+        records = (await client.executeKw(model, "read", [ids], {
+            fields,
+        }));
+        if (records.length === 0) {
+            throw notFoundError("record_not_found", `no ${model} record(s) with id(s): ${ids.join(", ")}`);
+        }
+    }
+    else {
+        records = (await client.executeKw(model, "search_read", [[["name", "ilike", opts.search]]], { fields, limit: MAX_READ, order: "id asc" }));
+    }
+    if (globals.json) {
+        printJson({ model, records, count: records.length, limit: MAX_READ });
+        return;
+    }
+    const headers = fields.map((f) => meta.get(f)?.string ?? f);
+    const rows = records.map((r) => fields.map((f) => humanCell(r[f])));
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}

package/dist/commands/partners.js

@@ -1,10 +1,11 @@
-import { ModelFields } from "../model.js";
-import { authenticatedClient, showCommand, } from "../resource.js";
-import { createCommand, deleteCommand, updateCommand, } from "../mutation.js";
+import { ModelFields, resolveReference, } from "../model.js";
+import { authenticatedClient, parseId, showCommand, } from "../resource.js";
+import { buildValues, createCommand, deleteCommand, fieldValuesEqual, isFlatPair, } from "../mutation.js";
 import { buildFilterClauses, parseDomain } from "../filter.js";
-import { usageError } from "../errors.js";
-import { colorEnabled, printJson } from "../output.js";
-import { formatTable, humanCell } from "../table.js";
+import { conflictError, notFoundError, usageError, } from "../errors.js";
+import { colorEnabled, printJson, verbose as logVerbose, } from "../output.js";
+import { formatKeyValues, formatTable, humanCell } from "../table.js";
+import { XmlRpcFaultError } from "../xmlrpc.js";
 function parseYesNoFlag(raw, flagName) {
     const v = raw.toLowerCase();
     if (v === "true" || v === "1" || v === "yes")
@@ -117,18 +118,19 @@ export const resPartner = {
     defaultListFields: [
         "id",
         "name",
+        "company_type",
         "is_company",
+        "city",
         "email",
-        "phone",
-        "parent_id",
-        "active",
-        "create_date",
+        "category_id",
+        "user_id",
     ],
     showExtraFields: [
         "website",
+        "phone",
         "street",
-        "city",
         "zip",
+        "parent_id",
         "country_id",
         "comment",
         "company_id",
@@ -188,6 +190,16 @@ export async function partnersListCommand(opts, globals) {
         domain.push(["is_company", "=", true]);
     if (opts.individual)
         domain.push(["is_company", "=", false]);
+    if (opts.search) {
+        // case-insensitive match on name OR email (crm-style ilike);
+        // domains are flat: the operator is a top-level element
+        domain.push("|", ["name", "ilike", opts.search], ["email", "ilike", opts.search]);
+    }
+    for (const tag of opts.tag ?? []) {
+        const resolved = await resolvePartnerTag(client, tag);
+        domain.push(["category_id", "=", resolved.id]);
+        logVerbose(`resolved --tag "${tag}" -> [${resolved.id}, "${resolved.name}"]`, globals.verbose);
+    }
     if (opts.domain) {
         domain.push(...parseDomain(opts.domain));
     }
@@ -225,20 +237,449 @@ export async function partnersListCommand(opts, globals) {
         printJson({ model: "res.partner", records, count, limit, offset });
         return;
     }
+    const categoryMap = fields.includes("category_id")
+        ? await loadCategoryNames(client)
+        : new Map();
     const headers = fields.map((f) => fieldsMeta.get(f)?.string ?? f);
-    const rows = records.map((rec) => fields.map((f) => humanCell(rec[f])));
+    const rows = records.map((rec) => fields.map((f) => f === "category_id"
+        ? categoryNames(categoryMap, rec[f])
+        : humanCell(rec[f])));
     const color = colorEnabled(globals.noColor);
     process.stdout.write(formatTable(headers, rows, color) + "\n");
 }
+/**
+ * Curated show view (§7): the key partner fields plus every populated
+ * x_studio* custom field as `name=value`. Explicit --fields/--all-fields
+ * requests are delegated to the shared show engine.
+ */
+const PARTNER_SHOW_FIELDS = [
+    "id",
+    "name",
+    "company_type",
+    "is_company",
+    "parent_id",
+    "website",
+    "email",
+    "phone",
+    "street",
+    "city",
+    "zip",
+    "country_id",
+    "category_id",
+    "user_id",
+    "customer_rank",
+    "supplier_rank",
+    "comment",
+];
+function isPopulated(value) {
+    return !(value === false || value === null || value === undefined || value === "");
+}
 export function partnersShowCommand(idArg, opts, globals) {
-    return showCommand(resPartner, idArg, opts, globals);
+    if (opts.fields || opts.allFields) {
+        return showCommand(resPartner, idArg, opts, globals);
+    }
+    return partnersShowCurated(idArg, globals);
+}
+async function partnersShowCurated(idArg, globals) {
+    const client = await authenticatedClient(globals);
+    const id = parseId(idArg);
+    const meta = await ModelFields.load(client, "res.partner");
+    const fields = [
+        ...PARTNER_SHOW_FIELDS,
+        ...meta.names().filter((n) => n.startsWith("x_studio")),
+    ].filter((f) => f === "id" || meta.get(f));
+    const rows = (await client.executeKw("res.partner", "read", [[id]], {
+        fields,
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("record_not_found", `no res.partner record with id ${id}`);
+    }
+    const record = rows[0];
+    if (globals.json) {
+        const pruned = {};
+        for (const [k, v] of Object.entries(record)) {
+            if (k.startsWith("x_studio") && !isPopulated(v))
+                continue;
+            pruned[k] = v;
+        }
+        printJson({ model: "res.partner", record: pruned });
+        return;
+    }
+    const categoryMap = fields.includes("category_id")
+        ? await loadCategoryNames(client)
+        : new Map();
+    const pairs = fields
+        .filter((f) => {
+        if (!f.startsWith("x_studio"))
+            return true;
+        // only populated x_studio fields appear in the curated view
+        return isPopulated(record[f]);
+    })
+        .map((f) => [
+        // custom fields render as technical `name=value`; curated use labels
+        f.startsWith("x_studio") ? f : (meta.get(f)?.string ?? f),
+        f === "category_id"
+            ? categoryNames(categoryMap, record[f])
+            : humanCell(record[f]),
+    ]);
+    process.stdout.write(formatKeyValues(pairs, colorEnabled(globals.noColor)) + "\n");
 }
 export function partnersCreateCommand(opts, globals) {
     return createCommand(resPartner, opts, globals);
 }
-export function partnersUpdateCommand(idArgs, opts, globals) {
-    return updateCommand(resPartner, idArgs, opts, globals);
+/**
+ * Fields that partners update refuses to write. `company_type` conversion
+ * (company <-> person) carries nested cleanup (company fields, vat, ranks)
+ * the CLI cannot perform; the studio approval field is protected by default.
+ */
+const PROTECTED_PARTNER_FIELDS = new Set([
+    "company_type",
+    "x_studio_invoice_approved",
+]);
+/**
+ * Coerce a --set/--values value to the field's Odoo type (§9). Partners
+ * update accepts atomic types plus many2one via numeric id — many2many/
+ * one2many need tag commands or JSON command values via --values and are
+ * refused.
+ */
+function coerceSetScalar(field, meta, value) {
+    const type = meta?.type ?? "char";
+    const fail = (expected) => {
+        throw usageError(`--set ${field} expects ${expected}`, "run `odoo models fields res.partner --filter ...` to check the field type");
+    };
+    if (type === "boolean") {
+        if (value === true || value === "true" || value === "1" || value === 1) {
+            return true;
+        }
+        if (value === false || value === "false" || value === "0" || value === 0) {
+            return false;
+        }
+        return fail("a boolean (true/false)");
+    }
+    if (type === "integer") {
+        if (typeof value === "number" && Number.isInteger(value))
+            return value;
+        if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+            return Number(value.trim());
+        }
+        return fail("an integer");
+    }
+    if (type === "float" || type === "monetary") {
+        const n = typeof value === "number" ? value : Number(String(value).trim());
+        if (Number.isFinite(n))
+            return n;
+        return fail("a number");
+    }
+    if (type === "many2one") {
+        if (typeof value === "number" && Number.isInteger(value))
+            return value;
+        return fail("a numeric record id");
+    }
+    if (type === "many2many" || type === "one2many") {
+        throw usageError(`--set ${field} is not supported for ${type} fields`, "use --add-tag/--remove-tag for partner tags");
+    }
+    return value;
+}
+/**
+ * Resolve a partner tag (res.partner.category) by exact name first, then
+ * ilike via the shared reference resolution (§4.3: never guesses).
+ */
+async function resolvePartnerTag(client, name) {
+    const exact = (await client.executeKw("res.partner.category", "search_read", [[["name", "=", name]]], { fields: ["display_name"], limit: 1 }));
+    if (exact.length === 1) {
+        return { id: exact[0].id, name: exact[0].display_name };
+    }
+    return resolveReference(client, "res.partner.category", name, {
+        label: "tag",
+    });
+}
+async function loadCategoryNames(client) {
+    const rows = (await client.executeKw("res.partner.category", "search_read", [], { fields: ["id", "name"], limit: 5000, order: "id asc" }));
+    return new Map(rows.map((r) => [r.id, r.name]));
+}
+/** Render a category id list as comma-separated tag names (unknowns as ids). */
+function categoryNames(map, value) {
+    if (!Array.isArray(value))
+        return humanCell(value);
+    return value.map((id) => map.get(id) ?? String(id)).join(", ");
+}
+function uniqueInOrder(values) {
+    return [...new Set(values)];
+}
+function wireScalar(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (isFlatPair(value))
+        return `[${value[0]}, ${JSON.stringify(value[1])}]`;
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => String(v)).join(", ")}]`;
+    }
+    if (value === false || value === null || value === undefined) {
+        return String(value);
+    }
+    return JSON.stringify(value) ?? String(value);
+}
+export async function partnersUpdateCommand(idArgs, opts, globals) {
+    const spec = resPartner.mutation;
+    if (!spec)
+        throw usageError("res.partner has no mutation support configured");
+    const addTag = (opts.addTag ?? []).filter((t) => t.trim() !== "");
+    const removeTag = (opts.removeTag ?? []).filter((t) => t.trim() !== "");
+    const tagOps = addTag.length > 0 || removeTag.length > 0;
+    const client = await authenticatedClient(globals);
+    const fieldsMeta = await ModelFields.load(client, "res.partner");
+    const built = await buildValues(client, resPartner, spec, opts, "update", globals);
+    for (const field of Object.keys(built.values)) {
+        if (PROTECTED_PARTNER_FIELDS.has(field)) {
+            throw conflictError("protected_field", `field "${field}" is protected and cannot be modified via partners update`, "company_type conversions and protected studio fields must be changed in the Odoo UI");
+        }
+    }
+    // --set values are validated against the field's Odoo type (atomic types
+    // + many2one by numeric id only). First-class flags already parse their
+    // own values, so only --set/--values pass through coercion here.
+    const flagFields = new Set(spec.flags.map((f) => f.field));
+    for (const [field, value] of Object.entries(built.values)) {
+        if (flagFields.has(field))
+            continue;
+        built.values[field] = coerceSetScalar(field, fieldsMeta.get(field), value);
+    }
+    if (Object.keys(built.values).length === 0 && !tagOps) {
+        throw usageError("nothing to update", "pass at least one field flag, --set, --values, --add-tag, or --remove-tag");
+    }
+    const ids = idArgs.map(parseId);
+    // Resolve tags before reading records so unknown --add-tag fails fast.
+    const addEntries = new Map();
+    for (const name of addTag) {
+        const resolved = await resolvePartnerTag(client, name);
+        addEntries.set(resolved.id, resolved.name);
+    }
+    const removeEntries = [];
+    const unresolvedRemoves = [];
+    for (const name of removeTag) {
+        try {
+            const resolved = await resolvePartnerTag(client, name);
+            removeEntries.push({ id: resolved.id, name: resolved.name });
+        }
+        catch (error) {
+            // unknown tag: removal is silent — the end state is already reached
+            if (error.code === "reference_not_found") {
+                unresolvedRemoves.push(name);
+                continue;
+            }
+            throw error;
+        }
+    }
+    const readFields = [
+        ...new Set([...Object.keys(built.values), "display_name", "category_id"]),
+    ];
+    const rows = (await client.executeKw("res.partner", "read", [ids], {
+        fields: readFields,
+    }));
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const missing = ids.filter((id) => !byId.has(id));
+    if (missing.length > 0) {
+        throw notFoundError("record_not_found", `no res.partner record(s) with id(s): ${missing.join(", ")}`, "no records were modified — update aborts the whole batch when any id is missing");
+    }
+    const diffs = ids.map((id) => {
+        const rec = byId.get(id);
+        const changes = {};
+        for (const [field, after] of Object.entries(built.values)) {
+            const before = rec[field];
+            if (!fieldValuesEqual(fieldsMeta.get(field)?.type, before, after)) {
+                changes[field] = { before, after };
+            }
+        }
+        let tagNext;
+        const tagAdded = [];
+        const tagRemoved = [];
+        const tagSkipped = [...unresolvedRemoves];
+        if (tagOps) {
+            const current = (rec.category_id ?? []).filter((n) => typeof n === "number");
+            const next = [...current];
+            for (const [tid, tname] of addEntries) {
+                if (!next.includes(tid)) {
+                    next.push(tid);
+                    tagAdded.push(tname);
+                }
+                else {
+                    tagSkipped.push(tname);
+                }
+            }
+            for (const entry of removeEntries) {
+                const idx = next.indexOf(entry.id);
+                if (idx >= 0) {
+                    next.splice(idx, 1);
+                    tagRemoved.push(entry.name);
+                }
+                else {
+                    tagSkipped.push(entry.name);
+                }
+            }
+            if (!fieldValuesEqual("many2many", current, [[6, 0, next]])) {
+                changes.category_id = { before: current, after: next };
+                tagNext = next;
+            }
+        }
+        return {
+            id,
+            display_name: String(rec.display_name ?? id),
+            changes,
+            tagNext,
+            tagAdded,
+            tagRemoved,
+            tagSkipped,
+        };
+    });
+    const addedTags = uniqueInOrder(diffs.flatMap((d) => d.tagAdded));
+    const removedTags = uniqueInOrder(diffs.flatMap((d) => d.tagRemoved));
+    const skippedTags = uniqueInOrder(diffs.flatMap((d) => d.tagSkipped));
+    // write first, then report (dry-run or post-write confirmation);
+    // no-op records are never written (§5.4 single-call atomic batches).
+    const changed = diffs.filter((d) => Object.keys(d.changes).length > 0);
+    if (!globals.dryRun && changed.length > 0) {
+        // write per distinct payload (tag sets may differ between records)
+        const groups = new Map();
+        for (const d of changed) {
+            const values = { ...built.values };
+            if (d.tagNext !== undefined) {
+                values.category_id = [[6, 0, d.tagNext]];
+            }
+            const key = JSON.stringify(values);
+            const group = groups.get(key);
+            if (group) {
+                group.ids.push(d.id);
+            }
+            else {
+                groups.set(key, { ids: [d.id], values });
+            }
+        }
+        for (const group of groups.values()) {
+            try {
+                await client.executeKw("res.partner", "write", [group.ids, group.values]);
+            }
+            catch (error) {
+                if (error instanceof XmlRpcFaultError) {
+                    throw conflictError("server_fault", `the server rejected the update (fault ${error.faultCode})`, "retry with --verbose to see the full server response");
+                }
+                throw error;
+            }
+        }
+    }
+    if (globals.json) {
+        const changes = {};
+        for (const d of diffs)
+            changes[String(d.id)] = d.changes;
+        printJson({
+            model: "res.partner",
+            action: "update",
+            dry_run: globals.dryRun,
+            changes,
+            ...(addTag.length > 0 || removeTag.length > 0
+                ? {
+                    added_tags: addedTags,
+                    removed_tags: removedTags,
+                    skipped_tags: skippedTags,
+                }
+                : {}),
+        });
+        return;
+    }
+    if (globals.dryRun) {
+        const tagNames = tagOps
+            ? await loadCategoryNames(client)
+            : new Map();
+        process.stdout.write(renderPartnerUpdatePlan(diffs, built, tagNames));
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const lines = [];
+    for (const d of diffs) {
+        if (Object.keys(d.changes).length === 0) {
+            lines.push(`Unchanged res.partner ${d.id}`);
+            continue;
+        }
+        const line = `Updated res.partner ${d.id}`;
+        lines.push(color ? `\x1b[33m${line}\x1b[0m` : line);
+    }
+    if (addedTags.length > 0)
+        lines.push(`  tags added: ${addedTags.join(", ")}`);
+    if (removedTags.length > 0) {
+        lines.push(`  tags removed: ${removedTags.join(", ")}`);
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+}
+function renderPartnerUpdatePlan(diffs, built, tagNames = new Map()) {
+    const lines = [];
+    for (const d of diffs) {
+        if (Object.keys(d.changes).length === 0) {
+            lines.push(`Unchanged res.partner ${d.id} (${d.display_name}) — nothing to change`);
+            continue;
+        }
+        lines.push(`Would update res.partner ${d.id} (${d.display_name}):`);
+        for (const [field, change] of Object.entries(d.changes)) {
+            if (field === "category_id") {
+                lines.push(`  tags: ${categoryNames(tagNames, change.before)} -> ${categoryNames(tagNames, change.after)}`);
+                continue;
+            }
+            const entry = built.resolved[field];
+            const after = entry && isFlatPair(entry) && !Array.isArray(change.after)
+                ? entry
+                : change.after;
+            lines.push(`  ${field}: ${wireScalar(change.before)} -> ${wireScalar(after)}`);
+        }
+    }
+    const added = uniqueInOrder(diffs.flatMap((d) => d.tagAdded));
+    const removed = uniqueInOrder(diffs.flatMap((d) => d.tagRemoved));
+    const skipped = uniqueInOrder(diffs.flatMap((d) => d.tagSkipped));
+    if (added.length > 0)
+        lines.push(`  tags added: ${added.join(", ")}`);
+    if (removed.length > 0)
+        lines.push(`  tags removed: ${removed.join(", ")}`);
+    if (skipped.length > 0) {
+        lines.push(`  tags skipped (no change): ${skipped.join(", ")}`);
+    }
+    return lines.join("\n") + "\n";
 }
 export function partnersDeleteCommand(idArgs, globals) {
     return deleteCommand(resPartner, idArgs, globals);
 }
+/**
+ * `odoo partners tags` — res.partner.category with usage counts. Counts come
+ * from a read_group over res.partner (active partners only, matching list
+ * defaults); unused categories report 0. Sorted by usage descending, then
+ * name ascending.
+ */
+export async function partnersTagsCommand(globals) {
+    const client = await authenticatedClient(globals);
+    await ModelFields.load(client, "res.partner.category");
+    const [categories, groups] = await Promise.all([
+        client.executeKw("res.partner.category", "search_read", [], { fields: ["id", "name", "parent_id"] }),
+        client.executeKw("res.partner", "read_group", [[], ["id"], ["category_id"]]),
+    ]);
+    const counts = new Map();
+    for (const g of groups) {
+        const id = Array.isArray(g.category_id) ? g.category_id[0] : false;
+        if (id !== false)
+            counts.set(id, g.category_id_count ?? 0);
+    }
+    const rows = categories
+        .map((c) => ({
+        id: c.id,
+        name: c.name,
+        parent_id: c.parent_id,
+        partner_count: counts.get(c.id) ?? 0,
+    }))
+        .sort((a, b) => b.partner_count - a.partner_count || a.name.localeCompare(b.name));
+    if (globals.json) {
+        printJson({ model: "res.partner.category", categories: rows });
+        return;
+    }
+    const headers = ["ID", "Name", "Parent", "PartnerCount"];
+    const table = rows.map((c) => [
+        String(c.id),
+        c.name,
+        humanCell(c.parent_id),
+        String(c.partner_count),
+    ]);
+    process.stdout.write(formatTable(headers, table, colorEnabled(globals.noColor)) + "\n");
+}

package/dist/model.js

@@ -37,6 +37,9 @@ export class ModelFields {
     get(name) {
         return this.fields[name];
     }
+    names() {
+        return Object.keys(this.fields);
+    }
 }
 const INVALID_MODEL_RE = /(?:Invalid model|Model not found)[: ]+['"]?([\w.]+)['"]?/;
 /**
@@ -54,6 +57,25 @@ function mapModelMissing(error, model) {
     }
     return error;
 }
+/**
+ * fields_get with caller-chosen attributes (used by the generic `models`
+ * surface). Unknown models are mapped onto the model_not_found taxonomy.
+ */
+export async function fieldsGet(client, model, attributes) {
+    let result;
+    try {
+        result = await client.executeKw(model, "fields_get", [[]], {
+            attributes,
+        });
+    }
+    catch (error) {
+        throw mapModelMissing(error, model);
+    }
+    if (typeof result !== "object" || result === null) {
+        throw notFoundError("model_not_found", `model ${JSON.stringify(model)} not found on the server`, `the ${model.split(".")[0]} module may not be installed`);
+    }
+    return result;
+}
 /**
  * Resolve a record reference by numeric id or case-insensitive name
  * (SPEC §4.3). Exactly one match required; zero matches list available

package/dist/mutation.js

@@ -370,7 +370,7 @@ export async function updateCommand(config, idArgs, opts, globals) {
  * no-op detection (§5.4) — Odoo's `write` returns True whether or not anything
  * changed, so this diffing is client-side only.
  */
-function fieldValuesEqual(type, before, after) {
+export function fieldValuesEqual(type, before, after) {
     if (type === "many2one") {
         const beforeId = Array.isArray(before) ? before[0] : before;
         return beforeId === after;
@@ -530,7 +530,7 @@ function renderCreatePlan(config, built) {
     return lines.join("\n") + "\n";
 }
 /** True for a single m2o resolved pair [id, "name"] stored flat. */
-function isFlatPair(x) {
+export function isFlatPair(x) {
     return (Array.isArray(x) &&
         x.length === 2 &&
         typeof x[0] === "number" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bergetai/odoo-cli",
-  "version": "0.8.1",
+  "version": "0.9.2",
   "description": "Agent-first CLI for the Odoo External API",
   "publishConfig": {
     "access": "public"