samuraizer 0.0.1

package/dist/config/paths.js

@@ -0,0 +1,20 @@
+import os from "node:os";
+import path from "node:path";
+const APP_DIR_NAME = "samuraizer";
+const CONFIG_FILE_NAME = "config.json";
+function getUserConfigDir() {
+    const home = os.homedir();
+    if (process.platform === "win32") {
+        return process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
+    }
+    if (process.platform === "darwin") {
+        return path.join(home, "Library", "Application Support");
+    }
+    return process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+}
+export function getConfigDir() {
+    return path.join(getUserConfigDir(), APP_DIR_NAME);
+}
+export function getConfigFilePath() {
+    return path.join(getConfigDir(), CONFIG_FILE_NAME);
+}

package/dist/config/schema.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const configSchema = z.object({
+    model: z.string().min(1),
+    ollamaBaseUrl: z.string().url(),
+    whisperCommand: z.string().min(1),
+    whisperModelPath: z.string().min(1),
+    language: z.string().min(1),
+    ffmpegCommand: z.string().min(1),
+    ffprobeCommand: z.string().min(1),
+    outputDir: z.string().min(1).optional(),
+});
+export const partialConfigSchema = configSchema.partial();

package/dist/config/template.js

@@ -0,0 +1,9 @@
+export const configTemplate = {
+    model: "qwen2.5:14b",
+    ollamaBaseUrl: "http://127.0.0.1:11434",
+    whisperCommand: "whisper-cli",
+    whisperModelPath: "/absolute/path/to/ggml-model.bin",
+    language: "auto",
+    ffmpegCommand: "ffmpeg",
+    ffprobeCommand: "ffprobe",
+};

package/dist/config/types.js

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

package/dist/dev/run-tool.js

@@ -0,0 +1,38 @@
+import { runTool } from "../shared/tool-definition.js";
+import { tools } from "../shared/tool-registry.js";
+async function main() {
+    const toolName = process.argv[2];
+    if (!toolName) {
+        throw new Error("Usage: tsx runTool.ts <tool-name>");
+    }
+    switch (toolName) {
+        case "normalize": {
+            const result = await runTool(tools.normalize_audio, {
+                inputPath: process.argv[3],
+                outputPath: process.argv[4] || "./normalized.wav",
+            });
+            console.log("normalize result:");
+            console.log(result);
+            break;
+        }
+        case "summarize": {
+            const text = process.argv[3];
+            if (!text) {
+                throw new Error("Provide transcript text");
+            }
+            const result = await runTool(tools.summarize_transcript, {
+                transcriptText: text,
+                model: process.env.SUMMARY_MODEL || "qwen2.5:14b",
+            });
+            console.log("summary:");
+            console.log(result.summary);
+            break;
+        }
+        default:
+            throw new Error(`Unknown tool: ${toolName}`);
+    }
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/dev/runProcessMeeting.js

@@ -0,0 +1,21 @@
+import { processMeeting } from "../orchestrators/process-meeting.js";
+async function main() {
+    const inputPath = process.argv[2];
+    if (!inputPath) {
+        throw new Error("Input path is required. Usage: tsx src/dev/runProcessMeeting.ts <audio-file>");
+    }
+    const result = await processMeeting({
+        inputPath,
+        outputRootDir: "./output",
+        whisperModelPath: process.env.WHISPER_MODEL_PATH || "",
+        summaryModel: process.env.SUMMARY_MODEL ?? "qwen2.5:14b",
+        language: process.env.TRANSCRIPT_LANGUAGE || "auto",
+    });
+    console.log("Process completed");
+    console.log(JSON.stringify(result, null, 2));
+}
+main().catch((error) => {
+    console.error("Process failed");
+    console.error(error);
+    process.exit(1);
+});

package/dist/infra/ffmpeg/run-ffmpeg.js

@@ -0,0 +1,29 @@
+import { spawn } from "node:child_process";
+export async function runFfmpeg(args) {
+    await runCommand("ffmpeg", args);
+}
+async function runCommand(command, args) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stderr = "";
+        let stdout = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => {
+            reject(new Error(`Failed to start ${command}: ${error instanceof Error ? error.message : String(error)}`));
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${command} exited with code ${code}\n stdout: ${stdout}\n stderr: ${stderr}`));
+        });
+    });
+}

package/dist/infra/ollama/ollama-client.js

@@ -0,0 +1,42 @@
+export async function generateWithOllama({ model, prompt, format, stream = false, baseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434" }) {
+    const body = {
+        model,
+        prompt,
+        stream,
+    };
+    if (format)
+        body.format = format;
+    let response;
+    try {
+        response = await fetch(`${baseUrl}/api/generate`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown network error";
+        throw new Error(`Failed to connect to Ollama API:\n${message}`);
+    }
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Ollama API request failed with status ${response.status}: ${body}`);
+    }
+    let data;
+    try {
+        data = (await response.json());
+    }
+    catch (error) {
+        throw new Error(`Failed to parse Ollama API response.`);
+    }
+    if (data.error) {
+        throw new Error(`Ollama API error: ${data.error}`);
+    }
+    const text = data.response?.trim();
+    if (!text) {
+        throw new Error(`Ollama API returned an empty response.`);
+    }
+    return text;
+}

package/dist/infra/whisper/run-whisper-cli.js

@@ -0,0 +1,40 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+export async function runWhisperCli({ inputPath, outputTxtPath, modelPath, language }) {
+    const args = [
+        "-m",
+        modelPath,
+        "-f",
+        inputPath,
+        "-otxt",
+        "-of",
+        outputTxtPath.replace(/\.txt$/, ""),
+    ];
+    if (language && language !== "auto") {
+        args.push("-l", language);
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn("whisper-cli", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stderr = "";
+        let stdout = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => {
+            reject(new Error(`Failed to start whisper-cli: ${error instanceof Error ? error.message : String(error)}`));
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`whisper-cli exited with code ${code}\nstdout:\n${stdout}\nstderr:\n${stderr}`));
+        });
+    });
+    return await readFile(outputTxtPath, "utf8");
+}

package/dist/lib/ollama.js

@@ -0,0 +1,51 @@
+export async function callOllama({ baseUrl, model, format, temperature, messages, }) {
+    const body = {
+        model,
+        messages,
+        stream: false,
+        options: {
+            num_ctx: 16384,
+            ...(temperature !== undefined && { options: { temperature } }),
+        },
+        ...(format && { format }),
+    };
+    let response;
+    try {
+        response = await fetch(`${baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown network error";
+        throw new Error(`Failed to connect to Ollama API:\n${message}`);
+    }
+    if (!response.ok) {
+        const text = await safeReadText(response);
+        throw new Error(`Ollama API returned ${response.status} ${response.statusText}.\n${text}`);
+    }
+    let data;
+    try {
+        data = (await response.json());
+    }
+    catch {
+        throw new Error("Failed to parse Ollama API JSON response.");
+    }
+    if (data.error) {
+        throw new Error(`Ollama API error: ${data.error}`);
+    }
+    const text = data.message?.content?.trim();
+    if (!text) {
+        throw new Error("Ollama API returned an empty response.");
+    }
+    return text;
+}
+async function safeReadText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/lib/run-command.js

@@ -0,0 +1,8 @@
+import { execa } from "execa";
+export async function runCommand(command, args) {
+    const result = await execa(command, args, { reject: true });
+    return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}

package/dist/orchestrators/process-meeting.js

@@ -0,0 +1,196 @@
+import { access, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { ensureFfmpeg } from "../checks/ffmpeg.js";
+import { ensureFfprobe } from "../checks/ffprobe.js";
+import { ensureOllama } from "../checks/ollama.js";
+import { ensureWhisperCli } from "../checks/whisper.js";
+import { probeAudio } from "../pipeline/audio/probe.js";
+import { validateInputFile } from "../pipeline/audio/validate-input.js";
+import { prepareOutput } from "../pipeline/output/prepare.js";
+import { saveMeta } from "../pipeline/output/save.js";
+import { generateReport } from "../pipeline/report/generate.js";
+import { runTool } from "../shared/tool-definition.js";
+import { tools } from "../shared/tool-registry.js";
+export async function processMeeting(input) {
+    const validatedFile = await validateInputFile(input.inputPath);
+    const outputRootDir = input.outputRootDir ?? path.dirname(validatedFile.resolvedPath);
+    const { paths, meta } = await prepareOutput(validatedFile, outputRootDir);
+    await ensureFfmpeg(input.ffmpegCommand);
+    await ensureFfprobe(input.ffprobeCommand);
+    await ensureWhisperCli(input.whisperCommand);
+    await ensureOllama(input.ollamaBaseUrl);
+    // Probe source audio
+    meta.input.audioMetadata = await probeAudio(validatedFile.resolvedPath, input.ffprobeCommand);
+    // Normalize audio
+    let normalized;
+    if (!input.force && await fileExists(paths.normalizedAudioPath)) {
+        console.log("Skipping normalization (cached).");
+        normalized = { normalizedAudioPath: paths.normalizedAudioPath };
+    }
+    else {
+        console.log("Normalizing audio...");
+        normalized = await runTool(tools.normalize_audio, {
+            inputPath: validatedFile.resolvedPath,
+            outputPath: paths.normalizedAudioPath,
+            ffmpegCommand: input.ffmpegCommand,
+        });
+    }
+    meta.output.normalizedAudioPath = normalized.normalizedAudioPath;
+    meta.output.normalizedAudioMetadata = await probeAudio(normalized.normalizedAudioPath, input.ffprobeCommand);
+    meta.status = "audio_normalized";
+    await saveMeta(paths, meta);
+    // Transcribe
+    let transcription;
+    if (!input.force && await fileExists(paths.transcriptJsonPath)) {
+        console.log("Skipping transcription (cached).");
+        const cached = await readJson(paths.transcriptJsonPath);
+        transcription = { ...cached, transcriptPath: paths.transcriptTextPath };
+    }
+    else {
+        console.log("Transcribing audio...");
+        transcription = await runTool(tools.transcribe_audio, {
+            audioPath: normalized.normalizedAudioPath,
+            outputDir: paths.runDir,
+            modelPath: input.whisperModelPath,
+            language: input.language,
+            whisperCommand: input.whisperCommand,
+        });
+        await writeFile(paths.transcriptJsonPath, JSON.stringify({
+            text: transcription.text,
+            segments: transcription.segments,
+            sourceAudioPath: transcription.sourceAudioPath,
+        }, null, 2), "utf-8");
+    }
+    meta.output.transcriptTextPath = transcription.transcriptPath;
+    meta.output.transcriptJsonPath = paths.transcriptJsonPath;
+    meta.transcription = {
+        engine: "whisper.cpp",
+        modelPath: input.whisperModelPath,
+        textLength: transcription.text.length,
+    };
+    meta.status = "transcribed";
+    await saveMeta(paths, meta);
+    // Summarize
+    let summaryResult;
+    if (!input.force && await fileExists(paths.summaryJsonPath)) {
+        console.log("Skipping summary (cached).");
+        summaryResult = await readJson(paths.summaryJsonPath);
+    }
+    else {
+        console.log("Generating summary...");
+        const { summary } = await runTool(tools.summarize_transcript, {
+            transcriptText: transcription.text,
+            model: input.model,
+            ollamaBaseUrl: input.ollamaBaseUrl,
+        });
+        const createdAt = new Date().toISOString();
+        summaryResult = { summary, model: input.model, sourceTranscriptPath: transcription.transcriptPath, createdAt };
+        await writeFile(paths.summaryTextPath, summary, "utf-8");
+        await writeFile(paths.summaryJsonPath, JSON.stringify(summaryResult, null, 2), "utf-8");
+    }
+    meta.output.summaryTextPath = paths.summaryTextPath;
+    meta.output.summaryJsonPath = paths.summaryJsonPath;
+    meta.summary = { model: input.model, textLength: summaryResult.summary.length };
+    meta.status = "summarized";
+    await saveMeta(paths, meta);
+    // Extract action items
+    let actionItemsResult;
+    if (!input.force && await fileExists(paths.actionItemsJsonPath)) {
+        console.log("Skipping action items (cached).");
+        actionItemsResult = await readJson(paths.actionItemsJsonPath);
+    }
+    else {
+        console.log("Extracting action items...");
+        const { items: actionItems } = await runTool(tools.extract_action_items, {
+            transcriptText: transcription.text,
+            model: input.model,
+            ollamaBaseUrl: input.ollamaBaseUrl,
+        });
+        actionItemsResult = { items: actionItems, model: input.model, sourceTranscriptPath: transcription.transcriptPath, createdAt: summaryResult.createdAt };
+        await writeFile(paths.actionItemsTextPath, formatActionItems(actionItems), "utf-8");
+        await writeFile(paths.actionItemsJsonPath, JSON.stringify(actionItemsResult, null, 2), "utf-8");
+    }
+    meta.output.actionItemsTextPath = paths.actionItemsTextPath;
+    meta.output.actionItemsJsonPath = paths.actionItemsJsonPath;
+    meta.actionItems = { model: input.model, count: actionItemsResult.items.length };
+    meta.status = "action_items_extracted";
+    await saveMeta(paths, meta);
+    // Extract decisions
+    let decisionsResult;
+    if (!input.force && await fileExists(paths.decisionsJsonPath)) {
+        console.log("Skipping decisions (cached).");
+        decisionsResult = await readJson(paths.decisionsJsonPath);
+    }
+    else {
+        console.log("Extracting decisions...");
+        const { items: decisions } = await runTool(tools.extract_decisions, {
+            transcriptText: transcription.text,
+            model: input.model,
+            ollamaBaseUrl: input.ollamaBaseUrl,
+        });
+        decisionsResult = { items: decisions, model: input.model, sourceTranscriptPath: transcription.transcriptPath, createdAt: summaryResult.createdAt };
+        await writeFile(paths.decisionsTextPath, formatDecisions(decisions), "utf-8");
+        await writeFile(paths.decisionsJsonPath, JSON.stringify(decisionsResult, null, 2), "utf-8");
+    }
+    meta.output.decisionsTextPath = paths.decisionsTextPath;
+    meta.output.decisionsJsonPath = paths.decisionsJsonPath;
+    meta.decisions = { model: input.model, count: decisionsResult.items.length };
+    meta.status = "decisions_extracted";
+    await saveMeta(paths, meta);
+    // Generate report
+    if (!input.force && await fileExists(paths.reportMarkdownPath)) {
+        console.log("Skipping report (cached).");
+    }
+    else {
+        console.log("Generating report...");
+        await generateReport({
+            reportPath: paths.reportMarkdownPath,
+            meetingTitle: validatedFile.baseName,
+            sourceFileName: validatedFile.fileName,
+            transcript: {
+                text: transcription.text,
+                segments: transcription.segments,
+                sourceAudioPath: transcription.sourceAudioPath,
+            },
+            summary: summaryResult,
+            actionItems: actionItemsResult,
+            decisions: decisionsResult,
+        });
+    }
+    meta.output.reportMarkdownPath = paths.reportMarkdownPath;
+    meta.report = { generated: true };
+    meta.status = "report_generated";
+    await saveMeta(paths, meta);
+    return { paths, meta };
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(filePath) {
+    const raw = await readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+}
+function formatActionItems(items) {
+    if (items.length === 0)
+        return "No action items found.";
+    return items
+        .map((item) => {
+        const details = [
+            item.owner ? `owner: ${item.owner}` : null,
+            item.dueDate ? `due: ${item.dueDate}` : null,
+        ].filter(Boolean);
+        return details.length > 0 ? `- ${item.text} — ${details.join(", ")}` : `- ${item.text}`;
+    })
+        .join("\n");
+}
+function formatDecisions(items) {
+    if (items.length === 0)
+        return "No decisions found.";
+    return items.map((item) => `- ${item.text}`).join("\n");
+}

package/dist/pipeline/analysis/action-items/generate.js

@@ -0,0 +1,117 @@
+import { writeFile } from "node:fs/promises";
+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 actionItemsResponseSchema = z.object({
+    items: z.array(actionItemSchema),
+});
+const actionItemsJsonSchema = {
+    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,
+};
+export async function generateActionItemsWithOllama({ transcript, model, actionItemsTextPath, sourceTranscriptPath, }) {
+    const prompt = buildActionItemsPrompt(transcript);
+    const rawText = await callOllama({ model, prompt, format: actionItemsJsonSchema, temperature: 0 });
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(rawText);
+    }
+    catch {
+        throw new Error(`Failed to parse action items JSON.\nRaw response:\n${rawText}`);
+    }
+    parsedJson = normalizeActionItemsJson(parsedJson);
+    const validated = actionItemsResponseSchema.safeParse(parsedJson);
+    if (!validated.success) {
+        throw new Error(`Action items 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(actionItemsTextPath, toActionItemsText(items), "utf-8");
+    return { items, model, sourceTranscriptPath, createdAt: new Date().toISOString() };
+}
+export function buildActionItemsPrompt(transcript) {
+    return [
+        "Extract action items from the meeting transcript.",
+        "Return ONLY valid JSON.",
+        "Do not return markdown.",
+        "Do not return explanations.",
+        "Do not return any text before or after JSON.",
+        "",
+        "Required JSON schema:",
+        `{
+            "items": [
+                {
+                "text": "string",
+                "owner": "string or null",
+                "dueDate": "string or null"
+                }
+            ]
+        }`,
+        "",
+        "Rules:",
+        "- Include only concrete tasks or follow-up actions.",
+        "- 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");
+}
+function toActionItemsText(items) {
+    if (items.length === 0)
+        return "No action items found.";
+    return items
+        .map((item) => {
+        const details = [
+            item.owner ? `owner: ${item.owner}` : null,
+            item.dueDate ? `due: ${item.dueDate}` : null,
+        ].filter(Boolean);
+        return details.length > 0 ? `- ${item.text} - ${details.join(", ")}` : `- ${item.text}`;
+    })
+        .join("\n");
+}
+function normalizeActionItemsJson(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error(`Action items response is not an object:\n${JSON.stringify(input, null, 2)}`);
+    }
+    const obj = input;
+    if (!("items" in obj)) {
+        throw new Error(`Action items response does not contain "items":\n${JSON.stringify(input, null, 2)}`);
+    }
+    if (!Array.isArray(obj.items)) {
+        throw new Error(`Action items field "items" is not an array:\n${JSON.stringify(input, null, 2)}`);
+    }
+    return {
+        items: obj.items.map((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item)) {
+                return { text: "", owner: null, dueDate: null };
+            }
+            const i = item;
+            return {
+                text: typeof i.text === "string" ? i.text : "",
+                owner: typeof i.owner === "string" ? i.owner : null,
+                dueDate: typeof i.dueDate === "string" ? i.dueDate : null,
+            };
+        }),
+    };
+}

package/dist/pipeline/analysis/action-items/types.js

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