interview-coach-cli 0.3.0__py3-none-any.whl

templates.py

@@ -0,0 +1,276 @@
+"""
+Interview / conversation template library.
+
+Each template ships a system prompt with `{name}`, `{background}`, etc. slots
+that get filled from the active user profile at runtime.
+
+Ship-defaults cover the top commercial use cases. Users can add their own
+via `interview-recorder --add-template`.
+"""
+from __future__ import annotations
+
+
+TEMPLATES: dict[str, dict] = {
+    "academic-phd": {
+        "label": "Academic / PhD interview",
+        "system_prompt": """You are a coach helping {name} ({pronouns}) navigate a live PhD or academic-research interview.
+
+BACKGROUND
+{background}
+
+TARGET
+{target_role}
+
+STRENGTHS TO LEAN ON
+{strengths}
+
+WEAKNESSES TO DEFUSE
+{weaknesses}
+
+ADDITIONAL CONTEXT
+{extra_context}
+
+Each user message is tagged with who spoke:
+  [INTERVIEWER said] ... = the interviewer's words — answer this
+  [USER said] ...        = {name}'s own words during the call — remember but don't re-answer
+  [HEARD] ...            = ambiguous — infer from context
+
+Reply using EXACTLY this three-section format:
+
+SAY:
+<Exact words {name} should speak. Natural, under 90 seconds, no meta.>
+
+ANALYSIS:
+<Hidden traps, subtext, what the interviewer really wants.>
+
+WHY:
+<One or two sentences on why this framing works.>""",
+    },
+
+    "tech-interview": {
+        "label": "Software engineering interview",
+        "system_prompt": """You coach {name} ({pronouns}) through a live software-engineering interview (behavioral, system-design, or coding-explanation).
+
+BACKGROUND
+{background}
+
+TARGET ROLE
+{target_role}
+
+STRENGTHS
+{strengths}
+
+WEAKNESSES
+{weaknesses}
+
+CONTEXT
+{extra_context}
+
+Tags in the conversation:
+  [INTERVIEWER said] ... = the interviewer — answer this
+  [USER said] ...        = {name} — remember, don't re-answer
+  [HEARD] ...            = ambiguous
+
+For behavioral questions, use STAR structure (Situation, Task, Action, Result).
+For system-design, name the constraints out loud before diving in.
+For coding, narrate the approach before the code.
+
+Reply in this exact format:
+
+SAY:
+<Exact words to speak. Concise, structured, natural.>
+
+ANALYSIS:
+<What the interviewer is really testing (comms, depth, red-flag detection).>
+
+WHY:
+<One-line justification for the framing choice.>""",
+    },
+
+    "product-management": {
+        "label": "Product / PM interview",
+        "system_prompt": """You coach {name} ({pronouns}) through a product-management interview (product-sense, execution, strategy, or estimation).
+
+BACKGROUND
+{background}
+
+TARGET ROLE
+{target_role}
+
+STRENGTHS
+{strengths}
+
+WEAKNESSES
+{weaknesses}
+
+CONTEXT
+{extra_context}
+
+Tags:
+  [INTERVIEWER said] ... = interviewer
+  [USER said] ...        = {name} (remember, don't re-answer)
+  [HEARD] ...            = ambiguous
+
+Frameworks to reach for:
+  - Product-sense: CIRCLES or persona → pain → solution → metric
+  - Execution: define success metric first
+  - Strategy: market → position → moat
+  - Estimation: state assumptions explicitly
+
+Reply format:
+
+SAY:
+<Words to speak. Lead with structure ("Let me break this into three parts...").>
+
+ANALYSIS:
+<What the interviewer is testing; likely follow-ups.>
+
+WHY:
+<Why this framing wins.>""",
+    },
+
+    "sales-discovery": {
+        "label": "Sales / discovery call",
+        "system_prompt": """You coach {name} ({pronouns}) through a live sales discovery or customer call.
+
+BACKGROUND
+{background}
+
+TARGET OUTCOME
+{target_role}
+
+STRENGTHS
+{strengths}
+
+WEAKNESSES
+{weaknesses}
+
+CONTEXT
+{extra_context}
+
+Tags:
+  [PROSPECT said] ... = the prospect — respond to this
+  [USER said] ...     = {name} — remember, don't re-answer
+  [HEARD] ...         = ambiguous
+
+Note: substitute [PROSPECT said] wherever you see [INTERVIEWER said].
+
+Reply format:
+
+SAY:
+<Words to speak. Discovery-style: acknowledge → mirror pain → open-ended follow-up.>
+
+ANALYSIS:
+<Buying signal? Objection? Where in the funnel?>
+
+WHY:
+<Why this move advances the deal.>""",
+    },
+
+    "medical-residency": {
+        "label": "Medical residency / clinical interview",
+        "system_prompt": """You coach {name} ({pronouns}) through a residency, fellowship, or clinical-position interview.
+
+BACKGROUND
+{background}
+
+TARGET PROGRAM
+{target_role}
+
+STRENGTHS
+{strengths}
+
+WEAKNESSES
+{weaknesses}
+
+CONTEXT
+{extra_context}
+
+Tags:
+  [INTERVIEWER said] ... = interviewer
+  [USER said] ...        = {name} — context, don't re-answer
+
+Reply format:
+
+SAY:
+<Words to speak. Weave clinical experience, empathy, and program-fit into every answer.>
+
+ANALYSIS:
+<What the interviewer is screening for; red flags to avoid.>
+
+WHY:
+<Why this framing lands.>""",
+    },
+
+    "general": {
+        "label": "General voice assistant",
+        "system_prompt": """You are a helpful voice assistant for {name} ({pronouns}).
+
+BACKGROUND
+{background}
+
+CONTEXT
+{extra_context}
+
+Reply in three sections:
+
+SAY:
+<Direct spoken answer.>
+
+ANALYSIS:
+<Reasoning or caveats.>
+
+WHY:
+<One-line justification.>""",
+    },
+}
+
+
+def get_template(template_id: str) -> dict:
+    if template_id not in TEMPLATES:
+        raise ValueError(f"Unknown template: {template_id}")
+    return TEMPLATES[template_id]
+
+
+def render_prompt(template_id: str, profile: dict, plan: dict | None = None) -> str:
+    tpl = get_template(template_id)
+    fields = {
+        "name": profile.get("name") or "the user",
+        "pronouns": profile.get("pronouns") or "they/them",
+        "background": profile.get("background") or "(not specified)",
+        "target_role": profile.get("target_role") or "(not specified)",
+        "strengths": profile.get("strengths") or "(not specified)",
+        "weaknesses": profile.get("weaknesses") or "(not specified)",
+        "extra_context": profile.get("extra_context") or "(none)",
+    }
+    base = tpl["system_prompt"].format(**fields)
+
+    if plan:
+        from meeting_plans import render_plan_for_prompt
+        plan_block = render_plan_for_prompt(plan)
+        addendum = f"""
+
+════════════════════════════════════════════════════════
+  MEETING-SPECIFIC PLAN — treat this as HIGH-PRIORITY context.
+════════════════════════════════════════════════════════
+
+{plan_block}
+
+════════════════════════════════════════════════════════
+
+WHEN THE PLAN IS ACTIVE, your SAY / ANALYSIS / WHY response should:
+  • Reference the section of the plan the turn belongs to when it fits
+    (e.g. "This is the moment for [Section 4 — How AI fits]").
+  • Point out when {fields['name']} is about to walk into a listed trap.
+  • Note if a listed question hasn't been asked yet and this is a chance.
+  • Note if a listed commitment can be secured in this turn.
+  • Nudge the conversation toward the next section when the current one
+    is winding down.
+"""
+        base = base + addendum
+
+    return base
+
+
+def list_template_choices() -> list[tuple[str, str]]:
+    return [(tid, t["label"]) for tid, t in TEMPLATES.items()]

transcriber.py

@@ -0,0 +1,12 @@
+"""Backwards-compat shim — real logic is in transcribers.py."""
+import numpy as np
+from transcribers import transcribe as _dispatch, preload_local
+
+
+def load_model(size: str = "base"):
+    preload_local(size)
+
+
+def transcribe(audio: np.ndarray, model_size: str = "base",
+               provider: str = "local") -> str:
+    return _dispatch(audio, provider=provider, model=model_size)

transcribers.py

@@ -0,0 +1,161 @@
+"""
+Multi-provider speech-to-text dispatch.
+
+Each transcriber exposes:
+    transcribe(audio: np.ndarray, model: str) -> str
+
+`audio` is a float32 mono numpy array at 16 kHz (what Whisper expects and what
+`recorder.py` produces). Cloud providers get it re-encoded to WAV bytes.
+
+Supported:
+    - local       (openai-whisper, offline, no key)
+    - groq        (Whisper on Groq LPU — very fast, cheap)
+    - openai      (Whisper-1 + GPT-4o transcribe family)
+    - deepgram    (Nova-3, streaming-quality accuracy)
+"""
+from __future__ import annotations
+
+import io
+import os
+import numpy as np
+
+
+SAMPLE_RATE = 16000
+
+
+STT_PROVIDERS = {
+    "local": {
+        "env": None,
+        "models": {
+            "tiny":   "tiny   — <1s latency, low accuracy",
+            "base":   "base   — quick, moderate accuracy",
+            "small":  "small  — recommended for real calls (local)",
+            "medium": "medium — slower, higher accuracy",
+        },
+        "default_model": "small",
+    },
+    "groq": {
+        "env": "GROQ_API_KEY",
+        "models": {
+            "whisper-large-v3-turbo": "Fastest — sub-second on LPU (default)",
+            "whisper-large-v3":       "Highest accuracy, still fast",
+        },
+        "default_model": "whisper-large-v3-turbo",
+        "base_url": "https://api.groq.com/openai/v1",
+    },
+    "openai": {
+        "env": "OPENAI_API_KEY",
+        "models": {
+            "whisper-1":            "Classic Whisper API",
+            "gpt-4o-mini-transcribe": "Newer, cheaper, accurate (default)",
+            "gpt-4o-transcribe":    "Most accurate cloud Whisper",
+        },
+        "default_model": "gpt-4o-mini-transcribe",
+    },
+    "deepgram": {
+        "env": "DEEPGRAM_API_KEY",
+        "models": {
+            "nova-3":  "Fastest + most accurate (default)",
+            "nova-2":  "Prior generation",
+        },
+        "default_model": "nova-3",
+    },
+}
+
+
+def _audio_to_wav_bytes(audio: np.ndarray) -> bytes:
+    import soundfile as sf
+    buf = io.BytesIO()
+    sf.write(buf, audio, SAMPLE_RATE, format="WAV", subtype="PCM_16")
+    return buf.getvalue()
+
+
+# ─── Local Whisper ─────────────────────────────────────────────────────────
+_local_model = None
+_local_size = None
+
+
+def _transcribe_local(audio: np.ndarray, model: str) -> str:
+    global _local_model, _local_size
+    import whisper
+    if _local_model is None or _local_size != model:
+        print(f"  [Loading Whisper {model} model...]")
+        _local_model = whisper.load_model(model)
+        _local_size = model
+        print("  [Model ready]")
+    result = _local_model.transcribe(audio, fp16=False, language="en")
+    return result["text"].strip()
+
+
+# ─── OpenAI-compatible (OpenAI + Groq) ─────────────────────────────────────
+_openai_clients: dict = {}
+
+
+def _transcribe_openai_compat(provider: str, audio: np.ndarray, model: str) -> str:
+    from openai import OpenAI
+    if provider not in _openai_clients:
+        cfg = STT_PROVIDERS[provider]
+        key = os.environ.get(cfg["env"])
+        if not key:
+            raise RuntimeError(f"Missing env var {cfg['env']}")
+        kwargs = {"api_key": key}
+        if "base_url" in cfg:
+            kwargs["base_url"] = cfg["base_url"]
+        _openai_clients[provider] = OpenAI(**kwargs)
+    client = _openai_clients[provider]
+
+    wav = _audio_to_wav_bytes(audio)
+    resp = client.audio.transcriptions.create(
+        model=model,
+        file=("audio.wav", wav, "audio/wav"),
+        language="en",
+    )
+    return resp.text.strip()
+
+
+# ─── Deepgram ──────────────────────────────────────────────────────────────
+def _transcribe_deepgram(audio: np.ndarray, model: str) -> str:
+    import requests
+    key = os.environ.get("DEEPGRAM_API_KEY")
+    if not key:
+        raise RuntimeError("Missing env var DEEPGRAM_API_KEY")
+
+    wav = _audio_to_wav_bytes(audio)
+    resp = requests.post(
+        "https://api.deepgram.com/v1/listen",
+        params={"model": model, "language": "en", "smart_format": "true"},
+        headers={
+            "Authorization": f"Token {key}",
+            "Content-Type": "audio/wav",
+        },
+        data=wav,
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return data["results"]["channels"][0]["alternatives"][0]["transcript"].strip()
+
+
+# ─── Dispatch ──────────────────────────────────────────────────────────────
+def transcribe(audio: np.ndarray, provider: str = "local", model: str = "small") -> str:
+    if audio is None or len(audio) == 0:
+        return ""
+    if provider == "local":
+        return _transcribe_local(audio, model)
+    if provider in ("openai", "groq"):
+        return _transcribe_openai_compat(provider, audio, model)
+    if provider == "deepgram":
+        return _transcribe_deepgram(audio, model)
+    raise ValueError(f"Unknown STT provider: {provider}")
+
+
+def preload_local(model: str):
+    """Warm up the local Whisper model so first turn isn't laggy."""
+    _transcribe_local(np.zeros(SAMPLE_RATE // 10, dtype=np.float32), model)
+
+
+def stt_key_status() -> dict:
+    return {
+        p: (True if cfg["env"] is None else bool(os.environ.get(cfg["env"])))
+        for p, cfg in STT_PROVIDERS.items()
+    }