@beomsukoh/zotero-cli 0.2.0

package/dist/commands/collectionsCommand.js

@@ -0,0 +1,52 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, parseArgs } from "../utils/args.js";
+import { parseIntOption, renderJson, resolveLibrary } from "./helpers.js";
+export class CollectionsCommand {
+    name = "collections";
+    category = "Core";
+    description = "List collections.";
+    help() {
+        return [
+            "Usage: zt collections [<parentKey>] [options]",
+            "",
+            "List collections, optionally filtered by parent collection.",
+            "",
+            "Options:",
+            "  --group <id>           Library group ID",
+            "  --parent <key>         Parent collection key",
+            "  --limit <n>            Maximum number of results",
+            "  --sort <field>         Sort field (e.g. title, dateModified)",
+            "  --direction <asc|desc> Sort direction",
+            "",
+            "Examples:",
+            "  zt collections",
+            "  zt collections --parent ABC12345",
+            "  zt collections --group 123456 --limit 50"
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["group", "parent", "limit", "sort", "direction"]);
+        assertNoMissingOptionValues(parsed, ["group", "parent", "limit", "sort", "direction"]);
+        if (parsed.positionals.length > 1) {
+            throw new ValidationError("collections accepts at most one positional argument (parent key).");
+        }
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const parentKey = parsed.positionals[0] ?? getOption(parsed, "parent");
+        const limit = parseIntOption(parsed, "limit");
+        const sort = getOption(parsed, "sort");
+        const direction = getOption(parsed, "direction");
+        return { library, parentKey, limit, sort, direction };
+    }
+    async execute(input, context) {
+        const options = {};
+        if (input.limit !== undefined)
+            options.limit = input.limit;
+        if (input.sort)
+            options.sort = input.sort;
+        if (input.direction)
+            options.direction = input.direction;
+        const result = await context.zotero.listCollections(input.library, input.parentKey, Object.keys(options).length > 0 ? options : undefined);
+        context.output.write(renderJson(result));
+    }
+}

package/dist/commands/createCollectionCommand.js

@@ -0,0 +1,47 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, parseArgs } from "../utils/args.js";
+import { renderJson, resolveLibrary } from "./helpers.js";
+export class CreateCollectionCommand {
+    name = "create:collection";
+    category = "Create";
+    description = "Create a collection.";
+    help() {
+        return [
+            "Usage: zt create:collection <name> [options]",
+            "",
+            "Create a new collection in the library.",
+            "",
+            "Options:",
+            "  --group <id>           Library group ID",
+            "  --parent <key>         Parent collection key (for subcollections)",
+            "",
+            "Examples:",
+            '  zt create:collection "My Papers"',
+            '  zt create:collection "Sub Collection" --parent ABC12345',
+            '  zt create:collection "Shared" --group 123456'
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["group", "parent"]);
+        assertNoMissingOptionValues(parsed, ["group", "parent"]);
+        const name = parsed.positionals[0];
+        if (!name) {
+            throw new ValidationError("create:collection requires a name. Usage: zt create:collection <name>");
+        }
+        if (parsed.positionals.length > 1) {
+            throw new ValidationError("create:collection accepts at most one positional argument (name). Wrap multi-word names in quotes.");
+        }
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const parentKey = getOption(parsed, "parent");
+        return { library, name, parentKey };
+    }
+    async execute(input, context) {
+        const data = { name: input.name };
+        if (input.parentKey) {
+            data.parentCollection = input.parentKey;
+        }
+        const result = await context.zotero.createCollection(input.library, data);
+        context.output.write(renderJson(result));
+    }
+}

package/dist/commands/createItemCommand.js

@@ -0,0 +1,91 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, parseArgs } from "../utils/args.js";
+import { renderJson, resolveLibrary } from "./helpers.js";
+export class CreateItemCommand {
+    name = "create:item";
+    category = "Create";
+    description = "Create an item from a JSON string or key=value pairs.";
+    help() {
+        return [
+            "Usage:",
+            "  zt create:item '<json>'",
+            '  zt create:item --type <itemType> --title "Title" [options]',
+            "",
+            "Create a new Zotero item from JSON or from individual options.",
+            "",
+            "Options:",
+            "  --group <id>           Library group ID",
+            "  --type <itemType>      Item type (e.g. journalArticle, book)",
+            '  --title <title>        Item title',
+            '  --date <date>          Date (e.g. "2026")',
+            "  --url <url>            URL",
+            "  --doi <doi>            DOI",
+            "  --collection <key>     Collection key to add the item to",
+            "",
+            "Examples:",
+            `  zt create:item '{"itemType":"journalArticle","title":"My Paper"}'`,
+            '  zt create:item --type journalArticle --title "My Paper" --date "2026"',
+            '  zt create:item --type book --title "My Book" --collection ABC12345'
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["group", "type", "title", "date", "url", "doi", "collection"]);
+        assertNoMissingOptionValues(parsed, ["group", "type", "title", "date", "url", "doi", "collection"]);
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const collection = getOption(parsed, "collection");
+        // If positional[0] looks like JSON, parse it directly
+        const positional = parsed.positionals[0];
+        if (positional && positional.trimStart().startsWith("{")) {
+            try {
+                const jsonData = JSON.parse(positional);
+                return { library, jsonData, collection };
+            }
+            catch {
+                throw new ValidationError("Invalid JSON provided. Ensure the JSON string is valid.");
+            }
+        }
+        if (parsed.positionals.length > 0 && !positional?.trimStart().startsWith("{")) {
+            throw new ValidationError("Unexpected positional argument. Provide JSON or use --type/--title options.");
+        }
+        // Build from options
+        const type = getOption(parsed, "type");
+        const title = getOption(parsed, "title");
+        const date = getOption(parsed, "date");
+        const url = getOption(parsed, "url");
+        const doi = getOption(parsed, "doi");
+        if (!type) {
+            throw new ValidationError("create:item requires --type or a JSON string. Usage: zt create:item --type <itemType> --title \"Title\"");
+        }
+        return { library, type, title, date, url, doi, collection };
+    }
+    async execute(input, context) {
+        let itemData;
+        if (input.jsonData) {
+            itemData = input.jsonData;
+        }
+        else {
+            // Get the template and overlay provided fields
+            const template = await context.zotero.getItemTemplate(input.type);
+            if (input.title !== undefined)
+                template["title"] = input.title;
+            if (input.date !== undefined)
+                template["date"] = input.date;
+            if (input.url !== undefined)
+                template["url"] = input.url;
+            if (input.doi !== undefined)
+                template["DOI"] = input.doi;
+            itemData = template;
+        }
+        // Add to collection if specified
+        if (input.collection) {
+            const data = itemData;
+            const existing = Array.isArray(data["collections"]) ? data["collections"] : [];
+            data["collections"] = [...existing, input.collection];
+            itemData = data;
+        }
+        // Zotero API expects an array for item creation
+        const result = await context.zotero.createItem(input.library, [itemData]);
+        context.output.write(renderJson(result));
+    }
+}

package/dist/commands/deleteCommand.js

@@ -0,0 +1,53 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, hasBoolean, parseArgs } from "../utils/args.js";
+import { ensureNoPositionals, renderJson, resolveLibrary } from "./helpers.js";
+export class DeleteCommand {
+    name = "delete";
+    category = "Core";
+    description = "Delete an item or collection.";
+    help() {
+        return [
+            "Usage: zt delete --key <key> [options]",
+            "",
+            "Delete an item or collection. The current version is fetched",
+            "automatically before deletion.",
+            "",
+            "Options:",
+            "  --key <key>            Item or collection key (required)",
+            "  --group <id>           Library group ID",
+            "  --collection           Delete a collection instead of an item",
+            "",
+            "Examples:",
+            '  zt delete --key ABC12345',
+            '  zt delete --key ABC12345 --collection',
+            '  zt delete --key ABC12345 --group 123456'
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["key", "group", "collection"]);
+        assertNoMissingOptionValues(parsed, ["key", "group"]);
+        ensureNoPositionals(parsed, "delete");
+        const key = getOption(parsed, "key");
+        if (!key) {
+            throw new ValidationError("delete requires --key.");
+        }
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const isCollection = hasBoolean(parsed, "collection");
+        return { library, key, isCollection };
+    }
+    async execute(input, context) {
+        if (input.isCollection) {
+            const collection = await context.zotero.getCollection(input.library, input.key);
+            const version = collection.version ?? 0;
+            const result = await context.zotero.deleteCollection(input.library, input.key, version);
+            context.output.write(renderJson(result));
+        }
+        else {
+            const item = await context.zotero.getItem(input.library, input.key);
+            const version = item.version ?? 0;
+            const result = await context.zotero.deleteItem(input.library, input.key, version);
+            context.output.write(renderJson(result));
+        }
+    }
+}

package/dist/commands/exportCommand.js

@@ -0,0 +1,56 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, parseArgs } from "../utils/args.js";
+import { ensureNoPositionals, parseIntOption, resolveLibrary } from "./helpers.js";
+export class ExportCommand {
+    name = "export";
+    category = "Core";
+    description = "Export items in various formats.";
+    help() {
+        return [
+            "Usage:",
+            "  zt export --format <format>",
+            "",
+            "Export items in a given citation/data format.",
+            "",
+            "Options:",
+            "  --format <format>      Export format (required): bibtex, biblatex, ris, csljson, csv, tei, wikipedia, mods, refer",
+            "  --group <id>           Library group ID",
+            "  --collection <key>     Limit to a specific collection",
+            "  --limit <n>            Maximum number of items",
+            "  --tag <tag>            Filter by tag",
+            "  --type <itemType>      Filter by item type",
+            "",
+            "Examples:",
+            "  zt export --format bibtex",
+            "  zt export --format ris --collection ABC12345",
+            "  zt export --format csljson --limit 50 --tag physics"
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["format", "group", "collection", "limit", "tag", "type"]);
+        assertNoMissingOptionValues(parsed, ["format", "group", "collection", "limit", "tag", "type"]);
+        ensureNoPositionals(parsed, "export");
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const format = getOption(parsed, "format");
+        if (!format) {
+            throw new ValidationError("export requires --format. Usage: zt export --format <format>");
+        }
+        const limit = parseIntOption(parsed, "limit");
+        const tag = getOption(parsed, "tag");
+        const itemType = getOption(parsed, "type");
+        const collection = getOption(parsed, "collection");
+        const searchOptions = {};
+        if (limit !== undefined)
+            searchOptions.limit = limit;
+        if (tag)
+            searchOptions.tag = [tag];
+        if (itemType)
+            searchOptions.itemType = itemType;
+        return { library, format, searchOptions: { ...searchOptions, ...(collection ? { query: collection } : {}) } };
+    }
+    async execute(input, context) {
+        const result = await context.zotero.exportItems(input.library, input.format, input.searchOptions);
+        context.output.write(result);
+    }
+}

package/dist/commands/fulltextCommand.js

@@ -0,0 +1,44 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, parseArgs } from "../utils/args.js";
+import { renderJson, resolveLibrary } from "./helpers.js";
+export class FulltextCommand {
+    name = "fulltext";
+    category = "Core";
+    description = "Get full-text content of an item.";
+    help() {
+        return [
+            "Usage:",
+            "  zt fulltext <itemKey>",
+            "  zt fulltext --key <itemKey>",
+            "",
+            "Retrieve the full-text content for an item.",
+            "",
+            "Options:",
+            "  --key <key>            Item key",
+            "  --group <id>           Library group ID",
+            "",
+            "Examples:",
+            "  zt fulltext ABC12345",
+            "  zt fulltext --key ABC12345",
+            "  zt fulltext ABC12345 --group 123456"
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["key", "group"]);
+        assertNoMissingOptionValues(parsed, ["key", "group"]);
+        if (parsed.positionals.length > 1) {
+            throw new ValidationError("fulltext accepts at most one positional argument (item key).");
+        }
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const key = parsed.positionals[0] ?? getOption(parsed, "key");
+        if (!key) {
+            throw new ValidationError("fulltext requires an item key. Usage: zt fulltext <itemKey> or zt fulltext --key <itemKey>");
+        }
+        return { library, key };
+    }
+    async execute(input, context) {
+        const result = await context.zotero.getFullText(input.library, input.key);
+        context.output.write(renderJson(result));
+    }
+}

package/dist/commands/helpers.js

@@ -0,0 +1,27 @@
+import { ValidationError } from "../application/errors.js";
+import { getOption } from "../utils/args.js";
+export function renderJson(value) {
+    return JSON.stringify(value, null, 2);
+}
+export function ensureNoPositionals(parsed, label) {
+    if (parsed.positionals.length > 0) {
+        throw new ValidationError(`${label} does not accept positional arguments.`);
+    }
+}
+export function resolveLibrary(parsed, config) {
+    const group = getOption(parsed, "group");
+    if (group) {
+        return { type: "group", id: group };
+    }
+    const userId = config.userId ?? "0";
+    return { type: "user", id: userId };
+}
+export function parseIntOption(parsed, name) {
+    const value = getOption(parsed, name);
+    if (value === undefined)
+        return undefined;
+    const num = parseInt(value, 10);
+    if (isNaN(num))
+        throw new ValidationError(`Option --${name} must be a number.`);
+    return num;
+}

package/dist/commands/itemGetCommand.js

@@ -0,0 +1,52 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, hasBoolean, parseArgs } from "../utils/args.js";
+import { renderJson, resolveLibrary } from "./helpers.js";
+export class ItemGetCommand {
+    name = "get";
+    category = "Core";
+    description = "Get an item by key.";
+    help() {
+        return [
+            "Usage:",
+            "  zt get <key>",
+            "  zt get --key <key>",
+            "",
+            "Retrieve a single item by its key.",
+            "",
+            "Options:",
+            "  --key <key>            Item key",
+            "  --group <id>           Library group ID",
+            "  --children             Show child items (attachments, notes)",
+            "",
+            "Examples:",
+            '  zt get ABC12345',
+            '  zt get --key ABC12345 --children',
+            '  zt get --key ABC12345 --group 123456'
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["key", "group", "children"]);
+        assertNoMissingOptionValues(parsed, ["key", "group"]);
+        if (parsed.positionals.length > 1) {
+            throw new ValidationError("get accepts at most one positional argument (item key).");
+        }
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const key = parsed.positionals[0] ?? getOption(parsed, "key");
+        const children = hasBoolean(parsed, "children");
+        if (!key) {
+            throw new ValidationError("get requires an item key. Usage: zt get <key> or zt get --key <key>");
+        }
+        return { library, key, children };
+    }
+    async execute(input, context) {
+        if (input.children) {
+            const result = await context.zotero.getItemChildren(input.library, input.key);
+            context.output.write(renderJson(result));
+        }
+        else {
+            const result = await context.zotero.getItem(input.library, input.key);
+            context.output.write(renderJson(result));
+        }
+    }
+}

package/dist/commands/itemsCommand.js

@@ -0,0 +1,62 @@
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, getOptions, hasBoolean, parseArgs } from "../utils/args.js";
+import { ensureNoPositionals, parseIntOption, renderJson, resolveLibrary } from "./helpers.js";
+export class ItemsCommand {
+    name = "items";
+    category = "Core";
+    description = "List items.";
+    help() {
+        return [
+            "Usage: zt items [options]",
+            "",
+            "List items, optionally within a collection.",
+            "",
+            "Options:",
+            "  --group <id>           Library group ID",
+            "  --collection <key>     Collection key to list items from",
+            "  --limit <n>            Maximum number of results",
+            "  --sort <field>         Sort field (e.g. title, dateModified, dateAdded)",
+            "  --direction <asc|desc> Sort direction",
+            "  --top                  Only show top-level items (no attachments/notes)",
+            "  --tag <tag>            Filter by tag (repeatable)",
+            "  --type <itemType>      Filter by item type (e.g. book, journalArticle)",
+            "",
+            "Examples:",
+            "  zt items --top --limit 25",
+            "  zt items --collection ABC12345 --sort dateAdded --direction desc",
+            "  zt items --tag \"machine learning\" --type journalArticle"
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["group", "collection", "limit", "sort", "direction", "top", "tag", "type"]);
+        assertNoMissingOptionValues(parsed, ["group", "collection", "limit", "sort", "direction", "tag", "type"]);
+        ensureNoPositionals(parsed, "items");
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const collection = getOption(parsed, "collection");
+        const limit = parseIntOption(parsed, "limit");
+        const sort = getOption(parsed, "sort");
+        const direction = getOption(parsed, "direction");
+        const top = hasBoolean(parsed, "top");
+        const tags = getOptions(parsed, "tag");
+        const itemType = getOption(parsed, "type");
+        return { library, collection, limit, sort, direction, top, tags, itemType };
+    }
+    async execute(input, context) {
+        const options = {};
+        if (input.limit !== undefined)
+            options.limit = input.limit;
+        if (input.sort)
+            options.sort = input.sort;
+        if (input.direction)
+            options.direction = input.direction;
+        if (input.tags.length > 0)
+            options.tag = input.tags;
+        if (input.itemType)
+            options.itemType = input.itemType;
+        const fetch = input.top
+            ? context.zotero.listTopItems
+            : context.zotero.listItems;
+        const result = await fetch.call(context.zotero, input.library, input.collection, Object.keys(options).length > 0 ? options : undefined);
+        context.output.write(renderJson(result));
+    }
+}

package/dist/commands/librariesCommand.js

@@ -0,0 +1,27 @@
+import { assertNoUnknownOptions, parseArgs } from "../utils/args.js";
+import { ensureNoPositionals, renderJson } from "./helpers.js";
+export class LibrariesCommand {
+    name = "libraries";
+    category = "Core";
+    description = "List group libraries.";
+    help() {
+        return [
+            "Usage: zt libraries",
+            "",
+            "List the user's group libraries.",
+            "",
+            "Examples:",
+            "  zt libraries"
+        ].join("\n");
+    }
+    parse(argv) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, []);
+        ensureNoPositionals(parsed, "libraries");
+        return {};
+    }
+    async execute(_input, context) {
+        const result = await context.zotero.listLibraries();
+        context.output.write(renderJson(result));
+    }
+}

package/dist/commands/searchCommand.js

@@ -0,0 +1,67 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, getOption, getOptions, parseArgs } from "../utils/args.js";
+import { parseIntOption, renderJson, resolveLibrary } from "./helpers.js";
+export class SearchCommand {
+    name = "search";
+    category = "Core";
+    description = "Search for items.";
+    help() {
+        return [
+            "Usage: zt search <query> [options]",
+            "",
+            "Search for items in the library.",
+            "",
+            "Options:",
+            "  --group <id>           Library group ID",
+            "  --limit <n>            Maximum number of results",
+            "  --sort <field>         Sort field (e.g. title, dateModified)",
+            "  --direction <asc|desc> Sort direction",
+            "  --tag <tag>            Filter by tag (repeatable)",
+            "  --type <itemType>      Filter by item type (e.g. book, journalArticle)",
+            "  --qmode <mode>         Search mode: titleCreatorYear or everything",
+            "",
+            "Examples:",
+            '  zt search "machine learning"',
+            '  zt search "neural networks" --limit 10 --sort dateAdded',
+            '  zt search "deep learning" --tag AI --type journalArticle',
+            '  zt search "attention" --qmode everything'
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["group", "limit", "sort", "direction", "tag", "type", "qmode"]);
+        assertNoMissingOptionValues(parsed, ["group", "limit", "sort", "direction", "tag", "type", "qmode"]);
+        const query = parsed.positionals[0];
+        if (!query) {
+            throw new ValidationError("search requires a query. Usage: zt search <query>");
+        }
+        if (parsed.positionals.length > 1) {
+            throw new ValidationError("search accepts at most one positional argument (query). Wrap multi-word queries in quotes.");
+        }
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const limit = parseIntOption(parsed, "limit");
+        const sort = getOption(parsed, "sort");
+        const direction = getOption(parsed, "direction");
+        const tags = getOptions(parsed, "tag");
+        const itemType = getOption(parsed, "type");
+        const qmode = getOption(parsed, "qmode");
+        return { library, query, limit, sort, direction, tags, itemType, qmode };
+    }
+    async execute(input, context) {
+        const options = {};
+        if (input.limit !== undefined)
+            options.limit = input.limit;
+        if (input.sort)
+            options.sort = input.sort;
+        if (input.direction)
+            options.direction = input.direction;
+        if (input.tags.length > 0)
+            options.tag = input.tags;
+        if (input.itemType)
+            options.itemType = input.itemType;
+        if (input.qmode)
+            options.qmode = input.qmode;
+        const result = await context.zotero.searchItems(input.library, input.query, Object.keys(options).length > 0 ? options : undefined);
+        context.output.write(renderJson(result));
+    }
+}

package/dist/commands/tagsCommand.js

@@ -0,0 +1,39 @@
+import { assertNoMissingOptionValues, assertNoUnknownOptions, parseArgs } from "../utils/args.js";
+import { ensureNoPositionals, parseIntOption, renderJson, resolveLibrary } from "./helpers.js";
+export class TagsCommand {
+    name = "tags";
+    category = "Core";
+    description = "List tags.";
+    help() {
+        return [
+            "Usage: zt tags [options]",
+            "",
+            "List tags in the library.",
+            "",
+            "Options:",
+            "  --group <id>           Library group ID",
+            "  --limit <n>            Maximum number of results",
+            "",
+            "Examples:",
+            "  zt tags",
+            "  zt tags --limit 100",
+            "  zt tags --group 123456"
+        ].join("\n");
+    }
+    parse(argv, context) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["group", "limit"]);
+        assertNoMissingOptionValues(parsed, ["group", "limit"]);
+        ensureNoPositionals(parsed, "tags");
+        const library = resolveLibrary(parsed, context?.config ?? { baseUrl: "" });
+        const limit = parseIntOption(parsed, "limit");
+        return { library, limit };
+    }
+    async execute(input, context) {
+        const options = {};
+        if (input.limit !== undefined)
+            options.limit = input.limit;
+        const result = await context.zotero.listTags(input.library, Object.keys(options).length > 0 ? options : undefined);
+        context.output.write(renderJson(result));
+    }
+}

package/dist/commands/templateCommand.js

@@ -0,0 +1,38 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, parseArgs } from "../utils/args.js";
+import { renderJson } from "./helpers.js";
+export class TemplateCommand {
+    name = "template";
+    category = "Lookup";
+    description = "Get the JSON template for creating an item of a specific type.";
+    help() {
+        return [
+            "Usage:",
+            "  zt template <itemType>",
+            "",
+            "Get the JSON template for creating a new item of the given type.",
+            "",
+            "Examples:",
+            "  zt template journalArticle",
+            "  zt template book",
+            "  zt template conferencePaper"
+        ].join("\n");
+    }
+    parse(argv) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, []);
+        assertNoMissingOptionValues(parsed, []);
+        const itemType = parsed.positionals[0];
+        if (!itemType) {
+            throw new ValidationError("template requires an item type. Usage: zt template <itemType>");
+        }
+        if (parsed.positionals.length > 1) {
+            throw new ValidationError("template accepts at most one positional argument (item type).");
+        }
+        return { itemType };
+    }
+    async execute(input, context) {
+        const result = await context.zotero.getItemTemplate(input.itemType);
+        context.output.write(renderJson(result));
+    }
+}