merleau 0.1.1__tar.gz → 0.2.0__tar.gz

merleau-0.2.0/.github/workflows/python-publish.yml

@@ -0,0 +1,65 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Build release distributions
+        run: |
+          # NOTE: put your own distribution build steps here.
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    # Dedicated environments with protections for publishing are strongly recommended.
+    # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules
+    environment:
+      name: pypi
+      url: https://pypi.org/p/merleau
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

merleau-0.2.0/.gitignore

@@ -0,0 +1,7 @@
+.env
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/

merleau-0.2.0/CLAUDE.md

@@ -0,0 +1,57 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Merleau is a CLI tool for video understanding using Google's Gemini API. Named after Maurice Merleau-Ponty, the phenomenologist philosopher. The CLI command is `ponty`.
+
+See `research/positioning_merleau.md` for market positioning and differentiation strategy.
+
+## Commands
+
+```bash
+# Install dependencies
+uv sync
+
+# Run the CLI
+uv run ponty video.mp4
+uv run ponty video.mp4 -p "Custom prompt" -m gemini-2.0-flash
+
+# Build package
+uv build
+
+# Publish to PyPI
+uv publish --token <token>
+```
+
+## Architecture
+
+```
+merleau/
+├── merleau/
+│   ├── __init__.py    # Package version
+│   └── cli.py         # CLI entry point (ponty command)
+├── research/          # Market research and positioning
+├── pyproject.toml     # Package config with [project.scripts] entry point
+└── analyze_video.py   # Legacy standalone script
+```
+
+### CLI Flow (merleau/cli.py)
+1. Parse arguments (video path, prompt, model, cost flag)
+2. Load API key from environment or `.env`
+3. Upload video to Gemini Files API
+4. Poll for processing completion
+5. Generate content analysis
+6. Display results and optional cost breakdown
+
+## Key Differentiators
+
+- **Native Gemini video** - Only CLI with true video understanding (not frame extraction)
+- **YouTube URL support** - Direct analysis via Gemini's preview feature
+- **Cost transparency** - Token usage and pricing shown by default
+
+## Configuration
+
+- `.env` - Contains `GEMINI_API_KEY` (required)
+- `pyproject.toml` - Package metadata, dependencies, and CLI entry point

{merleau-0.1.1 → merleau-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: merleau
-Version: 0.1.1
+Version: 0.2.0
 Summary: Video analysis using Google's Gemini 2.5 Flash API
 Requires-Python: >=3.10
 Requires-Dist: google-genai

merleau-0.2.0/README.md

@@ -0,0 +1,77 @@
+# Merleau
+
+> *"The world is not what I think, but what I live through."*
+> — Maurice Merleau-Ponty
+
+A CLI tool for video understanding using Google's Gemini API. Named after [Maurice Merleau-Ponty](https://en.wikipedia.org/wiki/Maurice_Merleau-Ponty), the phenomenologist philosopher whose work on perception inspires how this tool helps you perceive your videos.
+
+## Why Merleau?
+
+Google Gemini is the **only major AI provider** with native video understanding—Claude doesn't support video, and GPT-4o requires frame extraction workarounds. Merleau is the first CLI that actually understands video rather than analyzing frames.
+
+## Features
+
+- **Native Gemini video processing** - Upload and analyze videos directly
+- **YouTube URL support** - Analyze videos directly from YouTube (free preview)
+- **Customizable prompts** - Ask any question about your video
+- **Cost estimation** - Token usage tracking and cost breakdown
+- **Multiple models** - Support for different Gemini models
+
+## Installation
+
+Using [uv](https://docs.astral.sh/uv/) (recommended):
+```bash
+uv sync
+```
+
+Or install from PyPI:
+```bash
+pip install merleau
+```
+
+## Configuration
+
+1. Get a Gemini API key from [Google AI Studio](https://aistudio.google.com/apikey)
+2. Set the API key as an environment variable or create a `.env` file:
+   ```
+   GEMINI_API_KEY=your_api_key_here
+   ```
+
+## Usage
+
+```bash
+# Basic video analysis
+ponty video.mp4
+
+# Custom prompt
+ponty video.mp4 -p "Summarize the key points in this video"
+
+# Use a different model
+ponty video.mp4 -m gemini-2.0-flash
+
+# Hide cost information
+ponty video.mp4 --no-cost
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-p, --prompt` | Prompt for the analysis (default: "Explain what happens in this video") |
+| `-m, --model` | Gemini model to use (default: gemini-2.5-flash) |
+| `--no-cost` | Hide usage and cost information |
+
+## Output
+
+The CLI provides:
+- Video content analysis from Gemini
+- Token usage breakdown (prompt, response, total)
+- Estimated cost based on Gemini pricing
+
+## Pricing Reference
+
+Gemini 2.5 Flash (as of 2025):
+- Input: $0.15 per 1M tokens (text/image), $0.075 per 1M tokens (video)
+- Output: $0.60 per 1M tokens, $3.50 for thinking tokens
+
+A 1-hour video costs approximately **$0.11-0.32** to analyze.

merleau-0.2.0/analyze_video.py

@@ -0,0 +1,56 @@
+import os
+import time
+from dotenv import load_dotenv
+from google import genai
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Initialize the client with the API key
+client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
+
+# Upload the video file
+video_path = "MATLAB_Modernizer.mp4"
+print(f"Uploading video: {video_path}")
+myfile = client.files.upload(file=video_path)
+print(f"Upload complete. File URI: {myfile.uri}")
+
+# Wait for the file to be processed (become ACTIVE)
+print("Waiting for file to be processed...")
+while myfile.state.name == "PROCESSING":
+    print(".", end="", flush=True)
+    time.sleep(2)
+    myfile = client.files.get(name=myfile.name)
+
+if myfile.state.name == "FAILED":
+    raise ValueError(f"File processing failed: {myfile.state.name}")
+
+print(f"\nFile state: {myfile.state.name}")
+
+# Generate content using Gemini 2.5 Flash
+print("\nAnalyzing video with Gemini 2.5 Flash...")
+response = client.models.generate_content(
+    model="gemini-2.5-flash",
+    contents=[myfile, "Explain what happens in this video"]
+)
+print("\n--- Video Analysis ---")
+print(response.text)
+
+# Show usage/cost information
+print("\n--- Usage Information ---")
+if hasattr(response, 'usage_metadata'):
+    usage = response.usage_metadata
+    print(f"Prompt tokens: {usage.prompt_token_count}")
+    print(f"Response tokens: {usage.candidates_token_count}")
+    print(f"Total tokens: {usage.total_token_count}")
+
+    # Gemini 2.5 Flash pricing (as of 2025):
+    # Input: $0.15 per 1M tokens (text/image), $0.075 per 1M tokens for video
+    # Output: $0.60 per 1M tokens, $3.50 for thinking tokens
+    input_cost = (usage.prompt_token_count / 1_000_000) * 0.15
+    output_cost = (usage.candidates_token_count / 1_000_000) * 0.60
+    total_cost = input_cost + output_cost
+    print(f"\nEstimated cost:")
+    print(f"  Input:  ${input_cost:.6f}")
+    print(f"  Output: ${output_cost:.6f}")
+    print(f"  Total:  ${total_cost:.6f}")

merleau-0.2.0/merleau/__init__.py

@@ -0,0 +1,3 @@
+"""Merleau - Video analysis using Google's Gemini API."""
+
+__version__ = "0.2.0"

merleau-0.2.0/merleau/cli.py

@@ -0,0 +1,117 @@
+"""Command-line interface for Merleau video analysis."""
+
+import argparse
+import os
+import sys
+import time
+
+from dotenv import load_dotenv
+from google import genai
+
+
+def wait_for_processing(client, file):
+    """Wait for file to finish processing."""
+    while file.state.name == "PROCESSING":
+        print(".", end="", flush=True)
+        time.sleep(2)
+        file = client.files.get(name=file.name)
+    print()
+    return file
+
+
+def print_usage(usage):
+    """Print token usage and cost estimation."""
+    print("\n--- Usage Information ---")
+    print(f"Prompt tokens: {usage.prompt_token_count}")
+    print(f"Response tokens: {usage.candidates_token_count}")
+    print(f"Total tokens: {usage.total_token_count}")
+
+    # Gemini 2.5 Flash pricing (as of 2025):
+    # Input: $0.15 per 1M tokens (text/image), $0.075 per 1M tokens for video
+    # Output: $0.60 per 1M tokens, $3.50 for thinking tokens
+    input_cost = (usage.prompt_token_count / 1_000_000) * 0.15
+    output_cost = (usage.candidates_token_count / 1_000_000) * 0.60
+    total_cost = input_cost + output_cost
+    print(f"\nEstimated cost:")
+    print(f"  Input:  ${input_cost:.6f}")
+    print(f"  Output: ${output_cost:.6f}")
+    print(f"  Total:  ${total_cost:.6f}")
+
+
+def analyze(video_path, prompt, model, show_cost):
+    """Analyze a video file using Gemini."""
+    load_dotenv()
+
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        print("Error: GEMINI_API_KEY not found in environment or .env file", file=sys.stderr)
+        sys.exit(1)
+
+    if not os.path.exists(video_path):
+        print(f"Error: Video file not found: {video_path}", file=sys.stderr)
+        sys.exit(1)
+
+    client = genai.Client(api_key=api_key)
+
+    # Upload video
+    print(f"Uploading video: {video_path}")
+    myfile = client.files.upload(file=video_path)
+    print(f"Upload complete. File URI: {myfile.uri}")
+
+    # Wait for processing
+    print("Waiting for file to be processed...", end="")
+    myfile = wait_for_processing(client, myfile)
+
+    if myfile.state.name == "FAILED":
+        print(f"Error: File processing failed", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"File state: {myfile.state.name}")
+
+    # Generate analysis
+    print(f"\nAnalyzing video with {model}...")
+    response = client.models.generate_content(
+        model=model,
+        contents=[myfile, prompt]
+    )
+
+    print("\n--- Video Analysis ---")
+    print(response.text)
+
+    # Show usage if requested
+    if show_cost and hasattr(response, 'usage_metadata'):
+        print_usage(response.usage_metadata)
+
+
+def main():
+    """Main entry point for the CLI."""
+    parser = argparse.ArgumentParser(
+        prog="ponty",
+        description="Analyze videos using Google's Gemini API"
+    )
+    parser.add_argument(
+        "video",
+        help="Path to the video file to analyze"
+    )
+    parser.add_argument(
+        "-p", "--prompt",
+        default="Explain what happens in this video",
+        help="Prompt for the analysis (default: 'Explain what happens in this video')"
+    )
+    parser.add_argument(
+        "-m", "--model",
+        default="gemini-2.5-flash",
+        help="Gemini model to use (default: gemini-2.5-flash)"
+    )
+    parser.add_argument(
+        "--no-cost",
+        action="store_true",
+        help="Hide usage and cost information"
+    )
+
+    args = parser.parse_args()
+    analyze(args.video, args.prompt, args.model, show_cost=not args.no_cost)
+
+
+if __name__ == "__main__":
+    main()

{merleau-0.1.1 → merleau-0.2.0}/pyproject.toml

@@ -1,9 +1,16 @@
 [project]
 name = "merleau"
-version = "0.1.1"
+version = "0.2.0"
 description = "Video analysis using Google's Gemini 2.5 Flash API"
 requires-python = ">=3.10"
 dependencies = [
     "google-genai",
     "python-dotenv",
 ]
+
+[project.scripts]
+ponty = "merleau.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

merleau-0.2.0/research/positioning_merleau.md

@@ -0,0 +1,191 @@
+# Positioning merleau: A strategic guide for Gemini-powered video CLI tools
+
+**Merleau enters a market with a significant gap**: no unified CLI tool offers native Gemini video understanding combined with multi-provider support and developer-first design. Google Gemini is the **only major AI provider** with true native video processing—Claude doesn't support video at all, and GPT-4o requires manual frame extraction workarounds. This creates a compelling differentiation opportunity for a well-designed open-source tool.
+
+The addressable market includes **500,000-2 million technical users** (developers, agencies, technical creators) who are underserved by existing GUI-focused solutions. The timing is favorable: video AI is "one of the fastest growing areas in AI," and Gemini's 2024-2025 updates have made native video understanding both powerful and cost-effective at **$0.11-0.32 per hour of video**.
+
+---
+
+## The competitive landscape reveals a clear opportunity
+
+The AI video analysis tool ecosystem in 2024-2025 divides into four distinct categories, each with notable gaps:
+
+**Scene detection tools** like PySceneDetect (~2.5k GitHub stars) handle technical video segmentation well, but lack semantic understanding. **Traditional computer vision libraries** (supervision, MMAction2, PyTorchVideo) serve research use cases but require significant expertise. **YouTube-specific tools** like youtube-transcript-api (4k+ stars) extract transcripts effectively but don't analyze actual video content.
+
+The most direct competitor is **video-analyzer** (1.2k stars, byjlw/video-analyzer), which supports frame extraction + Whisper transcription + vision model analysis with Ollama, OpenAI, and OpenRouter. However, it doesn't support **native Gemini video upload**, meaning it misses Gemini's key advantage: processing video files directly with combined audio-visual analysis rather than frame extraction.
+
+| Capability Gap | Current State | merleau Opportunity |
+|----------------|---------------|---------------------|
+| Native Gemini video | No existing CLI tool | First-mover advantage |
+| Multi-provider unified UX | Fragmented approaches | Single consistent interface |
+| YouTube URL analysis | Transcript-only tools | Full video understanding via Gemini |
+| Cost estimation | Not available | Pre-processing cost preview |
+| Structured output standards | Inconsistent schemas | Standardized JSON output |
+
+The research frameworks (MiniGPT4-Video, SmolVLM2, Open-R1-Video) remain research-quality rather than production-ready. This leaves a clear market gap for a **production-grade CLI tool with native Gemini support**.
+
+---
+
+## Developer audience wants performance, composability, and clean output
+
+Developers researching video analysis tools consistently express frustration with **video processing complexity** and **multimodal pipeline challenges**. Building RAG systems for video requires handling text, audio, and visual data simultaneously—a task described as "challenging" even by NVIDIA's documentation.
+
+The most requested workflow patterns include:
+
+- **Video-to-text transcription pipelines** with timestamped output (SRT) and plain text versions
+- **Video RAG systems** combining frame sampling, vision-language analysis, and vector search
+- **Content moderation pipelines** requiring real-time processing and explainability
+- **Semantic video search** enabling natural language queries against video libraries
+
+**CLI framework preference has shifted to Typer** for new Python projects—it's described as "the FastAPI of CLIs" with type hint-driven design and auto-generated documentation. Click remains standard for complex applications but Typer is the 2024-2025 favorite for modern tooling.
+
+For output formats, **JSON is the universal default** for programmatic consumption (jq compatibility is essential), while **Markdown serves human-readable summaries**. Developers explicitly want `--format json|yaml|markdown|text` flags with JSON Lines for streaming scenarios.
+
+Key technical requirements developers mention:
+- Pipeline composability (chain FFmpeg → analysis → output)
+- Streaming and batch support (URLs, files, watch folders)
+- Progress indication for long processing
+- Timestamp preservation in all outputs
+- Multiple output granularities (frame-level, scene-level, video-level)
+
+---
+
+## Content creators represent a large but CLI-resistant market
+
+The YouTube creator ecosystem includes **65-69 million active creators**, but the vast majority are non-technical users who rely on browser extensions. TubeBuddy and VidIQ dominate with GUI-based competitor analysis, keyword research, and optimization features priced at $3.60-$99/month.
+
+**These tools have significant gaps that merleau could address**: neither offers deep content/script analysis beyond metadata, no automatic keyword extraction from video speech, no hook quality scoring, no batch video content analysis, and no programmatic access for developers.
+
+The realistic CLI-adoptable segment is much smaller:
+
+| Segment | Estimated Size | CLI Readiness |
+|---------|----------------|---------------|
+| MCNs/agencies managing multiple channels | ~10,000+ organizations | Medium-High |
+| Technical YouTubers (dev channels) | ~500,000-1 million | High |
+| Data-savvy marketers | ~100,000-500,000 | Medium |
+| Average YouTubers | 60+ million | Very Low |
+
+The **high-potential niches** are MCNs needing batch operations across 10+ channels, tech/developer YouTube channels already comfortable with CLI tools, enterprise content teams requiring workflow integration, and researchers studying YouTube trends at scale.
+
+A CLI tool succeeds in this market by targeting **power users who've outgrown TubeBuddy/VidIQ** rather than competing for the general creator market. Batch transcript extraction, programmatic competitor monitoring, and clean JSON/CSV export for data pipelines are the most valued features.
+
+---
+
+## Gemini's technical advantages define the differentiation strategy
+
+Google Gemini is **unique among major AI providers** in offering native video understanding. The competitive position is stark:
+
+| Provider | Native Video | Audio from Video | Max Duration | YouTube URLs |
+|----------|--------------|------------------|--------------|--------------|
+| **Gemini** | ✅ Direct upload | ✅ Combined analysis | 2+ hours | ✅ Free preview |
+| GPT-4o | ❌ Frame extraction | ❌ Separate Whisper | Minutes | ❌ No |
+| Claude | ❌ **No video support** | ❌ No | N/A | ❌ No |
+| Twelve Labs | ✅ Video-native | ✅ Native | Hours | ❌ No |
+
+Claude's complete lack of video support and GPT-4o's frame extraction requirement mean Gemini is the **only viable choice for a native video CLI tool** among the major general-purpose providers. Twelve Labs offers specialized video APIs but lacks Gemini's general reasoning capabilities.
+
+**Gemini's key technical capabilities** include:
+- **Native multimodal processing** at 1 FPS default (configurable)
+- **2 million token context** enabling ~6 hours of video in a single prompt
+- **Direct YouTube URL analysis** (currently free in preview)
+- **Combined audio-visual understanding** without separate transcription steps
+- **Video clipping** with start/end offsets for segment analysis
+
+**Pricing makes high-volume processing viable**: Gemini 2.5 Flash-Lite costs $0.10 per million tokens, making a 1-hour video analysis cost approximately $0.11-0.32 depending on resolution settings. Context caching reduces costs by 75-90% for repeated queries on the same video. This is **24x cheaper than GPT-4o** for comparable capabilities.
+
+The SDK situation requires attention: use `google-genai` (current), not `google-generativeai` (deprecated). Rate limits on the free tier are restrictive (5-10 RPM, 100-250 requests/day), so documentation should guide users toward the paid tier for production use.
+
+---
+
+## Differentiation through unique capabilities
+
+Based on the competitive and technical analysis, merleau should differentiate on these underserved capabilities:
+
+**Native Gemini video as the core value proposition.** No existing CLI tool offers this. Frame extraction workarounds for GPT-4o are complex, expensive, and lose audio context. merleau can be "the only CLI that actually understands video" rather than analyzing frames.
+
+**YouTube URL support as a killer feature.** Gemini's direct YouTube analysis (free in preview) enables workflows no competitor matches: `ponty youtube https://youtube.com/watch?v=... --summarize`. This appeals to both developers building YouTube-related tools and technical creators analyzing content.
+
+**Cost transparency before processing.** Current tools don't estimate costs upfront. merleau could offer `ponty estimate video.mp4` to show token counts and expected costs before committing to an API call—addressing a clear developer pain point.
+
+**Structured, consistent JSON output.** The ecosystem lacks standardized schemas for video analysis results. Defining a clear output format (with timestamps, confidence scores, frame references) and making it consistent across operations would improve integration into data pipelines.
+
+**Intelligent processing modes.** Offer presets like `--mode lecture` (low FPS, high compression), `--mode action` (high FPS), `--mode audio-focus` (optimize for speech), letting users optimize cost/quality without understanding token mechanics.
+
+---
+
+## Launch strategy for maximum open source impact
+
+Successful open-source CLI tools (ruff, httpie, ripgrep, fzf) share common patterns: **dramatic value proposition** (10-100x faster, dramatically simpler), **beautiful README with GIF demos**, **responsive maintenance**, and **clear differentiation messaging**.
+
+**The launch sequence should follow this timeline:**
+
+*4-2 weeks before launch:* Finalize repository structure with pyproject.toml, comprehensive README, CONTRIBUTING.md, and GitHub Actions for CI/CD and PyPI publishing via Trusted Publishers. Create demo GIF/video showing the tool in action.
+
+*Launch week:* Primary channel is **Hacker News Show HN** posted Monday-Tuesday morning US time. Title format: `Show HN: merleau – A CLI for video understanding using Google Gemini`. Opening comment should tell the personal story ("I built this because..."), mention the philosophy naming briefly as a curiosity hook, and explicitly ask for feedback.
+
+*Launch day execution:* Respond to every Hacker News comment within the first 3 hours. Simultaneously post to r/Python, r/commandline, Twitter (thread format with GIF), and Dev.to with a tutorial-style post.
+
+**The philosophy naming is a marketing asset.** Maurice Merleau-Ponty's work on perception and embodiment creates natural brand storytelling: "Just as the philosopher explored how we perceive reality, ponty helps you perceive your videos." The unusual name becomes a conversation starter and differentiator. A brief README quote from Merleau-Ponty adds character without being pretentious.
+
+**Community building should start simple.** Enable GitHub Discussions with categories (Q&A, Ideas, Show & Tell) before launch. Add Discord only after reaching 50+ active users—developers find Discussions "too formal" for quick questions. Fast PR review (within 48 hours) dramatically increases contributor return rates.
+
+---
+
+## Technical implementation recommendations
+
+**Use Typer as the CLI framework.** It's the modern standard for Python CLIs, built on Click but with type hint-driven automatic documentation. The FastAPI comparison is apt—it reduces boilerplate while maintaining power.
+
+**Output format structure:**
+```
+Default: JSON (machine-readable)
+Flags: --format json|yaml|markdown|text
+Streaming: JSON Lines (newline-delimited) for --stream mode
+```
+
+**Command structure suggestion:**
+```bash
+# Core analysis
+ponty analyze video.mp4 --prompt "Summarize key points"
+ponty analyze https://youtube.com/watch?v=... --summary
+
+# Specialized operations
+ponty transcribe video.mp4 --format srt
+ponty describe video.mp4 --timestamps
+ponty search video.mp4 --query "when does the speaker mention AI"
+
+# Utilities
+ponty estimate video.mp4  # Cost preview
+ponty config set api_key YOUR_KEY
+```
+
+**Implementation priorities for v1.0:**
+1. Native Gemini video upload with File API handling
+2. YouTube URL support (Gemini's preview feature)
+3. Basic prompting with `--prompt` flag
+4. JSON output with timestamps
+5. Cost estimation command
+6. Progress indication for long videos
+
+**Later releases** can add GPT-4o frame extraction mode (for users wanting multi-provider), local model support via Ollama, batch processing for directories, and watch folder functionality.
+
+---
+
+## Success metrics and realistic expectations
+
+**Week 1 targets:** 100+ GitHub stars, successful Hacker News front page, first external users providing feedback.
+
+**Month 1 targets:** 500-1,000 GitHub stars (strong launch), measurable PyPI downloads, first GitHub issues showing real usage, early contributors submitting PRs.
+
+**Month 3 targets:** Sustained star growth, active GitHub Discussions, mentions in newsletters or "awesome" lists, users building integrations.
+
+The tool serves a **niche but valuable segment**—not mass-market but technically sophisticated users who will appreciate the craftsmanship. Success looks like becoming the default recommendation when developers ask "how do I analyze video with Gemini from the command line?"
+
+---
+
+## Conclusion
+
+Merleau/ponty enters the market at an ideal moment: Gemini's native video capabilities are mature and cost-effective, no competitor offers a unified CLI for this workflow, and developer interest in video AI tooling is surging. The differentiation strategy is clear—be the **first and best CLI for native video understanding**, leveraging Gemini's unique position as the only major provider with true video input support.
+
+The path forward involves launching with a focused v1.0 (native Gemini, YouTube URLs, clean JSON output, cost estimation), targeting developers and technical creators rather than mass-market YouTubers, and building community through responsive maintenance and compelling documentation. The philosophy naming creates a distinctive brand identity that stands out in a sea of generic tool names.
+
+The competitive landscape analysis reveals that video-analyzer is the closest existing tool but misses the native Gemini opportunity. By filling this gap with excellent developer experience, merleau can establish a defensible position as the standard CLI for AI video understanding.