@bergetai/odoo-cli 0.1.3 → 0.3.0

package/README.md

@@ -28,6 +28,9 @@ odoo version
 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
@@ -47,6 +50,8 @@ 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
@@ -66,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

@@ -3,7 +3,8 @@ import { Command, CommanderError } from "commander";
 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 } from "./commands/notes.js";
+import { addNoteCommand, listMessagesCommand, } from "./commands/notes.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";
@@ -79,7 +80,9 @@ Examples:
         await run(authStatusCommand, program);
     });
     const crm = program.command("crm").description("CRM app (crm.lead)");
-    const leads = crm.command("records").description("leads and opportunities (crm.lead)");
+    const leads = crm
+        .command("records")
+        .description("leads and opportunities (crm.lead)");
     leads
         .command("list")
         .description("search and list leads/opportunities with curated default columns")
@@ -205,6 +208,126 @@ Examples:
         .action(async (id, opts) => {
         await run((g) => addNoteCommand(id, opts, g), program);
     });
+    tickets
+        .command("messages")
+        .description("list all messages for a ticket (emails, comments, notes)")
+        .argument("<id>", "ticket id")
+        .option("--limit <n>", "max messages to fetch", "50")
+        .option("--message-type <type>", "filter by message type (email, comment, notification)")
+        .option("--subtype <id>", "filter by subtype ID")
+        .option("--author <id>", "filter by author ID")
+        .option("--since <date>", "only messages after this date (YYYY-MM-DD HH:MM:SS)")
+        .addHelpText("after", `
+Examples:
+  # List all messages for ticket 398
+  $ odoo helpdesk tickets messages 398
+
+  # List only emails from customer
+  $ odoo helpdesk tickets messages 398 --message-type email
+
+  # List only internal notes
+  $ odoo helpdesk tickets messages 398 --subtype 2
+
+  # List messages from last 7 days
+  $ odoo helpdesk tickets messages 398 --since "2026-08-14 00:00:00"
+
+  # JSON output for scripting
+  $ odoo helpdesk tickets messages 398 --json`)
+        .action(async (id, opts) => {
+        await run((g) => listMessagesCommand(id, opts, g), program);
+    });
+    const project = program
+        .command("project")
+        .description("Project app (project.project, project.task)");
+    project
+        .command("list")
+        .description("search and list projects with curated default columns")
+        .option("--user <name|id>", "filter by project manager (login, email, or name)")
+        .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")
+        .option("--limit <n>", "max records (default: 50)", "50")
+        .option("--offset <n>", "skip the first n records", "0")
+        .option("--order <order>", 'sort order, e.g. "name asc"', undefined)
+        .action(async (opts) => {
+        await run((g) => projectListCommand(opts, g), program);
+    });
+    project
+        .command("show")
+        .description("read one project")
+        .argument("<id>", "project id")
+        .option("--fields <a,b,c>", "fields to display")
+        .option("--all-fields", "display every readable field")
+        .action(async (id, opts) => {
+        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)")
+        .requiredOption("--name <name>", "task name")
+        .requiredOption("--project <name|id>", "project name or ID")
+        .option("--stage <name|id>", "stage name or ID (within project)")
+        .option("--description <text>", "task description (HTML allowed)")
+        .option("--description-file <path>", "read description from file ('-' for stdin)")
+        .option("--tag <name|id>", "tag name or ID; repeatable, creates if missing", collect, [])
+        .option("--priority <level>", "priority: 0 (normal), 1 (high)")
+        .addHelpText("after", `
+Examples:
+  # Create a simple task
+  $ odoo project tasks create --name "Fix bug" --project "Product Backlog"
+
+  # Create task in specific stage with tags
+  $ odoo project tasks create \\
+      --name "Bug: API timeout" \\
+      --project 58 \\
+      --stage "New / Ideas" \\
+      --tag Bug \\
+      --tag API \\
+      --description "Customer reports API timeout..."
+
+  # Create from file
+  $ odoo project tasks create \\
+      --name "Bug report from ticket #409" \\
+      --project "Product Backlog" \\
+      --stage "New / Ideas" \\
+      --tag Bug \\
+      --description-file bug-report.md
+
+  # Dry run
+  $ odoo project tasks create --name "Test" --project 58 --dry-run`)
+        .action(async (opts) => {
+        await run((g) => createTaskCommand(opts, g), program);
+    });
     return program;
 }
 async function run(fn, program) {

package/dist/commands/notes.js

@@ -2,6 +2,7 @@ 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 { formatTable } from "../table.js";
 export async function addNoteCommand(ticketId, opts, globals) {
     const id = Number.parseInt(ticketId, 10);
     if (Number.isNaN(id) || id <= 0) {
@@ -90,3 +91,101 @@ export async function addNoteCommand(ticketId, opts, globals) {
         console.log(`  Type: Internal note (not sent to customer)`);
     }
 }
+/**
+ * List messages for a helpdesk ticket.
+ *
+ * Fetches all messages (emails, comments, notes) associated with a ticket.
+ * Useful for analyzing ticket history and determining if customer is waiting
+ * for a response.
+ */
+export async function listMessagesCommand(ticketId, opts, globals) {
+    const id = Number.parseInt(ticketId, 10);
+    if (Number.isNaN(id) || id <= 0) {
+        throw usageError(`invalid ticket id: ${ticketId}`, "provide a positive integer");
+    }
+    const config = await resolveConfig(globals);
+    if (!config.url || !config.db || !config.username || !config.apiKey) {
+        throw usageError("missing configuration", "run 'odoo auth login' or set ODOO_URL, ODOO_DB, ODOO_USERNAME, ODOO_API_KEY");
+    }
+    const { parseDurationMs } = await import("../duration.js");
+    const timeoutMs = parseDurationMs(globals.timeout);
+    const client = new OdooClient(config.url, config.db, config.username, config.apiKey, { timeoutMs, verbose: globals.verbose });
+    // Verify ticket exists
+    const tickets = (await client.executeKw("helpdesk.ticket", "search_read", [[["id", "=", id]]], { fields: ["id", "name"], limit: 1 }));
+    if (!tickets || tickets.length === 0) {
+        throw notFoundError("ticket_not_found", `helpdesk ticket #${id} does not exist`, "check the ticket id");
+    }
+    // Build domain for messages
+    const domain = [
+        ["model", "=", "helpdesk.ticket"],
+        ["res_id", "=", id],
+    ];
+    // Add optional filters
+    if (opts.messageType) {
+        domain.push(["message_type", "=", opts.messageType]);
+    }
+    if (opts.subtype) {
+        const subtypeId = Number.parseInt(opts.subtype, 10);
+        if (!Number.isNaN(subtypeId)) {
+            domain.push(["subtype_id", "=", subtypeId]);
+        }
+    }
+    if (opts.author) {
+        const authorId = Number.parseInt(opts.author, 10);
+        if (!Number.isNaN(authorId)) {
+            domain.push(["author_id", "=", authorId]);
+        }
+    }
+    if (opts.since) {
+        domain.push(["date", ">=", opts.since]);
+    }
+    const limit = opts.limit ? Number.parseInt(opts.limit, 10) : 50;
+    if (globals.verbose) {
+        logVerbose(`Fetching messages for ticket #${id}`, globals.verbose);
+        logVerbose(`Domain: ${JSON.stringify(domain)}`, globals.verbose);
+    }
+    const messages = (await client.executeKw("mail.message", "search_read", [domain], {
+        fields: [
+            "id",
+            "date",
+            "author_id",
+            "body",
+            "message_type",
+            "subtype_id",
+            "email_from",
+            "partner_ids",
+        ],
+        limit,
+        order: "date asc",
+    }));
+    if (globals.json) {
+        printJson({
+            ticket_id: id,
+            ticket_name: tickets[0].name,
+            message_count: messages.length,
+            messages,
+        });
+    }
+    else {
+        console.log(`Messages for ticket #${id}: ${tickets[0].name}`);
+        console.log(`Found ${messages.length} messages\n`);
+        const rows = messages.map((msg) => {
+            const author = msg.author_id ? msg.author_id[1] : msg.email_from || "System";
+            const subtype = msg.subtype_id ? msg.subtype_id[1] : "";
+            const bodyPreview = msg.body
+                .replace(/<[^>]*>/g, "") // Strip HTML
+                .replace(/\s+/g, " ")
+                .trim()
+                .substring(0, 60);
+            return [
+                msg.id.toString(),
+                msg.date,
+                msg.message_type,
+                subtype,
+                author,
+                bodyPreview + (msg.body.length > 60 ? "..." : ""),
+            ];
+        });
+        console.log(formatTable(["ID", "Date", "Type", "Subtype", "Author", "Preview"], rows, !globals.noColor));
+    }
+}

package/dist/commands/project.js

@@ -0,0 +1,409 @@
+import { OdooClient } from "../client.js";
+import { resolveConfig } from "../config.js";
+import { notFoundError, usageError } from "../errors.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.
+ *
+ * Useful for converting support tickets into backlog items.
+ */
+export const projectProjects = {
+    model: "project.project",
+    showCommand: "odoo project show",
+    defaultListFields: ["id", "name", "user_id", "create_date"],
+    showExtraFields: ["partner_id", "tag_ids", "active", "write_date"],
+    resolutionHints: {
+        user_id: "--user",
+        tag_ids: "--tag",
+    },
+    priorityLabels: {},
+    pinnedDomain: [],
+    references: {
+        assignee: {
+            model: "res.users",
+            label: "project manager",
+            field: "user_id",
+            searchFields: ["login", "email", "name"],
+        },
+        tag: { model: "project.tags", label: "tag", field: "tag_ids" },
+    },
+};
+export function projectListCommand(opts, globals) {
+    // --user maps onto the engine's generic assignee reference (user_id)
+    return listCommand(projectProjects, { ...opts, assignee: opts.user }, globals);
+}
+export function projectShowCommand(idArg, opts, globals) {
+    return showCommand(projectProjects, idArg, opts, globals);
+}
+export async function createTaskCommand(opts, globals) {
+    if (!opts.name || opts.name.trim().length === 0) {
+        throw usageError("task name cannot be empty", "provide --name");
+    }
+    if (!opts.project) {
+        throw usageError("project is required", "provide --project <name|id>");
+    }
+    const config = await resolveConfig(globals);
+    if (!config.url || !config.db || !config.username || !config.apiKey) {
+        throw usageError("missing configuration", "run 'odoo auth login' or set ODOO_URL, ODOO_DB, ODOO_USERNAME, ODOO_API_KEY");
+    }
+    const { parseDurationMs } = await import("../duration.js");
+    const timeoutMs = parseDurationMs(globals.timeout);
+    const client = new OdooClient(config.url, config.db, config.username, config.apiKey, { timeoutMs, verbose: globals.verbose });
+    // Resolve project ID
+    let projectId;
+    const projectIdNum = Number.parseInt(opts.project, 10);
+    if (!Number.isNaN(projectIdNum)) {
+        projectId = projectIdNum;
+    }
+    else {
+        // Search by name
+        const projects = (await client.executeKw("project.project", "search_read", [[["name", "=", opts.project]]], { fields: ["id", "name"], limit: 1 }));
+        if (!projects || projects.length === 0) {
+            throw notFoundError("project_not_found", `project "${opts.project}" not found`, "check the project name or use project ID");
+        }
+        projectId = projects[0].id;
+    }
+    // Resolve stage ID if provided
+    let stageId;
+    if (opts.stage) {
+        const stageIdNum = Number.parseInt(opts.stage, 10);
+        if (!Number.isNaN(stageIdNum)) {
+            stageId = stageIdNum;
+        }
+        else {
+            // Search by name within project
+            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;
+        }
+    }
+    // Resolve tag IDs if provided
+    const tagIds = [];
+    if (opts.tag && opts.tag.length > 0) {
+        for (const tagName of opts.tag) {
+            const tagIdNum = Number.parseInt(tagName, 10);
+            if (!Number.isNaN(tagIdNum)) {
+                tagIds.push(tagIdNum);
+            }
+            else {
+                // Search by name
+                const tags = (await client.executeKw("project.tags", "search_read", [[["name", "=", tagName]]], { fields: ["id", "name"], limit: 1 }));
+                if (tags && tags.length > 0) {
+                    tagIds.push(tags[0].id);
+                }
+                else {
+                    // Create tag if it doesn't exist
+                    if (globals.verbose) {
+                        logVerbose(`Tag "${tagName}" not found, creating it`, globals.verbose);
+                    }
+                    const newTagId = (await client.executeKw("project.tags", "create", [
+                        [{ name: tagName }],
+                    ]));
+                    tagIds.push(newTagId);
+                }
+            }
+        }
+    }
+    // Read description from file if specified
+    let description = opts.description || "";
+    if (opts.descriptionFile) {
+        const fs = await import("node:fs/promises");
+        try {
+            description = await fs.readFile(opts.descriptionFile, "utf-8");
+        }
+        catch (error) {
+            throw usageError(`failed to read description file: ${opts.descriptionFile}`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    // Build task values
+    const taskValues = {
+        name: opts.name,
+        project_id: projectId,
+        description: description,
+    };
+    if (stageId) {
+        taskValues.stage_id = stageId;
+    }
+    if (tagIds.length > 0) {
+        taskValues.tag_ids = [[6, 0, tagIds]]; // Replace all tags
+    }
+    if (opts.priority) {
+        taskValues.priority = opts.priority;
+    }
+    if (globals.verbose) {
+        logVerbose(`Creating task: ${JSON.stringify(taskValues, null, 2)}`, globals.verbose);
+    }
+    if (globals.dryRun) {
+        const result = {
+            dry_run: true,
+            name: opts.name,
+            project_id: projectId,
+            stage_id: stageId,
+            tag_ids: tagIds,
+            description_length: description.length,
+        };
+        if (globals.json) {
+            printJson(result);
+        }
+        else {
+            console.log(`[DRY RUN] Would create task:`);
+            console.log(`  Name: ${opts.name}`);
+            console.log(`  Project: ${projectId}`);
+            if (stageId)
+                console.log(`  Stage: ${stageId}`);
+            if (tagIds.length > 0)
+                console.log(`  Tags: ${tagIds.join(", ")}`);
+            console.log(`  Description: ${description.length} characters`);
+        }
+        return;
+    }
+    const taskId = (await client.executeKw("project.task", "create", [
+        [taskValues],
+    ]));
+    const result = {
+        task_id: taskId,
+        name: opts.name,
+        project_id: projectId,
+        stage_id: stageId,
+        tag_ids: tagIds,
+    };
+    if (globals.json) {
+        printJson(result);
+    }
+    else {
+        console.log(`✓ Task created (ID: ${taskId})`);
+        console.log(`  Name: ${opts.name}`);
+        console.log(`  Project: ${projectId}`);
+        if (stageId)
+            console.log(`  Stage: ${stageId}`);
+        if (tagIds.length > 0)
+            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.1.3",
+  "version": "0.3.0",
   "description": "Agent-first CLI for the Odoo External API",
   "publishConfig": {
     "access": "public"