mulmocast-preprocessor 0.1.0

package/README.md

@@ -0,0 +1,160 @@
+# mulmocast-preprocessor
+
+Preprocessor for MulmoScript that enables generating multiple variations (full, summary, teaser, etc.) from a single script.
+
+## Installation
+
+```bash
+npm install mulmocast-preprocessor
+```
+
+## Features
+
+- **Profile-based variants**: Generate different versions (summary, teaser) from one script
+- **Section filtering**: Extract beats by section
+- **Tag filtering**: Extract beats by tags
+- **Profile listing**: List available profiles with beat counts
+- **CLI tool**: Command-line interface for processing scripts
+
+## CLI Usage
+
+```bash
+# Process script with profile
+mulmocast-preprocessor script.json --profile summary -o summary.json
+
+# Output to stdout (for piping)
+mulmocast-preprocessor script.json --profile teaser
+
+# List available profiles
+mulmocast-preprocessor profiles script.json
+```
+
+### CLI Options
+
+| Option | Alias | Description |
+|--------|-------|-------------|
+| `--profile <name>` | `-p` | Profile name to apply (default: "default") |
+| `--output <path>` | `-o` | Output file path (default: stdout) |
+| `--help` | `-h` | Show help |
+| `--version` | `-v` | Show version |
+
+## Programmatic Usage
+
+### Basic Example
+
+```typescript
+import { processScript, listProfiles, applyProfile } from "mulmocast-preprocessor";
+import type { ExtendedScript } from "mulmocast-preprocessor";
+
+const script: ExtendedScript = {
+  title: "My Presentation",
+  beats: [
+    {
+      text: "Full introduction text here...",
+      variants: {
+        summary: { text: "Brief intro" },
+        teaser: { skip: true }
+      },
+      meta: { section: "intro", tags: ["important"] }
+    },
+    {
+      text: "Main content...",
+      meta: { section: "main", tags: ["core"] }
+    }
+  ]
+};
+
+// List available profiles
+const profiles = listProfiles(script);
+// [{ name: "default", beatCount: 2 }, { name: "summary", beatCount: 2 }, { name: "teaser", beatCount: 1, skippedCount: 1 }]
+
+// Generate summary version
+const summary = applyProfile(script, "summary");
+// First beat's text is replaced with "Brief intro"
+
+// Process with multiple options
+const result = processScript(script, {
+  profile: "summary",
+  section: "intro"
+});
+```
+
+## API
+
+### `processScript(script, options)`
+
+Main processing function that applies profile and filters.
+
+**Parameters:**
+- `script: ExtendedScript` - Input script with variants/meta
+- `options: ProcessOptions` - Processing options
+  - `profile?: string` - Profile name to apply
+  - `section?: string` - Filter by section
+  - `tags?: string[]` - Filter by tags (OR logic)
+
+**Returns:** `MulmoScript` - Standard MulmoScript with variants/meta stripped
+
+### `applyProfile(script, profileName)`
+
+Apply a profile to the script, replacing text/image and skipping marked beats.
+
+**Parameters:**
+- `script: ExtendedScript` - Input script
+- `profileName: string` - Profile name
+
+**Returns:** `MulmoScript` - Processed script
+
+### `listProfiles(script)`
+
+Get list of available profiles from script.
+
+**Parameters:**
+- `script: ExtendedScript` - Input script
+
+**Returns:** `ProfileInfo[]` - Array of profile info with beat counts
+
+### `filterBySection(script, section)`
+
+Filter beats by section.
+
+### `filterByTags(script, tags)`
+
+Filter beats by tags (extracts beats that have any of the specified tags).
+
+## Extended Schema
+
+### ExtendedBeat
+
+```typescript
+interface ExtendedBeat extends MulmoBeat {
+  variants?: Record<string, BeatVariant>;
+  meta?: BeatMeta;
+}
+```
+
+### BeatVariant
+
+```typescript
+interface BeatVariant {
+  text?: string;       // Override text
+  skip?: boolean;      // Skip this beat
+  image?: MulmoImage;  // Override image
+  imagePrompt?: string; // Override imagePrompt
+}
+```
+
+### BeatMeta
+
+```typescript
+interface BeatMeta {
+  tags?: string[];
+  section?: string;
+  context?: string;
+  keywords?: string[];
+  expectedQuestions?: string[];
+}
+```
+
+## License
+
+MIT

package/lib/actions/index.d.ts

@@ -0,0 +1 @@
+export declare const preprocessorVersion = "0.0.1";

package/lib/actions/index.js

@@ -0,0 +1,3 @@
+// Preprocessor actions
+// TODO: implement preprocessor functionality
+export const preprocessorVersion = "0.0.1";

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

@@ -0,0 +1,9 @@
+interface ProcessOptions {
+    profile?: string;
+    output?: string;
+}
+/**
+ * Process script with profile and output result
+ */
+export declare const processCommand: (scriptPath: string, options: ProcessOptions) => void;
+export {};

package/lib/cli/commands/process.js

@@ -0,0 +1,32 @@
+import { readFileSync, writeFileSync } from "fs";
+import { GraphAILogger } from "graphai";
+import { processScript } from "../../core/process.js";
+/**
+ * Process script with profile and output result
+ */
+export const processCommand = (scriptPath, options) => {
+    try {
+        const content = readFileSync(scriptPath, "utf-8");
+        const script = JSON.parse(content);
+        const result = processScript(script, {
+            profile: options.profile,
+        });
+        const output = JSON.stringify(result, null, 2);
+        if (options.output) {
+            writeFileSync(options.output, output);
+            GraphAILogger.info(`Output written to ${options.output}`);
+        }
+        else {
+            process.stdout.write(output + "\n");
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            GraphAILogger.error(`Error: ${error.message}`);
+        }
+        else {
+            GraphAILogger.error("Unknown error occurred");
+        }
+        process.exit(1);
+    }
+};

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

@@ -0,0 +1,4 @@
+/**
+ * List available profiles in script
+ */
+export declare const profilesCommand: (scriptPath: string) => void;

package/lib/cli/commands/profiles.js

@@ -0,0 +1,32 @@
+import { readFileSync } from "fs";
+import { GraphAILogger } from "graphai";
+import { listProfiles } from "../../core/profiles.js";
+/**
+ * List available profiles in script
+ */
+export const profilesCommand = (scriptPath) => {
+    try {
+        const content = readFileSync(scriptPath, "utf-8");
+        const script = JSON.parse(content);
+        const profiles = listProfiles(script);
+        GraphAILogger.log("\nAvailable profiles:");
+        profiles.forEach((profile) => {
+            const displayName = profile.displayName ? ` (${profile.displayName})` : "";
+            const skipped = profile.skippedCount > 0 ? `, ${profile.skippedCount} skipped` : "";
+            GraphAILogger.log(`  ${profile.name}${displayName}: ${profile.beatCount} beats${skipped}`);
+            if (profile.description) {
+                GraphAILogger.log(`    ${profile.description}`);
+            }
+        });
+        GraphAILogger.log("");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            GraphAILogger.error(`Error: ${error.message}`);
+        }
+        else {
+            GraphAILogger.error("Unknown error occurred");
+        }
+        process.exit(1);
+    }
+};

package/lib/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/cli/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { processCommand } from "./commands/process.js";
+import { profilesCommand } from "./commands/profiles.js";
+yargs(hideBin(process.argv))
+    .command("$0 <script>", "Process MulmoScript with profile", (builder) => builder
+    .positional("script", {
+    describe: "Path to MulmoScript JSON file",
+    type: "string",
+    demandOption: true,
+})
+    .option("profile", {
+    alias: "p",
+    describe: "Profile name to apply",
+    type: "string",
+    default: "default",
+})
+    .option("output", {
+    alias: "o",
+    describe: "Output file path (default: stdout)",
+    type: "string",
+}), (argv) => {
+    processCommand(argv.script, {
+        profile: argv.profile,
+        output: argv.output,
+    });
+})
+    .command("profiles <script>", "List available profiles in script", (builder) => builder.positional("script", {
+    describe: "Path to MulmoScript JSON file",
+    type: "string",
+    demandOption: true,
+}), (argv) => {
+    profilesCommand(argv.script);
+})
+    .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 profiles script.json", "List all available profiles")
+    .help()
+    .alias("h", "help")
+    .version()
+    .alias("v", "version")
+    .strict()
+    .parse();

package/lib/core/filter.d.ts

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

package/lib/core/filter.js

@@ -0,0 +1,26 @@
+const stripBeatExtendedFields = (beat) => {
+    const { variants: __variants, meta: __meta, ...baseBeat } = beat;
+    return baseBeat;
+};
+const filterBeats = (script, predicate) => {
+    const { outputProfiles: __outputProfiles, ...baseScript } = script;
+    return {
+        ...baseScript,
+        beats: script.beats.filter(predicate).map(stripBeatExtendedFields),
+    };
+};
+/**
+ * Filter beats by section
+ */
+export const filterBySection = (script, section) => filterBeats(script, (beat) => beat.meta?.section === section);
+/**
+ * Filter beats by tags (extract beats that have any of the specified tags)
+ */
+export const filterByTags = (script, tags) => {
+    const tagSet = new Set(tags);
+    return filterBeats(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);

package/lib/core/process.d.ts

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

package/lib/core/process.js

@@ -0,0 +1,16 @@
+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
+ */
+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;
+};

package/lib/core/profiles.d.ts

@@ -0,0 +1,5 @@
+import type { ExtendedScript, ProfileInfo } from "../types/index.js";
+/**
+ * Get list of available profiles from script
+ */
+export declare const listProfiles: (script: ExtendedScript) => ProfileInfo[];

package/lib/core/profiles.js

@@ -0,0 +1,38 @@
+/**
+ * Get list of available profiles from script
+ */
+export const listProfiles = (script) => {
+    const profileNames = new Set(["default"]);
+    script.beats
+        .filter((beat) => beat.variants)
+        .flatMap((beat) => Object.keys(beat.variants))
+        .forEach((name) => profileNames.add(name));
+    const buildProfileInfo = (profileName) => {
+        const outputProfile = script.outputProfiles?.[profileName];
+        const { beatCount, skippedCount } = profileName === "default"
+            ? { beatCount: script.beats.length, skippedCount: 0 }
+            : script.beats.reduce((acc, beat) => {
+                const isSkipped = beat.variants?.[profileName]?.skip === true;
+                return {
+                    beatCount: acc.beatCount + (isSkipped ? 0 : 1),
+                    skippedCount: acc.skippedCount + (isSkipped ? 1 : 0),
+                };
+            }, { beatCount: 0, skippedCount: 0 });
+        return {
+            name: profileName,
+            displayName: outputProfile?.name,
+            description: outputProfile?.description,
+            beatCount,
+            skippedCount,
+        };
+    };
+    return Array.from(profileNames)
+        .map(buildProfileInfo)
+        .sort((a, b) => {
+        if (a.name === "default")
+            return -1;
+        if (b.name === "default")
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+};

package/lib/core/variant.d.ts

@@ -0,0 +1,6 @@
+import type { MulmoScript } from "mulmocast";
+import type { ExtendedScript } from "../types/index.js";
+/**
+ * Apply profile to script and return standard MulmoScript
+ */
+export declare const applyProfile: (script: ExtendedScript, profileName: string) => MulmoScript;

package/lib/core/variant.js

@@ -0,0 +1,26 @@
+/**
+ * Apply profile variant to a single beat
+ * @returns Processed beat, or null if skip is set
+ */
+const applyVariantToBeat = (beat, profileName) => {
+    const variant = beat.variants?.[profileName];
+    if (variant?.skip) {
+        return null;
+    }
+    const { variants: __variants, meta: __meta, ...baseBeat } = beat;
+    if (!variant) {
+        return baseBeat;
+    }
+    const { skip: __skip, ...overrides } = variant;
+    return { ...baseBeat, ...overrides };
+};
+/**
+ * Apply profile to script and return standard MulmoScript
+ */
+export const applyProfile = (script, profileName) => {
+    const { outputProfiles: __outputProfiles, ...baseScript } = script;
+    return {
+        ...baseScript,
+        beats: script.beats.map((beat) => applyVariantToBeat(beat, profileName)).filter((beat) => beat !== null),
+    };
+};

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+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 type { BeatVariant, BeatMeta, ExtendedBeat, ExtendedScript, OutputProfile, ProcessOptions, ProfileInfo } from "./types/index.js";
+export { beatVariantSchema, beatMetaSchema, extendedBeatSchema, extendedScriptSchema, outputProfileSchema } from "./types/index.js";

package/lib/index.js

@@ -0,0 +1,7 @@
+// Core API
+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";
+// Schemas (for validation)
+export { beatVariantSchema, beatMetaSchema, extendedBeatSchema, extendedScriptSchema, outputProfileSchema } from "./types/index.js";