@mechanai/deepreview 2.0.0 → 2.0.2

package/README.md

@@ -6,15 +6,28 @@ implementation plan.
 
 ## Install
 
-Add to your `opencode.json` (project-level or global):
+Run the setup script:
 
-```jsonc
-{
-  "plugin": ["@mechanai/deepreview"],
-}
+```bash
+bunx @mechanai/deepreview@latest/setup          # Global install (~/.config/opencode/)
+bunx @mechanai/deepreview@latest/setup --local   # Project-level install (.opencode/)
+```
+
+Or with Node.js (v22+):
+
+```bash
+npx @mechanai/deepreview@latest/setup
+npx @mechanai/deepreview@latest/setup --local
 ```
 
-OpenCode installs the package automatically at startup.
+This will:
+
+1. Add `@mechanai/deepreview` to the `plugin` array in your `opencode.json` (creates the file if needed)
+2. Symlink agents and commands into the appropriate config directory
+
+> [!NOTE]
+> The symlinks are needed because OpenCode does not yet auto-discover
+> agents and commands from installed plugin packages.
 
 ## Usage
 
@@ -62,12 +75,16 @@ its own context, keeping token usage minimal.
 ## Requirements
 
 - [OpenCode](https://opencode.ai)
+- [Bun](https://bun.sh/) >= 1.2 or [Node.js](https://nodejs.org/) >= 22
 - `git`
 - `gh` CLI (only for PR commands)
 
 > [!NOTE]
 > If upgrading from the old `npx @anthropic/deepreview install` workflow, remove
-> `~/.config/opencode/agents/deepreview*` files — they are no longer used.
+> the old copied files first (`rm ~/.config/opencode/agents/deepreview*
+~/.config/opencode/commands/deepreview*`), then run the setup script above.
+> The setup script uses symlinks instead of copies, so future upgrades only
+> require re-running the script.
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mechanai/deepreview",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Multi-agent parallel code/spec review for OpenCode",
   "license": "MIT",
   "repository": {
@@ -9,15 +9,15 @@
   },
   "files": [
     "src/",
-    "agents/",
-    "commands/",
+    "dist/",
     ".opencode/"
   ],
   "type": "module",
   "main": "./.opencode/plugins/deepreview.ts",
   "exports": {
     ".": "./.opencode/plugins/deepreview.ts",
-    "./api": "./src/post-review.ts"
+    "./api": "./src/post-review.ts",
+    "./setup": "./dist/setup.mjs"
   },
   "publishConfig": {
     "access": "public"
@@ -25,6 +25,7 @@
   "dependencies": {
     "gray-matter": "4.0.3",
     "js-yaml": "4.1.0",
+    "jsonc-parser": "3.3.1",
     "parse-diff": "0.11.1"
   },
   "devDependencies": {
@@ -44,6 +45,7 @@
     }
   },
   "engines": {
-    "bun": ">=1.2.0"
+    "bun": ">=1.2.0",
+    "node": ">=22.0.0"
   }
 }

package/src/setup.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const setupScript = path.resolve(import.meta.dirname, "setup.ts");
+
+function makeTempDir(): string {
+  const dir = path.join(
+    os.tmpdir(),
+    `deepreview-setup-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function run(cwd: string, args: string[] = []) {
+  return Bun.spawnSync(["bun", "run", setupScript, ...args], {
+    cwd,
+    env: { ...process.env, XDG_CONFIG_HOME: cwd },
+  });
+}
+
+function readConfig(filePath: string): { plugin?: unknown } {
+  const parsed: unknown = JSON.parse(readFileSync(filePath, "utf-8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("config is not an object");
+  }
+  return parsed as { plugin?: unknown };
+}
+
+describe("setup script - config", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir();
+  });
+
+  afterEach(async () => {
+    await Bun.$`rm -rf ${tempDir}`;
+  });
+
+  test("creates opencode.json with plugin when no config exists (global)", () => {
+    const result = run(tempDir);
+    expect(result.exitCode).toBe(0);
+
+    const configPath = path.join(tempDir, "opencode", "opencode.json");
+    expect(existsSync(configPath)).toBe(true);
+
+    const config = readConfig(configPath);
+    expect(config.plugin).toContain("@mechanai/deepreview");
+  });
+
+  test("--local installs into .opencode/ in cwd", () => {
+    const result = run(tempDir, ["--local"]);
+    expect(result.exitCode).toBe(0);
+
+    const configPath = path.join(tempDir, "opencode.json");
+    expect(existsSync(configPath)).toBe(true);
+
+    const agentsDir = path.join(tempDir, ".opencode", "agents");
+    expect(existsSync(path.join(agentsDir, "deepreview-synthesizer.md"))).toBe(true);
+  });
+
+  test("adds plugin to existing config without duplicating", () => {
+    const configPath = path.join(tempDir, "opencode");
+    mkdirSync(configPath, { recursive: true });
+    writeFileSync(
+      path.join(configPath, "opencode.json"),
+      JSON.stringify({ plugin: ["other-plugin"] }, null, 2),
+    );
+
+    run(tempDir);
+    const config = readConfig(path.join(configPath, "opencode.json"));
+    expect(config.plugin).toEqual(["other-plugin", "@mechanai/deepreview"]);
+
+    // Run again — should not duplicate
+    run(tempDir);
+    const config2 = readConfig(path.join(configPath, "opencode.json"));
+    expect(config2.plugin).toEqual(["other-plugin", "@mechanai/deepreview"]);
+  });
+
+  test("preserves JSONC comments", () => {
+    const configDir = path.join(tempDir, "opencode");
+    mkdirSync(configDir, { recursive: true });
+    const content = '{\n  // My comment\n  "provider": {}\n}\n';
+    writeFileSync(path.join(configDir, "opencode.jsonc"), content);
+
+    run(tempDir);
+    const result = readFileSync(path.join(configDir, "opencode.jsonc"), "utf-8");
+    expect(result).toContain("// My comment");
+    expect(result).toContain("@mechanai/deepreview");
+  });
+});
+
+describe("setup script - symlinks", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir();
+  });
+
+  afterEach(async () => {
+    await Bun.$`rm -rf ${tempDir}`;
+  });
+
+  test("creates symlinks for agents and commands (global)", () => {
+    const result = run(tempDir);
+    expect(result.exitCode).toBe(0);
+
+    const agentsDir = path.join(tempDir, "opencode", "agents");
+    const synthesizer = path.join(agentsDir, "deepreview-synthesizer.md");
+    expect(existsSync(synthesizer)).toBe(true);
+    expect(lstatSync(synthesizer).isSymbolicLink()).toBe(true);
+
+    const commandsDir = path.join(tempDir, "opencode", "commands");
+    const mainCmd = path.join(commandsDir, "deepreview.md");
+    expect(existsSync(mainCmd)).toBe(true);
+    expect(lstatSync(mainCmd).isSymbolicLink()).toBe(true);
+  });
+
+  test("removes stale symlinks on upgrade", () => {
+    const agentsDir = path.join(tempDir, "opencode", "agents");
+    mkdirSync(agentsDir, { recursive: true });
+
+    // Create a fake stale symlink that contains "deepreview" but doesn't exist in package
+    symlinkSync("/nonexistent", path.join(agentsDir, "deepreview-old-agent.md"));
+
+    run(tempDir);
+
+    // Stale symlink should be removed
+    expect(existsSync(path.join(agentsDir, "deepreview-old-agent.md"))).toBe(false);
+    // But real agents should exist
+    expect(existsSync(path.join(agentsDir, "deepreview-synthesizer.md"))).toBe(true);
+  });
+
+  test("handles dangling symlinks at dest gracefully", () => {
+    const agentsDir = path.join(tempDir, "opencode", "agents");
+    mkdirSync(agentsDir, { recursive: true });
+
+    // Create a dangling symlink where a real agent should go
+    symlinkSync("/nonexistent", path.join(agentsDir, "deepreview-synthesizer.md"));
+
+    const result = run(tempDir);
+    expect(result.exitCode).toBe(0);
+
+    // Should have replaced the dangling symlink
+    const dest = path.join(agentsDir, "deepreview-synthesizer.md");
+    expect(lstatSync(dest).isSymbolicLink()).toBe(true);
+    expect(existsSync(dest)).toBe(true);
+  });
+});

package/src/setup.ts

@@ -0,0 +1,151 @@
+/**
+ * Setup script for @mechanai/deepreview.
+ *
+ * Ensures the plugin is registered in opencode.json and symlinks agents/commands
+ * into the OpenCode config directory.
+ *
+ * Usage:
+ *   bunx @mechanai/deepreview/setup          # Install globally (~/.config/opencode/)
+ *   bunx @mechanai/deepreview/setup --local   # Install into current project (.opencode/)
+ */
+
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  symlinkSync,
+  unlinkSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { applyEdits, modify, parse as parseJsonc } from "jsonc-parser";
+
+const PACKAGE_NAME = "@mechanai/deepreview";
+const local = process.argv.includes("--local");
+const cwd = process.cwd();
+
+const globalConfigDir = path.join(
+  process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"),
+  "opencode",
+);
+const targetDir = local ? path.join(cwd, ".opencode") : globalConfigDir;
+
+// Resolve the package directory (where this script lives)
+const packageDir = path.resolve(import.meta.dirname, "..");
+const packageOpencode = path.join(packageDir, ".opencode");
+
+function ensurePluginInConfig() {
+  const configFiles = ["opencode.jsonc", "opencode.json"];
+  const searchDir = local ? cwd : globalConfigDir;
+  let configPath: string | undefined;
+
+  for (const file of configFiles) {
+    const candidate = path.join(searchDir, file);
+    if (existsSync(candidate)) {
+      configPath = candidate;
+      break;
+    }
+  }
+
+  if (configPath === undefined) {
+    configPath = path.join(searchDir, "opencode.json");
+    mkdirSync(searchDir, { recursive: true });
+    writeFileSync(configPath, JSON.stringify({ plugin: [PACKAGE_NAME] }, null, 2) + "\n");
+    console.log(`Created ${configPath} with plugin entry.`);
+    return;
+  }
+
+  const raw = readFileSync(configPath, "utf-8");
+
+  // Check if plugin is already registered
+  let config: Record<string, unknown>;
+  try {
+    const parsed: unknown = parseJsonc(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("not an object");
+    }
+    // oxlint-disable-next-line no-unsafe-type-assertion -- Why: validated above with type guards
+    config = parsed as Record<string, unknown>;
+  } catch {
+    console.error(`Could not parse ${configPath}. Add the plugin manually:`);
+    console.error(`  "plugin": ["${PACKAGE_NAME}"]`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const pluginArray = Array.isArray(config.plugin) ? config.plugin : [];
+  const plugins = pluginArray.filter((p): p is string => typeof p === "string");
+  if (plugins.includes(PACKAGE_NAME)) {
+    console.log(`Plugin already registered in ${configPath}.`);
+    return;
+  }
+
+  // Use jsonc-parser to insert into the plugin array without stripping comments
+  const formatting = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+  const edits = Array.isArray(config.plugin)
+    ? modify(raw, ["plugin", pluginArray.length], PACKAGE_NAME, formatting)
+    : modify(raw, ["plugin"], [PACKAGE_NAME], formatting);
+
+  writeFileSync(configPath, applyEdits(raw, edits));
+  console.log(`Added "${PACKAGE_NAME}" to plugin array in ${configPath}.`);
+}
+
+function symlinkDirectory(kind: "agents" | "commands") {
+  const sourceDir = path.join(packageOpencode, kind);
+  if (!existsSync(sourceDir)) return;
+
+  const destDir = path.join(targetDir, kind);
+  mkdirSync(destDir, { recursive: true });
+
+  const sourceFiles = new Set(readdirSync(sourceDir).filter((f) => f.endsWith(".md")));
+  let created = 0;
+
+  // Remove stale deepreview symlinks that no longer exist in the package
+  for (const file of readdirSync(destDir)) {
+    if (!file.startsWith("deepreview-") && !file.startsWith("_deepreview-")) continue;
+    const dest = path.join(destDir, file);
+    try {
+      if (lstatSync(dest).isSymbolicLink() && !sourceFiles.has(file)) {
+        unlinkSync(dest);
+      }
+    } catch (err: unknown) {
+      if (err instanceof Error && !("code" in err && err.code === "ENOENT")) {
+        console.warn(`Could not check ${dest}: ${err.message}`);
+      }
+    }
+  }
+
+  for (const file of sourceFiles) {
+    const dest = path.join(destDir, file);
+    const source = path.relative(destDir, path.join(sourceDir, file));
+
+    try {
+      // Use lstatSync to detect both regular files and dangling symlinks
+      const stat = lstatSync(dest);
+      if (!stat.isSymbolicLink()) {
+        console.warn(`Skipping ${dest}: not a symlink (would overwrite regular file)`);
+        continue;
+      }
+      unlinkSync(dest);
+    } catch (err: unknown) {
+      if (err instanceof Error && "code" in err && err.code !== "ENOENT") {
+        throw err;
+      }
+    }
+    symlinkSync(source, dest);
+    created++;
+  }
+
+  const label = local ? `.opencode/${kind}/` : path.join(targetDir, kind) + "/";
+  console.log(`Linked ${created} ${kind} into ${label}`);
+}
+
+// Run
+ensurePluginInConfig();
+symlinkDirectory("agents");
+symlinkDirectory("commands");
+const scope = local ? "project" : "global";
+console.log(`Done (${scope}). Run opencode to use /deepreview commands.`);