diffity 0.1.0

package/packages/ui/vite.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+
+export default defineConfig({
+  plugins: [tailwindcss(), react()],
+  test: {
+    include: ['tests/**/*.test.ts'],
+  },
+  server: {
+    proxy: {
+      '/api': {
+        target: 'http://localhost:5391',
+        changeOrigin: true,
+      },
+    },
+  },
+  build: {
+    outDir: '../cli/dist/ui',
+    emptyOutDir: true,
+    chunkSizeWarningLimit: 1000,
+  },
+});

package/scripts/build-skills.ts

@@ -0,0 +1,26 @@
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readSkills, renderSkill, writeFile, cleanDir } from './lib/utils.js';
+import { claudeCode } from './lib/transformers/index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+const sourceDir = join(rootDir, 'packages', 'skills');
+const outputDir = join(rootDir, 'skills');
+const localClaudeSkillsDir = join(rootDir, '.claude', 'skills');
+
+const skills = readSkills(sourceDir);
+console.log(`Found ${skills.length} skills`);
+
+cleanDir(outputDir);
+for (const skill of skills) {
+  const content = renderSkill(skill, { binary: 'diffity' });
+  writeFile(join(outputDir, skill.name, 'SKILL.md'), content);
+}
+console.log(`Built ${skills.length} skills to skills/`);
+
+cleanDir(localClaudeSkillsDir);
+for (const skill of skills) {
+  claudeCode(skill, rootDir, { binary: 'diffity-dev', namePrefix: 'diffity-dev', slashPrefix: '/diffity-dev-', installHint: 'run `npm run dev` from the diffity repo root to link the CLI' });
+}
+console.log(`Synced ${skills.length} dev skills to .claude/skills/`);

package/scripts/build.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+import { execSync } from 'node:child_process';
+
+const steps = [
+  'npm run build:skills',
+  'npm run build -w @diffity/parser',
+  'npm run build -w @diffity/git',
+  'npm run build -w @diffity/ui',
+  'npm run build -w diffity',
+];
+
+for (const step of steps) {
+  execSync(step, { stdio: 'inherit' });
+}

package/scripts/dev.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import concurrently from 'concurrently';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = resolve(__dirname, '..');
+
+execSync('tsx scripts/link-dev.ts && npm run build:skills', {
+  cwd: rootDir,
+  stdio: 'inherit',
+});
+
+concurrently(
+  [
+    { command: 'npm run dev -w @diffity/parser', name: 'parser' },
+    { command: 'npm run dev -w @diffity/git', name: 'git' },
+    { command: 'npm run dev:watch -w diffity', name: 'cli' },
+    // `vite build --watch` instead of `vite dev` so the output lands in dist/ui
+    // where the CLI server can serve it. `vite dev` only serves from memory.
+    { command: 'npx -w @diffity/ui vite build --watch', name: 'ui' },
+    {
+      command: 'tsx --watch-path=packages/skills scripts/build-skills.ts',
+      name: 'skills',
+    },
+  ],
+  {
+    prefixColors: ['blue', 'green', 'yellow', 'magenta', 'cyan'],
+  }
+);

package/scripts/lib/transformers/claude-code.ts

@@ -0,0 +1,11 @@
+import { join } from 'path';
+import { renderSkill, writeFile, type Skill, type TransformOptions } from '../utils.js';
+
+export function transform(skill: Skill, outputDir: string, options: TransformOptions): void {
+  const content = renderSkill(skill, options);
+  const dirName = options.namePrefix
+    ? skill.name.replace('diffity-', `${options.namePrefix}-`)
+    : skill.name;
+  const outputPath = join(outputDir, '.claude', 'skills', dirName, 'SKILL.md');
+  writeFile(outputPath, content);
+}

package/scripts/lib/transformers/codex.ts

@@ -0,0 +1,17 @@
+import { join } from 'path';
+import matter from 'gray-matter';
+import { writeFile, type Skill, type TransformOptions } from '../utils.js';
+
+export function transform(skill: Skill, outputDir: string, options: TransformOptions): void {
+  const body = skill.content.replaceAll('{{binary}}', options.binary);
+  const data = {
+    name: skill.data.name,
+    description: skill.data.description,
+  };
+  if (options.namePrefix) {
+    data.name = data.name.replace('diffity-', `${options.namePrefix}-`);
+  }
+  const content = matter.stringify(body, data);
+  const outputPath = join(outputDir, '.codex', 'skills', skill.name, 'SKILL.md');
+  writeFile(outputPath, content);
+}

package/scripts/lib/transformers/cursor.ts

@@ -0,0 +1,17 @@
+import { join } from 'path';
+import matter from 'gray-matter';
+import { writeFile, type Skill, type TransformOptions } from '../utils.js';
+
+export function transform(skill: Skill, outputDir: string, options: TransformOptions): void {
+  const body = skill.content.replaceAll('{{binary}}', options.binary);
+  const data = {
+    name: skill.data.name,
+    description: skill.data.description,
+  };
+  if (options.namePrefix) {
+    data.name = data.name.replace('diffity-', `${options.namePrefix}-`);
+  }
+  const content = matter.stringify(body, data);
+  const outputPath = join(outputDir, '.cursor', 'skills', skill.name, 'SKILL.md');
+  writeFile(outputPath, content);
+}

package/scripts/lib/transformers/index.ts

@@ -0,0 +1,3 @@
+export { transform as claudeCode } from './claude-code.js';
+export { transform as cursor } from './cursor.js';
+export { transform as codex } from './codex.js';

package/scripts/lib/utils.ts

@@ -0,0 +1,70 @@
+import matter from 'gray-matter';
+import { readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+
+export interface SkillData {
+  name: string;
+  description: string;
+  [key: string]: unknown;
+}
+
+export interface Skill {
+  name: string;
+  data: SkillData;
+  content: string;
+}
+
+export interface TransformOptions {
+  binary: string;
+  namePrefix?: string;
+  slashPrefix?: string;
+  installHint?: string;
+}
+
+export function readSkills(sourceDir: string): Skill[] {
+  const skills: Skill[] = [];
+  const entries = readdirSync(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const skillPath = join(sourceDir, entry.name, 'SKILL.md');
+    if (!existsSync(skillPath)) {
+      continue;
+    }
+
+    const raw = readFileSync(skillPath, 'utf-8');
+    const { data, content } = matter(raw);
+    skills.push({ name: entry.name, data: data as SkillData, content });
+  }
+
+  return skills;
+}
+
+export function renderSkill(skill: Skill, { binary, namePrefix, slashPrefix, installHint }: TransformOptions): string {
+  const slash = slashPrefix ?? '/diffity-';
+  const hint = installHint ?? 'install it with `npm install -g diffity`';
+  const body = skill.content
+    .replaceAll('{{binary}}', binary)
+    .replaceAll('{{slash}}', slash)
+    .replaceAll('{{install_hint}}', hint);
+  const data = { ...skill.data };
+  if (namePrefix) {
+    data.name = data.name.replace('diffity-', `${namePrefix}-`);
+  }
+  return matter.stringify(body, data);
+}
+
+export function writeFile(filePath: string, content: string): void {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content);
+}
+
+export function cleanDir(dir: string): void {
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true });
+  }
+  mkdirSync(dir, { recursive: true });
+}

package/scripts/link-dev.ts

@@ -0,0 +1,54 @@
+import { writeFileSync, readFileSync, chmodSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = resolve(__dirname, '..');
+const binDir = join(rootDir, '.bin');
+const cliEntry = join(rootDir, 'packages', 'cli', 'dist', 'index.js');
+const watchDir = join(rootDir, 'packages', 'cli', 'dist');
+const linkPath = join(binDir, 'diffity-dev');
+
+if (!existsSync(cliEntry)) {
+  console.log('CLI not built yet, building packages first...');
+  execSync('npm run build', { cwd: rootDir, stdio: 'inherit' });
+}
+
+mkdirSync(binDir, { recursive: true });
+
+if (existsSync(linkPath)) {
+  unlinkSync(linkPath);
+}
+
+const script = `#!/usr/bin/env bash
+# Only use --watch for the server (no subcommand). One-off commands like "agent list" run and exit.
+if [ $# -eq 0 ] || [ "$1" = "--no-open" ]; then
+  exec node --watch-path="${watchDir}" "${cliEntry}" --no-open "$@"
+else
+  exec node "${cliEntry}" "$@"
+fi
+`;
+
+writeFileSync(linkPath, script);
+chmodSync(linkPath, 0o755);
+
+const pathIncludes = process.env.PATH?.includes(binDir);
+console.log(`Created diffity-dev (auto-restarts on changes)`);
+if (!pathIncludes) {
+  const profileName = process.env.SHELL?.includes('zsh') ? '.zshrc' : '.bashrc';
+  const profilePath = resolve(process.env.HOME || '~', profileName);
+  const exportLine = `export PATH="${binDir}:$PATH"`;
+
+  if (existsSync(profilePath)) {
+    const content = readFileSync(profilePath, 'utf-8');
+    if (!content.includes(binDir)) {
+      writeFileSync(profilePath, content + `\n# diffity dev CLI\n${exportLine}\n`);
+      console.log(`\nAdded .bin to PATH in ~/${profileName}`);
+      console.log(`Run: source ~/${profileName}`);
+    }
+  } else {
+    console.log(`\nAdd this to your shell profile:`);
+    console.log(`  ${exportLine}`);
+  }
+}

package/skills/diffity-resolve/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: diffity-resolve
+description: Read open review comments and resolve them by making code fixes
+user-invocable: true
+---
+
+# Diffity Resolve Skill
+
+You are reading open review comments and resolving them by making the requested code changes.
+
+## Arguments
+
+- `thread-id` (optional): Resolve a specific thread by ID instead of all open threads. Example: `/diffity-resolve abc123`
+
+## CLI Reference
+
+```
+diffity agent list [--status open|resolved|dismissed] [--json]
+diffity agent comment --file <path> --line <n> [--end-line <n>] [--side new|old] --body "<text>"
+diffity agent general-comment --body "<text>"
+diffity agent resolve <id> [--summary "<text>"]
+diffity agent dismiss <id> [--reason "<text>"]
+diffity agent reply <id> --body "<text>"
+```
+
+- `--file`, `--line`, `--body` are required for `comment`
+- `--end-line` defaults to `--line` (single-line comment)
+- `--side` defaults to `new`
+- `general-comment` creates a diff-level comment not tied to any file or line
+- `<id>` accepts full UUID or 8-char prefix
+
+## Prerequisites
+
+1. Check that `diffity` is available: run `which diffity`. If not found, install it with `npm install -g diffity`.
+2. Check that a review session exists: run `cat .diffity/current-session`. If the file doesn't exist or is stale, tell the user to start diffity first.
+
+## Instructions
+
+1. List open comment threads with full details:
+   ```
+   diffity agent list --status open --json
+   ```
+   If a `thread-id` argument was provided, filter to just that thread. The JSON output includes the full comment body, file path, line numbers, and side for each thread.
+2. If there are no open threads, tell the user there's nothing to resolve.
+3. For each open thread:
+   a. **Skip** general comments (filePath `__general__`) — these are summaries, not actionable code changes.
+   b. **Skip** threads tagged `[question]` or `[nit]` — these don't require code changes. Tell the user you skipped them and why.
+   c. Read the comment body from the JSON output and understand what change is requested.
+   d. Read the relevant source file to understand the full context around the commented lines, then make the requested code change using the Edit tool.
+   e. After making the change, resolve the thread with a summary:
+      ```
+      diffity agent resolve <thread-id> --summary "Fixed: <brief description of what was changed>"
+      ```
+4. After resolving all applicable threads, run `diffity agent list` to confirm status.
+5. Tell the user to check the browser — resolved status will appear within 2 seconds via polling.

package/skills/diffity-review/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: diffity-review
+description: Review current diff and leave comments using diffity agent commands
+user-invocable: true
+---
+
+# Diffity Review Skill
+
+You are reviewing a diff and leaving inline comments using the `diffity agent` CLI.
+
+## Arguments
+
+- `focus` (optional): Focus the review on a specific area. One of: `security`, `performance`, `naming`, `errors`, `types`, `logic`. If omitted, review everything.
+
+## CLI Reference
+
+```
+diffity agent list [--status open|resolved|dismissed] [--json]
+diffity agent comment --file <path> --line <n> [--end-line <n>] [--side new|old] --body "<text>"
+diffity agent general-comment --body "<text>"
+diffity agent resolve <id> [--summary "<text>"]
+diffity agent dismiss <id> [--reason "<text>"]
+diffity agent reply <id> --body "<text>"
+```
+
+- `--file`, `--line`, `--body` are required for `comment`
+- `--end-line` defaults to `--line` (single-line comment)
+- `--side` defaults to `new`
+- `general-comment` creates a diff-level comment not tied to any file or line
+- `<id>` accepts full UUID or 8-char prefix
+
+## Prerequisites
+
+1. Check that `diffity` is available: run `which diffity`. If not found, install it with `npm install -g diffity`.
+2. Check that a review session exists: run `cat .diffity/current-session`. If the file doesn't exist or is stale, tell the user to start diffity first (e.g. `diffity`).
+
+## Instructions
+
+1. Read the current diff using `git diff`. Check `.diffity/current-session` to determine which ref is active.
+2. For each changed file, read the **entire file** (not just the diff hunks) to understand the full context. This prevents false positives from missing surrounding code.
+3. Analyze the code changes thoroughly. If a `focus` argument was provided, concentrate on that area. Otherwise look for:
+   - Bugs, logic errors, off-by-one errors
+   - Security issues (injection, XSS, auth bypass)
+   - Performance problems
+   - Missing error handling at system boundaries
+   - Race conditions
+   - API contract violations
+   - Unclear or misleading naming
+4. **Only comment on code that was changed in the diff.** Do not flag pre-existing issues in unchanged code — this is a review of the diff, not an audit of the entire file. The only exception is if a change in the diff introduces a bug in combination with existing code.
+5. **Prioritize signal over volume.** A clean diff should get a clean review. Do not manufacture findings to appear thorough. If a diff with 5 changed lines only has 1 real issue, leave 1 comment.
+6. **Do not repeat the same issue across files.** If the same pattern appears in multiple places, leave one inline comment on the first occurrence and mention it in the general summary instead of commenting on every instance.
+7. Categorize each finding with a severity prefix in the comment body:
+   - `[must-fix]` — Bugs, security issues, data loss risks. These must be addressed.
+   - `[suggestion]` — Improvements that would meaningfully improve the code.
+   - `[nit]` — Style or preference. Fine to ignore.
+   - `[question]` — Something unclear that needs clarification from the author.
+8. For each finding, leave a comment using:
+   ```
+   diffity agent comment --file <path> --line <n> [--end-line <n>] [--side new] --body "<comment>"
+   ```
+   - Use `--side new` (default) for comments on added/modified code
+   - Use `--side old` for comments on removed code
+   - Use `--end-line` when the issue spans multiple lines
+   - Be specific and actionable in your comments
+9. After leaving all inline comments, write a general comment that summarizes your overall assessment of the diff. This should cover:
+   - Overall quality verdict (e.g. "Looks good with minor issues" or "Needs significant changes before merging")
+   - Cross-cutting concerns that don't belong on any single line (architecture, naming consistency across files, missing tests, etc.)
+   - A count of findings by severity (e.g. "2 must-fix, 3 suggestions, 1 nit")
+   ```
+   diffity agent general-comment --body "<overall review summary>"
+   ```
+   If there are no inline findings, still leave a general comment with your assessment (e.g. "Clean diff — no issues found").
+10. Run `diffity agent list` to confirm all comments were created.
+11. Tell the user to check the browser — comments will appear within 2 seconds via polling.

package/skills/diffity-start/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: diffity-start
+description: >-
+  Start the diffity diff viewer server for the current working tree or staged
+  changes
+user-invocable: true
+---
+
+# Diffity Start Skill
+
+You are starting the diffity diff viewer so the user can see their changes in the browser.
+
+## Instructions
+
+1. Check that `diffity` is available: run `which diffity`. If not found, install it with `npm install -g diffity`.
+2. Start the server using the Bash tool with `run_in_background: true`:
+   - Command: `diffity`
+   - Do NOT use `&` or `--quiet` — let the Bash tool handle backgrounding
+   - The browser will open automatically and the session is auto-created on startup
+4. Wait 2 seconds, then verify the session exists by checking that `.diffity/current-session` file is present.
+5. Tell the user diffity is running and show them what they can do next. Keep it short — don't show session IDs, hashes, or other internals. Example:
+
+   > Diffity is running — check your browser.
+   >
+   > Here's what you can do:
+   > - **/diffity-review** — get a code review on your changes
+   > - **/diffity-resolve** — fix issues from review comments

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "references": [
+    { "path": "./packages/parser" },
+    { "path": "./packages/git" },
+    { "path": "./packages/cli" },
+    { "path": "./packages/ui" }
+  ]
+}