Next.js Persona App

help me write a series of prompts which when given to CLIne will code the following program into a full stack next.js application with the final prompt being making it work with docker : import os import glob import base64 import json import requests import yaml import argparse import logging import ollama from datetime import datetime logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s") PERSONA_FOLDER = "personas" CACHE_FOLDER = "cache" STORIES_FOLDER = "stories" def list_text_files(folder): return sorted(glob.glob(os.path.join(folder, "*.txt"))) def read_file(filepath): with open(filepath, "r", encoding="utf-8") as f: return f.read() def write_yaml(filepath, data): with open(filepath, "w", encoding="utf-8") as f: yaml.dump(data, f, sort_keys=False, allow_unicode=True) def write_text(filepath, content): with open(filepath, "w", encoding="utf-8") as f: f.write(content) def extract_persona_from_text(text): prompt = f"""You are a world-class psychological analyst and computational literary theorist embedded in an advanced LLM. Your objective is to deeply analyze the following writing sample to reverse-engineer a nuanced and data-rich representation of the author’s psychological and narrative persona. You will return your analysis in **valid YAML format**, structured with the following fields. Your analysis must be interpretive, sensitive to subtlety, and grounded in psychological realism. --- PersonaSchema: name: > A plausible name that reflects the personality, cultural tone, and emotional charge of the writing sample. tone: > The dominant tonal signature. Choose or blend from tones such as irreverent, clinical, melancholic, earnest, ironic, poetic, paranoid, lyrical, didactic, satirical, etc. mood: > The emotional current beneath the surface. Describe both dominant and oscillating moods, if applicable (e.g., anxious but defiant, quietly elated, aggressively calm). formality: > Degree of linguistic formality or casualness. Use natural language labels like academic, relaxed, self-deprecating, ceremonial, streetwise, metaphysical, etc. perspective: pronouns: [first-person, second-person, third-person, mixed] narrative_distance: > Close, medium, or distant — describe how intimately or impersonally the narrator relates to the subject matter. temporal_orientation: > Does the writer dwell in memory, anticipate the future, or focus on the now? rhetorical_style: sentence_structure: > Comment on syntax (e.g., long and winding, clipped, recursive, breathless, minimalist). use_of_analogy: > Does the writer favor metaphor, simile, allegory, abstraction, or concrete literalism? persuasive_tactics: > Are they arguing, confessing, musing, venting, storytelling, or dialoguing with an internal voice? humor_profile: humor_type: [dark, dry, absurdist, slapstick, sarcastic, punny, self-deprecating, surreal, wordplay, observational, etc.] humor_target: > What is the typical subject of the humor? (e.g., the self, institutions, humanity, absurdity of life, physical reality) delivery_style: > Describe the delivery style — e.g., deadpan, explosive, meandering, sneaky punchlines, staccato one-liners, nested irony. frequency: > How often does humor appear? (saturated, sparse but sharp, consistent thread, rare) implicit_emotion: > What emotion underpins the humor? (e.g., anger, joy, despair, defiance, curiosity) values_and_themes: core_values: [list 3–5 values or beliefs inferred from the writing: e.g., justice, beauty, autonomy, defiance, connection, tradition] recurring_themes: [list 3–5 recurring themes or topics the author gravitates toward] implicit_worldview: > What implicit beliefs about human nature, society, or reality are embedded in the writing? lexical_and_stylistic_traits: favorite_words: [list 5–10 distinctive or repeated words] taboo_words: [if any, words the author avoids or handles cautiously] rhythm_and_pacing: > Describe how the language flows — musical, abrupt, rambling, staccato, breath-like? punctuation_signature: > Does the author use unconventional punctuation (e.g., em-dashes, ellipses, no punctuation, excessive commas)? capitalization_habits: > Any stylistic habits (e.g., all caps for emphasis, i instead of I, etc.) psychological_fingerprint: openness_to_experience: [1-10] conscientiousness: [1-10] extraversion: [1-10] agreeableness: [1-10] neuroticism: [1-10] cognitive_style: > Describe whether the writer seems more intuitive, logical, abstract, embodied, concrete, or poetic. inner_conflict: > Any evidence of internal contradictions or psychological tension? key_phrases: [list 5–10 phrases that uniquely capture the author’s voice or themes] summary_description: > A vivid, 4-6 sentence paragraph summarizing the narrator’s voice, tone, humor, psychology, and implied context. Include metaphor if useful. --- Use deep psychological and literary reasoning to infer this schema from the sample. Writing Sample: {text} Respond only with valid YAML, no explanation or preamble. """ try: response = ollama.generate( model="gemma3:27b", prompt=prompt, format="json" ) return yaml.safe_load(response["response"]) except Exception as e: logging.error(f"Failed to extract persona: {e}") return { "name": "Default Persona", "tone": "Neutral", "mood": "Calm", "formality": "Neutral", "key_phrases": ["clear", "structured", "neutral"], "description": "A balanced and neutral narrator with an even tone." } def generate_personas_from_input_folder(input_folder): os.makedirs(PERSONA_FOLDER, exist_ok=True) text_files = list_text_files(input_folder) persona_files = [] for txt_file in text_files: text = read_file(txt_file) persona = extract_persona_from_text(text) base_name = os.path.splitext(os.path.basename(txt_file))[0] persona_path = os.path.join(PERSONA_FOLDER, base_name + ".yaml") write_yaml(persona_path, persona) persona_files.append(persona_path) logging.info(f"Generated persona: {persona_path}") return persona_files def list_yaml_files(folder): return sorted(glob.glob(os.path.join(folder, "*.yaml"))) def load_yaml(filepath): with open(filepath, "r", encoding="utf-8") as f: return yaml.safe_load(f) def list_image_files(folder_path): exts = ["*.jpg", "*.png", "*.jpeg"] image_files = [] for ext in exts: image_files.extend(glob.glob(os.path.join(folder_path, ext))) return sorted(image_files) def analyze_image(image_path, persona, force=False): os.makedirs(CACHE_FOLDER, exist_ok=True) base_name = os.path.splitext(os.path.basename(image_path))[0] cache_path = os.path.join(CACHE_FOLDER, f"{base_name}.json") if os.path.exists(cache_path) and not force: with open(cache_path, "r", encoding="utf-8") as f: cached = json.load(f) logging.info(f"Loaded cached analysis: {base_name}") return cached["description"] # Read and encode the image with open(image_path, "rb") as img_file: image_b64 = base64.b64encode(img_file.read()).decode("utf-8") prompt = ( f"Imagine you're viewing this photo. Describe what you see with these constraints:\n\n" f"Persona Name: {persona.get('name', 'Unknown')}\n" f"Tone: {persona.get('tone', 'Neutral')}\n" f"Mood: {persona.get('mood', 'Calm')}\n" f"Formality: {persona.get('formality', 'Neutral')}\n" f"Key Phrases: {', '.join(persona.get('key_phrases', []))}\n\n" f"Write a vivid and stylistically interesting description of the image." ) try: response = requests.post( "http://localhost:11434/api/generate", json={ "model": "gemma3:27b", "prompt": prompt, "images": [image_b64], "stream": False } ) response.raise_for_status() result = response.json() description = result.get("response", "") with open(cache_path, "w", encoding="utf-8") as f: json.dump({"description": description}, f) logging.info(f"Saved analysis: {cache_path}") return description except Exception as e: logging.error(f"Failed image analysis: {e}") return None def load_all_cached_analyses(): if not os.path.exists(CACHE_FOLDER): return [] files = sorted(glob.glob(os.path.join(CACHE_FOLDER, "*.json"))) analyses = [] for fpath in files: try: with open(fpath, "r", encoding="utf-8") as f: data = json.load(f) if "description" in data: analyses.append(data["description"]) except Exception as e: logging.error(f"Error loading {fpath}: {e}") return analyses def generate_story_from_analyses(analyses, persona): if not analyses: logging.error("No analyses available for story generation.") return None prompt = "Here are image descriptions:\n\n" for i, analysis in enumerate(analyses, start=1): prompt += f"Image {i}: {analysis}\n\n" prompt += ( f"Write a reflective and stylistically distinctive story in the voice of {persona.get('name', 'Unknown')},\n" f"capturing a tone of '{persona.get('tone', 'Neutral')}' and a prevailing mood of '{persona.get('mood', 'Calm')}'.\n\n" f"Adopt a writing style that mirrors their rhetorical style:\n" f"- Use sentence structures that are {persona.get('rhetorical_style', {}).get('sentence_structure', 'balanced')}.\n" f"- Employ analogies or metaphor as {persona.get('rhetorical_style', {}).get('use_of_analogy', 'sparse or literal')}.\n" f"- Let the persuasive tone feel like they are {persona.get('rhetorical_style', {}).get('persuasive_tactics', 'contemplating or storytelling')}.\n\n" f"Integrate the persona’s humor subtly into the narrative:\n" f"- Use humor that is primarily {persona.get('humor_profile', {}).get('humor_type', 'dry or self-deprecating')},\n" f" with delivery that is {persona.get('humor_profile', {}).get('delivery_style', 'meandering or ironic')},\n" f" and underlying emotion of {persona.get('humor_profile', {}).get('implicit_emotion', 'bittersweet')}.\n" f"- Let it target {persona.get('humor_profile', {}).get('humor_target', 'existential absurdities or the narrator themselves')}.\n" f"- Adjust frequency to be {persona.get('humor_profile', {}).get('frequency', 'threaded or occasional')}.\n\n" f"Honor the narrator’s worldview and values:\n" f"- Let their worldview reflect beliefs about {persona.get('values_and_themes', {}).get('implicit_worldview', 'the complexity of human nature')}.\n" f"- Reinforce core values like {', '.join(persona.get('values_and_themes', {}).get('core_values', ['authenticity', 'resilience']))}.\n" f"- Weave in recurring themes such as {', '.join(persona.get('values_and_themes', {}).get('recurring_themes', ['identity', 'loss', 'connection']))}.\n\n" f"Mimic stylistic and lexical traits:\n" f"- Use favorite words such as {', '.join(persona.get('lexical_and_stylistic_traits', {}).get('favorite_words', ['dissonance', 'hollow', 'flicker']))}.\n" f"- Reflect a writing rhythm that is {persona.get('lexical_and_stylistic_traits', {}).get('rhythm_and_pacing', 'flowing but irregular')},\n" f" and a punctuation style that is {persona.get('lexical_and_stylistic_traits', {}).get('punctuation_signature', 'elliptical or expressive')}.\n\n" f"Embed psychological subtext:\n" f"- Allow the cognitive style to guide the internal logic — whether {persona.get('psychological_fingerprint', {}).get('cognitive_style', 'intuitive or poetic')}.\n" f"- Hint at inner tensions such as: {persona.get('psychological_fingerprint', {}).get('inner_conflict', 'longing for clarity vs embracing ambiguity')}.\n\n" f"Include key phrases like:\n" f"\"{', '.join(persona.get('key_phrases', [])[:3])}\" somewhere in the narration.\n\n" f"Make the story introspective, emotionally layered, and authentic to this persona's unique literary fingerprint." ) try: response = ollama.generate( model="mistral-small:24b-instruct-2501-q8_0", prompt=prompt ) return response["response"] except Exception as e: logging.error(f"Story generation failed: {e}") return None def save_story(story_text, persona_name): os.makedirs(STORIES_FOLDER, exist_ok=True) timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") filename = f"{persona_name.replace(' ', '_').lower()}_story_{timestamp}.txt" filepath = os.path.join(STORIES_FOLDER, filename) write_text(filepath, story_text) logging.info(f"Saved story: {filepath}") return filepath def select_persona_file(persona_files): print("Choose a persona:") for i, file in enumerate(persona_files, 1): print(f"{i}: {os.path.basename(file)}") while True: choice = input("Enter number: ").strip() if choice.isdigit() and 1 <= int(choice) <= len(persona_files): return persona_files[int(choice) - 1] print("Invalid choice.") def main(): parser = argparse.ArgumentParser() parser.add_argument("--input-texts", required=True) parser.add_argument("--input-images", required=True) args = parser.parse_args() persona_files = generate_personas_from_input_folder(args.input_texts) if not persona_files: logging.error("No persona files found.") return persona_file = select_persona_file(persona_files) persona = load_yaml(persona_file) images = list_image_files(args.input_images) if not images: logging.error("No images found.") return use_cache = input("Use cached descriptions? (y/n): ").lower().startswith("y") analyses = load_all_cached_analyses() if use_cache else [] if not use_cache or not analyses: analyses = [analyze_image(img, persona) for img in images if analyze_image(img, persona)] story = generate_story_from_analyses(analyses, persona) if story: save_story(story, persona.get("name", "Unknown")) if __name__ == "__main__": main()

To convert your Python-based persona extractor and image-to-story generator into a full-stack **Next.js** web application using **CLine**, you'll want to proceed step-by-step. Below is a **progressive series of prompts** you can feed into **CLine** to get it to build out each layer of your app. The final prompt will ask CLine to Dockerize the whole stack. --- ### ✅ Prompt Series for CLine --- #### **Prompt 1: Initialize a Full-Stack Next.js App** ```bash Create a full-stack Next.js 14 application using the App Router and TypeScript, with API routes configured for back-end logic. Include Tailwind CSS for styling. Name the project `persona-web`. ``` --- #### **Prompt 2: Set Up Folder Structure for Uploads** ```bash Add server-side support for uploading `.txt` writing samples and image files using the App Router. Create the folders `uploads/personas` and `uploads/images` on the server. Store writing samples as `.txt` and images as `.jpg`, `.jpeg`, or `.png`. Use multer or a similar middleware for file handling in the backend. ``` --- #### **Prompt 3: Integrate Persona Extraction Endpoint** ```bash Create an API route at `/api/extract-persona` that accepts a POST request with a `text` body and returns a persona in YAML format using the `extract_persona_from_text()` logic from the Python script. Port this logic to a Python microservice running locally and call it from the API using `fetch` or `axios` to `http://localhost:5000/extract`. ``` --- #### **Prompt 4: Create a Flask Microservice for Persona Extraction** ```bash Write a Python Flask app that exposes a POST endpoint `/extract` that accepts raw text and returns the result of `extract_persona_from_text()` as JSON. Make sure to import `ollama` and `yaml`, and wrap the logic with error handling. Run this microservice on port 5000. ``` --- #### **Prompt 5: Image Analysis via API** ```bash Add a new Flask route `/analyze-image` to the Python backend. Accept an image file and persona JSON. Convert the image to base64 and use the image description prompt logic from the original script. Return the generated description as JSON. ``` --- #### **Prompt 6: Frontend File Upload Page** ```bash Build a page in Next.js at `/upload` where users can upload: - One or more `.txt` writing samples - A batch of image files Use React hooks and form state management. After uploading text files, show YAML output from `/api/extract-persona`. After uploading images, call `/analyze-image` for each and display the generated descriptions. ``` --- #### **Prompt 7: Story Generation Endpoint** ```bash Add an API route `/api/generate-story` in the Next.js backend that accepts a list of image analysis texts and persona data. Forward this data to the Python Flask service at `/generate-story`, which uses the logic from `generate_story_from_analyses()` and returns the resulting story text. ``` --- #### **Prompt 8: Add Story Display Page** ```bash Create a page at `/story` that renders the story returned from `/api/generate-story`, styled using Tailwind typography and transitions. Show a summary of the persona traits alongside the story for context. ``` --- #### **Prompt 9: Add Persistent Persona & Story Storage** ```bash Integrate a lightweight SQLite or JSON-based local database using Prisma or plain file storage. Store: - Persona YAML files - Image descriptions - Final story text Provide a page `/history` listing past generations with links to view full stories and personas. ``` --- #### **Prompt 10: Dockerize the Whole Project** ```bash Create a `Dockerfile` for both the Next.js frontend and the Flask backend. Set up a `docker-compose.yml` file that: - Starts the Next.js frontend on port 3000 - Starts the Flask service on port 5000 - Mounts `uploads/`, `cache/`, and `personas/` as volumes - Supports hot-reloading in development Ensure the services can talk to each other by hostname in `docker-compose`. ``` --- Would you like me to generate any of these specific files (e.g., `Dockerfile`, `Flask app`, or `Next.js` API routes) to accelerate your workflow?

Got it! You want me to help you write a **series of CLIne prompts** that step-by-step build a **full stack Next.js app** implementing the Python app you provided — with the final prompt instructing it to add Docker support. --- Here’s a **suggested sequence** of CLIne prompts. Each builds on the last, guiding the AI to generate the full app incrementally, starting from a fresh Next.js app, adding backend API routes to replicate your Python logic, React UI, persona and story management, and finally Dockerization. --- ## Step 1: Initialize Next.js app with basic structure and dependencies ``` Create a new Next.js app from scratch with TypeScript support. Add these dependencies: axios, js-yaml, multer (for file uploads), dotenv, and any needed type packages. Structure the project with folders: - /pages/api for backend API routes - /components for React UI components - /lib for shared utilities Add a simple homepage that will later show personas and stories. ``` --- ## Step 2: Implement utility functions (file listing, reading, writing) in Node.js ``` Create a /lib/utils.ts file that includes: - listTextFiles(folder: string): Promise<string[]> — lists .txt files in a folder. - readFile(filepath: string): Promise<string> — reads text file content. - writeYaml(filepath: string, data: object): Promise<void> — writes YAML data to file. - writeText(filepath: string, content: string): Promise<void> — writes text content. Use Node.js fs/promises and glob or fast-glob for file operations. ``` --- ## Step 3: Implement persona extraction logic via an API route ``` Create /pages/api/personas/generate.ts that: - Accepts an input folder path as query or body param. - Lists all .txt files in that folder. - For each file, reads its content and sends it to an LLM API call to generate persona YAML. Implement the prompt for persona extraction exactly as in the Python app, but adapt for your LLM API (e.g., OpenAI, or mock an ollama client if available). Save the persona YAML files into a /personas folder inside the project. Return the list of generated persona filenames or contents as JSON. ``` --- ## Step 4: Implement image analysis API route ``` Create /pages/api/images/analyze.ts that: - Accepts image uploads or base64 images with an associated persona. - If a cached analysis JSON exists, return it. - Otherwise, send the image + persona info to the LLM API (using a similar prompt as the Python script) to generate an image description. - Cache the description as a JSON file in a /cache folder. - Return the description in the API response. Use multer for image upload handling. ``` --- ## Step 5: Implement story generation API route ``` Create /pages/api/stories/generate.ts that: - Loads all cached image analyses from /cache folder. - Accepts a persona (loaded from a YAML file). - Constructs a prompt combining all image descriptions with the persona details as in the Python app. - Calls the LLM API to generate a reflective story. - Returns the story text. ``` --- ## Step 6: Build React UI components and pages ``` Create React components: - PersonaList: Lists all generated personas with basic details. - PersonaDetail: Shows detailed YAML persona info. - ImageUpload: Allows user to upload images and analyze with selected persona. - StoryView: Displays the generated story from analyzed images and selected persona. Implement pages: - /personas: shows PersonaList - /personas/[id]: shows PersonaDetail and allows image upload for analysis and story generation - /stories: lists generated stories or allows story regeneration Use React Query or SWR for data fetching. ``` --- ## Step 7: Add environment config and replace any hardcoded paths ``` Use a .env.local file to configure folder paths like PERSONA_FOLDER, CACHE_FOLDER, STORIES_FOLDER. Modify API routes and utilities to read from environment variables. Ensure all file/folder operations are relative to the project root or configurable paths. ``` --- ## Step 8: Add Docker support ``` Create a Dockerfile to containerize the Next.js app: - Use node:18-alpine as base. - Copy package.json and install dependencies. - Copy source code. - Build Next.js app. - Expose port 3000. - Start the Next.js server. Create a docker-compose.yml if needed to mount volumes for persistent /personas, /cache, and /stories folders. Document how to build and run the container. Test the app inside Docker to verify full functionality. ``` --- If you want, I can write out **the full detailed prompts** for each step or even draft the full code output for some steps. Would you like me to do that?