create-leafmesh 2.2.3__tar.gz → 2.2.6__tar.gz

{create_leafmesh-2.2.3 → create_leafmesh-2.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-leafmesh
-Version: 2.2.3
+Version: 2.2.6
 Summary: Project scaffolding tool for LeafMesh
 License-Expression: MIT
 Requires-Python: >=3.10

{create_leafmesh-2.2.3 → create_leafmesh-2.2.6}/create_leafmesh/__init__.py

@@ -1,3 +1,3 @@
 """create-leafmesh — Project scaffolding tool for LeafMesh."""
 
-__version__ = "2.2.3"
+__version__ = "2.2.6"

{create_leafmesh-2.2.3 → create_leafmesh-2.2.6}/create_leafmesh/cli.py

@@ -232,7 +232,11 @@ def _prompt_template_choice_interactive() -> str:
             label = f"{cat}  ({n} template{'s' if n != 1 else ''})"
             cat_choices.append(questionary.Choice(title=label, value=cat))
         cat_choices.append(questionary.Separator())
-        cat_choices.append(questionary.Choice(title="Quit", value=None))
+        # NOTE: `value=None` causes questionary to fall back to the title
+        # string (treats None as "unset"), which then crashes our
+        # cat_to_items lookup with KeyError: 'Quit'. Use an explicit
+        # sentinel string instead.
+        cat_choices.append(questionary.Choice(title="Quit", value="__quit__"))
 
         chosen_cat = questionary.select(
             "Choose a business area:",
@@ -242,7 +246,7 @@ def _prompt_template_choice_interactive() -> str:
             use_indicator=True,
         ).ask()
 
-        if chosen_cat is None:
+        if chosen_cat is None or chosen_cat == "__quit__":
             print("\n  Cancelled.\n")
             sys.exit(0)
 
@@ -260,7 +264,7 @@ def _prompt_template_choice_interactive() -> str:
         tpl_choices.append(questionary.Separator())
         tpl_choices.append(questionary.Choice(title="← Back to categories",
                                               value="__back__"))
-        tpl_choices.append(questionary.Choice(title="Quit", value=None))
+        tpl_choices.append(questionary.Choice(title="Quit", value="__quit__"))
 
         chosen = questionary.select(
             f"Template in {chosen_cat}:",
@@ -270,7 +274,7 @@ def _prompt_template_choice_interactive() -> str:
             use_indicator=True,
         ).ask()
 
-        if chosen is None:
+        if chosen is None or chosen == "__quit__":
             print("\n  Cancelled.\n")
             sys.exit(0)
         if chosen == "__back__":

create_leafmesh-2.2.6/create_leafmesh/templates/bd-proposals/agency/bid_no_bid_decisioner_agent.py

@@ -0,0 +1,87 @@
+"""bid_no_bid_decisioner_agent — pre-bid go/no-go scorer.
+
+Cheaper-than-bidding triage. LLM scores fit on five axes; deterministic
+threshold maps to bid / qualify-further / no-bid. The hard rule
+underneath: any score below 0.4 OR confidence below 0.5 → mandatory
+partner review. We never silently no-bid a high-confidence customer
+opportunity because the LLM was conservative.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from leafmesh import LeafMeshLogger
+
+logger = LeafMeshLogger(__name__)
+
+
+async def bid_no_bid_decisioner_agent(llm_response, input_data, context):
+    if isinstance(llm_response, str):
+        try:
+            import json
+            llm_response = json.loads(llm_response)
+        except (ValueError, TypeError):
+            llm_response = {}
+    if not isinstance(llm_response, dict):
+        llm_response = {}
+
+    upstream = input_data.get("upstream_yields") or {}
+    rfp_id = str(upstream.get("rfp_id") or input_data.get("rfp_id") or "")
+
+    fit_strategic = float(llm_response.get("fit_strategic") or 0)
+    fit_capability = float(llm_response.get("fit_capability") or 0)
+    fit_economics = float(llm_response.get("fit_economics") or 0)
+    fit_relationship = float(llm_response.get("fit_relationship") or 0)
+    fit_competitive = float(llm_response.get("fit_competitive") or 0)
+    confidence = float(llm_response.get("confidence") or 0)
+
+    overall_score = (
+        fit_strategic * 0.25 + fit_capability * 0.25 +
+        fit_economics * 0.20 + fit_relationship * 0.20 +
+        fit_competitive * 0.10
+    )
+
+    if overall_score >= 0.65 and confidence >= 0.6:
+        recommendation = "bid"
+    elif overall_score >= 0.40:
+        recommendation = "qualify_further"
+    else:
+        recommendation = "no_bid"
+
+    # Mandatory partner review on weak signal — never silently no-bid
+    requires_partner_review = (
+        recommendation == "no_bid" or confidence < 0.5 or overall_score < 0.4
+    )
+
+    risk_flags = list(llm_response.get("risk_flags") or [])
+    win_themes = list(llm_response.get("win_themes") or [])
+
+    briefing = str(llm_response.get("decision_briefing") or "").strip()
+    if not briefing:
+        briefing = (
+            f"RFP {rfp_id}: recommendation={recommendation} "
+            f"(overall {overall_score:.2f}, confidence {confidence:.2f}). "
+            f"{len(risk_flags)} risks, {len(win_themes)} win themes. "
+            f"{'Partner review required.' if requires_partner_review else 'Proceed with kickoff.'}"
+        )
+
+    logger.info(
+        f"[bid-no-bid] {rfp_id} score={overall_score:.2f} "
+        f"conf={confidence:.2f} rec={recommendation}"
+    )
+
+    return {
+        "rfp_id": rfp_id,
+        "fit_strategic": round(fit_strategic, 2),
+        "fit_capability": round(fit_capability, 2),
+        "fit_economics": round(fit_economics, 2),
+        "fit_relationship": round(fit_relationship, 2),
+        "fit_competitive": round(fit_competitive, 2),
+        "overall_score": round(overall_score, 2),
+        "confidence": round(confidence, 2),
+        "recommendation": recommendation,
+        "risk_flags": risk_flags,
+        "win_themes": win_themes,
+        "requires_partner_review": requires_partner_review,
+        "decision_briefing": briefing,
+    }

create_leafmesh-2.2.6/create_leafmesh/templates/bd-proposals/agency/competitor_intel_archive_agent.py

@@ -0,0 +1,136 @@
+"""competitor_intel_archive_agent — real competitor knowledge ledger.
+
+Real SQLite archive (./data/competitor_intel.db) of every observed
+competitor move — pricing, launches, RFP wins, hires. Queryable by
+competitor name + tag.
+
+Two modes:
+  · ingest — record one signal (RSS feed, sales-team submission,
+             win/loss feedback)
+  · query  — return the most relevant rows for a competitor or for
+             a deal under consideration
+
+Production: connect to your real intel store (Crayon, Klue, Notion) —
+same return shape.
+"""
+from __future__ import annotations
+
+import os
+import sqlite3
+import threading
+import uuid
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+from leafmesh import LeafMeshLogger
+
+logger = LeafMeshLogger(__name__)
+
+DB_PATH = Path(os.environ.get("BD_COMPETITOR_DB", "./data/competitor_intel.db"))
+DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+_LOCK = threading.Lock()
+
+
+def _conn() -> sqlite3.Connection:
+    c = sqlite3.connect(str(DB_PATH), timeout=10)
+    c.row_factory = sqlite3.Row
+    return c
+
+
+def _ensure_schema() -> None:
+    with _LOCK, _conn() as c:
+        c.execute("""
+            CREATE TABLE IF NOT EXISTS competitor_signals (
+                signal_id        TEXT PRIMARY KEY,
+                competitor_name  TEXT NOT NULL,
+                signal_kind      TEXT NOT NULL,
+                summary          TEXT NOT NULL,
+                source           TEXT,
+                tags             TEXT,
+                impact_score     REAL,
+                observed_at_utc  TEXT NOT NULL
+            )
+        """)
+        c.execute("CREATE INDEX IF NOT EXISTS idx_comp_ts "
+                  "ON competitor_signals(competitor_name, observed_at_utc)")
+        c.commit()
+
+
+_ensure_schema()
+
+
+async def competitor_intel_archive_agent(
+    llm_response: dict[str, Any] | str | None,
+    input_data: dict[str, Any],
+    context: dict[str, Any],
+) -> dict[str, Any]:
+    mode = str(input_data.get("mode") or "query").lower()
+
+    if mode == "ingest":
+        with _LOCK, _conn() as c:
+            c.execute("""
+                INSERT INTO competitor_signals (signal_id, competitor_name,
+                  signal_kind, summary, source, tags, impact_score,
+                  observed_at_utc)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                f"sig-{uuid.uuid4().hex[:10]}",
+                str(input_data.get("competitor_name") or "unknown"),
+                str(input_data.get("signal_kind") or "general"),
+                str(input_data.get("summary") or ""),
+                str(input_data.get("source") or ""),
+                ",".join(str(t) for t in (input_data.get("tags") or [])),
+                float(input_data.get("impact_score") or 0.5),
+                datetime.now(timezone.utc).isoformat(),
+            ))
+            c.commit()
+
+    # Query mode
+    competitor = str(input_data.get("competitor_name") or "")
+    horizon_days = int(input_data.get("horizon_days") or 180)
+    cutoff = (datetime.now(timezone.utc) - timedelta(days=horizon_days)).isoformat()
+
+    where = "WHERE observed_at_utc>=?"
+    params: tuple[Any, ...] = (cutoff,)
+    if competitor:
+        where += " AND competitor_name=?"
+        params = params + (competitor,)
+
+    with _LOCK, _conn() as c:
+        rows = [dict(r) for r in c.execute(
+            f"SELECT * FROM competitor_signals {where} "
+            f"ORDER BY observed_at_utc DESC LIMIT 25",
+            params,
+        ).fetchall()]
+        # Top competitors by signal-count
+        top_comps = [dict(r) for r in c.execute(
+            "SELECT competitor_name, COUNT(*) AS n, "
+            "AVG(impact_score) AS avg_impact "
+            "FROM competitor_signals WHERE observed_at_utc>=? "
+            "GROUP BY competitor_name ORDER BY n DESC LIMIT 10",
+            (cutoff,),
+        ).fetchall()]
+
+    avg_impact = (sum(r["impact_score"] for r in rows) / len(rows)
+                  if rows else 0.0)
+    high_impact_count = sum(1 for r in rows if r["impact_score"] >= 0.7)
+
+    briefing = (
+        f"{len(rows)} signals in last {horizon_days}d"
+        f"{' for ' + competitor if competitor else ''}. "
+        f"{high_impact_count} high-impact. "
+        f"Top tracked competitor: "
+        f"{top_comps[0]['competitor_name'] if top_comps else 'none'}."
+    )
+
+    return {
+        "mode": mode,
+        "competitor_queried": competitor,
+        "horizon_days": horizon_days,
+        "signals": rows,
+        "top_competitors": top_comps,
+        "avg_impact_score": round(avg_impact, 2),
+        "high_impact_count": high_impact_count,
+        "intel_briefing": briefing,
+    }

{create_leafmesh-2.2.3 → create_leafmesh-2.2.6}/create_leafmesh/templates/bd-proposals/configs/config.yaml

@@ -117,6 +117,18 @@ entry_points:
     target: "rfp_ingester_agent"
     description: "BD-initiated"
 
+  - name: "competitor_signal_ingest"
+    target: "competitor_intel_archive_agent"
+    description: "Record one competitor signal (ingest mode)"
+
+  - name: "competitor_intel_query"
+    target: "competitor_intel_archive_agent"
+    description: "Query competitor intel — by competitor or by horizon"
+
+  - name: "bid_no_bid_review"
+    target: "bid_no_bid_decisioner_agent"
+    description: "Pre-bid go/no-go decisioning on an RFP"
+
   - name: "decision_received"
     target: "win_loss_analyzer_agent"
     description: "RFP decision (won/lost) — produce structured post-mortem"
@@ -129,6 +141,27 @@ entry_points:
     target: "win_loss_analyzer_agent"
     description: "QBR cadence — aggregate win/loss patterns for sales leadership"
 
+
+# ── Direct-call entry points (every non-human, non-terminal
+#    agent is API-addressable; bypasses the upstream chain).
+#    Use for ad-hoc invocation, debugging, programmatic ingest.
+  - name: "direct_call_past_proposal_retriever"
+    target: "past_proposal_retriever_agent"
+    description: "On-demand direct call to past_proposal_retriever (llm) — bypasses upstream chain"
+
+  - name: "direct_call_section_drafter"
+    target: "section_drafter_agent"
+    description: "On-demand direct call to section_drafter (llm) — bypasses upstream chain"
+
+  - name: "direct_call_pricing_configurator"
+    target: "pricing_configurator_agent"
+    description: "On-demand direct call to pricing_configurator (programmatic) — bypasses upstream chain"
+
+  - name: "direct_call_compliance_reviewer"
+    target: "compliance_reviewer_agent"
+    description: "On-demand direct call to compliance_reviewer (llm) — bypasses upstream chain"
+
+
 agents:
 
   rfp_ingester_agent:
@@ -469,3 +502,95 @@ agents:
 
     can_call:
       - agent: "practice_lead_human"
+
+  # ────────────────────────────────────────────────────────────
+  # competitor_intel_archive_agent — competitor knowledge ledger (SQLite)
+  # ────────────────────────────────────────────────────────────
+  competitor_intel_archive_agent:
+    name: "competitor_intel_archive_agent"
+    agent_type: "programmatic"
+    description: "Real SQLite ledger of competitor signals — ingest or query by competitor / horizon"
+    communication_type: "chain"
+    yields:
+      mode: "string"
+      competitor_queried: "string"
+      horizon_days: "number"
+      signals: "list"
+      top_competitors: "list"
+      avg_impact_score: "number"
+      high_impact_count: "number"
+      intel_briefing: "string"
+    inputs:
+      mode: "string"
+      competitor_name: "string"
+      signal_kind: "string"
+      summary: "string"
+      source: "string"
+      tags: "list"
+      impact_score: "number"
+      horizon_days: "number"
+    can_call: []
+
+    auto_store_response: true
+    auto_store_yields: true
+
+  # ────────────────────────────────────────────────────────────
+  # bid_no_bid_decisioner_agent — pre-bid go/no-go scorer (LLM)
+  # ────────────────────────────────────────────────────────────
+  bid_no_bid_decisioner_agent:
+    name: "bid_no_bid_decisioner_agent"
+    agent_type: "llm"
+    description: "Scores RFP fit on 5 axes → bid / qualify further / no-bid; partner review on low confidence"
+    model: "gpt-4o-mini"
+    temperature: 0.1
+    max_tokens: 1500
+    communication_type: "chain"
+
+    prompt: |
+      Score the fit on this RFP. Return JSON with these keys (all
+      required; do not omit any):
+        - fit_strategic: 0..1
+        - fit_capability: 0..1
+        - fit_economics: 0..1 (cost-to-bid vs deal size)
+        - fit_relationship: 0..1 (incumbent or relationship strength)
+        - fit_competitive: 0..1 (likelihood to win vs likely incumbents)
+        - confidence: 0..1 (how confident you are in these scores)
+        - risk_flags: list of objects (kind, note)
+        - win_themes: list of strings (the 3-5 narratives we'd lead with)
+        - decision_briefing: 2-3 sentence narrative for the partner
+
+    enforce_yields: true
+    enforce_yields_retry: 2
+
+    knowledge:
+      serviceName: "mongo_main"
+      enabled: true
+      groupName: "rfp_decision_playbook"
+
+    yields:
+      rfp_id: "string"
+      fit_strategic: "number"
+      fit_capability: "number"
+      fit_economics: "number"
+      fit_relationship: "number"
+      fit_competitive: "number"
+      overall_score: "number"
+      confidence: "number"
+      recommendation: "string"
+      risk_flags: "list"
+      win_themes: "list"
+      requires_partner_review: "boolean"
+      decision_briefing: "string"
+
+    inputs:
+      upstream_yields: "object"
+      rfp_id: "string"
+
+    can_call:
+      - agent: "partner_human"
+        condition: "calling_agent_response.requires_partner_review == true"
+      - agent: "section_drafter_agent"
+        condition: "calling_agent_response.recommendation == 'bid' and calling_agent_response.requires_partner_review == false"
+
+    auto_store_response: true
+    auto_store_yields: true

create_leafmesh-2.2.6/create_leafmesh/templates/bd-proposals/examples/01_new_rfp_received.json

@@ -0,0 +1,13 @@
+{
+  "_entry_point": "manual_action",
+  "_description": "RFP arrives from a regional government \u2014 rfp_ingester extracts key requirements, past_proposal_retriever finds 2 similar prior wins.",
+  "payload": {
+    "rfp_id": "RFP-2026-08813",
+    "client_org": "State Department of Transportation \u2014 Region IV",
+    "received_at_utc": "2026-06-04T11:00:00Z",
+    "deadline_utc": "2026-07-09T17:00:00Z",
+    "practice_area": "infrastructure_advisory",
+    "estimated_value_cents": 95000000,
+    "scope_summary": "Five-year roadmap consulting for I-95 corridor modernisation \u2014 traffic modelling, environmental review, federal funding strategy."
+  }
+}

create_leafmesh-2.2.6/create_leafmesh/templates/bd-proposals/examples/02_win_post_mortem.json

@@ -0,0 +1,23 @@
+{
+  "_entry_point": "decision_received",
+  "_description": "Won the deal \u2014 win_loss_analyzer produces a structured retro: what worked, what almost lost it, who internally championed.",
+  "payload": {
+    "rfp_id": "RFP-2026-07712",
+    "client_org": "Atlantic Power Cooperative",
+    "outcome": "won",
+    "deal_value_cents": 47000000,
+    "competition": [
+      "RivalConsult Group",
+      "GlobalAdvise Partners"
+    ],
+    "win_score": 0.83,
+    "decision_signals": [
+      "incumbent strength",
+      "named partner relationship",
+      "lower price by ~6%"
+    ],
+    "internal_champions": [
+      "partner.singh@example"
+    ]
+  }
+}

create_leafmesh-2.2.6/create_leafmesh/templates/bd-proposals/examples/03_loss_with_competitor.json

@@ -0,0 +1,16 @@
+{
+  "_entry_point": "competitor_takeaway",
+  "_description": "Lost to a known competitor \u2014 focused analysis on price, scope, and timing trade-offs.",
+  "payload": {
+    "rfp_id": "RFP-2026-07734",
+    "client_org": "Midwest Healthcare Alliance",
+    "outcome": "lost",
+    "winning_competitor": "GlobalAdvise Partners",
+    "deal_value_cents": 28500000,
+    "loss_reasons_known": [
+      "winning_bid_price_lower_pct: 14",
+      "incumbent_relationship: 3_years"
+    ],
+    "client_feedback_received": "Quote was strong on methodology; bid was 14% above the winner."
+  }
+}

create_leafmesh-2.2.6/create_leafmesh/templates/bd-proposals/examples/04_quarterly_win_rate.json

@@ -0,0 +1,17 @@
+{
+  "_entry_point": "quarterly_win_rate_review",
+  "_description": "Cadence \u2014 aggregate win/loss across the quarter for sales-leadership review.",
+  "payload": {
+    "review_period": "2026-Q2",
+    "rfp_count": 28,
+    "wins": 9,
+    "losses": 14,
+    "no_decision": 5,
+    "average_deal_size_cents": 38400000,
+    "top_competitors": [
+      "GlobalAdvise Partners",
+      "RivalConsult Group",
+      "Strategy 5"
+    ]
+  }
+}

create_leafmesh-2.2.6/create_leafmesh/templates/bd-proposals/examples/README.md

@@ -0,0 +1,23 @@
+# bd-proposals — example scenarios
+
+Four realistic scenarios that exercise the major paths through this mesh.
+
+## How to run
+
+```bash
+python examples/run_examples.py                 # all scenarios
+python examples/run_examples.py 01_             # one scenario (substring match)
+```
+
+## Scenario map
+
+- **01_new_rfp_received** — `manual_action` — RFP arrives from a regional government — rfp_ingester extracts key requirements, past_proposal_retriever finds 2 similar prior wins.
+- **02_win_post_mortem** — `decision_received` — Won the deal — win_loss_analyzer produces a structured retro: what worked, what almost lost it, who internally championed.
+- **03_loss_with_competitor** — `competitor_takeaway` — Lost to a known competitor — focused analysis on price, scope, and timing trade-offs.
+- **04_quarterly_win_rate** — `quarterly_win_rate_review` — Cadence — aggregate win/loss across the quarter for sales-leadership review.
+
+## Audit trail
+
+Every scenario appends one hash-chained entry to the template's
+`logs/<audit>.jsonl` file. Tail it during a run to see the
+ledger build up across scenarios.

create_leafmesh-2.2.6/create_leafmesh/templates/bd-proposals/examples/run_examples.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Run each example payload end-to-end through this mesh.
+
+Usage:
+    cd <this template's project root>
+    python examples/run_examples.py                 # all scenarios
+    python examples/run_examples.py 01_happy_path   # one scenario
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+# Make agency/ importable
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+# Register the audit connector before SDK start
+import agency._shared.audit_logger  # noqa: F401
+
+from leafmesh import LeafMesh, LeafMeshLogger
+
+logger = LeafMeshLogger(__name__)
+EXAMPLES_DIR = Path(__file__).parent
+
+
+async def run_scenario(sdk: LeafMesh, scenario_path: Path) -> None:
+    scenario = scenario_path.stem
+    payload = json.loads(scenario_path.read_text())
+    entry_point = payload.pop("_entry_point", "manual_action")
+    description = payload.pop("_description", "")
+    print()
+    print("=" * 78)
+    print(f"  SCENARIO: {scenario}")
+    print(f"  ENTRY:    {entry_point}")
+    if description:
+        print(f"  WHAT:     {description}")
+    print("=" * 78)
+    session_id = f"example-{scenario}"
+    try:
+        result = await asyncio.wait_for(
+            sdk.mesh_call(entry_point, payload, session_id=session_id),
+            timeout=120,
+        )
+        print(f"\n  → result type: {type(result).__name__}")
+        try:
+            print(f"  → result: {json.dumps(result, indent=2, default=str)[:600]}")
+        except Exception:
+            print(f"  → result (repr): {repr(result)[:400]}")
+    except asyncio.TimeoutError:
+        print(f"\n  ✗ TIMED OUT after 120s — the chain may have stalled at HITL.")
+        print(f"    Check logs/<audit>.jsonl and any HITL queue for pending requests.")
+    except Exception as e:
+        print(f"\n  ✗ ERROR: {type(e).__name__}: {e}")
+
+
+async def main() -> int:
+    pattern = sys.argv[1] if len(sys.argv) > 1 else None
+    scenarios = sorted(EXAMPLES_DIR.glob("*.json"))
+    if pattern:
+        scenarios = [s for s in scenarios if pattern in s.stem]
+    if not scenarios:
+        print("No scenarios matched.")
+        return 1
+
+    sdk = LeafMesh.from_yaml("configs/config.yaml")
+    await sdk.start()
+    try:
+        for scenario_path in scenarios:
+            await run_scenario(sdk, scenario_path)
+            await asyncio.sleep(2)  # let async chain settle between scenarios
+    finally:
+        await sdk.stop()
+    print()
+    print("=" * 78)
+    print(f"  Done — ran {len(scenarios)} scenario(s).")
+    print("  Audit trail: check logs/*.jsonl for the hash-chained record.")
+    print("=" * 78)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))