@narrative-os/cli 0.1.0

package/dist/commands/bible.d.ts

@@ -0,0 +1 @@
+export declare function bibleCommand(storyId: string): void;

package/dist/commands/bible.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bibleCommand = bibleCommand;
+const store_js_1 = require("../config/store.js");
+function bibleCommand(storyId) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    const { bible } = story;
+    console.log(`\n# ${bible.title}`);
+    console.log('─'.repeat(60));
+    console.log(`\n**Theme:** ${bible.theme}`);
+    console.log(`**Genre:** ${bible.genre}`);
+    console.log(`**Setting:** ${bible.setting}`);
+    console.log(`**Tone:** ${bible.tone}`);
+    console.log(`\n**Premise:**`);
+    console.log(bible.premise);
+    console.log('\n## Characters');
+    console.log('─'.repeat(60));
+    if (bible.characters.length === 0) {
+        console.log('No characters defined.');
+    }
+    else {
+        for (const char of bible.characters) {
+            console.log(`\n### ${char.name}`);
+            console.log(`  Role: ${char.role}`);
+            console.log(`  Personality: ${char.personality.join(', ')}`);
+            console.log(`  Goals: ${char.goals.join(', ')}`);
+            if (char.background) {
+                console.log(`  Background: ${char.background}`);
+            }
+        }
+    }
+    console.log('\n## Plot Threads');
+    console.log('─'.repeat(60));
+    if (bible.plotThreads.length === 0) {
+        console.log('No plot threads defined.');
+    }
+    else {
+        for (const thread of bible.plotThreads) {
+            console.log(`\n- ${thread.name}`);
+            console.log(`  Status: ${thread.status}`);
+            console.log(`  Description: ${thread.description}`);
+        }
+    }
+    console.log('');
+}

package/dist/commands/clone.d.ts

@@ -0,0 +1 @@
+export declare function cloneCommand(storyId: string, newTitle: string): void;

package/dist/commands/clone.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneCommand = cloneCommand;
+const engine_1 = require("@narrative-os/engine");
+const store_js_1 = require("../config/store.js");
+function cloneCommand(storyId, newTitle) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    const { bible, state } = story;
+    // Create new bible with same settings but new title
+    const newBible = (0, engine_1.createStoryBible)(newTitle, bible.theme, bible.genre, bible.setting, bible.tone, bible.premise, state.totalChapters);
+    // Copy characters
+    for (const char of bible.characters) {
+        newBible.characters.push({ ...char });
+    }
+    // Copy plot threads
+    for (const thread of bible.plotThreads) {
+        newBible.plotThreads.push({ ...thread });
+    }
+    // Create fresh state
+    const newState = (0, engine_1.createStoryState)(newBible.id, state.totalChapters);
+    const canon = (0, engine_1.extractCanonFromBible)(newBible);
+    // Save the cloned story
+    (0, store_js_1.saveStory)(newBible, newState, [], canon);
+    // Initialize structured state
+    let structuredState = (0, engine_1.createStructuredState)(newBible.id);
+    structuredState = (0, engine_1.initializeCharactersFromBible)(structuredState, newBible);
+    structuredState = (0, engine_1.initializePlotThreadsFromBible)(structuredState, newBible);
+    (0, store_js_1.saveStructuredState)(newBible.id, structuredState);
+    console.log(`✅ Story cloned: ${newTitle}`);
+    console.log(`Original: ${bible.title} (${storyId})`);
+    console.log(`New ID: ${newBible.id}`);
+    console.log(`\nNext: Run "nos generate ${newBible.id}" to start writing.`);
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,9 @@
+interface Config {
+    provider: 'openai' | 'deepseek';
+    apiKey: string;
+    model: string;
+}
+export declare function configCommand(): Promise<void>;
+export declare function getConfig(): Config | null;
+export declare function applyConfig(): void;
+export {};

package/dist/commands/config.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configCommand = configCommand;
+exports.getConfig = getConfig;
+exports.applyConfig = applyConfig;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.narrative-os');
+const CONFIG_FILE = (0, path_1.join)(CONFIG_DIR, 'config.json');
+const PROVIDERS = [
+    { name: 'OpenAI', value: 'openai', models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo'] },
+    { name: 'DeepSeek', value: 'deepseek', models: ['deepseek-chat', 'deepseek-reasoner'] },
+];
+const DEEPSEEK_MODEL_MAP = {
+    'deepseek-chat': 'deepseek-chat',
+    'deepseek-reasoner': 'deepseek-reasoner',
+};
+function loadConfig() {
+    if (!(0, fs_1.existsSync)(CONFIG_FILE))
+        return null;
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveConfig(config) {
+    if (!(0, fs_1.existsSync)(CONFIG_DIR))
+        (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    (0, fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+async function configCommand() {
+    const { select, password } = await import('@inquirer/prompts');
+    const existing = loadConfig();
+    const provider = await select({
+        message: 'Select LLM provider:',
+        choices: PROVIDERS.map(p => ({ name: p.name, value: p.value })),
+        default: existing?.provider,
+    });
+    const providerInfo = PROVIDERS.find(p => p.value === provider);
+    const model = await select({
+        message: 'Select model:',
+        choices: providerInfo.models.map(m => ({ name: m, value: m })),
+        default: existing?.model || providerInfo.models[0],
+    });
+    const apiKey = await password({
+        message: `Enter ${providerInfo.name} API key:`,
+        mask: '*',
+    });
+    const config = { provider: provider, model, apiKey };
+    saveConfig(config);
+    console.log(`\nConfiguration saved for ${providerInfo.name}`);
+    console.log(`Model: ${model}`);
+}
+function getConfig() {
+    return loadConfig();
+}
+function applyConfig() {
+    const config = loadConfig();
+    if (config) {
+        process.env.LLM_PROVIDER = config.provider;
+        process.env.LLM_MODEL = config.model;
+        if (config.provider === 'openai') {
+            process.env.OPENAI_API_KEY = config.apiKey;
+        }
+        else if (config.provider === 'deepseek') {
+            process.env.DEEPSEEK_API_KEY = config.apiKey;
+        }
+    }
+}

package/dist/commands/continue.d.ts

@@ -0,0 +1 @@
+export declare function continueCommand(storyId: string): Promise<void>;

package/dist/commands/continue.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.continueCommand = continueCommand;
+const engine_1 = require("@narrative-os/engine");
+const store_js_1 = require("../config/store.js");
+async function continueCommand(storyId) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    let { bible, state, chapters, canon } = story;
+    if (state.currentChapter >= state.totalChapters) {
+        console.log('Story is already complete!');
+        return;
+    }
+    // Load or initialize vector store for memory
+    const vectorStore = (0, engine_1.getVectorStore)(storyId);
+    const existingData = (0, store_js_1.loadVectorStore)(storyId);
+    if (existingData) {
+        await vectorStore.load(existingData);
+    }
+    else {
+        await vectorStore.initialize();
+    }
+    console.log(`Continuing story: ${bible.title}`);
+    console.log(`Generating chapters ${state.currentChapter + 1} to ${state.totalChapters}...\n`);
+    while (state.currentChapter < state.totalChapters) {
+        const nextChapterNumber = state.currentChapter + 1;
+        const context = {
+            bible,
+            state,
+            chapterNumber: nextChapterNumber,
+            targetWordCount: 1500,
+        };
+        try {
+            const result = await (0, engine_1.generateChapter)(context, { canon, vectorStore });
+            chapters = [...chapters, result.chapter];
+            state = (0, engine_1.updateStoryState)(state, result.summary);
+            (0, store_js_1.saveStory)(bible, state, chapters, canon);
+            (0, store_js_1.saveVectorStore)(storyId, vectorStore.serialize());
+            const violationWarn = result.violations.length > 0 ? ` [${result.violations.length} violations]` : '';
+            const memoryInfo = result.memoriesExtracted > 0 ? ` [${result.memoriesExtracted} memories]` : '';
+            console.log(`✓ Chapter ${result.chapter.number}: ${result.chapter.title} (${result.chapter.wordCount} words)${violationWarn}${memoryInfo}`);
+        }
+        catch (error) {
+            console.error(`\nFailed at Chapter ${nextChapterNumber}:`, error);
+            process.exit(1);
+        }
+    }
+    console.log('\nStory complete!');
+    console.log(`Total: ${chapters.length} chapters`);
+    console.log(`Total words: ${chapters.reduce((sum, ch) => sum + ch.wordCount, 0)}`);
+}

package/dist/commands/delete.d.ts

@@ -0,0 +1 @@
+export declare function deleteCommand(storyId: string, force?: boolean): void;

package/dist/commands/delete.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteCommand = deleteCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const store_js_1 = require("../config/store.js");
+const STORIES_DIR = (0, path_1.join)((0, os_1.homedir)(), '.narrative-os', 'stories');
+function deleteCommand(storyId, force = false) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    console.log(`Story: ${story.bible.title}`);
+    console.log(`ID: ${storyId}`);
+    console.log(`Chapters: ${story.state.currentChapter}/${story.state.totalChapters}`);
+    if (!force) {
+        console.log('\n⚠️  This will permanently delete the story and all its chapters.');
+        console.log('Use --force to skip this confirmation.');
+        process.exit(1);
+    }
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    if ((0, fs_1.existsSync)(storyDir)) {
+        (0, fs_1.rmSync)(storyDir, { recursive: true, force: true });
+        console.log(`\n✅ Story "${story.bible.title}" deleted.`);
+    }
+    else {
+        console.error(`Story directory not found: ${storyDir}`);
+        process.exit(1);
+    }
+}

package/dist/commands/export.d.ts

@@ -0,0 +1 @@
+export declare function exportCommand(storyId: string, format?: string, output?: string): void;

package/dist/commands/export.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportCommand = exportCommand;
+const fs_1 = require("fs");
+const store_js_1 = require("../config/store.js");
+function exportCommand(storyId, format = 'markdown', output) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    const { bible, chapters } = story;
+    let content;
+    let extension;
+    switch (format.toLowerCase()) {
+        case 'txt':
+        case 'text':
+            content = exportAsText(bible, chapters);
+            extension = 'txt';
+            break;
+        case 'md':
+        case 'markdown':
+        default:
+            content = exportAsMarkdown(bible, chapters);
+            extension = 'md';
+            break;
+    }
+    const filename = output || `${bible.title.replace(/[^a-zA-Z0-9]/g, '_')}.${extension}`;
+    (0, fs_1.writeFileSync)(filename, content, 'utf-8');
+    console.log(`✅ Exported ${chapters.length} chapters to ${filename}`);
+}
+function exportAsMarkdown(bible, chapters) {
+    const lines = [];
+    // Title page
+    lines.push(`# ${bible.title}`);
+    lines.push('');
+    lines.push(`**Theme:** ${bible.theme}`);
+    lines.push(`**Genre:** ${bible.genre}`);
+    lines.push(`**Setting:** ${bible.setting}`);
+    lines.push(`**Tone:** ${bible.tone}`);
+    lines.push('');
+    lines.push(`## Premise`);
+    lines.push(bible.premise);
+    lines.push('');
+    // Characters
+    if (bible.characters.length > 0) {
+        lines.push('## Characters');
+        lines.push('');
+        for (const char of bible.characters) {
+            lines.push(`### ${char.name}`);
+            lines.push(`- **Role:** ${char.role}`);
+            lines.push(`- **Traits:** ${char.traits.join(', ')}`);
+            lines.push(`- **Goals:** ${char.goals.join(', ')}`);
+            if (char.background) {
+                lines.push(`- **Background:** ${char.background}`);
+            }
+            lines.push('');
+        }
+    }
+    // Chapters
+    if (chapters.length > 0) {
+        lines.push('---');
+        lines.push('');
+        for (const chapter of chapters) {
+            lines.push(`# Chapter ${chapter.number}: ${chapter.title}`);
+            lines.push('');
+            lines.push(chapter.content);
+            lines.push('');
+            lines.push(`*Word count: ${chapter.wordCount}*`);
+            lines.push('');
+            lines.push('---');
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}
+function exportAsText(bible, chapters) {
+    const lines = [];
+    lines.push(bible.title.toUpperCase());
+    lines.push('');
+    lines.push(`Theme: ${bible.theme}`);
+    lines.push(`Genre: ${bible.genre}`);
+    lines.push(`Setting: ${bible.setting}`);
+    lines.push('');
+    lines.push('PREMISE');
+    lines.push(bible.premise);
+    lines.push('');
+    if (chapters.length > 0) {
+        for (const chapter of chapters) {
+            lines.push(`CHAPTER ${chapter.number}: ${chapter.title.toUpperCase()}`);
+            lines.push('');
+            lines.push(chapter.content);
+            lines.push('');
+            lines.push('---');
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1 @@
+export declare function generateCommand(storyId: string): Promise<void>;

package/dist/commands/generate.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = generateCommand;
+const engine_1 = require("@narrative-os/engine");
+const store_js_1 = require("../config/store.js");
+async function generateCommand(storyId) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`❌ Story not found: ${storyId}\n`);
+        console.log('💡 Try one of these:');
+        console.log('   • List all stories:    nos list');
+        console.log('   • Create new story:    nos init --title "My Story"');
+        console.log('   • Check story status:  nos status');
+        process.exit(1);
+    }
+    const { bible, state, chapters, canon } = story;
+    if (state.currentChapter >= state.totalChapters) {
+        console.log('Story is complete!');
+        return;
+    }
+    const nextChapterNumber = state.currentChapter + 1;
+    const context = {
+        bible,
+        state,
+        chapterNumber: nextChapterNumber,
+        targetWordCount: 1500,
+    };
+    // Load or initialize vector store for memory
+    const vectorStore = (0, engine_1.getVectorStore)(storyId);
+    const existingData = (0, store_js_1.loadVectorStore)(storyId);
+    if (existingData) {
+        await vectorStore.load(existingData);
+    }
+    else {
+        await vectorStore.initialize();
+    }
+    try {
+        const result = await (0, engine_1.generateChapter)(context, { canon, vectorStore });
+        const newChapters = [...chapters, result.chapter];
+        const newState = (0, engine_1.updateStoryState)(state, result.summary);
+        (0, store_js_1.saveStory)(bible, newState, newChapters, canon);
+        // Save vector store
+        (0, store_js_1.saveVectorStore)(storyId, vectorStore.serialize());
+        console.log(`\n✅ Chapter ${result.chapter.number} generated!`);
+        console.log(`   Title: ${result.chapter.title}`);
+        console.log(`   Words: ${result.chapter.wordCount}`);
+        if (result.violations.length > 0) {
+            console.log(`   ⚠️  Canon violations: ${result.violations.length}`);
+        }
+        if (result.memoriesExtracted > 0) {
+            console.log(`   🧠 Memories extracted: ${result.memoriesExtracted}`);
+        }
+        console.log(`   Summary: ${result.summary.summary}`);
+        const progress = Math.round((newState.currentChapter / state.totalChapters) * 100);
+        console.log(`\n📊 Progress: ${newState.currentChapter}/${state.totalChapters} (${progress}%)`);
+        console.log(`\n💡 Next steps:`);
+        if (newState.currentChapter < state.totalChapters) {
+            console.log(`   • Generate next chapter:  nos generate ${storyId}`);
+            console.log(`   • Read this chapter:      nos read ${storyId} ${result.chapter.number}`);
+            console.log(`   • Auto-generate rest:     nos continue ${storyId}`);
+        }
+        else {
+            console.log(`   🎉 Story complete!`);
+            console.log(`   • Export to file:         nos export ${storyId}`);
+            console.log(`   • Read full story:        nos read ${storyId}`);
+        }
+    }
+    catch (error) {
+        console.error('Generation failed:', error);
+        process.exit(1);
+    }
+}

package/dist/commands/hint.d.ts

@@ -0,0 +1,5 @@
+export declare function showHint(context?: {
+    storyId?: string;
+    afterCommand?: string;
+}): void;
+export declare function showWelcome(): void;

package/dist/commands/hint.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showHint = showHint;
+exports.showWelcome = showWelcome;
+const store_js_1 = require("../config/store.js");
+function showHint(context) {
+    const stories = (0, store_js_1.listStories)();
+    console.log('\n💡 Quick Tips:\n');
+    if (stories.length === 0) {
+        console.log('  You have no stories yet.');
+        console.log('  Create one:  nos init --title "My Story"');
+        return;
+    }
+    // Find an active story (not complete)
+    const activeStory = stories.find(s => s.currentChapter < s.totalChapters);
+    const storyId = context?.storyId || activeStory?.id || stories[0].id;
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story)
+        return;
+    const { state } = story;
+    const isComplete = state.currentChapter >= state.totalChapters;
+    // Show hints based on context
+    if (context?.afterCommand === 'init') {
+        console.log(`  Your story "${story.bible.title}" is ready!`);
+        console.log(`  Generate Chapter 1:  nos generate ${storyId}`);
+    }
+    else if (isComplete) {
+        console.log(`  Story "${story.bible.title}" is complete! 🎉`);
+        console.log(`  Export to file:      nos export ${storyId}`);
+        console.log(`  Read the story:      nos read ${storyId}`);
+        console.log(`  Clone as template:   nos clone ${storyId} "New Version"`);
+    }
+    else {
+        console.log(`  Continue "${story.bible.title}" (${state.currentChapter}/${state.totalChapters} chapters)`);
+        console.log(`  Generate next:       nos generate ${storyId}`);
+        console.log(`  Auto-complete:       nos continue ${storyId}`);
+        console.log(`  Check status:        nos status ${storyId}`);
+    }
+    console.log('');
+    console.log('  Other useful commands:');
+    console.log('    nos list              List all stories');
+    console.log('    nos bible <id>        View story bible');
+    console.log('    nos memories <id>     Search memories');
+    console.log('    nos validate <id>     Check consistency');
+    console.log('    nos --help            Show all commands');
+}
+function showWelcome() {
+    console.log('\n╔════════════════════════════════════════════════════════╗');
+    console.log('║          📝 Narrative OS - AI Story Engine             ║');
+    console.log('╚════════════════════════════════════════════════════════╝\n');
+    const stories = (0, store_js_1.listStories)();
+    if (stories.length === 0) {
+        console.log('Welcome! Let\'s create your first story.\n');
+        console.log('💡 Quick Start:');
+        console.log('   nos init --title "My Adventure" --chapters 10');
+        console.log('\nOr explore options:');
+        console.log('   nos init --help');
+    }
+    else {
+        console.log(`You have ${stories.length} story(s).\n`);
+        console.log('💡 Quick Commands:');
+        console.log('   nos list              See all stories');
+        console.log('   nos status            Check story status');
+        console.log('   nos generate <id>     Write next chapter');
+        console.log('   nos --help            All commands');
+    }
+    console.log('');
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,9 @@
+export declare function initCommand(options: {
+    title?: string;
+    theme?: string;
+    genre?: string;
+    setting?: string;
+    tone?: string;
+    premise?: string;
+    chapters?: string;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const engine_1 = require("@narrative-os/engine");
+const store_js_1 = require("../config/store.js");
+async function initCommand(options) {
+    console.log('Creating new story...\n');
+    const title = options.title || 'Untitled Story';
+    const theme = options.theme || 'Redemption';
+    const genre = options.genre || 'Science Fiction';
+    const setting = options.setting || 'Neo-Tokyo 2145';
+    const tone = options.tone || 'Dark, philosophical';
+    const premise = options.premise || 'A detective discovers a conspiracy that challenges everything she knows about reality.';
+    const targetChapters = parseInt(options.chapters || '5');
+    let bible = (0, engine_1.createStoryBible)(title, theme, genre, setting, tone, premise, targetChapters);
+    bible = (0, engine_1.addCharacter)(bible, 'Mira Kade', 'protagonist', ['determined', 'cynical', 'brilliant'], ['uncover the truth', 'protect her sister']);
+    bible = (0, engine_1.addCharacter)(bible, 'The Architect', 'antagonist', ['charismatic', 'ruthless', 'visionary'], ['reshape society', 'eliminate obstacles']);
+    const state = (0, engine_1.createStoryState)(bible.id, targetChapters);
+    (0, store_js_1.saveStory)(bible, state, []);
+    console.log(`\n✅ Story created: ${title}`);
+    console.log(`   ID: ${bible.id}`);
+    console.log(`   Target chapters: ${targetChapters}`);
+    console.log(`\n💡 Next steps:`);
+    console.log(`   • Generate Chapter 1:  nos generate ${bible.id}`);
+    console.log(`   • View story bible:    nos bible ${bible.id}`);
+    console.log(`   • Check status:        nos status ${bible.id}`);
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function listCommand(): void;

package/dist/commands/list.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = listCommand;
+const store_js_1 = require("../config/store.js");
+function listCommand() {
+    const stories = (0, store_js_1.listStories)();
+    if (stories.length === 0) {
+        console.log('No stories found. Run "nos init" to create one.');
+        return;
+    }
+    console.log(`Found ${stories.length} story(s):\n`);
+    for (const story of stories) {
+        const progress = Math.round((story.currentChapter / story.totalChapters) * 100);
+        const status = story.currentChapter >= story.totalChapters ? '✅ Complete' : '⏳ In Progress';
+        console.log(`  ${story.id}`);
+        console.log(`    Title: ${story.title}`);
+        console.log(`    Progress: ${story.currentChapter}/${story.totalChapters} (${progress}%)`);
+        console.log(`    Status: ${status}`);
+        console.log('');
+    }
+}

package/dist/commands/memories.d.ts

@@ -0,0 +1 @@
+export declare function memoriesCommand(storyId: string, query?: string): Promise<void>;

package/dist/commands/memories.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoriesCommand = memoriesCommand;
+const engine_1 = require("@narrative-os/engine");
+const store_js_1 = require("../config/store.js");
+async function memoriesCommand(storyId, query) {
+    // Load vector store
+    const vectorStore = (0, engine_1.getVectorStore)(storyId);
+    const existingData = (0, store_js_1.loadVectorStore)(storyId);
+    if (existingData) {
+        await vectorStore.load(existingData);
+    }
+    else {
+        console.log('No memories found for this story.');
+        return;
+    }
+    const allMemories = vectorStore.getAllMemories();
+    if (allMemories.length === 0) {
+        console.log('No memories found for this story.');
+        return;
+    }
+    if (query) {
+        // Search memories
+        console.log(`Searching memories for: "${query}"\n`);
+        const results = await vectorStore.searchSimilar(query, 10);
+        console.log(`Found ${results.length} relevant memories:\n`);
+        for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            console.log(`${i + 1}. [${r.memory.category}] Chapter ${r.memory.chapterNumber}`);
+            console.log(`   ${r.memory.content.substring(0, 80)}...`);
+            console.log(`   Relevance: ${(1 - r.score).toFixed(3)}`);
+            console.log('');
+        }
+    }
+    else {
+        // List all memories
+        console.log(`Total memories: ${allMemories.length}\n`);
+        // Group by category
+        const byCategory = {};
+        for (const mem of allMemories) {
+            if (!byCategory[mem.category]) {
+                byCategory[mem.category] = [];
+            }
+            byCategory[mem.category].push(mem);
+        }
+        for (const [category, memories] of Object.entries(byCategory)) {
+            console.log(`\n## ${category.toUpperCase()} (${memories.length})`);
+            console.log('─'.repeat(60));
+            for (const mem of memories.slice(0, 5)) { // Show first 5 per category
+                console.log(`\n  Chapter ${mem.chapterNumber}:`);
+                console.log(`  ${mem.content.substring(0, 100)}...`);
+            }
+            if (memories.length > 5) {
+                console.log(`\n  ... and ${memories.length - 5} more`);
+            }
+        }
+    }
+    console.log('');
+}

package/dist/commands/read.d.ts

@@ -0,0 +1 @@
+export declare function readCommand(storyId: string, chapterNumber?: number): void;