@tpitre/story-ui 1.3.0 → 1.4.0

package/dist/mcp-server/routes/generateStory.js

@@ -7,6 +7,7 @@ import { loadUserConfig, validateConfig } from '../../story-generator/configLoad
 import { setupProductionGitignore } from '../../story-generator/productionGitignoreManager.js';
 import { getInMemoryStoryService } from '../../story-generator/inMemoryStoryService.js';
 import { extractAndValidateCodeBlock, createFallbackStory } from '../../story-generator/validateStory.js';
+import { StoryTracker } from '../../story-generator/storyTracker.js';
 const CLAUDE_API_URL = 'https://api.anthropic.com/v1/messages';
 const CLAUDE_MODEL = process.env.CLAUDE_MODEL || 'claude-sonnet-4-20250514';
 // Legacy constants - now using dynamic discovery
@@ -178,6 +179,8 @@ export async function generateStoryFromPrompt(req, res) {
         const gitignoreManager = setupProductionGitignore(config);
         const storyService = getInMemoryStoryService(config);
         const isProduction = gitignoreManager.isProductionMode();
+        // Initialize story tracker for managing updates vs new creations
+        const storyTracker = new StoryTracker(config);
         // Check if this is an update to an existing story
         const isUpdate = fileName && conversation && conversation.length > 2;
         // Build prompt with conversation context if available
@@ -244,15 +247,29 @@ export async function generateStoryFromPrompt(req, res) {
             const title = config.storyPrefix + prettyPrompt;
             return p1 + title + p3;
         });
+        // Check if there's an existing story with this title or prompt
+        const existingByTitle = storyTracker.findByTitle(aiTitle);
+        const existingByPrompt = storyTracker.findByPrompt(prompt);
+        const existingStory = existingByTitle || existingByPrompt;
         // Generate unique ID and filename
         let hash, finalFileName, storyId;
-        if (isUpdate && fileName) {
-            // For updates, use existing fileName and ID
+        let isActuallyUpdate = false;
+        if (existingStory) {
+            // Use existing story's details to update instead of creating duplicate
+            console.log(`Found existing story "${existingStory.title}" - updating instead of creating new`);
+            hash = existingStory.hash;
+            finalFileName = existingStory.fileName;
+            storyId = existingStory.storyId;
+            isActuallyUpdate = true;
+        }
+        else if (isUpdate && fileName) {
+            // For conversation-based updates, use existing fileName and ID
             finalFileName = fileName;
             // Extract hash from existing fileName if possible
             const hashMatch = fileName.match(/-([a-f0-9]{8})(?:\.stories\.tsx)?$/);
             hash = hashMatch ? hashMatch[1] : crypto.createHash('sha1').update(prompt).digest('hex').slice(0, 8);
             storyId = `story-${hash}`;
+            isActuallyUpdate = true;
         }
         else {
             // For new stories, generate new IDs
@@ -265,15 +282,26 @@ export async function generateStoryFromPrompt(req, res) {
             const generatedStory = {
                 id: storyId,
                 title: aiTitle,
-                description: isUpdate ? `Updated: ${prompt}` : prompt,
+                description: isActuallyUpdate ? `Updated: ${prompt}` : prompt,
                 content: fixedFileContents,
-                createdAt: isUpdate ? (new Date()) : new Date(),
+                createdAt: isActuallyUpdate ? (new Date()) : new Date(),
                 lastAccessed: new Date(),
-                prompt: isUpdate ? conversation.map((msg) => `${msg.role}: ${msg.content}`).join('\n\n') : prompt,
+                prompt: isActuallyUpdate ? conversation.map((msg) => `${msg.role}: ${msg.content}`).join('\n\n') : prompt,
                 components: extractComponentsFromContent(fixedFileContents)
             };
             storyService.storeStory(generatedStory);
-            console.log(`Story ${isUpdate ? 'updated' : 'stored'} in memory: ${storyId}`);
+            // Register with story tracker
+            const mapping = {
+                title: aiTitle,
+                fileName: finalFileName,
+                storyId,
+                hash,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                prompt
+            };
+            storyTracker.registerStory(mapping);
+            console.log(`Story ${isActuallyUpdate ? 'updated' : 'stored'} in memory: ${storyId}`);
             res.json({
                 success: true,
                 fileName: finalFileName,
@@ -282,7 +310,7 @@ export async function generateStoryFromPrompt(req, res) {
                 story: fileContents,
                 environment: 'production',
                 storage: 'in-memory',
-                isUpdate,
+                isUpdate: isActuallyUpdate,
                 validation: {
                     hasWarnings: hasValidationWarnings,
                     errors: validationResult.errors || [],
@@ -293,7 +321,18 @@ export async function generateStoryFromPrompt(req, res) {
         else {
             // Development: Write to file system
             const outPath = generateStory({ fileContents: fixedFileContents, fileName: finalFileName });
-            console.log(`Story ${isUpdate ? 'updated' : 'written'} to:`, outPath);
+            // Register with story tracker
+            const mapping = {
+                title: aiTitle,
+                fileName: finalFileName,
+                storyId,
+                hash,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                prompt
+            };
+            storyTracker.registerStory(mapping);
+            console.log(`Story ${isActuallyUpdate ? 'updated' : 'written'} to:`, outPath);
             res.json({
                 success: true,
                 fileName: finalFileName,
@@ -302,7 +341,7 @@ export async function generateStoryFromPrompt(req, res) {
                 story: fileContents,
                 environment: 'development',
                 storage: 'file-system',
-                isUpdate,
+                isUpdate: isActuallyUpdate,
                 validation: {
                     hasWarnings: hasValidationWarnings,
                     errors: validationResult.errors || [],

package/dist/story-generator/storyTracker.js

@@ -0,0 +1,150 @@
+import fs from 'fs';
+import path from 'path';
+export class StoryTracker {
+    constructor(config) {
+        this.mappingFile = path.join(path.dirname(config.generatedStoriesPath), '.story-mappings.json');
+        this.mappings = new Map();
+        this.loadMappings();
+    }
+    /**
+     * Load existing mappings from disk
+     */
+    loadMappings() {
+        try {
+            if (fs.existsSync(this.mappingFile)) {
+                const data = JSON.parse(fs.readFileSync(this.mappingFile, 'utf-8'));
+                for (const mapping of data) {
+                    this.mappings.set(mapping.title.toLowerCase(), mapping);
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load story mappings:', error);
+            this.mappings = new Map();
+        }
+    }
+    /**
+     * Save mappings to disk
+     */
+    saveMappings() {
+        try {
+            const data = Array.from(this.mappings.values());
+            fs.writeFileSync(this.mappingFile, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to save story mappings:', error);
+        }
+    }
+    /**
+     * Find an existing story by title
+     */
+    findByTitle(title) {
+        // Normalize the title for comparison
+        const normalizedTitle = title.toLowerCase().trim();
+        // Try exact match first
+        let mapping = this.mappings.get(normalizedTitle);
+        if (mapping)
+            return mapping;
+        // Try fuzzy matching for similar titles
+        for (const [key, value] of this.mappings) {
+            // Check if the key contains the normalized title or vice versa
+            if (key.includes(normalizedTitle) || normalizedTitle.includes(key)) {
+                return value;
+            }
+            // Check for very similar titles (e.g., "dashboard" vs "inventory dashboard")
+            const keywords = normalizedTitle.split(/\s+/);
+            const keyKeywords = key.split(/\s+/);
+            // If all keywords from the shorter title are in the longer one
+            const shortKeywords = keywords.length < keyKeywords.length ? keywords : keyKeywords;
+            const longKeywords = keywords.length < keyKeywords.length ? keyKeywords : keywords;
+            if (shortKeywords.every(word => longKeywords.includes(word))) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find an existing story by prompt similarity
+     */
+    findByPrompt(prompt) {
+        const normalizedPrompt = prompt.toLowerCase().trim();
+        // Remove common prefixes like "generate a", "create a", etc.
+        const cleanPrompt = normalizedPrompt
+            .replace(/^(generate|create|build|make|design|show|write|produce|construct|draft|compose|implement|add|render|display)\s+(a|an|the)?\s*/i, '')
+            .trim();
+        // Try to find by similar prompts
+        for (const mapping of this.mappings.values()) {
+            const mappingPrompt = mapping.prompt.toLowerCase()
+                .replace(/^(generate|create|build|make|design|show|write|produce|construct|draft|compose|implement|add|render|display)\s+(a|an|the)?\s*/i, '')
+                .trim();
+            if (mappingPrompt === cleanPrompt) {
+                return mapping;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Register a new or updated story
+     */
+    registerStory(mapping) {
+        const normalizedTitle = mapping.title.toLowerCase();
+        // Check if we're updating an existing story
+        const existing = this.findByTitle(mapping.title);
+        if (existing) {
+            // Update the existing mapping
+            mapping.createdAt = existing.createdAt;
+            mapping.updatedAt = new Date().toISOString();
+        }
+        else {
+            // New story
+            mapping.createdAt = new Date().toISOString();
+            mapping.updatedAt = mapping.createdAt;
+        }
+        this.mappings.set(normalizedTitle, mapping);
+        this.saveMappings();
+    }
+    /**
+     * Remove a story mapping
+     */
+    removeStory(titleOrFileName) {
+        // Try to find by title first
+        const byTitle = this.findByTitle(titleOrFileName);
+        if (byTitle) {
+            this.mappings.delete(byTitle.title.toLowerCase());
+            this.saveMappings();
+            return true;
+        }
+        // Try to find by filename
+        for (const [key, mapping] of this.mappings) {
+            if (mapping.fileName === titleOrFileName) {
+                this.mappings.delete(key);
+                this.saveMappings();
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get all story mappings
+     */
+    getAllMappings() {
+        return Array.from(this.mappings.values());
+    }
+    /**
+     * Clean up orphaned mappings (stories that no longer exist)
+     */
+    cleanupOrphaned(generatedStoriesPath) {
+        let removed = 0;
+        for (const [key, mapping] of this.mappings) {
+            const filePath = path.join(generatedStoriesPath, mapping.fileName);
+            if (!fs.existsSync(filePath)) {
+                this.mappings.delete(key);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            this.saveMappings();
+        }
+        return removed;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tpitre/story-ui",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "AI-powered Storybook story generator for any React component library",
   "type": "module",
   "main": "dist/index.js",