@bergetai/odoo-cli 0.2.0 → 0.3.0

package/README.md

@@ -29,6 +29,8 @@ odoo crm leads list --open --limit 20
 odoo crm leads show 42
 odoo helpdesk tickets list --team Support --json
 odoo project list --json
+odoo project tasks list --project "Content Pipeline" --open
+odoo project tasks show 850
 
 # Mutations (support --dry-run)
 odoo crm leads create --name "New lead" --email info@example.com
@@ -49,6 +51,7 @@ Note: `odoo --version` prints the CLI's own version; `odoo version` queries the
 - 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
 - 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)
 - 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
 - Internal notes (`add-note`) — creates internal Log Notes only (subtype_id=2, message_type=comment), **NEVER sends email to customer**, by design prevents accidental customer communication
@@ -68,6 +71,12 @@ against the live server:
 - `execute_kw` kwargs must be a separate trailing dict param; packing it into
   the positional-args array makes the server silently ignore it (this caused
   `fields_get` to return full/empty structs).
+- `project.task` has no `user_id` field; assignees are the many2many
+  `user_ids`. The `priority` selection is two-valued (0/Low, 1/High), not the
+  four-level scale used by CRM/Helpdesk. Tasks carry a direct `is_closed`
+  boolean, which `--open`/`--closed` filter on (authoritative, unlike stage
+  `fold`). Stages (`project.task.type`) link to projects via the many2many
+  `project_ids`, so `--stage` resolves within the `--project`.
 
 ## Development
 

package/dist/cli.js

@@ -4,7 +4,7 @@ import { authLoginCommand, authStatusCommand } from "./commands/auth.js";
 import { leadsCreateCommand, leadsDeleteCommand, leadsListCommand, leadsShowCommand, leadsUpdateCommand, crmLeads, } from "./commands/crm.js";
 import { ticketsCreateCommand, ticketsDeleteCommand, ticketsListCommand, ticketsShowCommand, ticketsUpdateCommand, helpdeskTickets, } from "./commands/helpdesk.js";
 import { addNoteCommand, listMessagesCommand, } from "./commands/notes.js";
-import { createTaskCommand, projectListCommand, projectShowCommand, } from "./commands/project.js";
+import { createTaskCommand, projectListCommand, projectShowCommand, tasksListCommand, tasksShowCommand, } from "./commands/project.js";
 import { versionCommand } from "./commands/version.js";
 import { CliError } from "./errors.js";
 import { applyGlobalOptions, enforceTransportSecurity, DEFAULT_TIMEOUT, } from "./global-options.js";
@@ -263,6 +263,34 @@ Examples:
         await run((g) => projectShowCommand(id, opts, g), program);
     });
     const tasks = project.command("tasks").description("project tasks");
+    tasks
+        .command("list")
+        .description("search and list tasks in a project with curated columns")
+        .requiredOption("--project <name|id>", "project name or ID")
+        .option("--stage <name|id>", "filter by stage (resolved within the project)")
+        .option("--assignee <name|id>", "filter by assignee (login, email, or name)")
+        .option("--tag <name|id>", "filter by tag; repeatable, AND-ed", collect, [])
+        .option("--priority <level>", "filter by priority: 0 (low/normal) or 1 (high)")
+        .option("--open", "only open tasks (is_closed = false)")
+        .option("--closed", "only closed tasks (is_closed = true)")
+        .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")
+        .option("--limit <n>", "max records (default: 50)", "50")
+        .option("--offset <n>", "skip the first n records", "0")
+        .option("--order <order>", 'sort order, e.g. "priority desc"', undefined)
+        .action(async (opts) => {
+        await run((g) => tasksListCommand(opts, g), program);
+    });
+    tasks
+        .command("show")
+        .description("read one task")
+        .argument("<id>", "task id")
+        .option("--fields <a,b,c>", "fields to display")
+        .option("--all-fields", "display every readable field")
+        .action(async (id, opts) => {
+        await run((g) => tasksShowCommand(id, opts, g), program);
+    });
     tasks
         .command("create")
         .description("create a task in a project (preview with --dry-run)")

package/dist/commands/project.js

@@ -1,8 +1,11 @@
 import { OdooClient } from "../client.js";
 import { resolveConfig } from "../config.js";
 import { notFoundError, usageError } from "../errors.js";
-import { printJson, verbose as logVerbose } from "../output.js";
-import { listCommand, showCommand, } from "../resource.js";
+import { buildFilterClauses, parseDomain } from "../filter.js";
+import { ModelFields, resolveReference } from "../model.js";
+import { colorEnabled, printJson, verbose as logVerbose } from "../output.js";
+import { authenticatedClient, listCommand, parseId, showCommand, } from "../resource.js";
+import { formatKeyValues, formatTable, humanCell } from "../table.js";
 /**
  * Create a task in an Odoo project.
  *
@@ -188,3 +191,219 @@ export async function createTaskCommand(opts, globals) {
             console.log(`  Tags: ${tagIds.join(", ")}`);
     }
 }
+/**
+ * project.task diverges from the shared list/show engine (resource.ts) in
+ * three ways that make a custom command cleaner than engine surgery:
+ *   - assignee is user_ids (many2many), not user_id (many2one)
+ *   - priority is a 2-value selection (0/Low, 1/High), not the engine's
+ *     hardcoded low/medium/high/urgent map
+ *   - stages scope via project_ids (many2many) on project.task.type, not
+ *     team_id/team_ids
+ * The resolution/ordering mirrors listCommand (resource.ts) and the project
+ * resolution mirrors createTaskCommand above.
+ */
+const TASK_DEFAULT_LIST_FIELDS = [
+    "id",
+    "name",
+    "stage_id",
+    "user_ids",
+    "priority",
+    "date_deadline",
+    "is_closed",
+];
+const TASK_SHOW_EXTRA_FIELDS = [
+    "description",
+    "partner_id",
+    "tag_ids",
+    "parent_id",
+    "milestone_id",
+    "active",
+    "create_date",
+    "write_date",
+];
+const TASK_PRIORITY_LABELS = {
+    "0": "Low",
+    "1": "High",
+};
+/** Parse a task --priority into its raw Odoo selection value. */
+function parseTaskPriority(raw) {
+    const v = raw.toLowerCase();
+    if (v === "0" || v === "normal" || v === "low")
+        return "0";
+    if (v === "1" || v === "high")
+        return "1";
+    throw usageError(`invalid --priority ${JSON.stringify(raw)}`, "expected one of: 0 (normal/low), 1 (high)");
+}
+function parseCount(raw, flag) {
+    if (!/^\d+$/.test(raw)) {
+        throw usageError(`invalid ${flag} value ${JSON.stringify(raw)}`, "expected a non-negative integer");
+    }
+    return Number(raw);
+}
+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;
+}
+/** Resolve a project by numeric id or exact name match (mirrors create). */
+async function resolveProjectId(client, input) {
+    const num = Number.parseInt(input, 10);
+    if (!Number.isNaN(num))
+        return num;
+    const projects = (await client.executeKw("project.project", "search_read", [[["name", "=", input]]], { fields: ["id", "name"], limit: 1 }));
+    if (!projects || projects.length === 0) {
+        throw notFoundError("project_not_found", `project "${input}" not found`, "check the project name or use project ID");
+    }
+    return projects[0].id;
+}
+export async function tasksListCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    if (opts.domain && opts.filter && opts.filter.length > 0) {
+        throw usageError("--domain and --filter are mutually exclusive", "pick one filtering form");
+    }
+    if (opts.open && opts.closed) {
+        throw usageError("--open and --closed are mutually exclusive");
+    }
+    const limit = parseCount(opts.limit, "--limit");
+    const offset = parseCount(opts.offset, "--offset");
+    // fields_get first: doubles as the module-installed check (exit 4).
+    const fieldsMeta = await ModelFields.load(client, "project.task");
+    // project_ids (many2many) on project.task.type scopes stage resolution.
+    const projectId = await resolveProjectId(client, opts.project);
+    logVerbose(`resolved --project "${opts.project}" -> ${projectId}`, globals.verbose);
+    const domain = [["project_id", "=", projectId]];
+    if (opts.stage) {
+        const stageIdNum = Number.parseInt(opts.stage, 10);
+        let stageId;
+        if (!Number.isNaN(stageIdNum)) {
+            stageId = stageIdNum;
+        }
+        else {
+            const stages = (await client.executeKw("project.task.type", "search_read", [
+                [
+                    ["name", "=", opts.stage],
+                    ["project_ids", "in", [projectId]],
+                ],
+            ], { fields: ["id", "name"], limit: 1 }));
+            if (!stages || stages.length === 0) {
+                throw notFoundError("stage_not_found", `stage "${opts.stage}" not found in project ${projectId}`, "check the stage name or use stage ID");
+            }
+            stageId = stages[0].id;
+        }
+        domain.push(["stage_id", "=", stageId]);
+        logVerbose(`resolved --stage "${opts.stage}" -> ${stageId}`, globals.verbose);
+    }
+    if (opts.assignee) {
+        const user = await resolveReference(client, "res.users", opts.assignee, {
+            label: "assignee",
+            searchFields: ["login", "email", "name"],
+        });
+        // many2many membership
+        domain.push(["user_ids", "in", [user.id]]);
+        logVerbose(`resolved --assignee "${opts.assignee}" -> [${user.id}, "${user.name}"]`, globals.verbose);
+    }
+    for (const tag of opts.tag ?? []) {
+        const resolved = await resolveReference(client, "project.tags", tag, {
+            label: "tag",
+        });
+        domain.push(["tag_ids", "=", resolved.id]);
+        logVerbose(`resolved --tag "${tag}" -> [${resolved.id}, "${resolved.name}"]`, globals.verbose);
+    }
+    if (opts.priority) {
+        domain.push(["priority", "=", parseTaskPriority(opts.priority)]);
+    }
+    if (opts.open)
+        domain.push(["is_closed", "=", false]);
+    if (opts.closed)
+        domain.push(["is_closed", "=", true]);
+    if (opts.domain) {
+        domain.push(...parseDomain(opts.domain));
+    }
+    else if (opts.filter && opts.filter.length > 0) {
+        domain.push(...buildFilterClauses(opts.filter, fieldsMeta, {
+            stage_id: "--stage",
+            user_ids: "--assignee",
+            tag_ids: "--tag",
+        }));
+    }
+    const fields = opts.fields
+        ? parseFieldList(opts.fields)
+        : TASK_DEFAULT_LIST_FIELDS;
+    for (const field of fields) {
+        if (field !== "id" && !fieldsMeta.get(field)) {
+            throw usageError(`unknown field ${JSON.stringify(field)} on project.task`, `run \`odoo project tasks show <id> --all-fields\` to see available fields`);
+        }
+    }
+    const order = opts.order ?? "id asc";
+    const [records, count] = await Promise.all([
+        client.executeKw("project.task", "search_read", [domain], {
+            fields,
+            limit,
+            offset,
+            order,
+        }),
+        client.executeKw("project.task", "search_count", [
+            domain,
+        ]),
+    ]);
+    if (globals.json) {
+        printJson({ model: "project.task", records, count, limit, offset });
+        return;
+    }
+    const headers = fields.map((f) => fieldsMeta.get(f)?.string ?? f);
+    const rows = records.map((rec) => fields.map((f) => f === "priority" && typeof rec[f] === "string"
+        ? (TASK_PRIORITY_LABELS[rec[f]] ?? String(rec[f]))
+        : humanCell(rec[f])));
+    const color = colorEnabled(globals.noColor);
+    process.stdout.write(formatTable(headers, rows, color) + "\n");
+}
+export async function tasksShowCommand(idArg, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const id = parseId(idArg);
+    const fieldsMeta = await ModelFields.load(client, "project.task");
+    let fields;
+    if (opts.allFields) {
+        fields = undefined; // no fields kwarg => everything readable
+    }
+    else if (opts.fields) {
+        fields = parseFieldList(opts.fields);
+        for (const field of fields) {
+            if (field !== "id" && !fieldsMeta.get(field)) {
+                throw usageError(`unknown field ${JSON.stringify(field)} on project.task`, `run \`odoo project tasks show <id> --all-fields\` to see available fields`);
+            }
+        }
+    }
+    else {
+        // Curated view: intersect with fields_get so edition-dependent fields
+        // degrade gracefully instead of faulting the read.
+        const curated = [
+            ...new Set([...TASK_DEFAULT_LIST_FIELDS, ...TASK_SHOW_EXTRA_FIELDS]),
+        ];
+        fields = curated.filter((f) => f === "id" || fieldsMeta.get(f));
+    }
+    const rows = (await client.executeKw("project.task", "read", [[id]], {
+        ...(fields ? { fields } : {}),
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("record_not_found", `no project.task record with id ${id}`);
+    }
+    const record = rows[0];
+    if (globals.json) {
+        printJson({ model: "project.task", record });
+        return;
+    }
+    const keys = fields ?? Object.keys(record);
+    const pairs = keys.map((k) => [
+        fieldsMeta.get(k)?.string ?? k,
+        k === "priority" && typeof record[k] === "string"
+            ? (TASK_PRIORITY_LABELS[record[k]] ?? String(record[k]))
+            : humanCell(record[k]),
+    ]);
+    const color = colorEnabled(globals.noColor);
+    process.stdout.write(formatKeyValues(pairs, color) + "\n");
+}

package/package.json

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