@bergetai/odoo-cli 0.1.0 → 0.2.0

package/README.md

@@ -4,6 +4,14 @@ Agent-first CLI for the [Odoo External API](https://www.odoo.com/documentation/1
 
 Every command is non-interactive, scriptable, and supports `--json` for stable machine-readable output.
 
+## Installation
+
+```bash
+npm install -g @bergetai/odoo-cli
+```
+
+Requires Node.js 20 or later.
+
 ## Usage
 
 ```bash
@@ -15,30 +23,38 @@ odoo auth status --json
 
 # Unauthenticated connectivity check
 odoo version
+
+# List and inspect records
+odoo crm leads list --open --limit 20
+odoo crm leads show 42
+odoo helpdesk tickets list --team Support --json
+odoo project list --json
+
+# Mutations (support --dry-run)
+odoo crm leads create --name "New lead" --email info@example.com
+odoo crm leads update 42 --stage Won
+odoo crm leads delete 42 --yes
+
+# Internal notes (NEVER sends email to customer)
+odoo helpdesk tickets add-note 398 --body "Internal note text"
+odoo helpdesk tickets add-note 398 --body-file note.md
 ```
 
 Configuration precedence: flags > environment (`ODOO_URL`, `ODOO_DB`, `ODOO_USERNAME`, `ODOO_API_KEY`) > `$XDG_CONFIG_HOME/odoo/config.json`. The API key is never accepted as a flag value.
 
 Note: `odoo --version` prints the CLI's own version; `odoo version` queries the server.
 
-## Development
-
-```bash
-npm install
-npm run build   # compile to dist/
-npm test        # build + unit/e2e tests against a fake XML-RPC server
-```
-
-## Status
+## Features
 
-- [x] Skeleton, transport, and auth — command tree, global flags, config sources and precedence with atomic `0600` config writes, XML-RPC transport with timeouts and HTTPS enforcement, `odoo version`, `odoo auth login`, `odoo auth status` with the auth failure taxonomy (db missing / bad credentials / unreachable)
-- [x] 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
-- [x] Read-only Helpdesk surface (`helpdesk tickets list/show`) — `--open`/`--closed` via stage `fold`, strict team-scoped stage resolution, module-not-installed error (exit 4)
-- [x] `--dry-run` machinery for mutations — full validation, resolution, and before/after diffs without mutating
-- [x] 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`
-- [ ] Polish and packaging
+- 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)
+- 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
+- Config sources and precedence with atomic `0600` config writes, XML-RPC transport with timeouts and HTTPS enforcement, and an auth failure taxonomy (db missing / bad credentials / unreachable)
 
-## Production-instance notes
+## Compatibility
 
 Validated against a real Odoo 18.0+e instance. Schema realities discovered
 against the live server:
@@ -52,3 +68,19 @@ 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).
+
+## Development
+
+```bash
+npm install
+npm run build   # compile to dist/
+npm test        # build + unit/e2e tests against a fake XML-RPC server
+```
+
+## Contributing
+
+Issues and pull requests are welcome at [github.com/berget-ai/odoo-cli](https://github.com/berget-ai/odoo-cli).
+
+## License
+
+[MIT](LICENSE)

package/dist/cli.js

@@ -3,6 +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, listMessagesCommand, } from "./commands/notes.js";
+import { createTaskCommand, projectListCommand, projectShowCommand, } from "./commands/project.js";
 import { versionCommand } from "./commands/version.js";
 import { CliError } from "./errors.js";
 import { applyGlobalOptions, enforceTransportSecurity, DEFAULT_TIMEOUT, } from "./global-options.js";
@@ -78,15 +80,18 @@ Examples:
         await run(authStatusCommand, program);
     });
     const crm = program.command("crm").description("CRM app (crm.lead)");
-    const leads = crm.command("leads").description("leads (type=lead)");
+    const leads = crm
+        .command("records")
+        .description("leads and opportunities (crm.lead)");
     leads
         .command("list")
-        .description("search and list leads with curated default columns")
+        .description("search and list leads/opportunities with curated default columns")
         .option("--stage <name|id>", "filter by stage (resolved by name)")
         .option("--team <name|id>", "filter by sales team (resolved by name)")
         .option("--assignee <name|id>", "filter by salesperson (login, email, or name)")
         .option("--tag <name|id>", "filter by tag; repeatable, AND-ed", collect, [])
         .option("--priority <level>", "filter by priority: low, medium, high, urgent")
+        .option("--type <lead|opportunity>", "filter by record type (default: all)")
         .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")
@@ -98,7 +103,7 @@ Examples:
     });
     leads
         .command("show")
-        .description("read one lead")
+        .description("read one record")
         .argument("<id>", "record id")
         .option("--fields <a,b,c>", "fields to display")
         .option("--all-fields", "display every readable field")
@@ -107,19 +112,19 @@ Examples:
     });
     addMutationFlags(leads
         .command("create")
-        .description("create a lead (preview with --dry-run)"), crmLeads).action(async (opts) => {
+        .description("create a record (preview with --dry-run)"), crmLeads).action(async (opts) => {
         await run((g) => leadsCreateCommand(opts, g), program);
     });
     addMutationFlags(leads
         .command("update")
-        .description("update leads (preview with --dry-run)"), crmLeads)
+        .description("update records (preview with --dry-run)"), crmLeads)
         .argument("<id...>", "record ids")
         .action(async (ids, opts) => {
         await run((g) => leadsUpdateCommand(ids, opts, g), program);
     });
     leads
         .command("delete")
-        .description("delete leads (preview with --dry-run; unknown ids are skipped)")
+        .description("delete records (preview with --dry-run; unknown ids are skipped)")
         .argument("<id...>", "record ids")
         .action(async (ids) => {
         await run((g) => leadsDeleteCommand(ids, g), program);
@@ -181,6 +186,120 @@ the raw form.`)
         .action(async (ids) => {
         await run((g) => ticketsDeleteCommand(ids, g), program);
     });
+    tickets
+        .command("add-note")
+        .description("add an internal Log Note to a ticket (NEVER sends email to customer)")
+        .argument("<id>", "ticket id")
+        .option("--body <text>", "note body (HTML allowed)")
+        .option("--body-file <path>", "read note body from file ('-' for stdin)")
+        .addHelpText("after", `
+IMPORTANT: This command creates INTERNAL notes only. These notes:
+  • Are NEVER sent to the customer via email
+  • Are only visible to internal users in Odoo
+  • Use subtype_id=2 (Note) and message_type=comment
+  • Cannot be used for customer-facing communication
+
+This is by design to prevent accidental customer emails.
+
+Examples:
+  $ odoo helpdesk tickets add-note 398 --body "Internal note text"
+  $ odoo helpdesk tickets add-note 398 --body-file note.md
+  $ cat note.md | odoo helpdesk tickets add-note 398 --body-file -`)
+        .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("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/crm.js

@@ -1,8 +1,8 @@
+import { usageError } from "../errors.js";
 import { createCommand, deleteCommand, parseDate, parseDecimal, parsePriorityFlag, parseProbability, updateCommand, } from "../mutation.js";
 import { listCommand, showCommand, } from "../resource.js";
 /** CRM create/update field→flag mapping (§5.3). */
 const crmLeadsMutation = {
-    createPinnedValues: { type: "lead" },
     flags: [
         {
             flags: "--name <name>",
@@ -115,6 +115,19 @@ const crmLeadsMutation = {
             help: "Lead medium",
             reference: { model: "utm.medium", label: "medium" },
         },
+        {
+            flags: "--type <lead|opportunity>",
+            option: "type",
+            field: "type",
+            help: "Record type: lead (default) or opportunity",
+            parse: (raw, flagName) => {
+                const v = raw.toLowerCase();
+                if (v !== "lead" && v !== "opportunity") {
+                    throw usageError(`invalid ${flagName} ${JSON.stringify(raw)}`, "expected: lead or opportunity");
+                }
+                return v;
+            },
+        },
         {
             flags: "--description <text>",
             option: "description",
@@ -125,7 +138,7 @@ const crmLeadsMutation = {
 };
 export const crmLeads = {
     model: "crm.lead",
-    showCommand: "odoo crm leads show",
+    showCommand: "odoo crm records show",
     defaultListFields: [
         "id",
         "name",
@@ -161,7 +174,7 @@ export const crmLeads = {
         "2": "High",
         "3": "Very High",
     },
-    pinnedDomain: [["type", "=", "lead"]],
+    pinnedDomain: [],
     references: {
         team: { model: "crm.team", label: "team", field: "team_id" },
         stage: {
@@ -180,6 +193,15 @@ export const crmLeads = {
     },
     // Phase 3 (§4.4, §4.2, §5.4): dry-run plans for create/update/delete.
     mutation: crmLeadsMutation,
+    // --type filter: lead (default), opportunity, or all
+    extraFilters: (opts) => {
+        const o = opts;
+        if (o.type === "lead" || o.type === "opportunity") {
+            return Promise.resolve([["type", "=", o.type]]);
+        }
+        // default: no filter (both leads and opportunities)
+        return Promise.resolve([]);
+    },
 };
 export function leadsListCommand(opts, globals) {
     return listCommand(crmLeads, opts, globals);

package/dist/commands/notes.js

@@ -0,0 +1,191 @@
+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) {
+        throw usageError(`invalid ticket id: ${ticketId}`, "provide a positive integer");
+    }
+    // Read body from file if specified
+    let body = opts.body;
+    if (opts.bodyFile) {
+        const fs = await import("node:fs/promises");
+        try {
+            body = await fs.readFile(opts.bodyFile, "utf-8");
+        }
+        catch (error) {
+            throw usageError(`failed to read body file: ${opts.bodyFile}`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (!body || body.trim().length === 0) {
+        throw usageError("note body cannot be empty", "provide --body or --body-file");
+    }
+    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");
+    }
+    // Create internal Log Note
+    // CRITICAL: These parameters ensure the note is INTERNAL ONLY
+    // - subtype_id=2: "Note" subtype (internal, not sent to customer)
+    // - message_type="comment": Internal comment (not email)
+    // - author_id: Use the authenticated user's partner_id
+    const noteParams = {
+        model: "helpdesk.ticket",
+        res_id: id,
+        body: body,
+        message_type: "comment",
+        subtype_id: 2, // Note subtype = internal only, NEVER sends email
+    };
+    if (globals.verbose) {
+        logVerbose(`Creating internal note for ticket #${id} (${tickets[0].name})`, globals.verbose);
+        logVerbose(`Note parameters: ${JSON.stringify(noteParams, null, 2)}`, globals.verbose);
+    }
+    if (globals.dryRun) {
+        const result = {
+            dry_run: true,
+            ticket_id: id,
+            ticket_name: tickets[0].name,
+            note_type: "internal_log_note",
+            will_send_email: false,
+            body_preview: body.substring(0, 100) + (body.length > 100 ? "..." : ""),
+            body_length: body.length,
+        };
+        if (globals.json) {
+            printJson(result);
+        }
+        else {
+            console.log(`[DRY RUN] Would create internal Log Note:`);
+            console.log(`  Ticket: #${id} — ${tickets[0].name}`);
+            console.log(`  Type: Internal note (never sent to customer)`);
+            console.log(`  Body length: ${body.length} characters`);
+            console.log(`  Body preview: ${result.body_preview}`);
+        }
+        return;
+    }
+    const noteId = (await client.executeKw("mail.message", "create", [
+        [noteParams],
+    ]));
+    const result = {
+        note_id: noteId,
+        ticket_id: id,
+        ticket_name: tickets[0].name,
+        note_type: "internal_log_note",
+        email_sent: false,
+    };
+    if (globals.json) {
+        printJson(result);
+    }
+    else {
+        console.log(`✓ Internal Log Note created (ID: ${noteId})`);
+        console.log(`  Ticket: #${id} — ${tickets[0].name}`);
+        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,190 @@
+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";
+/**
+ * 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(", ")}`);
+    }
+}

package/package.json

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