$ show RhythmicWave/NovelForge
NovelForge is an AI-assisted long-form novel writing desktop application built with Electron, Vue 3, and FastAPI. It provides a card-based content management system where each story element (characters, scenes, chapters, items, concepts) is stored as typed cards with JSON Schema validation. The core differentiator is a custom workflow engine that uses a code-style DSL with marker comments (`#@node`) to define automation flows, supporting triggers, async execution, pause/resume, and streaming SSE progress. AI integration is deep: configurable LLM providers (OpenAI, Google, Anthropic, Qwen), structured generation via instruction streams (LLM outputs JSON instructions that the frontend executes incrementally), memory extraction from text into cards and a knowledge graph (dual backend: SQLModel or Neo4j), and a context assembly system with a rich template language. The frontend features a dynamic form renderer from JSON Schema, an inspiration assistant with tool-calling agents, a workflow agent that can autonomously edit workflow code via patches, and a chapter editor with AI continuation, polish, and review. The system is designed for professional novelists and supports full project lifecycles from tags and outlines to chapter drafts and quality reviews. The architecture is a typical two-tier application: the backend exposes RESTful APIs and SSE streams; the frontend is a single-page Vue 3 app bundled as an Electron desktop application (with web compatibility via mock). Notable engineering strengths include the workflow node registration pattern, the expression evaluator with safe eval, the memory extractor registry, and the dynamic form system—all of which are cleanly abstracted and potentially reusable across projects. The codebase is actively maintained, with regular commits, well-organized modules, and comprehensive bootstrap initialization for built-in prompts and card types. However, some features are experimental (workflow agent auto-patching), the custom DSL is format-sensitive, and the heavy reliance on LangChain may introduce version lock-in.
The LLM identified 5 files worth highlighting for reuse:
Defines `BaseNode` as a generic abstract class with typed input/output models, an `execute` method that yields either `ProgressEvent` or the output model, and a decorator-based registration system (`@register_node`). Demonstrates a clean, reusable pattern for building extensible workflow nodes with async streaming and Pydantic validation. Can be extracted to create new node libraries with minimal changes.
Implements a controlled expression evaluator using Python's `eval` with a whitelist of built-in functions and a context wrapper (`AttrDict` for dot access to dicts). Used within workflow nodes for dynamic parameter computation. The design decouples expression parsing from execution and can be reused in any application needing safe, configurable expression evaluation.
Provides `MemoryExtractorBase` abstract class with a standard interface for extracting structured information from text via LLM (prompt building, structured output parsing, preview, and persist). Combined with `RegistryFactory`, it enables plug-and-play extraction of character dynamics, relations, scene states, etc. This pattern is reusable for any domain needing LLM-based entity extraction into a structured store.
A generic form renderer that takes a JSON Schema and dynamically generates form fields using specialized sub-components (StringField, NumberField, ArrayField, ObjectField, etc.). Handles nested schemas, `$ref` resolution, and localization of titles. This component can be extracted and reused in any Vue 3 project that needs to render forms from JSON Schema with custom field components.
Implements instruction stream generation: prompts an LLM to output a sequence of JSON instructions (set/append operations on a structured target), validates each instruction in real-time, and automatically retries malformed outputs. This pattern enables fine-grained, step-by-step content construction from LLM responses and can be adapted for any scenario requiring controlled, incremental output from generative models.