100% Offline Meeting Transcription In‑Room Speaker Identification Fully Customizable AI Summarization

// ═══════════════════════════════════════════════════════════════════
//  Samurai Scribe — Default Summarization Template (v1.0)
// ═══════════════════════════════════════════════════════════════════
//
//  HOW TO CUSTOMIZE
//  ----------------
//  Everything you'll normally change lives in ZONE 1 below:
//    • The summary itself ... edit the text in `summary_template()` — the
//                             "## " sections are written out inline, so you can
//                             reword, add, remove, or reorder them in place.
//    • Long meetings ........ edit `chunk_instruction()` (per-part notes).
//    • The title ............ edit `title_instruction()`.
//    • Model temperature .... edit the TEMPERATURE constant.
//
//  ZONE 2 ("THE ENGINE") runs the pipeline — chunking long meetings, cleanup,
//  and titling. You can read it, but you rarely need to touch it.
//
//  (Tip: Rhai functions can't read outside variables, so the editable text is
//  wrapped in small functions that just `return` a string. Edit inside them.)
// ═══════════════════════════════════════════════════════════════════


// ═══════════════════════════════════════════════════════════════════
//  ZONE 1 — THE PROMPTS  (this is the part you edit)
// ═══════════════════════════════════════════════════════════════════

// Lower temperature → more consistent, less embellished notes (0.0–1.0).
const TEMPERATURE = 0.3;

// The instructions the model follows to write the notes. This reads top-to-
// bottom like the notes it produces — edit the wording, the sections, or the
// rules directly. To add a section, just write another "## Heading" block.
fn summary_template() {
    `You are a professional meeting-notes writer. Write clear, well-structured meeting notes in Markdown.

Use the sections below, in this order. Include a section ONLY when the meeting actually produced that content — otherwise leave it out entirely (no empty headings, no placeholders):

## Overview
A 2-4 sentence plain-language summary of the meeting's purpose and outcome. Always include this section.

## Discussion
Concise bullet points covering the main topics and key details (names, numbers, dates). Keep each bullet to one idea.

## Decisions
Each concrete decision that was reached, stated plainly. Skip this section if no decisions were made.

## Action Items
One Markdown checkbox per task: - [ ] **Owner** — task. Add a due date only if one was explicitly stated. Skip this section if there are none.

## Open Questions
Genuinely unresolved questions or items deferred to later. Skip this section if there are none.

Rules:
- Begin your reply immediately with the first heading. No title, preamble, or sign-off, and never comment on the notes themselves.
- Never write "None", "N/A", or any empty placeholder under a heading — omit the heading instead.
- Never add meta-commentary about what is missing or implied (e.g. "(no due date stated)"). State only what was actually said.
- Write in neutral third person — no "I", "we", or "you".
- Refer to people by name when the name is known; otherwise use their speaker label.
- Use ONLY what is in the transcript and the user's meeting notes if present. Do not speculate, embellish, or invent facts, dates, numbers, or names. If something is unclear, leave it out.
- Be specific and factual; avoid filler like "various topics were discussed".`
}

// Long meetings are summarized in parts first; this guides each part (the "map"
// step). Its output feeds the final summary, so keep the details.
fn chunk_instruction() {
    `You are taking structured notes on ONE part of a longer meeting. From the transcript segment below, extract the important content as concise Markdown bullet points, preserving:
- key discussion points and concrete details (names, numbers, dates)
- decisions that were made
- action items or commitments (note who owns each)
- open questions or deferred items

Keep the specifics; do not over-condense. Add no introduction or commentary — begin directly with the bullet points.`
}

// How the meeting title is generated from the finished summary.
fn title_instruction() {
    `Create a concise, descriptive title for this meeting in 3 to 6 words based on the summary below.
Output ONLY the title text — no quotes, no labels, no trailing punctuation, no markdown, no words like 'meeting' or 'summary'.`
}


// ═══════════════════════════════════════════════════════════════════
//  ZONE 2 — THE ENGINE  (runs the pipeline; rarely needs editing)
// ═══════════════════════════════════════════════════════════════════

fn run(ctx) {
    // `ctx` is the run; `ctx.meeting` is the meeting it's about. Alias it once
    // so the rest of the script stays terse (ctx.meetings holds all meetings in
    // scope — length 1 today).
    let meeting = ctx.meeting;
    let transcript = meeting.transcript;
    let intermediate = meeting.intermediate;
    let summary = meeting.summary;
    let title = meeting.title;
    let llm = meeting.llm;

    // User notes typed alongside the meeting steer the summary when present.
    let notes_block = build_notes_block(meeting.notes.text);

    // Split long transcripts into chunks that fit ~80% of the context window.
    let chunk_size_chars = llm.context_window * 0.8 * 4;
    if chunk_size_chars <= 0 { chunk_size_chars = 8192; }
    let chunks = chunk_turns(transcript.turns, chunk_size_chars);

    if chunks.len() <= 1 {
        // Short meeting: summarize the whole transcript in one pass.
        llm.write(summary, summary_template() + notes_block + "\n\nTranscript:\n" + transcript.text());
    } else {
        // Long meeting: note each part (map), then synthesize them all (reduce).
        for i in 0..chunks.len() {
            intermediate.append(`## Part ${i + 1} of ${chunks.len()}
`);
            llm.write(intermediate, chunk_instruction() + "\n\nTranscript segment:\n" + chunks[i]);
            intermediate.append("\n\n");
        }
        llm.write(summary, summary_template() + notes_block
            + `

The text below is rough notes from consecutive parts of one meeting (ignore any "Part N" headers — it is all one meeting). Synthesize them into a single cohesive, de-duplicated set of notes that follows the structure above.

Notes:
` + intermediate.text);
    }

    // Drop any empty/placeholder sections the model emitted anyway, then title it.
    summary.text = clean_summary(summary.text);

    // Auto-generate a title from the summary — but never clobber a title the
    // user renamed by hand (meeting.has_custom_title).
    if !meeting.has_custom_title {
        title.text = "";
        llm.write(title, title_instruction() + "\n\nSummary:\n" + summary.text);
    }

    llm.unload();   // free GPU/RAM now rather than waiting for the idle timer
}

// Builds the high-priority steering block from the user's notes ("" if none).
fn build_notes_block(notes) {
    let trimmed = notes;
    trimmed.trim();                 // Rhai trim() mutates in place
    if trimmed == "" { return ""; }
    return `

--- USER'S MEETING NOTES (high priority) ---
${notes}
--- END NOTES ---

Treat the notes above as the user's priorities: ensure every point they raised is addressed and use them to shape the structure and emphasis of the summary. Where the notes and transcript conflict on facts (names, spellings, decisions, numbers), trust the notes.`;
}

// Removes any "## " section whose body is empty or only a placeholder such as
// "None"/"N/A". Non-destructive: text without "## " headings is returned as-is,
// and an empty input returns "".
fn clean_summary(text) {
    let lines = text.split("\n");
    let n = lines.len();
    let out = [];
    let i = 0;
    while i < n {
        let line = lines[i];
        if is_heading(line) {
            // Collect this section's body until the next heading or end.
            let body = [];
            let j = i + 1;
            while j < n {
                if is_heading(lines[j]) { break; }
                body.push(lines[j]);
                j += 1;
            }
            let keep = false;
            for b in body {
                if !is_placeholder_line(b) { keep = true; break; }
            }
            if keep {
                out.push(line);
                for b in body { out.push(b); }
            }
            i = j;
        } else {
            out.push(line);
            i += 1;
        }
    }
    let result = "";
    for k in 0..out.len() {
        if k > 0 { result += "\n"; }
        result += out[k];
    }
    result.trim();          // Rhai trim() mutates in place
    return result;
}

// True when a line is a "## " section heading (tolerant of leading whitespace).
fn is_heading(line) {
    let t = line;
    t.trim();
    return t.starts_with("## ");
}

// True when a line carries no real content (blank, or a placeholder like
// "None", "N/A", "No decisions were made", once bullets/markup are stripped).
fn is_placeholder_line(s) {
    let t = s.to_lower();
    t.trim();
    if t == "" { return true; }
    t.replace("- [ ]", " ");
    t.replace("- [x]", " ");
    t.replace("-", " ");
    t.replace("*", " ");
    t.replace("_", " ");
    t.replace("#", " ");
    t.replace(".", " ");
    t.replace(":", " ");
    t.replace("/", " ");
    t.trim();
    if t == "" { return true; }
    if t == "none" || t == "n a" || t == "na" || t == "nothing" || t == "not applicable" {
        return true;
    }
    if t.contains("no decisions were made") || t.contains("no decisions made")
        || t.contains("no action items") || t.contains("no open questions")
        || t.contains("none mentioned") || t.contains("none noted")
        || t.contains("none identified") || t.contains("none recorded")
        || t.contains("none at this time") {
        return true;
    }
    return false;
}

fn chunk_turns(turns, max_chars) {
    let chunks = [];
    let current = "";

    for i in 0..turns.len() {
        let t = turns[i];
        let line = t.speaker + ": " + t.text + "\n";

        if (current.len() + line.len()) > max_chars && current.len() > 0 {
            chunks.push(current);
            current = "";
        }
        current += line;
    }

    if current.len() > 0 {
        chunks.push(current);
    }
    return chunks;
}

fn filter_turns(turns, speaker_name) {
    let filtered = [];
    for i in 0..turns.len() {
        let t = turns[i];
        if t.speaker == speaker_name {
            filtered.push(t);
        }
    }
    return filtered;
}

// ── Chapter Markers ──────────────────────────────────────────────
// Turns a long recording into timestamped chapters — ready to paste
// into show notes, a YouTube description, or meeting minutes.

const TEMPERATURE = 0.3;

fn chapter_instruction() {
    `Above is a section of a timestamped transcript. List the major
topic changes in it as chapter markers, in chronological order.

STRICT OUTPUT FORMAT — one chapter per line, nothing else, e.g.:
[12:30] Opening banter and news roundup

Rules:
- Copy the [MM:SS] timestamp of the line where each topic starts.
- Title each chapter in 3-7 words.
- One chapter roughly every 5-15 minutes; only genuinely new topics.
- Do NOT summarize, describe, or add headings, notes, or commentary.`
}

fn run(ctx) {
    let meeting = ctx.meeting;
    let llm = meeting.llm;
    let summary = meeting.summary;

    // Timestamped transcript, chunked to fit the context window.
    // (Timestamped lines run ~3 chars per token, so budget conservatively.)
    let stamped = meeting.transcript.text(#{ timestamps: true });
    let chunks = chunk_lines(stamped, llm.context_window * 0.5 * 4);

    summary.text = "## Chapters\n\n";
    for i in 0..chunks.len() {
        llm.write(summary, chapter_instruction()
            + "\n\nTranscript:\n" + chunks[i]);
        summary.append("\n");
    }
    llm.unload();
}

// Split text on line boundaries into chunks of at most max_chars.
fn chunk_lines(text, max_chars) {
    let chunks = [];
    let current = "";
    for line in text.split("\n") {
        if (current.len() + line.len() + 1) > max_chars && current.len() > 0 {
            chunks.push(current);
            current = "";
        }
        current += line + "\n";
    }
    if current.len() > 0 { chunks.push(current); }
    return chunks;
}

// ── Speaker Scorecard ────────────────────────────────────────────
// Talk-time plus a short digest of what each person brought to the
// conversation — who drove which topics, and where they stood.

const TEMPERATURE = 0.3;

fn speaker_instruction(name) {
    `The transcript excerpts below are everything ${name} said in a
longer conversation. In 2-3 tight bullet points, characterize what
this speaker contributed: the topics they drove, positions they took,
and anything they committed to. Neutral third person. Begin directly
with the bullets — no preamble.`
}

fn run(ctx) {
    let meeting = ctx.meeting;
    let transcript = meeting.transcript;
    let llm = meeting.llm;
    let summary = meeting.summary;

    summary.text = "## Speaker Scorecard\n\n";

    let budget = llm.context_window * 3;   // chars of quotes per speaker
    for s in transcript.speaker_stats {
        let pct = s.speaking_percentage.round().to_int();
        summary.append("### " + s.name + " — " + pct + "% of talk time\n");

        let said = "";
        for t in filter_turns(transcript.turns, s.name) {
            if said.len() > budget { break; }
            said += t.text + "\n";
        }
        llm.write(summary, speaker_instruction(s.name)
            + "\n\nWhat they said:\n" + said);
        summary.append("\n\n");
    }
    llm.unload();
}

fn filter_turns(turns, speaker_name) {
    let filtered = [];
    for t in turns {
        if t.speaker == speaker_name { filtered.push(t); }
    }
    return filtered;
}