volito 0.1.0 → 0.3.0

package/dist/chunks/chunk-ZHMWEZ4C.js

@@ -0,0 +1,186 @@
+import {
+  ASPECT_NAMES,
+  checkItem,
+  framePixels,
+  openSession,
+  renderSheet
+} from "./chunk-CUQY6YI3.js";
+
+// src/node/review.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+var PLATFORM_COVERS = {
+  reels: {
+    name: "Instagram Reels",
+    covers: [
+      { area: "header", rect: [0, 0, 1, 0.1] },
+      { area: "like, comment and share buttons", rect: [0.86, 0.46, 0.14, 0.24] },
+      { area: "username, caption and audio", rect: [0, 0.7, 1, 0.3] }
+    ]
+  },
+  shorts: {
+    name: "YouTube Shorts",
+    covers: [
+      { area: "search and menu", rect: [0, 0, 1, 0.07] },
+      { area: "like, comment and share buttons", rect: [0.86, 0.38, 0.14, 0.4] },
+      { area: "title, channel and Subscribe", rect: [0, 0.78, 1, 0.22] }
+    ]
+  },
+  tiktok: {
+    name: "TikTok",
+    covers: [
+      { area: "Following and For You", rect: [0, 0, 1, 0.075] },
+      { area: "profile, like, comment and share buttons", rect: [0.87, 0.4, 0.13, 0.38] },
+      { area: "username, caption and sound", rect: [0, 0.78, 1, 0.22] }
+    ]
+  }
+};
+var FPS = 20;
+var STILL = 4e-3;
+var ANALYSIS_WIDTH = 270;
+function frameChange(a, b) {
+  let changed = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i += 4) if (Math.abs(a[i] - b[i]) > 24 || Math.abs(a[i + 1] - b[i + 1]) > 24 || Math.abs(a[i + 2] - b[i + 2]) > 24 || Math.abs(a[i + 3] - b[i + 3]) > 24) changed++;
+  return changed / (n / 4);
+}
+function readTiming(changes, visible, fps, duration, still = STILL) {
+  const n = visible.length;
+  const firstVisible = visible.findIndex(Boolean);
+  const visibleAt = firstVisible < 0 ? duration : firstVisible / fps;
+  const min = Math.max(2, Math.round(0.3 * fps));
+  let best = { from: -1, to: -1 };
+  for (let i = Math.max(1, firstVisible + 1); i < n; ) {
+    if ((changes[i] ?? 1) > still) {
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j + 1 < n && (changes[j + 1] ?? 1) <= still) j++;
+    if (j - i + 1 >= min && j - i > best.to - best.from) best = { from: i - 1, to: j };
+    i = j + 1;
+  }
+  if (best.from < 0) return { visibleAt, settledAt: null, exitAt: null, hold: 0, duration };
+  const settledAt = best.from / fps;
+  const exitAt = best.to >= n - 1 ? null : best.to / fps;
+  return { visibleAt, settledAt, exitAt, hold: (exitAt ?? duration) - settledAt, duration };
+}
+function zoneShares(px, width, height) {
+  let total = 0;
+  const opaque = new Uint8Array(width * height);
+  for (let i = 0, p = 0; i < px.length; i += 4, p++) if (px[i + 3] > 128) {
+    opaque[p] = 1;
+    total++;
+  }
+  const out = [];
+  if (!total) return out;
+  for (const z of Object.values(PLATFORM_COVERS)) {
+    for (const c of z.covers) {
+      const [fx, fy, fw, fh] = c.rect;
+      const x0 = Math.floor(fx * width), x1 = Math.ceil((fx + fw) * width), y0 = Math.floor(fy * height), y1 = Math.ceil((fy + fh) * height);
+      let inside = 0;
+      for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) inside += opaque[y * width + x];
+      out.push({ platform: z.name, area: c.area, share: inside / total });
+    }
+  }
+  return out;
+}
+var aspectName = (a) => typeof a === "string" ? a : `${a.width}x${a.height}`;
+var s2 = (x) => `${x.toFixed(2)} s`;
+async function reviewItem(item, opts = {}) {
+  const aspects = opts.aspects?.length ? opts.aspects : opts.aspect ? [opts.aspect] : item.aspects ?? ASPECT_NAMES;
+  const dir = opts.outDir ? resolve(opts.outDir) : void 0;
+  if (dir) mkdirSync(dir, { recursive: true });
+  const out = [];
+  for (const aspect of aspects) {
+    const name = aspectName(aspect);
+    const issues = [];
+    const check = await checkItem(item, { ...opts, aspects: [aspect] });
+    const cr = check.aspects[0];
+    for (const e of cr.errors) issues.push({ level: "error", message: e });
+    for (const w of cr.warnings) issues.push({ level: "warning", message: w });
+    let timing = { visibleAt: 0, settledAt: null, exitAt: null, hold: 0, duration: 0 };
+    let zones = [];
+    if (cr.ok) {
+      const s = await openSession(item, { ...opts, aspect, width: ANALYSIS_WIDTH });
+      const duration = s.built.duration;
+      const n = Math.max(2, Math.floor(duration * FPS) + 1);
+      const frames = [];
+      const visible = [];
+      const changes = [0];
+      let size = { width: 0, height: 0 };
+      for (let i = 0; i < n; i++) {
+        const f = framePixels(s, Math.min(duration, i / FPS));
+        size = { width: f.width, height: f.height };
+        let any = false;
+        for (let k = 3; k < f.data.length; k += 16) if (f.data[k] > 8) {
+          any = true;
+          break;
+        }
+        visible.push(any);
+        if (i > 0) changes.push(frameChange(frames[i - 1], f.data));
+        frames.push(f.data);
+      }
+      timing = readTiming(changes, visible, FPS, duration);
+      const words = Object.entries(item.props).filter(([, p]) => p.type === "text" || p.type === "longtext").map(([k]) => String(s.built.props[k] ?? "")).join(" ").trim().split(/\s+/).filter(Boolean).length;
+      const interactive = !!item.states;
+      if (interactive) issues.push({ level: "note", message: "it has interactive states: on a page each state plays on its own, so its holds wait on the viewer \u2014 check each state with <volito-player>" });
+      else if (timing.settledAt === null) issues.push({ level: "note", message: "it never holds still (an idle, a moving ground or a long entrance) \u2014 fine for grounds; check the sheet that text is readable while it moves" });
+      else {
+        const entrance = timing.settledAt - timing.visibleAt;
+        if (entrance > 1.5) issues.push({ level: "warning", message: `its entrance takes ${s2(entrance)} to settle \u2014 viewers wait for it`, fix: "--speed 1.25, a faster mood, or a shorter entrance move" });
+        const needed = Math.max(1.5, words * 0.25);
+        if (words && timing.hold < needed) issues.push({ level: "warning", message: `it holds still for ${s2(timing.hold)}; ${words} words need about ${s2(needed)} to read`, fix: `a longer --duration, or --beat out to start the exit later` });
+        if (timing.visibleAt > 1) issues.push({ level: "note", message: `nothing shows until ${s2(timing.visibleAt)}` });
+      }
+      if (item.placement !== "full" && item.category !== "transition" && size.width && size.height > size.width * 1.5) {
+        const mid = timing.settledAt !== null ? Math.min(duration, timing.settledAt + Math.min(0.5, timing.hold / 2)) : duration / 2;
+        const f = framePixels(s, mid);
+        zones = zoneShares(f.data, f.width, f.height);
+        const worst = /* @__PURE__ */ new Map();
+        for (const z of zones) if (z.share > (worst.get(z.platform)?.share ?? 0)) worst.set(z.platform, z);
+        for (const [platform, z] of worst) if (z.share >= 0.05) issues.push({ level: "warning", message: `${Math.round(z.share * 100)}% of the graphic sits under ${platform}${platform.endsWith("s") ? "'" : "'s"} ${z.area}`, fix: "a top or centre placement, or keep it for 16:9 and 1:1" });
+      }
+    }
+    let sheet;
+    if (dir && cr.ok) {
+      const r = await renderSheet(item, { ...opts, aspect, tileWidth: 360 });
+      sheet = join(dir, `${item.id}-${name.replace(":", "x")}.png`);
+      writeFileSync(sheet, r.png);
+    }
+    out.push({ aspect: name, ok: !issues.some((i) => i.level === "error"), timing, zones, issues, ...sheet ? { sheet } : {} });
+  }
+  const report = { ref: item.ref, placement: item.placement, ok: out.every((a) => a.ok), aspects: out, ...dir ? { dir } : {} };
+  if (dir) {
+    writeFileSync(join(dir, "review.json"), `${JSON.stringify(report, null, 2)}
+`);
+    writeFileSync(join(dir, "review.md"), `${describeReview(report, { markdown: true })}
+`);
+  }
+  return report;
+}
+function describeReview(rep, opts = {}) {
+  const md = !!opts.markdown;
+  const lines = [md ? `# Review: ${rep.ref}` : `${rep.ref}: ${rep.ok ? "ready" : "problems"}`];
+  for (const a of rep.aspects) {
+    const t = a.timing;
+    const timing = t.settledAt === null ? "keeps moving" : `in by ${s2(t.settledAt)} \xB7 holds ${s2(t.hold)}${t.exitAt !== null ? ` \xB7 leaves at ${s2(t.exitAt)}` : " to the end"}`;
+    lines.push(md ? `
+## ${a.aspect} \u2014 ${a.ok ? "ok" : "problems"}
+
+${timing}` : `  ${a.aspect}: ${a.ok ? "ok" : "FAILED"} \xB7 ${timing}`);
+    for (const i of a.issues) lines.push(`${md ? "- " : "    "}${i.level}: ${i.message}${i.fix ? ` \u2192 ${i.fix}` : ""}`);
+    if (a.sheet) lines.push(md ? `
+![${a.aspect}](${a.sheet.split("/").pop()})` : `    sheet: ${a.sheet}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  PLATFORM_COVERS,
+  frameChange,
+  readTiming,
+  zoneShares,
+  reviewItem,
+  describeReview
+};

package/dist/chunks/init-JX2BYRKT.js

@@ -0,0 +1,189 @@
+import {
+  ffmpegPath,
+  packageRoot,
+  packageVersion,
+  probeFfmpeg
+} from "./chunk-ZFG3X3DU.js";
+
+// src/node/init.ts
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+var AGENTS = ["claude", "cursor", "vscode", "codex"];
+var AGENT_NAMES = { claude: "Claude Code", cursor: "Cursor", vscode: "VS Code", codex: "Codex" };
+var MCP_SERVER = { command: "npx", args: ["-y", "volito", "mcp"] };
+var CODEX_COMMAND = "codex mcp add volito -- npx -y volito mcp";
+var MCP_FILES = {
+  claude: { path: ".mcp.json", key: "mcpServers", entry: { ...MCP_SERVER } },
+  cursor: { path: join(".cursor", "mcp.json"), key: "mcpServers", entry: { ...MCP_SERVER } },
+  vscode: { path: join(".vscode", "mcp.json"), key: "servers", entry: { type: "stdio", ...MCP_SERVER } }
+};
+var SKILL_DIR = join(".claude", "skills", "volito");
+function detectAgents(cwd, onPath = binOnPath) {
+  const has = (p) => existsSync(join(cwd, p));
+  const found = /* @__PURE__ */ new Set();
+  if (has(".claude") || has("CLAUDE.md") || has(".mcp.json") || onPath("claude")) found.add("claude");
+  if (has(".cursor") || has(".cursorrules")) found.add("cursor");
+  if (has(".vscode")) found.add("vscode");
+  if (has("AGENTS.md") || has(".codex") || onPath("codex")) found.add("codex");
+  return AGENTS.filter((a) => found.has(a));
+}
+function parseAgents(arg) {
+  const words = arg.split(/[\s,]+/).map((w) => w.trim().toLowerCase()).filter(Boolean);
+  if (words.includes("all")) return [...AGENTS];
+  const bad = words.filter((w) => !AGENTS.includes(w));
+  if (bad.length || !words.length) throw new Error(`--agent takes all or any of ${AGENTS.join(", ")} (got "${arg}")`);
+  return AGENTS.filter((a) => words.includes(a));
+}
+function mergeMcpConfig(text, key, entry, force = false) {
+  let doc = {};
+  if (text && text.trim()) {
+    try {
+      const parsed = JSON.parse(text);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+      doc = parsed;
+    } catch {
+      return null;
+    }
+  }
+  const servers = doc[key] ?? {};
+  if (typeof servers !== "object" || servers === null || Array.isArray(servers)) return null;
+  const map = servers;
+  const had = "volito" in map;
+  if (had && !force) return { text: text ?? "", changed: false, had };
+  const next = { ...doc, [key]: { ...map, volito: entry } };
+  return { text: `${JSON.stringify(next, null, 2)}
+`, changed: true, had };
+}
+function planInit(cwd, opts = {}, onPath = binOnPath) {
+  const detected = detectAgents(cwd, onPath);
+  const agents = opts.agents?.length ? opts.agents : detected.length ? detected : ["claude"];
+  const actions = [];
+  for (const agent of agents) {
+    const file = MCP_FILES[agent];
+    if (!file) {
+      actions.push({ kind: "note", agent, detail: `${AGENT_NAMES[agent]} keeps MCP servers in its global config. Add Volito with:
+    ${CODEX_COMMAND}` });
+      continue;
+    }
+    const path = join(cwd, file.path);
+    const merged = mergeMcpConfig(existsSync(path) ? readFileSync(path, "utf8") : null, file.key, file.entry, opts.force);
+    if (!merged) actions.push({ kind: "skip", agent, path, detail: `${file.path} is not a JSON object with a "${file.key}" map \u2014 left alone. Add "volito": ${JSON.stringify(file.entry)} under "${file.key}" yourself.` });
+    else if (!merged.changed) actions.push({ kind: "skip", agent, path, detail: `${file.path} already has a volito server (--force replaces it)` });
+    else actions.push({ kind: "write", agent, path, content: merged.text, detail: `${merged.had ? "replaced" : "added"} the volito MCP server in ${file.path}` });
+  }
+  if (opts.skill !== false && agents.includes("claude")) {
+    const from = skillSource();
+    const path = join(cwd, SKILL_DIR);
+    if (existsSync(join(path, "SKILL.md")) && !opts.force) actions.push({ kind: "skip", agent: "claude", path, detail: `${SKILL_DIR} already exists (--force replaces it)` });
+    else actions.push({ kind: "copy", agent: "claude", from, path, detail: `put the Volito skill in ${SKILL_DIR}` });
+  }
+  if (agents.some((a) => a !== "claude")) actions.push({ kind: "note", detail: "For the skill in other agents: npx skills add monarcpro/volito" });
+  return { agents, detected: detected.length > 0, actions };
+}
+function applyInit(actions) {
+  for (const a of actions) {
+    if (a.kind === "write") {
+      mkdirSync(dirname(a.path), { recursive: true });
+      writeFileSync(a.path, a.content);
+    } else if (a.kind === "copy") {
+      mkdirSync(a.path, { recursive: true });
+      cpSync(a.from, a.path, { recursive: true, force: true });
+    }
+  }
+}
+function skillSource() {
+  return join(packageRoot(), "skills", "volito");
+}
+function binOnPath(bin) {
+  const exts = process.platform === "win32" ? ["", ".cmd", ".exe", ".bat"] : [""];
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) if (existsSync(join(dir, bin + ext))) return true;
+  }
+  return false;
+}
+function describeInit(plan, dryRun) {
+  const lines = [];
+  lines.push(`${dryRun ? "Would set up" : "Set up"} Volito ${packageVersion()} for ${plan.agents.map((a) => AGENT_NAMES[a]).join(", ")}${plan.detected ? "" : " (no agent found in this folder, so Claude Code; pick with --agent)"}`);
+  for (const a of plan.actions) {
+    const doing = a.kind === "write" || a.kind === "copy";
+    const mark = doing ? dryRun ? "\xB7" : "\u2713" : a.kind === "skip" ? "\u2013" : "\u2192";
+    const detail = doing && dryRun ? a.detail.replace(/^(added|replaced|put)\b/, (w) => `would ${{ added: "add", replaced: "replace", put: "put" }[w]}`) : a.detail;
+    lines.push(`  ${mark} ${detail}`);
+  }
+  lines.push("");
+  lines.push(dryRun ? "Nothing was written (--dry-run)." : 'Restart your agent, then ask it: "Make a lower third for Priya Sharma, product designer, 9:16 for Reels, in our brand."');
+  return lines.join("\n");
+}
+function runDoctor(cwd, onPath = binOnPath) {
+  const checks = [];
+  const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+  const nodeOk = major > 20 || major === 20 && minor >= 10;
+  checks.push({ name: "Node", ok: nodeOk, detail: `${process.versions.node}${nodeOk ? "" : " \u2014 Volito needs 20.10 or newer"}`, fix: nodeOk ? void 0 : "install Node.js 20.10 or newer" });
+  const probe = probeFfmpeg();
+  if (!probe) {
+    checks.push({ name: "FFmpeg", ok: false, detail: `not found (${ffmpegPath()}) \u2014 stills, sheets and PNG frames still work`, fix: "macOS: brew install ffmpeg \xB7 Debian/Ubuntu: apt install ffmpeg \xB7 Windows: winget install ffmpeg \xB7 or set VOLITO_FFMPEG" });
+  } else {
+    const want = [
+      ["prores_ks", "MOV ProRes 4444"],
+      ["libx264", "MP4"],
+      ["libvpx-vp9", "WebM"],
+      ["libopus", "WebM sound"],
+      ["aac", "MP4 sound"]
+    ];
+    const missing = want.filter(([enc]) => !probe.encoders.has(enc)).map(([, what]) => what);
+    const hevc = probe.encoders.has("hevc_videotoolbox") || probe.encoders.has("libx265");
+    checks.push({ name: "FFmpeg", ok: true, detail: probe.path });
+    checks.push({ name: "Formats", ok: missing.length === 0, detail: missing.length ? `missing encoders for ${missing.join(", ")}` : "MOV, MP4, WebM and their sound", fix: missing.length ? "install an FFmpeg built with libvpx, libopus and libx264" : void 0 });
+    checks.push({ name: "HEVC with alpha", ok: hevc, detail: hevc ? "available" : "needs VideoToolbox (macOS) or libx265", fix: hevc ? void 0 : "optional: render ProRes 4444 or WebM for alpha instead" });
+  }
+  const fonts = join(packageRoot(), "fonts");
+  const faces = existsSync(fonts) ? readdirSync(fonts).filter((f) => f.endsWith(".ttf")).length : 0;
+  checks.push({ name: "Fonts", ok: faces > 0, detail: `${faces} bundled faces` });
+  const agents = detectAgents(cwd, onPath);
+  for (const agent of AGENTS) {
+    const file = MCP_FILES[agent];
+    if (!file) {
+      if (agents.includes(agent)) checks.push({ name: AGENT_NAMES[agent], ok: true, detail: "found; its MCP config is global", fix: CODEX_COMMAND });
+      continue;
+    }
+    const path = join(cwd, file.path);
+    if (!existsSync(path)) {
+      if (agents.includes(agent)) checks.push({ name: AGENT_NAMES[agent], ok: false, detail: `no ${file.path}`, fix: `volito init --agent ${agent}` });
+      continue;
+    }
+    const merged = mergeMcpConfig(readFileSync(path, "utf8"), file.key, file.entry);
+    checks.push({ name: AGENT_NAMES[agent], ok: !!merged?.had, detail: merged?.had ? `volito server in ${file.path}` : `${file.path} has no volito server`, fix: merged?.had ? void 0 : `volito init --agent ${agent}` });
+  }
+  if (agents.includes("claude")) {
+    const has = existsSync(join(cwd, SKILL_DIR, "SKILL.md"));
+    checks.push({ name: "Skill", ok: has, detail: has ? SKILL_DIR : `no ${SKILL_DIR}`, fix: has ? void 0 : "volito init" });
+  }
+  return checks;
+}
+function describeDoctor(checks) {
+  const width = Math.max(...checks.map((c) => c.name.length));
+  const lines = [`Volito ${packageVersion()}`];
+  for (const c of checks) {
+    lines.push(`  ${c.ok ? "\u2713" : "\u2717"} ${c.name.padEnd(width)}  ${c.detail}`);
+    if (!c.ok && c.fix) lines.push(`    ${" ".repeat(width)}  \u2192 ${c.fix}`);
+  }
+  return lines.join("\n");
+}
+export {
+  AGENTS,
+  AGENT_NAMES,
+  CODEX_COMMAND,
+  MCP_SERVER,
+  SKILL_DIR,
+  applyInit,
+  binOnPath,
+  describeDoctor,
+  describeInit,
+  detectAgents,
+  mergeMcpConfig,
+  parseAgents,
+  planInit,
+  runDoctor,
+  skillSource
+};

package/dist/chunks/review-RBH5EUZN.js

@@ -0,0 +1,18 @@
+import {
+  PLATFORM_COVERS,
+  describeReview,
+  frameChange,
+  readTiming,
+  reviewItem,
+  zoneShares
+} from "./chunk-ZHMWEZ4C.js";
+import "./chunk-CUQY6YI3.js";
+import "./chunk-ZFG3X3DU.js";
+export {
+  PLATFORM_COVERS,
+  describeReview,
+  frameChange,
+  readTiming,
+  reviewItem,
+  zoneShares
+};