@vibeversion/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/login.ts
+import { input, password } from "@inquirer/prompts";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/lib/api.ts
+var ApiClient = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  async request(method, path3, body) {
+    const url = `${this.baseUrl}${path3}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      let message;
+      try {
+        const json = JSON.parse(text);
+        message = json.message || json.error || text;
+      } catch {
+        message = text;
+      }
+      throw new ApiError(response.status, message);
+    }
+    return await response.json();
+  }
+  async createToken(email, password2, deviceName = "vv-cli") {
+    return this.request("POST", "/api/auth/token", {
+      email,
+      password: password2,
+      device_name: deviceName
+    });
+  }
+  async listProjects() {
+    return this.request("GET", "/api/projects");
+  }
+  async createVersion(projectUlid, data) {
+    return this.request("POST", `/api/projects/${projectUlid}/versions`, data);
+  }
+};
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+
+// src/lib/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".vibeversion");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function getAuthConfig() {
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveAuthConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+    mode: 384
+  });
+}
+
+// src/commands/login.ts
+var DEFAULT_API_URL = "https://vibeversion.com";
+async function loginCommand() {
+  console.log(chalk.bold("\nLog in to Vibeversion\n"));
+  const apiUrl = process.env.VV_API_URL || await input({
+    message: "API URL",
+    default: DEFAULT_API_URL
+  });
+  const email = await input({
+    message: "Email",
+    validate: (v) => v.includes("@") ? true : "Enter a valid email"
+  });
+  const pw = await password({
+    message: "Password",
+    mask: "*"
+  });
+  const spinner = ora("Logging in...").start();
+  try {
+    const client = new ApiClient(apiUrl);
+    const { token } = await client.createToken(email, pw);
+    saveAuthConfig({ token, apiUrl, email });
+    spinner.succeed(`Logged in as ${chalk.cyan(email)}`);
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 422) {
+      spinner.fail("Invalid email or password.");
+    } else if (error instanceof ApiError) {
+      spinner.fail(`Login failed: ${error.message}`);
+    } else {
+      spinner.fail("Could not connect to server. Check the API URL and try again.");
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+import { select } from "@inquirer/prompts";
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/lib/project.ts
+import fs2 from "fs";
+import path2 from "path";
+var PROJECT_DIR = ".vibeversion";
+var PROJECT_FILE = "config.json";
+function getProjectConfigPath(dir) {
+  return path2.join(dir, PROJECT_DIR, PROJECT_FILE);
+}
+function getProjectConfig(dir = process.cwd()) {
+  try {
+    const raw = fs2.readFileSync(getProjectConfigPath(dir), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveProjectConfig(config, dir = process.cwd()) {
+  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");
+}
+function ensureGitignore(dir = process.cwd()) {
+  const gitignorePath = path2.join(dir, ".gitignore");
+  const entry = ".vibeversion/";
+  try {
+    const content = fs2.readFileSync(gitignorePath, "utf-8");
+    if (content.includes(entry)) return;
+    fs2.writeFileSync(gitignorePath, content.trimEnd() + "\n" + entry + "\n");
+  } catch {
+    fs2.writeFileSync(gitignorePath, entry + "\n");
+  }
+}
+
+// src/lib/git.ts
+import fs3 from "fs";
+import git from "isomorphic-git";
+var AUTHOR = { name: "Vibeversion", email: "cli@vibeversion.com" };
+async function ensureRepo(dir) {
+  try {
+    await git.findRoot({ fs: fs3, filepath: dir });
+  } catch {
+    await git.init({ fs: fs3, dir });
+  }
+}
+async function isFirstCommit(dir) {
+  try {
+    await git.resolveRef({ fs: fs3, dir, ref: "HEAD" });
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function stageAll(dir) {
+  const statusMatrix = await git.statusMatrix({ fs: fs3, dir });
+  for (const [filepath, head, workdir, stage] of statusMatrix) {
+    if (workdir === 0) {
+      await git.remove({ fs: fs3, dir, filepath });
+    } else if (head !== workdir || head !== stage) {
+      await git.add({ fs: fs3, dir, filepath });
+    }
+  }
+}
+async function commit(dir, message) {
+  return git.commit({
+    fs: fs3,
+    dir,
+    message,
+    author: AUTHOR
+  });
+}
+async function diffStats(dir) {
+  const first = await isFirstCommit(dir);
+  if (first) {
+    return { filesChanged: 0, insertions: 0, deletions: 0 };
+  }
+  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();
+  let filesChanged = 0;
+  let insertions = 0;
+  let deletions = 0;
+  for (const [filepath, currentOid] of currentFiles) {
+    const parentOid = parentFiles.get(filepath);
+    if (!parentOid) {
+      filesChanged++;
+      const content = await readBlob(dir, currentOid);
+      insertions += countLines(content);
+    } else if (parentOid !== currentOid) {
+      filesChanged++;
+      const oldContent = await readBlob(dir, parentOid);
+      const newContent = await readBlob(dir, currentOid);
+      const oldLines = countLines(oldContent);
+      const newLines = countLines(newContent);
+      if (newLines > oldLines) {
+        insertions += newLines - oldLines;
+      } else {
+        deletions += oldLines - newLines;
+      }
+    }
+  }
+  for (const [filepath] of parentFiles) {
+    if (!currentFiles.has(filepath)) {
+      filesChanged++;
+      const content = await readBlob(dir, parentFiles.get(filepath));
+      deletions += countLines(content);
+    }
+  }
+  return { filesChanged, insertions, deletions };
+}
+async function walkTree(dir, treeOid, prefix = "") {
+  const files = /* @__PURE__ */ new Map();
+  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") {
+      files.set(filepath, entry.oid);
+    } else if (entry.type === "tree") {
+      const subtree = await walkTree(dir, entry.oid, filepath);
+      for (const [k, v] of subtree) {
+        files.set(k, v);
+      }
+    }
+  }
+  return files;
+}
+async function readBlob(dir, oid) {
+  const { blob } = await git.readBlob({ fs: fs3, dir, oid });
+  return new TextDecoder().decode(blob);
+}
+function countLines(content) {
+  if (content.length === 0) return 0;
+  return content.split("\n").length;
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  const auth = getAuthConfig();
+  if (!auth) {
+    console.log(chalk2.red("Not logged in. Run `vv login` first."));
+    process.exit(1);
+  }
+  const spinner = ora2("Fetching your projects...").start();
+  const client = new ApiClient(auth.apiUrl, auth.token);
+  let projects;
+  try {
+    const response = await client.listProjects();
+    projects = response.data;
+  } catch {
+    spinner.fail("Could not fetch projects. Try `vv login` again.");
+    process.exit(1);
+  }
+  spinner.stop();
+  if (projects.length === 0) {
+    console.log(chalk2.yellow("No projects found. Create one on your Vibeversion dashboard first."));
+    process.exit(1);
+  }
+  const projectUlid = await select({
+    message: "Which project is this folder for?",
+    choices: projects.map((p) => ({
+      name: `${p.name} (${p.versions_count} saves)`,
+      value: p.ulid
+    }))
+  });
+  const project = projects.find((p) => p.ulid === projectUlid);
+  const dir = process.cwd();
+  const setupSpinner = ora2("Setting up...").start();
+  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.`);
+}
+
+// src/commands/save.ts
+import { input as input2 } from "@inquirer/prompts";
+import chalk3 from "chalk";
+import ora3 from "ora";
+async function saveCommand() {
+  const auth = getAuthConfig();
+  if (!auth) {
+    console.log(chalk3.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."));
+    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 spinner = ora3("Saving...").start();
+  try {
+    await stageAll(dir);
+    const commitHash = await commit(dir, title);
+    const stats = await diffStats(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",
+      files_changed: stats.filesChanged,
+      insertions: stats.insertions,
+      deletions: stats.deletions
+    });
+    spinner.succeed(
+      `Saved! ${chalk3.bold(`"${title}"`)} ${chalk3.dim(`- ${stats.filesChanged} files changed, +${stats.insertions} -${stats.deletions}`)}`
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail(`Save failed: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+program.name("vv").description("Save and version your projects with Vibeversion").version("0.1.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.parse();

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@vibeversion/cli",
+    "version": "0.1.0",
+    "description": "Save and version your projects with Vibeversion",
+    "type": "module",
+    "bin": {
+        "vv": "./dist/index.js"
+    },
+    "scripts": {
+        "build": "tsup",
+        "dev": "tsup --watch"
+    },
+    "files": [
+        "dist"
+    ],
+    "keywords": [
+        "vibeversion",
+        "version-control",
+        "save",
+        "cli"
+    ],
+    "license": "MIT",
+    "dependencies": {
+        "@inquirer/prompts": "^7.0.0",
+        "chalk": "^5.4.0",
+        "commander": "^13.0.0",
+        "isomorphic-git": "^1.27.0",
+        "ora": "^8.2.0"
+    },
+    "devDependencies": {
+        "@types/node": "^22.0.0",
+        "tsup": "^8.0.0",
+        "typescript": "^5.7.0"
+    }
+}