diffprism 0.10.2 → 0.11.1

package/README.md

@@ -20,45 +20,20 @@ DiffPrism gives you a visual review step for AI-written code — stage your chan
 
 ### Use with Claude Code (recommended)
 
-**1. Add the MCP server** — create `.mcp.json` in your project root:
+Run this from your project root:
 
-```json
-{
-  "mcpServers": {
-    "diffprism": {
-      "command": "npx",
-      "args": ["diffprism", "serve"]
-    }
-  }
-}
-```
-
-**2. Auto-approve the tool** (optional) — add to `.claude/settings.json` so Claude can open reviews without prompting:
-
-```json
-{
-  "permissions": {
-    "allow": [
-      "mcp__diffprism__open_review"
-    ]
-  }
-}
+```bash
+npx diffprism setup
 ```
 
-**3. Tell Claude to use it** — add to your project's `CLAUDE.md`:
-
-```markdown
-## Code Review
-
-Before committing changes, use the diffprism MCP tool to open a review:
-- Call `open_review` with the appropriate `diff_ref` (e.g. `"staged"`, `"HEAD~1..HEAD"`)
-- Include a `title` and `description` summarizing the changes
-- Wait for the user's review decision before proceeding
-```
+This single command configures everything:
+- Creates `.mcp.json` with the DiffPrism MCP server
+- Creates `.claude/settings.json` with auto-approve permissions
+- Installs a `/review` skill so you can type `/review` in Claude Code at any time
 
-That's it. Claude will now open a browser-based review before committing. You review the diff, leave comments, and the result goes back to Claude as structured JSON.
+After running, restart Claude Code. The first time you use `/review`, Claude will ask your preferences and save them to `diffprism.config.json`.
 
-See the [full setup guide](docs/claude-setup.md) for Claude Desktop config, troubleshooting, and advanced options.
+See the [full setup guide](docs/claude-setup.md) for manual configuration, Claude Desktop config, troubleshooting, and advanced options.
 
 ### Use from the CLI
 

package/dist/bin.js

@@ -40,9 +40,222 @@ async function serve() {
   await startMcpServer();
 }
 
+// cli/src/commands/setup.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// cli/src/templates/skill.ts
+var skillContent = `---
+name: review
+description: Open current code changes in DiffPrism's browser-based review UI for human review.
+---
+
+# DiffPrism Review Skill
+
+When the user invokes \`/review\`, open the current code changes in DiffPrism for browser-based human review.
+
+## Steps
+
+### 1. Check for Configuration
+
+Look for \`diffprism.config.json\` at the project root. If it exists, read it for preferences:
+
+\`\`\`json
+{
+  "reviewTrigger": "ask | before_commit | always",
+  "defaultDiffScope": "staged | unstaged | all",
+  "includeReasoning": true | false
+}
+\`\`\`
+
+**Defaults** (when fields are missing or file doesn't exist):
+- \`reviewTrigger\`: \`"ask"\`
+- \`defaultDiffScope\`: \`"all"\`
+- \`includeReasoning\`: \`true\`
+
+### 2. First-Run Onboarding
+
+If \`diffprism.config.json\` does **not** exist, ask the user these questions before proceeding:
+
+1. **"When should I open DiffPrism reviews?"**
+   - \`"ask"\` \u2014 Only when you explicitly ask (default)
+   - \`"before_commit"\` \u2014 Automatically before every commit
+   - \`"always"\` \u2014 After every code change
+
+2. **"What should the default diff scope be?"**
+   - \`"all"\` \u2014 All changes, staged and unstaged (default)
+   - \`"staged"\` \u2014 Only staged changes
+   - \`"unstaged"\` \u2014 Only unstaged changes
+
+3. **"Should I include my reasoning about the changes in reviews?"**
+   - Yes (default)
+   - No
+
+After collecting answers, create \`diffprism.config.json\` at the project root with the user's choices. Then proceed to open the review.
+
+### 3. Open the Review
+
+Call \`mcp__diffprism__open_review\` with:
+
+- \`diff_ref\`: Use the \`defaultDiffScope\` from config. If the user specified a scope in their message (e.g., "/review staged"), use that instead.
+- \`title\`: A short summary of the changes (generate from git status or the user's message).
+- \`description\`: A brief description of what changed and why.
+- \`reasoning\`: If \`includeReasoning\` is \`true\`, include your reasoning about the implementation decisions.
+
+### 4. Handle the Result
+
+The tool blocks until the user submits their review in the browser. When it returns:
+
+- **\`approved\`** \u2014 Acknowledge and proceed with whatever task was in progress.
+- **\`approved_with_comments\`** \u2014 Note the comments, address any actionable feedback.
+- **\`changes_requested\`** \u2014 Read the comments carefully, make the requested changes, and offer to open another review.
+
+### 5. Error Handling
+
+If the \`mcp__diffprism__open_review\` tool is not available:
+- Tell the user: "The DiffPrism MCP server isn't configured. Run \`npx diffprism setup\` to set it up, then restart Claude Code."
+
+## Behavior Rules
+
+- When invoked via \`/review\`, always open a review regardless of the \`reviewTrigger\` setting.
+- The \`reviewTrigger\` setting only applies to automatic review behavior during other workflows:
+  - \`"ask"\` \u2014 Never auto-review; only review when the user asks.
+  - \`"before_commit"\` \u2014 Open a review before creating any git commit.
+  - \`"always"\` \u2014 Open a review after any code change.
+- To re-run onboarding, the user can delete \`diffprism.config.json\` and invoke \`/review\` again.
+`;
+
+// cli/src/commands/setup.ts
+function findGitRoot(from) {
+  let dir = path.resolve(from);
+  while (true) {
+    if (fs.existsSync(path.join(dir, ".git"))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readJsonFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeJsonFile(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function setupMcpJson(gitRoot, force) {
+  const filePath = path.join(gitRoot, ".mcp.json");
+  const existing = readJsonFile(filePath);
+  const servers = existing.mcpServers ?? {};
+  if (servers.diffprism && !force) {
+    return { action: "skipped", filePath };
+  }
+  servers.diffprism = {
+    command: "npx",
+    args: ["diffprism@latest", "serve"]
+  };
+  const action = fs.existsSync(filePath) ? "updated" : "created";
+  writeJsonFile(filePath, { ...existing, mcpServers: servers });
+  return { action, filePath };
+}
+function setupClaudeSettings(gitRoot, force) {
+  const filePath = path.join(gitRoot, ".claude", "settings.json");
+  const existing = readJsonFile(filePath);
+  const permissions = existing.permissions ?? {};
+  const allow = permissions.allow ?? [];
+  const toolName = "mcp__diffprism__open_review";
+  if (allow.includes(toolName) && !force) {
+    return { action: "skipped", filePath };
+  }
+  if (!allow.includes(toolName)) {
+    allow.push(toolName);
+  }
+  permissions.allow = allow;
+  const action = fs.existsSync(filePath) ? "updated" : "created";
+  writeJsonFile(filePath, { ...existing, permissions });
+  return { action, filePath };
+}
+function setupSkill(gitRoot, global, force) {
+  const skillDir = global ? path.join(os.homedir(), ".claude", "skills", "review") : path.join(gitRoot, ".claude", "skills", "review");
+  const filePath = path.join(skillDir, "SKILL.md");
+  if (fs.existsSync(filePath)) {
+    const existingContent = fs.readFileSync(filePath, "utf-8");
+    if (existingContent === skillContent) {
+      return { action: "skipped", filePath };
+    }
+    if (!force) {
+      console.log(
+        `  Warning: ${filePath} exists with different content. Use --force to overwrite.`
+      );
+      return { action: "skipped", filePath };
+    }
+  }
+  if (!fs.existsSync(skillDir)) {
+    fs.mkdirSync(skillDir, { recursive: true });
+  }
+  const action = fs.existsSync(filePath) ? "updated" : "created";
+  fs.writeFileSync(filePath, skillContent);
+  return { action, filePath };
+}
+async function setup(flags) {
+  const gitRoot = findGitRoot(process.cwd());
+  if (!gitRoot) {
+    console.error(
+      "Error: Not in a git repository. Run this command from inside a git project."
+    );
+    process.exit(1);
+    return;
+  }
+  const force = flags.force ?? false;
+  const global = flags.global ?? false;
+  console.log("Setting up DiffPrism for Claude Code...\n");
+  const result = { created: [], updated: [], skipped: [] };
+  const mcp = setupMcpJson(gitRoot, force);
+  result[mcp.action === "skipped" ? "skipped" : mcp.action === "created" ? "created" : "updated"].push(mcp.filePath);
+  const settings = setupClaudeSettings(gitRoot, force);
+  result[settings.action === "skipped" ? "skipped" : settings.action === "created" ? "created" : "updated"].push(settings.filePath);
+  const skill = setupSkill(gitRoot, global, force);
+  result[skill.action === "skipped" ? "skipped" : skill.action === "created" ? "created" : "updated"].push(skill.filePath);
+  if (result.created.length > 0) {
+    console.log("Created:");
+    for (const f of result.created) {
+      console.log(`  + ${path.relative(gitRoot, f)}`);
+    }
+  }
+  if (result.updated.length > 0) {
+    console.log("Updated:");
+    for (const f of result.updated) {
+      console.log(`  ~ ${path.relative(gitRoot, f)}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    console.log("Skipped (already configured):");
+    for (const f of result.skipped) {
+      console.log(`  - ${path.relative(gitRoot, f)}`);
+    }
+  }
+  console.log(
+    "\nYou can now use /review in Claude Code to open a DiffPrism review."
+  );
+  console.log(
+    "If Claude Code is running, restart it to pick up the new configuration."
+  );
+}
+
 // cli/src/index.ts
 var program = new Command();
-program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.10.2" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.11.1" : "0.0.0-dev");
 program.command("review [ref]").description("Open a browser-based diff review").option("--staged", "Review staged changes").option("--unstaged", "Review unstaged changes").option("-t, --title <title>", "Review title").option("--dev", "Use Vite dev server with HMR instead of static files").action(review);
 program.command("serve").description("Start the MCP server for Claude Code integration").action(serve);
+program.command("setup").description("Configure DiffPrism for Claude Code integration").option("--global", "Install skill globally (~/.claude/skills/)").option("--force", "Overwrite existing configuration files").action(setup);
 program.parse();

package/dist/mcp-server.js

@@ -11,7 +11,7 @@ import { z } from "zod";
 async function startMcpServer() {
   const server = new McpServer({
     name: "diffprism",
-    version: true ? "0.10.2" : "0.0.0-dev"
+    version: true ? "0.11.1" : "0.0.0-dev"
   });
   server.tool(
     "open_review",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffprism",
-  "version": "0.10.2",
+  "version": "0.11.1",
   "type": "module",
   "description": "Local-first code review tool for agent-generated code changes",
   "bin": {