samuraizer 0.0.1

package/dist/pipeline/analysis/decisions/generate.js

@@ -0,0 +1,101 @@
+import { writeFile } from "node:fs/promises";
+import z from "zod";
+import { callOllama } from "../../../lib/ollama.js";
+const decisionItemSchema = z.object({
+    text: z.string().min(1),
+});
+const decisionsResponseSchema = z.object({
+    items: z.array(decisionItemSchema),
+});
+const decisionsJsonSchema = {
+    type: "object",
+    properties: {
+        items: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    text: { type: "string" },
+                },
+                required: ["text"],
+                additionalProperties: false,
+            },
+        },
+    },
+    required: ["items"],
+    additionalProperties: false,
+};
+export async function generateDecisionsWithOllama({ transcript, model, decisionsTextPath, sourceTranscriptPath, }) {
+    const prompt = buildDecisionsPrompt(transcript);
+    const rawText = await callOllama({ model, prompt, format: decisionsJsonSchema, temperature: 0 });
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(rawText);
+    }
+    catch {
+        throw new Error(`Failed to parse decisions JSON.\nRaw response:\n${rawText}`);
+    }
+    parsedJson = normalizeDecisionsJson(parsedJson);
+    const validated = decisionsResponseSchema.safeParse(parsedJson);
+    if (!validated.success) {
+        throw new Error(`Decisions JSON does not match schema.\n${validated.error.message}\nRaw response:\n${rawText}`);
+    }
+    const items = validated.data.items.filter((item) => item.text.trim().length > 0);
+    await writeFile(decisionsTextPath, toDecisionsText(items), "utf-8");
+    return { items, model, sourceTranscriptPath, createdAt: new Date().toISOString() };
+}
+function buildDecisionsPrompt(transcript) {
+    return `
+Extract only final decisions from the meeting transcript.
+
+Return ONLY valid JSON.
+Do not return markdown.
+Do not return explanations.
+Do not return prose.
+Do not return keys other than "items".
+
+Expected format:
+{
+  "items": [
+    { "text": "Decision 1" },
+    { "text": "Decision 2" }
+  ]
+}
+
+Rules:
+- Include only decisions that were actually agreed or confirmed.
+- Do not include action items.
+- Do not include discussion points.
+- Do not include open questions.
+- If there are no decisions, return exactly:
+{"items":[]}
+
+Transcript:
+${transcript}
+`.trim();
+}
+function toDecisionsText(items) {
+    if (items.length === 0)
+        return "No decisions found.";
+    return items.map((item) => `- ${item.text}`).join("\n");
+}
+function normalizeDecisionsJson(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error(`Decisions response is not an object: ${JSON.stringify(input)}`);
+    }
+    const obj = input;
+    if (!("items" in obj)) {
+        throw new Error(`Decisions response does not contain "items".\nRaw parsed JSON:\n${JSON.stringify(input, null, 2)}`);
+    }
+    if (!Array.isArray(obj.items)) {
+        throw new Error(`Decisions field "items" is not an array.\nRaw parsed JSON:\n${JSON.stringify(input, null, 2)}`);
+    }
+    return {
+        items: obj.items.map((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                return { text: "" };
+            const i = item;
+            return { text: typeof i.text === "string" ? i.text : "" };
+        }),
+    };
+}

package/dist/pipeline/analysis/decisions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/analysis/summary/generate.js

@@ -0,0 +1,24 @@
+import { writeFile } from "node:fs/promises";
+import { callOllama } from "../../../lib/ollama.js";
+export async function generateSummaryWithOllama({ transcript, model, summaryTextPath, sourceTranscriptPath, }) {
+    const prompt = buildSummaryPrompt(transcript);
+    const summaryText = await callOllama({ model, prompt });
+    await writeFile(summaryTextPath, summaryText, "utf-8");
+    return {
+        summary: summaryText,
+        model,
+        sourceTranscriptPath,
+        createdAt: new Date().toISOString(),
+    };
+}
+export function buildSummaryPrompt(transcript) {
+    return [
+        "You are an assistant that summarizes meeting transcripts.",
+        "Write a concise and clear summary of the conversation.",
+        "Focus on the main discussion points, important context, and outcomes.",
+        "Do not invent facts that are not present in the transcript.",
+        "Keep the summary readable and structured as plain text.",
+        "Transcript:",
+        transcript,
+    ].join("\n");
+}

package/dist/pipeline/analysis/summary/types.js

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/audio/normalize.js

@@ -0,0 +1,11 @@
+import { runCommand } from "../../lib/run-command.js";
+export async function normalizeAudio({ inputPath, outputPath, ffmpegCommand }) {
+    const args = ["-y", "-i", inputPath, "-ac", "1", "-ar", "16000", "-c:a", "pcm_s16le", outputPath];
+    try {
+        await runCommand(ffmpegCommand, args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown ffmpeg error";
+        throw new Error(`Failed to normalize audio: ${message}`);
+    }
+}

package/dist/pipeline/audio/probe.js

@@ -0,0 +1,37 @@
+import { runCommand } from "../../lib/run-command.js";
+export async function probeAudio(filePath, ffprobeCommand) {
+    const args = ["-v", "error", "-print_format", "json", "-show_format", "-show_streams", filePath];
+    let stdout;
+    try {
+        const result = await runCommand(ffprobeCommand, args);
+        stdout = result.stdout;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown ffprobe error";
+        throw new Error(`Failed to probe audio metadata.\n${message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error("Failed to parse ffprobe JSON output.");
+    }
+    const audioStream = parsed.streams?.find((s) => s.codec_type === "audio");
+    return {
+        filePath,
+        formatName: parsed.format?.format_name,
+        durationSec: toNumber(parsed.format?.duration),
+        sizeBytes: toNumber(parsed.format?.size),
+        bitRate: toNumber(parsed.format?.bit_rate),
+        sampleRate: toNumber(audioStream?.sample_rate),
+        channels: audioStream?.channels,
+        codecName: audioStream?.codec_name,
+    };
+}
+function toNumber(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

package/dist/pipeline/audio/validate-input.js

@@ -0,0 +1,46 @@
+import { access, stat } from "node:fs/promises";
+import path from "node:path";
+import { constants } from "node:fs";
+export const SUPPORTED_AUDIO_EXTENSIONS = [
+    ".mp3",
+    ".wav",
+    ".ogg",
+    ".flac",
+    ".m4a",
+    ".mp4",
+    ".aac",
+];
+export async function validateInputFile(inputPath) {
+    if (!inputPath || !inputPath.trim())
+        throw new Error("No input file provided.");
+    const resolvedPath = path.resolve(inputPath);
+    const extension = path.extname(resolvedPath).toLowerCase();
+    if (!isSupportedExtension(extension)) {
+        throw new Error([
+            `Unsupported file format: ${extension || "(no extension)"}`,
+            `Supported formats: ${SUPPORTED_AUDIO_EXTENSIONS.join(", ")}`,
+        ].join("\n"));
+    }
+    try {
+        await access(resolvedPath, constants.F_OK);
+    }
+    catch {
+        throw new Error(`File does not exist: ${resolvedPath}`);
+    }
+    try {
+        await stat(resolvedPath);
+    }
+    catch {
+        throw new Error(`Path is not a file: ${resolvedPath}`);
+    }
+    return {
+        inputPath,
+        resolvedPath,
+        fileName: path.basename(resolvedPath),
+        baseName: path.basename(resolvedPath, extension),
+        extension,
+    };
+}
+function isSupportedExtension(extension) {
+    return SUPPORTED_AUDIO_EXTENSIONS.includes(extension);
+}

package/dist/pipeline/output/paths.js

@@ -0,0 +1,19 @@
+import path from "node:path";
+export function buildOutputPaths(inputFile, outputRootDir = path.resolve("output")) {
+    const runDir = path.join(outputRootDir, inputFile.baseName);
+    return {
+        outputRootDir,
+        runDir,
+        metaFilePath: path.join(runDir, "meta.json"),
+        normalizedAudioPath: path.join(runDir, "normalized.wav"),
+        transcriptTextPath: path.join(runDir, "transcript.txt"),
+        transcriptJsonPath: path.join(runDir, "transcript.json"),
+        summaryTextPath: path.join(runDir, "summary.txt"),
+        summaryJsonPath: path.join(runDir, "summary.json"),
+        actionItemsTextPath: path.join(runDir, "action-items.txt"),
+        actionItemsJsonPath: path.join(runDir, "action-items.json"),
+        decisionsTextPath: path.join(runDir, "decisions.txt"),
+        decisionsJsonPath: path.join(runDir, "decisions.json"),
+        reportMarkdownPath: path.join(runDir, "report.md"),
+    };
+}

package/dist/pipeline/output/prepare.js

@@ -0,0 +1,22 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { buildOutputPaths } from "./paths.js";
+export async function prepareOutput(inputFile, outputRootDir) {
+    const paths = buildOutputPaths(inputFile, outputRootDir);
+    await mkdir(paths.runDir, { recursive: true });
+    const meta = {
+        createdAt: new Date().toISOString(),
+        input: {
+            originalPath: inputFile.inputPath,
+            resolvedPath: inputFile.resolvedPath,
+            fileName: inputFile.fileName,
+            baseName: inputFile.baseName,
+            extension: inputFile.extension,
+        },
+        output: {
+            runDir: paths.runDir,
+        },
+        status: "initialized",
+    };
+    await writeFile(paths.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
+    return { paths, meta };
+}

package/dist/pipeline/output/save.js

@@ -0,0 +1,16 @@
+import { writeFile } from "node:fs/promises";
+export async function saveTranscript(path, transcript) {
+    await writeFile(path, JSON.stringify(transcript, null, 2), "utf-8");
+}
+export async function saveSummary(path, summary) {
+    await writeFile(path, JSON.stringify(summary, null, 2), "utf-8");
+}
+export async function saveActionItems(path, actionItems) {
+    await writeFile(path, JSON.stringify(actionItems, null, 2), "utf-8");
+}
+export async function saveDecisions(path, decisions) {
+    await writeFile(path, JSON.stringify(decisions, null, 2), "utf-8");
+}
+export async function saveMeta(paths, meta) {
+    await writeFile(paths.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
+}

package/dist/pipeline/report/generate.js

@@ -0,0 +1,54 @@
+import { writeFile } from "node:fs/promises";
+export async function generateReport({ reportPath, meetingTitle, sourceFileName, transcript, summary, actionItems, decisions, }) {
+    const markdown = buildMarkdownReport({ meetingTitle, sourceFileName, transcript, summary, actionItems, decisions });
+    await writeFile(reportPath, markdown, "utf-8");
+}
+function buildMarkdownReport({ meetingTitle, sourceFileName, transcript, summary, actionItems, decisions, }) {
+    const lines = [];
+    lines.push(`# Meeting Report: ${esc(meetingTitle)}`);
+    lines.push("");
+    lines.push(`**Source file:** ${esc(sourceFileName)}`);
+    lines.push(`**Created at:** ${esc(summary.createdAt)}`);
+    lines.push(`**Summary model:** ${esc(summary.model)}`);
+    lines.push(`**Action items model:** ${esc(actionItems.model)}`);
+    lines.push(`**Decisions model:** ${esc(decisions.model)}`);
+    lines.push("");
+    lines.push("## Summary");
+    lines.push("");
+    lines.push(summary.summary.trim() || "No summary available.");
+    lines.push("");
+    lines.push("## Action Items");
+    lines.push("");
+    if (actionItems.items.length === 0) {
+        lines.push("No action items found.");
+    }
+    else {
+        for (const item of actionItems.items) {
+            const details = [
+                item.owner ? `owner: ${item.owner}` : null,
+                item.dueDate ? `due: ${item.dueDate}` : null,
+            ].filter(Boolean);
+            lines.push(details.length > 0 ? `- ${item.text} — ${details.join(", ")}` : `- ${item.text}`);
+        }
+    }
+    lines.push("");
+    lines.push("## Decisions");
+    lines.push("");
+    if (decisions.items.length === 0) {
+        lines.push("No decisions found.");
+    }
+    else {
+        for (const item of decisions.items) {
+            lines.push(`- ${item.text}`);
+        }
+    }
+    lines.push("");
+    lines.push("## Transcript");
+    lines.push("");
+    lines.push(transcript.text.trim() || "No transcript available.");
+    lines.push("");
+    return lines.join("\n");
+}
+function esc(value) {
+    return value.replace(/([*_`[\]])/g, "\\$1");
+}

package/dist/pipeline/transcription/transcribe.js

@@ -0,0 +1,36 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { runCommand } from "../../lib/run-command.js";
+export async function transcribeWithWhisper({ audioPath, outputPrefix, modelPath, language, whisperCommand, }) {
+    const args = ["-m", modelPath, "-f", audioPath, "-otxt", "-of", outputPrefix, "-nt", "-l", language];
+    try {
+        await runCommand(whisperCommand, args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown whisper-cli error";
+        throw new Error(`Failed to transcribe audio.\n${message}`);
+    }
+    const transcriptPath = `${outputPrefix}.txt`;
+    let transcriptText;
+    try {
+        transcriptText = await readFile(transcriptPath, "utf-8");
+    }
+    catch {
+        throw new Error(`whisper-cli finished but transcript file was not found: ${transcriptPath}`);
+    }
+    const cleanedText = transcriptText.trim();
+    await writeFile(transcriptPath, cleanedText, "utf-8");
+    return {
+        text: cleanedText,
+        segments: parseSegmentsFromPlainText(cleanedText),
+        sourceAudioPath: audioPath,
+    };
+}
+function parseSegmentsFromPlainText(text) {
+    if (!text.trim())
+        return [];
+    return text
+        .split(/\n+/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line, index) => ({ startSec: index, endSec: index, text: line }));
+}

package/dist/pipeline/transcription/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/tool-definition.js

@@ -0,0 +1,5 @@
+export async function runTool(tool, input) {
+    const parsedInput = tool.inputSchema.parse(input);
+    const result = await tool.execute(parsedInput);
+    return tool.outputSchema.parse(result);
+}

package/dist/shared/tool-registry.js

@@ -0,0 +1,12 @@
+import { extractActionItemsTool } from "../tools/analysis/extract-action-items-tool.js";
+import { extractDecisionsTool } from "../tools/analysis/extract-decisions-tool.js";
+import { summarizeTranscriptionTool } from "../tools/analysis/summarize-transcription-tool.js";
+import { normalizeAudioTool } from "../tools/input/normalize-audio-tool.js";
+import { transcribeAudioTool } from "../tools/transcription/transcribe-audio-tool.js";
+export const tools = {
+    normalize_audio: normalizeAudioTool,
+    transcribe_audio: transcribeAudioTool,
+    summarize_transcript: summarizeTranscriptionTool,
+    extract_action_items: extractActionItemsTool,
+    extract_decisions: extractDecisionsTool,
+};

package/dist/tools/analysis/action-item-types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/analysis/extract-action-items-tool.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { callOllama } from "../../lib/ollama.js";
+const actionItemSchema = z.object({
+    text: z.string().min(1),
+    owner: z.string().nullable(),
+    dueDate: z.string().nullable(),
+});
+const inputSchema = z.object({
+    transcriptText: z.string().min(1),
+    model: z.string().min(1),
+    ollamaBaseUrl: z.string().url(),
+});
+const outputSchema = z.object({
+    items: z.array(actionItemSchema),
+});
+const jsonSchema = {
+    type: "object",
+    properties: {
+        items: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    text: { type: "string" },
+                    owner: { type: ["string", "null"] },
+                    dueDate: { type: ["string", "null"] },
+                },
+                required: ["text", "owner", "dueDate"],
+                additionalProperties: false,
+            },
+        },
+    },
+    required: ["items"],
+    additionalProperties: false,
+};
+function buildPrompt(transcript) {
+    return [
+        "Extract action items from the meeting transcript.",
+        "Return ONLY valid JSON matching the required schema.",
+        "Do not return markdown, explanations, or any text outside of JSON.",
+        "",
+        "An action item is a concrete task that someone must DO after the meeting.",
+        "Examples of action items: 'Fix the login bug', 'Send credentials to John', 'Schedule follow-up call'.",
+        "",
+        "Rules:",
+        "- Include ONLY tasks with a clear verb: fix, send, check, create, review, schedule, etc.",
+        "- Do NOT include compliments, thank-yous, summaries, or observations.",
+        "- Do NOT include things that were already done during the meeting.",
+        "- If no clear owner is mentioned, use null.",
+        "- If no due date is mentioned, use null.",
+        '- If there are no action items, return {"items":[]}.',
+        "",
+        "Transcript:",
+        transcript,
+    ].join("\n");
+}
+export const extractActionItemsTool = {
+    name: "extract_action_items",
+    description: "Extract action items from a meeting transcript",
+    inputSchema,
+    outputSchema,
+    async execute(input) {
+        const raw = await callOllama({
+            baseUrl: input.ollamaBaseUrl,
+            model: input.model,
+            messages: [
+                {
+                    role: "system",
+                    content: "You are a meeting analyst. Extract action items from transcripts. Return ONLY valid JSON. Do not ask questions. Do not offer further help."
+                },
+                {
+                    role: "user",
+                    content: buildPrompt(input.transcriptText),
+                }
+            ],
+            format: jsonSchema,
+            temperature: 0,
+        });
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`Failed to parse action items JSON.\nRaw response:\n${raw}`);
+        }
+        const result = outputSchema.safeParse(parsed);
+        if (!result.success) {
+            throw new Error(`Action items response does not match schema.\n${result.error.message}\nRaw:\n${raw}`);
+        }
+        return {
+            items: result.data.items.filter((item) => item.text.trim().length > 0),
+        };
+    },
+};

package/dist/tools/analysis/extract-decisions-tool.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { callOllama } from "../../lib/ollama.js";
+const decisionItemSchema = z.object({
+    text: z.string().min(1),
+});
+const inputSchema = z.object({
+    transcriptText: z.string().min(1),
+    model: z.string().min(1),
+    ollamaBaseUrl: z.string().url(),
+});
+const outputSchema = z.object({
+    items: z.array(decisionItemSchema),
+});
+const jsonSchema = {
+    type: "object",
+    properties: {
+        items: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    text: { type: "string" },
+                },
+                required: ["text"],
+                additionalProperties: false,
+            },
+        },
+    },
+    required: ["items"],
+    additionalProperties: false,
+};
+function buildPrompt(transcript) {
+    return [
+        "Extract only final decisions from the meeting transcript.",
+        "Return ONLY valid JSON matching the required schema.",
+        "Do not return markdown, explanations, or any text outside of JSON.",
+        "",
+        "Rules:",
+        "- Include only decisions that were actually agreed or confirmed.",
+        "- Do not include action items, discussion points, or open questions.",
+        '- If there are no decisions, return {"items":[]}.',
+        "",
+        "Transcript:",
+        transcript,
+    ].join("\n");
+}
+export const extractDecisionsTool = {
+    name: "extract_decisions",
+    description: "Extract confirmed decisions from a meeting transcript",
+    inputSchema,
+    outputSchema,
+    async execute(input) {
+        const raw = await callOllama({
+            baseUrl: input.ollamaBaseUrl,
+            model: input.model,
+            messages: [
+                {
+                    role: "system",
+                    content: "You are a meeting analyst. Extract action items from transcripts. Return ONLY valid JSON. Do not ask questions. Do not offer further help."
+                },
+                {
+                    role: "user",
+                    content: buildPrompt(input.transcriptText),
+                }
+            ],
+            format: jsonSchema,
+            temperature: 0,
+        });
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`Failed to parse decisions JSON.\nRaw response:\n${raw}`);
+        }
+        const result = outputSchema.safeParse(parsed);
+        if (!result.success) {
+            throw new Error(`Decisions response does not match schema.\n${result.error.message}\nRaw:\n${raw}`);
+        }
+        return {
+            items: result.data.items.filter((item) => item.text.trim().length > 0),
+        };
+    },
+};

package/dist/tools/analysis/summarize-transcription-tool.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { callOllama } from "../../lib/ollama.js";
+const inputSchema = z.object({
+    transcriptText: z.string().min(1),
+    model: z.string().min(1),
+    ollamaBaseUrl: z.string().url(),
+});
+const outputSchema = z.object({
+    summary: z.string().min(1),
+});
+function buildPrompt(transcript) {
+    return [
+        "You are an assistant that summarizes meeting transcripts.",
+        "Write a concise and clear summary of the conversation.",
+        "Focus on the main discussion points, important context, and outcomes.",
+        "Do not invent facts that are not present in the transcript.",
+        "Keep the summary readable and structured as plain text.",
+        "Transcript:",
+        transcript,
+    ].join("\n");
+}
+export const summarizeTranscriptionTool = {
+    name: "summarize_transcript",
+    description: "Generate a meeting summary from transcript text",
+    inputSchema,
+    outputSchema,
+    async execute(input) {
+        const summary = await callOllama({
+            baseUrl: input.ollamaBaseUrl,
+            model: input.model,
+            messages: [
+                {
+                    role: "system",
+                    content: "You are a meeting analyst. Extract action items from transcripts. Return ONLY valid JSON. Do not ask questions. Do not offer further help."
+                },
+                {
+                    role: "user",
+                    content: buildPrompt(input.transcriptText),
+                }
+            ],
+        });
+        return { summary };
+    },
+};

package/dist/tools/input/normalize-audio-tool.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { normalizeAudio } from "../../pipeline/audio/normalize.js";
+const inputSchema = z.object({
+    inputPath: z.string().min(1),
+    outputPath: z.string().min(1),
+    ffmpegCommand: z.string().min(1),
+});
+const outputSchema = z.object({
+    normalizedAudioPath: z.string().min(1),
+});
+export const normalizeAudioTool = {
+    name: "normalize_audio",
+    description: "Normalize audio to 16kHz mono PCM WAV for Whisper",
+    inputSchema,
+    outputSchema,
+    async execute(input) {
+        await normalizeAudio({
+            inputPath: input.inputPath,
+            outputPath: input.outputPath,
+            ffmpegCommand: input.ffmpegCommand,
+        });
+        return { normalizedAudioPath: input.outputPath };
+    },
+};