novelforge 1.0__py3-none-any.whl

novelforge/__init__.py

@@ -0,0 +1,10 @@
+"""
+storyforge
+~~~~~~~~~~
+AI-powered novel writer — public API.
+"""
+
+from novelforge.ui.app import run as launch
+
+__all__ = ["launch"]
+__version__ = "0.2.0"

novelforge/__main__.py

@@ -0,0 +1,6 @@
+"""Allow `python -m storyforge` and the `storyforge` console script."""
+
+from novelforge.ui.app import run as main
+
+if __name__ == "__main__":
+    main()

novelforge/core/generators.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import json
+
+import ollama
+
+from novelforge.core.prompts import (
+    NOVEL_SYSTEM_PROMPT,
+    CREATE_NOVEL_PROMPT,
+    CHAPTER_PLAN_PROMPT,
+    CONTINUE_NOVEL_PROMPT,
+    MEMORY_COMPRESSION_PROMPT,
+    CHARACTER_EXTRACTION_PROMPT,
+    LORE_EXTRACTION_PROMPT,
+    QA_PROMPT,
+)
+
+STORY_MODEL = "qwen3:8b"
+
+GPU_OPTIONS = {
+    "num_gpu": -1,
+    "main_gpu": 0,
+    "num_batch": 512,
+    "num_ctx": 4096,
+    "f16_kv": True,
+    "use_mmap": True,
+    "use_mlock": False,
+    "num_thread": 0,
+}
+
+
+def llm(
+    prompt: str,
+    system: str = NOVEL_SYSTEM_PROMPT,
+    temperature: float = 0.8,
+) -> str:
+    response = ollama.chat(
+        model=STORY_MODEL,
+        messages=[
+            {"role": "system", "content": system},
+            {"role": "user", "content": prompt},
+        ],
+        options={**GPU_OPTIONS, "temperature": temperature},
+    )
+    return response["message"]["content"]
+
+
+def classify_intent(user_input: str) -> str:
+    text = user_input.lower().strip()
+    new_keywords = [
+        "new novel",
+        "new story",
+        "write a novel",
+        "create a novel",
+        "start a novel",
+        "novel idea",
+    ]
+    question_keywords = ["who", "what", "when", "where", "why", "how"]
+    if any(k in text for k in new_keywords):
+        return "NEW_NOVEL"
+    if "?" in text:
+        return "QUESTION"
+    if any(text.startswith(k) for k in question_keywords):
+        return "QUESTION"
+    return "CONTINUE"
+
+
+def create_first_chapter(idea: str) -> str:
+    return llm(CREATE_NOVEL_PROMPT.format(idea=idea))
+
+
+def create_chapter_plan(memory: str, instruction: str) -> str:
+    return llm(
+        CHAPTER_PLAN_PROMPT.format(memory=memory, instruction=instruction),
+        temperature=0.4,
+    )
+
+
+def generate_chapter(memory: str, plan: str, instruction: str) -> str:
+    return llm(
+        CONTINUE_NOVEL_PROMPT.format(memory=memory, plan=plan, instruction=instruction)
+    )
+
+
+def compress_memory(chapter: str) -> str:
+    return llm(
+        MEMORY_COMPRESSION_PROMPT.format(chapter=chapter),
+        temperature=0.2,
+    )
+
+
+def extract_characters(chapter: str) -> list[dict]:
+    result = llm(
+        CHARACTER_EXTRACTION_PROMPT.format(chapter=chapter),
+        temperature=0.1,
+    )
+    try:
+        return json.loads(result)
+    except Exception:
+        return []
+
+
+def extract_lore(chapter: str) -> str:
+    return llm(
+        LORE_EXTRACTION_PROMPT.format(chapter=chapter),
+        temperature=0.2,
+    )
+
+
+def answer_story_question(context: str, question: str) -> str:
+    return llm(
+        QA_PROMPT.format(context=context, question=question),
+        temperature=0.1,
+    )
+
+
+def generate_story_package(memory: str, instruction: str) -> dict:
+    plan = create_chapter_plan(memory, instruction)
+    chapter = generate_chapter(memory, plan, instruction)
+    summary = compress_memory(chapter)
+    characters = extract_characters(chapter)
+    lore = extract_lore(chapter)
+    return {
+        "plan": plan,
+        "chapter": chapter,
+        "summary": summary,
+        "characters": characters,
+        "lore": lore,
+    }

novelforge/core/memory.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from functools import lru_cache
+
+from endee import Endee, Precision
+import ollama
+
+STORY_INDEX = "story_memory"
+CHARACTER_INDEX = "character_memory"
+LORE_INDEX = "lore_memory"
+SUMMARY_INDEX = "summary_memory"
+
+EMBED_MODEL = "nomic-embed-text"
+
+EMBED_GPU_OPTIONS = {
+    "num_gpu": -1,
+    "main_gpu": 0,
+    "num_batch": 512,
+    "f16_kv": True,
+    "use_mmap": True,
+    "num_thread": 0,
+}
+
+
+@lru_cache(maxsize=None)
+def _client() -> Endee:
+    return Endee()
+
+
+def _ensure_index(name: str):
+    client = _client()
+    try:
+        return client.get_index(name)
+    except Exception:
+        client.create_index(
+            name=name,
+            dimension=768,
+            space_type="cosine",
+            precision=Precision.INT8,
+        )
+        return client.get_index(name)
+
+
+@lru_cache(maxsize=None)
+def _story_index():
+    return _ensure_index(STORY_INDEX)
+
+
+@lru_cache(maxsize=None)
+def _character_index():
+    return _ensure_index(CHARACTER_INDEX)
+
+
+@lru_cache(maxsize=None)
+def _lore_index():
+    return _ensure_index(LORE_INDEX)
+
+
+@lru_cache(maxsize=None)
+def _summary_index():
+    return _ensure_index(SUMMARY_INDEX)
+
+
+def get_embedding(text: str) -> list[float]:
+    response = ollama.embeddings(
+        model=EMBED_MODEL,
+        prompt=text,
+        options=EMBED_GPU_OPTIONS,
+    )
+    return response["embedding"]
+
+
+def chunk_text(text: str, chunk_size: int = 400) -> list[str]:
+    words = text.split()
+    return [
+        " ".join(words[i : i + chunk_size]) for i in range(0, len(words), chunk_size)
+    ]
+
+
+def _upsert(
+    index, novel_id: str, doc_type: str, chapter_number: int, text: str
+) -> None:
+    vectors = []
+    for i, chunk in enumerate(chunk_text(text)):
+        vectors.append(
+            {
+                "id": f"{novel_id}_{doc_type}_{chapter_number}_{i}",
+                "vector": get_embedding(chunk),
+                "meta": {
+                    "novel_id": novel_id,
+                    "doc_type": doc_type,
+                    "chapter": chapter_number,
+                    "text": chunk,
+                },
+                "filter": {
+                    "novel_id": novel_id,
+                    "chapter": str(chapter_number),
+                },
+            }
+        )
+    if vectors:
+        index.upsert(vectors)
+
+
+def save_story(novel_id: str, chapter_number: int, text: str) -> None:
+    _upsert(_story_index(), novel_id, "story", chapter_number, text)
+
+
+def save_summary(novel_id: str, chapter_number: int, text: str) -> None:
+    _upsert(_summary_index(), novel_id, "summary", chapter_number, text)
+
+
+def save_characters(novel_id: str, chapter_number: int, text: str) -> None:
+    _upsert(_character_index(), novel_id, "characters", chapter_number, text)
+
+
+def save_lore(novel_id: str, chapter_number: int, text: str) -> None:
+    _upsert(_lore_index(), novel_id, "lore", chapter_number, text)
+
+
+def search_index(index, novel_id: str, query: str, top_k: int = 5) -> str:
+    results = index.query(
+        vector=get_embedding(query),
+        top_k=top_k,
+        filter=[{"novel_id": {"$eq": novel_id}}],
+    )
+    memories = [
+        item["meta"]["text"] for item in results if item.get("meta", {}).get("text")
+    ]
+    return "\n\n".join(memories)
+
+
+def retrieve_story_memory(novel_id: str, query: str, top_k: int = 5) -> str:
+    return search_index(_story_index(), novel_id, query, top_k)
+
+
+def retrieve_character_memory(novel_id: str, query: str, top_k: int = 5) -> str:
+    return search_index(_character_index(), novel_id, query, top_k)
+
+
+def retrieve_lore_memory(novel_id: str, query: str, top_k: int = 5) -> str:
+    return search_index(_lore_index(), novel_id, query, top_k)
+
+
+def retrieve_summary_memory(novel_id: str, query: str, top_k: int = 5) -> str:
+    return search_index(_summary_index(), novel_id, query, top_k)
+
+
+def retrieve_all_memory(novel_id: str, query: str) -> str:
+    story = retrieve_story_memory(novel_id, query, top_k=8)
+    characters = retrieve_character_memory(novel_id, query, top_k=6)
+    lore = retrieve_lore_memory(novel_id, query, top_k=6)
+    summaries = retrieve_summary_memory(novel_id, query, top_k=8)
+    return f"""
+=== STORY ===
+{story}
+
+=== CHARACTERS ===
+{characters}
+
+=== LORE ===
+{lore}
+
+=== SUMMARIES ===
+{summaries}
+"""

novelforge/core/novel_manager.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import json
+import uuid
+from pathlib import Path
+
+NOVELS_DIR = Path("novels")
+NOVELS_DIR.mkdir(exist_ok=True)
+
+
+class NovelManager:
+
+    def __init__(self) -> None:
+        self.current_novel: str | None = None
+        self.metadata: dict = {}
+
+    def create_novel(self, title: str, genre: str, premise: str) -> str:
+        novel_id = str(uuid.uuid4())
+        metadata = {
+            "novel_id": novel_id,
+            "title": title,
+            "genre": genre,
+            "premise": premise,
+            "current_chapter": 1,
+            "characters": [],
+            "locations": [],
+            "factions": [],
+            "lore_topics": [],
+            "created": True,
+        }
+        self._novel_dir(novel_id).mkdir(parents=True, exist_ok=True)
+        self.save_metadata(novel_id, metadata)
+        self.current_novel = novel_id
+        self.metadata = metadata
+        return novel_id
+
+    def load_novel(self, novel_id: str) -> dict:
+        path = NOVELS_DIR / f"{novel_id}.json"
+        if not path.exists():
+            raise FileNotFoundError(f"Novel not found: {novel_id}")
+        with open(path, encoding="utf-8") as f:
+            metadata = json.load(f)
+        self.current_novel = novel_id
+        self.metadata = metadata
+        return metadata
+
+    def save_metadata(self, novel_id: str | None, metadata: dict) -> None:
+        novel_id = novel_id or self.current_novel
+        if novel_id is None:
+            raise ValueError("novel_id must be provided or current_novel must be set")
+        path = NOVELS_DIR / f"{novel_id}.json"
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(metadata, f, indent=4, ensure_ascii=False)
+
+    def _novel_dir(self, novel_id: str | None = None) -> Path:
+        dir_id = novel_id or self.current_novel
+        if dir_id is None:
+            raise ValueError("novel_id must be provided or current_novel must be set")
+        return NOVELS_DIR / dir_id
+
+    def save_chapter_to_disk(
+        self, chapter_number: int, chapter_text: str, summary_text: str
+    ) -> None:
+        d = self._novel_dir()
+        d.mkdir(parents=True, exist_ok=True)
+        (d / f"chapter_{chapter_number:03d}.txt").write_text(chapter_text, "utf-8")
+        (d / f"summary_{chapter_number:03d}.txt").write_text(summary_text, "utf-8")
+
+    def read_chapter_from_disk(self, chapter_number: int) -> str | None:
+        path = self._novel_dir() / f"chapter_{chapter_number:03d}.txt"
+        return path.read_text("utf-8") if path.exists() else None
+
+    def read_summary_from_disk(self, chapter_number: int) -> str | None:
+        path = self._novel_dir() / f"summary_{chapter_number:03d}.txt"
+        return path.read_text("utf-8") if path.exists() else None
+
+    def chapter_files(self, novel_id: str | None = None) -> list[Path]:
+        d = self._novel_dir(novel_id or self.current_novel)
+        return sorted(d.glob("chapter_*.txt")) if d.exists() else []
+
+    def update_chapter(self) -> int:
+        self.metadata["current_chapter"] += 1
+        self.save_metadata(self.current_novel, self.metadata)
+        return self.metadata["current_chapter"]
+
+    def get_current_chapter(self) -> int:
+        return self.metadata.get("current_chapter", 1)
+
+    def add_character(self, name: str) -> None:
+        if name and name not in self.metadata["characters"]:
+            self.metadata["characters"].append(name)
+            self.save_metadata(self.current_novel, self.metadata)
+
+    def add_location(self, location: str) -> None:
+        if location and location not in self.metadata["locations"]:
+            self.metadata["locations"].append(location)
+            self.save_metadata(self.current_novel, self.metadata)
+
+    def add_faction(self, faction: str) -> None:
+        if faction and faction not in self.metadata["factions"]:
+            self.metadata["factions"].append(faction)
+            self.save_metadata(self.current_novel, self.metadata)
+
+    def add_lore_topic(self, topic: str) -> None:
+        if topic and topic not in self.metadata["lore_topics"]:
+            self.metadata["lore_topics"].append(topic)
+            self.save_metadata(self.current_novel, self.metadata)
+
+    def apply_lore_extraction(self, lore_text: str) -> None:
+        if not lore_text:
+            return
+        section = None
+        location_headers = {"locations", "location"}
+        faction_headers = {
+            "factions",
+            "faction",
+            "political systems",
+            "political system",
+        }
+        lore_headers = {
+            "magic systems",
+            "magic system",
+            "technology",
+            "history",
+            "world rules",
+            "lore",
+            "other",
+        }
+        for line in lore_text.splitlines():
+            stripped = line.strip()
+            if not stripped:
+                continue
+            if stripped.startswith("#"):
+                header_text = stripped.lstrip("# ").rstrip(":").lower()
+                if header_text in location_headers:
+                    section = "location"
+                elif header_text in faction_headers:
+                    section = "faction"
+                elif header_text in lore_headers:
+                    section = "lore"
+                else:
+                    section = None
+                continue
+            if stripped.startswith(("-", "*")):
+                item = stripped.lstrip("-* ").split(":")[0].strip()
+                if not item:
+                    continue
+                if section == "location":
+                    self.add_location(item)
+                elif section == "faction":
+                    self.add_faction(item)
+                elif section == "lore":
+                    self.add_lore_topic(item)
+
+    def list_novels(self) -> list[dict]:
+        out = []
+        for f in NOVELS_DIR.glob("*.json"):
+            try:
+                data = json.loads(f.read_text("utf-8"))
+                out.append(
+                    {
+                        "novel_id": data.get("novel_id"),
+                        "title": data.get("title"),
+                        "genre": data.get("genre"),
+                        "chapter": data.get("current_chapter", 1),
+                    }
+                )
+            except Exception:
+                pass
+        return out
+
+    def delete_novel(self, novel_id: str) -> None:
+        path = NOVELS_DIR / f"{novel_id}.json"
+        if path.exists():
+            path.unlink()
+
+    def get_metadata(self) -> dict:
+        return self.metadata
+
+    def get_novel_id(self) -> str | None:
+        return self.current_novel
+
+    def get_story_bible(self) -> str:
+        m = self.metadata
+        return (
+            f"Title:\n{m.get('title', '')}\n\n"
+            f"Genre:\n{m.get('genre', '')}\n\n"
+            f"Premise:\n{m.get('premise', '')}\n\n"
+            f"Characters:\n{', '.join(m.get('characters', []))}\n\n"
+            f"Locations:\n{', '.join(m.get('locations', []))}\n\n"
+            f"Factions:\n{', '.join(m.get('factions', []))}\n\n"
+            f"Lore:\n{', '.join(m.get('lore_topics', []))}\n\n"
+            f"Current Chapter:\n{m.get('current_chapter', 1)}"
+        )

novelforge/core/prompts.py

@@ -0,0 +1,156 @@
+NOVEL_SYSTEM_PROMPT = """
+You are an award-winning novelist.
+
+Maintain perfect continuity across:
+- Characters
+- Locations
+- Timeline
+- Relationships
+- Lore
+- World rules
+
+Rules:
+1. Never contradict established canon.
+2. Use Story Memory as truth.
+3. Show, don't tell.
+4. Use vivid sensory descriptions.
+5. Write natural dialogue.
+6. Advance plot and character development.
+7. Avoid repetition.
+8. End scenes with momentum.
+
+Write like a bestselling novel.
+"""
+
+CREATE_NOVEL_PROMPT = """
+Create Chapter 1 of a new novel.
+
+Novel Concept:
+{idea}
+
+Requirements:
+- Introduce protagonist naturally
+- Establish setting
+- Introduce central conflict
+- Create emotional investment
+- End with a hook
+
+Write a complete chapter.
+"""
+
+CHAPTER_PLAN_PROMPT = """
+Story Memory:
+
+{memory}
+
+Instruction:
+
+{instruction}
+
+Create a chapter plan.
+
+Return:
+
+1. Chapter Goal
+2. Main Events
+3. Character Development
+4. Conflict
+5. Ending Hook
+"""
+
+CONTINUE_NOVEL_PROMPT = """
+Story Memory:
+
+{memory}
+
+Chapter Plan:
+
+{plan}
+
+User Instruction:
+
+{instruction}
+
+Write the next chapter.
+
+Maintain:
+- Character consistency
+- Timeline consistency
+- Relationship consistency
+- World consistency
+
+Write a complete chapter.
+"""
+
+MEMORY_COMPRESSION_PROMPT = """
+Chapter:
+
+{chapter}
+
+Extract continuity memory.
+
+Return:
+
+CHARACTERS:
+LOCATIONS:
+LORE:
+EVENTS:
+RELATIONSHIPS:
+OPEN_PLOTS:
+
+Maximum 500 words.
+"""
+
+CHARACTER_EXTRACTION_PROMPT = """
+Analyze chapter:
+
+{chapter}
+
+Return ONLY JSON.
+
+[
+  {{
+    "name":"",
+    "aliases":[],
+    "appearance":"",
+    "personality":"",
+    "goals":"",
+    "relationships":[],
+    "important_facts":[]
+  }}
+]
+"""
+
+LORE_EXTRACTION_PROMPT = """
+Analyze chapter:
+
+{chapter}
+
+Extract:
+
+- Locations
+- Factions
+- Magic systems
+- Technology
+- History
+- Political systems
+- World rules
+
+Return structured markdown.
+"""
+
+QA_PROMPT = """
+Context:
+
+{context}
+
+Question:
+
+{question}
+
+Answer only using context.
+
+If answer is unavailable say:
+
+Not mentioned in story.
+"""