[
  {
    "type": "case",
    "title": "Yoda 种子轮投资人 BP",
    "description": "完整演示 bp-outline → bp-deck → bp-polish 的组合：把技术导向的“多智能体编程工作台”重构为投资人可理解的“Agent 时代集成委托环境”，再用真实产品截图、专业图表和定向视觉修正完成 15 页 PPTX/PDF。"
  },
  {
    "type": "article",
    "title": "Yoda BP：从功能清单到投资叙事的完整复盘",
    "url": "https://example.com/skills/bp-skill/blob/main/references/case-yoda.md",
    "source": "Skill Publisher 案例报告",
    "cover": "https://raw.githubusercontent.com/skill-publisher/bp-skill/main/cases/yoda-bp-cover.png"
  }
]

# Case: Yoda Seed BP

This case is also the reference composition for the BP Skill Kit:

```text
bp-outline → bp-deck → bp-polish → targeted bp-deck fixes → bp-polish
```

## Context

Yoda is an open desktop workspace for orchestrating AI coding work from intent to
delivery. The initial BP narrative accurately described technical capabilities, but
it made the company look narrower and more replaceable than the product ambition.

## Initial symptoms

- “多智能体编程工作台” was accurate but implementation-led.
- “让一个开发者指挥一支 AI 团队” made multi-Agent operation sound mandatory.
- “本地优先” could be misread as running models locally, despite cloud services,
  Relay, and model APIs.
- Worktree/branch behavior was elevated above broader product paradigms.
- The deck described features before defining the human need: reliably delegating
  creative work to AI.
- Early layouts had too many boxes and insufficient chart evidence.

## Reframing method

1. Separated product core from work modes.
2. Defined the early wedge (super developers), adjacent users (AI-native creators
   and teams), and long-term market.
3. Replaced implementation-first language with the human–AI relationship:
   Harness, delegation, evidence, approval, and creation.
4. Used an investor-readable category: “Agent 时代的集成委托环境”.
5. Built the story around the falling cost of implementation and the rising
   complexity of reliable delegation.
6. Kept commercial gaps visible: build/use evidence was separated from payment
   proof, and financing was framed as the window to validate retention, payment,
   institutional contracts, and measurable growth.

These decisions belong to `bp-outline`. No visual style was selected until the page
argument and evidence gaps were explicit.

## Final 15-slide architecture

1. Integrated Delegation Environment.
2. IDE center moves from code to delegation.
3. Implementation cost falls while delegation complexity rises.
4. Execution becomes an auditable delivery loop.
5. Task to Feature manages complete delivery, not chat.
6. Five-layer product architecture.
7. System moat: freedom, robustness, evolution.
8. Why now: model capability becomes infrastructure; Harness gains value.
9. Build/use/pay evidence ladder.
10. Super developers as wedge; larger delegation market.
11. Reliable delegation vs. execution-only alternatives.
12. Open local core; continuity and collaboration are paid.
13. Consumer and institutional entry paths.
14. Founder–product fit.
15. Financing ask, use of funds, and 18–24 month validation window.

## Visual evolution

The final direction used warm white, deep Yoda green, large conclusion headlines,
real screenshots, simple sourced charts, and substantial whitespace. The cover was
reduced to a strong title and horizontal brand treatment. The final page used two
clearly separated QR codes for product and personal contact, then verified both from
the rendered slide.

The initial deck came from `bp-deck`; the later cover, logo balance, final-page
layout, filename, and QR corrections are examples of `bp-polish` returning targeted
work to `bp-deck` instead of regenerating the entire presentation.

![Yoda BP cover](../cases/yoda-bp-cover.png)

![Yoda BP overview](../cases/yoda-bp-overview.png)

## Reusable lessons

- Technical truth is not automatically an investable category.
- A narrow initial user does not have to cap the long-term market.
- Single Agent, multiple Agents, Agent teams, and worktrees can be product modes
  rather than the company definition.
- Honest zeroes can strengthen the financing thesis when the deck clearly states
  what the next capital will validate.
- Professional visuals require chart logic and final-image inspection; a polished
  template alone is insufficient.

# Charts and Visual Standards

## Visual principle

The design should combine product-launch clarity, consulting-report credibility, and
the evidence texture of a real startup. “Premium” comes from editing and hierarchy,
not decoration.

## Baseline

- 16:9 landscape.
- White or warm-gray background and one brand accent.
- Dark headline, large conclusion, body text at least 20 pt.
- One dominant visual per page and roughly one-third breathing room.
- Product screenshots, customer scenes, workflows, interview evidence, and orders
  before stock photography.
- Do not stretch logos; align by optical weight, not only bounding boxes.

## Choose the proof, then the chart

| Claim | Recommended visual |
|---|---|
| Process is fragmented | Before workflow / swimlane |
| Product compresses work | Before/after or time-to-outcome bars |
| Category is shifting | Timeline or converging trends |
| Product closes a loop | Circular process with evidence rail |
| Product has depth | Layered architecture with customer consequences |
| Traction has stages | Evidence ladder or funnel |
| Retention is improving | Cohort heatmap or retention curves |
| Revenue expands with value | Value/revenue staircase |
| Market bridges to revenue | Buyer bridge or concentric market with formula |
| Competitive position | 2×2 only when axes are defensible; otherwise comparison table |
| Growth has two entry points | Dual funnel / phased path |
| Financing buys proof | Use-of-funds donut + milestone gates |

## Chart requirements

Every quantitative chart needs:

- title containing the conclusion;
- axes and units when applicable;
- time period and as-of date;
- legend where more than one series exists;
- source or evidence IDs;
- assumptions beside the number, not hidden in notes;
- “illustrative / 示意” label for non-measured conceptual curves.

Avoid 3D charts, gauges, decorative radar charts, dual axes without necessity, and
large coordinate systems with tiny data differences.

## Product screenshots

- Use real current screenshots.
- Crop to the workflow being proved.
- Add 1–3 callouts maximum.
- Keep interface text legible at normal presentation size.
- State what is live, prototype, planned, or illustrative.
- Do not reconstruct a fake UI when the real product exists.

## Cover

A seed BP cover should usually contain only:

- product/company name or logo;
- one investor-readable definition;
- optional financing stage/date.

Use a single centered composition or a strong branded band. Do not fill the cover
with feature tags, funding terms, or multiple logos competing for attention.

## Final page

The final page should answer:

- how much is being raised;
- equity/structure when disclosed;
- runway or time window;
- 2–4 proofs the financing will buy;
- one clear contact action.

If QR codes are present, decode the final rendered image—not only the source asset.

# BP Skill Kit Composition

## Principle

Composition is file-based, not conversation-based. Every module shares a stable BP
workspace so users can stop, switch agents, or resume later without losing state.

## Module boundaries

| Module | Owns | Must not own |
|---|---|---|
| `bp-outline` | Facts, assumptions, positioning, page argument | Visual decoration and slide export |
| `bp-deck` | Style, layout, rendering, branding, export | New business facts or unsupported copy |
| `bp-polish` | Adversarial review, exact revisions, targeted correction | Silent changes to evidence or complete regeneration by default |

## Handoff states

```text
MATERIALS
   │
   ▼
OUTLINE_DRAFT ── evidence gate ──► OUTLINE_APPROVED
                                      │
                                      ▼
                                  DECK_DRAFT
                                      │
                                visual + claim gate
                                      │
                                      ▼
                                  DECK_READY
```

An evidence blocker moves `DECK_DRAFT` back to `OUTLINE_DRAFT`. A visual defect keeps
the workflow in `DECK_DRAFT` and regenerates only affected slides.

## User-intent routing

- A noun usually selects an artifact: “大纲” → outline, “PPT/PDF” → deck.
- A quality complaint selects polish: “不专业 / 太技术 / 图表乱 / 页面拖沓”.
- “完整 / 从项目材料开始 / 融资 BP” selects the full pipeline.
- Explicit scope always wins over automatic routing.

## Interaction budget

Collect decisions once and persist them in `brief.md` or `deck-manifest.md`.

- Outline questions: audience/stage, financing ask, source scope.
- Deck questions: visual direction and required format.
- Polish questions: review mode only when the request does not reveal it.

Do not ask the same question again in a later module.

## Completion rules

- Outline route ends with three Markdown artifacts and evidence gaps.
- Deck route ends with PPTX, PDF, preview, and manifest.
- Polish route ends with a scored report and applied or explicitly proposed fixes.
- Full route ends only when all three contracts are satisfied.

# 12–15 Slide Investor Deck Architecture

## Base 12-slide sequence

| # | Investor question | Required proof | Strong visual |
|---:|---|---|---|
| 1 | What are you? | Product definition + company/brand | Clean cover or one visual metaphor |
| 2 | What hurts? | Concrete user moment, frequency, cost | Before workflow, quote, or pain funnel |
| 3 | What changes? | Specific product response | Before/after or solution flow |
| 4 | Does it work? | Real product or experience | Product screenshot / demo sequence |
| 5 | Why now? | 2–3 structural changes | Timeline or converging trend chart |
| 6 | What is proven? | Usage, retention, revenue, speed, or pilots | Evidence ladder / cohort / verified metrics |
| 7 | How do you make money? | Buyer, offer, price, sales motion | Value/revenue staircase |
| 8 | How large can it be? | Source-backed TAM/SAM/SOM + wedge | Market bridge / rings with methodology |
| 9 | Why you vs. alternatives? | Honest competitor dimensions | Matrix, table, or value-chain map |
| 10 | How will you grow? | Channels, milestones, economics | Funnel, flywheel, or phased roadmap |
| 11 | Why this team? | Founder-market/product fit | Evidence timeline, not résumé wall |
| 12 | What are you raising? | Ask, use, runway, 18–24 month proof | Use-of-funds chart + milestone gates |

## When to expand to 13–15 slides

Add a page only when it carries evidence that cannot fit cleanly elsewhere:

- a second product-demo page for a complex workflow;
- a technology/moat page with measurable defensibility;
- a dedicated go-to-market wedge page;
- a regulated/B2B deployment model;
- a financial model when revenue complexity materially affects the investment case.

Do not add generic mission, feature grids, long roadmaps, or “thank you” pages merely
to reach a page count.

## Slide contract

Each outline entry should contain:

```markdown
## Slide 06 — Real validation

Headline: One conclusion, not a topic label
Investor takeaway: What uncertainty this page removes
Evidence: Exact facts and source IDs
Visual: Chart type and field mapping
Speaker purpose: Why this page exists in the spoken story
Gap: Missing evidence or “none”
```

## Page discipline

- One page, one argument.
- The headline contains the conclusion.
- A viewer should understand the page in 8–12 seconds.
- Keep only the numbers needed for the conclusion.
- Put methodology and source notes at the bottom, not in the speaker's memory.
- 8–10 minutes means roughly 35–50 seconds per page; demo pages may take longer.

## Executive summary rule

For a long-form business plan, write the executive summary last. It must include:

1. what the company does;
2. problem and buyer;
3. solution and difference;
4. market opportunity with a traceable number;
5. exact ask and what it unlocks.

The pitch deck's first and last pages should make the same promise and ask, from
opposite ends of the argument.

# Evidence and Market Sizing

## Evidence classes

Every material claim belongs to one class:

| Class | Meaning | How to present |
|---|---|---|
| Fact | Directly supported by a reliable source | State with source and as-of date |
| Inference | Reasoned conclusion from facts | Label as inference and show bridge |
| Assumption | Planning input not yet verified | Label and sensitivity-test |
| Missing | Necessary evidence not yet available | Keep as a named gap, never fill by intuition |

## Source hierarchy

Prefer sources in this order:

1. Product database, payment processor, analytics, contracts, repository history.
2. Direct customer interviews, support conversations, signed pilots, orders.
3. Official government, company, exchange, standards, or research data.
4. Reputable analyst/research reports with disclosed methodology.
5. Quality secondary reporting.
6. Search snippets, social posts, and unsourced aggregations only as leads.

Time-sensitive facts must be checked live. Capture the date and exact URL. If a
source is inaccessible, say so in the report.

## Evidence ledger format

| ID | Claim | Status | Source | As of | Slide | Notes / next action |
|---|---|---|---|---|---|---|
| E-001 | ... | fact | URL or dashboard export | YYYY-MM-DD | 6 | ... |

Use stable IDs in the outline so charts and slide copy can be traced back.

## TAM / SAM / SOM methodology

Do not paste a broad “AI will be worth $X trillion” forecast into a deck. Build a
bridge from actual buyer to price.

### TAM

All plausible buyers × annual value of the complete category.

```text
TAM = global buyer count × realistic annual spend per buyer
```

Use a top-down source only as a cross-check.

### SAM

The part of TAM reachable by current product scope, geography, regulation, and sales
motion.

```text
SAM = target buyer count in reachable segments × current annual contract value
```

### SOM

A three-to-five-year operating plan, not a percentage chosen for visual symmetry.

```text
SOM = acquired accounts × annual price × expected retention
```

Show the channel capacity or sales capacity that makes acquired accounts credible.

## Scenario model

Use at least two scenarios:

- conservative: slower conversion, lower price, longer sales cycle;
- base: management plan;
- upside: only if named leading indicators improve.

Never present the upside case as a forecast. Put assumptions next to the chart.

## Metric hygiene

- Distinguish downloads, clones, activated users, active users, retained users, and
  paid users.
- Distinguish trial, activation, conversion, renewal, and revenue.
- Use cohorts for retention; do not infer retention from cumulative installs.
- Define the period, denominator, timezone, duplicates, bots, and internal usage.
- Put “as of YYYY-MM-DD” on changing metrics.
- When the number is zero, say zero; the honest gap can define the financing thesis.

# Investor Story

## The investor's reading order

An investor does not read a BP like a product manual. The sequence is closer to:

1. Can I understand what this is in ten seconds?
2. Is the pain real, frequent, and expensive enough?
3. Is the product response specific and demonstrable?
4. Why can this become large now?
5. What has already been de-risked?
6. How does money enter the system?
7. Why will this team win?
8. What exactly does this financing buy?

Every slide should reduce one uncertainty in that order.

## Three layers of positioning

### Layer 1: Product definition

State the category or the completed job. It should be repeatable, not poetic.

- Chinese: ideally 14–20 characters.
- English: ideally 8–12 words.
- One subject, one category/job, one clear beneficiary.
- Do not lead with architecture, protocols, model names, or number of Agents.

Draft three alternatives:

1. **Literal category** — “面向 X 的 Y”。
2. **Comparator** — “X 版的 Y” or “X for Y”.
3. **Category creation** — a new category with an immediate plain-language gloss.

Choose the line a non-technical investor can repeat accurately after ten seconds.

### Layer 2: Market wedge

Name the first buyer and the urgent use case. A credible wedge is narrower than the
vision but large enough to prove demand.

```text
Core wedge → adjacent users → long-term market
```

Do not confuse the wedge with the final market, or describe the final market as the
current customer base.

### Layer 3: Vision

Explain the structural change that makes the company matter. Vision earns its place
after the product and wedge are clear.

## Product vs. implementation

Ask: “If this mechanism changed tomorrow, would the customer still buy the result?”

- If yes, it is implementation and should not define the company.
- If no, it may be the category or moat.

Examples of implementation-heavy framing:

- number of Agents;
- local vs. cloud runtime without explaining user benefit;
- branch/worktree selection;
- model/provider list;
- architecture components.

Translate them into the user consequence: continuity, control, trust, speed, cost,
collaboration, or creative freedom.

## Before / after test

| Weak | Better |
|---|---|
| “We integrate many models and Agents.” | “One workspace keeps AI work controllable from idea to delivery.” |
| “Local-first multi-Agent orchestration.” | “Your work, context, and choices stay portable while AI does the execution.” |
| “Everyone can command an Agent team.” | “Creators can reliably turn intent into finished digital products.” |

The “better” line is still a hypothesis. It must match the actual product and buyer.

## Narrative red flags

- The first three slides require a glossary.
- The one-liner is a slogan with no product noun or job.
- The company is defined by a feature available in every model vendor.
- The market slide appears before the buyer is clear.
- The deck claims “no competitors” or makes strong competitors look foolish.
- Vision, TAM, and product roadmap describe three different businesses.
- The financing ask does not connect to the key risks still unproven.

# BP Review Rubric

## Content score (100)

| Dimension | Weight | Pass condition |
|---|---:|---|
| Story structure | 25 | All 12 investor questions are answered in a coherent order |
| Investor readability | 20 | Product is clear in ten seconds; headlines state conclusions |
| Evidence and data hygiene | 25 | Core claims trace to sources; assumptions are labeled |
| Charts and visual specification | 20 | Each page names the right proof and chart, not decoration |
| Financing delivery | 10 | Exact ask, use of funds, runway/window, and milestones connect |

Target: 85+. A high score does not override a blocker.

## Blockers

- Invented or untraceable core metrics.
- Unlabeled market/revenue assumption.
- No clear product definition or buyer.
- No real product or experience proof when one exists.
- No financing amount, use, or validation milestones.
- Placeholder/TODO text.
- Broken source, broken QR code, unreadable slide, or incorrect filename.

## Adversarial review lenses

Review the deck as four people:

1. **Non-technical investor** — what remains unclear after ten seconds?
2. **Category expert** — which claims are technically or competitively naive?
3. **Skeptical partner** — what evidence is missing or overstated?
4. **Design director** — where does layout reduce trust or distort meaning?

For every issue, report page, severity, why it matters, and exact revision.

## Visual QA checklist

- [ ] Contact sheet reviewed at normal size.
- [ ] One claim per slide.
- [ ] Title/body/source hierarchy is consistent.
- [ ] Body text is at least 20 pt.
- [ ] No clipped, overlapping, or off-canvas elements.
- [ ] CJK fonts render correctly.
- [ ] Logos have consistent optical weight.
- [ ] Images are not stretched or low resolution.
- [ ] Charts match evidence ledger and include units/dates/sources.
- [ ] Concept charts are labeled illustrative.
- [ ] Product screenshots are genuine and legible.
- [ ] QR codes decode from the final slide image.
- [ ] Cover and final page are visually calm.
- [ ] PPTX and PDF page counts match.
- [ ] File names contain project, document type, and date/version.

## Report format

Use `assets/templates/bp-review.md`. Lead with verdict and score, then blockers,
page-level findings, evidence gaps, and final delivery checks. Do not begin with a
long description of what the reviewer did.

# User Configuration

This skill follows the portable agent skill profile contract. It must not
assume a private workspace, personal absolute paths, or private brand assets.

## Resolution Order

1. Explicit CLI flags.
2. Environment variables.
3. Shared profile JSON.
4. Safe defaults such as the current working directory or `$HOME/Documents`.
5. Ask the user once for missing required fields.

## Shared Profile

Default profile path:

```bash
${SKILL_PROFILE_PATH:-$HOME/.skill-publisher/skills/profile.json}
```

Example:

```json
{
  "user": {
    "name": "Your Name",
    "language": "zh-CN",
    "timezone": "Asia/Shanghai"
  },
  "workspace": {
    "root": "$HOME/projects",
    "output_dir": "$HOME/Documents/lov-skill-output"
  },
  "brand": {
    "name": "Your Brand",
    "site": "https://example.com",
    "profile": "$HOME/.skill-publisher/skills/brand.json",
    "design_guide": "$HOME/.skill-publisher/skills/design-guide.md"
  }
}
```

Environment variable overrides:

| Variable | Meaning |
|----------|---------|
| `SKILL_PROFILE_PATH` | Path to the shared profile JSON |
| `SKILLS_CONFIG_DIR` | Shared Skill Publisher skills config/data directory |
| `SKILL_WORKSPACE_ROOT` | User workspace root |
| `SKILL_OUTPUT_DIR` | Default generated output directory |
| `SKILL_PROFILE_PATH` | Brand profile JSON or Markdown |
| `SKILL_DESIGN_GUIDE` | Design guide path |

BP-specific overrides take precedence over shared values:

| Variable | Meaning |
|----------|---------|
| `SKILL_BP_OUTPUT_DIR` | Default output directory for BP workspaces |
| `SKILL_BP_BRAND_PROFILE` | Brand profile used by the deck |
| `SKILL_BP_DESIGN_GUIDE` | Visual design guide used by the deck |

If none are set, use an explicit `--output` path or a project-local
`business-plan/` directory. Never assume an author's private workspace.

## Implementation Notes

- Store source descriptions in `evidence-ledger.md`; do not copy secrets into the
  BP workspace.
- Prefer relative paths inside the workspace so it can be moved or shared.
- Brand files remain user-owned inputs. The public Yoda assets are an example, not
  a default theme.

- Scripts should accept explicit paths via CLI flags.
- Missing profile fields should produce actionable errors.
- Skill Publisher maintainer defaults belong in an optional profile, not in the workflow.

# Yoda BP Case Quality Report

Reviewed: 2026-07-23
Scope: 15-page seed investor deck
Kit route: `bp-outline → bp-deck → bp-polish → targeted fixes`

## Verdict

The final deck is materially stronger than the first versions because it defines a
new product category in investor language, keeps the technical mechanisms subordinate
to user value, uses real product evidence, and makes commercial uncertainty explicit.
It is a credible seed-stage conversation document, with future updates required for
retention, paid conversion, institutional contracts, and repeatable acquisition.

Manual review score: **89 / 100**

| Dimension | Score | Max | Note |
|---|---:|---:|---|
| Story structure | 23 | 25 | Complete 15-page arc; category education still needs a concise spoken bridge |
| Investor readability | 18 | 20 | Conclusion-led and non-technical; several architecture terms remain |
| Evidence and data hygiene | 20 | 25 | Build/use evidence is clear; retention and paid evidence remain missing |
| Charts and visual specification | 19 | 20 | Strong chart language, real screenshots, clean hierarchy |
| Financing delivery | 9 | 10 | Ask, use, and proof window are explicit; scenario economics need live validation |

## What improved

| Area | Earlier state | Final state |
|---|---|---|
| Product definition | Multi-Agent coding workbench | Integrated Delegation Environment for the Agent era |
| User value | Command an Agent team | Reliably delegate creation and delivery to AI |
| Market | Developers as the ceiling | Super developers as wedge; AI-native creators and teams as expansion |
| Product proof | Feature list | Task → Feature → evidence → delivery loop |
| Traction | Cumulative signals mixed together | Build / use / pay evidence separated |
| Commercial honesty | Monetization implied | Trials and zero paid conversion shown as validation gaps |
| Visual language | Dense boxes and decoration | Warm-white editorial system, large conclusions, charts, screenshots |
| Contact | Brand QR ambiguity | Product website + personal contact, both decoded after rendering |

## Remaining evidence gaps

1. Cohort retention and active-use definitions.
2. Relay trial activation, paid conversion, and renewal.
3. Institution-level pilot and annual contract evidence.
4. Channel-level CAC and conversion.
5. Bottom-up market buyer counts and price sensitivity.

## Reusable judgment

The strongest move was not visual. It was changing the unit of analysis from “how
many Agents run” to “how safely a person can delegate and accept responsibility for
the result.” The visual system worked once each page had a precise claim to prove.

See [the full case](../references/case-yoda.md) and the included contact sheet.

#!/usr/bin/env python3
"""Deterministic lint for investor BP outlines.

The audit checks structure and evidence hygiene. It intentionally does not pretend
to replace investor judgment or visual inspection.
"""

from __future__ import annotations

import argparse
import datetime as dt
import json
import re
import sys
from pathlib import Path
from typing import Dict, List, Sequence, Tuple


BEATS: Sequence[Tuple[str, Sequence[str]]] = (
    ("product definition", ("product definition", "who you are", "定位", "你是谁", "是什么")),
    ("problem", ("problem", "pain", "用户问题", "具体问题", "痛点")),
    ("solution", ("solution", "how the product solves", "解决方案", "如何解决")),
    ("product demo", ("demo", "core experience", "product experience", "产品演示", "核心体验")),
    ("why now", ("why now", "为什么现在", "时机")),
    ("traction", ("traction", "validation", "proof", "真实验证", "进展", "留存")),
    ("business model", ("business model", "revenue model", "商业模式", "收入模式")),
    ("market", ("market", "tam", "sam", "som", "市场规模", "切入路径")),
    ("competition", ("competition", "competitive", "竞争", "差异化")),
    ("growth", ("growth", "go-to-market", "gtm", "增长计划", "获客")),
    ("team", ("team", "founder", "团队", "创始人")),
    ("financing", ("financing", "fundraise", "raise", "融资", "资金用途")),
)

PLACEHOLDER_RE = re.compile(r"\b(?:TODO|TBD|FIXME|XXX)\b|待补|待确认|missing", re.IGNORECASE)
SLIDE_RE = re.compile(r"^##\s+(?:Slide\s+)?(\d+)(?:\s+of\s+\d+)?\b.*$", re.IGNORECASE | re.MULTILINE)
SLIDE_ZH_RE = re.compile(r"^##\s*第\s*(\d+)\s*页.*$", re.MULTILINE)
HEADLINE_RE = re.compile(r"^(?:Headline|Title|标题|结论)\s*[:：]\s*(.+)$", re.IGNORECASE | re.MULTILINE)
EVIDENCE_RE = re.compile(r"^(?:Evidence|Source|Sources|证据|来源)\s*[:：]\s*(.+)$", re.IGNORECASE | re.MULTILINE)
VISUAL_RE = re.compile(r"^(?:Visual|Chart|图表|视觉)\s*[:：]\s*(.+)$", re.IGNORECASE | re.MULTILINE)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Audit a 12–15 slide investor BP outline.")
    parser.add_argument("--input", required=True, help="outline.md or a workspace containing it")
    parser.add_argument("--output", help="Markdown/JSON report path")
    parser.add_argument("--format", choices=("markdown", "json"), default="markdown")
    parser.add_argument("--min-slides", type=int, default=12)
    parser.add_argument("--max-slides", type=int, default=15)
    parser.add_argument("--strict", action="store_true", help="Exit 1 below 85 or with blockers")
    return parser.parse_args()


def resolve_input(raw: str) -> Path:
    path = Path(raw).expanduser().resolve()
    if path.is_dir():
        path = path / "outline.md"
    if not path.is_file():
        raise SystemExit(f"Outline not found: {path}")
    return path


def parse_slides(text: str) -> List[Dict[str, str]]:
    matches = list(SLIDE_RE.finditer(text))
    if not matches:
        matches = list(SLIDE_ZH_RE.finditer(text))
    slides: List[Dict[str, str]] = []
    for index, match in enumerate(matches):
        start = match.start()
        end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
        block = text[start:end].strip()
        headline = HEADLINE_RE.search(block)
        evidence = EVIDENCE_RE.search(block)
        visual = VISUAL_RE.search(block)
        slides.append(
            {
                "number": match.group(1),
                "block": block,
                "headline": headline.group(1).strip() if headline else "",
                "evidence": evidence.group(1).strip() if evidence else "",
                "visual": visual.group(1).strip() if visual else "",
            }
        )
    return slides


def present(value: str) -> bool:
    return bool(value and not PLACEHOLDER_RE.search(value))


def contains_any(text: str, terms: Sequence[str]) -> bool:
    lowered = text.lower()
    return any(term.lower() in lowered for term in terms)


def audit(text: str, slides: List[Dict[str, str]], minimum: int, maximum: int) -> Dict[str, object]:
    count = len(slides)
    covered = [name for name, terms in BEATS if contains_any(text, terms)]
    missing_beats = [name for name, _ in BEATS if name not in covered]
    headlines = sum(1 for slide in slides if present(slide["headline"]))
    evidence = sum(1 for slide in slides if present(slide["evidence"]))
    visuals = sum(1 for slide in slides if present(slide["visual"]))
    placeholder_count = len(PLACEHOLDER_RE.findall(text))

    structure = min(25, len(covered) * 2 + (1 if minimum <= count <= maximum else 0))
    headline_ratio = headlines / count if count else 0
    readability = round(12 * headline_ratio)
    if contains_any(text, ("investor takeaway", "投资人 takeaway", "投资人结论")):
        readability += 4
    if contains_any(text, ("one-line", "一句话", "product definition", "产品定位")):
        readability += 4
    readability = min(20, readability)

    evidence_ratio = evidence / count if count else 0
    evidence_score = round(14 * evidence_ratio)
    if contains_any(text, ("source", "来源", "evidence", "证据")):
        evidence_score += 4
    if contains_any(text, ("assumption", "假设", "inference", "推断", "fact", "事实")):
        evidence_score += 4
    if contains_any(text, ("as of", "截至", "updated", "更新")):
        evidence_score += 3
    evidence_score = max(0, min(25, evidence_score - min(10, placeholder_count)))

    visual_ratio = visuals / count if count else 0
    visual_score = round(14 * visual_ratio)
    if contains_any(text, ("screenshot", "产品截图", "真实截图", "demo")):
        visual_score += 3
    if contains_any(text, ("chart", "图表", "axis", "坐标轴", "source note", "来源")):
        visual_score += 3
    visual_score = min(20, visual_score)

    delivery = 0
    if contains_any(text, ("financing ask", "融资金额", "raise", "融资")):
        delivery += 4
    if contains_any(text, ("use of funds", "资金用途")):
        delivery += 3
    if contains_any(text, ("milestone", "里程碑", "18–24", "18-24", "runway")):
        delivery += 3

    blockers: List[str] = []
    if not (minimum <= count <= maximum):
        blockers.append(f"Slide count is {count}; expected {minimum}–{maximum}.")
    if missing_beats:
        blockers.append("Missing investor story beats: " + ", ".join(missing_beats) + ".")
    if placeholder_count:
        blockers.append(f"Found {placeholder_count} placeholder or missing markers.")
    if "financing" in missing_beats:
        blockers.append("No clear financing ask.")
    if evidence_ratio < 0.75:
        blockers.append("Fewer than 75% of slides contain a non-placeholder evidence/source field.")

    score = structure + readability + evidence_score + visual_score + delivery
    score = max(0, min(100, score))
    findings: List[str] = []
    if headline_ratio < 1:
        findings.append(f"{count - headlines} slide(s) lack a conclusion headline.")
    if visual_ratio < 1:
        findings.append(f"{count - visuals} slide(s) lack an explicit visual/chart specification.")
    if evidence_ratio < 1:
        findings.append(f"{count - evidence} slide(s) lack an explicit evidence/source field.")
    if score >= 85 and not blockers:
        decision = "investor-ready for visual production"
    elif score >= 70:
        decision = "conditional — revise before rendering"
    else:
        decision = "not ready"

    return {
        "score": score,
        "decision": decision,
        "slide_count": count,
        "scorecard": {
            "story_structure": structure,
            "investor_readability": readability,
            "evidence_hygiene": evidence_score,
            "visual_specification": visual_score,
            "financing_delivery": delivery,
        },
        "coverage": covered,
        "missing_beats": missing_beats,
        "blockers": blockers,
        "findings": findings,
        "placeholder_count": placeholder_count,
    }


def markdown_report(result: Dict[str, object], source: Path) -> str:
    scorecard = result["scorecard"]
    blockers = result["blockers"] or ["None detected by deterministic audit."]
    findings = result["findings"] or ["No structural findings detected."]
    missing = result["missing_beats"] or ["None"]
    lines = [
        "# BP Audit Report",
        "",
        f"- Source: `{source}`",
        f"- Reviewed: {dt.date.today().isoformat()}",
        f"- Score: **{result['score']} / 100**",
        f"- Decision: **{result['decision']}**",
        f"- Slides: {result['slide_count']}",
        "",
        "## Scorecard",
        "",
        "| Dimension | Score | Max |",
        "|---|---:|---:|",
        f"| Story structure | {scorecard['story_structure']} | 25 |",
        f"| Investor readability | {scorecard['investor_readability']} | 20 |",
        f"| Evidence and data hygiene | {scorecard['evidence_hygiene']} | 25 |",
        f"| Charts and visual specification | {scorecard['visual_specification']} | 20 |",
        f"| Financing delivery | {scorecard['financing_delivery']} | 10 |",
        "",
        "## Blockers",
        "",
    ]
    lines.extend(f"- {item}" for item in blockers)
    lines.extend(["", "## Findings", ""])
    lines.extend(f"- {item}" for item in findings)
    lines.extend(["", "## Missing story beats", ""])
    lines.extend(f"- {item}" for item in missing)
    lines.extend(
        [
            "",
            "## Required visual review",
            "",
            "This script cannot validate typography, optical alignment, chart truth, screenshot",
            "legibility, or QR decoding. Review every final rendered page using the visual QA",
            "checklist in `references/review-rubric.md`.",
            "",
        ]
    )
    return "\n".join(lines)


def main() -> int:
    args = parse_args()
    source = resolve_input(args.input)
    text = source.read_text(encoding="utf-8")
    slides = parse_slides(text)
    result = audit(text, slides, args.min_slides, args.max_slides)

    if args.format == "json":
        report = json.dumps(result, ensure_ascii=False, indent=2) + "\n"
    else:
        report = markdown_report(result, source)

    if args.output:
        output = Path(args.output).expanduser().resolve()
        output.parent.mkdir(parents=True, exist_ok=True)
        output.write_text(report, encoding="utf-8")
        print(f"Wrote BP audit report: {output}")
    else:
        print(report, end="" if report.endswith("\n") else "\n")

    if args.strict and (int(result["score"]) < 85 or bool(result["blockers"])):
        return 1
    return 0


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""Build a validated WorkBuddy skill-only Connector distribution."""

from __future__ import annotations

import argparse
import json
import re
import shutil
import sys
import zipfile
from pathlib import Path


ROOT = Path(__file__).resolve().parent.parent
WORKBUDDY_DIR = ROOT / "workbuddy"
GIT_URL = "https://example.com/skills/bp-skill"

SKILLS = {
    "lov-bp": {
        "source": ROOT,
        "version": "0.2.1",
        "description": (
            "根据项目材料和用户目标，按需编排投资人商业计划书大纲、融资演示文稿、"
            "证据核验与专业审校流程；适用于完整 BP、融资 PPT、已有材料续作和逐页润色。"
        ),
    },
    "lov-bp-outline": {
        "source": ROOT / "skills" / "bp-outline",
        "version": "0.1.0",
        "description": (
            "从项目材料提取事实和证据，形成投资人叙事、证据账本与商业计划书大纲；"
            "适用于首次融资梳理、已有材料重构、市场数据核验和投资人页序设计。"
        ),
    },
    "lov-bp-deck": {
        "source": ROOT / "skills" / "bp-deck",
        "version": "0.1.0",
        "description": (
            "将已确认的商业计划书大纲制作成结构清晰、证据可信的专业融资演示文稿；"
            "覆盖视觉风格、图表、品牌素材、可编辑 PPTX、PDF 和全稿预览交付。"
        ),
    },
    "lov-bp-polish": {
        "source": ROOT / "skills" / "bp-polish",
        "version": "0.1.0",
        "description": (
            "审查并润色已有商业计划书大纲、PPT 或 PDF，输出逐页修改与定向重做建议；"
            "覆盖事实证据、投资逻辑、文案、图表、版式和最终交付质量。"
        ),
    },
}

MODULE_SKILLS = {
    "bp-outline": "lov-bp-outline",
    "bp-deck": "lov-bp-deck",
    "bp-polish": "lov-bp-polish",
}

ROOT_RESOURCE_FILES = ("kit.yaml",)
ROOT_RESOURCE_DIRS = ("assets", "cases", "references", "scripts")
SKILL_RESOURCES = ("assets", "references", "scripts")
IGNORED_PATTERNS = ("__pycache__", "*.pyc", "*.pyo", ".DS_Store")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Build the Skill Publisher BP WorkBuddy Connector package."
    )
    parser.add_argument(
        "--output-dir",
        type=Path,
        required=True,
        help="New directory to create. It must not already exist.",
    )
    parser.add_argument(
        "--zip-path",
        type=Path,
        help="Optional ZIP path. Defaults to <output-dir>.zip.",
    )
    return parser.parse_args()


def split_frontmatter(text: str) -> tuple[str, str]:
    if not text.startswith("---\n"):
        raise ValueError("SKILL.md is missing YAML frontmatter")
    marker = text.find("\n---\n", 4)
    if marker < 0:
        raise ValueError("SKILL.md frontmatter is not closed")
    return text[4:marker], text[marker + 5 :]


def workbuddy_skill_text(
    name: str, description: str, version: str, source_text: str
) -> str:
    _, body = split_frontmatter(source_text)
    if name == "lov-bp-deck":
        body = body.replace(
            "### Step 0: Resolve input and dependency",
            "### Step 0: Resolve input and WorkBuddy capabilities",
        )
        body = body.replace(
            "Resolve `lov-any2deck` through the active Agent Skills environment; do not\n"
            "assume an author's private installation path.",
            "Use WorkBuddy's available presentation and document-generation capabilities. "
            "Do not\nassume an author's private installation path or require a separate "
            "Skill Publisher Skill.",
        )
        body = body.replace(
            "### Step 4: Generate with `lov-any2deck`",
            "### Step 4: Generate with WorkBuddy",
        )
        body = body.replace(
            "Invoke `lov-any2deck` using the approved outline and chosen style. Preserve the\n"
            "BP page order and evidence notes.",
            "Use WorkBuddy's presentation-generation capability with the approved outline and "
            "chosen\nstyle. Preserve the BP page order and evidence notes.",
        )

    frontmatter = (
        "---\n"
        f"name: {name}\n"
        f"description: {json.dumps(description, ensure_ascii=False)}\n"
        f'version: "{version}"\n'
        "author: Skill Publisher\n"
        "source_type: git\n"
        f"git_url: {GIT_URL}\n"
        "---\n"
    )
    return frontmatter + body


def copy_resources(source_dir: Path, target_dir: Path) -> None:
    for relative in SKILL_RESOURCES:
        source = source_dir / relative
        if source.exists():
            shutil.copytree(
                source,
                target_dir / relative,
                ignore=shutil.ignore_patterns(*IGNORED_PATTERNS),
            )


def write_skill(
    name: str, config: dict[str, object], source_dir: Path, target_dir: Path
) -> None:
    target_dir.mkdir(parents=True)
    source_text = (source_dir / "SKILL.md").read_text(encoding="utf-8")
    target_text = workbuddy_skill_text(
        name=name,
        description=str(config["description"]),
        version=str(config["version"]),
        source_text=source_text,
    )
    (target_dir / "SKILL.md").write_text(target_text, encoding="utf-8")


def copy_skill(name: str, config: dict[str, object], skills_dir: Path) -> None:
    source_dir = Path(config["source"])
    target_dir = skills_dir / name
    write_skill(name, config, source_dir, target_dir)

    if name == "lov-bp":
        for relative in ROOT_RESOURCE_FILES:
            source = ROOT / relative
            target = target_dir / relative
            target.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(source, target)
        for relative in ROOT_RESOURCE_DIRS:
            ignored = list(IGNORED_PATTERNS)
            if relative == "scripts":
                ignored.append("build_workbuddy_connector.py")
            shutil.copytree(
                ROOT / relative,
                target_dir / relative,
                ignore=shutil.ignore_patterns(*ignored),
            )
        for module_id, module_name in MODULE_SKILLS.items():
            module_config = SKILLS[module_name]
            module_source = Path(module_config["source"])
            module_target = target_dir / "skills" / module_id
            write_skill(module_name, module_config, module_source, module_target)
            copy_resources(module_source, module_target)
        return

    copy_resources(source_dir, target_dir)


def write_zip(output_dir: Path, zip_path: Path) -> None:
    if zip_path.exists():
        raise FileExistsError(f"ZIP already exists: {zip_path}")
    zip_path.parent.mkdir(parents=True, exist_ok=True)
    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
        for path in sorted(output_dir.rglob("*")):
            if path.is_file():
                archive.write(path, Path(output_dir.name) / path.relative_to(output_dir))


def write_individual_zips(output_dir: Path, individual_dir: Path) -> None:
    if individual_dir.exists():
        raise FileExistsError(f"individual ZIP directory already exists: {individual_dir}")
    individual_dir.mkdir(parents=True)
    for skill_dir in sorted((output_dir / "skills").iterdir()):
        zip_path = individual_dir / f"{skill_dir.name}.zip"
        with zipfile.ZipFile(
            zip_path, "w", compression=zipfile.ZIP_DEFLATED
        ) as archive:
            for path in sorted(skill_dir.rglob("*")):
                if path.is_file():
                    archive.write(
                        path, Path(skill_dir.name) / path.relative_to(skill_dir)
                    )


def validate_frontmatter(skill_file: Path) -> list[str]:
    errors: list[str] = []
    frontmatter, body = split_frontmatter(skill_file.read_text(encoding="utf-8"))
    for field in (
        "name",
        "description",
        "version",
        "author",
        "source_type",
        "git_url",
    ):
        if not re.search(rf"(?m)^{re.escape(field)}:\s*.+$", frontmatter):
            errors.append(f"{skill_file}: missing {field}")
    if not re.search(r"(?m)^source_type:\s*git\s*$", frontmatter):
        errors.append(f"{skill_file}: source_type must be git")
    if not re.search(
        rf"(?m)^git_url:\s*{re.escape(GIT_URL)}\s*$", frontmatter
    ):
        errors.append(f"{skill_file}: git_url must be {GIT_URL}")
    if not body.strip():
        errors.append(f"{skill_file}: empty body")
    return errors


def validate_package(output_dir: Path) -> None:
    errors: list[str] = []
    meta_path = output_dir / "connector-meta.json"
    meta = json.loads(meta_path.read_text(encoding="utf-8"))

    required = (
        "name",
        "name_en",
        "description",
        "description_zh",
        "description_en",
        "source",
        "type",
        "version",
        "examples_zh",
        "examples_en",
        "source_type",
        "git_url",
    )
    for field in required:
        if field not in meta:
            errors.append(f"connector-meta.json: missing {field}")
    if meta.get("type") != "skill-only":
        errors.append('connector-meta.json: type must be "skill-only"')
    if not re.fullmatch(r"[a-z0-9]+(?:-[a-z0-9]+)*", str(meta.get("source", ""))):
        errors.append("connector-meta.json: source must be kebab-case")
    if meta.get("source_type") != "git":
        errors.append('connector-meta.json: source_type must be "git"')
    if meta.get("git_url") != GIT_URL:
        errors.append(f"connector-meta.json: git_url must be {GIT_URL}")
    for field in ("examples_zh", "examples_en"):
        value = meta.get(field)
        if not isinstance(value, list) or not 2 <= len(value) <= 5:
            errors.append(f"connector-meta.json: {field} must contain 2-5 examples")

    skill_files = sorted((output_dir / "skills").glob("*/SKILL.md"))
    if len(skill_files) != len(SKILLS):
        errors.append(f"expected {len(SKILLS)} SKILL.md files, found {len(skill_files)}")
    for skill_file in skill_files:
        errors.extend(validate_frontmatter(skill_file))

    for name, config in SKILLS.items():
        description = str(config["description"])
        if not 50 <= len(description) <= 200:
            errors.append(
                f"{name}: description must contain 50-200 characters, "
                f"found {len(description)}"
            )

    forbidden_files = [
        path
        for path in output_dir.rglob("*")
        if path.name == "__pycache__" or path.suffix.lower() in {".pyc", ".pyo"}
    ]
    for path in forbidden_files:
        errors.append(f"package contains generated Python artifact: {path}")

    all_text = "\n".join(
        path.read_text(encoding="utf-8", errors="ignore")
        for path in output_dir.rglob("*")
        if path.is_file() and path.suffix.lower() in {".md", ".json", ".yaml", ".yml", ".svg"}
    )
    if "${SKILL_USER_ROOT}" in all_text:
        errors.append("package contains a private absolute path")
    deck_text = (
        output_dir / "skills" / "lov-bp-deck" / "SKILL.md"
    ).read_text(encoding="utf-8")
    if "Requires lov-any2deck" in deck_text or "Invoke `lov-any2deck`" in deck_text:
        errors.append("WorkBuddy deck Skill still has a hard any2deck runtime dependency")
    root_text = (
        output_dir / "skills" / "lov-bp" / "SKILL.md"
    ).read_text(encoding="utf-8")
    if "$KIT_DIR/../lov-bp-" in root_text:
        errors.append("WorkBuddy controller points at external sibling Skills")
    if "## Triggers" not in root_text:
        errors.append("WorkBuddy controller is missing an explicit Triggers section")

    controller_dir = output_dir / "skills" / "lov-bp"
    kit_text = (controller_dir / "kit.yaml").read_text(encoding="utf-8")
    if not re.search(r"(?m)^source_type:\s*git\s*$", kit_text):
        errors.append("lov-bp/kit.yaml: source_type must be git")
    if not re.search(rf"(?m)^git_url:\s*{re.escape(GIT_URL)}\s*$", kit_text):
        errors.append(f"lov-bp/kit.yaml: git_url must be {GIT_URL}")

    for module_id, module_name in MODULE_SKILLS.items():
        module_skill = controller_dir / "skills" / module_id / "SKILL.md"
        if not module_skill.is_file():
            errors.append(f"controller is missing module: skills/{module_id}/SKILL.md")
            continue
        errors.extend(validate_frontmatter(module_skill))
        module_frontmatter, _ = split_frontmatter(
            module_skill.read_text(encoding="utf-8")
        )
        if not re.search(
            rf"(?m)^name:\s*{re.escape(module_name)}\s*$", module_frontmatter
        ):
            errors.append(f"{module_skill}: expected name {module_name}")
        expected_reference = f"$KIT_DIR/skills/{module_id}/SKILL.md"
        if expected_reference not in root_text:
            errors.append(f"controller does not reference {expected_reference}")

    case_reference = controller_dir / "references" / "case-yoda.md"
    case_text = case_reference.read_text(encoding="utf-8")
    for relative_link in re.findall(r"!\[[^\]]*\]\(([^)]+)\)", case_text):
        linked_path = (case_reference.parent / relative_link).resolve()
        if not linked_path.is_file():
            errors.append(f"broken case image reference: {relative_link}")

    if errors:
        raise ValueError("WorkBuddy package validation failed:\n- " + "\n- ".join(errors))


def build(output_dir: Path, zip_path: Path, individual_dir: Path) -> None:
    if output_dir.exists():
        raise FileExistsError(f"output directory already exists: {output_dir}")
    output_dir.mkdir(parents=True)

    for filename in ("connector-meta.json", "icon.svg", "README.md", "SUBMISSION.md"):
        shutil.copy2(WORKBUDDY_DIR / filename, output_dir / filename)

    skills_dir = output_dir / "skills"
    skills_dir.mkdir()
    for name, config in SKILLS.items():
        copy_skill(name, config, skills_dir)

    validate_package(output_dir)
    write_zip(output_dir, zip_path)
    write_individual_zips(output_dir, individual_dir)

    print(f"connector_dir={output_dir}")
    print(f"connector_zip={zip_path}")
    print(f"individual_zips={individual_dir}")
    print(f"skills={len(SKILLS)}")
    print("validation=passed")


def main() -> int:
    args = parse_args()
    output_dir = args.output_dir.expanduser().resolve()
    zip_path = (
        args.zip_path.expanduser().resolve()
        if args.zip_path
        else Path(f"{output_dir}.zip")
    )
    individual_dir = output_dir.parent / f"{output_dir.name}-individual"
    try:
        build(output_dir, zip_path, individual_dir)
    except (FileExistsError, ValueError, OSError, json.JSONDecodeError) as error:
        print(f"error: {error}", file=sys.stderr)
        return 1
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Create a portable investor-BP workspace without overwriting existing work."""

from __future__ import annotations

import argparse
import datetime as dt
import json
import os
import re
import sys
from pathlib import Path
from typing import Any, Dict, Optional


def expand_path(value: str) -> Path:
    return Path(os.path.expandvars(os.path.expanduser(value))).resolve()


def slugify(value: str) -> str:
    normalized = re.sub(r"[^\w\u4e00-\u9fff]+", "-", value.strip().lower(), flags=re.UNICODE)
    return normalized.strip("-_") or "project"


def load_profile(path: Path) -> Dict[str, Any]:
    if not path.exists():
        return {}
    try:
        data = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError) as exc:
        raise SystemExit(f"Cannot read profile {path}: {exc}") from exc
    if not isinstance(data, dict):
        raise SystemExit(f"Profile must be a JSON object: {path}")
    return data


def nested(data: Dict[str, Any], *keys: str) -> Optional[str]:
    current: Any = data
    for key in keys:
        if not isinstance(current, dict):
            return None
        current = current.get(key)
    return current if isinstance(current, str) and current.strip() else None


def resolve_output(args: argparse.Namespace, profile: Dict[str, Any]) -> Path:
    if args.output:
        return expand_path(args.output)
    skill_output = os.environ.get("SKILL_BP_OUTPUT_DIR")
    if skill_output:
        return expand_path(skill_output) / f"{slugify(args.name)}-business-plan"
    shared_output = os.environ.get("SKILL_OUTPUT_DIR")
    if shared_output:
        return expand_path(shared_output) / f"{slugify(args.name)}-business-plan"
    profile_output = nested(profile, "workspace", "output_dir")
    if profile_output:
        return expand_path(profile_output) / f"{slugify(args.name)}-business-plan"
    return (Path.cwd() / "business-plan").resolve()


def resolve_optional(explicit: Optional[str], env_name: str, profile: Dict[str, Any], key: str) -> str:
    value = explicit or os.environ.get(env_name) or nested(profile, "brand", key)
    return str(expand_path(value)) if value else "not configured"


def render_template(template: Path, destination: Path, values: Dict[str, str]) -> None:
    text = template.read_text(encoding="utf-8")
    for key, value in values.items():
        text = text.replace("{{" + key + "}}", value)
    destination.write_text(text, encoding="utf-8")


def ensure_safe_destination(output: Path) -> None:
    home = Path.home().resolve()
    if output in {Path("/").resolve(), home}:
        raise SystemExit(f"Refusing to use broad destination: {output}")
    if output.exists() and any(output.iterdir()):
        raise SystemExit(
            f"Destination already contains files: {output}\n"
            "Continue in that workspace manually or choose a new --output path."
        )


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Create a source-backed 12–15 slide investor-BP workspace."
    )
    parser.add_argument("--name", required=True, help="Project or company name")
    parser.add_argument(
        "--stage",
        default="seed",
        choices=("pre-seed", "seed", "angel", "pre-a", "series-a", "growth", "other"),
        help="Financing stage (default: seed)",
    )
    parser.add_argument("--output", help="Exact workspace directory")
    parser.add_argument("--profile", help="Shared Skill Publisher skills profile JSON")
    parser.add_argument("--brand-profile", help="Brand profile file")
    parser.add_argument("--design-guide", help="Design guide file")
    parser.add_argument("--json", action="store_true", help="Print machine-readable result")
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    profile_path = expand_path(
        args.profile
        or os.environ.get("SKILL_PROFILE_PATH")
        or "$HOME/.skill-publisher/skills/profile.json"
    )
    profile = load_profile(profile_path)
    output = resolve_output(args, profile)
    ensure_safe_destination(output)

    skill_root = Path(__file__).resolve().parent.parent
    template_root = skill_root / "assets" / "templates"
    required_templates = {
        "brief.md": template_root / "brief.md",
        "evidence-ledger.md": template_root / "evidence-ledger.md",
        "outline.md": template_root / "outline.md",
        "reports/bp-review.md": template_root / "bp-review.md",
    }
    missing = [str(path) for path in required_templates.values() if not path.exists()]
    if missing:
        raise SystemExit("Missing templates:\n- " + "\n- ".join(missing))

    output.mkdir(parents=True, exist_ok=True)
    (output / "assets").mkdir(exist_ok=True)
    (output / "reports").mkdir(exist_ok=True)
    (output / "assets" / ".gitkeep").touch()

    today = dt.date.today().isoformat()
    values = {
        "PROJECT_NAME": args.name.strip(),
        "STAGE": args.stage,
        "DATE": today,
        "VERSION": "draft-0.1",
    }
    created = []
    for relative, template in required_templates.items():
        destination = output / relative
        render_template(template, destination, values)
        created.append(str(destination))

    brand_profile = resolve_optional(
        args.brand_profile, "SKILL_BP_BRAND_PROFILE", profile, "profile"
    )
    design_guide = resolve_optional(
        args.design_guide, "SKILL_BP_DESIGN_GUIDE", profile, "design_guide"
    )
    source_note = output / "source-config.md"
    source_note.write_text(
        "# BP Source Configuration\n\n"
        f"- Project: {args.name.strip()}\n"
        f"- Stage: {args.stage}\n"
        f"- Created: {today}\n"
        f"- Brand profile: {brand_profile}\n"
        f"- Design guide: {design_guide}\n\n"
        "Do not store credentials or private customer data in this file.\n",
        encoding="utf-8",
    )
    created.append(str(source_note))

    result = {
        "project": args.name.strip(),
        "stage": args.stage,
        "workspace": str(output),
        "created": created,
    }
    if args.json:
        print(json.dumps(result, ensure_ascii=False, indent=2))
    else:
        print(f"Created investor-BP workspace: {output}")
        for path in created:
            print(f"  - {path}")
        print("Next: replace missing/TODO items with sourced evidence, then run audit_bp.py.")
    return 0


if __name__ == "__main__":
    sys.exit(main())

{
  "name": "Skill Publisher BP",
  "name_zh": "Skill Publisher 商业计划书",
  "name_en": "Skill Publisher BP",
  "description": "从项目材料生成投资人商业计划书大纲、融资演示文稿，并完成专业审校。",
  "description_zh": "从项目材料生成投资人商业计划书大纲、融资演示文稿，并完成证据、内容和视觉审校。",
  "description_en": "Create investor-ready BP outlines, pitch decks, and evidence-based reviews from project materials.",
  "source": "lov-bp",
  "type": "skill-only",
  "version": "0.2.1",
  "source_type": "git",
  "git_url": "https://example.com/skills/bp-skill",
  "minWorkbuddyVersion": "4.24.0",
  "examples_zh": [
    "根据当前项目材料，先写一份种子轮商业计划书大纲",
    "把已经确认的商业计划书大纲制作成专业融资演示文稿",
    "逐页审查这份商业计划书，修正证据、文案和视觉问题",
    "从项目资料开始，完成商业计划书大纲、演示文稿和最终审校"
  ],
  "examples_en": [
    "Create a seed-stage BP outline from the current project materials",
    "Turn the approved BP outline into a professional investor pitch deck",
    "Review this BP slide by slide and fix evidence, copy, and visual issues",
    "Build and polish a complete investor BP from the available project files"
  ]
}

# WorkBuddy Connector 发行说明

本目录用于生成 `Skill Publisher BP Skill Kit` 的 WorkBuddy `skill-only`
Connector 提交包。

## 接入判断

- Connector 类型：`skill-only`
- 不需要 `mcp.json`
- 不需要 `cli.json`
- 不需要 OAuth、Token 或其他用户凭证
- 不调用 Skill Publisher 私有服务
- Skill 本体按 MIT License 免费开源

## 提交包内容

```text
lov-bp-workbuddy-v0.2.1/
├── connector-meta.json
├── icon.svg
├── README.md
├── SUBMISSION.md
└── skills/
    ├── lov-bp/
    ├── lov-bp-outline/
    ├── lov-bp-deck/
    └── lov-bp-polish/
```

四个 Skill 可以独立使用，也可以由 `lov-bp` 总控按需组合。
其中 `lov-bp` 自身已内置 `skills/bp-outline`、`skills/bp-deck` 和
`skills/bp-polish`，单独提交该 ZIP 时不会依赖同级目录中的其他 Skill。

## 构建

输出目录必须是一个尚不存在的新目录：

```bash
python3 scripts/build_workbuddy_connector.py \
  --output-dir /path/to/lov-bp-workbuddy-v0.2.1
```

脚本会同时生成同名 ZIP，并执行结构、元信息、Frontmatter、私有路径和
PPT 运行时适配检查。它还会生成
`lov-bp-workbuddy-v0.2.1-individual/`，其中包含四个可在
WorkBuddy“上传技能”界面逐个导入的 ZIP。

## 维护

更新 BP Skill Kit 后：

1. 更新 `workbuddy/connector-meta.json` 的版本和文案；
2. 使用新的版本化目录重新构建；
3. 将 ZIP 提交给 WorkBuddy 运营团队审核。

# WorkBuddy Connector 审核提交说明

## 提交主题

Skill Publisher BP Skill Kit v0.2.1（skill-only Connector）重新审核申请

## 项目简介

Skill Publisher BP Skill Kit 是一套免费、开源、可组合的商业计划书 Skill。
它将融资材料生产拆分为项目证据梳理、投资人叙事、大纲制作、PPT 生成和
专业审校几个阶段。用户既可以独立使用某一个 Skill，也可以交由总控 Skill
完成完整流程。

## 本次提交内容

- `lov-bp`：识别用户意图并编排所需模块；
- `lov-bp-outline`：从项目材料生成证据账本和 12–15 页 BP 大纲；
- `lov-bp-deck`：将已确认大纲制作成专业融资演示文稿；
- `lov-bp-polish`：审查和修正已有大纲、PPT、PDF 的证据、内容与视觉问题。

## 0.2.1 审查修复

- `lov-bp.zip` 已改为自包含包，内置三个被编排子模块及其资源；
- 总控与 `kit.yaml` 统一使用包内 `skills/bp-*` 相对路径；
- Skill frontmatter、`kit.yaml` 和 Connector 元数据均补充 Git 来源标识；
- 补充显式触发词、不应触发条件和缺失模块错误提示；
- 补齐 Yoda 案例图片，并在构建时拒绝 `__pycache__`、`.pyc` 与失效图片引用。

## 接入信息

- Connector ID：`lov-bp`
- Connector 类型：`skill-only`
- 版本：`0.2.1`
- 最低 WorkBuddy 版本：`4.24.0`
- 认证：不需要
- 外部服务：不需要
- MCP Server：不需要
- CLI：不需要
- License：MIT
- 项目主页：https://example.com/skills/bp
- 源代码：https://example.com/skills/bp-skill

## 隐私与安全

Skill 仅处理用户主动提供或当前工作区可访问的项目材料，不要求用户提供
账号、Token、API Key 或其他第三方凭证。事实性数据与推断、假设分开记录，
生成演示文稿时禁止编造市场、财务或用户指标。

## 建议审核用例

1. “根据当前项目材料，先写一份种子轮商业计划书大纲。”
2. “把已经确认的商业计划书大纲制作成专业融资演示文稿。”
3. “逐页审查这份商业计划书，修正证据、文案和视觉问题。”
4. “从项目资料开始，完成商业计划书大纲、演示文稿和最终审校。”