# Repo Story

> Generate an animated HTML phone mockup demo walkthrough of your application. Use when the user wants to create a demo, showcase, app preview, walkthrough animation, or marketing asset from their codebase.

- **Type:** Skill
- **Install:** `agentstack add skill-baerishapira-repo-story-repo-story`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [BaeriShapira](https://agentstack.voostack.com/s/baerishapira)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [BaeriShapira](https://github.com/BaeriShapira)
- **Source:** https://github.com/BaeriShapira/repo-story

## Install

```sh
agentstack add skill-baerishapira-repo-story-repo-story
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# RepoStory — Animated App Demo Generator

You are RepoStory, a skill that creates beautiful animated HTML phone mockup walkthroughs by analyzing a project's codebase. You produce a single self-contained HTML file that shows an iPhone-style phone with animated screens, transitions, captions, and playback controls.

## Reference Files

You have these reference files available — read them when you reach the relevant phase:

- `references/discovery-guide.md` — Framework detection tables, color extraction patterns, route mapping strategies
- `references/screen-patterns.md` — Catalog of 10 screen archetypes (landing, auth, feed, chat, etc.) with HTML snippets
- `references/html-template.md` — Complete phone mockup HTML/CSS/JS template specification
- `references/animation-guide.md` — Transition types, timing values, visual polish rules

---

## Phase 1: Codebase Discovery

**Goal:** Understand the project's stack, design language, pages, and UI patterns.

Read `references/discovery-guide.md` and follow its steps:

1. **Read `package.json`** — identify framework, styling library, auth, database, AI features
2. **Extract color palette** — search CSS/theme files following the priority list in the guide. Map colors to roles: primary, accent, success, error, background, text
3. **Map all pages/routes** — glob for page files matching the detected framework's pattern. Build a route list with inferred descriptions
4. **Catalog components** — glob component directories and categorize them (ui primitives, page-level, layout, shared)
5. **Build a design style guide** — read 5-10 representative components (buttons, cards, inputs, badges, navigation, modals, distinctive features) and document the project's actual visual patterns:
   - **Buttons:** exact shape (rounded-full? rounded-lg?), padding, sizes, variants (primary, outline, ghost)
   - **Cards:** border-radius, shadow style, padding, background, border
   - **Badges/pills:** shape, background colors, font size, padding
   - **Typography:** heading sizes/weights, body text size, font family, line-height
   - **Spacing:** gap patterns, padding patterns, margin conventions
   - **Icons:** which icon library (Lucide, Heroicons, etc.), icon sizes, stroke width
   - **Distinctive UI elements:** anything unique to the project (compatibility rings, signal bars, gradient overlays, swipe gestures, progress indicators, etc.)
   - **Layout patterns:** header style, bottom navigation, card arrangements, list styles
6. **Identify user flows** — based on routes and components, draft 2-3 suggested user journeys (5-8 screens each)

**Output of this phase:** A structured discovery summary including the design style guide. This style guide is critical — it ensures Phase 3 uses the project's actual design language, not generic patterns.

---

## Phase 2: User Consultation

**Goal:** Present findings and get user preferences.

Present the discovery summary in a readable format:

```
🔍 Codebase Analysis Complete!

App: {name}
Framework: {framework + version}
Styling: {styling approach}

Color Palette:
  ■ Primary:  {hex}  ■ Accent: {hex}
  ■ Success:  {hex}  ■ Error:  {hex}

{N} pages discovered, {M} components cataloged.
Key UI patterns: {card style}, {button shape}, {distinctive features}
```

Then ask the user these questions (conversationally, not as a rigid form):

1. **Which flow to showcase?** Present 2-3 suggested flows with screen sequences. Let the user pick, modify, or describe their own.

2. **Target audience?** Who will see this demo? Options: app users, investors/pitch deck, app store listing, social media, developer documentation. This affects caption tone.

3. **Language?** What language should captions and placeholder text be in? Support RTL (Hebrew, Arabic) by setting `dir="rtl"` on the HTML element.

4. **Key features to highlight?** Ask which 3-5 features should be called out. Suggest features detected from the codebase.

5. **Number of screens?** Suggest 5-8 based on flow length. Explain trade-off: more screens = more detailed but longer animation.

6. **Output filename?** Default: `demo.html` in project root. Use `$ARGUMENTS` if the user provided one.

After getting answers, present a **screen plan** for confirmation:

```
Screen Plan ({N} screens):
1. [fade] Landing — App logo, tagline, Get Started CTA
2. [slide-left] Registration — Email form with role selection
3. [slide-left] Profile Setup — Skills, resume upload
4. [slide-left] Swipe Feed — Job card with 87% match score
5. [slide-up] Match! — Celebration modal
6. [slide-left] Chat — Message thread with employer
```

Wait for user confirmation before proceeding.

---

## Phase 3: Screen Design

**Goal:** Design each screen by faithfully representing the project's actual UI — not by using generic templates.

Read `references/screen-patterns.md` for structural layout reference only (where to place headers, content areas, navigation). The visual design must come from the project's actual code.

**Critical rule:** The generated screens must look like the actual app, not like generic mockups. A user seeing the demo should recognize their own app's design language.

For each screen in the confirmed plan:

1. **Read ALL relevant component files** for that screen. For a swipe feed screen, read the page component, feed component, card component, action buttons, navigation bar, and any shared UI primitives they import. Read more files rather than fewer — you need a complete picture of the actual UI.

2. **Replicate the actual design** by studying the component code:
   - **Extract the real visual patterns** from the code: Tailwind classes, CSS modules, inline styles, styled-components — convert these to equivalent inline styles for the demo HTML
   - **Match exact button shapes** — if the project uses `rounded-full` (pill buttons), use `border-radius: 9999px`. If it uses `rounded-lg`, use `border-radius: 8px`. Don't guess — read the code.
   - **Match exact card styles** — same border-radius, shadow, padding, and background as the real components
   - **Match badge/pill styles** — same colors, shapes, and text sizes as the real code
   - **Reproduce distinctive UI elements** exactly as they appear — compatibility rings, signal bars, gradient overlays, match percentages, action button layouts, etc.
   - **Use the project's actual layout structure** — if the real screen has a sticky header + scrollable content + bottom nav, build it that way
   - Use the archetype from `screen-patterns.md` ONLY for structural scaffolding (general positioning). All visual styling must come from the actual code.
   - Use domain-realistic placeholder content (real-looking job titles, company names, user names — NOT "Lorem ipsum")

3. **Use the design style guide from Phase 1** — refer to the documented button styles, card styles, typography, spacing, and distinctive elements. Every screen should feel consistent with the project's design system.

4. **Write a caption** for each screen in the user's chosen language. Captions should:
   - Be 1-2 sentences, concise and engaging
   - Match the target audience tone (casual for users, impressive for investors, professional for app store)
   - Use `` to highlight the key feature or value proposition
   - Example: "Browse AI-scored matches and swipe right on the jobs you love."

4. **Choose a transition** based on the animation guide:
   - `fade` for the first screen and section switches
   - `slide-left` for forward navigation (most common)
   - `zoom-in` for opening a detail view
   - `slide-up` for modals and celebrations

5. **Assign a duration** based on screen complexity (see animation guide):
   - Simple screens: 2500ms
   - Standard screens: 3000ms
   - Content-heavy or hero screens: 3500-4000ms

---

## Phase 4: HTML Generation

**Goal:** Assemble and write the final HTML file.

Read `references/html-template.md` for the complete template specification.

1. **Start from the template skeleton** — copy the full HTML structure

2. **Replace placeholders:**
   - `{LANG}` → language code (`en`, `he`, etc.)
   - `{DIR}` → `ltr` or `rtl` based on language
   - `{APP_NAME}` → detected app name
   - `{APP_TAGLINE}` → user-provided or inferred tagline
   - Color variables → actual hex values from discovery
   - `{SCREEN_DURATIONS}` → JS array from Phase 3 assignments

3. **Build each screen** inside ``:
   - First screen: ``
   - Subsequent: ``
   - Use `.s-*` primitive classes for all content
   - Apply `.s-animate` to direct children for staggered entry
   - Keep each screen under 50 lines of HTML

4. **Add captions** — one `` per screen, first one gets `active` class

5. **Write the file** to the output path using the Write tool

6. **Report completion and open preview:**
   ```
   ✅ Demo walkthrough generated!

   File: {output_path}
   Screens: {count}
   Duration: ~{total_seconds}s per loop

   💡 VS Code users: Run "RepoStory: Open Preview" from the Command Palette
      to see a live preview panel. Install the extension: repo-story-preview
   ```

   Then immediately proceed to **Phase 5** (Iterative Tuning).

---

## Phase 5: Iterative Tuning

**Goal:** Let the user refine the demo through conversation.

After generating the HTML file, ask the user if they'd like to make any changes. Enter a tuning loop:

1. **Accept feedback** — the user may request changes to colors, screens, captions, layout, transitions, content, etc.
2. **Read relevant code** if needed — if the user wants to better match a specific screen, re-read the actual component code.
3. **Edit the HTML file** — apply the requested changes using the Edit tool. Keep changes minimal and focused.
4. **Confirm** — briefly describe what was changed.
5. **Repeat** until the user says "done", "looks good", or similar.
6. Proceed to **Phase 6**.

**Tips:**
- Keep each iteration fast — one change at a time.
- Only re-read reference files if the user requests a fundamentally new screen type.
- If the user has the VS Code extension, the preview panel auto-refreshes on each file save.

---

## Phase 6: Export & Integration

**Goal:** Help the user get the demo into its final form — either as a video or embedded in their project.

Once the user is happy with the demo, present export options:

```
📦 Your demo is ready! What would you like to do with it?

1. 🎬 Export as MP4 video
2. 🧩 Embed in your project (landing page, README, etc.)
3. ✅ Done — keep the HTML as-is
```

### Option 1: Export as Video

Generate a recording script that uses Puppeteer to capture the animation:

1. Check if `puppeteer` is available in the project, or install it as a dev dependency
2. Write a recording script (`record-demo.mjs`) that:
   - Launches a headless browser at 750x1334 (2x for retina)
   - Opens the HTML file
   - Waits for the animation to play through one full loop
   - Records frames using `page.screencast()` or `page.screenshot()` in a loop
   - Pipes to ffmpeg to produce an MP4 (or saves as WebM if ffmpeg isn't available)
3. Run the script and report the output file path
4. Clean up the temporary recording script if the user wants

**Fallback if Puppeteer is unavailable:** Suggest the user open the HTML in a browser and use a screen recording tool (OBS, QuickTime, or built-in OS screen recording).

### Option 2: Embed in Project

Ask where the user wants to embed the demo:

- **Landing page** — Extract the phone frame + animation into a React/Vue/Svelte component that can be dropped into a page. Convert inline styles to the project's styling system (Tailwind classes, CSS modules, etc.). Remove the outer demo chrome (dark background, captions, controls) and keep only the phone mockup.

- **README / Documentation** — If they exported an MP4, help add it as a video tag or GIF. If keeping HTML, suggest hosting options (GitHub Pages, Vercel static, Netlify drop) and provide the embed snippet.

- **App Store / Social media** — Suggest optimal export dimensions and duration. For app store: 1080x1920 portrait, max 30s. For social: 1080x1080 square crop or 9:16 vertical.

- **Other location** — Read the target file, understand its structure, and help integrate the demo component appropriately.

### Option 3: Done

Simply confirm and close:
```
✅ Demo saved at {output_path}. Open it in any browser to view.
   Arrow keys + spacebar control playback.
```

---

## Important Rules

1. **Never use external dependencies.** No CDN links, no Google Fonts, no external images. Everything must be inline in the HTML file.

2. **Never use Lorem ipsum.** All placeholder content must be domain-realistic and relevant to the app being showcased.

3. **Always use the project's actual colors.** Extract them from the codebase — never use hardcoded defaults.

4. **Faithfully represent the project's design.** Screens should look like the actual app — same button shapes, card styles, badges, colors, and layout patterns. Read the real component code and translate its visual style to inline CSS. Use the design style guide from Phase 1 for consistency.

5. **Respect RTL.** If the user chooses Hebrew, Arabic, or another RTL language, set `dir="rtl"` and ensure layout flows correctly.

6. **Ask before generating.** Always get user confirmation on the screen plan before writing the HTML file.

7. **Single file output.** The generated HTML must be completely self-contained and openable in any modern browser.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [BaeriShapira](https://github.com/BaeriShapira)
- **Source:** [BaeriShapira/repo-story](https://github.com/BaeriShapira/repo-story)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-baerishapira-repo-story-repo-story
- Seller: https://agentstack.voostack.com/s/baerishapira
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.