rikrok 0.5.0

package/src/cli/voice.mjs

@@ -0,0 +1,214 @@
+// rikrok voice setup | test | devices
+// Records a short reference clip in your voice, saves it with its transcript, checks it
+// against your speech server, and switches RIKROK_VOICE to clone. No training, no upload.
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { execFileSync, spawnSync } from "node:child_process";
+import { RIKROK_HOME, VOICE_DIR, CLONE_REF, CLONE_TEXT, CONFIG_FILE, TTS_URL, VOICE_SERVER_DIR, VOICE_SERVER_PORT, ensureDirs } from "../lib/config.mjs";
+import { cloneVoice } from "../voices/clone.mjs";
+
+// Short, neutral, covers most English sounds, easy to read in one breath per line.
+export const SCRIPT = [
+  "Here is the recap for today. The signup form is fixed, all four tests pass, and the change is live.",
+  "Three things shipped, two are still open, and the next step is to check it on a phone before the demo.",
+];
+
+export function listDevices() {
+  if (process.platform !== "darwin") return [];
+  const out = spawnSync("ffmpeg", ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { encoding: "utf-8" });
+  const text = (out.stderr || "") + (out.stdout || "");
+  const audio = text.split("audio devices:")[1] || "";
+  return [...audio.matchAll(/\[(\d+)\]\s+(.+)$/gm)].map((m) => ({ index: Number(m[1]), name: m[2].trim() }));
+}
+
+function record(outPath, seconds, device) {
+  const args = process.platform === "darwin"
+    ? ["-y", "-f", "avfoundation", "-i", `:${device}`, "-t", String(seconds), "-ar", "24000", "-ac", "1", outPath]
+    : ["-y", "-f", "pulse", "-i", "default", "-t", String(seconds), "-ar", "24000", "-ac", "1", outPath];
+  execFileSync("ffmpeg", args, { stdio: ["ignore", "ignore", "inherit"] });
+}
+
+function trimSilence(p) {
+  const out = p.replace(/\.wav$/, "_trim.wav");
+  execFileSync("ffmpeg", ["-y", "-i", p, "-af", "silenceremove=start_periods=1:start_threshold=-40dB:start_silence=0.2,areverse,silenceremove=start_periods=1:start_threshold=-40dB:start_silence=0.3,areverse,loudnorm=I=-20:TP=-1.5:LRA=9", "-ar", "24000", "-ac", "1", out], { stdio: "ignore" });
+  fs.renameSync(out, p);
+}
+
+function play(p) {
+  try {
+    if (process.platform === "darwin") execFileSync("afplay", [p]);
+    else execFileSync("ffplay", ["-nodisp", "-autoexit", "-loglevel", "quiet", p]);
+  } catch {}
+}
+
+export function saveConfig(patch) {
+  let cfg = {};
+  try {
+    cfg = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {}
+  Object.assign(cfg, patch);
+  fs.mkdirSync(path.dirname(CONFIG_FILE), { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n");
+  try {
+    fs.chmodSync(CONFIG_FILE, 0o600);
+  } catch {}
+}
+
+export async function setup(args, rl) {
+  ensureDirs();
+  fs.mkdirSync(VOICE_DIR, { recursive: true });
+  const own = rl || readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = async (q, d) => {
+    const a = (await own.question(`${q}${d !== undefined ? ` [${d}]` : ""} `)).trim();
+    return a === "" ? d : a;
+  };
+  try {
+    if (args.file) {
+      // Bring your own clip: 10 to 25 seconds of you talking, plus what you said.
+      const src = path.resolve(String(args.file));
+      if (!fs.existsSync(src)) throw new Error(`no such file: ${src}`);
+      execFileSync("ffmpeg", ["-y", "-i", src, "-ar", "24000", "-ac", "1", CLONE_REF], { stdio: "ignore" });
+      let text = typeof args.text === "string" ? args.text : "";
+      if (!text && typeof args["text-file"] === "string") text = fs.readFileSync(args["text-file"], "utf-8");
+      if (!text) text = await ask("Type exactly what is said in the clip:");
+      fs.writeFileSync(CLONE_TEXT, text.trim() + "\n");
+    } else {
+      const devices = listDevices();
+      let device = args.device !== undefined ? Number(args.device) : 0;
+      if (devices.length > 1 && args.device === undefined) {
+        console.log("\nMicrophones:");
+        devices.forEach((d) => console.log(`  ${d.index}  ${d.name}`));
+        device = Number(await ask("Which one?", devices[0].index));
+      }
+      const seconds = Number(args.seconds || 22);
+      console.log(`\nRead this in your normal voice. Recording starts when you press Enter and runs ${seconds} seconds.\n`);
+      for (const line of SCRIPT) console.log(`    ${line}`);
+      console.log();
+      await ask("Press Enter to start recording");
+      console.log("Recording...");
+      record(CLONE_REF, seconds, device);
+      trimSilence(CLONE_REF);
+      fs.writeFileSync(CLONE_TEXT, SCRIPT.join(" ") + "\n");
+      console.log("Done. Playing it back.");
+      play(CLONE_REF);
+      const again = await ask("Keep it? (y = keep, n = record again)", "y");
+      if (/^n/i.test(again)) return setup({ ...args, device }, own);
+    }
+    // Try it against the speech server.
+    const v = cloneVoice();
+    const a = await v.available();
+    if (!a.ok) {
+      console.log(`\nSaved the clip and transcript in ${VOICE_DIR}.\nCould not reach a cloning server: ${a.reason}\nPoint RIKROK_TTS_URL at one (oMLX with Qwen3-TTS works) and run \`rikrok voice test\`.`);
+      saveConfig({ RIKROK_VOICE: "clone" });
+      return 0;
+    }
+    const testPath = path.join(VOICE_DIR, "test.wav");
+    console.log(`\nAsking ${TTS_URL} to say a line in your voice...`);
+    const r = await v.synth("This is your recap, in your own voice. Nothing left the machine.", testPath);
+    if (!r.ok) {
+      console.log(`The server did not like it: ${r.error}\nThe clip is saved; fix the server and run \`rikrok voice test\`.`);
+      saveConfig({ RIKROK_VOICE: "clone" });
+      return 1;
+    }
+    play(testPath);
+    saveConfig({ RIKROK_VOICE: "clone" });
+    console.log(`\nYour voice is set. RIKROK_VOICE=clone is saved in ${CONFIG_FILE}.\nNext: rikrok demo`);
+    return 0;
+  } finally {
+    if (!rl) own.close();
+  }
+}
+
+
+// ---- rikrok voice serve: a local cloning server, installed on first use ----
+// Runs the Qwen3-TTS OpenAI-compatible FastAPI server (Apache-2.0) in its own uv-managed
+// Python environment under ~/.rikrok/voice-server. MLX on Apple Silicon, PyTorch elsewhere.
+// The model (about 4.5 GB for the 1.7B Base) downloads from Hugging Face on first start.
+const SERVER_REPO = "https://github.com/groxaxo/Qwen3-TTS-Openai-Fastapi.git";
+const APPLE = process.platform === "darwin" && process.arch === "arm64";
+const MODELS = {
+  mlx: { full: "mlx-community/Qwen3-TTS-12Hz-1.7B-Base-bf16", fast: "mlx-community/Qwen3-TTS-12Hz-0.6B-Base-bf16" },
+  torch: { full: "Qwen/Qwen3-TTS-12Hz-1.7B-Base", fast: "Qwen/Qwen3-TTS-12Hz-0.6B-Base" },
+};
+const srcDir = () => path.join(VOICE_SERVER_DIR, "src");
+const venvPy = () => path.join(srcDir(), ".venv", "bin", process.platform === "win32" ? "python.exe" : "python");
+
+function haveUv() {
+  return spawnSync("uv", ["--version"], { stdio: "ignore" }).status === 0;
+}
+
+export function installServer({ log = console.log } = {}) {
+  if (!haveUv()) {
+    log("This needs uv (the Python tool manager). Install it with:\n  curl -LsSf https://astral.sh/uv/install.sh | sh\nthen run `rikrok voice serve` again.");
+    return false;
+  }
+  fs.mkdirSync(VOICE_SERVER_DIR, { recursive: true });
+  if (!fs.existsSync(path.join(srcDir(), "pyproject.toml"))) {
+    log(`Fetching the speech server into ${srcDir()} ...`);
+    execFileSync("git", ["clone", "--depth", "1", SERVER_REPO, srcDir()], { stdio: "inherit" });
+  }
+  if (!fs.existsSync(venvPy())) {
+    log("Creating its Python environment (uv, Python 3.12) ...");
+    execFileSync("uv", ["venv", "--python", "3.12", path.join(srcDir(), ".venv")], { stdio: "inherit", cwd: srcDir() });
+    const extras = APPLE ? ".[api,mlx]" : ".[api]";
+    log(`Installing the server${APPLE ? " with MLX" : ""} (a few minutes the first time) ...`);
+    execFileSync("uv", ["pip", "install", "--python", venvPy(), "-e", extras], { stdio: "inherit", cwd: srcDir() });
+  }
+  return true;
+}
+
+export async function serve(args) {
+  if (!installServer()) return 1;
+  const fast = Boolean(args.fast);
+  const backend = APPLE ? "mlx" : "pytorch";
+  const model = APPLE ? MODELS.mlx[fast ? "fast" : "full"] : MODELS.torch[fast ? "fast" : "full"];
+  const port = Number(args.port || VOICE_SERVER_PORT);
+  const lib = path.join(VOICE_DIR, "library");
+  fs.mkdirSync(lib, { recursive: true });
+  const env = { ...process.env, PORT: String(port), HOST: "127.0.0.1", TTS_BACKEND: backend, VOICE_LIBRARY_DIR: lib };
+  if (APPLE) env.MLX_MODEL_ID = model;
+  else {
+    env.TTS_MODEL_NAME = model;
+    if (!process.env.TTS_DEVICE) env.TTS_DEVICE = "cpu";
+  }
+  // Point Rik Rok at it, and at the dedicated clone endpoint.
+  saveConfig({ RIKROK_TTS_URL: `http://127.0.0.1:${port}`, RIKROK_CLONE_API: "voice-clone", RIKROK_VOICE: "clone" });
+  console.log(`Speech server: ${backend} backend, model ${model}, http://127.0.0.1:${port}\nFirst start downloads the model from Hugging Face (about ${fast ? "1.5" : "4.5"} GB). Ctrl-C to stop.\n`);
+  const child = spawnSync(venvPy(), ["-m", "api.main"], { cwd: srcDir(), env, stdio: "inherit" });
+  return child.status ?? 0;
+}
+
+export async function test() {
+  const v = cloneVoice();
+  const a = await v.available();
+  if (!a.ok) {
+    console.log(`clone voice not ready: ${a.reason}`);
+    return 1;
+  }
+  const testPath = path.join(VOICE_DIR, "test.wav");
+  const r = await v.synth("This is your recap, in your own voice. Nothing left the machine.", testPath);
+  if (!r.ok) {
+    console.log(`synthesis failed: ${r.error}`);
+    return 1;
+  }
+  console.log(`ok, wrote ${testPath}`);
+  play(testPath);
+  return 0;
+}
+
+export async function run(args) {
+  const sub = args._[0] || "help";
+  if (sub === "setup") return setup(args);
+  if (sub === "test") return test();
+  if (sub === "serve") return serve(args);
+  if (sub === "install-server") return installServer() ? 0 : 1;
+  if (sub === "devices") {
+    const d = listDevices();
+    if (!d.length) console.log(process.platform === "darwin" ? "no input devices found" : "device listing is macOS only; recording uses the default pulse input");
+    d.forEach((x) => console.log(`${x.index}  ${x.name}`));
+    return 0;
+  }
+  console.log("usage: rikrok voice setup [--file clip.wav --text \"what is said\"] [--device N] [--seconds 22] | test | devices | serve [--fast] [--port N] | install-server");
+  return 1;
+}

package/src/cli/watch.mjs

@@ -0,0 +1,5 @@
+import { startWatcher } from "../lib/watcher.mjs";
+export async function run() {
+  startWatcher();
+  await new Promise(() => {});
+}

package/src/hooks/comment.mjs

@@ -0,0 +1,21 @@
+// Comment routing. A comment on a reel is always saved to its sidecar. If
+// RIKROK_COMMENT_HOOK is set, that shell command also runs with a JSON payload on
+// stdin, so a reply to a recap can become an instruction for the project's agent
+// (an issue tracker, a message queue, `claude --resume`, whatever you wire up).
+import { spawn } from "node:child_process";
+import { COMMENT_HOOK } from "../lib/config.mjs";
+
+export const hookConfigured = () => Boolean(COMMENT_HOOK);
+
+export function routeComment(payload) {
+  if (!COMMENT_HOOK) return null;
+  try {
+    const proc = spawn("sh", ["-c", COMMENT_HOOK], { stdio: ["pipe", "inherit", "inherit"], timeout: 10_000 });
+    proc.on("error", (err) => console.error(`[feed] comment hook failed: ${err.message}`));
+    proc.on("close", (code) => code !== 0 && console.error(`[feed] comment hook exited ${code}`));
+    proc.stdin.end(JSON.stringify(payload));
+  } catch (err) {
+    console.error(`[feed] comment hook failed: ${err.message}`);
+  }
+  return COMMENT_HOOK;
+}

package/src/lib/backfill.mjs

@@ -0,0 +1,40 @@
+// Backfill: reels for the most recently modified qualifying sessions, generated
+// oldest to newest so the feed fills up in order.
+import { sources } from "../sources/index.mjs";
+import { saveState, sessionKey } from "./state.mjs";
+import { buildReel } from "./pipeline.mjs";
+
+export async function runBackfill(state, { limit = 10 } = {}) {
+  const picked = [];
+  for (const src of sources()) {
+    const files = src.listSessions().sort((a, b) => b.mtimeMs - a.mtimeMs);
+    let n = 0;
+    for (const f of files) {
+      if (n >= limit) break;
+      if (state.sessions[sessionKey(f)]?.lastRecapAt) continue;
+      let act;
+      try {
+        act = await src.parseSession(f.path, 0);
+      } catch {
+        continue;
+      }
+      if (src.qualifies(act)) {
+        picked.push(f);
+        n++;
+      }
+    }
+  }
+  picked.sort((a, b) => a.mtimeMs - b.mtimeMs); // oldest first
+  console.log(`[backfill] ${picked.length} qualifying session(s)`);
+  for (const f of picked) {
+    try {
+      console.log(`[backfill] ${f.source}:${f.projectDir}/${f.sessionId.slice(0, 8)}`);
+      const { totalLines } = await buildReel(f, 0);
+      state.sessions[sessionKey(f)] = { lastMtimeMs: f.mtimeMs, lastLine: totalLines, lastRecapAt: new Date().toISOString() };
+      saveState(state);
+    } catch (err) {
+      console.error(`[backfill] failed ${f.sessionId}: ${err.message}`);
+    }
+  }
+  return picked.length;
+}

package/src/lib/config.mjs

@@ -0,0 +1,89 @@
+// Runtime settings. Precedence: environment > ~/.rikrok/config.json > defaults.
+// Every knob is a RIKROK_* variable; see README "Configuration".
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CONFIG_FILE, RIKROK_HOME, expandHome } from "./paths.mjs";
+export * from "./paths.mjs";
+
+// config.json keys (RIKROK_*) fill in anything the environment did not set.
+try {
+  const j = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+  for (const [k, v] of Object.entries(j)) {
+    if (!/^RIKROK_/.test(k) || process.env[k] !== undefined || v == null) continue;
+    process.env[k] = typeof v === "string" ? v : JSON.stringify(v);
+  }
+} catch {}
+
+const env = (k, d) => (process.env[k] !== undefined && process.env[k] !== "" ? process.env[k] : d);
+const num = (k, d) => {
+  const n = Number(env(k, d));
+  return Number.isFinite(n) ? n : d;
+};
+const base = (u) => String(u).replace(/\/+$/, "").replace(/\/v1$/, "");
+
+// Sessions
+export const CLAUDE_PROJECTS = path.resolve(expandHome(env("RIKROK_CLAUDE_DIR", path.join(os.homedir(), ".claude", "projects"))));
+export const SOURCES = env("RIKROK_SOURCES", "claude").split(",").map((s) => s.trim()).filter(Boolean);
+export const IDLE_MINUTES = num("RIKROK_IDLE_MINUTES", 15);
+export const MIN_ASSISTANT_TURNS = num("RIKROK_MIN_TURNS", 10);
+export const MIN_TOOL_USES = num("RIKROK_MIN_TOOLS", 3);
+export const MAX_REELS_PER_HOUR = num("RIKROK_MAX_PER_HOUR", 4);
+export const PROJECT_NAME_RE = env("RIKROK_PROJECT_NAME_RE", "");
+
+// Feed
+export const FEED_PORT = num("RIKROK_PORT", 4870);
+export const FEED_BIND = env("RIKROK_BIND", "127.0.0.1");
+export const COMMENT_HOOK = env("RIKROK_COMMENT_HOOK", "");
+export const HANDLE = env("RIKROK_HANDLE", "");
+export const FLOW_BEAT = env("RIKROK_FLOW", "on") !== "off";
+
+// Who writes the script: "claude" (headless `claude -p`, your subscription), "local" (an
+// OpenAI-compatible server), or "auto" (claude when no local model is configured and the CLI exists)
+export const SCRIPT_BACKEND = env("RIKROK_SCRIPT", "auto");
+export const CLAUDE_BIN = env("RIKROK_CLAUDE_BIN", "claude");
+export const CLAUDE_MODEL = env("RIKROK_CLAUDE_MODEL", "sonnet");
+
+// Script LLM: any OpenAI-compatible chat endpoint (Ollama, LM Studio, oMLX, ...)
+export const LLM_URL = base(env("RIKROK_LLM_URL", "http://127.0.0.1:11434"));
+export const LLM_MODEL = env("RIKROK_LLM_MODEL", "");
+export const LLM_KEY = env("RIKROK_LLM_KEY", "");
+export const LLM_EXTRA = (() => {
+  try {
+    return JSON.parse(env("RIKROK_LLM_EXTRA", "{}"));
+  } catch {
+    console.error("[config] RIKROK_LLM_EXTRA is not valid JSON, ignoring it");
+    return {};
+  }
+})();
+
+// Voice: say:<Voice> | openai-speech:<voice> | module:<path> | none
+export const VOICE = env("RIKROK_VOICE", process.platform === "darwin" ? "say:Samantha" : "none");
+export const VOICE_FX = env("RIKROK_VOICE_FX", "none");
+export const TTS_URL = base(env("RIKROK_TTS_URL", LLM_URL));
+export const TTS_MODEL = env("RIKROK_TTS_MODEL", "tts-1");
+export const TTS_KEY = env("RIKROK_TTS_KEY", LLM_KEY);
+// Own voice (RIKROK_VOICE=clone): reference clip + transcript, recorded by `rikrok voice setup`
+export const VOICE_DIR = path.join(RIKROK_HOME, "voice");
+export const CLONE_REF = path.resolve(expandHome(env("RIKROK_CLONE_REF", path.join(VOICE_DIR, "ref.wav"))));
+export const CLONE_TEXT = path.resolve(expandHome(env("RIKROK_CLONE_TEXT", path.join(VOICE_DIR, "ref.txt"))));
+export const CLONE_MODEL = env("RIKROK_CLONE_MODEL", "Qwen3-TTS-12Hz-1.7B-Base-bf16");
+// How the speech server takes the reference clip: "speech" = ref_audio on /v1/audio/speech (oMLX),
+// "voice-clone" = the dedicated /v1/audio/voice-clone endpoint (the server `rikrok voice serve` runs)
+export const CLONE_API = env("RIKROK_CLONE_API", "speech");
+export const VOICE_SERVER_DIR = path.join(RIKROK_HOME, "voice-server");
+export const VOICE_SERVER_PORT = num("RIKROK_VOICE_PORT", 4873);
+
+// Optional transcribe-back QA of narration (off unless RIKROK_STT_URL is set)
+export const STT_URL = env("RIKROK_STT_URL", "") ? base(env("RIKROK_STT_URL")) : "";
+export const STT_MODEL = env("RIKROK_STT_MODEL", "whisper-1");
+export const STT_KEY = env("RIKROK_STT_KEY", LLM_KEY);
+
+export function authHeaders(key) {
+  return key ? { Authorization: `Bearer ${key}` } : {};
+}
+
+// Every RIKROK_* variable currently in effect (for doctor and install).
+export function effectiveEnv() {
+  return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith("RIKROK_")).sort());
+}

package/src/lib/evidence.mjs

@@ -0,0 +1,21 @@
+// Condensed, prompt-sized evidence for the script LLM. Works on the Activity
+// shape every session source produces (see src/sources/index.mjs).
+export function condense(act, gitCommits = []) {
+  const fmt = (arr, n, f) => arr.slice(-n).map(f);
+  const toolTally = {};
+  for (const t of act.tools) toolTally[t.name] = (toolTally[t.name] || 0) + 1;
+
+  return {
+    duration_minutes: Math.max(1, Math.round(act.activeMs / 60000)),
+    assistant_turns: act.assistantTurns,
+    tool_uses: act.toolUses,
+    user_prompts: fmt(act.userPrompts, 6, (p) => p.text),
+    assistant_notes: fmt(act.assistantTexts, 8, (a) => a.text.slice(0, 350)),
+    files_touched: act.filesTouched.slice(0, 15),
+    commands_run: fmt(act.commands, 10, (c) => c.desc || c.command),
+    tool_tally: toolTally,
+    git_commits: gitCommits.slice(0, 12),
+    urls_mentioned: act.urls.slice(0, 8),
+    todos: (act.todoSnapshots || []).map((t) => ({ content: t.content, status: t.status })),
+  };
+}

package/src/lib/gitinfo.mjs

@@ -0,0 +1,40 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+
+// Commits in the project repo within the session window. Read-only.
+export function gitCommitsFor(cwd, sinceTs, untilTs) {
+  if (!cwd || !fs.existsSync(cwd)) return [];
+  try {
+    const args = [
+      "-C", cwd, "log", "--oneline", "--no-decorate",
+      `--since=${new Date(sinceTs - 60000).toISOString()}`,
+    ];
+    if (untilTs) args.push(`--until=${new Date(untilTs + 300000).toISOString()}`);
+    const out = execFileSync("git", args, { encoding: "utf-8", timeout: 10000 });
+    return out.split("\n").filter(Boolean).slice(0, 20);
+  } catch {
+    return [];
+  }
+}
+
+export function gitDiffStat(cwd, sinceTs) {
+  if (!cwd || !fs.existsSync(cwd)) return null;
+  try {
+    const range = execFileSync(
+      "git",
+      ["-C", cwd, "log", "--format=%H", `--since=${new Date(sinceTs - 60000).toISOString()}`],
+      { encoding: "utf-8", timeout: 10000 },
+    )
+      .split("\n")
+      .filter(Boolean);
+    if (range.length === 0) return null;
+    const out = execFileSync(
+      "git",
+      ["-C", cwd, "diff", "--shortstat", `${range[range.length - 1]}~1..${range[0]}`],
+      { encoding: "utf-8", timeout: 10000, stdio: ["ignore", "pipe", "ignore"] },
+    ).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}