oh-aicoding-tool 0.1.0

package/opencode-ohai-report/bin/cli.js

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf8"));
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    if (!raw.startsWith("--")) {
+      args._.push(raw);
+      continue;
+    }
+    const eq = raw.indexOf("=");
+    if (eq !== -1) {
+      args[raw.slice(2, eq)] = raw.slice(eq + 1);
+      continue;
+    }
+    const key = raw.slice(2);
+    const next = argv[i + 1];
+    if (next && !next.startsWith("--") && ["email"].includes(key)) {
+      args[key] = next;
+      i += 1;
+    } else {
+      args[key] = true;
+    }
+  }
+  return args;
+}
+
+function configHome() {
+  const xdg = (process.env.XDG_CONFIG_HOME || "").trim();
+  if (xdg) return xdg;
+  return path.join(os.homedir(), ".config");
+}
+
+function opencodeConfigDir() {
+  return path.join(configHome(), "opencode");
+}
+
+function runtimeRoot() {
+  return path.join(configHome(), "ohai-report", "runtime");
+}
+
+function runtimeCliPath() {
+  return path.join(runtimeRoot(), "tools", "ohai-report", "ohai_report.py");
+}
+
+function sourceCliPath() {
+  return path.join(rootDir, "tools", "ohai-report", "ohai_report.py");
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) return;
+  ensureDir(dest);
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === "__pycache__" || entry.name === ".git" || entry.name === ".ohai-report") continue;
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+function installRuntime({ dryRun }) {
+  const dest = runtimeRoot();
+  const copies = [
+    [".opencode", ".opencode"],
+    [".claude", ".claude"],
+    ["scripts", "scripts"],
+    [path.join("tools", "ohai-report"), path.join("tools", "ohai-report")],
+  ];
+  if (dryRun) {
+    console.log(`[dry-run] copy package runtime -> ${dest}`);
+    return dest;
+  }
+  for (const [srcRel, destRel] of copies) {
+    copyDir(path.join(rootDir, srcRel), path.join(dest, destRel));
+  }
+  return dest;
+}
+
+function readJsonIfExists(p) {
+  if (!fs.existsSync(p)) return null;
+  const raw = fs.readFileSync(p, "utf8").replace(/^\uFEFF/, "");
+  if (!raw.trim()) return null;
+  return JSON.parse(raw);
+}
+
+function writeJson(p, obj) {
+  ensureDir(path.dirname(p));
+  fs.writeFileSync(p, `${JSON.stringify(obj, null, 2)}${os.EOL}`, "utf8");
+}
+
+function emailIsValid(value) {
+  const t = String(value || "").trim();
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(t);
+}
+
+function readSavedEmail(paths) {
+  for (const p of paths) {
+    try {
+      const obj = readJsonIfExists(p);
+      const email = obj?.user_email || obj?.userEmail;
+      if (emailIsValid(email)) return { email: String(email).trim(), path: p };
+    } catch {
+      // Ignore malformed legacy email files.
+    }
+  }
+  return null;
+}
+
+async function resolveEmail({ label, defaultPaths, destPath, skipEmail, emailArg, dryRun }) {
+  if (skipEmail) return "";
+  if (emailIsValid(emailArg)) return String(emailArg).trim();
+  if (emailArg) throw new Error(`Invalid --email value: ${emailArg}`);
+  const envEmail = process.env.OHAI_INSTALL_USER_EMAIL;
+  if (emailIsValid(envEmail)) return envEmail.trim();
+
+  const saved = readSavedEmail(defaultPaths);
+  const current = saved?.email || "";
+  if (!process.stdin.isTTY) return "";
+
+  console.log("");
+  console.log(`${label} email file: ${saved?.path || destPath}`);
+  console.log(`Current company email: ${current || "(not set)"}`);
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question("Update company email? [y/N] ")).trim().toLowerCase();
+    if (!["y", "yes"].includes(answer)) return "";
+    while (true) {
+      const value = (await rl.question("Company email: ")).trim();
+      if (emailIsValid(value)) return value;
+      console.log("Invalid email. Example: name@company.com");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+function saveEmail(destPath, email, { dryRun }) {
+  if (!email) return;
+  if (dryRun) {
+    console.log(`[dry-run] write ${destPath}`);
+    return;
+  }
+  writeJson(destPath, { user_email: email });
+  console.log(`Saved company email: ${destPath}`);
+}
+
+function psQuote(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function setUserEnv(name, value, { dryRun }) {
+  if (dryRun) {
+    console.log(`[dry-run] set user env ${name}=${value}`);
+    return;
+  }
+  if (process.platform === "win32") {
+    const cmd = `[Environment]::SetEnvironmentVariable(${psQuote(name)}, ${psQuote(value)}, 'User')`;
+    const r = spawnSync("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", cmd], {
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    if (r.status !== 0) throw new Error(`Failed to set user env ${name}`);
+    console.log(`Set user env ${name}=${value}`);
+    return;
+  }
+
+  const envDir = path.join(configHome(), "environment.d");
+  const envFile = path.join(envDir, "99-ohai-report-opencode.conf");
+  ensureDir(envDir);
+  fs.writeFileSync(envFile, `${name}=${value}${os.EOL}`, "utf8");
+  console.log(`Wrote ${envFile}`);
+
+  if (process.platform === "darwin") {
+    const zprofile = path.join(os.homedir(), ".zprofile");
+    const marker = "# oh-ai-report-opencode";
+    const current = fs.existsSync(zprofile) ? fs.readFileSync(zprofile, "utf8") : "";
+    if (!current.includes(marker)) {
+      fs.appendFileSync(zprofile, `${os.EOL}${marker}${os.EOL}export ${name}=${shellQuote(value)}${os.EOL}`, "utf8");
+      console.log(`Appended ${name} to ${zprofile}`);
+    }
+  }
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function mergePluginList(existing, entry) {
+  let list = [];
+  if (Array.isArray(existing)) list = existing.map(String).filter(Boolean);
+  else if (typeof existing === "string" && existing.trim()) list = [existing.trim()];
+  if (!list.includes(entry)) list.push(entry);
+  return list;
+}
+
+function updateOpenCodeConfig({ dryRun }) {
+  const configPath = path.join(opencodeConfigDir(), "opencode.json");
+  const entry = "./plugins/oh-ai-report.ts";
+  if (dryRun) {
+    console.log(`[dry-run] ensure ${configPath} includes plugin ${entry}`);
+    return;
+  }
+  let config = { "$schema": "https://opencode.ai/config.json" };
+  if (fs.existsSync(configPath)) {
+    try {
+      config = readJsonIfExists(configPath) || config;
+    } catch (err) {
+      console.warn(`Warning: could not parse ${configPath}; leaving it unchanged: ${err.message}`);
+      return;
+    }
+  }
+  config.plugin = mergePluginList(config.plugin, entry);
+  writeJson(configPath, config);
+  console.log(`Updated OpenCode config: ${configPath}`);
+}
+
+function detectPython() {
+  const candidates = process.platform === "win32" ? ["python", "python3", "py"] : ["python3", "python"];
+  for (const command of candidates) {
+    const r = spawnSync(command, ["--version"], { encoding: "utf8", windowsHide: true });
+    if (!r.error && r.status === 0) return command;
+  }
+  return "";
+}
+
+function installOpenCode(options) {
+  const ocRoot = opencodeConfigDir();
+  const pluginSrc = path.join(runtimeRoot(), ".opencode", "plugins", "oh-ai-report.ts");
+  const commandSrc = path.join(runtimeRoot(), ".opencode", "commands", "report-ai-issue.md");
+  const pluginDest = path.join(ocRoot, "plugins", "oh-ai-report.ts");
+  const commandDest = path.join(ocRoot, "commands", "report-ai-issue.md");
+
+  if (options.dryRun) {
+    console.log(`[dry-run] copy ${pluginSrc} -> ${pluginDest}`);
+    if (!options.pluginOnly) console.log(`[dry-run] copy ${commandSrc} -> ${commandDest}`);
+  } else {
+    ensureDir(path.dirname(pluginDest));
+    fs.copyFileSync(pluginSrc, pluginDest);
+    console.log(`Installed OpenCode plugin: ${pluginDest}`);
+    if (!options.pluginOnly) {
+      ensureDir(path.dirname(commandDest));
+      fs.copyFileSync(commandSrc, commandDest);
+      console.log(`Installed OpenCode command: ${commandDest}`);
+    }
+  }
+  updateOpenCodeConfig(options);
+}
+
+function installClaude(options) {
+  const claudeRoot = path.join(os.homedir(), ".claude");
+  const commandSrc = path.join(runtimeRoot(), ".claude", "commands", "report-ai-issue.md");
+  const hookSrc = path.join(runtimeRoot(), "scripts", "claude_report_hook.py");
+  const mergePy = path.join(runtimeRoot(), "scripts", "merge-claude-settings.py");
+  const commandDest = path.join(claudeRoot, "commands", "report-ai-issue.md");
+  const hookDest = path.join(claudeRoot, "hooks", "ohai-report-hook.py");
+  const settingsPath = path.join(claudeRoot, "settings.json");
+
+  if (options.dryRun) {
+    console.log(`[dry-run] copy ${commandSrc} -> ${commandDest}`);
+    if (!options.skipHook) {
+      console.log(`[dry-run] copy ${hookSrc} -> ${hookDest}`);
+      console.log(`[dry-run] merge Claude settings: ${settingsPath}`);
+    }
+    return;
+  }
+
+  ensureDir(path.dirname(commandDest));
+  fs.copyFileSync(commandSrc, commandDest);
+  console.log(`Installed Claude command: ${commandDest}`);
+
+  if (!options.skipHook) {
+    const python = detectPython();
+    if (!python) throw new Error("Python was not found. Install Python or use --skip-hook.");
+    ensureDir(path.dirname(hookDest));
+    fs.copyFileSync(hookSrc, hookDest);
+    console.log(`Installed Claude hook: ${hookDest}`);
+    const r = spawnSync(python, [mergePy, "--settings", settingsPath, "--hook", hookDest, "--python-command", python], {
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    if (r.status !== 0) throw new Error("Failed to merge Claude settings.json");
+  }
+}
+
+async function install(target, args) {
+  const options = {
+    dryRun: !!args["dry-run"],
+    pluginOnly: !!args["plugin-only"],
+    skipEnv: !!args["skip-env"],
+    skipEmail: !!args["skip-email"],
+    skipHook: !!args["skip-hook"],
+  };
+  if (!["opencode", "claude", "both"].includes(target)) {
+    throw new Error("Install target must be one of: opencode, claude, both");
+  }
+
+  installRuntime(options);
+
+  if (target === "opencode" || target === "both") {
+    const emailPath = path.join(opencodeConfigDir(), "ohai-report", "email.json");
+    const email = await resolveEmail({
+      label: "OpenCode",
+      defaultPaths: [emailPath, path.join(opencodeConfigDir(), "ohai-report-user.json")],
+      destPath: emailPath,
+      skipEmail: options.skipEmail,
+      emailArg: args.email,
+      dryRun: options.dryRun,
+    });
+    installOpenCode(options);
+    saveEmail(emailPath, email, options);
+  }
+
+  if (target === "claude" || target === "both") {
+    const emailPath = path.join(os.homedir(), ".claude", "ohai-report", "email.json");
+    const email = await resolveEmail({
+      label: "Claude",
+      defaultPaths: [emailPath, path.join(opencodeConfigDir(), "ohai-report", "email.json")],
+      destPath: emailPath,
+      skipEmail: options.skipEmail,
+      emailArg: args.email,
+      dryRun: options.dryRun,
+    });
+    installClaude(options);
+    saveEmail(emailPath, email, options);
+  }
+
+  if (!options.skipEnv) setUserEnv("OHAI_REPORT_CLI", runtimeCliPath(), options);
+  else console.log("Skipped env (--skip-env).");
+
+  console.log("");
+  console.log("Done. Fully quit and restart your AI coding assistant.");
+  console.log(`OHAI_REPORT_CLI: ${runtimeCliPath()}`);
+}
+
+function doctor() {
+  const rows = [
+    ["Package root", rootDir],
+    ["Runtime root", runtimeRoot()],
+    ["Runtime CLI", fs.existsSync(runtimeCliPath()) ? runtimeCliPath() : "(not installed yet)"],
+    ["Source CLI", sourceCliPath()],
+    ["Python", detectPython() || "(not found)"],
+    ["OpenCode config", opencodeConfigDir()],
+    ["OHAI_REPORT_CLI", process.env.OHAI_REPORT_CLI || "(not set in current process)"],
+  ];
+  for (const [key, value] of rows) console.log(`${key.padEnd(18)} ${value}`);
+}
+
+function runReporter(argv) {
+  const python = detectPython();
+  if (!python) throw new Error("Python was not found. Install Python and retry.");
+  const cli = fs.existsSync(runtimeCliPath()) ? runtimeCliPath() : sourceCliPath();
+  const r = spawnSync(python, [cli, ...argv], { stdio: "inherit", windowsHide: true });
+  return r.status ?? 1;
+}
+
+function printHelp() {
+  console.log(`${packageJson.name} ${packageJson.version}`);
+  console.log("");
+  console.log("Usage:");
+  console.log("  opencode-ohai-report install opencode [--email user@company.com]");
+  console.log("  opencode-ohai-report install claude");
+  console.log("  opencode-ohai-report install both");
+  console.log("  opencode-ohai-report doctor");
+  console.log("  opencode-ohai-report create ...");
+  console.log("  opencode-ohai-report metadata update ...");
+  console.log("");
+  console.log("Options:");
+  console.log("  --dry-run       Preview install actions");
+  console.log("  --plugin-only   OpenCode: install plugin without command");
+  console.log("  --skip-env      Do not write OHAI_REPORT_CLI");
+  console.log("  --skip-email    Do not prompt or write email.json");
+  console.log("  --skip-hook     Claude: skip hook/settings changes");
+  console.log("  --email <addr>  Save company email non-interactively");
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const [cmd, target] = args._;
+  if (!cmd || args.help || args.h) {
+    printHelp();
+    return 0;
+  }
+  if (args.version || args.v) {
+    console.log(packageJson.version);
+    return 0;
+  }
+  if (cmd === "install") {
+    await install(target || "opencode", args);
+    return 0;
+  }
+  if (cmd === "doctor" || cmd === "check") {
+    doctor();
+    return 0;
+  }
+  if (cmd === "create" || cmd === "metadata") {
+    return runReporter(args._);
+  }
+  printHelp();
+  return 1;
+}
+
+main()
+  .then((code) => process.exit(code))
+  .catch((err) => {
+    console.error(err?.message || String(err));
+    process.exit(1);
+  });