agentreel 0.3.3 → 0.3.5

package/bin/agentreel.mjs

@@ -30,6 +30,7 @@ function parseArgs() {
     else if (arg === "--output" || arg === "-o") flags.output = args[++i];
     else if (arg === "--music") flags.music = args[++i];
     else if (arg === "--auth" || arg === "-a") flags.auth = args[++i];
+    else if (arg === "--guidelines" || arg === "-g") flags.guidelines = args[++i];
     else if (arg === "--no-share") flags.noShare = true;
   }
   return flags;
@@ -49,6 +50,7 @@ Flags:
   -t, --title <text>      video title
   -o, --output <file>     output file (default: agentreel.mp4)
   -a, --auth <file>       Playwright storage state (cookies/auth) for browser demos
+  -g, --guidelines <text>  guidelines for highlight generation (e.g. "focus on speed")
       --music <file>      path to background music mp3
       --no-share          skip the share prompt
   -h, --help              show help
@@ -98,26 +100,28 @@ function ensureBrowserDeps() {
   });
 }
 
-function recordCLI(command, workDir, context) {
+function recordCLI(command, workDir, context, guidelines) {
   const python = findPython();
   const script = join(ROOT, "scripts", "cli_demo.py");
   const outFile = join(tmpdir(), "agentreel-cli-demo.cast");
 
   const args = [script, command, workDir, outFile];
   if (context) args.push(context);
+  if (guidelines) args.push(guidelines);
 
   console.error(`Agent planning CLI demo for: ${command}`);
   execFileSync(python, args, { stdio: ["ignore", "inherit", "inherit"], env: process.env });
   return outFile;
 }
 
-function extractHighlightsFromCast(castPath, context) {
+function extractHighlightsFromCast(castPath, context, guidelines) {
   const python = findPython();
   const script = join(ROOT, "scripts", "cli_demo.py");
   const outFile = castPath + "-highlights.json";
 
   const args = [script, "--highlights", castPath, outFile];
   if (context) args.push(context);
+  if (guidelines) args.push(guidelines);
 
   execFileSync(python, args, { stdio: ["ignore", "inherit", "inherit"], env: process.env });
   return outFile;
@@ -130,7 +134,7 @@ function browserEnv() {
   return { ...process.env, PLAYWRIGHT_BROWSERS_PATH: browsersDir };
 }
 
-function recordBrowser(url, task, authState) {
+function recordBrowser(url, task, authState, guidelines) {
   const python = findPython();
   const script = join(ROOT, "scripts", "browser_demo.py");
   const outFile = join(tmpdir(), "agentreel-browser-demo.mp4");
@@ -138,6 +142,7 @@ function recordBrowser(url, task, authState) {
   console.error(`Agent demoing browser app: ${url}`);
   const args = [script, url, outFile, task];
   if (authState) args.push("--auth", authState);
+  if (guidelines) args.push("--guidelines", guidelines);
   execFileSync(python, args, {
     stdio: ["ignore", "inherit", "inherit"],
     env: browserEnv(),
@@ -160,12 +165,28 @@ function extractBrowserHighlights(videoPath, task) {
 
 // ── Browser Highlight Builder ───────────────────────────────
 
-function buildBrowserHighlights(clicks, videoPath, task) {
+function buildBrowserHighlights(clicks, videoPath, task, guidelines) {
   const CLIP_DUR = 7;
   const MIN_HIGHLIGHTS = 3;
   const MAX_HIGHLIGHTS = 4;
-  const labels = ["Overview", "Interact", "Navigate", "Result"];
-  const overlays = ["**First look**", "**Key action**", "**Exploring**", "**The result**"];
+  // Ask Claude to generate labels/overlays based on the task
+  let labels, overlays;
+  try {
+    const guidelinesLine = guidelines ? `\nGuidelines: ${guidelines}` : "";
+    const genPrompt = `Generate exactly 4 highlight labels and overlay captions for a short browser demo video.
+Task: ${task}${guidelinesLine}
+
+Return a JSON object: {"labels": ["word1", "word2", "word3", "word4"], "overlays": ["**caption1**", "**caption2**", "**caption3**", "**caption4**"]}
+Labels: 1-2 words each, specific to this app (not generic). Overlays: short punchy captions with **markdown bold** for emphasis. Return ONLY JSON.`;
+    const result = execFileSync("claude", ["-p", genPrompt, "--output-format", "text"], {
+      encoding: "utf-8", timeout: 30000, stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const parsed = JSON.parse(result.replace(/```json?\n?/g, "").replace(/```/g, "").trim());
+    labels = parsed.labels?.length >= 4 ? parsed.labels : null;
+    overlays = parsed.overlays?.length >= 4 ? parsed.overlays : null;
+  } catch { /* fall through */ }
+  if (!labels) labels = ["Overview", "Interact", "Navigate", "Result"];
+  if (!overlays) overlays = ["**First look**", "**Key action**", "**Exploring**", "**The result**"];
 
   // Estimate video duration from last click or default to 25s
   const lastClickTime = clicks.length > 0 ? clicks[clicks.length - 1].timeSec : 0;
@@ -406,10 +427,10 @@ async function main() {
 
   if (demoCmd) {
     console.error("Step 1/3: Recording CLI demo...");
-    const castPath = recordCLI(demoCmd, process.cwd(), prompt);
+    const castPath = recordCLI(demoCmd, process.cwd(), prompt, flags.guidelines);
 
     console.error("Step 2/3: Extracting highlights...");
-    const highlightsPath = extractHighlightsFromCast(castPath, prompt);
+    const highlightsPath = extractHighlightsFromCast(castPath, prompt, flags.guidelines);
     const highlights = JSON.parse(readFileSync(highlightsPath, "utf-8"));
     console.error(`  ${highlights.length} highlights extracted`);
 
@@ -432,7 +453,7 @@ async function main() {
 
     ensureBrowserDeps();
     console.error("Step 1/3: Recording browser demo...");
-    const videoPath = recordBrowser(demoURL, task, flags.auth);
+    const videoPath = recordBrowser(demoURL, task, flags.auth, flags.guidelines);
 
     // Copy video to Remotion public dir so it can be served
     const publicDir = join(ROOT, "public");
@@ -449,7 +470,7 @@ async function main() {
       console.error(`  ${allClicks.length} clicks captured`);
     }
 
-    const highlights = buildBrowserHighlights(allClicks, videoPath, task);
+    const highlights = buildBrowserHighlights(allClicks, videoPath, task, flags.guidelines);
 
     console.error("Step 3/3: Rendering video...");
     await renderVideo({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentreel",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Turn your web apps and CLIs into viral clips",
   "bin": {
     "agentreel": "./bin/agentreel.mjs"

package/scripts/browser_demo.py

@@ -30,11 +30,13 @@ def find_claude():
     return "claude"
 
 
-def generate_playwright_script(url, task):
+def generate_playwright_script(url, task, guidelines=""):
     """Use claude CLI to generate a Playwright demo script."""
+    guidelines_part = f"IMPORTANT guidelines: {guidelines}. " if guidelines else ""
     prompt = (
         f"Generate a Playwright Python async function that demos a web app at {url}. "
         f"Task: {task}. "
+        f"{guidelines_part}"
         f"The function signature is: async def demo(page). "
         f"Navigate to the URL, wait for load, interact with key features — "
         f"click buttons, fill forms, scroll. Take about 20 seconds total. "
@@ -124,12 +126,12 @@ def extract_highlights(video_path, task):
     return highlights
 
 
-async def record_browser_demo(url, task, output_path, auth_state=None):
+async def record_browser_demo(url, task, output_path, auth_state=None, guidelines=""):
     """Generate and run a Playwright demo with video recording."""
     from playwright.async_api import async_playwright
 
     print(f"Generating demo script for {url}...", file=sys.stderr)
-    script_code = generate_playwright_script(url, task)
+    script_code = generate_playwright_script(url, task, guidelines)
     print(f"Script ready ({len(script_code)} chars)", file=sys.stderr)
 
     video_dir = tempfile.mkdtemp()
@@ -269,12 +271,16 @@ if __name__ == "__main__":
         # Parse remaining args: [task] [--auth <state_file>]
         task = "Explore the main features"
         auth_state = None
+        guidelines = ""
         i = 3
         while i < len(sys.argv):
             if sys.argv[i] == "--auth" and i + 1 < len(sys.argv):
                 auth_state = sys.argv[i + 1]
                 i += 2
+            elif sys.argv[i] == "--guidelines" and i + 1 < len(sys.argv):
+                guidelines = sys.argv[i + 1]
+                i += 2
             else:
                 task = sys.argv[i]
                 i += 1
-        asyncio.run(record_browser_demo(url, task, output, auth_state=auth_state))
+        asyncio.run(record_browser_demo(url, task, output, auth_state=auth_state, guidelines=guidelines))

package/scripts/cli_demo.py

@@ -33,12 +33,14 @@ def find_claude():
     return "claude"
 
 
-def generate_demo_plan(command: str, context: str) -> list[dict]:
+def generate_demo_plan(command: str, context: str, guidelines: str = "") -> list[dict]:
     """Use claude CLI to plan a demo sequence."""
+    guidelines_block = f"\n\nIMPORTANT guidelines you MUST follow:\n{guidelines}" if guidelines else ""
+
     prompt = f"""You are planning a terminal demo for a CLI tool. The tool is invoked with: {command}
 
 Context about what this tool does:
-{context}
+{context}{guidelines_block}
 
 Generate a JSON array of demo steps. Each step is an object with:
 - "type": "command" (run a shell command)
@@ -195,7 +197,7 @@ def record_demo(steps: list[dict], workdir: str, output_path: str):
     print(f"Saved: {output_path}", file=sys.stderr)
 
 
-def extract_highlights(cast_path: str, context: str) -> list[dict]:
+def extract_highlights(cast_path: str, context: str, guidelines: str = "") -> list[dict]:
     """Ask Claude to pick 3-4 highlight moments from the recorded session."""
     # Read the asciicast and strip to just the text content
     lines_output = []
@@ -214,13 +216,15 @@ def extract_highlights(cast_path: str, context: str) -> list[dict]:
     # Clean ANSI for Claude to read, but keep the raw for display
     clean = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', raw_output)
 
+    guidelines_block = f"\n\nAdditional guidelines: {guidelines}" if guidelines else ""
+
     prompt = f"""You are creating a highlights reel for a CLI tool demo video. Here is the full terminal output:
 
 ---
 {clean[:3000]}
 ---
 
-Context: {context}
+Context: {context}{guidelines_block}
 
 Pick 3-4 highlight moments that would look impressive in a short video. For each highlight, return:
 - "label": short label (1-2 words) like "Initialize", "Configure", "Run", "Results"
@@ -274,8 +278,9 @@ if __name__ == "__main__":
         cast_file = sys.argv[2]
         output = sys.argv[3]
         context = sys.argv[4] if len(sys.argv) > 4 else ""
+        guidelines = sys.argv[5] if len(sys.argv) > 5 else ""
         print(f"Extracting highlights from: {cast_file}", file=sys.stderr)
-        highlights = extract_highlights(cast_file, context)
+        highlights = extract_highlights(cast_file, context, guidelines)
         with open(output, "w") as f:
             json.dump(highlights, f, indent=2)
         print(f"Saved {len(highlights)} highlights to: {output}", file=sys.stderr)
@@ -286,9 +291,10 @@ if __name__ == "__main__":
     workdir = sys.argv[2]
     output = sys.argv[3]
     context = sys.argv[4] if len(sys.argv) > 4 else ""
+    guidelines = sys.argv[5] if len(sys.argv) > 5 else ""
 
     print(f"Planning demo for: {command}", file=sys.stderr)
-    steps = generate_demo_plan(command, context)
+    steps = generate_demo_plan(command, context, guidelines)
     print(f"Generated {len(steps)} steps:", file=sys.stderr)
     for s in steps:
         print(f"  $ {s['value']}  — {s.get('description', '')}", file=sys.stderr)
@@ -299,7 +305,7 @@ if __name__ == "__main__":
     # Extract highlights from the recording
     highlights_path = output.replace(".cast", "-highlights.json")
     print("Extracting highlights...", file=sys.stderr)
-    highlights = extract_highlights(output, context)
+    highlights = extract_highlights(output, context, guidelines)
     with open(highlights_path, "w") as f:
         json.dump(highlights, f, indent=2)
     print(f"Saved {len(highlights)} highlights to: {highlights_path}", file=sys.stderr)