@vibeversion/cli 0.1.1 → 0.2.1

package/dist/index.js

@@ -14,8 +14,8 @@ var ApiClient = class {
     this.baseUrl = baseUrl;
     this.token = token;
   }
-  async request(method, path3, body) {
-    const url = `${this.baseUrl}${path3}`;
+  async request(method, path5, body) {
+    const url = `${this.baseUrl}${path5}`;
     const headers = {
       "Content-Type": "application/json",
       Accept: "application/json"
@@ -51,9 +51,15 @@ var ApiClient = class {
   async listProjects() {
     return this.request("GET", "/api/projects");
   }
+  async listVersions(projectUlid) {
+    return this.request("GET", `/api/projects/${projectUlid}/versions`);
+  }
   async createVersion(projectUlid, data) {
     return this.request("POST", `/api/projects/${projectUlid}/versions`, data);
   }
+  async triggerDeploy(projectUlid, data) {
+    return this.request("POST", `/api/projects/${projectUlid}/deploy`, data);
+  }
 };
 var ApiError = class extends Error {
   constructor(status, message) {
@@ -67,21 +73,60 @@ var ApiError = class extends Error {
 import fs from "fs";
 import path from "path";
 import os from "os";
-var CONFIG_DIR = path.join(os.homedir(), ".vibeversion");
+var CONFIG_DIR = path.join(os.homedir(), ".vv");
 var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-function getAuthConfig() {
+var LEGACY_CONFIG_DIR = path.join(os.homedir(), ".vibeversion");
+var LEGACY_CONFIG_FILE = path.join(LEGACY_CONFIG_DIR, "config.json");
+function readAuthConfig(filePath) {
   try {
-    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+    const raw = fs.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
+function migrateLegacyAuthConfig() {
+  if (!fs.existsSync(LEGACY_CONFIG_FILE)) {
+    return null;
+  }
+  const legacyConfig = readAuthConfig(LEGACY_CONFIG_FILE);
+  if (!legacyConfig) {
+    return null;
+  }
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(legacyConfig, null, 2) + "\n", {
+    mode: 384
+  });
+  try {
+    fs.unlinkSync(LEGACY_CONFIG_FILE);
+    fs.rmdirSync(LEGACY_CONFIG_DIR);
+  } catch {
+  }
+  return legacyConfig;
+}
+function cleanupLegacyAuthConfig() {
+  try {
+    fs.unlinkSync(LEGACY_CONFIG_FILE);
+  } catch {
+  }
+  try {
+    fs.rmdirSync(LEGACY_CONFIG_DIR);
+  } catch {
+  }
+}
+function getAuthConfig() {
+  const currentConfig = readAuthConfig(CONFIG_FILE);
+  if (currentConfig) {
+    return currentConfig;
+  }
+  return migrateLegacyAuthConfig();
+}
 function saveAuthConfig(config) {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });
   fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
     mode: 384
   });
+  cleanupLegacyAuthConfig();
 }
 
 // src/commands/login.ts
@@ -119,38 +164,102 @@ async function loginCommand() {
 }
 
 // src/commands/init.ts
-import { select } from "@inquirer/prompts";
-import chalk2 from "chalk";
+import { confirm, select } from "@inquirer/prompts";
+import chalk3 from "chalk";
 import ora2 from "ora";
 
 // src/lib/project.ts
 import fs2 from "fs";
 import path2 from "path";
-var PROJECT_DIR = ".vibeversion";
+var PROJECT_DIR = ".vv";
+var LEGACY_PROJECT_DIR = ".vibeversion";
 var PROJECT_FILE = "config.json";
 function getProjectConfigPath(dir) {
   return path2.join(dir, PROJECT_DIR, PROJECT_FILE);
 }
-function getProjectConfig(dir = process.cwd()) {
+function getLegacyProjectConfigPath(dir) {
+  return path2.join(dir, LEGACY_PROJECT_DIR, PROJECT_FILE);
+}
+function readProjectConfig(filePath) {
   try {
-    const raw = fs2.readFileSync(getProjectConfigPath(dir), "utf-8");
+    const raw = fs2.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
+function migrateProjectConfig(dir) {
+  const currentPath = getProjectConfigPath(dir);
+  if (fs2.existsSync(currentPath)) {
+    return;
+  }
+  const legacyDir = path2.join(dir, LEGACY_PROJECT_DIR);
+  const legacyPath = getLegacyProjectConfigPath(dir);
+  if (!fs2.existsSync(legacyPath)) {
+    return;
+  }
+  const projectDir = path2.join(dir, PROJECT_DIR);
+  try {
+    fs2.renameSync(legacyDir, projectDir);
+    return;
+  } catch {
+  }
+  const legacyConfig = readProjectConfig(legacyPath);
+  if (!legacyConfig) {
+    return;
+  }
+  fs2.mkdirSync(projectDir, { recursive: true });
+  fs2.writeFileSync(currentPath, JSON.stringify(legacyConfig, null, 2) + "\n");
+  try {
+    fs2.rmSync(legacyDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function cleanupLegacyProjectDir(dir) {
+  const legacyDir = path2.join(dir, LEGACY_PROJECT_DIR);
+  if (!fs2.existsSync(legacyDir)) {
+    return;
+  }
+  try {
+    fs2.rmSync(legacyDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function getProjectConfig(dir = process.cwd()) {
+  migrateProjectConfig(dir);
+  const currentConfig = readProjectConfig(getProjectConfigPath(dir));
+  if (currentConfig) {
+    return currentConfig;
+  }
+  const legacyConfig = readProjectConfig(getLegacyProjectConfigPath(dir));
+  if (!legacyConfig) {
+    return null;
+  }
+  saveProjectConfig(legacyConfig, dir);
+  return legacyConfig;
+}
 function saveProjectConfig(config, dir = process.cwd()) {
+  migrateProjectConfig(dir);
   const projectDir = path2.join(dir, PROJECT_DIR);
   fs2.mkdirSync(projectDir, { recursive: true });
   fs2.writeFileSync(path2.join(projectDir, PROJECT_FILE), JSON.stringify(config, null, 2) + "\n");
+  cleanupLegacyProjectDir(dir);
 }
 function ensureGitignore(dir = process.cwd()) {
   const gitignorePath = path2.join(dir, ".gitignore");
-  const entry = ".vibeversion/";
+  const entry = ".vv/";
+  const legacyEntry = ".vibeversion/";
   try {
     const content = fs2.readFileSync(gitignorePath, "utf-8");
-    if (content.includes(entry)) return;
-    fs2.writeFileSync(gitignorePath, content.trimEnd() + "\n" + entry + "\n");
+    if (content.includes(entry)) {
+      if (content.includes(legacyEntry)) {
+        const updated2 = content.replaceAll(legacyEntry, entry);
+        fs2.writeFileSync(gitignorePath, updated2.trimEnd() + "\n");
+      }
+      return;
+    }
+    const updated = content.includes(legacyEntry) ? content.replaceAll(legacyEntry, entry) : content;
+    fs2.writeFileSync(gitignorePath, updated.trimEnd() + "\n" + entry + "\n");
   } catch {
     fs2.writeFileSync(gitignorePath, entry + "\n");
   }
@@ -158,6 +267,7 @@ function ensureGitignore(dir = process.cwd()) {
 
 // src/lib/git.ts
 import fs3 from "fs";
+import path3 from "path";
 import git from "isomorphic-git";
 var AUTHOR = { name: "Vibeversion", email: "cli@vibeversion.com" };
 async function ensureRepo(dir) {
@@ -185,6 +295,10 @@ async function stageAll(dir) {
     }
   }
 }
+async function isWorktreeClean(dir) {
+  const statusMatrix = await git.statusMatrix({ fs: fs3, dir });
+  return statusMatrix.every(([, head, workdir, stage]) => head === workdir && workdir === stage);
+}
 async function commit(dir, message) {
   return git.commit({
     fs: fs3,
@@ -243,6 +357,168 @@ async function diffStats(dir) {
   }
   return { filesChanged, insertions, deletions };
 }
+var MAX_DIFF_BYTES = 50 * 1024;
+async function perFileStats(dir) {
+  const first = await isFirstCommit(dir);
+  if (first) return [];
+  const headOid = await git.resolveRef({ fs: fs3, dir, ref: "HEAD" });
+  const headCommit = await git.readCommit({ fs: fs3, dir, oid: headOid });
+  const currentTree = headCommit.commit.tree;
+  let parentTree = null;
+  if (headCommit.commit.parent.length > 0) {
+    const parentCommit = await git.readCommit({ fs: fs3, dir, oid: headCommit.commit.parent[0] });
+    parentTree = parentCommit.commit.tree;
+  }
+  const currentFiles = await walkTree(dir, currentTree);
+  const parentFiles = parentTree ? await walkTree(dir, parentTree) : /* @__PURE__ */ new Map();
+  const stats = [];
+  for (const [filepath, currentOid] of currentFiles) {
+    const parentOid = parentFiles.get(filepath);
+    if (!parentOid) {
+      const content = await readBlob(dir, currentOid);
+      stats.push({ path: filepath, insertions: countLines(content), deletions: 0 });
+    } else if (parentOid !== currentOid) {
+      const oldContent = await readBlob(dir, parentOid);
+      const newContent = await readBlob(dir, currentOid);
+      const oldLines = countLines(oldContent);
+      const newLines = countLines(newContent);
+      stats.push({
+        path: filepath,
+        insertions: Math.max(0, newLines - oldLines),
+        deletions: Math.max(0, oldLines - newLines)
+      });
+    }
+  }
+  for (const [filepath] of parentFiles) {
+    if (!currentFiles.has(filepath)) {
+      const content = await readBlob(dir, parentFiles.get(filepath));
+      stats.push({ path: filepath, insertions: 0, deletions: countLines(content) });
+    }
+  }
+  return stats;
+}
+async function generateDiffText(dir) {
+  const first = await isFirstCommit(dir);
+  if (first) return null;
+  const headOid = await git.resolveRef({ fs: fs3, dir, ref: "HEAD" });
+  const headCommit = await git.readCommit({ fs: fs3, dir, oid: headOid });
+  const currentTree = headCommit.commit.tree;
+  let parentTree = null;
+  if (headCommit.commit.parent.length > 0) {
+    const parentCommit = await git.readCommit({ fs: fs3, dir, oid: headCommit.commit.parent[0] });
+    parentTree = parentCommit.commit.tree;
+  }
+  const currentFiles = await walkTree(dir, currentTree);
+  const parentFiles = parentTree ? await walkTree(dir, parentTree) : /* @__PURE__ */ new Map();
+  const chunks = [];
+  let totalBytes = 0;
+  for (const [filepath, currentOid] of currentFiles) {
+    const parentOid = parentFiles.get(filepath);
+    if (!parentOid) {
+      const content = await readBlob(dir, currentOid);
+      const lines = content.split("\n").map((l) => `+${l}`);
+      const chunk = `--- /dev/null
++++ b/${filepath}
+${lines.join("\n")}
+`;
+      totalBytes += Buffer.byteLength(chunk);
+      if (totalBytes > MAX_DIFF_BYTES) break;
+      chunks.push(chunk);
+    } else if (parentOid !== currentOid) {
+      const oldContent = await readBlob(dir, parentOid);
+      const newContent = await readBlob(dir, currentOid);
+      const oldLines = oldContent.split("\n");
+      const newLines = newContent.split("\n");
+      const removed = oldLines.filter((l) => !newLines.includes(l)).map((l) => `-${l}`);
+      const added = newLines.filter((l) => !oldLines.includes(l)).map((l) => `+${l}`);
+      const chunk = `--- a/${filepath}
++++ b/${filepath}
+${[...removed, ...added].join("\n")}
+`;
+      totalBytes += Buffer.byteLength(chunk);
+      if (totalBytes > MAX_DIFF_BYTES) break;
+      chunks.push(chunk);
+    }
+  }
+  for (const [filepath] of parentFiles) {
+    if (!currentFiles.has(filepath)) {
+      const content = await readBlob(dir, parentFiles.get(filepath));
+      const lines = content.split("\n").map((l) => `-${l}`);
+      const chunk = `--- a/${filepath}
++++ /dev/null
+${lines.join("\n")}
+`;
+      totalBytes += Buffer.byteLength(chunk);
+      if (totalBytes > MAX_DIFF_BYTES) break;
+      chunks.push(chunk);
+    }
+  }
+  return chunks.length > 0 ? chunks.join("\n") : null;
+}
+async function restoreCommit(dir, commitHash) {
+  const commitObj = await git.readCommit({ fs: fs3, dir, oid: commitHash });
+  const targetTree = commitObj.commit.tree;
+  const targetFiles = await walkTree(dir, targetTree);
+  const statusMatrix = await git.statusMatrix({ fs: fs3, dir });
+  for (const [filepath] of statusMatrix) {
+    const fullPath = path3.join(dir, filepath);
+    try {
+      fs3.unlinkSync(fullPath);
+    } catch {
+    }
+  }
+  for (const [filepath, oid] of targetFiles) {
+    const fullPath = path3.join(dir, filepath);
+    const dirPath = path3.dirname(fullPath);
+    fs3.mkdirSync(dirPath, { recursive: true });
+    const { blob } = await git.readBlob({ fs: fs3, dir, oid });
+    fs3.writeFileSync(fullPath, Buffer.from(blob));
+  }
+  cleanEmptyDirs(dir, dir);
+}
+async function listFiles(dir, commitHash) {
+  let oid;
+  if (commitHash) {
+    oid = commitHash;
+  } else {
+    oid = await git.resolveRef({ fs: fs3, dir, ref: "HEAD" });
+  }
+  const commitObj = await git.readCommit({ fs: fs3, dir, oid });
+  const treeOid = commitObj.commit.tree;
+  const files = await walkTreeWithSize(dir, treeOid);
+  return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function walkTreeWithSize(dir, treeOid, prefix = "") {
+  const files = [];
+  const { tree } = await git.readTree({ fs: fs3, dir, oid: treeOid });
+  for (const entry of tree) {
+    const filepath = prefix ? `${prefix}/${entry.path}` : entry.path;
+    if (entry.type === "blob") {
+      const { blob } = await git.readBlob({ fs: fs3, dir, oid: entry.oid });
+      files.push({ path: filepath, size: blob.length });
+    } else if (entry.type === "tree") {
+      const subtree = await walkTreeWithSize(dir, entry.oid, filepath);
+      files.push(...subtree);
+    }
+  }
+  return files;
+}
+function cleanEmptyDirs(dir, rootDir) {
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && entry.name !== ".git" && entry.name !== ".vv") {
+      const fullPath = path3.join(dir, entry.name);
+      cleanEmptyDirs(fullPath, rootDir);
+      try {
+        const remaining = fs3.readdirSync(fullPath);
+        if (remaining.length === 0) {
+          fs3.rmdirSync(fullPath);
+        }
+      } catch {
+      }
+    }
+  }
+}
 async function walkTree(dir, treeOid, prefix = "") {
   const files = /* @__PURE__ */ new Map();
   const { tree } = await git.readTree({ fs: fs3, dir, oid: treeOid });
@@ -268,11 +544,170 @@ function countLines(content) {
   return content.split("\n").length;
 }
 
+// src/lib/hooks.ts
+import fs4 from "fs";
+import path4 from "path";
+import chalk2 from "chalk";
+function setupClaudeCodeHook(dir) {
+  const claudeDir = path4.join(dir, ".claude");
+  const settingsPath = path4.join(claudeDir, "settings.json");
+  if (!fs4.existsSync(claudeDir)) {
+    fs4.mkdirSync(claudeDir, { recursive: true });
+  }
+  let settings = {};
+  if (fs4.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs4.readFileSync(settingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  const existing = settings.hooks.PostToolUse ?? [];
+  const alreadyHasHook = existing.some((h) => h.hooks?.some((hook) => hook.command?.includes("vv save")));
+  if (alreadyHasHook) {
+    return false;
+  }
+  settings.hooks.PostToolUse = [
+    ...existing,
+    {
+      matcher: "Write|Edit",
+      hooks: [
+        {
+          type: "command",
+          command: "vv save --auto",
+          timeout: 30
+        }
+      ]
+    }
+  ];
+  fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return true;
+}
+function setupCursorRule(dir) {
+  const cursorDir = path4.join(dir, ".cursor", "rules");
+  const rulePath = path4.join(cursorDir, "vibeversion.mdc");
+  if (fs4.existsSync(rulePath)) {
+    return false;
+  }
+  fs4.mkdirSync(cursorDir, { recursive: true });
+  const content = `---
+alwaysApply: true
+---
+This project uses Vibeversion for version tracking.
+After completing a task or making significant changes, run \`vv save\` to snapshot the project.
+Available commands: \`vv save\`, \`vv deploy\`, \`vv restore\`, \`vv files\`.
+`;
+  fs4.writeFileSync(rulePath, content);
+  return true;
+}
+function setupOpenCodePlugin(dir) {
+  const pluginDir = path4.join(dir, ".opencode", "plugins");
+  const pluginPath = path4.join(pluginDir, "vibeversion.js");
+  if (fs4.existsSync(pluginPath)) {
+    return false;
+  }
+  fs4.mkdirSync(pluginDir, { recursive: true });
+  const content = `export const VibeversionPlugin = async ({ $ }) => {
+  const debounceMs = 12000
+  let timer = null
+  let inFlight = false
+
+  const shouldIgnore = (filePath) => {
+    if (!filePath) return false
+    const normalized = String(filePath).replaceAll('\\\\', '/')
+
+    if (normalized.includes('/.git/')) return true
+    if (normalized.includes('/.vv/')) return true
+    if (normalized.includes('/.opencode/')) return true
+    if (normalized.endsWith('/.opencode/plugins/vibeversion.js')) return true
+
+    return false
+  }
+
+  const runSave = async () => {
+    if (inFlight) {
+      timer = setTimeout(runSave, debounceMs)
+      return
+    }
+
+    inFlight = true
+
+    try {
+      await $\`vv save --auto\`
+    } catch {
+      // Best-effort auto-save
+    } finally {
+      inFlight = false
+    }
+  }
+
+  return {
+    'file.edited': async (input) => {
+      const filePath =
+        input?.path ??
+        input?.file?.path ??
+        input?.filePath ??
+        input?.file?.name ??
+        input?.file
+
+      if (shouldIgnore(filePath)) return
+
+      if (timer) clearTimeout(timer)
+      timer = setTimeout(runSave, debounceMs)
+    },
+  }
+}
+`;
+  fs4.writeFileSync(pluginPath, content);
+  return true;
+}
+function setupClaudeMd(dir) {
+  const claudeMdPath = path4.join(dir, "CLAUDE.md");
+  const section = `
+## Vibeversion
+
+This project uses Vibeversion for version tracking. After completing a task, run \`vv save\` to snapshot the project.
+
+Available commands:
+- \`vv save\` - Save the current state
+- \`vv deploy\` - Save and deploy
+- \`vv restore\` - Restore to a previous version
+- \`vv files\` - List files in a version
+`;
+  if (fs4.existsSync(claudeMdPath)) {
+    const existing = fs4.readFileSync(claudeMdPath, "utf-8");
+    if (existing.includes("Vibeversion")) {
+      return false;
+    }
+    fs4.appendFileSync(claudeMdPath, section);
+  } else {
+    fs4.writeFileSync(claudeMdPath, `# CLAUDE.md
+${section}`);
+  }
+  return true;
+}
+function setupAllHooks(dir) {
+  const claudeResult = setupClaudeCodeHook(dir);
+  console.log(claudeResult ? chalk2.green("  \u2713 Claude Code hook added (.claude/settings.json)") : chalk2.dim("  - Claude Code hook already exists"));
+  const cursorResult = setupCursorRule(dir);
+  console.log(cursorResult ? chalk2.green("  \u2713 Cursor rule added (.cursor/rules/vibeversion.mdc)") : chalk2.dim("  - Cursor rule already exists"));
+  const openCodeResult = setupOpenCodePlugin(dir);
+  console.log(
+    openCodeResult ? chalk2.green("  \u2713 OpenCode plugin added (.opencode/plugins/vibeversion.js)") : chalk2.dim("  - OpenCode plugin already exists")
+  );
+  const claudeMdResult = setupClaudeMd(dir);
+  console.log(
+    claudeMdResult ? chalk2.green("  \u2713 CLAUDE.md updated with Vibeversion commands") : chalk2.dim("  - CLAUDE.md already has Vibeversion section")
+  );
+}
+
 // src/commands/init.ts
 async function initCommand() {
   const auth = getAuthConfig();
   if (!auth) {
-    console.log(chalk2.red("Not logged in. Run `vv login` first."));
+    console.log(chalk3.red("Not logged in. Run `vv login` first."));
     process.exit(1);
   }
   const spinner = ora2("Fetching your projects...").start();
@@ -287,7 +722,7 @@ async function initCommand() {
   }
   spinner.stop();
   if (projects.length === 0) {
-    console.log(chalk2.yellow("No projects found. Create one on your Vibeversion dashboard first."));
+    console.log(chalk3.yellow("No projects found. Create one on your Vibeversion dashboard first."));
     process.exit(1);
   }
   const projectUlid = await select({
@@ -303,50 +738,78 @@ async function initCommand() {
   saveProjectConfig({ projectUlid, apiUrl: auth.apiUrl, projectName: project.name }, dir);
   ensureGitignore(dir);
   await ensureRepo(dir);
-  setupSpinner.succeed(`Linked to ${chalk2.cyan(project.name)}. Run ${chalk2.bold("vv save")} to save your first version.`);
+  setupSpinner.succeed(`Linked to ${chalk3.cyan(project.name)}.`);
+  const setupHooks = await confirm({
+    message: "Set up auto-save hooks for AI tools (Claude Code, Cursor, OpenCode)?",
+    default: true
+  });
+  if (setupHooks) {
+    console.log("");
+    setupAllHooks(dir);
+  }
+  console.log(chalk3.green(`
+Run ${chalk3.bold("vv save")} to save your first version.
+`));
 }
 
 // src/commands/save.ts
 import { input as input2 } from "@inquirer/prompts";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import ora3 from "ora";
-async function saveCommand() {
+async function saveCommand(options = {}) {
   const auth = getAuthConfig();
   if (!auth) {
-    console.log(chalk3.red("Not logged in. Run `vv login` first."));
+    console.log(chalk4.red("Not logged in. Run `vv login` first."));
     process.exit(1);
   }
   const dir = process.cwd();
   const project = getProjectConfig(dir);
   if (!project) {
-    console.log(chalk3.red("Project not initialized. Run `vv init` first."));
+    console.log(chalk4.red("Project not initialized. Run `vv init` first."));
     process.exit(1);
   }
-  const title = await input2({
-    message: "What did you change?",
-    validate: (v) => v.trim().length > 0 ? true : "A title is required"
-  });
-  const synopsis = await input2({
-    message: "Any extra details? (optional)"
-  });
+  const worktreeClean = await isWorktreeClean(dir);
+  if (worktreeClean) {
+    console.log(chalk4.yellow("No changes to save."));
+    return;
+  }
+  let title;
+  let synopsis;
+  if (options.auto) {
+    const stats = await diffStats(dir);
+    title = `Auto-save: ${stats.filesChanged} ${stats.filesChanged === 1 ? "file" : "files"} changed`;
+    synopsis = void 0;
+  } else {
+    title = await input2({
+      message: "What did you change?",
+      validate: (v) => v.trim().length > 0 ? true : "A title is required"
+    });
+    synopsis = await input2({
+      message: "Any extra details? (optional)"
+    });
+  }
   const spinner = ora3("Saving...").start();
   try {
     await stageAll(dir);
     const commitHash = await commit(dir, title);
     const stats = await diffStats(dir);
+    const fileStats = await perFileStats(dir);
+    const diffText = await generateDiffText(dir);
     const client = new ApiClient(project.apiUrl, auth.token);
     await client.createVersion(project.projectUlid, {
       commit_hash: commitHash,
       title,
       synopsis: synopsis || void 0,
       risk_level: "low",
-      type: "named_save",
+      type: options.auto ? "auto_save" : "named_save",
       files_changed: stats.filesChanged,
       insertions: stats.insertions,
-      deletions: stats.deletions
+      deletions: stats.deletions,
+      diff_text: diffText,
+      per_file_stats: fileStats.length > 0 ? fileStats : void 0
     });
     spinner.succeed(
-      `Saved! ${chalk3.bold(`"${title}"`)} ${chalk3.dim(`- ${stats.filesChanged} files changed, +${stats.insertions} -${stats.deletions}`)}`
+      `Saved! ${chalk4.bold(`"${title}"`)} ${chalk4.dim(`- ${stats.filesChanged} files changed, +${stats.insertions} -${stats.deletions}`)}`
     );
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
@@ -355,9 +818,278 @@ async function saveCommand() {
   }
 }
 
+// src/commands/deploy.ts
+import { input as input3 } from "@inquirer/prompts";
+import chalk5 from "chalk";
+import ora4 from "ora";
+async function deployCommand(options = {}) {
+  const auth = getAuthConfig();
+  if (!auth) {
+    console.log(chalk5.red("Not logged in. Run `vv login` first."));
+    process.exit(1);
+  }
+  const dir = process.cwd();
+  const project = getProjectConfig(dir);
+  if (!project) {
+    console.log(chalk5.red("Project not initialized. Run `vv init` first."));
+    process.exit(1);
+  }
+  const worktreeClean = await isWorktreeClean(dir);
+  if (worktreeClean) {
+    console.log(chalk5.yellow("No changes to deploy."));
+    return;
+  }
+  let title;
+  let synopsis;
+  if (options.auto) {
+    const stats = await diffStats(dir);
+    title = `Auto-deploy: ${stats.filesChanged} ${stats.filesChanged === 1 ? "file" : "files"} changed`;
+    synopsis = void 0;
+  } else {
+    title = await input3({
+      message: "What are you deploying?",
+      validate: (v) => v.trim().length > 0 ? true : "A title is required"
+    });
+    synopsis = await input3({
+      message: "Any extra details? (optional)"
+    });
+  }
+  const spinner = ora4("Saving and deploying...").start();
+  try {
+    await stageAll(dir);
+    const commitHash = await commit(dir, title);
+    const stats = await diffStats(dir);
+    const fileStats = await perFileStats(dir);
+    const diffText = await generateDiffText(dir);
+    const client = new ApiClient(project.apiUrl, auth.token);
+    await client.createVersion(project.projectUlid, {
+      commit_hash: commitHash,
+      title,
+      synopsis: synopsis || void 0,
+      risk_level: "low",
+      type: "deploy_save",
+      files_changed: stats.filesChanged,
+      insertions: stats.insertions,
+      deletions: stats.deletions,
+      diff_text: diffText,
+      per_file_stats: fileStats.length > 0 ? fileStats : void 0
+    });
+    await client.triggerDeploy(project.projectUlid, {
+      commit_hash: commitHash
+    });
+    spinner.succeed(
+      `Deployed! ${chalk5.bold(`"${title}"`)} ${chalk5.dim(`- ${stats.filesChanged} files changed, +${stats.insertions} -${stats.deletions}`)}`
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail(`Deploy failed: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/restore.ts
+import { select as select2 } from "@inquirer/prompts";
+import chalk6 from "chalk";
+import ora5 from "ora";
+async function restoreCommand() {
+  const auth = getAuthConfig();
+  if (!auth) {
+    console.log(chalk6.red("Not logged in. Run `vv login` first."));
+    process.exit(1);
+  }
+  const dir = process.cwd();
+  const project = getProjectConfig(dir);
+  if (!project) {
+    console.log(chalk6.red("Project not initialized. Run `vv init` first."));
+    process.exit(1);
+  }
+  const client = new ApiClient(project.apiUrl, auth.token);
+  const fetchSpinner = ora5("Fetching versions...").start();
+  let versions;
+  try {
+    const response = await client.listVersions(project.projectUlid);
+    versions = response.data;
+  } catch {
+    fetchSpinner.fail("Could not fetch versions. Check your connection and try again.");
+    process.exit(1);
+  }
+  fetchSpinner.stop();
+  if (versions.length === 0) {
+    console.log(chalk6.yellow("No versions found. Save your project first with `vv save`."));
+    process.exit(1);
+  }
+  const selectedHash = await select2({
+    message: "Which version do you want to restore?",
+    choices: versions.map((v) => ({
+      name: `${v.title} ${chalk6.dim(`(${new Date(v.created_at).toLocaleDateString()})`)}`,
+      value: v.commit_hash,
+      description: v.synopsis || void 0
+    }))
+  });
+  const selectedVersion = versions.find((v) => v.commit_hash === selectedHash);
+  const restoreSpinner = ora5("Restoring...").start();
+  try {
+    await stageAll(dir);
+    const autoHash = await commit(dir, `Auto-save before restore to: ${selectedVersion.title}`);
+    const autoStats = await diffStats(dir);
+    await client.createVersion(project.projectUlid, {
+      commit_hash: autoHash,
+      title: `Auto-save before restore`,
+      synopsis: `Automatic backup before restoring to: ${selectedVersion.title}`,
+      risk_level: "low",
+      type: "auto_save",
+      files_changed: autoStats.filesChanged,
+      insertions: autoStats.insertions,
+      deletions: autoStats.deletions
+    });
+    await restoreCommit(dir, selectedHash);
+    await stageAll(dir);
+    const restoreHash = await commit(dir, `Restored to: ${selectedVersion.title}`);
+    const restoreStats = await diffStats(dir);
+    await client.createVersion(project.projectUlid, {
+      commit_hash: restoreHash,
+      title: `Restored to: ${selectedVersion.title}`,
+      risk_level: "low",
+      type: "named_save",
+      files_changed: restoreStats.filesChanged,
+      insertions: restoreStats.insertions,
+      deletions: restoreStats.deletions
+    });
+    restoreSpinner.succeed(
+      `Restored to ${chalk6.bold(`"${selectedVersion.title}"`)} ${chalk6.dim(`- ${restoreStats.filesChanged} files changed`)}`
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    restoreSpinner.fail(`Restore failed: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/files.ts
+import { select as select3 } from "@inquirer/prompts";
+import chalk7 from "chalk";
+import ora6 from "ora";
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function printTree(files) {
+  const tree = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const parts = file.path.split("/");
+    const dir = parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
+    if (!tree.has(dir)) tree.set(dir, []);
+    tree.get(dir).push(file);
+  }
+  for (const [dir, dirFiles] of [...tree.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    if (dir !== ".") {
+      console.log(chalk7.blue(`  ${dir}/`));
+    }
+    for (const file of dirFiles) {
+      const name = file.path.split("/").pop();
+      const size = chalk7.dim(formatSize(file.size));
+      const indent = dir === "." ? "  " : "    ";
+      console.log(`${indent}${name}  ${size}`);
+    }
+  }
+}
+async function filesCommand(options) {
+  const dir = process.cwd();
+  const project = getProjectConfig(dir);
+  if (!project) {
+    console.log(chalk7.red("Project not initialized. Run `vv init` first."));
+    process.exit(1);
+  }
+  let commitHash;
+  if (options.version) {
+    const auth = getAuthConfig();
+    if (!auth) {
+      console.log(chalk7.red("Not logged in. Run `vv login` first."));
+      process.exit(1);
+    }
+    const client = new ApiClient(project.apiUrl, auth.token);
+    const fetchSpinner = ora6("Fetching versions...").start();
+    try {
+      const response = await client.listVersions(project.projectUlid);
+      const versions = response.data;
+      fetchSpinner.stop();
+      if (versions.length === 0) {
+        console.log(chalk7.yellow("No versions found."));
+        process.exit(1);
+      }
+      commitHash = await select3({
+        message: "Which version?",
+        choices: versions.map((v) => ({
+          name: `${v.title} ${chalk7.dim(`(${new Date(v.created_at).toLocaleDateString()})`)}`,
+          value: v.commit_hash
+        }))
+      });
+    } catch {
+      fetchSpinner.fail("Could not fetch versions.");
+      process.exit(1);
+    }
+  }
+  const spinner = ora6("Reading files...").start();
+  try {
+    const files = await listFiles(dir, commitHash);
+    spinner.stop();
+    console.log(chalk7.bold(`
+  ${files.length} files
+`));
+    printTree(files);
+    console.log();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail(`Could not read files: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/hooks.ts
+import chalk8 from "chalk";
+async function hooksCommand(options) {
+  const dir = process.cwd();
+  const project = getProjectConfig(dir);
+  if (!project) {
+    console.log(chalk8.red("Project not initialized. Run `vv init` first."));
+    process.exit(1);
+  }
+  console.log(chalk8.bold("\nSetting up AI tool hooks...\n"));
+  if (options.all || !options.claude && !options.cursor && !options.opencode) {
+    setupAllHooks(dir);
+  } else {
+    if (options.claude) {
+      const result = setupClaudeCodeHook(dir);
+      console.log(
+        result ? chalk8.green("  \u2713 Claude Code hook added (.claude/settings.json)") : chalk8.dim("  - Claude Code hook already exists")
+      );
+      const mdResult = setupClaudeMd(dir);
+      console.log(
+        mdResult ? chalk8.green("  \u2713 CLAUDE.md updated with Vibeversion commands") : chalk8.dim("  - CLAUDE.md already has Vibeversion section")
+      );
+    }
+    if (options.cursor) {
+      const result = setupCursorRule(dir);
+      console.log(result ? chalk8.green("  \u2713 Cursor rule added (.cursor/rules/vibeversion.mdc)") : chalk8.dim("  - Cursor rule already exists"));
+    }
+    if (options.opencode) {
+      const result = setupOpenCodePlugin(dir);
+      console.log(
+        result ? chalk8.green("  \u2713 OpenCode plugin added (.opencode/plugins/vibeversion.js)") : chalk8.dim("  - OpenCode plugin already exists")
+      );
+    }
+  }
+  console.log(chalk8.green("\nDone! Auto-save hooks are ready.\n"));
+}
+
 // src/index.ts
-program.name("vv").description("Save and version your projects with Vibeversion").version("0.1.1");
+program.name("vv").description("Save and version your projects with Vibeversion").version("0.2.0");
 program.command("login").description("Log in to your Vibeversion account").action(loginCommand);
 program.command("init").description("Link this folder to a Vibeversion project").action(initCommand);
-program.command("save").description("Save the current state of your project").action(saveCommand);
+program.command("save").description("Save the current state of your project").option("--auto", "Non-interactive mode with auto-generated title").action(saveCommand);
+program.command("deploy").description("Save and deploy your project").option("--auto", "Non-interactive mode with auto-generated title").action(deployCommand);
+program.command("restore").description("Restore your project to a previous version").action(restoreCommand);
+program.command("files").description("List files in the current or a specific version").option("--version", "Choose a specific version to view").action(filesCommand);
+program.command("hooks").description("Set up auto-save hooks for AI tools (Claude Code, Cursor, OpenCode)").option("--claude", "Only set up Claude Code hook").option("--cursor", "Only set up Cursor rule").option("--opencode", "Only set up OpenCode plugin").option("--all", "Set up all hooks").action(hooksCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vibeversion/cli",
-    "version": "0.1.1",
+    "version": "0.2.1",
     "description": "Save and version your projects with Vibeversion",
     "type": "module",
     "bin": {