@content-reviewer/cli 0.0.1

package/README.md

@@ -0,0 +1,111 @@
+# @content-reviewer/cli
+
+CLI tool for reviewing written content using LLMs.
+
+## Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g @content-reviewer/cli
+```
+
+### Using npx (No Installation Required)
+
+```bash
+npx @content-reviewer/cli article.md
+```
+
+## Quick Start
+
+### 1. Set up your API key
+
+Set environment variables in your shell:
+
+```bash
+# For OpenAI (default)
+export OPENAI_API_KEY="sk-..."
+
+# For Anthropic Claude
+export ANTHROPIC_API_KEY="sk-ant-..."
+
+# For Google
+export GOOGLE_API_KEY="..."
+```
+
+Alternatively, pass the API key directly using the `--api-key` option:
+
+```bash
+content-review article.md --api-key "sk-..."
+```
+
+### 2. Review your content
+
+```bash
+content-review article.md
+```
+
+## Usage
+
+```bash
+content-review -h
+```
+
+### Examples
+
+```bash
+# Review in Japanese
+content-review article.md --language ja
+
+# Use Anthropic Claude
+content-review article.md --provider anthropic --model claude-sonnet-4-5
+
+# Use custom configuration
+content-review article.md -c .reviewrc.json
+
+# Save results to JSON file
+content-review article.md -o review-results.json
+```
+
+## Configuration
+
+Create a `.reviewrc.json` file in your project root:
+
+```json
+{
+  "language": "en",
+  "llm": {
+    "provider": "openai",
+    "model": "gpt-4.1-mini"
+  }
+}
+```
+
+### Custom Instruction (Persona & Guidelines)
+
+You can use a text file (such as a Markdown file) for review instructions, defining the reviewer's persona and specific guidelines:
+
+```bash
+content-review article.md --instruction ./my-instruction.md
+```
+
+Or via config file:
+
+```json
+{
+  "instructionFile": "./my-instruction.md",
+  "language": "en"
+}
+```
+
+Example instruction file:
+
+```markdown
+You are a strict technical editor.
+Please review the following text for technical accuracy and clarity.
+
+# Review Guidelines
+
+- Ensure all code examples are correct.
+- Check for passive voice usage.
+```

package/dist/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 atkei
+
+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.

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/review.ts
+var import_path2 = require("path");
+var import_promises3 = require("fs/promises");
+var import_core2 = require("@content-reviewer/core");
+var import_consola2 = require("consola");
+
+// src/config-loader.ts
+var import_path = require("path");
+var import_promises = require("fs/promises");
+var import_cosmiconfig = require("cosmiconfig");
+var import_core = require("@content-reviewer/core");
+var import_consola = require("consola");
+
+// package.json
+var package_default = {
+  name: "@content-reviewer/cli",
+  version: "0.0.1",
+  description: "CLI tool for reviewing written content using LLMs",
+  bin: {
+    "content-review": "./dist/index.js"
+  },
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup src/index.ts --format cjs --dts --clean",
+    dev: "tsup src/index.ts --format cjs --dts --watch",
+    test: "vitest run",
+    clean: "rm -rf dist"
+  },
+  keywords: [
+    "ai",
+    "llm",
+    "markdown",
+    "proofreading",
+    "content-review",
+    "cli"
+  ],
+  author: "atkei",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/atkei/content-reviewer.git",
+    directory: "packages/cli"
+  },
+  homepage: "https://github.com/atkei/content-reviewer#readme",
+  bugs: {
+    url: "https://github.com/atkei/content-reviewer/issues"
+  },
+  engines: {
+    node: ">=20.0.0",
+    pnpm: ">=9.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  dependencies: {
+    "@content-reviewer/core": "workspace:*",
+    commander: "^14.0.2",
+    consola: "^3.4.2",
+    cosmiconfig: "^9.0.0",
+    picocolors: "^1.1.1"
+  },
+  devDependencies: {
+    "@types/node": "^24.10.1",
+    tsup: "^8.5.1",
+    typescript: "^5.9.3",
+    vitest: "^4.0.9"
+  }
+};
+
+// src/constants.ts
+var PROGRAM_NAME = "content-review";
+var PROGRAM_DESCRIPTION = package_default.description;
+var PROGRAM_VERSION = package_default.version;
+var CONFIG_MODULE_NAME = "reviewrc";
+var EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1
+};
+
+// src/config-loader.ts
+async function loadConfiguration(options) {
+  let fileConfig = {};
+  let configDir = process.cwd();
+  if (options.config && typeof options.config === "string") {
+    const configPath = (0, import_path.resolve)(process.cwd(), options.config);
+    try {
+      const explorer = (0, import_cosmiconfig.cosmiconfig)(CONFIG_MODULE_NAME);
+      const result = await explorer.load(configPath);
+      if (result) {
+        fileConfig = result.config;
+        configDir = (0, import_path.dirname)(result.filepath);
+      }
+    } catch (error) {
+      import_consola.consola.warn(
+        `Failed to load config file: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  } else {
+    try {
+      const explorer = (0, import_cosmiconfig.cosmiconfig)(CONFIG_MODULE_NAME);
+      const result = await explorer.search();
+      if (result) {
+        fileConfig = result.config;
+        configDir = (0, import_path.dirname)(result.filepath);
+        import_consola.consola.success(`Loaded config from: ${result.filepath}`);
+      }
+    } catch {
+    }
+  }
+  let instructionContent;
+  if (options.instruction && typeof options.instruction === "string") {
+    try {
+      const instructionPath = (0, import_path.resolve)(process.cwd(), options.instruction);
+      instructionContent = await (0, import_promises.readFile)(instructionPath, "utf-8");
+      import_consola.consola.success(`Loaded instruction from: ${instructionPath}`);
+    } catch (error) {
+      import_consola.consola.warn(
+        `Failed to load instruction file: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  } else if (fileConfig.instructionFile) {
+    try {
+      const instructionPath = (0, import_path.resolve)(configDir, fileConfig.instructionFile);
+      instructionContent = await (0, import_promises.readFile)(instructionPath, "utf-8");
+      import_consola.consola.success(`Loaded instruction from: ${instructionPath}`);
+    } catch (error) {
+      import_consola.consola.warn(
+        `Failed to load instruction file from config: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const config = (0, import_core.createReviewConfig)({
+    ...fileConfig,
+    instruction: instructionContent,
+    language: options.language ?? fileConfig.language,
+    llm: {
+      ...fileConfig.llm,
+      provider: options.provider ?? fileConfig.llm?.provider,
+      apiKey: options.apiKey ?? fileConfig.llm?.apiKey,
+      model: options.model ?? fileConfig.llm?.model
+    }
+  });
+  (0, import_core.validateConfig)(config);
+  return config;
+}
+
+// src/document.ts
+var import_promises2 = require("fs/promises");
+async function readDocument(filePath) {
+  try {
+    const rawContent = await (0, import_promises2.readFile)(filePath, "utf-8");
+    return {
+      rawContent,
+      source: filePath
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// src/utils.ts
+var import_picocolors = __toESM(require("picocolors"));
+function formatReviewResult(result) {
+  let output = "";
+  output += `${import_picocolors.default.bold(`Review Result: ${result.source}`)}
+
+`;
+  output += `${import_picocolors.default.bold("Summary:")}
+`;
+  output += `${result.summary}
+
+`;
+  if (result.issues.length === 0) {
+    output += `${import_picocolors.default.green("\u2713 No issues found!")}
+`;
+  } else {
+    output += `${import_picocolors.default.bold(`Issues (${result.issues.length}):`)}
+
+`;
+    result.issues.forEach((issue, index) => {
+      output += formatIssue(issue, index + 1);
+    });
+  }
+  return output;
+}
+function formatIssue(issue, index) {
+  const severityIcon = getSeverityIcon(issue.severity);
+  const severityColorFn = getSeverityColorFn(issue.severity);
+  let output = `${import_picocolors.default.bold(`${index}.`)} `;
+  output += `${severityColorFn(`${severityIcon} ${issue.severity.toUpperCase()}`)}
+`;
+  if (issue.lineNumber) {
+    output += `   ${import_picocolors.default.gray(`Line ${issue.lineNumber}:`)} `;
+  } else {
+    output += `   `;
+  }
+  output += `${issue.message}
+`;
+  if (issue.matchText) {
+    output += `   ${import_picocolors.default.gray(`Snippet: "${issue.matchText}"`)}
+`;
+  }
+  if (issue.suggestion) {
+    output += `   ${import_picocolors.default.cyan("\u{1F4A1} Suggestion:")} ${issue.suggestion}
+`;
+  }
+  output += "\n";
+  return output;
+}
+function getSeverityIcon(severity) {
+  switch (severity) {
+    case "error":
+      return "\u2717";
+    case "warning":
+      return "\u26A0";
+    case "suggestion":
+      return "\u{1F4A1}";
+    default:
+      return "\u2022";
+  }
+}
+function getSeverityColorFn(severity) {
+  switch (severity) {
+    case "error":
+      return import_picocolors.default.red;
+    case "warning":
+      return import_picocolors.default.yellow;
+    case "suggestion":
+      return import_picocolors.default.cyan;
+    default:
+      return (text) => text;
+  }
+}
+function formatReviewResultJSON(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+// src/commands/review.ts
+async function handleReviewAction(file, options) {
+  try {
+    const filePath = (0, import_path2.resolve)(process.cwd(), file);
+    const config = await loadConfiguration(options);
+    if (options.dryRun) {
+      import_consola2.consola.info("Dry Run: Configuration Preview");
+      import_consola2.consola.log(`Target File: ${filePath}`);
+      import_consola2.consola.log(`Model: ${config.llm.model} (${config.llm.provider})`);
+      import_consola2.consola.log(`Language: ${config.language}`);
+      import_consola2.consola.log("\n[Applied Instructions]");
+      if (config.instruction) {
+        import_consola2.consola.log(config.instruction);
+      } else {
+        const defaultInstruction = config.language === "ja" ? import_core2.DEFAULT_INSTRUCTION_JA : import_core2.DEFAULT_INSTRUCTION_EN;
+        import_consola2.consola.log(defaultInstruction);
+        import_consola2.consola.log("\n(Note: These are the default instructions for the selected language)");
+      }
+      import_consola2.consola.info("End of Preview");
+      process.exit(EXIT_CODES.SUCCESS);
+    }
+    (0, import_core2.resolveApiKey)(config);
+    import_consola2.consola.start(`Reading document: ${filePath}`);
+    const document = await readDocument(filePath);
+    import_consola2.consola.success(`Document read successfully`);
+    import_consola2.consola.start("Initializing AI reviewer...");
+    const reviewer = new import_core2.ContentReviewer(config);
+    import_consola2.consola.start("Reviewing content (this may take a moment)...");
+    const result = await reviewer.review(document);
+    if (options.json) {
+      import_consola2.consola.log(formatReviewResultJSON(result));
+    } else {
+      import_consola2.consola.log(formatReviewResult(result));
+    }
+    if (options.output && typeof options.output === "string") {
+      const outputPath = (0, import_path2.resolve)(process.cwd(), options.output);
+      await (0, import_promises3.writeFile)(outputPath, formatReviewResultJSON(result), "utf-8");
+      import_consola2.consola.success(`Results saved to: ${outputPath}`);
+    }
+    const hasErrors = result.issues.some((issue) => issue.severity === "error");
+    process.exit(hasErrors ? EXIT_CODES.ERROR : EXIT_CODES.SUCCESS);
+  } catch (error) {
+    import_consola2.consola.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(EXIT_CODES.ERROR);
+  }
+}
+
+// src/options.ts
+var import_core3 = require("@content-reviewer/core");
+var CLI_OPTIONS = {
+  CONFIG: {
+    flag: "-c, --config <path>",
+    description: "path to review configuration file"
+  },
+  INSTRUCTION: {
+    flag: "-i, --instruction <path>",
+    description: "path to review instruction file"
+  },
+  OUTPUT: {
+    flag: "-o, --output <path>",
+    description: "output review result file path (JSON format)"
+  },
+  LANGUAGE: {
+    flag: "-l, --language <lang>",
+    description: "review language (ja, en)",
+    defaultValue: import_core3.DEFAULT_CONFIG.language
+  },
+  API_KEY: {
+    flag: "--api-key <key>",
+    description: "LLM provider API key",
+    envVar: `${import_core3.ENV_VARS.OPENAI_API_KEY}, ${import_core3.ENV_VARS.ANTHROPIC_API_KEY}, or ${import_core3.ENV_VARS.GOOGLE_API_KEY}`
+  },
+  MODEL: {
+    flag: "--model <model>",
+    description: "LLM model to use",
+    defaultValue: Object.entries(import_core3.PROVIDER_DEFAULT_MODELS).map(([p, m]) => `${m} (${p})`).join(", ")
+  },
+  PROVIDER: {
+    flag: "--provider <provider>",
+    description: "LLM provider (openai, anthropic, google)",
+    defaultValue: import_core3.DEFAULT_LLM_CONFIG.provider
+  },
+  JSON: {
+    flag: "--json",
+    description: "output review result in JSON format (to stdout)",
+    defaultValue: false
+  },
+  DRY_RUN: {
+    flag: "--dry-run",
+    description: "display configuration and instructions without running review",
+    defaultValue: false
+  }
+};
+function getOptionDescription(option) {
+  let desc = option.description;
+  if (option.envVar) {
+    desc += ` (alternatively use ${option.envVar} env var)`;
+  }
+  if (option.defaultValue !== void 0) {
+    desc += ` (default: ${option.defaultValue})`;
+  }
+  return desc;
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name(PROGRAM_NAME).description(PROGRAM_DESCRIPTION).version(PROGRAM_VERSION);
+program.argument("<file>", "File to review").option(CLI_OPTIONS.CONFIG.flag, getOptionDescription(CLI_OPTIONS.CONFIG)).option(CLI_OPTIONS.INSTRUCTION.flag, getOptionDescription(CLI_OPTIONS.INSTRUCTION)).option(CLI_OPTIONS.OUTPUT.flag, getOptionDescription(CLI_OPTIONS.OUTPUT)).option(CLI_OPTIONS.LANGUAGE.flag, getOptionDescription(CLI_OPTIONS.LANGUAGE)).option(CLI_OPTIONS.PROVIDER.flag, getOptionDescription(CLI_OPTIONS.PROVIDER)).option(CLI_OPTIONS.MODEL.flag, getOptionDescription(CLI_OPTIONS.MODEL)).option(CLI_OPTIONS.API_KEY.flag, getOptionDescription(CLI_OPTIONS.API_KEY)).option(CLI_OPTIONS.JSON.flag, getOptionDescription(CLI_OPTIONS.JSON)).option(CLI_OPTIONS.DRY_RUN.flag, getOptionDescription(CLI_OPTIONS.DRY_RUN)).action(handleReviewAction);
+program.parse();

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@content-reviewer/cli",
+  "version": "0.0.1",
+  "description": "CLI tool for reviewing written content using LLMs",
+  "bin": {
+    "content-review": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --dts --clean",
+    "dev": "tsup src/index.ts --format cjs --dts --watch",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "markdown",
+    "proofreading",
+    "content-review",
+    "cli"
+  ],
+  "author": "atkei",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atkei/content-reviewer.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/atkei/content-reviewer#readme",
+  "bugs": {
+    "url": "https://github.com/atkei/content-reviewer/issues"
+  },
+  "engines": {
+    "node": ">=20.0.0",
+    "pnpm": ">=9.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@content-reviewer/core": "workspace:*",
+    "commander": "^14.0.2",
+    "consola": "^3.4.2",
+    "cosmiconfig": "^9.0.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.9"
+  }
+}