@tacone/prosey 0.1.0 → 0.2.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@tacone/prosey",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Download YouTube video transcripts from the CLI",
   "module": "src/index.ts",
   "type": "module",
   "bin": {
-    "prosey": "bin/prosey.js"
+    "prosey": "bin/prosey"
   },
   "files": [
     "bin/",
@@ -16,12 +16,11 @@
   ],
   "scripts": {
     "start": "bun run src/index.ts",
-    "build": "bun build src/index.ts --compile --outfile dist/prosey",
-    "build:node": "bun build src/index.ts --target node --outfile bin/prosey.js",
+    "build": "bun build src/index.ts --target node --outfile bin/prosey",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "prettier": "prettier --write .",
-    "prepack": "bun run build:node",
+    "prepack": "bun run build",
     "prepare": "husky || true"
   },
   "lint-staged": {
@@ -59,6 +58,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "js-toml": "^1.1.2",
     "youtube-transcript-plus": "^2.0.0"
   }
 }

package/src/cache.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test, afterEach } from "bun:test";
+import { rm, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { cacheKey, cacheDir, readCache, writeCache } from "./cache";
+
+const testDir = "/tmp/prosey/test-cache-spec";
+
+afterEach(async () => {
+  await rm(testDir, { recursive: true, force: true });
+});
+
+describe("cacheKey", () => {
+  test("includes video ID and hash", () => {
+    const key = cacheKey("dQw4w9WgXcQ", {});
+    expect(key).toStartWith("dQw4w9WgXcQ_");
+    expect(key.length).toBe(20); // 11 + 1 + 8
+  });
+
+  test("different lang produces different key", () => {
+    const a = cacheKey("dQw4w9WgXcQ", { lang: "en" });
+    const b = cacheKey("dQw4w9WgXcQ", { lang: "fr" });
+    expect(a).not.toBe(b);
+  });
+
+  test("different flags produce different key", () => {
+    const a = cacheKey("dQw4w9WgXcQ", {});
+    const b = cacheKey("dQw4w9WgXcQ", { timestamps: true });
+    expect(a).not.toBe(b);
+  });
+
+  test("mode distinguishes transcript from summarize", () => {
+    const a = cacheKey("dQw4w9WgXcQ", {});
+    const b = cacheKey("dQw4w9WgXcQ", { mode: "summarize" });
+    expect(a).not.toBe(b);
+  });
+});
+
+describe("cacheDir", () => {
+  test("returns path under /tmp/prosey with cache key", () => {
+    const key = cacheKey("abc123def45", {});
+    const dir = cacheDir("abc123def45", {});
+    expect(dir).toBe(`/tmp/prosey/${key}`);
+  });
+});
+
+describe("readCache / writeCache", () => {
+  test("writes and reads a file", async () => {
+    await writeCache(testDir, "test.txt", "hello world");
+    const content = await readCache(testDir, "test.txt");
+    expect(content).toBe("hello world");
+  });
+
+  test("returns null for missing file", async () => {
+    const content = await readCache(testDir, "nonexistent.txt");
+    expect(content).toBeNull();
+  });
+
+  test("creates directory on write", async () => {
+    expect(existsSync(testDir)).toBe(false);
+    await writeCache(testDir, "createdir.txt", "data");
+    expect(existsSync(testDir)).toBe(true);
+  });
+});

package/src/cache.ts

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export interface CacheOptions {
+  lang?: string;
+  timestamps?: boolean;
+  json?: boolean;
+  noDecode?: boolean;
+  mode?: string;
+}
+
+function hashOptions(opts: CacheOptions): string {
+  return createHash("sha256").update(JSON.stringify(opts)).digest("hex").slice(0, 8);
+}
+
+export function cacheKey(videoId: string, opts: CacheOptions): string {
+  return `${videoId}_${hashOptions(opts)}`;
+}
+
+export function cacheDir(videoId: string, opts: CacheOptions): string {
+  return join("/tmp", "prosey", cacheKey(videoId, opts));
+}
+
+export async function readCache(dir: string, filename: string): Promise<string | null> {
+  try {
+    return await readFile(join(dir, filename), "utf8");
+  } catch {
+    return null;
+  }
+}
+
+export async function writeCache(dir: string, filename: string, data: string): Promise<void> {
+  if (!existsSync(dir)) await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, filename), data, "utf8");
+}

package/src/config.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test, afterEach } from "bun:test";
+import { rm, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { configPath, loadConfig, resetConfig } from "./config";
+
+const ORIGINAL_XDG = process.env.XDG_CONFIG_HOME;
+const ORIGINAL_PROSEY_CONFIG = process.env.PROSEY_CONFIG_PATH;
+
+afterEach(() => {
+  if (ORIGINAL_XDG) process.env.XDG_CONFIG_HOME = ORIGINAL_XDG;
+  else delete process.env.XDG_CONFIG_HOME;
+  if (ORIGINAL_PROSEY_CONFIG) process.env.PROSEY_CONFIG_PATH = ORIGINAL_PROSEY_CONFIG;
+  else delete process.env.PROSEY_CONFIG_PATH;
+});
+
+describe("configPath", () => {
+  test("default path uses XDG_CONFIG_HOME when set", () => {
+    process.env.XDG_CONFIG_HOME = "/custom/xdg";
+    delete process.env.PROSEY_CONFIG_PATH;
+    expect(configPath()).toBe("/custom/xdg/prosey/config.toml");
+  });
+
+  test("default path falls back to ~/.config", () => {
+    delete process.env.XDG_CONFIG_HOME;
+    delete process.env.PROSEY_CONFIG_PATH;
+    expect(configPath()).toBe(join(homedir(), ".config", "prosey", "config.toml"));
+  });
+
+  test("PROSEY_CONFIG_PATH overrides everything", () => {
+    process.env.XDG_CONFIG_HOME = "/custom/xdg";
+    process.env.PROSEY_CONFIG_PATH = "/override/path/config.toml";
+    expect(configPath()).toBe("/override/path/config.toml");
+  });
+});
+
+describe("loadConfig", () => {
+  const tmpConfig = join(import.meta.dir, "..", "tmp-test-config.toml");
+
+  afterEach(async () => {
+    try {
+      await rm(tmpConfig);
+    } catch {}
+  });
+
+  test("auto-creates config file when missing", async () => {
+    process.env.PROSEY_CONFIG_PATH = tmpConfig;
+    expect(existsSync(tmpConfig)).toBe(false);
+
+    const config = await loadConfig();
+    expect(config).toEqual({});
+    expect(existsSync(tmpConfig)).toBe(true);
+
+    const content = await readFile(tmpConfig, "utf8");
+    expect(content).toContain("[summarize]");
+    expect(content).toContain('command = "opencode run"');
+  });
+
+  test("reads existing config file", async () => {
+    process.env.PROSEY_CONFIG_PATH = tmpConfig;
+
+    await loadConfig();
+    const config = await loadConfig();
+    expect(config.summarize?.prompt).toBeString();
+    expect(config.summarize?.command).toBe("opencode run");
+  });
+
+  test("handles invalid TOML gracefully", async () => {
+    process.env.PROSEY_CONFIG_PATH = tmpConfig;
+    await Bun.write(tmpConfig, "invalid [[\ntoml{{{");
+
+    const config = await loadConfig();
+    expect(config).toEqual({});
+  });
+});
+
+describe("resetConfig", () => {
+  const tmpConfig = join(import.meta.dir, "..", "tmp-reset-config.toml");
+
+  afterEach(async () => {
+    try {
+      await rm(tmpConfig);
+    } catch {}
+  });
+
+  test("overwrites existing file with defaults", async () => {
+    process.env.PROSEY_CONFIG_PATH = tmpConfig;
+
+    await Bun.write(tmpConfig, "# garbage");
+    const path = await resetConfig();
+    expect(path).toBe(tmpConfig);
+
+    const content = await readFile(tmpConfig, "utf8");
+    expect(content).toContain("[summarize]");
+    expect(content).toContain('command = "opencode run"');
+  });
+});

package/src/config.ts

@@ -0,0 +1,79 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { load } from "js-toml";
+
+export interface ProseyConfig {
+  summarize?: {
+    prompt?: string;
+    command?: string;
+  };
+}
+
+const FALLBACK_CONFIG_TOML = `# Default prosey configuration
+# Created automatically on first run. Edit as needed.
+
+[summarize]
+# Prompt sent to the command via stdin.
+# Customize this to change how transcripts are summarized.
+prompt = """
+Summarize the following transcript.
+Focus on the key points and main arguments.
+"""
+
+# Command to execute with the prompt piped via stdin.
+command = "opencode run"
+`;
+
+async function readDefaultConfig(): Promise<string> {
+  const paths = [
+    join(dirname(fileURLToPath(import.meta.url)), "default-config.toml"),
+    join(dirname(fileURLToPath(import.meta.url)), "..", "src", "default-config.toml"),
+  ];
+  for (const p of paths) {
+    if (existsSync(p)) return readFile(p, "utf8");
+  }
+  return FALLBACK_CONFIG_TOML;
+}
+
+function configDir(): string {
+  const env = process.env.XDG_CONFIG_HOME;
+  if (env) return join(env, "prosey");
+  return join(homedir(), ".config", "prosey");
+}
+
+export function configPath(): string {
+  return process.env.PROSEY_CONFIG_PATH ?? join(configDir(), "config.toml");
+}
+
+function ensureDir(path: string): Promise<void> {
+  return mkdir(path, { recursive: true }) as Promise<void>;
+}
+
+export async function loadConfig(): Promise<ProseyConfig> {
+  const path = configPath();
+
+  if (!existsSync(path)) {
+    const dir = configDir();
+    await ensureDir(dir);
+    await writeFile(path, await readDefaultConfig(), "utf8");
+    return {};
+  }
+
+  const raw = await readFile(path, "utf8");
+  try {
+    return load(raw) as ProseyConfig;
+  } catch {
+    return {};
+  }
+}
+
+export async function resetConfig(): Promise<string> {
+  const path = configPath();
+  const dir = configDir();
+  await ensureDir(dir);
+  await writeFile(path, await readDefaultConfig(), "utf8");
+  return path;
+}

package/src/default-config.toml

@@ -0,0 +1,12 @@
+# Default prosey configuration
+# Created automatically on first run. Edit as needed.
+
+[summarize]
+# Prompt sent to the command via stdin.
+# Customize this to change how transcripts are summarized.
+prompt = """
+Write a comprehensive summary of the following transcription.
+"""
+
+# Command to execute with the prompt piped via stdin.
+command = "opencode run"

package/src/index.ts

@@ -2,8 +2,12 @@
 
 import { writeFile } from "node:fs/promises";
 import { fetchTranscript, listLanguages } from "youtube-transcript-plus";
-import type { CaptionTrackInfo, VideoDetails } from "youtube-transcript-plus";
+import type { CaptionTrackInfo, VideoDetails, TranscriptSegment } from "youtube-transcript-plus";
 import { formatWithTimestamps, toText, toJSON, formatDuration, decodeEntities } from "./format";
+import { loadConfig, resetConfig } from "./config";
+import type { ProseyConfig } from "./config";
+import { summarize } from "./summarize";
+import { cacheDir, readCache, writeCache } from "./cache";
 
 const NAME = "prosey";
 const VERSION = "0.1.0";
@@ -13,11 +17,13 @@ function help(): string {
 
 Usage: ${NAME} [options] <video-url-or-id>
        ${NAME} info [options] <video-url-or-id>
+       ${NAME} summarize [options] <video-url-or-id>
 
 Download a YouTube video transcript or show video details.
 
 Commands:
   info                  Show video metadata (title, channel, duration, etc.)
+  summarize             Pipe transcript to the command configured in [summarize]
 
 Arguments:
   video-url-or-id        YouTube URL (full or short) or bare video ID
@@ -32,6 +38,8 @@ Options:
   --details              Prepend video details to transcript (default, text only).
   --no-details           Suppress video details, transcript only.
   --no-decode-entities   Preserve HTML entities (decoded by default).
+  --reset-config         Reset config file to defaults and exit.
+  --no-cache             Skip cache and overwrite cache files.
   --help                 Show this help message.
   --version              Show version.
 
@@ -121,10 +129,21 @@ if (args.includes("--version")) {
   process.exit(0);
 }
 
+if (args.includes("--reset-config")) {
+  const path = await resetConfig();
+  console.log(`Config reset to defaults: ${path}`);
+  process.exit(0);
+}
+
+const config: ProseyConfig = await loadConfig().catch(() => ({}) as ProseyConfig);
+
 let mode = "transcript";
 if (args[0] === "info") {
   mode = "info";
   args.splice(0, 1);
+} else if (args[0] === "summarize") {
+  mode = "summarize";
+  args.splice(0, 1);
 }
 
 let videoId = "";
@@ -135,6 +154,7 @@ let outputPath: string | undefined;
 let outputJson = false;
 let noDecode = false;
 let showDetails = true;
+let noCache = false;
 
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
@@ -163,6 +183,8 @@ for (let i = 0; i < args.length; i++) {
     showDetails = true;
   } else if (arg === "--no-details") {
     showDetails = false;
+  } else if (arg === "--no-cache") {
+    noCache = true;
   } else if (arg === "--no-decode-entities") {
     noDecode = true;
   } else if (arg.startsWith("-")) {
@@ -190,25 +212,97 @@ try {
     process.exit(0);
   }
 
-  if (listOnly) {
+  if (mode === "summarize") {
+    if (!config.summarize?.command) {
+      console.error("Error: [summarize] section with a command is required in config");
+      process.exit(1);
+    }
+
+    const cacheOpts = { lang, mode: "summarize", noDecode };
+    const dir = cacheDir(videoId, cacheOpts);
+    let segments: TranscriptSegment[] | null = null;
+    let summary: string | null = null;
+
+    if (!noCache) {
+      const cachedSegments = await readCache(dir, "transcript.json");
+      const cachedSummary = await readCache(dir, "summary.md");
+      if (cachedSegments && cachedSummary) {
+        segments = JSON.parse(cachedSegments);
+        summary = cachedSummary;
+      }
+    }
+
+    if (!segments) {
+      segments = lang ? await fetchTranscript(videoId, { lang }) : await fetchTranscript(videoId);
+      await writeCache(dir, "transcript.json", JSON.stringify(segments));
+    }
+
+    const prompt = config.summarize.prompt ?? "";
+    const transcriptText = toText(segments, !noDecode);
+
+    if (!summary) {
+      summary = await summarize({
+        prompt,
+        command: config.summarize.command,
+        transcript: transcriptText,
+        cwd: dir,
+      });
+      await writeCache(dir, "summary.md", summary);
+    }
+
+    if (outputPath) {
+      await writeFile(outputPath, summary, "utf8");
+    } else {
+      console.log(summary);
+    }
+    process.exit(0);
+  } else if (listOnly) {
     const languages = await listLanguages(videoId);
     printLanguages(languages);
     process.exit(0);
   }
 
   const decode = !noDecode;
+  const cacheOpts = { lang, timestamps, json: outputJson, noDecode };
+  const dir = cacheDir(videoId, cacheOpts);
+  let segments: TranscriptSegment[] | null = null;
+  let videoDetailsCache: VideoDetails | null = null;
+
+  if (!noCache) {
+    const cached = await readCache(dir, "transcript.json");
+    if (cached) segments = JSON.parse(cached);
+  }
+
+  if (!segments) {
+    if (showDetails && !outputJson) {
+      const opts = lang ? { lang, videoDetails: true as const } : { videoDetails: true as const };
+      const result = (await fetchTranscript(videoId, opts)) as {
+        videoDetails: VideoDetails;
+        segments: TranscriptSegment[];
+      };
+      segments = result.segments;
+      videoDetailsCache = result.videoDetails;
+    } else {
+      segments = lang ? await fetchTranscript(videoId, { lang }) : await fetchTranscript(videoId);
+    }
+    await writeCache(dir, "transcript.json", JSON.stringify(segments));
+  }
 
   if (showDetails && !outputJson) {
-    const config = lang ? { lang, videoDetails: true as const } : { videoDetails: true as const };
-    const result = (await fetchTranscript(videoId, config)) as {
-      videoDetails: VideoDetails;
-      segments: { text: string; offset: number; duration: number; lang: string }[];
-    };
-    const detailsBlock = formatDetailsBlock(result.videoDetails);
-    const transcript = timestamps
-      ? formatWithTimestamps(result.segments, decode)
-      : toText(result.segments, decode);
-    const output = detailsBlock + "\n\n\n" + transcript + "\n";
+    if (!videoDetailsCache) {
+      const opts = lang ? { lang, videoDetails: true as const } : { videoDetails: true as const };
+      const result = (await fetchTranscript(videoId, opts)) as {
+        videoDetails: VideoDetails;
+        segments: TranscriptSegment[];
+      };
+      videoDetailsCache = result.videoDetails;
+    }
+
+    const detailsBlock = formatDetailsBlock(videoDetailsCache);
+    const transcriptText = timestamps
+      ? formatWithTimestamps(segments, decode)
+      : toText(segments, decode);
+    const output = detailsBlock + "\n\n\n" + transcriptText + "\n";
 
     if (outputPath) {
       await writeFile(outputPath, output, "utf8");
@@ -216,10 +310,6 @@ try {
       console.log(output);
     }
   } else {
-    const segments = lang
-      ? await fetchTranscript(videoId, { lang })
-      : await fetchTranscript(videoId);
-
     const output = outputJson
       ? toJSON(segments, decode) + "\n"
       : timestamps

package/src/summarize.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+import { summarize } from "./summarize";
+
+describe("summarize", () => {
+  test("strips input text from output", async () => {
+    const result = await summarize({
+      prompt: "Summarize this:",
+      command: "cat",
+      transcript: "Hello world. This is the transcript.",
+    });
+    expect(result).toBe("");
+  });
+
+  test("strips input text from output with empty prompt", async () => {
+    const result = await summarize({
+      prompt: "",
+      command: "cat",
+      transcript: "Just the transcript.",
+    });
+    expect(result).toBe("");
+  });
+
+  test("preserves response text beyond the input", async () => {
+    const cmd = "sh -c 'cat -; echo \"RESPONSE\"'";
+    const result = await summarize({
+      prompt: "Summarize:",
+      command: cmd,
+      transcript: "Transcript text.",
+    });
+    expect(result).toBe("RESPONSE");
+  });
+
+  test("rejects on non-zero exit code", async () => {
+    await expect(
+      summarize({
+        prompt: "test",
+        command: "false",
+        transcript: "whatever",
+      }),
+    ).rejects.toThrow(/exited with code 1/);
+  });
+});

package/src/summarize.ts

@@ -0,0 +1,42 @@
+import { spawn } from "node:child_process";
+
+export interface SummarizeOptions {
+  prompt: string;
+  command: string;
+  transcript: string;
+  cwd?: string;
+}
+
+function executeCommand(command: string, input: string, cwd?: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, [], { shell: true, stdio: "pipe", cwd });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout!.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr!.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code: number | null) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(`Command exited with code ${code}: ${stderr}`));
+    });
+
+    proc.on("error", (err: Error) => reject(err));
+
+    proc.stdin!.write(input);
+    proc.stdin!.end();
+  });
+}
+
+export async function summarize(options: SummarizeOptions): Promise<string> {
+  const { prompt, command, transcript, cwd } = options;
+  const fullPrompt = `${prompt}\n\n${transcript}`;
+  const output = await executeCommand(command, fullPrompt, cwd);
+  return output.replace(fullPrompt, "").replace(/\n+$/, "");
+}