From 7d62a43ea63f3a264cd8fa8820e1e53753e93d5a Mon Sep 17 00:00:00 2001
From: Yusef Almamari <yu9811sef.ya@gmail.com>
Date: Wed, 27 Nov 2024 17:17:29 +0400
Subject: [PATCH] First commit

---
 .eslintignore                 |   7 +
 .eslintrc                     |  26 ++
 .github/workflows/publish.yml |  54 ++++
 .gitignore                    |  10 +
 .prettierignore               |   4 +
 .prettierrc                   |   7 +
 LICENSE                       |   7 +
 README.md                     | 149 ++++++++++
 package.json                  |  73 +++++
 src/CSLJsonParser.ts          | 493 ++++++++++++++++++++++++++++++++++
 src/citeease-cli.ts           |   5 +
 src/common.ts                 |  87 ++++++
 src/index.ts                  | 349 ++++++++++++++++++++++++
 src/types.ts                  |  35 +++
 tsconfig.json                 |  18 ++
 15 files changed, 1324 insertions(+)
 create mode 100644 .eslintignore
 create mode 100644 .eslintrc
 create mode 100644 .github/workflows/publish.yml
 create mode 100644 .gitignore
 create mode 100644 .prettierignore
 create mode 100644 .prettierrc
 create mode 100644 LICENSE
 create mode 100644 README.md
 create mode 100644 package.json
 create mode 100644 src/CSLJsonParser.ts
 create mode 100644 src/citeease-cli.ts
 create mode 100644 src/common.ts
 create mode 100644 src/index.ts
 create mode 100644 src/types.ts
 create mode 100644 tsconfig.json

diff --git a/.eslintignore b/.eslintignore
new file mode 100644
index 0000000..cc302ac
--- /dev/null
+++ b/.eslintignore
@@ -0,0 +1,7 @@
+# See https://eslint.org/docs/latest/use/configure/ignore for more about ignoring files.
+
+# dependencies
+node_modules/
+
+# prodiction
+dist/
\ No newline at end of file
diff --git a/.eslintrc b/.eslintrc
new file mode 100644
index 0000000..1175cd1
--- /dev/null
+++ b/.eslintrc
@@ -0,0 +1,26 @@
+{
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+    },
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es6": true,
+        "node": true,
+    },
+    "plugins": ["@typescript-eslint", "import", "prettier"],
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended",
+        "plugin:import/errors",
+        "plugin:prettier/recommended",
+    ],
+    "rules": {
+        "indent": ["warn", 4],
+        "quotes": ["warn", "double"],
+        "no-unused-vars": "warn",
+        "@typescript-eslint/no-var-requires": "off",
+    },
+}
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 0000000..244f26f
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,54 @@
+name: Publish NPM package
+
+on:
+    push:
+        branches:
+            - main
+
+jobs:
+    publish:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v2
+              with:
+                  fetch-depth: 0
+
+            - name: Setup Node.js
+              uses: actions/setup-node@v2
+              with:
+                  node-version: "20"
+                  registry-url: "https://registry.npmjs.org"
+
+            - name: Install dependencies
+              run: npm install
+
+            # - name: Test
+            #   run: npm run test
+
+            - name: Check the version
+              id: check
+              run: |
+                  CURRENT_VERSION=$(jq -r .version package.json)
+                  echo "Current version: $CURRENT_VERSION"
+                  LATEST_VERSION=$(npm show <package-name> version || echo "0.0.0")
+                  echo "Latest version: $LATEST_VERSION"
+
+                  if [ "$LATEST_VERSION" != "$CURRENT_VERSION" ]; 
+                  then
+                    echo "Version changed"
+                    echo "version_changed=true" >> $GITHUB_OUTPUT
+                    echo "new_version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+                  else
+                    echo "Version not changed"
+                    echo "version_changed=false" >> $GITHUB_OUTPUT
+                  fi
+
+            - name: Build
+              run: npm run build
+              if: steps.check.outputs.version_changed == 'true'
+
+            - name: Publish
+              if: steps.check.outputs.version_changed == 'true'
+              run: npm publish --access public --no-git-checks
+              env:
+                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..9502a68
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,10 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+
+# production
+/dist
+
+# misc
+package-lock.json
\ No newline at end of file
diff --git a/.prettierignore b/.prettierignore
new file mode 100644
index 0000000..d4fd620
--- /dev/null
+++ b/.prettierignore
@@ -0,0 +1,4 @@
+# See https://prettier.io/docs/en/ignore.html for more about ignoring files.
+
+# dependencies
+node_modules/
diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 0000000..106964a
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,7 @@
+{
+    "trailingComma": "es5",
+    "printWidth": 120,
+    "tabWidth": 4,
+    "semi": true,
+    "singleQuote": false
+}
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7311083
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,7 @@
+Copyright © 2024 Ganemede Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..1085d59
--- /dev/null
+++ b/README.md
@@ -0,0 +1,149 @@
+# CiteEase CLI
+
+![npm](https://img.shields.io/npm/v/citeease-cli)  
+![npm](https://img.shields.io/npm/dw/citeease-cli)  
+![License](https://img.shields.io/npm/l/citeease-cli)
+
+`citeease-cli` is a CLI tool that generates formatted citations (references) based on various unique identifiers, including URL, DOI, ISBN, PMID, and PMCID. Just pass in your identifiers, and `citeease-cli` will handle the rest!
+
+## 📋 Table of Contents
+
+-   [Installation](#-installation)
+-   [Usage](#-usage)
+-   [Configuration](#-configuration)
+-   [Supported Identifiers](#-supported-identifiers)
+-   [Data Sources](#-data-sources)
+-   [Output](#-output)
+-   [License](#-license)
+-   [Contact](#-contact)
+
+## ⚙️ Installation
+
+Install `citeease-cli` globally via npm:
+
+```bash
+npm install -g citeease-cli
+```
+
+Or use it directly with `npx` without global installation:
+
+```bash
+npx citeease-cli cite <list of identifiers>
+```
+
+## 🚀 Usage
+
+To generate citations, provide a list of unique identifiers as arguments. `citeease-cli` will attempt to identify the type of each identifier automatically.
+
+### Options
+
+-   `--style`, `-s <style>`: Choose the citation style for the output (e.g., `apa`, `modern-language-association`, `chicago-author-date`). The default is APA.
+-   `--locale`, `-l <locale>`: Set the locale for the citation language (e.g., `en-US` for U.S. English, `fr-FR` for French, `ar` for Arabic). The default is `en-US`.
+-   `--format`, `-f <format>`: Specify the output format. Options include `text` (default), `html`, `rtf`, and `asciidoc`.
+-   `--log-errors`, `-e`: Enable logging of errors for debugging purposes.
+-   `--version`, `-v`: Display the current version of `citeease-cli`.
+
+> **Note:** You can check available citation styles and locales at:
+>
+> -   Styles: [https://github.com/citation-style-language/styles](https://github.com/citation-style-language/styles)
+> -   Locales: [https://github.com/citation-style-language/locales](https://github.com/citation-style-language/locales)
+
+### Examples
+
+```bash
+# Using a globally installed package
+cite 10.1000/xyz123 978-3-16-148410-0
+
+# Specifying a citation style and locale
+cite --style modern-language-association --locale en-GB 10.1000/xyz123
+
+# Specifying an output format
+cite --format html 10.1000/xyz123
+```
+
+Or with `npx`:
+
+```bash
+npx citeease-cli cite --style chicago-author-date --locale fr-FR --format rtf https://example.com/article
+```
+
+### Specifying Identifier Types
+
+If `citeease-cli` misinterprets an identifier’s type or if you want to force a specific type, you can prefix it with the type and a colon, like so:
+
+```bash
+cite "url: https://doi.org/10.xyz123" "isbn: 978-3-16-148410-0"
+```
+
+This will force `citeease-cli` to treat the first identifier as a URL and the second as an ISBN. This works for all identifier types: **url**, **doi**, **isbn**, **pmid**, and **pmcid**.
+
+---
+
+## ⚙️ Configuration
+
+`citeease-cli` allows you to configure default settings for citation generation using the `config` command. This helps you avoid repeating options like style, locale, or format with every command.
+
+### Configuration Options
+
+-   **`style`**: Set the default citation style (e.g., `apa`, `mla`, `chicago-author-date`).
+-   **`locale`**: Set the default locale (e.g., `en-US`, `fr-FR`, `ar`).
+-   **`format`**: Set the default output format (e.g., `text`, `HTML`, `rtf`, `asciidoc`).
+-   **`reset`**: Reset all configurations to their default values.
+
+### Examples
+
+```bash
+# Set default citation style to APA
+cite config style apa
+
+# Set default locale to en-US
+cite config locale en-US
+
+# Set default output format to HTML
+cite config format html
+
+# Reset all configurations
+cite config reset
+```
+
+Use the `config <KEY>` command without a value to view the current setting for a key.
+
+---
+
+## 🆔 Supported Identifiers
+
+-   **DOI**: e.g., `10.1093/ajae/aaq063`
+-   **URL**: e.g., `https://example.com`
+-   **ISBN**: e.g., `978-3-16-148410-0`
+-   **PMID**: e.g., `27097605`
+-   **PMCID**: e.g., `PMC6323133`
+
+---
+
+## 🌐 Data Sources
+
+`citeease-cli` uses the following free APIs to retrieve citation data:
+
+-   [CrossRef](https://www.crossref.org/documentation/retrieve-metadata/rest-api/): For DOI-based data, e.g., `https://api.crossref.org/works/<DOI>`
+-   [Open Library](https://openlibrary.org/developers/api): For ISBN-based data, e.g., `https://openlibrary.org/search.json?q=isbn:<ISBN>&mode=everything&fields=*,editions`
+-   [NCBI](https://api.ncbi.nlm.nih.gov/lit/ctxp/): For data from PubMed and PubMed Central, e.g., `https://api.ncbi.nlm.nih.gov/lit/ctxp/v1/pubmed/?format=csl&id=<PMID>` and `https://api.ncbi.nlm.nih.gov/lit/ctxp/v1/pmc/?format=csl&id=<PMCID>`
+
+These APIs provide open-access data for research and citation.
+
+---
+
+## 📄 Output
+
+`citeease-cli` generates a formatted citation (reference) for each identifier. The output is styled for easy copy-pasting into documents and includes all relevant citation details, formatted according to standard citation styles, locale settings, and output format.
+
+---
+
+## 📜 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+---
+
+## 📧 Contact
+
+For inquiries or more information, you can reach out to us at [ganemedelabs@gmail.com](mailto:ganemedelabs@gmail.com).
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..1fece95
--- /dev/null
+++ b/package.json
@@ -0,0 +1,73 @@
+{
+    "name": "citeease-cli",
+    "version": "1.0.0",
+    "description": "citeease-cli is a CLI tool that generates formatted citations (references) based on various unique identifiers, including URL, DOI, ISBN, PMID, and PMCID.",
+    "private": false,
+    "bin": {
+        "citeease-cli": "dist/citeease-cli.js",
+        "cite": "dist/index.js"
+    },
+    "types": "dist/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/ganymedelabs/citeease-cli.git"
+    },
+    "author": "ganymedelabs",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/ganymedelabs/citeease-cli/issues"
+    },
+    "homepage": "https://github.com/ganymedelabs/citeease-cli#readme",
+    "keywords": [
+        "citation",
+        "reference",
+        "references",
+        "bibliography",
+        "doi",
+        "isbn",
+        "pmid",
+        "pmcid",
+        "url",
+        "citation-generator",
+        "cli-tool",
+        "command-line",
+        "bibliography-generator",
+        "academic",
+        "research",
+        "csl",
+        "citation-style-language"
+    ],
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "package.json"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "dev": "ts-node src/index.ts",
+        "start": "node dist/index.js",
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "lint": "eslint .",
+        "lint:fix": "eslint --fix .",
+        "format": "prettier --write \"./**/*.{js,ts,json}\""
+    },
+    "dependencies": {
+        "citeproc": "^2.4.63",
+        "jsdom": "^25.0.1",
+        "xmlhttprequest": "^1.8.0"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.6.0",
+        "@types/node": "^22.9.0",
+        "@typescript-eslint/eslint-plugin": "^7.18.0",
+        "@typescript-eslint/parser": "^7.18.0",
+        "eslint": "^8.57.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-import": "^2.29.1",
+        "eslint-plugin-prettier": "^5.1.3",
+        "prettier": "^3.3.2",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.6.3"
+    }
+}
diff --git a/src/CSLJsonParser.ts b/src/CSLJsonParser.ts
new file mode 100644
index 0000000..e54d7bc
--- /dev/null
+++ b/src/CSLJsonParser.ts
@@ -0,0 +1,493 @@
+import { type CSLJson, type CSLJsonResponse, type DateObject } from "./types"; // eslint-disable-line import/no-unresolved
+
+const Citeproc = require("citeproc");
+const { XMLHttpRequest } = require("xmlhttprequest");
+const { JSDOM } = require("jsdom");
+const { FONT, RESULT, uid } = require("./common");
+
+type Options = {
+    logErrors: boolean;
+};
+
+type ToBibliographyOptions = {
+    style: string;
+    locale: string;
+    format: "text" | "html" | "rtf" | "asciidoc";
+};
+
+type OpenLibraryResponse = {
+    numFound: number;
+    start: number;
+    numFoundExact: boolean;
+    docs: Array<{
+        title?: string;
+        number_of_pages_median?: number;
+        author_name?: string[];
+        editions?: {
+            docs: Array<{ publisher?: string[]; publish_place?: string[]; publish_date?: string[]; isbn?: string[] }>;
+        };
+    }>;
+    num_found: number;
+    q: string;
+    offset: unknown;
+};
+
+type CrossRefResponse = CSLJson & {
+    "container-title": [string];
+    title: [string];
+};
+
+/**
+ * Class to manage CSL-JSON (Citation Style Language) data and convert it to various formats.
+ */
+class CSLJsonParser {
+    private cslJson: CSLJson[];
+    private options: Options;
+
+    private CORS_PROXY = "https://corsproxy.io/?";
+
+    /**
+     * Constructs a new instance of CSLJson.
+     * @param {CSLJson} cslJson - The CSL-JSON data.
+     * @param {Options} [options={ logErrors: false }] - Configuration options.
+     */
+    constructor(cslJson: CSLJson[] = [], options: Options = { logErrors: false }) {
+        this.cslJson = cslJson;
+        this.options = options;
+    }
+
+    /**
+     * Generates an error template string in a styled format.
+     * @param {Error} error - The error to format.
+     * @returns {string} The formatted error string.
+     */
+    private errorTemplate(error: Error): string {
+        return `\n${RESULT.ERROR} ${FONT.RED}${error.toString().replace("Error: ", "")}${FONT.RESET}\n\n`;
+    }
+
+    /**
+     * Fetches a CSL style file.
+     * @param {string} style - The style identifier (e.g., "apa").
+     * @returns {string} The CSL file content.
+     */
+    private getCslFile(style: string): string {
+        const xhr = new XMLHttpRequest();
+        xhr.open("GET", `https://raw.githubusercontent.com/citation-style-language/styles/master/${style}.csl`, false);
+        xhr.send(null);
+        const text = xhr.responseText;
+
+        if (text.startsWith("404:")) {
+            throw new Error(`Failed to retrieve style "${style}"`);
+        }
+
+        return text;
+    }
+
+    /**
+     * Fetches a locale file for CSL formatting.
+     * @param {string} lang - The locale identifier (e.g., "en-US").
+     * @returns {string} The locale file content.
+     */
+    private getLocaleFile(lang: string): string {
+        const xhr = new XMLHttpRequest();
+        xhr.open(
+            "GET",
+            `https://raw.githubusercontent.com/citation-style-language/locales/master/locales-${lang}.xml`,
+            false
+        );
+        xhr.send(null);
+        const text = xhr.responseText;
+
+        if (text.startsWith("404:")) {
+            throw new Error(`Failed to retrieve locale "${lang}"`);
+        }
+
+        return text;
+    }
+
+    /**
+     * Creates an array of author objects from an array of author names.
+     * @param {string[]} authors - Array of author names.
+     * @returns {Array<{ given: string; family: string }>} An array of author objects with given and family names.
+     */
+    private createAuthorsArray(authors: string[]): Array<{ given: string; family: string }> {
+        return authors.map((author) => {
+            const names = author.split(/\s+/);
+            const given = names.shift() || "";
+            const family = names.join(" ");
+            return { given, family };
+        });
+    }
+
+    /**
+     * Creates a date object in CSL format.
+     * @param {number | Date} yearOrDate - The year or Date object.
+     * @param {number} [month] - The month of the date.
+     * @param {number} [day] - The day of the date.
+     * @returns {DateObject} A CSL-compliant date object.
+     */
+    private createDateObject(yearOrDate: number | Date, month?: number, day?: number): DateObject {
+        let year: number;
+        let adjustedMonth: number | undefined;
+        let adjustedDay: number | undefined;
+
+        if (yearOrDate instanceof Date) {
+            year = yearOrDate.getFullYear();
+            adjustedMonth = yearOrDate.getMonth() + 1;
+            adjustedDay = yearOrDate.getDate();
+        } else {
+            year = yearOrDate;
+            adjustedMonth = month;
+            adjustedDay = day;
+        }
+
+        const dateParts = [year];
+        if (adjustedMonth) dateParts.push(adjustedMonth);
+        if (adjustedDay) dateParts.push(adjustedDay);
+
+        return { "date-parts": [dateParts] };
+    }
+
+    /**
+     * Retrieves CSL-JSON data for a given DOI.
+     * @param {string} doi - The DOI to fetch data for.
+     * @returns {Promise<CSLJsonResponse>} The response object with citation data.
+     */
+    public async fromDOI(doi: string): Promise<CSLJsonResponse> {
+        try {
+            const response = await fetch(`${this.CORS_PROXY}https://api.crossref.org/works/${doi}`);
+
+            if (response.status === 404) {
+                throw new Error(
+                    `Unable to retrieve data for DOI "${doi}". API responded with: ${JSON.stringify(response)}`
+                );
+            }
+
+            const data = await response.json();
+            const { message } = data as Record<string, CrossRefResponse>;
+
+            const newCslJsonObject = {
+                id: uid(),
+                DOI: message.DOI,
+                URL: message.URL || (message.DOI ? `https://doi.org/${message.DOI}` : undefined),
+                ISSN: message.ISSN,
+                "container-title": message["container-title"][0],
+                issue: message.issue,
+                issued: message.issued,
+                page: message.page,
+                publisher: message.publisher,
+                "publisher-place": message["publisher-place"],
+                source: message.source,
+                title: message.title[0],
+                volume: message.volume,
+                type: message.type,
+                accessed: this.createDateObject(new Date()),
+                author: message.author,
+            };
+
+            this.cslJson.push(newCslJsonObject);
+            return newCslJsonObject;
+        } catch (error) {
+            if (this.options.logErrors) process.stderr.write(this.errorTemplate(error as Error));
+            return { id: uid(), identifier: doi, type: "DOI", status: "failed" };
+        }
+    }
+
+    /**
+     * Retrieves CSL-JSON data from a given URL.
+     * @param {string} url - The URL to fetch data from.
+     * @returns {Promise<CSLJsonResponse>} The response object with citation data.
+     */
+    public async fromURL(url: string): Promise<CSLJsonResponse> {
+        /* eslint-disable quotes, indent */
+
+        try {
+            if (!/^https?:\/\//i.test(url)) {
+                url = `https://${url}`;
+            }
+
+            const response = await fetch(`${this.CORS_PROXY}${url}`);
+
+            if (response.status === 403) {
+                throw new Error(
+                    `Unable to retrieve data for URL "${url}". API responded with: ${JSON.stringify(response)}`
+                );
+            }
+
+            const text = await response.text();
+            const dom = new JSDOM(text);
+            const { document } = dom.window;
+
+            const extractAuthors = () => {
+                const authors: string[] = [];
+                document
+                    .querySelectorAll('meta[name="author"], meta[name="article:author"]')
+                    .forEach((meta: unknown) => {
+                        authors.push((meta as any).getAttribute("content") || ""); // eslint-disable-line @typescript-eslint/no-explicit-any
+                    });
+                return this.createAuthorsArray(authors);
+            };
+
+            const extractContent = (selector: string, attr?: string): string => {
+                const element = document.querySelector(selector);
+                return element ? (attr ? element.getAttribute(attr) || "" : element.textContent || "") : "";
+            };
+
+            const getAvailableIdentifiers = () => {
+                let pmidMatch;
+                let pmcidMatch;
+                let doiMatch;
+
+                if ((url as string).startsWith("https://pubmed.ncbi.nlm.nih.gov")) {
+                    const keywords = extractContent('meta[name="keywords"]', "content");
+
+                    pmidMatch = keywords.match(/pmid:\d+/);
+                    pmcidMatch = keywords.match(/PMC\d+/);
+                    doiMatch = keywords.match(/doi:[^,]+/);
+                }
+
+                const doi =
+                    extractContent('meta[name="publication_doi"], meta[name="citation_doi"]', "content") ||
+                    (doiMatch && doiMatch[0] ? doiMatch[0].replace("doi:", "") : undefined);
+
+                const pmid =
+                    extractContent('meta[name="ncbi_uid"]', "content") ||
+                    (pmidMatch && pmidMatch[0] ? pmidMatch[0].replace("pmid:", "") : undefined);
+
+                const pmcid = pmcidMatch && pmcidMatch[0] ? pmcidMatch[0] : undefined;
+
+                return { doi, pmid, pmcid };
+            };
+
+            const { doi, pmid, pmcid } = getAvailableIdentifiers();
+            const prioritizeIdentifiers = ["DOI", "PMID", "PMCID"];
+
+            for (let i = 0; i < prioritizeIdentifiers.length; i += 1) {
+                switch (prioritizeIdentifiers[i]) {
+                    case "DOI":
+                        if (doi) return await this.fromDOI(doi);
+                        continue;
+                    case "PMID":
+                        if (pmid) return await this.fromPMID(pmid);
+                        continue;
+                    case "PMCID":
+                        if (pmcid) return await this.fromPMCID(pmcid);
+                        continue;
+                    default:
+                        continue;
+                }
+            }
+
+            const newCslJsonObject = {
+                id: uid(),
+                type: "webpage",
+                title: extractContent("title"),
+                author: extractAuthors(),
+                "container-title": extractContent('meta[property="og:site_name"]', "content"),
+                publisher: extractContent('meta[property="article:publisher"]', "content"),
+                accessed: this.createDateObject(new Date()),
+                issued: this.createDateObject(new Date(extractContent('meta[name="date"]', "content") || "")),
+                URL: extractContent('meta[property="og:url"]', "content") || url,
+            };
+
+            this.cslJson.push(newCslJsonObject);
+            return newCslJsonObject;
+            /* eslint-disable quotes, indent */
+        } catch (error) {
+            if (this.options.logErrors) process.stderr.write(this.errorTemplate(error as Error));
+            return { id: uid(), identifier: url, type: "URL", status: "failed" };
+        }
+    }
+
+    /**
+     * Retrieves CSL-JSON data for a given ISBN.
+     * @param {string} isbn - The ISBN to fetch data for.
+     * @returns {Promise<CSLJsonResponse>} The response object with citation data.
+     */
+    public async fromISBN(isbn: string): Promise<CSLJsonResponse> {
+        try {
+            const response = await fetch(
+                `https://openlibrary.org/search.json?q=isbn:${isbn}&mode=everything&fields=*,editions`
+            );
+
+            const data = (await response.json()) as OpenLibraryResponse;
+
+            if (data.numFound === 0) {
+                throw new Error(
+                    `Unable to retrieve data for ISBN "${isbn}". API responded with: ${JSON.stringify(data)}`
+                );
+            }
+
+            const docs = data.docs[0];
+            const edition = docs?.editions?.docs[0];
+
+            const publishDate = edition?.publish_date?.[0] ? new Date(edition.publish_date[0]) : undefined;
+
+            const newCslJsonObject = {
+                id: uid(),
+                type: "book",
+                title: docs?.title,
+                "number-of-pages": docs?.number_of_pages_median,
+                author: this.createAuthorsArray(docs?.author_name as string[]),
+                publisher: edition?.publisher?.[0],
+                "publisher-place": edition?.publish_place?.[0],
+                ISBN: edition?.isbn?.[0] || isbn,
+                issued: publishDate ? this.createDateObject(publishDate) : undefined,
+                accessed: this.createDateObject(new Date()),
+            };
+
+            this.cslJson.push(newCslJsonObject);
+            return newCslJsonObject;
+        } catch (error) {
+            if (this.options.logErrors) process.stderr.write(this.errorTemplate(error as Error));
+            return { id: uid(), identifier: isbn, type: "ISBN", status: "failed" };
+        }
+    }
+
+    /**
+     * Retrieves CSL-JSON data for a given PMCID.
+     * @param {string} pmcid - The PMCID to fetch data for.
+     * @returns {Promise<CSLJsonResponse>} The response object with citation data.
+     */
+    public async fromPMCID(pmcid: string): Promise<CSLJsonResponse> {
+        /* eslint-disable indent */
+        const pmcIdWithoutPrefix = pmcid.replace(/^PMC/, "");
+
+        try {
+            const response = await fetch(
+                `${this.CORS_PROXY}https://api.ncbi.nlm.nih.gov/lit/ctxp/v1/pmc/?format=csl&id=${pmcIdWithoutPrefix}`
+            );
+
+            const data: CSLJson = await response.json();
+
+            if ("status" in data && data.status === "error") {
+                throw new Error(
+                    `Unable to retrieve data for PMCID "${pmcid}". API responded with: ${JSON.stringify(data)}`
+                );
+            }
+
+            let newCslJsonObject;
+
+            if (data?.DOI) {
+                newCslJsonObject = await this.fromDOI(data.DOI);
+            } else {
+                newCslJsonObject = {
+                    id: uid(),
+                    URL: data?.URL,
+                    ISSN: data?.ISSN,
+                    "container-title": data?.["container-title"],
+                    issue: data?.issue,
+                    issued: data?.issued,
+                    page: data?.page,
+                    "publisher-place": data?.["publisher-place"],
+                    source: data?.source,
+                    title: data?.title,
+                    type: data?.type,
+                    volume: data?.volume,
+                    accessed: this.createDateObject(new Date()),
+                    author: data?.author,
+                };
+            }
+
+            this.cslJson.push(newCslJsonObject);
+            return newCslJsonObject;
+            /* eslint-enable indent */
+        } catch (error) {
+            if (this.options.logErrors) process.stderr.write(this.errorTemplate(error as Error));
+            return { id: uid(), identifier: pmcid, type: "PMCID", status: "failed" };
+        }
+    }
+
+    /**
+     * Retrieves CSL-JSON data for a given PMID.
+     * @param {string} pmid - The PMID to fetch data for.
+     * @returns {Promise<CSLJsonResponse>} The response object with citation data.
+     */
+    public async fromPMID(pmid: string): Promise<CSLJsonResponse> {
+        /* eslint-disable indent */
+        try {
+            const response = await fetch(
+                `${this.CORS_PROXY}https://api.ncbi.nlm.nih.gov/lit/ctxp/v1/pubmed/?format=csl&id=${pmid}`
+            );
+
+            const data: CSLJson = await response.json();
+
+            if ("status" in data && data.status === "error") {
+                throw new Error(
+                    `Unable to retrieve data for PMID "${pmid}". API responded with: ${JSON.stringify(data)}`
+                );
+            }
+
+            let newCslJsonObject;
+
+            if (data?.DOI) {
+                newCslJsonObject = await this.fromDOI(data.DOI);
+            } else {
+                newCslJsonObject = {
+                    id: uid(),
+                    URL: data?.URL,
+                    ISSN: data?.ISSN,
+                    "container-title": data?.["container-title"],
+                    issue: data?.issue,
+                    issued: data?.issued,
+                    page: data?.page,
+                    "publisher-place": data?.["publisher-place"],
+                    source: data?.source,
+                    title: data?.title,
+                    type: data?.type,
+                    volume: data?.volume,
+                    accessed: this.createDateObject(new Date()),
+                    author: data?.author,
+                };
+            }
+
+            this.cslJson.push(newCslJsonObject);
+            return newCslJsonObject;
+            /* eslint-enable indent */
+        } catch (error) {
+            if (this.options.logErrors) process.stderr.write(this.errorTemplate(error as Error));
+            return { id: uid(), identifier: pmid, type: "PMID", status: "failed" };
+        }
+    }
+
+    /**
+     * Generates a formatted bibliography from the CSL-JSON data.
+     * @param {ToBibliographyOptions} options - The style, locale, and format for formatting.
+     * @returns {string | null} The formatted bibliography string or null if an error occurs.
+     */
+    public toBibliography(options: ToBibliographyOptions): string | null {
+        const { style = "apa", locale = "en-US", format = "text" } = options;
+
+        try {
+            const citations: Record<string, CSLJson> = {};
+            const itemIDs: string[] = [];
+            for (let i = 0, length = this.cslJson.length; i < length; i += 1) {
+                const item = this.cslJson[i];
+                const id = item.id;
+                citations[id] = item;
+                itemIDs.push(id);
+            }
+
+            const processorFunctions = {
+                retrieveLocale: () => this.getLocaleFile(locale),
+                retrieveItem: (id: string) => citations[id],
+            };
+
+            const getFormattedCitations = (): string => {
+                const cslFile = this.getCslFile(style);
+                const citeproc = new Citeproc.Engine(processorFunctions, cslFile);
+                citeproc.setOutputFormat(format.toLowerCase());
+                citeproc.updateItems(itemIDs);
+                const references = citeproc.makeBibliography();
+                return references[1].join(format.toLowerCase() === "rtf" ? "\n" : "");
+            };
+
+            return getFormattedCitations();
+        } catch (error) {
+            if (this.options.logErrors) process.stderr.write(this.errorTemplate(error as Error));
+            return null;
+        }
+    }
+}
+
+module.exports = CSLJsonParser;
diff --git a/src/citeease-cli.ts b/src/citeease-cli.ts
new file mode 100644
index 0000000..2c818f8
--- /dev/null
+++ b/src/citeease-cli.ts
@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { HELP_MESSAGE } = require("./common");
+
+process.stdout.write(HELP_MESSAGE);
diff --git a/src/common.ts b/src/common.ts
new file mode 100644
index 0000000..20738a8
--- /dev/null
+++ b/src/common.ts
@@ -0,0 +1,87 @@
+const crypto = require("crypto");
+
+const FONT = {
+    BOLD: "\x1b[1m",
+    GREEN: "\x1b[38;5;48m",
+    YELLOW: "\x1b[38;5;228m",
+    BLUE: "\x1b[38;5;33m",
+    RED: "\x1b[38;5;197m",
+    BLACK: "\x1b[38;5;0m",
+    BG_GREEN: "\x1b[48;5;48m",
+    BG_RED: "\x1b[48;5;9m",
+    RESET: "\x1b[0m",
+};
+
+const RESULT = {
+    SUCCESS: `${FONT.BG_GREEN}${FONT.BOLD}${FONT.BLACK} SUCCESS ${FONT.RESET}`,
+    FAIL: `${FONT.BG_RED}${FONT.BOLD}${FONT.BLACK} FAIL ${FONT.RESET}`,
+    ERROR: `${FONT.BG_RED}${FONT.BOLD}${FONT.BLACK} ERROR ${FONT.RESET}`,
+};
+
+const HELP_MESSAGE = `
+        Usage:
+
+          cite <list of identifiers> [options]
+          cite config <key> [value]
+
+        Description:
+
+          citeease-cli is a CLI tool that generates formatted citations (references) based on various
+          unique identifiers, including URL, DOI, ISBN, PMID, and PMCID.
+          It also allows you to manage configurations for citation style, locale, and output format.
+
+        Commands:
+
+          --style, -s <style>    Set the citation style (e.g., apa, modern-language-association, chicago-author-date)
+          --locale, -l <locale>  Set the locale for the output (e.g., en-US, fr-FR, ar)
+          --format, -f <format>  Set the output format (e.g., text, html, rtf, asciidoc). Default is "text".
+          --log-errors, -e       Enable logging of errors for debugging purposes
+          --version, -v          Display the current version of citeease-cli
+          config <key> [value]   Configure default settings. Keys: "style", "locale", "format", or "reset".
+
+        Examples:
+
+          cite identifier1 identifier2 identifier3 --locale ar --format html
+          cite id1 id2 -s chicago-author-date -e -f rtf
+          cite identifier --locale fr-FR
+          cite config style ieee      # Set default citation style to IEEE
+          cite config locale es-MX   # Set default locale to es-MX (Spanish - Mexico)
+          cite config reset          # Reset all configurations to defaults
+
+        Notes:
+
+          - Identifiers are processed in the order provided.
+          - Use "--log-errors" to output errors for troubleshooting.
+          - The "config" command allows you to set default configurations or reset them.
+          - Check available citation styles and locales at:
+            - Styles: https://github.com/citation-style-language/styles
+            - Locales: https://github.com/citation-style-language/locales
+
+`;
+
+/**
+ * Generates a unique identifier of a specified length.
+ *
+ * This function creates a unique ID by generating a sequence of characters from a predefined alphabet.
+ * It uses a pool of random bytes to select characters from the alphabet, ensuring uniqueness.
+ *
+ * @param {number} [length=16] - The desired length of the unique ID.
+ * @returns {string} A unique identifier of the specified length.
+ */
+function uid(length: number = 16): string {
+    if (length <= 0) {
+        throw new Error("Length must be a positive number");
+    }
+
+    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+    let result = "";
+    const array = crypto.randomBytes(length);
+
+    for (let i = 0; i < length; i++) {
+        result += chars[array[i] % chars.length];
+    }
+
+    return result;
+}
+
+module.exports = { FONT, RESULT, HELP_MESSAGE, uid };
diff --git a/src/index.ts b/src/index.ts
new file mode 100644
index 0000000..005060a
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+
+import { CSLJson, type CSLJsonResponse } from "./types"; // eslint-disable-line import/no-unresolved
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const CSLJsonParser = require("./CSLJsonParser");
+const pkg = require("../package.json");
+const { FONT, RESULT, HELP_MESSAGE } = require("./common");
+
+type ParsedArguments = {
+    identifiers: string[];
+    style: string;
+    locale: string;
+    format: string;
+    logErrors: boolean;
+    showVersion: boolean;
+};
+
+type IdentifierType = "URL" | "DOI" | "PMCID" | "PMID" | "ISBN" | "undefined";
+
+const configDir = path.join(os.homedir(), ".citease-cli");
+const configFile = path.join(configDir, "config.json");
+
+/**
+ * Ensures the configuration directory exists and retrieves the configuration from the file.
+ * If the configuration file does not exist, it initializes an empty configuration.
+ *
+ * @returns {Record<string, string>} The configuration as a key-value object.
+ */
+function getConfigFile(): Record<string, string> {
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    if (fs.existsSync(configFile)) {
+        try {
+            return JSON.parse(fs.readFileSync(configFile, "utf-8"));
+        } catch (error) {
+            process.stderr.write(
+                `${RESULT.ERROR} ${FONT.RED}Failed to parse configuration file: ${error}${FONT.RESET}\n\n`
+            );
+            process.exit(1);
+        }
+    }
+
+    return {};
+}
+
+/**
+ * Resets the configuration to its default state by clearing the configuration file.
+ */
+function resetConfig(): void {
+    try {
+        fs.writeFileSync(configFile, JSON.stringify({}, null, 2));
+        process.stdout.write(`${FONT.YELLOW}All configurations have been reset to default.${FONT.RESET}\n\n`);
+    } catch (error) {
+        process.stderr.write(`${RESULT.ERROR} ${FONT.RED}Failed to reset configuration: ${error}${FONT.RESET}\n\n`);
+    }
+    process.exit(0);
+}
+
+/**
+ * Updates a configuration key with a specified value, performing validation where necessary.
+ *
+ * @param {Record<string, string>} config - The current configuration object.
+ * @param {string} key - The key to update.
+ * @param {string} value - The value to set.
+ */
+function updateConfig(config: Record<string, string>, key: string, value: string): void {
+    if (key === "format" && !/^(text|html|rtf|asciidoc)$/.test(value)) {
+        process.stderr.write(
+            `${FONT.RED}Invalid format. Allowed formats are: "text", "html", "rtf", or "asciidoc".${FONT.RESET}\n\n`
+        );
+        process.exit(1);
+    }
+
+    config[key] = value;
+
+    try {
+        fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+        process.stdout.write(`${FONT.YELLOW}Configuration updated: ${key} = ${value}${FONT.RESET}\n\n`);
+    } catch (error) {
+        process.stderr.write(`${RESULT.ERROR} ${FONT.RED}Failed to update configuration: ${error}${FONT.RESET}\n\n`);
+    }
+    process.exit(0);
+}
+
+/**
+ * Retrieves and displays the value of a configuration key, or an error if the key is not found.
+ *
+ * @param {Record<string, string>} config - The current configuration object.
+ * @param {string} key - The key to retrieve.
+ */
+function retrieveConfig(config: Record<string, string>, key: string): void {
+    if (config[key]) {
+        process.stdout.write(`${FONT.YELLOW}${key} = ${config[key]}${FONT.RESET}\n\n`);
+    } else {
+        process.stderr.write(`${FONT.RED}Key "${key}" not found.${FONT.RESET}\n\n`);
+    }
+    process.exit(0);
+}
+
+/**
+ * Handles configuration commands passed via the command line. Supports setting, retrieving,
+ * and resetting configuration keys and values.
+ */
+function handleConfig(): void {
+    const config = getConfigFile();
+    const [, , command, key, value, extra] = process.argv;
+
+    /* eslint-disable quotes */
+    const ERROR_USAGE_MESSAGE =
+        `\n${FONT.RED}Invalid usage of the "config" command.\n` +
+        `Usage:\n` +
+        `  cite config <key> <value>  - Set a configuration key to a value.\n` +
+        `  cite config <key>          - Retrieve the value of a configuration key.\n` +
+        `  cite config reset          - Reset all configurations to defaults.${FONT.RESET}\n\n`;
+    /* eslint-enable quotes */
+
+    if (command !== "config") return;
+
+    if (!key || extra || key.startsWith("-") || value?.startsWith("-")) {
+        process.stderr.write(ERROR_USAGE_MESSAGE);
+        process.exit(1);
+    }
+
+    const validKeys = /^(style|locale|format|reset)$/;
+    if (!validKeys.test(key)) {
+        process.stderr.write(
+            `${FONT.RED}Invalid key. Allowed keys are "style", "locale", "format", or "reset".${FONT.RESET}\n\n`
+        );
+        process.exit(1);
+    }
+
+    if (key === "reset") {
+        resetConfig();
+    } else if (value) {
+        updateConfig(config, key, value);
+    } else {
+        retrieveConfig(config, key);
+    }
+}
+
+/**
+ * Creates a loading spinner in the console.
+ * @returns {(message?: string) => void} - A function to stop the spinner and display a completion message.
+ */
+// eslint-disable-next-line no-unused-vars
+function createLoadingSpinner(): (message?: string) => void {
+    const loadingCharacters = "⣾⣽⣻⢿⡿⣟⣯⣷";
+    let index = 0;
+
+    const intervalId = setInterval(() => {
+        process.stdout.write(`\r${loadingCharacters[index]} `);
+        index = (index + 1) % loadingCharacters.length;
+    }, 100);
+
+    return function logDone(message = "Done") {
+        clearInterval(intervalId);
+        process.stdout.write(`\r${message}`);
+    };
+}
+
+/**
+ * Parses command-line arguments to extract identifiers, style, locale, and other options.
+ * @param {string[]} args - Command-line arguments.
+ * @returns {ParsedArguments} - The parsed arguments.
+ */
+function parseArguments(args: string[]): ParsedArguments {
+    const config = getConfigFile();
+
+    const identifiers: string[] = [];
+    let style = config.style || "apa";
+    let locale = config.locale || "en-US";
+    let format = config.format || "text";
+    let logErrors = false;
+    let showVersion = false;
+
+    const regexes = {
+        showVersion: /^-{1,2}v(ersion)?$/,
+        logErrors: /^-{1,2}e(rrors)?$/,
+        style: /^-{1,2}s(tyle)?$/,
+        locale: /^-{1,2}l(ocale)?$/,
+        format: /^-{1,2}f(ormat)?$/,
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        if (regexes.showVersion.test(args[i])) {
+            showVersion = true;
+        } else if (regexes.logErrors.test(args[i])) {
+            logErrors = true;
+        } else if (regexes.style.test(args[i]) && args[i + 1]) {
+            style = args[i + 1];
+            i++;
+        } else if (regexes.locale.test(args[i]) && args[i + 1]) {
+            locale = args[i + 1];
+            i++;
+        } else if (regexes.format.test(args[i]) && args[i + 1]) {
+            format = args[i + 1];
+            i++;
+        } else if (!args[i].startsWith("-")) {
+            identifiers.push(args[i].replace("\\-", "-"));
+        }
+    }
+
+    return { identifiers, style, locale, format, logErrors, showVersion };
+}
+
+/**
+ * Recognizes the type of an identifier based on its format or prefix.
+ * @param {string} input - The identifier to classify.
+ * @returns {[IdentifierType, string]} - The identifier type and the trimmed identifier string.
+ */
+function recognizeIdentifierType(input: string): [IdentifierType, string] {
+    const trimmed = input.trim();
+    const identifierPrefixes = { "url:": "URL", "doi:": "DOI", "pmcid:": "PMCID", "pmid:": "PMID", "isbn:": "ISBN" };
+
+    for (const [prefix, type] of Object.entries(identifierPrefixes)) {
+        if (trimmed.startsWith(prefix)) return [type as IdentifierType, trimmed.slice(prefix.length).trim()];
+    }
+
+    const patterns: Record<IdentifierType, RegExp> = {
+        DOI: /^((https?:\/\/)?(?:dx\.)?doi\.org\/)?10\.\d{4,9}\/[-._;()/:a-zA-Z0-9]+$/,
+        URL: /^(https?:\/\/)[a-zA-Z0-9-._~:/?#[\]@!$&'()*+,;=]+$/,
+        PMCID: /^PMC\d+$/,
+        PMID: /^\d{7,10}$/,
+        ISBN: /^(97[89])\d{9}(\d|X)$/,
+        undefined: /.^/,
+    };
+
+    const cleaned = trimmed.replace(/-/g, "");
+    for (const [type, pattern] of Object.entries(patterns)) {
+        if (pattern.test(cleaned)) return [type as IdentifierType, trimmed];
+    }
+    return ["undefined", trimmed];
+}
+
+/**
+ * Retrieves CSL-JSON content for each identifier.
+ * @param {[IdentifierType, string][]} identifiers - Array of identifier types and values.
+ * @param {boolean} logErrors - Whether to log errors to stderr.
+ * @returns {Promise<CSLJsonResponse[]>} - Array of CSL-JSON responses.
+ */
+async function retrieveContent(
+    identifiers: [IdentifierType, string][],
+    logErrors: boolean
+): Promise<CSLJsonResponse[]> {
+    const parser = new CSLJsonParser([], { logErrors });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-unused-vars
+    const fetchers: Record<IdentifierType, (id: string) => Promise<any>> = {
+        URL: parser.fromURL.bind(parser),
+        DOI: parser.fromDOI.bind(parser),
+        PMCID: parser.fromPMCID.bind(parser),
+        PMID: parser.fromPMID.bind(parser),
+        ISBN: parser.fromISBN.bind(parser),
+        undefined: async () => null,
+    };
+
+    return Promise.all(identifiers.map(([type, id]) => fetchers[type](id)));
+}
+
+/**
+ * Displays a list of identifiers along with a message, using a specified color.
+ * @param {Array<[IdentifierType, string]>} identifiers - Array of identifier types and values.
+ * @param {string} message - The message to display above the identifiers.
+ * @param {string} color - The color code for console output.
+ */
+function displayIdentifiers(identifiers: Array<[IdentifierType, string]>, message: string, color: string = FONT.RESET) {
+    process.stdout.write(
+        `${color + FONT.BOLD}${message}:${FONT.RESET}\n${identifiers.map(([type, id]) => `${color}[${type}]${FONT.RESET} ${id}\n`).join("")}\n`
+    );
+}
+
+/**
+ * Formats CSL-JSON content into a bibliography using a specified style, locale, and format.
+ * @param {CSLJson[]} content - The CSL-JSON content to format.
+ * @param {string} options - The options for formatting.
+ * @returns {string | null} - The formatted bibliography or null if formatting fails.
+ */
+function formatBibliography(
+    content: CSLJson[],
+    options: { style: string; locale: string; format: string; logErrors: boolean }
+): string | null {
+    const { style, locale, format, logErrors } = options;
+    const parser = new CSLJsonParser(content, { logErrors });
+    const references = parser.toBibliography({ style, locale, format });
+    return references
+        ? `${RESULT.SUCCESS} ${FONT.GREEN}Successfully generated references:${FONT.RESET}\n${references}\n`
+        : null;
+}
+
+/**
+ * Main function to execute the script.
+ * Parses arguments, retrieves content, formats bibliography, and displays results.
+ * @returns {Promise<boolean | undefined>} - A promise that resolves when the script completes.
+ */
+async function main(): Promise<boolean | undefined> {
+    const { identifiers, style, locale, format, logErrors, showVersion } = parseArguments(process.argv.slice(2));
+
+    if (showVersion) return process.stdout.write(`${pkg.version}\n`);
+    if (!identifiers.length) return process.stdout.write(HELP_MESSAGE);
+
+    const parsedIdentifiers = identifiers.map(recognizeIdentifierType);
+    const [definedIdentifiers, undefinedIdentifiers] = parsedIdentifiers.reduce(
+        ([defined, nonDefined], id) =>
+            id[0] === "undefined" ? [[...defined], [...nonDefined, id]] : [[...defined, id], [...nonDefined]],
+        [[], []] as [[IdentifierType, string][], [IdentifierType, string][]]
+    );
+
+    if (undefinedIdentifiers.length) displayIdentifiers(undefinedIdentifiers, "Unable to determine the type", FONT.RED);
+    if (!definedIdentifiers.length) return;
+
+    displayIdentifiers(definedIdentifiers, "Retrieving data", FONT.BLUE);
+
+    const logDone = createLoadingSpinner();
+    const contentArray = (await retrieveContent(definedIdentifiers, logErrors)).filter(
+        (content): content is CSLJsonResponse => content != null
+    );
+    logDone("");
+
+    const [failed, successful] = contentArray.reduce(
+        ([failures, successes], content) =>
+            "status" in content && content?.status === "failed"
+                ? [[...failures, content], successes]
+                : [failures, [...successes, content]],
+        [[], []] as [Array<{ type: IdentifierType; identifier: string }>, CSLJsonResponse[]]
+    );
+
+    if (failed.length) {
+        displayIdentifiers(
+            failed.map(({ type, identifier }) => [type, identifier]),
+            "Failed to retrieve",
+            FONT.RED
+        );
+    }
+
+    if (successful.length) {
+        const bibliography = formatBibliography(successful, { style, locale, format, logErrors });
+        bibliography
+            ? process.stdout.write(bibliography)
+            : process.stdout.write(`${RESULT.FAIL} ${FONT.RED}Failed to format references!${FONT.RESET}\n\n`);
+    }
+}
+
+handleConfig();
+main();
diff --git a/src/types.ts b/src/types.ts
new file mode 100644
index 0000000..3f34bf7
--- /dev/null
+++ b/src/types.ts
@@ -0,0 +1,35 @@
+export type DateObject = { "date-parts": Array<number[]> };
+
+export type CSLJson = {
+    id: string;
+    DOI?: string;
+    URL?: string;
+    ISSN?: string[];
+    ISBN?: string;
+    PMID?: string;
+    PMCID?: string;
+    "container-title"?: string;
+    issue?: string;
+    issued?: DateObject;
+    page?: string;
+    "number-of-pages"?: number;
+    "publisher-place"?: string;
+    source?: string;
+    title?: string;
+    volume?: string;
+    type?: string;
+    accessed?: DateObject;
+    publisher?: string;
+    author?: Array<{ given: string; family: string }>;
+    locator?: string;
+    label?: string;
+};
+
+export type FailedCSLJson = {
+    id: string;
+    identifier: string;
+    type: "DOI" | "ISBN" | "URL" | "PMID" | "PMCID";
+    status: "failed";
+};
+
+export type CSLJsonResponse = CSLJson | FailedCSLJson;
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..37709ea
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "CommonJS",
+        "outDir": "dist",
+        "rootDir": "src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "declaration": true,
+        "allowJs": true,
+        "moduleDetection": "force",
+        "sourceMap": true
+    },
+    "include": ["src/**/*.ts"],
+    "exclude": ["node_modules", "dist"]
+}