neovate-code-wrapped 1.0.0

package/.releaserc.mjs

@@ -0,0 +1,28 @@
+/**
+ * @type {import('semantic-release').GlobalConfig}
+ */
+export default {
+  branches: [
+    "main",
+    { name: "beta", prerelease: true },
+    { name: "alpha", prerelease: true },
+  ],
+  plugins: [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    [
+      "@semantic-release/exec",
+      {
+        publishCmd: "bun run ./scripts/publish.ts ${nextRelease.version}",
+      },
+    ],
+    [
+      "@semantic-release/git",
+      {
+        assets: ["package.json"],
+        message: "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}",
+      },
+    ],
+    "@semantic-release/github",
+  ],
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vlad Ivanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+<div align="center">
+
+# neovate-code-wrapped
+
+**Your year in code, beautifully visualized.**
+
+Generate a personalized "Spotify Wrapped"-style summary of your [Neovate](https://neovateai.dev/en) usage.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Bun](https://img.shields.io/badge/Bun-%23000000.svg?logo=bun&logoColor=white)](https://bun.sh)
+
+<img src="./assets/images/demo-wrapped.png" alt="Neovate Wrapped Example" width="600" />
+
+</div>
+
+---
+
+## Installation
+
+### Quick Start
+
+Run directly without installing:
+
+```bash
+npx neovate-code-wrapped # or bunx, or yarn/pnpm dlx
+```
+
+### Global Install
+
+```bash
+npm install -g neovate-code-wrapped # or bun/yarn/pnpm
+```
+
+Then run anywhere:
+
+```bash
+neovate-wrapped
+```
+
+## Usage Options
+
+| Option          | Description                          |
+| --------------- | ------------------------------------ |
+| `--year, -y`    | Generate wrapped for a specific year |
+| `--help, -h`    | Show help message                    |
+| `--version, -v` | Show version number                  |
+
+## Features
+
+- Sessions, messages, tokens, projects, and streaks
+- GitHub-style activity heatmap
+- Top models and providers breakdown
+- Estimated cost tracking
+- Shareable PNG image
+- Inline image display (Ghostty, Kitty, iTerm2, WezTerm, Konsole)
+- Auto-copy to clipboard
+
+## Terminal Support
+
+The wrapped image displays natively in terminals that support inline images:
+
+| Terminal                                   | Protocol       | Status                      |
+| ------------------------------------------ | -------------- | --------------------------- |
+| [Ghostty](https://ghostty.org)             | Kitty Graphics | ✅ Full support             |
+| [Kitty](https://sw.kovidgoyal.net/kitty/)  | Kitty Graphics | ✅ Full support             |
+| [WezTerm](https://wezfurlong.org/wezterm/) | Kitty + iTerm2 | ✅ Full support             |
+| [iTerm2](https://iterm2.com)               | iTerm2 Inline  | ✅ Full support             |
+| [Konsole](https://konsole.kde.org)         | Kitty Graphics | ✅ Full support             |
+| Other terminals                            | —              | ⚠️ Image saved to file only |
+
+## Output
+
+The tool generates:
+
+1. **Terminal Summary** — Quick stats overview in your terminal
+2. **PNG Image** — A beautiful, shareable wrapped card saved to your home directory
+3. **Clipboard** — Automatically copies the image to your clipboard
+
+## Data Source
+
+Neovate Wrapped reads data from your local Neovate installation:
+
+```
+~/.neovate/projects/
+```
+
+No data is sent anywhere. Everything is processed locally.
+
+## Building
+
+### Development
+
+```bash
+# Run in development mode with hot reload
+bun run dev
+```
+
+### Production Build
+
+```bash
+# Build for all platforms
+bun run build
+```
+
+### Releasing
+
+Releases are automated via [semantic-release](https://semantic-release.gitbook.io). Merging PRs with [conventional commits](https://www.conventionalcommits.org) to `main` triggers a release.
+
+## Tech Stack
+
+- **Runtime**: [Bun](https://bun.sh)
+- **Image Generation**: [Satori](https://github.com/vercel/satori) + [Resvg](https://github.com/nicolo-ribaudo/resvg-js)
+- **CLI UI**: [@clack/prompts](https://github.com/natemoo-re/clack)
+- **Font**: IBM Plex Mono
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+---
+
+<div align="center">
+
+Made with ❤️ for the [Neovate](https://neovateai.dev/en) community
+
+</div>

package/bin/neovate-code-wrapped

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import { dirname, join } from "node:path";
+import { platform as osPlatform, arch as osArch } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function run(target) {
+  const result = spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+  });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  const code = typeof result.status === "number" ? result.status : 0;
+  process.exit(code);
+}
+
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+};
+
+let platform = platformMap[osPlatform()];
+if (!platform) {
+  platform = osPlatform();
+}
+let arch = archMap[osArch()];
+if (!arch) {
+  arch = osArch();
+}
+const base = "neovate-wrapped-" + platform + "-" + arch;
+const binary = platform === "windows" ? "neovate-wrapped.exe" : "neovate-wrapped";
+
+function findBinary(startDir) {
+  let current = startDir;
+  for (;;) {
+    const modules = join(current, "node_modules");
+    if (fs.existsSync(modules)) {
+      const entries = fs.readdirSync(modules);
+      for (const entry of entries) {
+        if (!entry.startsWith(base)) {
+          continue;
+        }
+        const candidate = join(modules, entry, "bin", binary);
+        if (fs.existsSync(candidate)) {
+          return candidate;
+        }
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+
+const resolved = findBinary(__dirname);
+if (!resolved) {
+  console.error(
+    'It seems that your package manager failed to install the right version of neovate-wrapped CLI for your platform. You can try manually installing "' +
+      base +
+      '" package'
+  );
+  process.exit(1);
+}
+
+run(resolved);

package/mise.toml

@@ -0,0 +1,6 @@
+[tools]
+bun = "1.3.5"
+
+[env]
+_.file = '.env'
+NPM_TOKEN = { required = true }

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "neovate-code-wrapped",
+  "version": "1.0.0",
+  "author": {
+    "name": "iamdin",
+    "email": "iamdinq@gmail.com"
+  },
+  "description": "Generate a personalized Spotify Wrapped-style summary of your Neovate usage",
+  "keywords": [
+    "neovate",
+    "wrapped",
+    "neovate-wrapped",
+    "neovate-code-wrapped"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iamdin/neovate-code-wrapped.git"
+  },
+  "type": "module",
+  "bin": {
+    "neovate-code-wrapped": "./bin/neovate-code-wrapped"
+  },
+  "scripts": {
+    "start": "bun src/index.ts",
+    "dev": "bun run --watch src/index.ts",
+    "build": "tsgo --noEmit && bun run scripts/build.ts",
+    "publish": "bun run scripts/publish.ts",
+    "release": "semantic-release",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "@resvg/resvg-wasm": "^2.6.2",
+    "react": "^19.2.3",
+    "satori": "^0.18.3",
+    "xdg-basedir": "^5.1.0"
+  },
+  "devDependencies": {
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^10.0.1",
+    "@types/bun": "latest",
+    "@types/react": "^19.2.0",
+    "@typescript/native-preview": "^7.0.0-dev.20251223.1",
+    "bunup": "^0.16.10",
+    "semantic-release": "^25.0.2",
+    "typescript": "^5.0.0"
+  }
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for neovate-wrapped
+ *
+ * This script runs after npm install and symlinks the correct platform-specific
+ * binary to the bin directory. It auto-detects:
+ * - Platform (darwin, linux, windows)
+ * - Architecture (arm64, x64)
+ * - Libc (glibc, musl) for Linux
+ * - AVX2 support (baseline vs optimized) for x64
+ */
+
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execSync, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const VERSION_CHECK_TIMEOUT_MS = 5000;
+
+/**
+ * Detect if the system uses musl libc (Alpine Linux, etc.)
+ */
+function detectMusl() {
+  if (os.platform() !== "linux") return false;
+
+  try {
+    // Method 1: Check ldd output
+    const lddOutput = execSync("ldd --version 2>&1 || true", { encoding: "utf8" });
+    if (lddOutput.toLowerCase().includes("musl")) {
+      return true;
+    }
+
+    // Method 2: Check for musl loader
+    const files = fs.readdirSync("/lib").filter((f) => f.startsWith("ld-musl-"));
+    if (files.length > 0) {
+      return true;
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  return false;
+}
+
+/**
+ * Detect if the CPU supports AVX2 instructions
+ */
+function detectAVX2() {
+  if (os.arch() !== "x64") return true; // Only relevant for x64
+
+  try {
+    if (os.platform() === "linux") {
+      const cpuinfo = fs.readFileSync("/proc/cpuinfo", "utf8");
+      return cpuinfo.toLowerCase().includes("avx2");
+    }
+
+    if (os.platform() === "darwin") {
+      const output = execSync("sysctl -n machdep.cpu.features 2>/dev/null || true", {
+        encoding: "utf8",
+      });
+      return output.toLowerCase().includes("avx2");
+    }
+
+    if (os.platform() === "win32") {
+      // Windows: Assume AVX2 support on modern systems
+      // A more robust check would require native code
+      return true;
+    }
+  } catch {
+    // If we can't detect, assume AVX2 is supported
+  }
+
+  return true;
+}
+
+function getPlatformInfo() {
+  let platform;
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin";
+      break;
+    case "linux":
+      platform = "linux";
+      break;
+    case "win32":
+      platform = "windows";
+      break;
+    default:
+      return null;
+  }
+
+  let arch;
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64";
+      break;
+    case "arm64":
+      arch = "arm64";
+      break;
+    default:
+      return null;
+  }
+
+  return { platform, arch };
+}
+
+function buildPackageName(platform, arch, { baseline, musl }) {
+  return [
+    "neovate-wrapped",
+    platform,
+    arch,
+    baseline ? "baseline" : undefined,
+    musl ? "musl" : undefined,
+  ]
+    .filter(Boolean)
+    .join("-");
+}
+
+function getCandidatePackageNames() {
+  const info = getPlatformInfo();
+  if (!info) {
+    return null;
+  }
+
+  const { platform, arch } = info;
+  const isLinux = platform === "linux";
+  const isX64 = arch === "x64";
+  const hasMusl = isLinux && detectMusl();
+  const hasAvx2 = isX64 ? detectAVX2() : true;
+  const candidates = [];
+
+  const addCandidate = (baseline, musl) => {
+    candidates.push(buildPackageName(platform, arch, { baseline, musl }));
+  };
+
+  if (hasMusl) {
+    if (isX64) {
+      if (hasAvx2) {
+        addCandidate(false, true);
+        addCandidate(true, true);
+      } else {
+        addCandidate(true, true);
+      }
+    } else {
+      addCandidate(false, true);
+    }
+    return { candidates, platform, arch, hasMusl, hasAvx2 };
+  }
+
+  if (isX64) {
+    if (hasAvx2) {
+      addCandidate(false, false);
+      addCandidate(true, false);
+    } else {
+      addCandidate(true, false);
+    }
+  } else {
+    addCandidate(false, false);
+  }
+
+  return { candidates, platform, arch, hasMusl, hasAvx2 };
+}
+
+function testBinary(binaryPath) {
+  const result = spawnSync(binaryPath, ["--version"], {
+    stdio: "pipe",
+    timeout: VERSION_CHECK_TIMEOUT_MS,
+  });
+
+  if (result.error) {
+    return { ok: false, reason: result.error.message };
+  }
+
+  if (result.signal) {
+    return { ok: false, reason: `terminated with ${result.signal}` };
+  }
+
+  if (typeof result.status === "number" && result.status !== 0) {
+    return { ok: false, reason: `exited with ${result.status}` };
+  }
+
+  return { ok: true };
+}
+
+/**
+ * Find the binary from the platform package
+ */
+function findBinary(packageName) {
+  const binaryName = os.platform() === "win32" ? "neovate-wrapped.exe" : "neovate-wrapped";
+
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageDir = path.dirname(packageJsonPath);
+    const binaryPath = path.join(packageDir, "bin", binaryName);
+
+    if (fs.existsSync(binaryPath)) {
+      return { binaryPath, binaryName };
+    }
+  } catch {
+    // Package not found via require.resolve
+  }
+
+  // Fallback: try common paths
+  const fallbackPaths = [
+    path.join(__dirname, "..", packageName, "bin", binaryName),
+    path.join(__dirname, "node_modules", packageName, "bin", binaryName),
+  ];
+
+  for (const p of fallbackPaths) {
+    if (fs.existsSync(p)) {
+      return { binaryPath: p, binaryName };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Prepare the bin directory
+ */
+function prepareBinDirectory(binaryName) {
+  const binDir = path.join(__dirname, "bin");
+  const targetPath = path.join(binDir, binaryName);
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  // Remove existing binary/symlink if it exists
+  if (fs.existsSync(targetPath)) {
+    fs.unlinkSync(targetPath);
+  }
+
+  return { binDir, targetPath };
+}
+
+/**
+ * Create symlink (or copy on Windows)
+ */
+function linkBinary(sourcePath, binaryName) {
+  const { targetPath } = prepareBinDirectory(binaryName);
+
+  if (os.platform() === "win32") {
+    // Windows: copy instead of symlink (symlinks require admin)
+    fs.copyFileSync(sourcePath, targetPath);
+  } else {
+    fs.symlinkSync(sourcePath, targetPath);
+  }
+
+  // Verify the file exists
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Failed to create binary at ${targetPath}`);
+  }
+}
+
+async function main() {
+  try {
+    const selection = getCandidatePackageNames();
+
+    if (!selection) {
+      console.error(`neovate-wrapped: Unsupported platform: ${os.platform()}-${os.arch()}`);
+      console.error("Please download the binary manually from:");
+      console.error("https://github.com/moddi3/neovate-code-wrapped/releases");
+      process.exit(0); // Exit gracefully
+    }
+
+    const { candidates, platform, arch, hasMusl, hasAvx2 } = selection;
+    const platformLabel = `${platform}-${arch}${hasMusl ? " (musl)" : ""}`;
+    const featureLabel = arch === "x64" ? (hasAvx2 ? "avx2" : "baseline") : "default";
+    console.log(`neovate-wrapped: Selecting binary for ${platformLabel} (${featureLabel})`);
+
+    let lastFailure = null;
+    for (const packageName of candidates) {
+      const result = findBinary(packageName);
+      if (!result) {
+        continue;
+      }
+
+      const check = testBinary(result.binaryPath);
+      if (!check.ok) {
+        lastFailure = `${packageName} ${check.reason}`;
+        console.log(`neovate-wrapped: ${packageName} failed (${check.reason}), trying fallback`);
+        continue;
+      }
+
+      linkBinary(result.binaryPath, result.binaryName);
+      console.log(`neovate-wrapped: Linked ${packageName}`);
+      return;
+    }
+
+    console.error("neovate-wrapped: Could not find a working binary for this platform.");
+    if (lastFailure) {
+      console.error(`Last error: ${lastFailure}`);
+    }
+    console.error("The optional dependency may have failed to install.");
+    console.error("Please download the binary manually from:");
+    console.error("https://github.com/moddi3/neovate-code-wrapped/releases");
+    process.exit(0);
+  } catch (error) {
+    console.error("neovate-wrapped: Postinstall error:", error.message);
+    process.exit(0); // Exit gracefully to not break npm install
+  }
+}
+
+main();