kt-wrapped 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,152 @@
-# Temporary Holding Version
+<div align="center">
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# kt-wrapped
+
+**Your year in code, beautifully visualized.**
+
+<p>
+  <strong>Credit:</strong> Modified from
+  <a href="https://github.com/numman-ali/codex-wrapped">numman-ali/codex-wrapped</a>,
+  which was built on top of
+  <a href="https://github.com/moddi3/opencode-wrapped">opencode-wrapped</a>.
+</p>
+<p>
+  Built for
+  <a href="https://github.com/Kohaku-Lab/KohakuTerrarium">Kohaku-Lab/KohakuTerrarium</a>.
+</p>
+
+Generate a personalized "Spotify Wrapped"-style summary of your
+[KohakuTerrarium](https://github.com/Kohaku-Lab/KohakuTerrarium) 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="KT Wrapped Example" width="600" />
+
+</div>
+
+---
+
+## Installation
+
+### Quick Start
+
+Run directly without installing:
+
+```bash
+npx kt-wrapped # or bunx, or yarn/pnpm dlx
+```
+
+### Global Install
+
+```bash
+npm install -g kt-wrapped # or bun/yarn/pnpm
+```
+
+Then run anywhere:
+
+```bash
+kt-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, turns, tokens, projects, and streaks
+- GitHub-style activity heatmap
+- Top models and providers breakdown
+- Usage cost (when available)
+- 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
+
+`kt-wrapped` reads data from your local KohakuTerrarium session store:
+
+```
+~/.kohakuterrarium/sessions
+```
+
+No data is sent anywhere. Everything is processed locally.
+
+Token pricing for cost estimates is also local and versioned in:
+
+```
+src/pricing-data.ts
+```
+
+If a model is missing from that table, cost is treated as unavailable for that model until it is added in a new release.
+
+## 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">
+
+Built for the KohakuTerrarium community
+
+Credit: <a href="https://github.com/ryoppippi/ccusage">ccusage</a>
+
+</div>

package/bin/kt-wrapped.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..");
+
+function run(command, args) {
+  const result = spawnSync(command, args, {
+    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 localEntry = path.join(projectRoot, "src", "index.ts");
+if (fs.existsSync(localEntry)) {
+  run("bun", [localEntry, ...process.argv.slice(2)]);
+}
+
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+};
+
+let platform = platformMap[os.platform()];
+if (!platform) {
+  platform = os.platform();
+}
+let arch = archMap[os.arch()];
+if (!arch) {
+  arch = os.arch();
+}
+
+const base = "kt-wrapped-" + platform + "-" + arch;
+const binary = platform === "windows" ? "kt-wrapped.exe" : "kt-wrapped";
+
+function findBinary(startDir) {
+  let current = startDir;
+  for (;;) {
+    const modules = path.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 = path.join(modules, entry, "bin", binary);
+        if (fs.existsSync(candidate)) {
+          return candidate;
+        }
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+
+const resolved = findBinary(__dirname);
+if (!resolved) {
+  console.error(
+    'Unable to find a runnable kt-wrapped binary. For local development, run "bun src/index.ts".'
+  );
+  process.exit(1);
+}
+
+run(resolved, process.argv.slice(2));

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "kt-wrapped",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Generate a personalized Spotify Wrapped-style summary of your KohakuTerrarium usage",
+  "bin": {
+    "kt-wrapped": "bin/kt-wrapped.mjs"
+  },
+  "scripts": {
+    "postinstall": "node ./postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "kt-wrapped-linux-arm64": "0.1.0",
+    "kt-wrapped-linux-x64": "0.1.0",
+    "kt-wrapped-linux-x64-baseline": "0.1.0",
+    "kt-wrapped-linux-arm64-musl": "0.1.0",
+    "kt-wrapped-linux-x64-musl": "0.1.0",
+    "kt-wrapped-linux-x64-baseline-musl": "0.1.0",
+    "kt-wrapped-darwin-arm64": "0.1.0",
+    "kt-wrapped-darwin-x64": "0.1.0",
+    "kt-wrapped-darwin-x64-baseline": "0.1.0",
+    "kt-wrapped-windows-x64": "0.1.0",
+    "kt-wrapped-windows-x64-baseline": "0.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Kohaku-Lab/KohakuTerrarium.git"
+  },
+  "homepage": "https://github.com/Kohaku-Lab/KohakuTerrarium",
+  "bugs": {
+    "url": "https://github.com/Kohaku-Lab/KohakuTerrarium/issues"
+  },
+  "keywords": [
+    "kohakuterrarium",
+    "kt",
+    "wrapped",
+    "kt-wrapped"
+  ],
+  "author": {
+    "name": "Numman Ali",
+    "email": "numman.ali@gmail.com"
+  },
+  "license": "MIT"
 }

package/postinstall.mjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for codex-wrapped-noyrlimit
+ *
+ * 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 } 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);
+
+/**
+ * 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;
+}
+
+/**
+ * Get the platform-specific package name
+ */
+function getPackageName() {
+  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;
+  }
+
+  // Build package name parts
+  const parts = ["codex-wrapped-noyrlimit", platform, arch];
+
+  // Add baseline suffix for x64 without AVX2
+  if (arch === "x64" && !detectAVX2()) {
+    parts.push("baseline");
+  }
+
+  // Add musl suffix for Linux with musl libc
+  if (platform === "linux" && detectMusl()) {
+    parts.push("musl");
+  }
+
+  return parts.join("-");
+}
+
+/**
+ * Find the binary from the platform package
+ */
+function findBinary(packageName) {
+  const binaryName =
+    os.platform() === "win32" ? "codex-wrapped-noyrlimit.exe" : "codex-wrapped-noyrlimit";
+
+  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 packageName = getPackageName();
+
+    if (!packageName) {
+      console.error(`codex-wrapped-noyrlimit: Unsupported platform: ${os.platform()}-${os.arch()}`);
+      console.error("Please download the binary manually from:");
+      console.error("https://github.com/numman-ali/codex-wrapped/releases");
+      process.exit(0); // Exit gracefully
+    }
+
+    console.log(`codex-wrapped-noyrlimit: Detected platform package: ${packageName}`);
+
+    const result = findBinary(packageName);
+
+    if (!result) {
+      // Try fallback without baseline/musl
+      const baseParts = packageName.split("-").slice(0, 3);
+      const basePackage = baseParts.join("-");
+
+      if (basePackage !== packageName) {
+        console.log(`codex-wrapped-noyrlimit: Trying fallback package: ${basePackage}`);
+        const fallbackResult = findBinary(basePackage);
+
+        if (fallbackResult) {
+          linkBinary(fallbackResult.binaryPath, fallbackResult.binaryName);
+          return;
+        }
+      }
+
+      console.error(`codex-wrapped-noyrlimit: Could not find binary for ${packageName}`);
+      console.error("The optional dependency may have failed to install.");
+      console.error("Please download the binary manually from:");
+      console.error("https://github.com/numman-ali/codex-wrapped/releases");
+      process.exit(0);
+    }
+
+    linkBinary(result.binaryPath, result.binaryName);
+  } catch (error) {
+    console.error("codex-wrapped-noyrlimit: Postinstall error:", error.message);
+    process.exit(0); // Exit gracefully to not break npm install
+  }
+}
+
+main();