yt-briefing 0.9.1 → 0.10.0

package/README.md

@@ -1,5 +1,12 @@
 # yt-briefing
 
+[![npm](https://img.shields.io/npm/v/yt-briefing)](https://www.npmjs.com/package/yt-briefing)
+[![license](https://img.shields.io/npm/l/yt-briefing)](./LICENSE)
+[![node](https://img.shields.io/node/v/yt-briefing)](https://www.npmjs.com/package/yt-briefing)
+[![mac](https://github.com/michal90r/yt-briefing/actions/workflows/ci-mac.yml/badge.svg)](https://github.com/michal90r/yt-briefing/actions/workflows/ci-mac.yml)
+[![ubuntu](https://github.com/michal90r/yt-briefing/actions/workflows/ci-ubuntu.yml/badge.svg)](https://github.com/michal90r/yt-briefing/actions/workflows/ci-ubuntu.yml)
+[![windows](https://github.com/michal90r/yt-briefing/actions/workflows/ci-windows.yml/badge.svg)](https://github.com/michal90r/yt-briefing/actions/workflows/ci-windows.yml)
+
 Save hours on YouTube. yt-briefing watches the channels you follow so you don't have to. For
 each new video it gives you a short briefing in your own language — every point that matters, with
 only the filler cut, so nothing important is lost. Reading it takes a fraction of the time the
@@ -55,9 +62,9 @@ YT_BRIEFING_LLM_MODEL=gemini-2.5-flash
 YT_BRIEFING_YOUTUBE_API_KEY=<key>    # console.cloud.google.com → enable "YouTube Data API v3"
 ```
 
-Any OpenAI-compatible endpoint works — see [Providers](#providers) to use OpenRouter, OpenAI, or a
-local Ollama instead of Gemini. Miss a key and the engine tells you exactly which one. Keep `.env`
-gitignored; `YT_BRIEFING_PROXY` (datacenter/VPS IPs) is the only optional extra.
+Any OpenAI-compatible endpoint works — see [Providers](#providers) to use OpenRouter, OpenAI,
+Anthropic, or a local Ollama instead of Gemini. `YT_BRIEFING_PROXY` (datacenter/VPS IPs) is the
+only optional extra.
 
 4. Onboard:
 
@@ -84,23 +91,32 @@ another language? Just say so when you run it (e.g. `/yt-transcribe <url> in Ger
 won't change your setup. `--lang pl|en` is separate — it picks which caption track to fetch,
 not the summary language.
 
-The skill is installed alongside `/yt` by `init` / `install-skill`. From the plain CLI:
+For example:
 
-```bash
-npx yt-briefing transcribe <url-or-id> --lang auto   # prints the transcript to stdout
+```
+/yt-transcribe https://www.youtube.com/watch?v=dQw4w9WgXcQ
 ```
 
 ## Search within a channel
 
 Mine one channel's videos for a topic and get a comparison. Run `/yt-search` with a channel and
-an intent — e.g. `/yt-search @betterstack which terminal for AI coding`.
+an intent — for example:
+
+```
+/yt-search @betterstack which terminal for AI coding
+```
 
 It covers the channel's **whole history** (not just recent uploads), re-ranks every upload against
 your intent, then lazily yields one matching video at a time to keep or skip — and synthesizes a
 comparison from everything you kept.
 
 The one flag is `--top N` — how many of the top re-ranked matches to triage (**default 10**). Raise
-it to go deeper, lower it for a quicker pass: `/yt-search @betterstack which terminal --top 20`.
+it to go deeper, lower it for a quicker pass:
+
+```
+/yt-search @betterstack which terminal
+/yt-search @betterstack which terminal --top 5
+```
 
 ## Run it
 
@@ -123,7 +139,8 @@ YT_BRIEFING_LLM_MODEL=gemini-2.5-flash
 > or switch to a paid key (enable billing, same model) to avoid it.
 
 Want something else? Change those three lines for OpenRouter (`https://openrouter.ai/api/v1`),
-OpenAI (`https://api.openai.com/v1`), or a local Ollama (`http://localhost:11434/v1`). Set
+OpenAI (`https://api.openai.com/v1`), Anthropic (`https://api.anthropic.com/v1/`,
+e.g. `claude-sonnet-4-6`), or a local Ollama (`http://localhost:11434/v1`). Set
 `YT_BRIEFING_LLM_BASE_URL`, `_API_KEY`, and `_MODEL` in your root `.env` (see [Setup](#setup)).
 
 ## Why an API, not the agent's native model

package/dist/lib/skill-install.js

@@ -13,18 +13,31 @@
  * agent's cwd IS the package folder AND the runtime is Bun (which runs TypeScript directly).
  * That's true for the publisher's own day-to-day use, so it stays the default.
  *
- * For everyone else — a Node user, or any install whose cwd won't be the package — we bake an
- * absolute, runtime-correct command instead: `"<this runtime>" "<abs>/dist/X.js"`. The runtime
- * is `process.execPath` of whoever runs the installer (so `init` under Node bakes node, under
- * Bun bakes bun), and it points at the compiled build, so it runs from any cwd. The engine
- * resolves data/.env from its own location regardless. (Requires `dist/` — build once with
- * `bun run build` / `npm run build`; that's exactly how a Node user already got here.)
+ * For everyone else — a Node user, or any install whose cwd won't be the package — we rewrite to
+ * a PORTABLE command: `<runtime> "<project-relative>/dist/X.js"`. The runtime is the bare name
+ * (`node`/`bun`) resolved from PATH, never an absolute binary; the script and `data/` paths are
+ * relative to the PROJECT ROOT, never machine-absolute. The invariant this rests on is the same
+ * one the whole package already relies on (paths.ts derives BASE_DIR/DATA_DIR from
+ * `process.cwd()` when consumed): the agent runs from the project root. So the rewritten skill is
+ * machine-independent — it survives being committed to git and shared across machines (e.g. a
+ * Mac dev box and a Linux VPS), which an absolute `process.execPath`/`<abs>/dist` baking did not.
+ * (Requires `dist/` — build once with `bun run build` / `npm run build`.)
  */
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { PKG_ROOT, DATA_DIR } from "./paths.js";
-/** Compiled output dir — what a baked (dist) skill command points the runtime at. */
+import { join, resolve, relative, dirname, sep } from 'node:path';
+import { PKG_ROOT, BASE_DIR, DATA_DIR } from "./paths.js";
+/** Compiled output dir — what a rewritten (dist) skill command points the runtime at. */
 const DIST_DIR = join(PKG_ROOT, 'dist');
+/** Consumed as a dependency? Then PKG_ROOT lives under node_modules (mirrors paths.ts). */
+const CONSUMED = PKG_ROOT.split(sep).includes('node_modules');
+/**
+ * The project root the agent runs from — the cwd against which the rewritten skill's relative
+ * paths resolve. When consumed, that's the user's project (parent of `<project>/.yt-briefing`);
+ * in a clone it's the package itself. Matches how paths.ts picks BASE_DIR.
+ */
+const PROJECT_ROOT = CONSUMED ? dirname(BASE_DIR) : PKG_ROOT;
+/** An absolute path expressed relative to PROJECT_ROOT, with POSIX `/` (portable on Windows too). */
+const toProjectRel = (abs) => relative(PROJECT_ROOT, abs).split(sep).join('/');
 /** The skills this package ships — each lives at `.claude/skills/<name>/SKILL.md`. */
 export const SKILLS = ['yt', 'yt-transcribe', 'yt-search'];
 /** True when the installer itself is running under Bun (vs plain Node). */
@@ -56,25 +69,26 @@ export const AGENTS = {
 /**
  * One shipped skill's SKILL.md. `dist=false` (default) returns it verbatim — the
  * `bun run src/X.ts` dev form, correct only when cwd is the package AND the runtime is Bun.
- * `dist=true` rewrites for the consumed case: engine commands become
- * `"<process.execPath>" "<abs>/dist/X.js"` (this machine's runtime, Node or Bun, against the
- * compiled build, so they run from any cwd), and the bare `data/…` paths the agent reads (e.g.
- * `data/config.json`) become the absolute `DATA_DIR`. In dev the agent's cwd IS the package so
- * `data/` resolves; when consumed, DATA_DIR moves to `<project>/.yt-briefing/data`, so the
- * dev-relative paths would miss — hence the rewrite.
+ * `dist=true` rewrites for the consumed case into PORTABLE, project-relative form: engine
+ * commands become `<node|bun> "<rel>/dist/X.js"` (bare runtime from PATH + a path relative to the
+ * project root, so they run on any machine from the project cwd), and the bare `data/…` paths the
+ * agent reads (e.g. `data/config.json`) become the project-relative DATA_DIR (`.yt-briefing/data/`
+ * when consumed). Nothing machine-absolute is baked, so the rewritten skill can be committed and
+ * shared across machines. The runtime name follows whoever runs the installer (Node→`node`,
+ * Bun→`bun`); the compiled `dist/` build runs under either.
  */
 export function skillBody(name, dist = false) {
     const raw = readFileSync(skillSource(name), 'utf8');
     if (!dist)
         return raw;
-    const exe = process.execPath;
-    const cmd = (base) => `"${exe}" "${join(DIST_DIR, base + '.js')}"`;
+    const runtime = isBun ? 'bun' : 'node';
+    const cmd = (base) => `${runtime} "${toProjectRel(join(DIST_DIR, base + '.js'))}"`;
     return raw
         .replace(/bun run src\/yt-sweep\.ts/g, cmd('yt-sweep'))
         .replace(/bun run src\/yt-rating\.ts/g, cmd('yt-rating'))
         .replace(/bun run src\/yt-transcript\.ts/g, cmd('yt-transcript'))
         .replace(/bun run src\/yt-search\.ts/g, cmd('yt-search'))
-        .replace(/data\//g, DATA_DIR + '/');
+        .replace(/data\//g, toProjectRel(DATA_DIR) + '/');
 }
 /**
  * Write every shipped skill into `root`, each under its own `<name>/SKILL.md` subdir

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yt-briefing",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "A self-learning YouTube briefing engine: it sweeps the channels you follow, filters noise in two stages (title, then transcript), summarizes the rest in your language, and adapts to your ratings — one video at a time.",
   "type": "module",
   "bin": {
@@ -22,7 +22,8 @@
     "sweep": "bun run src/yt-sweep.ts",
     "rate": "bun run src/yt-rating.ts",
     "transcribe": "bun run src/yt-transcript.ts",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   },
   "engines": {
     "node": ">=18",
@@ -51,6 +52,7 @@
   "devDependencies": {
     "@types/node": "^22",
     "typescript": "^5.7",
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "vitest": "^3"
   }
 }