mulmocast-preprocessor 0.1.0 → 0.1.2

package/README.md

@@ -25,6 +25,15 @@ mulmocast-preprocessor script.json --profile summary -o summary.json
 # Output to stdout (for piping)
 mulmocast-preprocessor script.json --profile teaser
 
+# Filter by section
+mulmocast-preprocessor script.json --section chapter1
+
+# Filter by tags
+mulmocast-preprocessor script.json --tags concept,demo
+
+# Combine profile and filters
+mulmocast-preprocessor script.json --profile summary --section chapter1
+
 # List available profiles
 mulmocast-preprocessor profiles script.json
 ```
@@ -35,6 +44,8 @@ mulmocast-preprocessor profiles script.json
 |--------|-------|-------------|
 | `--profile <name>` | `-p` | Profile name to apply (default: "default") |
 | `--output <path>` | `-o` | Output file path (default: stdout) |
+| `--section <name>` | `-s` | Filter by section name |
+| `--tags <tags>` | `-t` | Filter by tags (comma-separated) |
 | `--help` | `-h` | Show help |
 | `--version` | `-v` | Show version |
 

package/lib/cli/commands/process.d.ts

@@ -1,6 +1,8 @@
 interface ProcessOptions {
     profile?: string;
     output?: string;
+    section?: string;
+    tags?: string[];
 }
 /**
  * Process script with profile and output result

package/lib/cli/commands/process.js

@@ -10,6 +10,8 @@ export const processCommand = (scriptPath, options) => {
         const script = JSON.parse(content);
         const result = processScript(script, {
             profile: options.profile,
+            section: options.section,
+            tags: options.tags,
         });
         const output = JSON.stringify(result, null, 2);
         if (options.output) {

package/lib/cli/commands/summarize.d.ts

@@ -0,0 +1,17 @@
+import type { LLMProvider, SummarizeFormat } from "../../types/summarize.js";
+interface SummarizeCommandOptions {
+    provider?: LLMProvider;
+    model?: string;
+    format?: SummarizeFormat;
+    lang?: string;
+    targetLength?: number;
+    systemPrompt?: string;
+    verbose?: boolean;
+    section?: string;
+    tags?: string[];
+}
+/**
+ * Summarize command handler - outputs summary to stdout
+ */
+export declare const summarizeCommand: (scriptPath: string, options: SummarizeCommandOptions) => Promise<void>;
+export {};

package/lib/cli/commands/summarize.js

@@ -0,0 +1,67 @@
+import { readFileSync } from "fs";
+import { GraphAILogger } from "graphai";
+import { summarizeScript } from "../../core/summarize/index.js";
+/**
+ * Check if input is a URL
+ */
+const isUrl = (input) => {
+    return input.startsWith("http://") || input.startsWith("https://");
+};
+/**
+ * Fetch JSON from URL with timeout
+ */
+const fetchJson = async (url) => {
+    const controller = new AbortController();
+    const timeout_ms = 30000;
+    const timeoutId = setTimeout(() => controller.abort(), timeout_ms);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+};
+/**
+ * Load script from file path or URL
+ */
+const loadScript = async (input) => {
+    if (isUrl(input)) {
+        return fetchJson(input);
+    }
+    const content = readFileSync(input, "utf-8");
+    return JSON.parse(content);
+};
+/**
+ * Summarize command handler - outputs summary to stdout
+ */
+export const summarizeCommand = async (scriptPath, options) => {
+    try {
+        const script = await loadScript(scriptPath);
+        const result = await summarizeScript(script, {
+            provider: options.provider ?? "openai",
+            model: options.model,
+            format: options.format ?? "text",
+            lang: options.lang,
+            targetLengthChars: options.targetLength,
+            systemPrompt: options.systemPrompt,
+            verbose: options.verbose ?? false,
+            section: options.section,
+            tags: options.tags,
+        });
+        // Output summary to stdout
+        process.stdout.write(result.summary + "\n");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            GraphAILogger.error(`Error: ${error.message}`);
+        }
+        else {
+            GraphAILogger.error("Unknown error occurred");
+        }
+        process.exit(1);
+    }
+};

package/lib/cli/index.js

@@ -3,6 +3,7 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { processCommand } from "./commands/process.js";
 import { profilesCommand } from "./commands/profiles.js";
+import { summarizeCommand } from "./commands/summarize.js";
 yargs(hideBin(process.argv))
     .command("$0 <script>", "Process MulmoScript with profile", (builder) => builder
     .positional("script", {
@@ -20,10 +21,23 @@ yargs(hideBin(process.argv))
     alias: "o",
     describe: "Output file path (default: stdout)",
     type: "string",
+})
+    .option("section", {
+    alias: "s",
+    describe: "Filter by section name",
+    type: "string",
+})
+    .option("tags", {
+    alias: "t",
+    describe: "Filter by tags (comma-separated)",
+    type: "string",
 }), (argv) => {
+    const tags = argv.tags ? argv.tags.split(",").map((t) => t.trim()) : undefined;
     processCommand(argv.script, {
         profile: argv.profile,
         output: argv.output,
+        section: argv.section,
+        tags,
     });
 })
     .command("profiles <script>", "List available profiles in script", (builder) => builder.positional("script", {
@@ -32,10 +46,80 @@ yargs(hideBin(process.argv))
     demandOption: true,
 }), (argv) => {
     profilesCommand(argv.script);
+})
+    .command("summarize <script>", "Generate a summary of the script content", (builder) => builder
+    .positional("script", {
+    describe: "Path or URL to MulmoScript JSON file",
+    type: "string",
+    demandOption: true,
+})
+    .option("provider", {
+    describe: "LLM provider (openai, anthropic, groq, gemini)",
+    type: "string",
+    default: "openai",
+})
+    .option("model", {
+    alias: "m",
+    describe: "Model name",
+    type: "string",
+})
+    .option("format", {
+    alias: "f",
+    describe: "Output format (text, markdown)",
+    type: "string",
+    default: "text",
+})
+    .option("lang", {
+    alias: "l",
+    describe: "Output language (e.g., ja, en, zh)",
+    type: "string",
+})
+    .option("target-length", {
+    describe: "Target summary length in characters",
+    type: "number",
+})
+    .option("system-prompt", {
+    describe: "Custom system prompt",
+    type: "string",
+})
+    .option("verbose", {
+    describe: "Show detailed progress",
+    type: "boolean",
+    default: false,
+})
+    .option("section", {
+    alias: "s",
+    describe: "Filter by section name",
+    type: "string",
+})
+    .option("tags", {
+    alias: "t",
+    describe: "Filter by tags (comma-separated)",
+    type: "string",
+}), (argv) => {
+    const tags = argv.tags ? argv.tags.split(",").map((t) => t.trim()) : undefined;
+    summarizeCommand(argv.script, {
+        provider: argv.provider,
+        model: argv.model,
+        format: argv.format,
+        lang: argv.lang,
+        targetLength: argv.targetLength,
+        systemPrompt: argv.systemPrompt,
+        verbose: argv.verbose,
+        section: argv.section,
+        tags,
+    });
 })
     .example("$0 script.json --profile summary -o summary.json", "Apply summary profile and save to file")
     .example("$0 script.json -p teaser", "Apply teaser profile and output to stdout")
+    .example("$0 script.json --section chapter1", "Filter by section")
+    .example("$0 script.json --tags concept,demo", "Filter by tags")
+    .example("$0 script.json -p summary -s chapter1", "Combine profile and section filter")
     .example("$0 profiles script.json", "List all available profiles")
+    .example("$0 summarize script.json", "Generate text summary with OpenAI")
+    .example("$0 summarize script.json --format markdown", "Generate markdown summary")
+    .example("$0 summarize script.json -l ja", "Output summary in Japanese")
+    .example("$0 summarize https://example.com/script.json", "Summarize from URL")
     .help()
     .alias("h", "help")
     .version()

package/lib/core/filter.d.ts

@@ -1,13 +1,13 @@
 import type { MulmoScript } from "mulmocast";
 import type { ExtendedScript } from "../types/index.js";
 /**
- * Filter beats by section
+ * Filter beats by section (preserves meta for chaining)
  */
-export declare const filterBySection: (script: ExtendedScript, section: string) => MulmoScript;
+export declare const filterBySection: (script: ExtendedScript, section: string) => ExtendedScript;
 /**
- * Filter beats by tags (extract beats that have any of the specified tags)
+ * Filter beats by tags (preserves meta for chaining)
  */
-export declare const filterByTags: (script: ExtendedScript, tags: string[]) => MulmoScript;
+export declare const filterByTags: (script: ExtendedScript, tags: string[]) => ExtendedScript;
 /**
  * Strip variants and meta fields, converting to standard MulmoScript
  */

package/lib/core/filter.js

@@ -2,25 +2,29 @@ const stripBeatExtendedFields = (beat) => {
     const { variants: __variants, meta: __meta, ...baseBeat } = beat;
     return baseBeat;
 };
-const filterBeats = (script, predicate) => {
+const filterBeatsToMulmoScript = (script, predicate) => {
     const { outputProfiles: __outputProfiles, ...baseScript } = script;
     return {
         ...baseScript,
         beats: script.beats.filter(predicate).map(stripBeatExtendedFields),
     };
 };
+const filterBeatsPreservingMeta = (script, predicate) => ({
+    ...script,
+    beats: script.beats.filter(predicate),
+});
 /**
- * Filter beats by section
+ * Filter beats by section (preserves meta for chaining)
  */
-export const filterBySection = (script, section) => filterBeats(script, (beat) => beat.meta?.section === section);
+export const filterBySection = (script, section) => filterBeatsPreservingMeta(script, (beat) => beat.meta?.section === section);
 /**
- * Filter beats by tags (extract beats that have any of the specified tags)
+ * Filter beats by tags (preserves meta for chaining)
  */
 export const filterByTags = (script, tags) => {
     const tagSet = new Set(tags);
-    return filterBeats(script, (beat) => (beat.meta?.tags ?? []).some((tag) => tagSet.has(tag)));
+    return filterBeatsPreservingMeta(script, (beat) => (beat.meta?.tags ?? []).some((tag) => tagSet.has(tag)));
 };
 /**
  * Strip variants and meta fields, converting to standard MulmoScript
  */
-export const stripExtendedFields = (script) => filterBeats(script, () => true);
+export const stripExtendedFields = (script) => filterBeatsToMulmoScript(script, () => true);

package/lib/core/process.d.ts

@@ -2,6 +2,6 @@ import type { MulmoScript } from "mulmocast";
 import type { ExtendedScript, ProcessOptions } from "../types/index.js";
 /**
  * Main processing function
- * Applies profile and filters in a single call
+ * Applies filters first (while meta exists), then profile
  */
 export declare const processScript: (script: ExtendedScript, options?: ProcessOptions) => MulmoScript;

package/lib/core/process.js

@@ -1,16 +1,12 @@
 import { applyProfile } from "./variant.js";
 import { filterBySection, filterByTags, stripExtendedFields } from "./filter.js";
-const toExtendedScript = (script) => ({
-    ...script,
-    beats: script.beats.map((beat) => ({ ...beat })),
-});
 /**
  * Main processing function
- * Applies profile and filters in a single call
+ * Applies filters first (while meta exists), then profile
  */
 export const processScript = (script, options = {}) => {
-    const afterProfile = options.profile && options.profile !== "default" ? applyProfile(script, options.profile) : stripExtendedFields(script);
-    const afterSection = options.section ? filterBySection(toExtendedScript(afterProfile), options.section) : afterProfile;
-    const afterTags = options.tags && options.tags.length > 0 ? filterByTags(toExtendedScript(afterSection), options.tags) : afterSection;
-    return afterTags;
+    const afterSection = options.section ? filterBySection(script, options.section) : script;
+    const afterTags = options.tags && options.tags.length > 0 ? filterByTags(afterSection, options.tags) : afterSection;
+    const afterProfile = options.profile && options.profile !== "default" ? applyProfile(afterTags, options.profile) : stripExtendedFields(afterTags);
+    return afterProfile;
 };

package/lib/core/summarize/index.d.ts

@@ -0,0 +1,8 @@
+import type { ExtendedScript } from "../../types/index.js";
+import type { SummarizeOptions, SummarizeResult } from "../../types/summarize.js";
+/**
+ * Main summarize function - generates a summary of the entire script
+ */
+export declare const summarizeScript: (script: ExtendedScript, options?: Partial<SummarizeOptions>) => Promise<SummarizeResult>;
+export type { SummarizeOptions, SummarizeResult, LLMProvider, SummarizeFormat } from "../../types/summarize.js";
+export { summarizeOptionsSchema, llmProviderSchema, summarizeFormatSchema } from "../../types/summarize.js";

package/lib/core/summarize/index.js

@@ -0,0 +1,114 @@
+import dotenv from "dotenv";
+import { GraphAI, GraphAILogger } from "graphai";
+import * as vanillaAgents from "@graphai/vanilla";
+import { openAIAgent } from "@graphai/openai_agent";
+import { anthropicAgent } from "@graphai/anthropic_agent";
+import { groqAgent } from "@graphai/groq_agent";
+import { geminiAgent } from "@graphai/gemini_agent";
+import { summarizeOptionsSchema } from "../../types/summarize.js";
+import { getProviderConfig, getProviderApiKey } from "./provider.js";
+import { buildUserPrompt, getSystemPrompt } from "./prompts.js";
+import { filterBySection, filterByTags } from "../filter.js";
+dotenv.config({ quiet: true });
+const agents = vanillaAgents.default ?? vanillaAgents;
+/**
+ * Create GraphAI graph for summarizing script
+ */
+const createSummarizeGraph = (agentName) => ({
+    version: 0.5,
+    nodes: {
+        systemPrompt: {},
+        userPrompt: {},
+        model: {},
+        temperature: {},
+        maxTokens: {},
+        llmCall: {
+            agent: agentName,
+            inputs: {
+                system: ":systemPrompt",
+                prompt: ":userPrompt",
+                model: ":model",
+                temperature: ":temperature",
+                max_tokens: ":maxTokens",
+            },
+        },
+        result: {
+            isResult: true,
+            agent: "copyAgent",
+            inputs: {
+                summary: ":llmCall.text",
+            },
+        },
+    },
+});
+/**
+ * Filter script based on options (section, tags)
+ */
+const filterScript = (script, options) => {
+    const afterSection = options.section ? filterBySection(script, options.section) : script;
+    const afterTags = options.tags && options.tags.length > 0 ? filterByTags(afterSection, options.tags) : afterSection;
+    return afterTags;
+};
+/**
+ * Main summarize function - generates a summary of the entire script
+ */
+export const summarizeScript = async (script, options = {}) => {
+    // Validate and apply defaults
+    const validatedOptions = summarizeOptionsSchema.parse(options);
+    const providerConfig = getProviderConfig(validatedOptions.provider);
+    const apiKey = getProviderApiKey(validatedOptions.provider);
+    if (!apiKey) {
+        throw new Error(`API key not found for provider "${validatedOptions.provider}". ` + `Please set the ${providerConfig.keyName} environment variable.`);
+    }
+    // Filter script if section/tags specified
+    const filteredScript = filterScript(script, validatedOptions);
+    const scriptTitle = script.title || "Untitled";
+    if (filteredScript.beats.length === 0) {
+        return {
+            summary: "No content to summarize.",
+            format: validatedOptions.format,
+            scriptTitle,
+            beatCount: 0,
+        };
+    }
+    // Build GraphAI config
+    const config = {
+        openAIAgent: { apiKey: process.env.OPENAI_API_KEY },
+        anthropicAgent: { apiKey: process.env.ANTHROPIC_API_KEY },
+        groqAgent: { apiKey: process.env.GROQ_API_KEY },
+        geminiAgent: { apiKey: process.env.GEMINI_API_KEY },
+    };
+    // Create GraphAI instance
+    const graph = new GraphAI(createSummarizeGraph(providerConfig.agentName), {
+        ...agents,
+        openAIAgent,
+        anthropicAgent,
+        groqAgent,
+        geminiAgent,
+    }, { config });
+    // Build prompts
+    const systemPrompt = getSystemPrompt(validatedOptions);
+    const userPrompt = buildUserPrompt(filteredScript, validatedOptions);
+    if (validatedOptions.verbose) {
+        GraphAILogger.info(`Summarizing script "${script.title}" with ${validatedOptions.provider}...`);
+        GraphAILogger.info(`Beats: ${filteredScript.beats.length}, Format: ${validatedOptions.format}`);
+    }
+    // Inject values
+    graph.injectValue("systemPrompt", systemPrompt);
+    graph.injectValue("userPrompt", userPrompt);
+    graph.injectValue("model", validatedOptions.model ?? providerConfig.defaultModel);
+    graph.injectValue("temperature", validatedOptions.temperature ?? 0.7);
+    graph.injectValue("maxTokens", validatedOptions.maxTokens ?? providerConfig.maxTokens ?? 2048);
+    // Run graph
+    const graphResult = await graph.run();
+    // Extract summary from result node
+    const resultNode = graphResult.result;
+    const summary = resultNode?.summary || "";
+    return {
+        summary,
+        format: validatedOptions.format,
+        scriptTitle,
+        beatCount: filteredScript.beats.length,
+    };
+};
+export { summarizeOptionsSchema, llmProviderSchema, summarizeFormatSchema } from "../../types/summarize.js";

package/lib/core/summarize/prompts.d.ts

@@ -0,0 +1,18 @@
+import type { SummarizeOptions } from "../../types/summarize.js";
+import type { ExtendedScript } from "../../types/index.js";
+/**
+ * Default system prompt for text summary
+ */
+export declare const DEFAULT_SYSTEM_PROMPT_TEXT = "You are creating a summary based on the content provided.\n- Extract and explain the actual information and knowledge from the content\n- Do NOT describe what the presentation/script is about (avoid phrases like \"this presentation explains...\" or \"the script describes...\")\n- Write as if you are directly explaining the topic to the reader\n- Be concise and informative\n- Output plain text only";
+/**
+ * Default system prompt for markdown summary
+ */
+export declare const DEFAULT_SYSTEM_PROMPT_MARKDOWN = "You are creating a summary based on the content provided.\n- Extract and explain the actual information and knowledge from the content\n- Do NOT describe what the presentation/script is about (avoid phrases like \"this presentation explains...\" or \"the script describes...\")\n- Write as if you are directly explaining the topic to the reader\n- Use markdown formatting (headers, bullet points, etc.)\n- Include a title, key points, and conclusion\n- Output well-formatted markdown";
+/**
+ * Build user prompt from entire script
+ */
+export declare const buildUserPrompt: (script: ExtendedScript, options: SummarizeOptions) => string;
+/**
+ * Get system prompt based on format and language
+ */
+export declare const getSystemPrompt: (options: SummarizeOptions) => string;

package/lib/core/summarize/prompts.js

@@ -0,0 +1,87 @@
+/**
+ * Default system prompt for text summary
+ */
+export const DEFAULT_SYSTEM_PROMPT_TEXT = `You are creating a summary based on the content provided.
+- Extract and explain the actual information and knowledge from the content
+- Do NOT describe what the presentation/script is about (avoid phrases like "this presentation explains..." or "the script describes...")
+- Write as if you are directly explaining the topic to the reader
+- Be concise and informative
+- Output plain text only`;
+/**
+ * Default system prompt for markdown summary
+ */
+export const DEFAULT_SYSTEM_PROMPT_MARKDOWN = `You are creating a summary based on the content provided.
+- Extract and explain the actual information and knowledge from the content
+- Do NOT describe what the presentation/script is about (avoid phrases like "this presentation explains..." or "the script describes...")
+- Write as if you are directly explaining the topic to the reader
+- Use markdown formatting (headers, bullet points, etc.)
+- Include a title, key points, and conclusion
+- Output well-formatted markdown`;
+/**
+ * Build user prompt from entire script
+ */
+export const buildUserPrompt = (script, options) => {
+    const parts = [];
+    // Add script metadata
+    parts.push(`# Script: ${script.title}`);
+    parts.push(`Language: ${script.lang}`);
+    parts.push("");
+    // Collect all text from beats
+    const sections = new Map();
+    script.beats.forEach((beat, index) => {
+        const text = beat.text || "";
+        if (!text.trim())
+            return;
+        const section = beat.meta?.section || "main";
+        if (!sections.has(section)) {
+            sections.set(section, []);
+        }
+        sections.get(section).push(`[${index}] ${text}`);
+    });
+    // Output by section
+    sections.forEach((texts, section) => {
+        parts.push(`## Section: ${section}`);
+        texts.forEach((t) => parts.push(t));
+        parts.push("");
+    });
+    // Add target length if specified
+    if (options.targetLengthChars) {
+        parts.push(`Target summary length: approximately ${options.targetLengthChars} characters`);
+    }
+    parts.push("");
+    parts.push("Based on the above content, explain the topic directly to the reader:");
+    return parts.join("\n");
+};
+/**
+ * Get language name from code
+ */
+const getLanguageName = (langCode) => {
+    const langMap = {
+        ja: "Japanese",
+        en: "English",
+        zh: "Chinese",
+        ko: "Korean",
+        fr: "French",
+        de: "German",
+        es: "Spanish",
+        it: "Italian",
+        pt: "Portuguese",
+        ru: "Russian",
+    };
+    return langMap[langCode] || langCode;
+};
+/**
+ * Get system prompt based on format and language
+ */
+export const getSystemPrompt = (options) => {
+    if (options.systemPrompt) {
+        return options.systemPrompt;
+    }
+    const basePrompt = options.format === "markdown" ? DEFAULT_SYSTEM_PROMPT_MARKDOWN : DEFAULT_SYSTEM_PROMPT_TEXT;
+    // Add language instruction if specified
+    if (options.lang) {
+        const langName = getLanguageName(options.lang);
+        return `${basePrompt}\n- IMPORTANT: Write the output in ${langName}`;
+    }
+    return basePrompt;
+};

package/lib/core/summarize/provider.d.ts

@@ -0,0 +1,14 @@
+import type { ProviderConfig, LLMProvider } from "../../types/summarize.js";
+/**
+ * Provider to LLM agent configuration mapping
+ * Following mulmocast-cli provider2agent pattern
+ */
+export declare const provider2SummarizeAgent: Record<LLMProvider, ProviderConfig>;
+/**
+ * Get provider config by provider name
+ */
+export declare const getProviderConfig: (provider: LLMProvider) => ProviderConfig;
+/**
+ * Get API key from environment for provider
+ */
+export declare const getProviderApiKey: (provider: LLMProvider) => string | undefined;

package/lib/core/summarize/provider.js

@@ -0,0 +1,43 @@
+/**
+ * Provider to LLM agent configuration mapping
+ * Following mulmocast-cli provider2agent pattern
+ */
+export const provider2SummarizeAgent = {
+    openai: {
+        agentName: "openAIAgent",
+        defaultModel: "gpt-4o-mini",
+        keyName: "OPENAI_API_KEY",
+        maxTokens: 8192,
+    },
+    anthropic: {
+        agentName: "anthropicAgent",
+        defaultModel: "claude-sonnet-4-20250514",
+        keyName: "ANTHROPIC_API_KEY",
+        maxTokens: 8192,
+    },
+    groq: {
+        agentName: "groqAgent",
+        defaultModel: "llama-3.1-8b-instant",
+        keyName: "GROQ_API_KEY",
+        maxTokens: 4096,
+    },
+    gemini: {
+        agentName: "geminiAgent",
+        defaultModel: "gemini-2.0-flash",
+        keyName: "GEMINI_API_KEY",
+        maxTokens: 8192,
+    },
+};
+/**
+ * Get provider config by provider name
+ */
+export const getProviderConfig = (provider) => {
+    return provider2SummarizeAgent[provider];
+};
+/**
+ * Get API key from environment for provider
+ */
+export const getProviderApiKey = (provider) => {
+    const config = provider2SummarizeAgent[provider];
+    return process.env[config.keyName];
+};

package/lib/index.d.ts

@@ -2,5 +2,8 @@ export { processScript } from "./core/process.js";
 export { applyProfile } from "./core/variant.js";
 export { filterBySection, filterByTags, stripExtendedFields } from "./core/filter.js";
 export { listProfiles } from "./core/profiles.js";
+export { summarizeScript } from "./core/summarize/index.js";
 export type { BeatVariant, BeatMeta, ExtendedBeat, ExtendedScript, OutputProfile, ProcessOptions, ProfileInfo } from "./types/index.js";
+export type { SummarizeOptions, SummarizeResult, LLMProvider, SummarizeFormat, ProviderConfig } from "./types/summarize.js";
 export { beatVariantSchema, beatMetaSchema, extendedBeatSchema, extendedScriptSchema, outputProfileSchema } from "./types/index.js";
+export { summarizeOptionsSchema, llmProviderSchema, summarizeFormatSchema } from "./types/summarize.js";

package/lib/index.js

@@ -3,5 +3,8 @@ export { processScript } from "./core/process.js";
 export { applyProfile } from "./core/variant.js";
 export { filterBySection, filterByTags, stripExtendedFields } from "./core/filter.js";
 export { listProfiles } from "./core/profiles.js";
+// Summarize API
+export { summarizeScript } from "./core/summarize/index.js";
 // Schemas (for validation)
 export { beatVariantSchema, beatMetaSchema, extendedBeatSchema, extendedScriptSchema, outputProfileSchema } from "./types/index.js";
+export { summarizeOptionsSchema, llmProviderSchema, summarizeFormatSchema } from "./types/summarize.js";

package/lib/types/summarize.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+/**
+ * LLM Provider - supported providers for summarization
+ */
+export declare const llmProviderSchema: z.ZodEnum<{
+    openai: "openai";
+    anthropic: "anthropic";
+    groq: "groq";
+    gemini: "gemini";
+}>;
+export type LLMProvider = z.infer<typeof llmProviderSchema>;
+/**
+ * Output format for summary
+ */
+export declare const summarizeFormatSchema: z.ZodEnum<{
+    text: "text";
+    markdown: "markdown";
+}>;
+export type SummarizeFormat = z.infer<typeof summarizeFormatSchema>;
+/**
+ * Summarize Options - configuration for summarization
+ */
+export declare const summarizeOptionsSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        openai: "openai";
+        anthropic: "anthropic";
+        groq: "groq";
+        gemini: "gemini";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodDefault<z.ZodEnum<{
+        text: "text";
+        markdown: "markdown";
+    }>>;
+    lang: z.ZodOptional<z.ZodString>;
+    targetLengthChars: z.ZodOptional<z.ZodNumber>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    section: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SummarizeOptions = z.infer<typeof summarizeOptionsSchema>;
+/**
+ * Summarize Result - the generated summary
+ */
+export interface SummarizeResult {
+    summary: string;
+    format: SummarizeFormat;
+    scriptTitle: string;
+    beatCount: number;
+}
+/**
+ * Provider Config - configuration for LLM provider
+ */
+export interface ProviderConfig {
+    agentName: string;
+    defaultModel: string;
+    keyName: string;
+    maxTokens?: number;
+}

package/lib/types/summarize.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+/**
+ * LLM Provider - supported providers for summarization
+ */
+export const llmProviderSchema = z.enum(["openai", "anthropic", "groq", "gemini"]);
+/**
+ * Output format for summary
+ */
+export const summarizeFormatSchema = z.enum(["text", "markdown"]);
+/**
+ * Summarize Options - configuration for summarization
+ */
+export const summarizeOptionsSchema = z.object({
+    // LLM settings
+    provider: llmProviderSchema.default("openai"),
+    model: z.string().optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().positive().optional(),
+    // Output format
+    format: summarizeFormatSchema.default("text"),
+    // Output language (e.g., "ja", "en", "fr")
+    lang: z.string().optional(),
+    // Target length (optional)
+    targetLengthChars: z.number().positive().optional(),
+    // Custom prompt
+    systemPrompt: z.string().optional(),
+    // Processing options
+    verbose: z.boolean().default(false),
+    // Beat filtering
+    section: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast-preprocessor",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Preprocessor for MulmoScript",
   "type": "module",
   "main": "lib/index.js",
@@ -34,6 +34,12 @@
   },
   "homepage": "https://github.com/receptron/mulmocast-plus#readme",
   "dependencies": {
+    "@graphai/anthropic_agent": "^2.0.12",
+    "@graphai/gemini_agent": "^2.0.5",
+    "@graphai/groq_agent": "^2.0.2",
+    "@graphai/openai_agent": "^2.0.9",
+    "@graphai/vanilla": "^2.0.12",
+    "dotenv": "^17.2.4",
     "graphai": "^2.0.16",
     "mulmocast": "^2.1.35",
     "yargs": "^18.0.0",