@beomsukoh/zotero-cli 0.2.0

package/dist/commands/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/typesInfoCommand.js

@@ -0,0 +1,55 @@
+import { ValidationError } from "../application/errors.js";
+import { assertNoMissingOptionValues, assertNoUnknownOptions, hasBoolean, parseArgs } from "../utils/args.js";
+import { renderJson } from "./helpers.js";
+export class TypesInfoCommand {
+    name = "types";
+    category = "Lookup";
+    description = "Show available item types, or fields for a specific type.";
+    help() {
+        return [
+            "Usage:",
+            "  zt types",
+            "  zt types <itemType>",
+            "  zt types <itemType> --creators",
+            "",
+            "List all available item types, or show the fields (or creator types)",
+            "for a specific item type.",
+            "",
+            "Options:",
+            "  --creators             Show creator types instead of fields",
+            "",
+            "Examples:",
+            "  zt types",
+            "  zt types journalArticle",
+            "  zt types journalArticle --creators"
+        ].join("\n");
+    }
+    parse(argv) {
+        const parsed = parseArgs(argv);
+        assertNoUnknownOptions(parsed, ["creators"]);
+        assertNoMissingOptionValues(parsed, []);
+        if (parsed.positionals.length > 1) {
+            throw new ValidationError("types accepts at most one positional argument (item type).");
+        }
+        const itemType = parsed.positionals[0];
+        const creators = hasBoolean(parsed, "creators");
+        if (creators && !itemType) {
+            throw new ValidationError("--creators requires an item type. Usage: zt types <itemType> --creators");
+        }
+        return { itemType, creators };
+    }
+    async execute(input, context) {
+        if (!input.itemType) {
+            const result = await context.zotero.getItemTypes();
+            context.output.write(renderJson(result));
+        }
+        else if (input.creators) {
+            const result = await context.zotero.getItemTypeCreatorTypes(input.itemType);
+            context.output.write(renderJson(result));
+        }
+        else {
+            const result = await context.zotero.getItemTypeFields(input.itemType);
+            context.output.write(renderJson(result));
+        }
+    }
+}

package/dist/compositionRoot.js

@@ -0,0 +1,44 @@
+import { NodeHttpClient } from "./infrastructure/httpClient.js";
+import { HttpZoteroAdapter } from "./adapters/http/HttpZoteroAdapter.js";
+import { ConsoleOutputAdapter } from "./adapters/output/ConsoleOutputAdapter.js";
+import { CommandRegistry } from "./commands/CommandRegistry.js";
+import { LibrariesCommand } from "./commands/librariesCommand.js";
+import { CollectionsCommand } from "./commands/collectionsCommand.js";
+import { ItemsCommand } from "./commands/itemsCommand.js";
+import { ItemGetCommand } from "./commands/itemGetCommand.js";
+import { SearchCommand } from "./commands/searchCommand.js";
+import { TagsCommand } from "./commands/tagsCommand.js";
+import { CreateCollectionCommand } from "./commands/createCollectionCommand.js";
+import { CreateItemCommand } from "./commands/createItemCommand.js";
+import { DeleteCommand } from "./commands/deleteCommand.js";
+import { AttachCommand } from "./commands/attachCommand.js";
+import { ExportCommand } from "./commands/exportCommand.js";
+import { FulltextCommand } from "./commands/fulltextCommand.js";
+import { TemplateCommand } from "./commands/templateCommand.js";
+import { TypesInfoCommand } from "./commands/typesInfoCommand.js";
+export function createRuntime() {
+    const config = {
+        apiKey: process.env["ZOTERO_API_KEY"],
+        userId: process.env["ZOTERO_USER_ID"] ?? "0",
+        baseUrl: process.env["ZOTERO_BASE_URL"] ?? "http://localhost:23119/api"
+    };
+    const http = new NodeHttpClient();
+    const zotero = new HttpZoteroAdapter(http, config.baseUrl, config.apiKey, config.userId);
+    const output = new ConsoleOutputAdapter();
+    const registry = new CommandRegistry();
+    registry.register(new LibrariesCommand());
+    registry.register(new CollectionsCommand());
+    registry.register(new ItemsCommand());
+    registry.register(new ItemGetCommand());
+    registry.register(new SearchCommand());
+    registry.register(new TagsCommand());
+    registry.register(new CreateCollectionCommand());
+    registry.register(new CreateItemCommand());
+    registry.register(new DeleteCommand());
+    registry.register(new AttachCommand());
+    registry.register(new ExportCommand());
+    registry.register(new FulltextCommand());
+    registry.register(new TemplateCommand());
+    registry.register(new TypesInfoCommand());
+    return { output, zotero, registry, config };
+}

package/dist/infrastructure/httpClient.js

@@ -0,0 +1,55 @@
+export class NodeHttpClient {
+    async request(method, url, options = {}) {
+        const response = await fetch(url, {
+            method,
+            headers: options.headers,
+            body: options.body
+        });
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        return {
+            status: response.status,
+            headers,
+            body: await response.text()
+        };
+    }
+    async requestRaw(method, url, options = {}) {
+        const response = await fetch(url, {
+            method,
+            headers: options.headers,
+        });
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        const arrayBuffer = await response.arrayBuffer();
+        return {
+            status: response.status,
+            headers,
+            data: Buffer.from(arrayBuffer),
+        };
+    }
+    async requestFormData(url, fields, file) {
+        const formData = new FormData();
+        for (const [key, value] of Object.entries(fields)) {
+            formData.append(key, value);
+        }
+        const blob = new Blob([file.data], { type: file.contentType });
+        formData.append("file", blob, file.name);
+        const response = await fetch(url, {
+            method: "POST",
+            body: formData,
+        });
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        return {
+            status: response.status,
+            headers,
+            body: await response.text(),
+        };
+    }
+}

package/dist/utils/args.js

@@ -0,0 +1,67 @@
+import { ValidationError } from "../application/errors.js";
+export function parseArgs(tokens) {
+    const positionals = [];
+    const options = new Map();
+    const booleans = new Set();
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token)
+            continue;
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const optionToken = token.slice(2);
+        if (!optionToken)
+            throw new ValidationError(`Invalid option: ${token}`);
+        const equalsIndex = optionToken.indexOf("=");
+        if (equalsIndex >= 0) {
+            const key = optionToken.slice(0, equalsIndex);
+            const value = optionToken.slice(equalsIndex + 1);
+            appendOption(options, key, value);
+            continue;
+        }
+        const next = tokens[index + 1];
+        if (!next || next.startsWith("--")) {
+            booleans.add(optionToken);
+            continue;
+        }
+        appendOption(options, optionToken, next);
+        index += 1;
+    }
+    return { positionals, options, booleans };
+}
+export function getOption(parsed, name) {
+    return parsed.options.get(name)?.at(-1);
+}
+export function getOptions(parsed, name) {
+    return parsed.options.get(name) ?? [];
+}
+export function hasBoolean(parsed, name) {
+    return parsed.booleans.has(name);
+}
+export function assertNoUnknownOptions(parsed, allowed) {
+    const allowedSet = new Set(allowed);
+    for (const key of parsed.options.keys()) {
+        if (!allowedSet.has(key))
+            throw new ValidationError(`Unknown option: --${key}`);
+    }
+    for (const key of parsed.booleans) {
+        if (!allowedSet.has(key))
+            throw new ValidationError(`Unknown option: --${key}`);
+    }
+}
+export function assertNoMissingOptionValues(parsed, optionNames) {
+    for (const name of optionNames) {
+        if (parsed.booleans.has(name))
+            throw new ValidationError(`Option --${name} requires a value.`);
+    }
+}
+function appendOption(map, key, value) {
+    const existing = map.get(key);
+    if (!existing) {
+        map.set(key, [value]);
+        return;
+    }
+    existing.push(value);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@beomsukoh/zotero-cli",
+  "version": "0.2.0",
+  "description": "Pure CLI wrapper for the Zotero API.",
+  "type": "module",
+  "bin": {
+    "zt": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node ./scripts/build.mjs",
+    "check": "tsc --noEmit && node ./scripts/validate-docs.mjs",
+    "dt": "tsx ./src/cli.ts",
+    "test": "vitest run",
+    "test:smoke": "vitest run --config vitest.config.smoke.ts",
+    "release:check": "pnpm check && pnpm test && pnpm build && pnpm pack:check",
+    "pack:check": "pnpm build && npm pack --dry-run",
+    "prepack": "pnpm build",
+    "prepublishOnly": "pnpm check && pnpm test && pnpm pack:check"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.0"
+  }
+}