@leeguoo/zentao-mcp 0.4.0 → 0.5.0

package/src/commands/products.js

@@ -0,0 +1,27 @@
+import process from "node:process";
+import { extractCommand, hasHelpFlag, parseCliArgs } from "../cli/args.js";
+import { createClientFromCli } from "../zentao/client.js";
+
+function printHelp() {
+  process.stdout.write(`zentao-mcp products list\n\n`);
+  process.stdout.write(`Usage:\n`);
+  process.stdout.write(`  zentao-mcp products list [--page N] [--limit N] [--json]\n`);
+}
+
+export async function runProducts({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printHelp();
+    return;
+  }
+
+  const { command: sub, argv: argvWithoutSub } = extractCommand(argv);
+  if (sub !== "list") throw new Error(`Unknown products subcommand: ${sub || "(missing)"}`);
+
+  const cliArgs = parseCliArgs(argvWithoutSub);
+  const api = createClientFromCli({ argv: argvWithoutSub, env });
+  const result = await api.listProducts({
+    page: cliArgs.page,
+    limit: cliArgs.limit,
+  });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}

package/src/commands/release.js

@@ -0,0 +1,198 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import readline from "node:readline";
+import { spawnSync } from "node:child_process";
+import { extractCommand, hasHelpFlag, parseCliArgs } from "../cli/args.js";
+import { printReleaseHelp } from "../cli/help.js";
+
+function run(cmd, args, { cwd, env, dryRun } = {}) {
+  const printable = [cmd, ...args].join(" ");
+  if (dryRun) {
+    process.stdout.write(`[dry-run] ${printable}\n`);
+    return { status: 0 };
+  }
+  const res = spawnSync(cmd, args, {
+    cwd,
+    env,
+    stdio: "inherit",
+  });
+  if (res.status !== 0) {
+    const error = new Error(`Command failed (${res.status}): ${printable}`);
+    error.exitCode = res.status || 1;
+    throw error;
+  }
+  return res;
+}
+
+function commandExists(name) {
+  if (process.platform === "win32") {
+    const res = spawnSync("where", [name], { stdio: "ignore" });
+    return res.status === 0;
+  }
+  const res = spawnSync("sh", ["-lc", `command -v ${name}`], {
+    stdio: "ignore",
+  });
+  return res.status === 0;
+}
+
+async function confirm(question, { yes }) {
+  if (yes) return true;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question(`${question} (y/n) `, (value) => resolve(value));
+    });
+    return String(answer).trim().toLowerCase().startsWith("y");
+  } finally {
+    rl.close();
+  }
+}
+
+function readPackageVersion(repoRoot) {
+  const pkgPath = path.join(repoRoot, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  return String(pkg.version || "0.0.0");
+}
+
+function extractChangelogNotes(repoRoot, version) {
+  const changelogPath = path.join(repoRoot, "CHANGELOG.md");
+  if (!fs.existsSync(changelogPath)) return `Release v${version}`;
+  const text = fs.readFileSync(changelogPath, "utf8");
+  const start = text.match(new RegExp(`^## \\s*\\[?${version.replace(/\./g, "\\.")}\\]?\\s*$`, "m"));
+  if (!start) return `Release v${version}`;
+  const startIndex = start.index ?? 0;
+  const rest = text.slice(startIndex);
+  const next = rest.slice(1).match(/^##\s/m);
+  const endIndex = next ? startIndex + 1 + (next.index ?? 0) : text.length;
+  return text.slice(startIndex, endIndex).trim();
+}
+
+function gitHasUncommittedChanges(repoRoot) {
+  const res = spawnSync("git", ["diff-index", "--quiet", "HEAD", "--"], {
+    cwd: repoRoot,
+    stdio: "ignore",
+  });
+  return res.status !== 0;
+}
+
+function ensureGitRepo(repoRoot) {
+  const res = spawnSync("git", ["rev-parse", "--git-dir"], { cwd: repoRoot, stdio: "ignore" });
+  if (res.status !== 0) {
+    throw new Error("Not a git repo. Please run this command from a git repository.");
+  }
+}
+
+function ensureDependencies() {
+  const missing = [];
+  for (const cmd of ["git", "npm", "gh"]) {
+    if (!commandExists(cmd)) missing.push(cmd);
+  }
+  if (missing.length) {
+    throw new Error(`Missing required tools: ${missing.join(", ")}`);
+  }
+}
+
+export async function runRelease({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printReleaseHelp();
+    return;
+  }
+
+  const { command: versionTypeRaw, argv: argvWithoutVersionType } = extractCommand(argv);
+  const versionType = versionTypeRaw || "patch";
+  const cliArgs = parseCliArgs(argvWithoutVersionType);
+  const repoRoot = process.cwd();
+
+  const dryRun = Boolean(cliArgs["dry-run"]);
+  const yes = Boolean(cliArgs.yes);
+  const skipPush = Boolean(cliArgs["skip-push"]);
+  const skipGithubRelease = Boolean(cliArgs["skip-github-release"]);
+  const skipPublish = Boolean(cliArgs["skip-publish"]);
+
+  if (!new Set(["patch", "minor", "major"]).has(versionType)) {
+    throw new Error(`Invalid version type: ${versionType}`);
+  }
+
+  ensureDependencies();
+  ensureGitRepo(repoRoot);
+
+  if (gitHasUncommittedChanges(repoRoot)) {
+    const ok = await confirm("Warning: uncommitted changes. Continue?", { yes });
+    if (!ok) return;
+  }
+
+  const currentVersion = readPackageVersion(repoRoot);
+  process.stdout.write(`Current version: ${currentVersion}\n`);
+  run("npm", ["version", versionType, "--no-git-tag-version"], { cwd: repoRoot, env, dryRun });
+  const newVersion = readPackageVersion(repoRoot);
+  process.stdout.write(`New version: ${newVersion}\n`);
+
+  run("git", ["add", "package.json"], { cwd: repoRoot, env, dryRun });
+  try {
+    run("git", ["commit", "-m", `chore: bump version to ${newVersion}`], { cwd: repoRoot, env, dryRun });
+  } catch (error) {
+    if (!/nothing to commit/i.test(String(error.message || ""))) throw error;
+  }
+
+  run("git", ["tag", "-a", `v${newVersion}`, "-m", `Release v${newVersion}`], {
+    cwd: repoRoot,
+    env,
+    dryRun,
+  });
+
+  if (!skipPush) {
+    const pushAttempts = [
+      ["push", "origin", "main"],
+      ["push", "origin", "master"],
+      ["push"],
+    ];
+    let pushed = false;
+    for (const args of pushAttempts) {
+      try {
+        run("git", args, { cwd: repoRoot, env, dryRun });
+        pushed = true;
+        break;
+      } catch (error) {
+        if (dryRun) {
+          pushed = true;
+          break;
+        }
+      }
+    }
+    if (!pushed && !dryRun) {
+      throw new Error("Failed to push branch.");
+    }
+    run("git", ["push", "origin", `v${newVersion}`], { cwd: repoRoot, env, dryRun });
+  }
+
+  if (!skipGithubRelease) {
+    const notes = extractChangelogNotes(repoRoot, newVersion);
+    run(
+      "gh",
+      [
+        "release",
+        "create",
+        `v${newVersion}`,
+        "--title",
+        `v${newVersion}`,
+        "--notes",
+        notes,
+        "--latest",
+      ],
+      { cwd: repoRoot, env, dryRun }
+    );
+  }
+
+  if (!skipPublish) {
+    const whoami = spawnSync("npm", ["whoami"], { cwd: repoRoot, stdio: "ignore" });
+    if (whoami.status !== 0) {
+      const ok = await confirm("Warning: not logged into npm. Run npm login now?", { yes });
+      if (!ok) return;
+      run("npm", ["login"], { cwd: repoRoot, env, dryRun });
+    }
+    run("npm", ["publish", "--access", "public"], { cwd: repoRoot, env, dryRun });
+  }
+
+  process.stdout.write(`Release done: v${newVersion}\n`);
+}

package/src/commands/selftest.js

@@ -0,0 +1,52 @@
+import process from "node:process";
+import { getOption, hasHelpFlag, parseCliArgs } from "../cli/args.js";
+import { printSelfTestHelp } from "../cli/help.js";
+import { createClientFromCli } from "../zentao/client.js";
+
+export async function runSelfTest({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printSelfTestHelp();
+    return;
+  }
+
+  const cliArgs = parseCliArgs(argv);
+  const baseUrl = getOption(cliArgs, env, "ZENTAO_URL", "zentao-url");
+  const account = getOption(cliArgs, env, "ZENTAO_ACCOUNT", "zentao-account");
+  const password = getOption(cliArgs, env, "ZENTAO_PASSWORD", "zentao-password");
+  const expectedRaw = cliArgs.expected ?? null;
+  const expected = expectedRaw === null ? null : Number(expectedRaw);
+
+  if (!baseUrl || !account || !password) {
+    throw new Error("Missing ZENTAO_URL/ZENTAO_ACCOUNT/ZENTAO_PASSWORD (or CLI args). ");
+  }
+
+  const api = createClientFromCli({ argv, env });
+  const result = await api.bugsMine({
+    scope: "assigned",
+    status: "active",
+    includeDetails: false,
+  });
+
+  if (result.status !== 1) {
+    const error = new Error(`API error: ${JSON.stringify(result)}`);
+    error.exitCode = 1;
+    throw error;
+  }
+
+  const total = result.result?.total ?? 0;
+  process.stdout.write(`assigned active bugs: ${total}\n`);
+
+  const products = result.result?.products ?? [];
+  if (Array.isArray(products) && products.length) {
+    const summary = products.map((item) => `${item.name}(${item.myBugs})`).join(", ");
+    process.stdout.write(`products: ${summary}\n`);
+  }
+
+  if (Number.isFinite(expected) && expected !== null) {
+    if (total !== expected) {
+      const error = new Error(`Expected ${expected}, got ${total}.`);
+      error.exitCode = 2;
+      throw error;
+    }
+  }
+}

package/src/commands/whoami.js

@@ -0,0 +1,32 @@
+import process from "node:process";
+import { hasHelpFlag } from "../cli/args.js";
+import { loadConfig } from "../config/store.js";
+import { ZentaoClient, createClientFromCli } from "../zentao/client.js";
+
+function printHelp() {
+  process.stdout.write(`zentao whoami - show current account\n\n`);
+  process.stdout.write(`Usage:\n`);
+  process.stdout.write(`  zentao whoami\n`);
+  process.stdout.write(`\n`);
+  process.stdout.write(`Reads credentials from flags/env, falling back to saved login config.\n`);
+}
+
+export async function runWhoami({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printHelp();
+    return;
+  }
+
+  const stored = loadConfig({ env }) || null;
+  const client = createClientFromCli({ argv, env });
+
+  // Best-effort verification: ensure token can be fetched.
+  await client.ensureToken();
+
+  const account = client.account;
+  const baseUrl = client.baseUrl;
+  process.stdout.write(`${account}\n`);
+  if (stored && (stored.zentaoUrl || stored.zentaoAccount)) {
+    process.stdout.write(`url: ${baseUrl}\n`);
+  }
+}

package/src/config/store.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+function escapeTomlString(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\"/g, "\\\"");
+}
+
+function unescapeTomlString(value) {
+  return String(value)
+    .replace(/\\n/g, "\n")
+    .replace(/\\\"/g, '"')
+    .replace(/\\\\/g, "\\");
+}
+
+function parseToml(text) {
+  const out = {};
+  const lines = String(text).split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("#")) continue;
+    if (line.startsWith("[")) continue;
+
+    const idx = line.indexOf("=");
+    if (idx === -1) continue;
+
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = unescapeTomlString(value.slice(1, -1));
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+
+    if (key) out[key] = value;
+  }
+  return out;
+}
+
+function toToml(config) {
+  const lines = [];
+  lines.push('# zentao CLI config');
+  lines.push('# WARNING: stored as plaintext');
+  if (config.zentaoUrl) lines.push(`zentaoUrl = "${escapeTomlString(config.zentaoUrl)}"`);
+  if (config.zentaoAccount) lines.push(`zentaoAccount = "${escapeTomlString(config.zentaoAccount)}"`);
+  if (config.zentaoPassword) lines.push(`zentaoPassword = "${escapeTomlString(config.zentaoPassword)}"`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+function getConfigDir(env) {
+  const xdg = env.XDG_CONFIG_HOME;
+  if (xdg) return xdg;
+  const home = os.homedir();
+  return path.join(home, ".config");
+}
+
+export function getConfigPath({ env = process.env } = {}) {
+  return path.join(getConfigDir(env), "zentao", "config.toml");
+}
+
+export function loadConfig({ env = process.env } = {}) {
+  const filePath = getConfigPath({ env });
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const data = parseToml(raw);
+    if (!data || typeof data !== "object") return null;
+    return data;
+  } catch (error) {
+    return null;
+  }
+}
+
+export function saveConfig(config, { env = process.env } = {}) {
+  const filePath = getConfigPath({ env });
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, toToml(config), "utf8");
+  return filePath;
+}