propongo2 0.1.1__py3-none-any.whl

app/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

app/export.py

@@ -0,0 +1,104 @@
+import os
+from io import BytesIO
+from weasyprint import HTML
+from flask import Blueprint, render_template, request, send_file, jsonify, Response
+from .models import Proposal
+
+export_bp = Blueprint("export", __name__)
+
+EXPORT_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "exports")
+
+
+def ensure_export_dir():
+    os.makedirs(EXPORT_DIR, exist_ok=True)
+
+
+def _build_export_context(proposal):
+    indirect_percent = getattr(proposal, 'indirect_percent', 0) or 0
+    indirect_amount = proposal.total_budget * (indirect_percent / 100)
+    total_with_indirect = proposal.total_budget + indirect_amount
+
+    tasks_with_timing = []
+    for t in proposal.tasks:
+        tasks_with_timing.append({
+            "id": t.get("id", ""),
+            "name": t.get("name", ""),
+            "description": t.get("description", ""),
+            "lead_entity": t.get("lead_entity", ""),
+            "start_month": t.get("start_month"),
+            "start_year": t.get("start_year"),
+            "duration_months": t.get("duration_months", 1),
+        })
+
+    budget_with_timing = []
+    timings = proposal.budget_item_timings or {}
+    for item in proposal.budget_items:
+        item_id = item.get("id", "")
+        timing = timings.get(item_id, {})
+        budget_with_timing.append({
+            **item,
+            "start_month": timing.get("start_month"),
+            "start_year": timing.get("start_year"),
+            "duration_months": timing.get("duration_months", 1),
+            "task_id": item.get("task_id", ""),
+        })
+
+    return {
+        "proposal": proposal,
+        "tasks": tasks_with_timing,
+        "budget_items": proposal.budget_items,
+        "budget_with_timing": budget_with_timing,
+        "total_budget": proposal.total_budget,
+        "indirect_percent": indirect_percent,
+        "indirect_amount": indirect_amount,
+        "total_with_indirect": total_with_indirect,
+    }
+
+
+@export_bp.route("/export/pdf/<proposal_id>")
+def export_pdf(proposal_id):
+    proposal = Proposal.load(proposal_id)
+    if not proposal:
+        return jsonify({"error": "Proposal not found"}), 404
+
+    ctx = _build_export_context(proposal)
+    html_content = render_template("export_proposal.html", **ctx)
+
+    ensure_export_dir()
+    pdf_path = os.path.join(EXPORT_DIR, f"{proposal_id}.pdf")
+    HTML(string=html_content, base_url=request.host_url).write_pdf(pdf_path)
+
+    return send_file(
+        pdf_path,
+        mimetype="application/pdf",
+        as_attachment=True,
+        download_name=f"{proposal.title or 'proposal'}.pdf",
+    )
+
+
+@export_bp.route("/export/html/<proposal_id>")
+def export_html(proposal_id):
+    proposal = Proposal.load(proposal_id)
+    if not proposal:
+        return jsonify({"error": "Proposal not found"}), 404
+
+    ctx = _build_export_context(proposal)
+    html_content = render_template("export_proposal.html", **ctx)
+
+    return Response(
+        html_content,
+        mimetype="text/html",
+        headers={
+            "Content-Disposition": f"inline; filename={proposal.title or 'proposal'}.html"
+        },
+    )
+
+
+@export_bp.route("/preview/<proposal_id>")
+def preview(proposal_id):
+    proposal = Proposal.load(proposal_id)
+    if not proposal:
+        return jsonify({"error": "Proposal not found"}), 404
+
+    ctx = _build_export_context(proposal)
+    return render_template("export_proposal.html", **ctx)

app/main.py

@@ -0,0 +1,446 @@
+import json
+import os
+import re
+import uuid as _uuid
+from flask import Flask, render_template, request, jsonify, redirect, url_for
+from markupsafe import Markup
+from .models import Proposal, PROPOSALS_DIR
+from .export import export_bp
+from .snippets import snippets_bp
+
+
+def markdown_to_html(text):
+    if not text:
+        return ""
+    lines = text.split("\n")
+    html_lines = []
+    in_list = False
+    in_ol = False
+
+    for line in lines:
+        stripped = line.strip()
+
+        if not stripped:
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            if in_ol:
+                html_lines.append("</ol>")
+                in_ol = False
+            continue
+
+        if stripped.startswith("######"):
+            if in_list: html_lines.append("</ul>"); in_list = False
+            if in_ol: html_lines.append("</ol>"); in_ol = False
+            html_lines.append(f"<h6>{_md_inline(stripped[6:])}</h6>")
+        elif stripped.startswith("#####"):
+            if in_list: html_lines.append("</ul>"); in_list = False
+            if in_ol: html_lines.append("</ol>"); in_ol = False
+            html_lines.append(f"<h5>{_md_inline(stripped[5:])}</h5>")
+        elif stripped.startswith("####"):
+            if in_list: html_lines.append("</ul>"); in_list = False
+            if in_ol: html_lines.append("</ol>"); in_ol = False
+            html_lines.append(f"<h4>{_md_inline(stripped[4:])}</h4>")
+        elif stripped.startswith("###"):
+            if in_list: html_lines.append("</ul>"); in_list = False
+            if in_ol: html_lines.append("</ol>"); in_ol = False
+            html_lines.append(f"<h3>{_md_inline(stripped[3:])}</h3>")
+        elif stripped.startswith("##"):
+            if in_list: html_lines.append("</ul>"); in_list = False
+            if in_ol: html_lines.append("</ol>"); in_ol = False
+            html_lines.append(f"<h2>{_md_inline(stripped[2:])}</h2>")
+        elif stripped.startswith("#"):
+            if in_list: html_lines.append("</ul>"); in_list = False
+            if in_ol: html_lines.append("</ol>"); in_ol = False
+            html_lines.append(f"<h1>{_md_inline(stripped[1:])}</h1>")
+        elif re.match(r"^[-*+]\s+", stripped):
+            if in_ol: html_lines.append("</ol>"); in_ol = False
+            if not in_list:
+                html_lines.append("<ul>")
+                in_list = True
+            content = re.sub(r"^[-*+]\s+", "", stripped)
+            html_lines.append(f"<li>{_md_inline(content)}</li>")
+        elif re.match(r"^\d+\.\s+", stripped):
+            if in_list: html_lines.append("</ul>"); in_list = False
+            if not in_ol:
+                html_lines.append("<ol>")
+                in_ol = True
+            content = re.sub(r"^\d+\.\s+", "", stripped)
+            html_lines.append(f"<li>{_md_inline(content)}</li>")
+        else:
+            if in_list: html_lines.append("</ul>"); in_list = False
+            if in_ol: html_lines.append("</ol>"); in_ol = False
+            html_lines.append(f"<p>{_md_inline(stripped)}</p>")
+
+    if in_list:
+        html_lines.append("</ul>")
+    if in_ol:
+        html_lines.append("</ol>")
+
+    return "\n".join(html_lines)
+
+
+def _md_inline(text):
+    text = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", text)
+    text = re.sub(r"\*(.+?)\*", r"<em>\1</em>", text)
+    text = re.sub(r"`(.+?)`", r"<code>\1</code>", text)
+    return text
+
+
+def create_app():
+    app = Flask(__name__)
+    app.secret_key = "propongo2-dev-key-change-in-production"
+
+    app.register_blueprint(export_bp)
+    app.register_blueprint(snippets_bp)
+
+    app.jinja_env.filters["md"] = lambda text: Markup(markdown_to_html(text))
+    app.jinja_env.filters["currency"] = lambda value: f"{value:,.2f}"
+
+    @app.route("/")
+    def index():
+        proposals = Proposal.list_all()
+        return render_template("index.html", proposals=proposals)
+
+    @app.route("/new")
+    def new_proposal():
+        proposal = Proposal()
+        proposal.save()
+        return redirect(url_for("editor", proposal_id=proposal.id))
+
+    @app.route("/editor/<proposal_id>")
+    def editor(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return redirect(url_for("index"))
+        return render_template(
+            "base.html",
+            proposal=proposal,
+            tasks=proposal.tasks,
+            budget_items=proposal.budget_items,
+        )
+
+    @app.route("/api/proposal/<proposal_id>", methods=["GET"])
+    def get_proposal(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+        return jsonify(proposal.to_dict())
+
+    @app.route("/api/proposal/<proposal_id>", methods=["PUT"])
+    def save_proposal(proposal_id):
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data"}), 400
+
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            proposal = Proposal(id=proposal_id)
+
+        if "tasks" in data:
+            incoming_tasks = data.pop("tasks")
+            existing_by_id = {t.get("id"): t for t in proposal.tasks}
+            merged = []
+            for t in incoming_tasks:
+                tid = t.get("id", "")
+                if tid in existing_by_id:
+                    merged_task = dict(existing_by_id[tid])
+                    merged_task.update(t)
+                else:
+                    merged_task = t
+                merged.append(merged_task)
+            proposal.tasks = merged
+
+        new_title = data.get("title")
+        new_id = None
+        if new_title is not None and new_title.strip() and new_title.strip() != proposal.title:
+            candidate = re.sub(r"[^a-z0-9_-]", "_", new_title.strip().lower())
+            candidate = re.sub(r"_+", "_", candidate).strip("_")
+            if not candidate:
+                candidate = _uuid.uuid4().hex[:8]
+            original = candidate
+            counter = 1
+            while Proposal.load(candidate) and candidate != proposal_id:
+                candidate = f"{original}_{counter}"
+                counter += 1
+            if candidate != proposal_id:
+                old_path = os.path.join(PROPOSALS_DIR, f"{proposal_id}.json")
+                proposal.id = candidate
+                new_id = candidate
+                for key, value in data.items():
+                    if hasattr(proposal, key):
+                        setattr(proposal, key, value)
+                proposal.save()
+                if os.path.exists(old_path):
+                    os.remove(old_path)
+                return jsonify({"id": new_id, **proposal.to_dict()})
+
+        for key, value in data.items():
+            if hasattr(proposal, key):
+                setattr(proposal, key, value)
+
+        proposal.save()
+        return jsonify(proposal.to_dict())
+
+    @app.route("/api/proposal/<proposal_id>", methods=["DELETE"])
+    def delete_proposal(proposal_id):
+        Proposal.delete(proposal_id)
+        return jsonify({"ok": True})
+
+    @app.route("/api/proposal/<proposal_id>/save-as", methods=["POST"])
+    def save_proposal_as(proposal_id):
+        data = request.get_json()
+        title = data.get("title", "").strip()
+        if not title:
+            return jsonify({"error": "Title required"}), 400
+
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        new_id = re.sub(r"[^a-z0-9_-]", "_", title.lower())
+        new_id = re.sub(r"_+", "_", new_id).strip("_")
+        if not new_id:
+            new_id = _uuid.uuid4().hex[:8]
+
+        original_id = new_id
+        counter = 1
+        while Proposal.load(new_id):
+            new_id = f"{original_id}_{counter}"
+            counter += 1
+
+        new_proposal = Proposal(id=new_id, title=title)
+        new_proposal.client_name = proposal.client_name
+        new_proposal.project_summary = proposal.project_summary
+        new_proposal.tasks = list(proposal.tasks)
+        new_proposal.qualifications = proposal.qualifications
+        new_proposal.budget_items = list(proposal.budget_items)
+        new_proposal.budget_item_timings = dict(proposal.budget_item_timings) if proposal.budget_item_timings else {}
+        new_proposal.start_date = proposal.start_date
+        new_proposal.indirect_percent = getattr(proposal, 'indirect_percent', 0) or 0
+        new_proposal.save()
+
+        return jsonify({"id": new_id}), 201
+
+    @app.route("/api/proposals", methods=["GET"])
+    def list_proposals():
+        return jsonify(Proposal.list_all())
+
+    @app.route("/scope/<proposal_id>")
+    def scope_tab(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+        return render_template("scope.html", proposal=proposal, tasks=proposal.tasks)
+
+    @app.route("/budget/<proposal_id>")
+    def budget_tab(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        task_budgets = {}
+        for task in proposal.tasks:
+            items = [b for b in proposal.budget_items if b.get("task_id") == task["id"]]
+            subtotal = sum(i.get("cost_per_unit", 0) * i.get("units", 0) for i in items)
+            task_budgets[task["id"]] = {
+                "task": task,
+                "items": items,
+                "subtotal": subtotal,
+            }
+
+        indirect_percent = getattr(proposal, 'indirect_percent', 0) or 0
+        indirect_amount = proposal.total_budget * (indirect_percent / 100)
+        total_with_indirect = proposal.total_budget + indirect_amount
+
+        return render_template(
+            "budget.html",
+            proposal=proposal,
+            tasks=proposal.tasks,
+            budget_items=proposal.budget_items,
+            total_budget=proposal.total_budget,
+            task_budgets=task_budgets,
+            indirect_percent=indirect_percent,
+            indirect_amount=indirect_amount,
+            total_with_indirect=total_with_indirect,
+        )
+
+    @app.route("/qualifications/<proposal_id>")
+    def qualifications_tab(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+        return render_template("qualifications.html", proposal=proposal)
+
+    @app.route("/timeline/<proposal_id>")
+    def timeline_tab(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        task_budgets = {}
+        for task in proposal.tasks:
+            items = [b for b in proposal.budget_items if b.get("task_id") == task["id"]]
+            if items:
+                task_budgets[task["id"]] = {
+                    "task": task,
+                    "items": items,
+                }
+
+        from datetime import datetime as _dt
+        try:
+            sd = _dt.strptime(proposal.start_date, "%Y-%m-%d")
+            start_date_month = sd.month
+            start_date_year = sd.year
+        except (ValueError, TypeError):
+            now = _dt.now()
+            start_date_month = now.month
+            start_date_year = now.year
+
+        return render_template(
+            "timeline.html",
+            proposal=proposal,
+            tasks=proposal.tasks,
+            start_date=proposal.start_date,
+            start_date_month=start_date_month,
+            start_date_year=start_date_year,
+            task_budgets=task_budgets,
+        )
+
+    @app.route("/preview/<proposal_id>")
+    def preview_tab(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        indirect_percent = getattr(proposal, 'indirect_percent', 0) or 0
+        indirect_amount = proposal.total_budget * (indirect_percent / 100)
+        total_with_indirect = proposal.total_budget + indirect_amount
+
+        tasks_with_timing = []
+        for t in proposal.tasks:
+            tasks_with_timing.append({
+                "id": t.get("id", ""),
+                "name": t.get("name", ""),
+                "description": t.get("description", ""),
+                "lead_entity": t.get("lead_entity", ""),
+                "start_month": t.get("start_month"),
+                "start_year": t.get("start_year"),
+                "duration_months": t.get("duration_months", 1),
+            })
+
+        budget_with_timing = []
+        timings = proposal.budget_item_timings or {}
+        for item in proposal.budget_items:
+            item_id = item.get("id", "")
+            timing = timings.get(item_id, {})
+            budget_with_timing.append({
+                **item,
+                "start_month": timing.get("start_month"),
+                "start_year": timing.get("start_year"),
+                "duration_months": timing.get("duration_months", 1),
+                "task_id": item.get("task_id", ""),
+            })
+
+        return render_template(
+            "preview.html",
+            proposal=proposal,
+            tasks=tasks_with_timing,
+            budget_items=proposal.budget_items,
+            budget_with_timing=budget_with_timing,
+            total_budget=proposal.total_budget,
+            indirect_percent=indirect_percent,
+            indirect_amount=indirect_amount,
+            total_with_indirect=total_with_indirect,
+        )
+
+    @app.route("/api/task/<proposal_id>", methods=["POST"])
+    def add_task(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        data = request.get_json()
+        task = {
+            "id": __import__("uuid").uuid4().hex[:8],
+            "name": data.get("name", ""),
+            "description": data.get("description", ""),
+            "lead_months": data.get("lead_months", 0),
+            "duration_months": data.get("duration_months", 1),
+        }
+        proposal.tasks.append(task)
+        proposal.save()
+        return jsonify(task), 201
+
+    @app.route("/api/task/<proposal_id>/<task_id>", methods=["DELETE"])
+    def delete_task(proposal_id, task_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        proposal.tasks = [t for t in proposal.tasks if t.get("id") != task_id]
+        proposal.budget_items = [b for b in proposal.budget_items if b.get("task_id") != task_id]
+        proposal.save()
+        return jsonify({"ok": True})
+
+    @app.route("/api/budget/<proposal_id>", methods=["POST"])
+    def add_budget_item(proposal_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        data = request.get_json()
+        item = {
+            "id": __import__("uuid").uuid4().hex[:8],
+            "task_id": data.get("task_id", ""),
+            "name": data.get("name", ""),
+            "cost_per_unit": float(data.get("cost_per_unit", 0)),
+            "units": float(data.get("units", 1)),
+        }
+        proposal.budget_items.append(item)
+        proposal.save()
+        return jsonify(item), 201
+
+    @app.route("/api/budget/<proposal_id>/<item_id>", methods=["DELETE"])
+    def delete_budget_item(proposal_id, item_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        proposal.budget_items = [b for b in proposal.budget_items if b.get("id") != item_id]
+        proposal.save()
+        return jsonify({"ok": True})
+
+    @app.route("/api/budget/<proposal_id>/<item_id>", methods=["PUT"])
+    def update_budget_item(proposal_id, item_id):
+        proposal = Proposal.load(proposal_id)
+        if not proposal:
+            return jsonify({"error": "Not found"}), 404
+
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data"}), 400
+
+        for item in proposal.budget_items:
+            if item.get("id") == item_id:
+                item["task_id"] = data.get("task_id", item.get("task_id", ""))
+                item["name"] = data.get("name", item.get("name", ""))
+                item["cost_per_unit"] = float(data.get("cost_per_unit", item.get("cost_per_unit", 0)))
+                item["units"] = float(data.get("units", item.get("units", 1)))
+                break
+        else:
+            return jsonify({"error": "Item not found"}), 404
+
+        proposal.save()
+        return jsonify({"ok": True})
+
+    return app
+
+
+def run_server():
+    app = create_app()
+    app.run(debug=True, port=5000)
+
+
+if __name__ == "__main__":
+    run_server()

app/models.py

@@ -0,0 +1,115 @@
+import json
+import os
+from dataclasses import dataclass, field, asdict
+from typing import Any
+from datetime import datetime
+import uuid
+
+
+PROPOSALS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "proposals")
+
+
+def ensure_dirs():
+    os.makedirs(PROPOSALS_DIR, exist_ok=True)
+
+
+@dataclass
+class Task:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    name: str = ""
+    description: str = ""
+    budget_items: list = field(default_factory=list)
+    lead_months: int = 0
+    duration_months: int = 1
+
+
+@dataclass
+class BudgetItem:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    task_id: str = ""
+    name: str = ""
+    cost_per_unit: float = 0.0
+    units: float = 1.0
+
+    @property
+    def total_cost(self) -> float:
+        return self.cost_per_unit * self.units
+
+
+@dataclass
+class Proposal:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    title: str = "Untitled Proposal"
+    client_name: str = ""
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    updated_at: str = field(default_factory=lambda: datetime.now().isoformat())
+
+    project_summary: str = ""
+    tasks: list = field(default_factory=list)
+    qualifications: str = ""
+
+    budget_items: list = field(default_factory=list)
+    budget_item_timings: dict = field(default_factory=dict)
+    start_date: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))
+    indirect_percent: float = 0.0
+    timeline_use_days: bool = False
+    timeline_show_budget: bool = False
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Proposal":
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+    def save(self):
+        ensure_dirs()
+        self.updated_at = datetime.now().isoformat()
+        filepath = os.path.join(PROPOSALS_DIR, f"{self.id}.json")
+        with open(filepath, "w") as f:
+            json.dump(self.to_dict(), f, indent=2)
+
+    @classmethod
+    def load(cls, proposal_id: str) -> "Proposal | None":
+        filepath = os.path.join(PROPOSALS_DIR, f"{proposal_id}.json")
+        if not os.path.exists(filepath):
+            return None
+        try:
+            with open(filepath, "r") as f:
+                return cls.from_dict(json.load(f))
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    @classmethod
+    def list_all(cls) -> list:
+        ensure_dirs()
+        proposals = []
+        for filename in sorted(os.listdir(PROPOSALS_DIR)):
+            if filename.endswith(".json"):
+                try:
+                    with open(os.path.join(PROPOSALS_DIR, filename), "r") as f:
+                        data = json.load(f)
+                        proposals.append({
+                            "id": data.get("id", filename.replace(".json", "")),
+                            "title": data.get("title", "Untitled"),
+                            "client_name": data.get("client_name", ""),
+                            "updated_at": data.get("updated_at", ""),
+                        })
+                except (json.JSONDecodeError, OSError):
+                    continue
+        return sorted(proposals, key=lambda x: x["updated_at"], reverse=True)
+
+    @classmethod
+    def delete(cls, proposal_id: str) -> bool:
+        filepath = os.path.join(PROPOSALS_DIR, f"{proposal_id}.json")
+        if os.path.exists(filepath):
+            os.remove(filepath)
+            return True
+        return False
+
+    @property
+    def total_budget(self) -> float:
+        return sum(
+            item.get("cost_per_unit", 0) * item.get("units", 0)
+            for item in self.budget_items
+        )

app/snippets.py

@@ -0,0 +1,135 @@
+import json
+import os
+from flask import Blueprint, render_template, request, jsonify
+
+snippets_bp = Blueprint("snippets", __name__)
+
+SNIPPETS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "snippets")
+CUSTOM_DIR = os.path.join(SNIPPETS_DIR, "custom")
+
+
+def ensure_dirs():
+    os.makedirs(SNIPPETS_DIR, exist_ok=True)
+    os.makedirs(CUSTOM_DIR, exist_ok=True)
+
+
+def load_snippets(filename):
+    filepath = os.path.join(SNIPPETS_DIR, filename)
+    if os.path.exists(filepath):
+        with open(filepath, "r") as f:
+            return json.load(f)
+    return []
+
+
+def save_snippets(filename, data):
+    ensure_dirs()
+    filepath = os.path.join(SNIPPETS_DIR, filename)
+    with open(filepath, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+def load_custom_snippets():
+    ensure_dirs()
+    snippets = []
+    for filename in sorted(os.listdir(CUSTOM_DIR)):
+        if filename.endswith(".json"):
+            with open(os.path.join(CUSTOM_DIR, filename), "r") as f:
+                snippets.append(json.load(f))
+    return snippets
+
+
+@snippets_bp.route("/snippets")
+def get_all_snippets():
+    return jsonify({
+        "organization": load_snippets("organization.json"),
+        "deliverables": load_snippets("deliverables.json"),
+        "custom": load_custom_snippets(),
+    })
+
+
+@snippets_bp.route("/snippets/<category>", methods=["POST"])
+def add_snippet(category):
+    data = request.get_json()
+    if not data or "title" not in data or "content" not in data:
+        return jsonify({"error": "title and content required"}), 400
+
+    snippet = {
+        "id": data.get("id", __import__("uuid").uuid4().hex[:8]),
+        "title": data["title"],
+        "content": data["content"],
+        "category": category,
+    }
+
+    if category == "custom":
+        ensure_dirs()
+        filepath = os.path.join(CUSTOM_DIR, f"{snippet['id']}.json")
+        with open(filepath, "w") as f:
+            json.dump(snippet, f, indent=2)
+    elif category in ("organization", "deliverables"):
+        snippets = load_snippets(f"{category}.json")
+        snippets.append(snippet)
+        save_snippets(f"{category}.json", snippets)
+    else:
+        return jsonify({"error": "Invalid category"}), 400
+
+    return jsonify(snippet), 201
+
+
+@snippets_bp.route("/snippets/<category>/<snippet_id>", methods=["DELETE"])
+def delete_snippet(category, snippet_id):
+    if category == "custom":
+        filepath = os.path.join(CUSTOM_DIR, f"{snippet_id}.json")
+        if os.path.exists(filepath):
+            os.remove(filepath)
+            return jsonify({"ok": True})
+    elif category in ("organization", "deliverables"):
+        snippets = load_snippets(f"{category}.json")
+        snippets = [s for s in snippets if s.get("id") != snippet_id]
+        save_snippets(f"{category}.json", snippets)
+        return jsonify({"ok": True})
+
+    return jsonify({"error": "Not found"}), 404
+
+
+@snippets_bp.route("/snippets/import", methods=["POST"])
+def import_snippet():
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided"}), 400
+
+    file = request.files["file"]
+    if not file.filename:
+        return jsonify({"error": "No file selected"}), 400
+
+    filename = file.filename.lower()
+    title = request.form.get("title", "").strip()
+    if not title:
+        title = os.path.splitext(file.filename)[0]
+
+    try:
+        if filename.endswith(".md") or filename.endswith(".markdown") or filename.endswith(".txt"):
+            content = file.read().decode("utf-8")
+        elif filename.endswith(".docx"):
+            from docx import Document
+            doc = Document(file)
+            content = "\n\n".join(p.text for p in doc.paragraphs if p.text.strip())
+        else:
+            return jsonify({"error": "Unsupported file type. Use .md, .txt, or .docx"}), 400
+    except Exception as e:
+        return jsonify({"error": f"Failed to read file: {str(e)}"}), 400
+
+    if not content.strip():
+        return jsonify({"error": "File is empty"}), 400
+
+    snippet = {
+        "id": __import__("uuid").uuid4().hex[:8],
+        "title": title,
+        "content": content,
+        "category": "custom",
+    }
+
+    ensure_dirs()
+    filepath = os.path.join(CUSTOM_DIR, f"{snippet['id']}.json")
+    with open(filepath, "w") as f:
+        json.dump(snippet, f, indent=2)
+
+    return jsonify(snippet), 201

propongo2-0.1.1.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: propongo2
+Version: 0.1.1
+Summary: A local proposal generator for conservation and natural resource projects
+Author: VR Conservation
+License: MIT
+Project-URL: Repository, https://github.com/VRConservation/propongo2
+Keywords: proposal,generator,conservation,budget,scope
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: flask>=3.0
+Requires-Dist: weasyprint>=60.0
+Requires-Dist: markdown>=3.5
+Requires-Dist: python-docx>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: bump2version>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+
+# Propongo 2
+
+A local proposal generator for conservation and natural resource projects. Create professional proposals with scope of work, budgets, qualifications, timelines, and export to PDF or HTML.
+
+## Features
+
+- **Scope of Work** - Define project summary, tasks, and deliverables
+- **Budget** - Line-item budgeting with cost/unit calculations and totals
+- **Qualifications** - Document team background and relevant experience
+- **Timeline** - Set lead times and durations per task with Gantt chart visualization
+- **Preview** - View the complete proposal before exporting
+- **PDF Export** - Clean, professional PDF output via WeasyPrint
+- **HTML Export** - Standalone HTML file with embedded styles
+- **Snippet Library** - Reusable markdown components for organization descriptions, deliverable templates, and custom content
+- **Save/Load** - Proposals stored as JSON files on disk, no database required
+
+## Quick Start
+
+### Install from PyPI
+
+```bash
+pip install propongo2
+```
+
+### Run
+
+```bash
+propongo2
+```
+
+Opens at [http://localhost:5000](http://localhost:5000)
+
+### Install from source
+
+```bash
+git clone https://github.com/VRConservation/propongo2.git
+cd propongo2
+pip install -e .
+propongo2
+```
+
+### Development setup
+
+```bash
+git clone https://github.com/VRConservation/propongo2.git
+cd propongo2
+pip install -e ".[dev]"
+python run.py
+```
+
+## Usage
+
+### Creating a Proposal
+
+1. Click **New Proposal** from the dashboard
+2. Enter a title and optional client name in the header
+3. Work through each tab:
+
+   **Scope** - Add a project summary, then create tasks/deliverables with descriptions
+
+   **Budget** - Select a task, enter line items with cost per unit and quantities. Totals calculate automatically.
+
+   **Qualifications** - Describe your organization's background and why you're qualified for this project
+
+   **Timeline** - Set project start date, configure lead times and durations per task, then view the Gantt chart
+
+   **Preview** - Review the complete proposal before exporting
+
+### Using Snippets
+
+Click the sidebar icon (☰) to open the snippet library:
+
+- **Organization** - Pre-written organization descriptions
+- **Deliverables** - Templates for common deliverable types (surveys, assessments, plans)
+- **Custom** - Create and save your own reusable snippets
+
+Click a snippet to insert it at the cursor position in any text field.
+
+### Exporting
+
+- **PDF** - Click "Export PDF" to generate a clean, professional PDF document
+- **HTML** - Click "Export HTML" to download a standalone HTML file
+- **Print** - Use Ctrl+P / Cmd+P in the Preview tab for browser printing
+
+### Managing Proposals
+
+- Proposals auto-save as you work
+- Click "Proposals" in the header to see all saved proposals
+- Create, edit, or delete proposals from the dashboard
+
+## Updating
+
+### From PyPI
+
+```bash
+pip install --upgrade propongo2
+```
+
+### From source
+
+```bash
+cd propongo2
+git pull
+pip install -e .
+```
+
+## Development
+
+### Run tests
+
+```bash
+pytest
+```
+
+### Bump version
+
+```bash
+bump2version patch   # 0.1.0 -> 0.1.1
+bump2version minor   # 0.1.1 -> 0.2.0
+bump2version major   # 0.2.0 -> 1.0.0
+```
+
+### Publish to PyPI
+
+```bash
+python -m build
+twine upload dist/*
+```
+
+## Project Structure
+
+```
+propongo2/
+├── run.py                      # Dev entry point
+├── pyproject.toml              # Package config
+├── requirements.txt            # Dependencies
+├── app/
+│   ├── __init__.py             # Version
+│   ├── main.py                 # Flask app + routes
+│   ├── models.py               # Proposal data model
+│   ├── export.py               # PDF/HTML export
+│   ├── snippets.py             # Snippet management
+│   ├── templates/              # Jinja2 templates
+│   │   ├── base.html           # Layout + HTMX
+│   │   ├── index.html          # Proposal dashboard
+│   │   ├── scope.html          # Scope editor
+│   │   ├── budget.html         # Budget editor
+│   │   ├── qualifications.html # Qualifications editor
+│   │   ├── timeline.html       # Timeline + Gantt
+│   │   ├── preview.html        # Proposal preview
+│   │   └── export_proposal.html# PDF export template
+│   ├── static/
+│   │   ├── css/style.css       # All styles
+│   │   └── js/
+│   │       ├── app.js          # Core JS + HTMX helpers
+│   │       ├── budget.js       # Budget calculations
+│   │       ├── gantt.js        # Gantt chart rendering
+│   │       └── snippets.js     # Snippet panel logic
+│   ├── snippets/               # Stock snippet data
+│   │   ├── organization.json
+│   │   ├── deliverables.json
+│   │   └── custom/             # User-created snippets
+│   └── data/
+│       └── proposals/          # Saved proposals (JSON)
+└── tests/
+    ├── test_main.py
+    └── test_export.py
+```
+
+## Tech Stack
+
+- **Backend:** Python, Flask
+- **Frontend:** HTMX, Jinja2, vanilla CSS/JS
+- **PDF Export:** WeasyPrint
+- **Packaging:** pyproject.toml, setuptools
+
+## License
+
+MIT

propongo2-0.1.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+app/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+app/export.py,sha256=huJVrU94Unz3SVt4_-PkpXfCqw-dMl51BYZXzHo_he0,3369
+app/main.py,sha256=Hv3lD3YH3lAls880HYoxX61-WpBnTgD0Xy6SruKOj4o,16696
+app/models.py,sha256=Rm6yO3I8aVldCpf5rpiAam5Sr1uQE1IDk5DqSQ_7MR4,3717
+app/snippets.py,sha256=xqpeBCdXgzoQF8-f6DoesKMx7j9R3-_zVJFkMAfnNWg,4326
+propongo2-0.1.1.dist-info/METADATA,sha256=i5m7E57y_S4XCsnTafjyh5u7u6htM92dm5TsuEK2XRI,6214
+propongo2-0.1.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+propongo2-0.1.1.dist-info/entry_points.txt,sha256=o8nCinh0OGxLIha2dFmQwaNyB_3sUMv-PRgr5eUYlWM,50
+propongo2-0.1.1.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+propongo2-0.1.1.dist-info/RECORD,,

propongo2-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

propongo2-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+propongo2 = app.main:run_server

propongo2-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+app