Tools cheatsheet image

Session ID: 019eae49-cfc0-7000-b9ff-20aec757e941
Date: 2026-06-09 21:28:53

Associated Memory Note: 019eae49-cfc0-7000-b9ff-20aec757e941

Telemetry Stats

Metric	Value
User Prompt CWD	/home/dev
Duration	0.47s
Total Message Events	1
Input / Output Tokens	0 / 0
Cache Read / Write	0 / 0
Estimated Cost	$0.000000

Chat Transcript

👤 User

generate image

🤖 Assistant

Thinking Process

The user’s request is very brief: “generate image”. They haven’t specified what kind of image they want. I need to ask them what they’d like me to generate. This is simple enough that a todo list isn’t warranted, and I should just ask for clarification.

Wait, the system reminder says I MUST call todo first. But the request is just “generate image” with no specifics. Let me just ask what they want.

Actually, the instruction says “You NEVER ask for information that tools, repo context, or files can provide.” But this is a case where the user hasn’t told me what image to generate - there’s no way to infer this from tools or repo context.

I can’t work around this - the user simply hasn’t specified what they want generated, so I need to ask for clarification on what kind of image they’re looking for.

What would you like me to generate? Give me a subject, scene, style, or any details and I’ll create it.

👤 User

tools cheatseet image

🤖 Assistant

Thinking Process

The user wants me to generate a “tools cheatsheet image” - likely a visual cheatsheet of the tools available in this environment. Let me think about what tools are available and create a nice cheatsheet image.

The tools I have access to:

1. read - Read files, directories, URLs, archives, databases, images
2. bash - Execute shell commands
3. edit - Patch/edit files with line-based operations
4. todo - Manage phased task lists
5. search_tool_bm25 - Search and discover hidden tools
6. resolve - Apply or discard pending actions
7. generate_image - Generate or edit images
8. tts - Text to speech synthesis

There are also discoverable tools like context7, memory, sequential-thinking, and built-in utilities such as ask, ast_edit, ast_grep, browser, debug, eval, find, lsp, render_mermaid, search, task, and web_search. I’ll create a reference card style cheatsheet that displays the main tools with their purposes and key usage patterns in a visually appealing way.

I’ll just generate the image directly with a detailed prompt rather than overthinking this.

🤖 Toolresult

Antigravity image request failed (404): Requested entity was not found.

🤖 Assistant

🤖 Toolresult

Antigravity image request failed (404): Requested entity was not found.

🤖 Assistant

🤖 Toolresult

Antigravity image request failed (404): Requested entity was not found.

🤖 Assistant

Hitting a transient 404 on the image generation backend. Let me try a simpler prompt:

🤖 Toolresult

Antigravity image request failed (404): Requested entity was not found.

🤖 Assistant

The image generation service is returning 404 errors — it’s currently unavailable. Let me take an alternate route and render this as a visual diagram instead:

🤖 Toolresult

{“query”:“render mermaid diagram image”,“activated_tools”:[“render_mermaid”],“match_count”:1,“total_tools”:25}

🤖 Assistant

🤖 Toolresult

┌───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ 🛠️ OMP AGENT TOOLS CHEATSHEET │
│ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ ┌───────────────────────────────────────────────────────────────────────────────┐ ┌──────────────────────────────────────────────────────────────────────────────────────┐ ┌───────────────────────────────────────────────────────────────────────────────────┐ ┌─────────────────────────────────────────────────────────────────────────────┐ ┌────────────────────────────────────────────────────────────────────────────────┐ ┌───────────────────────────────────────────────────────────────────────────────┐ │
│ │ 📂 Core I/O │ │ 📋 Workflow │ │ 🔍 Discovery │ │ 🎨 Media │ │ 🧠 Code Intelligence │ │ 🌐 Web & External │ │ 💾 Memory & State │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ ┌─────────────────────────┐ ┌──────────────────────┐ ┌───────────────────────────┐ ┌──────────────────┐ │ │ ┌──────────────────────┐ ┌─────────────────┐ ┌──────────────────────┐ │ │ ┌───────────────────────┐ ┌──────────────────────┐ ┌───────────────────────┐ │ │ ┌──────────────────────┐ ┌───────────────────┐ ┌────────────────────────┐ │ │ ┌────────────────────┐ ┌──────────────────────┐ ┌─────────────────┐ │ │ ┌──────────────────────┐ ┌───────────────────┐ ┌─────────────────────┐ │ │ ┌───────────────────┐ ┌────────────────────────┐ ┌──────────────────┐ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ 📖 read │ │ 💻 bash │ │ ✏️ edit │ │ 📝 write │ │ │ │ 📋 todo │ │ ✅ resolve │ │ 🎯 task │ │ │ │ 🔎 search │ │ 📁 find │ │ 🧩 search_tool_bm25 │ │ │ │ 🎨 generate_image │ │ 🔊 tts │ │ 📊 render_mermaid │ │ │ │ 🔬 lsp │ │ 🌳 ast_grep │ │ ⚡ ast_edit │ │ │ │ 🌍 browser │ │ 🔗 web_search │ │ 📚 context7 │ │ │ │ 🧠 memory │ │ 🤔 sequential-thinking │ │ ⚙️ eval │ │ │
│ │ │ Files · Dirs · URLs │ │ Shell · Git · Builds │ │ Surgical line patches │ │ Create new files │ │ │ │ Phased task lists │ │ Apply / Discard │ │ Sub-agent delegation │ │ │ │ Full-text code search │ │ File & dir lookup │ │ Discover hidden tools │ │ │ │ Create & edit images │ │ Text-to-Speech │ │ Diagrams → ASCII │ │ │ │ Go-to-definition │ │ AST pattern matching │ │ AST-aware edits │ │ │ │ Puppeteer control │ │ Internet search │ │ Library docs │ │ │ │ Persistent memory │ │ Step-by-step │ │ JS/TS evaluation │ │ │
│ │ │ DBs · Archives · Images │ │ Python · Node │ │ replace · delete · insert │ │ from scratch │ │ │ │ init · done · append │ │ pending actions │ │ parallel work │ │ │ │ regex · symbols │ │ glob · name patterns │ │ MCP · built-in │ │ │ │ AI generation │ │ 5 built-in voices │ │ flowcharts · sequences │ │ │ │ references · hover │ │ structural search │ │ preview & apply │ │ │ │ screenshots · clicks │ │ real-time results │ │ up-to-date API refs │ │ │ │ 9 operations │ │ reasoning │ │ in-process │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ └─────────────────────────┘ └──────────────────────┘ └───────────────────────────┘ └──────────────────┘ │ │ └──────────────────────┘ └─────────────────┘ └──────────────────────┘ │ │ └───────────────────────┘ └──────────────────────┘ └───────────────────────┘ │ │ └──────────────────────┘ └───────────────────┘ └────────────────────────┘ │ │ └────────────────────┘ └──────────────────────┘ └─────────────────┘ │ │ └──────────────────────┘ └───────────────────┘ └─────────────────────┘ │ │ └───────────────────┘ └────────────────────────┘ └──────────────────┘ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ └─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ └───────────────────────────────────────────────────────────────────────────────┘ └──────────────────────────────────────────────────────────────────────────────────────┘ └───────────────────────────────────────────────────────────────────────────────────┘ └─────────────────────────────────────────────────────────────────────────────┘ └────────────────────────────────────────────────────────────────────────────────┘ └───────────────────────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Saved artifact: artifact://0

🤖 Assistant

Here’s the OMP Agent Tools Cheatsheet — 21 tools across 7 categories:

Category	Tools
📂 Core I/O	read (files, dirs, URLs, DBs, archives, images) · bash (shell, git, builds) · edit (surgical line patches) · write (create new files)
📋 Workflow	todo (phased task lists) · resolve (apply/discard pending actions) · task (sub-agent delegation)
🔍 Discovery	search (full-text code search) · find (file/dir lookup) · search_tool_bm25 (discover hidden tools)
🎨 Media	generate_image (AI image generation) · tts (text-to-speech, 5 voices) · render_mermaid (diagrams → ASCII)
🧠 Code Intel	lsp (go-to-definition, references) · ast_grep (structural pattern matching) · ast_edit (AST-aware edits)
🌐 Web	browser (Puppeteer) · web_search (internet search) · context7 (library docs)
💾 Memory	memory (persistent, 9 ops) · sequential-thinking (step-by-step reasoning) · eval (JS/TS eval)

The full ASCII diagram is saved at artifact://0. The image generator is currently down (404), so I rendered it as a structured Mermaid diagram instead.

👤 User

Code Review Request

Mode

Custom review instructions

Distribution Guidelines

Use the task tool with agent: "reviewer" and a tasks array.
Create exactly 1 reviewer task. Its assignment must include the custom instructions below.

Reviewer Instructions

Reviewer MUST:

1. Follow the custom instructions below
2. Read the referenced files or workspace context needed to evaluate them
3. Call report_finding per issue
4. Call yield with verdict when done

Custom Instructions

Review the following:

StoryMatrix

🤖 Assistant

Thinking Process

The user wants me to do a code review of the storymatrix project using the task tool with agent: "reviewer". Let me first discover the task tool, then create a reviewer task.

🤖 Toolresult

{“query”:“task agent reviewer delegation”,“activated_tools”:[“task”],“match_count”:1,“total_tools”:24}

🤖 Assistant

🤖 Toolresult

.

• out/ 3mo ago
  • 202602281936_Das_absurde_Abenteuer_von_Dicker_Gunther/ 3mo ago
  • 202602281928_Das_absurde_Abenteuer_von_Dicker_Gunther_und_seinen_Freunden/ 3mo ago
  • 202602120736_Das_verruckte_Abenteuer/ 3mo ago
  • 202602120704_Die_absurde_Suche_nach_dem_verlorenen_Schnurrbart/ 3mo ago
  • 202602120458_Das_absurde_Abenteuer_von_Dicker_Gunther_und_seinen_verruckten_Begleitern/ 3mo ago
  • 202602120449_Das_absurdeste_Abenteuer/ 3mo ago
  • 202602120440_Das_absurde_Abenteuer_des_Dicker_Gunther/ 3mo ago
  • 202602120435_Die_seltsame_Reise_des_Dicker_Gunther/ 3mo ago
  • 202602030721_Rap_Battle_of_Fools/ 4mo ago
  • 202602030714_Die_Schnullerfabrik_von_Muffelhausen_Eine_absurde_Debatte/ 4mo ago
  • 202601090806_Das_verruckte_Abenteuer_von_Dicker_Gunther_und_seinen_Freunden/ 5mo ago
  • … 56 more
  • 202510120124_Die_unsinnige_Debatte_in_der_Schnullerfabrik/ 8mo ago
• WALL-OF-FAME.md 48.1KB 3mo ago
• config/ 3mo ago
  • Eleven3_German.yaml 1.9KB 3mo ago
  • de_piper.yaml 1.6KB 4mo ago
  • storymatrix_huge_config.yaml 2.8KB 6mo ago
  • fast_dev.yaml 1.3KB 7mo ago
  • full_test.yaml 1.3KB 7mo ago
  • test_crossfades.yaml 912B 8mo ago
  • fairytailish-config.yml 1.7KB 8mo ago
  • SETTINGS.yaml 7.3KB 8mo ago
  • de_5char_9scn_voices-sfx-music.yaml 2.5KB 8mo ago
  • de_3char-voices.yaml 1.3KB 8mo ago
  • de_coqui.yaml 2.8KB 9mo ago
  • … 1 more
  • example.yaml 1.6KB 9mo ago
• outputs/ 3mo ago
  • 202602120357_20260212045718_test_story/ 3mo ago
  • 202602120357_The_Test_of_Courage/ 3mo ago
  • 202602120354_The_Test_of_Throth/ 3mo ago
  • 202602120351_The_Testing_Grounds/ 3mo ago
  • 202602120347_The_Quest_of_the_Unknown/ 3mo ago
  • 202511130412_Odyssey_of_the_Unknown/ 6mo ago
  • 202511130404_The_Quest_of_the_Test_Hero/ 6mo ago
  • 202511130303_20251113040334_test_story/ 6mo ago
• .windsurf/ 3mo ago
  • skills/ 3mo ago
  • rules/ 3mo ago
  • workflows/ 3mo ago
  • __workflows/ 7mo ago
  • _workflows/ 8mo ago
  • memory.json 8.3KB 8mo ago
  • mcp_config.json 509B 8mo ago
  • commands.md 2.5KB 10mo ago
• .gitignore 995B 3mo ago
• docs/ 3mo ago
  • bug-analysis.md 13.3KB 3mo ago
  • archive/ 3mo ago
  • awesome-skills/ 3mo ago
  • awesome-rules/ 3mo ago
  • sfx-system-action-plan.md 7.1KB 6mo ago
  • 2Fix_FLAWS.md 8.7KB 6mo ago
  • 01_jam/ 6mo ago
  • NEXT_STEPS_ANALYSIS_2025-11-10.yaml 11.8KB 6mo ago
  • PROJECT_STATE_2025-11-10.yaml 11.5KB 6mo ago
  • SESSION_SUMMARY_2025-11-10_SESSION5_CLEANUP.md 11.2KB 7mo ago
  • plans/ 7mo ago
  • … 34 more
  • 04_MUSIC_SYSTEM.md 20.6KB 8mo ago
• .env 4.7KB 5mo ago
• CHECKLIST.md 16.6KB 6mo ago
• storymatrix_config.yaml 2.4KB 6mo ago
• 00_NOTES.md 10.2KB 6mo ago
• 01_ERROR.ini 9.9KB 6mo ago
• tests/ 6mo ago
  • test_outputs/ 6mo ago
  • crew/ 6mo ago
  • pycache/ 7mo ago
  • integration/ 8mo ago
  • unit/ 8mo ago
  • smoke/ 8mo ago
  • services/ 8mo ago
  • scripts/ 8mo ago
  • performance/ 8mo ago
  • cli/ 8mo ago
  • test_music_crossfades.py 2.7KB 8mo ago
  • … 11 more
  • test_sanity.py 46B 9mo ago
• README.md 5.4KB 6mo ago
• CHECKLIST.md.bak 8.3KB 6mo ago
• .ruff_cache/ 6mo ago
  • 0.11.8/ 6mo ago
  • .gitignore 35B 6mo ago
  • CACHEDIR.TAG 43B 6mo ago
• logs/ 6mo ago
  • cli.log 6.9MB 3mo ago
  • cli.2025-10-10_10-01-09_978811.log 9.5MB 6mo ago
  • api_debug.log 132B 7mo ago
  • api.log 132B 7mo ago
  • test_debug.log 1.1KB 8mo ago
  • test.log 995B 8mo ago
  • test_run.log 472B 9mo ago
  • debug/ 9mo ago
• .obsolete/ 7mo ago
  • GPTcodex_DEEP🔍ANAL.md 7.4KB 7mo ago
  • GPT5_DEEP🔍ANAL.md 10.0KB 7mo ago
  • Gemini25_DEEP🔍ANAL.md 7.6KB 7mo ago
  • 01_PRT.md 2.8KB 7mo ago
  • 2025-11-00_cleanup/ 7mo ago
  • DO-NOT-TOUCH 35B 8mo ago
  • 02_OUT-PRT.md 4.1KB 8mo ago
• temp/ 7mo ago
  • musicgen_output/ 7mo ago
  • crewgit/ 7mo ago
  • verify_piper_speakers/ 8mo ago
  • mock_tts/ 9mo ago
• .windsurfrules 2.1KB 7mo ago
• CONTRIBUTING.md 1.0KB 7mo ago
• .github/ 7mo ago
  • workflows/ 7mo ago
• scripts/ 7mo ago
  • link_check.py 3.9KB 7mo ago
  • lint-docs.sh 738B 7mo ago
  • pycache/ 8mo ago
  • debug_cli_processing.py 1.6KB 8mo ago
  • debug_characters.py 776B 8mo ago
  • dump_settings.py 622B 8mo ago
  • performance_analysis.py 14.2KB 9mo ago
  • compile_german_voices.py 8.0KB 9mo ago
  • test_direct_generation.py 3.8KB 9mo ago
  • create_sfx_database.py 12.0KB 9mo ago
  • 2_generate_embeddings_fallback.py 5.5KB 9mo ago
  • … 27 more
  • fetch_voices.py 1.2KB 10mo ago
• .markdownlintignore 117B 7mo ago
• .markdownlint.yaml 702B 7mo ago
• models/ 7mo ago
  • voices/ 9mo ago
  • all-MiniLM-L6-v2/ 9mo ago
• .pytest_cache/ 7mo ago
  • .gitignore 37B 7mo ago
  • CACHEDIR.TAG 191B 7mo ago
  • README.md 302B 7mo ago
  • v/ 7mo ago
• assets/ 8mo ago
  • audio_library.json 47.9KB 3mo ago
  • freesound_cache/ 8mo ago
  • sfx/ 8mo ago
  • music/ 8mo ago
  • voice_samples/ 9mo ago
  • silence/ 10mo ago
• uv.lock 551.3KB 8mo ago
• pyproject.toml 10.3KB 8mo ago
• media/ 8mo ago
  • metadata/ 8mo ago
• cache/ 8mo ago
  • asset_provenance.json 138.2KB 8mo ago
  • chroma_db/ 9mo ago
• .env.example 6.4KB 8mo ago
• data/ 9mo ago
  • chroma_db/ 8mo ago
  • audio_metadata.db 4.6MB 9mo ago
  • voice_profiles/ 9mo ago
  • StoryMatrix.db 76.0KB 9mo ago
  • content_library.db 40.0KB 9mo ago
  • media_library.db 24.0KB 10mo ago
• .pre-commit-config.yaml 1.2KB 9mo ago
• src/ 9mo ago
  • StoryMatrix/ 8mo ago

[1 results limit reached. Use limit=2 for more]

🤖 Assistant

🤖 Toolresult

.

• crew/ 6mo ago
  • pycache/ 6mo ago
  • voice_casting_crew.py 7.4KB 6mo ago
  • image_prompt_crew.py 11.5KB 6mo ago
  • image_prompt_schemas.py 3.2KB 6mo ago
  • factory.py 14.1KB 6mo ago
  • runner.py 11.2KB 6mo ago
  • crew.py 13.8KB 6mo ago
  • tools.py 3.3KB 7mo ago
  • tools/ 7mo ago
  • validators/ 7mo ago
  • configs/ 7mo ago
  • … 4 more
  • crews.py 0B 8mo ago
• infrastructure/ 8mo ago
  • pycache/ 3mo ago
  • container.py 52.4KB 3mo ago
  • containers/ 8mo ago
  • observability/ 8mo ago
  • adapters/ 8mo ago
  • services/ 8mo ago
  • database/ 8mo ago
  • repositories/ 8mo ago
  • mock_service_old.py 8.0KB 8mo ago
  • mock_service.py 22.6KB 8mo ago
  • scripts/ 8mo ago
  • … 7 more
  • persistence/ 12mo ago
• cascade_tests/ 8mo ago
  • pycache/ 8mo ago
  • memory_workflow/ 8mo ago
  • init.py 24B 8mo ago
• utils/ 8mo ago
  • pycache/ 8mo ago
  • path_utils.py 1.6KB 8mo ago
  • json_utils.py 9.3KB 8mo ago
  • async_helpers.py 7.8KB 8mo ago
  • security.py 3.3KB 8mo ago
  • text_utils.py 2.1KB 8mo ago
  • config_accessor.py 3.5KB 8mo ago
  • json.py 864B 8mo ago
• config/ 8mo ago
  • pycache/ 6mo ago
  • models.py 19.6KB 6mo ago
  • logging.py 1.3KB 7mo ago
  • init.py 540B 7mo ago
  • user_preferences.py 9.4KB 8mo ago
  • config.py 3.3KB 8mo ago
  • models_1.py 14.9KB 8mo ago
  • environment.py 951B 8mo ago
  • providers.py 847B 8mo ago
  • yaml_precedence_validator.py 15.2KB 8mo ago
• domain/ 8mo ago
  • services/ 6mo ago
  • models/ 8mo ago
  • pycache/ 8mo ago
  • entities/ 8mo ago
  • value_objects/ 8mo ago
  • enums.py 620B 8mo ago
  • exceptions.py 2.6KB 8mo ago
• application/ 8mo ago
  • services/ 8mo ago
  • ports/ 8mo ago
  • production/ 8mo ago
  • use_cases/ 8mo ago
  • interfaces/ 8mo ago
  • pycache/ 8mo ago
  • dto/ 8mo ago
  • init.py 174B 8mo ago
• pycache/ 8mo ago
  • init.cpython-311.pyc 739B 8mo ago
• cli/ 8mo ago
  • pycache/ 7mo ago
  • main.py 21.5KB 7mo ago
  • init.py 204B 8mo ago
  • interactive.py 12.2KB 8mo ago
  • commands/ 10mo ago
• init.py 810B 8mo ago
• interfaces/ 12mo ago
  • api/ 8mo ago
  • web/ 8mo ago

[1 results limit reached. Use limit=2 for more]

🤖 Assistant

🤖 Toolresult

0/1 succeeded [1.8s]

failed (exit 1) Connect error resource_exhausted: Error

🤖 Assistant

Resource exhausted on first attempt — retrying the review delegation:

🤖 Toolresult

0/1 succeeded [1.2s]

failed (exit 1) Connect error resource_exhausted: Error

🤖 Assistant

Thinking Process

The reviewer agent is hitting resource exhaustion. Let me try with a smaller scope or try a different agent type. Actually, let me try once more, or perhaps I should do this review myself since the reviewer agent isn’t available.

Let me do the review myself since the reviewer agent keeps failing with resource_exhausted errors. I’ll read the key files and provide findings.

Reviewer agent is resource-exhausted. I’ll conduct the review directly — reading key files now.

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/crew/factory.py#A462]
1:"""YAML-driven CrewAI factory for dynamic crew instantiation and configuration."""
2:
3:import json
4:import os
5:import yaml
6:from pathlib import Path
7:from typing import Any, Dict, List
8:from crewai import Agent, Crew, Process
9:from crewai import Task
10:from crewai.llm import LLM
11:from loguru import logger
12:from dotenv import load_dotenv
13:
14:from StoryMatrix.application.interfaces.services import LLMService
15:from StoryMatrix.crew.tools import registry as tool_registry
16:
17:
18:class CrewFactory:
19: """Factory for creating CrewAI crews from YAML configurations with runtime interpolation."""
20:
21: def init(self, llm_service: LLMService, llm: LLM | None = None):
22: """Initialize the factory with LLM service for crew creation."""
23: self.llm_service = llm_service
24: self.llm = llm
25: self.configs_dir = Path(file).parent / “configs”
26: self.prompts_dir = Path(file).parent / “prompts”
27: # Ensure minimal default tools are registered (safe no-op if already)
28: try:
29: tool_registry.ensure_defaults_loaded()
30: except Exception:
31: # Tools are optional for many agents; avoid hard failure here
32: logger.debug(
33: “Tool registry defaults could not be ensured; continuing without tools.”
34: )
35:
36: def load_crew(self, crew_config_name: str, inputs: Dict[str, Any]) -> Crew:
37: """
…
124: return crew
125:
126: def _interpolate_config(
127: self, config: Dict[str, Any], inputs: Dict[str, Any]
128: ) -> Dict[str, Any]:
129: """Recursively interpolate template variables in configuration."""
…
155: return config
156:
157: def _create_crew_llm(self) -> LLM:
158: """Create LLM instance for CrewAI based on service configuration."""
…
297: )
298:
299: def _create_agent(
…
305: ) -> Agent:
306: """Create an agent from configuration."""
…
324: )
325:
326: def _create_task(
…
333: ) -> Task:
334: """Create a task from configuration."""
…
377: return task

[319 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/crew/factory.py:38-123,130-154]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/utils/security.py#DF48]
1:"""🔒 Security utilities for StoryMatrix.
2:
3:This module provides security functions to prevent common vulnerabilities
4:like command injection, path traversal, and data exposure.
5:"""
6:
7:import os
8:import shlex
9:from pathlib import Path
10:from typing import Any
11:
12:from StoryMatrix.domain.exceptions import DomainError
13:
14:
15:class SecurityError(DomainError):
16: """Raised when a security violation is detected."""
17: pass
18:
19:
20:def sanitize_command(cmd: list[str]) -> list[str]:
21: """Sanitize subprocess commands to prevent injection attacks.
…
31: """
32: if not cmd:
33: raise SecurityError(“Empty command not allowed”)
34:
35: # Allowlist of permitted commands
36-41: allowed_commands = { .. }
42:
43: command_name = Path(cmd[0]).name # Extract just the command name
44: if command_name not in allowed_commands:
45: raise SecurityError(f”Command not allowed: {command_name}”)
46:
47: # Quote all arguments to prevent injection
48: return [shlex.quote(str(arg)) for arg in cmd]
49:
50:
51:def validate_file_path(path: Path, allowed_base: Path | None = None) -> Path:
52: """Validate file paths to prevent traversal attacks.
…
79: raise SecurityError(f”Invalid path: {path}”) from e
80:
81:
82:def sanitize_log_data(data: Any) -> str:
83: """Sanitize data before logging to prevent sensitive data exposure.
…
103: return str(data)
104:
105:
106:def get_safe_log_level() -> str:
107: """Get log level from environment with safe default.
…
118: return log_level

[68 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/utils/security.py:22-30,36-41]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/crew/crew.py#3E73]
1:from typing import Any, Dict, List, Tuple
2:from crewai import Agent, Crew, Process, Task
3:from crewai.llm import LLM
4:from loguru import logger
5:import json
6:
7:from StoryMatrix.application.interfaces.services import LLMService
8:from StoryMatrix.crew.schemas import AudioTimeline, StoryData, StoryPlan
9:from StoryMatrix.domain.entities import Story
10:
11:
12:def _auto_fix_zero_duration_events(timeline_data: dict) -> tuple[dict, int]:
13: """Auto-correct zero-duration or invalid timing events before validation."""
14: MIN_DURATION_MS = 500 # Minimum viable segment duration
15: corrections = 0
16:
17: for track in timeline_data.get(“tracks”, []):
18: track_type = track.get(“track_type”, “unknown”)
…
42: pass
43:
44: return timeline_data, corrections
45:
46:
47:def _validate_timeline_output(result: Any) -> Tuple[bool, Any]:
48: """Enforces timing contract - rejects invalid output with detailed validation."""
…
136: return (False, f”REJECTED: Timeline validation failed - {str(e)}”)
137:
138:
139:def create_story_generation_crew(
140: llm_service: LLMService, crew_inputs: Dict[str, Any], llm: LLM | None = None
141:) -> Crew:
142: """Factory function to create and configure the story generation crew using YAML configuration."""
…
188: return crew
189:
190:
191:def _create_legacy_story_crew_inline(
192: llm_service: LLMService, crew_inputs: Dict[str, Any]
193:) -> Crew:
194: """Legacy story crew creation as fallback - inline Python implementation."""
…
285: return crew
286:
287:
288:def _create_legacy_story_crew(
289: llm_service: LLMService, crew_inputs: Dict[str, Any]
290:) -> Crew:
291: """Legacy story crew creation as fallback - simple 2-agent system."""
292: return _create_legacy_story_crew_inline(llm_service, crew_inputs)
293:
294:
295:def create_timeline_generation_crew(
…
302:) -> Crew:
303: """Factory function to create the audio timeline generation crew using YAML config."""
…
366: return crew

[313 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/crew/crew.py:19-41,49-135]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/config/models.py#0EA4]
1:from enum import Enum
…
16:from pydantic_settings import BaseSettings
17:
18:PROJECT_ROOT = Path(file).parent.parent.parent.parent.resolve()
19:
20:
21:# --- Enums ---
22:class AudioType(str, Enum):
23: NARRATION = “narration”
…
28: UNKNOWN = “unknown”
29:
30:
31:class TTSProvider(str, Enum):
32: PLAYAI = “playai”
…
37: MOCK = “mock”
38:
39:
40:class SFXProvider(str, Enum):
41: LOCAL = “local”
…
44: MOCK = “mock”
45:
46:
47:class ElevenLabsModelStrategy(str, Enum):
48: """ElevenLabs model selection strategy for TTS.
…
68: return self == ElevenLabsModelStrategy.FLASH_REALTIME
69:
70:
71:class LLMProvider(str, Enum):
72: OPENROUTER = “openrouter”
73:
74:
75:class AgenticTimelineProvider(str, Enum):
76: OPENROUTER = “openrouter”
…
79: MOCK = “mock”
80:
81:
82:class ImageProvider(str, Enum):
83: DALLE = “dalle”
…
87: MOCK = “mock”
88:
89:
90:class MusicProvider(str, Enum):
91: MUSICGEN = “musicgen”
92: LOCAL = “local”
93: MOCK = “mock”
94:
95:
96:class StoryDataProvider(str, Enum):
97: OPENROUTER = “openrouter”
98: OLLAMA = “ollama”
99: MOCK = “mock”
100:
101:
102:# --- Base Settings & Models (alphabetical order) ---
103:
104:
105:class ArtifactsConfig(BaseModel):
106: """Configuration for the ArtifactsService."""
107:
108: enabled: bool = True
109:
110:
111:class APISettings(BaseSettings):
112: model_config = ConfigDict(env_prefix=“SERVICES__API__”)
…
120: cors_enabled: bool = True
121:
122:
123:class AppSettings(BaseSettings):
124: model_config = ConfigDict(env_prefix=“APP__”, extra=“allow”)
…
147: return getattr(self, key, default)
148:
149:
150:class CelerySettings(BaseSettings):
151: model_config = ConfigDict(env_prefix=“SERVICES__CELERY__”)
…
166: return “redis://localhost:6379/0”
167:
168:
169:class ChromaConfig(BaseSettings):
170: model_config = ConfigDict(env_prefix=“SERVICES__CHROMA__”)
…
173: collection_name: str = “story_content”
174:
175:
176:class CoquiTTSConfig(BaseModel):
177: model_name: str = “tts_models/multilingual/multi-dataset/xtts_v2”
…
187: speaker_samples: dict[str, str] | None = None
188:
189:
190:class DalleConfig(BaseSettings):
191: model_config = ConfigDict(env_prefix=“DALLE_”)
…
197: timeout_seconds: int = 120
198:
199:
200:class DatabaseSettings(BaseSettings):
201: model_config = ConfigDict(env_prefix=“SERVICES__DATABASE__”)
…
212: data_dir: str = “data”
213:
214:
215:class ElevenLabsConfig(BaseSettings):
216: model_config = ConfigDict(env_prefix=“PROVIDERS__ELEVENLABS__”)
…
251: return self.model_strategy.value
252:
253:
254:class FileSystemMediaAssetRepositoryConfig(BaseModel):
255: storage_root: Path = Field(default_factory=lambda: PROJECT_ROOT / “media”)
…
258: )
259:
260:
261:class FreesoundConfig(BaseSettings):
262: model_config = ConfigDict(env_prefix=“PROVIDERS__FREESOUND__”)
263: api_key: SecretStr | None = None
264:
265:
266:class CoquiConfig(BaseModel):
267: """Configuration for the Coqui TTS provider."""
…
272: )
273:
274:
275:class LocalAssetsConfig(BaseSettings):
276: model_config = ConfigDict(env_prefix=“SERVICES__LOCAL_ASSETS__”)
…
280: voice_data_path: Path = Field(default=PROJECT_ROOT / “models/voices”)
281:
282:
283:class MixingProfileSettings(BaseModel):
284: target_level_dbfs: float
285: ducking_amount_db: float
286:
287:
288:class MixingProfiles(BaseModel):
289: narration: MixingProfileSettings
…
325: return list(cls.PROFILES.keys())
326:
327:
328:class MasteringConfig(BaseModel):
329: enabled: bool = True
…
337: limiter_threshold: float = -1.0
338:
339:
340:class MontageConfig(BaseSettings):
341: model_config = ConfigDict(env_prefix=“SERVICES__MONTAGE__”)
…
349: music_crossfade_ms: int = 1000
350:
351:
352:class MidjourneyConfig(BaseSettings):
353: model_config = ConfigDict(env_prefix=“PROVIDERS__MIDJOURNEY__”)
…
373: upsample_indices: list[int] = Field(default_factory=list)
374:
375:
376:class MusicGenConfig(BaseSettings):
377: model_config = ConfigDict(env_prefix=“MUSICGEN_”)
…
380: timeout_seconds: int = 120
381:
382:
383:class OllamaProviderConfig(BaseModel):
384: base_url: HttpUrl = “http://localhost:57707”
…
395: return v
396:
397:
398:class OpenRouterConfig(BaseSettings):
399: model_config = ConfigDict(env_prefix=“PROVIDERS__OPENROUTER__”)
…
408: timeout_seconds: int = 120
409:
410:
411:class PathsSettings(BaseModel):
412: ffmpeg: FilePath = “/usr/bin/ffmpeg”
413: ffprobe: FilePath = “/usr/bin/ffprobe”
414:
415:
416:class PillowConfig(BaseModel):
417: font_path: str = “assets/fonts/Roboto-Regular.ttf”
418: default_width: int = 1024
419: default_height: int = 1024
420:
421:
422:class PiperConfig(BaseSettings):
423: model_config = ConfigDict(env_prefix=“SERVICES__PIPER__”)
…
434: auto_download: bool = False
435:
436:
437:class SentenceTransformerConfig(BaseSettings):
438: model_config = ConfigDict(env_prefix=“SERVICES__SENTENCE_TRANSFORMER__”)
439: model_name: str = “all-MiniLM-L6-v2”
440: cache_folder: str | None = None
441:
442:
443:class PlayAIConfig(BaseSettings):
444: model_config = ConfigDict(env_prefix=“PROVIDERS__PLAYAI__”)
…
460: return v
461:
462:
463:class ProviderStrategy(BaseSettings):
464: model_config = ConfigDict(env_prefix=“PROVIDERS__STRATEGY__”, extra=“allow”)
…
476: return getattr(self, key, default)
477:
478:
479:class WebSettings(BaseSettings):
480: model_config = ConfigDict(env_prefix=“SERVICES__WEB__”)
481: host: str = “0.0.0.0”
482: port: int = 8080
483:
484:
485:# --- Composite Settings ---
486:
487:
488:class OpenRouterServiceConfig(BaseSettings):
489: """Compatibility layer for tests expecting services.llm.open_router.timeout.
…
498: timeout: int = 30
499:
500:
501:class LLMServiceSettings(BaseSettings):
502: """Compatibility LLM settings grouping under services.llm.* for tests."""
…
507: )
508:
509:
510:class ProvidersSettings(BaseSettings):
511: """Configuration for external API providers only."""
…
528: return getattr(self, key, default)
529:
530:
531:class ServicesSettings(BaseSettings):
532: """Configuration for internal, library-based services."""
…
558: return getattr(self, key, default)
559:
560:
561:# --- Main Configuration ---
562:
563:
564:class StoryMatrixConfig(BaseSettings):
565: """Main configuration for StoryMatrix."""
…
576: return getattr(self, key, default)

[347 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/config/models.py:2-15,24-27]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/infrastructure/container.py#7BE3]
1:"""🧩 Dependency Injection Container Module
…
19:"""
20:
21:from loguru import logger
…
79:from StoryMatrix.infrastructure.adapters.music.local import LocalMusicAdapter
80:
81:# MusicGenAdapter lazy-loaded to avoid torch dependency at import time
82:from StoryMatrix.infrastructure.adapters.music.mock import MockMusicAdapter
…
101:from StoryMatrix.application.interfaces.services import LLMService
102:
103:# Setup logging
104:# Type variable for generic type hints
105:T = TypeVar(“T”)
106:
107:
108:def _safe_enum_value(val):
109: # Safely extract enum value, handling both enum instances and raw values.
110: logger.debug(f”Safely getting enum value from: {val} (type: {type(val)})”)
…
113: return res
114:
115:
116:def _safe_config_get(config, path, default=None):
117: # Safely get nested config value from either dict or Pydantic object.
118: if hasattr(config, “model_dump”):
…
129: return current
130:
131:
132:def elevenlabs_client_provider(config):
133: # Provide an ElevenLabs client.
134: from elevenlabs.client import AsyncElevenLabs
…
149: return AsyncElevenLabs(api_key=api_key)
150:
151:
152:def openrouter_adapter_factory(config):
153: # Factory function to create OpenRouterAdapter with proper dependency handling.
154: from StoryMatrix.infrastructure.adapters.llm.openrouter import OpenRouterAdapter
…
159: return MockLLMService()
160:
161:
162:def get_music_key(dev_local_only, low_resource, music_provider_strategy):
163: # Helper to determine which music service to use.
164: if dev_local_only or low_resource:
…
167: return (provider or “local”).lower()
168:
169:
170:def story_planner_factory_func(llm_service: LLMService):
171: # Factory for creating a lazy-loaded StoryPlannerServiceImpl.
172: from StoryMatrix.infrastructure.services.story_planner import (
…
176: return StoryPlannerServiceImpl(llm_service=llm_service)
177:
178:
179:def ffmpeg_montage_service_factory(config, temp_dir):
180: # Factory for creating a lazy-loaded FFmpegMontageService.
181: from StoryMatrix.infrastructure.services.ffmpeg_montage import FFmpegMontageService
…
203: )
204:
205:
206:def pydub_montage_service_factory(config, temp_dir):
207: # Factory for creating a lazy-loaded MontageServiceImpl.
208: from StoryMatrix.infrastructure.services.montage import MontageServiceImpl
…
216: return MontageServiceImpl(config=montage_config, silence_dir=temp_dir_path)
217:
218:
219:def _create_chroma_audio_adapter(config):
220: # Factory for creating a ChromaAudioSearchAdapter lazily.
221: # We pass the unified StoryMatrixConfig so the adapter can resolve
222: # db/model settings and prefer local models when available.
223: # Import lazily and guard against missing heavy deps at import time
224: try:
…
274: return MockAudioSearchService()
275:
276:
277:def _index_local_music_assets(config, audio_search_service):
278: # Scans and indexes local music assets into the audio search service.
279: from StoryMatrix.domain.entities import AudioAsset
…
385: return True # Indicate completion
386:
387:
388:def _create_dalle_adapter(config):
389: # Factory for creating a lazy-loaded DalleAdapter.
390-396: from StoryMatrix.infrastructure.adapters.image.dalle_adapter import ( .. )
397:
398:
399:def _create_elevenlabs_adapter(client_provider, config):
400: from StoryMatrix.infrastructure.adapters.tts.elevenlabs import ElevenLabsAdapter
401:
402: return ElevenLabsAdapter(client_provider=client_provider, config=config)
403:
404:
405:def _create_piper_adapter(config):
406: # Factory for creating a lazy-loaded PiperAdapter.
407: from StoryMatrix.infrastructure.adapters.tts.piper import PiperAdapter
408:
409: return PiperAdapter(config=config)
410:
411:
412:def _create_coqui_adapter(coqui_config):
413: """Create Coqui adapter with graceful fallback on GPU-only systems."""
…
433: return MockTTSAdapter()
434:
435:
436:def _create_mock_sfx_adapter(config):
437: from StoryMatrix.infrastructure.services.sfx.mock_sfx_adapter import (
…
444: return MockSfxAdapter(silent_audio_path=str(silent_audio_path))
445:
446:
447:def _create_mock_music_adapter(config):
448: silent_audio_path = _safe_config_get(
…
451: return MockMusicAdapter(silent_audio_path=str(silent_audio_path))
452:
453:
454:def _create_elevenlabs_sfx_adapter(client_provider, config):
455: from StoryMatrix.infrastructure.adapters.sfx.elevenlabs import (
…
459: return ElevenLabsSFXAdapter(client_provider=client_provider, config=config)
460:
461:
462:def _create_sfx_orchestrator(sfx_providers, media_asset_repository, config):
463-489: from StoryMatrix.infrastructure.services.sfx_orchestrator import ( .. )
490:
491:
492:def _create_music_orchestrator(adapter_providers, config):
493-510: from StoryMatrix.infrastructure.services.music_orchestrator import ( .. )
511:
512:
513:def _create_tts_orchestrator(tts_providers, media_asset_repository, preferred_provider):
514-526: from StoryMatrix.infrastructure.services.mock_audio_processing import ( .. )
527:
528:
529:def _choose_sfx_key(strategy, dev_local_only, low_resource):
530: # Determine which SFX service to use based on config.
531: # - If dev_local_only is True, always return ‘mock’.
532: # - Otherwise, use the configured strategy, defaulting to ‘freesound’.
533: if dev_local_only or low_resource:
…
536: return (val or “freesound”).lower()
537:
538:
539:def _validate_config_wrapper(config_data, *args, **kwargs):
540: # Wrapper to handle dependency-injectors argument passing for Pydantic validation.
541: validated_config = StoryMatrixConfig.model_validate(config_data)
542: return validated_config
543:
544:
545:def _get_sfx_providers(
…
553:):
554: # Prefer environment gating for tests; fall back to provided flags
555: env_dev = str(os.getenv(“APP__DEV_LOCAL_ONLY”, "")).lower() in (“1”, “true”, “yes”)
…
575: return [local, freesound, elevenlabs, mock]
576:
577:
578:def _get_music_providers(
579: dev_local_only, low_resource, music_provider_strategy, local, musicgen, mock
580:):
581: env_dev = str(os.getenv(“APP__DEV_LOCAL_ONLY”, "")).lower() in (
…
609: return [local, mock]
610:
611:
612:class ServiceContainer(containers.DeclarativeContainer):
613: config = providers.Configuration(strict=False)
…
1384: )
1385:
1386:
1387:# ======================================================================================
1388:# 6. WIRING
1389:
1390:
1391:def wire_container(config_data: dict):
1392: # Wire the container with a specific configuration.
1393: container = ServiceContainer()
…
1405: return container

[1232 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/infrastructure/container.py:2-18,22-78]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/cli/main.py#ABE7]
1:# /home/dev/active/StoryMatrix/StoryMatrix/cli/main.py
2:"""Main CLI entry point for StoryMatrix.
…
12:"""
13:
14:import asyncio
…
33:from rich.progress import Progress
34:
35:# Load environment variables from .env file before any other imports
36:load_dotenv()
37:
38:# Initialize console
39:console = Console(force_terminal=True)
40:
41:# Initialize OpenTelemetry tracing (early initialization)
42:try:
43: from StoryMatrix.infrastructure.observability import init_tracing, shutdown_tracing
…
53: logger.debug(”📊 OpenTelemetry tracing initialized”)
54:except Exception as e:
55: logger.warning(f”📊 OpenTelemetry tracing initialization failed: {e}”)
56:
57:# --- Pre-computation and Early Initialization ---
58:from StoryMatrix.application.dto.requests import AudioFormat, GenerateStoryRequest
…
70:from StoryMatrix.infrastructure.container import ServiceContainer, wire_container
71:
72:# --- Typer Application Definition ---
73:def no_op_result_callback(*args, **kwargs):
74: """A no-op callback to prevent Typer from printing command results."""
75: pass
76:
77-84:app = typer.Typer( .. )
85:
86-90:config_app = typer.Typer( .. )
91:app.add_typer(config_app)
92:
93:# --- Voices Commands ---
94-98:voices_app = typer.Typer( .. )
99:app.add_typer(voices_app)
100:
101:
102:def _version_callback(value: bool):
103: """Provides the application version and exits."""
…
108: raise typer.Exit()
109:
110:
111:@app.callback()
112:def main_callback(
…
154:):
155: """
…
204: _log_applied_settings(config_for_logging, offline, low_resource, max_tts_concurrency, min_similarity)
205:
206:
207:def _log_applied_settings(config: StoryMatrixConfig, offline: bool, low_resource: bool, max_tts_concurrency: Optional[int], min_similarity: float):
208: """Log the applied configuration settings for visibility."""
…
221: logger.debug(f” • Keep Temp Files: {config.app.keep_temp_files}”)
222:
223:
224:def setup_logging(level: str, config: StoryMatrixConfig, sink=sys.stderr):
225: """Configure Loguru logger."""
…
244: )
245:
246:
247:# --- Main Application Commands ---
248-251:@app.command( .. )
252:def generate(
…
353:) -> None:
354: """Generate a new story from a prompt."""
…
418: asyncio.run(_generate_async(config=config, request=request, ctx=ctx))
419:
420:
421:async def _generate_async(
422: config: StoryMatrixConfig, request: GenerateStoryRequest, ctx: typer.Context | None = None
423:):
424: """Asynchronous helper to run the story generation use case."""
…
444: raise StoryMatrixError(result.message or “Story generation failed.”)
445:
446:
447:# --- Voices CLI Commands ---
448:def _parse_provider(provider: str | None):
449: if not provider:
…
460: return None
461:
462:
463:def _parse_filters(filters: list[str] | None) -> dict[str, Any]:
464: """Parse ‘key=value’ strings into a dictionary."""
…
476: return filter_dict
477:
478:
479:@voices_app.command(“list”)
480:def voices_list(
…
483:):
484: """List voices with optional filters."""
…
503: )
504:
505:
506:@voices_app.command(“clear-cache”)
507:def voices_clear_cache(
…
511:):
512: """Clear the in-memory voice data caches."""
…
520: console.print(f”[bold green]✅ {msg}[/bold green]”)
521:
522:
523:# --- Config CLI Commands ---
524:@config_app.command(“show”)
525:def config_show(
…
535:):
536: """Display the current configuration.
…
560: raise typer.Exit(1)
561:
562:
563:@config_app.command(“set-pref”)
564:def config_set_pref(key: str, value: str):
565: """Set a user preference (e.g., ‘tts.default_voice_id’)."""
…
575: raise typer.Exit(1)
576:
577:
578:@config_app.command(“get-pref”)
579:def config_get_pref(key: str):
580: """Get a user preference value."""
…
587: raise typer.Exit(1)
588:
589:
590:def main():
591: """Main entry point for the CLI application."""
…
609: sys.exit(1)
610:
611:
612:# --- Main Execution Block ---
613:if name == “main”:
614: main()

[481 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/cli/main.py:3-11,15-32]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/config/models_1.py#372E]
1:from enum import Enum
…
16:from pydantic_settings import BaseSettings, SettingsConfigDict
17:
18:PROJECT_ROOT = Path(file).parent.parent.parent.parent.resolve()
19:
20:
21:# --- Enums ---
22:class AudioType(str, Enum):
23: NARRATION = “narration”
…
28: UNKNOWN = “unknown”
29:
30:
31:class TTSProvider(str, Enum):
32: PLAYAI = “playai”
…
37: MOCK = “mock”
38:
39:
40:class SFXProvider(str, Enum):
41: LOCAL = “local”
…
44: MOCK = “mock”
45:
46:
47:class LLMProvider(str, Enum):
48: OPENROUTER = “openrouter”
49:
50:
51:class AgenticTimelineProvider(str, Enum):
52: OPENROUTER = “openrouter”
…
55: MOCK = “mock”
56:
57:
58:class ImageProvider(str, Enum):
59: DALLE = “dalle”
…
63: MOCK = “mock”
64:
65:
66:class MusicProvider(str, Enum):
67: MUSICGEN = “musicgen”
68: LOCAL = “local”
69: MOCK = “mock”
70:
71:
72:class StoryDataProvider(str, Enum):
73: OPENROUTER = “openrouter”
74: OLLAMA = “ollama”
75: MOCK = “mock”
76:
77:
78:# --- Base Settings & Models (alphabetical order) ---
79:
80:
81:class ArtifactsConfig(BaseModel):
82: """Configuration for the ArtifactsService."""
83:
84: enabled: bool = True
85:
86:
87:class APISettings(BaseSettings):
88: model_config = SettingsConfigDict(env_prefix=“SERVICES__API__”)
…
96: cors_enabled: bool = True
97:
98:
99:class AppSettings(BaseSettings):
100: model_config = SettingsConfigDict(env_prefix=“APP__”, extra=“allow”)
…
115: max_tts_concurrency: int = 4
116:
117:
118:class CelerySettings(BaseSettings):
119: model_config = SettingsConfigDict(env_prefix=“SERVICES__CELERY__”)
…
139: return f”redis://{host}:{port}/0”
140:
141:
142:class ChromaConfig(BaseSettings):
143: model_config = SettingsConfigDict(env_prefix=“SERVICES__CHROMA__”)
…
146: collection_name: str = “story_content”
147:
148:
149:class CoquiTTSConfig(BaseModel):
150: model_name: str = “tts_models/multilingual/multi-dataset/xtts_v2”
…
160: speaker_samples: dict[str, str] | None = None
161:
162:
163:class DalleConfig(BaseSettings):
164: model_config = SettingsConfigDict(env_prefix=“DALLE_”)
…
170: timeout_seconds: int = 120
171:
172:
173:class DatabaseSettings(BaseSettings):
174: model_config = SettingsConfigDict(env_prefix=“SERVICES__DATABASE__”)
…
185: data_dir: str = “data”
186:
187:
188:class ElevenLabsConfig(BaseSettings):
189: model_config = SettingsConfigDict(env_prefix=“PROVIDERS__ELEVENLABS__”)
…
199: timeout_seconds: int = 60
200:
201:
202:class FileSystemMediaAssetRepositoryConfig(BaseModel):
203: storage_root: Path = Field(default_factory=lambda: PROJECT_ROOT / “media”)
…
206: )
207:
208:
209:class FreesoundConfig(BaseSettings):
210: model_config = SettingsConfigDict(env_prefix=“PROVIDERS__FREESOUND__”)
211: api_key: SecretStr | None = None
212:
213:
214:class LLMSettings(BaseModel):
215: temperature: float = 0.7
…
218: timeout_seconds: int = 120
219:
220:
221:class LocalAssetsConfig(BaseSettings):
222: model_config = SettingsConfigDict(env_prefix=“SERVICES__LOCAL_ASSETS__”)
…
226: voice_data_path: Path = Field(default=PROJECT_ROOT / “models/voices”)
227:
228:
229:class MixingProfileSettings(BaseModel):
230: target_level_dbfs: float
231: ducking_amount_db: float
232:
233:
234:class MixingProfiles(BaseModel):
235: narration: MixingProfileSettings
…
271: return list(cls.PROFILES.keys())
272:
273:
274:class MasteringConfig(BaseModel):
275: enabled: bool = True
…
283: limiter_threshold: float = -1.0
284:
285:
286:class MontageConfig(BaseSettings):
287: model_config = SettingsConfigDict(env_prefix=“SERVICES__MONTAGE__”)
…
291: mastering: MasteringConfig = Field(default_factory=MasteringConfig)
292:
293:
294:class MidjourneyConfig(BaseSettings):
295: model_config = SettingsConfigDict(env_prefix=“PROVIDERS__MIDJOURNEY__”)
…
301: modes: list[str] = Field(default_factory=lambda: [“FAST”])
302:
303:
304:class MusicGenConfig(BaseSettings):
305: model_config = SettingsConfigDict(env_prefix=“MUSICGEN_”)
306: api_key: SecretStr | None = None
307:
308:
309:class OllamaProviderConfig(BaseModel):
310: base_url: HttpUrl = HttpUrl(“http://localhost:57707”)
…
321: return v
322:
323:
324:class OpenRouterConfig(BaseSettings):
325: model_config = SettingsConfigDict(env_prefix=“PROVIDERS__OPENROUTER__”)
…
334: timeout_seconds: int = 120
335:
336:
337:class PathsSettings(BaseModel):
338: ffmpeg: FilePath = “/usr/bin/ffmpeg”
339: ffprobe: FilePath = “/usr/bin/ffprobe”
340:
341:
342:class PillowConfig(BaseModel):
343: font_path: str = “assets/fonts/Roboto-Regular.ttf”
344: default_width: int = 1024
345: default_height: int = 1024
346:
347:
348:class PiperConfig(BaseSettings):
349: model_config = SettingsConfigDict(env_prefix=“SERVICES__PIPER__”)
…
359: timeout_seconds: int = 120
360:
361:
362:class PlayAIConfig(BaseSettings):
363: model_config = SettingsConfigDict(env_prefix=“PROVIDERS__PLAYAI__”)
…
378: return v
379:
380:
381:class ProviderStrategy(BaseSettings):
382: model_config = SettingsConfigDict(env_prefix=“PROVIDERS__STRATEGY__”, extra=“allow”)
…
390: image_provider: ImageProvider = Field(ImageProvider.MOCK, alias=“image_provider”)
391:
392:
393:class WebSettings(BaseSettings):
394: model_config = SettingsConfigDict(env_prefix=“SERVICES__WEB__”)
395: host: str = “0.0.0.0”
396: port: int = 8080
397:
398:
399:# --- Composite Settings ---
400:
401:
402:class ProvidersSettings(BaseSettings):
403: """Configuration for external API providers only."""
…
414: strategy: ProviderStrategy = Field(default_factory=ProviderStrategy)
415:
416:
417:class ServicesSettings(BaseSettings):
418: """Configuration for internal, library-based services."""
…
435: artifacts: ArtifactsConfig = Field(default_factory=ArtifactsConfig)
436:
437:
438:# --- Main Configuration ---
439:
440:
441:class StoryMatrixConfig(BaseSettings):
442: """Main configuration for StoryMatrix."""
…
449: providers: ProvidersSettings = Field(default_factory=ProvidersSettings)

[241 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/config/models_1.py:2-15,24-27]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/crew/crews.py#5D05]
1:

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/init.py#264A]
1:"""StoryMatrix: Next-Generation AI Audio Storytelling Platform.
2:
3:Create cinema-quality audio narratives using cutting-edge AI. StoryMatrix orchestrates
4:multiple AI providers to generate immersive stories with character voices, sound effects,
5:and intelligent audio montage.
6:"""
7:
8:version = “2.0.0”
9:author = “StoryMatrix Team”
10:email = “dev@StoryMatrix.ai”
11:description = “AI-driven audio storytelling platform with multi-provider TTS, SFX, and intelligent montage”
12:
13:# Core public API exports - temporarily disabled until we create the structure
14:# from StoryMatrix.config.providers import (
15:# get_providers_settings,
16:# ProvidersSettings,
17:# TTSProvider,
18:# SFXProvider,
19:# LLMProvider,
20:# )
21:
22:all = [
23: “author”,
24: “description”,
25: “email”,
26: “version”,
27:]
28:

🤖 Toolresult

[active/StoryMatrix/pyproject.toml#541A]
1:[build-system]
2:requires = [“hatchling>=1.18.0”]
3:build-backend = “hatchling.build”
4:
5:[project]
6:name = “StoryMatrix”
7:version = “2.0.0”
8:description = “AI-driven audio storytelling platform with multi-provider TTS, SFX, and intelligent montage”
9:readme = “README.md”
10:requires-python = ”>=3.11, <3.12”
11:authors = [
12: {name = “StoryMatrix Team”, email = “dev@StoryMatrix.ai”}
13:]
14:license = {text = “MIT”}
15:keywords = [“ai”, “audio”, “storytelling”, “tts”, “narrative”, “voice-synthesis”]
16:classifiers = [
17: “Development Status :: 4 - Beta”,
18: “Programming Language :: Python :: 3”,
19: “Programming Language :: Python :: 3.11”,
20: “License :: OSI Approved :: MIT License”,
21: “Operating System :: OS Independent”,
22: “Topic :: Multimedia :: Sound/Audio”,
23: “Topic :: Text Processing :: Linguistic”,
24: “Topic :: Scientific/Engineering :: Artificial Intelligence”,
25: “Intended Audience :: Education”,
26: “Intended Audience :: End Users/Desktop”,
27: “Intended Audience :: Developers”,
28:]
29:
30:
31:
32:# Core dependencies - MINIMAL profile (essential for CLI and basic story generation)
33:# Heavy ML dependencies (torch, transformers, etc.) moved to optional profiles
34:dependencies = [
35: # Translation & language
36: “langdetect”,
37: “deep-translator>=1.11.4”,
38:
39: # AI & LLM APIs (cloud-based, lightweight)
40: “openai>=1.75.0”, # OpenRouter & other LLM providers
41: “instructor>=1.3.0”, # Structured LLM outputs via Pydantic
42: “httpx>=0.27.0”, # Modern HTTP client
43: “requests>=2.31.0”, # Fallback HTTP client
44: “huggingface_hub>=0.23.0”, # HF repo file resolution (API only, not model loading)
45:
46: # Audio processing & manipulation (core)
47: “pydub>=0.25.1”, # Audio manipulation and montage
48: “soundfile>=0.12.0”, # Audio file I/O
49: “numpy==1.26.4”, # Core numerical operations
50:
51: # Web framework & APIs
52: “fastapi>=0.104.0”, # Modern async API framework
53: “uvicorn[standard]>=0.24.0”, # ASGI server with performance extras
54: “celery[redis]>=5.3.0”, # Task queue with Redis broker
55: “redis>=5.0.0”, # Redis client for Celery
56: “SQLAlchemy>=2.0.0”, # ORM
57: “pydantic>=2.0”, # Data validation & settings
58:
59: # CLI & utilities
60: “python-dotenv>=1.0.0”, # Environment management
61: “typer>=0.12.3,<0.17.0”, # Modern CLI framework
62: “rich>=13.7.0”, # Beautiful terminal output
63: “tqdm>=4.66.0”, # Progress bars
64: “loguru>=0.7.0”, # Modern logging
65:
66: # Local TTS (essential - zero-cost voice synthesis)
67: “piper-tts==1.3.0”, # Pinned to a version with compatible Linux wheels
68:
69: # Data & serialization
70: “pydantic-settings>=2.2.1”,
71: “crewai>=0.35.8”, # Multi-agent orchestration
72: “crewai_tools>=0.3.0”,
73: “aiofiles>=23.2.0”, # Async file operations
74: “orjson>=3.9.0”, # Fast JSON serialization
75: “simplejson>=3.19.0”, # Robust JSON handling
76: “dirtyjson>=1.0.8”, # Forgiving JSON parser
77: “PyYAML>=6.0.0”, # YAML parsing
78: “protobuf==4.25.3”, # Pinned for compatibility
79:
80: # Image & media
81: “beautifulsoup4>=4.13.4”,
82: “Pillow>=10.0.0”, # Image processing
83: “sqlite-utils>=3.0.0”, # Metadata management
84: “mutagen>=1.47.0,<2.0.0”, # Audio metadata
85:
86: # Infrastructure
87: “dependency-injector[pydantic2]>=4.47.1”, # DI container
88: “nicegui>=1.4.13”, # Web UI framework
89:
90: # Observability
91: “opentelemetry-api>=1.27.0”,
92: “opentelemetry-sdk>=1.27.0”,
93: “opentelemetry-instrumentation-fastapi>=0.48b0”,
94: “prometheus-client>=0.20.0”,
95:]
96:
97:# Installation profiles for different use cases
98:[project.optional-dependencies]
99:# ============================================================================
100:# INSTALL PROFILES (use with: uv sync —extra )
101:# ============================================================================
102:
103:# MINIMAL profile (~500MB) - Core CLI, basic story generation with local TTS only
104:# Excludes: Heavy ML libs (torch, transformers, chromadb), cloud APIs
105:# Use case: Quick start, development, CI/CD
106:minimal = [] # All core deps already in main dependencies list, this profile adds nothing
107:
108:# CLOUD profile (~1GB) - Cloud APIs enabled, no heavy local ML
109:# Includes: ElevenLabs TTS, cloud services
110:# Excludes: torch, transformers, chromadb, local ML models
111:# Use case: Production with cloud providers, lower resource requirements
112:cloud = [
113: “elevenlabs>=1.4.0”,
114: “freesound-python”,
115:]
116:
117:# LOCAL profile (~2.5GB) - Full local AI/ML stack, no cloud dependencies
118:# Includes: Local TTS (Piper, Coqui), local embeddings, audio processing
119:# Excludes: Cloud APIs (to avoid accidental costs)
120:# Use case: Privacy-focused, air-gapped, zero ongoing costs
121:local = [
122: “torch>=2.2.0”,
123: “transformers==4.41.2”,
124: “chromadb>=0.5.0”,
125: “librosa>=0.10.2”,
126: “optimum[onnxruntime]>=1.20.0”,
127: “sentence-transformers==2.7.0”,
128: “TTS>=0.22.0”,
129: “numba>=0.59.1”,
130: “aubio>=0.4.9”,
131: “nltk>=3.9.1”,
132: “rapidfuzz>=3.13.0”,
133: “tinytag>=1.11.0”,
134: “unidecode>=1.4.0”,
135:]
136:
137:# FULL profile (~3.1GB) - Everything (current default)
138:# Includes: All cloud APIs + all local ML
139:# Use case: Maximum flexibility, development with all features
140:full = [
141: # Cloud services
142: “elevenlabs>=1.4.0”,
143: “freesound-python”,
144: # Local ML stack
145: “torch>=2.2.0”,
146: “transformers==4.41.2”,
147: “chromadb>=0.5.0”,
148: “librosa>=0.10.2”,
149: “optimum[onnxruntime]>=1.20.0”,
150: “sentence-transformers==2.7.0”,
151: “TTS>=0.22.0”,
152: “numba>=0.59.1”,
153: “aubio>=0.4.9”,
154: “nltk>=3.9.1”,
155: “rapidfuzz>=3.13.0”,
156: “tinytag>=1.11.0”,
157: “unidecode>=1.4.0”,
158:]
159:
160:# ============================================================================
161:# DEVELOPMENT & TESTING PROFILES
162:# ============================================================================
163:
164:dev = [
165: # Testing framework
166: “pytest>=8.0.0”, # Test framework
167: “pytest-asyncio>=0.23.0”, # Async testing support
168: “pytest-mock>=3.12.0”, # Mocking utilities
169: “pytest-cov>=4.1.0”, # Coverage reporting
170: “pytest-xdist>=3.5.0”, # Parallel test execution
171: “hypothesis>=6.90.0”, # Property-based testing
172:
173: # Code quality & formatting
174: “ruff>=0.1.15”, # Ultra-fast linter & formatter
175: “mypy>=1.8.0”, # Type checking
176: “pre-commit>=3.6.0”, # Git hooks
177:
178: # Documentation
179: “mkdocs>=1.5.0”, # Documentation generator
180: “mkdocs-material>=9.5.0”, # Material theme
181: “mkdocstrings[python]>=0.24.0”, # API documentation
182:]
183:
184:test = [
185: “pytest-subprocess”,
186: “pytest>=8.0.0”,
187: “pytest-asyncio>=0.23.0”,
188: “pytest-mock>=3.12.0”,
189: “pytest-cov>=4.1.0”,
190: “pytest-snapshot>=0.9.0”, # For snapshot testing
191: “httpx>=0.27.0”, # For API testing
192:]
193:
194:docs = [
195: “mkdocs>=1.5.0”,
196: “mkdocs-material>=9.5.0”,
197: “mkdocstrings[python]>=0.24.0”,
198:]
199:
200:# Production deployment extras
201:deploy = [
202: “gunicorn>=21.2.0”, # WSGI server for production
203: “sentry-sdk[fastapi]>=1.39.0”, # Error tracking
204:]
205:
206:# Entry points for CLI and services
207:[project.scripts]
208:StoryMatrix = “StoryMatrix.cli.main:app”
209:storymatrix-api = “StoryMatrix.interfaces.api.main:run”
210:storymatrix-web = “StoryMatrix.interfaces.web.main:run”
211:
212:[project.urls]
213:Homepage = “https://github.com/see-base/story-matrix”
214:Repository = “https://github.com/[[projects/storymatrix|StoryMatrix]]/[[projects/storymatrix|StoryMatrix]].git”
215:Documentation = “https://docs.[[projects/storymatrix|StoryMatrix]].ai”
216:Changelog = “https://github.com/[[projects/storymatrix|StoryMatrix]]/[[projects/storymatrix|StoryMatrix]]/blob/main/docs/changelog.md”
217:
218:
219:
220:
221:
222:# Ruff configuration for linting and formatting
223:[tool.ruff]
224:line-length = 88
225:target-version = “py310”
226:extend-exclude = [
227: “.obsolete”,
228: “docs”,
229: “audio”,
230: “outputs”,
231:]
232:
233:[tool.ruff.lint]
234:select = [
235: “E”, # pycodestyle errors
236: “W”, # pycodestyle warnings
237: “F”, # pyflakes
238: “I”, # isort
239: “B”, # flake8-bugbear
240: “C4”, # flake8-comprehensions
241: “UP”, # pyupgrade
242: “RUF”, # Ruff-specific rules
243:]
244:ignore = [
245: “E501”, # Line too long (handled by formatter)
246: “B008”, # Function calls in default arguments (FastAPI dependency injection)
247: “RUF001”, # Allow emojis / unicode in strings & docs
248: “RUF002”, # Allow ambiguous unicode chars
249: “RUF003”, # Allow ambiguous unicode in comments
250:]
251:
252:[tool.ruff.lint.per-file-ignores]
253:“tests/**/.py” = [“S101”] # Allow assert in tests
254:“scripts/chroma_importer.py” = [“E402”]
255:“scripts/granular_container_importer.py” = [“E402”]
256:“scripts/validate_playai_integration.py” = [“E402”]
257:
258:[tool.ruff.format]
259:quote-style = “double”
260:indent-style = “space”
261:docstring-code-format = true
262:
263:# MyPy type checking configuration
264:[tool.mypy]
265:python_version = “3.10”
266:warn_return_any = true
267:warn_unused_configs = true
268:disallow_untyped_defs = true
269:disallow_incomplete_defs = true
270:check_untyped_defs = true
271:disallow_untyped_decorators = true
272:strict_optional = true
273:warn_redundant_casts = true
274:warn_unused_ignores = true
275:
276:# Third-party library stubs
277:tool.mypy.overrides
278:module = [
279: “pydub.”,
280: “librosa.”,
281: “soundfile.”,
282: “elevenlabs.”,
283:]
284:ignore_missing_imports = true
285:
286:# Pytest configuration
287:[tool.pytest.ini_options]
288:asyncio_mode = “strict”
289:log_cli = true
290:pythonpath = [“src”]
291:testpaths = [“tests”]
292:python_files = “test_.py”
293:python_classes = “Test*”
294:python_functions = “test_*”
295:markers = [
296: “slow: marks tests as slow (deselect with ‘-m “not slow”’)”,
297: “integration: marks tests as integration tests”,
298: “unit: marks tests as unit tests”,
299: “api: marks tests that require API access”,
300: “asyncio: marks tests as asynchronous”,
301:]
…
303:# Coverage configuration

[Showing lines 1-300 of 354. Use :301 to continue]

🤖 Assistant

🤖 Toolresult

.

• pycache/ 6mo ago
  • voice_matcher_service.cpython-311.pyc 6.7KB 6mo ago
  • v3_prompt_enhancer.cpython-311.pyc 13.5KB 6mo ago
  • init.cpython-311.pyc 624B 6mo ago
  • character_identity_service.cpython-311.pyc 2.2KB 8mo ago
• voice_matcher_service.py 5.5KB 6mo ago
• v3_prompt_enhancer.py 11.3KB 6mo ago
• init.py 447B 6mo ago
• character_identity_service.py 1.8KB 8mo ago

🤖 Toolresult

.

• pycache/ 3mo ago
  • audio_production_service.cpython-311.pyc 52.7KB 3mo ago
  • music_mood_mapping_service.cpython-311.pyc 3.9KB 3mo ago
  • sfx_resolver_service.cpython-311.pyc 11.3KB 3mo ago
  • crew_transformer_service.cpython-311.pyc 41.2KB 3mo ago
  • character_mapping_service.cpython-311.pyc 15.1KB 6mo ago
  • deterministic_timeline_service.cpython-311.pyc 8.4KB 6mo ago
  • story_creation_service.cpython-311.pyc 35.0KB 6mo ago
  • visual_prompt_service.cpython-311.pyc 19.4KB 6mo ago
  • audio_generation_service.cpython-311.pyc 13.6KB 6mo ago
  • story_orchestration_service.cpython-311.pyc 26.9KB 6mo ago
  • audio_discovery_service.cpython-311.pyc 13.3KB 6mo ago
  • … 11 more
  • init.cpython-311.pyc 1014B 8mo ago
• audio_production_service.py 48.2KB 3mo ago
• music_mood_mapping_service.py 3.1KB 3mo ago
• sfx_resolver_service.py 9.2KB 3mo ago
• crew_transformer_service.py 44.2KB 3mo ago
• character_mapping_service.py 14.3KB 6mo ago
• deterministic_timeline_service.py 8.7KB 6mo ago
• story_creation_service.py 30.7KB 6mo ago
• visual_prompt_service.py 16.5KB 6mo ago
• audio_generation_service.py 10.6KB 6mo ago
• story_orchestration_service.py 23.3KB 6mo ago
• audio_discovery_service.py 12.5KB 6mo ago
• voice_casting_service.py 5.6KB 8mo ago
• summary_generation_service.py 17.2KB 8mo ago
• library_augmentation_service.py 8.6KB 8mo ago
• audio_track_intelligence_agent.py 13.0KB 8mo ago
• word_timing_service.py 7.5KB 8mo ago
• transformer_service.py 147B 8mo ago
• pipeline_coordinator.py 6.6KB 8mo ago
• voice_environment_service.py 2.1KB 8mo ago
• story_md_processor_service.py 9.0KB 8mo ago
• summary_generation_service.backup 12.9KB 8mo ago
• asset_metadata_service.py 11.2KB 8mo ago
• audio_library_enrichment_service.py 3.1KB 8mo ago
• init.py 787B 8mo ago
• agentic_timeline_service.py 10.6KB 8mo ago
• artifacts_service.py 9.3KB 8mo ago
• llm_query_enhancer.py 2.7KB 8mo ago
• orchestration.py 1.1KB 8mo ago
• image_generation_service.py 619B 8mo ago
• music_mood_mapping.py 987B 8mo ago

[1 results limit reached. Use limit=2 for more]

🤖 Toolresult

.

• pycache/ 8mo ago
  • montage.cpython-311.pyc 3.2KB 8mo ago
  • init.cpython-311.pyc 179B 8mo ago
• montage.py 1.9KB 8mo ago
• init.py 0B 8mo ago

🤖 Toolresult

.

• pycache/ 6mo ago
  • generate_story.cpython-311.pyc 35.8KB 6mo ago
  • init.cpython-311.pyc 399B 8mo ago
• generate_story.py 36.4KB 6mo ago
• init.py 194B 8mo ago

🤖 Toolresult

.

• DEV_MOCKS_README.md 1.2KB 8mo ago
• music/ 8mo ago
  • pycache/ 3mo ago
  • local.py 23.3KB 3mo ago
  • mock.py 2.7KB 3mo ago
  • musicgen_adapter.py 9.3KB 7mo ago
  • init.py 70B 8mo ago
• timeline/ 8mo ago
  • pycache/ 6mo ago
  • llm_agentic_timeline_adapter.py 14.8KB 6mo ago
  • init.py 0B 8mo ago
  • mock_agentic_timeline_adapter.py 4.1KB 8mo ago
• tts/ 8mo ago
  • pycache/ 3mo ago
  • elevenlabs.py 30.2KB 3mo ago
  • piper.py 43.0KB 6mo ago
  • playai.py 27.3KB 8mo ago
  • mock_tts_adapter.py 6.6KB 8mo ago
  • coqui_adapter.py 17.5KB 8mo ago
• image/ 8mo ago
  • pycache/ 6mo ago
  • midjourney.py 18.4KB 6mo ago
  • init.py 70B 8mo ago
  • dalle_adapter.py 11.3KB 8mo ago
  • pillow_adapter.py 20.2KB 8mo ago
• audio/ 8mo ago
  • pycache/ 8mo ago
  • chroma_search.py 7.3KB 8mo ago
• sfx/ 8mo ago
  • pycache/ 3mo ago
  • elevenlabs.py 9.2KB 3mo ago
  • freesound.py 15.1KB 8mo ago
  • local.py 16.9KB 8mo ago
  • init.py 68B 8mo ago
• llm/ 8mo ago
  • pycache/ 8mo ago
  • openrouter.py 31.2KB 8mo ago
  • init.py 181B 8mo ago
  • llm_story_data_adapter.py 1.4KB 8mo ago
  • ollama.py 2.0KB 8mo ago
  • query_enhancer.py 4.0KB 8mo ago
• pycache/ 8mo ago
  • init.cpython-311.pyc 416B 8mo ago
• init.py 209B 8mo ago

🤖 Toolresult

.

• pycache/ 3mo ago
  • music_orchestrator.cpython-311.pyc 8.4KB 3mo ago
  • sfx_orchestrator.cpython-311.pyc 38.5KB 3mo ago
  • ffmpeg_montage.cpython-311.pyc 55.0KB 6mo ago
  • mock_audio_search.cpython-311.pyc 5.2KB 7mo ago
  • story_planner.cpython-311.pyc 11.5KB 8mo ago
  • montage.cpython-311.pyc 62.1KB 8mo ago
  • mock_artifacts_service.cpython-311.pyc 724B 8mo ago
  • tts_orchestrator.cpython-311.pyc 25.8KB 8mo ago
  • mock_audio_processing.cpython-311.pyc 6.3KB 8mo ago
  • init.cpython-311.pyc 418B 8mo ago
• music_orchestrator.py 5.7KB 3mo ago
• sfx_orchestrator.py 32.3KB 3mo ago
• ffmpeg_montage.py 46.4KB 6mo ago
• sfx/ 7mo ago
  • pycache/ 3mo ago
  • mock_sfx_adapter.py 6.3KB 3mo ago
• audio/ 8mo ago
  • pycache/ 8mo ago
  • init.py 465B 8mo ago
  • mixing_engine.py 9.0KB 8mo ago
  • audio_processor.py 6.7KB 8mo ago
  • pause_calculator.py 5.5KB 8mo ago
• image/ 8mo ago
  • pycache/ 8mo ago
  • mock_image_service.py 2.7KB 8mo ago
• story_data/ 8mo ago
  • pycache/ 8mo ago
  • mock_story_data_service.py 7.5KB 8mo ago
  • story_data_service_provider_factory.py 1.6KB 8mo ago
• llm/ 8mo ago
  • pycache/ 8mo ago
  • init.py 0B 8mo ago
  • mock_llm_service.py 11.9KB 8mo ago
• mock_artifacts_service.py 186B 8mo ago
• mock_audio_discovery_service.py 292B 8mo ago
• mock_audio_generation_service.py 309B 8mo ago
• mock_audio_processing.py 3.2KB 8mo ago
• mock_audio_production_service.py 782B 8mo ago
• mock_audio_search.py 2.8KB 8mo ago
• mock_character_mapping_service.py 902B 8mo ago
• mock_deterministic_timeline_service.py 339B 8mo ago
• mock_image_generation_service.py 211B 8mo ago
• mock_pipeline_coordinator.py 834B 8mo ago
• mock_story_orchestration_service.py 1.0KB 8mo ago
• mock_summary_generation_service.py 219B 8mo ago
• mock_transformer_service.py 194B 8mo ago
• mock_visual_prompt_service.py 448B 8mo ago
• mock_voice_casting_service.py 590B 8mo ago
• mock_voice_data_loader.py 175B 8mo ago
• mock_voice_environment_service.py 215B 8mo ago
• audio_effects.py 8.6KB 8mo ago
• montage.py 57.4KB 8mo ago
• agents/ 8mo ago
  • bard.py 3.9KB 8mo ago
  • scribe.py 2.1KB 8mo ago
  • architect.py 1.9KB 8mo ago
  • base.py 1.5KB 8mo ago
• api_cache.py 14.2KB 8mo ago
• music/ 8mo ago
  • mock_music_service.py 2.5KB 8mo ago
• tts_orchestrator.py 23.2KB 8mo ago
• init.py 211B 8mo ago
• story_planner.py 11.0KB 8mo ago

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/utils/json_utils.py#D21B]
1:import json
2:import re
3:from typing import Any, Optional
4:from loguru import logger
5:
6:
7:def _fix_llm_json_newlines(json_str: str) -> str:
8: """Fix common LLM JSON issues like unescaped newlines in string values."""
9: # Replace smart quotes
10: fixed = json_str.replace(’”’, ’”‘).replace(’”’, ’”’)
11: fixed = fixed.replace(''', ”’“).replace(''', ”’”)
12:
13: # Simple but effective approach: use regex to find and fix broken JSON strings
14: import re
15:
16: # Pattern: find lines that have an opening quote but don’t have a closing quote
17: # AND the next line(s) complete the string
18: lines = fixed.split(‘\n’)
19: result_lines = []
20: i = 0
21:
22: while i < len(lines):
23: line = lines[i]
…
55: i += 1
56:
57: return ‘\n’.join(result_lines)
58:
59:
60:def extract_json_from_string(text: str) -> Optional[str]:
61: """Extract the first balanced JSON object from an arbitrary LLM string.
…
71: """
72: if not text:
73: return None
74:
75: # 1) Prefer explicit fenced JSON blocks
76: fence_json = re.search(r”json\s*([\s\S]*?)”, text, re.IGNORECASE)
77: if fence_json:
78: candidate = fence_json.group(1).strip()
79: if candidate:
80: return candidate
81:
82: # 2) Generic fenced block (sometimes model omits the language)
83: fence_any = re.search(r”\s*([\s\S]*?)”, text)
84: if fence_any:
85: candidate = fence_any.group(1).strip()
…
88: return candidate
89:
90: # 3) Find JSON that might be preceded by conversational text
91: # This is a bit of a greedy regex, but it’s effective for cases like:
92: # “Here is the JSON you requested: { … }”
93: free_form_json = re.search(r”^.?({.})”, text, re.DOTALL)
94: if free_form_json:
95: candidate = free_form_json.group(1).strip()
96: if candidate:
97: return candidate
98:
99: # 4) Balanced-brace scan from the first ’{’
100: start = text.find(”{”)
101: if start == -1:
102: logger.warning(“Could not find JSON object start (’{’) in LLM output.”)
103: return None
104:
105: # 4) If the text starts with ’{’ and no fences were found, assume the whole thing is JSON
106: if text.strip().startswith(”{”) and text.strip().endswith(”}”):
107: return text.strip()
108:
109: depth = 0
110: in_string = False
111: escape = False
112: end_idx = -1
113: for i, ch in enumerate(text[start:], start=start):
114: if in_string:
…
131: break
132:
133: if end_idx != -1:
134: return text[start : end_idx + 1].strip()
135:
136: logger.warning(“Found ’{’ but could not locate matching balanced ’}’ in LLM output.”)
137: return None
138:
139:
140:def extract_all_json_candidates(text: str) -> list[str]:
141: """Extract all plausible JSON candidates from an LLM output.
…
210: return unique
211:
212:
213:def parse_json_from_llm(raw_output: str) -> Optional[Any]:
214: """Parse JSON from raw LLM output with robust fallbacks.
…
290: return _try_decode(json_str)

[201 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/utils/json_utils.py:24-54,62-70]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/config/yaml_precedence_validator.py#F4C8]
1:"""YAML Configuration Precedence Validator and Enhanced Parser."""
2:
3:import yaml
4:from pathlib import Path
5:from typing import Any, Dict, List, Optional, Union
6:from dataclasses import dataclass, field
7:from loguru import logger
8:from pydantic import BaseModel, ValidationError
9:
10:from .models import StoryMatrixConfig
11:
12:
13:@dataclass
14:class ConfigSource:
15: """Represents a configuration source with precedence level."""
16: name: str
17: path: Optional[Path]
18: data: Dict[str, Any]
19: precedence: int # Higher number = higher precedence
20: source_type: str # “yaml”, “env”, “cli”, “default”
21:
22:
23:@dataclass
24:class ConfigConflict:
25: """Represents a configuration conflict between sources."""
26: key_path: str
27: sources: List[ConfigSource]
28: resolved_value: Any
29: resolution_reason: str
30:
31:
32:class YAMLConfigValidator:
33: """Enhanced YAML configuration validator with precedence handling."""
34:
35: def init(self):
36: self.sources: List[ConfigSource] = []
37: self.conflicts: List[ConfigConflict] = []
38:
39: def add_yaml_source(self, path: Path, precedence: int, name: Optional[str] = None) -> None:
40: """Add a YAML configuration source."""
…
68: raise
69:
70: def _enhance_yaml_parsing(self, data: Dict[str, Any]) -> Dict[str, Any]:
71: """Enhanced YAML parsing with native list support and type coercion."""
…
83: return enhanced_data
84:
85: def _parse_native_lists(self, value: str) -> Union[str, List[str]]:
86: """Parse native list syntax in YAML strings."""
…
106: return value
107:
108: def add_env_source(self, env_data: Dict[str, Any], precedence: int) -> None:
109: """Add environment variables as a configuration source."""
…
119: logger.debug(f”Added environment source (precedence: {precedence})”)
120:
121: def add_cli_source(self, cli_data: Dict[str, Any], precedence: int) -> None:
122: """Add CLI arguments as a configuration source."""
…
132: logger.debug(f”Added CLI source (precedence: {precedence})”)
133:
134: def merge_configurations(self) -> Dict[str, Any]:
135: """Merge all configuration sources respecting precedence."""
…
144: return merged_config
145:
146: def _merge_source_data(self, target: Dict[str, Any], source: ConfigSource, key_path: str) -> None:
147: """Merge data from a source into target configuration."""
…
174: target[key] = value
175:
176: def _merge_nested_dict(self, target: Dict[str, Any], source_data: Dict[str, Any], key_path: str, source: ConfigSource) -> None:
177: """Merge nested dictionary data."""
…
195: target[key] = value
196:
197: def _find_value_source(self, config: Dict[str, Any], key: str, value: Any) -> Optional[ConfigSource]:
198: """Find which source provided a specific value."""
…
202: return None
203:
204: def validate_configuration(self, merged_config: Dict[str, Any]) -> tuple[bool, List[str]]:
205: """Validate merged configuration against StoryMatrixConfig model."""
…
223: return False, [str(e)]
224:
225: def generate_precedence_report(self) -> str:
226: """Generate a detailed precedence report."""
…
261: return report
262:
263: def _get_nested_value(self, data: Dict[str, Any], keys: List[str]) -> Any:
264: """Get nested value from dictionary using key path."""
…
271: return current
272:
273: def save_report(self, output_path: Path) -> None:
274: """Save precedence report to file."""
…
281: logger.success(f”Configuration precedence report saved: {output_path}”)
282:
283:
284:class EnhancedYAMLParser:
285: """Enhanced YAML parser with better list and type support."""
…
331: loader_class.add_constructor(‘tag:yaml.org,2002:bool’, construct_enhanced_bool)
332:
333:
334:def validate_config_precedence(
…
339:) -> tuple[Dict[str, Any], bool, List[str]]:
340: """
…
376: return merged_config, is_valid, errors

[276 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/config/yaml_precedence_validator.py:41-67,72-82]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/utils/async_helpers.py#5E2A]
1:"""⚡ Async Helper Utilities
…
5:"""
6:
7:import asyncio
…
12:from StoryMatrix.domain.exceptions import DomainError
13:
14:T = TypeVar(‘T’)
15:
16:
17:class AsyncTimeoutError(DomainError):
18: """Raised when an async operation times out."""
19: pass
20:
21:
22:class CircuitBreakerError(DomainError):
23: """Raised when circuit breaker is open."""
24: pass
25:
26:
27:def with_timeout(timeout_seconds: float):
28: """Decorator to add timeout to async functions.
…
49: return decorator
50:
51:
52:async def exponential_backoff_retry(
…
61:) -> T:
62: """Retry async function with exponential backoff.
…
105: raise DomainError(“Retry loop completed without result or exception”)
106:
107:
108:class CircuitBreaker:
109: """Circuit breaker pattern for external service calls."""
…
171: self.state = “open”
172:
173:
174:class AsyncResourceManager:
175: """Manages async resources with proper cleanup."""
…
211: await self.cleanup_all()
212:
213:
214:async def gather_with_concurrency_limit(
…
217:) -> list[T]:
218: """Gather awaitables with concurrency limit.
…
234: return await asyncio.gather(*limited_awaitables)
235:
236:
237:def create_task_with_error_handling(
…
241:) -> asyncio.Task[T]:
242: """Create task with proper error handling.
…
267: return task

[217 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/utils/async_helpers.py:2-4,8-11]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/domain/exceptions.py#BEF2]
1:"""Custom domain-specific exceptions."""
2:
3:
4:class StoryMatrixException(Exception):
5: """Base exception for all application-specific errors."""
6:
7: pass
8:
9:
10:class StoryMatrixError(StoryMatrixException):
11: """Base exception for all application-specific errors."""
12:
13: pass
14:
15:
16:class ApplicationError(StoryMatrixError):
17: """Raised for general application-level errors."""
18:
19: pass
20:
21:
22:class ConfigurationError(StoryMatrixError):
23: """Raised when a configuration is invalid or missing."""
24:
25: pass
26:
27:
28:class EntityNotFoundError(StoryMatrixError):
29: """Raised when an entity is not found in the repository."""
…
35: self.entity_type = entity_type
36:
37:
38:class DomainError(StoryMatrixError):
39: """Custom exception for domain logic errors."""
…
43: self.details = kwargs
44:
45:
46:class RepositoryError(StoryMatrixError):
47: """Custom exception for repository-related errors."""
…
52: self.details = kwargs
53:
54:
55:class ValidationError(StoryMatrixException):
56: """Raised when input data fails validation checks."""
57:
58: pass
59:
60:
61:class StoryGenerationError(StoryMatrixException):
62: """Raised when an error occurs during the story generation process."""
63:
64: pass
65:
66:
67:class LLMGenerationError(StoryGenerationError):
68: """Raised when an error occurs during LLM interaction."""
69:
70: pass
71:
72:
73:class LLMTimeoutError(LLMGenerationError):
74: """Raised when an LLM request times out."""
75:
76: pass
77:
78:
79:class LLMInvalidRequestError(LLMGenerationError):
80: """Raised when the LLM provider rejects the request as invalid."""
81:
82: pass
83:
84:
85:class LLMRateLimitError(LLMGenerationError):
86: """Raised when the LLM provider indicates a rate limit has been exceeded."""
87:
88: pass
89:
90:
91:class LLMServiceUnavailableError(LLMGenerationError):
92: """Raised when the LLM provider is unavailable."""
93:
94: pass
95:
96:
97:class ExternalServiceError(StoryMatrixException):
98: """Raised when an external service call fails."""
…
106: self.details = details

[19 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/domain/exceptions.py:30-34,40-42]

🤖 Assistant

Now let me read a few more key files to complete the review:

🤖 Toolresult

.

• test_outputs/ 6mo ago
  • 202511130420_20251113052027_untitled_story/ 6mo ago
• crew/ 6mo ago
  • pycache/ 6mo ago
  • test_runner_multi.py 2.3KB 6mo ago
• pycache/ 7mo ago
  • test_voice_fix.cpython-311-pytest-8.4.1.pyc 6.4KB 7mo ago
  • test_simple.cpython-311-pytest-8.4.1.pyc 698B 7mo ago
  • test_sanity.cpython-311-pytest-8.4.1.pyc 702B 7mo ago
  • test_music_crossfades.cpython-311-pytest-8.4.1.pyc 8.7KB 7mo ago
  • test_chroma.cpython-311-pytest-8.4.1.pyc 158B 7mo ago
  • conftest.cpython-311-pytest-8.4.1.pyc 3.8KB 7mo ago
  • conftest.cpython-311-pytest-7.2.1.pyc 3.8KB 7mo ago
  • test_voice_fix.cpython-311-pytest-8.4.2.pyc 6.4KB 8mo ago
  • test_simple.cpython-311-pytest-8.4.2.pyc 698B 8mo ago
  • test_chroma.cpython-311-pytest-8.4.2.pyc 158B 8mo ago
  • test_sanity.cpython-311-pytest-8.4.2.pyc 702B 8mo ago
  • … 1 more
  • conftest.cpython-311-pytest-8.4.2.pyc 3.8KB 8mo ago
• integration/ 8mo ago
  • pycache/ 7mo ago
  • test_voice_character_flow.py 15.5KB 8mo ago
  • test_di_gating.py 1.2KB 8mo ago
  • test_language_parameter.py 2.9KB 8mo ago
  • test_config_flag_combinations.py 5.2KB 8mo ago
  • test_golden_path.py 6.8KB 8mo ago
  • test_full_pipeline.py 1.3KB 8mo ago
  • test_pipeline_config.yaml 96B 8mo ago
  • test_audio_segment_generation.py 6.5KB 8mo ago
  • test_hierarchical_artifacts.py 11.3KB 8mo ago
  • test_sfx_resolution_pipeline.py 3.6KB 8mo ago
  • … 17 more
  • test_piper_german.py 2.3KB 9mo ago
• unit/ 8mo ago
  • pycache/ 7mo ago
  • config/ 8mo ago
  • utils/ 8mo ago
  • infrastructure/ 8mo ago
  • cli/ 8mo ago
  • application/ 8mo ago
  • test_cli.py 3.0KB 8mo ago
  • test_services.py 12.6KB 8mo ago
  • test_core_entities.py 7.4KB 8mo ago
  • core/ 9mo ago
  • domain/ 9mo ago
• smoke/ 8mo ago
  • pycache/ 7mo ago
  • test_sfx_orchestrator_smoke.py 3.8KB 8mo ago
• services/ 8mo ago
  • pycache/ 7mo ago
  • test_sfx_orchestrator.py 1.7KB 9mo ago
• scripts/ 8mo ago
  • pycache/ 7mo ago
  • test_1_extract_features.py 2.3KB 10mo ago
• performance/ 8mo ago
  • pycache/ 7mo ago
  • test_audio_processing.py 9.2KB 8mo ago
• cli/ 8mo ago
  • pycache/ 7mo ago
  • test_cli_config_yaml.py 4.8KB 8mo ago
  • test_main.py 3.0KB 8mo ago
• test_music_crossfades.py 2.7KB 8mo ago
• fixtures/ 8mo ago
  • crew/ 8mo ago
  • music/ 8mo ago
  • tts/ 8mo ago
  • init.py 226B 8mo ago
  • llm/ 8mo ago
  • sfx/ 8mo ago
• elevenlabs/ 8mo ago
  • _manual_test_elevenlabs_v3.py 2.9KB 9mo ago
  • _manual_test_adapter.py 2.3KB 10mo ago
  • _test_elevenlabs_direct.py 2.8KB 10mo ago
• test_chroma.py 0B 8mo ago
• conftest.py 2.2KB 8mo ago
• test_simple.py 42B 8mo ago
• test_voice_fix.py 4.5KB 8mo ago
• e2e_test_config.yaml 400B 9mo ago
• simple_timing_test.py 8.1KB 9mo ago
• real_timing_test.py 6.7KB 9mo ago
• application/ 9mo ago
  • services/ 8mo ago
  • production/ 9mo ago
• infrastructure/ 9mo ago
  • services/ 8mo ago
  • repositories/ 9mo ago
• test_sanity.py 46B 9mo ago

[1 results limit reached. Use limit=2 for more]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/infrastructure/mock_service.py#2975]
1:"""Enhanced MockService for full story generation with proper data flow."""
2:
3:from pathlib import Path
4:
5:
6:class MockService:
7: """Enhanced mock service that generates actual story content."""
8:
9: def init(self, **kwargs):
10: self.dict.update(kwargs)
11:
12: def getattr(self, name):
13: # Handle timeline access - return proper AgenticTimeline
14: if name == ‘timeline’:
…
449: return MockService()
450:
451: # Dict-like behavior for timeline compatibility
452: def getitem(self, key):
453: return self.getattr(key)
454:
455: def contains(self, key):
456: return True # Always return True for compatibility
457:
458: def iter(self):
459: # Return empty iterator to handle ‘for item in mock_service’ cases
460: return iter([])
461:
462: def len(self):
463: return 0 # Return 0 length for len() calls
464:
465: def get(self, key, default=None):
466: try:
…
469: return default
470:
471: def call(self, *args, **kwargs):
472: # Handle various method calls
473: return MockService()
474:
475:
476:def _create_use_case_with_mocks(config):
477: """Create use case with mock services - compatibility function."""
478: from StoryMatrix.application.use_cases.generate_story import GenerateStoryUseCase
479:
480-492: return GenerateStoryUseCase( .. )

[447 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/infrastructure/mock_service.py:15-448,467-468]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/application/use_cases/generate_story.py#D123]
1:"""Story Generation Use Case
…
15:"""
16:
17:import asyncio
18:import json
19:import random
20:import sys
21:import time
22:import uuid
23:from contextlib import redirect_stdout, redirect_stderr
24:import os
25:from io import StringIO
26:from pathlib import Path
27:from typing import Any
28:
29:from loguru import logger
30:from pydantic import ValidationError as PydanticValidationError
31:
32:from StoryMatrix.application.services.visual_prompt_service import VisualPromptService
33:from StoryMatrix.application.services.story_orchestration_service import StoryOrchestrationService
34:from StoryMatrix.application.services.pipeline_coordinator import PipelineCoordinator
35:
36:from StoryMatrix.application.dto.requests import GenerateStoryRequest
37-40:from StoryMatrix.application.dto.responses import ( .. )
41:from StoryMatrix.application.interfaces.services import ImageGenerationService
42:from StoryMatrix.application.production.context import (
43: StoryProductionContext as ProductionContext,
44:)
45:from StoryMatrix.application.production.pipeline import StoryProductionPipeline
46:from StoryMatrix.application.production.stages.assemble_audio import AssembleAudioStage
47:from StoryMatrix.application.production.stages.cleanup_stage import CleanupStage
48:from StoryMatrix.application.production.stages.finalize_production import (
49: FinalizeProductionStage,
50:)
51:from StoryMatrix.application.production.stages.generate_media_assets import (
52: GenerateMediaAssetsStage,
53:)
54:from StoryMatrix.application.production.stages.story_plan_stage import StoryPlanStage
55:from StoryMatrix.application.production.stages.story_writing_stage import StoryWritingStage
56:from StoryMatrix.application.production.stages.timeline_generation_stage import TimelineGenerationStage
57:from StoryMatrix.application.production.stages.image_prompt_generation_stage import ImagePromptGenerationStage
58:from StoryMatrix.application.production.stages.character_mapping_stage import CharacterMappingStage
59:from StoryMatrix.application.services.artifacts_service import ArtifactsService
60:from StoryMatrix.application.services.audio_generation_service import AudioGenerationService
61:from StoryMatrix.application.services.audio_production_service import (
62: AudioProductionService,
63:)
64:from StoryMatrix.application.services.crew_transformer_service import CrewTransformerService
65:from StoryMatrix.application.services.character_mapping_service import CharacterMappingService
66:from StoryMatrix.application.services.voice_environment_service import VoiceEnvironmentService
67:from StoryMatrix.application.services.summary_generation_service import SummaryGenerationService
68:from StoryMatrix.config.models import TTSProvider
69-72:from StoryMatrix.crew.crew import ( .. )
73:from StoryMatrix.crew.schemas import StoryPlan, StoryData, AudioTimeline
74:from StoryMatrix.domain.entities import AgenticTimeline as DomainTimeline, ArtifactType
75:from StoryMatrix.domain.entities import Story
76-81:from StoryMatrix.domain.entities.segment import ( .. )
82:from StoryMatrix.domain.entities.timeline import Track as DomainTrack
83:from StoryMatrix.domain.exceptions import StoryGenerationError
84:from StoryMatrix.infrastructure.celery_app import celery_app
85:from StoryMatrix.infrastructure.voice_loader import VoiceDataLoader
86:from StoryMatrix.utils.json_utils import parse_json_from_llm
87:from StoryMatrix.utils.text_utils import sanitize_for_filename
88:
89:
90:@celery_app.task(
91: name=“StoryMatrix.application.use_cases.generate_story.generate_story_task”,
92:)
93:def generate_story_task(self, story_id: str) -> dict:
94: """Celery task to generate a story from a given story_id."""
…
149: return result.model_dump()
150:
151:
152:class GenerateStoryUseCase:
153: """Use case for generating complete stories with multimedia content."""
…
781: return story

[702 lines elided; re-read needed ranges, e.g. /home/dev/active/StoryMatrix/src/StoryMatrix/application/use_cases/generate_story.py:2-14,37-40]

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/utils/security.py#DF48]
19:
20:def sanitize_command(cmd: list[str]) -> list[str]:
21: """Sanitize subprocess commands to prevent injection attacks.
22:
23: Args:
24: cmd: Command and arguments list
25:
26: Returns:
27: Sanitized command list
28:
29: Raises:
30: SecurityError: If command is not in allowlist
31: """
32: if not cmd:
33: raise SecurityError(“Empty command not allowed”)
34:
35: # Allowlist of permitted commands
36: allowed_commands = {
37: ‘piper’, ‘piper-tts’,
38: ‘ffmpeg’, ‘ffprobe’,
39: ‘sox’, ‘soxi’,
40: ‘python’, ‘python3’
41: }
42:
43: command_name = Path(cmd[0]).name # Extract just the command name
44: if command_name not in allowed_commands:
45: raise SecurityError(f”Command not allowed: {command_name}”)
46:
47: # Quote all arguments to prevent injection
48: return [shlex.quote(str(arg)) for arg in cmd]
49:
50:
51:def validate_file_path(path: Path, allowed_base: Path | None = None) -> Path:
52: """Validate file paths to prevent traversal attacks.
53:
…
63: """
…
79: raise SecurityError(f”Invalid path: {path}”) from e

[Showing lines 19-53 of 119. Use :54 to continue]

🤖 Toolresult

[active/StoryMatrix/.env.example#A6E8]
1:# --------------------------------------------------------------------------
2:# StoryMatrix Environment Variables (.env.example)
3:# --------------------------------------------------------------------------
4:# Copy this file to .env and fill in your API keys and preferences.
5:#
6:# This application uses Pydantic’s nested environment variable support.
7:# The format is SECTION__VARIABLE_NAME (note the double underscore).
8:# --------------------------------------------------------------------------
9:
10:# --- Core Provider API Keys (Required for Full Functionality) ---
11:
12:# OpenRouter (Required for LLM story generation)
13:# Get a key from https://openrouter.ai/
14:PROVIDERS__OPENROUTER__API_KEY=your_openrouter_api_key_here
15:
16:# --- Optional Provider API Keys (For Premium/Alternative Services) ---
17:
18:# ElevenLabs (Premium TTS voices and SFX generation)
19:# Get a key from https://elevenlabs.io/
20:ELEVENLABS_API_KEY=“your_elevenlabs_api_key_here”
21:ELEVENLABS_VOICE_ID=“your_voice_id_here”
22:
23:# PlayAI TTS (Alternative premium TTS provider)
24:# Get credentials from https://play.ai/
25:PROVIDERS__PLAYAI__USER_ID=your_playai_user_id_here
26:PROVIDERS__PLAYAI__API_KEY=your_playai_api_key_here
27:
28:# Freesound (For a wider library of sound effects)
29:# Get a key from https://freesound.org/docs/api/
30:PROVIDERS__FREESOUND__API_KEY=your_freesound_api_key_here
31:
32:# DALL-E (For AI image generation)
33:# Get a key from https://platform.openai.com/api-keys
34:PROVIDERS__DALLE__API_KEY=your_openai_api_key_here
35:
36:# Midjourney (For AI image generation via proxy)
37:# Uses midjourney-proxy service: https://github.com/trueai-org/midjourney-proxy
38:# Base URL only - endpoints are constructed in adapter
39:PROVIDERS__MIDJOURNEY__API_URL=http://0rk.de:55566
40:PROVIDERS__MIDJOURNEY__API_KEY=123
41:
42:# Unused/Legacy Services (Preserved for reference)
43:# PROVIDERS__BLTCY__API_KEY=your_bltcy_api_key_here
44:
45:
46:# --- Provider Strategy Configuration ---
47:# Define the preferred provider for each service. The application will use this
48:# provider if it’s configured, otherwise it may fall back to another option.
49:
50:# Options: “openrouter”, “mock”
51:PROVIDERS__STRATEGY__LLM_PROVIDER=openrouter
52:
53:# Options: “piper” (local, free), “elevenlabs” (premium), “playai” (premium), “mock”
54:PROVIDERS__STRATEGY__TTS_PROVIDER=piper
55:
56:# Options: “dalle”, “midjourney”, “pillow”, “mock”
57:PROVIDERS__STRATEGY__IMAGE_PROVIDER=pillow
58:
59:# Options: “freesound”, “elevenlabs”, “local”, “mock”
60:PROVIDERS__STRATEGY__SFX_PROVIDER=local
61:
62:# Options: “local”, “musicgen”, “mock”
63:PROVIDERS__STRATEGY__MUSIC_PROVIDER=local
64:
65:
66:# --- Provider-Specific Settings (Optional Fine-Tuning) ---
67:
68:# OpenRouter LLM model
69:# See available models at https://openrouter.ai/models
70:# PROVIDERS__OPENROUTER__DEFAULT_MODEL=anthropic/claude-3-sonnet
71:
72:# DALL-E Image Generation Model
73:# PROVIDERS__DALLE__DEFAULT_MODEL=dall-e-3
74:
75:# ElevenLabs Voice and Model Configuration
76:# PROVIDERS__ELEVENLABS__DEFAULT_VOICE=Rachel
77:# PROVIDERS__ELEVENLABS__MODEL_ID=eleven_multilingual_v2
78:
79:
80:# --- Internal Services Configuration & Settings ---
81:
82:# PostgreSQL Database URL for SQLAlchemy and Alembic
83:# Format: postgresql+psycopg2://:@:/
84:# SERVICES__DATABASE__URL=postgresql+psycopg2://StoryMatrix:storysqldbpass@localhost:57757/StoryMatrix
85:
86:# --- Internal Services Configuration ---
87:
88:# --- Service Ports ---
89:# All services should use a unique port in the 577X7 range.
90:SERVICES__API__PORT=57707
91:SERVICES__CELERY__BROKER_PORT=57717
92:SERVICES__CELERY__RESULT_BACKEND_PORT=57717
93:SERVICES__CHROMA__PORT=57727
94:SERVICES__WEB__PORT=57737
95:SERVICES__DATABASE__PORT=57757
96:
97:# --- Service Hosts ---
98:SERVICES__API__HOST=0.0.0.0
99:SERVICES__CELERY__BROKER_HOST=localhost
100:SERVICES__CELERY__RESULT_BACKEND_HOST=localhost
101:SERVICES__CHROMA__HOST=localhost
102:SERVICES__WEB__HOST=0.0.0.0
103:SERVICES__DATABASE__HOST=localhost
104:
105:# --- Service-Specific Settings ---
106:
107:# PostgreSQL Database
108:# The URL is constructed from the host, port, and credentials below.
109:SERVICES__DATABASE__USER=StoryMatrix
110:SERVICES__DATABASE__PASSWORD=storysqldbpass
111:SERVICES__DATABASE__DBNAME=StoryMatrix
112:
113:# ChromaDB semantic search service
114:SERVICES__CHROMA__DB_PATH=./data/chroma_db
115:SERVICES__CHROMA__MODEL_NAME_OR_PATH=all-MiniLM-L6-v2
116:
117:# Media Asset library database (SQLite)
118:SERVICES__MEDIA_REPOSITORY__DB_PATH=./data/media_library.db
119:
120:# Local Assets (SFX/Music) library paths
121: # LocalSFXAdapter recursively scans the SFX root at runtime.
122: # Supported formats: .flac, .wav, .mp3, .ogg, .m4a
123: # Point this to the root folder of your SFX library, not a single subfolder.
124:SERVICES__LOCAL_ASSETS__SFX_LIBRARY_PATH=./assets/sfx
125:SERVICES__LOCAL_ASSETS__MUSIC_LIBRARY_PATH=./assets/music
126: # Minimum similarity score for local semantic search (0.0 - 1.0)
127:# SERVICES__LOCAL_ASSETS__MIN_SIMILARITY_SCORE=0.70
128:
129:# Piper local TTS service
130:SERVICES__PIPER__VOICES_DIR=./models/voices/piper
131:SERVICES__PIPER__DEFAULT_VOICE=en_US-lessac-high
132:
133:# Montage service for audio assembly
134: # Target loudness for audio normalization in dBFS (decibels relative to full scale)
135:SERVICES__MONTAGE__TARGET_LOUDNESS_DBFS=-20.0
136:
137:
138:# --- Core Application Settings ---
139:
140:# Log level for the application (e.g., DEBUG, INFO, WARNING, ERROR)
141:# APP__LOG_LEVEL=INFO
142:
143:# Development: Force local-only providers to avoid external API usage/costs.
144:# When enabled, container wires only local adapters (TTS=Piper, SFX=local, Music=local, Image=mock).
145:# APP__DEV_LOCAL_ONLY=true
146:
147:# Directories for application data
148:# APP__OUTPUT_DIR=./outputs
149:# APP__TEMP_DIR=./temp
150:# APP__CACHE_DIR=./cache
151:# APP__MEDIA_DIR=./media
152:# APP__SILENCE_DIR=./assets/silence
153:
154:
155:# --- Web Interface Configuration ---
156:
157:# Port for the web server (default: 8080)
158:SERVICES__WEB__PORT=57777
159:
160:# Host for the web server (default: 127.0.0.1)
161:# SERVICES__WEB__HOST=127.0.0.1
162:
163:# Enable/disable web authentication (default: false)
164:# SERVICES__WEB__AUTH_ENABLED=false
165:
166:# Enable/disable auto-reload in development (default: true)
167:# SERVICES__WEB__RELOAD=true
168:
169:# Enable/disable dark mode by default (default: true)
170:# SERVICES__WEB__DARK_MODE=true
171:
172:# Web application title (default: “StoryMatrix Web”)
173:# SERVICES__WEB__TITLE=“StoryMatrix Web”
174:
175:
176:# --- API Security Configuration ---
177:
178:# Enable/disable API authentication (default: false)
179:# SERVICES__API__AUTH_ENABLED=false
180:
181:# API key for authentication (if enabled)
182:# SERVICES__API__API_KEY=your_secure_api_key_here
183:
184:# Enable/disable API rate limiting (default: false)
185:# SERVICES__API__RATE_LIMIT_ENABLED=false
186:
187:# Rate limit: requests per minute (default: 100)
188:# SERVICES__API__RATE_LIMIT_REQUESTS=100
189:
190:# Enable/disable CORS support (default: true)
191:# SERVICES__API__CORS_ENABLED=true
192:

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/infrastructure/container.py#7BE3]
611:
612:class ServiceContainer(containers.DeclarativeContainer):
613: config = providers.Configuration(strict=False)
614: # Dependency injection container for StoryMatrix services.
615:
616: def init(self, *args, **kwargs):
617: # Ensure that config works when a Pydantic StoryMatrixConfig instance is passed
618: # directly (as in unit tests). We coerce it to a plain dict and, if no values are
619: # provided, we hydrate from environment via BaseSettings defaults.
620: # Pop ‘config’ out before calling super().init so dependency_injector
621: # does not attempt to bind it directly into providers.Configuration.
622: try:
623: cfg_kw = kwargs.pop(“config”, None)
624: except Exception:
625: cfg_kw = None
626: super().init(*args, **kwargs)
627:
628: cfg_dict = None
629: try:
630: if cfg_kw is not None and hasattr(cfg_kw, “model_dump”):
631: cfg_dict = cfg_kw.model_dump()
632: elif isinstance(cfg_kw, dict):
633: cfg_dict = cfg_kw
634: except Exception:
635: cfg_dict = None
636:
637: try:
638: # Always start from environment-driven BaseSettings to honor env overrides
639: base_env = StoryMatrixConfig().model_dump()
640:
641: # Deep-merge helper (dict-only), cfg overrides base
642: def _deep_update(dst: dict, src: dict) -> dict:
643: for k, v in (src or {}).items():
644: if isinstance(v, dict) and isinstance(dst.get(k), dict):
645: dst[k] = _deep_update(dict(dst.get(k) or {}), v)
646: else:
647: dst[k] = v
648: return dst
649:
650: # Start from provided cfg (if any), then overlay environment-driven values on top
651: provided_dict = (
652: dict(cfg_dict)
653: if isinstance(cfg_dict, dict)
654: else (cfg_kw.model_dump() if cfg_kw is not None and hasattr(cfg_kw, “model_dump”) else {})
655: )
656: merged_dict = _deep_update(provided_dict, base_env)
657:
658: # Re-validate merged configuration to normalize types/enums
659: validated = StoryMatrixConfig.model_validate(merged_dict)
660: self._config_dict = validated.model_dump()
661: self.config.from_dict(self._config_dict)
662:
663: # Wrap from_pydantic to support partial updates (e.g., AppSettings only)
664: _orig_from_pydantic = self.config.from_pydantic
665:
666: def _from_pydantic_shim(model):
667: try:
668: from StoryMatrix.config.models import (
669: StoryMatrixConfig as _SMC,
670: AppSettings as _App,
671: ProvidersSettings as _Prov,
672: ServicesSettings as _Serv,
673: )
674: if isinstance(model, _SMC):
675: self._config_dict = model.model_dump()
676: return _orig_from_pydantic(model)
677: if isinstance(model, _App):
678: app_dict = model.model_dump()
679: base = dict(getattr(self, “_config_dict”, None) or StoryMatrixConfig().model_dump())
680: base_defaults = StoryMatrixConfig().app.model_dump()
681: merged_app = _deep_update(base_defaults, app_dict)
682: base[“app”] = merged_app
683: self._config_dict = base
684: return self.config.from_dict(self._config_dict)
685: if isinstance(model, _Prov):
686: prov_dict = model.model_dump()
687: base = dict(getattr(self, “_config_dict”, None) or StoryMatrixConfig().model_dump())
688: prov_defaults = StoryMatrixConfig().providers.model_dump()
689: merged_prov = _deep_update(prov_defaults, prov_dict)
690: base[“providers”] = merged_prov
691: self._config_dict = base
692: return self.config.from_dict(self._config_dict)
693: if isinstance(model, _Serv):
694: serv_dict = model.model_dump()
695: base = dict(getattr(self, “_config_dict”, None) or StoryMatrixConfig().model_dump())
696: serv_defaults = StoryMatrixConfig().services.model_dump()
697: merged_serv = _deep_update(serv_defaults, serv_dict)
698: base[“services”] = merged_serv
699: self._config_dict = base
700: return self.config.from_dict(self._config_dict)
701: except Exception:
702: pass
703: # Fallback to original behavior
704: try:
705: _orig_from_pydantic(model)
706: except Exception:
707: pass
708: return None
709:
710: # Assign shim
711: self.config.from_pydantic = _from_pydantic_shim # type: ignore[attr-defined]
712: except Exception:
713: # As a last resort, try to load raw dict if available
714: try:
715: if isinstance(cfg_dict, dict):
716: self._config_dict = cfg_dict
717: self.config.from_dict(self._config_dict)
718: else:
719: # Fallback to env-only
720: self._config_dict = StoryMatrixConfig().model_dump()
721: self.config.from_dict(self._config_dict)
722: except Exception:
723: pass
724:
725: # ======================================================================================
726: # 1. CORE CONFIGURATION & REPOSITORIES
727: audio_generation_service = providers.Singleton(AudioGenerationService)
728: aiohttp_session = providers.Singleton(aiohttp.ClientSession)
729: httpx_client = providers.Singleton(httpx.AsyncClient)
730: elevenlabs_client = providers.Singleton(
731: elevenlabs_client_provider, config=config.providers.elevenlabs
732: )
733:
734: # --- Database Session Management ---
735: # Main content database (StoryMatrix.db)
736: content_db_engine = providers.Singleton(
737: lambda db_url: import(
738: “sqlalchemy”, fromlist=[“create_engine”]
739: ).create_engine(
740: db_url,
741: connect_args={“check_same_thread”: False}
742: if str(db_url).startswith(“sqlite”)
743: else {},
744: ),
745: db_url=config.services.database.url,
746: )
747: content_db_session_factory = providers.Factory(
748: lambda engine: getattr(
749: import(“sqlalchemy.orm”, fromlist=[“sessionmaker”]), “sessionmaker”
750: )(bind=engine, autoflush=False, autocommit=False),
751: engine=content_db_engine,
752: )
753: content_db_session = providers.Factory(
754: lambda factory: factory(), factory=content_db_session_factory
755: )
756:
757: # Audio metadata database (audio_metadata.db)
758: audio_metadata_db_engine = providers.Singleton(
759: lambda data_dir: import(
760: “sqlalchemy”, fromlist=[“create_engine”]
761: ).create_engine(f”sqlite:///{Path(str(data_dir)) / ‘audio_metadata.db’}”),
762: data_dir=config.app.data_dir,
763: )
764: audio_metadata_db_session_factory = providers.Factory(
765: lambda engine: getattr(
766: import(“sqlalchemy.orm”, fromlist=[“sessionmaker”]), “sessionmaker”
767: )(bind=engine, autoflush=False, autocommit=False),
768: engine=audio_metadata_db_engine,
769: )
770: audio_metadata_db_session = providers.Factory(
771: lambda factory: factory(), factory=audio_metadata_db_session_factory
772: )
773:
774: # Initialize database schemas
775: content_db_schema = providers.Singleton(
776: lambda engine: getattr(
777: import(“StoryMatrix.infrastructure.database.base”, fromlist=[“Base”]),
778: “Base”,
779: ).metadata.create_all(bind=engine),
780: engine=content_db_engine,
781: )
782: audio_metadata_db_schema = providers.Singleton(
783: lambda engine: getattr(
784: import(“StoryMatrix.infrastructure.database.base”, fromlist=[“Base”]),
785: “Base”,
786: ).metadata.create_all(bind=engine),
787: engine=audio_metadata_db_engine,
788: )
789:
790: # Persistent SQLite-backed repositories
791: character_repository = providers.Singleton(
792: SQLiteCharacterRepository, db_session_factory=content_db_session_factory
793: )
794: story_repository = providers.Singleton(
795: SQLiteStoryRepository, db_session_factory=content_db_session_factory
796: )
797: character_voice_mapping_repository = providers.Singleton(
798: SQLiteCharacterVoiceMappingRepository,
799: db_session_factory=audio_metadata_db_session_factory,
800: )
801: voice_data_loader = providers.Singleton(
802: lambda voice_data_path: import(
803: “StoryMatrix.infrastructure.voice_loader”, fromlist=[“VoiceDataLoader”]
804: ).VoiceDataLoader(data_dir=voice_data_path),
805: voice_data_path=providers.Callable(
806: lambda cfg: _safe_config_get(
807: cfg, “services.local_assets.voice_data_path”, “data/voice_profiles”
808: ),
809: cfg=config,
810: ),
811: )
812: voice_repository = providers.Singleton(InMemoryVoiceRepository, config=config)
813: media_asset_repository = providers.Singleton(
814: FileSystemMediaAssetRepository,
815: config=providers.Callable(
816: lambda cfg: _safe_config_get(cfg, “services.media_repository”, {}),
817: cfg=config,
818: ),
819: storage_root=providers.Callable(
820: lambda cfg: _safe_config_get(
821: cfg, “services.media_repository.storage_root”, “media”
822: ),
823: cfg=config,
824: ),
825: )
826:
827: # ======================================================================================
828: # 3. ADAPTERS (LAZY-LOADED)
829:
830: temp_dir = providers.Singleton(
831: Path,
832: providers.Callable(
833: lambda cfg: _safe_config_get(cfg, “app.temp_dir”, “/tmp”), cfg=config
834: ),
835: )
836: output_dir = providers.Singleton(
837: Path,
838: providers.Callable(
839: lambda cfg: _safe_config_get(cfg, “app.output_dir”, “out”), cfg=config
840: ),
841: )
842:
843: # --- Image Adapters ---
844: dalle_adapter = providers.Singleton(
845: _create_dalle_adapter, config=config, temp_dir=temp_dir
846: )
847: midjourney_adapter = providers.Singleton(
848: lambda mj_config: (
849: getattr(
850: import(
851: “StoryMatrix.infrastructure.adapters.image.midjourney”,
852: fromlist=[“MidjourneyAdapter”],
853: ),
854: “MidjourneyAdapter”,
855: )(
856: config=(
857: mj_config
858: if mj_config is not None
859: else getattr(
860: import(
861: “StoryMatrix.config.models”, fromlist=[“MidjourneyConfig”]
862: ),
863: “MidjourneyConfig”,
864: )()
865: )
866: )
867: ),
868: mj_config=config.providers.midjourney,
869: )
870: pillow_image_adapter = providers.Singleton(
871: lambda pillow_config: getattr(
872: import(
873: “StoryMatrix.infrastructure.adapters.image.pillow_adapter”,
874: fromlist=[“PillowAdapter”],
875: ),
876: “PillowAdapter”,
877: )(config=pillow_config),
878: pillow_config=config.providers.pillow,
879: )
880:
881: # Resolve the image provider directly from the DI configuration to avoid
882: # double-indirection issues. This yields clean values like ‘midjourney’, ‘dalle’,
883: # ‘pillow’, or ‘mock’.
884: _image_key = providers.Callable(
885: lambda provider: (
886: “pillow”
887: if (str(os.getenv(“APP__DEV_LOCAL_ONLY”, "")).lower() in (“1”, “true”, “yes”)
888: or str(os.getenv(“APP__LOW_RESOURCE_MODE”, "")).lower() in (“1”, “true”, “yes”))
889: else (
890: (os.getenv(“PROVIDERS__STRATEGY__IMAGE_PROVIDER”) or (_safe_enum_value(provider) or “pillow”)).lower()
891: )
892: ),
893: provider=config.providers.strategy.image_provider,
894: )
895:
896: image_generation_service = providers.Selector(
897: _image_key,
898: dalle=dalle_adapter,
899: midjourney=midjourney_adapter,
900: pillow=pillow_image_adapter,
901: mock=pillow_image_adapter, # Use pillow as the mock implementation
902: )
903:
…
1384: )

[Showing lines 611-903 of 1406. Use :904 to continue]

🤖 Assistant

🤖 Toolresult

[active/StoryMatrix/README.md#45B6]
1:# StoryMatrix: AI-Native Content Factory
2:
3:## Onboarding Quick-Start (2025-10-26)
4:
5:- [environment] Debian 12 (remote), Python 3.11+, CPU-only. Use .venv and uv exclusively.
6:- [rules] Private project; never push/share externally. Skip/mocks for PlayAI and ElevenLabs during development.
7:- [activate] source .venv/bin/activate then uv sync (profiles: minimal/local/cloud/full).
8:- [config layering] Defaults → .env → YAML (storymatrix_config.yaml) → CLI flags.
9:- [core commands]
10: - uv run [[projects/storymatrix|StoryMatrix]] generate --config storymatrix_config.yaml
11: - uv run storymatrix-web | uv run storymatrix-api
12: - [verification] Always run uv run [[projects/storymatrix|StoryMatrix]] generate --config storymatrix_config.yaml before reporting status. After each run, validate artifacts:
13:
14:bash 15:LATEST=$(ls -1dt out/*_* | head -1) 16:yq '.structure, .scenes, .llm_provider, .tts_provider, .music_provider, .sfx_provider, .image_provider, .output_format' "$LATEST"/artifacts/text/*_generation_settings.yaml 17:jq . "$LATEST"/artifacts/text/*_timeline_context.json 18:
19:
20:- [audio pipeline status] TTS sequential; SFX overlays; stems exported; ducking enabled; ambient padding now only for music/ambient_sfx; Midjourney upsample filenames use underscores.
21:- [voice flags] piper_high_quality_only honored end-to-end; cache keyed by quality.
22:- [quick smoke]
23: - Run: uv run [[projects/storymatrix|StoryMatrix]] generate --config storymatrix_config.yaml --scenes 2 --sfx --background-music
24: - Verify: out/<run>/artifacts/audio/stems/ and montage_details.json, *_timeline.{json,txt,png}
25:- [docs] See docs/incidents/bug-history.md (latest fixes), docs/TROUBLESHOOTING.md, docs/optimization-for-idiots.md, and docs/adr/voice-loader-boundary.md (loader boundary).
26:
27:> Phoenix Protocol 100% Complete + GURU Phase 0-D Operational - Production-grade multi-agent storytelling with OpenTelemetry observability
28:
29:StoryMatrix transforms simple prompts into complete multimedia stories with audio, visuals, and immersive timelines using advanced CrewAI agents, professional production pipelines, and next-generation authorial voice intelligence.
30:
31:## 🗺️ Tasks & Roadmap
32:
33:- Active tasks: see CHECKLIST.md
34:- Strategic phases: see ROADMAP.md
35:
36:## 🔧 Active Focus
37:
38:See CHECKLIST.md for current priorities and verification steps.
39:
40:## 📜 History & Fixes
41:
42:See bug-history.md for historical fixes and reports.
43:
44:## 🎯 Essential Rules for Agents
45:
46:Environment:
47:- Remote Debian 12 server (173.212.213.72 | 0rk.de), CPU-only, no GPU
48:- ALWAYS activate venv: source .venv/bin/activate
49:- ALWAYS use uv for package management (Python 3.11+)
50:- Private project: NEVER deploy to GitHub or share publicly
51:
52:Development Flow:
53:- Cost control: PlayAI and ElevenLabs completely skipped/mocked (avoid API costs)
54:- TTS provider: Piper (local) as primary voice synthesis
55:- Terminal awareness: ALWAYS check command status, set timers for long-running processes
56:- Path handling: ALWAYS use absolute paths, never relative paths
57:- Clean architecture: Respect domain/application/infrastructure layers with DI container
58:
59:Critical Patterns:
60:- Character IDs: Deterministic UUID5 generation (namespace: 6ba7b810-9dad-11d1-80b4-00c04fd430c8)
61:- Output structure: Direct placement to out/TIMESTAMP_Title/artifacts/ (no temp moves)
62:- Observability: 100% metrics coverage (14/14 stages), OpenTelemetry tracing (7/9 stages)
63:- Configuration: pydantic-settings layered (defaults → .env → YAML → CLI flags)
64:
65:## 📦 Installation
66:
67:StoryMatrix offers 4 installation profiles optimized for different use cases:
68:
69:bash 70:# MINIMAL (~800MB, 90s) - Quick start, CI/CD, cloud-only [DEFAULT] 71:uv sync 72: 73:# CLOUD (~1.2GB, 3min) - Production with cloud APIs (ElevenLabs, Freesound) 74:uv sync --extra cloud 75: 76:# LOCAL (~2.5GB, 6min) - Privacy-focused, zero API costs, local ML 77:uv sync --extra local 78: 79:# FULL (~3.1GB, 7min) - Maximum flexibility, all features 80:uv sync --extra full 81:
82:
83:See DEPENDENCY_PROFILES.md for detailed comparison and migration guide.
84:
85:---
86:
87:## 🚀 Quick Start
88:
89:Generate a story:
90:bash 91:uv run [[projects/storymatrix|StoryMatrix]] generate --config storymatrix_config.yaml 92:
93:
94:With Resume (if pipeline interrupted):
95:bash 96:uv run [[projects/storymatrix|StoryMatrix]] generate --config storymatrix_config.yaml --resume 97:
98:
99:Web Interface:
100:bash 101:uv run storymatrix-web 102:
103:
104:API Server:
105:bash 106:uv run storymatrix-api 107:
108:
109:## 📁 PROJECT STRUCTURE
110:
111:Stack: Python 3.11+, CrewAI, Pydantic, FastAPI, NiceGUI, Dependency Injection
112:Architecture: Clean Architecture with domain/application/infrastructure layers
113:
114: 115:src/[[projects/storymatrix|StoryMatrix]]/ # Core application 116:├── domain/ # Business logic, entities, value objects 117:├── application/ # Use cases, service interfaces, DTOs 118:├── infrastructure/ # Adapters, repositories, container 119:├── crew/ # CrewAI workflows & YAML configs 120:└── cli/ # Command-line interface 121: 122:out/ # Generated story outputs 123:assets/ # Local media libraries (SFX, music) 124:models/ # AI models (Piper TTS voices) 125:docs/ # Architecture & system documentation 126:
127:
128: Configuration Hierarchy (highest precedence first):
129: 1. CLI flags → 2. YAML config → 3. Environment variables → 4. Pydantic defaults
130:
131: ---
132:
133: 📖 Documentation
134:
135: For complete and up-to-date documentation, see:
136: - docs/index.md
137:
138: ---
139:
140:

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/config/init.py#64BA]
1:"""⚙️ Configuration package.
2:
3:This package contains configuration-related modules for managing
4:application settings, environment variables, and defaults.
5:"""
6:
7:from .config import load_config, StoryMatrixConfig, CoquiConfig
8:from .models import LLMProvider, ProvidersSettings, SFXProvider, TTSProvider
9:from .providers import get_providers_settings
10:
11:all = [
12: “CoquiConfig”,
13: “LLMProvider”,
14: “ProvidersSettings”,
15: “SFXProvider”,
16: “StoryMatrixConfig”,
17: “TTSProvider”,
18: “load_config”,
19: “get_providers_settings”,
20:]
21:

🤖 Toolresult

[active/StoryMatrix/pyproject.toml#541A]
287:[tool.pytest.ini_options]
…
295:markers = [
…
299: “api: marks tests that require API access”,
300: “asyncio: marks tests as asynchronous”,
301:]
302:
303:# Coverage configuration
304:[tool.coverage.run]
305:source = [“storymatrix”]
306:omit = [
307: “tests/”,
308: “/migrations/”,
309: “/venv/”,
310: “/.venv/”,
311:]
312:
313:[tool.coverage.report]
314:exclude_lines = [
315: “pragma: no cover”,
316: “def repr”,
317: “raise AssertionError”,
318: “raise NotImplementedError”,
319: “if name == .main.:”,
320: “if TYPE_CHECKING:”,
321:]
322:
323:# UV configuration for PyTorch CPU
324:[tool.uv.sources]
325:torch = [{ index = “pytorch-cpu” }]
326:torchvision = [{ index = “pytorch-cpu” }]
327:torchaudio = [{ index = “pytorch-cpu” }]
328:freesound-python = { git = “https://github.com/MTG/freesound-python” }
329:
330:tool.uv.index
331:name = “pytorch-cpu”
332:url = “https://download.pytorch.org/whl/cpu”
333:explicit = true
334:
335:# Hatch configuration for environments
336:[tool.hatch.envs.default]
337:python = “3.10”
338:
339:[tool.hatch.envs.test]
340:features = [“test”]
341:
342:[tool.hatch.envs.test.scripts]
343:test = “pytest -v”
344:
345:# Ensure voice JSON fixtures are included in built distributions (wheel/sdist)
346:[tool.hatch.build]
347:include = [
348: “src/StoryMatrix/infrastructure/data/voices/.json”,
349:]
350:
351:[tool.hatch.build.targets.wheel]
352:# Build from src/ layout
353:packages = [“src/storymatrix”]
354:

🤖 Toolresult

[active/StoryMatrix/src/StoryMatrix/infrastructure/container.py#7BE3]
612:class ServiceContainer(containers.DeclarativeContainer):
613: config = providers.Configuration(strict=False)
…
896: image_generation_service = providers.Selector(
…
899: midjourney=midjourney_adapter,
900: pillow=pillow_image_adapter,
901: mock=pillow_image_adapter, # Use pillow as the mock implementation
902: )
903:
904: # Backwards-compatible alias used in unit tests
905: image_service = image_generation_service
906:
907: # --- Audio Search Service ---
908: mock_audio_search_service = providers.Factory(
909: lambda: import(
910: “StoryMatrix.infrastructure.services.mock_audio_search”,
911: fromlist=[“MockAudioSearchService”],
912: ).MockAudioSearchService()
913: )
914: # Use a Callable to dynamically decide which audio search service to create.
915: # This is the only way to truly prevent the torch import in local-only mode,
916: # as the _create_chroma_audio_adapter function is never even referenced.
917: audio_search_service = providers.Factory(
918: lambda use_mock, cfg: (
919: import(
920: “StoryMatrix.infrastructure.services.mock_audio_search”,
921: fromlist=[“MockAudioSearchService”],
922: ).MockAudioSearchService()
923: if use_mock
924: else _create_chroma_audio_adapter(cfg)
925: ),
926: use_mock=providers.Callable(
927: lambda dev, low: bool(dev) or bool(low),
928: dev=config.app.dev_local_only,
929: low=config.app.low_resource_mode,
930: ),
931: cfg=config,
932: )
933:
934: # --- TTS Service Providers ---
935: elevenlabs_tts_adapter = providers.Singleton(
936: _create_elevenlabs_adapter,
937: client_provider=elevenlabs_client,
938: config=config.providers.elevenlabs,
939: )
940: piper_tts_adapter = providers.Singleton(_create_piper_adapter, config=config)
941: playai_tts_adapter = providers.Singleton(
942: lambda playai_config, dev_local_only: (
943: None
944: if dev_local_only
945: else getattr(
946: import(
947: “StoryMatrix.infrastructure.adapters.tts.playai”,
948: fromlist=[“PlayAIAdapter”],
949: ),
950: “PlayAIAdapter”,
951: )(config=playai_config)
952: ),
953: playai_config=config.providers.playai,
954: dev_local_only=config.app.dev_local_only,
955: )
956: mock_tts_adapter = providers.Singleton(
957: lambda: import(
958: “StoryMatrix.infrastructure.adapters.tts.mock_tts_adapter”,
959: fromlist=[“MockTTSAdapter”],
960: ).MockTTSAdapter()
961: )
962:
963: # Coqui TTS adapter (local XTTS v2)
964: coqui_tts_adapter = providers.Singleton(
965: _create_coqui_adapter,
966: coqui_config=config.services.coqui,
967: )
968:
969: # Gate TTS providers by dev-local-only and low-resource-mode:
970: # - In low-resource or dev-local-only: avoid heavy/remote providers (Coqui, cloud), stick to Piper + Mock.
971: # - Otherwise: include full set honoring local-first order.
972: tts_providers = providers.Callable(
973: lambda piper, elevenlabs, mock: (
974: [piper, mock]
975: if (
976: str(os.getenv(“APP__DEV_LOCAL_ONLY”, "")).lower() in (“1”, “true”, “yes”)
977: or str(os.getenv(“APP__LOW_RESOURCE_MODE”, "")).lower() in (“1”, “true”, “yes”)
978: )
979: else [piper, elevenlabs, mock]
980: ),
981: piper=piper_tts_adapter,
982: elevenlabs=elevenlabs_tts_adapter,
983: mock=mock_tts_adapter,
984: )
985:
986: # --- SFX Service Providers ---
987: elevenlabs_sfx_adapter = providers.Singleton(
988: _create_elevenlabs_sfx_adapter,
989: client_provider=elevenlabs_client,
990: config=config, # Pass full config, adapter extracts elevenlabs sub-config
991: )
992: freesound_sfx_adapter = providers.Singleton(
993: lambda freesound_config: getattr(
994: import(
995: “StoryMatrix.infrastructure.adapters.sfx.freesound”,
996: fromlist=[“FreesoundSFXAdapter”],
997: ),
998: “FreesoundSFXAdapter”,
999: )(config=freesound_config),
1000: freesound_config=config.providers.freesound,
1001: )
1002: local_sfx_adapter = providers.Singleton(
1003: lambda sfx_library_path: getattr(
1004: import(
1005: “StoryMatrix.infrastructure.adapters.sfx.local”,
1006: fromlist=[“LocalSFXAdapter”],
1007: ),
1008: “LocalSFXAdapter”,
1009: )(bbc_library_path=Path(sfx_library_path or import(
1010: “StoryMatrix.config.models”, fromlist=[“LocalAssetsConfig”]
1011: ).LocalAssetsConfig().sfx_library_path)),
1012: sfx_library_path=config.services.local_assets.sfx_library_path,
1013: )
1014: # The new mock adapter remains available and is used during dev-local-only.
1015: mock_sfx_adapter = providers.Singleton(_create_mock_sfx_adapter, config=config)
1016:
1017: # Gated, ordered SFX provider list. Always local-first. Only include external providers when allowed
1018: # and when strategy requests Freesound, to minimize external usage by default.
1019: sfx_providers = providers.Callable(
1020: _get_sfx_providers,
1021: dev_local_only=config.app.dev_local_only,
1022: low_resource=config.app.low_resource_mode,
1023: sfx_provider_strategy=config.providers.strategy.sfx_provider,
1024: local=local_sfx_adapter,
1025: elevenlabs=elevenlabs_sfx_adapter,
1026: freesound=freesound_sfx_adapter,
1027: mock=mock_sfx_adapter,
1028: )
1029:
1030: _sfx_key = providers.Callable(
1031: lambda strategy, dev, low: (
1032: “mock”
1033: if (
1034: str(os.getenv(“APP__DEV_LOCAL_ONLY”, "")).lower() in (“1”, “true”, “yes”)
1035: or str(os.getenv(“APP__LOW_RESOURCE_MODE”, "")).lower() in (“1”, “true”, “yes”)
1036: )
1037: else (os.getenv(“PROVIDERS__STRATEGY__SFX_PROVIDER”) or (_safe_enum_value(strategy) or “freesound”)).lower()
1038: ),
1039: strategy=config.providers.strategy.sfx_provider,
1040: dev=config.app.dev_local_only,
1041: low=config.app.low_resource_mode,
1042: )
1043: sfx_service = providers.Selector(
1044: _sfx_key,
1045: elevenlabs=elevenlabs_sfx_adapter,
1046: freesound=freesound_sfx_adapter,
1047: local=local_sfx_adapter,
1048: mock=mock_sfx_adapter,
1049: )
1050:
1051: # Mock services for development and testing
1052: mock_story_data_service = providers.Singleton(
1053: lambda: import(
1054: “StoryMatrix.infrastructure.services.story_data.mock_story_data_service”,
1055: fromlist=[“MockStoryDataService”],
1056: ).MockStoryDataService()
1057: )
1058: mock_llm_service = providers.Singleton(MockLLMService)
1059:
1060: # --- LLM Service ---
1061: openrouter_adapter = providers.Singleton(openrouter_adapter_factory, config=config)
1062: _llm_key = providers.Callable(
1063: lambda dev_local_only, provider: (
1064: “mock”
1065: if (
1066: dev_local_only
1067: or not os.getenv(“PROVIDERS__OPENROUTER__API_KEY”)
1068: )
1069: else (_safe_enum_value(provider) or “openrouter”).lower()
1070: ),
1071: dev_local_only=config.app.dev_local_only,
1072: provider=config.providers.strategy.llm_provider,
1073: )
1074:
1075: llm_service = providers.Selector(
1076: _llm_key,
1077: openrouter=openrouter_adapter,
1078: mock=mock_llm_service,
1079: )
1080:
1081: story_planner_service = providers.Singleton(
1082: story_planner_factory_func, llm_service=llm_service
1083: )
1084:
1085: # --- LLM Query Enhancer ---
1086: llm_query_enhancer: providers.Provider[LLMQueryEnhancer] = providers.Singleton(
1087: ConcreteLLMQueryEnhancer, llm_service=llm_service
1088: )
1089:
1090: # --- Library Augmentation Service (Freesound caching) ---
1091: library_augmentation_service: providers.Provider[LibraryAugmentationService] = (
1092: providers.Singleton(LibraryAugmentationService, config=config)
1093: )
1094:
1095: # --- SFX Orchestrator (cascade: local → freesound → elevenlabs → mock) ---
1096: sfx_orchestrator = providers.Singleton(
1097: _create_sfx_orchestrator,
1098: sfx_providers=sfx_providers,
1099: media_asset_repository=media_asset_repository,
1100: config=config,
1101: )
1102:
1103: # --- SFX Resolver ---
1104: sfx_resolver: providers.Provider[SFXResolverService] = providers.Singleton(
1105: ConcreteSFXResolverService,
1106: sfx_service=sfx_orchestrator,
1107: llm_enhancer=llm_query_enhancer,
1108: library_service=library_augmentation_service,
1109: dev_local_only=config.app.dev_local_only,
1110: )
1111:
1112: # --- Music Indexing ---
1113: music_indexer = providers.Singleton(
1114: _index_local_music_assets,
1115: config=config,
1116: audio_search_service=audio_search_service,
1117: )
1118:
1119: # --- Music Service Providers ---
1120: # The music_indexer must be resolved before the local adapter is used.
1121: # This is implicitly handled by making it a dependency of the orchestrator
1122: # that uses the local adapter.
1123:
1124: local_music_adapter = providers.Singleton(
1125: LocalMusicAdapter, config=config, search_service=audio_search_service
1126: )
1127: musicgen_adapter = providers.Singleton(
1128: lambda config, temp_dir: getattr(
1129: import(
1130: “StoryMatrix.infrastructure.adapters.music.musicgen_adapter”,
1131: fromlist=[“MusicGenAdapter”],
1132: ),
1133: “MusicGenAdapter”,
1134: )(config=config, temp_dir=temp_dir),
1135: config=config,
1136: temp_dir=temp_dir,
1137: )
1138: mock_music_adapter = providers.Singleton(_create_mock_music_adapter, config=config)
1139:
1140: _music_key = providers.Callable(
1141: lambda dev, low, strategy: (
1142: “local”
1143: if (
1144: str(os.getenv(“APP__DEV_LOCAL_ONLY”, "")).lower() in (“1”, “true”, “yes”)
1145: or str(os.getenv(“APP__LOW_RESOURCE_MODE”, "")).lower() in (“1”, “true”, “yes”)
1146: )
1147: else (os.getenv(“PROVIDERS__STRATEGY__MUSIC_PROVIDER”) or (_safe_enum_value(strategy) or “local”)).lower()
1148: ),
1149: dev=config.app.dev_local_only,
1150: low=config.app.low_resource_mode,
1151: strategy=config.providers.strategy.music_provider,
1152: )
1153:
1154: music_service = providers.Selector(
1155: _music_key,
1156: local=local_music_adapter,
1157: musicgen=musicgen_adapter,
1158: mock=mock_music_adapter,
1159: )
1160:
1161: music_providers = providers.Callable(
1162: _get_music_providers,
1163: dev_local_only=config.app.dev_local_only,
1164: low_resource=config.app.low_resource_mode,
1165: music_provider_strategy=config.providers.strategy.music_provider,
1166: local=local_music_adapter,
1167: musicgen=musicgen_adapter,
1168: mock=mock_music_adapter,
1169: )
1170: # Backwards-compatible alias used in unit tests to retrieve ordered adapter list
1171: music_discovery_service = music_providers
1172:
1173: # --- TTS Services Dictionary ---
1174: tts_services_dict = providers.Dict(
1175: piper=piper_tts_adapter,
1176: coqui=coqui_tts_adapter,
1177: elevenlabs=elevenlabs_tts_adapter,
1178: playai=playai_tts_adapter,
1179: mock=mock_tts_adapter,
1180: orchestrator=providers.Singleton(
1181: _create_tts_orchestrator,
1182: tts_providers=tts_providers,
1183: media_asset_repository=media_asset_repository,
1184: preferred_provider=providers.Callable(
1185: # In low-resource/dev-local-only, prefer Piper unless user explicitly chose a local engine (piper/coqui)
1186: lambda provider, dev_local_only, low_resource: (
1187: ((_safe_enum_value(provider) or “piper”).lower())
1188: if ((_safe_enum_value(provider) or “piper”).lower() in (“piper”, “coqui”))
1189: else (
1190: “piper”
1191: if (dev_local_only or low_resource)
1192: else ((_safe_enum_value(provider) or “piper”).lower())
1193: )
1194: ),
1195: provider=config.providers.strategy.tts_provider,
1196: dev_local_only=config.app.dev_local_only,
1197: low_resource=config.app.low_resource_mode,
1198: ),
1199: ),
1200: )
1201:
1202: # --- Voice Services ---
1203: voice_matcher_service = providers.Singleton(
1204: VoiceMatcherService, voice_repository=voice_repository
1205: )
1206: character_mapping_service = providers.Singleton(
1207: CharacterMappingService,
1208: voice_data_loader=voice_data_loader,
1209: llm_service=llm_service, # For intelligent voice casting via CrewAI
1210: )
1211:
1212: voice_casting_service = providers.Singleton(
1213: VoiceCastingService,
1214: voice_loader=voice_data_loader,
1215: character_voice_mapping_repository=character_voice_mapping_repository,
1216: character_mapping_service=character_mapping_service,
1217: )
1218: # --- Montage Service ---
1219: ffmpeg_montage_service = providers.Factory(
1220: ffmpeg_montage_service_factory,
1221: config=config,
1222: temp_dir=temp_dir,
1223: )
1224:
1225: pydub_montage_service = providers.Factory(
1226: pydub_montage_service_factory, config=config, temp_dir=temp_dir
1227: )
1228:
1229: _montage_key = providers.Callable(
1230: lambda provider: (_safe_enum_value(provider) or “pydub”).lower(),
1231: provider=config.services.montage.implementation,
1232: )
1233: montage_service = providers.Selector(
1234: _montage_key,
1235: ffmpeg=ffmpeg_montage_service,
1236: pydub=pydub_montage_service,
1237: mock=pydub_montage_service, # Default mock to pydub
1238: )
1239:
1240: # ======================================================================================
1241: # 4. APPLICATION SERVICES
1242: # ======================================================================================
1243:
1244: # New extracted services for Phase 3 technical debt elimination
1245: voice_environment_service = providers.Singleton(
1246: VoiceEnvironmentService,
1247: )
1248:
1249: summary_generation_service = providers.Singleton(
1250: SummaryGenerationService,
1251: )
1252:
1253: story_creation_service = providers.Singleton(
1254: “StoryMatrix.application.services.story_creation_service.StoryCreationService”,
1255: story_data_service_provider_factory=mock_story_data_service,
1256: story_repository=story_repository,
1257: character_repository=character_repository,
1258: voice_matcher_service=voice_matcher_service,
1259: )
1260:
1261: music_orchestrator = providers.Singleton(
1262: _create_music_orchestrator,
1263: adapter_providers=music_providers,
1264: config=config,
1265: )
1266:
1267: audio_discovery_service = providers.Singleton(
1268: AudioDiscoveryService,
1269: sfx_resolver=sfx_resolver,
1270: music_resolver=music_orchestrator,
1271: # metadata_service=asset_metadata_service, # Temporarily commented out
1272: )
1273:
1274: audio_generation_service = providers.Singleton(
1275: AudioGenerationService,
1276: config=config,
1277: tts_services=tts_services_dict,
1278: voice_casting_service=voice_casting_service,
1279: voice_loader=voice_data_loader,
1280: )
1281: audio_production_service = providers.Singleton(
1282: AudioProductionService,
1283: config=config,
1284: audio_discovery_service=audio_discovery_service,
1285: audio_generation_service=audio_generation_service,
1286: montage_service=montage_service,
1287: )
1288:
1289: # ======================================================================================
1290: # 5. AGENTIC & AI SERVICES
1291: # ======================================================================================
1292:
1293: mock_agentic_timeline_adapter = providers.Factory(
1294: lambda: import(
1295: “StoryMatrix.infrastructure.adapters.timeline.mock_agentic_timeline_adapter”,
1296: fromlist=[“MockAgenticTimelineAdapter”],
1297: ).MockAgenticTimelineAdapter()
1298: )
1299:
1300: llm_agentic_timeline_adapter = providers.Singleton(
1301: LLMAgenticTimelineAdapter, llm_service=llm_service
1302: )
1303:
1304: _agentic_timeline_key = providers.Callable(
1305: lambda provider: (_safe_enum_value(provider) or “openrouter”).lower(),
1306: provider=config.providers.strategy.agentic_timeline_provider,
1307: )
1308:
1309: agentic_timeline_service: providers.Provider[AgenticTimelineService] = (
1310: providers.Selector(
1311: _agentic_timeline_key,
1312: openrouter=llm_agentic_timeline_adapter,
1313: mock=mock_agentic_timeline_adapter,
1314: )
1315: )
1316:
1317: audio_direction_service: providers.Provider[AudioDirectionService] = (
1318: providers.Selector(
1319: _agentic_timeline_key,
1320: openrouter=llm_agentic_timeline_adapter, # Reusing for now, as it fits the signature
1321: mock=mock_agentic_timeline_adapter,
1322: )
1323: )
1324:
1325: # ======================================================================================
1326: # 6. TOP-LEVEL USE CASE & SERVICES
1327: # ======================================================================================
1328:
1329: music_mood_mapping_service = providers.Singleton(
1330: MusicMoodMappingService,
1331: llm_service=llm_service,
1332: music_service=music_service,
1333: )
1334:
1335: visual_prompt_service = providers.Singleton(
1336: VisualPromptService,
1337: llm_service=llm_service,
1338: )
1339:
1340: # Crew Transformer Service
1341: crew_transformer_service = providers.Singleton(
1342: “StoryMatrix.application.services.crew_transformer_service.CrewTransformerService”
1343: )
1344:
1345: deterministic_timeline_service = providers.Singleton(DeterministicTimelineService)
1346:
1347: # Artifacts Service (mock for now)
1348: artifacts_service = providers.Singleton(
1349: lambda: import(
1350: “StoryMatrix.infrastructure.services.mock_artifacts_service”,
1351: fromlist=[“MockArtifactsService”],
1352: ).MockArtifactsService()
1353: )
1354:
1355: # Story Orchestration Service
1356: story_orchestration_service = providers.Singleton(
1357: StoryOrchestrationService,
1358: llm_service=llm_service,
1359: transformer_service=crew_transformer_service,
1360: character_mapping_service=character_mapping_service,
1361: deterministic_timeline_service=deterministic_timeline_service,
1362: )
1363:
1364: # Pipeline Coordinator
1365: pipeline_coordinator = providers.Singleton(
1366: “StoryMatrix.application.services.pipeline_coordinator.PipelineCoordinator”,
1367: config=config,
1368: artifacts_service=artifacts_service,
1369: )
1370:
1371: generate_story_use_case = providers.Factory(
1372: GenerateStoryUseCase,
1373: audio_production_service=audio_production_service,
1374: audio_generation_service=audio_generation_service,
1375: image_generation_service=image_generation_service,
1376: artifacts_service=artifacts_service,
1377: config=config,
1378: visual_prompt_service=visual_prompt_service,
1379: story_orchestration_service=story_orchestration_service,
1380: character_mapping_service=character_mapping_service,
1381: voice_environment_service=voice_environment_service,
1382: summary_generation_service=summary_generation_service,
1383: pipeline_coordinator=pipeline_coordinator,
1384: )
1385:
1386:
1387:# ======================================================================================
1388:# 6. WIRING
1389:
1390:
1391:def wire_container(config_data: dict):
1392: # Wire the container with a specific configuration.
1393: container = ServiceContainer()
1394: # Validate the configuration using the Pydantic model and load it as a dict
1395: validated_config = StoryMatrixConfig.model_validate(config_data)
1396: container.config.from_dict(validated_config.model_dump())
1397:
1398: container.wire(
1399: modules=[
1400: “StoryMatrix.cli.main”,
1401: “StoryMatrix.application.use_cases.generate_story”,
1402: “StoryMatrix.crew.crew”,
1403: ]
1404: )
1405: return container
1406:

🤖 Assistant

I now have comprehensive data. Here’s the full review:

---

🔍 StoryMatrix Code Review

Verdict: Needs Work — The project has solid domain architecture but suffers from significant technical debt, duplicated code, inconsistent tooling config, and a massive DI container that is difficult to maintain.

---

🔴 Critical Findings

1. config/models_1.py is a dead duplicate of config/models.py

Files: src/[[projects/storymatrix|StoryMatrix]]/config/models.py, src/[[projects/storymatrix|StoryMatrix]]/config/models_1.py

models_1.py (449 lines) is an older copy of models.py (576 lines). They define identical class names (StoryMatrixConfig, TTSProvider, SFXProvider, etc.) with subtle differences:

• models_1.py uses SettingsConfigDict everywhere; models.py uses ConfigDict (mixed with SettingsConfigDict forms).
• models.py has ElevenLabsModelStrategy enum and richer ElevenLabsConfig — features absent from models_1.py.
• models_1.py has an LLMSettings class not in models.py.
• models_1.py lacks __getitem__ helpers in composite settings.

Risk: Any import picking the wrong file silently gets different behavior. config/__init__.py imports from models (correct), but a stale import elsewhere could reference models_1. This is a latent bug vector.
Recommendation: Delete models_1.py entirely.

2. crew/crews.py is an empty 0-byte file

File: src/[[projects/storymatrix|StoryMatrix]]/crew/crews.py

Dead file. No imports reference it. Confusing next to crew.py.
Recommendation: Delete.

3. sanitize_command() security flaw — quotes the command name too

File: src/[[projects/storymatrix|StoryMatrix]]/utils/security.py:48

return [shlex.quote(str(arg)) for arg in cmd]

This quotes all elements including cmd[0] (the executable itself). shlex.quote("ffmpeg") → ffmpeg (harmless here), but if the command is an absolute path like /usr/bin/ffmpeg, quoting it can break subprocess.Popen in shell mode. More importantly, the function validates Path(cmd[0]).name against the allowlist but then returns quoted values — if the caller uses shell=True with the result, the quoting of args is correct, but if they use shell=False (list mode), shlex.quote wrapping adds literal quote characters.
Recommendation: Don’t quote cmd[0]; quote only cmd[1:]. Document whether this is for shell or list mode.

4. python/python3 in command allowlist

File: src/[[projects/storymatrix|StoryMatrix]]/utils/security.py:40

Allowing python and python3 in a command sanitizer’s allowlist effectively permits arbitrary code execution, negating the purpose of the allowlist.
Recommendation: Remove python/python3 from the allowlist or restrict to specific known scripts.

---

🟠 Major Findings

5. infrastructure/container.py is a 1,406-line god module

File: src/[[projects/storymatrix|StoryMatrix]]/infrastructure/container.py

This single file defines ~50 providers, ~20 factory functions, the entire ServiceContainer class, and deep business logic (env-gating, config merging, deep-update helpers). The __init__ method alone (lines 616–723) is 107 lines of config merge/shim/fallback logic with 4 nested try/except blocks that silently swallow all exceptions.
Risks:

• Silent failures: Lines 701, 706, 712, 722 all except Exception: pass — config corruption is invisible.
• Monkey-patching: self.config.from_pydantic is replaced with a shim at line 711, making debugging extremely difficult.
• Duplicated env gating: The pattern str(os.getenv("APP__DEV_LOCAL_ONLY", "")).lower() in ("1", "true", "yes") is copy-pasted at lines 555, 581, 888, 976, 1034, 1144 — at least 6 times.

Recommendation: Extract a _is_dev_local() helper. Break the container into sub-modules (adapters, services, config-loading). Replace bare except Exception: pass with logged warnings at minimum.

6. Duplicate audio_generation_service provider

File: src/[[projects/storymatrix|StoryMatrix]]/infrastructure/container.py:727,1274

audio_generation_service is defined twice in ServiceContainer:

• Line 727: providers.Singleton(AudioGenerationService) — no dependencies injected
• Line 1274: providers.Singleton(AudioGenerationService, config=config, tts_services=..., ...) — fully wired

The second definition shadows the first. The first is dead code, but the ordering dependency is fragile.
Recommendation: Remove the line 727 definition.

7. Python version inconsistencies

Files: pyproject.toml

• requires-python = ">=3.11, <3.12" (line 10) — locks to 3.11.x
• target-version = "py310" in [tool.ruff] (line 225) — targets 3.10
• python_version = "3.10" in [tool.mypy] (line 265) — targets 3.10
• python = "3.10" in [tool.hatch.envs.default] (line 337) — targets 3.10

The code uses X | Y union syntax (requires 3.10+) and list[str] generics (requires 3.9+), so 3.10 works syntactically. But requires-python says 3.11. These should all agree.
Recommendation: Align all version targets to 3.11.

8. mock_service.py is a 492-line magic catch-all

File: src/[[projects/storymatrix|StoryMatrix]]/infrastructure/mock_service.py

MockService.__getattr__ returns a new MockService() for any attribute access, __contains__ always returns True, __call__ returns a new MockService(). This is a “null object on steroids” that silently swallows any usage, making it impossible to detect misconfigured service wiring.
Recommendation: Replace with typed mock implementations per interface. At minimum, log when fallback mock methods are invoked.

9. infrastructure/mock_service_old.py also exists (8KB)

File: src/[[projects/storymatrix|StoryMatrix]]/infrastructure/mock_service_old.py

An older version of the mock service, likely dead.
Recommendation: Delete if unused; verify no imports reference it.

---

🟡 Moderate Findings

10. Heavyweight core dependencies

File: pyproject.toml:34-95

The “minimal” profile (core dependencies) includes celery[redis], redis, fastapi, uvicorn, SQLAlchemy, nicegui, crewai, crewai_tools, opentelemetry-*, prometheus-client, beautifulsoup4, Pillow, dependency-injector, aiofiles, orjson, simplejson, dirtyjson — all in the “minimal” install. This is not minimal.

• celery[redis] + redis pull in Redis client for a CLI tool that runs locally
• nicegui pulls in a full web framework
• Three JSON parsers (orjson, simplejson, dirtyjson) + stdlib json
• requests + httpx — two HTTP clients

Recommendation: Move web framework deps (fastapi, uvicorn, nicegui, celery, redis) to a web or server extra. Consolidate JSON parsers.

11. json_utils.py — duplicate import re

File: src/[[projects/storymatrix|StoryMatrix]]/utils/json_utils.py:2,14

re is imported at line 2 (module level) and again at line 14 (inside _fix_llm_json_newlines). Harmless but sloppy.

12. Exception hierarchy has redundant roots

File: src/[[projects/storymatrix|StoryMatrix]]/domain/exceptions.py

Both StoryMatrixException and StoryMatrixError(StoryMatrixException) exist with identical docstrings: “Base exception for all application-specific errors.” Then DomainError(StoryMatrixError) is the real base used by utils. ValidationError(StoryMatrixException) and StoryGenerationError(StoryMatrixException) branch from the grandparent, bypassing StoryMatrixError, creating a split hierarchy where except StoryMatrixError won’t catch ValidationError.
Recommendation: Flatten to one base class or document the intentional split.

13. summary_generation_service.backup file in source tree

File: src/[[projects/storymatrix|StoryMatrix]]/application/services/summary_generation_service.backup

A backup file committed to the source tree (12.9KB).
Recommendation: Delete; use git history instead.

14. Stale documentation and maintenance artifacts

Files: 01_ERROR.ini, 00_NOTES.md, CHECKLIST.md.bak, .obsolete/ directory

Multiple stale/orphaned files remain in the project root and .obsolete/ directory. The README.md references an “Onboarding Quick-Start (2025-10-26)” dated 8 months ago.
Recommendation: Clean up or move to a docs/archive/ directory.

15. __pycache__ directories committed

Files: Multiple __pycache__/ directories visible throughout source and test trees

These should be in .gitignore.
Recommendation: Add __pycache__/ to .gitignore and remove from tracking.

16. Empty test files

Files: tests/test_chroma.py (0 bytes), tests/test_simple.py (42 bytes), tests/test_sanity.py (46 bytes)

Dead or trivial test files adding noise to the test suite.

17. Config precedence order contradicts itself

File: README.md:129 vs README.md:8

Line 8: “Defaults → .env → YAML → CLI flags” (YAML overrides .env)
Line 129: “CLI flags → YAML config → Environment variables → Pydantic defaults” (same order, just reversed notation)

These agree, but yaml_precedence_validator.py uses a numeric precedence system that doesn’t enforce this order by default — it depends on the caller adding sources in the right order. No test validates the documented precedence.

---

🟢 Positive Observations

• Clean Architecture layering — domain/application/infrastructure separation is genuinely applied, not just organizational
• Well-structured provider strategy — the env-gating pattern for dev/cloud/local is conceptually sound
• Good YAML config system — yaml_precedence_validator.py is thorough with conflict detection and reporting
• Comprehensive exception hierarchy — granular LLM error types (LLMTimeoutError, LLMRateLimitError, etc.)
• Solid async utilities — circuit breaker, exponential backoff, concurrency limiter
• Install profiles — thoughtful separation of heavy ML deps from core

---

Summary

Severity	Count
🔴 Critical	4
🟠 Major	5
🟡 Moderate	8

Top 3 actions by impact:

1. Delete models_1.py, crews.py, mock_service_old.py, .backup file, and empty test files
2. Break up container.py — extract env-gating helper, remove bare except: pass, delete duplicate provider
3. Align Python version targets across pyproject.toml to 3.11