samuraizer 0.0.1

package/README.md

@@ -0,0 +1,206 @@
+# Samuraizer
+
+Local-first CLI for meeting transcription and analysis.
+
+Samuraizer processes audio recordings and generates:
+- transcript
+- summary
+- action items
+- decisions
+- report
+
+All processing is done locally using tools like Whisper and Ollama
+
+
+## ✨ Features
+
+- 🎙 Transcribe audio recordings (Whisper)
+- 🧠 Generate summaries (local LLM via Ollama)
+- ✅ Extract action items
+- 📌 Extract decisions
+- ⚡ Resume processing (skip already processed steps)
+- 🔧 Simple CLI + config system
+- 🔒 Local-first (no cloud required)
+
+
+## 📦 Installation
+
+```bash
+npm install -g samuraizer
+```
+
+## ⚙️ Prerequisites
+
+Make sure you have installed:
+```bash
+Node.js >= 20
+ffmpeg
+whisper-cli (whisper.cpp)
+Ollama
+Start Ollama
+ollama serve
+ollama pull qwen2.5:14b
+```
+
+## 🚀 Quick Start
+```bash
+samuraizer init
+samuraizer process meeting.m4a
+```
+
+## ⚙️ Configuration
+
+Samuraizer uses a global JSON config file.
+
+### Initialize config
+```bash
+samuraizer init
+```
+
+### Config location
+* **macOS**: `~/Library/Application Support/samuraizer/config.json`
+* **Linux**: `~/.config/samuraizer/config.json`
+* **Windows**: `%AppData%/samuraizer/config.json`
+
+### View config
+```bash
+samuraizer config get
+```
+### Example config
+```json
+{
+  "model": "qwen2.5:14b",
+  "ollamaBaseUrl": "http://127.0.0.1:11434",
+  "whisperCommand": "whisper-cli",
+  "ffmpegCommand": "ffmpeg",
+  "ffprobeCommand": "ffprobe"
+}
+```
+
+### 🧩 Config fields
+
+- **model** — LLM model used for analysis (summary, action items, decisions)
+- **ollamaBaseUrl** — URL where Ollama is running
+- **whisperCommand** — Command used to run Whisper
+- **ffmpegCommand** — Command used for audio processing
+- **ffprobeCommand** — Command used for audio inspection
+
+
+## 🧪 Commands
+
+### Show help
+
+```bash
+samuraizer --help
+```
+
+### Show version
+
+```bash
+samuraizer --version
+```
+
+## 🚀 Full pipeline
+
+### Process an audio recording:
+```bash
+samuraizer process meeting.m4a
+```
+
+### Show detailed metadata after processing:
+```bash
+samuraizer process meeting.m4a --verbose
+```
+
+### Recompute all steps even if outputs already exist:
+```bash
+samuraizer process meeting.m4a --force
+```
+
+### You can combine flags:
+```bash
+samuraizer process meeting.m4a --verbose --force
+```
+
+## 🎛 Individual commands
+
+### Normalize audio to Whisper-compatible WAV:
+```bash
+samuraizer normalize input.m4a output.wav
+```
+
+### Summarize a transcript file:
+```bash
+samuraizer summarize transcript.txt
+```
+
+### Extract action items from a transcript file:
+```bash
+samuraizer actions transcript.txt
+```
+
+### Extract decisions from a transcript file:
+```bash
+samuraizer decisions transcript.txt
+```
+
+
+## ⚙️ Configuration commands
+
+### Create the default config file:
+```bash
+samuraizer init
+```
+
+### Print config file path:
+```bash
+samuraizer config path
+```
+
+### Print resolved config as JSON:
+```bash
+samuraizer config get
+```
+
+
+### 📂 Output
+```json
+output/<file-name>/
+  transcript.txt
+  summary.txt
+  action-items.json
+  decisions.json
+  report.txt
+  ```
+
+
+### 🔁 Resume Behavior
+
+Samuraizer skips already processed steps.
+
+Use `--force` to rebuild everything.
+
+
+### ⚠️ Common Issues
+#### Ollama not running
+```bash
+ollama serve
+```
+
+#### ffmpeg not found
+
+macOS:
+```bash
+brew install ffmpeg
+```
+
+Linux:
+```bash
+apt install ffmpeg
+```
+
+### 📄 License
+
+ISC
+
+---

package/dist/checks/ffmpeg.js

@@ -0,0 +1,9 @@
+import { runCommand } from "../lib/run-command.js";
+export async function ensureFfmpeg(command) {
+    try {
+        await runCommand(command, ["-version"]);
+    }
+    catch {
+        throw new Error(`ffmpeg is not installed or not in PATH (tried '${command}'). Please install ffmpeg.`);
+    }
+}

package/dist/checks/ffprobe.js

@@ -0,0 +1,9 @@
+import { runCommand } from "../lib/run-command.js";
+export async function ensureFfprobe(command) {
+    try {
+        await runCommand(command, ["-version"]);
+    }
+    catch {
+        throw new Error(`ffprobe is not installed or not in PATH (tried '${command}'). Please install ffprobe.`);
+    }
+}

package/dist/checks/ollama.js

@@ -0,0 +1,12 @@
+export async function ensureOllama(baseUrl) {
+    let response;
+    try {
+        response = await fetch(`${baseUrl}/api/ps`, { method: "GET" });
+    }
+    catch {
+        throw new Error(`Ollama is not reachable at ${baseUrl}. Make sure ollama is running.`);
+    }
+    if (!response.ok) {
+        throw new Error(`Ollama API check failed with ${response.status} ${response.statusText}.`);
+    }
+}

package/dist/checks/whisper.js

@@ -0,0 +1,9 @@
+import { runCommand } from "../lib/run-command.js";
+export async function ensureWhisperCli(command) {
+    try {
+        await runCommand(command, ["-h"]);
+    }
+    catch {
+        throw new Error(`whisper-cli is not installed or not in PATH (tried '${command}'). Please install whisper-cli.`);
+    }
+}

package/dist/cli/commands/process.js

@@ -0,0 +1,138 @@
+import { ensureFfmpeg } from "../../checks/ffmpeg.js";
+import { ensureFfprobe } from "../../checks/ffprobe.js";
+import { ensureWhisperCli } from "../../checks/whisper.js";
+import { generateActionItemsWithOllama } from "../../pipeline/analysis/action-items/generate.js";
+import { generateDecisionsWithOllama } from "../../pipeline/analysis/decisions/generate.js";
+import { generateSummaryWithOllama } from "../../pipeline/analysis/summary/generate.js";
+import { normalizeAudio } from "../../pipeline/audio/normalize.js";
+import { probeAudio } from "../../pipeline/audio/probe.js";
+import { validateInputFile } from "../../pipeline/audio/validate-input.js";
+import { saveActionItems, saveDecisions, saveMeta, saveSummary, saveTranscript } from "../../pipeline/output/save.js";
+import { prepareOutput } from "../../pipeline/output/prepare.js";
+import { generateReport } from "../../pipeline/report/generate.js";
+import { transcribeWithWhisper } from "../../pipeline/transcription/transcribe.js";
+const DEFAULT_WHISPER_MODEL_PATH = process.env.WHISPER_MODEL_PATH ?? "";
+const DEFAULT_OLLAMA_MODEL = process.env.OLLAMA_MODEL ?? "qwen2.5:14b";
+export function registerProcessCommand(program) {
+    program
+        .command("process")
+        .description("Process a recording file")
+        .argument("<file>", "Path to the recording file")
+        .option("-v, --verbose", "Enable verbose logging")
+        .action(async (file, options) => {
+        try {
+            if (!DEFAULT_WHISPER_MODEL_PATH) {
+                throw new Error("WHISPER_MODEL_PATH is not set. Please export WHISPER_MODEL_PATH=/absolute/path/to/model.bin");
+            }
+            const validatedFile = await validateInputFile(file);
+            const preparedOutput = await prepareOutput(validatedFile);
+            console.log("samuraizer started");
+            console.log(`Input:      ${validatedFile.resolvedPath}`);
+            console.log(`Output dir: ${preparedOutput.paths.runDir}`);
+            console.log("Checking ffmpeg...");
+            await ensureFfmpeg();
+            console.log("Checking ffprobe...");
+            await ensureFfprobe();
+            console.log("Checking whisper-cli...");
+            await ensureWhisperCli();
+            console.log("Probing input audio...");
+            preparedOutput.meta.input.audioMetadata = await probeAudio(validatedFile.resolvedPath);
+            console.log("Normalizing audio...");
+            await normalizeAudio({
+                inputPath: validatedFile.resolvedPath,
+                outputPath: preparedOutput.paths.normalizedAudioPath,
+            });
+            preparedOutput.meta.output.normalizedAudioPath = preparedOutput.paths.normalizedAudioPath;
+            preparedOutput.meta.status = "audio_normalized";
+            console.log("Probing normalized audio...");
+            preparedOutput.meta.output.normalizedAudioMetadata = await probeAudio(preparedOutput.paths.normalizedAudioPath);
+            preparedOutput.meta.status = "audio_probed";
+            console.log("Transcribing audio...");
+            const transcript = await transcribeWithWhisper({
+                audioPath: preparedOutput.paths.normalizedAudioPath,
+                outputTextPath: preparedOutput.paths.runDir,
+                modelPath: DEFAULT_WHISPER_MODEL_PATH,
+            });
+            await saveTranscript(preparedOutput.paths.transcriptJsonPath, transcript);
+            preparedOutput.meta.output.transcriptTextPath = preparedOutput.paths.transcriptTextPath;
+            preparedOutput.meta.output.transcriptJsonPath = preparedOutput.paths.transcriptJsonPath;
+            preparedOutput.meta.transcription = {
+                engine: "whisper.cpp",
+                modelPath: DEFAULT_WHISPER_MODEL_PATH,
+                textLength: transcript.text.length,
+            };
+            preparedOutput.meta.status = "transcribed";
+            console.log("Generating summary...");
+            const summary = await generateSummaryWithOllama({
+                transcript: transcript.text,
+                model: DEFAULT_OLLAMA_MODEL,
+                summaryTextPath: preparedOutput.paths.summaryTextPath,
+                sourceTranscriptPath: preparedOutput.paths.transcriptTextPath,
+            });
+            await saveSummary(preparedOutput.paths.summaryJsonPath, summary);
+            preparedOutput.meta.output.summaryTextPath = preparedOutput.paths.summaryTextPath;
+            preparedOutput.meta.output.summaryJsonPath = preparedOutput.paths.summaryJsonPath;
+            preparedOutput.meta.summary = { model: DEFAULT_OLLAMA_MODEL, textLength: summary.summary.length };
+            preparedOutput.meta.status = "summarized";
+            console.log("Extracting action items...");
+            const actionItems = await generateActionItemsWithOllama({
+                transcript: transcript.text,
+                model: DEFAULT_OLLAMA_MODEL,
+                actionItemsTextPath: preparedOutput.paths.actionItemsTextPath,
+                sourceTranscriptPath: preparedOutput.paths.transcriptTextPath,
+            });
+            await saveActionItems(preparedOutput.paths.actionItemsJsonPath, actionItems);
+            preparedOutput.meta.output.actionItemsTextPath = preparedOutput.paths.actionItemsTextPath;
+            preparedOutput.meta.output.actionItemsJsonPath = preparedOutput.paths.actionItemsJsonPath;
+            preparedOutput.meta.actionItems = { model: DEFAULT_OLLAMA_MODEL, count: actionItems.items.length };
+            preparedOutput.meta.status = "action_items_extracted";
+            console.log("Extracting decisions...");
+            const decisions = await generateDecisionsWithOllama({
+                transcript: transcript.text,
+                model: DEFAULT_OLLAMA_MODEL,
+                decisionsTextPath: preparedOutput.paths.decisionsTextPath,
+                sourceTranscriptPath: preparedOutput.paths.transcriptTextPath,
+            });
+            await saveDecisions(preparedOutput.paths.decisionsJsonPath, decisions);
+            preparedOutput.meta.output.decisionsTextPath = preparedOutput.paths.decisionsTextPath;
+            preparedOutput.meta.output.decisionsJsonPath = preparedOutput.paths.decisionsJsonPath;
+            preparedOutput.meta.decisions = { model: DEFAULT_OLLAMA_MODEL, count: decisions.items.length };
+            preparedOutput.meta.status = "decisions_extracted";
+            console.log("Generating report...");
+            await generateReport({
+                reportPath: preparedOutput.paths.reportMarkdownPath,
+                meetingTitle: validatedFile.baseName,
+                sourceFileName: validatedFile.fileName,
+                transcript,
+                summary,
+                actionItems,
+                decisions,
+            });
+            preparedOutput.meta.output.reportMarkdownPath = preparedOutput.paths.reportMarkdownPath;
+            preparedOutput.meta.report = { generated: true };
+            preparedOutput.meta.status = "report_generated";
+            await saveMeta(preparedOutput.paths, preparedOutput.meta);
+            console.log("\nDone.");
+            console.log(`Normalized audio: ${preparedOutput.paths.normalizedAudioPath}`);
+            console.log(`Transcript:       ${preparedOutput.paths.transcriptTextPath}`);
+            console.log(`Summary:          ${preparedOutput.paths.summaryTextPath}`);
+            console.log(`Action items:     ${preparedOutput.paths.actionItemsTextPath}`);
+            console.log(`Decisions:        ${preparedOutput.paths.decisionsTextPath}`);
+            console.log(`Report:           ${preparedOutput.paths.reportMarkdownPath}`);
+            console.log(`Meta:             ${preparedOutput.paths.metaFilePath}`);
+            if (options.verbose) {
+                console.log("\n--- Verbose ---");
+                console.log("Transcript preview:", transcript.text.slice(0, 500));
+                console.log("Summary preview:", summary.summary.slice(0, 500));
+                console.log("Action items:", actionItems.items.slice(0, 5));
+                console.log("Decisions:", decisions.items.slice(0, 5));
+                console.log("Meta:", JSON.stringify(preparedOutput.meta, null, 2));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            console.error(`Error: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/index.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { Command } from "commander";
+import { initConfig } from "../config/init.js";
+import { loadConfig } from "../config/load.js";
+import { getConfigFilePath } from "../config/paths.js";
+import { processMeeting } from "../orchestrators/process-meeting.js";
+import { runTool } from "../shared/tool-definition.js";
+import { tools } from "../shared/tool-registry.js";
+const program = new Command();
+program
+    .name("samuraizer")
+    .description("Transform meeting recordings into structured knowledge")
+    .version("0.0.1");
+program
+    .command("process")
+    .description("Run the full pipeline on an audio recording")
+    .argument("<input>", "Path to the audio recording")
+    .option("-v, --verbose", "Show detailed output after processing")
+    .option("-f, --force", "Recompute all steps even if outputs already exist")
+    .action(async (input, options) => {
+    try {
+        const config = await loadConfig();
+        console.log(`Input:      ${input}`);
+        console.log(`Model:      ${config.model}`);
+        console.log(`Ollama URL: ${config.ollamaBaseUrl}`);
+        const result = await processMeeting({
+            inputPath: input,
+            outputRootDir: config.outputDir,
+            model: config.model,
+            ollamaBaseUrl: config.ollamaBaseUrl,
+            whisperCommand: config.whisperCommand,
+            whisperModelPath: config.whisperModelPath,
+            language: config.language,
+            ffmpegCommand: config.ffmpegCommand,
+            ffprobeCommand: config.ffprobeCommand,
+            force: options.force,
+        });
+        console.log("\nDone.");
+        console.log(`Output dir:   ${result.paths.runDir}`);
+        console.log(`Transcript:   ${result.paths.transcriptTextPath}`);
+        console.log(`Summary:      ${result.paths.summaryTextPath}`);
+        console.log(`Action items: ${result.paths.actionItemsTextPath}`);
+        console.log(`Decisions:    ${result.paths.decisionsTextPath}`);
+        console.log(`Report:       ${result.paths.reportMarkdownPath}`);
+        console.log(`Meta:         ${result.paths.metaFilePath}`);
+        if (options.verbose) {
+            console.log("\nMeta:", JSON.stringify(result.meta, null, 2));
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("normalize")
+    .description("Normalize audio to Whisper-compatible WAV format")
+    .argument("<input>", "Input audio file")
+    .argument("<output>", "Output WAV file path")
+    .action(async (input, output) => {
+    try {
+        const config = await loadConfig();
+        const result = await runTool(tools.normalize_audio, {
+            inputPath: input,
+            outputPath: output,
+            ffmpegCommand: config.ffmpegCommand,
+        });
+        console.log(`Normalized: ${result.normalizedAudioPath}`);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("summarize")
+    .description("Summarize a transcript file")
+    .argument("<file>", "Path to the transcript text file")
+    .action(async (file) => {
+    try {
+        const config = await loadConfig();
+        const text = await readFile(file, "utf-8");
+        const result = await runTool(tools.summarize_transcript, {
+            transcriptText: text,
+            model: config.model,
+            ollamaBaseUrl: config.ollamaBaseUrl,
+        });
+        console.log(result.summary);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("actions")
+    .description("Extract action items from a transcript file")
+    .argument("<file>", "Path to the transcript text file")
+    .action(async (file) => {
+    try {
+        const config = await loadConfig();
+        const text = await readFile(file, "utf-8");
+        const result = await runTool(tools.extract_action_items, {
+            transcriptText: text,
+            model: config.model,
+            ollamaBaseUrl: config.ollamaBaseUrl,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("decisions")
+    .description("Extract decisions from a transcript file")
+    .argument("<file>", "Path to the transcript text file")
+    .action(async (file) => {
+    try {
+        const config = await loadConfig();
+        const text = await readFile(file, "utf-8");
+        const result = await runTool(tools.extract_decisions, {
+            transcriptText: text,
+            model: config.model,
+            ollamaBaseUrl: config.ollamaBaseUrl,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("init")
+    .description("Create the Samuraizer config file with default values")
+    .action(async () => {
+    try {
+        const result = await initConfig();
+        if (result.created) {
+            console.log(`Created config at: ${result.path}`);
+        }
+        else {
+            console.log(`Config already exists at: ${result.path}`);
+            console.log("No changes were made. Edit the file manually to update values.");
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+});
+const configCommand = program.command("config").description("Inspect Samuraizer configuration");
+configCommand
+    .command("path")
+    .description("Print the absolute path to the config file")
+    .action(() => {
+    console.log(getConfigFilePath());
+});
+configCommand
+    .command("get")
+    .description("Print the resolved configuration (file + env) as JSON")
+    .action(async () => {
+    try {
+        const config = await loadConfig();
+        console.log(JSON.stringify(config, null, 2));
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+});
+program.parse(process.argv);

package/dist/cli/process-command.js

@@ -0,0 +1,21 @@
+import { processMeeting } from "../orchestrators/process-meeting.js";
+export async function processCommand(inputPath) {
+    const whisperModelPath = process.env.WHISPER_MODEL_PATH;
+    const summaryModel = process.env.SUMMARY_MODEL ?? "qwen2.5:14b";
+    const outputRootDir = process.env.SAMMURAIZER_OUTPUT_DIR ?? "./output";
+    const language = process.env.TRANSCRIPT_LANGUAGE || "auto";
+    if (!whisperModelPath) {
+        throw new Error("WHISPER_MODEL_PATH is not set.");
+    }
+    const result = await processMeeting({
+        inputPath,
+        outputRootDir,
+        whisperModelPath,
+        summaryModel,
+        language,
+    });
+    console.log("samuraizer finished successfully");
+    console.log(`Output directory: ${result.outputDir}`);
+    console.log(`Transcript path: ${result.transcriptPath}`);
+    console.log(`Summary path: ${result.summaryPath}`);
+}

package/dist/config/defaults.js

@@ -0,0 +1,7 @@
+export const defaultConfig = {
+    model: "qwen2.5:14b",
+    ollamaBaseUrl: "http://127.0.0.1:11434",
+    whisperCommand: "whisper-cli",
+    ffmpegCommand: "ffmpeg",
+    ffprobeCommand: "ffprobe",
+};

package/dist/config/init.js

@@ -0,0 +1,21 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { getConfigDir, getConfigFilePath } from "./paths.js";
+import { configTemplate } from "./template.js";
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function initConfig() {
+    const filePath = getConfigFilePath();
+    if (await fileExists(filePath)) {
+        return { path: filePath, created: false };
+    }
+    await mkdir(getConfigDir(), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(configTemplate, null, 2)}\n`, "utf-8");
+    return { path: filePath, created: true };
+}

package/dist/config/load.js

@@ -0,0 +1,57 @@
+import { access, readFile } from "node:fs/promises";
+import { getConfigFilePath } from "./paths.js";
+import { configSchema, partialConfigSchema } from "./schema.js";
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readConfigFile(filePath) {
+    const raw = await readFile(filePath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid config file at ${filePath}. Please fix the JSON or run 'samuraizer init' to recreate it.`);
+    }
+    const result = partialConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new Error(`Config file at ${filePath} is invalid: ${result.error.message}`);
+    }
+    return result.data;
+}
+function readEnvOverrides() {
+    const env = {};
+    if (process.env.SAMURAIZER_MODEL)
+        env.model = process.env.SAMURAIZER_MODEL;
+    if (process.env.SAMURAIZER_OLLAMA_BASE_URL)
+        env.ollamaBaseUrl = process.env.SAMURAIZER_OLLAMA_BASE_URL;
+    if (process.env.SAMURAIZER_WHISPER_COMMAND)
+        env.whisperCommand = process.env.SAMURAIZER_WHISPER_COMMAND;
+    if (process.env.SAMURAIZER_WHISPER_MODEL_PATH)
+        env.whisperModelPath = process.env.SAMURAIZER_WHISPER_MODEL_PATH;
+    if (process.env.SAMURAIZER_LANGUAGE)
+        env.language = process.env.SAMURAIZER_LANGUAGE;
+    if (process.env.SAMURAIZER_FFMPEG_COMMAND)
+        env.ffmpegCommand = process.env.SAMURAIZER_FFMPEG_COMMAND;
+    if (process.env.SAMURAIZER_FFPROBE_COMMAND)
+        env.ffprobeCommand = process.env.SAMURAIZER_FFPROBE_COMMAND;
+    if (process.env.SAMURAIZER_OUTPUT_DIR)
+        env.outputDir = process.env.SAMURAIZER_OUTPUT_DIR;
+    return env;
+}
+export async function loadConfig() {
+    const filePath = getConfigFilePath();
+    if (!(await fileExists(filePath))) {
+        throw new Error(`The config file is not created, please run 'samuraizer init' to create it. Expected at: ${filePath}`);
+    }
+    const fileConfig = await readConfigFile(filePath);
+    const envConfig = readEnvOverrides();
+    const merged = { ...fileConfig, ...envConfig };
+    return configSchema.parse(merged);
+}